@jini-ai/agent-runtime 0.3.10 → 0.4.1

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

@@ -178,10 +178,17 @@ export interface OpenAiTurnResult {
 }
 /** Matches OD's own default (`apps/daemon/src/routes/chat.ts`'s openai/azure handlers both fall back to this when the caller doesn't supply one) — a real, explicit bound is always sent, never an unbounded request. */
 export declare const DEFAULT_OPENAI_MAX_TOKENS = 8192;
-export declare function openAiRequestUrl(baseUrl: string | undefined): string;
-export declare function openAiHeaders(options: OpenAiTurnOptions): Record<string, string>;
-export declare function openAiRequestBody(options: OpenAiTurnOptions, messages: readonly OpenAiMessageParam[]): Record<string, unknown>;
-export declare function extractOpenAiErrorDetail(rawText: string): string;
+export declare function openAiRequestUrl({ baseUrl }: {
+    baseUrl: string | undefined;
+}): string;
+export declare function openAiHeaders(requiredArgs: Pick<OpenAiTurnOptions, "apiKey" | "model" | "messages" | "onEvent">, optionalArgs?: Omit<OpenAiTurnOptions, "apiKey" | "model" | "messages" | "onEvent">): Record<string, string>;
+export declare function openAiRequestBody({ options, messages }: {
+    options: OpenAiTurnOptions;
+    messages: readonly OpenAiMessageParam[];
+}): Record<string, unknown>;
+export declare function extractOpenAiErrorDetail({ rawText }: {
+    rawText: string;
+}): string;
 export interface PendingToolCall {
     id: string;
     name: string;
@@ -233,24 +240,48 @@ export interface OpenAiStreamState {
     usage: Record<string, unknown> | null;
 }
 /** Parses one SSE frame's data as a JSON object, or `null` for a malformed/empty keep-alive frame or a non-object payload — both are tolerated by the caller as "nothing to do this frame". */
-export declare function parseOpenAiSseData(raw: string): Record<string, unknown> | null;
-export declare function applyOpenAiStreamUsage(state: OpenAiStreamState, data: Record<string, unknown>, onEvent: (event: OpenAiTurnEvent) => void): void;
+export declare function parseOpenAiSseData({ raw }: {
+    raw: string;
+}): Record<string, unknown> | null;
+export declare function applyOpenAiStreamUsage({ state, data, onEvent }: {
+    state: OpenAiStreamState;
+    data: Record<string, unknown>;
+    onEvent: (event: OpenAiTurnEvent) => void;
+}): void;
 /** The chunk's first (and, for Chat Completions, only) choice — `null` when the chunk carries no choice at all (e.g. a usage-only trailer chunk). */
-export declare function firstOpenAiChoice(data: Record<string, unknown>): Record<string, unknown> | null;
+export declare function firstOpenAiChoice({ data }: {
+    data: Record<string, unknown>;
+}): Record<string, unknown> | null;
 /**
  * Feeds one text delta through the role-marker guard and emits the safe portion. Returns
  * `'break'` once the guard flags contamination (the caller ends the turn immediately), otherwise
  * `'continue'` — same contract as `anthropic-messages.ts#handleAnthropicTextDelta`.
  */
-export declare function handleOpenAiTextContentDelta(state: OpenAiStreamState, content: string, onEvent: (event: OpenAiTurnEvent) => void): 'continue' | 'break';
+export declare function handleOpenAiTextContentDelta({ state, content, onEvent }: {
+    state: OpenAiStreamState;
+    content: string;
+    onEvent: (event: OpenAiTurnEvent) => void;
+}): 'continue' | 'break';
 /** Builds a fresh `PendingToolCall` from the streaming chunk that first mentions a given tool-call index — OpenAI sends `id`/`function.name` once, on that first chunk, then dribbles `function.arguments` in across subsequent chunks (accumulated separately by the caller). */
-export declare function newPendingOpenAiToolCall(rawCall: Record<string, unknown>, index: number): PendingToolCall;
+export declare function newPendingOpenAiToolCall({ rawCall, index }: {
+    rawCall: Record<string, unknown>;
+    index: number;
+}): PendingToolCall;
 /** Accumulates one `delta.tool_calls[]` entry from a streaming chunk into its running `PendingToolCall`. */
-export declare function accumulateOpenAiToolCallDelta(state: OpenAiStreamState, rawCall: unknown): void;
+export declare function accumulateOpenAiToolCallDelta({ state, rawCall }: {
+    state: OpenAiStreamState;
+    rawCall: unknown;
+}): void;
 /** Reduces one chunk's `choices[0]` — `finish_reason`, text content, and tool-call deltas — into `state`. Returns `'break'` when the text-delta guard detects contamination. */
-export declare function handleOpenAiChoiceDelta(state: OpenAiStreamState, choice: Record<string, unknown>, onEvent: (event: OpenAiTurnEvent) => void): 'continue' | 'break';
+export declare function handleOpenAiChoiceDelta({ state, choice, onEvent }: {
+    state: OpenAiStreamState;
+    choice: Record<string, unknown>;
+    onEvent: (event: OpenAiTurnEvent) => void;
+}): 'continue' | 'break';
 /** Parses one accumulated tool call's `argsJson`, falling back to `{}` for empty or malformed JSON — mirrors Anthropic's identical fallback for `input_json_delta` accumulation in `anthropic-messages.ts`. */
-export declare function resolveOpenAiToolCalls(pending: ReadonlyMap<number, PendingToolCall>): OpenAiToolCall[];
+export declare function resolveOpenAiToolCalls({ pending }: {
+    pending: ReadonlyMap<number, PendingToolCall>;
+}): OpenAiToolCall[];
 export type OpenAiFrameResult = 'continue' | 'done' | 'contaminated';
 /**
  * Reduces one decoded SSE frame into `state`, reporting what the caller's loop should do next:
@@ -259,7 +290,11 @@ export type OpenAiFrameResult = 'continue' | 'done' | 'contaminated';
  * turns what would be four sequential, nesting-penalized `if`s into a single function call plus
  * one outcome check — see `runOpenAiCompatibleRequest`'s loop below.
  */
-export declare function processOpenAiStreamFrame(state: OpenAiStreamState, frame: DecodedSseEvent, onEvent: (event: OpenAiTurnEvent) => void): OpenAiFrameResult;
+export declare function processOpenAiStreamFrame({ state, frame, onEvent }: {
+    state: OpenAiStreamState;
+    frame: DecodedSseEvent;
+    onEvent: (event: OpenAiTurnEvent) => void;
+}): OpenAiFrameResult;
 /**
  * Runs exactly one OpenAI-compatible (Chat Completions JSON wire format)
  * streaming HTTP request and reduces its SSE events into a single outcome.
@@ -275,7 +310,7 @@ export declare function processOpenAiStreamFrame(state: OpenAiStreamState, frame
  * `anthropic-messages.ts#runSingleAnthropicRequest`'s `emitEnd` contract —
  * see that function's doc.
  */
-export declare function runOpenAiCompatibleRequest(init: OpenAiCompatibleRequestInit): Promise<OpenAiCompatibleRequestOutcome>;
+export declare function runOpenAiCompatibleRequest(requiredArgs: Pick<OpenAiCompatibleRequestInit, "url" | "headers" | "body" | "redactSecretsList" | "guardMessageId" | "providerLabel" | "onEvent" | "emitEnd" | "hasEnded">, optionalArgs?: Omit<OpenAiCompatibleRequestInit, "url" | "headers" | "body" | "redactSecretsList" | "guardMessageId" | "providerLabel" | "onEvent" | "emitEnd" | "hasEnded">): Promise<OpenAiCompatibleRequestOutcome>;
 /**
  * Validates one content part against OpenAI's real format/size constraints. Returns the violation
  * reason, or `null` when the part is legal to send.
@@ -288,7 +323,9 @@ export declare function runOpenAiCompatibleRequest(init: OpenAiCompatibleRequest
  *
  * @complexity O(1) — reads `data.length`, never decodes or parses the base64 payload.
  */
-export declare function invalidOpenAiContentPartReason(part: OpenAiContentPart): string | null;
+export declare function invalidOpenAiContentPartReason({ part }: {
+    part: OpenAiContentPart;
+}): string | null;
 export interface SanitizedOpenAiToolResult {
     readonly content: string | readonly OpenAiContentPart[];
     readonly isError: boolean;
@@ -306,7 +343,9 @@ export interface SanitizedOpenAiToolResult {
  *
  * @complexity O(n) in the number of content parts; O(1) per part (see `invalidOpenAiContentPartReason`).
  */
-export declare function sanitizeOpenAiToolResult(result: OpenAiToolResult): SanitizedOpenAiToolResult;
+export declare function sanitizeOpenAiToolResult({ result }: {
+    result: OpenAiToolResult;
+}): SanitizedOpenAiToolResult;
 export interface SplitOpenAiToolResultContent {
     readonly toolMessageContent: string | readonly OpenAiTextPart[];
     readonly imageParts: readonly OpenAiImageUrlPart[];
@@ -323,13 +362,19 @@ export interface SplitOpenAiToolResultContent {
  *
  * @complexity O(n) in the number of content parts.
  */
-export declare function splitOpenAiToolResultContent(content: string | readonly OpenAiContentPart[]): SplitOpenAiToolResultContent;
+export declare function splitOpenAiToolResultContent({ content }: {
+    content: string | readonly OpenAiContentPart[];
+}): SplitOpenAiToolResultContent;
 /**
  * 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 openAiLoopExitReason(outcome: OpenAiCompatibleRequestOutcome, toolTurns: number, maxToolTurns: number): OpenAiTurnEndReason | null;
+export declare function openAiLoopExitReason({ outcome, toolTurns, maxToolTurns }: {
+    outcome: OpenAiCompatibleRequestOutcome;
+    toolTurns: number;
+    maxToolTurns: number;
+}): OpenAiTurnEndReason | null;
 export interface OpenAiToolExecutionOutcome {
     readonly toolResultMessages: OpenAiMessageParam[];
     readonly followUpParts: OpenAiContentPart[];
@@ -340,16 +385,26 @@ export interface OpenAiToolExecutionOutcome {
  * module doc's "Tool messages cannot carry an image" section for why the split exists and why the
  * follow-up is assembled once per batch rather than per call.
  */
-export declare function executeOpenAiToolCalls(executeTool: OpenAiToolExecutor, calls: readonly OpenAiToolCall[], onEvent: (event: OpenAiTurnEvent) => void): Promise<OpenAiToolExecutionOutcome>;
+export declare function executeOpenAiToolCalls({ executeTool, calls, onEvent }: {
+    executeTool: OpenAiToolExecutor;
+    calls: readonly OpenAiToolCall[];
+    onEvent: (event: OpenAiTurnEvent) => void;
+}): Promise<OpenAiToolExecutionOutcome>;
 /** Builds the assistant turn that records the model's pending tool calls in `messages` history — `content` falls back to `null` (never `''`) per the wire schema. */
-export declare function buildOpenAiAssistantToolCallMessage(text: string, toolCalls: readonly OpenAiToolCallParam[]): OpenAiMessageParam;
+export declare function buildOpenAiAssistantToolCallMessage({ text, toolCalls }: {
+    text: string;
+    toolCalls: readonly OpenAiToolCallParam[];
+}): OpenAiMessageParam;
 /** Appends the batch's `tool` messages plus, when present, the single labeled-image follow-up message — see module doc's "Tool messages cannot carry an image" section for why the follow-up is at most one message per batch. */
-export declare function buildOpenAiToolExchangeMessages(toolResultMessages: readonly OpenAiMessageParam[], followUpParts: readonly OpenAiContentPart[]): OpenAiMessageParam[];
+export declare function buildOpenAiToolExchangeMessages({ toolResultMessages, followUpParts }: {
+    toolResultMessages: readonly OpenAiMessageParam[];
+    followUpParts: readonly OpenAiContentPart[];
+}): OpenAiMessageParam[];
 /**
  * Runs a full OpenAI Chat Completions 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 runOpenAiToolTurn(options: OpenAiTurnOptions): Promise<OpenAiTurnResult>;
+export declare function runOpenAiToolTurn(requiredArgs: Pick<OpenAiTurnOptions, "apiKey" | "model" | "messages" | "onEvent">, optionalArgs?: Omit<OpenAiTurnOptions, "apiKey" | "model" | "messages" | "onEvent">): Promise<OpenAiTurnResult>;
 //# sourceMappingURL=openai-chat.d.ts.map

package/dist/providers/openai-chat.js

@@ -1,3 +1,4 @@
+import { redactSecrets } from '@jini-ai/core';
 /**
  * @module providers/openai-chat
  *
@@ -67,7 +68,7 @@
  * reasoning.
  */
 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 { decodeSseStream } from './sse-decode.js';
 import { buildOpenAIChatTokenParam } from './token-params.js';
 import { createTurnEndGuard } from './turn-end-guard.js';
@@ -79,30 +80,31 @@ export const DEFAULT_OPENAI_MAX_TOKENS = 8192;
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-export function openAiRequestUrl(baseUrl) {
+export function openAiRequestUrl({ baseUrl }) {
     const base = (baseUrl ?? DEFAULT_OPENAI_BASE_URL).replace(/\/+$/, '');
     return /\/v\d+(\/|$)/.test(base) ? `${base}/chat/completions` : `${base}/v1/chat/completions`;
 }
-export function openAiHeaders(options) {
+export function openAiHeaders(requiredArgs, optionalArgs = {}) {
+    const options = { ...optionalArgs, ...requiredArgs };
     return {
         'content-type': 'application/json',
         authorization: `Bearer ${options.apiKey}`,
         ...(options.extraHeaders ?? {}),
     };
 }
-export function openAiRequestBody(options, messages) {
+export function openAiRequestBody({ options, messages }) {
     const effectiveMaxTokens = typeof options.maxTokens === 'number' && options.maxTokens > 0 ? options.maxTokens : DEFAULT_OPENAI_MAX_TOKENS;
     return {
         model: options.model,
         stream: true,
         stream_options: { include_usage: true },
         messages,
-        ...buildOpenAIChatTokenParam(options.model, effectiveMaxTokens),
+        ...buildOpenAIChatTokenParam({ model: options.model, maxTokens: effectiveMaxTokens }),
         ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
         ...(options.tools && options.tools.length > 0 ? { tools: options.tools } : {}),
     };
 }
-export function extractOpenAiErrorDetail(rawText) {
+export function extractOpenAiErrorDetail({ rawText }) {
     try {
         const parsed = JSON.parse(rawText);
         if (isRecord(parsed) && isRecord(parsed.error) && typeof parsed.error.message === 'string') {
@@ -115,7 +117,7 @@ export function extractOpenAiErrorDetail(rawText) {
     return rawText.trim().slice(0, 500);
 }
 /** Parses one SSE frame's data as a JSON object, or `null` for a malformed/empty keep-alive frame or a non-object payload — both are tolerated by the caller as "nothing to do this frame". */
-export function parseOpenAiSseData(raw) {
+export function parseOpenAiSseData({ raw }) {
     let data;
     try {
         data = JSON.parse(raw);
@@ -125,14 +127,14 @@ export function parseOpenAiSseData(raw) {
     }
     return isRecord(data) ? data : null;
 }
-export function applyOpenAiStreamUsage(state, data, onEvent) {
+export function applyOpenAiStreamUsage({ state, data, onEvent }) {
     if (!isRecord(data.usage))
         return;
     state.usage = data.usage;
     onEvent({ type: 'usage', usage: data.usage });
 }
 /** The chunk's first (and, for Chat Completions, only) choice — `null` when the chunk carries no choice at all (e.g. a usage-only trailer chunk). */
-export function firstOpenAiChoice(data) {
+export function firstOpenAiChoice({ data }) {
     const choices = Array.isArray(data.choices) ? data.choices : [];
     const choice = choices[0];
     return isRecord(choice) ? choice : null;
@@ -142,8 +144,8 @@ export function firstOpenAiChoice(data) {
  * `'break'` once the guard flags contamination (the caller ends the turn immediately), otherwise
  * `'continue'` — same contract as `anthropic-messages.ts#handleAnthropicTextDelta`.
  */
-export function handleOpenAiTextContentDelta(state, content, onEvent) {
-    const safe = state.guard.feedText(content);
+export function handleOpenAiTextContentDelta({ state, content, onEvent }) {
+    const safe = state.guard.feedText({ text: content });
     if (safe.length > 0) {
         state.fullText += safe;
         onEvent({ type: 'text_delta', delta: safe });
@@ -156,19 +158,19 @@ export function handleOpenAiTextContentDelta(state, content, onEvent) {
     return 'break';
 }
 /** Builds a fresh `PendingToolCall` from the streaming chunk that first mentions a given tool-call index — OpenAI sends `id`/`function.name` once, on that first chunk, then dribbles `function.arguments` in across subsequent chunks (accumulated separately by the caller). */
-export function newPendingOpenAiToolCall(rawCall, index) {
+export function newPendingOpenAiToolCall({ rawCall, index }) {
     const id = typeof rawCall.id === 'string' ? rawCall.id : `call_${index}`;
     const fn = isRecord(rawCall.function) ? rawCall.function : {};
     const name = typeof fn.name === 'string' ? fn.name : '';
     return { id, name, argsJson: '' };
 }
 /** Accumulates one `delta.tool_calls[]` entry from a streaming chunk into its running `PendingToolCall`. */
-export function accumulateOpenAiToolCallDelta(state, rawCall) {
+export function accumulateOpenAiToolCallDelta({ state, rawCall }) {
     if (!isRecord(rawCall) || typeof rawCall.index !== 'number')
         return;
     let pending = state.toolCalls.get(rawCall.index);
     if (!pending) {
-        pending = newPendingOpenAiToolCall(rawCall, rawCall.index);
+        pending = newPendingOpenAiToolCall({ rawCall: rawCall, index: rawCall.index });
         state.toolCalls.set(rawCall.index, pending);
     }
     const fn = isRecord(rawCall.function) ? rawCall.function : null;
@@ -177,7 +179,7 @@ export function accumulateOpenAiToolCallDelta(state, rawCall) {
     }
 }
 /** Reduces one chunk's `choices[0]` — `finish_reason`, text content, and tool-call deltas — into `state`. Returns `'break'` when the text-delta guard detects contamination. */
-export function handleOpenAiChoiceDelta(state, choice, onEvent) {
+export function handleOpenAiChoiceDelta({ state, choice, onEvent }) {
     if (typeof choice.finish_reason === 'string') {
         state.finishReason = choice.finish_reason;
     }
@@ -185,18 +187,18 @@ export function handleOpenAiChoiceDelta(state, choice, onEvent) {
     if (!delta)
         return 'continue';
     if (typeof delta.content === 'string' && delta.content.length > 0) {
-        if (handleOpenAiTextContentDelta(state, delta.content, onEvent) === 'break')
+        if (handleOpenAiTextContentDelta({ state: state, content: delta.content, onEvent: onEvent }) === 'break')
             return 'break';
     }
     if (Array.isArray(delta.tool_calls)) {
         for (const rawCall of delta.tool_calls) {
-            accumulateOpenAiToolCallDelta(state, rawCall);
+            accumulateOpenAiToolCallDelta({ state: state, rawCall: rawCall });
         }
     }
     return 'continue';
 }
 /** Parses one accumulated tool call's `argsJson`, falling back to `{}` for empty or malformed JSON — mirrors Anthropic's identical fallback for `input_json_delta` accumulation in `anthropic-messages.ts`. */
-export function resolveOpenAiToolCalls(pending) {
+export function resolveOpenAiToolCalls({ pending }) {
     return Array.from(pending.values()).map((call) => {
         let input = {};
         if (call.argsJson.trim()) {
@@ -226,26 +228,26 @@ async function requestOpenAiCompatibleStream(init) {
     const { onEvent, emitEnd } = init;
     let response;
     try {
-        response = await (init.fetchImpl ?? pinnedFetch)(init.url, {
-            method: 'POST',
-            headers: init.headers,
-            body: JSON.stringify(init.body),
-            // The caller's SSRF check (`validateBaseUrlResolved`) only ever sees the
-            // ORIGINAL url. Following a redirect would let a public, guard-passing
-            // endpoint hand back a `302 -> http://169.254.169.254/...` and reach the
-            // address the guard exists to refuse — with the provider auth headers
-            // still attached. `model-catalog.ts`'s own fetch already refuses
-            // redirects for the same reason; a redirecting chat-completions endpoint
-            // is not a thing any supported provider does. `pinnedFetch` never
-            // follows one regardless (see its doc); `redirect: 'error'` here is
-            // self-documentation, not the mechanism.
-            redirect: 'error',
-            ...(init.signal ? { signal: init.signal } : {}),
-        }, init.pinnedAddress);
+        response = await (init.fetchImpl ?? pinnedFetch)({ url: init.url, init: {
+                method: 'POST',
+                headers: init.headers,
+                body: JSON.stringify(init.body),
+                // The caller's SSRF check (`validateBaseUrlResolved`) only ever sees the
+                // ORIGINAL url. Following a redirect would let a public, guard-passing
+                // endpoint hand back a `302 -> http://169.254.169.254/...` and reach the
+                // address the guard exists to refuse — with the provider auth headers
+                // still attached. `model-catalog.ts`'s own fetch already refuses
+                // redirects for the same reason; a redirecting chat-completions endpoint
+                // is not a thing any supported provider does. `pinnedFetch` never
+                // follows one regardless (see its doc); `redirect: 'error'` here is
+                // self-documentation, not the mechanism.
+                redirect: 'error',
+                ...(init.signal ? { signal: init.signal } : {}),
+            }, pinnedAddress: init.pinnedAddress });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        onEvent({ type: 'error', message: redactSecrets(message, init.redactSecretsList) });
+        onEvent({ type: 'error', message: redactSecrets({ input: message }, { exactSecrets: init.redactSecretsList }) });
         emitEnd('error');
         return { type: 'ended' };
     }
@@ -258,7 +260,7 @@ async function requestOpenAiCompatibleStream(init) {
         }
         onEvent({
             type: 'error',
-            message: redactSecrets(extractOpenAiErrorDetail(rawText), init.redactSecretsList),
+            message: redactSecrets({ input: extractOpenAiErrorDetail({ rawText: rawText }) }, { exactSecrets: init.redactSecretsList }),
             code: String(response.status),
         });
         emitEnd('error');
@@ -278,17 +280,17 @@ async function requestOpenAiCompatibleStream(init) {
  * turns what would be four sequential, nesting-penalized `if`s into a single function call plus
  * one outcome check — see `runOpenAiCompatibleRequest`'s loop below.
  */
-export function processOpenAiStreamFrame(state, frame, onEvent) {
+export function processOpenAiStreamFrame({ state, frame, onEvent }) {
     if (frame.data === DONE_SENTINEL)
         return 'done';
-    const data = parseOpenAiSseData(frame.data);
+    const data = parseOpenAiSseData({ raw: frame.data });
     if (!data)
         return 'continue'; // malformed/empty keep-alive frame, or a non-object payload
-    applyOpenAiStreamUsage(state, data, onEvent);
-    const choice = firstOpenAiChoice(data);
+    applyOpenAiStreamUsage({ state: state, data: data, onEvent: onEvent });
+    const choice = firstOpenAiChoice({ data: data });
     if (!choice)
         return 'continue';
-    return handleOpenAiChoiceDelta(state, choice, onEvent) === 'break' ? 'contaminated' : 'continue';
+    return handleOpenAiChoiceDelta({ state: state, choice: choice, onEvent: onEvent }) === 'break' ? 'contaminated' : 'continue';
 }
 /**
  * Runs exactly one OpenAI-compatible (Chat Completions JSON wire format)
@@ -305,24 +307,25 @@ export function processOpenAiStreamFrame(state, frame, onEvent) {
  * `anthropic-messages.ts#runSingleAnthropicRequest`'s `emitEnd` contract —
  * see that function's doc.
  */
-export async function runOpenAiCompatibleRequest(init) {
+export async function runOpenAiCompatibleRequest(requiredArgs, optionalArgs = {}) {
+    const init = { ...optionalArgs, ...requiredArgs };
     const { onEvent, hasEnded } = init;
     const fetchOutcome = await requestOpenAiCompatibleStream(init);
     if (fetchOutcome.type === 'ended') {
         return { finishReason: null, toolCalls: [], text: '' };
     }
     if (fetchOutcome.type === 'retry') {
-        return runOpenAiCompatibleRequest(fetchOutcome.retryInit);
+        return (({ url, headers, body, redactSecretsList, guardMessageId, providerLabel, onEvent, emitEnd, hasEnded, ...optionalArgs }) => runOpenAiCompatibleRequest({ url, headers, body, redactSecretsList, guardMessageId, providerLabel, onEvent, emitEnd, hasEnded }, optionalArgs))(fetchOutcome.retryInit);
     }
     onEvent({ type: 'status', label: 'requesting' });
     const state = {
-        guard: createRoleMarkerGuard(init.guardMessageId),
+        guard: createRoleMarkerGuard({ messageId: init.guardMessageId }),
         toolCalls: new Map(),
         fullText: '',
         finishReason: null,
         usage: null,
     };
-    for await (const frame of decodeSseStream(fetchOutcome.body)) {
+    for await (const frame of decodeSseStream({ source: fetchOutcome.body })) {
         // No `hasEnded()` re-check at the top of this loop: the only in-loop call to `emitEnd`
         // (contamination, below) is immediately followed by `break`, and every other call site is a
         // pre-loop early `return` — traced across all five call sites in this function and
@@ -330,7 +333,7 @@ export async function runOpenAiCompatibleRequest(init) {
         // `anthropic-messages.ts#runSingleAnthropicRequest`. `hasEnded()` is still consulted once,
         // after this loop, to decide whether pending tool_use events should still be emitted (a
         // contaminating delta can arrive on a *later* chunk than the one that set `finish_reason`).
-        const result = processOpenAiStreamFrame(state, frame, onEvent);
+        const result = processOpenAiStreamFrame({ state: state, frame: frame, onEvent: onEvent });
         if (result === 'done')
             break;
         if (result === 'contaminated') {
@@ -338,7 +341,7 @@ export async function runOpenAiCompatibleRequest(init) {
             break;
         }
     }
-    const resolvedToolCalls = resolveOpenAiToolCalls(state.toolCalls);
+    const resolvedToolCalls = resolveOpenAiToolCalls({ pending: state.toolCalls });
     if (state.finishReason === 'tool_calls' && !hasEnded()) {
         emitPendingOpenAiToolUseEvents(resolvedToolCalls, onEvent);
     }
@@ -350,16 +353,16 @@ async function runSingleOpenAiRequest(options, messages, emitEnd, hasEnded) {
     // so `https://internal.example.com -> 10.0.0.5` passed it and this runner connected to private
     // infrastructure on behalf of whoever supplied `baseUrl`. Matches what the Azure, Google and
     // Ollama runners in this directory already did.
-    const baseUrlCheck = await validateBaseUrlResolved(options.baseUrl ?? DEFAULT_OPENAI_BASE_URL, options.dnsLookup ?? defaultDnsLookup);
+    const baseUrlCheck = await validateBaseUrlResolved({ baseUrl: options.baseUrl ?? DEFAULT_OPENAI_BASE_URL, lookup: options.dnsLookup ?? defaultDnsLookup });
     if (baseUrlCheck.error) {
         options.onEvent({ type: 'error', message: baseUrlCheck.error });
         emitEnd('error');
         return { finishReason: null, toolCalls: [], text: '' };
     }
-    return runOpenAiCompatibleRequest({
-        url: openAiRequestUrl(options.baseUrl),
-        headers: openAiHeaders(options),
-        body: openAiRequestBody(options, messages),
+    return (({ url, headers, body, redactSecretsList, guardMessageId, providerLabel, onEvent, emitEnd, hasEnded, ...optionalArgs }) => runOpenAiCompatibleRequest({ url, headers, body, redactSecretsList, guardMessageId, providerLabel, onEvent, emitEnd, hasEnded }, optionalArgs))({
+        url: openAiRequestUrl({ baseUrl: options.baseUrl }),
+        headers: (({ apiKey, model, messages, onEvent, ...optionalArgs }) => openAiHeaders({ apiKey, model, messages, onEvent }, optionalArgs))(options),
+        body: openAiRequestBody({ options: options, messages: messages }),
         ...(baseUrlCheck.pinnedAddress ? { pinnedAddress: baseUrlCheck.pinnedAddress } : {}),
         ...(options.signal ? { signal: options.signal } : {}),
         ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
@@ -399,7 +402,7 @@ const OPENAI_DATA_URI_PATTERN = /^data:([^;,]+)(?:;charset=[^;,]+)?;base64,(.+)$
  *
  * @complexity O(1) — reads `data.length`, never decodes or parses the base64 payload.
  */
-export function invalidOpenAiContentPartReason(part) {
+export function invalidOpenAiContentPartReason({ part }) {
     if (part.type === 'text')
         return null;
     const dataUriMatch = OPENAI_DATA_URI_PATTERN.exec(part.image_url.url);
@@ -427,14 +430,14 @@ export function invalidOpenAiContentPartReason(part) {
  *
  * @complexity O(n) in the number of content parts; O(1) per part (see `invalidOpenAiContentPartReason`).
  */
-export function sanitizeOpenAiToolResult(result) {
+export function sanitizeOpenAiToolResult({ result }) {
     if (typeof result.content === 'string')
         return { content: result.content, isError: false };
     if (result.content.length > MAX_IMAGES_PER_OPENAI_TOOL_RESULT) {
         return { content: `tool result rejected: exceeds the ${MAX_IMAGES_PER_OPENAI_TOOL_RESULT}-image-per-request guard (${result.content.length} parts)`, isError: true };
     }
     for (const part of result.content) {
-        const reason = invalidOpenAiContentPartReason(part);
+        const reason = invalidOpenAiContentPartReason({ part: part });
         if (reason)
             return { content: `tool result rejected: ${reason}`, isError: true };
     }
@@ -452,7 +455,7 @@ export function sanitizeOpenAiToolResult(result) {
  *
  * @complexity O(n) in the number of content parts.
  */
-export function splitOpenAiToolResultContent(content) {
+export function splitOpenAiToolResultContent({ content }) {
     if (typeof content === 'string')
         return { toolMessageContent: content, imageParts: [] };
     const textParts = content.filter((part) => part.type === 'text');
@@ -465,7 +468,7 @@ export function splitOpenAiToolResultContent(content) {
  * instead proceed to execute the pending tool calls — mirrors
  * `anthropic-messages.ts#anthropicLoopExitReason`'s pure decision/effect split.
  */
-export function openAiLoopExitReason(outcome, toolTurns, maxToolTurns) {
+export function openAiLoopExitReason({ outcome, toolTurns, maxToolTurns }) {
     if (outcome.finishReason !== 'tool_calls' || outcome.toolCalls.length === 0)
         return 'stop';
     if (toolTurns >= maxToolTurns)
@@ -478,14 +481,14 @@ export function openAiLoopExitReason(outcome, toolTurns, maxToolTurns) {
  * module doc's "Tool messages cannot carry an image" section for why the split exists and why the
  * follow-up is assembled once per batch rather than per call.
  */
-export async function executeOpenAiToolCalls(executeTool, calls, onEvent) {
+export async function executeOpenAiToolCalls({ executeTool, calls, onEvent }) {
     const toolResultMessages = [];
     const followUpParts = [];
     for (const call of calls) {
         const result = await executeTool(call);
-        const sanitized = sanitizeOpenAiToolResult(result);
+        const sanitized = sanitizeOpenAiToolResult({ result: result });
         onEvent({ type: 'tool_result', toolUseId: call.id, content: sanitized.content, isError: sanitized.isError });
-        const split = splitOpenAiToolResultContent(sanitized.content);
+        const split = splitOpenAiToolResultContent({ content: sanitized.content });
         toolResultMessages.push({ role: 'tool', content: split.toolMessageContent, tool_call_id: call.id });
         if (split.imageParts.length > 0) {
             // Attribution label — without it, the model cannot tell this image apart from a human
@@ -498,11 +501,11 @@ export async function executeOpenAiToolCalls(executeTool, calls, onEvent) {
     return { toolResultMessages, followUpParts };
 }
 /** Builds the assistant turn that records the model's pending tool calls in `messages` history — `content` falls back to `null` (never `''`) per the wire schema. */
-export function buildOpenAiAssistantToolCallMessage(text, toolCalls) {
+export function buildOpenAiAssistantToolCallMessage({ text, toolCalls }) {
     return { role: 'assistant', content: text || null, tool_calls: toolCalls };
 }
 /** Appends the batch's `tool` messages plus, when present, the single labeled-image follow-up message — see module doc's "Tool messages cannot carry an image" section for why the follow-up is at most one message per batch. */
-export function buildOpenAiToolExchangeMessages(toolResultMessages, followUpParts) {
+export function buildOpenAiToolExchangeMessages({ toolResultMessages, followUpParts }) {
     return [...toolResultMessages, ...(followUpParts.length > 0 ? [{ role: 'user', content: followUpParts }] : [])];
 }
 /**
@@ -511,7 +514,8 @@ export function buildOpenAiToolExchangeMessages(toolResultMessages, followUpPart
  * function call. See `anthropic-messages.ts#runAnthropicToolTurn`'s doc for
  * the shared event-stream/`ended`-flag contract this mirrors exactly.
  */
-export async function runOpenAiToolTurn(options) {
+export async function runOpenAiToolTurn(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 }));
@@ -524,7 +528,7 @@ export async function runOpenAiToolTurn(options) {
         lastFinishReason = outcome.finishReason;
         if (endGuard.hasEnded())
             break;
-        const exitReason = openAiLoopExitReason(outcome, toolTurns, maxToolTurns);
+        const exitReason = openAiLoopExitReason({ outcome: outcome, toolTurns: toolTurns, maxToolTurns: maxToolTurns });
         if (exitReason) {
             emitEnd(exitReason);
             break;
@@ -539,11 +543,11 @@ export async function runOpenAiToolTurn(options) {
             type: 'function',
             function: { name: call.name, arguments: JSON.stringify(call.input) },
         }));
-        const { toolResultMessages, followUpParts } = await executeOpenAiToolCalls(executeTool, outcome.toolCalls, options.onEvent);
+        const { toolResultMessages, followUpParts } = await executeOpenAiToolCalls({ executeTool: executeTool, calls: outcome.toolCalls, onEvent: options.onEvent });
         messages = [
             ...messages,
-            buildOpenAiAssistantToolCallMessage(outcome.text, assistantToolCalls),
-            ...buildOpenAiToolExchangeMessages(toolResultMessages, followUpParts),
+            buildOpenAiAssistantToolCallMessage({ text: outcome.text, toolCalls: assistantToolCalls }),
+            ...buildOpenAiToolExchangeMessages({ toolResultMessages: toolResultMessages, followUpParts: followUpParts }),
         ];
     }
     return { finishReason: lastFinishReason, toolTurns };