@jini-ai/daemon 0.6.9 → 0.6.11

package/dist/http/runs.js

@@ -154,8 +154,8 @@ export const runCancelRoute = defineJsonRoute({
 /**
  * `POST /api/runs/:runId/messages` — a message the human sent while the run is going. `202` when it
  * reached the live agent; `409 CONFLICT` with `details.delivery` (`'unsupported'` or
- * `'not-running'`) when it did not, which tells the client whether to interrupt the run and send the
- * text as the next turn, or simply send it next because the run is already ending.
+ * `'not-running'`) when it did not, which tells the client to retain the next-turn queue without canceling live work.
+ * Acceptance is distinct from the UUID-attributed consumption receipt in the run stream.
  */
 export const runMessageRoute = defineJsonRoute({
     method: 'post', path: '/api/runs/:runId/messages', parse: parseRunMessage, handle: async ({ input, deps }) => {
@@ -163,9 +163,10 @@ export const runMessageRoute = defineJsonRoute({
         if (run === undefined)
             return err({ error: createApiError({ code: 'NOT_FOUND', message: `run "${input.runId}" was not found` }) });
         const deliver = input.attachmentIds?.length ? deps.deliverUserMessageWithAttachments : deps.deliverUserMessage;
-        const delivery = deliver ? await deliver(input) : 'unsupported';
+        const id = randomUUID();
+        const delivery = deliver ? await deliver({ ...input, id }) : 'unsupported';
         if (delivery === 'delivered')
-            return ok({ value: { delivery } });
+            return ok({ value: { delivery, id } });
         return err({ error: createApiError({ code: 'CONFLICT', message: `run "${input.runId}" did not take the message` }, { details: { delivery } }) });
     }
 }, { requireSameOrigin: true, successStatus: 202 });
@@ -208,7 +209,12 @@ export async function handleRunEventStreamRequest({ res, runId, afterCursor, dep
         }
     });
     try {
-        const subscribed = await deps.lifecycle.stream({ runId, onEvent: (event) => channel.enqueue({ event }) }, { afterCursor });
+        const subscribed = await deps.lifecycle.stream({ runId, onEvent: (event) => {
+                // RunLifecycle validates the run/cursor before replay callbacks. Open before enqueueing
+                // history so a healthy response drains replay instead of overflowing the unopened queue.
+                channel.open();
+                channel.enqueue({ event });
+            } }, { afterCursor });
         if (subscribed.kind !== 'ok') {
             // Nothing was ever subscribed, so `abandon()` has nothing to unsubscribe — it only marks
             // the channel closed. `res` itself is untouched, leaving `sendStreamFailure` free to send

package/dist/index.d.ts

@@ -93,4 +93,6 @@ export * from './run/index.js';
 export * from './continuation/index.js';
 export * from './routines/index.js';
 export * from './attachment-content.js';
+export * from './delegated-result-correlation.js';
+export type { StdoutJournalBlobPort } from './tool-result-diagnostics.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -93,4 +93,5 @@ export * from './run/index.js';
 export * from './continuation/index.js';
 export * from './routines/index.js';
 export * from './attachment-content.js';
+export * from './delegated-result-correlation.js';
 //# sourceMappingURL=index.js.map

package/dist/run-lifecycle.d.ts

@@ -1,3 +1,20 @@
+/**
+ * `RunLifecycle` — start/stream/cancel/resume a run keyed on an opaque
+ * `contextRef` (extraction-plan §2.1: runs key on an opaque `contextRef`,
+ * never a product-record identifier), generalized from OD's `design.runs` service
+ * (`apps/daemon/src/runtimes/runs.ts` + the terminal-decision half of
+ * `apps/daemon/src/runtimes/start-chat-run.ts`, `arch/server-startserver-endgame`
+ * branch — see `archived provenance ledger` for exact line citations).
+ *
+ * Scope boundary: this module owns the run *state machine* and its event
+ * log — create, transition, emit, replay, cancellation-intent propagation,
+ * idempotent start/finish, resume. It does not spawn or signal a subprocess;
+ * that is `@jini-ai/agent-runtime`'s job (extraction-plan task 7). A driver
+ * (today: this package's tests; later: agent-runtime) calls `emit()` for
+ * agent/stdout/stderr/error events, observes cancellation via
+ * `onCancelRequested`, and calls `finish()` once it knows the real outcome.
+ */
+import type { DelegatedResultCorrelation } from './delegated-result-correlation.js';
 import type { RunAgentPayload, RunCancelRequest, RunChunkPayload, RunErrorPayload, RunProtocolEvent, RunStartPayload, RunStatus } from '@jini-ai/protocol';
 import type { EventLog, EventLogEntry, EventLogReplayResult } from './event-log.js';
 import type { InactivityWatchdog, TerminalRunOutcome } from './close-status.js';
@@ -276,6 +293,8 @@ export declare function finishStreamSubscription({ record, subscriber, terminal
     readonly terminal: boolean;
 }): StreamSubscribeResult;
 export interface CreateRunLifecycleInput {
+    /** Share the negotiated bridge/executor digest store so run eviction also releases proofs. */
+    readonly delegatedResultCorrelation?: DelegatedResultCorrelation;
     readonly eventLog: EventLog;
     /** Host-owned sink for asynchronous lifecycle failures that cannot be returned to a caller. Defaults to `console.error`. */
     readonly onInternalError?: (context: RunLifecycleInternalErrorContext) => void;
@@ -319,5 +338,5 @@ export interface RunLifecycleInternalErrorContext {
  * @complexity Per-call complexities documented on each method; the registry itself is a `Map` keyed by `runId` (O(1) lookup). Memory is bounded: non-terminal runs are O(n) in concurrently-live runs, and terminal runs are capped at `maxTerminalRuns` (each additionally bounded in retention time by `terminalRetentionMs`) rather than growing for the life of the process.
  * @overallScore 100/100
  */
-export declare function createRunLifecycle(requiredArgs: Pick<CreateRunLifecycleInput, "eventLog">, optionalArgs?: Pick<CreateRunLifecycleInput, "onInternalError" | "terminalRetentionMs" | "maxTerminalRuns" | "slowRunThresholdMs" | "dropEventsOnEviction">): RunLifecycle;
+export declare function createRunLifecycle(requiredArgs: Pick<CreateRunLifecycleInput, "eventLog">, optionalArgs?: Pick<CreateRunLifecycleInput, "onInternalError" | "terminalRetentionMs" | "maxTerminalRuns" | "slowRunThresholdMs" | "dropEventsOnEviction" | "delegatedResultCorrelation">): RunLifecycle;
 //# sourceMappingURL=run-lifecycle.d.ts.map

package/dist/run-lifecycle.js

@@ -1,19 +1,3 @@
-/**
- * `RunLifecycle` — start/stream/cancel/resume a run keyed on an opaque
- * `contextRef` (extraction-plan §2.1: runs key on an opaque `contextRef`,
- * never a product-record identifier), generalized from OD's `design.runs` service
- * (`apps/daemon/src/runtimes/runs.ts` + the terminal-decision half of
- * `apps/daemon/src/runtimes/start-chat-run.ts`, `arch/server-startserver-endgame`
- * branch — see `archived provenance ledger` for exact line citations).
- *
- * Scope boundary: this module owns the run *state machine* and its event
- * log — create, transition, emit, replay, cancellation-intent propagation,
- * idempotent start/finish, resume. It does not spawn or signal a subprocess;
- * that is `@jini-ai/agent-runtime`'s job (extraction-plan task 7). A driver
- * (today: this package's tests; later: agent-runtime) calls `emit()` for
- * agent/stdout/stderr/error events, observes cancellation via
- * `onCancelRequested`, and calls `finish()` once it knows the real outcome.
- */
 import { randomUUID } from 'node:crypto';
 import { RUN_PROTOCOL_VERSION, isTerminalRunState } from '@jini-ai/protocol';
 import { createInactivityWatchdog } from './close-status.js';
@@ -367,6 +351,7 @@ export function createRunLifecycle(requiredArgs, optionalArgs = {}) {
         }
         catch (error) {
             runs.delete(runId);
+            input.delegatedResultCorrelation?.clearRun({ runId });
             clearIdempotencyIndexEntryIfMatching({ idempotencyIndex: idempotencyIndex, idempotencyKey: startInput.idempotencyKey, runId: runId });
             throw error;
         }
@@ -418,6 +403,7 @@ export function createRunLifecycle(requiredArgs, optionalArgs = {}) {
             return;
         record.retentionTimer = undefined;
         runs.delete(runId);
+        input.delegatedResultCorrelation?.clearRun({ runId });
         clearIdempotencyIndexEntryIfMatching({ idempotencyIndex: idempotencyIndex, idempotencyKey: record.idempotencyKey, runId: runId });
         if (input.dropEventsOnEviction === true)
             void dropEvictedRunEvents(runId);

package/dist/tool-executor.js

@@ -212,11 +212,12 @@ export function createToolExecutor(requiredArgs, optionalArgs = {}) {
         const error = guidance ? `${message}\n\n${guidance}` : message;
         return { executionId, status: 'failed', error, errorKind, ...(normalizationNotes.length ? { normalizationNotes } : {}) };
     }
-    /** Throws the typed unknown-tool input error, naming up to eight registered prefix matches. */
-    function assertKnownTool({ registry: invocationRegistry, toolId }) {
+    /** Throws the typed unknown-tool input error, naming up to eight similarity-ranked registrations.
+     * Input is used only for a diagnostic resource hint; this never dispatches an alternate tool. */
+    function assertKnownTool({ registry: invocationRegistry, toolId, input }) {
         if (invocationRegistry.has({ toolId }))
             return;
-        const candidates = toolCandidates({ toolId, tools: invocationRegistry.list({}) });
+        const candidates = toolCandidates({ toolId, tools: invocationRegistry.list({}), input });
         const hint = candidates.length > 0 ? `; did you mean ${candidates.join(', ')}?` : '';
         throw new ToolInputError({ message: `ToolExecutor: unknown tool "${toolId}"${hint}` });
     }
@@ -395,7 +396,7 @@ export function createToolExecutor(requiredArgs, optionalArgs = {}) {
         // policy that hangs or throws used to still leave a record behind. `has()` only confirms
         // existence, never returns a handler, so this doesn't reopen the leak authorizeToolInvocation
         // closed — that gate still runs, still unconditionally, inside the call below.
-        assertKnownTool({ registry: invocationRegistry, toolId });
+        assertKnownTool({ registry: invocationRegistry, toolId, input });
         const executionId = openAudit(principal, run, toolId);
         // Observes `signal` for this execution's ENTIRE remaining lifetime, not just the handler-run
         // phase. `requestConfirmation()`'s wait below is unbounded — it settles only when a human

package/dist/tool-result-diagnostics.d.ts

@@ -0,0 +1,27 @@
+/** Audit writers must store exact chunks in blobs and retain resolvable references separately.
+ * This port deliberately cannot masquerade as the inline RunByteJournal contract. */
+export interface StdoutJournalBlobPort {
+    /** Buffer chunks remain bytes, including UTF-8 characters split at OS read boundaries. */
+    record(input: {
+        runId: string;
+        chunk: string | Uint8Array;
+    }, options?: Record<string, never>): Promise<void>;
+}
+/** Projects one complete diagnostic frame; ordinary non-JSON output remains byte-identical. */
+export declare function projectDiagnosticFrame({ line }: {
+    line: string;
+}, { maxFrameChars }?: {
+    maxFrameChars?: number;
+}): string;
+/** Bounded JSONL framing: split chunks are held until complete, tails flush at close.
+ * Oversized frames produce an explicit notice and are discarded through their newline.
+ * @complexity O(n) total input characters; O(maxFrameChars) retained carry, no per-chunk joins. */
+export declare function createToolResultDiagnosticProjection(_input: Record<string, never>, { maxFrameChars }?: {
+    maxFrameChars?: number;
+}): {
+    feed({ chunk }: {
+        chunk: string;
+    }, _options?: {}): string;
+    flush(_input: Record<string, never>, _options?: {}): string;
+};
+//# sourceMappingURL=tool-result-diagnostics.d.ts.map

package/dist/tool-result-diagnostics.js

@@ -0,0 +1,77 @@
+function imageSummary(value) {
+    if (value.type !== 'image')
+        return undefined;
+    if (typeof value.mimeType === 'string' && typeof value.data === 'string') {
+        return { ...value, data: `[image ${value.mimeType}; ${value.data.length} base64 characters]` };
+    }
+    const source = value.source;
+    if (typeof source !== 'object' || source === null)
+        return undefined;
+    const image = source;
+    if (image.type !== 'base64' || typeof image.data !== 'string' || typeof image.media_type !== 'string')
+        return undefined;
+    return { ...value, source: { ...image, data: `[image ${image.media_type}; ${image.data.length} base64 characters]` } };
+}
+/** Redacts only recognized image fields, including JSON-encoded tool-result content.
+ * @complexity O(n) frame bytes, bounded by the framing limit before parsing. */
+function summarizeImages(_key, value) {
+    if (_key === 'content' && typeof value === 'string')
+        return projectDiagnosticFrame({ line: value });
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return value;
+    return imageSummary(value) ?? value;
+}
+/** Projects one complete diagnostic frame; ordinary non-JSON output remains byte-identical. */
+export function projectDiagnosticFrame({ line }, { maxFrameChars = 16 * 1024 * 1024 } = {}) {
+    if (line.length > maxFrameChars)
+        return '[diagnostic frame exceeded image projection limit]';
+    try {
+        return JSON.stringify(JSON.parse(line), summarizeImages);
+    }
+    catch {
+        return line;
+    }
+}
+/** Bounded JSONL framing: split chunks are held until complete, tails flush at close.
+ * Oversized frames produce an explicit notice and are discarded through their newline.
+ * @complexity O(n) total input characters; O(maxFrameChars) retained carry, no per-chunk joins. */
+export function createToolResultDiagnosticProjection(_input, { maxFrameChars = 16 * 1024 * 1024 } = {}) {
+    if (!Number.isSafeInteger(maxFrameChars) || maxFrameChars < 1)
+        throw new Error('diagnostic frame limit must be a positive integer');
+    let parts = [];
+    let size = 0;
+    let dropping = false;
+    function append(part) {
+        if (dropping || part.length === 0)
+            return;
+        size += part.length;
+        if (size > maxFrameChars) {
+            parts = [];
+            dropping = true;
+            return;
+        }
+        parts.push(part);
+    }
+    function finish() {
+        const line = dropping ? '[diagnostic frame exceeded image projection limit]' : projectDiagnosticFrame({ line: parts.join('') }, { maxFrameChars });
+        parts = [];
+        size = 0;
+        dropping = false;
+        return line;
+    }
+    return {
+        feed({ chunk }, _options = {}) {
+            const completed = [];
+            let start = 0;
+            for (let end = chunk.indexOf('\n'); end !== -1; end = chunk.indexOf('\n', start)) {
+                append(chunk.slice(start, end));
+                completed.push(finish(), '\n');
+                start = end + 1;
+            }
+            append(chunk.slice(start));
+            return completed.join('');
+        },
+        flush(_input, _options = {}) { return size > 0 || dropping ? finish() : ''; },
+    };
+}
+//# sourceMappingURL=tool-result-diagnostics.js.map

package/dist/tool-result-media.d.ts

@@ -1,3 +1,4 @@
+import type { ToolExecutionResult } from './tool-executor.js';
 /**
  * Extracts UI-renderable media blocks from a tool handler's raw MCP-style content envelope
  * (`{ content: [...] }`), for `delegated-tool-bridge.ts` and `agent-executor.ts` to attach to the
@@ -11,18 +12,9 @@
  * and is deliberately narrower: it recognizes exactly one block type today (`image`), and has no
  * withhold-from-model concept of its own.
  *
- * The two DO interact, though not by pipelining: `delegated-tool-bridge.ts`'s `execute()` calls both
- * of them against the SAME raw `executed.output`, not this module's `remainder` into
- * `splitToolResultSurfaces`. That used to be pipelined — this module removed recognized image
- * blocks from `content` before the surfaces pass ran, because `splitToolResultSurfaces`'s whitelist
- * used to recognize only `text`, and an image block left in place would have been swept into
- * `surfaces` and withheld from the model. Now that `image` is itself one of
- * `tool-result-surfaces.ts`'s `MODEL_VISIBLE_BLOCK_TYPES` (a deliberate addition — see that
- * constant's own doc), the surfaces pass classifies an image block correctly on its own, so there is
- * no misclassification left to prevent by removing it first. This module's `remainder` field is
- * therefore no longer read by that caller at all (kept for this module's own tests and any future
- * caller that wants a de-imaged copy); only `media` is used, to populate the `tool_result` event's
- * sibling `media` field for a UI that wants to render inline without re-parsing `content`.
+ * The surface whitelist runs on the original output first. Its model-visible result still
+ * contains images for MCP/model delivery. Only the event projection below serializes this
+ * module's de-imaged remainder, alongside one `media` array for rendering.
  *
  * ## Why only `image`, and why blocks are silently skipped rather than reported
  *
@@ -67,8 +59,7 @@ export interface ExtractResultMedia {
 }
 /**
  * Splits a tool handler's raw return value into its recognized media blocks and the remainder,
- * ready to feed onward into `splitToolResultSurfaces` (see this module's doc for why that order
- * matters).
+ * without modifying the model-facing output. Run the surface whitelist on the original first.
  *
  * @param output - A tool handler's raw return value (`ToolExecutionResult.output` when
  * `status === 'completed'`). Non-envelope values (the overwhelming majority of tools, which return
@@ -78,4 +69,26 @@ export interface ExtractResultMedia {
 export declare function extractResultMedia({ output }: {
     readonly output: unknown;
 }): ExtractResultMedia;
+/** Converts arbitrary registered-tool output into the string-bearing run protocol. */
+export declare function serializeDelegatedToolOutput({ output }: {
+    readonly output: unknown;
+}): string;
+/**
+ * Maps a `ToolExecutionResult`'s status to the string a delegated-tool caller (this bridge, or
+ * gap 3's stdin-tool-result injector in `agent-executor.ts`) reports back as the tool's visible
+ * output/failure reason. Exported so both real callers share one mapping rather than drifting.
+ */
+export declare function resultContent({ result }: {
+    readonly result: ToolExecutionResult;
+}): string;
+/** Projects a model-safe result into the saved event: pixels occur only in `media`.
+ * Uses the existing serializer and status mapping; callers keep the original for the model.
+ * @complexity O(n) output bytes, with O(n) transient serialization space. */
+export declare function projectToolResultEvent({ result }: {
+    result: ToolExecutionResult;
+}, _options?: {}): {
+    content: string;
+    isError?: true;
+    media?: readonly ToolResultMediaBlock[];
+};
 //# sourceMappingURL=tool-result-media.d.ts.map

package/dist/tool-result-media.js

@@ -1,39 +1,4 @@
-/**
- * Extracts UI-renderable media blocks from a tool handler's raw MCP-style content envelope
- * (`{ content: [...] }`), for `delegated-tool-bridge.ts` and `agent-executor.ts` to attach to the
- * `tool_result` wire event's new `media` field (`@jini-ai/protocol`'s `events.ts`).
- *
- * ## Why this is not `tool-result-surfaces.ts`
- *
- * That module's whitelist governs a SECURITY property: which blocks may reach the model versus
- * which are withheld for a human-only UI resource (MCP-UI, still deferred). This module answers a
- * different question — "does this block carry displayable media a chat pane can render inline" —
- * and is deliberately narrower: it recognizes exactly one block type today (`image`), and has no
- * withhold-from-model concept of its own.
- *
- * The two DO interact, though not by pipelining: `delegated-tool-bridge.ts`'s `execute()` calls both
- * of them against the SAME raw `executed.output`, not this module's `remainder` into
- * `splitToolResultSurfaces`. That used to be pipelined — this module removed recognized image
- * blocks from `content` before the surfaces pass ran, because `splitToolResultSurfaces`'s whitelist
- * used to recognize only `text`, and an image block left in place would have been swept into
- * `surfaces` and withheld from the model. Now that `image` is itself one of
- * `tool-result-surfaces.ts`'s `MODEL_VISIBLE_BLOCK_TYPES` (a deliberate addition — see that
- * constant's own doc), the surfaces pass classifies an image block correctly on its own, so there is
- * no misclassification left to prevent by removing it first. This module's `remainder` field is
- * therefore no longer read by that caller at all (kept for this module's own tests and any future
- * caller that wants a de-imaged copy); only `media` is used, to populate the `tool_result` event's
- * sibling `media` field for a UI that wants to render inline without re-parsing `content`.
- *
- * ## Why only `image`, and why blocks are silently skipped rather than reported
- *
- * `text` blocks already reach the model (and the UI, via `content`) through the existing flattened
- * string — duplicating them into `media` would be redundant, not additive, so this module leaves
- * them in `remainder` and never collects them. A block claiming `type: 'image'` without a string
- * `mimeType`/`data` is dropped rather than surfaced as a malformed-block error: a handler's return
- * value is untrusted input to this module (it may come from an external MCP server), and the
- * contract is "render what is well-formed, ignore what isn't" — the same fail-quiet posture
- * `serializeDelegatedToolOutput` already takes on a non-serializable output.
- */
+import { batchOutcomeFor } from '@jini-ai/core';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -50,8 +15,7 @@ function asImageBlock(block) {
 }
 /**
  * Splits a tool handler's raw return value into its recognized media blocks and the remainder,
- * ready to feed onward into `splitToolResultSurfaces` (see this module's doc for why that order
- * matters).
+ * without modifying the model-facing output. Run the surface whitelist on the original first.
  *
  * @param output - A tool handler's raw return value (`ToolExecutionResult.output` when
  * `status === 'completed'`). Non-envelope values (the overwhelming majority of tools, which return
@@ -77,4 +41,53 @@ export function extractResultMedia({ output }) {
         return { remainder: output, media: [] };
     return { remainder: { ...output, content: kept }, media };
 }
+/** Converts arbitrary registered-tool output into the string-bearing run protocol. */
+export function serializeDelegatedToolOutput({ output }) {
+    if (typeof output === 'string')
+        return output;
+    if (output === undefined)
+        return '';
+    try {
+        const serialized = JSON.stringify(output);
+        return serialized === undefined ? String(output) : serialized;
+    }
+    catch {
+        return String(output);
+    }
+}
+/**
+ * Maps a `ToolExecutionResult`'s status to the string a delegated-tool caller (this bridge, or
+ * gap 3's stdin-tool-result injector in `agent-executor.ts`) reports back as the tool's visible
+ * output/failure reason. Exported so both real callers share one mapping rather than drifting.
+ */
+export function resultContent({ result }) {
+    switch (result.status) {
+        case 'completed':
+            return serializeDelegatedToolOutput({ output: result.output });
+        case 'denied':
+            return 'Tool execution denied by policy.';
+        case 'confirmation-denied':
+            return 'Tool execution denied during confirmation.';
+        case 'timed-out':
+            return 'Tool execution timed out.';
+        case 'cancelled':
+            return 'Tool execution cancelled.';
+        case 'failed':
+            return result.error ?? 'Tool execution failed.';
+    }
+}
+/** Projects a model-safe result into the saved event: pixels occur only in `media`.
+ * Uses the existing serializer and status mapping; callers keep the original for the model.
+ * @complexity O(n) output bytes, with O(n) transient serialization space. */
+export function projectToolResultEvent({ result }, _options = {}) {
+    const { remainder, media } = extractResultMedia({ output: result.output });
+    const isError = result.status !== 'completed'
+        || (batchOutcomeFor({ output: result.output }) ?? 'completed') !== 'completed'
+        || (isRecord(result.output) && result.output.isError === true);
+    return {
+        content: resultContent({ result: { ...result, output: remainder } }),
+        ...(isError ? { isError: true } : {}),
+        ...(media.length > 0 ? { media } : {}),
+    };
+}
 //# sourceMappingURL=tool-result-media.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/daemon",
-  "version": "0.6.9",
+  "version": "0.6.11",
   "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.6",
-    "@jini-ai/http-kit": "0.4.3",
-    "@jini-ai/agent-runtime": "^0.4.12",
-    "@jini-ai/core": "^0.4.9",
-    "@jini-ai/protocol": "^0.4.5",
-    "@jini-ai/platform": "^0.5.10",
-    "@jini-ai/chat": "0.6.7"
+    "@jini-ai/db": "0.6.11",
+    "@jini-ai/core": "^0.6.11",
+    "@jini-ai/platform": "^0.6.11",
+    "@jini-ai/agent-runtime": "^0.6.11",
+    "@jini-ai/chat": "0.6.11",
+    "@jini-ai/protocol": "^0.6.11",
+    "@jini-ai/http-kit": "0.6.11"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.9",
-    "@jini-ai/protocol": "^0.4.5"
+    "@jini-ai/protocol": "^0.6.11",
+    "@jini-ai/core": "^0.6.11"
   },
   "peerDependencies": {
     "node-pty": "^1.1.0",
-    "@jini-ai/db": "^0.3.2",
+    "@jini-ai/db": "^0.6.10",
     "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",
+    "@jini-ai/http-kit": "^0.6.10",
     "express": "^4.21.0 || ^5.0.0",
-    "@jini-ai/agent-runtime": "^0.4.10",
-    "@jini-ai/platform": "^0.5.5"
+    "@jini-ai/agent-runtime": "^0.6.10",
+    "@jini-ai/platform": "^0.6.10"
   },
   "peerDependenciesMeta": {
     "node-pty": {