@orkestrel/ollama 0.0.14 → 0.0.15

package/dist/src/server/index.d.ts

@@ -1,17 +1,17 @@
-import { ContextFormat } from '@orkestrel/agent';
-import { Message } from '@orkestrel/agent';
-import { ProviderDelta } from '@orkestrel/agent';
-import { ProviderInterface } from '@orkestrel/agent';
-import { ProviderResult } from '@orkestrel/agent';
-import { ProviderStreamOptions } from '@orkestrel/agent';
-import { ThinkSplitterInterface } from '@orkestrel/agent';
-import { TimeoutInterface } from '@orkestrel/timeout';
-import { TokenUsage } from '@orkestrel/budget';
-import { ToolCall } from '@orkestrel/tool';
-import { ToolDefinition } from '@orkestrel/tool';
+import type { ContextFormat } from '@orkestrel/agent';
+import type { Message } from '@orkestrel/agent';
+import type { ProviderDelta } from '@orkestrel/agent';
+import type { ProviderInterface } from '@orkestrel/agent';
+import type { ProviderResult } from '@orkestrel/agent';
+import type { ProviderStreamOptions } from '@orkestrel/agent';
+import type { ThinkSplitterInterface } from '@orkestrel/agent';
+import type { TimeoutInterface } from '@orkestrel/timeout';
+import type { TokenUsage } from '@orkestrel/budget';
+import type { ToolCall } from '@orkestrel/tool';
+import type { ToolDefinition } from '@orkestrel/tool';
 
 /**
- * Builds a provider result from a turn's content, reasoning, tool calls, and usage.
+ * Builds a `ProviderResult` from a turn's content, reasoning, tool calls, and usage.
  *
  * @remarks
  * Only the present optionals are set: no empty `thinking`, no empty `tools`, and no
@@ -38,36 +38,43 @@ export declare function buildResult(content: string, thinking: string, tools: re
  * @remarks
  * Only `model` is required; `url` defaults to the local daemon, `keepAlive` to `'5m'`,
  * `timeout` to `120_000`ms, and `options` is forwarded verbatim as sampling
- * parameters (`temperature`, `seed`, and `num_predict`). Both calls take an
+ * parameters (`temperature`, `seed`, and `num_predict`). Each call takes an
  * `AbortSignal` to bound the request; a `stream` cancelled mid-flight throws a
  * `ProviderAbortError` carrying the partial result.
  *
  * The optional `fetch` + `headers` form a transport seam (see {@link OllamaOptions}):
  * point `url` at your own server, inject a custom `fetch`, and have `headers` attach a
  * generated/obfuscated bearer token your server validates — so a browser runtime
- * reaches the LLM through your middleware WITHOUT this library ever handling the real API
+ * reaches the LLM through your middleware without this library ever handling the real API
  * key. Both omitted ⇒ the global `fetch` and only a JSON content type.
  *
- * The optional `format` is the provider's context-framing default — the PROVIDER-DEFAULT
+ * The optional `format` is the provider's context-framing default — the provider-default
  * level of `AgentContext`'s format cascade (beaten by a manager-options or per-item
  * override, beating the managers' built-in framing), declaring how this
  * provider's models prefer context sections framed (for example XML group wrappers vs. Markdown
- * headers). It is EXPOSED on the provider for the Agent's `build()` and is NOT Ollama's
- * `/api/chat` `format` wire parameter (structured output) — the two are unrelated despite
- * the shared word. Omitted ⇒ the provider is framing-agnostic (core's built-in defaults).
+ * headers). It is exposed on the provider for the Agent's `build()` and is not Ollama's
+ * `/api/chat` `format` wire parameter (structured output) — the framing default and that
+ * wire parameter are unrelated despite the shared word. Omitted ⇒ the provider is
+ * framing-agnostic (core's built-in defaults).
  *
  * @param options - `model` (required), and optional `url` / `keepAlive` / `timeout` /
  *   `options` / `fetch` / `headers` / `format` (see {@link OllamaOptions})
  * @returns A working {@link ProviderInterface} backed by Ollama
  *
- * @example
+ * @example createOllama + generate
  * ```ts
  * import { createAbort } from '@orkestrel/abort'
  * import { createOllama } from '@orkestrel/ollama'
  *
- * const provider = createOllama({ model: 'qwen3.5:2b-q4_K_M' })
+ * const provider = createOllama({ model: 'qwen3.5:2b-q4_K_M', options: { temperature: 0 } })
  * const abort = createAbort()
+ * const messages = [
+ * 	{ id: '1', role: 'user', content: 'Summarize the release notes for version 2.0.' },
+ * ] as const
+ *
  * const result = await provider.generate(messages, abort.signal)
+ * console.log(result.content)
+ * if (result.usage) charge(result.usage) // fold into a token budget
  * ```
  *
  * @example
@@ -83,7 +90,7 @@ export declare function buildResult(content: string, thinking: string, tools: re
  *
  * @example
  * Declare a context-framing default — wrap the instructions section in an XML group (the
- * provider-default level of `AgentContext`'s cascade; NOT the wire `format`):
+ * provider-default level of `AgentContext`'s cascade; not the wire `format`):
  * ```ts
  * const provider = createOllama({
  *   model: 'qwen3.5:2b-q4_K_M',
@@ -100,8 +107,9 @@ export declare function buildResult(content: string, thinking: string, tools: re
 export declare function createOllama(options: OllamaOptions): ProviderInterface;
 
 /**
- * Names how long the model stays resident after a call when `OllamaOptions.keepAlive` is
- * omitted — Ollama's own `keep_alive` default, expressed as a duration string.
+ * Names how long the model stays resident after a call — `'5m'` when
+ * `OllamaOptions.keepAlive` is omitted, Ollama's own `keep_alive` default, expressed as a
+ * duration string.
  *
  * @remarks
  * The name mirrors the Ollama `/api/chat` `keep_alive` field this value is sent as, so
@@ -109,12 +117,15 @@ export declare function createOllama(options: OllamaOptions): ProviderInterface;
  */
 export declare const DEFAULT_KEEP_ALIVE = "5m";
 
-/** Names the local Ollama daemon base URL assumed when `OllamaOptions.url` is omitted. */
+/**
+ * Names the local Ollama daemon base URL, `'http://localhost:11434'`, assumed when
+ * `OllamaOptions.url` is omitted.
+ */
 export declare const DEFAULT_OLLAMA_URL = "http://localhost:11434";
 
 /**
- * Names the per-call deadline in milliseconds when `OllamaOptions.timeout` is omitted —
- * generous enough that a cold model load does not trip it.
+ * Names the per-call deadline in milliseconds, `120_000`, when `OllamaOptions.timeout` is
+ * omitted — generous enough that a cold model load does not trip it.
  */
 export declare const DEFAULT_PROVIDER_TIMEOUT = 120000;
 
@@ -205,17 +216,22 @@ export declare function extractUsage(record: Readonly<Record<string, unknown>>):
 /**
  * Checks whether a value is an {@link OllamaHTTPError}.
  *
+ * @remarks
+ * The check is an `instanceof` test, so it narrows a caught `unknown` to the error class
+ * without parsing the thrown message.
+ *
  * @param value - The value to test
  * @returns True if `value` is an `OllamaHTTPError`; false otherwise
  */
 export declare function isOllamaHTTPError(value: unknown): value is OllamaHTTPError;
 
 /**
- * Joins a call's two reasoning carriers into the result's `thinking`.
+ * Joins a call's reasoning carriers — the splitter's separated in-content spans and the
+ * accumulated wire-side `message.thinking` — into the result's `thinking`.
  *
  * @param splitter - The per-call splitter holding the separated in-content spans
  * @param wired - The accumulated wire-side `message.thinking` text
- * @returns The two carriers separated by a blank line, or whichever one is non-empty
+ * @returns The carriers separated by a blank line, or whichever one is non-empty
  *
  * @example
  * ```ts
@@ -243,15 +259,14 @@ export declare function joinThinking(splitter: ThinkSplitterInterface, wired: st
 export declare function mapMessages(messages: readonly Message[]): WireChatRequest['messages'];
 
 /**
- * Names the cap, in characters, on how much of a non-OK response body is
+ * Names the character cap, `2048`, on how much of a non-OK response body is
  * incorporated into a thrown {@link OllamaHTTPError}'s message.
  *
  * @remarks
  * Bounds the excerpt so a defensive proxy or a misbehaving daemon handing
  * back an unbounded response body cannot inflate the thrown error's message
- * without limit. `2048` characters is generous enough to carry a
- * useful diagnostic snippet while staying well short of any practical size
- * concern.
+ * without limit, while the cap stays generous enough to carry a useful
+ * diagnostic snippet.
  */
 export declare const MAX_ERROR_BODY_LENGTH = 2048;
 
@@ -263,7 +278,8 @@ export declare const MAX_ERROR_BODY_LENGTH = 2048;
  * HTTP response was received at all, for example a `null` body). Thrown by
  * {@link OllamaProvider} at its HTTP failure sites — the non-OK status branch and the
  * null-body branch — so a caller can branch on `error.code` and read `error.status`
- * for the HTTP number instead of parsing the message. Narrow a caught value with
+ * for the HTTP number instead of parsing the message. The message carries a body excerpt
+ * bounded to {@link MAX_ERROR_BODY_LENGTH} — `2048` characters. Narrow a caught value with
  * {@link isOllamaHTTPError}.
  *
  * @example
@@ -311,8 +327,8 @@ export declare interface OllamaHTTPErrorOptions {
  *
  * The optional `fetch` + `headers` form a **transport seam**: by default the provider
  * talks straight to a local daemon over `globalThis.fetch` with only a JSON content
- * type, but a browser-side runtime can inject a custom transport AND a dynamic header
- * (for example an obfuscated bearer token) so requests route through the developer's OWN
+ * type, but a browser-side runtime can inject both a custom transport and a dynamic header
+ * (for example an obfuscated bearer token) so requests route through the developer's own
  * server, which validates that header and forwards to the real LLM. Your app never
  * holds a real API key — the real key lives only on the developer's server; the
  * `headers` hook supplies whatever short-lived/obfuscated token that server expects.
@@ -337,12 +353,12 @@ export declare interface OllamaOptions {
     readonly options?: Readonly<Record<string, unknown>>;
     /**
      * Sets the `/api/chat` `think` wire flag; defaults to `false`. When `true`, a thinking-capable
-     * model (for example `qwen3`) separates its reasoning NATIVELY at the wire — the daemon returns it
+     * model (for example `qwen3`) separates its reasoning natively at the wire — the daemon returns it
      * on the distinct `message.thinking` channel (surfaced on `ProviderResult.thinking`) rather
      * than inline in `message.content`. The default is `false`, so a non-thinking model needs no
      * configuration and answers immediately; the per-call ThinkSplitter
      * remains the defensive fallback for daemons/models that still inline `<think>` tags either
-     * way. Set it `true` for a thinking model whose reasoning you intend to DISPLAY separately.
+     * way. Set it `true` for a thinking model whose reasoning you intend to display separately.
      */
     readonly think?: boolean;
     /**
@@ -357,18 +373,18 @@ export declare interface OllamaOptions {
      * headers are merged into the request on top of the base `Content-Type`. Use it to
      * attach an authorization header — for example an obfuscated/generated bearer token the
      * developer's server validates before relaying to the real LLM — so a browser
-     * runtime can authenticate WITHOUT your app ever handling a real API key. Async so a
+     * runtime can authenticate without your app ever handling a real API key. Async so a
      * token can be refreshed/fetched per call. A returned `Content-Type` overrides the
      * default; other headers add to it. Omitted ⇒ only `Content-Type: application/json`.
      */
     readonly headers?: () => Readonly<Record<string, string>> | Promise<Readonly<Record<string, string>>>;
     /**
-     * Sets the provider's OPTIONAL context-framing default — the PROVIDER-DEFAULT level of
+     * Sets the provider's optional context-framing default — the provider-default level of
      * `AgentContext`'s format cascade (beaten by a manager-options or per-item override,
      * beating the managers' built-in framing). Declares how this provider's models prefer
      * context sections framed (for example XML group wrappers vs. Markdown headers). Omitted ⇒
-     * the provider is framing-agnostic and core's built-in defaults apply unchanged. NOTE:
-     * this is the prompt-CONTEXT framing consumed by `AgentContext.build()` — it is NOT
+     * the provider is framing-agnostic and core's built-in defaults apply unchanged. This
+     * is the prompt-context framing consumed by `AgentContext.build()` — it is not
      * Ollama's `/api/chat` `format` wire parameter (structured-output / JSON schema),
      * which this provider sends only when a call supplies a `schema`; the two are unrelated
      * despite the shared word.
@@ -383,16 +399,16 @@ export declare interface OllamaOptions {
  * @remarks
  * - **Wire protocol.** Posts `{ model, messages, stream, keep_alive, think }` plus
  *   passthrough sampling `options` and mapped function `tools`. The `think` flag is
- *   CONFIGURABLE through {@link OllamaOptions.think} (default `false`). Non-stream parses
+ *   configurable through {@link OllamaOptions.think} (default `false`). Non-stream parses
  *   one JSON body; stream consumes NDJSON (one JSON object per `\n`-terminated line) —
  *   deltas carry `message.content`, the final `done: true` line carries the token usage.
  * - **Think separation.** The wire `think` flag is configurable
  *   ({@link OllamaOptions.think}, default `false`). With `think: true` a thinking model's
- *   daemon separates reasoning NATIVELY — returning it on the distinct `message.thinking`
- *   channel (read here through `extractThinking`) instead of inline in `message.content`. EITHER
+ *   daemon separates reasoning natively — returning it on the distinct `message.thinking`
+ *   channel (read here through `extractThinking`) instead of inline in `message.content`. Either
  *   way the per-call {@link ThinkSplitterInterface} is the defensive guarantee: a daemon
  *   may ignore `think: false` for a thinking model and inline `<think>` tags, so every
- *   content delta routes through the splitter, only CLEAN content is yielded / assembled,
+ *   content delta routes through the splitter, only clean content is yielded / assembled,
  *   and the separated reasoning (plus any daemon-side `message.thinking` deltas) lands on
  *   `ProviderResult.thinking`, never in the conversation.
  * - **Boundary narrowing.** Every wire value arrives as `unknown` and is
@@ -401,11 +417,11 @@ export declare interface OllamaOptions {
  *   usage, `{}` arguments), never a throw.
  * - **Bounded.** Each call arms a {@link Timeout} for `OllamaOptions.timeout` and
  *   passes `AbortSignal.any([timeout.signal, signal])` to `fetch`, so the caller's
- *   signal AND the deadline both cancel the request. The timeout is always cleared —
+ *   signal and the deadline both cancel the request. The timeout is always cleared —
  *   in `#fetch` if the request fails/aborts, otherwise in the consuming call's `finally`.
  * - **Abort recovers partial.** A `stream` cancelled mid-flight throws a
  *   `ProviderAbortError` carrying the partial result assembled so far; pairing the
- *   `TextDecoder({ stream: true })` with the {@link NDJSONParser} parser keeps multi-byte
+ *   `TextDecoder({ stream: true })` with the `createNDJSONParser` parser keeps multi-byte
  *   UTF-8 splits and partial lines honest.
  * - **Event-free.** A pure functional boundary — no Emitter, no events.
  * - **Transport seam.** {@link OllamaOptions.fetch} swaps the transport (default
@@ -436,107 +452,146 @@ export declare class OllamaProvider implements ProviderInterface {
      */
     get id(): string;
     /**
-     * Exposes the provider's context-framing default — the PROVIDER-DEFAULT level of
-     * {@link import('@orkestrel/agent').AgentContextInterface.build}'s format cascade (it BEATS
-     * the managers' built-in framing, is BEATEN by a manager-options or per-item override).
-     * Satisfies the OPTIONAL {@link ProviderInterface.format} contract member: `undefined`
+     * Exposes the provider's context-framing default — the provider-default level of
+     * {@link import('@orkestrel/agent').AgentContextInterface.build}'s format cascade (it beats
+     * the managers' built-in framing, is beaten by a manager-options or per-item override).
+     * Satisfies the optional {@link ProviderInterface.format} contract member: `undefined`
      * when {@link OllamaOptions.format} was omitted (the framing-agnostic default ⇒ core's
      * built-in framing applies unchanged), else the exact configured framing the Agent
      * threads into `build()`.
      *
      * @remarks
-     * EXPOSE-ONLY — read by the Agent loop and consumed by core's cascade; it is NEVER sent
-     * on the `/api/chat` wire (it is absent from `#body` / the request). This is NOT Ollama's
-     * structured-output `format` wire parameter — that one IS sent in `#body`, but only when
+     * Expose-only — read by the Agent loop and consumed by core's cascade; it is never sent
+     * on the `/api/chat` wire (it is absent from `#body` / the request). This is not Ollama's
+     * structured-output `format` wire parameter — that one is sent in `#body`, but only when
      * a per-call `ProviderStreamOptions.schema` is supplied; only the word collides.
      *
      * @returns The configured {@link ContextFormat}, or `undefined` when none
      */
     get format(): ContextFormat | undefined;
-    generate(messages: readonly Message[], signal: AbortSignal, tools?: readonly ToolDefinition[], options?: ProviderStreamOptions): Promise<ProviderResult>;
-    stream(messages: readonly Message[], signal: AbortSignal, tools?: readonly ToolDefinition[], options?: ProviderStreamOptions): AsyncGenerator<ProviderDelta, ProviderResult>;
-}
+    /**
+     * Generates one complete turn and resolves the assembled result — the clean content,
+     * any separated reasoning, any tool calls, and any usage the wire reported.
+     *
+     * @remarks
+     * Sends `stream: false` and parses one JSON body. Content routes through a per-call
+     * think splitter, so the assembled content stays clean even where the daemon renders a
+     * thinking model's reasoning inline; the separated spans and any daemon-side
+     * `message.thinking` land on `thinking`. The caller's signal and the armed deadline
+     * both cancel the request, and the deadline is cleared once the body is read.
+     *
+     * @param messages - The conversation turns to send
+     * @param signal - The caller's bounding signal, folded with the armed deadline
+     * @param tools - The callable tools to advertise for this turn, when the caller passes any
+     * @param options - The per-call overrides, `think` and `schema` among them
+     * @returns The assembled result of the turn
+     * @throws {@link OllamaHTTPError} When the daemon answers a non-OK status.
+         */
+     generate(messages: readonly Message[], signal: AbortSignal, tools?: readonly ToolDefinition[], options?: ProviderStreamOptions): Promise<ProviderResult>;
+     /**
+      * Streams one turn, yielding a channel-tagged delta per non-empty content or reasoning
+      * span and returning the assembled result when the stream completes.
+      *
+      * @remarks
+      * Sends `stream: true` and consumes NDJSON — one JSON object per newline-terminated
+      * line — pairing a streaming `TextDecoder` with the `NDJSONParser` so a record split
+      * across byte reads is reassembled. The returned result's content is the splitter's
+      * clean accumulation, beside any tool calls collected across lines and the usage the
+      * `done` line carries. A cancel mid-flight throws a `ProviderAbortError` carrying the
+      * partial assembled so far.
+      *
+      * @param messages - The conversation turns to send
+      * @param signal - The caller's bounding signal, folded with the armed deadline
+      * @param tools - The callable tools to advertise for this turn, when the caller passes any
+      * @param options - The per-call overrides, `think` and `schema` among them
+      * @returns The assembled result of the turn, after the last delta
+      * @throws {@link OllamaHTTPError} When the daemon answers a non-OK status or a `null` body.
+          */
+      stream(messages: readonly Message[], signal: AbortSignal, tools?: readonly ToolDefinition[], options?: ProviderStreamOptions): AsyncGenerator<ProviderDelta, ProviderResult>;
+     }
 
-/**
- * Represents an open `POST /api/chat` response together with the deadline and the
- * combined signal that bound the request.
- *
- * @remarks
- * The `response` is the open `POST /api/chat` `Response`; `timeout` is the armed
- * {@link TimeoutInterface} the consuming call clears once it finishes reading the body
- * (or that the provider clears on a failed or aborted request); `combined` is the
- * `AbortSignal.any([timeout.signal, callerSignal])` the request was issued under, which
- * the streaming path checks to tell a mid-stream cancel apart from any other error.
- */
-export declare interface OllamaResponse {
-    readonly response: Response;
-    readonly timeout: TimeoutInterface;
-    readonly combined: AbortSignal;
-}
+     /**
+      * Represents an open `POST /api/chat` response together with the deadline and the
+      * combined signal that bound the request.
+      *
+      * @remarks
+      * The `response` is the open `POST /api/chat` `Response`; `timeout` is the armed
+      * {@link TimeoutInterface} the consuming call clears once it finishes reading the body
+      * (or that the provider clears on a failed or aborted request); `combined` is the
+      * `AbortSignal.any([timeout.signal, callerSignal])` the request was issued under, which
+      * the streaming path checks to tell a mid-stream cancel apart from any other error.
+      */
+     export declare interface OllamaResponse {
+         readonly response: Response;
+         readonly timeout: TimeoutInterface;
+         readonly combined: AbortSignal;
+     }
 
-/**
- * Parses a non-stream `/api/chat` response body into a wire record.
- *
- * @remarks
- * Total by construction: an empty body, a body that is not JSON, and a body whose JSON is
- * not an object all yield `undefined`, so a malformed daemon response never escapes as a
- * `SyntaxError`. The call site supplies the empty-record default that reads as empty
- * content and no usage.
- *
- * @param response - The 200-OK `/api/chat` response whose body is read as text
- * @returns The parsed record, or `undefined` when the body is empty or malformed
- *
- * @example
- * ```ts
- * await parseBody(new Response('{"message":{"content":"ok"}}'))
- * // { message: { content: 'ok' } }
- * ```
- */
-export declare function parseBody(response: Response): Promise<Readonly<Record<string, unknown>> | undefined>;
+     /**
+      * Parses a non-stream `/api/chat` response body into a wire record.
+      *
+      * @remarks
+      * Total by construction: an empty body, a body that is not JSON, and a body whose JSON is
+      * not an object all yield `undefined`, so a malformed daemon response never escapes as a
+      * `SyntaxError`. The call site supplies the empty-record default that reads as empty
+      * content and no usage.
+      *
+      * @param response - The 200-OK `/api/chat` response whose body is read as text
+      * @returns The parsed record, or `undefined` when the body is empty or malformed
+      *
+      * @example
+      * ```ts
+      * await parseBody(new Response('{"message":{"content":"ok"}}'))
+      * // { message: { content: 'ok' } }
+      * ```
+      */
+     export declare function parseBody(response: Response): Promise<Readonly<Record<string, unknown>> | undefined>;
 
-/**
- * Represents the exact `POST /api/chat` request body `OllamaProvider` sends — the internal typed
- * wire contract.
- *
- * @remarks
- * This is the typed wire shape asserted against the official `ollama` client's
- * `ChatRequest` by the compile-time parity test; `src/` never imports `ollama` itself.
- * `messages` mirrors the minimal turn shape `mapMessages` builds (`role` / `content`, plus
- * `tool_calls` only on a turn that replays them and `images` only on a multimodal
- * turn); `options` and `tools` are only present when configured.
- */
-export declare interface WireChatRequest {
-    readonly model: string;
-    readonly messages: ReadonlyArray<{
-        readonly role: string;
-        readonly content: string;
-        readonly tool_calls?: ReadonlyArray<{
-            readonly function: {
-                readonly name: string;
-                readonly arguments: Readonly<Record<string, unknown>>;
-            };
-        }>;
-        readonly images?: readonly string[];
-    }>;
-    readonly stream: boolean;
-    readonly keep_alive: string | number;
-    readonly think: boolean;
-    readonly options?: Readonly<Record<string, unknown>>;
-    readonly tools?: ReadonlyArray<{
-        readonly type: 'function';
-        readonly function: {
-            readonly name: string;
-            readonly description?: string;
-            readonly parameters?: Readonly<Record<string, unknown>>;
-        };
-    }>;
-    /**
-     * Holds the `/api/chat` structured-output constraint — a JSON-Schema object forwarded
-     * verbatim from the per-call `ProviderStreamOptions.schema`. This is NOT
-     * `OllamaOptions.format` (the unrelated prompt-context framing); only present
-     * when a call supplies a `schema`.
-     */
-    readonly format?: Readonly<Record<string, unknown>>;
-}
+     /**
+      * Represents the exact `POST /api/chat` request body `OllamaProvider` sends — the internal typed
+      * wire contract.
+      *
+      * @remarks
+      * This is the typed wire shape asserted against the official `ollama` client's
+      * `ChatRequest` by the compile-time parity test; `src/` never imports `ollama` itself.
+      * `messages` mirrors the minimal turn shape `mapMessages` builds (`role` / `content`, plus
+      * `tool_calls` only on a turn that replays them and `images` only on a multimodal
+      * turn); `options` and `tools` are only present when configured. `format` carries the
+      * `/api/chat` structured-output constraint, forwarded verbatim from the per-call
+      * `ProviderStreamOptions.schema` and absent when no schema is supplied.
+      */
+     export declare interface WireChatRequest {
+         readonly model: string;
+         readonly messages: ReadonlyArray<{
+             readonly role: string;
+             readonly content: string;
+             readonly tool_calls?: ReadonlyArray<{
+                 readonly function: {
+                     readonly name: string;
+                     readonly arguments: Readonly<Record<string, unknown>>;
+                 };
+             }>;
+             readonly images?: readonly string[];
+         }>;
+         readonly stream: boolean;
+         readonly keep_alive: string | number;
+         readonly think: boolean;
+         readonly options?: Readonly<Record<string, unknown>>;
+         readonly tools?: ReadonlyArray<{
+             readonly type: 'function';
+             readonly function: {
+                 readonly name: string;
+                 readonly description?: string;
+                 readonly parameters?: Readonly<Record<string, unknown>>;
+             };
+         }>;
+         /**
+          * Holds the `/api/chat` structured-output constraint — a JSON-Schema object forwarded
+          * verbatim from the per-call `ProviderStreamOptions.schema`. This is not
+          * `OllamaOptions.format` (the unrelated prompt-context framing); only present
+          * when a call supplies a `schema`.
+          */
+         readonly format?: Readonly<Record<string, unknown>>;
+     }
 
-export { }
+     export { }