@jini-ai/agent-runtime 0.3.10 → 0.4.0

package/dist/providers/tool-turn.js

@@ -0,0 +1,252 @@
+import { runAnthropicToolTurn } from './anthropic-messages.js';
+import { runAzureToolTurn } from './azure-chat.js';
+import { runGoogleToolTurn } from './google-messages.js';
+import { runOpenAiToolTurn } from './openai-chat.js';
+import { googleParametersOf, findNumericEnumPaths, coerceNumericEnumStringsToNumbers } from './google-schema.js';
+export { googleParametersOf, sanitizeGoogleSchema, findNumericEnumPaths, coerceNumericEnumStringsToNumbers } from './google-schema.js';
+/** Existing provider loops, ready for host composition; callers may replace any adapter. */
+export const providerTurnAdapters = Object.freeze({ anthropic: runAnthropicToolTurn, openai: runOpenAiToolTurn, azure: runAzureToolTurn, google: runGoogleToolTurn });
+const TOOL_ERROR_PREFIX = "[tool error] ";
+function toAnthropicToolContent(content) {
+    if (typeof content === "string")
+        return content;
+    return content.map((block) => block.type === "text"
+        ? { type: "text", text: block.text }
+        : { type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+}
+function toOpenAiToolContent(content) {
+    if (typeof content === "string")
+        return content;
+    return content.map((block) => block.type === "text" ? { type: "text", text: block.text } : { type: "image_url", image_url: { url: `data:${block.mimeType};base64,${block.data}` } });
+}
+function toGoogleToolContent(content) {
+    if (typeof content === "string")
+        return content;
+    return content.map((block) => (block.type === "text" ? { text: block.text } : { inlineData: { mimeType: block.mimeType, data: block.data } }));
+}
+function foldToolError(content, isError) {
+    if (!isError)
+        return content;
+    return typeof content === "string" ? `${TOOL_ERROR_PREFIX}${content}` : [{ type: "text", text: TOOL_ERROR_PREFIX.trimEnd() }, ...content];
+}
+function imagePartMimeType(part) {
+    const source = part.source;
+    if (part.type === "image" && typeof source?.media_type === "string")
+        return source.media_type;
+    const imageUrl = part.image_url;
+    if (part.type === "image_url" && typeof imageUrl?.url === "string")
+        return /^data:([^;,]+)/.exec(imageUrl.url)?.[1] ?? "url";
+    const inlineData = part.inlineData;
+    if (typeof inlineData?.mimeType === "string")
+        return inlineData.mimeType;
+    return null;
+}
+function describeToolResultContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return JSON.stringify(content);
+    return content
+        .map((part) => {
+        if (typeof part.text === "string")
+            return part.text;
+        const mimeType = imagePartMimeType(part);
+        return mimeType === null ? JSON.stringify(part) : `[image: ${mimeType}]`;
+    })
+        .join("\n");
+}
+function inputSchemaOf(descriptor) {
+    return descriptor.inputSchema && typeof descriptor.inputSchema === "object"
+        ? descriptor.inputSchema
+        : { type: "object", additionalProperties: false, required: [], properties: {} };
+}
+function normalizeTurnResult(result, capturedEndReason = null) {
+    return { stopReason: capturedEndReason ?? result.stopReason ?? result.finishReason ?? null, toolTurns: result.toolTurns };
+}
+async function runAnthropicTurn(input) {
+    const tools = input.tools.map((d) => ({
+        name: d.id,
+        ...(d.description !== undefined ? { description: d.description } : {}),
+        input_schema: inputSchemaOf(d),
+    }));
+    const messages = input.messages.map((m) => ({ role: m.role, content: m.content }));
+    const executeTool = async (call) => {
+        const result = await input.executeTool({ id: call.id, name: call.name, input: call.input });
+        return { content: toAnthropicToolContent(result.content), ...(result.isError !== undefined ? { isError: result.isError } : {}) };
+    };
+    let capturedEndReason = null;
+    const result = await (({ apiKey, model, messages, maxTokens, onEvent, ...optionalArgs }) => input.adapters.anthropic({ apiKey, model, messages, maxTokens, onEvent }, optionalArgs))({
+        apiKey: input.apiKey,
+        ...(input.baseUrl ? { baseUrl: input.baseUrl } : {}),
+        model: input.model,
+        system: input.system,
+        messages,
+        tools,
+        maxTokens: input.maxTokens ?? 8192,
+        ...(input.maxToolTurns !== undefined ? { maxToolTurns: input.maxToolTurns } : {}),
+        executeTool,
+        ...(input.signal ? { signal: input.signal } : {}),
+        onEvent: (event) => {
+            if (event.type === "fabricated_role_marker")
+                return;
+            if (event.type === "end")
+                capturedEndReason = event.reason;
+            if (event.type === "tool_result") {
+                input.onEvent({
+                    type: "tool_result",
+                    toolUseId: event.toolUseId,
+                    content: describeToolResultContent(event.content),
+                    isError: event.isError,
+                });
+                return;
+            }
+            input.onEvent(event);
+        },
+    });
+    return normalizeTurnResult(result, capturedEndReason);
+}
+async function runOpenAiTurn(input) {
+    const tools = input.tools.map((d) => ({
+        type: "function",
+        function: { name: d.id, ...(d.description !== undefined ? { description: d.description } : {}), parameters: inputSchemaOf(d) },
+    }));
+    const messages = [
+        { role: "system", content: input.system },
+        ...input.messages.map((m) => ({ role: m.role, content: m.content })),
+    ];
+    const executeTool = async (call) => {
+        const result = await input.executeTool({ id: call.id, name: call.name, input: call.input });
+        return { content: foldToolError(toOpenAiToolContent(result.content), result.isError) };
+    };
+    let capturedEndReason = null;
+    const result = await (({ apiKey, model, messages, onEvent, ...optionalArgs }) => input.adapters.openai({ apiKey, model, messages, onEvent }, optionalArgs))({
+        apiKey: input.apiKey,
+        ...(input.baseUrl ? { baseUrl: input.baseUrl } : {}),
+        model: input.model,
+        messages,
+        tools,
+        ...(input.maxTokens !== undefined ? { maxTokens: input.maxTokens } : {}),
+        ...(input.maxToolTurns !== undefined ? { maxToolTurns: input.maxToolTurns } : {}),
+        executeTool,
+        ...(input.signal ? { signal: input.signal } : {}),
+        onEvent: (event) => {
+            if (event.type === "fabricated_role_marker")
+                return;
+            if (event.type === "end")
+                capturedEndReason = event.reason;
+            if (event.type === "tool_result") {
+                const content = describeToolResultContent(event.content);
+                input.onEvent({ type: "tool_result", toolUseId: event.toolUseId, content, isError: event.isError || content.startsWith(TOOL_ERROR_PREFIX.trimEnd()) });
+                return;
+            }
+            input.onEvent(event);
+        },
+    });
+    return normalizeTurnResult(result, capturedEndReason);
+}
+async function runAzureTurn(input) {
+    if (!input.baseUrl) {
+        input.onEvent({ type: "error", message: "the azure protocol requires a base URL (each Azure OpenAI resource has its own endpoint)" });
+        input.onEvent({ type: "end", reason: "error" });
+        return { stopReason: "error", toolTurns: 0 };
+    }
+    const tools = input.tools.map((d) => ({
+        type: "function",
+        function: { name: d.id, ...(d.description !== undefined ? { description: d.description } : {}), parameters: inputSchemaOf(d) },
+    }));
+    const messages = [
+        { role: "system", content: input.system },
+        ...input.messages.map((m) => ({ role: m.role, content: m.content })),
+    ];
+    const executeTool = async (call) => {
+        const result = await input.executeTool({ id: call.id, name: call.name, input: call.input });
+        return { content: foldToolError(toOpenAiToolContent(result.content), result.isError) };
+    };
+    let capturedEndReason = null;
+    const result = await (({ apiKey, baseUrl, model, messages, onEvent, ...optionalArgs }) => input.adapters.azure({ apiKey, baseUrl, model, messages, onEvent }, optionalArgs))({
+        apiKey: input.apiKey,
+        baseUrl: input.baseUrl,
+        model: input.model,
+        messages,
+        tools,
+        ...(input.maxTokens !== undefined ? { maxTokens: input.maxTokens } : {}),
+        ...(input.maxToolTurns !== undefined ? { maxToolTurns: input.maxToolTurns } : {}),
+        executeTool,
+        ...(input.signal ? { signal: input.signal } : {}),
+        onEvent: (event) => {
+            if (event.type === "fabricated_role_marker")
+                return;
+            if (event.type === "end")
+                capturedEndReason = event.reason;
+            if (event.type === "tool_result") {
+                const content = describeToolResultContent(event.content);
+                input.onEvent({ type: "tool_result", toolUseId: event.toolUseId, content, isError: event.isError || content.startsWith(TOOL_ERROR_PREFIX.trimEnd()) });
+                return;
+            }
+            input.onEvent(event);
+        },
+    });
+    return normalizeTurnResult(result, capturedEndReason);
+}
+async function runGoogleTurn(input) {
+    const tools = [
+        { functionDeclarations: input.tools.map((d) => ({ name: d.id, ...(d.description !== undefined ? { description: d.description } : {}), parameters: googleParametersOf({ descriptor: d }) })) },
+    ];
+    const numericEnumPathsByToolName = new Map(input.tools.map((d) => [d.id, findNumericEnumPaths({ schema: inputSchemaOf(d) })]));
+    const contents = input.messages.map((m) => ({
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }],
+    }));
+    const executeTool = async (call) => {
+        const coercedInput = coerceNumericEnumStringsToNumbers({ input: call.input, paths: numericEnumPathsByToolName.get(call.name) ?? [] });
+        const result = await input.executeTool({ id: call.id, name: call.name, input: coercedInput });
+        return { content: toGoogleToolContent(result.content), ...(result.isError !== undefined ? { isError: result.isError } : {}) };
+    };
+    let capturedEndReason = null;
+    const result = await (({ apiKey, model, contents, onEvent, ...optionalArgs }) => input.adapters.google({ apiKey, model, contents, onEvent }, optionalArgs))({
+        apiKey: input.apiKey,
+        ...(input.baseUrl ? { baseUrl: input.baseUrl } : {}),
+        model: input.model,
+        system: input.system,
+        contents,
+        tools,
+        ...(input.maxTokens !== undefined ? { maxOutputTokens: input.maxTokens } : {}),
+        ...(input.maxToolTurns !== undefined ? { maxToolTurns: input.maxToolTurns } : {}),
+        executeTool,
+        ...(input.signal ? { signal: input.signal } : {}),
+        onEvent: (event) => {
+            if (event.type === "fabricated_role_marker")
+                return;
+            if (event.type === "end")
+                capturedEndReason = event.reason;
+            if (event.type === "tool_result") {
+                input.onEvent({
+                    type: "tool_result",
+                    toolUseId: event.toolUseId,
+                    content: describeToolResultContent(event.content),
+                    isError: event.isError,
+                });
+                return;
+            }
+            input.onEvent(event);
+        },
+    });
+    return normalizeTurnResult(result, capturedEndReason);
+}
+/** Runs one provider-neutral turn through the supplied adapters. The adapter end event takes precedence over a raw provider stop code.
+ * Local mapping is proportional to the descriptors, expanded schemas and emitted result parts; request and loop cost belongs to the adapter ports.
+ */
+export async function runProviderToolTurn(required, optional = {}) {
+    const input = { ...optional, ...required };
+    switch (input.protocol) {
+        case "anthropic":
+            return runAnthropicTurn(input);
+        case "openai":
+            return runOpenAiTurn(input);
+        case "azure":
+            return runAzureTurn(input);
+        case "google":
+            return runGoogleTurn(input);
+    }
+}
+//# sourceMappingURL=tool-turn.js.map

package/dist/qoder-stream.d.ts

@@ -2,7 +2,7 @@
  * @module qoder-stream
  *
  * Ported verbatim from OD's `apps/daemon/src/runtimes/qoder-stream.ts`
- * (only `node:buffer` as a dependency). See `source-map.md`.
+ * (only `node:buffer` as a dependency). See `archived provenance ledger`.
  *
  * Parses Qoder CLI's `--output-format stream-json` JSONL stream into the
  * small event set consumed by the chat UI. Qoder's top-level records are
@@ -38,8 +38,12 @@ export type QoderEvent = {
     line: string;
 };
 type QoderEventSink = (event: QoderEvent) => void;
-export declare function createQoderStreamHandler(onEvent: QoderEventSink): {
-    feed: (chunk: unknown) => void;
+export declare function createQoderStreamHandler({ onEvent }: {
+    onEvent: QoderEventSink;
+}): {
+    feed: ({ chunk }: {
+        chunk: unknown;
+    }) => void;
     flush: () => void;
 };
 export {};

package/dist/qoder-stream.js

@@ -2,7 +2,7 @@
  * @module qoder-stream
  *
  * Ported verbatim from OD's `apps/daemon/src/runtimes/qoder-stream.ts`
- * (only `node:buffer` as a dependency). See `source-map.md`.
+ * (only `node:buffer` as a dependency). See `archived provenance ledger`.
  *
  * Parses Qoder CLI's `--output-format stream-json` JSONL stream into the
  * small event set consumed by the chat UI. Qoder's top-level records are
@@ -60,7 +60,7 @@ function messageFromResult(obj) {
     }
     return 'Qoder run failed';
 }
-export function createQoderStreamHandler(onEvent) {
+export function createQoderStreamHandler({ onEvent }) {
     let buffer = '';
     let emittedThinkingStart = false;
     function handleObject(obj, rawLine) {
@@ -144,7 +144,7 @@ export function createQoderStreamHandler(onEvent) {
             onEvent({ type: 'raw', line });
         }
     }
-    function feed(chunk) {
+    function feed({ chunk }) {
         buffer += stringifyContent(chunk);
         let nl;
         while ((nl = buffer.indexOf('\n')) !== -1) {

package/dist/registry.d.ts

@@ -1,7 +1,9 @@
 import type { RuntimeAgentDef } from './types.js';
 export declare const BASE_AGENT_DEFS: RuntimeAgentDef[];
 export declare const AGENT_DEFS: RuntimeAgentDef[];
-export declare function getAgentDef(id: string): RuntimeAgentDef | null;
+export declare function getAgentDef({ id }: {
+    id: string;
+}): RuntimeAgentDef | null;
 /**
  * Whether a caller can inject external MCP servers (the host application's or this engine's own
  * tools) into a session run by this
@@ -18,5 +20,7 @@ export declare function getAgentDef(id: string): RuntimeAgentDef | null;
  *
  * @complexity Time/space: O(1).
  */
-export declare function runtimeSupportsExternalTools(def: Pick<RuntimeAgentDef, 'externalMcpInjection'>): boolean;
+export declare function runtimeSupportsExternalTools({ def }: {
+    def: Pick<RuntimeAgentDef, 'externalMcpInjection'>;
+}): boolean;
 //# sourceMappingURL=registry.d.ts.map

package/dist/registry.js

@@ -12,10 +12,10 @@
  * product-branded default path under the user's home dir, reads a
  * product-prefixed data-dir env var, and depends on OD's daemon-level
  * sandbox-runtime-config subsystem (out of this package's charter
- * entirely; see `source-map.md` for the exact original names). `AGENT_DEFS`
+ * entirely; see `archived provenance ledger` for the exact original names). `AGENT_DEFS`
  * here is exactly `BASE_AGENT_DEFS` (no local-profile merge). A future task
  * can reintroduce a de-branded, sandbox-free local-profile loader as an
- * injected port if a consumer needs it. See `source-map.md`.
+ * injected port if a consumer needs it. See `archived provenance ledger`.
  */
 import { aiderAgentDef, ampAgentDef, amrAgentDef, antigravityAgentDef, auggieAgentDef, claudeAgentDef, clineAgentDef, codebuddyAgentDef, codexAgentDef, copilotAgentDef, crushAgentDef, cursorAgentDef, deepseekAgentDef, devinAgentDef, droidAgentDef, geminiAgentDef, gooseAgentDef, grokBuildAgentDef, hermesAgentDef, kiloAgentDef, kimiAgentDef, kiroAgentDef, mimoAgentDef, opencodeAgentDef, piAgentDef, qoderAgentDef, qwenAgentDef, reasonixAgentDef, traeCliAgentDef, vibeAgentDef, } from './defs/index.js';
 export const BASE_AGENT_DEFS = [
@@ -58,7 +58,7 @@ for (const def of AGENT_DEFS) {
     }
     ids.add(def.id);
 }
-export function getAgentDef(id) {
+export function getAgentDef({ id }) {
     return AGENT_DEFS.find((a) => a.id === id) || null;
 }
 /**
@@ -77,7 +77,7 @@ export function getAgentDef(id) {
  *
  * @complexity Time/space: O(1).
  */
-export function runtimeSupportsExternalTools(def) {
+export function runtimeSupportsExternalTools({ def }) {
     return def.externalMcpInjection !== undefined;
 }
 //# sourceMappingURL=registry.js.map

package/dist/resolution.d.ts

@@ -1,2 +1,6 @@
-export declare function resolveAgentBin(id: string, configuredEnv?: Record<string, string>): string | null;
+export declare function resolveAgentBin({ id }: {
+    id: string;
+}, { configuredEnv }?: {
+    configuredEnv?: Record<string, string>;
+}): string | null;
 //# sourceMappingURL=resolution.d.ts.map

package/dist/resolution.js

@@ -10,10 +10,10 @@ import { resolveAgentExecutable } from './executables.js';
 // Used by the chat handler so spawn() gets the same executable that
 // detection reported as available — fixes Windows ENOENT when the bare
 // bin name isn't on the child process's PATH.
-export function resolveAgentBin(id, configuredEnv = {}) {
-    const def = getAgentDef(id);
+export function resolveAgentBin({ id }, { configuredEnv = {} } = {}) {
+    const def = getAgentDef({ id: id });
     if (!def?.bin)
         return null;
-    return resolveAgentExecutable(def, configuredEnv);
+    return resolveAgentExecutable({ def: def }, { configuredEnv: configuredEnv });
 }
 //# sourceMappingURL=resolution.js.map

package/dist/role-marker-guard.d.ts

@@ -13,7 +13,7 @@
  * Ported verbatim from OD's `apps/daemon/src/role-marker-guard.ts` (a
  * top-level daemon file, not under `runtimes/`, but consumed by
  * `claude-stream.ts` and self-contained with no product coupling — see
- * `source-map.md`).
+ * `archived provenance ledger`).
  */
 export declare const FABRICATED_ROLE_MARKER_RE: RegExp;
 export type RoleMarkerWarningEvent = {
@@ -25,7 +25,9 @@ export interface RoleMarkerGuard {
     /** Feed a text delta for the current message. Returns the safe portion
      *  to emit (may be shorter than `text` if a marker was found mid-chunk,
      *  or empty string if the entire chunk is past the cut point). */
-    feedText(text: string): string;
+    feedText(requiredArgs: {
+        text: string;
+    }): string;
     /** Whether a fabricated marker was detected (further text is dropped). */
     readonly contaminated: boolean;
     /** If contaminated, the warning event to emit. `null` if clean. */
@@ -40,9 +42,9 @@ export interface RoleMarkerGuard {
  *
  * Usage in a stream handler:
  *
- *   const guard = createRoleMarkerGuard(messageId);
+ *   const guard = createRoleMarkerGuard({ messageId });
  *   for (const delta of deltas) {
- *     const safe = guard.feedText(delta.text);
+ *     const safe = guard.feedText({ text: delta.text });
  *     if (safe.length > 0) onEvent({ type: 'text_delta', delta: safe });
  *     if (guard.contaminated) {
  *       onEvent(guard.warningEvent()!);
@@ -50,5 +52,7 @@ export interface RoleMarkerGuard {
  *     }
  *   }
  */
-export declare function createRoleMarkerGuard(messageId: string): RoleMarkerGuard;
+export declare function createRoleMarkerGuard({ messageId }: {
+    messageId: string;
+}): RoleMarkerGuard;
 //# sourceMappingURL=role-marker-guard.d.ts.map

package/dist/role-marker-guard.js

@@ -13,7 +13,7 @@
  * Ported verbatim from OD's `apps/daemon/src/role-marker-guard.ts` (a
  * top-level daemon file, not under `runtimes/`, but consumed by
  * `claude-stream.ts` and self-contained with no product coupling — see
- * `source-map.md`).
+ * `archived provenance ledger`).
  */
 // Regex matching fabricated role-marker lines injected by the model into
 // its own output. Anchored to start-of-line via (?:^|\n) so we don't
@@ -140,9 +140,9 @@ const TAIL_BUFFER_SIZE = 64;
  *
  * Usage in a stream handler:
  *
- *   const guard = createRoleMarkerGuard(messageId);
+ *   const guard = createRoleMarkerGuard({ messageId });
  *   for (const delta of deltas) {
- *     const safe = guard.feedText(delta.text);
+ *     const safe = guard.feedText({ text: delta.text });
  *     if (safe.length > 0) onEvent({ type: 'text_delta', delta: safe });
  *     if (guard.contaminated) {
  *       onEvent(guard.warningEvent()!);
@@ -150,7 +150,7 @@ const TAIL_BUFFER_SIZE = 64;
  *     }
  *   }
  */
-export function createRoleMarkerGuard(messageId) {
+export function createRoleMarkerGuard({ messageId }) {
     // Rolling tail of the bytes we have ALREADY EMITTED, capped at
     // TAIL_BUFFER_SIZE. Used as the prefix when matching against new
     // text so we catch markers that straddle a chunk boundary.
@@ -186,7 +186,7 @@ export function createRoleMarkerGuard(messageId) {
         get contaminated() {
             return _contaminated;
         },
-        feedText(text) {
+        feedText({ text }) {
             if (_contaminated)
                 return '';
             if (text.length === 0)

package/dist/terminal-launch.d.ts

@@ -7,5 +7,10 @@ export type TerminalLaunchResult = {
     platform: NodeJS.Platform;
     reason: string;
 };
-export declare function launchAgentInSystemTerminal(command: string, platform?: NodeJS.Platform, windowTitle?: string): Promise<TerminalLaunchResult>;
+export declare function launchAgentInSystemTerminal({ command }: {
+    command: string;
+}, { platform, windowTitle }?: {
+    platform?: NodeJS.Platform;
+    windowTitle?: string;
+}): Promise<TerminalLaunchResult>;
 //# sourceMappingURL=terminal-launch.d.ts.map

package/dist/terminal-launch.js

@@ -10,7 +10,7 @@
  *
  * Ported from OD's `apps/daemon/src/runtimes/terminal-launch.ts`
  * with one de-branding change: the Windows path opened a `cmd.exe` window
- * titled literally with the product's own name (see `source-map.md` for
+ * titled literally with the product's own name (see `archived provenance ledger` for
  * the exact original string). `launchAgentInSystemTerminal` now takes an
  * optional `windowTitle` (default `'Agent Sign-in'`).
  *
@@ -104,7 +104,7 @@ async function launchOnWindows(command, windowTitle) {
         };
     }
 }
-export async function launchAgentInSystemTerminal(command, platform = process.platform, windowTitle = 'Agent Sign-in') {
+export async function launchAgentInSystemTerminal({ command }, { platform = process.platform, windowTitle = 'Agent Sign-in' } = {}) {
     switch (platform) {
         case 'darwin':
             return launchOnDarwin(command);

package/dist/types.d.ts

@@ -9,7 +9,7 @@
  * runtime-probed sibling.
  *
  * Ported from OD's `apps/daemon/src/runtimes/types.ts`. Product-neutral
- * as found — see `source-map.md` for the full provenance table.
+ * as found — see `archived provenance ledger` for the full provenance table.
  */
 import type { ExecFileOptions } from 'node:child_process';
 import type { AgentDiagnostic } from '@jini-ai/protocol';
@@ -124,7 +124,9 @@ export type RuntimeCapabilityMap = Record<string, boolean>;
 export type RuntimeListModels = {
     args: string[];
     timeoutMs: number;
-    parse: (stdout: string) => RuntimeModelOption[] | null;
+    parse: (requiredArgs: {
+        stdout: string;
+    }) => RuntimeModelOption[] | null;
 };
 export type RuntimePromptBudgetError = {
     code: 'AGENT_PROMPT_TOO_LARGE';
@@ -173,7 +175,9 @@ export type RuntimeStdoutPolicy =
      * nothing better to fall back on than the unsanitized text, so a
      * throwing sanitizer is the leak it was added to prevent.
      */
-    readonly sanitize?: (fullText: string) => string;
+    readonly sanitize?: (requiredArgs: {
+        fullText: string;
+    }) => string;
 };
 /**
  * Context for {@link RuntimeLock.acquire}, so a def can decide whether the
@@ -273,7 +277,14 @@ export type RuntimeAgentDef = {
      * does that comparison for you whenever the relevant CLI is installed.
      */
     fallbackModelsAssertedAt?: string;
-    buildArgs: (prompt: string, imagePaths: string[], extraAllowedDirs?: string[], options?: RuntimeBuildOptions, runtimeContext?: RuntimeContext) => string[];
+    buildArgs: (requiredArgs: {
+        prompt: string;
+        imagePaths: string[];
+    }, optionalArgs?: {
+        extraAllowedDirs?: string[];
+        options?: RuntimeBuildOptions;
+        runtimeContext?: RuntimeContext;
+    }) => string[];
     streamFormat: string;
     fallbackBins?: string[];
     versionProbeTimeoutMs?: number;
@@ -285,7 +296,10 @@ export type RuntimeAgentDef = {
     eventParser?: string;
     env?: Record<string, string>;
     listModels?: RuntimeListModels;
-    fetchModels?: (resolvedBin: string, env: RuntimeEnv) => Promise<RuntimeModelOption[] | null>;
+    fetchModels?: (requiredArgs: {
+        resolvedBin: string;
+        env: RuntimeEnv;
+    }) => Promise<RuntimeModelOption[] | null>;
     reasoningOptions?: RuntimeReasoningOption[];
     /**
      * Narrows `reasoningOptions` to what the runtime's LIVE model list actually supports.
@@ -303,7 +317,9 @@ export type RuntimeAgentDef = {
      *
      * Stripped from `DetectedAgent` alongside the other closures — see `detection.ts#stripFns`.
      */
-    deriveReasoningOptions?: (models: readonly RuntimeModelOption[]) => RuntimeReasoningOption[] | null;
+    deriveReasoningOptions?: (requiredArgs: {
+        models: readonly RuntimeModelOption[];
+    }) => RuntimeReasoningOption[] | null;
     /**
      * See {@link RuntimeReasoningInModelId}. Mutually exclusive with
      * `reasoningOptions` in practice: a def declaring both would tell a picker

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/agent-runtime",
-  "version": "0.3.10",
+  "version": "0.4.0",
   "description": "Coding-agent runtime adapters: runtime registry, detection, launch, stream parsers, and the ACP/pi-rpc subprocess transport.",
   "license": "Apache-2.0",
   "repository": {
@@ -11,7 +11,13 @@
   "jini": {
     "domain": "agent",
     "kind": "runtime",
-    "runtime": "node"
+    "runtime": "node",
+    "entries": {
+      ".": "node",
+      "./providers/tool-turn": "node",
+      "./model-catalog/cache": "universal",
+      "./providers/sse-decode": "universal"
+    }
   },
   "type": "module",
   "sideEffects": false,
@@ -22,10 +28,41 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./providers/tool-turn": {
+      "types": "./dist/providers/tool-turn.d.ts",
+      "import": "./dist/providers/tool-turn.js",
+      "default": "./dist/providers/tool-turn.js"
+    },
+    "./model-catalog/cache": {
+      "types": "./dist/model-catalog-cache.d.ts",
+      "import": "./dist/model-catalog-cache.js",
+      "default": "./dist/model-catalog-cache.js"
+    },
+    "./providers/sse-decode": {
+      "types": "./dist/providers/sse-decode.d.ts",
+      "import": "./dist/providers/sse-decode.js",
+      "default": "./dist/providers/sse-decode.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "providers/tool-turn": [
+        "./dist/providers/tool-turn.d.ts"
+      ],
+      "model-catalog/cache": [
+        "./dist/model-catalog-cache.d.ts"
+      ],
+      "providers/sse-decode": [
+        "./dist/providers/sse-decode.d.ts"
+      ]
     }
   },
   "files": [
     "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
     "!dist/**/*.test.js",
     "!dist/**/*.test.d.ts",
     "!dist/**/*.test.js.map",
@@ -38,8 +75,10 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/platform": "0.3.0",
-    "@jini-ai/protocol": "0.3.1"
+    "@jini-ai/core": "^0.4.0",
+    "@jini-ai/platform": "0.5.0",
+    "@jini-ai/oauth": "0.2.0",
+    "@jini-ai/protocol": "0.4.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^2.1.9"