@jini-ai/chat 0.6.7 → 0.6.11

package/dist/react/tool-call-display.d.ts

@@ -6,8 +6,8 @@
  * - `'show'`      — every tool card, where it happened. The layout every host had before this.
  * - `'collapsed'` — each turn's tool cards fold into ONE line ("Used 3 tools") that expands on
  *   click; while a tool runs the line names it instead ("Running Bash…").
- * - `'hidden'`    — no tool cards at all, EXCEPT a failed one: an error must never vanish from the
- *   transcript just because the reader asked for a quieter view.
+ * - `'hidden'`    — recovered failures disappear with successful calls. Unrecovered failures stay
+ *   behind one compact disclosure per reply: work that stopped must never vanish silently.
  *
  * Pure rules over `interleaveMessageBlocks`' output (or the flat row list when that refused), kept
  * out of `MessageRow.tsx` so every mode is testable without rendering.
@@ -25,7 +25,7 @@ export interface ToolDisplayRow {
     };
 }
 /**
- * Whether a row is a failure the reader must always see: the tool returned an error, or the run
+ * Whether a row failed: the tool returned an error, or the run
  * ended without the tool ever answering (`deriveToolStatus` maps both to `'error'`).
  * @complexity O(1).
  */
@@ -41,7 +41,8 @@ export declare function isFailedToolRow({ row }: {
  * one line per reply. Keeping the first block's key keeps the line's open/closed state across
  * streaming updates, since later blocks append after it.
  *
- * `'hidden'` keeps only failed rows and drops `tools` blocks left empty.
+ * `'hidden'` keeps unrecovered failures in one block per reply. Later assistant text or a successful
+ * tool proves recovery; running tools and reasoning do not. An errored final reply keeps its failures.
  *
  * @param input.blocks - `interleaveMessageBlocks` output.
  * @param input.mode - The display mode.
@@ -51,15 +52,20 @@ export declare function isFailedToolRow({ row }: {
 export declare function applyToolCallDisplay<Row extends ToolDisplayRow>({ blocks, mode }: {
     blocks: readonly MessageBlock<Row>[];
     mode: ToolCallDisplay;
+}, { runFailed }?: {
+    runFailed?: boolean;
 }): readonly MessageBlock<Row>[];
 /**
- * The flat layout's counterpart (used when `interleaveMessageBlocks` refused): `'hidden'` keeps only
- * failed rows; the other modes keep every row (`'collapsed'` folds them into one line at render).
+ * Row-level recovery scan, also used by the flat fallback. Without trustworthy text ordering,
+ * only later successful rows prove recovery. Other modes keep every row.
  * @complexity O(n) in rows.
  */
 export declare function toolRowsForDisplay<Row extends ToolDisplayRow>({ rows, mode }: {
     rows: readonly Row[];
     mode: ToolCallDisplay;
+}, { recovered, runFailed }?: {
+    recovered?: boolean;
+    runFailed?: boolean;
 }): readonly Row[];
 /** What a collapsed tool line says: the tool running now, or how many ran (and how many failed). */
 export type ToolGroupSummary = {

package/dist/react/tool-call-display.js

@@ -1,6 +1,6 @@
 import { humanizeToolName } from '../core/index.js';
 /**
- * Whether a row is a failure the reader must always see: the tool returned an error, or the run
+ * Whether a row failed: the tool returned an error, or the run
  * ended without the tool ever answering (`deriveToolStatus` maps both to `'error'`).
  * @complexity O(1).
  */
@@ -20,31 +20,48 @@ function isRunningToolRow(row) {
  * one line per reply. Keeping the first block's key keeps the line's open/closed state across
  * streaming updates, since later blocks append after it.
  *
- * `'hidden'` keeps only failed rows and drops `tools` blocks left empty.
+ * `'hidden'` keeps unrecovered failures in one block per reply. Later assistant text or a successful
+ * tool proves recovery; running tools and reasoning do not. An errored final reply keeps its failures.
  *
  * @param input.blocks - `interleaveMessageBlocks` output.
  * @param input.mode - The display mode.
  * @returns New blocks; the input is never mutated. `'show'` returns `blocks` itself.
  * @complexity O(n) in blocks + rows.
  */
-export function applyToolCallDisplay({ blocks, mode }) {
+export function applyToolCallDisplay({ blocks, mode }, { runFailed = false } = {}) {
     if (mode === 'show')
         return blocks;
-    return mode === 'hidden' ? hideToolCalls({ blocks }) : collapseToolCalls({ blocks });
+    return mode === 'hidden' ? hideToolCalls({ blocks, runFailed }) : collapseToolCalls({ blocks });
 }
-/** `'hidden'`: keeps only failed rows and drops `tools` blocks left empty. */
-function hideToolCalls({ blocks }) {
+/**
+ * Scan backwards so only later content in the SAME reply can prove recovery. Failures stay visible
+ * while streaming until that evidence arrives. This is a display filter, never a deletion from the
+ * durable events: see assistant-client/transport.ts's forensics rationale.
+ * @complexity O(n) in blocks + rows, excluding the shared grouping pass.
+ */
+function hideToolCalls({ blocks, runFailed }) {
     const out = [];
-    for (const block of blocks) {
+    let recovered = false;
+    let failedReply = runFailed;
+    for (let i = blocks.length - 1; i >= 0; i -= 1) {
+        const block = blocks[i];
+        if (block.kind === 'reply-end') {
+            recovered = false;
+            failedReply = false;
+        }
+        if (block.kind === 'text' && block.text.trim())
+            recovered = true;
         if (block.kind !== 'tools') {
             out.push(block);
             continue;
         }
-        const failed = block.rows.filter((row) => isFailedToolRow({ row }));
-        if (failed.length > 0)
-            out.push({ kind: 'tools', rows: failed, key: block.key });
+        const rows = toolRowsForDisplay({ rows: block.rows, mode: 'hidden' }, { recovered, runFailed: failedReply });
+        if (rows.length > 0)
+            out.push({ ...block, rows });
+        if (block.rows.some((row) => row.status === 'complete'))
+            recovered = true;
     }
-    return out;
+    return collapseToolCalls({ blocks: out.reverse() });
 }
 /** `'collapsed'`: merges every `tools` block of a turn into the turn's first one (see above). */
 function collapseToolCalls({ blocks }) {
@@ -65,12 +82,22 @@ function collapseToolCalls({ blocks }) {
     return out;
 }
 /**
- * The flat layout's counterpart (used when `interleaveMessageBlocks` refused): `'hidden'` keeps only
- * failed rows; the other modes keep every row (`'collapsed'` folds them into one line at render).
+ * Row-level recovery scan, also used by the flat fallback. Without trustworthy text ordering,
+ * only later successful rows prove recovery. Other modes keep every row.
  * @complexity O(n) in rows.
  */
-export function toolRowsForDisplay({ rows, mode }) {
-    return mode === 'hidden' ? rows.filter((row) => isFailedToolRow({ row })) : rows;
+export function toolRowsForDisplay({ rows, mode }, { recovered = false, runFailed = false } = {}) {
+    if (mode !== 'hidden')
+        return rows;
+    const failed = [];
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        const row = rows[i];
+        if (isFailedToolRow({ row }) && (runFailed || !recovered))
+            failed.push(row);
+        if (row.status === 'complete')
+            recovered = true;
+    }
+    return failed.reverse();
 }
 /**
  * Summarises one turn's tool rows. The LAST running row wins, so a line over several in-flight calls

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.7",
+  "version": "0.6.11",
   "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,12 +196,12 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.9"
+    "@jini-ai/core": "^0.6.11"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",
     "react-dom": "^18.3.0 || ^19.0.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",
@@ -213,11 +213,11 @@
     "@radix-ui/react-radio-group": "^1.4.7",
     "@radix-ui/react-select": "^2.3.7",
     "@radix-ui/react-slot": "^1.3.3",
-    "@jini-ai/agent-runtime": "^0.4.5",
-    "@jini-ai/agentic": "^0.4.4",
-    "@jini-ai/protocol": "^0.4.4",
-    "@jini-ai/ui": "^0.5.0",
-    "@jini-ai/diagnostics": "^0.5.2"
+    "@jini-ai/agent-runtime": "^0.6.10",
+    "@jini-ai/agentic": "^0.6.10",
+    "@jini-ai/protocol": "^0.6.10",
+    "@jini-ai/ui": "^0.6.10",
+    "@jini-ai/diagnostics": "^0.6.10"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -303,13 +303,13 @@
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
     "fast-check": "4.3.0",
-    "@jini-ai/agentic": "^0.4.5",
-    "@jini-ai/agent-runtime": "0.4.12",
-    "@jini-ai/protocol": "^0.4.5",
-    "@jini-ai/core": "^0.4.9",
-    "@jini-ai/db": "0.3.6",
-    "@jini-ai/diagnostics": "^0.5.4",
-    "@jini-ai/ui": "^0.5.6"
+    "@jini-ai/db": "0.6.11",
+    "@jini-ai/agent-runtime": "0.6.11",
+    "@jini-ai/protocol": "^0.6.11",
+    "@jini-ai/core": "^0.6.11",
+    "@jini-ai/diagnostics": "^0.6.11",
+    "@jini-ai/ui": "^0.6.11",
+    "@jini-ai/agentic": "^0.6.11"
   },
   "typesVersions": {
     "*": {