@jini-ai/agent-runtime 0.3.10 → 0.4.0

package/dist/providers/anthropic-messages.js

@@ -1,3 +1,4 @@
+import { redactSecrets } from '@jini-ai/core';
 /**
  * @module providers/anthropic-messages
  *
@@ -74,7 +75,7 @@
  *    for the integration-level regression proof.
  */
 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 { createTurnEndGuard } from './turn-end-guard.js';
 const DEFAULT_ANTHROPIC_BASE_URL = 'https://api.anthropic.com';
@@ -83,11 +84,12 @@ const DEFAULT_MAX_TOOL_TURNS = 8;
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-export function anthropicRequestUrl(baseUrl) {
+export function anthropicRequestUrl({ baseUrl }) {
     const base = (baseUrl ?? DEFAULT_ANTHROPIC_BASE_URL).replace(/\/+$/, '');
     return `${base}/v1/messages`;
 }
-export function anthropicHeaders(options) {
+export function anthropicHeaders(requiredArgs, optionalArgs = {}) {
+    const options = { ...optionalArgs, ...requiredArgs };
     return {
         'content-type': 'application/json',
         'x-api-key': options.apiKey,
@@ -95,7 +97,7 @@ export function anthropicHeaders(options) {
         ...(options.extraHeaders ?? {}),
     };
 }
-export function anthropicRequestBody(options, messages) {
+export function anthropicRequestBody({ options, messages }) {
     return {
         model: options.model,
         max_tokens: options.maxTokens,
@@ -106,7 +108,7 @@ export function anthropicRequestBody(options, messages) {
         ...(options.tools && options.tools.length > 0 ? { tools: options.tools } : {}),
     };
 }
-export function extractAnthropicErrorDetail(rawText) {
+export function extractAnthropicErrorDetail({ rawText }) {
     try {
         const parsed = JSON.parse(rawText);
         if (isRecord(parsed) && isRecord(parsed.error) && typeof parsed.error.message === 'string') {
@@ -144,7 +146,7 @@ const MAX_IMAGE_BASE64_CHARS = Math.ceil((10 * 1024 * 1024 * 4) / 3);
  * @complexity O(1) — reads `data.length`, never decodes or parses the base64 payload.
  * @overallScore 100
  */
-export function invalidToolResultContentBlockReason(block) {
+export function invalidToolResultContentBlockReason({ block }) {
     if (block.type === 'text')
         return null;
     if (block.source.type === 'url')
@@ -175,11 +177,11 @@ export function invalidToolResultContentBlockReason(block) {
  * `invalidToolResultContentBlockReason`).
  * @overallScore 100
  */
-export function guardToolResult(result) {
+export function guardToolResult({ result }) {
     if (typeof result.content === 'string')
         return result;
     for (const block of result.content) {
-        const reason = invalidToolResultContentBlockReason(block);
+        const reason = invalidToolResultContentBlockReason({ block: block });
         if (reason) {
             return { content: `[rejected tool result] ${reason}`, isError: true };
         }
@@ -187,7 +189,7 @@ export function guardToolResult(result) {
     return result;
 }
 /** 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 parseAnthropicSseData(raw) {
+export function parseAnthropicSseData({ raw }) {
     let data;
     try {
         data = JSON.parse(raw);
@@ -197,7 +199,7 @@ export function parseAnthropicSseData(raw) {
     }
     return isRecord(data) ? data : null;
 }
-export function handleContentBlockStart(state, data) {
+export function handleContentBlockStart({ state, data }) {
     if (!isRecord(data.content_block) || typeof data.index !== 'number')
         return;
     const block = data.content_block;
@@ -216,7 +218,7 @@ export function handleContentBlockStart(state, data) {
  * `'break'` once the guard flags contamination (the caller ends the turn immediately), otherwise
  * `'continue'`.
  */
-export function handleAnthropicTextDelta(state, index, text, onEvent) {
+export function handleAnthropicTextDelta({ state, index, text, onEvent }) {
     const blockState = state.blocks.get(index);
     if (blockState)
         blockState.text += text;
@@ -225,7 +227,7 @@ export function handleAnthropicTextDelta(state, index, text, onEvent) {
     // delta in the same request can never reach this point already contaminated. (`feedText` itself
     // is still safe to call unconditionally regardless — it early-returns `''` once contaminated,
     // per its own doc.)
-    const safe = state.guard.feedText(text);
+    const safe = state.guard.feedText({ text: text });
     if (safe.length > 0) {
         state.fullText += safe;
         onEvent({ type: 'text_delta', delta: safe });
@@ -237,26 +239,26 @@ export function handleAnthropicTextDelta(state, index, text, onEvent) {
         onEvent(warn);
     return 'break';
 }
-export function handleAnthropicInputJsonDelta(state, index, partialJson) {
+export function handleAnthropicInputJsonDelta({ state, index, partialJson }) {
     const blockState = state.blocks.get(index);
     if (!blockState)
         return;
     blockState.inputJson += partialJson;
 }
-export function handleContentBlockDelta(state, data, onEvent) {
+export function handleContentBlockDelta({ state, data, onEvent }) {
     if (!isRecord(data.delta) || typeof data.index !== 'number')
         return 'continue';
     const { delta, index } = data;
     if (delta.type === 'text_delta' && typeof delta.text === 'string') {
-        return handleAnthropicTextDelta(state, index, delta.text, onEvent);
+        return handleAnthropicTextDelta({ state: state, index: index, text: delta.text, onEvent: onEvent });
     }
     if (delta.type === 'input_json_delta' && typeof delta.partial_json === 'string') {
-        handleAnthropicInputJsonDelta(state, index, delta.partial_json);
+        handleAnthropicInputJsonDelta({ state: state, index: index, partialJson: delta.partial_json });
     }
     return 'continue';
 }
 /** Parses one tool_use block's accumulated `input_json_delta` text, falling back to `{}` for empty or malformed JSON — mirrors OpenAI's identical fallback for `tool_calls[].function.arguments` in `openai-chat.ts`. */
-export function parseAccumulatedToolInputJson(inputJson) {
+export function parseAccumulatedToolInputJson({ inputJson }) {
     if (!inputJson.trim())
         return {};
     try {
@@ -266,18 +268,18 @@ export function parseAccumulatedToolInputJson(inputJson) {
         return {};
     }
 }
-export function handleContentBlockStop(state, data, onEvent) {
+export function handleContentBlockStop({ state, data, onEvent }) {
     if (typeof data.index !== 'number')
         return;
     const blockState = state.blocks.get(data.index);
     if (blockState?.type === 'tool_use' && blockState.toolId && blockState.toolName) {
-        const call = { id: blockState.toolId, name: blockState.toolName, input: parseAccumulatedToolInputJson(blockState.inputJson) };
+        const call = { id: blockState.toolId, name: blockState.toolName, input: parseAccumulatedToolInputJson({ inputJson: blockState.inputJson }) };
         state.toolCalls.push(call);
         onEvent({ type: 'tool_use', id: call.id, name: call.name, input: call.input });
     }
     state.blocks.delete(data.index);
 }
-export function handleMessageDelta(state, data, onEvent) {
+export function handleMessageDelta({ state, data, onEvent }) {
     if (isRecord(data.delta) && typeof data.delta.stop_reason === 'string') {
         state.stopReason = data.delta.stop_reason;
     }
@@ -286,13 +288,13 @@ export function handleMessageDelta(state, data, onEvent) {
         onEvent({ type: 'usage', usage: data.usage });
     }
 }
-export function handleAnthropicErrorFrame(data, onEvent, apiKey) {
+export function handleAnthropicErrorFrame({ data, onEvent, apiKey }) {
     const errorDetail = isRecord(data.error) && typeof data.error.message === 'string' ? data.error.message : 'upstream error';
     const errorType = isRecord(data.error) && typeof data.error.type === 'string' ? data.error.type : undefined;
-    onEvent({ type: 'error', message: redactSecrets(errorDetail, [apiKey]), ...(errorType ? { code: errorType } : {}) });
+    onEvent({ type: 'error', message: redactSecrets({ input: errorDetail }, { exactSecrets: [apiKey] }), ...(errorType ? { code: errorType } : {}) });
 }
 /** The SSE event's dispatch key: `data.type` when present (every real Anthropic frame carries one), else the record's `event:` line, else `''` — a key that intentionally matches no entry in {@link ANTHROPIC_FRAME_HANDLERS} (`message_start`/`message_stop`/`ping`/future event types fall through as no-ops, same as before this frame was a lookup table). */
-export function anthropicFrameKind(data, frameEvent) {
+export function anthropicFrameKind({ data, frameEvent }) {
     if (typeof data.type === 'string')
         return data.type;
     return frameEvent ?? '';
@@ -300,20 +302,20 @@ export function anthropicFrameKind(data, frameEvent) {
 /** One entry per SSE event kind this adapter reacts to. Replaces a sequential if-chain over `kind` — every branch below is now a single object-key lookup instead of N nesting-penalized `if` statements (see `runSingleAnthropicRequest`'s doc for the resulting flat loop). */
 const ANTHROPIC_FRAME_HANDLERS = {
     content_block_start: (state, data) => {
-        handleContentBlockStart(state, data);
+        handleContentBlockStart({ state: state, data: data });
         return { action: 'continue' };
     },
-    content_block_delta: (state, data, onEvent) => handleContentBlockDelta(state, data, onEvent) === 'break' ? { action: 'end', reason: 'contaminated' } : { action: 'continue' },
+    content_block_delta: (state, data, onEvent) => handleContentBlockDelta({ state: state, data: data, onEvent: onEvent }) === 'break' ? { action: 'end', reason: 'contaminated' } : { action: 'continue' },
     content_block_stop: (state, data, onEvent) => {
-        handleContentBlockStop(state, data, onEvent);
+        handleContentBlockStop({ state: state, data: data, onEvent: onEvent });
         return { action: 'continue' };
     },
     message_delta: (state, data, onEvent) => {
-        handleMessageDelta(state, data, onEvent);
+        handleMessageDelta({ state: state, data: data, onEvent: onEvent });
         return { action: 'continue' };
     },
     error: (_state, data, onEvent, apiKey) => {
-        handleAnthropicErrorFrame(data, onEvent, apiKey);
+        handleAnthropicErrorFrame({ data: data, onEvent: onEvent, apiKey: apiKey });
         return { action: 'end', reason: 'error' };
     },
 };
@@ -328,7 +330,7 @@ async function openAnthropicResponseStream(options, messages, emitEnd) {
     const { onEvent } = options;
     // DNS-resolving, not merely textual — see the identical note in `openai-chat.ts`. A literal
     // private IP was already rejected; a hostname resolving to one was not.
-    const baseUrlCheck = await validateBaseUrlResolved(options.baseUrl ?? DEFAULT_ANTHROPIC_BASE_URL, options.dnsLookup ?? defaultDnsLookup);
+    const baseUrlCheck = await validateBaseUrlResolved({ baseUrl: options.baseUrl ?? DEFAULT_ANTHROPIC_BASE_URL, lookup: options.dnsLookup ?? defaultDnsLookup });
     if (baseUrlCheck.error) {
         onEvent({ type: 'error', message: baseUrlCheck.error });
         emitEnd('error');
@@ -336,17 +338,17 @@ async function openAnthropicResponseStream(options, messages, emitEnd) {
     }
     let response;
     try {
-        response = await (options.fetchImpl ?? pinnedFetch)(anthropicRequestUrl(options.baseUrl), {
-            method: 'POST',
-            headers: anthropicHeaders(options),
-            body: JSON.stringify(anthropicRequestBody(options, messages)),
-            redirect: 'error',
-            ...(options.signal ? { signal: options.signal } : {}),
-        }, baseUrlCheck.pinnedAddress);
+        response = await (options.fetchImpl ?? pinnedFetch)({ url: anthropicRequestUrl({ baseUrl: options.baseUrl }), init: {
+                method: 'POST',
+                headers: (({ apiKey, model, messages, maxTokens, onEvent, ...optionalArgs }) => anthropicHeaders({ apiKey, model, messages, maxTokens, onEvent }, optionalArgs))(options),
+                body: JSON.stringify(anthropicRequestBody({ options: options, messages: messages })),
+                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;
     }
@@ -354,7 +356,7 @@ async function openAnthropicResponseStream(options, messages, emitEnd) {
         const rawText = await response.text();
         onEvent({
             type: 'error',
-            message: redactSecrets(extractAnthropicErrorDetail(rawText), [options.apiKey]),
+            message: redactSecrets({ input: extractAnthropicErrorDetail({ rawText: rawText }) }, { exactSecrets: [options.apiKey] }),
             code: String(response.status),
         });
         emitEnd('error');
@@ -376,24 +378,24 @@ async function runSingleAnthropicRequest(options, messages, emitEnd) {
     }
     onEvent({ type: 'status', label: 'requesting' });
     const state = {
-        guard: createRoleMarkerGuard('anthropic-turn'),
+        guard: createRoleMarkerGuard({ messageId: 'anthropic-turn' }),
         blocks: new Map(),
         toolCalls: [],
         fullText: '',
         stopReason: null,
         usage: null,
     };
-    for await (const frame of decodeSseStream(body)) {
+    for await (const frame of decodeSseStream({ source: body })) {
         // No `isEnded()` re-check at the top of this loop: every `emitEnd(...)` call site below is
         // immediately followed by `break`, so `ended` can never be true when a new iteration starts
         // — traced across all six call sites in this function and its handlers (the four pre-stream
         // early returns inside `openAnthropicResponseStream` plus the two in-loop
         // contamination/error branches below). Verified, not assumed; see
         // `__tests__/anthropic-messages.test.ts`'s duplicate-end-event regression case.
-        const data = parseAnthropicSseData(frame.data);
+        const data = parseAnthropicSseData({ raw: frame.data });
         if (!data)
             continue; // malformed/empty keep-alive frame, or a non-object payload
-        const handler = ANTHROPIC_FRAME_HANDLERS[anthropicFrameKind(data, frame.event)];
+        const handler = ANTHROPIC_FRAME_HANDLERS[anthropicFrameKind({ data: data, frameEvent: frame.event })];
         if (!handler)
             continue; // `message_start`, `message_stop`, `ping`, or a future event type — nothing to do
         const outcome = handler(state, data, onEvent, options.apiKey);
@@ -422,25 +424,25 @@ async function runSingleAnthropicRequest(options, messages, emitEnd) {
  * "stop" conditions (no/empty tool_use, no executor, turn ceiling reached) are exercised as plain
  * value-in/value-out assertions rather than through the full request/event-emission machinery.
  */
-export function anthropicLoopExitReason(outcome, toolTurns, maxToolTurns) {
+export function anthropicLoopExitReason({ outcome, toolTurns, maxToolTurns }) {
     if (outcome.stopReason !== 'tool_use' || outcome.toolCalls.length === 0)
         return 'stop';
     if (toolTurns >= maxToolTurns)
         return 'max_tool_turns';
     return null;
 }
-export function buildAnthropicAssistantContent(text, toolCalls) {
+export function buildAnthropicAssistantContent({ text, toolCalls }) {
     return [
         ...(text ? [{ type: 'text', text }] : []),
         ...toolCalls.map((call) => ({ type: 'tool_use', id: call.id, name: call.name, input: call.input })),
     ];
 }
 /** Runs every pending tool call in order and reduces the results into the `tool_result` blocks the next request's `user` message carries. Emits one `tool_result` event per call as it goes. */
-export async function executeAnthropicToolCalls(executeTool, calls, onEvent) {
+export async function executeAnthropicToolCalls({ executeTool, calls, onEvent }) {
     const toolResultBlocks = [];
     for (const call of calls) {
         const rawResult = await executeTool(call);
-        const result = guardToolResult(rawResult);
+        const result = guardToolResult({ result: rawResult });
         onEvent({ type: 'tool_result', toolUseId: call.id, content: result.content, isError: result.isError ?? false });
         toolResultBlocks.push({
             type: 'tool_result',
@@ -451,7 +453,8 @@ export async function executeAnthropicToolCalls(executeTool, calls, onEvent) {
     }
     return toolResultBlocks;
 }
-export async function runAnthropicToolTurn(options) {
+export async function runAnthropicToolTurn(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 }));
@@ -464,7 +467,7 @@ export async function runAnthropicToolTurn(options) {
         lastStopReason = outcome.stopReason;
         if (endGuard.hasEnded())
             break;
-        const exitReason = anthropicLoopExitReason(outcome, toolTurns, maxToolTurns);
+        const exitReason = anthropicLoopExitReason({ outcome: outcome, toolTurns: toolTurns, maxToolTurns: maxToolTurns });
         if (exitReason) {
             emitEnd(exitReason);
             break;
@@ -477,8 +480,8 @@ export async function runAnthropicToolTurn(options) {
             break;
         }
         toolTurns += 1;
-        const assistantContent = buildAnthropicAssistantContent(outcome.text, outcome.toolCalls);
-        const toolResultBlocks = await executeAnthropicToolCalls(executeTool, outcome.toolCalls, options.onEvent);
+        const assistantContent = buildAnthropicAssistantContent({ text: outcome.text, toolCalls: outcome.toolCalls });
+        const toolResultBlocks = await executeAnthropicToolCalls({ executeTool: executeTool, calls: outcome.toolCalls, onEvent: options.onEvent });
         messages = [
             ...messages,
             { role: 'assistant', content: assistantContent },

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

@@ -17,14 +17,14 @@
  * to `'2024-10-21'`, the default this repo's real OD predecessor used for
  * its own azure chat-completions proxy route (`apps/daemon/src/routes/
  * chat.ts`'s `[proxy:azure]` handler, confirmed by reading that file
- * directly in a sibling checkout — see `source-map.md`'s dated entry).
+ * directly in a sibling checkout — see `archived provenance ledger`'s dated entry).
  * That source additionally branches on whether `baseUrl` already contains
  * a versioned `/openai/v1` path (a newer Azure OpenAI API preview); that
  * branch is deliberately not carried forward here — this adapter targets
  * the one documented, stable URL/body shape per this task's approved scope
  * ("byte-identical to OpenAI, only URL/auth differ"). Its 400-retry
  * behavior IS carried forward (see "Token-limit fix" below) — round-4
- * external audit (`AUD-R4-001`) found the first port had dropped it,
+ * external audit found the first port had dropped it,
  * which fails every request against a GPT-5/o-series Azure deployment.
  *
  * **Auth**: `api-key: {apiKey}` header — NOT `Authorization: Bearer`,
@@ -70,6 +70,7 @@
  * follow-up (never interleaved — a real 400 otherwise), same per-image attribution label naming
  * the tool call it answers. See that module's doc for the full rationale; it is not repeated here
  * beyond this pointer to avoid the two copies drifting.
+ * See docs/decisions/DR-001-provider-native-tool-lifecycle.md.
  */
 import { type DnsLookupFn, type PinnedFetch } from './connection-guard.js';
 import { type OpenAiCompatibleRequestOutcome } from './openai-chat.js';
@@ -188,22 +189,35 @@ export interface AzureTurnResult {
  * instead proceed to execute the pending tool calls — mirrors
  * `anthropic-messages.ts#anthropicLoopExitReason`'s pure decision/effect split.
  */
-export declare function azureLoopExitReason(outcome: OpenAiCompatibleRequestOutcome, toolTurns: number, maxToolTurns: number): AzureTurnEndReason | null;
+export declare function azureLoopExitReason({ outcome, toolTurns, maxToolTurns }: {
+    outcome: OpenAiCompatibleRequestOutcome;
+    toolTurns: number;
+    maxToolTurns: number;
+}): AzureTurnEndReason | null;
 /** Builds the assistant continuation's `tool_calls` field — same shape as `openai-chat.ts#buildOpenAiAssistantToolCallMessage`'s `tool_calls`, since Azure's wire body is byte-identical to plain OpenAI's (see module doc). */
-export declare function buildAzureAssistantToolCalls(toolCalls: readonly AzureToolCall[]): AzureToolCallParam[];
+export declare function buildAzureAssistantToolCalls({ toolCalls }: {
+    toolCalls: readonly AzureToolCall[];
+}): AzureToolCallParam[];
 export interface AzureToolExecutionOutcome {
     readonly toolResultMessages: AzureMessageParam[];
     readonly followUpParts: AzureContentPart[];
 }
 /** Azure counterpart of `openai-chat.ts#executeOpenAiToolCalls` — same split (text-only `tool` message plus one labeled-image follow-up per batch) and same per-batch assembly discipline; see that function's doc and module doc's "synthetic follow-up message" note for why. */
-export declare function executeAzureToolCalls(executeTool: AzureToolExecutor, calls: readonly AzureToolCall[], onEvent: (event: AzureTurnEvent) => void): Promise<AzureToolExecutionOutcome>;
+export declare function executeAzureToolCalls({ executeTool, calls, onEvent }: {
+    executeTool: AzureToolExecutor;
+    calls: readonly AzureToolCall[];
+    onEvent: (event: AzureTurnEvent) => void;
+}): Promise<AzureToolExecutionOutcome>;
 /** Azure counterpart of `openai-chat.ts#buildOpenAiToolExchangeMessages` — appends the batch's `tool` messages plus, when present, the single labeled-image follow-up message. */
-export declare function buildAzureToolExchangeMessages(toolResultMessages: readonly AzureMessageParam[], followUpParts: readonly AzureContentPart[]): AzureMessageParam[];
+export declare function buildAzureToolExchangeMessages({ toolResultMessages, followUpParts }: {
+    toolResultMessages: readonly AzureMessageParam[];
+    followUpParts: readonly AzureContentPart[];
+}): AzureMessageParam[];
 /**
  * Runs a full Azure 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 runAzureToolTurn(options: AzureTurnOptions): Promise<AzureTurnResult>;
+export declare function runAzureToolTurn(requiredArgs: Pick<AzureTurnOptions, "apiKey" | "baseUrl" | "model" | "messages" | "onEvent">, optionalArgs?: Omit<AzureTurnOptions, "apiKey" | "baseUrl" | "model" | "messages" | "onEvent">): Promise<AzureTurnResult>;
 //# sourceMappingURL=azure-chat.d.ts.map

package/dist/providers/azure-chat.js

@@ -17,14 +17,14 @@
  * to `'2024-10-21'`, the default this repo's real OD predecessor used for
  * its own azure chat-completions proxy route (`apps/daemon/src/routes/
  * chat.ts`'s `[proxy:azure]` handler, confirmed by reading that file
- * directly in a sibling checkout — see `source-map.md`'s dated entry).
+ * directly in a sibling checkout — see `archived provenance ledger`'s dated entry).
  * That source additionally branches on whether `baseUrl` already contains
  * a versioned `/openai/v1` path (a newer Azure OpenAI API preview); that
  * branch is deliberately not carried forward here — this adapter targets
  * the one documented, stable URL/body shape per this task's approved scope
  * ("byte-identical to OpenAI, only URL/auth differ"). Its 400-retry
  * behavior IS carried forward (see "Token-limit fix" below) — round-4
- * external audit (`AUD-R4-001`) found the first port had dropped it,
+ * external audit found the first port had dropped it,
  * which fails every request against a GPT-5/o-series Azure deployment.
  *
  * **Auth**: `api-key: {apiKey}` header — NOT `Authorization: Bearer`,
@@ -70,6 +70,7 @@
  * follow-up (never interleaved — a real 400 otherwise), same per-image attribution label naming
  * the tool call it answers. See that module's doc for the full rationale; it is not repeated here
  * beyond this pointer to avoid the two copies drifting.
+ * See docs/decisions/DR-001-provider-native-tool-lifecycle.md.
  */
 import { defaultDnsLookup, validateBaseUrlResolved } from './connection-guard.js';
 import { runOpenAiCompatibleRequest } from './openai-chat.js';
@@ -107,19 +108,19 @@ function azureRequestBody(options, messages, tokenParam) {
 }
 /** Validates `options.baseUrl`, then delegates to `openai-chat.ts#runOpenAiCompatibleRequest` with Azure's own URL/header/body builders. */
 async function runSingleAzureRequest(options, messages, emitEnd, hasEnded) {
-    const baseUrlCheck = await validateBaseUrlResolved(options.baseUrl, options.dnsLookup ?? defaultDnsLookup);
+    const baseUrlCheck = await validateBaseUrlResolved({ baseUrl: options.baseUrl, lookup: options.dnsLookup ?? defaultDnsLookup });
     if (baseUrlCheck.error) {
         options.onEvent({ type: 'error', message: baseUrlCheck.error });
         emitEnd('error');
         return { finishReason: null, toolCalls: [], text: '' };
     }
     const maxTokens = effectiveAzureMaxTokens(options);
-    return runOpenAiCompatibleRequest({
+    return (({ url, headers, body, redactSecretsList, guardMessageId, providerLabel, onEvent, emitEnd, hasEnded, ...optionalArgs }) => runOpenAiCompatibleRequest({ url, headers, body, redactSecretsList, guardMessageId, providerLabel, onEvent, emitEnd, hasEnded }, optionalArgs))({
         url: azureRequestUrl(options.baseUrl, options.model, options.apiVersion),
         headers: azureHeaders(options),
-        body: azureRequestBody(options, messages, buildLegacyMaxTokensParam(maxTokens)),
-        retryableBody: (status, rawErrorText) => status === 400 && isUnsupportedMaxTokensError(rawErrorText)
-            ? azureRequestBody(options, messages, buildMaxCompletionTokensParam(maxTokens))
+        body: azureRequestBody(options, messages, buildLegacyMaxTokensParam({ maxTokens: maxTokens })),
+        retryableBody: (status, rawErrorText) => status === 400 && isUnsupportedMaxTokensError({ detail: rawErrorText })
+            ? azureRequestBody(options, messages, buildMaxCompletionTokensParam({ maxTokens: maxTokens }))
             : null,
         ...(baseUrlCheck.pinnedAddress ? { pinnedAddress: baseUrlCheck.pinnedAddress } : {}),
         ...(options.signal ? { signal: options.signal } : {}),
@@ -182,7 +183,7 @@ function splitAzureToolResultContent(content) {
  * instead proceed to execute the pending tool calls — mirrors
  * `anthropic-messages.ts#anthropicLoopExitReason`'s pure decision/effect split.
  */
-export function azureLoopExitReason(outcome, toolTurns, maxToolTurns) {
+export function azureLoopExitReason({ outcome, toolTurns, maxToolTurns }) {
     if (outcome.finishReason !== 'tool_calls' || outcome.toolCalls.length === 0)
         return 'stop';
     if (toolTurns >= maxToolTurns)
@@ -190,11 +191,11 @@ export function azureLoopExitReason(outcome, toolTurns, maxToolTurns) {
     return null;
 }
 /** Builds the assistant continuation's `tool_calls` field — same shape as `openai-chat.ts#buildOpenAiAssistantToolCallMessage`'s `tool_calls`, since Azure's wire body is byte-identical to plain OpenAI's (see module doc). */
-export function buildAzureAssistantToolCalls(toolCalls) {
+export function buildAzureAssistantToolCalls({ toolCalls }) {
     return toolCalls.map((call) => ({ id: call.id, type: 'function', function: { name: call.name, arguments: JSON.stringify(call.input) } }));
 }
 /** Azure counterpart of `openai-chat.ts#executeOpenAiToolCalls` — same split (text-only `tool` message plus one labeled-image follow-up per batch) and same per-batch assembly discipline; see that function's doc and module doc's "synthetic follow-up message" note for why. */
-export async function executeAzureToolCalls(executeTool, calls, onEvent) {
+export async function executeAzureToolCalls({ executeTool, calls, onEvent }) {
     const toolResultMessages = [];
     const followUpParts = [];
     for (const call of calls) {
@@ -212,7 +213,7 @@ export async function executeAzureToolCalls(executeTool, calls, onEvent) {
     return { toolResultMessages, followUpParts };
 }
 /** Azure counterpart of `openai-chat.ts#buildOpenAiToolExchangeMessages` — appends the batch's `tool` messages plus, when present, the single labeled-image follow-up message. */
-export function buildAzureToolExchangeMessages(toolResultMessages, followUpParts) {
+export function buildAzureToolExchangeMessages({ toolResultMessages, followUpParts }) {
     return [...toolResultMessages, ...(followUpParts.length > 0 ? [{ role: 'user', content: followUpParts }] : [])];
 }
 /**
@@ -221,7 +222,8 @@ export function buildAzureToolExchangeMessages(toolResultMessages, followUpParts
  * requests a function call. See `anthropic-messages.ts#runAnthropicToolTurn`'s
  * doc for the shared event-stream/`ended`-flag contract this mirrors exactly.
  */
-export async function runAzureToolTurn(options) {
+export async function runAzureToolTurn(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 }));
@@ -234,7 +236,7 @@ export async function runAzureToolTurn(options) {
         lastFinishReason = outcome.finishReason;
         if (endGuard.hasEnded())
             break;
-        const exitReason = azureLoopExitReason(outcome, toolTurns, maxToolTurns);
+        const exitReason = azureLoopExitReason({ outcome: outcome, toolTurns: toolTurns, maxToolTurns: maxToolTurns });
         if (exitReason) {
             emitEnd(exitReason);
             break;
@@ -244,12 +246,12 @@ export async function runAzureToolTurn(options) {
             break;
         }
         toolTurns += 1;
-        const assistantToolCalls = buildAzureAssistantToolCalls(outcome.toolCalls);
-        const { toolResultMessages, followUpParts } = await executeAzureToolCalls(executeTool, outcome.toolCalls, options.onEvent);
+        const assistantToolCalls = buildAzureAssistantToolCalls({ toolCalls: outcome.toolCalls });
+        const { toolResultMessages, followUpParts } = await executeAzureToolCalls({ executeTool: executeTool, calls: outcome.toolCalls, onEvent: options.onEvent });
         messages = [
             ...messages,
             { role: 'assistant', content: outcome.text || null, tool_calls: assistantToolCalls },
-            ...buildAzureToolExchangeMessages(toolResultMessages, followUpParts),
+            ...buildAzureToolExchangeMessages({ toolResultMessages: toolResultMessages, followUpParts: followUpParts }),
         ];
     }
     return { finishReason: lastFinishReason, toolTurns };