@nhtio/adk 1.20260607.2 → 1.20260609.1

package/batteries/llm/ollama/adapter.mjs

@@ -0,0 +1,734 @@
+import { a as Tokenizable, c as isObject, n as canonicalStringify, o as isError, s as isInstanceOf, t as ToolRegistry } from "../../../tool_registry-791Vrjtf.mjs";
+import { n as Message, t as Thought } from "../../../thought-B_vxAiKU.mjs";
+import { i as ArtifactTool, t as SpooledArtifact } from "../../../spooled_artifact-7eePq7JA.mjs";
+import "../../../common-DYDUi99O.mjs";
+import { n as Media, t as ToolCall } from "../../../tool_call-B4-_-vjG.mjs";
+import "../../../guards.mjs";
+import { computeBackoff, linkAbortSignals, parseRetryAfter, sleepWithJitter } from "../../../lib/utils/retry.mjs";
+import { InMemorySpoolStore } from "../../storage/in_memory.mjs";
+import { a as defaultRenderMemories, c as defaultRenderStandingInstructions, d as defaultRenderThought, f as defaultRenderTrustedContent, i as defaultRenderFirstPartyRetrievables, l as defaultRenderThirdPartyPrivateRetrievables, m as defaultToolsToChatCompletionsTools, n as defaultFilterThoughts, o as defaultRenderRetrievableSafetyDirective, p as defaultRenderUntrustedContent, r as defaultRenderChatCompletionsSystemPrompt, s as defaultRenderRetrievables, t as defaultDescriptionToChatCompletionsJsonSchema, u as defaultRenderThirdPartyPublicRetrievables } from "../../../helpers-xhrQbMAG.mjs";
+import { E_INVALID_OLLAMA_OPTIONS, E_OLLAMA_CONTEXT_OVERFLOW, E_OLLAMA_HTTP_ERROR, E_OLLAMA_INVALID_TOOL_CALL_ARGS, E_OLLAMA_REQUEST_TIMEOUT, E_OLLAMA_STREAM_ERROR, E_OLLAMA_STREAM_STALLED } from "./exceptions.mjs";
+import { validateOptions } from "./validation.mjs";
+import { defaultBuildOllamaHistory, defaultRenderOllamaTimelineMessage, defaultRenderOllamaToolCallResult, ollamaToolsFromTools } from "./helpers.mjs";
+import { DateTime } from "luxon";
+import { sha256 } from "js-sha256";
+import { v6 } from "uuid";
+//#region src/batteries/llm/ollama/adapter.ts
+/**
+* Cross-environment executor adapter for the native Ollama `/api/chat` endpoint.
+*
+* @module @nhtio/adk/batteries/llm/ollama/adapter
+*
+* @remarks
+* Native Ollama LLM adapter targeting `/api/chat` (NOT the OpenAI-compat `/v1` layer — the
+* `openai_chat_completions` battery already covers `/v1`). Works against both LOCAL Ollama
+* (`http://localhost:11434`, no auth) and CLOUD Ollama (`https://ollama.com`, `Authorization:
+* Bearer <apiKey>`); the only difference is `baseURL` + the auth header. Native is HTTP-only — a
+* Unix-socket deployment is reached via a custom `fetch` or an external bridge, not an adapter
+* option.
+*
+* Structurally a sibling of the OpenAI Chat Completions adapter, with the native-wire divergences:
+*
+* - Request body: generation params are NESTED under `options`; `think` / `format` / `keep_alive`
+*   are top-level native controls; ADK control fields are stripped before sending.
+* - Streaming: NDJSON (newline-delimited JSON objects), terminated in-band by `done: true` — there
+*   is no SSE `data:` framing and no `[DONE]` sentinel. Whole `tool_calls` arrive per chunk (no
+*   delta accumulation).
+* - Reasoning: the single native `message.thinking` field (no multi-field precedence dance).
+* - Tool calls: `arguments` is already a JSON OBJECT (no `JSON.parse`); native calls carry no `id`,
+*   so the adapter synthesizes one (uuidv6) for correlation / checksum / spool keying. Tool-result
+*   history messages use `tool_name` (the originating tool), not `tool_call_id`.
+* - Generation stats: the terminal `done: true` object's token counts + nanosecond durations +
+*   `done_reason` are surfaced via `helpers.reportGenerationStats`.
+*/
+var mergeRecord = (layers) => {
+	let merged;
+	for (const layer of layers) {
+		if (!layer) continue;
+		merged = {
+			...merged ?? {},
+			...layer
+		};
+	}
+	return merged;
+};
+var mergeOptions = (baseline, exec, stash) => {
+	const layers = [
+		baseline,
+		exec ?? {},
+		stash ?? {}
+	];
+	const out = {};
+	for (const layer of layers) for (const [k, v] of Object.entries(layer)) {
+		if (v === void 0) continue;
+		if (k === "headers" || k === "helpers" || k === "retry" || k === "options") continue;
+		out[k] = v;
+	}
+	const headers = mergeRecord(layers.map((l) => l.headers));
+	if (headers !== void 0) out.headers = headers;
+	const helpers = mergeRecord(layers.map((l) => l.helpers));
+	if (helpers !== void 0) out.helpers = helpers;
+	const retry = mergeRecord(layers.map((l) => l.retry));
+	if (retry !== void 0) out.retry = retry;
+	const runtime = mergeRecord(layers.map((l) => l.options));
+	if (runtime !== void 0) out.options = runtime;
+	return out;
+};
+var resolveHelpers = (overrides) => {
+	const src = overrides ?? {};
+	return {
+		descriptionToChatCompletionsJsonSchema: src.descriptionToChatCompletionsJsonSchema ?? defaultDescriptionToChatCompletionsJsonSchema,
+		renderUntrustedContent: src.renderUntrustedContent ?? defaultRenderUntrustedContent,
+		renderTrustedContent: src.renderTrustedContent ?? defaultRenderTrustedContent,
+		renderStandingInstructions: src.renderStandingInstructions ?? defaultRenderStandingInstructions,
+		renderMemories: src.renderMemories ?? defaultRenderMemories,
+		renderRetrievables: src.renderRetrievables ?? defaultRenderRetrievables,
+		renderRetrievableSafetyDirective: src.renderRetrievableSafetyDirective ?? defaultRenderRetrievableSafetyDirective,
+		renderFirstPartyRetrievables: src.renderFirstPartyRetrievables ?? defaultRenderFirstPartyRetrievables,
+		renderThirdPartyPublicRetrievables: src.renderThirdPartyPublicRetrievables ?? defaultRenderThirdPartyPublicRetrievables,
+		renderThirdPartyPrivateRetrievables: src.renderThirdPartyPrivateRetrievables ?? defaultRenderThirdPartyPrivateRetrievables,
+		renderThought: src.renderThought ?? defaultRenderThought,
+		filterThoughts: src.filterThoughts ?? defaultFilterThoughts,
+		toolsToChatCompletionsTools: src.toolsToChatCompletionsTools ?? defaultToolsToChatCompletionsTools,
+		renderChatCompletionsSystemPrompt: src.renderChatCompletionsSystemPrompt ?? defaultRenderChatCompletionsSystemPrompt,
+		renderOllamaTimelineMessage: src.renderOllamaTimelineMessage ?? defaultRenderOllamaTimelineMessage,
+		renderOllamaToolCallResult: src.renderOllamaToolCallResult ?? defaultRenderOllamaToolCallResult,
+		buildOllamaHistory: src.buildOllamaHistory ?? defaultBuildOllamaHistory
+	};
+};
+var computeChecksum = (tool, args) => sha256(canonicalStringify({
+	tool,
+	args
+}));
+var nowIso = () => DateTime.now().toISO() ?? (/* @__PURE__ */ new Date()).toISOString();
+var estimateTokensOf = async (value, encoding) => Promise.resolve(value.estimateTokens(encoding));
+var extractGenerationStats = (src, model) => {
+	const stats = {
+		provider: "ollama",
+		model: src.model ?? model,
+		raw: { ...src }
+	};
+	if (typeof src.prompt_eval_count === "number") stats.promptTokens = src.prompt_eval_count;
+	if (typeof src.eval_count === "number") stats.completionTokens = src.eval_count;
+	if (typeof src.prompt_eval_count === "number" && typeof src.eval_count === "number") stats.totalTokens = src.prompt_eval_count + src.eval_count;
+	if (typeof src.total_duration === "number") stats.totalDurationNs = src.total_duration;
+	if (typeof src.load_duration === "number") stats.loadDurationNs = src.load_duration;
+	if (typeof src.prompt_eval_duration === "number") stats.promptEvalDurationNs = src.prompt_eval_duration;
+	if (typeof src.eval_duration === "number") stats.evalDurationNs = src.eval_duration;
+	if (typeof src.done_reason === "string") stats.finishReason = src.done_reason;
+	return stats;
+};
+/**
+* Opinionated cross-environment LLM adapter for the native Ollama `/api/chat` wire shape.
+*
+* @remarks
+* Construction validates options eagerly via {@link validateOptions} and throws
+* {@link @nhtio/adk/batteries/llm/ollama!E_INVALID_OLLAMA_OPTIONS} on failure. The returned instance is reusable: call
+* {@link OllamaAdapter.executor} once per `DispatchRunner` configuration to obtain a
+* {@link @nhtio/adk!DispatchExecutorFn} bound to the baseline plus optional executor-scope
+* overrides. Per-iteration overrides live on `ctx.stash.ollama` and take highest precedence;
+* `headers`, `helpers`, `retry`, and the nested runtime `options` merge key-by-key across all three
+* layers, every other field is replaced wholesale at the highest layer that sets it.
+*/
+var OllamaAdapter = class OllamaAdapter {
+	/** Customary key for per-iteration overrides on `ctx.stash`. */
+	static STASH_KEY = "ollama";
+	#baseline;
+	/**
+	* @param options - Constructor-baseline options. Re-validated on every iteration after
+	*   per-dispatch and per-iteration overrides are layered in.
+	* @throws {@link @nhtio/adk/batteries/llm/ollama!E_INVALID_OLLAMA_OPTIONS} when `options` does not satisfy `ollamaOptionsSchema`.
+	*/
+	constructor(options) {
+		this.#baseline = validateOptions(options);
+	}
+	/**
+	* Returns a {@link @nhtio/adk!DispatchExecutorFn} bound to this adapter's baseline plus optional
+	* executor-scope overrides.
+	*
+	* @param overrides - Optional executor-scope overrides. Higher precedence than the baseline,
+	*   lower precedence than `ctx.stash[STASH_KEY]`.
+	*/
+	executor(overrides) {
+		const baseline = this.#baseline;
+		const adapterClass = OllamaAdapter;
+		return async (ctx, helpers) => {
+			const localWarn = (msg) => {
+				helpers.log.warn({
+					kind: "helper-warning",
+					message: msg
+				});
+			};
+			const stashRaw = ctx.stash.get(adapterClass.STASH_KEY, {});
+			const merged = validateOptions(mergeOptions(baseline, overrides, stashRaw && typeof stashRaw === "object" ? stashRaw : {}));
+			if (merged.tokenEncoding !== null && merged.contextWindow === void 0) throw new E_INVALID_OLLAMA_OPTIONS(["tokenEncoding is non-null but contextWindow is undefined"]);
+			const resolvedHelpers = resolveHelpers(merged.helpers);
+			const uniqueCtors = /* @__PURE__ */ new Set();
+			for (const tc of ctx.turnToolCalls) {
+				const ctor = tc.results?.constructor;
+				if (ctor && SpooledArtifact.isSpooledArtifactConstructor(ctor)) uniqueCtors.add(ctor);
+			}
+			const forgedRegistries = [];
+			for (const ctor of uniqueCtors) {
+				const forgeFn = ctor.forgeTools;
+				if (typeof forgeFn === "function") forgedRegistries.push(forgeFn.call(ctor, ctx));
+			}
+			const mergedRegistry = ToolRegistry.merge([ctx.tools, ...forgedRegistries], { onCollision: "replace" });
+			mergedRegistry.bindContext(ctx);
+			const renderedToolCallResults = /* @__PURE__ */ new Map();
+			for (const tc of ctx.turnToolCalls) {
+				const rendered = await resolvedHelpers.renderOllamaToolCallResult({
+					toolCall: tc,
+					results: tc.results,
+					tool: mergedRegistry.get(tc.tool),
+					renderUntrustedContent: resolvedHelpers.renderUntrustedContent,
+					renderTrustedContent: resolvedHelpers.renderTrustedContent,
+					unsupportedMediaPolicy: merged.unsupportedMediaPolicy ?? "throw",
+					warn: localWarn
+				});
+				renderedToolCallResults.set(tc.id, rendered);
+			}
+			if (merged.tokenEncoding !== null && merged.contextWindow !== void 0) {
+				const encoding = merged.tokenEncoding;
+				let spTokens = await estimateTokensOf(ctx.systemPrompt, encoding);
+				let siTokens = 0;
+				for (const si of ctx.standingInstructions) siTokens += await estimateTokensOf(si, encoding);
+				let memTokens = 0;
+				for (const mem of ctx.turnMemories) memTokens += await estimateTokensOf(mem.content, encoding);
+				let retTokens = 0;
+				for (const r of ctx.turnRetrievables) retTokens += await estimateTokensOf(r.content, encoding);
+				let tlTokens = 0;
+				for (const msg of ctx.turnMessages) if (msg.content !== void 0) tlTokens += await estimateTokensOf(msg.content, encoding);
+				for (const th of ctx.turnThoughts) tlTokens += await estimateTokensOf(th.content, encoding);
+				for (const rendered of renderedToolCallResults.values()) tlTokens += await estimateTokensOf(new Tokenizable(rendered), encoding);
+				const total = spTokens + siTokens + memTokens + retTokens + tlTokens;
+				const perBucketObj = {
+					systemPrompt: spTokens,
+					standingInstructions: siTokens,
+					memories: memTokens,
+					retrievables: retTokens,
+					timeline: tlTokens
+				};
+				helpers.log.debug({
+					kind: "context-window-usage",
+					message: `Context window usage: ${total}/${merged.contextWindow} tokens`,
+					payload: {
+						total,
+						limit: merged.contextWindow,
+						encoding,
+						perBucket: perBucketObj
+					}
+				});
+				if (total > merged.contextWindow) throw new E_OLLAMA_CONTEXT_OVERFLOW([
+					total,
+					merged.contextWindow,
+					encoding,
+					JSON.stringify(perBucketObj)
+				]);
+			}
+			const { messages: wireMessages, reasoningPayloads } = await resolvedHelpers.buildOllamaHistory({
+				systemPrompt: ctx.systemPrompt,
+				standingInstructions: ctx.standingInstructions,
+				memories: ctx.turnMemories,
+				retrievables: ctx.turnRetrievables,
+				messages: ctx.turnMessages,
+				thoughts: ctx.turnThoughts,
+				toolCalls: ctx.turnToolCalls,
+				tools: mergedRegistry,
+				renderedToolCallResults,
+				bucketOrder: merged.bucketOrder ?? [
+					"standingInstructions",
+					"memories",
+					"retrievables",
+					"timeline"
+				],
+				selfIdentity: merged.selfIdentity ?? "assistant",
+				thoughtSurfacing: merged.thoughtSurfacing ?? "all-self",
+				replayCompatibility: merged.replayCompatibility ?? [],
+				renderOllamaToolCallResult: resolvedHelpers.renderOllamaToolCallResult,
+				renderChatCompletionsSystemPrompt: resolvedHelpers.renderChatCompletionsSystemPrompt,
+				renderStandingInstructions: resolvedHelpers.renderStandingInstructions,
+				renderMemories: resolvedHelpers.renderMemories,
+				renderRetrievables: resolvedHelpers.renderRetrievables,
+				renderRetrievableSafetyDirective: resolvedHelpers.renderRetrievableSafetyDirective,
+				renderFirstPartyRetrievables: resolvedHelpers.renderFirstPartyRetrievables,
+				renderThirdPartyPublicRetrievables: resolvedHelpers.renderThirdPartyPublicRetrievables,
+				renderThirdPartyPrivateRetrievables: resolvedHelpers.renderThirdPartyPrivateRetrievables,
+				renderOllamaTimelineMessage: resolvedHelpers.renderOllamaTimelineMessage,
+				renderThought: resolvedHelpers.renderThought,
+				filterThoughts: resolvedHelpers.filterThoughts,
+				renderUntrustedContent: resolvedHelpers.renderUntrustedContent,
+				renderTrustedContent: resolvedHelpers.renderTrustedContent,
+				unsupportedMediaPolicy: merged.unsupportedMediaPolicy ?? "throw",
+				warn: localWarn
+			});
+			const stream = merged.stream ?? true;
+			const body = {
+				model: merged.model,
+				messages: wireMessages,
+				stream
+			};
+			if (merged.think !== void 0) body.think = merged.think;
+			if (merged.format !== void 0) body.format = merged.format;
+			if (merged.keep_alive !== void 0) body.keep_alive = merged.keep_alive;
+			if (merged.options !== void 0) body.options = merged.options;
+			const toolsArr = mergedRegistry.visible();
+			if (toolsArr.length > 0) body.tools = ollamaToolsFromTools(toolsArr, { descriptionToChatCompletionsJsonSchema: resolvedHelpers.descriptionToChatCompletionsJsonSchema });
+			if (reasoningPayloads.length > 0) body._adk_reasoning_payloads = reasoningPayloads;
+			const rawBase = merged.baseURL ?? "http://localhost:11434";
+			const url = `${rawBase.endsWith("/") ? rawBase.slice(0, -1) : rawBase}/api/chat`;
+			const headers = { "Content-Type": "application/json" };
+			if (stream) headers["Accept"] = "application/x-ndjson";
+			if (merged.apiKey) headers["Authorization"] = `Bearer ${merged.apiKey}`;
+			if (merged.headers) Object.assign(headers, merged.headers);
+			const retryCfg = {
+				maxAttempts: merged.retry?.maxAttempts ?? 1,
+				baseDelayMs: merged.retry?.baseDelayMs ?? 500,
+				maxDelayMs: merged.retry?.maxDelayMs ?? 3e4,
+				retriableStatuses: merged.retry?.retriableStatuses ?? [
+					429,
+					502,
+					503,
+					504
+				],
+				honorRetryAfter: merged.retry?.honorRetryAfter ?? true
+			};
+			const fetchFn = merged.fetch ?? globalThis.fetch;
+			const maxAttempts = retryCfg.maxAttempts;
+			let response;
+			let attempt = 1;
+			let disposeLink = () => {};
+			while (attempt <= maxAttempts) {
+				if (ctx.abortSignal.aborted) return;
+				const internalController = new AbortController();
+				let timeoutHandle;
+				const requestTimeoutMs = merged.requestTimeoutMs ?? 0;
+				if (requestTimeoutMs > 0) timeoutHandle = setTimeout(() => internalController.abort(), requestTimeoutMs);
+				disposeLink();
+				const { signal: linkedSignal, dispose: disposeCurrentLink } = linkAbortSignals([ctx.abortSignal, internalController.signal]);
+				disposeLink = disposeCurrentLink;
+				try {
+					response = await fetchFn(url, {
+						method: "POST",
+						headers,
+						body: JSON.stringify(body),
+						signal: linkedSignal
+					});
+				} catch (err) {
+					if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
+					if (ctx.abortSignal.aborted) return;
+					if (internalController.signal.aborted) {
+						helpers.log.warn({
+							kind: "request-timeout",
+							message: `Request timed out after ${requestTimeoutMs}ms on attempt ${attempt}/${maxAttempts}`,
+							payload: {
+								requestTimeoutMs,
+								attempt,
+								maxAttempts
+							}
+						});
+						if (attempt < maxAttempts) {
+							await sleepWithJitter(computeBackoff(attempt, retryCfg), ctx.abortSignal);
+							attempt += 1;
+							continue;
+						}
+						ctx.nack(new E_OLLAMA_REQUEST_TIMEOUT([requestTimeoutMs]));
+						return;
+					}
+					helpers.log.error({
+						kind: "transport-error",
+						message: `Transport failure on attempt ${attempt}/${maxAttempts}: ${isError(err) ? err.message : String(err)}`,
+						payload: {
+							attempt,
+							maxAttempts,
+							detail: isError(err) ? err.message : String(err)
+						}
+					});
+					ctx.nack(new E_OLLAMA_HTTP_ERROR([0, isError(err) ? err.message : String(err)]));
+					return;
+				}
+				if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
+				if (!response.ok) {
+					const status = response.status;
+					const retriable = retryCfg.retriableStatuses.includes(status);
+					if (retriable && attempt < maxAttempts) {
+						let delay = computeBackoff(attempt, retryCfg);
+						if (retryCfg.honorRetryAfter !== false) {
+							const ra = response.headers.get("Retry-After");
+							if (ra) {
+								const raMs = parseRetryAfter(ra);
+								if (raMs > 0) delay = Math.min(Math.max(delay, raMs), retryCfg.maxDelayMs);
+							}
+						}
+						helpers.log.warn({
+							kind: "retry-attempt",
+							message: `HTTP ${status} on attempt ${attempt}/${maxAttempts}; retrying in ~${delay}ms`,
+							payload: {
+								reason: "http-status",
+								status,
+								delayMs: delay,
+								attempt: attempt + 1,
+								maxAttempts
+							}
+						});
+						await sleepWithJitter(delay, ctx.abortSignal);
+						attempt += 1;
+						continue;
+					}
+					const errBody = await response.text().catch(() => "");
+					helpers.log.error({
+						kind: "http-error",
+						message: `HTTP ${status} (terminal): ${errBody.slice(0, 256)}`,
+						payload: {
+							status,
+							body: errBody,
+							attempt,
+							maxAttempts,
+							retriable
+						}
+					});
+					ctx.nack(new E_OLLAMA_HTTP_ERROR([status, errBody]));
+					return;
+				}
+				break;
+			}
+			if (!response) return;
+			const spoolStore = merged.spoolStore ?? new InMemorySpoolStore();
+			const selfIdentity = merged.selfIdentity ?? "assistant";
+			const executeAndPersistToolCall = async (call) => {
+				const tool = mergedRegistry.get(call.name);
+				let args = {};
+				let parseError;
+				if (isObject(call.args)) args = call.args;
+				else parseError = new E_OLLAMA_INVALID_TOOL_CALL_ARGS([`must be a JSON object; received ${Array.isArray(call.args) ? "array" : call.args === null ? "null" : typeof call.args}`, JSON.stringify(call.args)]);
+				const completedAt = nowIso();
+				if (parseError !== void 0) {
+					const results = new Tokenizable(parseError.message);
+					helpers.reportToolCall(call.id, {
+						tool: call.name,
+						args
+					});
+					helpers.reportToolCall(call.id, {
+						results,
+						isError: true,
+						isComplete: true
+					});
+					await ctx.storeToolCall(new ToolCall({
+						id: call.id,
+						tool: call.name,
+						args,
+						checksum: computeChecksum(call.name, args),
+						isComplete: true,
+						isError: true,
+						results,
+						createdAt: completedAt,
+						updatedAt: completedAt,
+						completedAt
+					}));
+					return;
+				}
+				if (!tool) {
+					const available = mergedRegistry.all().map((t) => t.name).sort();
+					const results = new Tokenizable(available.length > 0 ? `Tool not found: ${call.name}. Available tools: ${available.join(", ")}.` : `Tool not found: ${call.name}. No tools are available this turn.`);
+					helpers.reportToolCall(call.id, {
+						tool: call.name,
+						args
+					});
+					helpers.reportToolCall(call.id, {
+						results,
+						isError: true,
+						isComplete: true
+					});
+					await ctx.storeToolCall(new ToolCall({
+						id: call.id,
+						tool: call.name,
+						args,
+						checksum: computeChecksum(call.name, args),
+						isComplete: true,
+						isError: true,
+						results,
+						createdAt: completedAt,
+						updatedAt: completedAt,
+						completedAt
+					}));
+					return;
+				}
+				helpers.reportToolCall(call.id, {
+					tool: tool.name,
+					args
+				});
+				const isArtifactTool = ArtifactTool.isArtifactTool(tool);
+				let results = new Tokenizable("");
+				let toolHadError = false;
+				try {
+					const raw = await tool.executor(ctx)(args);
+					if (isArtifactTool) if (Tokenizable.isTokenizable(raw)) results = raw;
+					else if (typeof raw === "string") results = new Tokenizable(raw);
+					else throw new Error(`ArtifactTool "${tool.name}" returned a non-string/non-Tokenizable value`);
+					else if (Media.isMedia(raw)) results = raw;
+					else if (Array.isArray(raw) && raw.length > 0 && raw.every((m) => Media.isMedia(m))) results = raw;
+					else if (typeof raw === "string" || isInstanceOf(raw, "Uint8Array", Uint8Array)) {
+						const reader = await spoolStore.write(call.id, raw);
+						results = new ((tool.artifactConstructor?.()) ?? SpooledArtifact)(reader);
+					} else {
+						const reader = await spoolStore.write(call.id, String(raw));
+						results = new ((tool.artifactConstructor?.()) ?? SpooledArtifact)(reader);
+					}
+				} catch (err) {
+					toolHadError = true;
+					let detailMsg = isError(err) ? err.message : String(err);
+					if (isError(err) && isError(err.cause) && err.cause.message && err.cause.message !== err.message) detailMsg = `${detailMsg} ${err.cause.message}`;
+					results = new Tokenizable(detailMsg);
+				}
+				helpers.reportToolCall(call.id, {
+					results,
+					isError: toolHadError,
+					isComplete: true
+				});
+				const completedAt2 = nowIso();
+				await ctx.storeToolCall(new ToolCall({
+					id: call.id,
+					tool: tool.name,
+					args,
+					checksum: computeChecksum(tool.name, args),
+					isComplete: true,
+					isError: toolHadError,
+					results,
+					fromArtifactTool: isArtifactTool,
+					createdAt: completedAt2,
+					updatedAt: completedAt2,
+					completedAt: completedAt2
+				}));
+			};
+			if (stream) {
+				if (!response.body) {
+					ctx.nack(new E_OLLAMA_STREAM_ERROR(["response has no body"]));
+					return;
+				}
+				const reader = response.body.getReader();
+				const decoder = new TextDecoder();
+				const streamId = v6();
+				let buffer = "";
+				let idleTimer;
+				let stalled = false;
+				let partialMessageContent = "";
+				let sawMessageDelta = false;
+				let partialThinking = "";
+				let sawThinking = false;
+				let doneSeen = false;
+				const collectedToolCalls = [];
+				const thoughtStreamId = `${streamId}:thought`;
+				const idleMs = merged.streamIdleTimeoutMs ?? 0;
+				const armIdleTimer = () => {
+					if (idleMs <= 0) return;
+					if (idleTimer) clearTimeout(idleTimer);
+					idleTimer = setTimeout(() => {
+						stalled = true;
+						helpers.log.warn({
+							kind: "stream-idle-timeout",
+							message: `NDJSON stream went idle for ${idleMs}ms; cancelling`,
+							payload: { idleMs }
+						});
+						reader.cancel().catch(() => {});
+					}, idleMs);
+				};
+				const clearIdleTimer = () => {
+					if (idleTimer) {
+						clearTimeout(idleTimer);
+						idleTimer = void 0;
+					}
+				};
+				const drainAndPersist = async (statsSrc) => {
+					if (sawMessageDelta) {
+						helpers.reportMessage(streamId, "", { isComplete: true });
+						await ctx.storeMessage(new Message({
+							id: streamId,
+							role: "assistant",
+							content: partialMessageContent,
+							identity: selfIdentity,
+							createdAt: nowIso(),
+							updatedAt: nowIso()
+						}));
+					}
+					if (sawThinking) {
+						helpers.reportThought(thoughtStreamId, "", { isComplete: true });
+						await ctx.storeThought(new Thought({
+							id: thoughtStreamId,
+							content: partialThinking,
+							identity: selfIdentity,
+							createdAt: nowIso(),
+							updatedAt: nowIso()
+						}));
+					}
+					if (statsSrc !== void 0) helpers.reportGenerationStats(extractGenerationStats(statsSrc, merged.model));
+					if (collectedToolCalls.length === 0) {
+						if (merged.autoAck) ctx.ack();
+						return;
+					}
+					for (const call of collectedToolCalls) {
+						if (ctx.abortSignal.aborted) return;
+						await executeAndPersistToolCall(call);
+					}
+				};
+				const handleChunk = (chunk) => {
+					const m = chunk.message;
+					if (m) {
+						if (typeof m.content === "string" && m.content.length > 0) {
+							sawMessageDelta = true;
+							partialMessageContent += m.content;
+							helpers.reportMessage(streamId, m.content);
+						}
+						if (typeof m.thinking === "string" && m.thinking.length > 0) {
+							sawThinking = true;
+							partialThinking += m.thinking;
+							helpers.reportThought(thoughtStreamId, m.thinking);
+						}
+						if (Array.isArray(m.tool_calls)) for (const tc of m.tool_calls) collectedToolCalls.push({
+							id: v6(),
+							name: tc.function?.name ?? "",
+							args: tc.function?.arguments ?? {}
+						});
+					}
+				};
+				const parseLine = (line) => {
+					const trimmed = line.trim();
+					if (trimmed.length === 0) return void 0;
+					try {
+						return JSON.parse(trimmed);
+					} catch {
+						helpers.log.trace({
+							kind: "ndjson-parse-failure",
+							message: "Failed to parse NDJSON line as JSON; skipping",
+							payload: { linePreview: trimmed.slice(0, 256) }
+						});
+						return;
+					}
+				};
+				try {
+					armIdleTimer();
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						armIdleTimer();
+						if (ctx.abortSignal.aborted) {
+							clearIdleTimer();
+							return;
+						}
+						buffer += decoder.decode(value, { stream: true });
+						let nl = buffer.indexOf("\n");
+						while (nl !== -1) {
+							const line = buffer.slice(0, nl);
+							buffer = buffer.slice(nl + 1);
+							const chunk = parseLine(line);
+							if (chunk !== void 0) {
+								handleChunk(chunk);
+								if (chunk.done === true) {
+									doneSeen = true;
+									clearIdleTimer();
+									await drainAndPersist(chunk);
+									return;
+								}
+							}
+							nl = buffer.indexOf("\n");
+						}
+					}
+					clearIdleTimer();
+					if (stalled) {
+						ctx.nack(new E_OLLAMA_STREAM_STALLED([idleMs]));
+						return;
+					}
+					if (!doneSeen && buffer.trim().length > 0) {
+						const chunk = parseLine(buffer);
+						buffer = "";
+						if (chunk !== void 0) {
+							handleChunk(chunk);
+							if (chunk.done === true) {
+								await drainAndPersist(chunk);
+								return;
+							}
+						}
+					}
+					if (!doneSeen) {
+						helpers.log.warn({
+							kind: "ndjson-eof-without-done",
+							message: "NDJSON stream ended without a done:true chunk; draining accumulated state"
+						});
+						await drainAndPersist(void 0);
+					}
+				} catch (err) {
+					clearIdleTimer();
+					if (ctx.abortSignal.aborted) return;
+					if (stalled) {
+						ctx.nack(new E_OLLAMA_STREAM_STALLED([idleMs]));
+						return;
+					}
+					helpers.log.error({
+						kind: "stream-error",
+						message: `NDJSON stream failed: ${isError(err) ? err.message : String(err)}`,
+						payload: { detail: isError(err) ? err.message : String(err) }
+					});
+					ctx.nack(new E_OLLAMA_STREAM_ERROR([isError(err) ? err.message : String(err)]));
+					return;
+				}
+				return;
+			}
+			let parsed;
+			try {
+				parsed = await response.json();
+			} catch (err) {
+				ctx.nack(new E_OLLAMA_STREAM_ERROR([isError(err) ? err.message : String(err)]));
+				return;
+			}
+			const responseId = v6();
+			const msg = parsed.message;
+			if (msg && typeof msg.content === "string" && msg.content.length > 0) {
+				const messageId = `${responseId}:message`;
+				helpers.reportMessage(messageId, msg.content, { isComplete: true });
+				await ctx.storeMessage(new Message({
+					id: messageId,
+					role: "assistant",
+					content: msg.content,
+					identity: selfIdentity,
+					createdAt: nowIso(),
+					updatedAt: nowIso()
+				}));
+			}
+			if (msg && typeof msg.thinking === "string" && msg.thinking.length > 0) {
+				const thoughtId = `${responseId}:thought`;
+				helpers.reportThought(thoughtId, msg.thinking, { isComplete: true });
+				await ctx.storeThought(new Thought({
+					id: thoughtId,
+					content: msg.thinking,
+					identity: selfIdentity,
+					createdAt: nowIso(),
+					updatedAt: nowIso()
+				}));
+			}
+			helpers.reportGenerationStats(extractGenerationStats(parsed, merged.model));
+			const rawCalls = msg?.tool_calls ?? [];
+			if (rawCalls.length === 0) {
+				if (merged.autoAck) ctx.ack();
+				return;
+			}
+			const calls = rawCalls.map((tc) => ({
+				id: v6(),
+				name: tc.function?.name ?? "",
+				args: tc.function?.arguments ?? {}
+			}));
+			for (const call of calls) {
+				if (ctx.abortSignal.aborted) return;
+				await executeAndPersistToolCall(call);
+			}
+		};
+	}
+	/**
+	* Returns `true` when `value` is an {@link OllamaAdapter} instance.
+	*/
+	static isOllamaAdapter(value) {
+		return isInstanceOf(value, "OllamaAdapter", OllamaAdapter);
+	}
+};
+//#endregion
+export { OllamaAdapter };
+
+//# sourceMappingURL=adapter.mjs.map