@orkestrel/ollama 0.0.14 → 0.0.16

package/README.md

@@ -1,9 +1,18 @@
 # @orkestrel/ollama
 
-A typed local-LLM provider for the `@orkestrel` line — a `ProviderInterface`
-implementation over a local Ollama daemon's `POST /api/chat`, with NDJSON
-streaming, tool calls, thinking, and usage accounting, built on pure
-web-standard `fetch` / `ReadableStream` (no Ollama SDK dependency).
+> A typed local-LLM provider for the `@orkestrel` line: the Ollama daemon's `POST /api/chat`
+> wire carried on the shared `AgentProvider` engine from `@orkestrel/agent`, with NDJSON
+> streaming, tool calls, thinking, and usage accounting narrowed off the wire through
+> `@orkestrel/contract` guards and no Ollama SDK dependency.
+
+Create a provider with the `createOllama` function, hand it a conversation and a
+bounding `AbortSignal`, and read the assembled `ProviderResult` the `generate`
+method resolves — or drive the `stream` method for live deltas. The engine in
+`@orkestrel/agent` holds the deadline, the transport, the header hook, and the
+result assembly; this package holds the Ollama wire. Point `url` at your own server
+and attach a short-lived token through `headers` where a browser runtime must not
+hold the real key, or relay the whole provider through your server so the page never
+learns which model answers.
 
 ## Install
 
@@ -13,10 +22,10 @@ npm install @orkestrel/ollama
 
 ## Requirements
 
-- Node.js >= 22
-- A running Ollama daemon (default `http://localhost:11434`) with a pulled
+- Node.js >= 22, or any browser with `fetch` and `ReadableStream`
+- A reachable Ollama daemon (default `http://localhost:11434`) with a pulled
   model — required at runtime by any consumer, and by this repository's live
-  `service` test project; the `src:server` project is hermetic and passes with
+  `service` test project; the `src:core` project is hermetic and passes with
   the daemon down
 - ESM + CJS (dual-format build)
 
@@ -41,27 +50,36 @@ output, `stream` is the same call streamed — it yields `ProviderDelta`s
 assembled result when the stream completes:
 
 ```ts
+const answer: string[] = []
 const generator = provider.stream(messages, abort.signal)
 let step = await generator.next()
 while (!step.done) {
-	if (step.value.channel === 'content') process.stdout.write(step.value.text)
+	if (step.value.channel === 'content') answer.push(step.value.text)
 	step = await generator.next()
 }
 const streamed = step.value // the assembled ProviderResult
+streamed.content // the answer — the settled content is the authoritative one
+answer.join('') // what arrived on the content channel
 ```
 
+Read the answer from the settled `streamed.content`. The deltas are what arrived,
+and a turn whose reasoning the daemon opened without a `<think>` marker streams a
+prefix the base later moves to `streamed.thinking`, leaving the joined deltas
+longer than the settled content — see [`guides/ollama.md`](guides/ollama.md).
+
 ## Guide
 
-For the full surface — `createOllama`, `OllamaProvider`, `OllamaOptions`,
-tool calls (`ToolDefinition` / `ToolCall` from `@orkestrel/tool`), thinking,
-and the context-framing default — see
+For the full surface — `createOllama`, `OllamaProvider`, `OllamaOptions`, the
+wire seams (`frame` / `body` / `read` / `finish`), tool calls
+(`ToolDefinition` / `ToolCall` from `@orkestrel/tool`), thinking, the
+context-framing default, and the browser relay — see
 [`guides/ollama.md`](guides/ollama.md).
 
 ## Package
 
-Published as a single server surface per the `exports` field in
-`package.json` — one `.` entry backed by a dual ESM + CommonJS build of
-`src/server`.
+The `exports` field in `package.json` publishes the `.` entry alone — a dual
+ESM + CommonJS build of `src/core`, host-independent so the same build serves a
+server process and a browser page.
 
 ## License
 

package/dist/src/core/index.cjs

@@ -0,0 +1,362 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _orkestrel_contract = require("@orkestrel/contract");
+let _orkestrel_agent = require("@orkestrel/agent");
+let _orkestrel_ndjson = require("@orkestrel/ndjson");
+//#region src/core/constants.ts
+/**
+* Names the local Ollama daemon base URL, `'http://localhost:11434'`, assumed when
+* `OllamaOptions.url` is omitted.
+*/
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+/**
+* 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
+* the constant, the `OllamaOptions.keepAlive` key, and the wire member read as one term.
+*/
+var DEFAULT_KEEP_ALIVE = "5m";
+/** Names the Ollama chat endpoint appended to the configured base URL. */
+var OLLAMA_CHAT_PATH = "/api/chat";
+//#endregion
+//#region src/core/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] } : {}
+	}));
+}
+/**
+* Extracts the assistant text of one wire record.
+*
+* @param record - One parsed `/api/chat` NDJSON record
+* @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 (!(0, _orkestrel_contract.isRecord)(message)) return "";
+	const content = Reflect.get(message, "content");
+	return (0, _orkestrel_contract.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` NDJSON record
+* @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 (!(0, _orkestrel_contract.isRecord)(message)) return "";
+	const thinking = Reflect.get(message, "thinking");
+	return (0, _orkestrel_contract.isString)(thinking) ? thinking : "";
+}
+/**
+* Extracts the token usage of one wire record.
+*
+* @remarks
+* Both counts must be numbers, which is true of the stream's `done: true` line. A
+* delta line carries neither, so it yields `undefined`.
+*
+* @param record - One parsed `/api/chat` NDJSON record
+* @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 (!(0, _orkestrel_contract.isNumber)(prompt) || !(0, _orkestrel_contract.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` NDJSON record
+* @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 (!(0, _orkestrel_contract.isRecord)(message)) return [];
+	const calls = Reflect.get(message, "tool_calls");
+	if (!Array.isArray(calls)) return [];
+	const out = [];
+	for (const entry of calls) {
+		if (!(0, _orkestrel_contract.isRecord)(entry)) continue;
+		const callable = Reflect.get(entry, "function");
+		if (!(0, _orkestrel_contract.isRecord)(callable)) continue;
+		const name = Reflect.get(callable, "name");
+		if (!(0, _orkestrel_contract.isString)(name)) continue;
+		const id = Reflect.get(entry, "id");
+		out.push({
+			id: (0, _orkestrel_contract.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 ((0, _orkestrel_contract.isRecord)(value)) return value;
+	if ((0, _orkestrel_contract.isString)(value)) return (0, _orkestrel_contract.parseJSONAs)(value, _orkestrel_contract.isRecord) ?? {};
+	return {};
+}
+//#endregion
+//#region src/core/OllamaProvider.ts
+/**
+* Implements the Ollama `/api/chat` wire over the shared {@link AgentProvider} engine.
+*
+* @remarks
+* Every request uses NDJSON streaming. The base assembles complete turns, separates
+* reasoning, and bounds requests; this class supplies Ollama framing and projections.
+* Usage comes only from a `done: true` record carrying the token counts.
+*
+* @example
+* ```ts
+* const provider = new OllamaProvider({ model: 'qwen3.5:2b-q4_K_M' })
+* const result = await provider.generate(messages, abort.signal)
+* ```
+*/
+var OllamaProvider = class extends _orkestrel_agent.AgentProvider {
+	name = "ollama";
+	#model;
+	#keepAlive;
+	#think;
+	#options;
+	constructor(options) {
+		super({
+			url: options.url ?? "http://localhost:11434",
+			path: OLLAMA_CHAT_PATH,
+			...options.timeout === void 0 ? {} : { timeout: options.timeout },
+			...options.fetch === void 0 ? {} : { fetch: options.fetch },
+			...options.headers === void 0 ? {} : { headers: options.headers },
+			...options.format === void 0 ? {} : { format: options.format }
+		});
+		this.#model = options.model;
+		this.#keepAlive = options.keepAlive ?? "5m";
+		this.#think = options.think ?? false;
+		this.#options = options.options;
+	}
+	/**
+	* Creates fresh NDJSON framing state for a call.
+	*
+	* @returns The parser that buffers incomplete Ollama records
+	*/
+	frame() {
+		return (0, _orkestrel_ndjson.createNDJSONParser)();
+	}
+	/**
+	* Projects conversation turns and per-call options onto the Ollama request body.
+	*
+	* @param request - The conversation, advertised tools, and per-call overrides
+	* @returns The `/api/chat` body with streaming enabled
+	*/
+	body(request) {
+		return {
+			model: this.#model,
+			messages: mapMessages(request.messages),
+			stream: true,
+			keep_alive: this.#keepAlive,
+			think: request.options?.think ?? this.#think,
+			...this.#options !== void 0 ? { options: this.#options } : {},
+			...request.options?.schema !== void 0 ? { format: request.options.schema } : {},
+			...request.tools !== void 0 && request.tools.length > 0 ? { tools: request.tools.map((tool) => ({
+				type: "function",
+				function: {
+					name: tool.name,
+					...tool.description === void 0 ? {} : { description: tool.description },
+					...tool.parameters === void 0 ? {} : { parameters: tool.parameters }
+				}
+			})) } : {}
+		};
+	}
+	/**
+	* Extracts a record's content, reasoning, tools, and completed usage report.
+	*
+	* @param record - One parsed Ollama NDJSON record
+	* @returns The turn increment, omitting usage until `done` and the counts are present
+	*/
+	read(record) {
+		const usage = Reflect.get(record, "done") === true ? extractUsage(record) : void 0;
+		return {
+			content: extractContent(record),
+			thinking: extractThinking(record),
+			tools: extractTools(record),
+			...usage === void 0 ? {} : { usage }
+		};
+	}
+	/**
+	* Recovers a final NDJSON record that arrived without its line terminator.
+	*
+	* @param parser - The call's parser holding any unterminated input
+	* @returns The records completed by the final newline
+	*/
+	finish(parser) {
+		return parser.parse("\n");
+	}
+};
+//#endregion
+//#region src/core/factories.ts
+/**
+* Creates a local Ollama inference provider — a {@link ProviderInterface} over the
+* daemon's `POST /api/chat`, assembling `generate` from the same NDJSON engine as `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`, 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
+* 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 (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 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 createOllama + generate
+* ```ts
+* import { createAbort } from '@orkestrel/abort'
+* import type { TokenUsage } from '@orkestrel/budget'
+* import { createOllama } from '@orkestrel/ollama'
+*
+* declare function charge(usage: TokenUsage): void // your billing integration
+*
+* 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
+* Route through your own server with an obfuscated token:
+* ```ts
+* const provider = createOllama({
+*   model: 'qwen3.5:2b-q4_K_M',
+*   url: 'https://my-app.example.com/llm', // your server, not the daemon
+*   fetch: myFetch, // optional custom transport
+*   headers: () => ({ authorization: `Bearer ${myToken}` }), // your server validates this
+* })
+* ```
+*
+* @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`):
+* ```ts
+* const provider = createOllama({
+*   model: 'qwen3.5:2b-q4_K_M',
+*   format: {
+*     instructions: {
+*       open: '<instructions>',
+*       render: (i) => `<instruction>${i.content}</instruction>`,
+*       close: '</instructions>',
+*     },
+*   },
+* })
+* ```
+*/
+function createOllama(options) {
+	return new OllamaProvider(options);
+}
+//#endregion
+exports.DEFAULT_KEEP_ALIVE = DEFAULT_KEEP_ALIVE;
+exports.DEFAULT_OLLAMA_URL = DEFAULT_OLLAMA_URL;
+exports.OLLAMA_CHAT_PATH = OLLAMA_CHAT_PATH;
+exports.OllamaProvider = OllamaProvider;
+exports.createOllama = createOllama;
+exports.extractArguments = extractArguments;
+exports.extractContent = extractContent;
+exports.extractThinking = extractThinking;
+exports.extractTools = extractTools;
+exports.extractUsage = extractUsage;
+exports.mapMessages = mapMessages;
+
+//# sourceMappingURL=index.cjs.map

package/dist/src/core/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../src/core/constants.ts","../../../src/core/helpers.ts","../../../src/core/OllamaProvider.ts","../../../src/core/factories.ts"],"sourcesContent":["// Ollama constants — the provider's defaults.\n\n/**\n * Names the local Ollama daemon base URL, `'http://localhost:11434'`, assumed when\n * `OllamaOptions.url` is omitted.\n */\nexport const DEFAULT_OLLAMA_URL = 'http://localhost:11434'\n\n/**\n * Names how long the model stays resident after a call — `'5m'` when\n * `OllamaOptions.keepAlive` is omitted, Ollama's own `keep_alive` default, expressed as a\n * duration string.\n *\n * @remarks\n * The name mirrors the Ollama `/api/chat` `keep_alive` field this value is sent as, so\n * the constant, the `OllamaOptions.keepAlive` key, and the wire member read as one term.\n */\nexport const DEFAULT_KEEP_ALIVE = '5m'\n\n/** Names the Ollama chat endpoint appended to the configured base URL. */\nexport const OLLAMA_CHAT_PATH = '/api/chat'\n","// The Ollama wire leaves — the request projections and the response extractions\n// `OllamaProvider` composes. Each is a pure, total function of its parameters: a missing\n// or malformed wire field degrades to a sensible default (empty content, no usage, `{}`\n// arguments), never a throw, and no value is reached through `as`.\n\nimport type { Message } from '@orkestrel/agent'\nimport type { TokenUsage } from '@orkestrel/budget'\nimport type { ToolCall } from '@orkestrel/tool'\nimport type { WireChatRequest } from './types.js'\nimport { isNumber, isRecord, isString, parseJSONAs } from '@orkestrel/contract'\n\n/**\n * Maps conversation turns onto the `/api/chat` wire's minimal message shape.\n *\n * @remarks\n * `tool_calls` is emitted only on a turn that replays them and `images` only on a\n * multimodal turn, so an empty optional never reaches the wire.\n *\n * @param messages - The conversation turns to send\n * @returns The wire `messages` array, one entry per turn, in order\n *\n * @example\n * ```ts\n * mapMessages([{ id: '1', role: 'user', content: 'Say hello.' }])\n * // [{ role: 'user', content: 'Say hello.' }]\n * ```\n */\nexport function mapMessages(messages: readonly Message[]): WireChatRequest['messages'] {\n\treturn messages.map((message) => ({\n\t\trole: message.role,\n\t\tcontent: message.content,\n\t\t...(message.calls !== undefined && message.calls.length > 0\n\t\t\t? {\n\t\t\t\t\ttool_calls: message.calls.map((call) => ({\n\t\t\t\t\t\tfunction: { name: call.name, arguments: call.arguments },\n\t\t\t\t\t})),\n\t\t\t\t}\n\t\t\t: {}),\n\t\t// Forward multimodal image data — Ollama accepts a base64 `images` array on a\n\t\t// message, which a vision-capable model receives alongside the text content.\n\t\t...(message.images !== undefined && message.images.length > 0\n\t\t\t? { images: [...message.images] }\n\t\t\t: {}),\n\t}))\n}\n\n/**\n * Extracts the assistant text of one wire record.\n *\n * @param record - One parsed `/api/chat` NDJSON record\n * @returns The record's `message.content` when it is a string, else `''`\n *\n * @example\n * ```ts\n * extractContent({ message: { content: 'ok' } }) // 'ok'\n * ```\n */\nexport function extractContent(record: Readonly<Record<string, unknown>>): string {\n\tconst message = Reflect.get(record, 'message')\n\tif (!isRecord(message)) return ''\n\tconst content = Reflect.get(message, 'content')\n\treturn isString(content) ? content : ''\n}\n\n/**\n * Extracts the daemon-side reasoning of one wire record.\n *\n * @remarks\n * `message.thinking` is the `think: true` wire shape. It is read whatever the configured\n * flag says, because a daemon may separate reasoning on its own.\n *\n * @param record - One parsed `/api/chat` NDJSON record\n * @returns The record's `message.thinking` when it is a string, else `''`\n *\n * @example\n * ```ts\n * extractThinking({ message: { thinking: 'weighing it' } }) // 'weighing it'\n * ```\n */\nexport function extractThinking(record: Readonly<Record<string, unknown>>): string {\n\tconst message = Reflect.get(record, 'message')\n\tif (!isRecord(message)) return ''\n\tconst thinking = Reflect.get(message, 'thinking')\n\treturn isString(thinking) ? thinking : ''\n}\n\n/**\n * Extracts the token usage of one wire record.\n *\n * @remarks\n * Both counts must be numbers, which is true of the stream's `done: true` line. A\n * delta line carries neither, so it yields `undefined`.\n *\n * @param record - One parsed `/api/chat` NDJSON record\n * @returns The `TokenUsage` shape, or `undefined` when either count is absent\n *\n * @example\n * ```ts\n * extractUsage({ prompt_eval_count: 3, eval_count: 4 })\n * // { prompt: 3, completion: 4, total: 7 }\n * ```\n */\nexport function extractUsage(record: Readonly<Record<string, unknown>>): TokenUsage | undefined {\n\tconst prompt = Reflect.get(record, 'prompt_eval_count')\n\tconst completion = Reflect.get(record, 'eval_count')\n\tif (!isNumber(prompt) || !isNumber(completion)) return undefined\n\treturn { prompt, completion, total: prompt + completion }\n}\n\n/**\n * Extracts the tool calls of one wire record's `message.tool_calls`.\n *\n * @remarks\n * Each entry narrows to `{ id, name, arguments }`: the entry and its `function` must be\n * records and `name` a string, else the entry is dropped. An id is minted when the wire\n * omits one.\n *\n * @param record - One parsed `/api/chat` NDJSON record\n * @returns The narrowed tool calls, empty when the record carries none\n *\n * @example\n * ```ts\n * extractTools({ message: { tool_calls: [{ function: { name: 'weather' } }] } })\n * // [{ id: '…', name: 'weather', arguments: {} }]\n * ```\n */\nexport function extractTools(record: Readonly<Record<string, unknown>>): readonly ToolCall[] {\n\tconst message = Reflect.get(record, 'message')\n\tif (!isRecord(message)) return []\n\tconst calls = Reflect.get(message, 'tool_calls')\n\tif (!Array.isArray(calls)) return []\n\tconst out: ToolCall[] = []\n\tfor (const entry of calls) {\n\t\tif (!isRecord(entry)) continue\n\t\tconst callable = Reflect.get(entry, 'function')\n\t\tif (!isRecord(callable)) continue\n\t\tconst name = Reflect.get(callable, 'name')\n\t\tif (!isString(name)) continue\n\t\tconst id = Reflect.get(entry, 'id')\n\t\tout.push({\n\t\t\tid: isString(id) ? id : crypto.randomUUID(),\n\t\t\tname,\n\t\t\targuments: extractArguments(Reflect.get(callable, 'arguments')),\n\t\t})\n\t}\n\treturn out\n}\n\n/**\n * Extracts a wire `arguments` value as a record.\n *\n * @remarks\n * Total: an object passes through, a JSON string is parsed when it yields a record, and\n * a malformed string yields `{}` rather than throwing.\n *\n * @param value - The wire's `function.arguments` value, of unknown shape\n * @returns The argument record, or `{}` when the value carries none\n *\n * @example\n * ```ts\n * extractArguments('{\"city\":\"Oslo\"}') // { city: 'Oslo' }\n * ```\n */\nexport function extractArguments(value: unknown): Readonly<Record<string, unknown>> {\n\tif (isRecord(value)) return value\n\tif (isString(value)) return parseJSONAs(value, isRecord) ?? {}\n\treturn {}\n}\n","import type {\n\tAgentProviderInterface,\n\tProviderIncrement,\n\tProviderParserInterface,\n\tProviderRequest,\n} from '@orkestrel/agent'\nimport type { OllamaOptions, WireChatRequest } from './types.js'\nimport { AgentProvider } from '@orkestrel/agent'\nimport { createNDJSONParser } from '@orkestrel/ndjson'\nimport { DEFAULT_KEEP_ALIVE, DEFAULT_OLLAMA_URL, OLLAMA_CHAT_PATH } from './constants.js'\nimport {\n\textractContent,\n\textractThinking,\n\textractTools,\n\textractUsage,\n\tmapMessages,\n} from './helpers.js'\n\n/**\n * Implements the Ollama `/api/chat` wire over the shared {@link AgentProvider} engine.\n *\n * @remarks\n * Every request uses NDJSON streaming. The base assembles complete turns, separates\n * reasoning, and bounds requests; this class supplies Ollama framing and projections.\n * Usage comes only from a `done: true` record carrying the token counts.\n *\n * @example\n * ```ts\n * const provider = new OllamaProvider({ model: 'qwen3.5:2b-q4_K_M' })\n * const result = await provider.generate(messages, abort.signal)\n * ```\n */\nexport class OllamaProvider extends AgentProvider implements AgentProviderInterface {\n\treadonly name = 'ollama'\n\treadonly #model: string\n\treadonly #keepAlive: string | number\n\treadonly #think: boolean\n\treadonly #options: Readonly<Record<string, unknown>> | undefined\n\n\tconstructor(options: OllamaOptions) {\n\t\tsuper({\n\t\t\turl: options.url ?? DEFAULT_OLLAMA_URL,\n\t\t\tpath: OLLAMA_CHAT_PATH,\n\t\t\t...(options.timeout === undefined ? {} : { timeout: options.timeout }),\n\t\t\t...(options.fetch === undefined ? {} : { fetch: options.fetch }),\n\t\t\t...(options.headers === undefined ? {} : { headers: options.headers }),\n\t\t\t...(options.format === undefined ? {} : { format: options.format }),\n\t\t})\n\t\tthis.#model = options.model\n\t\tthis.#keepAlive = options.keepAlive ?? DEFAULT_KEEP_ALIVE\n\t\tthis.#think = options.think ?? false\n\t\tthis.#options = options.options\n\t}\n\n\t/**\n\t * Creates fresh NDJSON framing state for a call.\n\t *\n\t * @returns The parser that buffers incomplete Ollama records\n\t */\n\tframe(): ProviderParserInterface {\n\t\treturn createNDJSONParser()\n\t}\n\n\t/**\n\t * Projects conversation turns and per-call options onto the Ollama request body.\n\t *\n\t * @param request - The conversation, advertised tools, and per-call overrides\n\t * @returns The `/api/chat` body with streaming enabled\n\t */\n\tbody(request: ProviderRequest): WireChatRequest {\n\t\treturn {\n\t\t\tmodel: this.#model,\n\t\t\tmessages: mapMessages(request.messages),\n\t\t\tstream: true,\n\t\t\tkeep_alive: this.#keepAlive,\n\t\t\tthink: request.options?.think ?? this.#think,\n\t\t\t...(this.#options !== undefined ? { options: this.#options } : {}),\n\t\t\t...(request.options?.schema !== undefined ? { format: request.options.schema } : {}),\n\t\t\t...(request.tools !== undefined && request.tools.length > 0\n\t\t\t\t? {\n\t\t\t\t\t\ttools: request.tools.map((tool): NonNullable<WireChatRequest['tools']>[number] => ({\n\t\t\t\t\t\t\ttype: 'function',\n\t\t\t\t\t\t\tfunction: {\n\t\t\t\t\t\t\t\tname: tool.name,\n\t\t\t\t\t\t\t\t...(tool.description === undefined ? {} : { description: tool.description }),\n\t\t\t\t\t\t\t\t...(tool.parameters === undefined ? {} : { parameters: tool.parameters }),\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t})),\n\t\t\t\t\t}\n\t\t\t\t: {}),\n\t\t}\n\t}\n\n\t/**\n\t * Extracts a record's content, reasoning, tools, and completed usage report.\n\t *\n\t * @param record - One parsed Ollama NDJSON record\n\t * @returns The turn increment, omitting usage until `done` and the counts are present\n\t */\n\tread(record: Readonly<Record<string, unknown>>): ProviderIncrement {\n\t\tconst usage = Reflect.get(record, 'done') === true ? extractUsage(record) : undefined\n\t\treturn {\n\t\t\tcontent: extractContent(record),\n\t\t\tthinking: extractThinking(record),\n\t\t\ttools: extractTools(record),\n\t\t\t...(usage === undefined ? {} : { usage }),\n\t\t}\n\t}\n\n\t/**\n\t * Recovers a final NDJSON record that arrived without its line terminator.\n\t *\n\t * @param parser - The call's parser holding any unterminated input\n\t * @returns The records completed by the final newline\n\t */\n\tfinish(parser: ProviderParserInterface): ReadonlyArray<Readonly<Record<string, unknown>>> {\n\t\treturn parser.parse('\\n')\n\t}\n}\n","import type { ProviderInterface } from '@orkestrel/agent'\nimport type { OllamaOptions } from './types.js'\nimport { OllamaProvider } from './OllamaProvider.js'\n\n/**\n * Creates a local Ollama inference provider — a {@link ProviderInterface} over the\n * daemon's `POST /api/chat`, assembling `generate` from the same NDJSON engine as `stream`.\n *\n * @remarks\n * Only `model` is required; `url` defaults to the local daemon, `keepAlive` to `'5m'`,\n * `timeout` to `120_000`ms, and `options` is forwarded verbatim as sampling\n * parameters (`temperature`, `seed`, and `num_predict`). Each call takes an\n * `AbortSignal` to bound the request; a `stream` cancelled mid-flight throws a\n * `ProviderAbortError` carrying the partial result.\n *\n * The optional `fetch` + `headers` form a transport seam (see {@link OllamaOptions}):\n * point `url` at your own server, inject a custom `fetch`, and have `headers` attach a\n * generated/obfuscated bearer token your server validates — so a browser runtime\n * reaches the LLM through your middleware without this library ever handling the real API\n * key. Both omitted ⇒ the global `fetch` and only a JSON content type.\n *\n * The optional `format` is the provider's context-framing default — the provider-default\n * level of `AgentContext`'s format cascade (beaten by a manager-options or per-item\n * override, beating the managers' built-in framing), declaring how this\n * provider's models prefer context sections framed (for example XML group wrappers vs. Markdown\n * headers). It is exposed on the provider for the Agent's `build()` and is not Ollama's\n * `/api/chat` `format` wire parameter (structured output) — the framing default and that\n * wire parameter are unrelated despite the shared word. Omitted ⇒ the provider is\n * framing-agnostic (core's built-in defaults).\n *\n * @param options - `model` (required), and optional `url` / `keepAlive` / `timeout` /\n *   `options` / `fetch` / `headers` / `format` (see {@link OllamaOptions})\n * @returns A working {@link ProviderInterface} backed by Ollama\n *\n * @example createOllama + generate\n * ```ts\n * import { createAbort } from '@orkestrel/abort'\n * import type { TokenUsage } from '@orkestrel/budget'\n * import { createOllama } from '@orkestrel/ollama'\n *\n * declare function charge(usage: TokenUsage): void // your billing integration\n *\n * const provider = createOllama({ model: 'qwen3.5:2b-q4_K_M', options: { temperature: 0 } })\n * const abort = createAbort()\n * const messages = [\n * \t{ id: '1', role: 'user', content: 'Summarize the release notes for version 2.0.' },\n * ] as const\n *\n * const result = await provider.generate(messages, abort.signal)\n * console.log(result.content)\n * if (result.usage) charge(result.usage) // fold into a token budget\n * ```\n *\n * @example\n * Route through your own server with an obfuscated token:\n * ```ts\n * const provider = createOllama({\n *   model: 'qwen3.5:2b-q4_K_M',\n *   url: 'https://my-app.example.com/llm', // your server, not the daemon\n *   fetch: myFetch, // optional custom transport\n *   headers: () => ({ authorization: `Bearer ${myToken}` }), // your server validates this\n * })\n * ```\n *\n * @example\n * Declare a context-framing default — wrap the instructions section in an XML group (the\n * provider-default level of `AgentContext`'s cascade; not the wire `format`):\n * ```ts\n * const provider = createOllama({\n *   model: 'qwen3.5:2b-q4_K_M',\n *   format: {\n *     instructions: {\n *       open: '<instructions>',\n *       render: (i) => `<instruction>${i.content}</instruction>`,\n *       close: '</instructions>',\n *     },\n *   },\n * })\n * ```\n */\nexport function createOllama(options: OllamaOptions): ProviderInterface {\n\treturn new OllamaProvider(options)\n}\n"],"mappings":"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"}