@jini-ai/agent-runtime 0.3.9 → 0.4.0

package/dist/models.js

@@ -13,7 +13,7 @@ function liveModelCacheKey(agentId, scope) {
     const trimmedScope = typeof scope === 'string' ? scope.trim() : '';
     return trimmedScope ? `${agentId}\0${trimmedScope}` : agentId;
 }
-export function rememberLiveModels(agentId, models, scope) {
+export function rememberLiveModels({ agentId, models }, { scope } = {}) {
     if (!Array.isArray(models))
         return;
     const ids = models
@@ -23,14 +23,14 @@ export function rememberLiveModels(agentId, models, scope) {
     liveModelCache.set(key, new Set(ids));
     liveModelOrder.set(key, ids);
 }
-export function getRememberedLiveModels(agentId, scope) {
+export function getRememberedLiveModels({ agentId }, { scope } = {}) {
     const ids = liveModelOrder.get(liveModelCacheKey(agentId, scope)) ?? [];
     return ids.map((id) => ({ id, label: id }));
 }
-export function preferFreshLiveModels(freshModels, rememberedModels) {
+export function preferFreshLiveModels({ freshModels, rememberedModels }) {
     return freshModels.length > 0 ? freshModels : rememberedModels;
 }
-export function isKnownModel(def, modelId, scope) {
+export function isKnownModel({ def, modelId }, { scope } = {}) {
     if (!modelId)
         return false;
     const live = liveModelCache.get(liveModelCacheKey(def.id, scope));
@@ -49,7 +49,7 @@ export function isKnownModel(def, modelId, scope) {
 // surfaced to the UI, then fall back to the def's first concrete fallback
 // id so the spawn layer always has a real model to forward. Defs that DO
 // list 'default' (the common case) are left untouched.
-export function resolveModelForAgent(def, resolved, env = process.env, liveModelScope) {
+export function resolveModelForAgent({ def, resolved }, { env = process.env, liveModelScope } = {}) {
     if (resolved && resolved !== 'default')
         return resolved;
     // Host-process env override. Lets an operator pin a different fallback
@@ -80,7 +80,7 @@ export function resolveModelForAgent(def, resolved, env = process.env, liveModel
 // as a child-process arg — not a shell string — so injection isn't a
 // concern, but we still reject anything that could be misread as a flag
 // by a downstream CLI or that contains whitespace / control chars.
-export function sanitizeCustomModel(id) {
+export function sanitizeCustomModel({ id }) {
     if (typeof id !== 'string')
         return null;
     const trimmed = id.trim();

package/dist/opencode-log.d.ts

@@ -4,13 +4,21 @@ export interface OpenCodeServiceFailure {
     message: string;
     statusCode: number | null;
 }
-export declare function resolveOpenCodeLogDir(env: Record<string, string | undefined>): string | null;
-export declare function readLatestOpenCodeLogTail(logDir: string, options?: {
+export declare function resolveOpenCodeLogDir({ env }: {
+    env: Record<string, string | undefined>;
+}): string | null;
+export declare function readLatestOpenCodeLogTail({ logDir }: {
+    logDir: string;
+}, options?: {
     maxBytes?: number;
     since?: number;
 }): string | null;
-export declare function extractOpenCodeServiceFailure(logTail: string): OpenCodeServiceFailure | null;
-export declare function readOpenCodeServiceFailure(env: Record<string, string | undefined>, options?: {
+export declare function extractOpenCodeServiceFailure({ logTail }: {
+    logTail: string;
+}): OpenCodeServiceFailure | null;
+export declare function readOpenCodeServiceFailure({ env }: {
+    env: Record<string, string | undefined>;
+}, options?: {
     since?: number;
 }): OpenCodeServiceFailure | null;
 //# sourceMappingURL=opencode-log.d.ts.map

package/dist/opencode-log.js

@@ -19,7 +19,7 @@ import { classifyAgentServiceFailure } from './auth.js';
 // `$HOME/.local/share/opencode`, with session logs under `log/`. Mirror that
 // so we read the same files the spawned CLI wrote. Null when neither var is
 // set (we have no basis to guess a path).
-export function resolveOpenCodeLogDir(env) {
+export function resolveOpenCodeLogDir({ env }) {
     const xdg = typeof env.XDG_DATA_HOME === 'string' ? env.XDG_DATA_HOME.trim() : '';
     const home = typeof env.HOME === 'string' ? env.HOME.trim() : '';
     const base = xdg || (home ? path.join(home, '.local', 'share') : '');
@@ -38,7 +38,7 @@ export function resolveOpenCodeLogDir(env) {
 // callers are a (non-async) run-close handler and an inactivity watchdog,
 // once per failed OpenCode run. Returns null on any fs error (no dir yet,
 // perms).
-export function readLatestOpenCodeLogTail(logDir, options = {}) {
+export function readLatestOpenCodeLogTail({ logDir }, options = {}) {
     const { maxBytes = 2_000_000, since } = options;
     let names;
     try {
@@ -124,7 +124,7 @@ function defaultMessageForCode(code) {
 // We scope to that single line so the huge request body of *other* lines
 // can't leak in, key the classification on the unambiguous HTTP `statusCode`
 // first, and fall back to keyword matching the extracted message only.
-export function extractOpenCodeServiceFailure(logTail) {
+export function extractOpenCodeServiceFailure({ logTail }) {
     if (!logTail || !logTail.trim())
         return null;
     const lines = logTail.split(/\r?\n/);
@@ -143,7 +143,7 @@ export function extractOpenCodeServiceFailure(logTail) {
     const message = pickServiceErrorMessage(line);
     let code = statusCode != null ? codeFromStatus(statusCode) : null;
     if (!code && message)
-        code = classifyAgentServiceFailure(message);
+        code = classifyAgentServiceFailure({ text: message });
     if (!code)
         return null;
     return { code, message: message || defaultMessageForCode(code), statusCode };
@@ -151,13 +151,13 @@ export function extractOpenCodeServiceFailure(logTail) {
 // Convenience for a run-close handler / inactivity watchdog: resolve the
 // log dir from the spawned agent's env, read the newest log tail (bound to
 // the current run via `since`), and classify it.
-export function readOpenCodeServiceFailure(env, options = {}) {
-    const logDir = resolveOpenCodeLogDir(env);
+export function readOpenCodeServiceFailure({ env }, options = {}) {
+    const logDir = resolveOpenCodeLogDir({ env: env });
     if (!logDir)
         return null;
-    const tail = readLatestOpenCodeLogTail(logDir, options);
+    const tail = readLatestOpenCodeLogTail({ logDir: logDir }, options);
     if (!tail)
         return null;
-    return extractOpenCodeServiceFailure(tail);
+    return extractOpenCodeServiceFailure({ logTail: tail });
 }
 //# sourceMappingURL=opencode-log.js.map

package/dist/paths.d.ts

@@ -1,3 +1,7 @@
-export declare function expandConfiguredEnv(configuredEnv: unknown): Record<string, string>;
-export declare function expandHomePath(value: string): string;
+export declare function expandConfiguredEnv({ configuredEnv }: {
+    configuredEnv: unknown;
+}): Record<string, string>;
+export declare function expandHomePath({ value }: {
+    value: string;
+}): string;
 //# sourceMappingURL=paths.d.ts.map

package/dist/paths.js

@@ -7,18 +7,18 @@
  */
 import path from 'node:path';
 import { homedir } from 'node:os';
-export function expandConfiguredEnv(configuredEnv) {
+export function expandConfiguredEnv({ configuredEnv }) {
     const out = {};
     if (!configuredEnv || typeof configuredEnv !== 'object')
         return out;
     for (const [key, value] of Object.entries(configuredEnv)) {
         if (typeof value !== 'string')
             continue;
-        out[key] = expandHomePath(value);
+        out[key] = expandHomePath({ value: value });
     }
     return out;
 }
-export function expandHomePath(value) {
+export function expandHomePath({ value }) {
     if (value === '~')
         return homedir();
     if (value.startsWith('~/') || value.startsWith('~\\')) {

package/dist/pi-models.d.ts

@@ -9,5 +9,7 @@
  * dependency on it.
  */
 import type { RuntimeModelOption } from './types.js';
-export declare function parsePiModels(stdout: unknown): RuntimeModelOption[] | null;
+export declare function parsePiModels({ stdout }: {
+    stdout: unknown;
+}): RuntimeModelOption[] | null;
 //# sourceMappingURL=pi-models.d.ts.map

package/dist/pi-models.js

@@ -1,4 +1,4 @@
-export function parsePiModels(stdout) {
+export function parsePiModels({ stdout }) {
     const lines = String(stdout || '')
         .split('\n')
         .map((l) => l.trim())
@@ -14,7 +14,7 @@ export function parsePiModels(stdout) {
         // defined; the non-null assertion documents that runtime invariant
         // instead of a `noUncheckedIndexedAccess`-driven guard that could never
         // actually trigger (same treatment as this function's other port,
-        // `agent-protocol/pi-rpc/models.ts` — see source-map.md's "Barrel
+        // `agent-protocol/pi-rpc/models.ts` — see archived provenance ledger's "Barrel
         // merge" section for why two copies of this function exist).
         const line = lines[i];
         const parts = line.split(/\s+/);

package/dist/prompt-budget.d.ts

@@ -11,10 +11,23 @@
  * "Reduce the selected skills/design-system context…" (OD's own content
  * catalog). Replaced with the generic "selected context" phrasing so the
  * message doesn't assume a design-system-shaped host. Mechanics (byte
- * budgets, Windows quote-doubling math) are unchanged. See `source-map.md`.
+ * budgets, Windows quote-doubling math) are unchanged. See `archived provenance ledger`.
  */
 import type { RuntimeAgentDef, RuntimePromptBudgetError } from './types.js';
-export declare function checkPromptArgvBudget(def: RuntimeAgentDef | null | undefined, composed: unknown, platform?: NodeJS.Platform): RuntimePromptBudgetError | null;
-export declare function checkWindowsCmdShimCommandLineBudget(def: RuntimeAgentDef | null | undefined, resolvedBin: unknown, args: unknown): RuntimePromptBudgetError | null;
-export declare function checkWindowsDirectExeCommandLineBudget(def: RuntimeAgentDef | null | undefined, resolvedBin: unknown, args: unknown): RuntimePromptBudgetError | null;
+export declare function checkPromptArgvBudget({ def, composed }: {
+    def: RuntimeAgentDef | null | undefined;
+    composed: unknown;
+}, { platform }?: {
+    platform?: NodeJS.Platform;
+}): RuntimePromptBudgetError | null;
+export declare function checkWindowsCmdShimCommandLineBudget({ def, resolvedBin, args }: {
+    def: RuntimeAgentDef | null | undefined;
+    resolvedBin: unknown;
+    args: unknown;
+}): RuntimePromptBudgetError | null;
+export declare function checkWindowsDirectExeCommandLineBudget({ def, resolvedBin, args }: {
+    def: RuntimeAgentDef | null | undefined;
+    resolvedBin: unknown;
+    args: unknown;
+}): RuntimePromptBudgetError | null;
 //# sourceMappingURL=prompt-budget.d.ts.map

package/dist/prompt-budget.js

@@ -23,7 +23,7 @@ function resolveArgvPromptBudget(maxPromptArgBytes, platform) {
         return maxPromptArgBytes;
     return Math.max(maxPromptArgBytes, POSIX_ARGV_PROMPT_BUDGET);
 }
-export function checkPromptArgvBudget(def, composed, platform = process.platform) {
+export function checkPromptArgvBudget({ def, composed }, { platform = process.platform } = {}) {
     if (!def || typeof def.maxPromptArgBytes !== 'number')
         return null;
     const bytes = Buffer.byteLength(typeof composed === 'string' ? composed : '', 'utf8');
@@ -124,7 +124,7 @@ const WINDOWS_CREATE_PROCESS_HEADROOM = 256;
 // Pure: takes `resolvedBin` explicitly so a test on macOS can pass a fake
 // `C:\\…\\deepseek.cmd` path and exercise the same math the daemon would
 // run on Windows.
-export function checkWindowsCmdShimCommandLineBudget(def, resolvedBin, args) {
+export function checkWindowsCmdShimCommandLineBudget({ def, resolvedBin, args }) {
     if (!def || typeof def.maxPromptArgBytes !== 'number')
         return null;
     if (typeof resolvedBin !== 'string' || !/\.(bat|cmd)$/i.test(resolvedBin))
@@ -192,7 +192,7 @@ function looksLikeWindowsPath(p) {
 // pass a fake `C:\…\deepseek.exe` and exercise the same math the daemon
 // would run on Windows. The libuv quoting math lives in
 // `quoteForWindowsDirectExe` above.
-export function checkWindowsDirectExeCommandLineBudget(def, resolvedBin, args) {
+export function checkWindowsDirectExeCommandLineBudget({ def, resolvedBin, args }) {
     if (!def || typeof def.maxPromptArgBytes !== 'number')
         return null;
     if (typeof resolvedBin !== 'string' || resolvedBin.length === 0)

package/dist/prompt-file.d.ts

@@ -3,5 +3,9 @@ export type PreparedPromptFile = {
     path: string;
     cleanup: () => Promise<void>;
 };
-export declare function preparePromptFileForAgent(def: RuntimeAgentDef | null | undefined, prompt: string, label: string): Promise<PreparedPromptFile | null>;
+export declare function preparePromptFileForAgent({ def, prompt, label }: {
+    def: RuntimeAgentDef | null | undefined;
+    prompt: string;
+    label: string;
+}): Promise<PreparedPromptFile | null>;
 //# sourceMappingURL=prompt-file.d.ts.map

package/dist/prompt-file.js

@@ -10,7 +10,7 @@
 import { promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-export async function preparePromptFileForAgent(def, prompt, label) {
+export async function preparePromptFileForAgent({ def, prompt, label }) {
     if (!def?.promptViaFile)
         return null;
     const safeLabel = label.replace(/[^a-zA-Z0-9_.-]/g, '-').slice(0, 80) || 'prompt';

package/dist/providers/aihubmix.d.ts

@@ -29,7 +29,9 @@ export declare const AIHUBMIX_DEFAULT_BASE_URL = "https://aihubmix.com/v1";
  * fixed `APP-Code` attribution header. Callers spread the result into their
  * `fetch` headers and may add `content-type` etc. on top.
  */
-export declare function aihubmixHeaders(apiKey: string): Record<string, string>;
+export declare function aihubmixHeaders({ apiKey }: {
+    apiKey: string;
+}): Record<string, string>;
 /**
  * The APP-Code attribution header on its own (no auth). For the Anthropic /
  * Gemini routes, which carry their own auth header (`x-api-key` /
@@ -42,7 +44,9 @@ export declare function aihubmixHeaders(apiKey: string): Record<string, string>;
  */
 export declare function aihubmixAppCodeHeader(): Record<string, string>;
 export type AIHubMixProtocol = 'openai' | 'anthropic' | 'gemini';
-export declare function classifyAIHubMixModel(model: string): AIHubMixProtocol;
+export declare function classifyAIHubMixModel({ model }: {
+    model: string;
+}): AIHubMixProtocol;
 /**
  * Origin of the configured AIHubMix base URL — the three protocol clients all
  * derive their endpoint from it:
@@ -50,9 +54,14 @@ export declare function classifyAIHubMixModel(model: string): AIHubMixProtocol;
  *   anthropic -> `${origin}` (+ /v1/messages)
  *   gemini    -> `${origin}/gemini` (+ /v1beta/models/{model}:...)
  */
-export declare function aihubmixOriginFromBase(baseUrl: string): string;
+export declare function aihubmixOriginFromBase({ baseUrl }: {
+    baseUrl: string;
+}): string;
 /** Gemini-native generateContent endpoint for an AIHubMix image model. */
-export declare function aihubmixGeminiImageUrl(baseUrl: string, wireModel: string): string;
+export declare function aihubmixGeminiImageUrl({ baseUrl, wireModel }: {
+    baseUrl: string;
+    wireModel: string;
+}): string;
 export interface AIHubMixGeminiImageRequest {
     baseUrl: string;
     apiKey: string;
@@ -73,11 +82,25 @@ export interface AIHubMixGeminiImageRequest {
  * dispatcher, abort signal, redirect policy). Throws on a non-OK status or a
  * response without inline image data.
  */
-export declare function aihubmixGeminiImageBytes(req: AIHubMixGeminiImageRequest, doFetch: (url: string, init: RequestInit) => Promise<Response>): Promise<Buffer>;
-export declare function aihubmixWireModel(catalogId: string): string;
-export declare function aihubmixVideoSeconds(wireModel: string, requested: number): string;
+export declare function aihubmixGeminiImageBytes({ req, doFetch }: {
+    req: AIHubMixGeminiImageRequest;
+    doFetch: (requiredArgs: {
+        url: string;
+        init: RequestInit;
+    }) => Promise<Response>;
+}): Promise<Buffer>;
+export declare function aihubmixWireModel({ catalogId }: {
+    catalogId: string;
+}): string;
+export declare function aihubmixVideoSeconds({ wireModel, requested }: {
+    wireModel: string;
+    requested: number;
+}): string;
 export type AIHubMixCatalogType = 'llm' | 'image_generation' | 'tts' | 'video';
-export declare function aihubmixCatalogUrl(baseUrl: string, type: AIHubMixCatalogType): string;
+export declare function aihubmixCatalogUrl({ baseUrl, type }: {
+    baseUrl: string;
+    type: AIHubMixCatalogType;
+}): string;
 export interface AIHubMixCatalogModel {
     id: string;
     label: string;
@@ -94,6 +117,8 @@ export interface ParseAIHubMixCatalogOptions {
 }
 /** Parses the AIHubMix catalogue envelope into { id, label } options. Reads
  *  `model_id` (the wire name sent as `model`) and `model_name` (display). */
-export declare function parseAIHubMixCatalog(data: unknown, options?: ParseAIHubMixCatalogOptions): AIHubMixCatalogModel[];
+export declare function parseAIHubMixCatalog({ data }: {
+    data: unknown;
+}, options?: ParseAIHubMixCatalogOptions): AIHubMixCatalogModel[];
 export declare const AIHUBMIX_IMAGE_ASPECT_TO_SIZE: Record<string, string>;
 //# sourceMappingURL=aihubmix.d.ts.map

package/dist/providers/aihubmix.js

@@ -36,7 +36,7 @@ export const AIHUBMIX_DEFAULT_BASE_URL = 'https://aihubmix.com/v1';
  * fixed `APP-Code` attribution header. Callers spread the result into their
  * `fetch` headers and may add `content-type` etc. on top.
  */
-export function aihubmixHeaders(apiKey) {
+export function aihubmixHeaders({ apiKey }) {
     return {
         authorization: `Bearer ${apiKey}`,
         ...aihubmixAppCodeHeader(),
@@ -55,7 +55,7 @@ export function aihubmixHeaders(apiKey) {
 export function aihubmixAppCodeHeader() {
     return { 'APP-Code': AIHUBMIX_APP_CODE };
 }
-export function classifyAIHubMixModel(model) {
+export function classifyAIHubMixModel({ model }) {
     const m = (model || '').trim().toLowerCase();
     // Gemini: gemini*/imagen*, excluding the `-nothink`/`-search` suffixes and
     // any embedding model (those stay on the OpenAI-compatible path per §4.1).
@@ -75,7 +75,7 @@ export function classifyAIHubMixModel(model) {
  *   anthropic -> `${origin}` (+ /v1/messages)
  *   gemini    -> `${origin}/gemini` (+ /v1beta/models/{model}:...)
  */
-export function aihubmixOriginFromBase(baseUrl) {
+export function aihubmixOriginFromBase({ baseUrl }) {
     try {
         return new URL(baseUrl || AIHUBMIX_DEFAULT_BASE_URL).origin;
     }
@@ -84,8 +84,8 @@ export function aihubmixOriginFromBase(baseUrl) {
     }
 }
 /** Gemini-native generateContent endpoint for an AIHubMix image model. */
-export function aihubmixGeminiImageUrl(baseUrl, wireModel) {
-    return (`${aihubmixOriginFromBase(baseUrl)}/gemini/v1beta/models/`
+export function aihubmixGeminiImageUrl({ baseUrl, wireModel }) {
+    return (`${aihubmixOriginFromBase({ baseUrl: baseUrl })}/gemini/v1beta/models/`
         + `${encodeURIComponent(wireModel)}:generateContent`);
 }
 /**
@@ -100,24 +100,24 @@ export function aihubmixGeminiImageUrl(baseUrl, wireModel) {
  * dispatcher, abort signal, redirect policy). Throws on a non-OK status or a
  * response without inline image data.
  */
-export async function aihubmixGeminiImageBytes(req, doFetch) {
-    const url = aihubmixGeminiImageUrl(req.baseUrl, req.wireModel);
-    const resp = await doFetch(url, {
-        method: 'POST',
-        redirect: 'error',
-        headers: {
-            'content-type': 'application/json',
-            'x-goog-api-key': req.apiKey,
-            ...aihubmixAppCodeHeader(),
-        },
-        body: JSON.stringify({
-            contents: [{ role: 'user', parts: [{ text: req.prompt }] }],
-            generationConfig: {
-                responseModalities: ['TEXT', 'IMAGE'],
-                imageConfig: { aspectRatio: req.aspect },
+export async function aihubmixGeminiImageBytes({ req, doFetch }) {
+    const url = aihubmixGeminiImageUrl({ baseUrl: req.baseUrl, wireModel: req.wireModel });
+    const resp = await doFetch({ url: url, init: {
+            method: 'POST',
+            redirect: 'error',
+            headers: {
+                'content-type': 'application/json',
+                'x-goog-api-key': req.apiKey,
+                ...aihubmixAppCodeHeader(),
             },
-        }),
-    });
+            body: JSON.stringify({
+                contents: [{ role: 'user', parts: [{ text: req.prompt }] }],
+                generationConfig: {
+                    responseModalities: ['TEXT', 'IMAGE'],
+                    imageConfig: { aspectRatio: req.aspect },
+                },
+            }),
+        } });
     if (!resp.ok) {
         const text = await resp.text().catch(() => '');
         throw new Error(`aihubmix image (gemini) ${resp.status}: ${text.slice(0, 240)}`);
@@ -143,7 +143,7 @@ const AIHUBMIX_WIRE_MODELS = {
     'aihubmix-dall-e-3': 'dall-e-3',
     'aihubmix-tts-1': 'tts-1',
 };
-export function aihubmixWireModel(catalogId) {
+export function aihubmixWireModel({ catalogId }) {
     return AIHUBMIX_WIRE_MODELS[catalogId] ?? catalogId.replace(/^aihubmix-/, '');
 }
 // AIHubMix's unified /videos API uses a single `seconds` (string) field for
@@ -156,7 +156,7 @@ export function aihubmixWireModel(catalogId) {
 //   wan:  5, 10     (default 5)
 //   seedance/doubao + unknown: accepts a range — clamp to 3-12.
 // `wireModel` is the upstream name (prefix already stripped).
-export function aihubmixVideoSeconds(wireModel, requested) {
+export function aihubmixVideoSeconds({ wireModel, requested }) {
     const m = (wireModel || '').toLowerCase();
     const req = Number.isFinite(requested) ? requested : 5;
     let allowed = null;
@@ -174,7 +174,7 @@ export function aihubmixVideoSeconds(wireModel, requested) {
     const snapped = allowed.reduce((best, v) => (Math.abs(v - req) < Math.abs(best - req) ? v : best), allowed[0]);
     return String(snapped);
 }
-export function aihubmixCatalogUrl(baseUrl, type) {
+export function aihubmixCatalogUrl({ baseUrl, type }) {
     let origin;
     try {
         origin = new URL(baseUrl || AIHUBMIX_DEFAULT_BASE_URL).origin;
@@ -200,7 +200,7 @@ function aihubmixRowTypes(row) {
 }
 /** Parses the AIHubMix catalogue envelope into { id, label } options. Reads
  *  `model_id` (the wire name sent as `model`) and `model_name` (display). */
-export function parseAIHubMixCatalog(data, options) {
+export function parseAIHubMixCatalog({ data }, options = {}) {
     const rows = data?.data;
     if (!Array.isArray(rows))
         return [];

package/dist/providers/anthropic-messages.d.ts

@@ -207,10 +207,17 @@ export interface AnthropicTurnResult {
     readonly stopReason: string | null;
     readonly toolTurns: number;
 }
-export declare function anthropicRequestUrl(baseUrl: string | undefined): string;
-export declare function anthropicHeaders(options: AnthropicTurnOptions): Record<string, string>;
-export declare function anthropicRequestBody(options: AnthropicTurnOptions, messages: readonly AnthropicMessageParam[]): Record<string, unknown>;
-export declare function extractAnthropicErrorDetail(rawText: string): string;
+export declare function anthropicRequestUrl({ baseUrl }: {
+    baseUrl: string | undefined;
+}): string;
+export declare function anthropicHeaders(requiredArgs: Pick<AnthropicTurnOptions, "apiKey" | "model" | "messages" | "maxTokens" | "onEvent">, optionalArgs?: Omit<AnthropicTurnOptions, "apiKey" | "model" | "messages" | "maxTokens" | "onEvent">): Record<string, string>;
+export declare function anthropicRequestBody({ options, messages }: {
+    options: AnthropicTurnOptions;
+    messages: readonly AnthropicMessageParam[];
+}): Record<string, unknown>;
+export declare function extractAnthropicErrorDetail({ rawText }: {
+    rawText: string;
+}): string;
 /**
  * Validates one tool-result content block against the real API's format/size constraints.
  * Returns the violation reason, or `null` when the block is legal to send.
@@ -223,7 +230,9 @@ export declare function extractAnthropicErrorDetail(rawText: string): string;
  * @complexity O(1) — reads `data.length`, never decodes or parses the base64 payload.
  * @overallScore 100
  */
-export declare function invalidToolResultContentBlockReason(block: AnthropicToolResultContentBlock): string | null;
+export declare function invalidToolResultContentBlockReason({ block }: {
+    block: AnthropicToolResultContentBlock;
+}): string | null;
 /**
  * Runtime guard applied to every `AnthropicToolExecutor` result before it is wired onto the
  * outbound request or reported via `onEvent`. `AnthropicToolResult` is host-owned (see
@@ -242,7 +251,9 @@ export declare function invalidToolResultContentBlockReason(block: AnthropicTool
  * `invalidToolResultContentBlockReason`).
  * @overallScore 100
  */
-export declare function guardToolResult(result: AnthropicToolResult): AnthropicToolResult;
+export declare function guardToolResult({ result }: {
+    result: AnthropicToolResult;
+}): AnthropicToolResult;
 export interface AnthropicBlockState {
     readonly type: 'text' | 'tool_use' | 'other';
     text: string;
@@ -265,23 +276,58 @@ export interface AnthropicStreamState {
     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 parseAnthropicSseData(raw: string): Record<string, unknown> | null;
-export declare function handleContentBlockStart(state: AnthropicStreamState, data: Record<string, unknown>): void;
+export declare function parseAnthropicSseData({ raw }: {
+    raw: string;
+}): Record<string, unknown> | null;
+export declare function handleContentBlockStart({ state, data }: {
+    state: AnthropicStreamState;
+    data: Record<string, unknown>;
+}): void;
 /**
  * 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'`.
  */
-export declare function handleAnthropicTextDelta(state: AnthropicStreamState, index: number, text: string, onEvent: (event: AnthropicTurnEvent) => void): 'continue' | 'break';
-export declare function handleAnthropicInputJsonDelta(state: AnthropicStreamState, index: number, partialJson: string): void;
-export declare function handleContentBlockDelta(state: AnthropicStreamState, data: Record<string, unknown>, onEvent: (event: AnthropicTurnEvent) => void): 'continue' | 'break';
+export declare function handleAnthropicTextDelta({ state, index, text, onEvent }: {
+    state: AnthropicStreamState;
+    index: number;
+    text: string;
+    onEvent: (event: AnthropicTurnEvent) => void;
+}): 'continue' | 'break';
+export declare function handleAnthropicInputJsonDelta({ state, index, partialJson }: {
+    state: AnthropicStreamState;
+    index: number;
+    partialJson: string;
+}): void;
+export declare function handleContentBlockDelta({ state, data, onEvent }: {
+    state: AnthropicStreamState;
+    data: Record<string, unknown>;
+    onEvent: (event: AnthropicTurnEvent) => void;
+}): 'continue' | 'break';
 /** 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 declare function parseAccumulatedToolInputJson(inputJson: string): unknown;
-export declare function handleContentBlockStop(state: AnthropicStreamState, data: Record<string, unknown>, onEvent: (event: AnthropicTurnEvent) => void): void;
-export declare function handleMessageDelta(state: AnthropicStreamState, data: Record<string, unknown>, onEvent: (event: AnthropicTurnEvent) => void): void;
-export declare function handleAnthropicErrorFrame(data: Record<string, unknown>, onEvent: (event: AnthropicTurnEvent) => void, apiKey: string): void;
+export declare function parseAccumulatedToolInputJson({ inputJson }: {
+    inputJson: string;
+}): unknown;
+export declare function handleContentBlockStop({ state, data, onEvent }: {
+    state: AnthropicStreamState;
+    data: Record<string, unknown>;
+    onEvent: (event: AnthropicTurnEvent) => void;
+}): void;
+export declare function handleMessageDelta({ state, data, onEvent }: {
+    state: AnthropicStreamState;
+    data: Record<string, unknown>;
+    onEvent: (event: AnthropicTurnEvent) => void;
+}): void;
+export declare function handleAnthropicErrorFrame({ data, onEvent, apiKey }: {
+    data: Record<string, unknown>;
+    onEvent: (event: AnthropicTurnEvent) => void;
+    apiKey: string;
+}): void;
 /** 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 declare function anthropicFrameKind(data: Record<string, unknown>, frameEvent: string | null): string;
+export declare function anthropicFrameKind({ data, frameEvent }: {
+    data: Record<string, unknown>;
+    frameEvent: string | null;
+}): string;
 /**
  * Runs a full Anthropic Messages API turn, including the tool-execution
  * loop when `options.executeTool` is supplied and the model requests tool
@@ -300,9 +346,20 @@ export declare function anthropicFrameKind(data: Record<string, unknown>, frameE
  * "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 declare function anthropicLoopExitReason(outcome: SingleRequestOutcome, toolTurns: number, maxToolTurns: number): AnthropicTurnEndReason | null;
-export declare function buildAnthropicAssistantContent(text: string, toolCalls: readonly AnthropicToolCall[]): AnthropicContentBlockParam[];
+export declare function anthropicLoopExitReason({ outcome, toolTurns, maxToolTurns }: {
+    outcome: SingleRequestOutcome;
+    toolTurns: number;
+    maxToolTurns: number;
+}): AnthropicTurnEndReason | null;
+export declare function buildAnthropicAssistantContent({ text, toolCalls }: {
+    text: string;
+    toolCalls: readonly AnthropicToolCall[];
+}): AnthropicContentBlockParam[];
 /** 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 declare function executeAnthropicToolCalls(executeTool: AnthropicToolExecutor, calls: readonly AnthropicToolCall[], onEvent: (event: AnthropicTurnEvent) => void): Promise<AnthropicToolResultBlockParam[]>;
-export declare function runAnthropicToolTurn(options: AnthropicTurnOptions): Promise<AnthropicTurnResult>;
+export declare function executeAnthropicToolCalls({ executeTool, calls, onEvent }: {
+    executeTool: AnthropicToolExecutor;
+    calls: readonly AnthropicToolCall[];
+    onEvent: (event: AnthropicTurnEvent) => void;
+}): Promise<AnthropicToolResultBlockParam[]>;
+export declare function runAnthropicToolTurn(requiredArgs: Pick<AnthropicTurnOptions, "apiKey" | "model" | "messages" | "maxTokens" | "onEvent">, optionalArgs?: Omit<AnthropicTurnOptions, "apiKey" | "model" | "messages" | "maxTokens" | "onEvent">): Promise<AnthropicTurnResult>;
 //# sourceMappingURL=anthropic-messages.d.ts.map