@jini-ai/chat 0.5.1 → 0.5.3

package/dist/react/features/chat-pane/rules.js

@@ -105,6 +105,80 @@ export function describeChatPaneSendBlocker(blocker) {
 export function isChatPaneQueueableBlocker({ blocker }) {
     return blocker === 'streaming';
 }
+/**
+ * Whether the run in flight is holding a question open for the human: the newest message is the
+ * assistant's, and it carries an interactive surface (`kind: 'ext'`, e.g. an MCP-UI card) that
+ * arrived inside a still-open call to the host's question tool (`toolName`). That is the one moment
+ * text typed into the composer is an ANSWER rather than a next turn — the tool is parked waiting on
+ * it, and queueing the text behind the run would only deliver it after the question had expired, as
+ * a new paid run.
+ *
+ * Only the question tool counts. Other tools park on cards too — a delete confirm, an approval —
+ * but they take no typed answer: the server routes typed text only to the question tool, so treating
+ * those as waiting would refuse the text with "no longer waiting" and drop it instead of queueing.
+ * A call is the question tool when ANY `tool_use` for its id names it, since the same call's
+ * `tool_use` can arrive more than once (the CLI re-emits it). A vendor's wrapper row
+ * (`execute_delegated_tool`) and the daemon's canonical row do NOT share an id — the wrapper carries
+ * the CLI's `toolu_…` id and the canonical row a fresh UUID from `@jini-ai/mcp`. The canonical row
+ * opens after its wrapper, so it is the newest open call when the surface arrives, and that is
+ * what attributes the surface to the question tool.
+ *
+ * A surface is attributed to the newest call still open when it arrived — the same rule
+ * `useExtEventGroups` uses to give a card its `call` — so an older call returning does not settle
+ * it. Once its call returns (answered, expired, abandoned), typing is a next turn again.
+ *
+ * @complexity O(e·c): e events in the newest message, c calls open at once (one or two in practice).
+ */
+export function isAwaitingTypedAnswer({ messages, toolName }) {
+    return findAwaitedTypedAnswerId({ messages, toolName }) !== null;
+}
+/**
+ * The tool-use id of the question {@link isAwaitingTypedAnswer} sees waiting, or `null` — the newest
+ * one when several are open. The id lets the pane tell one question from the next: a draft typed
+ * for a question stays tied to THAT question after it closes (see `useChatPane`'s held answer).
+ *
+ * @complexity O(e·c), as {@link isAwaitingTypedAnswer}.
+ */
+export function findAwaitedTypedAnswerId({ messages, toolName }) {
+    const newest = messages.at(-1);
+    if (newest?.role !== 'assistant')
+        return null;
+    // Open call id -> whether it is the question tool. Insertion-ordered, so the last entry is the
+    // newest call still open; a repeat id keeps its slot and only ORs in its name.
+    const openCalls = new Map();
+    const awaited = new Set();
+    for (const event of newest.events ?? []) {
+        if (event.kind === 'tool_use')
+            openCalls.set(event.id, openCalls.get(event.id) === true || event.name === toolName);
+        if (event.kind === 'tool_result') {
+            openCalls.delete(event.toolUseId);
+            awaited.delete(event.toolUseId);
+        }
+        const owner = event.kind === 'ext' ? [...openCalls].at(-1) : undefined;
+        if (owner?.[1] === true)
+            awaited.add(owner[0]);
+    }
+    return [...awaited].at(-1) ?? null;
+}
+/**
+ * Whether a composer send is an answer to a waiting question rather than a next turn: a run is
+ * streaming ({@link isChatPaneQueueableBlocker}), the turn has no attachments (a typed answer
+ * carries text only), and that run is holding the `toolName` question open
+ * ({@link isAwaitingTypedAnswer}).
+ *
+ * @complexity O(e·c), from {@link isAwaitingTypedAnswer}.
+ */
+export function isTypedAnswerTurn({ blocker, attachmentCount, messages, toolName }) {
+    return isChatPaneQueueableBlocker({ blocker }) && attachmentCount === 0 && isAwaitingTypedAnswer({ messages, toolName });
+}
+const TYPED_ANSWER_NOTICES = {
+    'not-pending': 'That question is no longer waiting for an answer, so your message was not sent.',
+    failed: 'Your answer could not be delivered. Try sending it again.',
+};
+/** The English copy (and i18n key) for why a typed answer was not sent. */
+export function describeTypedAnswerNotice({ notice }) {
+    return TYPED_ANSWER_NOTICES[notice];
+}
 export function orderChatPaneAgents({ agents }) {
     return [...agents].sort((left, right) => {
         const availability = Number(left.available === false) - Number(right.available === false);

package/dist/react/features/chat-pane/types.d.ts

@@ -120,6 +120,28 @@ export interface ChatPaneComposerHandle {
      */
     insertText: (text: string) => void;
 }
+/**
+ * What happened to text typed while the running agent waits on a question (see
+ * {@link ChatPaneProps.deliverTypedAnswer}): `'delivered'` — the question took it as its answer;
+ * `'not-pending'` — nothing is waiting any more (already answered, expired, or never open);
+ * `'failed'` — the host could not tell (network error, unexpected status).
+ */
+export type TypedAnswerDelivery = 'delivered' | 'not-pending' | 'failed';
+/** Why the pane did not send a typed answer — shown to the human until the next send or reset. */
+export type TypedAnswerNotice = Exclude<TypedAnswerDelivery, 'delivered'>;
+/**
+ * Delivers text typed into the composer to the question the running agent is waiting on.
+ *
+ * Carries `toolName`, the host's question tool id, so the pane routes typed text here only while a
+ * card raised by THAT tool is open — any other pending card (a confirm, an approval) still queues the
+ * text behind the run. One value, so the tool the pane waits on and the tool the answer is posted to
+ * cannot drift apart; `createTypedAnswerPoster` sets it.
+ */
+export type DeliverTypedAnswer = ((input: {
+    text: string;
+}) => Promise<TypedAnswerDelivery>) & {
+    readonly toolName: string;
+};
 export interface ChatPaneProps {
     transport: ChatTransport;
     agents?: readonly ChatPaneAgent[];
@@ -170,6 +192,18 @@ export interface ChatPaneProps {
      * before the pane exists has nothing to call.
      */
     composerHandle?: RefObject<ChatPaneComposerHandle | null>;
+    /**
+     * Called instead of queueing when the human types while the running agent is holding a question
+     * open in the transcript (an interactive surface whose call to `deliverTypedAnswer.toolName` has
+     * not returned — `isAwaitingTypedAnswer`) and the turn carries no attachments. `'delivered'` clears the draft
+     * (only if unchanged since it went out); any other outcome, or a throw, leaves the draft in place with a
+     * notice and NEVER queues it — a queued answer would go out after the run ends as a new, paid run
+     * answering nothing. A draft typed while the question waited stays held after it closes, until the
+     * human clears it or picks "Send as a new message" (`useChatPane`'s `sendAsNewMessage`).
+     *
+     * Omit it and typing while a run streams queues exactly as before.
+     */
+    deliverTypedAnswer?: DeliverTypedAnswer;
     placeholder?: string;
     /**
      * Rotating composer suggestions, cycled every few seconds in place of one fixed `placeholder` —

package/dist/react/hooks/composer-draft-cache.d.ts

@@ -115,6 +115,34 @@ export declare function clearCachedDraft({ conversationId }: {
 export declare function readCachedAttachments({ conversationId }: {
     conversationId: string | null | undefined;
 }): readonly ChatAttachment[] | null;
+/**
+ * The upload batch `conversationId`'s cached attachments were uploaded under, so a pane that
+ * restores those attachments uploads the next file into the SAME batch.
+ *
+ * Why this exists: the daemon grants the agent exactly one batch directory per turn and refuses a
+ * turn whose attachments span two ("Attachments must belong to one batch"). A pane that restored an
+ * attachment after a remount, reload, or conversation switch used to upload the next file under a
+ * brand-new batch id, so every such turn failed before the agent started (2026-10-06).
+ *
+ * @returns The batch id, or `null` when there are no cached attachments to stay consistent with
+ * (none staged, attachment persistence off because the host supplied no validator, or an entry
+ * written before batch ids were recorded) — the caller then starts a fresh batch.
+ * @complexity Time/space: O(1) on an in-memory hit, O(n) in the stored count otherwise.
+ */
+export declare function readCachedAttachmentBatchId({ conversationId }: {
+    conversationId: string | null | undefined;
+}): string | null;
+/**
+ * Records the upload batch of an attachment about to be staged in `conversationId`'s composer.
+ * Memory only: the stored envelope picks it up on the {@link writeCachedAttachments} that persists
+ * that attachment, so it is never written ahead of the references it describes.
+ *
+ * @complexity Time/space: O(1) amortized.
+ */
+export declare function writeCachedAttachmentBatchId({ conversationId, batchId }: {
+    conversationId: string | null | undefined;
+    batchId: string;
+}): void;
 /**
  * Stores `attachments` for `conversationId` in both tiers.
  *

package/dist/react/hooks/composer-draft-cache.js

@@ -62,6 +62,10 @@ export const COMPOSER_DRAFT_STORAGE_PREFIX = 'jini.chat.composer-draft.v1.';
 export const COMPOSER_ATTACHMENTS_STORAGE_PREFIX = 'jini.chat.composer-attachments.v1.';
 const drafts = new Map();
 const stagedAttachments = new Map();
+// Kept beside `stagedAttachments` rather than inside it so `writeCachedAttachments` keeps its
+// attachments-only signature: `useComposer` persists the list and never sees a batch id, while
+// `useChatPane` (the one caller that uploads in batches) records the batch here.
+const stagedBatchIds = new Map();
 /**
  * The origin's `localStorage`, or `null` when it cannot be used.
  *
@@ -282,10 +286,11 @@ function isChatAttachment(candidate) {
     return true;
 }
 /**
- * Reads the stored attachment references for `conversationId`.
+ * Reads the stored attachment references (and their upload batch) for `conversationId`.
  *
  * Elements that do not validate are dropped individually rather than failing the whole entry — one
- * malformed row should cost the operator that row, not every attachment on the turn.
+ * malformed row should cost the operator that row, not every attachment on the turn. A missing or
+ * malformed batch id costs only the batch (`batchId: null`), never the references.
  *
  * @returns The stored references, or `null` when there are none, storage is unavailable, or nothing
  * in the entry validated.
@@ -302,6 +307,7 @@ function readStoredAttachments(conversationId) {
             return null;
         const parsed = JSON.parse(raw);
         const list = parsed?.a;
+        const batchId = parsed?.b;
         if (!Array.isArray(list)) {
             store.removeItem(key);
             return null;
@@ -311,7 +317,7 @@ function readStoredAttachments(conversationId) {
             store.removeItem(key);
             return null;
         }
-        return valid;
+        return { attachments: valid, batchId: typeof batchId === 'string' && batchId !== '' ? batchId : null };
     }
     catch {
         try {
@@ -345,8 +351,48 @@ export function readCachedAttachments({ conversationId }) {
     const stored = readStoredAttachments(conversationId);
     if (stored === null)
         return null;
-    stagedAttachments.set(conversationId, stored);
-    return stored;
+    stagedAttachments.set(conversationId, stored.attachments);
+    if (stored.batchId !== null)
+        stagedBatchIds.set(conversationId, stored.batchId);
+    return stored.attachments;
+}
+/**
+ * The upload batch `conversationId`'s cached attachments were uploaded under, so a pane that
+ * restores those attachments uploads the next file into the SAME batch.
+ *
+ * Why this exists: the daemon grants the agent exactly one batch directory per turn and refuses a
+ * turn whose attachments span two ("Attachments must belong to one batch"). A pane that restored an
+ * attachment after a remount, reload, or conversation switch used to upload the next file under a
+ * brand-new batch id, so every such turn failed before the agent started (2026-10-06).
+ *
+ * @returns The batch id, or `null` when there are no cached attachments to stay consistent with
+ * (none staged, attachment persistence off because the host supplied no validator, or an entry
+ * written before batch ids were recorded) — the caller then starts a fresh batch.
+ * @complexity Time/space: O(1) on an in-memory hit, O(n) in the stored count otherwise.
+ */
+export function readCachedAttachmentBatchId({ conversationId }) {
+    if (!conversationId)
+        return null;
+    if (readCachedAttachments({ conversationId: conversationId }) === null)
+        return null;
+    return stagedBatchIds.get(conversationId) ?? null;
+}
+/**
+ * Records the upload batch of an attachment about to be staged in `conversationId`'s composer.
+ * Memory only: the stored envelope picks it up on the {@link writeCachedAttachments} that persists
+ * that attachment, so it is never written ahead of the references it describes.
+ *
+ * @complexity Time/space: O(1) amortized.
+ */
+export function writeCachedAttachmentBatchId({ conversationId, batchId }) {
+    if (!conversationId)
+        return;
+    if (!stagedBatchIds.has(conversationId) && stagedBatchIds.size >= MAX_CACHED_CONVERSATION_DRAFTS) {
+        const oldest = stagedBatchIds.keys().next().value;
+        if (oldest !== undefined)
+            stagedBatchIds.delete(oldest);
+    }
+    stagedBatchIds.set(conversationId, batchId);
 }
 /**
  * Stores `attachments` for `conversationId` in both tiers.
@@ -362,6 +408,8 @@ export function writeCachedAttachments({ conversationId, attachments }) {
     const store = storage();
     if (attachments.length === 0) {
         stagedAttachments.delete(conversationId);
+        // A sent or cleared turn's batch is spent; the next upload starts a fresh one.
+        stagedBatchIds.delete(conversationId);
         try {
             store?.removeItem(key);
         }
@@ -381,7 +429,8 @@ export function writeCachedAttachments({ conversationId, attachments }) {
     try {
         if (store.getItem(key) === null)
             pruneStored(COMPOSER_ATTACHMENTS_STORAGE_PREFIX, MAX_CACHED_CONVERSATION_DRAFTS - 1);
-        const envelope = { v: 1, t: Date.now(), a: attachments };
+        const batchId = stagedBatchIds.get(conversationId);
+        const envelope = { v: 1, t: Date.now(), a: attachments, ...(batchId === undefined ? {} : { b: batchId }) };
         store.setItem(key, JSON.stringify(envelope));
     }
     catch {
@@ -399,6 +448,7 @@ export function writeCachedAttachments({ conversationId, attachments }) {
 export function __resetComposerDraftCacheForTests(options) {
     drafts.clear();
     stagedAttachments.clear();
+    stagedBatchIds.clear();
     if (options?.keepStorage === true)
         return;
     pruneStored(COMPOSER_DRAFT_STORAGE_PREFIX, 0);

package/dist/react/hooks/last-conversation-store.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @module last-conversation-store
+ *
+ * Remembers which conversation an operator last had open, so a host's chat surface can land back
+ * on it after a page reload, a closed tab, or a navigation away — instead of an empty new chat.
+ *
+ * Conversation SELECTION is host-owned (`ChatPane` is uncontrolled and takes a `conversationId`;
+ * `ConversationList` takes `activeConversationId` as a prop), so this module does not decide when
+ * to restore. It is only the durable slot: the host reads it once at mount, checks the id still
+ * exists for this caller, and writes it whenever its active conversation changes.
+ *
+ * Same storage discipline as `composer-draft-cache.ts`: a versioned key, every access wrapped, and a
+ * foreign or corrupt entry treated as "nothing remembered" and deleted. A private window, blocked
+ * site data or a quota rejection degrades this to remembering nothing — never a throw at the host.
+ *
+ * Unlike the draft cache this is NOT a module singleton. The partition here is the caller's
+ * identity (`scope`), which only the host knows — two users on one browser must never land in each
+ * other's chat — so a host constructs one store per scope and passes it down.
+ */
+/**
+ * Key prefix for the stored entry. Versioned (`.v1.`) so a future change to the stored shape can be
+ * introduced without interpreting, or mis-interpreting, entries written by this one.
+ */
+export declare const LAST_CONVERSATION_STORAGE_PREFIX = "jini.chat.last-conversation.v1.";
+/** The subset of Web Storage this module uses — `localStorage` satisfies it; tests pass a fake. */
+export interface LastConversationStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/** The host-facing port. Every method is total: none throws, whatever storage does. */
+export interface LastConversationStore {
+    /** The remembered conversation id, or `null` when there is none or storage is unusable. */
+    read(): string | null;
+    /** Remembers `conversationId` as the one to land on next time, replacing any earlier one. */
+    write(conversationId: string): void;
+    /** Forgets the remembered id — for a conversation that was deleted or is no longer reachable. */
+    clear(): void;
+}
+/**
+ * Creates the last-conversation slot for one caller identity.
+ *
+ * @param required.scope Who this memory belongs to — e.g. `${workspaceId}:${userId}`. Part of the
+ *   key, so a different scope on the same browser reads nothing.
+ * @param optional.storage Defaults to the origin's `localStorage`, resolved on every call (not once)
+ *   so a store created during SSR still works after hydration. `null` disables persistence.
+ * @returns A {@link LastConversationStore}; see its methods for the never-throws contract.
+ * @example
+ * const store = createLastConversationStore({ scope: `${workspaceId}:${user.id}` });
+ * const id = store.read(); // land here if it still exists, else store.clear()
+ * @complexity Time/space: O(1) per call, plus O(n) in the entry's length for the JSON parse.
+ */
+export declare function createLastConversationStore({ scope }: {
+    scope: string;
+}, { storage }?: {
+    storage?: LastConversationStorage | null;
+}): LastConversationStore;
+//# sourceMappingURL=last-conversation-store.d.ts.map

package/dist/react/hooks/last-conversation-store.js

@@ -0,0 +1,112 @@
+/**
+ * @module last-conversation-store
+ *
+ * Remembers which conversation an operator last had open, so a host's chat surface can land back
+ * on it after a page reload, a closed tab, or a navigation away — instead of an empty new chat.
+ *
+ * Conversation SELECTION is host-owned (`ChatPane` is uncontrolled and takes a `conversationId`;
+ * `ConversationList` takes `activeConversationId` as a prop), so this module does not decide when
+ * to restore. It is only the durable slot: the host reads it once at mount, checks the id still
+ * exists for this caller, and writes it whenever its active conversation changes.
+ *
+ * Same storage discipline as `composer-draft-cache.ts`: a versioned key, every access wrapped, and a
+ * foreign or corrupt entry treated as "nothing remembered" and deleted. A private window, blocked
+ * site data or a quota rejection degrades this to remembering nothing — never a throw at the host.
+ *
+ * Unlike the draft cache this is NOT a module singleton. The partition here is the caller's
+ * identity (`scope`), which only the host knows — two users on one browser must never land in each
+ * other's chat — so a host constructs one store per scope and passes it down.
+ */
+/**
+ * Key prefix for the stored entry. Versioned (`.v1.`) so a future change to the stored shape can be
+ * introduced without interpreting, or mis-interpreting, entries written by this one.
+ */
+export const LAST_CONVERSATION_STORAGE_PREFIX = 'jini.chat.last-conversation.v1.';
+/**
+ * The origin's `localStorage`, or `null` when it cannot be used — a non-browser runtime, or a
+ * browser that throws on the property access itself (Safari and Chrome both do with site data
+ * blocked), which is why this is a try/catch rather than a `typeof` check alone.
+ * @complexity Time/space: O(1).
+ */
+function browserStorage() {
+    try {
+        return typeof localStorage === 'undefined' ? null : localStorage;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Validates one parsed entry as this module's own envelope.
+ * @complexity Time/space: O(1).
+ */
+function storedId(parsed) {
+    const entry = parsed;
+    if (entry?.v !== 1 || typeof entry.id !== 'string' || entry.id === '')
+        return null;
+    return entry.id;
+}
+/**
+ * Creates the last-conversation slot for one caller identity.
+ *
+ * @param required.scope Who this memory belongs to — e.g. `${workspaceId}:${userId}`. Part of the
+ *   key, so a different scope on the same browser reads nothing.
+ * @param optional.storage Defaults to the origin's `localStorage`, resolved on every call (not once)
+ *   so a store created during SSR still works after hydration. `null` disables persistence.
+ * @returns A {@link LastConversationStore}; see its methods for the never-throws contract.
+ * @example
+ * const store = createLastConversationStore({ scope: `${workspaceId}:${user.id}` });
+ * const id = store.read(); // land here if it still exists, else store.clear()
+ * @complexity Time/space: O(1) per call, plus O(n) in the entry's length for the JSON parse.
+ */
+export function createLastConversationStore({ scope }, { storage } = {}) {
+    const key = `${LAST_CONVERSATION_STORAGE_PREFIX}${encodeURIComponent(scope)}`;
+    const resolve = () => (storage === undefined ? browserStorage() : storage);
+    const remove = (store) => {
+        try {
+            store.removeItem(key);
+        }
+        catch {
+            /* storage is unusable; nothing further this module can do */
+        }
+    };
+    return {
+        read() {
+            const store = resolve();
+            if (!store)
+                return null;
+            try {
+                const raw = store.getItem(key);
+                if (raw === null)
+                    return null;
+                const id = storedId(JSON.parse(raw));
+                if (id === null)
+                    remove(store);
+                return id;
+            }
+            catch {
+                // A parse failure or a throwing read: a corrupt entry must not survive to be read again.
+                remove(store);
+                return null;
+            }
+        },
+        write(conversationId) {
+            const store = resolve();
+            if (!store)
+                return;
+            try {
+                const envelope = { v: 1, id: conversationId };
+                store.setItem(key, JSON.stringify(envelope));
+            }
+            catch {
+                /* blocked, full, or unusable storage — remembering nothing is the documented degraded mode */
+            }
+        },
+        clear() {
+            const store = resolve();
+            if (store)
+                remove(store);
+        },
+    };
+}
+//# sourceMappingURL=last-conversation-store.js.map

package/dist/react/hooks/useSurfaceExpiry.d.ts

@@ -0,0 +1,20 @@
+import { type SurfaceExpiry } from '../../core/index.js';
+/** The clock port: the current time, and a repeating ticker that returns its own stop function. */
+export interface SurfaceExpiryClock {
+    nowMs(): number;
+    every(intervalMs: number, tick: () => void): () => void;
+}
+/** The wall clock and `setInterval`; the default when a caller injects none. */
+export declare const SYSTEM_SURFACE_EXPIRY_CLOCK: SurfaceExpiryClock;
+/**
+ * @param input.expiresAtMs - The card's deadline (epoch ms), or `undefined` when it has none.
+ * @param options.clock - Time source and ticker. Defaults to {@link SYSTEM_SURFACE_EXPIRY_CLOCK}.
+ * @returns The deadline's state at the last tick, or `undefined` when there is no deadline.
+ * @complexity O(1) per render; one ticker while live.
+ */
+export declare function useSurfaceExpiry({ expiresAtMs }: {
+    expiresAtMs: number | undefined;
+}, { clock }?: {
+    clock?: SurfaceExpiryClock;
+}): SurfaceExpiry | undefined;
+//# sourceMappingURL=useSurfaceExpiry.d.ts.map

package/dist/react/hooks/useSurfaceExpiry.js

@@ -0,0 +1,35 @@
+/**
+ * @module useSurfaceExpiry
+ *
+ * The live countdown for a pending MCP-UI card: `describeSurfaceExpiry` re-read once a second on an
+ * injected clock. Ticks only while the card is answerable and has a deadline; an expired card or one
+ * without a deadline runs no timer.
+ */
+import { useEffect, useState } from 'react';
+import { describeSurfaceExpiry, SURFACE_EXPIRY_TICK_MS } from '../../core/index.js';
+/** The wall clock and `setInterval`; the default when a caller injects none. */
+export const SYSTEM_SURFACE_EXPIRY_CLOCK = {
+    nowMs: () => Date.now(),
+    every: (intervalMs, tick) => {
+        const timer = setInterval(tick, intervalMs);
+        return () => clearInterval(timer);
+    },
+};
+/**
+ * @param input.expiresAtMs - The card's deadline (epoch ms), or `undefined` when it has none.
+ * @param options.clock - Time source and ticker. Defaults to {@link SYSTEM_SURFACE_EXPIRY_CLOCK}.
+ * @returns The deadline's state at the last tick, or `undefined` when there is no deadline.
+ * @complexity O(1) per render; one ticker while live.
+ */
+export function useSurfaceExpiry({ expiresAtMs }, { clock = SYSTEM_SURFACE_EXPIRY_CLOCK } = {}) {
+    const [nowMs, setNowMs] = useState(() => clock.nowMs());
+    const expiry = expiresAtMs === undefined ? undefined : describeSurfaceExpiry({ expiresAtMs, nowMs });
+    const live = expiry?.expired === false;
+    useEffect(() => {
+        if (!live)
+            return undefined;
+        return clock.every(SURFACE_EXPIRY_TICK_MS, () => setNowMs(clock.nowMs()));
+    }, [live, clock]);
+    return expiry;
+}
+//# sourceMappingURL=useSurfaceExpiry.js.map

package/dist/react/hooks/useToolTimeline.js

@@ -3,17 +3,20 @@
  *
  * Per-tool lifecycle rows for a message's events: pairs each `tool_use` with
  * its `tool_result` (deduped by id via `@jini-ai/chat/core`'s
- * `dedupeToolUsesById`), derives a four-state status via
+ * `dedupeToolUsesById`, delegated wrapper calls folded onto their canonical
+ * rows via `foldDelegatedWrapperCalls`), derives a four-state status via
  * `deriveToolStatus`, and tracks per-row expand/collapse UI state. Pure over
  * `AgentEvent[]` — zero I/O. Per
  * `ADS-memory/reports/jini-port/recon/r4b-webui-design.md` §4.
  */
 import { useCallback, useMemo, useState } from 'react';
-import { dedupeToolUsesById, deriveToolStatus } from '../../core/index.js';
+import { dedupeToolUsesById, deriveToolStatus, foldDelegatedWrapperCalls } from '../../core/index.js';
 export function useToolTimeline({ events }, options = {}) {
     const { runStreaming = false, runSucceeded = false, defaultExpanded = false } = options;
     const [overrides, setOverrides] = useState({});
-    const deduped = useMemo(() => dedupeToolUsesById({ events: events }), [events]);
+    // A delegated call's wrapper row and the daemon's canonical row have different ids, so dedupe
+    // alone leaves both; the fold keeps the canonical one (see `foldDelegatedWrapperCalls`).
+    const deduped = useMemo(() => foldDelegatedWrapperCalls({ events: dedupeToolUsesById({ events: events }) }), [events]);
     const rows = useMemo(() => {
         const out = [];
         for (const ev of deduped) {

package/dist/react/index.d.ts

@@ -36,8 +36,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, 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, McpUiToolCallRequest, RuntimePickerPlacement, UseChatPaneAgentControlOptions, UseChatPaneOptions, UseChatPaneResult, UseChatPaneRuntimeInventoryOptions, UseChatPaneRuntimeInventoryResult, UseChatPaneWorkingDirectoryOptions, UseChatPaneWorkingDirectoryResult, } from './chat-pane.js';
+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 { useRunStream, } from './hooks/useRunStream.js';
 export type { RunStreamState, RunStreamStatus, StartRunOptions, UseRunStreamResult, } from './hooks/useRunStream.js';
 export { useConversation, } from './hooks/useConversation.js';
@@ -48,6 +48,8 @@ export { useToolTimeline, } from './hooks/useToolTimeline.js';
 export type { ToolTimelineRow, UseToolTimelineOptions, UseToolTimelineResult, } from './hooks/useToolTimeline.js';
 export { useExtEventGroups, } from './hooks/useExtEventGroups.js';
 export type { ExtEventGroup, } from './hooks/useExtEventGroups.js';
+export { SYSTEM_SURFACE_EXPIRY_CLOCK, useSurfaceExpiry, } from './hooks/useSurfaceExpiry.js';
+export type { SurfaceExpiryClock, } from './hooks/useSurfaceExpiry.js';
 export { usePinnedTodos, } from './hooks/usePinnedTodos.js';
 export type { UsePinnedTodosResult, } from './hooks/usePinnedTodos.js';
 export { parseSubmittedAnswers, useQuestionForms, } from './hooks/useQuestionForms.js';
@@ -110,6 +112,12 @@ export type { TodoCardProps } from './components/TodoCard.js';
  */
 export { ConversationList } from './components/ConversationList.js';
 export type { ConversationListProps, ConversationListItem } from './components/ConversationList.js';
+/**
+ * The conversation an operator last had open, per caller identity — so a host's switcher lands
+ * back on it after a reload instead of an empty new chat. See the module doc for the contract.
+ */
+export { createLastConversationStore, LAST_CONVERSATION_STORAGE_PREFIX } from './hooks/last-conversation-store.js';
+export type { LastConversationStorage, LastConversationStore } from './hooks/last-conversation-store.js';
 export { ToolCard } from './components/ToolCard.js';
 export type { ToolCardProps } from './components/ToolCard.js';
 export { A2uiSurfaceCard } from './components/A2uiSurfaceCard.js';

package/dist/react/index.js

@@ -26,12 +26,13 @@ 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, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './chat-pane.js';
+export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, 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';
 export { useToolTimeline, } from './hooks/useToolTimeline.js';
 export { useExtEventGroups, } from './hooks/useExtEventGroups.js';
+export { SYSTEM_SURFACE_EXPIRY_CLOCK, useSurfaceExpiry, } from './hooks/useSurfaceExpiry.js';
 export { usePinnedTodos, } from './hooks/usePinnedTodos.js';
 export { parseSubmittedAnswers, useQuestionForms, } from './hooks/useQuestionForms.js';
 export { useArtifactStream, } from './hooks/useArtifactStream.js';
@@ -85,6 +86,11 @@ export { TodoCard } from './components/TodoCard.js';
  * `leadingAccessory` slot; it needs no changes to `ChatPane` itself.
  */
 export { ConversationList } from './components/ConversationList.js';
+/**
+ * The conversation an operator last had open, per caller identity — so a host's switcher lands
+ * back on it after a reload instead of an empty new chat. See the module doc for the contract.
+ */
+export { createLastConversationStore, LAST_CONVERSATION_STORAGE_PREFIX } from './hooks/last-conversation-store.js';
 export { ToolCard } from './components/ToolCard.js';
 export { A2uiSurfaceCard } from './components/A2uiSurfaceCard.js';
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "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": {
@@ -145,15 +145,15 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/agentic": "^0.4.1",
+    "@jini-ai/agentic": "^0.4.2",
+    "@jini-ai/ui": "^0.4.4",
     "@jini-ai/protocol": "^0.4.0",
-    "@jini-ai/core": "^0.4.0",
-    "@jini-ai/ui": "^0.4.2"
+    "@jini-ai/core": "^0.4.1"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",
     "react-dom": "^18.3.0 || ^19.0.0",
-    "@jini-ai/db": "^0.2.0",
+    "@jini-ai/db": "^0.2.0 || ^0.3.0",
     "kysely": "^0.29.6",
     "better-sqlite3": "^13.0.0",
     "@electric-sql/pglite": "0.5.8",
@@ -238,8 +238,8 @@
     "@electric-sql/pglite": "0.5.8",
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
-    "@jini-ai/agent-runtime": "0.4.0",
-    "@jini-ai/db": "0.2.0"
+    "@jini-ai/db": "0.3.0",
+    "@jini-ai/agent-runtime": "0.4.0"
   },
   "typesVersions": {
     "*": {