@jini-ai/daemon 0.6.17 → 0.6.19

package/dist/surface-restoration.d.ts

@@ -0,0 +1,38 @@
+import type { Clock } from '@jini-ai/core/primitives';
+import type { DeliverResult, SurfaceEmitter, SurfaceEmission, SurfaceExchangeBinding, SurfaceExchangeStore } from '@jini-ai/core';
+type Lifetime = NonNullable<SurfaceEmitter['exchangeLifetime']>;
+type Delivery = SurfaceExchangeStore['deliver'];
+/** Shared recovery owner for every exchange channel. The store supplies delivery; the executor
+ * supplies retry, so recovery cannot bypass authorization or invent a second handler.
+ * @complexity O(n) per open/restore/accepted answer in active entries plus at most 128 retained
+ * entries; O(t) per emission to t observing tabs.
+ */
+export declare function createSurfaceRestoration({ clock, defaultChannel, deliver }: {
+    clock: Clock;
+    defaultChannel: string;
+    deliver: Delivery;
+}, _options?: Record<string, never>): {
+    track: ({ id, binding, lifetime }: {
+        id: string;
+        binding: SurfaceExchangeBinding;
+        lifetime: Lifetime;
+    }) => {
+        send: ({ emission }: {
+            emission: SurfaceEmission;
+        }) => Promise<void>;
+        answered: () => void;
+        end: () => void;
+    };
+    restore: (required: {
+        exchangeId: string;
+        principalId: string;
+        emit: SurfaceEmitter;
+    }, optional?: {
+        toolId?: string;
+        channel?: import("@jini-ai/core").SurfaceAnswerChannel;
+        params?: Record<string, unknown>;
+        signal?: AbortSignal;
+    }) => Promise<DeliverResult>;
+};
+export {};
+//# sourceMappingURL=surface-restoration.d.ts.map

package/dist/surface-restoration.js

@@ -0,0 +1,152 @@
+/** Only unanswered public invocations survive a call. Bounded in count, with no timer
+ * keeping a process alive. Submitted secrets never enter this cache; late answers stay on the
+ * submitting request's stack until they can be delivered to the newly authorized call. */
+const MAX_RETAINED = 128;
+const unavailable = () => ({ ok: false, reason: 'unknown-or-closed' });
+/** Fan out display-only updates. Losing a tab must never replace the tool's authoritative result.
+ * @complexity O(t) in tabs observing this card. */
+async function broadcast({ entry, emission }) {
+    await Promise.allSettled([...entry.observers].map(observer => observer(emission)));
+}
+/** Strict binding survives expiry and every retry; restoration cannot weaken ordinary delivery. */
+function matches({ entry, principalId, toolId, channel, defaultChannel }) {
+    if (entry.binding.principalId !== principalId)
+        return false;
+    if (toolId !== undefined && entry.binding.toolId !== toolId)
+        return false;
+    return (entry.binding.channel ?? defaultChannel) === (channel ?? defaultChannel);
+}
+/** Subscribe until this request leaves or the shared work finishes. A departing tab cancels a
+ * replacement only when no other tab still observes it. It never cancels the original agent call.
+ * @complexity O(1) subscription state per request. */
+async function join({ entry, emit, work, signal }, { initial } = {}) {
+    let leave;
+    const aborted = new Promise(resolve => { leave = () => resolve(unavailable()); });
+    const observer = emission => emit(emission);
+    entry.observers.add(observer);
+    signal?.addEventListener('abort', leave, { once: true });
+    if (signal?.aborted)
+        leave();
+    try {
+        if (initial)
+            await emit(initial);
+        return await Promise.race([work, aborted]);
+    }
+    finally {
+        entry.observers.delete(observer);
+        signal?.removeEventListener('abort', leave);
+        if (entry.observers.size === 0)
+            entry.restartAbort?.abort();
+    }
+}
+/** Restart once, even if several tabs return together. The old scrollback handle survives an
+ * interrupted replacement; a received answer consumes both it and the replacement handle.
+ * @complexity O(t) per emitted frame, plus the original executor's cost.
+ */
+function restart({ entry }) {
+    if (entry.restarting)
+        return entry.restarting;
+    const controller = new AbortController();
+    entry.restartAbort = controller;
+    let identify;
+    entry.replacementReady = new Promise(resolve => { identify = resolve; });
+    delete entry.replacementId;
+    entry.restarting = Promise.resolve().then(async () => {
+        await entry.lifetime.retry({ signal: controller.signal, emit: async (emission) => {
+                entry.emission = emission;
+                const metadata = emission.payload['surfaceExchange'];
+                if (metadata?.exchangeId) {
+                    entry.replacementId = metadata.exchangeId;
+                    identify(metadata.exchangeId);
+                }
+                await broadcast({ entry, emission });
+            } });
+        return entry.replacementId === undefined ? unavailable() : { ok: true };
+    }).finally(() => {
+        identify(undefined); // Authorization/preparation can refuse before opening any replacement.
+        delete entry.restarting;
+        delete entry.restartAbort;
+    });
+    return entry.restarting;
+}
+/** Deliver a late answer only after a new, authorized exchange exists. The answer is not cached,
+ * reused as tool input or broadcast. A second tab cannot repeat an already consumed decision.
+ */
+async function deliverLate({ entry, principalId, params, deliver }, options) {
+    const exchangeId = await entry.replacementReady;
+    if (exchangeId === undefined || entry.answered || options?.signal?.aborted)
+        return;
+    deliver({ exchangeId, principalId, params }, options);
+}
+/** Shared recovery owner for every exchange channel. The store supplies delivery; the executor
+ * supplies retry, so recovery cannot bypass authorization or invent a second handler.
+ * @complexity O(n) per open/restore/accepted answer in active entries plus at most 128 retained
+ * entries; O(t) per emission to t observing tabs.
+ */
+export function createSurfaceRestoration({ clock, defaultChannel, deliver }, _options = {}) {
+    const entries = new Map();
+    function prune() {
+        const retained = [];
+        for (const [id, entry] of entries) {
+            if (entry.endedAt === undefined || entry.restarting)
+                continue;
+            retained.push(id);
+        }
+        for (const id of retained.slice(0, Math.max(0, retained.length - MAX_RETAINED)))
+            entries.delete(id);
+    }
+    function forgetAnswered({ id }) {
+        for (const [key, entry] of entries) {
+            if (key === id || entry.replacementId === id) {
+                entry.answered = true;
+                entries.delete(key);
+            }
+        }
+    }
+    function track({ id, binding, lifetime }) {
+        prune();
+        let finish;
+        const ended = new Promise(resolve => { finish = resolve; });
+        const entry = { binding: { ...binding }, lifetime, answered: false, observers: new Set(), finish, ended };
+        entries.set(id, entry);
+        return {
+            send: async ({ emission }) => {
+                entry.emission = emission;
+                await broadcast({ entry, emission });
+            },
+            answered: () => forgetAnswered({ id }),
+            end: () => {
+                entry.endedAt = clock.nowMs();
+                entry.finish();
+                // A synthetic/nested card cannot safely replay its outer tool. No emitted surface means
+                // nobody saw a card to return to; retaining that call would be speculative work.
+                if (!entry.emission || entry.answered || binding.toolId !== lifetime.toolId)
+                    entries.delete(id);
+                prune();
+            },
+        };
+    }
+    const restore = async ({ exchangeId, principalId, emit }, options = {}) => {
+        prune();
+        const entry = entries.get(exchangeId);
+        if (!entry)
+            return unavailable();
+        if (!matches({ entry, principalId, toolId: options.toolId, channel: options.channel, defaultChannel }))
+            return { ok: false, reason: 'binding-mismatch' };
+        if (options.signal?.aborted)
+            return unavailable();
+        if (entry.endedAt === undefined) {
+            if (options.params)
+                return deliver({ exchangeId, principalId, params: options.params }, options);
+            return join({ entry, emit, work: entry.ended.then(() => ({ ok: true })), signal: options.signal }, entry.emission ? { initial: entry.emission } : {});
+        }
+        const work = restart({ entry });
+        // Subscribe synchronously before the retry's microtask can emit the first card.
+        const observed = join({ entry, emit, work, signal: options.signal }, entry.replacementId && entry.emission ? { initial: entry.emission } : {});
+        if (options.params)
+            await deliverLate({ entry, principalId, params: options.params, deliver }, options);
+        return observed;
+    };
+    return { track, restore };
+}
+//# sourceMappingURL=surface-restoration.js.map

package/dist/tool-recovery/index.d.ts

@@ -5,4 +5,5 @@ export * from "./stack.js";
 export * from "./federated-refusal.js";
 export * from "./observability.js";
 export * from "./analytics.js";
+export * from './surface-lifetime.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/tool-recovery/index.js

@@ -5,4 +5,5 @@ export * from "./stack.js";
 export * from "./federated-refusal.js";
 export * from "./observability.js";
 export * from "./analytics.js";
+export * from './surface-lifetime.js';
 //# sourceMappingURL=index.js.map

package/dist/tool-recovery/stack.js

@@ -46,6 +46,7 @@ import { withReadOnlyToolConstraint } from "../core/read-only-tools.js";
 import { withToolAttemptAudit } from "../core/tool-audit.js";
 import { withToolFailureRecovery } from "./recovery.js";
 import { withRedactedToolFailures, readToolErrorId } from "./redaction.js";
+import { withSurfaceExchangeLifetime } from './surface-lifetime.js';
 /** The audit wrapper's options: only an error sink the caller actually supplied. */
 function auditOptions(audit) {
     return audit.onSinkError ? { onSinkError: audit.onSinkError } : {};
@@ -61,6 +62,6 @@ export function createAssistantToolExecutor(deps, _optional = {}) {
     const audited = deps.toolAttemptAudit
         ? withToolAttemptAudit({ inner: redacted, ...deps.toolAttemptAudit, readErrorId: readToolErrorId }, auditOptions(deps.toolAttemptAudit))
         : redacted;
-    return withToolFailureRecovery({ ...deps, inner: audited }, {});
+    return withSurfaceExchangeLifetime({ inner: withToolFailureRecovery({ ...deps, inner: audited }, {}) });
 }
 //# sourceMappingURL=stack.js.map

package/dist/tool-recovery/surface-lifetime.d.ts

@@ -0,0 +1,11 @@
+import type { ToolExecutor } from '../tool-executor.js';
+/** Bind every card type to the executing call, and make restoration re-enter this same stack.
+ * No submitted answer is captured here: input is the original model-supplied invocation only.
+ * @param required.inner The complete authorization, recovery and audit stack.
+ * @returns An executor with the same cancellation and audit ports.
+ * @complexity O(input size) to snapshot public arguments; O(1) lifecycle state per call.
+ */
+export declare function withSurfaceExchangeLifetime({ inner }: {
+    inner: ToolExecutor;
+}, _options?: Record<string, never>): ToolExecutor;
+//# sourceMappingURL=surface-lifetime.d.ts.map

package/dist/tool-recovery/surface-lifetime.js

@@ -0,0 +1,41 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/** Bind every card type to the executing call, and make restoration re-enter this same stack.
+ * No submitted answer is captured here: input is the original model-supplied invocation only.
+ * @param required.inner The complete authorization, recovery and audit stack.
+ * @returns An executor with the same cancellation and audit ports.
+ * @complexity O(input size) to snapshot public arguments; O(1) lifecycle state per call.
+ */
+export function withSurfaceExchangeLifetime({ inner }, _options = {}) {
+    const execute = async (required, options = {}) => {
+        if (!options.emitSurface)
+            return inner.execute(required, options);
+        const invocation = { ...required, principal: structuredClone(required.principal),
+            run: { ...required.run }, input: structuredClone(required.input) };
+        // Remote execution adapters establish trusted site/run context around this call. A later
+        // authenticated answer arrives in another async chain; restore that context before re-gating.
+        const withinInvocation = AsyncLocalStorage.snapshot();
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        options.signal?.addEventListener('abort', abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+        const emit = Object.assign((emission) => options.emitSurface(emission), { exchangeLifetime: {
+                signal: controller.signal, runId: required.run.id, toolId: required.toolId, principalId: required.principal.id,
+                retry: async ({ emit: replacement, signal }) => {
+                    await withinInvocation(() => execute({ ...invocation, input: structuredClone(invocation.input) }, {
+                        ...options, signal, emitSurface: replacement,
+                    }));
+                },
+            } });
+        try {
+            return await inner.execute(required, { ...options, signal: controller.signal, emitSurface: emit });
+        }
+        finally {
+            options.signal?.removeEventListener('abort', abort);
+            controller.abort();
+        }
+    };
+    return { execute, cancel: inner.cancel.bind(inner), resumeConfirmation: inner.resumeConfirmation.bind(inner),
+        getAuditRecord: inner.getAuditRecord.bind(inner) };
+}
+//# sourceMappingURL=surface-lifetime.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/daemon",
-  "version": "0.6.17",
+  "version": "0.6.19",
   "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": {
@@ -152,23 +152,23 @@
     "@types/pg": "8.23.1",
     "express": "^4.21.0",
     "@types/express": "^4.17.21",
-    "@jini-ai/http-kit": "0.6.17",
-    "@jini-ai/chat": "0.6.17",
-    "@jini-ai/db": "0.6.17",
-    "@jini-ai/core": "^0.6.17",
-    "@jini-ai/agent-runtime": "^0.6.17",
-    "@jini-ai/platform": "^0.6.17",
-    "@jini-ai/protocol": "^0.6.17"
+    "@jini-ai/db": "0.6.19",
+    "@jini-ai/agent-runtime": "^0.6.19",
+    "@jini-ai/chat": "0.6.19",
+    "@jini-ai/core": "^0.6.19",
+    "@jini-ai/platform": "^0.6.19",
+    "@jini-ai/http-kit": "0.6.19",
+    "@jini-ai/protocol": "^0.6.19"
   },
   "dependencies": {
     "smol-toml": "1.9.1",
     "kysely": "^0.29.6",
-    "@jini-ai/core": "^0.6.17",
-    "@jini-ai/db": "^0.6.17",
-    "@jini-ai/platform": "^0.6.17",
-    "@jini-ai/agent-runtime": "^0.6.17",
-    "@jini-ai/protocol": "^0.6.17",
-    "@jini-ai/http-kit": "^0.6.17"
+    "@jini-ai/core": "^0.6.19",
+    "@jini-ai/protocol": "^0.6.19",
+    "@jini-ai/agent-runtime": "^0.6.19",
+    "@jini-ai/db": "^0.6.19",
+    "@jini-ai/platform": "^0.6.19",
+    "@jini-ai/http-kit": "^0.6.19"
   },
   "peerDependencies": {
     "node-pty": "^1.1.0",