@jini-ai/daemon 0.6.0 → 0.6.1

package/dist/agent-executor/contracts.d.ts

@@ -2,7 +2,7 @@ import type { MessageAttachmentImage } from '../attachment-content.js';
 import type { spawn as nodeSpawn, ChildProcess } from 'node:child_process';
 import type { Principal } from '@jini-ai/core';
 import type { RunAgentPayload, RunErrorPayload } from '@jini-ai/protocol';
-import type { applyAgentLaunchEnv, ensureAgentCapabilities, resolveModelForLaunch, getAgentDef, resolveAgentLaunch, attachAcpSession, attachPiRpcSession, prepareAgentLogFile, preparePromptFileForAgent, AcpMcpServerInput, AcpPermissionHandler, PromptAugmenter } from '@jini-ai/agent-runtime';
+import type { AgentRuntimeState, applyAgentLaunchEnv, ensureAgentCapabilities, resolveModelForLaunch, getAgentDef, resolveAgentLaunch, attachAcpSession, attachPiRpcSession, prepareAgentLogFile, preparePromptFileForAgent, AcpMcpServerInput, AcpPermissionHandler, PromptAugmenter } from '@jini-ai/agent-runtime';
 import type { createCommandInvocation, listProcessSnapshots, ProcessSnapshot, StopProcessesResult } from '@jini-ai/platform';
 import type { RunByteJournal } from '../continuation/journal.js';
 import type { RunRetrySideEffectState } from '../run/core/index.js';
@@ -571,6 +571,9 @@ export interface FailureClassificationContext {
  */
 export type ClassifyFailure = (context: FailureClassificationContext) => boolean | Promise<boolean>;
 export interface CreateAgentExecutorOptions {
+    /** Host environment snapshot; baseline spawn keys and source config paths are allowlisted. */
+    readonly hostEnv?: NodeJS.ProcessEnv;
+    readonly runtimeState?: AgentRuntimeState;
     readonly lifecycle: RunLifecycle;
     /** Resolves/pins the concrete starting model against the actual launch scope. */
     readonly resolveModelForLaunch?: typeof resolveModelForLaunch;

package/dist/agent-executor/event-translation.js

@@ -39,11 +39,15 @@ function translateUsagePayload(rawEvent) {
     const rawUsage = isRecord(rawEvent.usage) ? rawEvent.usage : undefined;
     const usage = extractUsageTokens({ rawUsage: rawUsage });
     const costUsd = asOptionalNumber(rawEvent.costUsd);
+    const cumulativeCostUsd = asOptionalNumber(rawEvent.cumulativeCostUsd);
+    const costSessionId = asOptionalString(rawEvent.costSessionId);
     const durationMs = asOptionalNumber(rawEvent.durationMs);
     return {
         type: 'usage',
         ...(usage !== undefined ? { usage } : {}),
         ...(costUsd !== undefined ? { costUsd } : {}),
+        ...(cumulativeCostUsd !== undefined ? { cumulativeCostUsd } : {}),
+        ...(costSessionId !== undefined ? { costSessionId } : {}),
         ...(durationMs !== undefined ? { durationMs } : {}),
     };
 }

package/dist/agent-executor/events.js

@@ -26,7 +26,7 @@ function statusWithChildIdentity({ payload, childPid }, _optional = {}) {
  * parser's own documented behavior. Never called for `streamFormat:
  * 'plain'` — `wireChildLifecycle` handles that format inline with no
  * parser at all (see `ChildDrivenStreamFormat`'s doc).
- * @param def - The resolved agent def (only `.eventParser` is read beyond `streamFormat`).
+ * @param def - The resolved agent def (`.eventParser` and `.usageCostBasis` configure parser behavior).
  * @param streamFormat - `def.streamFormat`, already narrowed by {@link isSupportedStreamFormat}.
  * @param onEvent - Sink the parser calls once per parsed (or malformed-raw) event.
  * @returns A `{feed, flush}` handle for the chosen parser.
@@ -36,7 +36,7 @@ function statusWithChildIdentity({ payload, childPid }, _optional = {}) {
 function createStreamHandlerForDef(def, streamFormat, onEvent) {
     switch (streamFormat) {
         case 'claude-stream-json':
-            return createClaudeStreamHandler({ onEvent: onEvent });
+            return createClaudeStreamHandler({ onEvent: onEvent }, { costBasis: def.usageCostBasis ?? 'run' });
         case 'copilot-stream-json':
             return createCopilotStreamHandler({ onEvent: onEvent });
         case 'qoder-stream-json':
@@ -350,27 +350,63 @@ export function wireChildLifecycle(ctx) {
     // Set once this run has interrupted its agent: from then on a turn the interrupt aborted
     // (`aborted_*` stop reason) is not the run's last — the message that follows starts a new one.
     let interruptSent = false;
-    // stdout carry-over for spotting acks; only filled while an interrupt waits for one.
-    let ackScanBuffer = '';
-    /** Resolves every waiting interrupt whose `control_response` is in this stdout chunk. @complexity O(chunk length). */
-    function scanForInterruptAcks(text) {
-        if (pendingInterruptAcks.size === 0)
+    // Claude Code's background tasks still running (a subagent or shell it started in the
+    // background), from its latest `background_tasks_changed` line, which lists them all. While any
+    // runs, an `end_turn` is not the run's end: the CLI keeps going until they finish and reports on
+    // them, so stdin must stay open for mid-run messages. Closing it there (2026-10-10, plannie chat)
+    // made every message sent while two subagents worked come back 'not-running' and wait for the run
+    // to end — and at EOF the CLI stops background tasks at its own wait ceiling (10 minutes).
+    let backgroundTaskCount = 0;
+    // Set when a turn ended and stdin stayed open only for background tasks: no turn is running, so a
+    // mid-run message has nothing to interrupt, and the last task finishing closes stdin (below).
+    let heldForBackgroundTasks = false;
+    // stdout carry-over for the control lines below; holds at most the current partial line.
+    let controlScanBuffer = '';
+    /** Resolves the waiting interrupt this `control_response` line acknowledges, if any. @complexity O(line length). */
+    function settleInterruptAck(line) {
+        const requestId = controlResponseRequestId({ line: line });
+        const settle = requestId === undefined ? undefined : pendingInterruptAcks.get(requestId);
+        if (!settle)
             return;
-        ackScanBuffer += text;
-        const lines = ackScanBuffer.split('\n');
-        ackScanBuffer = lines.pop() ?? '';
+        pendingInterruptAcks.delete(requestId);
+        settle(true);
+    }
+    /**
+     * Tracks a `background_tasks_changed` line. The last background task finishing while stdin is
+     * held only for them closes it, exactly as the turn end would have: the CLI then answers what it
+     * still owes (the tasks' report) and exits. @complexity O(line length).
+     */
+    function updateBackgroundTasks(line) {
+        const count = backgroundTaskListLength({ line: line });
+        if (count === undefined)
+            return;
+        backgroundTaskCount = count;
+        if (count === 0 && heldForBackgroundTasks) {
+            heldForBackgroundTasks = false;
+            closeStdinOnce();
+        }
+    }
+    /**
+     * Reads the stdout lines a mid-run message depends on: interrupt acks and background-task
+     * changes. Only agents that take mid-run messages are scanned. A chunk with no newline is only
+     * appended, so a long line split across many chunks is split once, not once per chunk.
+     * @complexity O(chunk length) amortized.
+     */
+    function scanControlLines(text) {
+        if (!acceptsMidRunUserMessages({ def: def }))
+            return;
+        controlScanBuffer += text;
+        if (!text.includes('\n'))
+            return;
+        const lines = controlScanBuffer.split('\n');
+        controlScanBuffer = lines.pop() ?? '';
         for (const line of lines) {
-            if (!line.includes('"control_response"'))
-                continue;
-            const requestId = controlResponseRequestId({ line: line });
-            const settle = requestId === undefined ? undefined : pendingInterruptAcks.get(requestId);
-            if (!settle)
-                continue;
-            pendingInterruptAcks.delete(requestId);
-            settle(true);
+            // Both checked: either word can also appear inside the other kind of line's text.
+            if (line.includes('"control_response"'))
+                settleInterruptAck(line);
+            if (line.includes('"background_tasks_changed"'))
+                updateBackgroundTasks(line);
         }
-        if (pendingInterruptAcks.size === 0)
-            ackScanBuffer = '';
     }
     /**
      * Writes a structured (never string-concatenated — see `ContinuationOptions`'s doc on the
@@ -392,19 +428,24 @@ export function wireChildLifecycle(ctx) {
             enqueueEmit(() => journal.record({ runId: runId, entry: sentJournalEntry(content) }));
     }
     /**
-     * Whether a `turn_end` leaves stdin open for a live agent that takes mid-run messages, because
-     * the run is not over: a `tool_use` stop (the CLI runs the tool itself and carries on, and a
+     * Whether a `turn_end` leaves stdin open for a live agent that takes mid-run messages — and why:
+     * `'background-tasks'` when only background tasks keep the run going (no turn runs until the next
+     * message or task report), `'turn-continues'` for the reasons below, `'close'` otherwise. Open
+     * because the run is not over: a `tool_use` stop (the CLI runs the tool itself and carries on, and a
      * message sent while the tool runs must still reach it), any end while an interrupt still waits
      * for its ack (the message is about to be written), and the end of a turn an interrupt aborted
-     * (the message written after it starts the next turn). Every other end closes stdin, so the CLI
-     * exits once it has answered everything written before EOF.
+     * (the message written after it starts the next turn), and any end while background tasks still
+     * run (see `backgroundTaskCount`). Every other end closes stdin, so the CLI exits once it has
+     * answered everything written before EOF.
      */
-    function keepsStdinOpenAfterTurnEnd(stopReason) {
+    function stdinHoldAfterTurnEnd(stopReason) {
         if (!acceptsMidRunUserMessages({ def: def }))
-            return false;
+            return 'close';
         if (stopReason === 'tool_use' || pendingInterruptAcks.size > 0)
-            return true;
-        return interruptSent && stopReason !== undefined && stopReason.startsWith('aborted');
+            return 'turn-continues';
+        if (interruptSent && stopReason !== undefined && stopReason.startsWith('aborted'))
+            return 'turn-continues';
+        return backgroundTaskCount > 0 ? 'background-tasks' : 'close';
     }
     /**
      * Decides, per `turn_end`, whether to auto-resolve a pending tool_use through the injected
@@ -425,7 +466,9 @@ export function wireChildLifecycle(ctx) {
             resolveContinuationTransport({ def: def }) === 'stdin-injection' &&
             continuation.autonomousToolNames.has(toolUse.name);
         if (!shouldInject) {
-            if (!keepsStdinOpenAfterTurnEnd(stopReason))
+            const hold = stdinHoldAfterTurnEnd(stopReason);
+            heldForBackgroundTasks = hold === 'background-tasks';
+            if (hold === 'close')
                 closeStdinOnce();
             return;
         }
@@ -580,8 +623,9 @@ export function wireChildLifecycle(ctx) {
         }
         enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'stdout', data: { chunk: text } } }));
         // Before the parser: an ack and the aborted turn's end can share a chunk, and the turn end must
-        // see that no interrupt is still waiting (see `keepsStdinOpenAfterTurnEnd`).
-        scanForInterruptAcks(text);
+        // see that no interrupt is still waiting (see `stdinHoldAfterTurnEnd`); a background task
+        // starting and the turn's end can share one too.
+        scanControlLines(text);
         // Non-null: `streamHandler` is only ever null when `streamFormat === 'plain'` (see its
         // construction above), the branch this statement is provably unreachable from.
         streamHandler.feed({ chunk: text });
@@ -656,7 +700,8 @@ export function wireChildLifecycle(ctx) {
      * An ack that never comes (an agent that ignores control requests) only delays the write by
      * {@link INTERRUPT_ACK_TIMEOUT_MS}: the CLI then folds the line in at its next step. Once
      * `turn_end` has closed stdin, or the process exits before the ack, there is no session left to
-     * reach — `'not-running'`.
+     * reach — `'not-running'`. Between turns, while stdin is held only for background tasks, there is
+     * no generation to stop: the line is written at once and starts the next turn.
      */
     async function sendUserMessage(text) {
         if (!acceptsMidRunUserMessages({ def: def }))
@@ -664,6 +709,11 @@ export function wireChildLifecycle(ctx) {
         const stdin = child.stdin;
         if (stdinClosed || !stdin)
             return 'not-running';
+        if (heldForBackgroundTasks) {
+            heldForBackgroundTasks = false;
+            writeUserMessage(stdin, text);
+            return 'delivered';
+        }
         const requestId = `jini-interrupt-${randomUUID()}`;
         interruptSent = true;
         // Capture before requesting the interrupt. Its result can precede the acknowledgement, or
@@ -687,11 +737,15 @@ export function wireChildLifecycle(ctx) {
         pendingInterruptAcks.delete(requestId);
         if (!processAlive || stdinClosed)
             return 'not-running';
+        writeUserMessage(stdin, text);
+        return 'delivered';
+    }
+    /** Writes a mid-run message as the next user line, journals it, and emits its `user_message` run event. */
+    function writeUserMessage(stdin, text) {
         stdin.write(`${JSON.stringify(streamJsonUserMessage({ content: [{ type: 'text', text: text }] }))}\n`, 'utf8');
         if (journal)
             enqueueEmit(() => journal.record({ runId: runId, entry: sentJournalEntry(text) }));
         enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'agent', data: { type: 'user_message', id: randomUUID(), text: text } } }));
-        return 'delivered';
     }
     return {
         closeStdinOnce,
@@ -729,6 +783,18 @@ function controlResponseRequestId({ line }) {
         return undefined;
     }
 }
+/** How many tasks a `background_tasks_changed` line lists, or `undefined` for any other line. */
+function backgroundTaskListLength({ line }) {
+    try {
+        const parsed = JSON.parse(line);
+        if (!isRecord(parsed) || parsed.type !== 'system' || parsed.subtype !== 'background_tasks_changed')
+            return undefined;
+        return Array.isArray(parsed.tasks) ? parsed.tasks.length : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** The stream-json stdin envelope for one user message — the initial prompt and every mid-run one. */
 function streamJsonUserMessage({ content }) {
     return { type: 'user', message: { role: 'user', content: content } };

package/dist/agent-executor/index.d.ts

@@ -90,7 +90,7 @@
  * this module.
  */
 export { type SupportedStreamFormat, type AgentExecutorCompatibility, type AgentRuntimeEventTranslation, type AgentExecutorErrorCode, AgentExecutorError, type AgentExecutorRunInput, type AgentExecutor, type UserMessageDelivery, type CollectProcessTreePidsPort, type StopProcessesPort, type AgentCleanupFailurePhase, type AgentCleanupFailureContext, type ContinuationOptions, type McpJsonInjectionOptions, type McpBridgeDelivery, type PreparedCodexHome, type PreparedClaudeConfigDir, type ClaudeConfigDirSeams, type ClaudeConfigDirIsolationOptions, type FailureClassificationContext, type ClassifyFailure, type CreateAgentExecutorOptions, type SystemPromptOverlayDelivery, type PreparedSystemPromptOverlayFile, type SpawnAgentChildProcessResult, } from './contracts.js';
-export { isSupportedStreamFormat, assessAgentExecutorCompatibility, isAgentExecutorSupported, resolveDefAndStreamFormat, resolveImageDeliveryAndArgvBudget, resolveRunEnv, resolveLaunch, stagePromptFile, stageLogFile, computeChildEnv, computeRuntimeContext, buildAgentBuildArgsOptions, resolveSystemPromptOverlayDelivery, buildRunArgs, prepareSystemPromptOverlayFileIfNeeded, guardWindowsCommandLineBudget, spawnAgentChildProcess, isStdinDrivenFormat, confirmChildSpawned, createAgentExecutor, } from './launch.js';
+export { isSupportedStreamFormat, assessAgentExecutorCompatibility, isAgentExecutorSupported, resolveDefAndStreamFormat, resolveImageDeliveryAndArgvBudget, resolveRunEnv, selectAgentExecutorHostEnv, resolveLaunch, stagePromptFile, stageLogFile, computeChildEnv, computeRuntimeContext, buildAgentBuildArgsOptions, resolveSystemPromptOverlayDelivery, buildRunArgs, prepareSystemPromptOverlayFileIfNeeded, guardWindowsCommandLineBudget, spawnAgentChildProcess, isStdinDrivenFormat, confirmChildSpawned, createAgentExecutor, } from './launch.js';
 export { extractUsageTokens, translateStatusEvent, translateToolResultEvent, translateErrorEvent, translateTurnEndEvent, translateAgentRuntimeEvent, applyAgentTranslationSideEffects, } from './event-translation.js';
 export { MCP_BRIDGE_UNAVAILABLE, unavailableJiniBridgeStatus, buildMcpJsonServerEntry, mergeMcpJsonContent, buildAcpMcpBridgeServers, mergeEnvContentMcpConfig, mergeEnvContentInstructions, buildCodexMcpServerToml, buildCodexHomeConfigToml, resolveSourceCodexHomeDir, buildMcpBridgeDelivery, resolveSourceClaudeConfigDir, resolveMcpBridgeForRun, writeMcpJsonIfNeeded, prepareCodexHomeIfNeeded, prepareClaudeConfigDirIfNeeded, } from './mcp-bridge.js';
 export { DEFAULT_BUFFERED_STDOUT_MAX_BYTES, runAcpDispatch, runPiRpcDispatch, } from './events.js';

package/dist/agent-executor/index.js

@@ -90,7 +90,7 @@
  * this module.
  */
 export { AgentExecutorError, } from './contracts.js';
-export { isSupportedStreamFormat, assessAgentExecutorCompatibility, isAgentExecutorSupported, resolveDefAndStreamFormat, resolveImageDeliveryAndArgvBudget, resolveRunEnv, resolveLaunch, stagePromptFile, stageLogFile, computeChildEnv, computeRuntimeContext, buildAgentBuildArgsOptions, resolveSystemPromptOverlayDelivery, buildRunArgs, prepareSystemPromptOverlayFileIfNeeded, guardWindowsCommandLineBudget, spawnAgentChildProcess, isStdinDrivenFormat, confirmChildSpawned, createAgentExecutor, } from './launch.js';
+export { isSupportedStreamFormat, assessAgentExecutorCompatibility, isAgentExecutorSupported, resolveDefAndStreamFormat, resolveImageDeliveryAndArgvBudget, resolveRunEnv, selectAgentExecutorHostEnv, resolveLaunch, stagePromptFile, stageLogFile, computeChildEnv, computeRuntimeContext, buildAgentBuildArgsOptions, resolveSystemPromptOverlayDelivery, buildRunArgs, prepareSystemPromptOverlayFileIfNeeded, guardWindowsCommandLineBudget, spawnAgentChildProcess, isStdinDrivenFormat, confirmChildSpawned, createAgentExecutor, } from './launch.js';
 export { extractUsageTokens, translateStatusEvent, translateToolResultEvent, translateErrorEvent, translateTurnEndEvent, translateAgentRuntimeEvent, applyAgentTranslationSideEffects, } from './event-translation.js';
 export { MCP_BRIDGE_UNAVAILABLE, unavailableJiniBridgeStatus, buildMcpJsonServerEntry, mergeMcpJsonContent, buildAcpMcpBridgeServers, mergeEnvContentMcpConfig, mergeEnvContentInstructions, buildCodexMcpServerToml, buildCodexHomeConfigToml, resolveSourceCodexHomeDir, buildMcpBridgeDelivery, resolveSourceClaudeConfigDir, resolveMcpBridgeForRun, writeMcpJsonIfNeeded, prepareCodexHomeIfNeeded, prepareClaudeConfigDirIfNeeded, } from './mcp-bridge.js';
 export { DEFAULT_BUFFERED_STDOUT_MAX_BYTES, runAcpDispatch, runPiRpcDispatch, } from './events.js';

package/dist/agent-executor/launch.d.ts

@@ -1,5 +1,5 @@
 import { spawn as nodeSpawn, type ChildProcess } from 'node:child_process';
-import { getAgentDef, resolveAgentLaunch, prepareAgentLogFile, preparePromptFileForAgent, type AgentLaunchResolution, type PreparedAgentLogFile, type PreparedPromptFile, type RuntimeAgentDef, type RuntimeBuildOptions, type RuntimeContext } from '@jini-ai/agent-runtime';
+import { type AgentRuntimeState, getAgentDef, resolveAgentLaunch, prepareAgentLogFile, preparePromptFileForAgent, type AgentLaunchResolution, type PreparedAgentLogFile, type PreparedPromptFile, type RuntimeAgentDef, type RuntimeBuildOptions, type RuntimeContext } from '@jini-ai/agent-runtime';
 import { createCommandInvocation } from '@jini-ai/platform';
 import { type ImagePromptDelivery } from '../image-prompt-delivery.js';
 import { type SupportedStreamFormat, type ChildDrivenStreamFormat, type AgentExecutorCompatibility, type AgentExecutorRunInput, type AgentExecutor, type McpBridgeDelivery, type CreateAgentExecutorOptions, type FailBeforeSpawn, type SystemPromptOverlayDelivery, type PreparedSystemPromptOverlayFile, type SpawnAgentChildProcessResult } from './contracts.js';
@@ -53,6 +53,13 @@ export declare function assessAgentExecutorCompatibility({ def }: {
 export declare function isAgentExecutorSupported({ def }: {
     readonly def: RuntimeAgentDef;
 }): boolean;
+/** Snapshot only host configuration used by spawn and config staging; credentials stay per-run.
+ * Returns an independent allowlisted record. @complexity O(1), fixed key list. */
+export declare function selectAgentExecutorHostEnv({ env }: {
+    env: NodeJS.ProcessEnv;
+}, { runtimeState }?: {
+    runtimeState?: AgentRuntimeState;
+}): NodeJS.ProcessEnv;
 interface ResolvedDefAndFormat {
     readonly def: RuntimeAgentDef;
     readonly streamFormat: SupportedStreamFormat;
@@ -236,6 +243,8 @@ export declare function resolveSystemPromptOverlayDelivery(input: {
     readonly overlay: string | null | undefined;
     readonly prompt: string;
     readonly resumeSessionId: string | null | undefined;
+}, { state }?: {
+    state?: AgentRuntimeState;
 }): SystemPromptOverlayDelivery;
 /**
  * Phase 9b: calls the def's `buildArgs`, releasing staged resources and failing the run on a throw.
@@ -370,6 +379,6 @@ export declare function confirmChildSpawned({ input, deps }: {
  * @complexity `run()`'s own setup is O(1); steady-state cost is the chosen stream parser's.
  * @overallScore 100/100
  */
-export declare function createAgentExecutor(requiredArgs: Pick<CreateAgentExecutorOptions, "lifecycle">, optionalArgs?: Pick<CreateAgentExecutorOptions, "getAgentDef" | "resolveAgentLaunch" | "resolveModelForLaunch" | "ensureAgentCapabilities" | "applyAgentLaunchEnv" | "createCommandInvocation" | "spawn" | "attachAcpSession" | "acpPermissionHandler" | "attachPiRpcSession" | "preparePromptFileForAgent" | "prepareAgentLogFile" | "listProcessSnapshots" | "collectProcessTreePids" | "stopProcesses" | "onCleanupFailure" | "journal" | "continuation" | "classifyFailure" | "mcpJsonInjection" | "claudeConfigDirIsolation" | "claudeConfigDirIsolationEnabled" | "bufferedStdoutMaxBytes" | "promptAugmenter">): AgentExecutor;
+export declare function createAgentExecutor(requiredArgs: Pick<CreateAgentExecutorOptions, "lifecycle">, optionalArgs?: Pick<CreateAgentExecutorOptions, "runtimeState" | "hostEnv" | "getAgentDef" | "resolveAgentLaunch" | "resolveModelForLaunch" | "ensureAgentCapabilities" | "applyAgentLaunchEnv" | "createCommandInvocation" | "spawn" | "attachAcpSession" | "acpPermissionHandler" | "attachPiRpcSession" | "preparePromptFileForAgent" | "prepareAgentLogFile" | "listProcessSnapshots" | "collectProcessTreePids" | "stopProcesses" | "onCleanupFailure" | "journal" | "continuation" | "classifyFailure" | "mcpJsonInjection" | "claudeConfigDirIsolation" | "claudeConfigDirIsolationEnabled" | "bufferedStdoutMaxBytes" | "promptAugmenter">): AgentExecutor;
 export {};
 //# sourceMappingURL=launch.d.ts.map

package/dist/agent-executor/launch.js

@@ -2,7 +2,7 @@ import { spawn as nodeSpawn, } from 'node:child_process';
 import { promises as fsPromises, } from 'node:fs';
 import { tmpdir, } from 'node:os';
 import { join, } from 'node:path';
-import { agentCapabilities, applyAgentLaunchEnv, ensureAgentCapabilities, resolveModelForLaunch, getAgentDef, resolveAgentLaunch, attachAcpSession, attachPiRpcSession, checkPromptArgvBudget, checkWindowsCmdShimCommandLineBudget, checkWindowsDirectExeCommandLineBudget, prepareAgentLogFile, preparePromptFileForAgent, } from '@jini-ai/agent-runtime';
+import { agentCapabilities, bindRuntimeAgentDef, defaultRuntimeState, getRuntimeModelDiscoveryDeps, userToolchainBinDirs, applyAgentLaunchEnv, ensureAgentCapabilities, resolveModelForLaunch, getAgentDef, resolveAgentLaunch, attachAcpSession, attachPiRpcSession, checkPromptArgvBudget, checkWindowsCmdShimCommandLineBudget, checkWindowsDirectExeCommandLineBudget, prepareAgentLogFile, preparePromptFileForAgent, } from '@jini-ai/agent-runtime';
 import { collectProcessTreePids, createCommandInvocation, listProcessSnapshots, stopProcesses, } from '@jini-ai/platform';
 import { applyImagePromptDelivery, } from '../image-prompt-delivery.js';
 import { SUPPORTED_STREAM_FORMATS, AgentExecutorError, } from './contracts.js';
@@ -131,6 +131,22 @@ function buildAgentEnv(hostEnv, credentialEnv) {
     }
     return result;
 }
+/** Snapshot only host configuration used by spawn and config staging; credentials stay per-run.
+ * Returns an independent allowlisted record. @complexity O(1), fixed key list. */
+export function selectAgentExecutorHostEnv({ env }, { runtimeState } = {}) {
+    const selected = buildAgentEnv(env, undefined);
+    for (const key of ['CODEX_HOME', 'CLAUDE_CONFIG_DIR', 'VELA_OPENCODE_BIN', 'AGENT_RUNTIME_HOME', 'AGENT_RUNTIME_RESOURCE_ROOT', 'VP_HOME', 'NPM_CONFIG_PREFIX', 'npm_config_prefix', 'APPDATA', 'LOCALAPPDATA', 'MISE_DATA_DIR', 'FNM_DIR']) {
+        if (typeof env[key] === 'string')
+            selected[key] = env[key];
+    }
+    // Host-configured resolution names are explicit configuration, never a scan of the env bag.
+    const state = runtimeState ?? defaultRuntimeState;
+    for (const key of Object.values(state.executable.envNames)) {
+        if (typeof env[key] === 'string')
+            selected[key] = env[key];
+    }
+    return selected;
+}
 /**
  * Resolves once `child` emits `'spawn'`, or rejects on `'error'`. Replicates
  * `@jini-ai/platform`'s own internal (non-exported) `waitForChildSpawn` race
@@ -156,11 +172,17 @@ function waitForSpawnOrError(child) {
  * hiding which options belong together. Pure.
  */
 function resolveAgentRuntimeDeps(options) {
+    const runtimeOptions = options.runtimeState ? { state: options.runtimeState } : {};
+    const envOptions = options.hostEnv ? { env: options.hostEnv } : {};
+    const lookupDef = options.getAgentDef ?? getAgentDef;
     return {
-        getAgentDef: options.getAgentDef ?? getAgentDef,
-        resolveAgentLaunch: options.resolveAgentLaunch ?? resolveAgentLaunch,
-        ensureAgentCapabilities: options.ensureAgentCapabilities ?? ensureAgentCapabilities,
-        applyAgentLaunchEnv: options.applyAgentLaunchEnv ?? applyAgentLaunchEnv,
+        getAgentDef: (input) => {
+            const def = lookupDef(input);
+            return def && options.runtimeState ? bindRuntimeAgentDef({ def, state: options.runtimeState }) : def;
+        },
+        resolveAgentLaunch: options.resolveAgentLaunch ?? ((input, optional = {}) => resolveAgentLaunch(input, { ...optional, ...runtimeOptions, ...envOptions })),
+        ensureAgentCapabilities: options.ensureAgentCapabilities ?? ((input) => ensureAgentCapabilities(input, runtimeOptions)),
+        applyAgentLaunchEnv: options.applyAgentLaunchEnv ?? ((input, optional = {}) => applyAgentLaunchEnv(input, { appendPathDirs: userToolchainBinDirs({}, { ...runtimeOptions, ...envOptions }), ...optional })),
         attachAcpSession: options.attachAcpSession ?? attachAcpSession,
         attachPiRpcSession: options.attachPiRpcSession ?? attachPiRpcSession,
         preparePromptFileForAgent: options.preparePromptFileForAgent ?? preparePromptFileForAgent,
@@ -397,7 +419,7 @@ export function buildAgentBuildArgsOptions({ input, systemPromptOverlay }) {
  * @complexity O(n) in the overlay/prompt lengths — string concatenation only, no I/O.
  * @overallScore 100/100
  */
-export function resolveSystemPromptOverlayDelivery(input) {
+export function resolveSystemPromptOverlayDelivery(input, { state } = {}) {
     const { defId, systemPromptDelivery, resumesSessionViaCli, resumesSessionViaAcpLoad, overlay, prompt, resumeSessionId } = input;
     if (typeof overlay !== 'string' || overlay.length === 0) {
         return { promptPrefix: '', prompt, extraArgs: [], envOverrides: {} };
@@ -410,7 +432,7 @@ export function resolveSystemPromptOverlayDelivery(input) {
         // `--help` probe ran and did not find the flag) withholds it. `capabilityKey === undefined`
         // (e.g. `pi`'s existing `--append-system-prompt`, trusted unconditionally) always passes, same
         // as an absent key.
-        const capabilityOk = capabilityKey === undefined || agentCapabilities.get(defId)?.[capabilityKey] !== false;
+        const capabilityOk = capabilityKey === undefined || (state?.capabilities ?? agentCapabilities).get(defId)?.[capabilityKey] !== false;
         return { promptPrefix: '', prompt, extraArgs: capabilityOk ? [systemPromptDelivery.flag, overlay] : [], envOverrides: {} };
     }
     if (systemPromptDelivery?.strategy === 'env-var') {
@@ -607,7 +629,8 @@ export async function confirmChildSpawned({ input, deps }) {
 export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
     const options = { ...requiredArgs, ...optionalArgs };
     const lifecycle = options.lifecycle;
-    const { getAgentDef: getAgentDefFn, resolveAgentLaunch: resolveAgentLaunchFn, ensureAgentCapabilities: ensureAgentCapabilitiesFn, applyAgentLaunchEnv: applyAgentLaunchEnvFn, attachAcpSession: attachAcpSessionFn, attachPiRpcSession: attachPiRpcSessionFn, preparePromptFileForAgent: preparePromptFileForAgentFn, prepareAgentLogFile: prepareAgentLogFileFn, } = resolveAgentRuntimeDeps(options);
+    const hostEnv = selectAgentExecutorHostEnv({ env: options.hostEnv ?? process.env }, options.runtimeState ? { runtimeState: options.runtimeState } : {});
+    const { getAgentDef: getAgentDefFn, resolveAgentLaunch: resolveAgentLaunchFn, ensureAgentCapabilities: ensureAgentCapabilitiesFn, applyAgentLaunchEnv: applyAgentLaunchEnvFn, attachAcpSession: attachAcpSessionFn, attachPiRpcSession: attachPiRpcSessionFn, preparePromptFileForAgent: preparePromptFileForAgentFn, prepareAgentLogFile: prepareAgentLogFileFn, } = resolveAgentRuntimeDeps({ ...options, hostEnv });
     const { createCommandInvocation: createCommandInvocationFn, spawn: spawnFn, listProcessSnapshots: listProcessSnapshotsFn, collectProcessTreePids: collectProcessTreePidsFn, stopProcesses: stopProcessesFn, } = resolveProcessDeps(options);
     const { onCleanupFailure: onCleanupFailureFn, bufferedStdoutMaxBytes } = resolveMiscExecutorDeps(options);
     const journal = options.journal;
@@ -711,18 +734,19 @@ export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
             overlay: systemPromptOverlay,
             prompt: imageDelivery.prompt,
             resumeSessionId: preStagingRuntimeContext?.resumeSessionId,
-        });
+        }, options.runtimeState ? { state: options.runtimeState } : {});
         // The def's own declared env (e.g. claude's `ENABLE_TOOL_SEARCH=false`) is a default the run's
         // env can override. Detection already spawns with it (`detection.ts`); without this the run
         // spawn silently dropped it. Declared by the def itself, so it never widens SEC-001's allowlist.
-        const resolvedEnv = { ...(def.env ?? {}), ...resolveRunEnv({ input: input, hostEnv: process.env }) };
+        const resolvedEnv = { ...(def.env ?? {}), ...resolveRunEnv({ input: input, hostEnv }) };
         const launch = await resolveLaunch({ input: { runId: input.runId, def, resolvedEnv }, deps: { resolveAgentLaunch: resolveAgentLaunchFn, failBeforeSpawn } });
         const spawnEnv = applyAgentLaunchEnvFn({ env: { ...resolvedEnv }, launch });
         // Resolve from the launch environment before staging or sending any prompt. Pin the same
         // concrete ID that the picker displays; an opaque native route cannot silently start a run.
         let modelCatalog;
         try {
-            const selection = await (options.resolveModelForLaunch ?? resolveModelForLaunch)({ def, context: {
+            const selectModel = options.resolveModelForLaunch ?? ((input) => resolveModelForLaunch(input, options.runtimeState ? { deps: getRuntimeModelDiscoveryDeps({ state: options.runtimeState }) } : {}));
+            const selection = await selectModel({ def, context: {
                     executable: launch.launchPath, cwd: input.cwd, env: spawnEnv,
                     ...(input.model && input.model !== 'default' ? { model: input.model } : {}),
                     ...(input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : {}),
@@ -868,7 +892,7 @@ export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
         // `codex.ts`'s `buildArgs` needs no argv change for this (CODEX_HOME is an env var, not a flag),
         // so — unlike the `.mcp.json` staging above — this can run after `buildArgs` with no ordering
         // constraint of its own; it is placed here only to keep the two staging steps adjacent.
-        preparedCodexHome = await prepareCodexHomeIfNeeded({ input: { runId: input.runId, def, mcpBridge }, deps: { mcpJsonInjection, hostEnv: process.env, releaseStagedResources, failBeforeSpawn } });
+        preparedCodexHome = await prepareCodexHomeIfNeeded({ input: { runId: input.runId, def, mcpBridge }, deps: { mcpJsonInjection, hostEnv, releaseStagedResources, failBeforeSpawn } });
         // Finding 1 of SEC-assistant-env-isolation-2026-09-07's one effect — stage this run's scratch
         // `CLAUDE_CONFIG_DIR` directory. Unconditional for a `claude`-id run (unlike CODEX_HOME above,
         // this does not depend on `mcpJsonInjection` being configured at all — see
@@ -878,7 +902,7 @@ export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
         preparedClaudeConfigDir = await prepareClaudeConfigDirIfNeeded({ input: { runId: input.runId, def }, deps: {
                 enabled: claudeConfigDirIsolationEnabled,
                 claudeConfigDirIsolation,
-                hostEnv: process.env,
+                hostEnv,
                 releaseStagedResources,
                 failBeforeSpawn,
             } });

package/dist/agent-executor.d.ts

@@ -6,5 +6,5 @@
  * wrappers or a second implementation would let tested and shipped behavior drift.
  * See agent-executor/index.ts for the driver contracts and invariants.
  */
-export { type SupportedStreamFormat, isSupportedStreamFormat, type AgentExecutorCompatibility, assessAgentExecutorCompatibility, isAgentExecutorSupported, type AgentRuntimeEventTranslation, extractUsageTokens, translateStatusEvent, translateToolResultEvent, translateErrorEvent, translateTurnEndEvent, translateAgentRuntimeEvent, type AgentExecutorErrorCode, AgentExecutorError, type AgentExecutorRunInput, type AgentExecutor, type UserMessageDelivery, type CollectProcessTreePidsPort, type StopProcessesPort, type AgentCleanupFailurePhase, type AgentCleanupFailureContext, type ContinuationOptions, type McpJsonInjectionOptions, MCP_BRIDGE_UNAVAILABLE, unavailableJiniBridgeStatus, buildMcpJsonServerEntry, mergeMcpJsonContent, buildAcpMcpBridgeServers, mergeEnvContentMcpConfig, mergeEnvContentInstructions, buildCodexMcpServerToml, buildCodexHomeConfigToml, resolveSourceCodexHomeDir, type McpBridgeDelivery, buildMcpBridgeDelivery, type PreparedCodexHome, type PreparedClaudeConfigDir, type ClaudeConfigDirSeams, type ClaudeConfigDirIsolationOptions, resolveSourceClaudeConfigDir, type FailureClassificationContext, type ClassifyFailure, DEFAULT_BUFFERED_STDOUT_MAX_BYTES, applyAgentTranslationSideEffects, type CreateAgentExecutorOptions, resolveDefAndStreamFormat, resolveImageDeliveryAndArgvBudget, resolveRunEnv, resolveLaunch, stagePromptFile, stageLogFile, resolveMcpBridgeForRun, computeChildEnv, computeRuntimeContext, buildAgentBuildArgsOptions, type SystemPromptOverlayDelivery, resolveSystemPromptOverlayDelivery, buildRunArgs, writeMcpJsonIfNeeded, type PreparedSystemPromptOverlayFile, prepareSystemPromptOverlayFileIfNeeded, prepareCodexHomeIfNeeded, prepareClaudeConfigDirIfNeeded, guardWindowsCommandLineBudget, type SpawnAgentChildProcessResult, spawnAgentChildProcess, isStdinDrivenFormat, confirmChildSpawned, armHandoffWatcher, runAcpDispatch, runPiRpcDispatch, createAgentExecutor, } from './agent-executor/index.js';
+export { type SupportedStreamFormat, isSupportedStreamFormat, type AgentExecutorCompatibility, assessAgentExecutorCompatibility, isAgentExecutorSupported, type AgentRuntimeEventTranslation, extractUsageTokens, translateStatusEvent, translateToolResultEvent, translateErrorEvent, translateTurnEndEvent, translateAgentRuntimeEvent, type AgentExecutorErrorCode, AgentExecutorError, type AgentExecutorRunInput, type AgentExecutor, type UserMessageDelivery, type CollectProcessTreePidsPort, type StopProcessesPort, type AgentCleanupFailurePhase, type AgentCleanupFailureContext, type ContinuationOptions, type McpJsonInjectionOptions, MCP_BRIDGE_UNAVAILABLE, unavailableJiniBridgeStatus, buildMcpJsonServerEntry, mergeMcpJsonContent, buildAcpMcpBridgeServers, mergeEnvContentMcpConfig, mergeEnvContentInstructions, buildCodexMcpServerToml, buildCodexHomeConfigToml, resolveSourceCodexHomeDir, type McpBridgeDelivery, buildMcpBridgeDelivery, type PreparedCodexHome, type PreparedClaudeConfigDir, type ClaudeConfigDirSeams, type ClaudeConfigDirIsolationOptions, resolveSourceClaudeConfigDir, type FailureClassificationContext, type ClassifyFailure, DEFAULT_BUFFERED_STDOUT_MAX_BYTES, applyAgentTranslationSideEffects, type CreateAgentExecutorOptions, resolveDefAndStreamFormat, resolveImageDeliveryAndArgvBudget, resolveRunEnv, selectAgentExecutorHostEnv, resolveLaunch, stagePromptFile, stageLogFile, resolveMcpBridgeForRun, computeChildEnv, computeRuntimeContext, buildAgentBuildArgsOptions, type SystemPromptOverlayDelivery, resolveSystemPromptOverlayDelivery, buildRunArgs, writeMcpJsonIfNeeded, type PreparedSystemPromptOverlayFile, prepareSystemPromptOverlayFileIfNeeded, prepareCodexHomeIfNeeded, prepareClaudeConfigDirIfNeeded, guardWindowsCommandLineBudget, type SpawnAgentChildProcessResult, spawnAgentChildProcess, isStdinDrivenFormat, confirmChildSpawned, armHandoffWatcher, runAcpDispatch, runPiRpcDispatch, createAgentExecutor, } from './agent-executor/index.js';
 //# sourceMappingURL=agent-executor.d.ts.map

package/dist/agent-executor.js

@@ -6,5 +6,5 @@
  * wrappers or a second implementation would let tested and shipped behavior drift.
  * See agent-executor/index.ts for the driver contracts and invariants.
  */
-export { isSupportedStreamFormat, assessAgentExecutorCompatibility, isAgentExecutorSupported, extractUsageTokens, translateStatusEvent, translateToolResultEvent, translateErrorEvent, translateTurnEndEvent, translateAgentRuntimeEvent, AgentExecutorError, MCP_BRIDGE_UNAVAILABLE, unavailableJiniBridgeStatus, buildMcpJsonServerEntry, mergeMcpJsonContent, buildAcpMcpBridgeServers, mergeEnvContentMcpConfig, mergeEnvContentInstructions, buildCodexMcpServerToml, buildCodexHomeConfigToml, resolveSourceCodexHomeDir, buildMcpBridgeDelivery, resolveSourceClaudeConfigDir, DEFAULT_BUFFERED_STDOUT_MAX_BYTES, applyAgentTranslationSideEffects, resolveDefAndStreamFormat, resolveImageDeliveryAndArgvBudget, resolveRunEnv, resolveLaunch, stagePromptFile, stageLogFile, resolveMcpBridgeForRun, computeChildEnv, computeRuntimeContext, buildAgentBuildArgsOptions, resolveSystemPromptOverlayDelivery, buildRunArgs, writeMcpJsonIfNeeded, prepareSystemPromptOverlayFileIfNeeded, prepareCodexHomeIfNeeded, prepareClaudeConfigDirIfNeeded, guardWindowsCommandLineBudget, spawnAgentChildProcess, isStdinDrivenFormat, confirmChildSpawned, armHandoffWatcher, runAcpDispatch, runPiRpcDispatch, createAgentExecutor, } from './agent-executor/index.js';
+export { isSupportedStreamFormat, assessAgentExecutorCompatibility, isAgentExecutorSupported, extractUsageTokens, translateStatusEvent, translateToolResultEvent, translateErrorEvent, translateTurnEndEvent, translateAgentRuntimeEvent, AgentExecutorError, MCP_BRIDGE_UNAVAILABLE, unavailableJiniBridgeStatus, buildMcpJsonServerEntry, mergeMcpJsonContent, buildAcpMcpBridgeServers, mergeEnvContentMcpConfig, mergeEnvContentInstructions, buildCodexMcpServerToml, buildCodexHomeConfigToml, resolveSourceCodexHomeDir, buildMcpBridgeDelivery, resolveSourceClaudeConfigDir, DEFAULT_BUFFERED_STDOUT_MAX_BYTES, applyAgentTranslationSideEffects, resolveDefAndStreamFormat, resolveImageDeliveryAndArgvBudget, resolveRunEnv, selectAgentExecutorHostEnv, resolveLaunch, stagePromptFile, stageLogFile, resolveMcpBridgeForRun, computeChildEnv, computeRuntimeContext, buildAgentBuildArgsOptions, resolveSystemPromptOverlayDelivery, buildRunArgs, writeMcpJsonIfNeeded, prepareSystemPromptOverlayFileIfNeeded, prepareCodexHomeIfNeeded, prepareClaudeConfigDirIfNeeded, guardWindowsCommandLineBudget, spawnAgentChildProcess, isStdinDrivenFormat, confirmChildSpawned, armHandoffWatcher, runAcpDispatch, runPiRpcDispatch, createAgentExecutor, } from './agent-executor/index.js';
 //# sourceMappingURL=agent-executor.js.map

package/dist/http/index.d.ts

@@ -40,8 +40,8 @@ export type { HealthHttpDeps, HealthReadinessResult, LivenessResponse, Readiness
 export { apiHealthRoute, apiReadyRoute, apiVersionInfoRoute, healthRoute, readyRoute, registerHealthRoutes, versionInfoRoute, } from './health.js';
 export type { AuthCredentials, AuthProvider, AuthSession, AuthUser, Charge, ChargeInput, ChargeStatus, ConnectorsAuthSessionResponse, ConnectorsAuthUserResponse, ConnectorsAuthVerifyResponse, ConnectorsChargeResponse, ConnectorsDbQueryResponse, ConnectorsDbRecordResponse, ConnectorsHttpDeps, ConnectorsInternalErrorContext, ConnectorsOkResponse, ConnectorsStorageGetResponse, ConnectorsStorageListResponse, ConnectorsStorageMetaResponse, DbProvider, DbQuery, DbRecord, PaymentsProvider, RealtimeProvider, StorageObjectMeta, StorageProvider, StoragePutOptions, } from './connectors.js';
 export { connectorsAuthSessionRoute, connectorsAuthSignInRoute, connectorsAuthSignOutRoute, connectorsAuthSignUpRoute, connectorsDbDeleteRoute, connectorsDbGetRoute, connectorsDbInsertRoute, connectorsDbQueryRoute, connectorsDbUpdateRoute, connectorsPaymentsChargeRoute, connectorsPaymentsGetRoute, connectorsPaymentsRefundRoute, connectorsRealtimePublishRoute, connectorsStorageDeleteRoute, connectorsStorageGetRoute, connectorsStorageListRoute, connectorsStoragePutRoute, registerConnectorsRoutes, } from './connectors.js';
-export type { ResearchHttpDeps, ResearchInternalErrorContext, ResearchProviderCredentials, ResearchSearchResponse, ResearchSource, } from './research.js';
-export { registerResearchRoutes, researchSearchRoute } from './research.js';
+export type { ResearchProvider, ResearchSearchRequest, ResearchHttpDeps, ResearchInternalErrorContext, ResearchProviderCredentials, ResearchSearchResponse, ResearchSource, } from './research.js';
+export { createResearchSearchRoute, registerResearchRoutes, researchSearchRoute } from './research.js';
 export type { MediaGenerateResponse, MediaHttpDeps, MediaInternalErrorContext, MediaTaskDeleteResponse, MediaTaskListResponse, MediaTaskResponse, } from './media.js';
 export { mediaGenerateRoute, mediaTaskDeleteRoute, mediaTaskGetRoute, mediaTaskListRoute, registerMediaRoutes, } from './media.js';
 export type { AttachmentClaim, AttachmentRejectionReason, AttachmentsHttpDeps, AttachmentsInternalErrorContext, AttachmentStore, AttachmentUploadResponse, CreateDiskAttachmentStoreOptions, ObservedAttachmentIdentity, PendingAttachmentSummary, RecordedAttachmentIdentity, StoredAttachment, } from './attachments.js';
@@ -49,4 +49,5 @@ export { ATTACHMENTS_ROUTE_PATH, AttachmentRejectedError, createDiskAttachmentSt
 export type { XaiAuthStatusResponse, XaiHttpDeps, XaiInternalErrorContext, XaiOauthStartResponse, XaiOkResponse, XaiSearchResponse, } from './xai.js';
 export { registerXaiRoutes, xaiAuthStatusRoute, xaiOauthCancelRoute, xaiOauthCompleteRoute, xaiOauthDisconnectRoute, xaiOauthStartRoute, xaiSearchRoute, } from './xai.js';
 export * from './run-credentials.js';
+export { createTavilyResearchProvider } from './research-tavily.adapter.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/http/index.js

@@ -19,9 +19,10 @@ export { registerTerminalEventStream, registerTerminalRoutes, terminalCreateRout
 export { registerModelProxyRoutes } from './model-proxy.js';
 export { apiHealthRoute, apiReadyRoute, apiVersionInfoRoute, healthRoute, readyRoute, registerHealthRoutes, versionInfoRoute, } from './health.js';
 export { connectorsAuthSessionRoute, connectorsAuthSignInRoute, connectorsAuthSignOutRoute, connectorsAuthSignUpRoute, connectorsDbDeleteRoute, connectorsDbGetRoute, connectorsDbInsertRoute, connectorsDbQueryRoute, connectorsDbUpdateRoute, connectorsPaymentsChargeRoute, connectorsPaymentsGetRoute, connectorsPaymentsRefundRoute, connectorsRealtimePublishRoute, connectorsStorageDeleteRoute, connectorsStorageGetRoute, connectorsStorageListRoute, connectorsStoragePutRoute, registerConnectorsRoutes, } from './connectors.js';
-export { registerResearchRoutes, researchSearchRoute } from './research.js';
+export { createResearchSearchRoute, registerResearchRoutes, researchSearchRoute } from './research.js';
 export { mediaGenerateRoute, mediaTaskDeleteRoute, mediaTaskGetRoute, mediaTaskListRoute, registerMediaRoutes, } from './media.js';
 export { ATTACHMENTS_ROUTE_PATH, AttachmentRejectedError, createDiskAttachmentStore, detectAttachmentKind, handleAttachmentCleanup, handleAttachmentUpload, isUnchangedAttachment, registerAttachmentRoutes, sanitizeAttachmentName, writeBoundedAttachmentBody, } from './attachments.js';
 export { registerXaiRoutes, xaiAuthStatusRoute, xaiOauthCancelRoute, xaiOauthCompleteRoute, xaiOauthDisconnectRoute, xaiOauthStartRoute, xaiSearchRoute, } from './xai.js';
 export * from './run-credentials.js';
+export { createTavilyResearchProvider } from './research-tavily.adapter.js';
 //# sourceMappingURL=index.js.map

package/dist/http/research-tavily.adapter.d.ts

@@ -0,0 +1,6 @@
+import type { ResearchProvider } from './research.js';
+/** Creates today's transport with a host-owned fetch port. */
+export declare function createTavilyResearchProvider(_required: Record<string, never>, options?: {
+    fetch?: typeof globalThis.fetch;
+}): ResearchProvider;
+//# sourceMappingURL=research-tavily.adapter.d.ts.map

package/dist/http/research-tavily.adapter.js

@@ -0,0 +1,109 @@
+/** Tavily default adapter. Request limits, timeout and secret-redaction policy remain here. */
+import { validateBaseUrl } from '@jini-ai/agent-runtime';
+import { redactSecrets } from '@jini-ai/core';
+const DEFAULT_TAVILY_BASE_URL = 'https://api.tavily.com';
+/** Tavily's own documented cap on `max_results` (see OD's `tavily.ts#TAVILY_MAX_RESULTS_LIMIT`). */
+const TAVILY_MAX_RESULTS_LIMIT = 20;
+const DEFAULT_MAX_SOURCES = 5;
+/** Matches OD's own `tavily.ts` timeout — see research.ts's module doc. */
+const DEFAULT_TAVILY_TIMEOUT_MS = 30_000;
+/**
+ * Calls Tavily's real `POST /search` endpoint directly — see research.ts's module doc for the port's exact
+ * scope/provenance. Throws (never a `Result`) on any failure; the route handler in research.ts is the one
+ * place that converts a thrown error into the package's SEC-005 response shape.
+ *
+ * `apiKey` is a separate, non-optional parameter rather than being read off `credentials`, so the
+ * "credential is present" invariant is carried by the type system instead of by a runtime guard.
+ * This function used to take only `credentials` and re-check `credentials.apiKey` itself, but the
+ * route caller in research.ts already returns `NOT_CONFIGURED` before it ever gets here — the check was
+ * unreachable by construction, so it is now expressed as a required argument instead of dead code.
+ * `credentials` is still passed for its optional transport config (`baseUrl`).
+ */
+async function tavilySearch({ apiKey, credentials, request }, { fetch: fetchImpl = globalThis.fetch } = {}) {
+    const baseUrl = credentials.baseUrl ?? DEFAULT_TAVILY_BASE_URL;
+    const baseUrlCheck = validateBaseUrl({ baseUrl });
+    if (baseUrlCheck.error) {
+        throw new Error(baseUrlCheck.error);
+    }
+    const base = baseUrl.replace(/\/+$/, '');
+    // Floor before clamping, matching OD's real `clampMaxSources` — see research.ts's module doc. Without the
+    // floor, a fractional `maxSources` (e.g. `2.7`, or `0.5` before the `Math.max(1, ...)` floor
+    // below) would forward a non-integer `max_results` straight to Tavily's real API.
+    const maxResults = Math.max(1, Math.min(Math.floor(request.maxSources ?? DEFAULT_MAX_SOURCES), TAVILY_MAX_RESULTS_LIMIT));
+    const body = {
+        query: request.query,
+        search_depth: 'basic',
+        max_results: maxResults,
+        include_answer: true,
+        include_raw_content: false,
+    };
+    // The timeout must stay armed for the full operation, not just until `fetch` resolves —
+    // `fetch` resolves as soon as response headers arrive, before the body is read. A round-2
+    // external audit caught (and locally reproduced) an earlier version of this fix that cleared
+    // the timer right after `fetch` resolved, leaving `response.text()`/`response.json()` below
+    // completely unbounded against a server that sends headers promptly and then stalls the body.
+    //
+    // `TavilyHttpError` marks an error already redacted and formatted by the `!response.ok` branch
+    // below, so the outer catch can rethrow it verbatim instead of wrapping it a second time (which
+    // would otherwise produce a "Tavily request failed: Tavily 429: ..." double-prefixed message).
+    class TavilyHttpError extends Error {
+    }
+    const timeoutController = new AbortController();
+    const timeoutHandle = setTimeout(() => timeoutController.abort(), DEFAULT_TAVILY_TIMEOUT_MS);
+    // Assigned in the `try` and returned *after* the `finally`, rather than returned from inside the
+    // `try`. Both forms behave identically, but a return-through-`finally` compiles to three copies of
+    // the `finally` body (normal completion, return, throw) and one of those is unreachable here — the
+    // `try` cannot fall off its end and the `catch` always throws. Falling through to a single return
+    // keeps the cleanup path honestly measurable instead of permanently one-third uncovered.
+    let output;
+    try {
+        const response = await fetchImpl(`${base}/search`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
+            body: JSON.stringify(body),
+            signal: timeoutController.signal,
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new TavilyHttpError(redactSecrets({ input: `Tavily ${response.status}: ${text.slice(0, 200) || 'no body'}` }, { exactSecrets: [apiKey] }));
+        }
+        const json = (await response.json());
+        const answer = typeof json.answer === 'string' ? json.answer : '';
+        const rawResults = Array.isArray(json.results) ? json.results : [];
+        const sources = [];
+        for (const raw of rawResults) {
+            const url = typeof raw.url === 'string' ? raw.url : '';
+            if (!url)
+                continue;
+            const publishedAt = typeof raw.published_date === 'string' && raw.published_date.trim() ? raw.published_date.trim() : undefined;
+            sources.push({
+                title: typeof raw.title === 'string' && raw.title.trim() ? raw.title.trim() : url,
+                url,
+                snippet: typeof raw.content === 'string' ? raw.content.trim().slice(0, 800) : '',
+                provider: 'tavily',
+                ...(publishedAt ? { publishedAt } : {}),
+            });
+        }
+        output = { answer, sources };
+    }
+    catch (error) {
+        if (!timeoutController.signal.aborted && error instanceof TavilyHttpError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(redactSecrets({
+            input: timeoutController.signal.aborted
+                ? `Tavily request timed out after ${DEFAULT_TAVILY_TIMEOUT_MS}ms`
+                : `Tavily request failed: ${message}`,
+        }, { exactSecrets: [apiKey] }));
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+    }
+    return output;
+}
+/** Creates today's transport with a host-owned fetch port. */
+export function createTavilyResearchProvider(_required, options = {}) {
+    return { id: 'tavily', search: (input) => tavilySearch(input, options) };
+}
+//# sourceMappingURL=research-tavily.adapter.js.map

package/dist/http/research.d.ts

@@ -25,7 +25,22 @@ export interface ResearchProviderCredentials {
     readonly baseUrl?: string;
     readonly model?: string;
 }
+/** Research transport contract: the route owns validation/HTTP errors; adapters own vendor I/O. */
+export interface ResearchProvider {
+    readonly id: string;
+    search(required: {
+        apiKey: string;
+        credentials: ResearchProviderCredentials;
+        request: ResearchSearchRequest;
+    }, optional: Record<string, never>): Promise<{
+        readonly answer: string;
+        readonly sources: readonly ResearchSource[];
+    }>;
+}
 export interface ResearchHttpDeps {
+    readonly provider?: ResearchProvider;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly env?: Readonly<Record<string, string | undefined>>;
     /** Resolves per-provider credentials. Defaults to `TAVILY_API_KEY` for the built-in Tavily transport. */
     readonly resolveCredentials?: ({ providerId }: {
         providerId: string;
@@ -33,10 +48,14 @@ export interface ResearchHttpDeps {
     /** Host-owned sink for the real exception behind a generic `INTERNAL_ERROR` response (SEC-005). Defaults to `console.error`. */
     readonly onInternalError?: (context: ResearchInternalErrorContext) => void;
 }
-interface ResearchSearchRequest {
+export interface ResearchSearchRequest {
     readonly query: string;
     readonly maxSources?: number;
 }
+/** Builds one route over a host-selected provider, preserving the default Tavily validation contract. */
+export declare function createResearchSearchRoute({ provider }: {
+    provider?: ResearchProvider;
+}, _optional?: Record<string, never>): import("@jini-ai/http-kit").JsonRouteSpec<ResearchSearchRequest, ResearchSearchResponse, ResearchHttpDeps, undefined>;
 export declare const researchSearchRoute: import("@jini-ai/http-kit").JsonRouteSpec<ResearchSearchRequest, ResearchSearchResponse, ResearchHttpDeps, undefined>;
 /** Mounts `POST /api/research/search` on `app`. A pack's `http(app, services)` calls this directly. */
 export declare function registerResearchRoutes({ app, deps, adapter }: {
@@ -44,5 +63,4 @@ export declare function registerResearchRoutes({ app, deps, adapter }: {
     readonly deps: ResearchHttpDeps;
     readonly adapter: AdapterContext;
 }, _optional?: Record<string, never>): void;
-export {};
 //# sourceMappingURL=research.d.ts.map

package/dist/http/research.js

@@ -96,17 +96,11 @@ import { redactSecrets } from '@jini-ai/core';
  * generic-message substitution.
  */
 import { randomUUID } from 'node:crypto';
-import { validateBaseUrl } from '@jini-ai/agent-runtime';
+import { createTavilyResearchProvider } from './research-tavily.adapter.js';
 import { createApiError } from '@jini-ai/protocol';
 import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
 import { validationError } from '@jini-ai/http-kit';
 import { err, ok } from '@jini-ai/http-kit';
-const DEFAULT_TAVILY_BASE_URL = 'https://api.tavily.com';
-/** Tavily's own documented cap on `max_results` (see OD's `tavily.ts#TAVILY_MAX_RESULTS_LIMIT`). */
-const TAVILY_MAX_RESULTS_LIMIT = 20;
-const DEFAULT_MAX_SOURCES = 5;
-/** Matches OD's own `tavily.ts` timeout — see module doc. */
-const DEFAULT_TAVILY_TIMEOUT_MS = 30_000;
 /** Matches OD's real `research/index.ts#searchResearch` query cap — see module doc. */
 const MAX_QUERY_LENGTH = 1000;
 function defaultInternalErrorSink(context) {
@@ -123,8 +117,8 @@ function defaultInternalErrorSink(context) {
  * other provider name at parse time. A host that supports a second provider injects its own
  * `resolveCredentials` rather than reaching this function with a different id.
  */
-async function defaultResolveCredentials() {
-    const apiKey = process.env.TAVILY_API_KEY?.trim();
+async function defaultResolveCredentials({ env }) {
+    const apiKey = env.TAVILY_API_KEY?.trim();
     return apiKey ? { apiKey } : {};
 }
 function isRecord(value) {
@@ -138,17 +132,17 @@ function nonEmptyString(value) {
  * doc). OD only inspects `providers[0]` and treats a non-array `providers` value as absent rather
  * than rejecting it; this mirrors both.
  */
-function validateRequestedProvider(rawProviders) {
+function validateRequestedProvider(rawProviders, providerId) {
     if (!Array.isArray(rawProviders))
         return ok({ value: null });
     const filtered = rawProviders.filter((p) => typeof p === 'string' && p.length > 0);
     const requested = filtered[0];
-    if (requested !== undefined && requested !== 'tavily') {
-        return err({ error: validationError({ message: `provider "${requested}" is not supported — only "tavily" is available` }) });
+    if (requested !== undefined && requested !== providerId) {
+        return err({ error: validationError({ message: `provider "${requested}" is not supported — only "${providerId}" is available` }) });
     }
     return ok({ value: null });
 }
-function parseResearchSearch(input) {
+function parseResearchSearch(input, providerId = 'tavily') {
     if (!isRecord(input.body))
         return err({ error: validationError({ message: 'body must be a JSON object' }) });
     const rawQuery = nonEmptyString(input.body.query);
@@ -159,106 +153,11 @@ function parseResearchSearch(input) {
     if (maxSources !== undefined && (typeof maxSources !== 'number' || !Number.isFinite(maxSources) || maxSources <= 0)) {
         return err({ error: validationError({ message: 'maxSources must be a positive number when provided' }) });
     }
-    const providerCheck = validateRequestedProvider(input.body.providers);
+    const providerCheck = validateRequestedProvider(input.body.providers, providerId);
     if (!providerCheck.ok)
         return providerCheck;
     return ok({ value: { query, ...(maxSources !== undefined ? { maxSources: maxSources } : {}) } });
 }
-/**
- * Calls Tavily's real `POST /search` endpoint directly — see module doc for the port's exact
- * scope/provenance. Throws (never a `Result`) on any failure; the route handler below is the one
- * place that converts a thrown error into the package's SEC-005 response shape.
- *
- * `apiKey` is a separate, non-optional parameter rather than being read off `credentials`, so the
- * "credential is present" invariant is carried by the type system instead of by a runtime guard.
- * This function used to take only `credentials` and re-check `credentials.apiKey` itself, but the
- * sole caller below already returns `NOT_CONFIGURED` before it ever gets here — the check was
- * unreachable by construction, so it is now expressed as a required argument instead of dead code.
- * `credentials` is still passed for its optional transport config (`baseUrl`).
- */
-async function tavilySearch(apiKey, credentials, request) {
-    const baseUrl = credentials.baseUrl ?? DEFAULT_TAVILY_BASE_URL;
-    const baseUrlCheck = validateBaseUrl({ baseUrl });
-    if (baseUrlCheck.error) {
-        throw new Error(baseUrlCheck.error);
-    }
-    const base = baseUrl.replace(/\/+$/, '');
-    // Floor before clamping, matching OD's real `clampMaxSources` — see module doc. Without the
-    // floor, a fractional `maxSources` (e.g. `2.7`, or `0.5` before the `Math.max(1, ...)` floor
-    // below) would forward a non-integer `max_results` straight to Tavily's real API.
-    const maxResults = Math.max(1, Math.min(Math.floor(request.maxSources ?? DEFAULT_MAX_SOURCES), TAVILY_MAX_RESULTS_LIMIT));
-    const body = {
-        query: request.query,
-        search_depth: 'basic',
-        max_results: maxResults,
-        include_answer: true,
-        include_raw_content: false,
-    };
-    // The timeout must stay armed for the full operation, not just until `fetch` resolves —
-    // `fetch` resolves as soon as response headers arrive, before the body is read. A round-2
-    // external audit caught (and locally reproduced) an earlier version of this fix that cleared
-    // the timer right after `fetch` resolved, leaving `response.text()`/`response.json()` below
-    // completely unbounded against a server that sends headers promptly and then stalls the body.
-    //
-    // `TavilyHttpError` marks an error already redacted and formatted by the `!response.ok` branch
-    // below, so the outer catch can rethrow it verbatim instead of wrapping it a second time (which
-    // would otherwise produce a "Tavily request failed: Tavily 429: ..." double-prefixed message).
-    class TavilyHttpError extends Error {
-    }
-    const timeoutController = new AbortController();
-    const timeoutHandle = setTimeout(() => timeoutController.abort(), DEFAULT_TAVILY_TIMEOUT_MS);
-    // Assigned in the `try` and returned *after* the `finally`, rather than returned from inside the
-    // `try`. Both forms behave identically, but a return-through-`finally` compiles to three copies of
-    // the `finally` body (normal completion, return, throw) and one of those is unreachable here — the
-    // `try` cannot fall off its end and the `catch` always throws. Falling through to a single return
-    // keeps the cleanup path honestly measurable instead of permanently one-third uncovered.
-    let output;
-    try {
-        const response = await fetch(`${base}/search`, {
-            method: 'POST',
-            headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
-            body: JSON.stringify(body),
-            signal: timeoutController.signal,
-        });
-        if (!response.ok) {
-            const text = await response.text().catch(() => '');
-            throw new TavilyHttpError(redactSecrets({ input: `Tavily ${response.status}: ${text.slice(0, 200) || 'no body'}` }, { exactSecrets: [apiKey] }));
-        }
-        const json = (await response.json());
-        const answer = typeof json.answer === 'string' ? json.answer : '';
-        const rawResults = Array.isArray(json.results) ? json.results : [];
-        const sources = [];
-        for (const raw of rawResults) {
-            const url = typeof raw.url === 'string' ? raw.url : '';
-            if (!url)
-                continue;
-            const publishedAt = typeof raw.published_date === 'string' && raw.published_date.trim() ? raw.published_date.trim() : undefined;
-            sources.push({
-                title: typeof raw.title === 'string' && raw.title.trim() ? raw.title.trim() : url,
-                url,
-                snippet: typeof raw.content === 'string' ? raw.content.trim().slice(0, 800) : '',
-                provider: 'tavily',
-                ...(publishedAt ? { publishedAt } : {}),
-            });
-        }
-        output = { answer, sources };
-    }
-    catch (error) {
-        if (!timeoutController.signal.aborted && error instanceof TavilyHttpError) {
-            throw error;
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(redactSecrets({
-            input: timeoutController.signal.aborted
-                ? `Tavily request timed out after ${DEFAULT_TAVILY_TIMEOUT_MS}ms`
-                : `Tavily request failed: ${message}`,
-        }, { exactSecrets: [apiKey] }));
-    }
-    finally {
-        clearTimeout(timeoutHandle);
-    }
-    return output;
-}
 /** Ported verbatim from OD's real `research/index.ts#synthesizeFallbackSummary` — see module doc. Used when Tavily returns no `answer` text so the caller still gets a usable `summary`. */
 function synthesizeFallbackSummary(sources) {
     const lead = sources
@@ -267,49 +166,65 @@ function synthesizeFallbackSummary(sources) {
         .join('\n');
     return `(No provider summary; top snippets follow.)\n${lead}`;
 }
-export const researchSearchRoute = defineJsonRoute({
-    method: 'post', path: '/api/research/search', parse: parseResearchSearch, handle: async ({ input: request, deps }) => {
-        const resolveCredentials = deps.resolveCredentials ?? defaultResolveCredentials;
-        const onInternalError = deps.onInternalError ?? defaultInternalErrorSink;
-        let credentials;
-        try {
-            credentials = await resolveCredentials({ providerId: 'tavily' });
-        }
-        catch (error) {
-            const correlationId = randomUUID();
-            onInternalError({ correlationId, error });
-            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
-        }
-        const apiKey = credentials.apiKey;
-        if (!apiKey) {
-            return err({ error: createApiError({ code: 'NOT_CONFIGURED', message: 'tavily provider not configured' }) });
-        }
-        try {
-            const raw = await tavilySearch(apiKey, credentials, request);
-            // Matches OD's real `NO_RESEARCH_SOURCES` (404) — see module doc. Zero usable sources is a
-            // failure, not an empty success, even when the upstream Tavily call itself succeeded.
-            if (raw.sources.length === 0) {
-                return err({ error: createApiError({ code: 'NOT_FOUND', message: 'no sources found' }) });
+/** Builds one route over a host-selected provider, preserving the default Tavily validation contract. */
+export function createResearchSearchRoute({ provider }, _optional = {}) {
+    const providerId = provider?.id ?? 'tavily';
+    return defineJsonRoute({
+        method: 'post', path: '/api/research/search', parse: (input) => parseResearchSearch(input, providerId), handle: async ({ input: request, deps }) => {
+            const selectedProvider = provider ?? deps.provider ?? createTavilyResearchProvider({}, deps.fetch ? { fetch: deps.fetch } : {});
+            const resolveCredentials = deps.resolveCredentials ?? (() => selectedProvider.id === 'tavily' ? defaultResolveCredentials({ env: deps.env ?? process.env }) : Promise.resolve({}));
+            const onInternalError = deps.onInternalError ?? defaultInternalErrorSink;
+            let credentials;
+            try {
+                credentials = await resolveCredentials({ providerId: selectedProvider.id });
+            }
+            catch (error) {
+                const correlationId = randomUUID();
+                onInternalError({ correlationId, error });
+                return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
+            }
+            const apiKey = credentials.apiKey;
+            if (!apiKey) {
+                return err({ error: createApiError({ code: 'NOT_CONFIGURED', message: `${selectedProvider.id} provider not configured` }) });
+            }
+            try {
+                const raw = await selectedProvider.search({ apiKey, credentials, request }, {});
+                // Matches OD's real `NO_RESEARCH_SOURCES` (404) — see module doc. Zero usable sources is a
+                // failure, not an empty success, even when the upstream Tavily call itself succeeded.
+                if (raw.sources.length === 0) {
+                    return err({ error: createApiError({ code: 'NOT_FOUND', message: 'no sources found' }) });
+                }
+                const result = {
+                    query: request.query,
+                    summary: raw.answer || synthesizeFallbackSummary(raw.sources),
+                    sources: raw.sources,
+                    provider: selectedProvider.id,
+                    depth: 'shallow',
+                    fetchedAt: Date.now(),
+                };
+                return ok({ value: result });
+            }
+            catch (error) {
+                const correlationId = randomUUID();
+                // A host provider can throw transport text too; keep its configured key out of the sink.
+                const safeMessage = redactSecrets({ input: error instanceof Error ? error.message : String(error) }, { exactSecrets: [apiKey] });
+                const safeError = new Error(safeMessage);
+                if (error instanceof Error) {
+                    safeError.name = redactSecrets({ input: error.name }, { exactSecrets: [apiKey] });
+                    if (error.stack === undefined)
+                        delete safeError.stack;
+                    else
+                        safeError.stack = redactSecrets({ input: error.stack }, { exactSecrets: [apiKey] });
+                }
+                onInternalError({ correlationId, error: safeError });
+                return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
             }
-            const result = {
-                query: request.query,
-                summary: raw.answer || synthesizeFallbackSummary(raw.sources),
-                sources: raw.sources,
-                provider: 'tavily',
-                depth: 'shallow',
-                fetchedAt: Date.now(),
-            };
-            return ok({ value: result });
-        }
-        catch (error) {
-            const correlationId = randomUUID();
-            onInternalError({ correlationId, error });
-            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
         }
-    }
-}, { requireSameOrigin: true });
+    }, { requireSameOrigin: true });
+}
+export const researchSearchRoute = createResearchSearchRoute({});
 /** Mounts `POST /api/research/search` on `app`. A pack's `http(app, services)` calls this directly. */
 export function registerResearchRoutes({ app, deps, adapter }, _optional = {}) {
-    mountJsonRoute({ app, spec: researchSearchRoute, deps, adapter });
+    mountJsonRoute({ app, spec: deps.provider ? createResearchSearchRoute({ provider: deps.provider }) : researchSearchRoute, deps, adapter });
 }
 //# sourceMappingURL=research.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/daemon",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "The stateful agent daemon runtime: run lifecycle, durable event-log port, the tool-execution boundary, agent executor, terminal sessions, and routines.",
   "license": "Apache-2.0",
   "repository": {
@@ -139,29 +139,29 @@
     "@types/pg": "8.23.1",
     "express": "^4.21.0",
     "@types/express": "^4.17.21",
-    "@jini-ai/db": "0.3.1",
-    "@jini-ai/http-kit": "0.4.1",
-    "@jini-ai/agent-runtime": "^0.4.4",
-    "@jini-ai/chat": "0.5.7",
-    "@jini-ai/core": "^0.4.2",
-    "@jini-ai/platform": "^0.5.2",
-    "@jini-ai/protocol": "^0.4.3"
+    "@jini-ai/chat": "0.5.8",
+    "@jini-ai/db": "0.3.2",
+    "@jini-ai/agent-runtime": "^0.4.5",
+    "@jini-ai/protocol": "^0.4.4",
+    "@jini-ai/core": "^0.4.3",
+    "@jini-ai/platform": "^0.5.3",
+    "@jini-ai/http-kit": "0.4.1"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.2",
-    "@jini-ai/protocol": "^0.4.3"
+    "@jini-ai/core": "^0.4.3",
+    "@jini-ai/protocol": "^0.4.4"
   },
   "peerDependencies": {
     "node-pty": "^1.1.0",
-    "@jini-ai/db": "^0.2.0 || ^0.3.0",
+    "@jini-ai/db": "^0.3.2",
     "kysely": "^0.29.6",
     "better-sqlite3": "^13.0.0",
     "@electric-sql/pglite": "0.5.8",
     "pg": "^8.23.0",
     "@jini-ai/http-kit": "^0.4.0",
     "express": "^4.21.0",
-    "@jini-ai/agent-runtime": "^0.4.4",
-    "@jini-ai/platform": "^0.5.1"
+    "@jini-ai/agent-runtime": "^0.4.5",
+    "@jini-ai/platform": "^0.5.3"
   },
   "peerDependenciesMeta": {
     "node-pty": {