Struct ipworksllm::LLMClient

Properties   Methods   Events   Config Settings   Errors  

Provides a single, provider-neutral way to generate replies with, call tools through, create embeddings with, count tokens for, and list models of the OpenAI, Anthropic, and Google Gemini APIs, and of the many services that implement one of them.

Syntax

ipworksllm::LLMClient

Remarks

The LLMClient struct provides one API for the OpenAI Chat Completions API, the Anthropic Messages API, and the Google Gemini API. The conversation, the tools, and the reply are held in a normalized form; the struct translates them into the request of the selected provider and translates the provider's reply back, so the same application code works with every provider.

Selecting a Provider

The service_provider property selects the provider: spOpenAI (0) (the default), spAnthropic (1), or spGemini (2); one of the services that implement the OpenAI Chat Completions API, spOllama (3), spLMStudio (4), spGroq (5), spOpenRouter (6), spTogetherAI (7), or spFireworksAI (8); or a custom endpoint of one of the three APIs, spCustomGemini (97), spCustomAnthropic (98), or spCustomOpenAI (99). The api_key property holds the API key issued by that provider, and model names the model that processes each request.

LLMClient llmclient = new LLMClient(); llmclient.ServiceProvider = LLMClientServiceProviders.spAnthropic; llmclient.APIKey = "sk-ant-..."; llmclient.Model = "claude-sonnet-5"; llmclient.MaxOutputTokens = 1024; // Required by the Anthropic API.

Selecting an Endpoint

When server_url is empty (the default), the struct uses the default endpoint of the selected provider, such as https://api.openai.com/v1 for spOpenAI or http://localhost:11434/v1 for spOllama; server_url lists them all. In most cases, the default endpoint is the correct choice. The server_url property should only be set when connecting to a custom endpoint, to an Ollama or LM Studio server on another host or port, or through a gateway or proxy that implements the selected provider's API. When server_url is set, operation paths such as /chat/completions or /messages are appended to its value verbatim; no part of the value is rewritten, and no version segment is added or removed.

Any other service that implements one of the three APIs, such as vLLM or DeepSeek, is used by selecting the matching custom value and setting server_url to the base URL of that service; the custom values have no default endpoint. When api_key is left empty, no authentication header is sent at all, as a locally hosted server expects.

// A locally hosted Ollama server, at its default address. No API key is required. llmclient.ServiceProvider = LLMClientServiceProviders.spOllama; llmclient.Model = "llama3.2"; // A vLLM server on another machine. llmclient.ServiceProvider = LLMClientServiceProviders.spCustomOpenAI; llmclient.ServerURL = "http://192.168.1.20:8000/v1"; llmclient.Model = "meta-llama/Llama-3.1-8B-Instruct";

Building a Conversation

A conversation is held in two properties. Each message is one LLMMessage item in the messages properties, carrying the message's Id and Role (user, assistant, or tool). The content of the messages is held in the message_parts properties, in which each LLMMessagePart item is one piece of content, such as text, an image, a file, or a tool call. The MessageId property of a part holds the Id of the message it belongs to.

The add_message method appends a message, adds a text part to it when Content is not empty, and returns the new message's Id. The add_message_part method adds further parts to that message, such as an image or a file given by URL. To send the bytes of an image or file inline, add the part with an empty Content and set the part's Data property. Instructions that apply to the whole conversation are supplied through system_prompt rather than as a message.

llmclient.SystemPrompt = "You are a concise assistant."; string id = llmclient.AddMessage("user", "What is in these pictures?"); // An image given by URL. llmclient.AddMessagePart(id, (int)PartTypes.ptImage, "https://www.example.com/photo.jpg", "image/jpeg"); // An image sent inline. llmclient.AddMessagePart(id, (int)PartTypes.ptImage, "", "image/png"); llmclient.MessageParts[llmclient.MessageParts.Count - 1].DataB = File.ReadAllBytes("chart.png");

Calling reset clears the conversation, the tools, and the reply, while configuration such as service_provider, api_key, and model is kept.

Generating a Reply

The generate method sends the conversation to the selected provider. On success, the reply is appended to messages as a message with role assistant, and its parts are appended to message_parts. response_text holds the text of the reply, finish_reason reports why the model stopped, and input_tokens, output_tokens, and total_tokens report the token usage the provider counted.

llmclient.AddMessage("user", "What is the capital of France?"); llmclient.Generate(); Console.WriteLine(llmclient.ResponseText); Console.WriteLine("Tokens used: " + llmclient.TotalTokens);

Streaming

Setting stream to True before calling generate causes the reply to be streamed. The on_content_delta event fires once for each fragment as it arrives; its PartType parameter is 0 (ptText) for visible text and 5 (ptReasoning) for the model's reasoning. Once the stream completes, the assembled reply is appended exactly as in the non-streaming case.

llmclient.Stream = true; llmclient.OnContentDelta += (s, e) => { if (e.PartType == (int)PartTypes.ptText) Console.Write(e.Delta); }; llmclient.AddMessage("user", "Write a short poem about the sea."); llmclient.Generate();

Tool Calling

A tool is declared by queuing its parameters with add_tool_param and then calling add_tool, or by passing a complete JSON Schema to add_tool. When the reply calls one or more tools, the reply is appended first, and then the on_tool_call event fires once for each call. Answer each call with add_tool_result, passing the call's Id, and then call generate again so the model can use the results. While the model is calling tools, finish_reason reports frToolCalls.

llmclient.AddToolParam("location", "string", "The city and state, e.g. San Francisco, CA", true); llmclient.AddTool("get_weather", "Gets the current weather for a location.", ""); llmclient.OnToolCall += (s, e) => { llmclient.AddToolResult(e.Id, GetWeather(e.ArgumentsJson), false); }; llmclient.AddMessage("user", "What is the weather like in Boston?"); llmclient.Generate(); // Send the tool results back until the model gives its final answer. while (llmclient.FinishReason == LLMClientFinishReasons.frToolCalls) llmclient.Generate(); Console.WriteLine(llmclient.ResponseText);

Provider Differences

The struct hides the differences between the providers wherever the provider APIs allow it. Where this documentation describes spOpenAI, spAnthropic, or spGemini, the same applies to every other provider that uses the same API, unless stated otherwise. The differences that remain are:

• The Anthropic API requires a limit on the length of the reply, so max_output_tokens must be set to a positive value when service_provider is spAnthropic or spCustomAnthropic; otherwise generate fails with error 802.
• The OpenAI Chat Completions API has no token counting endpoint, so count_tokens fails with error 804 when service_provider is spOpenAI or any other provider that uses that API.
• Services that implement the OpenAI Chat Completions API name the limit on the length of the reply differently; max_output_tokens lists the field each provider receives.
• Ollama does not support choosing tools, so the ToolChoice configuration setting must be empty or auto when service_provider is spOllama.
• The Anthropic API cannot request JSON output without a schema, so setting the ResponseFormat configuration setting to json without also setting ResponseSchema causes generate to fail with error 804 when service_provider is spAnthropic.
• Changing service_provider keeps the conversation and the tools, so a conversation may be continued with another provider. The ProviderData property of every part is cleared, however, because provider specific data, such as the signature of an Anthropic thinking block, cannot be sent to a different provider.
• Message roles other than user, assistant, and tool, such as developer, are passed through with spOpenAI only; with spAnthropic or spGemini, generate fails with error 804.
• The Anthropic API offers no embeddings, so create_embedding fails with error 804 when service_provider is spAnthropic or spCustomAnthropic.
• A few configuration settings apply to one API only: AnthropicVersion, GeminiSafetySettings, OpenAIOrganization, OpenAIProject, and EmbeddingTaskType, which is supported only with the Gemini API.

A reply that the provider blocks for safety reasons is not an error: generate returns normally and finish_reason reports frContentFilter. The provider's own finish reason is always available through the ProviderFinishReason configuration setting.

Creating Embeddings

An embedding is a vector of floating point numbers that represents the meaning of a piece of text: texts with similar meanings have vectors that point in similar directions, which makes embeddings the basis of semantic search, clustering, and classification. The create_embedding method creates an embedding for every item of the embeddings properties in a single request, and sets the OutputVector property of each item to the vector created for its InputText, as JSON text containing an array of floating point numbers.

Embeddings are created with a model dedicated to them, which the EmbeddingModel configuration setting selects without disturbing model. Providers that use the OpenAI or the Gemini API are supported when the service offers embeddings; the Anthropic API offers none.

llmclient.Config("EmbeddingModel=text-embedding-3-small"); llmclient.Embeddings.Add(new LLMEmbedding("The quick brown fox jumps over the lazy dog.")); llmclient.Embeddings.Add(new LLMEmbedding("A fast auburn fox leaps over a sleepy hound.")); llmclient.CreateEmbedding(); foreach (LLMEmbedding embedding in llmclient.Embeddings) { Console.WriteLine(embedding.OutputVector); }

To compare two texts, parse both vectors and compute their cosine similarity: the dot product of the vectors divided by the product of their lengths. Values near 1 mean the texts are close in meaning. Vectors are only comparable when the same model, with the same EmbeddingDimensions, created them.

Counting Tokens and Listing Models

With spAnthropic and spGemini, the count_tokens method returns the number of input tokens the current conversation would consume, without generating a reply.

int inputTokens = llmclient.CountTokens();

The list_models method fires the on_model_list event once for each model the provider reports. The Anthropic and Gemini APIs return the list in pages: when more pages remain, model_marker is set, and calling list_models again returns the next page. The OpenAI list is not paged, so model_marker stays empty with spOpenAI.

llmclient.OnModelList += (s, e) => { Console.WriteLine(e.Id + " (" + e.Name + ")"); }; do { llmclient.ListModels(); } while (llmclient.ModelMarker != "");

Object Lifetime

The new() method returns a mutable reference to a struct instance. The object itself is kept in the global list maintained by IPWorksLLM. Due to this, the LLMClient struct cannot be disposed of automatically. Please, call the dispose(&self) method of LLMClient when you have finished using the instance.

Property List

The following is the full list of the properties of the struct with short descriptions. Click on the links for further details.

Method List

The following is the full list of the methods of the struct with short descriptions. Click on the links for further details.

Event List

The following is the full list of the events fired by the struct with short descriptions. Click on the links for further details.

Config Settings

The following is a list of config settings for the struct with short descriptions. Click on the links for further details.

api_key property (LLMClient Struct)

The API key used to authenticate with the selected provider.

Syntax

fn api_key(&self) -> Result<String, IPWorksLLMError> 
fn set_api_key(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_api_key_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property specifies the API key used to authenticate requests to the provider selected by service_provider. The header that carries it depends on the API the provider uses:

When this property is left empty, no authentication header is sent at all. This is required by some servers, such as a locally hosted Ollama, LM Studio, or vLLM instance, and supports gateways placed in front of a provider that supply credentials of their own.

An API key is issued for one provider only. When service_provider is changed, this property should be set to a key issued by the newly selected provider.

Data Type

String

embedding_count property (LLMClient Struct)

The number of records in the Embedding arrays.

Syntax

fn embedding_count(&self) -> Result<i32, IPWorksLLMError> 
fn set_embedding_count(&self, value : i32) ->  Option<IPWorksLLMError> 

Default Value

0

Remarks

This property controls the size of the following arrays:

• embedding_input_text
• embedding_output_vector

The array indices start at 0 and end at embedding_count - 1.

Data Type

i32

embedding_input_text property (LLMClient Struct)

The text to create an embedding for.

Syntax

fn embedding_input_text(&self, EmbeddingIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_embedding_input_text(&self, EmbeddingIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_embedding_input_text_ref(&self, EmbeddingIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property holds the text that create_embedding sends to the server for this item. It must not be empty; otherwise create_embedding fails with error 802 before anything is sent.

The EmbeddingIndex parameter specifies the index of the item in the array. The size of the array is controlled by the embedding_count property.

Data Type

String

embedding_output_vector property (LLMClient Struct)

The embedding vector created for the text, as a JSON array.

Syntax

fn embedding_output_vector(&self, EmbeddingIndex : i32) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

This property holds the embedding vector the server created for embedding_input_text, as JSON text containing an array of floating point numbers, for example [0.0023064255,-0.009327292,0.015797347]. Each number is reported exactly as the server wrote it; only the whitespace between the numbers is removed. The number of elements depends on the model, and on the EmbeddingDimensions configuration setting when that setting is set.

This property is empty until create_embedding succeeds. create_embedding clears it in every item before its request is sent, so a failed call never leaves a vector from an earlier call next to new text.

The EmbeddingIndex parameter specifies the index of the item in the array. The size of the array is controlled by the embedding_count property.

This property is read-only.

Data Type

String

finish_reason property (LLMClient Struct)

The reason the model stopped generating the last reply.

Syntax

fn finish_reason(&self) -> Result<i32, IPWorksLLMError> 

Possible Values

0   // None
1   // Stop
2   // Length
3   // ToolCalls
4   // ContentFilter
5   // Other

Default Value

0

Remarks

This property reports why the model stopped generating the reply received by the last call to generate. The value is normalized across providers; the provider's own value is always available, unchanged, through the ProviderFinishReason configuration setting. This property is cleared when generate, count_tokens, create_embedding, or list_models is called.

Possible values are:

The values reported by each provider are mapped as follows:

A blocked request or reply is never reported as an error: generate returns normally and this property reports frContentFilter. A reply that carries no content at all appends nothing to messages. This happens, for example, when the Gemini API blocks the prompt itself; ProviderFinishReason then holds the block reason the server reported.

This property is read-only.

Data Type

i32

firewall_auto_detect property (LLMClient Struct)

Whether to automatically detect and use firewall system settings, if available.

Syntax

fn firewall_auto_detect(&self) -> Result<bool, IPWorksLLMError> 
fn set_firewall_auto_detect(&self, value : bool) ->  Option<IPWorksLLMError> 

Default Value

false

Remarks

Data Type

bool

firewall_type property (LLMClient Struct)

The type of firewall to connect through.

Syntax

fn firewall_type(&self) -> Result<i32, IPWorksLLMError> 
fn set_firewall_type(&self, value : i32) ->  Option<IPWorksLLMError> 

Possible Values

0   // None
1   // Tunnel
2   // SOCKS4
3   // SOCKS5
10   // SOCKS4A

Default Value

0

Remarks

The type of firewall to connect through. The applicable values are as follows:

Data Type

i32

firewall_host property (LLMClient Struct)

The name or IP address of the firewall (optional).

Syntax

fn firewall_host(&self) -> Result<String, IPWorksLLMError> 
fn set_firewall_host(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_firewall_host_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

The name or IP address of the firewall (optional). If a firewall_host is given, the requested connections will be authenticated through the specified firewall when connecting.

If this property is set to a Domain Name, a DNS request is initiated. Upon successful termination of the request, this property is set to the corresponding address. If the search is not successful, the struct fails with an error.

Data Type

String

firewall_password property (LLMClient Struct)

A password if authentication is to be used when connecting through the firewall.

Syntax

fn firewall_password(&self) -> Result<String, IPWorksLLMError> 
fn set_firewall_password(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_firewall_password_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

A password if authentication is to be used when connecting through the firewall. If firewall_host is specified, the firewall_user and firewall_password properties are used to connect and authenticate to the given firewall. If the authentication fails, the struct fails with an error.

Data Type

String

firewall_port property (LLMClient Struct)

The Transmission Control Protocol (TCP) port for the firewall Host .

Syntax

fn firewall_port(&self) -> Result<i32, IPWorksLLMError> 
fn set_firewall_port(&self, value : i32) ->  Option<IPWorksLLMError> 

Default Value

0

Remarks

The Transmission Control Protocol (TCP) port for the firewall firewall_host. See the description of the firewall_host property for details.

NOTE: This property is set automatically when firewall_type is set to a valid value. See the description of the firewall_type property for details.

Data Type

i32

firewall_user property (LLMClient Struct)

A username if authentication is to be used when connecting through a firewall.

Syntax

fn firewall_user(&self) -> Result<String, IPWorksLLMError> 
fn set_firewall_user(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_firewall_user_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

A username if authentication is to be used when connecting through a firewall. If firewall_host is specified, this property and the firewall_password property are used to connect and authenticate to the given Firewall. If the authentication fails, the struct fails with an error.

Data Type

String

input_tokens property (LLMClient Struct)

The number of input tokens the provider counted for the last request.

Syntax

fn input_tokens(&self) -> Result<i32, IPWorksLLMError> 

Default Value

0

Remarks

This property reports the number of input (prompt) tokens the provider counted for the request sent by the last call to generate or create_embedding. It counts every input token of the request, which the providers report as follows:

A value of 0 means the provider did not report usage for the last request. This property is cleared when generate, count_tokens, create_embedding, or list_models is called.

To learn how many input tokens a conversation would consume before sending it, use count_tokens, which returns the count instead of setting this property.

This property is read-only.

Data Type

i32

max_output_tokens property (LLMClient Struct)

The maximum number of tokens the model may generate in a reply.

Syntax

fn max_output_tokens(&self) -> Result<i32, IPWorksLLMError> 
fn set_max_output_tokens(&self, value : i32) ->  Option<IPWorksLLMError> 

Default Value

0

Remarks

This property specifies an upper bound on the number of tokens the model may generate for a single reply. A reply that reaches the limit is cut short, and finish_reason reports frLength.

The field that carries the value depends on service_provider:

When this property is left at 0 (the default), the field is omitted from the request and the provider's own default is used. The Anthropic API, however, requires this field and defines no default for it: when service_provider is spAnthropic or spCustomAnthropic, this property must be set to a positive value before calling generate, which otherwise fails with error 802.

Different models accept different upper bounds for this value. Refer to the provider's documentation for the limit that applies to the model named by model.

Data Type

i32

message_part_count property (LLMClient Struct)

The number of records in the MessagePart arrays.

Syntax

fn message_part_count(&self) -> Result<i32, IPWorksLLMError> 
fn set_message_part_count(&self, value : i32) ->  Option<IPWorksLLMError> 

Default Value

0

Remarks

This property controls the size of the following arrays:

• message_part_arguments_json
• message_part_data
• message_part_file_name
• message_part_is_error
• message_part_media_type
• message_part_message_id
• message_part_part_type
• message_part_provider_data
• message_part_text
• message_part_tool_call_id
• message_part_tool_name
• message_part_url

The array indices start at 0 and end at message_part_count - 1.

Data Type

i32

message_part_arguments_json property (LLMClient Struct)

The JSON arguments of a tool call.

Syntax

fn message_part_arguments_json(&self, MessagePartIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_part_arguments_json(&self, MessagePartIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_part_arguments_json_ref(&self, MessagePartIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property is used when message_part_part_type is ptToolCall. It holds the JSON arguments object the model produced for the call, as also reported by the ArgumentsJson parameter of the on_tool_call event.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

String

message_part_data property (LLMClient Struct)

The inline bytes of an image or a file.

Syntax

fn message_part_data(&self, MessagePartIndex : i32) -> Result<Vec<u8>, IPWorksLLMError> 
fn set_message_part_data(&self, MessagePartIndex : i32, value : Vec<u8>) ->  Option<IPWorksLLMError> 
fn set_message_part_data_ref(&self, MessagePartIndex : i32, value : &[u8]) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property is used when message_part_part_type is ptImage or ptFile, and holds the bytes of the image or file when they are sent inline rather than referenced by message_part_url. message_part_media_type must be set to describe them.

The struct encodes the bytes in the form the selected provider expects, such as a base64 data: URL for an image with spOpenAI. Set either this property or message_part_url, not both.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

Vec<u8>

message_part_file_name property (LLMClient Struct)

The name of a file.

Syntax

fn message_part_file_name(&self, MessagePartIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_part_file_name(&self, MessagePartIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_part_file_name_ref(&self, MessagePartIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property is used when message_part_part_type is ptFile, and holds the name of the file, such as report.pdf. It is sent where the provider's API accepts a file name, such as the filename of a file part with spOpenAI.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

String

message_part_is_error property (LLMClient Struct)

Whether a tool result reports an error.

Syntax

fn message_part_is_error(&self, MessagePartIndex : i32) -> Result<bool, IPWorksLLMError> 
fn set_message_part_is_error(&self, MessagePartIndex : i32, value : bool) ->  Option<IPWorksLLMError> 

Default Value

false

Remarks

This property is used when message_part_part_type is ptToolResult. When True, message_part_text describes an error the tool encountered rather than its result. It is set from the IsError parameter of add_tool_result.

It is sent as the is_error field of the tool result with spAnthropic, and causes the result to be sent as {"error": ...} with spGemini. The OpenAI API has no equivalent, so it has no effect with spOpenAI.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

bool

message_part_media_type property (LLMClient Struct)

The media type of an image or a file.

Syntax

fn message_part_media_type(&self, MessagePartIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_part_media_type(&self, MessagePartIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_part_media_type_ref(&self, MessagePartIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property is used when message_part_part_type is ptImage or ptFile, and holds the media type (MIME type) of the content, such as image/png, image/jpeg, or application/pdf.

It must be set when the content is sent inline through message_part_data. For a data: URL in message_part_url, the media type the URL names is used when this property is empty. generate fails with error 802 when inline content has no media type from either source.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

String

message_part_message_id property (LLMClient Struct)

The Id of the message this part belongs to.

Syntax

fn message_part_message_id(&self, MessagePartIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_part_message_id(&self, MessagePartIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_part_message_id_ref(&self, MessagePartIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property links the part to its message: it holds the Id of an item in the messages properties. The add_message, add_message_part, add_tool_result, and generate methods set it automatically. When a part is added to message_parts directly, set this property to the Id of the message the part belongs to; generate and count_tokens fail with error 802 when a part refers to a message that does not exist.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

String

message_part_part_type property (LLMClient Struct)

The kind of content the part holds.

Syntax

fn message_part_part_type(&self, MessagePartIndex : i32) -> Result<i32, IPWorksLLMError> 
fn set_message_part_part_type(&self, MessagePartIndex : i32, value : i32) ->  Option<IPWorksLLMError> 

Possible Values

0   // Text
1   // Image
2   // File
3   // ToolCall
4   // ToolResult
5   // Reasoning
6   // Other

Default Value

0

Remarks

This property identifies the kind of content the part holds, and therefore which of the other properties apply. Possible values are:

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

i32

message_part_provider_data property (LLMClient Struct)

The raw JSON of the part, as the provider returned it.

Syntax

fn message_part_provider_data(&self, MessagePartIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_part_provider_data(&self, MessagePartIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_part_provider_data_ref(&self, MessagePartIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property is set by the struct on the parts of a reply, and holds the raw JSON of the part exactly as the provider returned it. When the conversation is sent back to the same provider, a part of the model's reply that holds this value is sent verbatim instead of being rebuilt from the other properties. This is how the parts that a provider requires to be returned unmodified survive the round trip: the Anthropic API requires it for thinking blocks and their signatures, and the Gemini API for thought signatures. The OpenAI Chat Completions API returns no such data, so this property stays empty with spOpenAI.

When message_part_part_type is ptOther, this property holds the whole content of the part. Such a part is sent verbatim with spAnthropic and spGemini, and is not sent with spOpenAI.

The value is meaningful only to the provider that returned it. When service_provider is changed to a different value, this property is cleared on every item in message_parts.

Apart from ptOther parts, an application does not normally set this property. When a conversation is saved and restored later, however, this property should be saved and restored along with the others.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

String

message_part_text property (LLMClient Struct)

The text of the part.

Syntax

fn message_part_text(&self, MessagePartIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_part_text(&self, MessagePartIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_part_text_ref(&self, MessagePartIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property holds the text of a part whose message_part_part_type is ptText, the result of a tool call when message_part_part_type is ptToolResult, or the model's reasoning when message_part_part_type is ptReasoning.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

String

message_part_tool_call_id property (LLMClient Struct)

The identifier of a tool call.

Syntax

fn message_part_tool_call_id(&self, MessagePartIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_part_tool_call_id(&self, MessagePartIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_part_tool_call_id_ref(&self, MessagePartIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

When message_part_part_type is ptToolCall, this property holds the identifier of the call, as also reported by the Id parameter of the on_tool_call event. The identifier is assigned by the provider; when the Gemini API does not assign one, the struct generates an identifier of the form llm_call_ followed by a number. A generated identifier is only used locally, to link a result to its call, and is never sent to the provider.

When message_part_part_type is ptToolResult, this property holds the identifier of the call the result answers, as passed to add_tool_result.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

String

message_part_tool_name property (LLMClient Struct)

The name of the tool a call or a result refers to.

Syntax

fn message_part_tool_name(&self, MessagePartIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_part_tool_name(&self, MessagePartIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_part_tool_name_ref(&self, MessagePartIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

When message_part_part_type is ptToolCall, this property holds the name of the tool the model called. When message_part_part_type is ptToolResult, it holds the name of the tool whose result the part carries; add_tool_result copies it from the matching call, because the Gemini API identifies a result by the name of the function it answers.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

String

message_part_url property (LLMClient Struct)

The URL of an image or a file.

Syntax

fn message_part_url(&self, MessagePartIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_part_url(&self, MessagePartIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_part_url_ref(&self, MessagePartIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property is used when message_part_part_type is ptImage or ptFile, and holds the location of the content: an http or https URL, or a data: URL that carries the content itself. A data: URL must be base64 encoded; the struct sends its content inline, in the form the selected provider expects. To send bytes the application already holds, set message_part_data instead.

When service_provider is spOpenAI, a file cannot be given by an http or https URL: generate fails with error 804 when a ptFile part holds one.

The MessagePartIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_part_count property.

Data Type

String

message_count property (LLMClient Struct)

The number of records in the Message arrays.

Syntax

fn message_count(&self) -> Result<i32, IPWorksLLMError> 
fn set_message_count(&self, value : i32) ->  Option<IPWorksLLMError> 

Default Value

0

Remarks

This property controls the size of the following arrays:

• message_id
• message_role

The array indices start at 0 and end at message_count - 1.

Data Type

i32

message_id property (LLMClient Struct)

The identifier of the message.

Syntax

fn message_id(&self, MessageIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_id(&self, MessageIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_id_ref(&self, MessageIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property holds the identifier that links the message to its content: every item in the message_parts properties whose MessageId matches this value belongs to this message.

The add_message, add_tool_result, and generate methods generate a unique identifier, of the form msg followed by a number, for each message they append. When an item is added to messages directly, set this property to a value that no other message uses.

The MessageIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_count property.

Data Type

String

message_role property (LLMClient Struct)

The role of the message's author.

Syntax

fn message_role(&self, MessageIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_message_role(&self, MessageIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_message_role_ref(&self, MessageIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property identifies the role of the message's author:

Each provider receives the role in the form its API expects. For example, the Gemini API calls the assistant role model, and the Anthropic and Gemini APIs carry the results of tool calls in a user message. Other roles, such as developer, are sent unchanged when service_provider is spOpenAI; with spAnthropic or spGemini, generate and count_tokens fail with error 804 when the conversation holds such a role. A system prompt is supplied through the system_prompt property instead of a message.

The MessageIndex parameter specifies the index of the item in the array. The size of the array is controlled by the message_count property.

Data Type

String

model property (LLMClient Struct)

The model used to generate replies and count tokens.

Syntax

fn model(&self) -> Result<String, IPWorksLLMError> 
fn set_model(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_model_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property specifies the identifier of the model that will process the request, for example gpt-4o with spOpenAI, claude-sonnet-5 with spAnthropic, or gemini-2.0-flash with spGemini. Model identifiers are specific to a provider, so this property normally changes together with service_provider.

This property must be set before calling generate or count_tokens, which otherwise fail with error 802, and before calling create_embedding unless the EmbeddingModel configuration setting supplies a model of its own. The OpenAI and Anthropic APIs name the model in the request body; the Gemini API names it in the request path, as {ServerURL}/models/{Model}:{operation}. With spGemini, a value that already carries the models/ resource name prefix is accepted as well; the prefix is not duplicated in the request path.

The list_models method may be used to discover the model identifiers the provider accepts.

Data Type

String

model_marker property (LLMClient Struct)

A marker indicating what page of models to return next.

Syntax

fn model_marker(&self) -> Result<String, IPWorksLLMError> 
fn set_model_marker(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_model_marker_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property will be populated when list_models is called if the results are paged and there are more pages. To list all models, continue to call list_models until this property returns an empty string.

The Anthropic and Gemini APIs return the list of models in pages; the marker is sent back to them as the after_id and pageToken query parameters respectively. The OpenAI API returns every model at once, so this property is always empty when service_provider is spOpenAI.

A marker is only meaningful to the provider that returned it, so changing service_provider to a different value clears this property.

Refer to list_models for more information.

Data Type

String

output_tokens property (LLMClient Struct)

The number of output tokens the provider counted for the last reply.

Syntax

fn output_tokens(&self) -> Result<i32, IPWorksLLMError> 

Default Value

0

Remarks

This property reports the number of output tokens the provider counted for the reply received by the last call to generate. It counts every generated token, including the tokens of any reasoning the model performed, which the providers report as follows:

A value of 0 means the provider did not report usage for the last reply. After create_embedding, this property is always 0, because creating embeddings generates no output tokens. This property is cleared when generate, count_tokens, create_embedding, or list_models is called.

This property is read-only.

Data Type

i32

proxy_auth_scheme property (LLMClient Struct)

The type of authorization to perform when connecting to the proxy.

Syntax

fn proxy_auth_scheme(&self) -> Result<i32, IPWorksLLMError> 
fn set_proxy_auth_scheme(&self, value : i32) ->  Option<IPWorksLLMError> 

Possible Values

0   // Basic
1   // Digest
2   // Proprietary
3   // None
4   // Ntlm
5   // Negotiate

Default Value

0

Remarks

The type of authorization to perform when connecting to the proxy. This is used only when the proxy_user and proxy_password properties are set.

proxy_auth_scheme should be set to authNone (3) when no authentication is expected.

By default, proxy_auth_scheme is authBasic (0), and if the proxy_user and proxy_password properties are set, the struct will attempt basic authentication.

If proxy_auth_scheme is set to authDigest (1), digest authentication will be attempted instead.

If proxy_auth_scheme is set to authProprietary (2), then the authorization token will not be generated by the struct. Look at the configuration file for the struct being used to find more information about manually setting this token.

If proxy_auth_scheme is set to authNtlm (4), NTLM authentication will be used.

For security reasons, setting this property will clear the values of proxy_user and proxy_password.

Data Type

i32

proxy_auto_detect property (LLMClient Struct)

Whether to automatically detect and use proxy system settings, if available.

Syntax

fn proxy_auto_detect(&self) -> Result<bool, IPWorksLLMError> 
fn set_proxy_auto_detect(&self, value : bool) ->  Option<IPWorksLLMError> 

Default Value

false

Remarks

Whether to automatically detect and use proxy system settings, if available. The default value is false.

Data Type

bool

proxy_password property (LLMClient Struct)

A password if authentication is to be used for the proxy.

Syntax

fn proxy_password(&self) -> Result<String, IPWorksLLMError> 
fn set_proxy_password(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_proxy_password_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

If proxy_auth_scheme is set to Basic Authentication, the proxy_user and proxy_password properties are Base64 encoded and the proxy authentication token will be generated in the form Basic [encoded-user-password].

If proxy_auth_scheme is set to Digest Authentication, the proxy_user and proxy_password properties are used to respond to the Digest Authentication challenge from the server.

If proxy_auth_scheme is set to NTLM Authentication, the proxy_user and proxy_password properties are used to authenticate through NTLM negotiation.

Data Type

String

proxy_port property (LLMClient Struct)

The Transmission Control Protocol (TCP) port for the proxy Server (default 80).

Syntax

fn proxy_port(&self) -> Result<i32, IPWorksLLMError> 
fn set_proxy_port(&self, value : i32) ->  Option<IPWorksLLMError> 

Default Value

80

Remarks

The Transmission Control Protocol (TCP) port for the proxy proxy_server (default 80). See the description of the proxy_server property for details.

Data Type

i32

proxy_server property (LLMClient Struct)

If a proxy Server is given, then the HTTP request is sent to the proxy instead of the server otherwise specified.

Syntax

fn proxy_server(&self) -> Result<String, IPWorksLLMError> 
fn set_proxy_server(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_proxy_server_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

If the proxy_server property is set to a domain name, a DNS request is initiated. Upon successful termination of the request, the proxy_server property is set to the corresponding address. If the search is not successful, an error is returned.

Data Type

String

proxy_ssl property (LLMClient Struct)

When to use a Secure Sockets Layer (SSL) for the connection to the proxy.

Syntax

fn proxy_ssl(&self) -> Result<i32, IPWorksLLMError> 
fn set_proxy_ssl(&self, value : i32) ->  Option<IPWorksLLMError> 

Possible Values

0   // Automatic
1   // Always
2   // Never
3   // Tunnel

Default Value

0

Remarks

When to use a Secure Sockets Layer (SSL) for the connection to the proxy. The applicable values are as follows:

Data Type

i32

proxy_user property (LLMClient Struct)

A username if authentication is to be used for the proxy.

Syntax

fn proxy_user(&self) -> Result<String, IPWorksLLMError> 
fn set_proxy_user(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_proxy_user_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

If proxy_auth_scheme is set to Basic Authentication, the proxy_user and proxy_password properties are Base64 encoded and the proxy authentication token will be generated in the form Basic [encoded-user-password].

If proxy_auth_scheme is set to Digest Authentication, the proxy_user and proxy_password properties are used to respond to the Digest Authentication challenge from the server.

If proxy_auth_scheme is set to NTLM Authentication, the proxy_user and proxy_password properties are used to authenticate through NTLM negotiation.

Data Type

String

response_text property (LLMClient Struct)

The text of the last reply.

Syntax

fn response_text(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

This property holds the text of the reply received by the last call to generate: the Text of every text part of the reply, concatenated in order. It is a convenient way to read the reply in the common case, without searching message_parts for the parts of the appended message.

The model's reasoning is not included. When the reply holds only tool calls, this property is empty; the calls are reported through the on_tool_call event.

This property is cleared when generate, count_tokens, create_embedding, or list_models is called.

This property is read-only.

Data Type

String

server_url property (LLMClient Struct)

The base URL of the provider's API endpoint.

Syntax

fn server_url(&self) -> Result<String, IPWorksLLMError> 
fn set_server_url(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_server_url_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property specifies the base URL used to build request URLs. When this property is empty (the default), the default base URL of the provider selected by service_provider is used:

The custom values of service_provider (spCustomGemini (97), spCustomAnthropic (98), and spCustomOpenAI (99)) have no default base URL: this property must be set before calling generate, count_tokens, or list_models, which otherwise fail with error 802.

Operation paths, such as /chat/completions, /messages, or /models/{Model}:generateContent, are appended to this value verbatim; no part of the value is rewritten, so endpoints that include or omit a version segment (such as /v1) are both supported.

In most cases, the default endpoint is the correct choice. This property should only be set when connecting to a custom endpoint, to an Ollama or LM Studio server on another host or port, or through a gateway or proxy that implements the selected provider's API.

Changing service_provider does not change this property. Set it back to an empty string to use the default base URL of the newly selected provider.

The following example targets a vLLM server on another machine, which expects no api_key at all.

llmclient.ServiceProvider = LLMClientServiceProviders.spCustomOpenAI; llmclient.ServerURL = "http://192.168.1.20:8000/v1"; llmclient.Model = "meta-llama/Llama-3.1-8B-Instruct"; llmclient.AddMessage("user", "What is the capital of France?"); llmclient.Generate();

In the Async Edition (nsoftware.async.IPWorksLLM), the same operation is awaited:

llmclient.ServiceProvider = LLMClientServiceProviders.spCustomOpenAI; llmclient.ServerURL = "http://192.168.1.20:8000/v1"; llmclient.Model = "meta-llama/Llama-3.1-8B-Instruct"; await llmclient.AddMessage("user", "What is the capital of France?"); await llmclient.Generate();

Data Type

String

service_provider property (LLMClient Struct)

The provider the struct communicates with.

Syntax

fn service_provider(&self) -> Result<i32, IPWorksLLMError> 
fn set_service_provider(&self, value : i32) ->  Option<IPWorksLLMError> 

Possible Values

0   // OpenAI
1   // Anthropic
2   // Gemini
3   // Ollama
4   // LMStudio
5   // Groq
6   // OpenRouter
7   // TogetherAI
8   // FireworksAI
97   // CustomGemini
98   // CustomAnthropic
99   // CustomOpenAI

Default Value

0

Remarks

This property specifies the provider whose API is used by generate, count_tokens, create_embedding, and list_models. Every provider implements one of three APIs: the OpenAI Chat Completions API, the Anthropic Messages API, or the Google Gemini API. Possible values are:

The selected provider determines the default request URL, the header that carries api_key, and the shape of every request and reply. The conversation itself is held in a provider-neutral form in messages and message_parts, and is translated for the selected provider each time a request is sent.

Where this documentation describes the behavior of spOpenAI, spAnthropic, or spGemini, the same behavior applies to every other value that uses the same API, unless stated otherwise. The differences between providers that share an API are:

• The default base URL, listed under server_url. The custom values (97 to 99) have no default, so server_url must be set before any request is made; otherwise the request fails with error 802.
• The field that carries max_output_tokens, as described there.
• The ToolChoice configuration setting, which must be empty or auto with spOllama, because Ollama does not support choosing tools.

A service that expects requests exactly as one of the official APIs does, such as a gateway or proxy in front of that API, is best used by selecting the official value (for example spOpenAI) and setting server_url, rather than by selecting a custom value.

Changing this property to a different value keeps messages, message_parts, and tools, so a conversation may be continued with another provider. The ProviderData property of every item in message_parts is cleared, however, because data that one provider returned, such as the signature of an Anthropic thinking block, cannot be sent to another, and model_marker is cleared for the same reason. Properties such as api_key, model, and server_url keep their values, and normally need to be changed along with this property.

The following example asks a question of one provider and continues the same conversation with another.

llmclient.ServiceProvider = LLMClientServiceProviders.spOpenAI; llmclient.APIKey = "sk-..."; llmclient.Model = "gpt-4o"; llmclient.AddMessage("user", "What is the capital of France?"); llmclient.Generate(); llmclient.ServiceProvider = LLMClientServiceProviders.spAnthropic; llmclient.APIKey = "sk-ant-..."; llmclient.Model = "claude-sonnet-5"; llmclient.MaxOutputTokens = 1024; llmclient.AddMessage("user", "And what is the capital of Germany?"); llmclient.Generate();

In the Async Edition (nsoftware.async.IPWorksLLM), the method calls are awaited:

llmclient.ServiceProvider = LLMClientServiceProviders.spOpenAI; llmclient.APIKey = "sk-..."; llmclient.Model = "gpt-4o"; await llmclient.AddMessage("user", "What is the capital of France?"); await llmclient.Generate(); llmclient.ServiceProvider = LLMClientServiceProviders.spAnthropic; llmclient.APIKey = "sk-ant-..."; llmclient.Model = "claude-sonnet-5"; llmclient.MaxOutputTokens = 1024; await llmclient.AddMessage("user", "And what is the capital of Germany?"); await llmclient.Generate();

Data Type

i32

ssl_accept_server_cert_effective_date property (LLMClient Struct)

The date on which this certificate becomes valid.

Syntax

fn ssl_accept_server_cert_effective_date(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The date on which this certificate becomes valid. Before this date, it is not valid. The date is localized to the system's time zone. The following example illustrates the format of an encoded date:

23-Jan-2000 15:00:00.

This property is read-only.

Data Type

String

ssl_accept_server_cert_expiration_date property (LLMClient Struct)

The date on which the certificate expires.

Syntax

fn ssl_accept_server_cert_expiration_date(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The date on which the certificate expires. After this date, the certificate will no longer be valid. The date is localized to the system's time zone. The following example illustrates the format of an encoded date:

23-Jan-2001 15:00:00.

This property is read-only.

Data Type

String

ssl_accept_server_cert_extended_key_usage property (LLMClient Struct)

A comma-delimited list of extended key usage identifiers.

Syntax

fn ssl_accept_server_cert_extended_key_usage(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

A comma-delimited list of extended key usage identifiers. These are the same as ASN.1 object identifiers (OIDs).

This property is read-only.

Data Type

String

ssl_accept_server_cert_fingerprint property (LLMClient Struct)

The hex-encoded, 16-byte MD5 fingerprint of the certificate.

Syntax

fn ssl_accept_server_cert_fingerprint(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The hex-encoded, 16-byte MD5 fingerprint of the certificate. This property is primarily used for keys which do not have a corresponding X.509 public certificate, such as PEM keys that only contain a private key. It is commonly used for SSH keys.

The following example illustrates the format: bc:2a:72:af:fe:58:17:43:7a:5f:ba:5a:7c:90:f7:02

This property is read-only.

Data Type

String

ssl_accept_server_cert_fingerprint_sha1 property (LLMClient Struct)

The hex-encoded, 20-byte SHA-1 fingerprint of the certificate.

Syntax

fn ssl_accept_server_cert_fingerprint_sha1(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The hex-encoded, 20-byte SHA-1 fingerprint of the certificate. This property is primarily used for keys which do not have a corresponding X.509 public certificate, such as PEM keys that only contain a private key. It is commonly used for SSH keys.

The following example illustrates the format: 30:7b:fa:38:65:83:ff:da:b4:4e:07:3f:17:b8:a4:ed:80:be:ff:84

This property is read-only.

Data Type

String

ssl_accept_server_cert_fingerprint_sha256 property (LLMClient Struct)

The hex-encoded, 32-byte SHA-256 fingerprint of the certificate.

Syntax

fn ssl_accept_server_cert_fingerprint_sha256(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The hex-encoded, 32-byte SHA-256 fingerprint of the certificate. This property is primarily used for keys which do not have a corresponding X.509 public certificate, such as PEM keys that only contain a private key. It is commonly used for SSH keys.

The following example illustrates the format: 6a:80:5c:33:a9:43:ea:b0:96:12:8a:64:96:30:ef:4a:8a:96:86:ce:f4:c7:be:10:24:8e:2b:60:9e:f3:59:53

This property is read-only.

Data Type

String

ssl_accept_server_cert_issuer property (LLMClient Struct)

The issuer of the certificate.

Syntax

fn ssl_accept_server_cert_issuer(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The issuer of the certificate. This property contains a string representation of the name of the issuing authority for the certificate.

This property is read-only.

Data Type

String

ssl_accept_server_cert_private_key property (LLMClient Struct)

The private key of the certificate (if available).

Syntax

fn ssl_accept_server_cert_private_key(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The private key of the certificate (if available). The key is provided as PEM/Base64-encoded data.

NOTE: The ssl_accept_server_cert_private_key may be available but not exportable. In this case, ssl_accept_server_cert_private_key returns an empty string.

This property is read-only.

Data Type

String

ssl_accept_server_cert_private_key_available property (LLMClient Struct)

Whether a PrivateKey is available for the selected certificate.

Syntax

fn ssl_accept_server_cert_private_key_available(&self) -> Result<bool, IPWorksLLMError> 

Default Value

false

Remarks

Whether a ssl_accept_server_cert_private_key is available for the selected certificate. If ssl_accept_server_cert_private_key_available is True, the certificate may be used for authentication purposes (e.g., server authentication).

This property is read-only.

Data Type

bool

ssl_accept_server_cert_private_key_container property (LLMClient Struct)

The name of the PrivateKey container for the certificate (if available).

Syntax

fn ssl_accept_server_cert_private_key_container(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The name of the ssl_accept_server_cert_private_key container for the certificate (if available). This functionality is available only on Windows platforms.

This property is read-only.

Data Type

String

ssl_accept_server_cert_public_key property (LLMClient Struct)

The public key of the certificate.

Syntax

fn ssl_accept_server_cert_public_key(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The public key of the certificate. The key is provided as PEM/Base64-encoded data.

This property is read-only.

Data Type

String

ssl_accept_server_cert_public_key_algorithm property (LLMClient Struct)

The textual description of the certificate's public key algorithm.

Syntax

fn ssl_accept_server_cert_public_key_algorithm(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The textual description of the certificate's public key algorithm. The property contains either the name of the algorithm (e.g., "RSA" or "RSA_DH") or an object identifier (OID) string representing the algorithm.

This property is read-only.

Data Type

String

ssl_accept_server_cert_public_key_length property (LLMClient Struct)

The length of the certificate's public key (in bits).

Syntax

fn ssl_accept_server_cert_public_key_length(&self) -> Result<i32, IPWorksLLMError> 

Default Value

0

Remarks

The length of the certificate's public key (in bits). Common values are 512, 1024, and 2048.

This property is read-only.

Data Type

i32

ssl_accept_server_cert_serial_number property (LLMClient Struct)

The serial number of the certificate encoded as a string.

Syntax

fn ssl_accept_server_cert_serial_number(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The serial number of the certificate encoded as a string. The number is encoded as a series of hexadecimal digits, with each pair representing a byte of the serial number.

This property is read-only.

Data Type

String

ssl_accept_server_cert_signature_algorithm property (LLMClient Struct)

The text description of the certificate's signature algorithm.

Syntax

fn ssl_accept_server_cert_signature_algorithm(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The text description of the certificate's signature algorithm. The property contains either the name of the algorithm (e.g., "RSA" or "RSA_MD5RSA") or an object identifier (OID) string representing the algorithm.

This property is read-only.

Data Type

String

ssl_accept_server_cert_store property (LLMClient Struct)

The name of the certificate store for the client certificate.

Syntax

fn ssl_accept_server_cert_store(&self) -> Result<Vec<u8>, IPWorksLLMError> 
fn set_ssl_accept_server_cert_store(&self, value : Vec<u8>) ->  Option<IPWorksLLMError> 
fn set_ssl_accept_server_cert_store_ref(&self, value : &[u8]) ->  Option<IPWorksLLMError> 

Default Value

"MY"

Remarks

The ssl_accept_server_cert_store_type property denotes the type of the certificate store specified by ssl_accept_server_cert_store. If the store is password-protected, specify the password in ssl_accept_server_cert_store_password.

ssl_accept_server_cert_store is used in conjunction with the ssl_accept_server_cert_subject property to specify client certificates. If ssl_accept_server_cert_store has a value, and ssl_accept_server_cert_subject or ssl_accept_server_cert_encoded is set, a search for a certificate is initiated. Please see the ssl_accept_server_cert_subject property for details.

Designations of certificate stores are platform dependent.

The following designations are the most common User and Machine certificate stores in Windows:

When the certificate store type is cstPFXFile, this property must be set to the name of the file. When the type is cstPFXBlob, the property must be set to the binary contents of a PFX file (i.e., PKCS#12 certificate store).

Data Type

Vec<u8>

ssl_accept_server_cert_store_password property (LLMClient Struct)

If the type of certificate store requires a password, this property is used to specify the password needed to open the certificate store.

Syntax

fn ssl_accept_server_cert_store_password(&self) -> Result<String, IPWorksLLMError> 
fn set_ssl_accept_server_cert_store_password(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_ssl_accept_server_cert_store_password_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

If the type of certificate store requires a password, this property is used to specify the password needed to open the certificate store.

Data Type

String

ssl_accept_server_cert_store_type property (LLMClient Struct)

The type of certificate store for this certificate.

Syntax

fn ssl_accept_server_cert_store_type(&self) -> Result<i32, IPWorksLLMError> 
fn set_ssl_accept_server_cert_store_type(&self, value : i32) ->  Option<IPWorksLLMError> 

Possible Values

0   // User
1   // Machine
2   // PFXFile
3   // PFXBlob
4   // JKSFile
5   // JKSBlob
6   // PEMKeyFile
7   // PEMKeyBlob
8   // PublicKeyFile
9   // PublicKeyBlob
10   // SSHPublicKeyBlob
11   // P7BFile
12   // P7BBlob
13   // SSHPublicKeyFile
14   // PPKFile
15   // PPKBlob
16   // XMLFile
17   // XMLBlob
18   // JWKFile
19   // JWKBlob
20   // SecurityKey
21   // BCFKSFile
22   // BCFKSBlob
23   // PKCS11
99   // Auto

Default Value

0

Remarks

The struct supports both public and private keys in a variety of formats. When the cstAuto value is used, the struct will automatically determine the type. This property can take one of the following values:

Data Type

i32

ssl_accept_server_cert_subject_alt_names property (LLMClient Struct)

Comma-separated lists of alternative subject names for the certificate.

Syntax

fn ssl_accept_server_cert_subject_alt_names(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

Comma-separated lists of alternative subject names for the certificate.

This property is read-only.

Data Type

String

ssl_accept_server_cert_thumbprint_md5 property (LLMClient Struct)

The MD5 hash of the certificate.

Syntax

fn ssl_accept_server_cert_thumbprint_md5(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The MD5 hash of the certificate. It is primarily used for X.509 certificates. If the hash does not already exist, it is automatically computed.

This property is read-only.

Data Type

String

ssl_accept_server_cert_thumbprint_sha1 property (LLMClient Struct)

The SHA-1 hash of the certificate.

Syntax

fn ssl_accept_server_cert_thumbprint_sha1(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The SHA-1 hash of the certificate. It is primarily used for X.509 certificates. If the hash does not already exist, it is automatically computed.

This property is read-only.

Data Type

String

ssl_accept_server_cert_thumbprint_sha256 property (LLMClient Struct)

The SHA-256 hash of the certificate.

Syntax

fn ssl_accept_server_cert_thumbprint_sha256(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The SHA-256 hash of the certificate. It is primarily used for X.509 certificates. If the hash does not already exist, it is automatically computed.

This property is read-only.

Data Type

String

ssl_accept_server_cert_usage property (LLMClient Struct)

The text description of UsageFlags .

Syntax

fn ssl_accept_server_cert_usage(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

This value will be one or more of the following strings and will be separated by commas:

• Digital Signature
• Non-Repudiation
• Key Encipherment
• Data Encipherment
• Key Agreement
• Certificate Signing
• CRL Signing
• Encipher Only

If the provider is OpenSSL, the value is a comma-separated list of X.509 certificate extension names.

This property is read-only.

Data Type

String

ssl_accept_server_cert_usage_flags property (LLMClient Struct)

The flags that show intended use for the certificate.

Syntax

fn ssl_accept_server_cert_usage_flags(&self) -> Result<i32, IPWorksLLMError> 

Default Value

0

Remarks

The flags that show intended use for the certificate. The value of ssl_accept_server_cert_usage_flags is a combination of the following flags:

Please see the ssl_accept_server_cert_usage property for a text representation of ssl_accept_server_cert_usage_flags.

This functionality currently is not available when the provider is OpenSSL.

This property is read-only.

Data Type

i32

ssl_accept_server_cert_version property (LLMClient Struct)

The certificate's version number.

Syntax

fn ssl_accept_server_cert_version(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The certificate's version number. The possible values are the strings "V1", "V2", and "V3".

This property is read-only.

Data Type

String

ssl_accept_server_cert_subject property (LLMClient Struct)

The subject of the certificate used for client authentication.

Syntax

fn ssl_accept_server_cert_subject(&self) -> Result<String, IPWorksLLMError> 
fn set_ssl_accept_server_cert_subject(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_ssl_accept_server_cert_subject_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property must be set after all other certificate properties are set. When this property is set, a search is performed in the current certificate store to locate a certificate with a matching subject.

If a matching certificate is found, the property is set to the full subject of the matching certificate.

If an exact match is not found, the store is searched for subjects containing the value of the property.

If a match is still not found, the property is set to an empty string, and no certificate is selected.

The special value "*" picks a random certificate in the certificate store.

The certificate subject is a comma-separated list of distinguished name fields and values. For instance, "CN=www.server.com, OU=test, C=US, E=example@email.com". Common fields and their meanings are as follows:

If a field value contains a comma, it must be quoted.

Data Type

String

ssl_accept_server_cert_encoded property (LLMClient Struct)

The certificate (PEM/Base64 encoded).

Syntax

fn ssl_accept_server_cert_encoded(&self) -> Result<Vec<u8>, IPWorksLLMError> 
fn set_ssl_accept_server_cert_encoded(&self, value : Vec<u8>) ->  Option<IPWorksLLMError> 
fn set_ssl_accept_server_cert_encoded_ref(&self, value : &[u8]) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

The certificate (PEM/Base64 encoded). This property is used to assign a specific certificate. The ssl_accept_server_cert_store and ssl_accept_server_cert_subject properties also may be used to specify a certificate.

When ssl_accept_server_cert_encoded is set, a search is initiated in the current ssl_accept_server_cert_store for the private key of the certificate. If the key is found, ssl_accept_server_cert_subject is updated to reflect the full subject of the selected certificate; otherwise, ssl_accept_server_cert_subject is set to an empty string.

Data Type

Vec<u8>

ssl_cert_effective_date property (LLMClient Struct)

The date on which this certificate becomes valid.

Syntax

fn ssl_cert_effective_date(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The date on which this certificate becomes valid. Before this date, it is not valid. The date is localized to the system's time zone. The following example illustrates the format of an encoded date:

23-Jan-2000 15:00:00.

This property is read-only.

Data Type

String

ssl_cert_expiration_date property (LLMClient Struct)

The date on which the certificate expires.

Syntax

fn ssl_cert_expiration_date(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The date on which the certificate expires. After this date, the certificate will no longer be valid. The date is localized to the system's time zone. The following example illustrates the format of an encoded date:

23-Jan-2001 15:00:00.

This property is read-only.

Data Type

String

ssl_cert_extended_key_usage property (LLMClient Struct)

A comma-delimited list of extended key usage identifiers.

Syntax

fn ssl_cert_extended_key_usage(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

A comma-delimited list of extended key usage identifiers. These are the same as ASN.1 object identifiers (OIDs).

This property is read-only.

Data Type

String

ssl_cert_fingerprint property (LLMClient Struct)

The hex-encoded, 16-byte MD5 fingerprint of the certificate.

Syntax

fn ssl_cert_fingerprint(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The hex-encoded, 16-byte MD5 fingerprint of the certificate. This property is primarily used for keys which do not have a corresponding X.509 public certificate, such as PEM keys that only contain a private key. It is commonly used for SSH keys.

The following example illustrates the format: bc:2a:72:af:fe:58:17:43:7a:5f:ba:5a:7c:90:f7:02

This property is read-only.

Data Type

String

ssl_cert_fingerprint_sha1 property (LLMClient Struct)

The hex-encoded, 20-byte SHA-1 fingerprint of the certificate.

Syntax

fn ssl_cert_fingerprint_sha1(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The hex-encoded, 20-byte SHA-1 fingerprint of the certificate. This property is primarily used for keys which do not have a corresponding X.509 public certificate, such as PEM keys that only contain a private key. It is commonly used for SSH keys.

The following example illustrates the format: 30:7b:fa:38:65:83:ff:da:b4:4e:07:3f:17:b8:a4:ed:80:be:ff:84

This property is read-only.

Data Type

String

ssl_cert_fingerprint_sha256 property (LLMClient Struct)

The hex-encoded, 32-byte SHA-256 fingerprint of the certificate.

Syntax

fn ssl_cert_fingerprint_sha256(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The hex-encoded, 32-byte SHA-256 fingerprint of the certificate. This property is primarily used for keys which do not have a corresponding X.509 public certificate, such as PEM keys that only contain a private key. It is commonly used for SSH keys.

The following example illustrates the format: 6a:80:5c:33:a9:43:ea:b0:96:12:8a:64:96:30:ef:4a:8a:96:86:ce:f4:c7:be:10:24:8e:2b:60:9e:f3:59:53

This property is read-only.

Data Type

String

ssl_cert_issuer property (LLMClient Struct)

The issuer of the certificate.

Syntax

fn ssl_cert_issuer(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The issuer of the certificate. This property contains a string representation of the name of the issuing authority for the certificate.

This property is read-only.

Data Type

String

ssl_cert_private_key property (LLMClient Struct)

The private key of the certificate (if available).

Syntax

fn ssl_cert_private_key(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The private key of the certificate (if available). The key is provided as PEM/Base64-encoded data.

NOTE: The ssl_cert_private_key may be available but not exportable. In this case, ssl_cert_private_key returns an empty string.

This property is read-only.

Data Type

String

ssl_cert_private_key_available property (LLMClient Struct)

Whether a PrivateKey is available for the selected certificate.

Syntax

fn ssl_cert_private_key_available(&self) -> Result<bool, IPWorksLLMError> 

Default Value

false

Remarks

Whether a ssl_cert_private_key is available for the selected certificate. If ssl_cert_private_key_available is True, the certificate may be used for authentication purposes (e.g., server authentication).

This property is read-only.

Data Type

bool

ssl_cert_private_key_container property (LLMClient Struct)

The name of the PrivateKey container for the certificate (if available).

Syntax

fn ssl_cert_private_key_container(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The name of the ssl_cert_private_key container for the certificate (if available). This functionality is available only on Windows platforms.

This property is read-only.

Data Type

String

ssl_cert_public_key property (LLMClient Struct)

The public key of the certificate.

Syntax

fn ssl_cert_public_key(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The public key of the certificate. The key is provided as PEM/Base64-encoded data.

This property is read-only.

Data Type

String

ssl_cert_public_key_algorithm property (LLMClient Struct)

The textual description of the certificate's public key algorithm.

Syntax

fn ssl_cert_public_key_algorithm(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The textual description of the certificate's public key algorithm. The property contains either the name of the algorithm (e.g., "RSA" or "RSA_DH") or an object identifier (OID) string representing the algorithm.

This property is read-only.

Data Type

String

ssl_cert_public_key_length property (LLMClient Struct)

The length of the certificate's public key (in bits).

Syntax

fn ssl_cert_public_key_length(&self) -> Result<i32, IPWorksLLMError> 

Default Value

0

Remarks

The length of the certificate's public key (in bits). Common values are 512, 1024, and 2048.

This property is read-only.

Data Type

i32

ssl_cert_serial_number property (LLMClient Struct)

The serial number of the certificate encoded as a string.

Syntax

fn ssl_cert_serial_number(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The serial number of the certificate encoded as a string. The number is encoded as a series of hexadecimal digits, with each pair representing a byte of the serial number.

This property is read-only.

Data Type

String

ssl_cert_signature_algorithm property (LLMClient Struct)

The text description of the certificate's signature algorithm.

Syntax

fn ssl_cert_signature_algorithm(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The text description of the certificate's signature algorithm. The property contains either the name of the algorithm (e.g., "RSA" or "RSA_MD5RSA") or an object identifier (OID) string representing the algorithm.

This property is read-only.

Data Type

String

ssl_cert_store property (LLMClient Struct)

The name of the certificate store for the client certificate.

Syntax

fn ssl_cert_store(&self) -> Result<Vec<u8>, IPWorksLLMError> 
fn set_ssl_cert_store(&self, value : Vec<u8>) ->  Option<IPWorksLLMError> 
fn set_ssl_cert_store_ref(&self, value : &[u8]) ->  Option<IPWorksLLMError> 

Default Value

"MY"

Remarks

The ssl_cert_store_type property denotes the type of the certificate store specified by ssl_cert_store. If the store is password-protected, specify the password in ssl_cert_store_password.

ssl_cert_store is used in conjunction with the ssl_cert_subject property to specify client certificates. If ssl_cert_store has a value, and ssl_cert_subject or ssl_cert_encoded is set, a search for a certificate is initiated. Please see the ssl_cert_subject property for details.

Designations of certificate stores are platform dependent.

The following designations are the most common User and Machine certificate stores in Windows:

When the certificate store type is cstPFXFile, this property must be set to the name of the file. When the type is cstPFXBlob, the property must be set to the binary contents of a PFX file (i.e., PKCS#12 certificate store).

Data Type

Vec<u8>

ssl_cert_store_password property (LLMClient Struct)

If the type of certificate store requires a password, this property is used to specify the password needed to open the certificate store.

Syntax

fn ssl_cert_store_password(&self) -> Result<String, IPWorksLLMError> 
fn set_ssl_cert_store_password(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_ssl_cert_store_password_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

If the type of certificate store requires a password, this property is used to specify the password needed to open the certificate store.

Data Type

String

ssl_cert_store_type property (LLMClient Struct)

The type of certificate store for this certificate.

Syntax

fn ssl_cert_store_type(&self) -> Result<i32, IPWorksLLMError> 
fn set_ssl_cert_store_type(&self, value : i32) ->  Option<IPWorksLLMError> 

Possible Values

0   // User
1   // Machine
2   // PFXFile
3   // PFXBlob
4   // JKSFile
5   // JKSBlob
6   // PEMKeyFile
7   // PEMKeyBlob
8   // PublicKeyFile
9   // PublicKeyBlob
10   // SSHPublicKeyBlob
11   // P7BFile
12   // P7BBlob
13   // SSHPublicKeyFile
14   // PPKFile
15   // PPKBlob
16   // XMLFile
17   // XMLBlob
18   // JWKFile
19   // JWKBlob
20   // SecurityKey
21   // BCFKSFile
22   // BCFKSBlob
23   // PKCS11
99   // Auto

Default Value

0

Remarks

The struct supports both public and private keys in a variety of formats. When the cstAuto value is used, the struct will automatically determine the type. This property can take one of the following values:

Data Type

i32

ssl_cert_subject_alt_names property (LLMClient Struct)

Comma-separated lists of alternative subject names for the certificate.

Syntax

fn ssl_cert_subject_alt_names(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

Comma-separated lists of alternative subject names for the certificate.

This property is read-only.

Data Type

String

ssl_cert_thumbprint_md5 property (LLMClient Struct)

The MD5 hash of the certificate.

Syntax

fn ssl_cert_thumbprint_md5(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The MD5 hash of the certificate. It is primarily used for X.509 certificates. If the hash does not already exist, it is automatically computed.

This property is read-only.

Data Type

String

ssl_cert_thumbprint_sha1 property (LLMClient Struct)

The SHA-1 hash of the certificate.

Syntax

fn ssl_cert_thumbprint_sha1(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The SHA-1 hash of the certificate. It is primarily used for X.509 certificates. If the hash does not already exist, it is automatically computed.

This property is read-only.

Data Type

String

ssl_cert_thumbprint_sha256 property (LLMClient Struct)

The SHA-256 hash of the certificate.

Syntax

fn ssl_cert_thumbprint_sha256(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The SHA-256 hash of the certificate. It is primarily used for X.509 certificates. If the hash does not already exist, it is automatically computed.

This property is read-only.

Data Type

String

ssl_cert_usage property (LLMClient Struct)

The text description of UsageFlags .

Syntax

fn ssl_cert_usage(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

This value will be one or more of the following strings and will be separated by commas:

• Digital Signature
• Non-Repudiation
• Key Encipherment
• Data Encipherment
• Key Agreement
• Certificate Signing
• CRL Signing
• Encipher Only

If the provider is OpenSSL, the value is a comma-separated list of X.509 certificate extension names.

This property is read-only.

Data Type

String

ssl_cert_usage_flags property (LLMClient Struct)

The flags that show intended use for the certificate.

Syntax

fn ssl_cert_usage_flags(&self) -> Result<i32, IPWorksLLMError> 

Default Value

0

Remarks

The flags that show intended use for the certificate. The value of ssl_cert_usage_flags is a combination of the following flags:

Please see the ssl_cert_usage property for a text representation of ssl_cert_usage_flags.

This functionality currently is not available when the provider is OpenSSL.

This property is read-only.

Data Type

i32

ssl_cert_version property (LLMClient Struct)

The certificate's version number.

Syntax

fn ssl_cert_version(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The certificate's version number. The possible values are the strings "V1", "V2", and "V3".

This property is read-only.

Data Type

String

ssl_cert_subject property (LLMClient Struct)

The subject of the certificate used for client authentication.

Syntax

fn ssl_cert_subject(&self) -> Result<String, IPWorksLLMError> 
fn set_ssl_cert_subject(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_ssl_cert_subject_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property must be set after all other certificate properties are set. When this property is set, a search is performed in the current certificate store to locate a certificate with a matching subject.

If a matching certificate is found, the property is set to the full subject of the matching certificate.

If an exact match is not found, the store is searched for subjects containing the value of the property.

If a match is still not found, the property is set to an empty string, and no certificate is selected.

The special value "*" picks a random certificate in the certificate store.

The certificate subject is a comma-separated list of distinguished name fields and values. For instance, "CN=www.server.com, OU=test, C=US, E=example@email.com". Common fields and their meanings are as follows:

If a field value contains a comma, it must be quoted.

Data Type

String

ssl_cert_encoded property (LLMClient Struct)

The certificate (PEM/Base64 encoded).

Syntax

fn ssl_cert_encoded(&self) -> Result<Vec<u8>, IPWorksLLMError> 
fn set_ssl_cert_encoded(&self, value : Vec<u8>) ->  Option<IPWorksLLMError> 
fn set_ssl_cert_encoded_ref(&self, value : &[u8]) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

The certificate (PEM/Base64 encoded). This property is used to assign a specific certificate. The ssl_cert_store and ssl_cert_subject properties also may be used to specify a certificate.

When ssl_cert_encoded is set, a search is initiated in the current ssl_cert_store for the private key of the certificate. If the key is found, ssl_cert_subject is updated to reflect the full subject of the selected certificate; otherwise, ssl_cert_subject is set to an empty string.

Data Type

Vec<u8>

ssl_provider property (LLMClient Struct)

The Secure Sockets Layer/Transport Layer Security (SSL/TLS) implementation to use.

Syntax

fn ssl_provider(&self) -> Result<i32, IPWorksLLMError> 
fn set_ssl_provider(&self, value : i32) ->  Option<IPWorksLLMError> 

Possible Values

0   // Automatic
1   // Platform
2   // Internal

Default Value

0

Remarks

This property specifies the SSL/TLS implementation to use. In most cases the default value of 0 (Automatic) is recommended and should not be changed. When set to 0 (Automatic), the struct will select whether to use the platform implementation or the internal implementation depending on the operating system as well as the TLS version being used.

Possible values are as follows:

In most cases using the default value (Automatic) is recommended. The struct will select a provider depending on the current platform.

When Automatic is selected, on Windows, the struct will use the platform implementation. On Linux/macOS, the struct will use the internal implementation. When TLS 1.3 is enabled via SSLEnabledProtocols, the struct will always try and use the platform implementation. If the platform TLS 1.3 implementation is not available, the internal implementation will be used.

Data Type

i32

ssl_server_cert_effective_date property (LLMClient Struct)

The date on which this certificate becomes valid.

Syntax

fn ssl_server_cert_effective_date(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The date on which this certificate becomes valid. Before this date, it is not valid. The date is localized to the system's time zone. The following example illustrates the format of an encoded date:

23-Jan-2000 15:00:00.

This property is read-only.

Data Type

String

ssl_server_cert_expiration_date property (LLMClient Struct)

The date on which the certificate expires.

Syntax

fn ssl_server_cert_expiration_date(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The date on which the certificate expires. After this date, the certificate will no longer be valid. The date is localized to the system's time zone. The following example illustrates the format of an encoded date:

23-Jan-2001 15:00:00.

This property is read-only.

Data Type

String

ssl_server_cert_extended_key_usage property (LLMClient Struct)

A comma-delimited list of extended key usage identifiers.

Syntax

fn ssl_server_cert_extended_key_usage(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

A comma-delimited list of extended key usage identifiers. These are the same as ASN.1 object identifiers (OIDs).

This property is read-only.

Data Type

String

ssl_server_cert_fingerprint property (LLMClient Struct)

The hex-encoded, 16-byte MD5 fingerprint of the certificate.

Syntax

fn ssl_server_cert_fingerprint(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The hex-encoded, 16-byte MD5 fingerprint of the certificate. This property is primarily used for keys which do not have a corresponding X.509 public certificate, such as PEM keys that only contain a private key. It is commonly used for SSH keys.

The following example illustrates the format: bc:2a:72:af:fe:58:17:43:7a:5f:ba:5a:7c:90:f7:02

This property is read-only.

Data Type

String

ssl_server_cert_fingerprint_sha1 property (LLMClient Struct)

The hex-encoded, 20-byte SHA-1 fingerprint of the certificate.

Syntax

fn ssl_server_cert_fingerprint_sha1(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The hex-encoded, 20-byte SHA-1 fingerprint of the certificate. This property is primarily used for keys which do not have a corresponding X.509 public certificate, such as PEM keys that only contain a private key. It is commonly used for SSH keys.

The following example illustrates the format: 30:7b:fa:38:65:83:ff:da:b4:4e:07:3f:17:b8:a4:ed:80:be:ff:84

This property is read-only.

Data Type

String

ssl_server_cert_fingerprint_sha256 property (LLMClient Struct)

The hex-encoded, 32-byte SHA-256 fingerprint of the certificate.

Syntax

fn ssl_server_cert_fingerprint_sha256(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The hex-encoded, 32-byte SHA-256 fingerprint of the certificate. This property is primarily used for keys which do not have a corresponding X.509 public certificate, such as PEM keys that only contain a private key. It is commonly used for SSH keys.

The following example illustrates the format: 6a:80:5c:33:a9:43:ea:b0:96:12:8a:64:96:30:ef:4a:8a:96:86:ce:f4:c7:be:10:24:8e:2b:60:9e:f3:59:53

This property is read-only.

Data Type

String

ssl_server_cert_issuer property (LLMClient Struct)

The issuer of the certificate.

Syntax

fn ssl_server_cert_issuer(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The issuer of the certificate. This property contains a string representation of the name of the issuing authority for the certificate.

This property is read-only.

Data Type

String

ssl_server_cert_private_key property (LLMClient Struct)

The private key of the certificate (if available).

Syntax

fn ssl_server_cert_private_key(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The private key of the certificate (if available). The key is provided as PEM/Base64-encoded data.

NOTE: The ssl_server_cert_private_key may be available but not exportable. In this case, ssl_server_cert_private_key returns an empty string.

This property is read-only.

Data Type

String

ssl_server_cert_private_key_available property (LLMClient Struct)

Whether a PrivateKey is available for the selected certificate.

Syntax

fn ssl_server_cert_private_key_available(&self) -> Result<bool, IPWorksLLMError> 

Default Value

false

Remarks

Whether a ssl_server_cert_private_key is available for the selected certificate. If ssl_server_cert_private_key_available is True, the certificate may be used for authentication purposes (e.g., server authentication).

This property is read-only.

Data Type

bool

ssl_server_cert_private_key_container property (LLMClient Struct)

The name of the PrivateKey container for the certificate (if available).

Syntax

fn ssl_server_cert_private_key_container(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The name of the ssl_server_cert_private_key container for the certificate (if available). This functionality is available only on Windows platforms.

This property is read-only.

Data Type

String

ssl_server_cert_public_key property (LLMClient Struct)

The public key of the certificate.

Syntax

fn ssl_server_cert_public_key(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The public key of the certificate. The key is provided as PEM/Base64-encoded data.

This property is read-only.

Data Type

String

ssl_server_cert_public_key_algorithm property (LLMClient Struct)

The textual description of the certificate's public key algorithm.

Syntax

fn ssl_server_cert_public_key_algorithm(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The textual description of the certificate's public key algorithm. The property contains either the name of the algorithm (e.g., "RSA" or "RSA_DH") or an object identifier (OID) string representing the algorithm.

This property is read-only.

Data Type

String

ssl_server_cert_public_key_length property (LLMClient Struct)

The length of the certificate's public key (in bits).

Syntax

fn ssl_server_cert_public_key_length(&self) -> Result<i32, IPWorksLLMError> 

Default Value

0

Remarks

The length of the certificate's public key (in bits). Common values are 512, 1024, and 2048.

This property is read-only.

Data Type

i32

ssl_server_cert_serial_number property (LLMClient Struct)

The serial number of the certificate encoded as a string.

Syntax

fn ssl_server_cert_serial_number(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The serial number of the certificate encoded as a string. The number is encoded as a series of hexadecimal digits, with each pair representing a byte of the serial number.

This property is read-only.

Data Type

String

ssl_server_cert_signature_algorithm property (LLMClient Struct)

The text description of the certificate's signature algorithm.

Syntax

fn ssl_server_cert_signature_algorithm(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The text description of the certificate's signature algorithm. The property contains either the name of the algorithm (e.g., "RSA" or "RSA_MD5RSA") or an object identifier (OID) string representing the algorithm.

This property is read-only.

Data Type

String

ssl_server_cert_store property (LLMClient Struct)

The name of the certificate store for the client certificate.

Syntax

fn ssl_server_cert_store(&self) -> Result<Vec<u8>, IPWorksLLMError> 

Default Value

"MY"

Remarks

The ssl_server_cert_store_type property denotes the type of the certificate store specified by ssl_server_cert_store. If the store is password-protected, specify the password in ssl_server_cert_store_password.

ssl_server_cert_store is used in conjunction with the ssl_server_cert_subject property to specify client certificates. If ssl_server_cert_store has a value, and ssl_server_cert_subject or ssl_server_cert_encoded is set, a search for a certificate is initiated. Please see the ssl_server_cert_subject property for details.

Designations of certificate stores are platform dependent.

The following designations are the most common User and Machine certificate stores in Windows:

When the certificate store type is cstPFXFile, this property must be set to the name of the file. When the type is cstPFXBlob, the property must be set to the binary contents of a PFX file (i.e., PKCS#12 certificate store).

This property is read-only.

Data Type

Vec<u8>

ssl_server_cert_store_password property (LLMClient Struct)

If the type of certificate store requires a password, this property is used to specify the password needed to open the certificate store.

Syntax

fn ssl_server_cert_store_password(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

If the type of certificate store requires a password, this property is used to specify the password needed to open the certificate store.

This property is read-only.

Data Type

String

ssl_server_cert_store_type property (LLMClient Struct)

The type of certificate store for this certificate.

Syntax

fn ssl_server_cert_store_type(&self) -> Result<i32, IPWorksLLMError> 

Possible Values

0   // User
1   // Machine
2   // PFXFile
3   // PFXBlob
4   // JKSFile
5   // JKSBlob
6   // PEMKeyFile
7   // PEMKeyBlob
8   // PublicKeyFile
9   // PublicKeyBlob
10   // SSHPublicKeyBlob
11   // P7BFile
12   // P7BBlob
13   // SSHPublicKeyFile
14   // PPKFile
15   // PPKBlob
16   // XMLFile
17   // XMLBlob
18   // JWKFile
19   // JWKBlob
20   // SecurityKey
21   // BCFKSFile
22   // BCFKSBlob
23   // PKCS11
99   // Auto

Default Value

0

Remarks

The struct supports both public and private keys in a variety of formats. When the cstAuto value is used, the struct will automatically determine the type. This property can take one of the following values:

This property is read-only.

Data Type

i32

ssl_server_cert_subject_alt_names property (LLMClient Struct)

Comma-separated lists of alternative subject names for the certificate.

Syntax

fn ssl_server_cert_subject_alt_names(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

Comma-separated lists of alternative subject names for the certificate.

This property is read-only.

Data Type

String

ssl_server_cert_thumbprint_md5 property (LLMClient Struct)

The MD5 hash of the certificate.

Syntax

fn ssl_server_cert_thumbprint_md5(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The MD5 hash of the certificate. It is primarily used for X.509 certificates. If the hash does not already exist, it is automatically computed.

This property is read-only.

Data Type

String

ssl_server_cert_thumbprint_sha1 property (LLMClient Struct)

The SHA-1 hash of the certificate.

Syntax

fn ssl_server_cert_thumbprint_sha1(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The SHA-1 hash of the certificate. It is primarily used for X.509 certificates. If the hash does not already exist, it is automatically computed.

This property is read-only.

Data Type

String

ssl_server_cert_thumbprint_sha256 property (LLMClient Struct)

The SHA-256 hash of the certificate.

Syntax

fn ssl_server_cert_thumbprint_sha256(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The SHA-256 hash of the certificate. It is primarily used for X.509 certificates. If the hash does not already exist, it is automatically computed.

This property is read-only.

Data Type

String

ssl_server_cert_usage property (LLMClient Struct)

The text description of UsageFlags .

Syntax

fn ssl_server_cert_usage(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

This value will be one or more of the following strings and will be separated by commas:

• Digital Signature
• Non-Repudiation
• Key Encipherment
• Data Encipherment
• Key Agreement
• Certificate Signing
• CRL Signing
• Encipher Only

If the provider is OpenSSL, the value is a comma-separated list of X.509 certificate extension names.

This property is read-only.

Data Type

String

ssl_server_cert_usage_flags property (LLMClient Struct)

The flags that show intended use for the certificate.

Syntax

fn ssl_server_cert_usage_flags(&self) -> Result<i32, IPWorksLLMError> 

Default Value

0

Remarks

The flags that show intended use for the certificate. The value of ssl_server_cert_usage_flags is a combination of the following flags:

Please see the ssl_server_cert_usage property for a text representation of ssl_server_cert_usage_flags.

This functionality currently is not available when the provider is OpenSSL.

This property is read-only.

Data Type

i32

ssl_server_cert_version property (LLMClient Struct)

The certificate's version number.

Syntax

fn ssl_server_cert_version(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

The certificate's version number. The possible values are the strings "V1", "V2", and "V3".

This property is read-only.

Data Type

String

ssl_server_cert_subject property (LLMClient Struct)

The subject of the certificate used for client authentication.

Syntax

fn ssl_server_cert_subject(&self) -> Result<String, IPWorksLLMError> 

Default Value

""

Remarks

This property must be set after all other certificate properties are set. When this property is set, a search is performed in the current certificate store to locate a certificate with a matching subject.

If a matching certificate is found, the property is set to the full subject of the matching certificate.

If an exact match is not found, the store is searched for subjects containing the value of the property.

If a match is still not found, the property is set to an empty string, and no certificate is selected.

The special value "*" picks a random certificate in the certificate store.

The certificate subject is a comma-separated list of distinguished name fields and values. For instance, "CN=www.server.com, OU=test, C=US, E=example@email.com". Common fields and their meanings are as follows:

If a field value contains a comma, it must be quoted.

This property is read-only.

Data Type

String

ssl_server_cert_encoded property (LLMClient Struct)

The certificate (PEM/Base64 encoded).

Syntax

fn ssl_server_cert_encoded(&self) -> Result<Vec<u8>, IPWorksLLMError> 

Default Value

""

Remarks

The certificate (PEM/Base64 encoded). This property is used to assign a specific certificate. The ssl_server_cert_store and ssl_server_cert_subject properties also may be used to specify a certificate.

When ssl_server_cert_encoded is set, a search is initiated in the current ssl_server_cert_store for the private key of the certificate. If the key is found, ssl_server_cert_subject is updated to reflect the full subject of the selected certificate; otherwise, ssl_server_cert_subject is set to an empty string.

This property is read-only.

Data Type

Vec<u8>

stream property (LLMClient Struct)

Whether the reply should be streamed.

Syntax

fn stream(&self) -> Result<bool, IPWorksLLMError> 
fn set_stream(&self, value : bool) ->  Option<IPWorksLLMError> 

Default Value

false

Remarks

When this property is set to True, generate requests a streamed reply and the on_content_delta event fires once for each fragment of the reply as it is received. The event's PartType parameter is 0 (ptText) for a fragment of visible text and 5 (ptReasoning) for a fragment of the model's reasoning.

A streamed reply is requested with the stream field of the request when service_provider is spOpenAI or spAnthropic, and through the streamGenerateContent operation, with the alt=sse query parameter, when it is spGemini.

In both cases, once the reply has been fully received it is appended to messages and message_parts, and the on_tool_call event fires for each tool the model called.

The default value is False.

The following example prints the text of the reply as it arrives.

llmclient.Stream = true; llmclient.OnContentDelta += (s, e) => { if (e.PartType == (int)PartTypes.ptText) Console.Write(e.Delta); }; llmclient.AddMessage("user", "Write a short poem about the sea."); llmclient.Generate();

In the Async Edition (nsoftware.async.IPWorksLLM), the handler returns a task and the request is awaited:

llmclient.Stream = true; llmclient.OnContentDelta += async (s, e) => { if (e.PartType == (int)PartTypes.ptText) Console.Write(e.Delta); }; await llmclient.AddMessage("user", "Write a short poem about the sea."); await llmclient.Generate();

Data Type

bool

system_prompt property (LLMClient Struct)

The system prompt sent alongside the conversation.

Syntax

fn system_prompt(&self) -> Result<String, IPWorksLLMError> 
fn set_system_prompt(&self, value : &str) ->  Option<IPWorksLLMError> 
fn set_system_prompt_ref(&self, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property specifies the system prompt, which gives the model context and instructions that apply to the whole conversation, such as a role to adopt or a goal to pursue.

Each provider receives the system prompt in the form its API expects:

When this property is left empty (the default), no system prompt is sent.

The following example gives the model a role that applies to the whole conversation.

llmclient.SystemPrompt = "You are a concise assistant. Answer in one sentence."; llmclient.AddMessage("user", "What is the capital of France?"); llmclient.Generate();

In the Async Edition (nsoftware.async.IPWorksLLM), the property is set the same way and the request is awaited:

llmclient.SystemPrompt = "You are a concise assistant. Answer in one sentence."; await llmclient.AddMessage("user", "What is the capital of France?"); await llmclient.Generate();

Data Type

String

timeout property (LLMClient Struct)

The timeout for operations in seconds.

Syntax

fn timeout(&self) -> Result<i32, IPWorksLLMError> 
fn set_timeout(&self, value : i32) ->  Option<IPWorksLLMError> 

Default Value

60

Remarks

This property specifies the timeout period in seconds for operations performed by the struct.

If this is set to 0, all operations will run uninterrupted until successful completion or an error condition is encountered.

If this is set to a positive value, the struct will wait for the operation to complete before returning control. If the timeout expires before the operation completes, the struct throws an exception.

Note that all timeouts are inactivity timeouts, meaning the timeout period is extended by value specified in this property when any amount of data is successfully sent or received.

Data Type

i32

tool_count property (LLMClient Struct)

The number of records in the Tool arrays.

Syntax

fn tool_count(&self) -> Result<i32, IPWorksLLMError> 
fn set_tool_count(&self, value : i32) ->  Option<IPWorksLLMError> 

Default Value

0

Remarks

This property controls the size of the following arrays:

• tool_description
• tool_input_schema
• tool_name

The array indices start at 0 and end at tool_count - 1.

Data Type

i32

tool_description property (LLMClient Struct)

A description of what the tool does.

Syntax

fn tool_description(&self, ToolIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_tool_description(&self, ToolIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_tool_description_ref(&self, ToolIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property holds a natural language description of what the tool does and when it should be used. A thorough description materially improves the model's ability to choose the tool appropriately.

The ToolIndex parameter specifies the index of the item in the array. The size of the array is controlled by the tool_count property.

Data Type

String

tool_input_schema property (LLMClient Struct)

The raw JSON Schema describing the tool's input.

Syntax

fn tool_input_schema(&self, ToolIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_tool_input_schema(&self, ToolIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_tool_input_schema_ref(&self, ToolIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property holds the raw JSON Schema object describing the input the tool expects, as built by add_tool from calls to add_tool_param, as passed to add_tool, or as set directly. It is sent as the parameters of the function with spOpenAI, as the input_schema of the tool with spAnthropic, and as the parametersJsonSchema of the function declaration with spGemini.

When left empty, a schema equivalent to {"type": "object"} (no input) is used.

The ToolIndex parameter specifies the index of the item in the array. The size of the array is controlled by the tool_count property.

Data Type

String

tool_name property (LLMClient Struct)

The unique name associated with the tool.

Syntax

fn tool_name(&self, ToolIndex : i32) -> Result<String, IPWorksLLMError> 
fn set_tool_name(&self, ToolIndex : i32, value : &str) ->  Option<IPWorksLLMError> 
fn set_tool_name_ref(&self, ToolIndex : i32, value : &String) ->  Option<IPWorksLLMError> 

Default Value

""

Remarks

This property identifies the unique name associated with the tool. The model uses this name when it calls the tool, and it is reported as the Name parameter of the on_tool_call event. The ToolChoice configuration setting may be set to this name to require the model to call the tool.

The ToolIndex parameter specifies the index of the item in the array. The size of the array is controlled by the tool_count property.

Data Type

String

total_tokens property (LLMClient Struct)

The total number of tokens the provider counted for the last request.

Syntax

fn total_tokens(&self) -> Result<i32, IPWorksLLMError> 

Default Value

0

Remarks

This property reports the total number of tokens used by the last call to generate or create_embedding. When the provider reports a total, that value is used:

When the provider reports usage but no total, this property holds the sum of input_tokens and output_tokens. A value of 0 means the provider did not report usage for the last request. This property is cleared when generate, count_tokens, create_embedding, or list_models is called.

This property is read-only.

Data Type

i32

add_message method (LLMClient Struct)

Adds a message to the conversation and returns its Id.

Syntax

fn add_message(&self, role : &str, content : &str) -> Result<String, IPWorksLLMError>

Remarks

This method appends a new LLMMessage item with the given Role to the messages properties, and returns the Id generated for it. A generated Id has the form msg followed by a number, and never repeats an Id already present in messages.

When Content is not empty, a text part holding Content is also appended to the message_parts properties for the new message. To add further content to the message, such as an image or a file, pass the returned Id to add_message_part.

Role must not be empty, and is normally user or assistant. The results of tool calls are added with add_tool_result, which maintains the messages with role tool. Other roles, such as developer, are sent unchanged when service_provider is spOpenAI; the Anthropic and Gemini APIs do not accept them, so with spAnthropic or spGemini generate and count_tokens fail with error 804. A system prompt is supplied through the system_prompt property instead of a message.

The following example adds a question together with an image.

string id = llmclient.AddMessage("user", "What is in this picture?"); llmclient.AddMessagePart(id, (int)PartTypes.ptImage, "https://www.example.com/photo.jpg", "image/jpeg"); llmclient.Generate();

In the Async Edition (nsoftware.async.IPWorksLLM), the method calls are awaited:

string id = await llmclient.AddMessage("user", "What is in this picture?"); await llmclient.AddMessagePart(id, (int)PartTypes.ptImage, "https://www.example.com/photo.jpg", "image/jpeg"); await llmclient.Generate();

add_message_part method (LLMClient Struct)

Adds a content part to a message.

Syntax

fn add_message_part(&self, message_id : &str, part_type : i32, content : &str, media_type : &str) -> Result<(), IPWorksLLMError>

Remarks

This method appends a new LLMMessagePart item of the given PartType to the message_parts properties. MessageId must be the Id of a message in messages, such as the value returned by add_message; otherwise this method fails with error 802.

PartType specifies the kind of part, and determines the meaning of Content. A value outside the range below causes this method to fail with error 802.

MediaType specifies the media type of an image or a file, such as image/png or application/pdf, and is stored in the part's MediaType property. It must be set when the bytes are supplied through Data; for a data: URL, the media type the URL names is used when MediaType is empty. It may be left empty for the other part types.

The following example adds a PDF document read from disk to a question.

string id = llmclient.AddMessage("user", "Summarize this report."); llmclient.AddMessagePart(id, (int)PartTypes.ptFile, "", "application/pdf"); LLMMessagePart part = llmclient.MessageParts[llmclient.MessageParts.Count - 1]; part.DataB = File.ReadAllBytes("report.pdf"); part.FileName = "report.pdf"; llmclient.Generate();

In the Async Edition (nsoftware.async.IPWorksLLM), the method calls are awaited:

string id = await llmclient.AddMessage("user", "Summarize this report."); await llmclient.AddMessagePart(id, (int)PartTypes.ptFile, "", "application/pdf"); LLMMessagePart part = llmclient.MessageParts[llmclient.MessageParts.Count - 1]; part.DataB = File.ReadAllBytes("report.pdf"); part.FileName = "report.pdf"; await llmclient.Generate();

add_tool method (LLMClient Struct)

Appends a tool to the Tools collection.

Syntax

fn add_tool(&self, name : &str, description : &str, input_schema : &str) -> Result<(), IPWorksLLMError>

Remarks

This method appends a new LLMTool item, with the given Name, Description, and InputSchema, to the tools properties. Name must not be empty.

InputSchema is the JSON Schema object that describes the input the tool expects. When InputSchema is empty, the schema is built from the parameters queued by prior calls to add_tool_param. When no parameters were queued either, the tool's InputSchema is left empty, and a schema equivalent to {"type":"object"} (no input) is sent. The parameter queue is cleared each time this method is called.

Example: llmclient.AddToolParam("location", "string", "The city and state, e.g. San Francisco, CA", true); llmclient.AddTool("get_weather", "Gets the current weather for a location.", ""); // Alternatively, declare the same tool with a complete JSON Schema. llmclient.AddTool("get_weather", "Gets the current weather for a location.", "{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\"," + "\"description\":\"The city and state, e.g. San Francisco, CA\"}}," + "\"required\":[\"location\"]}");

In the Async Edition (nsoftware.async.IPWorksLLM), the calls are awaited:

await llmclient.AddToolParam("location", "string", "The city and state, e.g. San Francisco, CA", true); await llmclient.AddTool("get_weather", "Gets the current weather for a location.", "");

add_tool_param method (LLMClient Struct)

Queues a parameter to be included in the next tool added via AddTool.

Syntax

fn add_tool_param(&self, name : &str, param_type : &str, description : &str, required : bool) -> Result<(), IPWorksLLMError>

Remarks

This method queues a parameter to be included in the JSON Schema of the next tool appended via add_tool.

Name specifies the parameter's name.

ParamType specifies the parameter's JSON Schema type, such as string, number, boolean, or object.

Description specifies a natural language description of the parameter, which helps the model determine appropriate values for it.

Required specifies whether the model must supply a value for this parameter whenever it calls the tool.

Queued parameters are consumed, and the queue is cleared, the next time add_tool is called. They are used only when that call passes an empty InputSchema; a non-empty InputSchema is used as given.

add_tool_result method (LLMClient Struct)

Adds the result of a tool call to the conversation.

Syntax

fn add_tool_result(&self, tool_call_id : &str, content : &str, is_error : bool) -> Result<(), IPWorksLLMError>

Remarks

This method answers a tool call the model made, as reported by the on_tool_call event. It appends a tool result part to the message with role tool at the end of messages; when the last message is not a tool message, a new one is appended first. Calling this method once for each call of a reply therefore collects all of the results in one message.

ToolCallId is the Id reported by on_tool_call. It must match the ToolCallId of a tool call part in message_parts; otherwise this method fails with error 802. The ToolName of that call is copied to the new part, because the Gemini API identifies a result by the name of the function it answers.

Content is the result of the tool, typically text or a JSON value, and is stored in the new part's Text property. The Gemini API accepts only a JSON object as the response of a function. With spGemini, when IsError is False, a Content that is a JSON object is sent as is and any other value is sent as {"result": Content}; when IsError is True, the result is sent as {"error": Content}.

IsError specifies whether the tool failed, in which case Content describes the error. It is sent as the is_error field of the tool result when service_provider is spAnthropic. The OpenAI API has no equivalent field, so with spOpenAI this parameter has no effect and Content alone should describe the error.

Each provider receives the results in the form its API expects: one message with role tool per result with spOpenAI, tool_result blocks at the start of a user message with spAnthropic, and functionResponse parts of a user message with spGemini.

Once every call of the reply has been answered, call generate again so the model can use the results.

The following example answers each call as it is reported.

llmclient.OnToolCall += (s, e) => { string result; bool failed = false; try { result = GetWeather(e.ArgumentsJson); } catch (Exception ex) { result = "The weather service failed: " + ex.Message; failed = true; } llmclient.AddToolResult(e.Id, result, failed); }; llmclient.AddMessage("user", "What is the weather like in Boston?"); llmclient.Generate(); while (llmclient.FinishReason == LLMClientFinishReasons.frToolCalls) llmclient.Generate();

In the Async Edition (nsoftware.async.IPWorksLLM), the handler returns a task and each call is awaited:

llmclient.OnToolCall += async (s, e) => { string result; bool failed = false; try { result = GetWeather(e.ArgumentsJson); } catch (Exception ex) { result = "The weather service failed: " + ex.Message; failed = true; } await llmclient.AddToolResult(e.Id, result, failed); }; await llmclient.AddMessage("user", "What is the weather like in Boston?"); await llmclient.Generate(); while (llmclient.FinishReason == LLMClientFinishReasons.frToolCalls) await llmclient.Generate();

config method (LLMClient Struct)

Sets or retrieves a configuration setting.

Syntax

fn config(&self, configuration_string : &str) -> Result<String, IPWorksLLMError>

Remarks

config is a generic method available in every struct. It is used to set and retrieve configuration settings for the struct.

These settings are similar in functionality to properties, but they are rarely used. In order to avoid "polluting" the property namespace of the struct, access to these internal properties is provided through the config method.

To set a configuration setting named PROPERTY, you must call Config("PROPERTY=VALUE"), where VALUE is the value of the setting expressed as a string. For boolean values, use the strings "True", "False", "0", "1", "Yes", or "No" (case does not matter).

To read (query) the value of a configuration setting, you must call Config("PROPERTY"). The value will be returned as a string.

count_tokens method (LLMClient Struct)

Counts the input tokens the current conversation would consume.

Syntax

fn count_tokens(&self) -> Result<i32, IPWorksLLMError>

Remarks

This method sends the conversation in messages and message_parts, together with system_prompt and tools, to the token counting endpoint of the selected provider, and returns the number of input tokens the model would consume. No reply is generated and nothing is appended to the conversation.

The endpoint depends on service_provider:

This is useful for checking a conversation against a model's context window, or for estimating cost, before sending it.

The model property must be set before calling this method, which otherwise fails with error 802. max_output_tokens is not required, because no output is generated.

The following example measures a conversation before paying to send it.

llmclient.ServiceProvider = LLMClientServiceProviders.spGemini; llmclient.Model = "gemini-2.0-flash"; llmclient.AddMessage("user", "What is the capital of France?"); int inputTokens = llmclient.CountTokens();

In the Async Edition (nsoftware.async.IPWorksLLM), the same operation is awaited:

llmclient.ServiceProvider = LLMClientServiceProviders.spGemini; llmclient.Model = "gemini-2.0-flash"; await llmclient.AddMessage("user", "What is the capital of France?"); int inputTokens = await llmclient.CountTokens();

create_embedding method (LLMClient Struct)

Creates an embedding vector for each item of the Embeddings collection.

Syntax

fn create_embedding(&self) -> Result<(), IPWorksLLMError>

Remarks

This method sends the InputText of every item in the embeddings properties to the provider selected by service_provider in a single request, and sets the OutputVector of each item to the embedding vector the provider created for its text, as JSON text containing an array of floating point numbers. The request is sent to:

The model specified by the EmbeddingModel configuration setting is used, or, when that setting is empty, the model specified by model. Most providers publish models dedicated to embeddings, such as text-embedding-3-small with spOpenAI or gemini-embedding-001 with spGemini, so EmbeddingModel lets one model generate replies while another creates embeddings. The EmbeddingDimensions and EmbeddingTaskType configuration settings refine the request.

llmclient.ServiceProvider = LLMClientServiceProviders.spOpenAI; llmclient.APIKey = "sk-..."; llmclient.Config("EmbeddingModel=text-embedding-3-small"); llmclient.Embeddings.Add(new LLMEmbedding("The quick brown fox jumps over the lazy dog.")); llmclient.Embeddings.Add(new LLMEmbedding("A fast auburn fox leaps over a sleepy hound.")); llmclient.CreateEmbedding(); string firstVector = llmclient.Embeddings[0].OutputVector;

In the Async Edition (nsoftware.async.IPWorksLLM), the same operation is awaited:

await llmclient.Config("EmbeddingModel=text-embedding-3-small"); llmclient.Embeddings.Add(new LLMEmbedding("The quick brown fox jumps over the lazy dog.")); llmclient.Embeddings.Add(new LLMEmbedding("A fast auburn fox leaps over a sleepy hound.")); await llmclient.CreateEmbedding(); string firstVector = llmclient.Embeddings[0].OutputVector;

Every provider that uses the OpenAI API is sent the same request as spOpenAI, and every provider that uses the Gemini API the same request as spGemini. Not every such service offers embeddings; a service that does not answers with an error, which this method reports as error 801.

All items are sent in one request; this method never splits them over several requests. The provider limits the size of that request: the OpenAI API, for example, accepts at most 2048 inputs, at most 8192 tokens in any one input, and at most 300,000 tokens across all inputs of a request. A request beyond a limit fails with error 801, which carries the provider's own explanation; spread a large set of texts over several calls in that case.

The OutputVector of every item is cleared before the request is sent, so after an error no item holds a vector. When the reply does not hold exactly one embedding for each item, this method fails with error 803. On success, input_tokens and total_tokens report the tokens the provider counted, or 0 when the reply carries no token count, which not every provider includes; output_tokens is always 0, because creating embeddings generates no output tokens. response_text and finish_reason are cleared, as by every other request, while messages and message_parts are left unchanged.

This method fails with error 802 when embeddings is empty, when an item's InputText is empty, when neither the EmbeddingModel configuration setting nor model is set, or when service_provider is a custom value (97 to 99) and server_url is empty. It fails with error 804 when service_provider uses the Anthropic API, and when the EmbeddingTaskType configuration setting is set while service_provider uses the OpenAI API, which has no such field.

do_events method (LLMClient Struct)

This method processes events from the internal message queue.

Syntax

fn do_events(&self) -> Result<(), IPWorksLLMError>

Remarks

When do_events is called, the struct processes any available events. If no events are available, it waits for a preset period of time, and then returns.

generate method (LLMClient Struct)

Sends the current conversation to the model and appends the reply.

Syntax

fn generate(&self) -> Result<(), IPWorksLLMError>

Remarks

This method sends the conversation in messages and message_parts, together with system_prompt, tools, max_output_tokens, and the request configuration settings, such as Temperature and ToolChoice, to the provider selected by service_provider:

Request properties and configuration settings left at their default values are omitted from the provider request.

On success, the reply is appended to messages as a new message with role assistant, and its parts, such as text, reasoning, and tool calls, are appended to message_parts. response_text then holds the text of the reply, finish_reason reports why the model stopped, and input_tokens, output_tokens, and total_tokens report the token usage the provider counted.

When the model's reply requests one or more tool invocations, the on_tool_call event fires once for each requested call, after the reply has been appended. To continue the conversation, answer each call with add_tool_result and call this method again.

A reply that the provider blocks for safety reasons is not an error: this method returns normally and finish_reason reports frContentFilter. A reply that carries no content at all, such as one for a prompt the provider blocked, appends nothing to messages.

The model property must be set before calling this method; when service_provider is spAnthropic or spCustomAnthropic, max_output_tokens must be set to a positive value; and when service_provider is a custom value (97 to 99), server_url must be set. Otherwise this method fails with error 802.

The following example sends a short conversation and reads the reply.

llmclient.ServiceProvider = LLMClientServiceProviders.spOpenAI; llmclient.APIKey = "sk-..."; llmclient.Model = "gpt-4o"; llmclient.SystemPrompt = "You are a concise assistant."; llmclient.AddMessage("user", "What is the capital of France?"); llmclient.Generate(); string reply = llmclient.ResponseText;

In the Async Edition (nsoftware.async.IPWorksLLM), the same operation is awaited:

llmclient.ServiceProvider = LLMClientServiceProviders.spOpenAI; llmclient.APIKey = "sk-..."; llmclient.Model = "gpt-4o"; llmclient.SystemPrompt = "You are a concise assistant."; await llmclient.AddMessage("user", "What is the capital of France?"); await llmclient.Generate(); string reply = llmclient.ResponseText;

interrupt method (LLMClient Struct)

This method interrupts the current method.

Syntax

fn interrupt(&self) -> Result<(), IPWorksLLMError>

Remarks

If there is no method in progress, interrupt simply returns, doing nothing.

list_models method (LLMClient Struct)

Retrieves the list of models available from the provider.

Syntax

fn list_models(&self) -> Result<(), IPWorksLLMError>

Remarks

This method sends a request to {ServerURL}/models of the provider selected by service_provider. The on_model_list event fires once for each model reported by the server.

The Anthropic and Gemini APIs return the list in pages. If there are still more models to list when this method returns, the model_marker property will be populated; continue to call this method until model_marker is empty to list every page. The OpenAI API returns every model at once, so with spOpenAI a single call lists all models and model_marker stays empty.

This method is typically used to discover which model identifiers are valid for the model property.

The following example prints every model the provider reports.

llmclient.OnModelList += (s, e) => { Console.WriteLine(e.Id + " (" + e.Name + ")"); }; do { llmclient.ListModels(); } while (llmclient.ModelMarker != "");

In the Async Edition (nsoftware.async.IPWorksLLM), the handler returns a task and each request is awaited:

llmclient.OnModelList += async (s, e) => { Console.WriteLine(e.Id + " (" + e.Name + ")"); }; do { await llmclient.ListModels(); } while (llmclient.ModelMarker != "");

reset method (LLMClient Struct)

This method will reset the struct.

Syntax

fn reset(&self) -> Result<(), IPWorksLLMError>

Remarks

This method will reset the struct's properties to their default values.

on_connected event (LLMClient Struct)

Fired immediately after a connection completes (or fails).

Syntax

// LLMClientConnectedEventArgs carries the LLMClient Connected event's parameters.
pub struct LLMClientConnectedEventArgs {
  fn status_code(&self) -> i32
  fn description(&self) -> &String
}

// LLMClientConnectedEvent defines the signature of the LLMClient Connected event's handler function.
pub trait LLMClientConnectedEvent {
  fn on_connected(&self, sender : LLMClient, e : &mut LLMClientConnectedEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_connected(&self) -> &'a dyn LLMClientConnectedEvent;
  pub fn set_on_connected(&mut self, value : &'a dyn LLMClientConnectedEvent);
  ...
}

Remarks

If the connection is made normally, status_code is 0 and description is "OK".

If the connection fails, status_code has the error code returned by the Transmission Control Protocol (TCP)/IP stack. description contains a description of this code. The value of status_code is equal to the value of the error.

Please refer to the Error Codes section for more information.

on_connection_status event (LLMClient Struct)

Fired to indicate changes in the connection state.

Syntax

// LLMClientConnectionStatusEventArgs carries the LLMClient ConnectionStatus event's parameters.
pub struct LLMClientConnectionStatusEventArgs {
  fn connection_event(&self) -> &String
  fn status_code(&self) -> i32
  fn description(&self) -> &String
}

// LLMClientConnectionStatusEvent defines the signature of the LLMClient ConnectionStatus event's handler function.
pub trait LLMClientConnectionStatusEvent {
  fn on_connection_status(&self, sender : LLMClient, e : &mut LLMClientConnectionStatusEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_connection_status(&self) -> &'a dyn LLMClientConnectionStatusEvent;
  pub fn set_on_connection_status(&mut self, value : &'a dyn LLMClientConnectionStatusEvent);
  ...
}

Remarks

This event is fired when the connection state changes: for example, completion of a firewall or proxy connection or completion of a security handshake.

The connection_event parameter indicates the type of connection event. Values may include the following:

on_content_delta event (LLMClient Struct)

Fires once for each incremental fragment of a streamed reply.

Syntax

// LLMClientContentDeltaEventArgs carries the LLMClient ContentDelta event's parameters.
pub struct LLMClientContentDeltaEventArgs {
  fn part_type(&self) -> i32
  fn delta(&self) -> &String
}

// LLMClientContentDeltaEvent defines the signature of the LLMClient ContentDelta event's handler function.
pub trait LLMClientContentDeltaEvent {
  fn on_content_delta(&self, sender : LLMClient, e : &mut LLMClientContentDeltaEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_content_delta(&self) -> &'a dyn LLMClientContentDeltaEvent;
  pub fn set_on_content_delta(&mut self, value : &'a dyn LLMClientContentDeltaEvent);
  ...
}

Remarks

This event fires when stream is set to True and generate is called. It fires once for each incremental fragment of the reply as it is received from the server.

PartType identifies the kind of content the fragment belongs to: 0 (ptText) for the visible text of the reply, or 5 (ptReasoning) for the model's reasoning, when the provider streams it.

Delta holds the fragment itself. Concatenating Delta across every occurrence of this event with the same PartType reconstructs that content; the assembled reply is also appended to messages and message_parts once streaming completes.

Tool calls are not reported through this event. The struct assembles each tool call as it is streamed, and the on_tool_call event fires for each completed call once the reply has been appended.

The following example prints the visible text of the reply as it arrives, ignoring the model's reasoning.

llmclient.Stream = true; llmclient.OnContentDelta += (s, e) => { if (e.PartType == (int)PartTypes.ptText) Console.Write(e.Delta); }; llmclient.AddMessage("user", "Write a short poem about the sea."); llmclient.Generate();

In the Async Edition (nsoftware.async.IPWorksLLM), the handler returns a task and the request is awaited:

llmclient.Stream = true; llmclient.OnContentDelta += async (s, e) => { if (e.PartType == (int)PartTypes.ptText) Console.Write(e.Delta); }; await llmclient.AddMessage("user", "Write a short poem about the sea."); await llmclient.Generate();

on_disconnected event (LLMClient Struct)

Fired when a connection is closed.

Syntax

// LLMClientDisconnectedEventArgs carries the LLMClient Disconnected event's parameters.
pub struct LLMClientDisconnectedEventArgs {
  fn status_code(&self) -> i32
  fn description(&self) -> &String
}

// LLMClientDisconnectedEvent defines the signature of the LLMClient Disconnected event's handler function.
pub trait LLMClientDisconnectedEvent {
  fn on_disconnected(&self, sender : LLMClient, e : &mut LLMClientDisconnectedEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_disconnected(&self) -> &'a dyn LLMClientDisconnectedEvent;
  pub fn set_on_disconnected(&mut self, value : &'a dyn LLMClientDisconnectedEvent);
  ...
}

Remarks

If the connection is broken normally, status_code is 0 and description is "OK".

If the connection is broken for any other reason, status_code has the error code returned by the Transmission Control Protocol (TCP/IP) subsystem. description contains a description of this code. The value of status_code is equal to the value of the TCP/IP error.

Please refer to the Error Codes section for more information.

on_end_transfer event (LLMClient Struct)

Fired when a document finishes transferring.

Syntax

// LLMClientEndTransferEventArgs carries the LLMClient EndTransfer event's parameters.
pub struct LLMClientEndTransferEventArgs {
  fn direction(&self) -> i32
}

// LLMClientEndTransferEvent defines the signature of the LLMClient EndTransfer event's handler function.
pub trait LLMClientEndTransferEvent {
  fn on_end_transfer(&self, sender : LLMClient, e : &mut LLMClientEndTransferEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_end_transfer(&self) -> &'a dyn LLMClientEndTransferEvent;
  pub fn set_on_end_transfer(&mut self, value : &'a dyn LLMClientEndTransferEvent);
  ...
}

Remarks

This event is fired first when the client finishes sending data to the server (in a POST or PUT request) and then when the document text finishes transferring from the server to the local host.

The Direction parameter shows whether the client (0) or the server (1) is sending the data.

on_error event (LLMClient Struct)

Fired when information is available about errors during data delivery.

Syntax

// LLMClientErrorEventArgs carries the LLMClient Error event's parameters.
pub struct LLMClientErrorEventArgs {
  fn error_code(&self) -> i32
  fn description(&self) -> &String
}

// LLMClientErrorEvent defines the signature of the LLMClient Error event's handler function.
pub trait LLMClientErrorEvent {
  fn on_error(&self, sender : LLMClient, e : &mut LLMClientErrorEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_error(&self) -> &'a dyn LLMClientErrorEvent;
  pub fn set_on_error(&mut self, value : &'a dyn LLMClientErrorEvent);
  ...
}

Remarks

The on_error event is fired in case of exceptional conditions during message processing. Normally the struct fails with an error.

The error_code parameter contains an error code, and the description parameter contains a textual description of the error. For a list of valid error codes and their descriptions, please refer to the Error Codes section.

on_header event (LLMClient Struct)

Fired every time a header line comes in.

Syntax

// LLMClientHeaderEventArgs carries the LLMClient Header event's parameters.
pub struct LLMClientHeaderEventArgs {
  fn field(&self) -> &String
  fn value(&self) -> &String
}

// LLMClientHeaderEvent defines the signature of the LLMClient Header event's handler function.
pub trait LLMClientHeaderEvent {
  fn on_header(&self, sender : LLMClient, e : &mut LLMClientHeaderEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_header(&self) -> &'a dyn LLMClientHeaderEvent;
  pub fn set_on_header(&mut self, value : &'a dyn LLMClientHeaderEvent);
  ...
}

Remarks

The field parameter contains the name of the HTTP header (which is the same as it is delivered). The value parameter contains the header contents.

If the header line being retrieved is a continuation header line, then the field parameter contains "" (empty string).

on_log event (LLMClient Struct)

Fired once for each log message.

Syntax

// LLMClientLogEventArgs carries the LLMClient Log event's parameters.
pub struct LLMClientLogEventArgs {
  fn log_level(&self) -> i32
  fn message(&self) -> &String
  fn log_type(&self) -> &String
}

// LLMClientLogEvent defines the signature of the LLMClient Log event's handler function.
pub trait LLMClientLogEvent {
  fn on_log(&self, sender : LLMClient, e : &mut LLMClientLogEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_log(&self) -> &'a dyn LLMClientLogEvent;
  pub fn set_on_log(&mut self, value : &'a dyn LLMClientLogEvent);
  ...
}

Remarks

This event is fired once for each log message generated by the struct. The verbosity is controlled by the LogLevel setting.

log_level indicates the level of message. Possible values are as follows:

The value 1 (Info) logs basic information, including the URL, HTTP version, and status details.

The value 2 (Verbose) logs additional information about the request and response.

The value 3 (Debug) logs the headers and body for both the request and response, as well as additional debug information (if any).

message is the log entry.

log_type identifies the type of log entry. Possible values are as follows:

• "Info"
• "RequestHeaders"
• "ResponseHeaders"
• "RequestBody"
• "ResponseBody"
• "ProxyRequest"
• "ProxyResponse"
• "FirewallRequest"
• "FirewallResponse"

on_model_list event (LLMClient Struct)

Fires once for each model reported by the server.

Syntax

// LLMClientModelListEventArgs carries the LLMClient ModelList event's parameters.
pub struct LLMClientModelListEventArgs {
  fn id(&self) -> &String
  fn name(&self) -> &String
  fn description(&self) -> &String
}

// LLMClientModelListEvent defines the signature of the LLMClient ModelList event's handler function.
pub trait LLMClientModelListEvent {
  fn on_model_list(&self, sender : LLMClient, e : &mut LLMClientModelListEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_model_list(&self) -> &'a dyn LLMClientModelListEvent;
  pub fn set_on_model_list(&mut self, value : &'a dyn LLMClientModelListEvent);
  ...
}

Remarks

This event fires once for each model returned in response to a call to list_models.

Id holds the model's identifier, as would be supplied to model. Name holds a human readable name for the model, and Description holds a description of the model. The providers report them as follows:

on_redirect event (LLMClient Struct)

Fired when a redirection is received from the server.

Syntax

// LLMClientRedirectEventArgs carries the LLMClient Redirect event's parameters.
pub struct LLMClientRedirectEventArgs {
  fn location(&self) -> &String
  fn accept(&self) -> bool
  fn set_accept(&self, value : bool)
}

// LLMClientRedirectEvent defines the signature of the LLMClient Redirect event's handler function.
pub trait LLMClientRedirectEvent {
  fn on_redirect(&self, sender : LLMClient, e : &mut LLMClientRedirectEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_redirect(&self) -> &'a dyn LLMClientRedirectEvent;
  pub fn set_on_redirect(&mut self, value : &'a dyn LLMClientRedirectEvent);
  ...
}

Remarks

This event is fired in cases in which the client can decide whether or not to continue with the redirection process. The accept parameter is always True by default, but if you do not want to follow the redirection, accept may be set to False, in which case the struct fails with an error. location is the location to which the client is being redirected. Further control over redirection is provided in the follow_redirects property.

on_set_cookie event (LLMClient Struct)

Fired for every cookie set by the server.

Syntax

// LLMClientSetCookieEventArgs carries the LLMClient SetCookie event's parameters.
pub struct LLMClientSetCookieEventArgs {
  fn name(&self) -> &String
  fn value(&self) -> &String
  fn expires(&self) -> &String
  fn domain(&self) -> &String
  fn path(&self) -> &String
  fn secure(&self) -> bool
}

// LLMClientSetCookieEvent defines the signature of the LLMClient SetCookie event's handler function.
pub trait LLMClientSetCookieEvent {
  fn on_set_cookie(&self, sender : LLMClient, e : &mut LLMClientSetCookieEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_set_cookie(&self) -> &'a dyn LLMClientSetCookieEvent;
  pub fn set_on_set_cookie(&mut self, value : &'a dyn LLMClientSetCookieEvent);
  ...
}

Remarks

This event is fired for every Set-Cookie: header received from the HTTP server.

The name parameter contains the name of the cookie, with the corresponding value supplied in the value parameter.

The expires parameter contains an expiration time for the cookie (if provided by the server). The time format used is "Weekday, DD-Mon-YY HH:MM:SS GMT". If the server does not provide an expiration time, the expires parameter will be an empty string. In this case, the convention is to drop the cookie at the end of the session.

The domain parameter contains a domain name to limit the cookie to (if provided by the server). If the server does not provide a domain name, the domain parameter will be an empty string. The convention in this case is to use the server specified in the URL (url_server) as the cookie domain.

The path parameter contains a path name to limit the cookie to (if provided by the server). If the server does not provide a cookie path, the path parameter will be an empty string. The convention in this case is to use the path specified in the URL (url_path) as the cookie path.

The secure parameter specifies whether the cookie is secure. If the value of this parameter is True, the cookie value must be submitted only through a secure (HTTPS) connection.

on_ssl_server_authentication event (LLMClient Struct)

Fired after the server presents its certificate to the client.

Syntax

// LLMClientSSLServerAuthenticationEventArgs carries the LLMClient SSLServerAuthentication event's parameters.
pub struct LLMClientSSLServerAuthenticationEventArgs {
  fn cert_encoded(&self) -> &[u8]
  fn cert_subject(&self) -> &String
  fn cert_issuer(&self) -> &String
  fn status(&self) -> &String
  fn accept(&self) -> bool
  fn set_accept(&self, value : bool)
}

// LLMClientSSLServerAuthenticationEvent defines the signature of the LLMClient SSLServerAuthentication event's handler function.
pub trait LLMClientSSLServerAuthenticationEvent {
  fn on_ssl_server_authentication(&self, sender : LLMClient, e : &mut LLMClientSSLServerAuthenticationEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_ssl_server_authentication(&self) -> &'a dyn LLMClientSSLServerAuthenticationEvent;
  pub fn set_on_ssl_server_authentication(&mut self, value : &'a dyn LLMClientSSLServerAuthenticationEvent);
  ...
}

Remarks

During this event, the client can decide whether or not to continue with the connection process. The accept parameter is a recommendation on whether to continue or close the connection. This is just a suggestion: application software must use its own logic to determine whether or not to continue.

When accept is False, status shows why the verification failed (otherwise, status contains the string OK). If it is decided to continue, you can override and accept the certificate by setting the accept parameter to True.

on_ssl_status event (LLMClient Struct)

Fired when secure connection progress messages are available.

Syntax

// LLMClientSSLStatusEventArgs carries the LLMClient SSLStatus event's parameters.
pub struct LLMClientSSLStatusEventArgs {
  fn message(&self) -> &String
}

// LLMClientSSLStatusEvent defines the signature of the LLMClient SSLStatus event's handler function.
pub trait LLMClientSSLStatusEvent {
  fn on_ssl_status(&self, sender : LLMClient, e : &mut LLMClientSSLStatusEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_ssl_status(&self) -> &'a dyn LLMClientSSLStatusEvent;
  pub fn set_on_ssl_status(&mut self, value : &'a dyn LLMClientSSLStatusEvent);
  ...
}

Remarks

The event is fired for informational and logging purposes only. This event tracks the progress of the connection.

on_start_transfer event (LLMClient Struct)

Fired when a document starts transferring (after the headers).

Syntax

// LLMClientStartTransferEventArgs carries the LLMClient StartTransfer event's parameters.
pub struct LLMClientStartTransferEventArgs {
  fn direction(&self) -> i32
}

// LLMClientStartTransferEvent defines the signature of the LLMClient StartTransfer event's handler function.
pub trait LLMClientStartTransferEvent {
  fn on_start_transfer(&self, sender : LLMClient, e : &mut LLMClientStartTransferEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_start_transfer(&self) -> &'a dyn LLMClientStartTransferEvent;
  pub fn set_on_start_transfer(&mut self, value : &'a dyn LLMClientStartTransferEvent);
  ...
}

Remarks

This event is fired first when the client starts sending data to the server (in a POST or PUT request) and then when the document text starts transferring from the server to the local host.

The Direction parameter shows whether the client (0) or the server (1) is sending the data.

on_status event (LLMClient Struct)

Fired when the HTTP status line is received from the server.

Syntax

// LLMClientStatusEventArgs carries the LLMClient Status event's parameters.
pub struct LLMClientStatusEventArgs {
  fn http_version(&self) -> &String
  fn status_code(&self) -> i32
  fn description(&self) -> &String
}

// LLMClientStatusEvent defines the signature of the LLMClient Status event's handler function.
pub trait LLMClientStatusEvent {
  fn on_status(&self, sender : LLMClient, e : &mut LLMClientStatusEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_status(&self) -> &'a dyn LLMClientStatusEvent;
  pub fn set_on_status(&mut self, value : &'a dyn LLMClientStatusEvent);
  ...
}

Remarks

http_version is a string containing the HTTP version string as returned from the server (e.g., "1.1").

status_code contains the HTTP status code (e.g., 200), and description the associated message returned by the server (e.g., "OK").

on_tool_call event (LLMClient Struct)

Fires once for each tool call requested by the model.

Syntax

// LLMClientToolCallEventArgs carries the LLMClient ToolCall event's parameters.
pub struct LLMClientToolCallEventArgs {
  fn id(&self) -> &String
  fn name(&self) -> &String
  fn arguments_json(&self) -> &String
}

// LLMClientToolCallEvent defines the signature of the LLMClient ToolCall event's handler function.
pub trait LLMClientToolCallEvent {
  fn on_tool_call(&self, sender : LLMClient, e : &mut LLMClientToolCallEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_tool_call(&self) -> &'a dyn LLMClientToolCallEvent;
  pub fn set_on_tool_call(&mut self, value : &'a dyn LLMClientToolCallEvent);
  ...
}

Remarks

This event fires when the model's reply requests one or more tool invocations, once for each call. It fires for both streamed and non-streamed replies, after the reply, including one tool call part for each call, has been appended to messages and message_parts.

Id is the identifier of the call. It is assigned by the provider; when the Gemini API does not assign one, the struct generates an identifier of the form llm_call_ followed by a number. Name is the name of the tool, and ArgumentsJson holds the JSON arguments object the model produced for the call.

To continue the conversation, pass Id and the tool's result to add_tool_result, then call generate again once every call has been answered.

The following example answers the call and lets the model produce a final reply.

llmclient.OnToolCall += (s, e) => { llmclient.AddToolResult(e.Id, GetWeather(e.ArgumentsJson), false); }; llmclient.AddMessage("user", "What is the weather like in Boston?"); llmclient.Generate(); // The tool results were added above, so call Generate again for the final answer. while (llmclient.FinishReason == LLMClientFinishReasons.frToolCalls) llmclient.Generate(); Console.WriteLine(llmclient.ResponseText);

In the Async Edition (nsoftware.async.IPWorksLLM), the handler returns a task and each request is awaited:

llmclient.OnToolCall += async (s, e) => { await llmclient.AddToolResult(e.Id, GetWeather(e.ArgumentsJson), false); }; await llmclient.AddMessage("user", "What is the weather like in Boston?"); await llmclient.Generate(); while (llmclient.FinishReason == LLMClientFinishReasons.frToolCalls) await llmclient.Generate(); Console.WriteLine(llmclient.ResponseText);

on_transfer event (LLMClient Struct)

Fired while a document transfers (delivers document).

Syntax

// LLMClientTransferEventArgs carries the LLMClient Transfer event's parameters.
pub struct LLMClientTransferEventArgs {
  fn direction(&self) -> i32
  fn bytes_transferred(&self) -> i64
  fn percent_done(&self) -> i32
  fn text(&self) -> &[u8]
}

// LLMClientTransferEvent defines the signature of the LLMClient Transfer event's handler function.
pub trait LLMClientTransferEvent {
  fn on_transfer(&self, sender : LLMClient, e : &mut LLMClientTransferEventArgs);
}

impl <'a> LLMClient<'a> {
  pub fn on_transfer(&self) -> &'a dyn LLMClientTransferEvent;
  pub fn set_on_transfer(&mut self, value : &'a dyn LLMClientTransferEvent);
  ...
}

Remarks

The text parameter contains the portion of the document text being received. It is empty if data are being posted to the server.

The bytes_transferred parameter contains the number of bytes transferred in this direction since the beginning of the document text (excluding HTTP response headers).

The Direction parameter shows whether the client (0) or the server (1) is sending the data.

The PercentDone parameter shows the progress of the transfer in the corresponding direction. If PercentDone can not be calculated the value will be -1.

NOTE: Events are not re-entrant. Performing time-consuming operations within this event will prevent it from firing again in a timely manner and may affect overall performance.

Config Settings (LLMClient Struct)

LLMClient Config Settings

HTTP Config Settings

TCPClient Config Settings

SSL Config Settings

-----BEGIN CERTIFICATE-----
MIIEKzCCAxOgAwIBAgIRANTET4LIkxdH6P+CFIiHvTowDQYJKoZIhvcNAQELBQAw
... Intermediate Cert ...
eWHV5OW1K53o/atv59sOiW5K3crjFhsBOd5Q+cJJnU+SWinPKtANXMht+EDvYY2w
F0I1XhM+pKj7FjDr+XNj
-----END CERTIFICATE-----
\r \n
-----BEGIN CERTIFICATE-----
MIIEFjCCAv6gAwIBAgIQetu1SMxpnENAnnOz1P+PtTANBgkqhkiG9w0BAQUFADBp
... Root Cert ...
d8q23djXZbVYiIfE9ebr4g3152BlVCHZ2GyPdjhIuLeH21VbT/dyEHHA
-----END CERTIFICATE-----

-----BEGIN CERTIFICATE-----
MIIEKzCCAxOgAwIBAgIRANTET4LIkxdH6P+CFIiHvTowDQYJKoZIhvcNAQELBQAw
... Intermediate Cert ...
eWHV5OW1K53o/atv59sOiW5K3crjFhsBOd5Q+cJJnU+SWinPKtANXMht+EDvYY2w
F0I1XhM+pKj7FjDr+XNj
-----END CERTIFICATE-----
\r \n
-----BEGIN CERTIFICATE-----
MIIEFjCCAv6gAwIBAgIQetu1SMxpnENAnnOz1P+PtTANBgkqhkiG9w0BAQUFADBp
... Root Cert ...
d8q23djXZbVYiIfE9ebr4g3152BlVCHZ2GyPdjhIuLeH21VbT/dyEHHA
-----END CERTIFICATE-----

-----BEGIN CERTIFICATE-----
MIIEKzCCAxOgAwIBAgIRANTET4LIkxdH6P+CFIiHvTowDQYJKoZIhvcNAQELBQAw
... Intermediate Cert...
eWHV5OW1K53o/atv59sOiW5K3crjFhsBOd5Q+cJJnU+SWinPKtANXMht+EDvYY2w
F0I1XhM+pKj7FjDr+XNj
-----END CERTIFICATE-----
\r \n
-----BEGIN CERTIFICATE-----
MIIEFjCCAv6gAwIBAgIQetu1SMxpnENAnnOz1P+PtTANBgkqhkiG9w0BAQUFADBp
... Root Cert...
d8q23djXZbVYiIfE9ebr4g3152BlVCHZ2GyPdjhIuLeH21VbT/dyEHHA
-----END CERTIFICATE-----

Socket Config Settings

Base Config Settings