@jini-ai/agent-runtime 0.3.10 → 0.4.1

package/dist/providers/ollama-chat.d.ts

@@ -12,29 +12,29 @@
  * `/api/proxy/ollama/stream` handler):
  *
  * - **Endpoint**: `{baseUrl}/api/chat` — Ollama's own native chat API, not
- *   the OpenAI-compatible shim. `baseUrl` has any trailing `/api` stripped
- *   before appending, matching OD's `.replace(/\/api\/?$/, '')`.
+ * the OpenAI-compatible shim. `baseUrl` has any trailing `/api` stripped
+ * before appending, matching OD's `.replace(\/api\/?$/, '')`.
  * - **Wire format**: newline-delimited JSON (NDJSON), one JSON object per
- *   line, terminated by a line with `"done": true` — NOT Server-Sent
- *   Events. `text_delta`s come from `message.content`; the terminal line's
- *   `done: true` ends the stream (see `runSingleOllamaRequest` below).
+ * line, terminated by a line with `"done": true` — NOT Server-Sent
+ * Events. `text_delta`s come from `message.content`; the terminal line's
+ * `done: true` ends the stream (see `runSingleOllamaRequest` below).
  * - **`apiKey` is required**, like every other provider — OD's real handler
- *   rejects a request with no `apiKey` (`if (!apiKey || !model)`), because
- *   its default target is Ollama Cloud (see next point), not a bare local
- *   install.
+ * rejects a request with no `apiKey` (`if (!apiKey || !model)`), because
+ * its default target is Ollama Cloud (see next point), not a bare local
+ * install.
  * - **Default `baseUrl` is `https://ollama.com`** (Ollama Cloud), matching
- *   OD's `effectiveBaseUrl = baseUrl || 'https://ollama.com'` — not a local
- *   loopback address. A caller running a real local Ollama install still
- *   just passes `baseUrl: 'http://localhost:11434'` explicitly; the
- *   loopback carve-out in `connection-guard.ts` (documented there as
- *   existing "for local LLM servers like Ollama") still applies when they
- *   do.
+ * OD's `effectiveBaseUrl = baseUrl || 'https://ollama.com'` — not a local
+ * loopback address. A caller running a real local Ollama install still
+ * just passes `baseUrl: 'http://localhost:11434'` explicitly; the
+ * loopback carve-out in `connection-guard.ts` (documented there as
+ * existing "for local LLM servers like Ollama") still applies when they
+ * do.
  * - **Token limit**: `options.num_predict` (Ollama's native token-limit
- *   field), sent only when `maxTokens` is a positive number — matches OD's
- *   `if (typeof maxTokens === 'number' && maxTokens > 0) payload.options = {
- *   num_predict: maxTokens }`.
+ * field), sent only when `maxTokens` is a positive number — matches OD's
+ * `if (typeof maxTokens === 'number' && maxTokens > 0) payload.options = {
+ * num_predict: maxTokens }`.
  *
- * **Round-4 external audit fix (`AUD-R4-002`)**: the first port of this
+ * **Round-4 external audit fix **: the first port of this
  * module's tool-call loop kept the OpenAI-compatible wire shape for both the
  * emitted lifecycle event and the continuation request — `tool_use` was
  * never emitted, and the assistant/tool continuation messages used a
@@ -101,6 +101,7 @@
  * as an error the model can see, which is impossible without it. Wired
  * through as `result.isError ?? false`, so every existing caller that never
  * set `isError` keeps its exact prior behavior.
+ * See docs/decisions/DR-001-provider-native-tool-lifecycle.md.
  */
 import { createRoleMarkerGuard } from '../role-marker-guard.js';
 import { type DnsLookupFn, type PinnedFetch } from './connection-guard.js';
@@ -120,10 +121,11 @@ export interface OllamaFunctionToolDef {
  * no `id`/`type` field at all (confirmed against Ollama's own documented
  * "Chat request (No streaming, with tools)" example,
  * `github.com/ollama/ollama/blob/main/docs/api.md`). Round-4 external audit
- * (`AUD-R4-002`) found the first port had kept the OpenAI shape here, which
+ * found the first port had kept the OpenAI shape here, which
  * a strict Ollama server can reject. Synthetic per-call `id`s are still
  * generated (see `runSingleOllamaRequest`) but stay purely internal to this
  * module's own event stream — they are never put on the wire.
+ * See docs/decisions/DR-001-provider-native-tool-lifecycle.md.
  */
 export interface OllamaToolCallParam {
     readonly function: {
@@ -240,17 +242,29 @@ export interface OllamaStreamState {
     finishReason: string | null;
 }
 /** Parses one `function.arguments` value: Ollama's native tool-call payload documents it as a native JSON object, but a strict/older server can still send a stringified blob — this tolerates either, falling back to the raw string on malformed JSON. */
-export declare function parseOllamaToolCallArguments(args: unknown): unknown;
+export declare function parseOllamaToolCallArguments({ args }: {
+    args: unknown;
+}): unknown;
 /** Resolves one raw `message.tool_calls[]` entry into an `OllamaToolCall`, or `null` when the entry is missing its `function`/`name` (malformed, so skipped rather than surfaced). `index` seeds the synthetic id fallback — see `OllamaToolCallParam`'s doc for why a call id is generated locally rather than trusted off the wire. */
-export declare function resolveOllamaToolCall(rawCall: unknown, index: number): OllamaToolCall | null;
+export declare function resolveOllamaToolCall({ rawCall, index }: {
+    rawCall: unknown;
+    index: number;
+}): OllamaToolCall | null;
 /** Resolves every entry in `message.tool_calls` into `state.toolCalls`, then marks `finishReason: 'tool_calls'` once at least one resolved — mirrors the original inline loop's behavior of setting `finishReason` after the whole batch rather than per-call. */
-export declare function handleOllamaToolCallsField(state: OllamaStreamState, message: Record<string, unknown>): void;
+export declare function handleOllamaToolCallsField({ state, message }: {
+    state: OllamaStreamState;
+    message: Record<string, unknown>;
+}): void;
 /**
  * Feeds one `message.content` delta through the role-marker guard and emits the safe portion.
  * Returns `'break'` once the guard flags contamination, otherwise `'continue'` — same contract as
  * `anthropic-messages.ts#handleAnthropicTextDelta`/`openai-chat.ts#handleOpenAiTextContentDelta`.
  */
-export declare function handleOllamaTextContent(state: OllamaStreamState, content: string, onEvent: (event: OllamaTurnEvent) => void): 'continue' | 'break';
+export declare function handleOllamaTextContent({ state, content, onEvent }: {
+    state: OllamaStreamState;
+    content: string;
+    onEvent: (event: OllamaTurnEvent) => void;
+}): 'continue' | 'break';
 /**
  * Reduces one already-parsed NDJSON line into `state`, reporting whether the caller's line loop
  * should stop and, if so, why. `'break'` calls `emitEnd('contaminated')` itself (mirroring the
@@ -259,37 +273,58 @@ export declare function handleOllamaTextContent(state: OllamaStreamState, conten
  * the caller (`runSingleOllamaRequest`) still owns the normal-completion `emitEnd`, exactly like
  * every sibling turn-runner's `emitEnd` contract.
  */
-export declare function processOllamaLine(state: OllamaStreamState, line: Record<string, unknown>, onEvent: (event: OllamaTurnEvent) => void, emitEnd: (reason: OllamaTurnEndReason) => void): 'continue' | 'break' | 'done';
+export declare function processOllamaLine({ state, line, onEvent, emitEnd }: {
+    state: OllamaStreamState;
+    line: Record<string, unknown>;
+    onEvent: (event: OllamaTurnEvent) => void;
+    emitEnd: (reason: OllamaTurnEndReason) => void;
+}): 'continue' | 'break' | 'done';
 /** Parses one NDJSON line, returning `undefined` for a malformed/empty line — JSON has no `undefined` literal, so a successful parse is never confused with a failed one. Extracted so the generator below never nests a `try`/`catch` inside its loops (see that function's doc). */
-export declare function parseNdjsonLine(line: string): unknown;
+export declare function parseNdjsonLine({ line }: {
+    line: string;
+}): unknown;
 /** Splits already-accumulated buffer content into complete newline-terminated lines (newline stripped) plus the remaining partial-line `remainder`. Pure — no I/O — so this buffering/splitting logic is exercised as plain value-in/value-out assertions instead of through the full streaming generator. */
-export declare function splitNdjsonLines(buffer: string): {
+export declare function splitNdjsonLines({ buffer }: {
+    buffer: string;
+}): {
     readonly lines: readonly string[];
     readonly remainder: string;
 };
 /** Trims and parses each complete line in `rawLines`, yielding only the ones that parsed to something other than `undefined` — a plain (non-async) generator so `decodeNdjsonStream` below can delegate to it with `yield*` instead of nesting a `for`/`if`/`if` inside its own `for await` loop. */
-export declare function parseNdjsonLines(rawLines: readonly string[]): Generator<unknown>;
+export declare function parseNdjsonLines({ rawLines }: {
+    rawLines: readonly string[];
+}): Generator<unknown>;
 /**
  * Decides why the tool loop should stop after one request, or returns `null` when it should
  * instead proceed to execute the pending tool calls — mirrors
  * `anthropic-messages.ts#anthropicLoopExitReason`'s pure decision/effect split.
  */
-export declare function ollamaLoopExitReason(outcome: SingleRequestOutcome, toolTurns: number, maxToolTurns: number): OllamaTurnEndReason | null;
+export declare function ollamaLoopExitReason({ outcome, toolTurns, maxToolTurns }: {
+    outcome: SingleRequestOutcome;
+    toolTurns: number;
+    maxToolTurns: number;
+}): OllamaTurnEndReason | null;
 /** Builds the assistant continuation's `tool_calls` field — Ollama's native shape has no `id`/`type` on the wire (see `OllamaToolCallParam`'s doc). */
-export declare function buildOllamaAssistantToolCalls(toolCalls: readonly OllamaToolCall[]): OllamaToolCallParam[];
+export declare function buildOllamaAssistantToolCalls({ toolCalls }: {
+    toolCalls: readonly OllamaToolCall[];
+}): OllamaToolCallParam[];
 /**
  * Runs every pending tool call in order, applying `guardToolResult` and reducing the results into
  * the `tool`-role continuation messages Ollama's native `tool_name`-association scheme expects —
  * see module doc's "Design decision: native `tool`-role images" section for why no separate
  * follow-up message is needed here, unlike `openai-chat.ts`/`azure-chat.ts`.
  */
-export declare function executeOllamaToolCalls(executeTool: OllamaToolExecutor, calls: readonly OllamaToolCall[], onEvent: (event: OllamaTurnEvent) => void): Promise<OllamaMessageParam[]>;
+export declare function executeOllamaToolCalls({ executeTool, calls, onEvent }: {
+    executeTool: OllamaToolExecutor;
+    calls: readonly OllamaToolCall[];
+    onEvent: (event: OllamaTurnEvent) => void;
+}): Promise<OllamaMessageParam[]>;
 /**
  * Runs a full Ollama native `/api/chat` turn, including the tool-execution
  * loop when `options.executeTool` is supplied and the model requests a
  * function call. See `anthropic-messages.ts#runAnthropicToolTurn`'s doc for
  * the shared event-stream/`ended`-flag contract this mirrors exactly.
  */
-export declare function runOllamaToolTurn(options: OllamaTurnOptions): Promise<OllamaTurnResult>;
+export declare function runOllamaToolTurn(requiredArgs: Pick<OllamaTurnOptions, "apiKey" | "model" | "messages" | "onEvent">, optionalArgs?: Omit<OllamaTurnOptions, "apiKey" | "model" | "messages" | "onEvent">): Promise<OllamaTurnResult>;
 export {};
 //# sourceMappingURL=ollama-chat.d.ts.map

package/dist/providers/ollama-chat.js

@@ -1,3 +1,4 @@
+import { redactSecrets } from '@jini-ai/core';
 /**
  * @module providers/ollama-chat
  *
@@ -12,29 +13,29 @@
  * `/api/proxy/ollama/stream` handler):
  *
  * - **Endpoint**: `{baseUrl}/api/chat` — Ollama's own native chat API, not
- *   the OpenAI-compatible shim. `baseUrl` has any trailing `/api` stripped
- *   before appending, matching OD's `.replace(/\/api\/?$/, '')`.
+ * the OpenAI-compatible shim. `baseUrl` has any trailing `/api` stripped
+ * before appending, matching OD's `.replace(\/api\/?$/, '')`.
  * - **Wire format**: newline-delimited JSON (NDJSON), one JSON object per
- *   line, terminated by a line with `"done": true` — NOT Server-Sent
- *   Events. `text_delta`s come from `message.content`; the terminal line's
- *   `done: true` ends the stream (see `runSingleOllamaRequest` below).
+ * line, terminated by a line with `"done": true` — NOT Server-Sent
+ * Events. `text_delta`s come from `message.content`; the terminal line's
+ * `done: true` ends the stream (see `runSingleOllamaRequest` below).
  * - **`apiKey` is required**, like every other provider — OD's real handler
- *   rejects a request with no `apiKey` (`if (!apiKey || !model)`), because
- *   its default target is Ollama Cloud (see next point), not a bare local
- *   install.
+ * rejects a request with no `apiKey` (`if (!apiKey || !model)`), because
+ * its default target is Ollama Cloud (see next point), not a bare local
+ * install.
  * - **Default `baseUrl` is `https://ollama.com`** (Ollama Cloud), matching
- *   OD's `effectiveBaseUrl = baseUrl || 'https://ollama.com'` — not a local
- *   loopback address. A caller running a real local Ollama install still
- *   just passes `baseUrl: 'http://localhost:11434'` explicitly; the
- *   loopback carve-out in `connection-guard.ts` (documented there as
- *   existing "for local LLM servers like Ollama") still applies when they
- *   do.
+ * OD's `effectiveBaseUrl = baseUrl || 'https://ollama.com'` — not a local
+ * loopback address. A caller running a real local Ollama install still
+ * just passes `baseUrl: 'http://localhost:11434'` explicitly; the
+ * loopback carve-out in `connection-guard.ts` (documented there as
+ * existing "for local LLM servers like Ollama") still applies when they
+ * do.
  * - **Token limit**: `options.num_predict` (Ollama's native token-limit
- *   field), sent only when `maxTokens` is a positive number — matches OD's
- *   `if (typeof maxTokens === 'number' && maxTokens > 0) payload.options = {
- *   num_predict: maxTokens }`.
+ * field), sent only when `maxTokens` is a positive number — matches OD's
+ * `if (typeof maxTokens === 'number' && maxTokens > 0) payload.options = {
+ * num_predict: maxTokens }`.
  *
- * **Round-4 external audit fix (`AUD-R4-002`)**: the first port of this
+ * **Round-4 external audit fix **: the first port of this
  * module's tool-call loop kept the OpenAI-compatible wire shape for both the
  * emitted lifecycle event and the continuation request — `tool_use` was
  * never emitted, and the assistant/tool continuation messages used a
@@ -101,9 +102,10 @@
  * as an error the model can see, which is impossible without it. Wired
  * through as `result.isError ?? false`, so every existing caller that never
  * set `isError` keeps its exact prior behavior.
+ * See docs/decisions/DR-001-provider-native-tool-lifecycle.md.
  */
 import { createRoleMarkerGuard } from '../role-marker-guard.js';
-import { defaultDnsLookup, pinnedFetch, redactSecrets, validateBaseUrlResolved } from './connection-guard.js';
+import { defaultDnsLookup, pinnedFetch, validateBaseUrlResolved } from './connection-guard.js';
 import { createTurnEndGuard } from './turn-end-guard.js';
 const DEFAULT_OLLAMA_BASE_URL = 'https://ollama.com';
 const DEFAULT_MAX_TOOL_TURNS = 8;
@@ -199,7 +201,7 @@ function guardToolResult(result) {
     return result;
 }
 /** Parses one `function.arguments` value: Ollama's native tool-call payload documents it as a native JSON object, but a strict/older server can still send a stringified blob — this tolerates either, falling back to the raw string on malformed JSON. */
-export function parseOllamaToolCallArguments(args) {
+export function parseOllamaToolCallArguments({ args }) {
     if (typeof args !== 'string')
         return args;
     try {
@@ -210,22 +212,22 @@ export function parseOllamaToolCallArguments(args) {
     }
 }
 /** Resolves one raw `message.tool_calls[]` entry into an `OllamaToolCall`, or `null` when the entry is missing its `function`/`name` (malformed, so skipped rather than surfaced). `index` seeds the synthetic id fallback — see `OllamaToolCallParam`'s doc for why a call id is generated locally rather than trusted off the wire. */
-export function resolveOllamaToolCall(rawCall, index) {
+export function resolveOllamaToolCall({ rawCall, index }) {
     if (!isRecord(rawCall) || !isRecord(rawCall.function))
         return null;
     const name = typeof rawCall.function.name === 'string' ? rawCall.function.name : '';
     if (!name)
         return null;
-    const input = parseOllamaToolCallArguments(rawCall.function.arguments);
+    const input = parseOllamaToolCallArguments({ args: rawCall.function.arguments });
     const id = typeof rawCall.id === 'string' && rawCall.id ? rawCall.id : `ollama-tool-${index}`;
     return { id, name, input };
 }
 /** Resolves every entry in `message.tool_calls` into `state.toolCalls`, then marks `finishReason: 'tool_calls'` once at least one resolved — mirrors the original inline loop's behavior of setting `finishReason` after the whole batch rather than per-call. */
-export function handleOllamaToolCallsField(state, message) {
+export function handleOllamaToolCallsField({ state, message }) {
     if (!Array.isArray(message.tool_calls))
         return;
     for (const rawCall of message.tool_calls) {
-        const call = resolveOllamaToolCall(rawCall, state.toolCalls.length);
+        const call = resolveOllamaToolCall({ rawCall: rawCall, index: state.toolCalls.length });
         if (call)
             state.toolCalls.push(call);
     }
@@ -237,8 +239,8 @@ export function handleOllamaToolCallsField(state, message) {
  * Returns `'break'` once the guard flags contamination, otherwise `'continue'` — same contract as
  * `anthropic-messages.ts#handleAnthropicTextDelta`/`openai-chat.ts#handleOpenAiTextContentDelta`.
  */
-export function handleOllamaTextContent(state, content, onEvent) {
-    const safe = state.guard.feedText(content);
+export function handleOllamaTextContent({ state, content, onEvent }) {
+    const safe = state.guard.feedText({ text: content });
     if (safe.length > 0) {
         state.fullText += safe;
         onEvent({ type: 'text_delta', delta: safe });
@@ -258,17 +260,17 @@ export function handleOllamaTextContent(state, content, onEvent) {
  * the caller (`runSingleOllamaRequest`) still owns the normal-completion `emitEnd`, exactly like
  * every sibling turn-runner's `emitEnd` contract.
  */
-export function processOllamaLine(state, line, onEvent, emitEnd) {
+export function processOllamaLine({ state, line, onEvent, emitEnd }) {
     const message = isRecord(line.message) ? line.message : null;
     if (message && typeof message.content === 'string' && message.content.length > 0) {
-        if (handleOllamaTextContent(state, message.content, onEvent) === 'break') {
+        if (handleOllamaTextContent({ state: state, content: message.content, onEvent: onEvent }) === 'break') {
             state.finishReason = 'contaminated';
             emitEnd('contaminated');
             return 'break';
         }
     }
     if (message)
-        handleOllamaToolCallsField(state, message);
+        handleOllamaToolCallsField({ state: state, message: message });
     if (line.done === true) {
         if (state.finishReason !== 'contaminated' && state.finishReason !== 'tool_calls')
             state.finishReason = 'stop';
@@ -276,7 +278,7 @@ export function processOllamaLine(state, line, onEvent, emitEnd) {
     }
     return 'continue';
 }
-/** Emitted for every resolved call as soon as the stream ends, independent of whether the caller actually supplied an `executeTool` — see AUD-R4-002 fix note in the module doc. */
+/** Emitted for every resolved call as soon as the stream ends, independent of whether the caller actually supplied an `executeTool` — see fix note in the module doc. See docs/decisions/DR-001-provider-native-tool-lifecycle.md. */
 function emitPendingOllamaToolUseEvents(toolCalls, onEvent) {
     for (const call of toolCalls) {
         onEvent({ type: 'tool_use', id: call.id, name: call.name, input: call.input });
@@ -291,7 +293,7 @@ function emitPendingOllamaToolUseEvents(toolCalls, onEvent) {
  */
 async function openOllamaResponseStream(options, messages, emitEnd) {
     const { onEvent } = options;
-    const baseUrlCheck = await validateBaseUrlResolved(options.baseUrl ?? DEFAULT_OLLAMA_BASE_URL, options.dnsLookup ?? defaultDnsLookup);
+    const baseUrlCheck = await validateBaseUrlResolved({ baseUrl: options.baseUrl ?? DEFAULT_OLLAMA_BASE_URL, lookup: options.dnsLookup ?? defaultDnsLookup });
     if (baseUrlCheck.error) {
         onEvent({ type: 'error', message: baseUrlCheck.error });
         emitEnd('error');
@@ -299,22 +301,22 @@ async function openOllamaResponseStream(options, messages, emitEnd) {
     }
     let response;
     try {
-        response = await (options.fetchImpl ?? pinnedFetch)(ollamaRequestUrl(options.baseUrl), {
-            method: 'POST',
-            headers: ollamaHeaders(options),
-            body: JSON.stringify(ollamaRequestBody(options, messages)),
-            // Unlike the other three providers, this call never set `redirect: 'error'` even before
-            // this pinning change — the reviewer's redirect-rebinding finding was only reported (and
-            // fixed) for `openai-chat.ts`. `pinnedFetch` closes it here regardless, the same way it
-            // does everywhere else (`node:http`'s `request` never auto-follows); the flag is added for
-            // self-documentation, matching the other three call sites.
-            redirect: 'error',
-            ...(options.signal ? { signal: options.signal } : {}),
-        }, baseUrlCheck.pinnedAddress);
+        response = await (options.fetchImpl ?? pinnedFetch)({ url: ollamaRequestUrl(options.baseUrl), init: {
+                method: 'POST',
+                headers: ollamaHeaders(options),
+                body: JSON.stringify(ollamaRequestBody(options, messages)),
+                // Unlike the other three providers, this call never set `redirect: 'error'` even before
+                // this pinning change — the reviewer's redirect-rebinding finding was only reported (and
+                // fixed) for `openai-chat.ts`. `pinnedFetch` closes it here regardless, the same way it
+                // does everywhere else (`node:http`'s `request` never auto-follows); the flag is added for
+                // self-documentation, matching the other three call sites.
+                redirect: 'error',
+                ...(options.signal ? { signal: options.signal } : {}),
+            }, pinnedAddress: baseUrlCheck.pinnedAddress });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        onEvent({ type: 'error', message: redactSecrets(message, [options.apiKey]) });
+        onEvent({ type: 'error', message: redactSecrets({ input: message }, { exactSecrets: [options.apiKey] }) });
         emitEnd('error');
         return null;
     }
@@ -322,7 +324,7 @@ async function openOllamaResponseStream(options, messages, emitEnd) {
         const rawText = await response.text();
         onEvent({
             type: 'error',
-            message: redactSecrets(extractOllamaErrorDetail(rawText), [options.apiKey]),
+            message: redactSecrets({ input: extractOllamaErrorDetail(rawText) }, { exactSecrets: [options.apiKey] }),
             code: String(response.status),
         });
         emitEnd('error');
@@ -336,7 +338,7 @@ async function openOllamaResponseStream(options, messages, emitEnd) {
     return response.body;
 }
 /** Parses one NDJSON line, returning `undefined` for a malformed/empty line — JSON has no `undefined` literal, so a successful parse is never confused with a failed one. Extracted so the generator below never nests a `try`/`catch` inside its loops (see that function's doc). */
-export function parseNdjsonLine(line) {
+export function parseNdjsonLine({ line }) {
     try {
         return JSON.parse(line);
     }
@@ -345,7 +347,7 @@ export function parseNdjsonLine(line) {
     }
 }
 /** Splits already-accumulated buffer content into complete newline-terminated lines (newline stripped) plus the remaining partial-line `remainder`. Pure — no I/O — so this buffering/splitting logic is exercised as plain value-in/value-out assertions instead of through the full streaming generator. */
-export function splitNdjsonLines(buffer) {
+export function splitNdjsonLines({ buffer }) {
     const lines = [];
     let rest = buffer;
     let newlineIndex;
@@ -356,12 +358,12 @@ export function splitNdjsonLines(buffer) {
     return { lines, remainder: rest };
 }
 /** Trims and parses each complete line in `rawLines`, yielding only the ones that parsed to something other than `undefined` — a plain (non-async) generator so `decodeNdjsonStream` below can delegate to it with `yield*` instead of nesting a `for`/`if`/`if` inside its own `for await` loop. */
-export function* parseNdjsonLines(rawLines) {
+export function* parseNdjsonLines({ rawLines }) {
     for (const rawLine of rawLines) {
         const line = rawLine.trim();
         if (!line)
             continue; // tolerate a malformed/empty keep-alive line
-        const parsed = parseNdjsonLine(line);
+        const parsed = parseNdjsonLine({ line: line });
         if (parsed !== undefined)
             yield parsed;
     }
@@ -379,14 +381,14 @@ async function* decodeNdjsonStream(body) {
     let buffer = '';
     for await (const chunk of body) {
         buffer += typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
-        const { lines, remainder } = splitNdjsonLines(buffer);
+        const { lines, remainder } = splitNdjsonLines({ buffer: buffer });
         buffer = remainder;
-        yield* parseNdjsonLines(lines);
+        yield* parseNdjsonLines({ rawLines: lines });
     }
     const trailing = buffer.trim();
     if (!trailing)
         return;
-    const parsed = parseNdjsonLine(trailing);
+    const parsed = parseNdjsonLine({ line: trailing });
     if (parsed !== undefined)
         yield parsed; // else: final partial line was never completed — nothing usable to yield
 }
@@ -399,7 +401,7 @@ async function runSingleOllamaRequest(options, messages, emitEnd) {
     }
     onEvent({ type: 'status', label: 'requesting' });
     const state = {
-        guard: createRoleMarkerGuard('ollama-turn'),
+        guard: createRoleMarkerGuard({ messageId: 'ollama-turn' }),
         toolCalls: [],
         fullText: '',
         finishReason: null,
@@ -407,7 +409,7 @@ async function runSingleOllamaRequest(options, messages, emitEnd) {
     for await (const line of decodeNdjsonStream(body)) {
         if (!isRecord(line))
             continue;
-        const result = processOllamaLine(state, line, onEvent, emitEnd);
+        const result = processOllamaLine({ state: state, line: line, onEvent: onEvent, emitEnd: emitEnd });
         if (result === 'break' || result === 'done')
             break;
     }
@@ -421,7 +423,7 @@ async function runSingleOllamaRequest(options, messages, emitEnd) {
  * instead proceed to execute the pending tool calls — mirrors
  * `anthropic-messages.ts#anthropicLoopExitReason`'s pure decision/effect split.
  */
-export function ollamaLoopExitReason(outcome, toolTurns, maxToolTurns) {
+export function ollamaLoopExitReason({ outcome, toolTurns, maxToolTurns }) {
     if (outcome.finishReason !== 'tool_calls' || outcome.toolCalls.length === 0)
         return 'stop';
     if (toolTurns >= maxToolTurns)
@@ -429,7 +431,7 @@ export function ollamaLoopExitReason(outcome, toolTurns, maxToolTurns) {
     return null;
 }
 /** Builds the assistant continuation's `tool_calls` field — Ollama's native shape has no `id`/`type` on the wire (see `OllamaToolCallParam`'s doc). */
-export function buildOllamaAssistantToolCalls(toolCalls) {
+export function buildOllamaAssistantToolCalls({ toolCalls }) {
     return toolCalls.map((call) => ({ function: { name: call.name, arguments: call.input } }));
 }
 /**
@@ -438,7 +440,7 @@ export function buildOllamaAssistantToolCalls(toolCalls) {
  * see module doc's "Design decision: native `tool`-role images" section for why no separate
  * follow-up message is needed here, unlike `openai-chat.ts`/`azure-chat.ts`.
  */
-export async function executeOllamaToolCalls(executeTool, calls, onEvent) {
+export async function executeOllamaToolCalls({ executeTool, calls, onEvent }) {
     const toolResultMessages = [];
     for (const call of calls) {
         const rawResult = await executeTool(call);
@@ -465,7 +467,8 @@ export async function executeOllamaToolCalls(executeTool, calls, onEvent) {
  * function call. See `anthropic-messages.ts#runAnthropicToolTurn`'s doc for
  * the shared event-stream/`ended`-flag contract this mirrors exactly.
  */
-export async function runOllamaToolTurn(options) {
+export async function runOllamaToolTurn(requiredArgs, optionalArgs = {}) {
+    const options = { ...optionalArgs, ...requiredArgs };
     const maxToolTurns = options.maxToolTurns ?? DEFAULT_MAX_TOOL_TURNS;
     const executeTool = options.executeTool;
     const endGuard = createTurnEndGuard(options.onEvent, (reason) => ({ type: 'end', reason }));
@@ -478,7 +481,7 @@ export async function runOllamaToolTurn(options) {
         lastFinishReason = outcome.finishReason;
         if (endGuard.hasEnded())
             break;
-        const exitReason = ollamaLoopExitReason(outcome, toolTurns, maxToolTurns);
+        const exitReason = ollamaLoopExitReason({ outcome: outcome, toolTurns: toolTurns, maxToolTurns: maxToolTurns });
         if (exitReason) {
             emitEnd(exitReason);
             break;
@@ -488,8 +491,8 @@ export async function runOllamaToolTurn(options) {
             break;
         }
         toolTurns += 1;
-        const assistantToolCalls = buildOllamaAssistantToolCalls(outcome.toolCalls);
-        const toolResultMessages = await executeOllamaToolCalls(executeTool, outcome.toolCalls, options.onEvent);
+        const assistantToolCalls = buildOllamaAssistantToolCalls({ toolCalls: outcome.toolCalls });
+        const toolResultMessages = await executeOllamaToolCalls({ executeTool: executeTool, calls: outcome.toolCalls, onEvent: options.onEvent });
         messages = [
             ...messages,
             { role: 'assistant', content: outcome.text || null, tool_calls: assistantToolCalls },