@jini-ai/chat 0.5.5 → 0.5.7

package/dist/react/hooks/useComposer.js

@@ -29,20 +29,89 @@
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useComposerHistory } from './useComposerHistory.hooks.js';
-import { readCachedAttachments, readCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
+import { readCachedAttachments, readCachedDraft, rememberCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
 import { cacheAttachmentPreviewSource } from './attachment-preview-cache.js';
 const EMPTY_MENTION = { open: false, query: '', results: [] };
+/**
+ * How long typing must pause before the draft reaches `localStorage` and the host's persistence
+ * port. Those writes used to run synchronously on every keystroke (owner report 2026-10-08: typing
+ * lagged in a long conversation). The in-memory cache tier still updates per keystroke, and every
+ * exit path (send, conversation switch, unmount, page hide, blur) writes or discards immediately,
+ * so the delay can only cost a draft on a hard crash inside this window.
+ */
+export const DRAFT_PERSIST_DEBOUNCE_MS = 800;
+/**
+ * One pending durable draft write at a time, trailing-edge debounced. Flushes on unmount and when
+ * the page is hidden (`pagehide`, or `visibilitychange` to hidden — the last event a mobile browser
+ * reliably delivers before discarding the tab).
+ * @complexity Time/space: O(1) per call.
+ */
+function useDeferredDraftWrite() {
+    const pendingRef = useRef(null);
+    const cancel = useCallback(() => {
+        const pending = pendingRef.current;
+        if (!pending)
+            return;
+        pendingRef.current = null;
+        clearTimeout(pending.timer);
+    }, []);
+    const flush = useCallback(() => {
+        const pending = pendingRef.current;
+        if (!pending)
+            return;
+        pendingRef.current = null;
+        clearTimeout(pending.timer);
+        pending.write();
+    }, []);
+    const schedule = useCallback((write) => {
+        if (pendingRef.current)
+            clearTimeout(pendingRef.current.timer);
+        const timer = setTimeout(() => {
+            pendingRef.current = null;
+            write();
+        }, DRAFT_PERSIST_DEBOUNCE_MS);
+        pendingRef.current = { timer, write };
+    }, []);
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return flush;
+        const onVisibilityChange = () => {
+            if (document.visibilityState === 'hidden')
+                flush();
+        };
+        window.addEventListener('pagehide', flush);
+        document.addEventListener('visibilitychange', onVisibilityChange);
+        return () => {
+            window.removeEventListener('pagehide', flush);
+            document.removeEventListener('visibilitychange', onVisibilityChange);
+            flush();
+        };
+    }, [flush]);
+    return useMemo(() => ({ schedule, flush, cancel }), [schedule, flush, cancel]);
+}
 export function useComposer(options = {}) {
     const { project, composerSlots, persistence, conversationId, validateAttachments } = options;
     const [draft, setDraftState] = useState(() => options.initialDraft ?? persistence?.read() ?? readCachedDraft({ conversationId: conversationId }) ?? '');
     const [attachments, setAttachments] = useState([]);
     const [agent, setAgent] = useState(options.initialAgent);
     const [mention, setMention] = useState(EMPTY_MENTION);
+    const deferredWrite = useDeferredDraftWrite();
     const commitDraft = useCallback((next) => {
         setDraftState(next);
-        persistence?.write(next);
-        writeCachedDraft({ conversationId: conversationId, draft: next });
-    }, [persistence, conversationId]);
+        rememberCachedDraft({ conversationId: conversationId, draft: next });
+        const write = () => {
+            persistence?.write(next);
+            writeCachedDraft({ conversationId: conversationId, draft: next });
+        };
+        // A cleared draft (send, reset) is written at once and drops any pending write, so a stale
+        // timer can never put the sent text back.
+        if (next.trim() === '') {
+            deferredWrite.cancel();
+            write();
+            return;
+        }
+        deferredWrite.schedule(write);
+    }, [persistence, conversationId, deferredWrite]);
     const history = useComposerHistory({ setRecalledDraft: setDraftState }, {
         ...(options.historyMessages === undefined ? {} : { messages: options.historyMessages }),
         ...(options.historyScope === undefined ? {} : { scope: options.historyScope }),
@@ -68,6 +137,8 @@ export function useComposer(options = {}) {
         if (conversationId === previousConversationIdRef.current)
             return;
         previousConversationIdRef.current = conversationId;
+        // The pending write closed over the conversation being left, so this lands under its id.
+        deferredWrite.flush();
         const restored = readCachedDraft({ conversationId: conversationId });
         // An id arriving where there was none is NOT a switch between two conversations — it is the one
         // the operator is already looking at finally getting a key (a new chat created server-side
@@ -85,7 +156,7 @@ export function useComposer(options = {}) {
         setDraftState(restored ?? '');
         setAttachments([]);
         setMention(EMPTY_MENTION);
-    }, [conversationId]);
+    }, [conversationId, deferredWrite]);
     // Held in a ref so an inline arrow from the host does not re-run the restore below on every
     // render. Reassigned each render so a host that swaps implementations still gets the new one.
     const validateAttachmentsRef = useRef(validateAttachments);
@@ -221,6 +292,7 @@ export function useComposer(options = {}) {
         selectMention,
         canSubmit,
         reset,
-    }), [draft, history, setDraft, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset]);
+        flushDraft: deferredWrite.flush,
+    }), [draft, history, setDraft, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset, deferredWrite.flush]);
 }
 //# sourceMappingURL=useComposer.js.map

package/dist/react/index.d.ts

@@ -18,8 +18,8 @@ export type { ExtEventRenderProps, ExtEventRenderer, ExtEventRendererOptions, Ex
  * This alias has no removal date scheduled yet; see `chat-pane.ts` for the canonical surface and
  * the module doc there for why the split exists.
  */
-export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './chat-pane.js';
-export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAgentToolDef, ChatPaneAgentToolInputSchema, ChatPaneAgentToolRisk, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, CreateDaemonAttachmentUploaderOptions, CreateMcpUiToolCallerOptions, CreateTypedAnswerPosterOptions, DeliverTypedAnswer, McpUiToolCallRequest, RuntimePickerPlacement, TypedAnswerDelivery, TypedAnswerNotice, UseChatPaneAgentControlOptions, UseChatPaneOptions, UseChatPaneResult, UseChatPaneRuntimeInventoryOptions, UseChatPaneRuntimeInventoryResult, UseChatPaneWorkingDirectoryOptions, UseChatPaneWorkingDirectoryResult, } from './chat-pane.js';
+export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createMidRunMessagePoster, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './chat-pane.js';
+export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAgentToolDef, ChatPaneAgentToolInputSchema, ChatPaneAgentToolRisk, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, CreateDaemonAttachmentUploaderOptions, CreateMcpUiToolCallerOptions, CreateMidRunMessagePosterOptions, CreateTypedAnswerPosterOptions, DeliverMidRunMessage, DeliverTypedAnswer, McpUiToolCallRequest, MidRunMessageDelivery, RuntimePickerPlacement, TypedAnswerDelivery, TypedAnswerNotice, UseChatPaneAgentControlOptions, UseChatPaneOptions, UseChatPaneResult, UseChatPaneRuntimeInventoryOptions, UseChatPaneRuntimeInventoryResult, UseChatPaneWorkingDirectoryOptions, UseChatPaneWorkingDirectoryResult, } from './chat-pane.js';
 export { useRunStream, } from './hooks/useRunStream.js';
 export type { RunStreamState, RunStreamStatus, StartRunOptions, UseRunStreamResult, } from './hooks/useRunStream.js';
 export { useConversation, } from './hooks/useConversation.js';
@@ -111,6 +111,8 @@ export type { A2uiAgentActionOutcome, A2uiSurfaceCardProps } from './components/
  */
 export { McpUiSurfaceCard, mcpUiSurfaceSlotKey, registerMcpUiSurfaceRenderer, MCP_UI_EXT_EVENT_NAME } from './components/McpUiSurfaceCard.js';
 export type { McpUiSurfaceCardProps } from './components/McpUiSurfaceCard.js';
+/** A message sent mid-run (`ChatPane`'s `deliverMidRunMessage`), drawn as a user bubble inside the running turn. */
+export { MidRunUserMessage, midRunUserMessageSlotKey, registerMidRunUserMessageRenderer, MID_RUN_USER_MESSAGE_EXT_EVENT_NAME } from './components/MidRunUserMessage.js';
 export { ExtEventErrorBoundary } from './components/ExtEventErrorBoundary.js';
 export type { ExtEventErrorBoundaryProps } from './components/ExtEventErrorBoundary.js';
 export { QuestionForm } from './components/QuestionForm.js';

package/dist/react/index.js

@@ -26,7 +26,7 @@ export { clearExtEventRenderers, extEventSlot, getExtEventRenderer, registerExtE
  * This alias has no removal date scheduled yet; see `chat-pane.ts` for the canonical surface and
  * the module doc there for why the split exists.
  */
-export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './chat-pane.js';
+export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createMidRunMessagePoster, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './chat-pane.js';
 export { useRunStream, } from './hooks/useRunStream.js';
 export { useConversation, } from './hooks/useConversation.js';
 export { useComposer, } from './hooks/useComposer.js';
@@ -99,6 +99,8 @@ export { A2uiSurfaceCard } from './components/A2uiSurfaceCard.js';
  * resources instead of A2UI surfaces.
  */
 export { McpUiSurfaceCard, mcpUiSurfaceSlotKey, registerMcpUiSurfaceRenderer, MCP_UI_EXT_EVENT_NAME } from './components/McpUiSurfaceCard.js';
+/** A message sent mid-run (`ChatPane`'s `deliverMidRunMessage`), drawn as a user bubble inside the running turn. */
+export { MidRunUserMessage, midRunUserMessageSlotKey, registerMidRunUserMessageRenderer, MID_RUN_USER_MESSAGE_EXT_EVENT_NAME } from './components/MidRunUserMessage.js';
 export { ExtEventErrorBoundary } from './components/ExtEventErrorBoundary.js';
 export { QuestionForm } from './components/QuestionForm.js';
 export { QuestionsPanel } from './components/QuestionsPanel.js';

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.5",
+  "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,13 +286,13 @@
     "@electric-sql/pglite": "0.5.8",
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
+    "@jini-ai/ui": "^0.4.7",
     "@jini-ai/db": "0.3.1",
-    "@jini-ai/agent-runtime": "0.4.2",
+    "@jini-ai/protocol": "^0.4.3",
+    "@jini-ai/diagnostics": "^0.5.1",
     "@jini-ai/agentic": "^0.4.3",
-    "@jini-ai/ui": "^0.4.5",
-    "@jini-ai/protocol": "^0.4.2",
-    "@jini-ai/core": "^0.4.2",
-    "@jini-ai/diagnostics": "^0.5.1"
+    "@jini-ai/agent-runtime": "0.4.4",
+    "@jini-ai/core": "^0.4.2"
   },
   "typesVersions": {
     "*": {