@jini-ai/chat 0.5.2 → 0.5.4

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 0.5.4 — 2026-10-06
+
+- Prompt history in the composer: ↑ with the caret on the first line recalls earlier sent messages and ↓ on the last line walks forward; the first ↑ stashes the current draft (empty or not) and ↓ past the newest entry (or Escape) restores it exactly. Recalled entries are never mutated; consecutive duplicates collapse. New pure `createComposerHistoryState` / `transitionComposerHistory` / `composerHistoryKeyAction` / `mergeComposerHistory` / `normalizeComposerHistory` (core) and `createBrowserComposerHistoryStorage` (react, a `ComposerHistoryStoragePort` default). `useComposer`/`ChatPane` take `historyScope`, `historyStorage` and `historyMessages`.
+- Durable runs: new `recoveredRunEvents` (core) projects a recovered run's saved events so a continued answer completes the same message; a run notice shows only on a real resume.
+- Message attachments: the transport sends each message's own attachment refs, and attachment chips keep their kind across reloads.
+- Requires `@jini-ai/protocol` ^0.4.1.
+
+## 0.5.3 — 2026-10-06
+
+- New `createLastConversationStore({ scope }, { storage? })` (react): remembers one conversation id per caller identity under a versioned localStorage key (`jini.chat.last-conversation.v1.<scope>`); corrupt or foreign entries read as nothing remembered. Selection stays host-owned.
+- Restored staged attachments keep their upload batch: the draft cache records the batch id beside each conversation's attachment references, and `useChatPane` resumes that batch on mount and on a conversation switch, so a second attachment after a remount no longer fails the turn ("Attachments must belong to one batch").
+- A display-only A2UI surface (`surfaceProperties.displayOnly`, e.g. a drawn chart) no longer reads as "Waiting for your answer above".
+- A run held on an open form reads as waiting, not working: new `isAwaitingAnswer`, passed to ext event renderers as `awaitingAnswer`.
+- One row per delegated tool call: `isDelegatedWrapperToolName` covers both delegated gateways (bare or `mcp__<server>__`-prefixed) and `foldDelegatedWrapperCalls` drops a wrapper call once its canonical call exists (`useToolTimeline`, `ToolCard`).
+- Markdown: `[label](url)` links render (relative and parenthesized URLs, unsafe schemes kept as text, off-site links open in a new tab); intraword underscores never open or close emphasis.
+- A late scroll event no longer unsticks the transcript from the bottom; only a move up does.
+- Requires `@jini-ai/agentic` ^0.4.2 (`displayOnlySurfaceIdOf`).
+
 ## 0.5.2 — 2026-10-05
 
 - `useChatPane` holds a draft typed for a question that has since closed (answered elsewhere, expired, or refused with `'not-pending'`): `send` shows the `'not-pending'` notice instead of queueing it as a new paid run. Only clearing the draft or the new `sendAsNewMessage()` (the notice's "Send as a new message" button in `ChatPane`) lets it out as an ordinary turn. New pure `findAwaitedTypedAnswerId`.

package/dist/core/composer-history.d.ts

@@ -0,0 +1,54 @@
+/** Text-only prompt recall. Browsing owns a snapshot so incoming turns cannot move its cursor. */
+export interface ComposerHistoryState {
+    entries: readonly string[];
+    index: number | null;
+    draft: string | null;
+}
+export interface ComposerHistoryStoragePort {
+    read: (required: {
+        scope: string;
+    }, optional: {}) => Promise<readonly string[]>;
+    write: (required: {
+        scope: string;
+        entries: readonly string[];
+    }, optional: {}) => Promise<void>;
+}
+export interface ComposerHistoryKeyInput {
+    key: string;
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+    isComposing?: boolean;
+    popupOpen?: boolean;
+    /** A DOM host can refine logical newline boundaries with measured soft-wrap boundaries. */
+    firstLine?: boolean;
+    lastLine?: boolean;
+}
+export declare function normalizeComposerHistory({ entries }: {
+    entries: readonly string[];
+}, { cap }?: {
+    cap?: number;
+}): string[];
+export declare function mergeComposerHistory({ recent, current }: {
+    recent: readonly string[];
+    current: readonly string[];
+}, { cap }?: {
+    cap?: number;
+}): string[];
+export declare function createComposerHistoryState(_required: {}, _optional?: {}): ComposerHistoryState;
+export declare function composerHistoryKeyAction(input: ComposerHistoryKeyInput, _optional?: {}): 'previous' | 'next' | 'restore' | null;
+export declare function transitionComposerHistory({ state, action, text, entries }: {
+    state: ComposerHistoryState;
+    action: 'previous' | 'next' | 'restore' | 'edit' | 'reset';
+    text: string;
+    entries: readonly string[];
+}, _optional?: {}): {
+    state: ComposerHistoryState;
+    text: string;
+    handled: boolean;
+};
+//# sourceMappingURL=composer-history.d.ts.map

package/dist/core/composer-history.js

@@ -0,0 +1,57 @@
+export function normalizeComposerHistory({ entries }, { cap = 100 } = {}) {
+    const result = [];
+    for (const text of entries) {
+        // Blank/attachment-only turns are not useful prompts; meaningful whitespace stays exact.
+        if (text.trim() && text !== result[result.length - 1])
+            result.push(text);
+    }
+    return result.slice(-Math.max(1, Math.floor(cap)));
+}
+export function mergeComposerHistory({ recent, current }, { cap = 100 } = {}) {
+    const left = normalizeComposerHistory({ entries: recent }, { cap });
+    const right = normalizeComposerHistory({ entries: current }, { cap });
+    // A mounted conversation is usually already the recent list's suffix. Do not append its
+    // entire transcript again on every streamed render; preserve nonconsecutive repetitions.
+    let overlap = Math.min(left.length, right.length);
+    while (overlap > 0 && !right.slice(0, overlap).every((text, i) => text === left[left.length - overlap + i]))
+        overlap -= 1;
+    return normalizeComposerHistory({ entries: [...left, ...right.slice(overlap)] }, { cap });
+}
+export function createComposerHistoryState(_required, _optional = {}) {
+    return { entries: [], index: null, draft: null };
+}
+export function composerHistoryKeyAction(input, _optional = {}) {
+    if (input.shiftKey || input.ctrlKey || input.altKey || input.metaKey || input.isComposing || input.popupOpen)
+        return null;
+    if (input.key === 'Escape')
+        return 'restore';
+    const start = Math.min(input.selectionStart, input.selectionEnd);
+    const end = Math.max(input.selectionStart, input.selectionEnd);
+    if (input.text.slice(start, end).includes('\n'))
+        return null;
+    const firstLine = !input.text.slice(0, end).includes('\n') && input.firstLine !== false;
+    const lastLine = !input.text.slice(start).includes('\n') && input.lastLine !== false;
+    if (input.key === 'ArrowUp' && firstLine)
+        return 'previous';
+    if (input.key === 'ArrowDown' && lastLine)
+        return 'next';
+    return null;
+}
+export function transitionComposerHistory({ state, action, text, entries }, _optional = {}) {
+    if (action === 'edit' || action === 'reset') {
+        return { state: createComposerHistoryState({}), text, handled: false };
+    }
+    if (state.index === null) {
+        if (action !== 'previous' || entries.length === 0)
+            return { state, text, handled: false };
+        const snapshot = [...entries];
+        const index = snapshot.length - 1;
+        return { state: { entries: snapshot, index, draft: text }, text: snapshot[index], handled: true };
+    }
+    if (action === 'restore' || (action === 'next' && state.index === state.entries.length - 1)) {
+        return { state: createComposerHistoryState({}), text: state.draft ?? '', handled: true };
+    }
+    const index = action === 'previous' ? Math.max(0, state.index - 1) : state.index + 1;
+    return { state: { ...state, index }, text: state.entries[index], handled: true };
+}
+//# sourceMappingURL=composer-history.js.map

package/dist/core/durable-projection.d.ts

@@ -0,0 +1,28 @@
+import type { AgentEvent } from './events.js';
+import type { ChatMessage } from './messages.js';
+/** Saved checkpoints can coalesce deltas and a completion may replay only a prefix. Keep the
+ * saved projection, merge identifiable events, and append only text beyond its saved prefix. */
+export declare function mergeRunEvents({ saved, incoming }: {
+    saved?: readonly AgentEvent[] | undefined;
+    incoming: readonly AgentEvent[];
+}, _optional?: {}): AgentEvent[];
+/** A recovered attempt stays visibly in progress until new text or tool work supersedes its marker. */
+export declare function continuingRunNotice({ events, active }: {
+    events: readonly AgentEvent[] | undefined;
+    active: boolean;
+}, _optional?: {}): string | null;
+export declare function preserveAssistantContent({ saved, incoming }: {
+    saved: string;
+    incoming: string;
+}, _optional?: {}): string;
+/** Terminal failure belongs to the message. Legacy resend instructions are display-only;
+ * changing this copy must never execute or reopen an old terminal run. */
+export declare function terminalMessageNotice({ message }: {
+    message: ChatMessage;
+}, _optional?: {}): string | null;
+/** The first answer has no earlier segment to divide, even if startup was retried. Only saved
+ * visible text can justify a Continued divider; the recovery marker still records the attempt. */
+export declare function recoveredRunEvents({ saved }: {
+    saved: readonly AgentEvent[];
+}, _optional?: {}): AgentEvent[];
+//# sourceMappingURL=durable-projection.d.ts.map

package/dist/core/durable-projection.js

@@ -0,0 +1,71 @@
+function identity(event) {
+    const wire = event;
+    if (wire.eventId !== undefined)
+        return `event:${wire.eventId}`;
+    if (wire.cursor !== undefined)
+        return `cursor:${wire.cursor}`;
+    if (event.kind === 'tool_use')
+        return `use:${event.id}`;
+    if (event.kind === 'tool_result')
+        return `result:${event.toolUseId}`;
+    return JSON.stringify(event);
+}
+function textOf(events) {
+    return events.filter((event) => event.kind === 'text').map((event) => event.text).join('');
+}
+/** Saved checkpoints can coalesce deltas and a completion may replay only a prefix. Keep the
+ * saved projection, merge identifiable events, and append only text beyond its saved prefix. */
+export function mergeRunEvents({ saved, incoming }, _optional = {}) {
+    const previous = saved ?? [];
+    const result = [...previous];
+    const keys = new Set(previous.map(identity));
+    const before = textOf(previous);
+    const after = textOf(incoming);
+    let skip = after.startsWith(before) ? before.length : after.length;
+    for (const event of incoming) {
+        if (event.kind === 'text') {
+            const text = event.text.slice(skip);
+            skip = Math.max(0, skip - event.text.length);
+            if (text)
+                result.push({ ...event, text });
+        }
+        else if (!keys.has(identity(event))) {
+            keys.add(identity(event));
+            result.push(event);
+        }
+    }
+    return result;
+}
+/** A recovered attempt stays visibly in progress until new text or tool work supersedes its marker. */
+export function continuingRunNotice({ events, active }, _optional = {}) {
+    if (!active)
+        return null;
+    const list = events ?? [];
+    const marker = list.findLastIndex((event) => event.kind === 'status' && event.code === 'run_recovering');
+    if (marker < 0)
+        return null;
+    const progressed = list.slice(marker + 1).some((event) => event.kind === 'text' || event.kind === 'tool_use' || event.kind === 'tool_result');
+    return progressed ? null : 'Continuing…';
+}
+export function preserveAssistantContent({ saved, incoming }, _optional = {}) {
+    return incoming.length >= saved.length ? incoming : saved;
+}
+/** Terminal failure belongs to the message. Legacy resend instructions are display-only;
+ * changing this copy must never execute or reopen an old terminal run. */
+export function terminalMessageNotice({ message }, _optional = {}) {
+    if (message.runStatus !== 'failed' && message.runStatus !== 'canceled')
+        return null;
+    const notice = message.events?.filter((event) => event.kind === 'status' &&
+        (event.code === 'run_terminal' || /failed|stopped|restarted|could not|not logged in|cancell?ed/i.test(event.label))).at(-1);
+    if (notice?.kind === 'status')
+        return [notice.label, notice.detail].filter(Boolean).join(' ').replace(/Send your message again to retry\.?/gi, '').trim();
+    return message.runStatus === 'failed' ? 'This turn failed.' : 'Stopped.';
+}
+/** The first answer has no earlier segment to divide, even if startup was retried. Only saved
+ * visible text can justify a Continued divider; the recovery marker still records the attempt. */
+export function recoveredRunEvents({ saved }, _optional = {}) {
+    const hasAnswer = saved.some(event => event.kind === 'text' && event.text.trim().length > 0);
+    return [...saved, ...(hasAnswer ? [{ kind: 'text', text: '\n\n---\n\nContinued\n\n' }] : []),
+        { kind: 'status', code: 'run_recovering', label: 'Continuing…' }];
+}
+//# sourceMappingURL=durable-projection.js.map

package/dist/core/index.d.ts

@@ -42,4 +42,7 @@ export * from './agentic/index.js';
  * module, and a host binds it to its own authentication.
  */
 export * from './persistence/index.js';
+export { recoveredRunEvents } from './durable-projection.js';
+export { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from './composer-history.js';
+export type { ComposerHistoryKeyInput, ComposerHistoryState, ComposerHistoryStoragePort } from './composer-history.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -42,4 +42,6 @@ export * from './agentic/index.js';
  * module, and a host binds it to its own authentication.
  */
 export * from './persistence/index.js';
+export { recoveredRunEvents } from './durable-projection.js';
+export { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from './composer-history.js';
 //# sourceMappingURL=index.js.map

package/dist/core/run-activity.d.ts

@@ -1,22 +1,3 @@
-/**
- * @module run-activity
- *
- * What a running turn is doing right now, as one short line ("Running Page Fill… 1 m 20 s").
- *
- * Why: once a turn's first tool row appeared, nothing on screen showed the run was still alive —
- * the old "Thinking…" placeholder only showed while the message was completely empty. Model think
- * time, long tool calls, held cards and API overload retries all looked identical: dead.
- *
- * Shape: {@link deriveRunActivity} reads the events the pane already has and returns the latest
- * signal; {@link RUN_ACTIVITY_LABELS} is the ONE table that turns a signal into words. The clock
- * (seconds since the signal began) is the caller's: the React hook ticks it once a second. Nothing
- * here special-cases a particular tool.
- *
- * Status events this reads (a host translates its runtime's heartbeats into them):
- * - `code: 'api_retry'`, `data: { attempt, maxAttempts, service? }` — the model API is overloaded.
- * - `code: 'tool_progress'`, `data: { elapsedSeconds }` — a tool call is still running.
- * - `code: 'thinking'` — the model is reasoning (keeps the idle timer honest).
- */
 import type { AgentEvent } from './events.js';
 /** The latest thing a running turn is doing. */
 export type RunActivity = {
@@ -57,7 +38,8 @@ export declare function humanizeToolName({ name }: {
  * The latest signal in a running turn's events.
  *
  * Precedence, newest wins: an API retry with nothing visible after it; a card that arrived while a
- * tool call is still open (the tool is waiting on the person); the newest open tool call; else
+ * tool call is still open (the tool is waiting on the person; a display-only A2UI surface is not a
+ * card); the newest open tool call; else
  * writing (last visible event is text) or thinking.
  *
  * @complexity O(n) in events, O(open tool calls) extra space.
@@ -65,6 +47,16 @@ export declare function humanizeToolName({ name }: {
 export declare function deriveRunActivity({ events }: {
     events: readonly AgentEvent[] | undefined;
 }): RunActivityState;
+/**
+ * Whether the run is waiting on the person: a card (form, confirm, sign-in) arrived while its tool
+ * call is still open. Hosts use it to hide "still working" notices, which read as a hung run while
+ * the run is really waiting for an answer.
+ *
+ * @complexity O(n) in events.
+ */
+export declare function isAwaitingAnswer({ events }: {
+    events: readonly AgentEvent[] | undefined;
+}): boolean;
 /** `4` → `"4 s"`, `80` → `"1 m 20 s"`, `120` → `"2 m 0 s"`. */
 export declare function formatActivityClock({ totalSeconds }: {
     totalSeconds: number;

package/dist/core/run-activity.js

@@ -1,3 +1,24 @@
+/**
+ * @module run-activity
+ *
+ * What a running turn is doing right now, as one short line ("Running Page Fill… 1 m 20 s").
+ *
+ * Why: once a turn's first tool row appeared, nothing on screen showed the run was still alive —
+ * the old "Thinking…" placeholder only showed while the message was completely empty. Model think
+ * time, long tool calls, held cards and API overload retries all looked identical: dead.
+ *
+ * Shape: {@link deriveRunActivity} reads the events the pane already has and returns the latest
+ * signal; {@link RUN_ACTIVITY_LABELS} is the ONE table that turns a signal into words. The clock
+ * (seconds since the signal began) is the caller's: the React hook ticks it once a second. Nothing
+ * here special-cases a particular tool.
+ *
+ * Status events this reads (a host translates its runtime's heartbeats into them):
+ * - `code: 'api_retry'`, `data: { attempt, maxAttempts, service? }` — the model API is overloaded.
+ * - `code: 'tool_progress'`, `data: { elapsedSeconds }` — a tool call is still running.
+ * - `code: 'thinking'` — the model is reasoning (keeps the idle timer honest).
+ */
+import { a2uiSurfaceIdOf, displayOnlySurfaceIdOf } from '@jini-ai/agentic/a2ui';
+import { isDelegatedWrapperToolName } from './tool-events.js';
 /** Tool names whose only job is finding the right tool (MCP tool search / schema lookup). */
 const DISCOVERY_TOOL_NAMES = new Set([
     'ToolSearch',
@@ -6,10 +27,10 @@ const DISCOVERY_TOOL_NAMES = new Set([
     'mcp__jini__search_tools',
     'mcp__jini__describe_tool',
 ]);
-/** Transport wrappers whose real tool id is in `input.toolId`. */
-const WRAPPER_TOOL_NAMES = new Set(['execute_delegated_tool', 'mcp__jini__execute_delegated_tool']);
 /** Ext events that are a card for the person (a form, a confirm, a sign-in). */
 const CARD_EXT_NAMES = new Set(['mcp-ui', 'a2ui']);
+/** The A2UI ext name: its surfaces may declare themselves display-only (`@jini-ai/agentic/a2ui`). */
+const A2UI_EXT_NAME = 'a2ui';
 /** After this long with nothing new on screen, a thinking/writing line says "Still working…". */
 export const RUN_ACTIVITY_IDLE_MS = 20_000;
 function isRecord(value) {
@@ -25,7 +46,8 @@ function stringField(data, key) {
 }
 /** `"page.fill"` → `"Page Fill"`, `"mcp__supabase__list_projects"` → `"List Projects"`. Display only. */
 export function humanizeToolName({ name }, { input } = {}) {
-    const real = WRAPPER_TOOL_NAMES.has(name) ? (stringField(input, 'toolId') ?? name) : name;
+    // A transport wrapper's real tool id is in `input.toolId`.
+    const real = isDelegatedWrapperToolName({ name: name }) ? (stringField(input, 'toolId') ?? name) : name;
     const bare = real.startsWith('mcp__') ? real.split('__').slice(2).join('__') || real : real;
     return bare
         .split(/[._\s]+/)
@@ -36,6 +58,23 @@ export function humanizeToolName({ name }, { input } = {}) {
 function isVisible(event) {
     return event.kind === 'text' ? event.text.length > 0 : event.kind === 'tool_use' || event.kind === 'tool_result' || event.kind === 'ext';
 }
+/**
+ * Whether an ext event is a card the person must answer. A display-only A2UI surface shows
+ * something and asks nothing, so a tool holding its call open after drawing one (assistant_render_ui
+ * waits a few seconds to hear a browser refusal) must not read as "Waiting for your answer above"
+ * (demo V3, 2026-10-05).
+ */
+function isAnswerCard(scan, name, data) {
+    if (!CARD_EXT_NAMES.has(name))
+        return false;
+    if (name !== A2UI_EXT_NAME)
+        return true;
+    const displayOnlyId = displayOnlySurfaceIdOf({ message: data });
+    if (displayOnlyId !== undefined)
+        scan.displayOnlySurfaces.add(displayOnlyId);
+    const surfaceId = a2uiSurfaceIdOf({ message: data });
+    return surfaceId === undefined || !scan.displayOnlySurfaces.has(surfaceId);
+}
 function scanEvent(scan, event, index) {
     if (isVisible(event)) {
         scan.lastVisible = { index, kind: event.kind };
@@ -48,7 +87,7 @@ function scanEvent(scan, event, index) {
     else if (event.kind === 'tool_result') {
         scan.open = scan.open.filter((tool) => tool.id !== event.toolUseId);
     }
-    else if (event.kind === 'ext' && CARD_EXT_NAMES.has(event.name)) {
+    else if (event.kind === 'ext' && isAnswerCard(scan, event.name, event.data)) {
         scan.lastCardIndex = index;
     }
     else if (event.kind === 'status' && event.code === 'api_retry') {
@@ -64,13 +103,14 @@ function scanEvent(scan, event, index) {
  * The latest signal in a running turn's events.
  *
  * Precedence, newest wins: an API retry with nothing visible after it; a card that arrived while a
- * tool call is still open (the tool is waiting on the person); the newest open tool call; else
+ * tool call is still open (the tool is waiting on the person; a display-only A2UI surface is not a
+ * card); the newest open tool call; else
  * writing (last visible event is text) or thinking.
  *
  * @complexity O(n) in events, O(open tool calls) extra space.
  */
 export function deriveRunActivity({ events }) {
-    const scan = { open: [], lastVisible: null, lastCardIndex: -1, retry: null, progress: null, visibleCount: 0 };
+    const scan = { open: [], lastVisible: null, lastCardIndex: -1, retry: null, progress: null, visibleCount: 0, displayOnlySurfaces: new Set() };
     (events ?? []).forEach((event, index) => scanEvent(scan, event, index));
     const visibleCount = scan.visibleCount;
     const lastVisibleIndex = scan.lastVisible?.index ?? -1;
@@ -114,6 +154,16 @@ export function deriveRunActivity({ events }) {
     }
     return { activity: { kind: 'thinking' }, key: `thinking:${lastVisibleIndex}`, visibleCount };
 }
+/**
+ * Whether the run is waiting on the person: a card (form, confirm, sign-in) arrived while its tool
+ * call is still open. Hosts use it to hide "still working" notices, which read as a hung run while
+ * the run is really waiting for an answer.
+ *
+ * @complexity O(n) in events.
+ */
+export function isAwaitingAnswer({ events }) {
+    return deriveRunActivity({ events }).activity.kind === 'awaiting-answer';
+}
 /** `4` → `"4 s"`, `80` → `"1 m 20 s"`, `120` → `"2 m 0 s"`. */
 export function formatActivityClock({ totalSeconds }) {
     const seconds = Math.max(0, Math.floor(totalSeconds));
@@ -133,7 +183,9 @@ export const RUN_ACTIVITY_LABELS = {
         : t('Writing…'),
     'finding-tool': (_a, clock, t) => t('Finding the right tool… {time}', { time: formatActivityClock({ totalSeconds: clock.seconds }) }),
     'running-tool': (a, clock, t) => t('Running {tool}… {time}', { tool: a.tool, time: formatActivityClock({ totalSeconds: clock.seconds }) }),
-    'awaiting-answer': (_a, clock, t) => t('Waiting for your answer above · {time}', { time: formatActivityClock({ totalSeconds: clock.seconds }) }),
+    // No clock: the run is waiting on the person, not working, and a ticking timer under an open
+    // form read as a hung run (demo dry-run, 2026-10-05).
+    'awaiting-answer': (_a, _clock, t) => t('Waiting for your answer above'),
     retrying: (a, _clock, t) => {
         const who = a.service ? t("{service}'s servers are busy", { service: a.service }) : t('The AI service is busy');
         return a.attempt !== undefined && a.maxAttempts !== undefined

package/dist/core/tool-events.d.ts

@@ -17,4 +17,38 @@ import type { AgentEvent } from './events.js';
 export declare function dedupeToolUsesById({ events }: {
     events: AgentEvent[] | undefined;
 }): AgentEvent[];
+/**
+ * Whether `name` is a delegated-tool transport wrapper — `execute_delegated_tool` or
+ * `execute_readonly_delegated_tool`, bare or as an MCP client names it (`mcp__<server>__…`). Its real
+ * tool id is in `input.toolId`. The one shared definition, so a renderer and the run-activity line
+ * cannot disagree about which names are wrappers (both once missed the read-only gateway).
+ *
+ * @complexity O(n) in the length of `name`.
+ */
+export declare function isDelegatedWrapperToolName({ name }: {
+    name: string;
+}): boolean;
+/**
+ * Drop each delegated-tool wrapper call that the daemon also reported as its own canonical row,
+ * so one call shows as one row.
+ *
+ * WHY. A delegated call arrives twice: the vendor CLI's wrapper `tool_use`
+ * (`mcp__jini__execute_delegated_tool {toolId, input}`, with the CLI's `toolu_…` id) and the
+ * daemon bridge's canonical `tool_use` named after the real tool (`content_stats`, with a fresh
+ * UUID from `@jini-ai/mcp`). The ids differ, so {@link dedupeToolUsesById} cannot merge them, and a
+ * failed call showed two red rows. The canonical row is the one to keep: it carries the tool's own
+ * name, input and result.
+ *
+ * A wrapper folds onto the first LATER canonical `tool_use` whose name equals its `input.toolId`
+ * and that no earlier wrapper has claimed; its `tool_result` events go with it. A wrapper with no
+ * such canonical row (refused before the bridge, e.g. a read-only 403) stays, so its error is not
+ * hidden.
+ *
+ * @param events - The event list, normally already passed through {@link dedupeToolUsesById}.
+ * @returns A new array without the folded wrappers, or the original reference when none fold.
+ * @complexity O(n·w): n events, w wrapper calls (a handful per message).
+ */
+export declare function foldDelegatedWrapperCalls({ events }: {
+    events: AgentEvent[] | undefined;
+}): AgentEvent[];
 //# sourceMappingURL=tool-events.d.ts.map

package/dist/core/tool-events.js

@@ -33,4 +33,65 @@ export function dedupeToolUsesById({ events }) {
     }
     return deduped ?? events;
 }
+/** The two delegated-tool gateways `@jini-ai/mcp` hosts: the write gateway and its read-only companion. */
+const DELEGATED_WRAPPER_PATTERN = /^(?:mcp__.+__)?execute_(?:readonly_)?delegated_tool$/;
+/**
+ * Whether `name` is a delegated-tool transport wrapper — `execute_delegated_tool` or
+ * `execute_readonly_delegated_tool`, bare or as an MCP client names it (`mcp__<server>__…`). Its real
+ * tool id is in `input.toolId`. The one shared definition, so a renderer and the run-activity line
+ * cannot disagree about which names are wrappers (both once missed the read-only gateway).
+ *
+ * @complexity O(n) in the length of `name`.
+ */
+export function isDelegatedWrapperToolName({ name }) {
+    return DELEGATED_WRAPPER_PATTERN.test(name);
+}
+function wrapperToolId(event) {
+    if (event.kind !== 'tool_use' || !isDelegatedWrapperToolName({ name: event.name }))
+        return undefined;
+    const input = event.input;
+    const toolId = typeof input === 'object' && input !== null ? input.toolId : undefined;
+    return typeof toolId === 'string' && toolId ? toolId : undefined;
+}
+/**
+ * Drop each delegated-tool wrapper call that the daemon also reported as its own canonical row,
+ * so one call shows as one row.
+ *
+ * WHY. A delegated call arrives twice: the vendor CLI's wrapper `tool_use`
+ * (`mcp__jini__execute_delegated_tool {toolId, input}`, with the CLI's `toolu_…` id) and the
+ * daemon bridge's canonical `tool_use` named after the real tool (`content_stats`, with a fresh
+ * UUID from `@jini-ai/mcp`). The ids differ, so {@link dedupeToolUsesById} cannot merge them, and a
+ * failed call showed two red rows. The canonical row is the one to keep: it carries the tool's own
+ * name, input and result.
+ *
+ * A wrapper folds onto the first LATER canonical `tool_use` whose name equals its `input.toolId`
+ * and that no earlier wrapper has claimed; its `tool_result` events go with it. A wrapper with no
+ * such canonical row (refused before the bridge, e.g. a read-only 403) stays, so its error is not
+ * hidden.
+ *
+ * @param events - The event list, normally already passed through {@link dedupeToolUsesById}.
+ * @returns A new array without the folded wrappers, or the original reference when none fold.
+ * @complexity O(n·w): n events, w wrapper calls (a handful per message).
+ */
+export function foldDelegatedWrapperCalls({ events }) {
+    if (!events || events.length === 0)
+        return [];
+    const claimed = new Set();
+    const folded = new Set();
+    events.forEach((event, i) => {
+        const toolId = wrapperToolId(event);
+        // A replayed wrapper (same id) must not claim a second canonical row.
+        if (toolId === undefined || event.kind !== 'tool_use' || folded.has(event.id))
+            return;
+        const match = events.findIndex((other, j) => j > i && !claimed.has(j) && other.kind === 'tool_use' && other.name === toolId);
+        if (match === -1)
+            return;
+        claimed.add(match);
+        folded.add(event.id);
+    });
+    if (folded.size === 0)
+        return events;
+    return events.filter((event) => !((event.kind === 'tool_use' && folded.has(event.id)) ||
+        (event.kind === 'tool_result' && folded.has(event.toolUseId))));
+}
 //# sourceMappingURL=tool-events.js.map

package/dist/core/tools.d.ts

@@ -10,7 +10,7 @@
  * archived provenance ledger.
  */
 import type { ToolResultEvent, ToolResultMediaBlock, ToolUseEvent } from './events.js';
-export { dedupeToolUsesById } from './tool-events.js';
+export { dedupeToolUsesById, foldDelegatedWrapperCalls, isDelegatedWrapperToolName } from './tool-events.js';
 /** The four-state tool-call lifecycle agreed across AG-UI / CopilotKit / LangGraph render props. */
 export type ToolStatus = 'inProgress' | 'executing' | 'complete' | 'error';
 /** The render-prop payload a tool-call UI needs, independent of any framework. */

package/dist/core/tools.js

@@ -1,4 +1,4 @@
-export { dedupeToolUsesById } from './tool-events.js';
+export { dedupeToolUsesById, foldDelegatedWrapperCalls, isDelegatedWrapperToolName } from './tool-events.js';
 /**
  * Map a tool call to its AG-UI-style lifecycle status.
  *

package/dist/core/transport.d.ts

@@ -30,6 +30,8 @@ import type { ChatAttachment, ChatMessage, ChatRunStatus } from './messages.js';
  * via `extends`.
  */
 export interface RunHandlers {
+    /** Authoritative saved projection; may advance an attempt without ending its message. */
+    onCheckpoint?: (message: ChatMessage) => void;
     /** Fired once per renderable unit of agent output. */
     onEvent: (ev: AgentEvent) => void;
     /**
@@ -50,6 +52,8 @@ export interface RunHandlers {
  */
 export type RunContext = Record<string, unknown>;
 export interface StartRunInput {
+    /** The logical assistant message identity, allocated before acceptance. */
+    assistantMessageId?: string;
     history: ChatMessage[];
     agentId?: string;
     conversationId?: string | null;

package/dist/react/components/Composer.js

@@ -15,6 +15,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useLayoutEffect, useRef, useState, } from 'react';
 import { RemixIcon } from '@jini-ai/ui';
 import { useT } from '../hooks/context.js';
+import { useComposerHistoryKeys } from '../hooks/useComposerHistoryKeys.hooks.js';
 import { AttachmentTray } from './AttachmentTray.js';
 import { ComposerDiscoveryMenu, ComposerSlashMenu } from './ComposerDiscovery.js';
 import { appendComposerDiscovery, composerDiscoveryMenuPosition, composerSlashMenuPosition, filterComposerDiscovery, parseComposerSlashQuery, replaceComposerSlashTrigger, resolveComposerSlashInvocation, resolveComposerSlashKeyAction, } from './composer-discovery.js';
@@ -103,6 +104,9 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
      * point the shrinking list is its own feedback.
      */
     const showSlashFilterHint = slashQuery !== null && slashQuery.command === '' && slashQuery.argument === null;
+    const handleHistoryKey = useComposerHistoryKeys({ composer, textareaRef }, {
+        popupOpen: slashOpen || discoveryMenuOpen || workdirOpen || composer.mention.open,
+    });
     function restoreComposerFocus() {
         textareaRef.current?.focus();
     }
@@ -286,6 +290,8 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
                 return;
             }
         }
+        if (handleHistoryKey(event))
+            return;
         if (event.key !== 'Enter' || event.shiftKey)
             return;
         event.preventDefault();