@jini-ai/chat 0.6.17 → 0.6.19

package/dist/react/components/ConversationTitleEditor.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { formatErrorForLog } from '@jini-ai/core';
 import { useRef, useState } from 'react';
 import { MAX_CONVERSATION_TITLE_LENGTH } from '../../core/conversation-title.js';
 import { useT } from '../hooks/context.js';
@@ -28,7 +29,7 @@ export function ConversationTitleEditor({ title, onCommit, onCancel, className =
             await onCommit(next);
         }
         catch (error) {
-            console.error('[@jini-ai/chat] ConversationTitleEditor onCommit host effect failed:', error);
+            console.error('[@jini-ai/chat] ConversationTitleEditor onCommit host effect failed:', formatErrorForLog({ error }));
         }
     };
     return _jsx("input", { autoFocus: true, className: className, "aria-label": t('Rename chat'), "data-testid": testId, maxLength: MAX_CONVERSATION_TITLE_LENGTH, value: draft, onChange: (event) => setDraft(event.currentTarget.value), onBlur: () => { void finish(); }, onKeyDown: (event) => {

package/dist/react/components/ExtEventErrorBoundary.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { formatErrorForLog } from '@jini-ai/core';
 /**
  * @module ExtEventErrorBoundary
  *
@@ -25,7 +26,7 @@ export class ExtEventErrorBoundary extends Component {
         // React already surfaces this in the dev console via its own error-boundary reporting; this
         // adds the ext-event `name` React's generic report has no way to know, and gives a host a
         // hook to route it into its own error reporting.
-        console.error(`[ExtEventErrorBoundary] ext event "${this.props.name}" failed to render:`, error);
+        console.error(`[ExtEventErrorBoundary] ext event "${this.props.name}" failed to render:`, formatErrorForLog({ error }));
         this.props.onError?.(error, info);
     }
     render() {

package/dist/react/components/McpUiSurfaceCard.js

@@ -71,6 +71,7 @@ import { useT } from '../hooks/context.js';
 import { useSurfaceExpiry } from '../hooks/useSurfaceExpiry.js';
 import { closedSurfaceLabel, reportDeliveredAnswer } from './mcp-ui-surface-state.js';
 import { surfaceQuestionInput } from './mcp-ui-question-input.js';
+import { useSurfaceRecovery } from '../hooks/useSurfaceRecovery.js';
 /** The `kind: 'ext'` event name this renderer claims. */
 export const MCP_UI_EXT_EVENT_NAME = 'mcp-ui';
 /** Collapses the event stream to the newest resource per `ui://` URI, in first-appearance order. */
@@ -147,18 +148,24 @@ function surfaceInteraction({ resource, answered, onToolCall, onAnswered, onAnsw
 /** Registered against `ext-event-renderer-registry.ts`'s `'mcp-ui'` name — see module doc. */
 export function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall, onOpenLink, maxHeight, call, runStreaming, expiryClock, answered, onAnswered, onAnswerText, answerText, answerRecorded }) {
     const t = useT();
-    const resources = useMemo(() => latestResourcesByUri(events), [events]);
+    const originalResources = useMemo(() => latestResourcesByUri(events), [events]);
+    const recovery = useSurfaceRecovery({ resource: originalResources.length === 1 ? originalResources[0] : undefined,
+        call, runStreaming, onToolCall });
+    const resources = recovery.restored && recovery.resource ? [recovery.resource] : originalResources;
     // One card per slot is the registered shape (`mcpUiSurfaceSlotKey`), so `call` belongs to exactly
     // that card. A group holding several URIs has no single call to judge them by, and stays live.
     const single = resources.length === 1 ? resources[0] : undefined;
-    const { displayCall, input, standalone } = useSurfaceQuestionCall({ events, call });
-    const { expiresAtMs, toolCall } = surfaceInteraction({ resource: single, answered, onToolCall, onAnswered, onAnswerText, call: displayCall });
+    const currentEvents = recovery.restored && recovery.resource ? [recovery.resource] : events;
+    const currentCall = recovery.restored ? undefined : call;
+    const { displayCall, input, standalone } = useSurfaceQuestionCall({ events: currentEvents, call: currentCall });
+    const { expiresAtMs, toolCall } = surfaceInteraction({ resource: single, answered, onToolCall: recovery.onToolCall, onAnswered, onAnswerText, call: displayCall });
     const expiry = useSurfaceExpiry({ expiresAtMs }, expiryClock === undefined ? {} : { clock: expiryClock });
     const closed = single === undefined
         ? undefined
-        : closedSurfaceLabel({ t, call, runStreaming, documentsForUri: events.length, expired: expiry?.expired === true });
+        : closedSurfaceLabel({ t, call: currentCall, runStreaming: recovery.live || runStreaming,
+            documentsForUri: currentEvents.length, expired: expiry?.expired === true });
     // A completed call answered the original document; a replacement outcome or retry owns its view.
-    const answer = (events.length === 1 ? questionAnswerFromResult({ result: call?.result, input }) : undefined) ?? answerText;
+    const answer = (currentEvents.length === 1 ? questionAnswerFromResult({ result: currentCall?.result, input }) : undefined) ?? answerText;
     return _jsx(SurfaceCardContent, { resources: resources, single: single, answerRecorded: answerRecorded, answer: answer, closed: closed, call: displayCall, standalone: standalone, t: t, sandboxProxyUrl: sandboxProxyUrl, toolCall: toolCall, onOpenLink: onOpenLink, maxHeight: maxHeight, expiry: expiry });
 }
 /** A standalone form's call may lack the question; its current document supplies the title and

package/dist/react/components/ToolCard.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { formatErrorForLog } from '@jini-ai/core';
 const RUNNING_TITLE_CLASS = ' shimmer-text';
 /**
  * @module ToolCard
@@ -79,7 +80,7 @@ function renderRegistered({ use, card, registry }) {
             return node;
     }
     catch (err) {
-        console.error(`[ToolCard] custom renderer for "${use.name}" threw; falling back`, err);
+        console.error(`[ToolCard] custom renderer for "${use.name}" threw; falling back`, formatErrorForLog({ error: err }));
     }
     return undefined;
 }
@@ -124,7 +125,7 @@ function renderToolCardBody(args) {
  * The head every Jini/MCP/unknown tool row shares: status, "<Humanized Name>" (announced as
  * "Tool call · <Humanized Name>"), and the
  * target ({@link toolRowTarget}). One place, so a tool id the family table doesn't know (`content_post_update`,
- * `mcp__tovu__theme_list_files`) still reads as a label and never as its raw name and JSON args.
+ * `mcp__acme__theme_list_files`) still reads as a label and never as its raw name and JSON args.
  */
 function ToolRowHead({ name, input, result, runStreaming, runSucceeded }) {
     const t = useT();

package/dist/react/components/ToolCard.rules.js

@@ -48,7 +48,8 @@ function resultName(content) {
     const obj = parsed;
     if (isErrorResult(obj))
         return undefined;
-    const nested = Object.values(obj).filter((v) => v != null && typeof v === 'object' && !Array.isArray(v));
+    // The nested level gets the same error check: `{ result: { error, name: 'NotFoundError' } }` is still a failure.
+    const nested = Object.values(obj).filter((v) => v != null && typeof v === 'object' && !Array.isArray(v) && !isErrorResult(v));
     return firstReadable(obj, RESULT_NAME_KEYS) ?? nested.map((v) => firstReadable(v, RESULT_NAME_KEYS)).find(Boolean);
 }
 /** A batch member's own target: a readable string member, or an object member's summary key. O(k). */

package/dist/react/features/chat-pane/components/AgentRuntimePicker.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { pickerModelValue, pickerCatalogNote, pickerModelOptions, shortModelLabel } from '../model-options.js';
+import { friendlyModelLabel, pickerModelValue, pickerCatalogNote, pickerModelOptions, shortModelLabel } from '../model-options.js';
 import { useId } from 'react';
 import { createPortal } from 'react-dom';
 import { AgentIcon, RemixIcon, SearchableModelSelect } from '@jini-ai/ui';
@@ -62,9 +62,11 @@ function RuntimeAgentRow({ agent, active, noteId, onChange, agentIconBasePath, t
 function RuntimeBarMenus({ selectedAgent, value, onChange, modelLabel, t }) {
     if (!selectedAgent)
         return null;
-    const models = pickerModelOptions(selectedAgent);
+    // Raw catalog ids (an offline fallback list's rows) read as friendly names in the bar and its list.
+    const models = pickerModelOptions(selectedAgent).map((row) => ({ ...row, label: friendlyModelLabel({ label: row.label }) }));
     const efforts = selectedAgent.reasoningOptions ?? [];
-    return (_jsxs(_Fragment, { children: [models.length > 0 ? (_jsx(RuntimeDropUp, { label: t('Model'), valueLabel: modelLabel, 
+    const modelName = friendlyModelLabel({ label: modelLabel });
+    return (_jsxs(_Fragment, { children: [models.length > 0 ? (_jsx(RuntimeDropUp, { label: t('Model'), valueLabel: modelName, 
                 // The agent icon sits right beside it, so the bar drops the vendor word and caps the rest.
                 triggerLabel: shortModelLabel({ label: modelLabel, agentId: selectedAgent.id }), value: pickerModelValue(selectedAgent, value.model), options: models, note: pickerCatalogNote(selectedAgent, t), width: 260, onSelect: (model) => onChange({
                     agentId: value.agentId,

package/dist/react/features/chat-pane/create-mcp-ui-tool-caller.d.ts

@@ -34,7 +34,20 @@
  * single-use token minted into the dialog is what proves a human saw it. Adding a client-side
  * allow-list would suggest a protection that is not real.
  */
-import type { McpUiToolCallHandler } from '@jini-ai/ui/mcp-ui';
+import type { McpUiToolCall, McpUiToolCallHandler } from '@jini-ai/ui/mcp-ui';
+import type { SurfaceEmission } from '@jini-ai/core';
+import type { SurfaceRecoveryInfo } from '../../../core/surface-recovery.js';
+export interface SurfaceRecoveryCallbacks {
+    readonly onSurface: (emission: SurfaceEmission) => void;
+    readonly signal: AbortSignal;
+}
+/** Callable as before; lifecycle controllers can also restore without replaying browser input. */
+export type RecoverableMcpUiToolCaller = McpUiToolCallHandler & {
+    restore(required: SurfaceRecoveryInfo & SurfaceRecoveryCallbacks, options?: Record<string, never>): Promise<unknown>;
+    answer(required: {
+        call: McpUiToolCall;
+    } & SurfaceRecoveryCallbacks, options?: Record<string, never>): Promise<unknown>;
+};
 export interface CreateMcpUiToolCallerOptions {
     /**
      * Path appended to `baseUrl`. Defaults to `/api/mcp-ui/tool-calls`.
@@ -69,5 +82,5 @@ export interface McpUiToolCallRequest {
 export declare function createMcpUiToolCaller({ baseUrl, fetch }: {
     baseUrl: string;
     fetch: typeof globalThis.fetch;
-}, options?: CreateMcpUiToolCallerOptions): McpUiToolCallHandler;
+}, options?: CreateMcpUiToolCallerOptions): RecoverableMcpUiToolCaller;
 //# sourceMappingURL=create-mcp-ui-tool-caller.d.ts.map

package/dist/react/features/chat-pane/create-mcp-ui-tool-caller.js

@@ -1,3 +1,4 @@
+import { readSurfaceRecoveryStream } from './surface-recovery-stream.js';
 const DEFAULT_PATH = '/api/mcp-ui/tool-calls';
 const DEFAULT_TIMEOUT_MS = 30_000;
 function errorTextFrom(body, status) {
@@ -35,7 +36,7 @@ function timeoutAware(error, timeoutMs) {
         : error;
 }
 /** One POST of a confirmed action and its parsed answer; a non-2xx response rejects via {@link errorFrom}. */
-async function postToolCall({ call, endpoint, headers, signal, fetch }) {
+async function postToolCall({ call, endpoint, headers, signal, fetch, onSurface, exchangeId, restore }) {
     // `{name, arguments}` on the MCP-UI side becomes `{toolName, params}` on the wire: `arguments`
     // is a reserved word in a JS function scope and reads badly in a server handler, and the
     // renamed pair matches what the reference implementation's redemption route already accepts.
@@ -48,9 +49,12 @@ async function postToolCall({ call, endpoint, headers, signal, fetch }) {
         // Same-origin cookie session is the usual authenticator for the human's second step.
         credentials: 'same-origin',
         headers: { ...headers, 'content-type': 'application/json' },
-        body: JSON.stringify(request),
+        body: JSON.stringify({ ...request, ...(restore ? { exchangeId, restore } : {}) }),
         signal,
     });
+    if (response.ok && response.headers.get('content-type')?.includes('application/x-ndjson')) {
+        return readSurfaceRecoveryStream({ response, onSurface });
+    }
     const raw = await response.text();
     let parsed = raw;
     if (raw.length > 0) {
@@ -83,12 +87,24 @@ export function createMcpUiToolCaller({ baseUrl, fetch }, options = {}) {
     const path = options.path ?? DEFAULT_PATH;
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const endpoint = `${baseUrl.replace(/\/$/u, '')}${path}`;
-    return async (call) => {
+    const answer = async (call) => {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
         return postToolCall({ call, endpoint, headers: options.headers, signal: controller.signal, fetch })
             .catch((error) => { throw timeoutAware(error, timeoutMs); })
             .finally(() => clearTimeout(timer));
     };
+    return Object.assign(answer, {
+        // Recovery streams deliberately have no reading-time deadline. The controller cancels on
+        // unmount; the server's executing-call lease handles run cancellation independently.
+        restore: (required) => postToolCall({
+            call: { name: required.toolId, arguments: {} }, endpoint, headers: options.headers, fetch,
+            signal: required.signal, onSurface: required.onSurface, exchangeId: required.exchangeId, restore: true,
+        }),
+        answer: (required) => postToolCall({
+            call: required.call, endpoint, headers: options.headers, fetch,
+            signal: required.signal, onSurface: required.onSurface,
+        }),
+    });
 }
 //# sourceMappingURL=create-mcp-ui-tool-caller.js.map

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.js

@@ -262,6 +262,20 @@ export function useChatPane(options) {
         queued, next: { text: input.text, secretRedacted: input.secretRedaction?.secretRedacted ?? false,
             count: input.secretRedaction?.count ?? 0 },
     }), null), [queuedInputs]);
+    const releaseStateRef = useRef({ streaming: conversation.isStreaming, queued: queuedInputs.length > 0 });
+    releaseStateRef.current = { streaming: conversation.isStreaming, queued: queuedInputs.length > 0 };
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const onReleaseCheck = (event) => {
+            const { streaming, queued } = releaseStateRef.current;
+            // Read mutable operation locks at dispatch time, including the gap before React renders.
+            if (streaming || queued || activeUploadsRef.current.size > 0 || startingPromptRef.current || deliveringTypedAnswerRef.current)
+                event.preventDefault();
+        };
+        window.addEventListener('jini:release-check', onReleaseCheck);
+        return () => window.removeEventListener('jini:release-check', onReleaseCheck);
+    }, []);
     // Release consumed text/files locally as well as hiding them; next-turn fallback uses this same projection.
     useEffect(() => {
         if (queuedInputs.length !== storedQueuedInputs.length)

package/dist/react/features/chat-pane/hooks/useChatPaneFileDrop.hooks.js

@@ -1,3 +1,4 @@
+import { formatErrorForLog } from '@jini-ai/core';
 import { useCallback, } from 'react';
 import { useFileDropTarget } from '@jini-ai/ui';
 function carriesFiles(event) {
@@ -12,11 +13,11 @@ function runOnFilesHostEffect(onFiles, files) {
         result = onFiles(files);
     }
     catch (error) {
-        console.error('[@jini-ai/chat] useChatPaneFileDrop onFiles host effect failed:', error);
+        console.error('[@jini-ai/chat] useChatPaneFileDrop onFiles host effect failed:', formatErrorForLog({ error }));
         return;
     }
     void Promise.resolve(result).catch((error) => {
-        console.error('[@jini-ai/chat] useChatPaneFileDrop onFiles host effect failed:', error);
+        console.error('[@jini-ai/chat] useChatPaneFileDrop onFiles host effect failed:', formatErrorForLog({ error }));
     });
 }
 /**

package/dist/react/features/chat-pane/hooks/useRuntimeDropUp.hooks.js

@@ -100,13 +100,30 @@ export function useRuntimeDropUp({ width }) {
         const checked = menu?.querySelector(`${MENU_ITEMS}[aria-checked="true"]`);
         (checked ?? menu?.querySelector(MENU_ITEMS))?.focus();
     }, [open, position]);
+    // Escape is also handled here, on the menu and the trigger themselves: the document listener
+    // above never hears a keydown that something between them and the document stopped (demo
+    // practice run, 2026-11-02: Escape left the model picker open). preventDefault marks it consumed,
+    // so a host's own Escape (the admin dock closing) leaves this press to the menu.
+    const closeOnOwnEscape = useCallback((event) => {
+        if (event.key !== 'Escape')
+            return false;
+        event.preventDefault();
+        closeToTrigger();
+        return true;
+    }, [closeToTrigger]);
     const handleTriggerKeyDown = useCallback((event) => {
-        if (open || (event.key !== 'ArrowUp' && event.key !== 'ArrowDown'))
+        if (open) {
+            closeOnOwnEscape(event);
+            return;
+        }
+        if (event.key !== 'ArrowUp' && event.key !== 'ArrowDown')
             return;
         event.preventDefault();
         setOpen(true);
-    }, [open]);
+    }, [closeOnOwnEscape, open]);
     const handleMenuKeyDown = useCallback((event) => {
+        if (closeOnOwnEscape(event))
+            return;
         if (event.key === 'Tab') {
             setOpen(false);
             return;
@@ -123,7 +140,7 @@ export function useRuntimeDropUp({ width }) {
             return;
         event.preventDefault();
         items[next]?.focus();
-    }, []);
+    }, [closeOnOwnEscape]);
     const choose = useCallback((apply) => {
         apply();
         closeToTrigger();

package/dist/react/features/chat-pane/model-options.d.ts

@@ -12,6 +12,16 @@ export declare function configuredPickerModel(agent: ChatPaneAgent): string | un
 export declare function pickerModelLabel(agent: ChatPaneAgent | undefined, requested?: string, t?: I18nAdapter['t']): string;
 export declare function pickerModelValue(agent: ChatPaneAgent, requested?: string): string;
 export declare function pickerCatalogNote(agent: ChatPaneAgent, t?: I18nAdapter['t']): string | undefined;
+/**
+ * A catalog row's display name: a bare raw id ("claude-opus-5-5", which offline fallback lists carry)
+ * reads as "Claude Opus 5.5"; a human label is kept as written. Still exact: a date or context suffix
+ * stays, and a routed id ("anthropic/…") is left whole, since its prefix names a different model.
+ * @example friendlyModelLabel({ label: 'claude-haiku-4-5-20251001' }) // "Claude Haiku 4.5 20251001"
+ * @complexity O(n) in the label length. Pure.
+ */
+export declare function friendlyModelLabel({ label }: {
+    label: string;
+}, _options?: Record<string, never>): string;
 /**
  * The composer bar's compact model name: the catalog label (or a prettified raw id when the catalog
  * has no label), minus the leading vendor word the agent's icon already conveys, capped with "…".

package/dist/react/features/chat-pane/model-options.js

@@ -35,6 +35,10 @@ export function pickerCatalogNote(agent, t = passthrough) {
     const catalog = agent.modelCatalog;
     if (catalog?.freshness === 'stale')
         return `${t('Cached')} · ${catalog.fetchedAt}`;
+    // While the host is still probing, the live list has not failed yet: the rows are the
+    // cached/fallback list the inventory contract says to show meanwhile, not an offline verdict.
+    if (agent.discoveryPending)
+        return undefined;
     if (catalog?.freshness === 'offline-fallback' || !catalog && agent.models)
         return t('Offline fallback');
     return undefined;
@@ -49,21 +53,36 @@ const BAR_VENDOR_WORDS = {
 // A bare catalog id ("claude-opus-5-5", "gpt-6-astra[1m]", "anthropic/claude-sonnet-5") rather than a display name.
 const RAW_MODEL_ID = /^(?:[a-z0-9._-]+\/)*[a-z0-9][a-z0-9._-]*(?:\[[^\]]*\])?$/;
 const BRAND_CASING = { gpt: 'GPT' };
-function prettifyRawModelId(id) {
+function prettifyRawModelId(id, { keepDates = false } = {}) {
     // A routing prefix ("anthropic/") is the full name's job; the bar names only the model.
     // The caller proved RAW_MODEL_ID, so the first '[' can only start its trailing context suffix.
-    const tokens = id.slice(id.lastIndexOf('/') + 1).split('[', 1)[0].split(/[-_]+/).filter((token) => token && !/^\d{8}$/.test(token));
+    const tokens = id.slice(id.lastIndexOf('/') + 1).split('[', 1)[0].split(/[-_]+/).filter((token) => token && (keepDates || !/^\d{8}$/.test(token)));
     const words = [];
     for (const token of tokens) {
         const previous = words[words.length - 1];
         // Dash-separated version digits read as one dotted version: "5-5" → "5.5".
-        if (/^\d+$/.test(token) && previous && /^\d+(?:\.\d+)*$/.test(previous))
+        // A kept 8-digit date stays its own word, never a version part.
+        if (/^\d{1,7}$/.test(token) && previous && /^\d+(?:\.\d+)*$/.test(previous))
             words[words.length - 1] = `${previous}.${token}`;
         else
             words.push(BRAND_CASING[token] ?? token.charAt(0).toUpperCase() + token.slice(1));
     }
     return words;
 }
+/**
+ * A catalog row's display name: a bare raw id ("claude-opus-5-5", which offline fallback lists carry)
+ * reads as "Claude Opus 5.5"; a human label is kept as written. Still exact: a date or context suffix
+ * stays, and a routed id ("anthropic/…") is left whole, since its prefix names a different model.
+ * @example friendlyModelLabel({ label: 'claude-haiku-4-5-20251001' }) // "Claude Haiku 4.5 20251001"
+ * @complexity O(n) in the label length. Pure.
+ */
+export function friendlyModelLabel({ label }, _options = {}) {
+    if (!RAW_MODEL_ID.test(label) || label.includes('/'))
+        return label;
+    const suffix = label.indexOf('[');
+    const words = prettifyRawModelId(label, { keepDates: true }).join(' ');
+    return suffix === -1 ? words : `${words} ${label.slice(suffix)}`;
+}
 /**
  * The composer bar's compact model name: the catalog label (or a prettified raw id when the catalog
  * has no label), minus the leading vendor word the agent's icon already conveys, capped with "…".