@orkestrel/ollama 0.0.12 → 0.0.14

package/dist/src/server/index.js

@@ -1,28 +1,32 @@
+import { isNumber, isRecord, isString, parseJSONAs } from "@orkestrel/contract";
 import { ProviderAbortError, createThinkSplitter } from "@orkestrel/agent";
-import { isNumber, isRecord, isString } from "@orkestrel/contract";
 import { createNDJSONParser } from "@orkestrel/ndjson";
 import { Timeout } from "@orkestrel/timeout";
 //#region src/server/constants.ts
-/** The local Ollama daemon base URL assumed when `OllamaOptions.url` is omitted. */
+/** Names the local Ollama daemon base URL assumed when `OllamaOptions.url` is omitted. */
 var DEFAULT_OLLAMA_URL = "http://localhost:11434";
 /**
-* How long the model stays resident after a call when `OllamaOptions.keepAlive` is
+* 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.
+*
+* @remarks
+* The name mirrors the Ollama `/api/chat` `keep_alive` field this value is sent as, so
+* the constant, the `OllamaOptions.keepAlive` key, and the wire member read as one term.
 */
 var DEFAULT_KEEP_ALIVE = "5m";
 /**
-* The per-call deadline in milliseconds when `OllamaOptions.timeout` is omitted —
+* Names the per-call deadline in milliseconds when `OllamaOptions.timeout` is omitted —
 * generous enough that a cold model load does not trip it.
 */
 var DEFAULT_PROVIDER_TIMEOUT = 12e4;
 /**
-* The cap, in characters, on how much of a non-OK response body is
+* Names the cap, in characters, 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 (§14). `2048` characters is generous enough to carry a
+* without limit. `2048` characters is generous enough to carry a
 * useful diagnostic snippet while staying well short of any practical size
 * concern.
 */
@@ -30,14 +34,15 @@ var MAX_ERROR_BODY_LENGTH = 2048;
 //#endregion
 //#region src/server/errors.ts
 /**
-* An error thrown when the Ollama `/api/chat` HTTP transport fails.
+* Represents an error thrown when the Ollama `/api/chat` HTTP transport fails.
 *
 * @remarks
-* Carries the response `status` (0 when no HTTP response was received at all,
-* e.g. a `null` body). Thrown by {@link OllamaProvider} at its two HTTP
-* failure sites — the non-OK status branch and the null-body branch — so a
-* caller can branch on `error.status` instead of parsing the message. Narrow
-* a caught value with {@link isOllamaHTTPError}.
+* Carries the machine-readable `code` `'HTTP'` and the response `status` (0 when no
+* 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
+* {@link isOllamaHTTPError}.
 *
 * @example
 * ```ts
@@ -51,6 +56,11 @@ var MAX_ERROR_BODY_LENGTH = 2048;
 * ```
 */
 var OllamaHTTPError = class extends Error {
+	/**
+	* Names the machine-readable condition this error reports — `'HTTP'`: an `/api/chat`
+	* transport, status, or body failure.
+	*/
+	code = "HTTP";
 	status;
 	constructor(message, status, options) {
 		super(message, options);
@@ -59,36 +69,252 @@ var OllamaHTTPError = class extends Error {
 	}
 };
 /**
-* Whether a value is an {@link OllamaHTTPError}.
+* Checks whether a value is an {@link OllamaHTTPError}.
 *
 * @param value - The value to test
-* @returns `true` when `value` is an `OllamaHTTPError`
+* @returns True if `value` is an `OllamaHTTPError`; false otherwise
 */
 function isOllamaHTTPError(value) {
 	return value instanceof OllamaHTTPError;
 }
 //#endregion
+//#region src/server/helpers.ts
+/**
+* Maps conversation turns onto the `/api/chat` wire's minimal message shape.
+*
+* @remarks
+* `tool_calls` is emitted only on a turn that replays them and `images` only on a
+* multimodal turn, so an empty optional never reaches the wire.
+*
+* @param messages - The conversation turns to send
+* @returns The wire `messages` array, one entry per turn, in order
+*
+* @example
+* ```ts
+* mapMessages([{ id: '1', role: 'user', content: 'Say hello.' }])
+* // [{ role: 'user', content: 'Say hello.' }]
+* ```
+*/
+function mapMessages(messages) {
+	return messages.map((message) => ({
+		role: message.role,
+		content: message.content,
+		...message.calls !== void 0 && message.calls.length > 0 ? { tool_calls: message.calls.map((call) => ({ function: {
+			name: call.name,
+			arguments: call.arguments
+		} })) } : {},
+		...message.images !== void 0 && message.images.length > 0 ? { images: [...message.images] } : {}
+	}));
+}
+/**
+* Builds a provider result 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
+* `usage` unless the wire reported one.
+*
+* @param content - The clean assistant content the splitter accumulated
+* @param thinking - The joined reasoning, empty when the turn produced none
+* @param tools - The tool calls collected across the turn
+* @param usage - The token usage, or `undefined` when the wire reported none
+* @returns The result carrying only its populated fields
+*
+* @example
+* ```ts
+* buildResult('ok', '', [], undefined) // { content: 'ok' }
+* ```
+*/
+function buildResult(content, thinking, tools, usage) {
+	const result = { content };
+	if (thinking.length > 0) result.thinking = thinking;
+	if (tools.length > 0) result.tools = tools;
+	if (usage !== void 0) result.usage = usage;
+	return result;
+}
+/**
+* Extracts the assistant text of one wire record.
+*
+* @param record - One parsed `/api/chat` record — a non-stream body or an NDJSON line
+* @returns The record's `message.content` when it is a string, else `''`
+*
+* @example
+* ```ts
+* extractContent({ message: { content: 'ok' } }) // 'ok'
+* ```
+*/
+function extractContent(record) {
+	const message = Reflect.get(record, "message");
+	if (!isRecord(message)) return "";
+	const content = Reflect.get(message, "content");
+	return isString(content) ? content : "";
+}
+/**
+* Extracts the daemon-side reasoning of one wire record.
+*
+* @remarks
+* `message.thinking` is the `think: true` wire shape. It is read whatever the configured
+* flag says, because a daemon may separate reasoning on its own.
+*
+* @param record - One parsed `/api/chat` record — a non-stream body or an NDJSON line
+* @returns The record's `message.thinking` when it is a string, else `''`
+*
+* @example
+* ```ts
+* extractThinking({ message: { thinking: 'weighing it' } }) // 'weighing it'
+* ```
+*/
+function extractThinking(record) {
+	const message = Reflect.get(record, "message");
+	if (!isRecord(message)) return "";
+	const thinking = Reflect.get(message, "thinking");
+	return isString(thinking) ? thinking : "";
+}
+/**
+* Joins a call's two reasoning carriers 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
+*
+* @example
+* ```ts
+* joinThinking(createThinkSplitter(), 'from the wire') // 'from the wire'
+* ```
+*/
+function joinThinking(splitter, wired) {
+	if (splitter.thinking.length === 0) return wired;
+	if (wired.length === 0) return splitter.thinking;
+	return `${splitter.thinking}\n\n${wired}`;
+}
+/**
+* Extracts the token usage of one wire record.
+*
+* @remarks
+* Both counts must be numbers, which is true of the non-stream body and the stream's
+* `done: true` line. A delta line carries neither, so it yields `undefined`.
+*
+* @param record - One parsed `/api/chat` record — a non-stream body or an NDJSON line
+* @returns The `TokenUsage` shape, or `undefined` when either count is absent
+*
+* @example
+* ```ts
+* extractUsage({ prompt_eval_count: 3, eval_count: 4 })
+* // { prompt: 3, completion: 4, total: 7 }
+* ```
+*/
+function extractUsage(record) {
+	const prompt = Reflect.get(record, "prompt_eval_count");
+	const completion = Reflect.get(record, "eval_count");
+	if (!isNumber(prompt) || !isNumber(completion)) return void 0;
+	return {
+		prompt,
+		completion,
+		total: prompt + completion
+	};
+}
+/**
+* Extracts the tool calls of one wire record's `message.tool_calls`.
+*
+* @remarks
+* Each entry narrows to `{ id, name, arguments }`: the entry and its `function` must be
+* records and `name` a string, else the entry is dropped. An id is minted when the wire
+* omits one.
+*
+* @param record - One parsed `/api/chat` record — a non-stream body or an NDJSON line
+* @returns The narrowed tool calls, empty when the record carries none
+*
+* @example
+* ```ts
+* extractTools({ message: { tool_calls: [{ function: { name: 'weather' } }] } })
+* // [{ id: '…', name: 'weather', arguments: {} }]
+* ```
+*/
+function extractTools(record) {
+	const message = Reflect.get(record, "message");
+	if (!isRecord(message)) return [];
+	const calls = Reflect.get(message, "tool_calls");
+	if (!Array.isArray(calls)) return [];
+	const out = [];
+	for (const entry of calls) {
+		if (!isRecord(entry)) continue;
+		const callable = Reflect.get(entry, "function");
+		if (!isRecord(callable)) continue;
+		const name = Reflect.get(callable, "name");
+		if (!isString(name)) continue;
+		const id = Reflect.get(entry, "id");
+		out.push({
+			id: isString(id) ? id : crypto.randomUUID(),
+			name,
+			arguments: extractArguments(Reflect.get(callable, "arguments"))
+		});
+	}
+	return out;
+}
+/**
+* Extracts a wire `arguments` value as a record.
+*
+* @remarks
+* Total: an object passes through, a JSON string is parsed when it yields a record, and
+* a malformed string yields `{}` rather than throwing.
+*
+* @param value - The wire's `function.arguments` value, of unknown shape
+* @returns The argument record, or `{}` when the value carries none
+*
+* @example
+* ```ts
+* extractArguments('{"city":"Oslo"}') // { city: 'Oslo' }
+* ```
+*/
+function extractArguments(value) {
+	if (isRecord(value)) return value;
+	if (isString(value)) return parseJSONAs(value, isRecord) ?? {};
+	return {};
+}
+//#endregion
+//#region src/server/parsers.ts
+/**
+* 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' } }
+* ```
+*/
+async function parseBody(response) {
+	return parseJSONAs(await response.text(), isRecord);
+}
+//#endregion
 //#region src/server/OllamaProvider.ts
 /**
-* The local Ollama inference boundary — a {@link ProviderInterface} over Ollama's
+* Implements the local Ollama inference boundary — a {@link ProviderInterface} over Ollama's
 * `POST /api/chat`, both non-streaming (`generate`) and streaming NDJSON (`stream`).
 *
 * @remarks
 * - **Wire protocol.** Posts `{ model, messages, stream, keep_alive, think }` plus
 *   passthrough sampling `options` and mapped function `tools`. The `think` flag is
-*   CONFIGURABLE via {@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 (H4).** The wire `think` flag is configurable
+* - **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 via `#thinking`) instead of inline in `message.content`. EITHER
+*   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,
 *   and the separated reasoning (plus any daemon-side `message.thinking` deltas) lands on
 *   `ProviderResult.thinking`, never in the conversation.
-* - **Boundary narrowing (§14).** Every wire value arrives as `unknown` and is
+* - **Boundary narrowing.** Every wire value arrives as `unknown` and is
 *   narrowed through guards (`isRecord` / `isString` / `isNumber`) — never `as`. A
 *   missing / malformed field degrades to a sensible default (empty content, no
 *   usage, `{}` arguments), never a throw.
@@ -105,7 +331,8 @@ function isOllamaHTTPError(value) {
 *   `globalThis.fetch`) and {@link OllamaOptions.headers} is a per-request, possibly
 *   async header injector merged over the base `Content-Type` — so a browser runtime
 *   can route through the developer's own server with an obfuscated bearer token,
-*   without this library ever handling a real API key. Both omitted ⇒ today's behaviour.
+*   without this library ever handling a real API key. Both omitted ⇒ the global `fetch`
+*   and only a JSON content type.
 *   Orthogonal to the deadline: the hook is awaited inside `#fetch`'s try, so a hook
 *   rejection clears the armed timer like any other request failure.
 *
@@ -116,8 +343,8 @@ function isOllamaHTTPError(value) {
 * ```
 */
 var OllamaProvider = class {
-	id = crypto.randomUUID();
 	name = "ollama";
+	#id;
 	#model;
 	#url;
 	#keepAlive;
@@ -128,6 +355,7 @@ var OllamaProvider = class {
 	#headers;
 	#format;
 	constructor(options) {
+		this.#id = crypto.randomUUID();
 		this.#model = options.model;
 		this.#url = options.url ?? "http://localhost:11434";
 		this.#keepAlive = options.keepAlive ?? "5m";
@@ -139,7 +367,17 @@ var OllamaProvider = class {
 		this.#format = options.format;
 	}
 	/**
-	* The provider's context-framing default — the PROVIDER-DEFAULT level of
+	* Exposes this instance's identity — a fresh `crypto.randomUUID()` minted at
+	* construction, satisfying the {@link ProviderInterface.id} contract member. A second
+	* provider built from identical options carries a distinct id.
+	*
+	* @returns The instance's minted identifier
+	*/
+	get id() {
+		return this.#id;
+	}
+	/**
+	* 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`
@@ -153,7 +391,7 @@ var OllamaProvider = class {
 	* 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 ContextFormatInterface}, or `undefined` when none
+	* @returns The configured {@link ContextFormat}, or `undefined` when none
 	*/
 	get format() {
 		return this.#format;
@@ -161,12 +399,12 @@ var OllamaProvider = class {
 	async generate(messages, signal, tools, options) {
 		const { response, timeout } = await this.#fetch(messages, false, signal, tools, options);
 		try {
-			const record = await this.#parseBody(response);
+			const record = await parseBody(response) ?? {};
 			const splitter = createThinkSplitter();
-			splitter.split(this.#content(record));
+			splitter.split(extractContent(record));
 			splitter.flush();
-			const thinking = this.#thought(splitter, this.#thinking(record));
-			return this.#result(splitter.content, thinking, this.#tools(record), this.#usage(record));
+			const thinking = joinThinking(splitter, extractThinking(record));
+			return buildResult(splitter.content, thinking, extractTools(record), extractUsage(record));
 		} finally {
 			timeout.clear();
 		}
@@ -182,54 +420,63 @@ var OllamaProvider = class {
 		const decoder = new TextDecoder();
 		const parser = createNDJSONParser();
 		const splitter = createThinkSplitter();
-		const state = {
-			splitter,
-			wired: "",
-			calls: [],
-			usage: void 0
-		};
+		let wired = "";
+		const calls = [];
+		let usage;
 		try {
 			for (;;) {
 				const { value, done } = await reader.read();
 				if (done) break;
-				for (const record of parser.parse(decoder.decode(value, { stream: true }))) yield* this.#deltas(record, state);
+				for (const record of parser.parse(decoder.decode(value, { stream: true }))) {
+					const increment = yield* this.#deltas(record, splitter, usage);
+					wired += increment.thinking;
+					calls.push(...increment.calls);
+					usage = increment.usage;
+				}
 			}
 			const decoderTail = decoder.decode();
-			for (const record of parser.parse(decoderTail.length > 0 ? `${decoderTail}\n` : "\n")) yield* this.#deltas(record, state);
+			for (const record of parser.parse(decoderTail.length > 0 ? `${decoderTail}\n` : "\n")) {
+				const increment = yield* this.#deltas(record, splitter, usage);
+				wired += increment.thinking;
+				calls.push(...increment.calls);
+				usage = increment.usage;
+			}
 			const tail = splitter.flush();
 			if (tail.length > 0) yield {
-				type: "content",
+				channel: "content",
 				text: tail
 			};
 		} catch (error) {
 			if (combined.aborted) {
 				splitter.flush();
-				throw new ProviderAbortError(this.#result(splitter.content, this.#thought(splitter, state.wired), state.calls, state.usage));
+				throw new ProviderAbortError(buildResult(splitter.content, joinThinking(splitter, wired), calls, usage));
 			}
 			throw error;
 		} finally {
 			try {
 				await reader.cancel();
 			} catch {}
-			parser.reset();
+			parser.clear();
 			timeout.clear();
 		}
-		return this.#result(splitter.content, this.#thought(splitter, state.wired), state.calls, state.usage);
+		return buildResult(splitter.content, joinThinking(splitter, wired), calls, usage);
 	}
-	*#deltas(record, state) {
-		const delta = state.splitter.split(this.#content(record));
+	*#deltas(record, splitter, usage) {
+		const delta = splitter.split(extractContent(record));
 		if (delta.length > 0) yield {
-			type: "content",
+			channel: "content",
 			text: delta
 		};
-		const thinking = this.#thinking(record);
+		const thinking = extractThinking(record);
 		if (thinking.length > 0) yield {
-			type: "thinking",
+			channel: "thinking",
 			text: thinking
 		};
-		state.wired += thinking;
-		state.calls.push(...this.#tools(record));
-		if (Reflect.get(record, "done") === true) state.usage = this.#usage(record);
+		return {
+			thinking,
+			calls: extractTools(record),
+			usage: Reflect.get(record, "done") === true ? extractUsage(record) : usage
+		};
 	}
 	async #fetch(messages, stream, signal, tools, options) {
 		const timeout = new Timeout({ ms: this.#timeout });
@@ -262,16 +509,6 @@ var OllamaProvider = class {
 			throw error;
 		}
 	}
-	async #parseBody(response) {
-		const text = await response.text();
-		if (text.length === 0) return {};
-		try {
-			const data = JSON.parse(text);
-			return isRecord(data) ? data : {};
-		} catch {
-			return {};
-		}
-	}
 	async #requestHeaders() {
 		const headers = { "Content-Type": "application/json" };
 		if (this.#headers !== void 0) for (const [key, value] of Object.entries(await this.#headers())) headers[key] = value;
@@ -280,7 +517,7 @@ var OllamaProvider = class {
 	#body(messages, stream, tools, options) {
 		return {
 			model: this.#model,
-			messages: this.#plain(messages),
+			messages: mapMessages(messages),
 			stream,
 			keep_alive: this.#keepAlive,
 			think: options?.think ?? this.#think,
@@ -296,94 +533,18 @@ var OllamaProvider = class {
 			})) } : {}
 		};
 	}
-	#plain(messages) {
-		return messages.map((message) => ({
-			role: message.role,
-			content: message.content,
-			...message.calls !== void 0 && message.calls.length > 0 ? { tool_calls: message.calls.map((call) => ({ function: {
-				name: call.name,
-				arguments: call.arguments
-			} })) } : {},
-			...message.images !== void 0 && message.images.length > 0 ? { images: [...message.images] } : {}
-		}));
-	}
-	#result(content, thinking, tools, usage) {
-		const result = { content };
-		if (thinking.length > 0) result.thinking = thinking;
-		if (tools.length > 0) result.tools = tools;
-		if (usage !== void 0) result.usage = usage;
-		return result;
-	}
-	#content(record) {
-		const message = Reflect.get(record, "message");
-		if (!isRecord(message)) return "";
-		const content = Reflect.get(message, "content");
-		return isString(content) ? content : "";
-	}
-	#thinking(record) {
-		const message = Reflect.get(record, "message");
-		if (!isRecord(message)) return "";
-		const thinking = Reflect.get(message, "thinking");
-		return isString(thinking) ? thinking : "";
-	}
-	#thought(splitter, wired) {
-		if (splitter.thinking.length === 0) return wired;
-		if (wired.length === 0) return splitter.thinking;
-		return `${splitter.thinking}\n\n${wired}`;
-	}
-	#usage(record) {
-		const prompt = Reflect.get(record, "prompt_eval_count");
-		const completion = Reflect.get(record, "eval_count");
-		if (!isNumber(prompt) || !isNumber(completion)) return void 0;
-		return {
-			prompt,
-			completion,
-			total: prompt + completion
-		};
-	}
-	#tools(record) {
-		const message = Reflect.get(record, "message");
-		if (!isRecord(message)) return [];
-		const calls = Reflect.get(message, "tool_calls");
-		if (!Array.isArray(calls)) return [];
-		const out = [];
-		for (const entry of calls) {
-			if (!isRecord(entry)) continue;
-			const callable = Reflect.get(entry, "function");
-			if (!isRecord(callable)) continue;
-			const name = Reflect.get(callable, "name");
-			if (!isString(name)) continue;
-			const id = Reflect.get(entry, "id");
-			out.push({
-				id: isString(id) ? id : crypto.randomUUID(),
-				name,
-				arguments: this.#arguments(Reflect.get(callable, "arguments"))
-			});
-		}
-		return out;
-	}
-	#arguments(value) {
-		if (isRecord(value)) return value;
-		if (isString(value)) try {
-			const parsed = JSON.parse(value);
-			if (isRecord(parsed)) return parsed;
-		} catch {
-			return {};
-		}
-		return {};
-	}
 };
 //#endregion
 //#region src/server/factories.ts
 /**
-* Create a local Ollama inference provider — a {@link ProviderInterface} over the
+* Creates a local Ollama inference provider — a {@link ProviderInterface} over the
 * daemon's `POST /api/chat`, supporting non-streaming `generate` and streaming
 * `stream`.
 *
 * @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` / `num_predict` / …). Both calls take an
+* parameters (`temperature`, `seed`, and `num_predict`). Both calls take an
 * `AbortSignal` to bound the request; a `stream` cancelled mid-flight throws a
 * `ProviderAbortError` carrying the partial result.
 *
@@ -391,12 +552,12 @@ var OllamaProvider = class {
 * 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
-* key. Both omitted ⇒ today's behaviour (the global `fetch`, only a JSON content type).
+* 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
-* level of `AgentContext`'s format cascade (see [agents.md]; 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 (e.g. XML group wrappers vs. Markdown
+* 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).
@@ -408,7 +569,7 @@ var OllamaProvider = class {
 * @example
 * ```ts
 * import { createAbort } from '@orkestrel/abort'
-* import { createOllama } from '@src/server'
+* import { createOllama } from '@orkestrel/ollama'
 *
 * const provider = createOllama({ model: 'qwen3.5:2b-q4_K_M' })
 * const abort = createAbort()
@@ -416,7 +577,7 @@ var OllamaProvider = class {
 * ```
 *
 * @example
-* Route through your own server with an obfuscated token (deployment scenario S2):
+* Route through your own server with an obfuscated token:
 * ```ts
 * const provider = createOllama({
 *   model: 'qwen3.5:2b-q4_K_M',
@@ -446,6 +607,6 @@ function createOllama(options) {
 	return new OllamaProvider(options);
 }
 //#endregion
-export { DEFAULT_KEEP_ALIVE, DEFAULT_OLLAMA_URL, DEFAULT_PROVIDER_TIMEOUT, MAX_ERROR_BODY_LENGTH, OllamaHTTPError, OllamaProvider, createOllama, isOllamaHTTPError };
+export { DEFAULT_KEEP_ALIVE, DEFAULT_OLLAMA_URL, DEFAULT_PROVIDER_TIMEOUT, MAX_ERROR_BODY_LENGTH, OllamaHTTPError, OllamaProvider, buildResult, createOllama, extractArguments, extractContent, extractThinking, extractTools, extractUsage, isOllamaHTTPError, joinThinking, mapMessages, parseBody };
 
 //# sourceMappingURL=index.js.map