OpenAICompatibleDialect

Adds provider-specific reasoning fields to a request body, given the configured model and the caller's options. Standard: adds nothing, so CompletionOptions.reasoning is ignored.

Whether an assistant message with no text still carries a content field ("" for empty text, null for none). Standard: false - the field is omitted, which is what most providers expect alongside tool_calls.

Reads the text of a reply's content value - on a completion's message or a stream's delta. Standard: a JSON string, anything else is no text.

The thinking blocks for one reply's replay data: the items thinkingDetails read from its message, or from each of its stream's deltas concatenated in order - so a dialect whose provider streams an item in fragments joins them here. They follow the reply's thinking text on the returned message, and the client binds them to the request it answered (see ThinkingReplay), so they should be sealed - normally org.llm4s.llmconnect.model.ThinkingBlock.Opaque. Standard: none.

Encodes the text of a user, system, assistant or tool message. Standard: a JSON string.

The response_format sent for CompletionOptions.responseFormat, or None to send none. Standard: OpenAI's shapes - {"type": "json_object"}, and {"type": "json_schema", "json_schema": {"name", "strict", "schema"}} for a schema.

Adds an assistant turn's thinking - its org.llm4s.llmconnect.model.AssistantMessage.thinking blocks, as they may be replayed - to that turn's encoded message, after its content and tool_calls are set. Called only when the turn has thinking. The blocks' text is ThinkingBlock.text(thinking).

By the time this is called the client has unsealed any turn whose sealed thinking no longer matches the conversation before it (see ThinkingReplay), so sealed blocks here - such as the org.llm4s.llmconnect.model.ThinkingBlock.Opaque blocks decodeThinkingDetails produced - can be sent back as they are. A dialect sends only the blocks that are its own and ignores the rest, which may have come from another provider.

Standard: adds nothing, so the thinking is dropped. The OpenAI format has no field for it, and an unknown field can fail a request. A provider that documents a field for a model's earlier reasoning overrides this: DeepSeek and Z.ai (reasoning_content, which both require back across a tool-calling turn), OpenRouter (reasoning, and its reasoning_details unchanged) and Mistral (a thinking chunk in content).

The id sent for a tool call - on an assistant turn's tool_calls and on the tool message answering it. Standard: the id as the model produced it.

A provider that accepts only its own id format overrides this. It must map the same id to the same result every time, since the call and its answer are encoded separately and must still match; ids that came from another provider in the same conversation go through it too.

The content parts of a user message that has an image or a document, each as one element of the message's content array; a part it does not cover fails the request with an org.llm4s.error.UnsupportedContentPartError before it is sent. A user message of text only is sent as encodeContent of its text, and a tool result takes text only. Standard: OpenAICompatibleDialect.standardUserParts - text, and an image by URL or inline (image_url, inline as a data: URL).

Headers sent on every request, after Content-Type and - when the provider has an API key - Authorization: Bearer <key>.

Parses the tool_calls array of a non-streaming reply.

Standard: OpenAICompatibleDialect.lenientToolCalls, which fills in missing fields and turns unparseable arguments into {}. Streamed tool calls do not come here: their argument fragments are passed on verbatim and reassembled by the stream's accumulator.

Reads the reasoning-token count from a usage object. Standard: none.

Whether an assistant turn with neither text nor tool calls is sent at all. Standard: true - it goes out as {"role": "assistant"} (with content if alwaysSendAssistantContent). A provider that rejects a message carrying neither content nor tool_calls, as Mistral does, answers false and the turn is left out. A turn with thinking that encodeThinking encodes is not empty, and is sent either way.

Whether a streaming request asks for token usage with "stream_options": {"include_usage": true}. Standard: true.

OpenAI streams usage only when asked this way, and servers that follow it - vLLM, Ollama's /v1, Perplexity Router - stream none otherwise. A provider that rejects the field (Mistral answers an unknown field with a 422), does not document it, or always reports usage without it answers false. Usage is read from whichever event carries it either way, including a final event with empty choices.

The role a org.llm4s.llmconnect.model.SystemMessage is sent under. Standard: "system". Cohere's Compatibility API documents system instructions under "developer".

Reads the model's thinking from a JSON object: a completion's message (then, if that has none, its enclosing choice), or a stream's delta. Standard: none.

The provider-specific replay data on a JSON object - a completion's message or a stream's delta - as raw items, for decodeThinkingDetails. Standard: none.

For a provider that returns more than reasoning text and needs it back unchanged, as OpenRouter does with reasoning_details.