@jini-ai/chat 0.3.11 → 0.5.1

package/dist/embed-widget/transports/fetch-sse.js

@@ -0,0 +1,175 @@
+/** Default JSON wire request is an explicit host choice, never a hidden endpoint default. O(history). */
+export function buildJsonChatRequest({ message, history }) {
+    return { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ message, history }) };
+}
+/** Maps the text/error/end/directive JSON protocol with required directive vocabulary and copy. O(data). */
+export function mapJsonChatSseFrame({ frame, directiveEventName, streamError }) {
+    if (!frame.data)
+        return {};
+    const data = JSON.parse(frame.data);
+    const obj = typeof data === 'object' && data !== null ? data : {};
+    if (frame.event === 'text') {
+        if (typeof obj.delta !== 'string')
+            throw new Error('Invalid text frame');
+        return { event: { kind: 'text', text: obj.delta } };
+    }
+    if (frame.event === 'error')
+        return { error: new Error(typeof obj.message === 'string' && obj.message ? obj.message : streamError) };
+    if (frame.event === 'end')
+        return { done: true };
+    if (frame.event === directiveEventName)
+        return { event: { kind: 'ext', name: directiveEventName, data } };
+    return {};
+}
+async function* responseChunks(body, signal) {
+    const reader = body.getReader();
+    const cancel = () => { void reader.cancel().catch(() => { }); };
+    signal.addEventListener('abort', cancel, { once: true });
+    if (signal.aborted)
+        cancel();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            yield value;
+        }
+    }
+    finally {
+        signal.removeEventListener('abort', cancel);
+        try {
+            await reader.cancel();
+        }
+        catch { /* Already closed or aborted. */ }
+        reader.releaseLock();
+    }
+}
+/**
+ * Creates a cancellable, one-POST-per-run transport with no reattachable server state.
+ * Uses the host-bound SSE decoder rather than implementing another parser. Every run
+ * owns its controller, listeners and event log; cancellation and end settle once and
+ * prevent late events. Input and cancelSignal aborts release readers/listeners, and frames after
+ * end cannot mutate the settled reply. A later settlement clears an earlier pending directive.
+ * Default request bytes retain the {message, history} wire shape; a host requestBuilder may carry
+ * required agent identity differently. No browser module imports a Node-backed runtime barrel.
+ * The returned positional methods implement the existing ChatTransport.
+ * @complexity O(history + streamed bytes + emitted events); O(emitted events + decoder buffer) space.
+ */
+export function createFetchSseTransport(args, options = {}) {
+    for (const limit of [args.maxHistoryMessages, args.maxHistoryMessageChars]) {
+        if (!Number.isSafeInteger(limit) || limit < 0)
+            throw new Error('Invalid history limit');
+    }
+    if (!args.endpoint || !args.agentId)
+        throw new Error('Endpoint and agent identity are required');
+    const activeRuns = new Map();
+    const observe = (runId, phase) => {
+        try {
+            options.onLifecycle?.({ runId, phase });
+        }
+        catch { /* Telemetry cannot break a run. */ }
+    };
+    return {
+        async startRun(input, handlers) {
+            let latestIndex = input.history.length - 1;
+            while (latestIndex >= 0 && input.history[latestIndex]?.role !== 'user')
+                latestIndex -= 1;
+            const message = input.history[latestIndex]?.content;
+            if (!message)
+                throw new Error(args.copy.noUserMessage);
+            const history = (args.maxHistoryMessages === 0 ? [] : input.history.slice(Math.max(0, latestIndex - args.maxHistoryMessages), latestIndex))
+                .filter(m => m.content.trim().length > 0)
+                .map(m => ({ role: m.role, content: m.content.slice(0, args.maxHistoryMessageChars) }));
+            // Build before registering a run, so a synchronous host-builder failure leaks no state.
+            const request = args.requestBuilder({ endpoint: args.endpoint, agentId: args.agentId, message, history, input });
+            const runId = args.ids({});
+            if (!runId || activeRuns.has(runId))
+                throw new Error('Run ID must be unique and nonempty');
+            const controller = options.createAbortController?.({}) ?? new AbortController();
+            activeRuns.set(runId, controller);
+            const collected = [];
+            let settled = false;
+            const signals = [input.signal, ...(input.cancelSignal ? [input.cancelSignal] : [])];
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                activeRuns.delete(runId);
+                for (const signal of signals)
+                    signal.removeEventListener('abort', abort);
+                controller.signal.removeEventListener('abort', onAborted);
+                observe(runId, 'settled');
+                handlers.onDone([...collected]);
+            };
+            const onAborted = () => { observe(runId, 'aborted'); finish(); };
+            const abort = () => controller.abort();
+            controller.signal.addEventListener('abort', onAborted, { once: true });
+            for (const signal of signals)
+                signal.addEventListener('abort', abort, { once: true });
+            observe(runId, 'started');
+            if (signals.some(signal => signal.aborted))
+                abort();
+            void (async () => {
+                try {
+                    if (settled)
+                        return;
+                    const response = await args.fetch(args.endpoint, { ...request, signal: controller.signal });
+                    if (settled) {
+                        try {
+                            await response.body?.cancel();
+                        }
+                        catch { /* closed body */ }
+                        return;
+                    }
+                    if (!response.ok) {
+                        const body = await response.json().catch(() => null);
+                        if (settled)
+                            return;
+                        const error = typeof body === 'object' && body !== null && 'error' in body && typeof body.error === 'string' && body.error
+                            ? body.error : args.copy.requestFailed({ status: response.status });
+                        observe(runId, 'error');
+                        handlers.onError(new Error(error));
+                        return;
+                    }
+                    if (!response.body)
+                        throw new Error(args.copy.missingBody);
+                    for await (const frame of args.decode({ source: responseChunks(response.body, controller.signal) })) {
+                        if (settled)
+                            break;
+                        const result = args.frameMapper({ frame });
+                        if (result.event) {
+                            collected.push(result.event);
+                            handlers.onEvent(result.event);
+                        }
+                        if (settled)
+                            break;
+                        if (result.error) {
+                            observe(runId, 'error');
+                            handlers.onError(result.error);
+                        }
+                        if (settled)
+                            break;
+                        if (result.done) {
+                            finish();
+                            break;
+                        }
+                    }
+                }
+                catch (error) {
+                    if (!settled && !controller.signal.aborted) {
+                        observe(runId, 'error');
+                        handlers.onError(error instanceof Error ? error : new Error(String(error)));
+                    }
+                }
+                finally {
+                    finish();
+                }
+            })();
+            return { runId };
+        },
+        async reattachRun(_runId, handlers) { handlers.onDone([]); },
+        async fetchRunStatus() { return null; },
+        async stopRun(runId) { activeRuns.get(runId)?.abort(); },
+    };
+}
+//# sourceMappingURL=fetch-sse.js.map

package/dist/react/agent-bridge/frontend-session-bridge.d.ts

@@ -1,8 +1,6 @@
 import { type PageDriver } from '@jini-ai/agentic';
 import type { ChatPaneAgentBridgeAccess, ChatPaneAgentToolAction } from '../features/chat-pane/types.js';
 export interface FrontendSessionBridgeOptions {
-    /** Daemon origin. Defaults to same-origin, which is how the dev server proxies `/api`. */
-    readonly baseUrl?: string;
     /** Supplying one claims the six `page.*` verbs. Omit for a chat-only surface. */
     readonly pageDriver?: PageDriver;
     /**
@@ -15,6 +13,20 @@ export interface FrontendSessionBridgeOptions {
     /** Reported for failures that are nobody's tool call: stream errors, malformed frames. */
     readonly onError?: (error: unknown) => void;
 }
+/** The host supplies its origin and stream transport; native fetch defaults may be overridden. */
+export interface FrontendSessionBridgeArgs {
+    /** Pass an empty string for the same-origin proxy used by a browser host. */
+    readonly baseUrl: string;
+    readonly openStream: (args: {
+        url: string;
+    }) => EventSource;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly request?: (args: {
+        url: string;
+        init: RequestInit;
+        timeoutMs: number;
+    }) => Promise<Response>;
+}
 export interface FrontendSessionBridge {
     /** Hand this to `ChatPane`'s `agentControl.bridgeAccess`. */
     readonly bridgeAccess: ChatPaneAgentBridgeAccess;
@@ -41,5 +53,5 @@ export interface FrontendSessionBridge {
  * @param options - What this page can serve and where the daemon is.
  * @returns The pane's bridge, the attach result, and a teardown.
  */
-export declare function createFrontendSessionBridge(options?: FrontendSessionBridgeOptions): FrontendSessionBridge;
+export declare function createFrontendSessionBridge({ baseUrl: base, openStream, request, fetch }: FrontendSessionBridgeArgs, options?: FrontendSessionBridgeOptions): FrontendSessionBridge;
 //# sourceMappingURL=frontend-session-bridge.d.ts.map

package/dist/react/agent-bridge/frontend-session-bridge.js

@@ -34,7 +34,6 @@
  *   {@link FrontendSessionBridge.bindToken} answers "what is valid now", and only the latter
  *   belongs in a run request.
  */
-import { FETCH_TIMEOUT_MS, fetchWithTimeout } from '@jini-ai/platform/fetch-with-timeout';
 import { CHAT_CAPABILITIES } from '../../core/index.js';
 import { PAGE_CAPABILITIES, executePageCapability } from '@jini-ai/agentic';
 /** How many settled invocation ids to remember for replay suppression. */
@@ -59,9 +58,13 @@ function errorMessage(error) {
  * @param options - What this page can serve and where the daemon is.
  * @returns The pane's bridge, the attach result, and a teardown.
  */
-export function createFrontendSessionBridge(options = {}) {
-    const base = options.baseUrl ?? '';
+export function createFrontendSessionBridge({ baseUrl: base, openStream, request, fetch }, options = {}) {
     const capabilities = claimedCapabilities(options);
+    const send = request ?? (({ url, init, timeoutMs }) => {
+        const timeout = AbortSignal.timeout(timeoutMs);
+        const signal = init.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
+        return (fetch ?? globalThis.fetch)(url, { ...init, signal });
+    });
     let sessionId;
     /** Replaced on every reattach; a promise resolved once could never carry this. */
     let currentBindToken;
@@ -79,11 +82,15 @@ export function createFrontendSessionBridge(options = {}) {
     /** Invocation ids already run here, so a stream reconnect cannot double-click a button. */
     const executed = new Set();
     const query = capabilities.map((id) => `capability=${encodeURIComponent(id)}`).join('&');
-    const source = new EventSource(`${base}/api/frontend-sessions/stream?${query}`);
+    const source = openStream({ url: `${base}/api/frontend-sessions/stream?${query}` });
     async function respond(invocationId, body) {
         if (sessionId === undefined)
             throw new Error('the surface is not attached yet');
-        const response = await fetchWithTimeout(`${base}/api/frontend-sessions/${encodeURIComponent(sessionId)}/responses`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ invocationId, ...body }) }, { timeoutMs: FETCH_TIMEOUT_MS.QUICK });
+        const response = await send({
+            url: `${base}/api/frontend-sessions/${encodeURIComponent(sessionId)}/responses`,
+            init: { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ invocationId, ...body }) },
+            timeoutMs: 15_000,
+        });
         if (!response.ok)
             throw new Error(`answering "${invocationId}" failed: ${response.status}`);
     }
@@ -94,7 +101,7 @@ export function createFrontendSessionBridge(options = {}) {
         let output;
         try {
             if (options.pageDriver !== undefined && action.capabilityId.startsWith('page.')) {
-                output = await executePageCapability(options.pageDriver, action.capabilityId, action.input);
+                output = await executePageCapability({ driver: options.pageDriver, capabilityId: action.capabilityId, input: action.input });
             }
             else {
                 const entry = Object.entries(options.executors ?? {})

package/dist/react/artifact-types.d.ts

@@ -42,8 +42,8 @@ export interface ArtifactRenderMatch {
     file: ArtifactFile;
 }
 /**
- * A minimal ordered registry of `ArtifactRenderer`s: first-registered,
- * first-matched (later registrations can still override by registering
+ * A minimal ordered registry of `ArtifactRenderer`s: newest-registered,
+ * first-matched (later registrations override earlier matches by registering
  * before resolution, mirroring the tool-renderer registry's "last writer
  * wins on the same id" convention is intentionally NOT used here — artifact
  * renderers are matched by predicate, not by name, so ordering is the
@@ -53,7 +53,7 @@ export declare class RendererRegistry {
     private readonly renderers;
     /** Registers `renderer`, returning an unregister handle. */
     register(renderer: ArtifactRenderer): () => void;
-    /** The first registered renderer whose `canRender` accepts `ctx`, or `null`. */
+    /** The newest registered renderer whose `canRender` accepts `ctx`, or `null`. */
     resolve(ctx: ArtifactRenderContext): ArtifactRenderMatch | null;
     /** Visible mainly for tests. */
     list(): readonly ArtifactRenderer[];

package/dist/react/artifact-types.js

@@ -1,6 +1,6 @@
 /**
- * A minimal ordered registry of `ArtifactRenderer`s: first-registered,
- * first-matched (later registrations can still override by registering
+ * A minimal ordered registry of `ArtifactRenderer`s: newest-registered,
+ * first-matched (later registrations override earlier matches by registering
  * before resolution, mirroring the tool-renderer registry's "last writer
  * wins on the same id" convention is intentionally NOT used here — artifact
  * renderers are matched by predicate, not by name, so ordering is the
@@ -17,7 +17,7 @@ export class RendererRegistry {
                 this.renderers.splice(idx, 1);
         };
     }
-    /** The first registered renderer whose `canRender` accepts `ctx`, or `null`. */
+    /** The newest registered renderer whose `canRender` accepts `ctx`, or `null`. */
     resolve(ctx) {
         for (const renderer of this.renderers) {
             if (renderer.canRender(ctx))

package/dist/react/components/A2uiSurfaceCard.js

@@ -32,12 +32,16 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
  * surfaces as a visible, honest notice instead of vanishing or hitting the wrong endpoint.
  */
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { createA2uiInterpreter, createLabCatalog } from '@jini-ai/agentic/a2ui';
+import { createA2uiInterpreter, createLabCatalog, DynamicValueSchema } from '@jini-ai/agentic/a2ui';
+import { createSystemClock } from '@jini-ai/core/primitives';
 import { buildA2uiCatalogFromRegistry } from '@jini-ai/ui/a2ui';
 import { DEFAULT_INTERACTIVE_UI_REGISTRY } from '@jini-ai/ui/interactive-ui';
 import { useT } from '../hooks/context.js';
 /** Every agent→renderer message shape carries `surfaceId` under exactly one of these keys. */
 const SURFACE_ID_KEYS = ['createSurface', 'updateComponents', 'updateDataModel', 'deleteSurface'];
+// Preserve the interpreter's former module-wide sequence so separate cards cannot reuse an
+// action ID in the same millisecond; the wall-clock suffix keeps the existing wire format.
+let actionIdCounter = 0;
 function extractSurfaceId(message) {
     if (typeof message !== 'object' || message === null)
         return undefined;
@@ -54,7 +58,7 @@ function RenderComponent({ interpreter, surfaceId, componentId, ancestors, onAct
     if (ancestors.has(componentId)) {
         return (_jsxs("span", { className: "a2ui-placeholder a2ui-placeholder-cycle", "data-a2ui-status": "cycle", "data-a2ui-component-id": componentId, children: ["\u27F2 circular reference at \u201C", componentId, "\u201D"] }));
     }
-    const surface = interpreter.getSurface(surfaceId);
+    const surface = interpreter.getSurface({ surfaceId });
     const component = surface?.components.get(componentId);
     if (!component) {
         return (_jsxs("span", { className: "a2ui-placeholder a2ui-placeholder-missing", "data-a2ui-status": "missing", "data-a2ui-component-id": componentId, children: ["\u26A0 missing component \u201C", componentId, "\u201D"] }));
@@ -63,7 +67,9 @@ function RenderComponent({ interpreter, surfaceId, componentId, ancestors, onAct
     nextAncestors.add(componentId);
     const childProps = { interpreter, surfaceId, ancestors: nextAncestors, onAction };
     function resolveText(value) {
-        const result = interpreter.resolve(surfaceId, value);
+        // Text props already passed the catalog schema. Parsing preserves that wire type at this
+        // Record<string, unknown> boundary without asserting a shape the compiler cannot verify.
+        const result = interpreter.resolve({ surfaceId, value: DynamicValueSchema.parse(value) });
         if (!result.ok)
             return `⚠ unresolved (${result.reason})`;
         return typeof result.value === 'string' ? result.value : JSON.stringify(result.value);
@@ -104,7 +110,7 @@ function RenderComponent({ interpreter, surfaceId, componentId, ancestors, onAct
             // `buildA2uiCatalogFromRegistry` call below. Resolved against the SAME registry
             // `@jini-ai/ui`'s own `A2uiSurfaceRenderer` uses, so a type addable to the catalog and
             // renderable there is addable and renderable here too.
-            const entry = DEFAULT_INTERACTIVE_UI_REGISTRY.resolveById(component.component);
+            const entry = DEFAULT_INTERACTIVE_UI_REGISTRY.resolveById({ id: component.component });
             if (!entry) {
                 return (_jsxs("span", { className: "a2ui-placeholder", "data-a2ui-status": "unrenderable-type", children: ["\u26A0 no renderer yet for component type \u201C", component.component, "\u201D"] }));
             }
@@ -137,15 +143,26 @@ export function A2uiSurfaceCard({ events, runId, onAgentAction }) {
     const t = useT();
     // Merges `DEFAULT_INTERACTIVE_UI_REGISTRY` (shadcn/recharts) into the lab catalog, keyed under
     // the SAME `catalogId` the lab catalog already uses — so a tool built against
-    // `createLabCatalog().catalogId` (e.g. `demo-a2ui-tool.ts`) still validates unchanged, and now
+    // `createLabCatalog({}).catalogId` (e.g. `demo-a2ui-tool.ts`) still validates unchanged, and now
     // ALSO gains every registry component as a real, addable/removable catalog entry.
     const catalog = useMemo(() => {
-        const base = createLabCatalog();
-        return buildA2uiCatalogFromRegistry(DEFAULT_INTERACTIVE_UI_REGISTRY, base.catalogId, { base });
+        const base = createLabCatalog({});
+        return buildA2uiCatalogFromRegistry({ registry: DEFAULT_INTERACTIVE_UI_REGISTRY, catalogId: base.catalogId }, { base });
     }, []);
     const interpreterRef = useRef(null);
-    if (!interpreterRef.current)
-        interpreterRef.current = createA2uiInterpreter(catalog);
+    if (!interpreterRef.current) {
+        const clock = createSystemClock();
+        interpreterRef.current = createA2uiInterpreter({
+            catalog,
+            clock,
+            ids: {
+                next: (_required) => {
+                    actionIdCounter += 1;
+                    return `a2ui-action-${actionIdCounter}-${clock.nowMs().toString(36)}`;
+                },
+            },
+        });
+    }
     const interpreter = interpreterRef.current;
     const [, forceRender] = useState(0);
     const appliedCountRef = useRef(0);
@@ -157,7 +174,11 @@ export function A2uiSurfaceCard({ events, runId, onAgentAction }) {
     const [pendingAgentAction, setPendingAgentAction] = useState(null);
     const [localActionResult, setLocalActionResult] = useState(null);
     const [deliveryFailureNotice, setDeliveryFailureNotice] = useState(null);
-    useEffect(() => interpreter.subscribe(() => forceRender((n) => n + 1)), [interpreter]);
+    useEffect(() => {
+        const unsubscribe = interpreter.subscribe({ listener: () => forceRender((n) => n + 1) });
+        // React invokes cleanup with no arguments; the interpreter's port takes a required bag.
+        return () => unsubscribe({});
+    }, [interpreter]);
     useEffect(() => {
         while (appliedCountRef.current < events.length) {
             const message = events[appliedCountRef.current];
@@ -165,7 +186,7 @@ export function A2uiSurfaceCard({ events, runId, onAgentAction }) {
             const surfaceId = extractSurfaceId(message);
             if (surfaceId)
                 surfaceIdRef.current = surfaceId;
-            const result = interpreter.applyAgentMessage(message);
+            const result = interpreter.applyAgentMessage({ raw: message });
             if (result.unattributedViolation) {
                 setRefusalNotice(result.unattributedViolation);
             }
@@ -200,13 +221,13 @@ export function A2uiSurfaceCard({ events, runId, onAgentAction }) {
         // the same way `handleAction`'s own (non-effect) call site already gets one on every render.
     }, [events, interpreter, onAgentAction, runId]);
     const surfaceId = surfaceIdRef.current;
-    const root = surfaceId ? interpreter.getRoot(surfaceId) : undefined;
+    const root = surfaceId ? interpreter.getRoot({ surfaceId }) : undefined;
     function handleAction(componentId) {
         // `surfaceId` is non-null here by construction, not by luck: this callback is only ever reached
         // from a `Button` inside the rendered tree, and nothing renders until `root` resolves — which
         // the `!root` early return below only permits when `surfaceId` was already truthy. Asserted
         // rather than re-checked, exactly as the `RenderComponent` call site below already does.
-        const built = interpreter.buildAction(surfaceId, componentId);
+        const built = interpreter.buildAction({ surfaceId: surfaceId, componentId });
         if (!built.ok) {
             setRefusalNotice(built.reason);
             return;

package/dist/react/components/AttachmentPreviewModal.hooks.d.ts

@@ -42,7 +42,9 @@ export type AttachmentPreviewStatus = 'image' | 'text' | 'unsupported';
 /** Hard cap on rendered text-preview characters, so a large attached log/CSV cannot hang the tab painting one giant `<pre>`. */
 export declare const MAX_TEXT_PREVIEW_CHARS = 200000;
 /** Exported for the component's own render branch, which needs the same answer without re-deriving it from `status`. */
-export declare function looksLikeImageAttachment(attachment: Pick<ChatAttachment, 'kind' | 'name'>): boolean;
+export declare function looksLikeImageAttachment({ attachment }: {
+    attachment: Pick<ChatAttachment, 'kind' | 'name'>;
+}): boolean;
 export interface AttachmentTextPreview {
     content: string;
     truncated: boolean;
@@ -66,5 +68,8 @@ export interface AttachmentPreviewController {
  * read on mount (bounded in practice by the upload route's own 20 MB per-attachment cap, and by
  * {@link MAX_TEXT_PREVIEW_CHARS} for what actually renders).
  */
-export declare function useAttachmentPreviewModal(attachment: ChatAttachment, onClose: () => void): AttachmentPreviewController;
+export declare function useAttachmentPreviewModal({ attachment, onClose }: {
+    attachment: ChatAttachment;
+    onClose: () => void;
+}): AttachmentPreviewController;
 //# sourceMappingURL=AttachmentPreviewModal.hooks.d.ts.map

package/dist/react/components/AttachmentPreviewModal.hooks.js

@@ -50,7 +50,7 @@ function extensionOf(name) {
     return dot === -1 ? '' : name.slice(dot + 1).toLowerCase();
 }
 /** Exported for the component's own render branch, which needs the same answer without re-deriving it from `status`. */
-export function looksLikeImageAttachment(attachment) {
+export function looksLikeImageAttachment({ attachment }) {
     return attachment.kind === 'image' || IMAGE_PREVIEW_EXTENSIONS.has(extensionOf(attachment.name));
 }
 function looksLikeTextAttachment(name) {
@@ -89,15 +89,15 @@ function canCreateObjectUrl() {
  * read on mount (bounded in practice by the upload route's own 20 MB per-attachment cap, and by
  * {@link MAX_TEXT_PREVIEW_CHARS} for what actually renders).
  */
-export function useAttachmentPreviewModal(attachment, onClose) {
+export function useAttachmentPreviewModal({ attachment, onClose }) {
     const dialogRef = useRef(null);
     const triggerRef = useRef(null);
     const [imageFailed, setImageFailed] = useState(false);
     const [imageUrl, setImageUrl] = useState(undefined);
     const [text, setText] = useState(undefined);
     const [textLoading, setTextLoading] = useState(false);
-    const cachedFile = getAttachmentPreviewSource(attachment.path);
-    const attemptImage = !imageFailed && cachedFile !== undefined && looksLikeImageAttachment(attachment) && canCreateObjectUrl();
+    const cachedFile = getAttachmentPreviewSource({ path: attachment.path });
+    const attemptImage = !imageFailed && cachedFile !== undefined && looksLikeImageAttachment({ attachment: attachment }) && canCreateObjectUrl();
     const attemptText = !attemptImage && cachedFile !== undefined && looksLikeTextAttachment(attachment.name);
     const status = attemptImage ? 'image' : attemptText ? 'text' : 'unsupported';
     // Object URL: created/revoked in an effect (not `useMemo`) so a React 18 Strict Mode double-render
@@ -192,7 +192,7 @@ export function useAttachmentPreviewModal(attachment, onClose) {
         onImageError: () => setImageFailed(true),
         textLoading,
         text,
-        sizeLabel: formatAttachmentSize(attachment.size),
+        sizeLabel: formatAttachmentSize({ size: attachment.size }),
         handleNativeCancel,
         handleBackdropClick,
     };

package/dist/react/components/AttachmentPreviewModal.js

@@ -12,7 +12,7 @@ import { Icon } from './Icon.js';
 import { looksLikeImageAttachment, useAttachmentPreviewModal } from './AttachmentPreviewModal.hooks.js';
 export function AttachmentPreviewModal({ attachment, onClose }) {
     const t = useT();
-    const c = useAttachmentPreviewModal(attachment, onClose);
-    return (_jsxs("dialog", { ref: c.dialogRef, className: "jini-attachment-preview-dialog", role: "dialog", "aria-modal": "true", "aria-label": t('{name} preview', { name: attachment.name }), onCancel: c.handleNativeCancel, onClick: c.handleBackdropClick, children: [_jsxs("div", { className: "jini-attachment-preview-header", children: [_jsx("span", { className: "jini-attachment-preview-name", title: attachment.name, children: attachment.name }), _jsx("button", { type: "button", className: "jini-attachment-preview-close", onClick: onClose, title: t('Close'), "aria-label": t('Close'), children: _jsx(Icon, { name: "close", size: 16 }) })] }), _jsx("div", { className: "jini-attachment-preview-body", children: c.status === 'image' && c.imageUrl ? (_jsx("img", { src: c.imageUrl, alt: attachment.name, className: "jini-attachment-preview-image", onError: c.onImageError })) : c.status === 'text' ? (c.textLoading ? (_jsx("div", { className: "jini-attachment-preview-loading", children: t('Loading…') })) : (_jsxs(_Fragment, { children: [_jsx("pre", { className: "jini-attachment-preview-text", children: c.text?.content ?? '' }), c.text?.truncated ? (_jsx("div", { className: "jini-attachment-preview-truncated", children: t('Preview truncated — this file is larger than the preview limit.') })) : null] }))) : (_jsxs("div", { className: "jini-attachment-preview-meta", children: [_jsxs("div", { className: "jini-attachment-preview-meta-row", children: [_jsx("span", { className: "jini-attachment-preview-meta-label", children: t('Name') }), _jsx("span", { children: attachment.name })] }), _jsxs("div", { className: "jini-attachment-preview-meta-row", children: [_jsx("span", { className: "jini-attachment-preview-meta-label", children: t('Type') }), _jsx("span", { children: looksLikeImageAttachment(attachment) ? t('Image') : t('File') })] }), c.sizeLabel ? (_jsxs("div", { className: "jini-attachment-preview-meta-row", children: [_jsx("span", { className: "jini-attachment-preview-meta-label", children: t('Size') }), _jsx("span", { children: c.sizeLabel })] })) : null, _jsx("div", { className: "jini-attachment-preview-meta-note", children: t('A preview is not available for this file.') })] })) })] }));
+    const c = useAttachmentPreviewModal({ attachment: attachment, onClose: onClose });
+    return (_jsxs("dialog", { ref: c.dialogRef, className: "jini-attachment-preview-dialog", role: "dialog", "aria-modal": "true", "aria-label": t('{name} preview', { name: attachment.name }), onCancel: c.handleNativeCancel, onClick: c.handleBackdropClick, children: [_jsxs("div", { className: "jini-attachment-preview-header", children: [_jsx("span", { className: "jini-attachment-preview-name", title: attachment.name, children: attachment.name }), _jsx("button", { type: "button", className: "jini-attachment-preview-close", onClick: onClose, title: t('Close'), "aria-label": t('Close'), children: _jsx(Icon, { name: "close", size: 16 }) })] }), _jsx("div", { className: "jini-attachment-preview-body", children: c.status === 'image' && c.imageUrl ? (_jsx("img", { src: c.imageUrl, alt: attachment.name, className: "jini-attachment-preview-image", onError: c.onImageError })) : c.status === 'text' ? (c.textLoading ? (_jsx("div", { className: "jini-attachment-preview-loading", children: t('Loading…') })) : (_jsxs(_Fragment, { children: [_jsx("pre", { className: "jini-attachment-preview-text", children: c.text?.content ?? '' }), c.text?.truncated ? (_jsx("div", { className: "jini-attachment-preview-truncated", children: t('Preview truncated — this file is larger than the preview limit.') })) : null] }))) : (_jsxs("div", { className: "jini-attachment-preview-meta", children: [_jsxs("div", { className: "jini-attachment-preview-meta-row", children: [_jsx("span", { className: "jini-attachment-preview-meta-label", children: t('Name') }), _jsx("span", { children: attachment.name })] }), _jsxs("div", { className: "jini-attachment-preview-meta-row", children: [_jsx("span", { className: "jini-attachment-preview-meta-label", children: t('Type') }), _jsx("span", { children: looksLikeImageAttachment({ attachment: attachment }) ? t('Image') : t('File') })] }), c.sizeLabel ? (_jsxs("div", { className: "jini-attachment-preview-meta-row", children: [_jsx("span", { className: "jini-attachment-preview-meta-label", children: t('Size') }), _jsx("span", { children: c.sizeLabel })] })) : null, _jsx("div", { className: "jini-attachment-preview-meta-note", children: t('A preview is not available for this file.') })] })) })] }));
 }
 //# sourceMappingURL=AttachmentPreviewModal.js.map

package/dist/react/components/AttachmentTray.d.ts

@@ -2,5 +2,7 @@ import type { AttachmentTraySlot } from '../slots.js';
 export type AttachmentTrayProps = AttachmentTraySlot;
 export declare function AttachmentTray({ attachments, onRemove, renderItem }: AttachmentTrayProps): import("react").JSX.Element | null;
 /** Formats optional byte counts for the compact composer attachment chip. */
-export declare function formatAttachmentSize(size: number | undefined): string | null;
+export declare function formatAttachmentSize({ size }: {
+    size: number | undefined;
+}): string | null;
 //# sourceMappingURL=AttachmentTray.d.ts.map

package/dist/react/components/AttachmentTray.js

@@ -8,11 +8,11 @@ export function AttachmentTray({ attachments, onRemove, renderItem }) {
     return (_jsx("div", { className: "jini-attachment-tray", "data-testid": "composer-attachment-tray", children: attachments.map((a) => (_jsxs("div", { className: "jini-attachment-chip", "data-testid": "attachment-chip", "data-attachment-kind": a.kind, "data-attachment-name": a.name, children: [renderItem ? renderItem(a) : _jsx(DefaultAttachmentChip, { attachment: a }), _jsx("button", { type: "button", className: "jini-attachment-remove", onClick: () => onRemove(a.path), title: t('Remove {name}', { name: a.name }), "aria-label": t('Remove {name}', { name: a.name }), children: _jsx(Icon, { name: "close", size: 12 }) })] }, a.path))) }));
 }
 function DefaultAttachmentChip({ attachment }) {
-    const size = formatAttachmentSize(attachment.size);
+    const size = formatAttachmentSize({ size: attachment.size });
     return (_jsxs("span", { className: "jini-attachment-chip-body", children: [_jsx("span", { className: `jini-attachment-chip-icon is-${attachment.kind}`, children: _jsx(Icon, { name: attachment.kind === 'image' ? 'image' : 'file', size: 15 }) }), _jsxs("span", { className: "jini-attachment-chip-copy", children: [_jsx("span", { className: "jini-attachment-chip-name", title: attachment.name, children: attachment.name }), size ? _jsx("small", { className: "jini-attachment-chip-size", children: size }) : null] })] }));
 }
 /** Formats optional byte counts for the compact composer attachment chip. */
-export function formatAttachmentSize(size) {
+export function formatAttachmentSize({ size }) {
     if (size === undefined || !Number.isFinite(size) || size < 0)
         return null;
     if (size < 1_024)

package/dist/react/components/ChatFab.js

@@ -8,7 +8,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
  */
 import { useChatFabDrag } from '../hooks/useChatFabDrag.js';
 export function ChatFab({ open, onToggle, label = 'chat' }) {
-    const { buttonRef, position, onPointerDown, onPointerMove, onPointerUp, onPointerCancel } = useChatFabDrag(onToggle);
+    const { buttonRef, position, onPointerDown, onPointerMove, onPointerUp, onPointerCancel } = useChatFabDrag({ onClick: onToggle });
     return (_jsx("button", { ref: buttonRef, type: "button", className: `chat-fab${open ? ' chat-fab-open' : ''}`, 
         // Not `onClick`: the pointer gesture already decides click-versus-drag, and keeping both
         // would fire the toggle twice on a tap.

package/dist/react/components/Composer.js

@@ -90,8 +90,8 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
     const resolvedPlaceholder = placeholder ?? t('Send a message…');
     const discoveryGroups = slots?.discoveryGroups ?? [];
     const hasDiscoveryItems = discoveryGroups.some((group) => group.items.length > 0);
-    const slashQuery = parseComposerSlashQuery(composer.draft);
-    const slashMatches = slashQuery === null ? [] : filterComposerDiscovery(discoveryGroups, slashQuery);
+    const slashQuery = parseComposerSlashQuery({ draft: composer.draft });
+    const slashMatches = slashQuery === null ? [] : filterComposerDiscovery({ groups: discoveryGroups, query: slashQuery });
     const slashOpen = slashMatches.length > 0 && dismissedSlashDraft !== composer.draft;
     /**
      * A bare "/" intentionally matches every item (`matchesFuzzyCommand`'s own doc) so the palette
@@ -167,14 +167,14 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
         function update() {
             const rect = composerRoot.getBoundingClientRect();
             if (discoveryMenuOpen)
-                setDiscoveryMenuPosition(composerDiscoveryMenuPosition(rect));
+                setDiscoveryMenuPosition(composerDiscoveryMenuPosition({ composerRect: rect }));
             if (slashOpen)
-                setSlashMenuPosition(composerSlashMenuPosition(rect));
+                setSlashMenuPosition(composerSlashMenuPosition({ composerRect: rect }));
             // Shares the discovery menu's own anchor math (same left inset off `.jini-composer`) rather
             // than measuring the working-dir button's own rect — one less measurement to keep in sync,
             // and the two popovers already never open at once (each is gated on its own trigger).
             if (workdirOpen)
-                setWorkdirPosition(composerDiscoveryMenuPosition(rect));
+                setWorkdirPosition(composerDiscoveryMenuPosition({ composerRect: rect }));
         }
         update();
         window.addEventListener('scroll', update, true);
@@ -222,7 +222,7 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
         const match = slashMatches[index];
         if (!match)
             return;
-        const resolution = resolveComposerSlashInvocation(composer.draft, match.item);
+        const resolution = resolveComposerSlashInvocation({ draft: composer.draft, item: match.item });
         if (!resolution)
             return;
         if (resolution.type === 'complete') {
@@ -235,7 +235,7 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
         }
         let expectedDraft = composer.draft;
         if (!match.item.command) {
-            expectedDraft = replaceComposerSlashTrigger(composer.draft, match.item.insertText ?? match.item.label);
+            expectedDraft = replaceComposerSlashTrigger({ draft: composer.draft, insertText: match.item.insertText ?? match.item.label });
             composer.setDraft(expectedDraft);
         }
         setDismissedSlashDraft(null);
@@ -243,7 +243,7 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
         restoreComposerFocus();
     }
     function selectPlusItem(item) {
-        const expectedDraft = item.insertText ? appendComposerDiscovery(composer.draft, item.insertText) : composer.draft;
+        const expectedDraft = item.insertText ? appendComposerDiscovery({ draft: composer.draft, insertText: item.insertText }) : composer.draft;
         if (item.insertText)
             composer.setDraft(expectedDraft);
         setDiscoveryMenuOpen(false);
@@ -271,7 +271,7 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
         if (event.nativeEvent.isComposing)
             return;
         if (slashOpen) {
-            const action = resolveComposerSlashKeyAction(event.key, event.shiftKey);
+            const action = resolveComposerSlashKeyAction({ key: event.key, shiftKey: event.shiftKey });
             if (action.type !== 'none') {
                 event.preventDefault();
                 if (action.type === 'move') {

package/dist/react/components/ConversationList.js

@@ -6,7 +6,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * into `ChatPane`'s `leadingAccessory` slot — it needs no changes to `ChatPane` itself.
  *
  * Storage-agnostic by construction. It takes data and callbacks and owns nothing durable, so a
- * host backs it with `@jini-ai/sqlite`'s `ChatHistoryStore`, an HTTP endpoint, or an in-memory
+ * host backs it with `@jini-ai/sqlite-chat`'s `ChatHistoryStore`, an HTTP endpoint, or an in-memory
  * array without this file knowing the difference.
  *
  * Search is a **client-side filter by default**, and delegates to `onSearch` when a host provides

package/dist/react/components/McpUiSurfaceCard.d.ts

@@ -29,10 +29,12 @@ export declare function McpUiSurfaceCard({ events, sandboxProxyUrl, onToolCall,
  * The ext-event slot key for MCP-UI: one slot per `ui://` URI. Each resource is its own card, so a
  * run's second card renders where it arrived instead of inside the first card's slot, while a
  * re-emitted resource with the same URI still updates its card in place. Pass it as
- * `registerExtEventRenderer(MCP_UI_EXT_EVENT_NAME, renderer, { slotKey: mcpUiSurfaceSlotKey })`
+ * `registerExtEventRenderer({ name: MCP_UI_EXT_EVENT_NAME, renderer }, { slotKey: mcpUiSurfaceSlotKey })`
  * when registering a custom MCP-UI renderer; {@link registerMcpUiSurfaceRenderer} already does.
  */
-export declare function mcpUiSurfaceSlotKey(data: unknown): string | undefined;
+export declare function mcpUiSurfaceSlotKey({ data }: {
+    data: unknown;
+}): string | undefined;
 /**
  * Registers {@link McpUiSurfaceCard} against the ext-event registry.
  *