@nhtio/adk 1.20260607.2 → 1.20260609.1

package/batteries/llm/ollama/helpers.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Swappable translation helpers for rendering ADK state into native Ollama `/api/chat` requests.
+ *
+ * @module @nhtio/adk/batteries/llm/ollama/helpers
+ *
+ * @remarks
+ * The wire-shape-agnostic helpers (`renderUntrustedContent`, `renderMemories`,
+ * `renderChatCompletionsSystemPrompt`, `toolsToChatCompletionsTools`, …) are shared with the OpenAI
+ * battery via the internal `../chat_common/helpers` submodule and re-exported here under their
+ * original names. Only the Ollama-WIRE-SPECIFIC helpers are defined here:
+ * `renderOllamaTimelineMessage` (flat `content` + base64 `images[]` + `thinking`),
+ * `renderOllamaToolCallResult` (string-only result content), `buildOllamaHistory` (synthetic
+ * `assistant.tool_calls` with object-form `arguments` + `tool`-role messages labelled by
+ * `tool_name`), and `ollamaToolsFromTools` (alias of the shared tool-definition renderer — native
+ * `/api/chat` uses the same function-tool wire shape).
+ *
+ * Native `/api/chat` supports only base64 `images[]`; every non-image modality routes through the
+ * `unsupportedMediaPolicy` fallback (stash text / synthetic description) or throws.
+ */
+import { Media } from "../../../common";
+import { toolsToChatCompletionsTools } from "../chat_common/helpers";
+import type { ChatHelpersCommon } from "../chat_common/types";
+import type { OllamaMessage, OllamaTool, OllamaHelpers, ChatCompletionsBucketOrder, UnsupportedMediaPolicy } from "./types";
+import type { Tool, ArtifactTool, ToolRegistry, Tokenizable, Memory, Message, Thought, ToolCall, Retrievable, SpooledArtifact } from "../../../common";
+export { descriptionToChatCompletionsJsonSchema, defaultDescriptionToChatCompletionsJsonSchema, renderUntrustedContent, defaultRenderUntrustedContent, renderTrustedContent, defaultRenderTrustedContent, renderStandingInstructions, defaultRenderStandingInstructions, renderMemories, defaultRenderMemories, renderRetrievableSafetyDirective, defaultRenderRetrievableSafetyDirective, renderFirstPartyRetrievables, defaultRenderFirstPartyRetrievables, renderThirdPartyPublicRetrievables, defaultRenderThirdPartyPublicRetrievables, renderThirdPartyPrivateRetrievables, defaultRenderThirdPartyPrivateRetrievables, renderRetrievables, defaultRenderRetrievables, renderThought, defaultRenderThought, filterThoughts, defaultFilterThoughts, toolsToChatCompletionsTools, defaultToolsToChatCompletionsTools, renderChatCompletionsSystemPrompt, defaultRenderChatCompletionsSystemPrompt, } from "../chat_common/helpers";
+/**
+ * Convert ADK tools to the native Ollama `tools[]` wire. Native `/api/chat` uses the identical
+ * `{ type: 'function', function: { name, description, parameters } }` shape as Chat Completions, so
+ * this is an alias of the shared renderer.
+ */
+export declare const ollamaToolsFromTools: (tools: ReadonlyArray<Tool | ArtifactTool>, deps: Parameters<typeof toolsToChatCompletionsTools>[1]) => OllamaTool[];
+/** Default implementation of {@link OllamaHelpers}-style tool translation; alias of {@link ollamaToolsFromTools}. */
+export declare const defaultOllamaToolsFromTools: (tools: ReadonlyArray<Tool | ArtifactTool>, deps: Parameters<typeof toolsToChatCompletionsTools>[1]) => OllamaTool[];
+/**
+ * Renders a single timeline {@link @nhtio/adk!Message} into a native Ollama message — flattening any
+ * media into the base64 `images[]` array, surfacing reasoning as `thinking`, and wrapping textual
+ * bodies in the appropriate trust envelope.
+ */
+export declare const renderOllamaTimelineMessage: (input: {
+    message: Message;
+    selfIdentity: string;
+    unsupportedMediaPolicy: UnsupportedMediaPolicy;
+    warn?: (msg: string) => void;
+}) => Promise<OllamaMessage>;
+/** Default timeline-message renderer; alias of {@link renderOllamaTimelineMessage}. */
+export declare const defaultRenderOllamaTimelineMessage: (input: {
+    message: Message;
+    selfIdentity: string;
+    unsupportedMediaPolicy: UnsupportedMediaPolicy;
+    warn?: (msg: string) => void;
+}) => Promise<OllamaMessage>;
+/**
+ * Render a tool-call result to native Ollama tool-message content (always a string). Media results
+ * are routed through the internal media renderer: images cannot ride on a tool-role message's
+ * `content`, so an image result is replaced with a short text marker (the image bytes are not
+ * re-sent on a tool message); non-image media use the same fallback-text path as elsewhere.
+ */
+export declare const renderOllamaToolCallResult: (input: {
+    toolCall: ToolCall;
+    results: Tokenizable | SpooledArtifact | SpooledArtifact[] | Media | Media[];
+    tool: Tool | ArtifactTool | undefined;
+    renderUntrustedContent: ChatHelpersCommon["renderUntrustedContent"];
+    renderTrustedContent: ChatHelpersCommon["renderTrustedContent"];
+    unsupportedMediaPolicy: UnsupportedMediaPolicy;
+    warn?: (msg: string) => void;
+}) => Promise<string>;
+/** Default tool-call-result renderer; alias of {@link renderOllamaToolCallResult}. */
+export declare const defaultRenderOllamaToolCallResult: (input: {
+    toolCall: ToolCall;
+    results: Tokenizable | SpooledArtifact | SpooledArtifact[] | Media | Media[];
+    tool: Tool | ArtifactTool | undefined;
+    renderUntrustedContent: ChatHelpersCommon["renderUntrustedContent"];
+    renderTrustedContent: ChatHelpersCommon["renderTrustedContent"];
+    unsupportedMediaPolicy: UnsupportedMediaPolicy;
+    warn?: (msg: string) => void;
+}) => Promise<string>;
+/**
+ * Assembles the complete native Ollama message history for a dispatch — system prompt and content
+ * buckets, the interleaved timeline of messages/thoughts/tool calls, and the collected opaque
+ * reasoning payloads — by delegating to the injected sub-renderers.
+ */
+export declare const buildOllamaHistory: (input: {
+    systemPrompt: Tokenizable;
+    standingInstructions: Iterable<Tokenizable>;
+    memories: Iterable<Memory>;
+    retrievables: Iterable<Retrievable>;
+    messages: Iterable<Message>;
+    thoughts: Iterable<Thought>;
+    toolCalls: Iterable<ToolCall>;
+    tools: ToolRegistry;
+    renderedToolCallResults: Map<string, string>;
+    bucketOrder: ChatCompletionsBucketOrder;
+    selfIdentity: string;
+    thoughtSurfacing: "all-self" | "latest-self" | "all";
+    replayCompatibility: ReadonlyArray<string>;
+    unsupportedMediaPolicy: UnsupportedMediaPolicy;
+    renderOllamaToolCallResult: OllamaHelpers["renderOllamaToolCallResult"];
+    renderChatCompletionsSystemPrompt: ChatHelpersCommon["renderChatCompletionsSystemPrompt"];
+    renderStandingInstructions: ChatHelpersCommon["renderStandingInstructions"];
+    renderMemories: ChatHelpersCommon["renderMemories"];
+    renderRetrievables: ChatHelpersCommon["renderRetrievables"];
+    renderRetrievableSafetyDirective: ChatHelpersCommon["renderRetrievableSafetyDirective"];
+    renderFirstPartyRetrievables: ChatHelpersCommon["renderFirstPartyRetrievables"];
+    renderThirdPartyPublicRetrievables: ChatHelpersCommon["renderThirdPartyPublicRetrievables"];
+    renderThirdPartyPrivateRetrievables: ChatHelpersCommon["renderThirdPartyPrivateRetrievables"];
+    renderOllamaTimelineMessage: OllamaHelpers["renderOllamaTimelineMessage"];
+    renderThought: ChatHelpersCommon["renderThought"];
+    filterThoughts: ChatHelpersCommon["filterThoughts"];
+    renderUntrustedContent: ChatHelpersCommon["renderUntrustedContent"];
+    renderTrustedContent: ChatHelpersCommon["renderTrustedContent"];
+    warn?: (msg: string) => void;
+}) => Promise<{
+    messages: OllamaMessage[];
+    reasoningPayloads: Array<{
+        id: string;
+        replayCompatibility: string;
+        payload: unknown;
+    }>;
+}>;
+/** Default native-history assembler; alias of {@link buildOllamaHistory}. */
+export declare const defaultBuildOllamaHistory: (input: {
+    systemPrompt: Tokenizable;
+    standingInstructions: Iterable<Tokenizable>;
+    memories: Iterable<Memory>;
+    retrievables: Iterable<Retrievable>;
+    messages: Iterable<Message>;
+    thoughts: Iterable<Thought>;
+    toolCalls: Iterable<ToolCall>;
+    tools: ToolRegistry;
+    renderedToolCallResults: Map<string, string>;
+    bucketOrder: ChatCompletionsBucketOrder;
+    selfIdentity: string;
+    thoughtSurfacing: "all-self" | "latest-self" | "all";
+    replayCompatibility: ReadonlyArray<string>;
+    unsupportedMediaPolicy: UnsupportedMediaPolicy;
+    renderOllamaToolCallResult: OllamaHelpers["renderOllamaToolCallResult"];
+    renderChatCompletionsSystemPrompt: ChatHelpersCommon["renderChatCompletionsSystemPrompt"];
+    renderStandingInstructions: ChatHelpersCommon["renderStandingInstructions"];
+    renderMemories: ChatHelpersCommon["renderMemories"];
+    renderRetrievables: ChatHelpersCommon["renderRetrievables"];
+    renderRetrievableSafetyDirective: ChatHelpersCommon["renderRetrievableSafetyDirective"];
+    renderFirstPartyRetrievables: ChatHelpersCommon["renderFirstPartyRetrievables"];
+    renderThirdPartyPublicRetrievables: ChatHelpersCommon["renderThirdPartyPublicRetrievables"];
+    renderThirdPartyPrivateRetrievables: ChatHelpersCommon["renderThirdPartyPrivateRetrievables"];
+    renderOllamaTimelineMessage: OllamaHelpers["renderOllamaTimelineMessage"];
+    renderThought: ChatHelpersCommon["renderThought"];
+    filterThoughts: ChatHelpersCommon["filterThoughts"];
+    renderUntrustedContent: ChatHelpersCommon["renderUntrustedContent"];
+    renderTrustedContent: ChatHelpersCommon["renderTrustedContent"];
+    warn?: (msg: string) => void;
+}) => Promise<{
+    messages: OllamaMessage[];
+    reasoningPayloads: Array<{
+        id: string;
+        replayCompatibility: string;
+        payload: unknown;
+    }>;
+}>;

package/batteries/llm/ollama/helpers.mjs

@@ -0,0 +1,450 @@
+import "../../../common-DYDUi99O.mjs";
+import { n as Media } from "../../../tool_call-B4-_-vjG.mjs";
+import "../../../guards.mjs";
+import { A as retrievableToAttrs, C as renderRetrievables, D as renderThought, E as renderThirdPartyPublicRetrievables, M as toolsToChatCompletionsTools, O as renderTrustedContent, S as renderRetrievableSafetyDirective, T as renderThirdPartyPrivateRetrievables, _ as filterThoughts, a as defaultRenderMemories, b as renderFirstPartyRetrievables, c as defaultRenderStandingInstructions, d as defaultRenderThought, f as defaultRenderTrustedContent, g as escapeXmlAttribute, h as descriptionToChatCompletionsJsonSchema, i as defaultRenderFirstPartyRetrievables, k as renderUntrustedContent, 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, v as memoryToAttrs, w as renderStandingInstructions, x as renderMemories, y as renderChatCompletionsSystemPrompt } from "../../../helpers-xhrQbMAG.mjs";
+import { E_OLLAMA_UNSUPPORTED_MEDIA_MODALITY } from "./exceptions.mjs";
+//#region src/batteries/llm/ollama/helpers.ts
+/**
+* Swappable translation helpers for rendering ADK state into native Ollama `/api/chat` requests.
+*
+* @module @nhtio/adk/batteries/llm/ollama/helpers
+*
+* @remarks
+* The wire-shape-agnostic helpers (`renderUntrustedContent`, `renderMemories`,
+* `renderChatCompletionsSystemPrompt`, `toolsToChatCompletionsTools`, …) are shared with the OpenAI
+* battery via the internal `../chat_common/helpers` submodule and re-exported here under their
+* original names. Only the Ollama-WIRE-SPECIFIC helpers are defined here:
+* `renderOllamaTimelineMessage` (flat `content` + base64 `images[]` + `thinking`),
+* `renderOllamaToolCallResult` (string-only result content), `buildOllamaHistory` (synthetic
+* `assistant.tool_calls` with object-form `arguments` + `tool`-role messages labelled by
+* `tool_name`), and `ollamaToolsFromTools` (alias of the shared tool-definition renderer — native
+* `/api/chat` uses the same function-tool wire shape).
+*
+* Native `/api/chat` supports only base64 `images[]`; every non-image modality routes through the
+* `unsupportedMediaPolicy` fallback (stash text / synthetic description) or throws.
+*/
+/**
+* Convert ADK tools to the native Ollama `tools[]` wire. Native `/api/chat` uses the identical
+* `{ type: 'function', function: { name, description, parameters } }` shape as Chat Completions, so
+* this is an alias of the shared renderer.
+*/
+var ollamaToolsFromTools = (tools, deps) => toolsToChatCompletionsTools(tools, deps);
+/** Default implementation of {@link OllamaHelpers}-style tool translation; alias of {@link ollamaToolsFromTools}. */
+var defaultOllamaToolsFromTools = ollamaToolsFromTools;
+var DEFAULT_STASH_FALLBACK_KEYS = [
+	"text:transcript",
+	"text:caption",
+	"text:description"
+];
+var modalityHazardToAttr = (h) => {
+	if (h === "inert") return "inert";
+	if (h === "extractable-instructions") return "extractable";
+	return "opaque";
+};
+var formatBytesHumanReadable = (bytes) => {
+	if (bytes === void 0 || !Number.isFinite(bytes)) return "unknown size";
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+	return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+};
+var isMediaTextStashEntry = (e) => {
+	if (!e || typeof e !== "object") return false;
+	const r = e;
+	return typeof r.value === "string" && typeof r.trustTier === "string";
+};
+var resolveFallbackStash = (media, keys) => {
+	for (const key of keys) {
+		const entry = media.stash.get(key);
+		if (isMediaTextStashEntry(entry)) return {
+			text: entry.value,
+			entryTier: entry.trustTier
+		};
+	}
+};
+var renderTextInEnvelope = (text, args) => {
+	if (args.trustTier === "first-party") return args.renderTrustedContent(text, {
+		nonce: args.nonce,
+		kind: "media-fallback",
+		tool: args.toolName,
+		modality: args.modality
+	});
+	return args.renderUntrustedContent(text, {
+		nonce: args.nonce,
+		kind: "media-fallback",
+		tool: args.toolName,
+		modality: args.modality
+	});
+};
+var renderSyntheticMediaDescription = (media, byteLen) => `[media: ${media.filename}, ${media.mimeType}, ${formatBytesHumanReadable(byteLen)}]`;
+/**
+* Render a single {@link Media} for the native Ollama wire. Images become a base64 entry pushed to
+* the message's `images[]` array (returned via `image`); every other modality is unsupported and
+* routes through `unsupportedMediaPolicy` to a text envelope (returned via `text`) or throws.
+*/
+var renderMediaForOllama = async (input) => {
+	const { media, toolName, nonce, unsupportedMediaPolicy, warn } = input;
+	const modality = modalityHazardToAttr(media.modalityHazard);
+	if (media.kind === "image") return { image: await media.asBase64() };
+	const fallbackText = async (keys, allowSyntheticFallthrough) => {
+		const fallback = resolveFallbackStash(media, keys);
+		if (fallback) return { text: renderTextInEnvelope(fallback.text, {
+			trustTier: fallback.entryTier,
+			modality,
+			nonce,
+			toolName,
+			renderTrustedContent: input.renderTrustedContent,
+			renderUntrustedContent: input.renderUntrustedContent
+		}) };
+		if (!allowSyntheticFallthrough) warn?.(`unsupportedMediaPolicy='fallback-stash' for ${media.filename}: no matching stash entry — falling through to synthetic description.`);
+		return { text: renderTextInEnvelope(renderSyntheticMediaDescription(media, await media.byteLength()), {
+			trustTier: media.trustTier,
+			modality,
+			nonce,
+			toolName,
+			renderTrustedContent: input.renderTrustedContent,
+			renderUntrustedContent: input.renderUntrustedContent
+		}) };
+	};
+	if (unsupportedMediaPolicy === "throw") throw new E_OLLAMA_UNSUPPORTED_MEDIA_MODALITY([
+		media.kind,
+		media.mimeType,
+		media.filename
+	]);
+	if (unsupportedMediaPolicy === "fallback-stash" || typeof unsupportedMediaPolicy === "object" && unsupportedMediaPolicy.mode === "fallback-stash") return fallbackText(typeof unsupportedMediaPolicy === "object" ? unsupportedMediaPolicy.stashKeys : DEFAULT_STASH_FALLBACK_KEYS, false);
+	return fallbackText([], true);
+};
+/**
+* Renders a single timeline {@link @nhtio/adk!Message} into a native Ollama message — flattening any
+* media into the base64 `images[]` array, surfacing reasoning as `thinking`, and wrapping textual
+* bodies in the appropriate trust envelope.
+*/
+var renderOllamaTimelineMessage = async (input) => {
+	const { message, selfIdentity, unsupportedMediaPolicy, warn } = input;
+	const identifier = message.identity?.identifier !== void 0 && message.identity?.identifier !== null ? String(message.identity.identifier) : "";
+	const representationRaw = message.identity?.representation !== void 0 && message.identity?.representation !== null ? message.identity.representation.toString() : "";
+	const representation = representationRaw.length > 0 ? representationRaw : identifier;
+	const text = message.content !== void 0 ? message.content.toString() : "";
+	const createdAtStr = message.createdAt.toISO?.() ?? "";
+	const createdAtAttr = createdAtStr ? ` createdAt="${escapeXmlAttribute(createdAtStr)}"` : "";
+	const attachments = message.attachments;
+	let envelopeText;
+	let role;
+	if (message.role === "user") {
+		role = "user";
+		if (identifier.length === 0) envelopeText = text;
+		else {
+			const fromAttr = escapeXmlAttribute(representation);
+			envelopeText = `<message_${message.id} from="${fromAttr}" role="user"${createdAtAttr}>\n${text}\n</message_${message.id}>`;
+		}
+	} else {
+		role = "assistant";
+		if (identifier.length === 0 || identifier === selfIdentity) envelopeText = text;
+		else {
+			const fromAttr = escapeXmlAttribute(representation);
+			envelopeText = `<peer_agent_output_${message.id} from="${fromAttr}"${createdAtAttr}>\n${text}\n</peer_agent_output_${message.id}>`;
+		}
+	}
+	const images = [];
+	const extraTexts = [];
+	for (const media of attachments) {
+		const rendered = await renderMediaForOllama({
+			media,
+			toolName: void 0,
+			nonce: message.id,
+			unsupportedMediaPolicy,
+			renderTrustedContent,
+			renderUntrustedContent,
+			warn
+		});
+		if (rendered.image !== void 0) images.push(rendered.image);
+		if (rendered.text !== void 0) extraTexts.push(rendered.text);
+	}
+	const contentParts = [];
+	if (envelopeText.length > 0) contentParts.push(envelopeText);
+	for (const t of extraTexts) contentParts.push(t);
+	const out = {
+		role,
+		content: contentParts.join("\n")
+	};
+	if (images.length > 0) out.images = images;
+	return out;
+};
+/** Default timeline-message renderer; alias of {@link renderOllamaTimelineMessage}. */
+var defaultRenderOllamaTimelineMessage = renderOllamaTimelineMessage;
+var looksLikeSpooledArtifact = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const v = value;
+	return typeof v.asString === "function" && typeof v.byteLength === "function" && typeof v.lineCount === "function" && typeof v.estimateTokens === "function";
+};
+var renderArtifactHandleBody = (toolCall, artifact, byteLength, lineCount) => {
+	const ctor = artifact.constructor;
+	const methods = ctor?.toolMethods ?? [];
+	const lines = [];
+	lines.push(`This tool returned a large artifact that was not inlined to preserve context budget.`);
+	lines.push(``);
+	lines.push(`Artifact metadata:`);
+	lines.push(`- callId: ${toolCall.id}`);
+	lines.push(`- kind: ${ctor?.constructor?.name ?? "SpooledArtifact"}`);
+	lines.push(`- byteLength: ${byteLength}`);
+	lines.push(`- lineCount: ${lineCount}`);
+	lines.push(``);
+	lines.push(`To read this artifact in this turn, call one of the following tools with`);
+	lines.push(`callId=${toolCall.id}:`);
+	for (const m of methods) if (m.description) lines.push(`- ${m.name} — ${m.description}`);
+	else lines.push(`- ${m.name}`);
+	lines.push(``);
+	lines.push(`The artifact persists in this turn's context — multiple queries against the same callId are allowed and efficient. Do not assume the body has been inlined anywhere else.`);
+	return lines.join("\n");
+};
+/**
+* Render a tool-call result to native Ollama tool-message content (always a string). Media results
+* are routed through the internal media renderer: images cannot ride on a tool-role message's
+* `content`, so an image result is replaced with a short text marker (the image bytes are not
+* re-sent on a tool message); non-image media use the same fallback-text path as elsewhere.
+*/
+var renderOllamaToolCallResult = async (input) => {
+	const { toolCall, results, tool, warn, unsupportedMediaPolicy } = input;
+	const isTrusted = tool !== null && tool !== void 0 && tool.trusted === true;
+	if (tool === void 0) warn?.(`Tool "${toolCall.tool}" is not present in the bound tool registry at render time; defaulting to untrusted envelope.`);
+	const isMediaResult = Media.isMedia(results);
+	const isMediaArrayResult = Array.isArray(results) && results.length > 0 && results.every((r) => Media.isMedia(r));
+	if (isMediaResult || isMediaArrayResult) {
+		const mediaList = isMediaResult ? [results] : results;
+		const parts = [];
+		for (const media of mediaList) {
+			const rendered = await renderMediaForOllama({
+				media,
+				toolName: toolCall.tool,
+				nonce: toolCall.checksum,
+				unsupportedMediaPolicy,
+				renderTrustedContent: input.renderTrustedContent,
+				renderUntrustedContent: input.renderUntrustedContent,
+				warn
+			});
+			if (rendered.text !== void 0) parts.push(rendered.text);
+			else {
+				const byteLen = await media.byteLength();
+				parts.push(input.renderUntrustedContent(renderSyntheticMediaDescription(media, byteLen), {
+					nonce: toolCall.checksum,
+					kind: "tool-result-image",
+					tool: toolCall.tool,
+					modality: modalityHazardToAttr(media.modalityHazard)
+				}));
+			}
+		}
+		return parts.join("\n");
+	}
+	if (Array.isArray(results)) {
+		const parts = [];
+		for (const a of results) parts.push(await a.asString());
+		const joined = parts.join("\n\n");
+		return isTrusted ? input.renderTrustedContent(joined, {
+			nonce: toolCall.checksum,
+			kind: "trusted-tool-result",
+			tool: toolCall.tool
+		}) : input.renderUntrustedContent(joined, {
+			nonce: toolCall.checksum,
+			kind: "tool-result",
+			tool: toolCall.tool
+		});
+	}
+	const isSpooled = looksLikeSpooledArtifact(results);
+	if (isSpooled && toolCall.inline === false) {
+		const artifact = results;
+		let byteLength = 0;
+		let lineCount = 0;
+		try {
+			byteLength = await artifact.byteLength();
+		} catch {
+			byteLength = 0;
+		}
+		try {
+			lineCount = await artifact.lineCount();
+		} catch {
+			lineCount = 0;
+		}
+		const body = renderArtifactHandleBody(toolCall, artifact, byteLength, lineCount);
+		return input.renderUntrustedContent(body, {
+			nonce: toolCall.checksum,
+			kind: "artifact-handle",
+			tool: toolCall.tool
+		});
+	}
+	if (!isSpooled && toolCall.inline === false) warn?.(`Tool call ${toolCall.id} has inline=false but results is a Tokenizable (not a SpooledArtifact); rendering inline anyway.`);
+	const body = isSpooled ? await results.asString() : results.toString();
+	return isTrusted ? input.renderTrustedContent(body, {
+		nonce: toolCall.checksum,
+		kind: "trusted-tool-result",
+		tool: toolCall.tool
+	}) : input.renderUntrustedContent(body, {
+		nonce: toolCall.checksum,
+		kind: "tool-result",
+		tool: toolCall.tool
+	});
+};
+/** Default tool-call-result renderer; alias of {@link renderOllamaToolCallResult}. */
+var defaultRenderOllamaToolCallResult = renderOllamaToolCallResult;
+/**
+* Assembles the complete native Ollama message history for a dispatch — system prompt and content
+* buckets, the interleaved timeline of messages/thoughts/tool calls, and the collected opaque
+* reasoning payloads — by delegating to the injected sub-renderers.
+*/
+var buildOllamaHistory = async (input) => {
+	const out = [];
+	const reasoningPayloads = [];
+	const buckets = input.bucketOrder;
+	const timelineIdx = buckets.indexOf("timeline");
+	const leadingSystem = await input.renderChatCompletionsSystemPrompt({
+		systemPrompt: input.systemPrompt,
+		standingInstructions: input.standingInstructions,
+		memories: input.memories,
+		retrievables: input.retrievables,
+		bucketOrder: buckets,
+		renderStandingInstructions: input.renderStandingInstructions,
+		renderMemories: input.renderMemories,
+		renderRetrievables: input.renderRetrievables,
+		renderRetrievableSafetyDirective: input.renderRetrievableSafetyDirective,
+		renderFirstPartyRetrievables: input.renderFirstPartyRetrievables,
+		renderThirdPartyPublicRetrievables: input.renderThirdPartyPublicRetrievables,
+		renderThirdPartyPrivateRetrievables: input.renderThirdPartyPrivateRetrievables,
+		renderUntrustedContent: input.renderUntrustedContent
+	});
+	if (leadingSystem.length > 0) out.push({
+		role: "system",
+		content: leadingSystem
+	});
+	const includesTimeline = timelineIdx !== -1;
+	if (includesTimeline) {
+		const survivingThoughts = input.filterThoughts(input.thoughts, input.thoughtSurfacing, input.selfIdentity, input.replayCompatibility);
+		const items = [];
+		for (const m of input.messages) items.push({
+			kind: "message",
+			createdAt: m.createdAt.toMillis(),
+			value: m
+		});
+		for (const t of survivingThoughts) items.push({
+			kind: "thought",
+			createdAt: t.createdAt.toMillis(),
+			value: t
+		});
+		for (const tc of input.toolCalls) items.push({
+			kind: "toolCall",
+			createdAt: tc.createdAt.toMillis(),
+			value: tc
+		});
+		items.sort((a, b) => a.createdAt - b.createdAt);
+		const replaySet = new Set([...input.replayCompatibility]);
+		for (const item of items) if (item.kind === "message") out.push(await input.renderOllamaTimelineMessage({
+			message: item.value,
+			selfIdentity: input.selfIdentity,
+			unsupportedMediaPolicy: input.unsupportedMediaPolicy,
+			warn: input.warn
+		}));
+		else if (item.kind === "thought") {
+			const t = item.value;
+			const identifier = String(t.identity?.identifier ?? "");
+			const isSelf = identifier === input.selfIdentity;
+			const hasPayload = t.payload !== void 0;
+			const compatTag = t.replayCompatibility;
+			if (hasPayload && compatTag && replaySet.has(compatTag)) {
+				reasoningPayloads.push({
+					id: t.id,
+					replayCompatibility: compatTag,
+					payload: t.payload
+				});
+				const envelope = input.renderThought(t.content.toString(), {
+					nonce: t.id,
+					kind: "opaque-reasoning",
+					from: identifier,
+					createdAt: t.createdAt?.toISO?.() ?? void 0,
+					replayCompatibility: compatTag
+				}, t.payload);
+				out.push({
+					role: "assistant",
+					content: envelope
+				});
+			} else if (!hasPayload) {
+				const envelope = input.renderThought(t.content.toString(), {
+					nonce: t.id,
+					kind: isSelf ? "self-reasoning" : "peer-reasoning",
+					from: identifier,
+					createdAt: t.createdAt?.toISO?.() ?? void 0
+				});
+				out.push({
+					role: "assistant",
+					content: envelope
+				});
+			}
+		} else {
+			const tc = item.value;
+			const args = tc.args !== null && typeof tc.args === "object" && !Array.isArray(tc.args) ? tc.args : {};
+			out.push({
+				role: "assistant",
+				content: "",
+				tool_calls: [{ function: {
+					name: tc.tool,
+					arguments: args
+				} }]
+			});
+			let rendered = input.renderedToolCallResults.get(tc.id);
+			if (rendered === void 0) {
+				const tool = input.tools.get?.(tc.tool);
+				rendered = await input.renderOllamaToolCallResult({
+					toolCall: tc,
+					results: tc.results,
+					tool,
+					renderUntrustedContent: input.renderUntrustedContent,
+					renderTrustedContent: input.renderTrustedContent,
+					unsupportedMediaPolicy: input.unsupportedMediaPolicy,
+					warn: input.warn
+				});
+			}
+			out.push({
+				role: "tool",
+				content: rendered,
+				tool_name: tc.tool
+			});
+		}
+	}
+	if (includesTimeline) {
+		const trailingParts = [];
+		for (let i = timelineIdx + 1; i < buckets.length; i++) {
+			const label = buckets[i];
+			if (label === "standingInstructions") {
+				const block = input.renderStandingInstructions(input.standingInstructions);
+				if (block.length > 0) trailingParts.push(block);
+			} else if (label === "memories") {
+				const wrapped = [];
+				for (const m of input.memories) wrapped.push(memoryToAttrs(m));
+				const block = input.renderMemories(wrapped);
+				if (block.length > 0) trailingParts.push(block);
+			} else if (label === "retrievables") {
+				const wrapped = [];
+				for (const r of input.retrievables) wrapped.push(retrievableToAttrs(r));
+				const block = await input.renderRetrievables(wrapped, {
+					renderRetrievableSafetyDirective: input.renderRetrievableSafetyDirective,
+					renderFirstPartyRetrievables: input.renderFirstPartyRetrievables,
+					renderThirdPartyPublicRetrievables: input.renderThirdPartyPublicRetrievables,
+					renderThirdPartyPrivateRetrievables: input.renderThirdPartyPrivateRetrievables,
+					renderUntrustedContent: input.renderUntrustedContent
+				});
+				if (block.length > 0) trailingParts.push(block);
+			}
+		}
+		if (trailingParts.length > 0) out.push({
+			role: "system",
+			content: trailingParts.join("\n\n")
+		});
+	}
+	return {
+		messages: out,
+		reasoningPayloads
+	};
+};
+/** Default native-history assembler; alias of {@link buildOllamaHistory}. */
+var defaultBuildOllamaHistory = buildOllamaHistory;
+//#endregion
+export { buildOllamaHistory, defaultBuildOllamaHistory, defaultDescriptionToChatCompletionsJsonSchema, defaultFilterThoughts, defaultOllamaToolsFromTools, defaultRenderChatCompletionsSystemPrompt, defaultRenderFirstPartyRetrievables, defaultRenderMemories, defaultRenderOllamaTimelineMessage, defaultRenderOllamaToolCallResult, defaultRenderRetrievableSafetyDirective, defaultRenderRetrievables, defaultRenderStandingInstructions, defaultRenderThirdPartyPrivateRetrievables, defaultRenderThirdPartyPublicRetrievables, defaultRenderThought, defaultRenderTrustedContent, defaultRenderUntrustedContent, defaultToolsToChatCompletionsTools, descriptionToChatCompletionsJsonSchema, filterThoughts, ollamaToolsFromTools, renderChatCompletionsSystemPrompt, renderFirstPartyRetrievables, renderMemories, renderOllamaTimelineMessage, renderOllamaToolCallResult, renderRetrievableSafetyDirective, renderRetrievables, renderStandingInstructions, renderThirdPartyPrivateRetrievables, renderThirdPartyPublicRetrievables, renderThought, renderTrustedContent, renderUntrustedContent, toolsToChatCompletionsTools };
+
+//# sourceMappingURL=helpers.mjs.map