@jini-ai/chat 0.6.10 → 0.6.12

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

@@ -17,22 +17,29 @@ function lastIndexWhere({ events, match }, _optional = {}) {
             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 [];
+/** One complete stdout line's contribution to executor diagnostics. */
+function diagnosticLine({ line }, _optional = {}) {
     try {
-        const result = JSON.parse(event.line);
+        const result = JSON.parse(line);
         // Successful CLI summaries contain usage metadata and answer prose, not failure evidence.
         if (result?.type === "result" && result.is_error === false)
             return [];
+        // A subagent report can discuss billing/auth in completed work; it is not executor evidence.
+        if (result?.type === "system" && result.subtype === "task_notification")
+            return [];
     }
     catch {
         // Non-JSON stdout can still contain the executor's failure reason.
     }
-    return [event.line];
+    return [line];
+}
+/** A saved raw event may hold several JSONL lines; filter each before failure classification. */
+function diagnosticLines({ event }, _optional = {}) {
+    if (event.kind === "status")
+        return [event.label, event.detail ?? ""];
+    if (event.kind !== "raw")
+        return [];
+    return event.line.split(/\r?\n/).flatMap(line => diagnosticLine({ 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
@@ -118,8 +125,8 @@ function savedWork({ run }, _optional = {}) {
     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);
+function continuesNow({ run, trigger, now }, _optional = {}) {
+    return 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. */
@@ -193,37 +200,66 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
         if (exclusion(run))
             return { decision: await finalize(run, STOPPED_NOTICE, { canceled: true }) };
         const probe = await probeAttempt({ run, trigger, liveRunId });
+        // HTTP/storage awaits can cross cancellation, settlement, or an attempt-generation change.
+        // Re-read before attaching or applying diagnostics to the probed attempt.
+        const current = await reload(run);
+        if (typeof current === "string")
+            return { probe, decision: current };
         if (probe === "live")
-            return { probe, decision: await reattach(run) };
+            return { probe, decision: await reattach(current) };
+        if (probe === "uncertain") {
+            // Transport uncertainty is not proof of death and spends no restart/time budget. The
+            // existing watcher waits and probes again; even an expired budget cannot kill a live child.
+            await reattach(current);
+            return { probe, decision: "waiting" };
+        }
+        return decideDead(current, trigger);
+    }
+    async function decideDead(run, trigger) {
+        const probe = "dead";
         // A pending human answer takes precedence over executor exit diagnostics.
-        if (probe === "dead" && awaitingAnswer({ run }))
-            return { probe, decision: await resolveMissing(run, probe, trigger) };
+        if (awaitingAnswer({ run }))
+            return { probe, decision: await resolveMissing(run, 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 diagnostics = attemptDiagnostics({ run });
         const failure = attemptFailure({ diagnostics });
-        const decision = failure === "retryable" ? await resolveMissing(run, probe, trigger) : await finalizeFailure({ run, failure, diagnostics });
+        const decision = failure === "retryable" ? await resolveMissing(run, trigger) : await finalizeFailure({ run, failure, diagnostics });
         return { probe, failure, decision };
     }
-    async function resolveMissing(run, probe, trigger) {
+    async function resolveMissing(run, trigger) {
         await ports.store.recoveryClock({ runId: run.runId, now: ports.now(), active: true }, {});
-        const timed = await ports.store.load({ messageId: run.messageId }, {}) ?? run;
+        const timed = await reload(run);
+        return typeof timed === "string" ? timed : resolveDead(timed, trigger);
+    }
+    /** The saved row after an await, or the outcome that ends this decision. O(1) store reads. */
+    async function reload(run) {
+        const current = await ports.store.load({ messageId: run.messageId }, {});
+        if (!current)
+            return "gone";
         // A probe only speaks about the generation it inspected. Never apply its dead result to
         // a newer attempt committed by another caller while this one was awaiting storage/HTTP.
-        if (timed.runId !== run.runId)
+        if (current.runId !== run.runId)
             return "superseded";
+        if (current.message.runStatus !== "queued" && current.message.runStatus !== "running")
+            return "terminal";
+        if (exclusion(current))
+            return finalize(current, STOPPED_NOTICE, { canceled: true });
+        return current;
+    }
+    async function resolveDead(run, trigger) {
         // 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 (awaitingAnswer({ run }))
+            return finalize(run, AWAITING_ANSWER_NOTICE);
+        const notice = budgetNotice(run, ports.now());
         if (notice)
-            return finalize(run, notice, { detail: notice === EXHAUSTED_NOTICE ? exhaustedDetail({ run: timed }) : undefined });
+            return finalize(run, notice, { detail: notice === EXHAUSTED_NOTICE ? exhaustedDetail({ run }) : 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 (continuesNow({ run, probe, trigger, now: ports.now() }))
-            return continueDead(timed);
+        if (continuesNow({ run, trigger, now: ports.now() }))
+            return continueDead(run);
         ports.attach(run, {});
         return "waiting";
     }

package/dist/store/sql/store.d.ts

@@ -28,8 +28,8 @@ export declare function toMessage(row: MessageRow): ChatMessage;
  * @param scope the isolation predicate, resolved from the host's authentication. For a guest,
  *   `ownerId` must already be a hash of the session key (`tenant-scope.ts`).
  * @param optional Optional core Clock for deterministic host/tests; defaults to system wall time.
- * @complexity each method is one to four indexed statements; `list` is O(owned conversations),
- *   `messages` O(messages in the conversation).
+ * @complexity each method is one to four indexed statements; conversation summaries scan their
+ *   messages and embedded events in SQL; `messages` is O(messages in the conversation).
  */
 export declare function createSqlChatStore<DB extends ChatDatabase>({ kernel, scope: inputScope }: {
     kernel: StorageKernel<DB>;

package/dist/store/sql/store.js

@@ -13,6 +13,7 @@ import { sql } from 'kysely';
 import { createSystemClock } from '@jini-ai/core/primitives';
 import { isUniqueViolation } from '@jini-ai/db/kernel';
 import { redactUserMessage } from '../../core/user-text-redaction.js';
+import { MID_RUN_USER_MESSAGE_EVENT_NAME } from '../../core/turn-usage.js';
 import { ChatStoreError } from '../errors.js';
 import { copyScope, atStoreBoundary, runChatQuery } from './boundary.js';
 import { pageLimit, decodeCursor, encodeCursor } from './cursor.js';
@@ -113,8 +114,8 @@ function toHistoryMessage(row, { includeToolEvents }) {
  * @param scope the isolation predicate, resolved from the host's authentication. For a guest,
  *   `ownerId` must already be a hash of the session key (`tenant-scope.ts`).
  * @param optional Optional core Clock for deterministic host/tests; defaults to system wall time.
- * @complexity each method is one to four indexed statements; `list` is O(owned conversations),
- *   `messages` O(messages in the conversation).
+ * @complexity each method is one to four indexed statements; conversation summaries scan their
+ *   messages and embedded events in SQL; `messages` is O(messages in the conversation).
  */
 export function createSqlChatStore({ kernel, scope: inputScope }, { clock = createSystemClock(), ...redactionOptions } = {}) {
     const scope = copyScope({ scope: inputScope });
@@ -122,6 +123,13 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
     // The single subset boundary: DB must contain both required table definitions. Extra host tables
     // stay on the exact borrowed kernel; its transaction context is never projected or recreated.
     const run = (body) => runChatQuery({ kernel: kernel, body: body });
+    // Count embedded user messages in SQL: list/get still return summaries, never whole transcripts.
+    // Writers store `JSON.stringify` output (no whitespace, as appendedEventsJson also relies on), so
+    // each mid-run event holds this exact text once; text inside a JSON string has escaped quotes and
+    // cannot match, and invalid JSON stays readable (it counts what it holds, never throws). Plain
+    // length/replace run on SQLite and PostgreSQL 14+, unlike `IS JSON` (PostgreSQL 16+).
+    const needle = `"name":"${MID_RUN_USER_MESSAGE_EVENT_NAME}"`;
+    const midRunCount = sql `((length(coalesce(m.events_json, '')) - length(replace(coalesce(m.events_json, ''), ${sql.lit(needle)}, ''))) / ${sql.lit(needle.length)})`;
     /** This scope's conversations, projected as {@link ConversationRow}s with their message count. */
     function ownedConversations(db) {
         return db
@@ -135,7 +143,7 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
             "c.expires_at",
             eb
                 .selectFrom("ai_chat_messages as m")
-                .select((sb) => sb.fn.countAll().as("n"))
+                .select(sql `coalesce(sum(1 + case when m.role = 'assistant' then ${midRunCount} else 0 end), 0)`.as("n"))
                 .whereRef("m.conversation_id", "=", "c.id")
                 .as("message_count"),
         ])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "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": {
@@ -196,7 +196,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.6.10"
+    "@jini-ai/core": "^0.6.12"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",
@@ -303,13 +303,13 @@
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
     "fast-check": "4.3.0",
-    "@jini-ai/agentic": "^0.6.10",
-    "@jini-ai/db": "0.6.10",
-    "@jini-ai/agent-runtime": "0.6.10",
-    "@jini-ai/ui": "^0.6.10",
-    "@jini-ai/core": "^0.6.10",
-    "@jini-ai/diagnostics": "^0.6.10",
-    "@jini-ai/protocol": "^0.6.10"
+    "@jini-ai/db": "0.6.12",
+    "@jini-ai/agentic": "^0.6.12",
+    "@jini-ai/agent-runtime": "0.6.12",
+    "@jini-ai/diagnostics": "^0.6.12",
+    "@jini-ai/ui": "^0.6.12",
+    "@jini-ai/core": "^0.6.12",
+    "@jini-ai/protocol": "^0.6.12"
   },
   "typesVersions": {
     "*": {