@jini-ai/chat 0.6.6 → 0.6.10

package/dist/server/durable-runs/recover.js

@@ -7,6 +7,33 @@ export { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE
 // translateRunFrame saves a run error frame as a status label holding only its message: the
 // daemon's MCP_BRIDGE_UNAVAILABLE code is dropped, so the bridge failure is matched by its text.
 const MCP_BRIDGE_FAILURE = /The assistant's tools did not load \(MCP bridge "jini" status: [^\r\n]*/;
+const STOPPED_NOTICE = "Stopped. Saved work is above.";
+/** Index of the last event matching `match`, or -1.
+ * @complexity O(e) time, O(1) space, no effects. */
+function lastIndexWhere({ events, match }, _optional = {}) {
+    // Reverse scan preserves the last-marker rule on the desktop's ES2022 target.
+    for (let index = events.length - 1; index >= 0; index--)
+        if (match(events[index]))
+            return index;
+    return -1;
+}
+/** One saved event's contribution to the executor diagnostics. */
+function diagnosticLines({ event }, _optional = {}) {
+    if (event.kind === "status")
+        return [event.label, event.detail ?? ""];
+    if (event.kind !== "raw")
+        return [];
+    try {
+        const result = JSON.parse(event.line);
+        // Successful CLI summaries contain usage metadata and answer prose, not failure evidence.
+        if (result?.type === "result" && result.is_error === false)
+            return [];
+    }
+    catch {
+        // Non-JSON stdout can still contain the executor's failure reason.
+    }
+    return [event.line];
+}
 /** Retryability is independent of session resumability. Inspect executor diagnostics, never
  * answer text or tool results: those can quote unrelated failures from completed work. Old
  * attempt diagnostics remain visible but cannot decide the fate of their continuation. */
@@ -14,55 +41,36 @@ function attemptDiagnostics({ run }, _optional = {}) {
     const events = run.message.events ?? [];
     // Checkpoints merge adjacent text, so a base's event count is not a durable offset. The
     // coordinator's recovery marker separates attempts and survives that compaction.
-    let marker = -1;
-    // Reverse scan preserves the last-marker rule on the desktop's ES2022 target.
-    for (let index = run.attemptBase.length ? events.length - 1 : -1; index >= 0; index--) {
-        const event = events[index];
-        if (event.kind === "status" && event.code === "run_recovering") {
-            marker = index;
-            break;
-        }
-    }
-    return events.slice(marker >= 0 ? marker + 1 : run.attemptBase.length).flatMap((event) => {
-        if (event.kind === "status")
-            return [event.label, event.detail ?? ""];
-        if (event.kind !== "raw")
-            return [];
-        try {
-            const result = JSON.parse(event.line);
-            // Successful CLI summaries contain usage metadata and answer prose, not failure evidence.
-            if (result?.type === "result" && result.is_error === false)
-                return [];
-        }
-        catch {
-            // Non-JSON stdout can still contain the executor's failure reason.
-        }
-        return [event.line];
-    }).join("\n");
+    const marker = run.attemptBase.length
+        ? lastIndexWhere({ events, match: (event) => event.kind === "status" && event.code === "run_recovering" })
+        : -1;
+    return events.slice(marker >= 0 ? marker + 1 : run.attemptBase.length).flatMap((event) => diagnosticLines({ event })).join("\n");
 }
-function attemptFailure(run) {
-    const diagnostics = attemptDiagnostics({ run }, {});
+/** Quota/billing and bad requests need human repair. A 429 for rate throttling and a 5xx
+ * overload remain retryable; the provider's coarse RATE_LIMITED class also includes billing. */
+function needsHumanRepair({ diagnostics }, _optional = {}) {
+    const requestStatuses = diagnostics.matchAll(/\b(?:http(?:[ /]?\d(?:\.\d)?)?|(?:status|error|response)(?:[ _-]?code)?|code(?=\s*[:=#]))[\s:=#-]*(4\d\d)\b/gi);
+    if ([...requestStatuses].some((match) => match[1] !== "408" && match[1] !== "429"))
+        return true;
+    return /another answer in this chat is still running|invalid[_ -]?request|context[_ -](length|window)|maximum context|model.*(?:not[_ -]found|does not exist|not supported)|unsupported|does not support|permission denied|forbidden|insufficient[_ -]?(quota|balance|credit|funds)|credit balance is too low|exceeded your current quota|quota[_ -]?exceeded|usage limit|billing|payment required/i.test(diagnostics);
+}
+function attemptFailure({ diagnostics }, _optional = {}) {
     // MCP_BRIDGE_UNAVAILABLE needs bridge repair; another attempt repeats the same failure.
     // Classify it before interpreting the bridge's stderr as an agent auth/watchdog failure.
     if (MCP_BRIDGE_FAILURE.test(diagnostics))
         return "permanent";
     if (/inactivity[_ -]?(timeout|watchdog)|watchdog.*(kill|stop)/i.test(diagnostics))
         return "inactivity-watchdog";
-    const service = classifyAgentServiceFailure({ text: diagnostics });
-    if (service === "AGENT_AUTH_REQUIRED")
+    if (classifyAgentServiceFailure({ text: diagnostics }) === "AGENT_AUTH_REQUIRED")
         return "auth-failure";
-    // Quota/billing and bad requests need human repair. A 429 for rate throttling and a 5xx
-    // overload remain retryable; the provider's coarse RATE_LIMITED class also includes billing.
-    const requestStatuses = diagnostics.matchAll(/\b(?:http(?:[ /]?\d(?:\.\d)?)?|(?:status|error|response)(?:[ _-]?code)?|code(?=\s*[:=#]))[\s:=#-]*(4\d\d)\b/gi);
-    if ([...requestStatuses].some((match) => match[1] !== "408" && match[1] !== "429"))
-        return "permanent";
-    if (/another answer in this chat is still running|invalid[_ -]?request|context[_ -](length|window)|maximum context|model.*(?:not[_ -]found|does not exist|not supported)|unsupported|does not support|permission denied|forbidden|insufficient[_ -]?(quota|balance|credit|funds)|credit balance is too low|exceeded your current quota|quota[_ -]?exceeded|usage limit|billing|payment required/i.test(diagnostics))
-        return "permanent";
-    return "retryable";
+    return needsHumanRepair({ diagnostics }) ? "permanent" : "retryable";
 }
 /** Keep the notice bounded and scoped to the same executor diagnostics as failure classification. */
+function lastDiagnosticLine({ diagnostics }, _optional = {}) {
+    return diagnostics.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).at(-1)?.slice(0, 300);
+}
 function attemptFailureDetail({ run }, _optional = {}) {
-    return attemptDiagnostics({ run }, {}).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).at(-1)?.slice(0, 300);
+    return lastDiagnosticLine({ diagnostics: attemptDiagnostics({ run }) });
 }
 function exclusion(run) {
     if (run.cancelReason)
@@ -71,15 +79,48 @@ function exclusion(run) {
         return "excluded";
     return null;
 }
+/** Preflight cards precede model tools, so the normal open-tool activity scan cannot see them.
+ * Chat saves the bare resource without its wire toolUseId. Saved consent or subsequent model
+ * execution closes this preflight wait, including cards saved before this fix.
+ * A model tool closes the wait and no later card can reopen it, so the wait is pending exactly
+ * when no tool ran and the last card follows the last consent for this conversation.
+ * @complexity O(e) time, O(1) space, no effects.
+ */
+function awaitingAnswer({ run }, _options = {}) {
+    if (isAwaitingAnswer({ events: run.message.events }))
+        return true;
+    const events = run.message.events ?? [];
+    if (events.some((event) => event.kind === "tool_use"))
+        return false;
+    const card = lastIndexWhere({ events, match: (event) => event.kind === "ext" && event.name === "mcp-ui" });
+    const consent = lastIndexWhere({ events, match: (event) => event.kind === "ext" && event.name === "agent_plugins"
+            && event.data?.conversationId === run.conversationId });
+    return card > consent;
+}
 function budgetNotice(run, now) {
     if (now - run.lastProgressAt >= RUN_STALENESS_MS)
-        return isAwaitingAnswer({ events: run.message.events }) ? AWAITING_ANSWER_NOTICE : SAVED_WORK_NOTICE;
+        return awaitingAnswer({ run }) ? AWAITING_ANSWER_NOTICE : SAVED_WORK_NOTICE;
     if (run.recoveryCount >= RECOVERY_LIMIT)
         return EXHAUSTED_NOTICE;
     if (run.recoveryDeadline !== null && now >= run.recoveryDeadline)
         return EXHAUSTED_NOTICE;
     return null;
 }
+/** The exhausted notice's detail: the attempt's last diagnostic, else which budget ended. */
+function exhaustedDetail({ run }, _optional = {}) {
+    return attemptFailureDetail({ run }) ?? (run.recoveryCount >= RECOVERY_LIMIT ? `Tried ${RECOVERY_LIMIT} times` : "Recovery window ended");
+}
+/** Saved work to carry into the next attempt, seeding the saved content when no text event holds it. */
+function savedWork({ run }, _optional = {}) {
+    const saved = [...(run.message.events ?? [])];
+    if (!saved.some((event) => event.kind === "text") && run.message.content)
+        saved.unshift({ kind: "text", text: run.message.content });
+    return saved;
+}
+/** A dead attempt continues now; a fresh queued one waits (see the caller's comment). */
+function continuesNow({ run, probe, trigger, now }, _optional = {}) {
+    return probe === "dead" && (trigger === "attempt-failed" || now - run.attemptStartedAt >= 10_000);
+}
 /** Recovery coordinator behind explicit host ports. One CAS owns both the attempt and its conversation slot.
  * Each recovery decision logs one `logger.info` line (default console) of run metadata. */
 export function createDurableRecovery(ports, { logger = console } = {}) {
@@ -98,6 +139,16 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
             return false;
         return ports.verifyChildDead(run.child, {}).catch(() => false);
     }
+    async function launchNext({ run, next, native }, _optional = {}) {
+        try {
+            await ports.launch({ run: next, request: continuationRequest({ run: { ...run, message: next.message, transcript: next.transcript }, native }, {}) }, {});
+            await ports.store.recoveryClock({ runId: next.runId, now: ports.now(), active: false }, {});
+        }
+        catch {
+            // A rejected/lost start response is uncertain: the daemon may already be executing. The
+            // same idempotent attempt is probed by the attached watcher before another CAS is possible.
+        }
+    }
     async function continueDead(run) {
         await ports.cancelAttempt(run, {}).catch(() => undefined);
         // A locator captured before a hard cancel can outlive its rollout. Reuse reconstruction,
@@ -105,10 +156,7 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
         const missingResume = run.request.agentId === 'codex' && /no rollout found for thread id/.test(attemptDiagnostics({ run }, {}));
         const native = !missingResume && await nativeAllowed(run);
         const nextRunId = ports.mintRunId();
-        const saved = [...(run.message.events ?? [])];
-        if (!saved.some((event) => event.kind === "text") && run.message.content)
-            saved.unshift({ kind: "text", text: run.message.content });
-        const events = recoveredRunEvents({ saved }, { notice: missingResume ? 'silent' : 'visible' });
+        const events = recoveredRunEvents({ saved: savedWork({ run }) }, { notice: missingResume ? 'silent' : 'visible' });
         if (!await ports.store.advance({ run, nextRunId, now: ports.now(), events }, {}))
             return "superseded";
         const next = await ports.store.load({ messageId: run.messageId }, {});
@@ -117,41 +165,46 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
         if (!next || next.runId !== nextRunId)
             return "superseded";
         if (next.cancelReason)
-            return finalize(next, "Stopped. Saved work is above.", { canceled: true });
-        try {
-            await ports.launch({ run: next, request: continuationRequest({ run: { ...run, message: next.message, transcript: next.transcript }, native }, {}) }, {});
-            await ports.store.recoveryClock({ runId: next.runId, now: ports.now(), active: false }, {});
-        }
-        catch {
-            // A rejected/lost start response is uncertain: the daemon may already be executing. The
-            // same idempotent attempt is probed by the attached watcher before another CAS is possible.
-        }
+            return finalize(next, STOPPED_NOTICE, { canceled: true });
+        await launchNext({ run, next, native });
         ports.attach(next, {});
         return "continued";
     }
-    async function decide(run, trigger, liveRunId, seen) {
-        if (exclusion(run))
-            return finalize(run, "Stopped. Saved work is above.", { canceled: true });
+    async function probeAttempt({ run, trigger, liveRunId }, _optional = {}) {
         // A terminal executor end confirms this attempt is dead even when the daemon retains its
         // replayable record (HTTP 200). Other triggers must obtain fresh liveness evidence.
-        const probe = seen.probe = trigger === "attempt-failed" ? "dead" : liveRunId === run.runId ? "live" : await ports.probe(run, {});
-        if (probe === "live") {
-            await ports.store.recoveryClock({ runId: run.runId, now: ports.now(), active: false }, {});
-            ports.attach(run, {});
-            return "reattached";
-        }
+        if (trigger === "attempt-failed")
+            return "dead";
+        return liveRunId === run.runId ? "live" : ports.probe(run, {});
+    }
+    async function reattach(run) {
+        await ports.store.recoveryClock({ runId: run.runId, now: ports.now(), active: false }, {});
+        ports.attach(run, {});
+        return "reattached";
+    }
+    async function finalizeFailure({ run, failure, diagnostics }, _optional = {}) {
+        if (failure !== "permanent")
+            return finalize(run, failure === "auth-failure" ? "Not logged in. Saved work is above." : STOPPED_NOTICE, { canceled: true });
+        // A bridge failure shows its own reason (and stderr): the generic notice hides what needs repair.
+        const bridgeNotice = diagnostics.match(MCP_BRIDGE_FAILURE)?.[0];
+        return finalize(run, bridgeNotice ?? EXHAUSTED_NOTICE, { detail: bridgeNotice ? undefined : lastDiagnosticLine({ diagnostics }) });
+    }
+    async function decide(run, trigger, liveRunId) {
+        if (exclusion(run))
+            return { decision: await finalize(run, STOPPED_NOTICE, { canceled: true }) };
+        const probe = await probeAttempt({ run, trigger, liveRunId });
+        if (probe === "live")
+            return { probe, decision: await reattach(run) };
+        // A pending human answer takes precedence over executor exit diagnostics.
+        if (probe === "dead" && awaitingAnswer({ run }))
+            return { probe, decision: await resolveMissing(run, probe, trigger) };
         // Diagnostics decide only the fate of an attempt that is no longer running. Read before the
         // probe, raw stdout quoting a tool description ("OAuth-authenticated") canceled a live turn
         // as "Not logged in" (luvira, 2026-10-08).
-        const failure = seen.failure = attemptFailure(run);
-        if (failure === "auth-failure" || failure === "inactivity-watchdog")
-            return finalize(run, failure === "auth-failure" ? "Not logged in. Saved work is above." : "Stopped. Saved work is above.", { canceled: true });
-        // A bridge failure shows its own reason (and stderr): the generic notice hides what needs repair.
-        if (failure === "permanent") {
-            const bridgeNotice = attemptDiagnostics({ run }, {}).match(MCP_BRIDGE_FAILURE)?.[0];
-            return finalize(run, bridgeNotice ?? EXHAUSTED_NOTICE, { detail: bridgeNotice ? undefined : attemptFailureDetail({ run }, {}) });
-        }
-        return resolveMissing(run, probe, trigger);
+        const diagnostics = attemptDiagnostics({ run });
+        const failure = attemptFailure({ diagnostics });
+        const decision = failure === "retryable" ? await resolveMissing(run, probe, trigger) : await finalizeFailure({ run, failure, diagnostics });
+        return { probe, failure, decision };
     }
     async function resolveMissing(run, probe, trigger) {
         await ports.store.recoveryClock({ runId: run.runId, now: ports.now(), active: true }, {});
@@ -160,16 +213,16 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
         // a newer attempt committed by another caller while this one was awaiting storage/HTTP.
         if (timed.runId !== run.runId)
             return "superseded";
+        // A dead process cannot resume its question. End this turn with the existing card intact,
+        // rather than minting an attempt that runs preflight and asks the same question again.
+        if (probe === "dead" && awaitingAnswer({ run: timed }))
+            return finalize(timed, AWAITING_ANSWER_NOTICE);
         const notice = budgetNotice(timed, ports.now());
-        if (notice) {
-            const detail = notice === EXHAUSTED_NOTICE
-                ? attemptFailureDetail({ run: timed }, {}) ?? (timed.recoveryCount >= RECOVERY_LIMIT ? `Tried ${RECOVERY_LIMIT} times` : "Recovery window ended")
-                : undefined;
-            return finalize(run, notice, { detail });
-        }
+        if (notice)
+            return finalize(run, notice, { detail: notice === EXHAUSTED_NOTICE ? exhaustedDetail({ run: timed }) : undefined });
         // A queued attempt may be between durable acceptance and the daemon's start transaction.
         // Give that idempotent launch time to appear before a 404 can advance its generation.
-        if (probe === "dead" && (trigger === "attempt-failed" || ports.now() - run.attemptStartedAt >= 10_000))
+        if (continuesNow({ run, probe, trigger, now: ports.now() }))
             return continueDead(timed);
         ports.attach(run, {});
         return "waiting";
@@ -183,12 +236,11 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
                 return "terminal";
             if (expectedRunId && expectedRunId !== run.runId)
                 return "superseded";
-            const seen = {};
-            const decision = await decide(run, trigger, options.liveRunId, seen);
+            const { decision, probe, failure } = await decide(run, trigger, options.liveRunId);
             // The watcher re-confirms its own live run every resolution window; log only real recovery
             // decisions. Metadata only: diagnostics, answers and cancel reasons can hold secrets.
             if (options.liveRunId !== run.runId)
-                logger.info("[durable-recovery] " + JSON.stringify({ runId: run.runId, trigger, probe: seen.probe, decision, failureClass: seen.failure }));
+                logger.info("[durable-recovery] " + JSON.stringify({ runId: run.runId, trigger, probe, decision, failureClass: failure }));
             return decision;
         },
     };

package/dist/server/run-finalizer/entry.js

@@ -1,5 +1,9 @@
 import { isTerminalRunStatus } from '../../core/messages.js';
 import { readSseFrames, runContentFromEvents, runEventsForSave, runInterruptedNotice, translateRunFrame } from '../../core/run-events/entry.js';
+/** An error frame keeps a later successful end from settling as a success. */
+function endStatus({ failed, terminal }, _optional = {}) {
+    return failed && terminal === "succeeded" ? "failed" : terminal;
+}
 /** Follow replayable run streams and save through atomic host ledger operations.
  * The host retains authorization, owner scope, kernel transactions, boot reconciliation, HTTP
  * credentials and excluded run-ID prefixes. Replay starts at zero; error-before-success and
@@ -22,11 +26,14 @@ export function createAssistantRunFinalizer(args, options = {}) {
         catch { /* The host owns reporting failures. */ }
     }
     const active = new Map();
-    async function settle(watch, status, events) {
-        watch.terminal = true;
+    function clearTrailing(watch) {
         if (watch.trailing)
             scheduler.cancel({ handle: watch.trailing.handle });
         watch.trailing = undefined;
+    }
+    async function settle(watch, status, events) {
+        watch.terminal = true;
+        clearTrailing(watch);
         await args.ledger.settle({
             conversationId: watch.conversationId,
             messageId: watch.messageId,
@@ -57,9 +64,7 @@ export function createAssistantRunFinalizer(args, options = {}) {
             }
             return;
         }
-        if (watch.trailing)
-            scheduler.cancel({ handle: watch.trailing.handle });
-        watch.trailing = undefined;
+        clearTrailing(watch);
         watch.checkpointedEvents = watch.events.length;
         watch.checkpointedAt = now();
         watch.checkpointPending = true;
@@ -77,29 +82,36 @@ export function createAssistantRunFinalizer(args, options = {}) {
             void checkpoint(watch);
         });
     }
-    async function readStream(watch) {
+    /** The connection's event body, or why it cannot be followed. Non-success bodies are cancelled. */
+    async function openStream(watch) {
         const response = await daemon.openEvents({ runId: watch.runId, principalId: watch.principalId });
-        if (response.status === 404 || !response.ok || !response.body) {
-            await response.body?.cancel().catch(() => undefined);
-            return response.status === 404 ? { kind: "gone" } : { kind: "dropped" };
-        }
+        if (response.ok && response.body)
+            return { kind: "open", body: response.body };
+        await response.body?.cancel().catch(() => undefined);
+        return response.status === 404 ? { kind: "gone" } : { kind: "dropped" };
+    }
+    async function consumeFrames(watch, body) {
         // Each connection replays the complete history, rather than appending duplicate deltas.
         watch.events = [];
         watch.failed = false;
         const carry = {};
-        for await (const frame of readSseFrames({ body: response.body })) {
+        for await (const frame of readSseFrames({ body })) {
             const outcome = translateRunFrame({ kind: frame.event, raw: frame.data, notices: args.notices }, { carry });
             watch.events.push(...outcome.events);
             if (outcome.error)
                 watch.failed = true;
             if (outcome.terminal) {
                 watch.terminal = true;
-                return { kind: "ended", status: watch.failed && outcome.terminal === "succeeded" ? "failed" : outcome.terminal };
+                return { kind: "ended", status: endStatus({ failed: watch.failed, terminal: outcome.terminal }) };
             }
             void checkpoint(watch);
         }
         return { kind: "dropped" };
     }
+    async function readStream(watch) {
+        const opened = await openStream(watch);
+        return opened.kind === "open" ? consumeFrames(watch, opened.body) : opened;
+    }
     async function follow(watch) {
         for (let attempt = 0; attempt <= maxReconnects; attempt += 1) {
             const result = await readStream(watch).catch(() => ({ kind: "dropped" }));
@@ -140,9 +152,7 @@ export function createAssistantRunFinalizer(args, options = {}) {
             })
                 .finally(() => {
                 watch.terminal = true;
-                if (watch.trailing)
-                    scheduler.cancel({ handle: watch.trailing.handle });
-                watch.trailing = undefined;
+                clearTrailing(watch);
                 active.delete(runId);
             });
             active.set(runId, { watch, done });

package/dist/store/legacy/sqlite/conversations.d.ts

@@ -18,8 +18,8 @@ export declare function listConversations({ db, projectId }: {
 }): {
     latestRun: {
         durationMs?: number;
-        endedAt?: number | undefined;
-        startedAt?: number | undefined;
+        endedAt?: number;
+        startedAt?: number;
         status: string;
     } | undefined;
     totalDurationMs?: number;
@@ -41,13 +41,13 @@ export declare function getConversation({ db, id }: {
     db: SqliteDb;
     id: string;
 }): {
-    totalDurationMs?: number;
     latestRun: {
         durationMs?: number;
-        endedAt?: number | undefined;
-        startedAt?: number | undefined;
+        endedAt?: number;
+        startedAt?: number;
         status: string;
     } | undefined;
+    totalDurationMs?: number;
     id: any;
     projectId: any;
     title: any;
@@ -75,13 +75,13 @@ export declare function insertConversation({ db, c }: {
     db: SqliteDb;
     c: DbRow;
 }): {
-    totalDurationMs?: number;
     latestRun: {
         durationMs?: number;
-        endedAt?: number | undefined;
-        startedAt?: number | undefined;
+        endedAt?: number;
+        startedAt?: number;
         status: string;
     } | undefined;
+    totalDurationMs?: number;
     id: any;
     projectId: any;
     title: any;
@@ -102,13 +102,13 @@ export declare function updateConversation({ db, id, patch }: {
     id: string;
     patch: DbRow;
 }): {
-    totalDurationMs?: number;
     latestRun: {
         durationMs?: number;
-        endedAt?: number | undefined;
-        startedAt?: number | undefined;
+        endedAt?: number;
+        startedAt?: number;
         status: string;
     } | undefined;
+    totalDurationMs?: number;
     id: any;
     projectId: any;
     title: any;