@jini-ai/chat 0.5.6 → 0.5.7

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

@@ -6,7 +6,7 @@ export { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE
 /** 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. */
-function attemptFailure(run) {
+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.
@@ -19,7 +19,10 @@ function attemptFailure(run) {
             break;
         }
     }
-    const diagnostics = events.slice(marker >= 0 ? marker + 1 : run.attemptBase.length).flatMap((event) => event.kind === "status" ? [event.label, event.detail ?? ""] : event.kind === "raw" ? [event.line] : []).join("\n");
+    return events.slice(marker >= 0 ? marker + 1 : run.attemptBase.length).flatMap((event) => event.kind === "status" ? [event.label, event.detail ?? ""] : event.kind === "raw" ? [event.line] : []).join("\n");
+}
+function attemptFailure(run) {
+    const diagnostics = attemptDiagnostics({ run }, {});
     if (/inactivity[_ -]?(timeout|watchdog)|watchdog.*(kill|stop)/i.test(diagnostics))
         return "inactivity-watchdog";
     const service = classifyAgentServiceFailure({ text: diagnostics });
@@ -34,13 +37,11 @@ function attemptFailure(run) {
         return "permanent";
     return "retryable";
 }
-function exclusion(run, failure) {
+function exclusion(run) {
     if (run.cancelReason)
         return run.cancelReason;
     if (!run.principalId || run.engine !== "daemon")
         return "excluded";
-    if (failure === "auth-failure" || failure === "inactivity-watchdog")
-        return failure;
     return null;
 }
 function budgetNotice(run, now) {
@@ -71,12 +72,15 @@ export function createDurableRecovery(ports, _optional = {}) {
     }
     async function continueDead(run) {
         await ports.cancelAttempt(run, {}).catch(() => undefined);
-        const native = await nativeAllowed(run);
+        // A locator captured before a hard cancel can outlive its rollout. Reuse reconstruction,
+        // including prior turns/tool outcomes, instead of retrying a known missing native session.
+        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 }, {});
+        const events = recoveredRunEvents({ saved }, { 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 }, {});
@@ -98,10 +102,8 @@ export function createDurableRecovery(ports, _optional = {}) {
         return "continued";
     }
     async function decide(run, trigger, liveRunId) {
-        const failure = attemptFailure(run);
-        const reason = exclusion(run, failure);
-        if (reason)
-            return finalize(run, reason === "auth-failure" ? "Not logged in. Saved work is above." : "Stopped. Saved work is above.", true);
+        if (exclusion(run))
+            return finalize(run, "Stopped. Saved work is above.", true);
         // 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 = trigger === "attempt-failed" ? "dead" : liveRunId === run.runId ? "live" : await ports.probe(run, {});
@@ -110,6 +112,12 @@ export function createDurableRecovery(ports, _optional = {}) {
             ports.attach(run, {});
             return "reattached";
         }
+        // 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 = 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.", true);
         if (failure === "permanent")
             return finalize(run, EXHAUSTED_NOTICE);
         return resolveMissing(run, probe, trigger);

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

@@ -86,8 +86,9 @@ export function createAssistantRunFinalizer(args, options = {}) {
         // 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 })) {
-            const outcome = translateRunFrame({ kind: frame.event, raw: frame.data, notices: args.notices });
+            const outcome = translateRunFrame({ kind: frame.event, raw: frame.data, notices: args.notices }, { carry });
             watch.events.push(...outcome.events);
             if (outcome.error)
                 watch.failed = true;

package/dist/store/runtime/durable-run-store.js

@@ -88,8 +88,11 @@ function continuationEvents({ current, incoming }, _optional = {}) {
             break;
         }
     }
-    if (marker >= 0)
-        return [...recoveredRunEvents({ saved }, {}), ...incoming.slice(marker + 1)];
+    if (marker >= 0) {
+        const event = incoming[marker];
+        const notice = event.kind === 'status' && event.label === '' ? 'silent' : 'visible';
+        return [...recoveredRunEvents({ saved }, { notice }), ...incoming.slice(marker + 1)];
+    }
     return runContentFromEvents({ events: incoming }).length >= current.message.content.length ? incoming : saved;
 }
 /** Same kernel and message lock as checkpoint/settle. Claim changes run_id before any spawn;

package/dist/store/runtime/run-ledger.js

@@ -126,15 +126,18 @@ export function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, _opti
         async checkpoint(progress, _optional = {}) {
             return kernel.transaction(async () => {
                 await kernel.lockKey(runLockKey(progress));
-                const current = await kernel.run((db) => db.selectFrom("ai_chat_messages").select(["content", "events_json"])
+                const current = await kernel.run((db) => db.selectFrom("ai_chat_messages").select(["content", "events_json", "run_status"])
                     .where((eb) => eb.and([isRunRow(eb, progress), notTerminal(eb)])).executeTakeFirst());
                 if (!current || progress.content.length < current.content.length)
                     return false;
                 const events = keepToolCheckpoints(readEvents(current.events_json), progress.events);
                 const grown = progress.content.length > current.content.length || hasNewToolProgress(readEvents(current.events_json), events);
+                // A checkpoint is the run producing output, so an accepted (`queued`) row is now `running`;
+                // nothing else moves it there, and a streaming answer must not read as still waiting.
+                const runStatus = current.run_status === "queued" ? "running" : current.run_status;
                 const result = await kernel.run((db) => db
                     .updateTable("ai_chat_messages")
-                    .set({ content: progress.content, events_json: JSON.stringify(events) })
+                    .set({ content: progress.content, events_json: JSON.stringify(events), run_status: runStatus })
                     .where((eb) => eb.and([isRunRow(eb, progress), notTerminal(eb)]))
                     .executeTakeFirst());
                 if (Number(result.numUpdatedRows) > 0 && grown) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "Jini's chat/artifact frontend, consolidated into one package with two subpaths: framework-free chat vocabulary and pure parsers in `/core`, headless hooks + presentational components + slots in `/react`. Import only the layer you need.",
   "license": "Apache-2.0",
   "repository": {
@@ -194,10 +194,10 @@
     "@radix-ui/react-select": "^2.3.7",
     "@radix-ui/react-slot": "^1.3.3",
     "recharts": "^3.10.1",
-    "@jini-ai/agent-runtime": "^0.4.1",
+    "@jini-ai/agent-runtime": "^0.4.4",
     "@jini-ai/agentic": "^0.4.2",
-    "@jini-ai/protocol": "^0.4.1",
-    "@jini-ai/ui": "^0.4.5",
+    "@jini-ai/protocol": "^0.4.3",
+    "@jini-ai/ui": "^0.4.7",
     "@jini-ai/diagnostics": "^0.5.0"
   },
   "peerDependenciesMeta": {
@@ -286,12 +286,12 @@
     "@electric-sql/pglite": "0.5.8",
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
-    "@jini-ai/protocol": "^0.4.2",
-    "@jini-ai/agent-runtime": "0.4.3",
-    "@jini-ai/ui": "^0.4.6",
+    "@jini-ai/ui": "^0.4.7",
     "@jini-ai/db": "0.3.1",
-    "@jini-ai/agentic": "^0.4.3",
+    "@jini-ai/protocol": "^0.4.3",
     "@jini-ai/diagnostics": "^0.5.1",
+    "@jini-ai/agentic": "^0.4.3",
+    "@jini-ai/agent-runtime": "0.4.4",
     "@jini-ai/core": "^0.4.2"
   },
   "typesVersions": {