@jini-ai/chat 0.6.6 → 0.6.10

package/CHANGELOG.md

@@ -1,3 +1,131 @@
+## 0.6.10
+
+### Patch Changes
+
+- f9d9894: Hide recovered tool failures when tool calls are hidden. Keep unrecovered failures in one compact, localized disclosure per reply, preserving their existing details.
+- 8ff5653: Make the chat-pane transcript readable from outside the component — a must-have for an AI (or an
+  e2e harness) verifying that commands it gave the pane (create a form, add a user, change a
+  permission) actually happened.
+
+  Before this, `<ChatPane>` fully encapsulated its conversation state: `useConversation()`'s
+  `messages` never left the component, `ChatPaneProps` had no callback that reported the live message
+  list, and the rendered transcript (`MessageList`/`MessageRow`/`ToolCard`) carried zero
+  `data-agent-element` tags — unlike every other interactive surface in this app's reference pages.
+
+  - `ChatPaneProps.onMessagesChange?: (messages: ChatMessage[]) => void` — fires with the full message
+    array on every change, mirroring the existing `onActivityChange` pattern. Each `ChatMessage`
+    already carries its `events` array (`tool_use`/`tool_result`), so a subscriber gets complete,
+    structured tool-call data for free — no DOM parsing needed.
+  - `data-agent-element="chat-transcript"` (role `list`) on the message-list container, and
+    `data-agent-element="chat-message-<id>"` (role `region`) on every message row, so `page.*` DOM
+    tools can enumerate the transcript the same way they read everything else in this app.
+  - `ToolCard` now wraps whatever it renders (any of its dozen built-in card variants, or a host's own
+    custom-registered renderer) in one `data-agent-element="tool-call-<use.id>"` (role `region`)
+    element — added at the single dispatch point every branch already funnels through, so no
+    individual card variant's own markup changed. The collapsed-by-default accordion detail (args/
+    result JSON) sits inside this tagged element, not gated behind expanding it: `textContent` (what
+    the `page.*` DOM driver actually reads) is layout-agnostic, so the full detail is readable whether
+    or not anything has been clicked open.
+
+- 3fe4d14: Add compatibility regression fixtures for legacy inline image results, media-only saved events and delegated echo notes; runtime behavior is unchanged.
+- 8ff5653: Add `createDaemonAttachmentUploader`, so composer drag-and-drop is one line instead of 160.
+
+  `ChatPane` has always gated its drop target and file picker on `uploadAttachments` being supplied — but
+  supplying it meant writing the client half yourself: a bounded-concurrency worker pool that preserves
+  input order, per-turn quota accounting, abort and timeout plumbing, and cleanup of files that already
+  landed when a later one fails. Every host would write the same ~160 lines, and the ordering and
+  cleanup details are exactly the ones that get skipped.
+
+  ```tsx
+  <ChatPane
+    transport={transport}
+    uploadAttachments={createDaemonAttachmentUploader(daemonUrl)}
+  />
+  ```
+
+  That talks to `@jini-ai/http-kit`'s `POST`/`DELETE /api/attachments`. Pass `''` when a dev-server proxy
+  already forwards `/api` from the page's own origin. `maxAttachmentBytes`, `maxAttachmentCount`,
+  `maxBatchBytes`, `timeoutMs`, and `concurrency` are all configurable and all default to the daemon side's
+  own limits, so the client's early rejection matches what the daemon would have said anyway.
+
+  Client-side quotas are a courtesy, never the boundary — telling a user their 400 MB video is too large
+  before the browser streams it, not after. The daemon re-derives every one of them.
+
+  Two behavioral notes for anyone porting hand-rolled code onto this:
+
+  - **The request always sends `content-type: application/octet-stream`**, not `file.type`. The daemon
+    sniffs the real kind from the bytes and ignores the header, so forwarding the browser's guess buys
+    nothing — and breaks real uploads: a dropped `.json` file arrives as `application/json`, which an
+    app-wide `express.json()` on the daemon then claims, draining the request stream before the upload
+    route can read a byte.
+  - **Batch accounting is per uploader instance**, not module-global, so two panes pointed at two daemons
+    cannot consume each other's per-turn quota. Reservations are rolled back on failure, so a retry of a
+    failed turn is not refused for quota it never actually used.
+
+- 72ea04d: Folded `@jini-ai/renderers-react` into `@jini-ai/ui` as an independently-importable, tree-shakeable
+  `./renderers` subpath, and retired the package.
+
+  Real (non-comment) imports of `@jini-ai/renderers-react` anywhere in the repo were exactly 3 files,
+  2 symbols, all inside `@jini-ai/ui`'s own `features/html-viewer` — `openSandboxedPreviewInNewTab`
+  and `useSandboxBridge`. `@jini-ai/ui` was already the package's only real consumer, so a standalone
+  package bought nothing, the same reasoning that folded `@jini-ai/ui-core` into `./core` and
+  `@jini-ai/composio` into `@jini-ai/admin`. The whole `src/**` tree (registry, renderers, srcDoc
+  host, annotation-canvas, preview-modal-shell, i18n) moves to `packages/ui/src/renderers/` as one
+  `git mv`, unchanged in shape; `html-viewer`'s two consumers switch from the package-qualified
+  import to a relative one, since they're now in the same package.
+
+  **The `@jini-ai/renderers-react → @jini-ai/chat` dependency was dropped first, before the move,
+  not after.** `registry.ts` imported `ArtifactManifest`/`inferLegacyManifest` from `@jini-ai/chat`,
+  and `types.ts` re-exported five manifest types from there. `@jini-ai/chat` already depends on
+  `@jini-ai/ui`, so folding renderers-react into `ui` unchanged would have created a real `ui ↔ chat`
+  package cycle. The five manifest types (`ArtifactManifest`, `ArtifactKind`, `ArtifactRendererId`,
+  `ArtifactExportKind`, `ArtifactStatus`) are now defined locally in `types.ts`, copied verbatim from
+  `@jini-ai/chat`'s `src/core/util/types.ts` — a small duplicated-type cost, accepted because a
+  renderer package must not depend on a chat package.
+
+  **`resolveArtifactManifest` no longer infers a legacy manifest from a file's name/extension** — a
+  real, disclosed API behavior change. It now returns `file.manifest ?? null`. Manifest inference
+  (guessing kind/renderer from `.md`/`.html`/`.svg`/`.tsx`, etc.) is a caller concern that depends on
+  a product's own naming conventions, not something a generic renderer registry should do on a
+  caller's behalf; a caller that still wants that inference should resolve a manifest for the file
+  itself (see `@jini-ai/chat`'s `inferLegacyManifest`) before handing it to this registry. Verified
+  zero external callers of `RendererRegistry`/`resolveArtifactManifest`/`createDefaultRendererRegistry`
+  anywhere in Jini or Tovu before making this change — `@jini-ai/chat`'s own `RendererRegistry` is an
+  unrelated, locally-defined class in `artifact-types.ts`, and `@jini-ai/artifacts`' own
+  `resolveArtifactManifest` is an unrelated 3-argument function; both are same-name coincidences, not
+  real dependents. The four bundled renderers (`HtmlRenderer`, `MarkdownRenderer`, `SvgRenderer`,
+  `ReactComponentRenderer`) gate `canRender` on a resolvable manifest before falling back to any
+  `file.kind`/extension heuristic of their own, so this ripples into every test that exercised
+  default-registry routing via a bare file name with no explicit `manifest` — all updated to attach
+  one, with the extension-inference-specific assertions flipped to assert the removed behavior no
+  longer fires. No test was weakened or deleted: every changed assertion now tests the new,
+  documented contract, or restores a manifest to keep testing what it always meant to test.
+
+  **`@jini-ai/renderers-react` is retired, not versioned forward.** It was published (0.1.2), and
+  `packages/renderers-react` is deleted from this workspace. Deleting the source does not unpublish
+  anything, so whoever runs the next release should follow up with:
+
+  ```
+  npm deprecate @jini-ai/renderers-react "Merged into @jini-ai/ui; import from '@jini-ai/ui/renderers' instead."
+  ```
+
+  `@jini-ai/chat`'s dead `@jini-ai/renderers-react` dependency (declared, never imported — its own
+  `react/artifact-types.ts` defines a local placeholder registry instead, per its
+  `TODO(renderers-react)` header, left untouched here as out of scope) is removed from its
+  `package.json`, hence the accompanying patch bump.
+
+- 0c247a8: Fix visitor chat streaming announcements, resumed focus, frame batching, persistence and lazy mount/retry handling. Document the additive A2uiSurfaceCard registry prop for host validation and rendering.
+- e16a907: Clear floating-point noise in displayed costs, reconcile resumed counter resets and revisited sessions, and expose reported output tokens to assistive technology.
+- ea8d883: Release modal semantics when focus leaves chat, announce bounded rendered reply text, and retry opening without reloading mounted assets.
+- Updated dependencies [22f0619]
+- Updated dependencies [82ed2d3]
+- Updated dependencies [5a3de86]
+  - @jini-ai/core@0.6.10
+
+## 0.6.7 — 2026-10-22
+
+- 2026-10-22: Memory fixes (durable run store reads its own row, ledger parses events once), shared settings segmented control, Slack token rule restored, coverage.
+
 ## 0.6.6 — 2026-10-16
 
 - Staged attachment rows sit 8px apart so the top row's remove target stays 44px (4884cf15).
@@ -114,7 +242,6 @@
 - Correct renderer priority and opt-in stylesheet documentation; retain the layout rationale with neutral provenance.
 - BREAKING: replace the local finalizer Clock with core Clock.nowMs(); core/React helpers and ext-event slot-key callbacks take required objects.
 
-
 - BREAKING: ChatStore methods use required argument objects; paging options move to the second bag. ChatHistoryMaintenance and ChatStoreFactory follow the same convention.
 - BREAKING: SQLite/Postgres/PGlite factories use core `Clock` through `{ clock }` rather than `{ now }`; system-time defaults and SQL behavior are preserved.
 
@@ -204,5 +331,6 @@
   - @jini-ai/agentic@0.1.1
 
 ### C2 storage ownership
+
 - Added `./store/legacy` and `./store/legacy/sqlite`; preserved sync local project chat CRUD and schema.
 - Retained the original owner-isolation suite on the concern adapter after draining the old package.

package/dist/core/accepted-input.d.ts

@@ -0,0 +1,54 @@
+import type { AgentEvent } from './events.js';
+import type { ChatAttachment, ChatMessage } from './messages.js';
+export interface AcceptedChatInput {
+    id: string;
+    text: string;
+    attachments?: ChatAttachment[];
+    secretRedaction?: ChatMessage['secretRedaction'];
+    /** Wire ids replaced by this receipt remain seen by recall. */
+    aliases?: readonly string[];
+}
+/** Display queue constituents using their accepted identities; storage and delivery retain one turn.
+ * MOVE: Receipts travel in events_json, so separate bubbles survive a history reload without another store.
+ * @complexity O(m + e + i) time/space for m messages, e receipt events and i accepted queue inputs.
+ */
+export declare function projectAcceptedInputMessages({ messages }: {
+    messages: readonly ChatMessage[];
+}, _options?: {}): ChatMessage[];
+type UserMessageEvent = Extract<AgentEvent, {
+    kind: 'ext';
+}> & {
+    data: AcceptedChatInput & {
+        optimistic?: boolean;
+        toolUseId?: string;
+        afterInputId?: string;
+        inputs?: AcceptedChatInput[];
+    };
+};
+/** Reads the existing event-backed user bubble without depending on a host renderer. */
+export declare function acceptedInputEvent({ event }: {
+    event: AgentEvent;
+}, _options?: {}): UserMessageEvent | null;
+/** Builds the same bubble for delivered answers and steering; queues use the existing pending row. */
+export declare function acceptedInputUserEvent({ input, inputs, toolUseId, afterInputId }: {
+    input: AcceptedChatInput;
+    inputs?: AcceptedChatInput[];
+    toolUseId?: string;
+    afterInputId?: string;
+}, { receipt }?: {
+    receipt?: 'optimistic' | 'accepted';
+}): AgentEvent;
+/** Projects saved answers and reconciles optimistic bubbles with wire events, occurrence for
+ * occurrence. Legacy steering receipts have no client id: only unmatched optimistic input may
+ * match by text; two real events with equal text always remain distinct.
+ * @complexity O(e + u + a) time, O(e + u) space for e events, u user inputs and total answer-label lookup cost a.
+ */
+export declare function projectAcceptedInputEvents({ events }: {
+    events: readonly AgentEvent[];
+}, _options?: {}): AgentEvent[];
+/** The sole transcript-to-recall projection. A merged queued turn retains its original inputs. */
+export declare function acceptedInputsFromMessages({ messages }: {
+    messages: readonly ChatMessage[];
+}, _options?: {}): AcceptedChatInput[];
+export {};
+//# sourceMappingURL=accepted-input.d.ts.map

package/dist/core/accepted-input.js

@@ -0,0 +1,165 @@
+/** Accepted composer input has one identity across optimistic display, replay and recall. */
+import { questionAnswerFromResult } from './question-answer.js';
+import { MID_RUN_USER_MESSAGE_EVENT_NAME } from './turn-usage.js';
+/** Display queue constituents using their accepted identities; storage and delivery retain one turn.
+ * MOVE: Receipts travel in events_json, so separate bubbles survive a history reload without another store.
+ * @complexity O(m + e + i) time/space for m messages, e receipt events and i accepted queue inputs.
+ */
+export function projectAcceptedInputMessages({ messages }, _options = {}) {
+    return messages.flatMap(message => {
+        if (message.role !== 'user')
+            return [message];
+        const inputs = (message.events ?? []).flatMap(event => {
+            const input = acceptedInputEvent({ event });
+            return input ? [input.data] : [];
+        });
+        if (inputs.length === 0)
+            return [message];
+        const { attachments: _attachments, secretRedaction: _redaction, ...turn } = message;
+        // MOVE: Older receipts have no per-input files; retain those legacy files on the final bubble.
+        return inputs.map((input, index) => ({ ...turn, id: input.id, content: input.text,
+            attachments: input.attachments ?? (index === inputs.length - 1 ? message.attachments ?? [] : []), ...(input.secretRedaction ? { secretRedaction: input.secretRedaction } : {}) }));
+    });
+}
+/** Reads the existing event-backed user bubble without depending on a host renderer. */
+export function acceptedInputEvent({ event }, _options = {}) {
+    if (event.kind !== 'ext' || event.name !== MID_RUN_USER_MESSAGE_EVENT_NAME)
+        return null;
+    const data = event.data;
+    return data && typeof data.id === 'string' && typeof data.text === 'string' ? event : null;
+}
+/** Project a persisted answer through the same receipt owner as composer input. */
+function questionAnswerEvent({ event, input }, _options = {}) {
+    if (event.kind !== 'tool_result')
+        return null;
+    const text = questionAnswerFromResult({ result: event, input });
+    if (text === undefined)
+        return null;
+    return { kind: 'ext', name: MID_RUN_USER_MESSAGE_EVENT_NAME,
+        data: { id: `answer:${event.toolUseId}`, text, toolUseId: event.toolUseId } };
+}
+/** Builds the same bubble for delivered answers and steering; queues use the existing pending row. */
+export function acceptedInputUserEvent({ input, inputs, toolUseId, afterInputId }, { receipt = 'optimistic' } = {}) {
+    return { kind: 'ext', name: MID_RUN_USER_MESSAGE_EVENT_NAME,
+        data: { ...input, ...(receipt === 'optimistic' ? { optimistic: true } : {}), ...(inputs === undefined ? {} : { inputs }), ...(afterInputId === undefined ? {} : { afterInputId }), ...(toolUseId === undefined ? {} : { toolUseId }) } };
+}
+function expandQuestionAnswers({ events }, _options = {}) {
+    const savedAnswers = new Set(events.flatMap(event => {
+        const input = acceptedInputEvent({ event });
+        return input && !input.data.optimistic && input.data.toolUseId ? [input.data.toolUseId] : [];
+    }));
+    // MOVE: Persisted picks carry values; the original tool input retains their human-readable labels.
+    const questions = new Map(events.flatMap(event => event.kind === 'tool_use' ? [[event.id, event.input]] : []));
+    return events.flatMap(event => {
+        const answer = questionAnswerEvent({ event, input: event.kind === 'tool_result' ? questions.get(event.toolUseId) : undefined });
+        return answer && !savedAnswers.has(answer.data.toolUseId) ? [event, answer] : [event];
+    });
+}
+function collectOptimisticInputs({ events }, _options = {}) {
+    const optimisticByText = new Map();
+    const optimisticByQuestion = new Map();
+    for (const event of events) {
+        const input = acceptedInputEvent({ event });
+        if (!input?.data.optimistic)
+            continue;
+        if (input.data.toolUseId)
+            optimisticByQuestion.set(input.data.toolUseId, input);
+        else {
+            const list = optimisticByText.get(input.data.text) ?? { events: [], index: 0 };
+            list.events.push(input);
+            optimisticByText.set(input.data.text, list);
+        }
+    }
+    return { byText: optimisticByText, byQuestion: optimisticByQuestion };
+}
+function matchOptimisticInput({ input, optimistic, seen }, _options = {}) {
+    const candidates = optimistic.byText.get(input.data.text);
+    const next = candidates?.events[candidates.index];
+    const follows = next?.data.afterInputId === undefined || seen.has(next.data.afterInputId);
+    // Keep predecessor testing before the caller adds this receipt's ids to seen.
+    return input.data.toolUseId ? optimistic.byQuestion.get(input.data.toolUseId) : follows ? next : undefined;
+}
+function mergeAcceptedReceipt({ input, pending }, _options = {}) {
+    return { ...input, data: { ...input.data, id: pending.data.id,
+            ...(pending.data.inputs ? { inputs: pending.data.inputs } : {}),
+            aliases: [...new Set([...(input.data.aliases ?? []), input.data.id, ...(pending.data.aliases ?? [])])] } };
+}
+function acceptedInputIds({ input }, _options = {}) {
+    return [input.data.id, ...(input.data.toolUseId ? [`answer:${input.data.toolUseId}`] : []), ...(input.data.aliases ?? [])];
+}
+function reconcileAcceptedInput({ event, optimistic, state }, _options = {}) {
+    const input = acceptedInputEvent({ event });
+    if (!input || input.data.optimistic)
+        return;
+    const { replacements, replaced, seen } = state;
+    const ids = acceptedInputIds({ input });
+    if (ids.some(id => seen.has(id))) {
+        replaced.add(event);
+        return;
+    }
+    const pending = matchOptimisticInput({ input, optimistic, seen });
+    for (const id of ids)
+        seen.add(id);
+    if (!pending)
+        return;
+    advanceOptimisticInput({ input, optimistic });
+    for (const id of [pending.data.id, ...(pending.data.aliases ?? [])])
+        seen.add(id);
+    optimistic.byQuestion.delete(input.data.toolUseId ?? '');
+    replaced.add(pending);
+    replacements.set(event, mergeAcceptedReceipt({ input, pending }));
+}
+function advanceOptimisticInput({ input, optimistic }, _options = {}) {
+    const candidates = optimistic.byText.get(input.data.text);
+    if (candidates && !input.data.toolUseId)
+        candidates.index += 1;
+}
+/** Projects saved answers and reconciles optimistic bubbles with wire events, occurrence for
+ * occurrence. Legacy steering receipts have no client id: only unmatched optimistic input may
+ * match by text; two real events with equal text always remain distinct.
+ * @complexity O(e + u + a) time, O(e + u) space for e events, u user inputs and total answer-label lookup cost a.
+ */
+export function projectAcceptedInputEvents({ events }, _options = {}) {
+    const expanded = expandQuestionAnswers({ events });
+    const optimistic = collectOptimisticInputs({ events: expanded });
+    const state = { replacements: new Map(), replaced: new Set(), seen: new Set() };
+    for (const event of expanded)
+        reconcileAcceptedInput({ event, optimistic, state });
+    const { replacements, replaced } = state;
+    const projected = [];
+    const emitted = new Set();
+    for (const event of expanded) {
+        if (replaced.has(event))
+            continue;
+        const next = replacements.get(event) ?? event;
+        const input = acceptedInputEvent({ event: next });
+        if (input && emitted.has(input.data.id))
+            continue;
+        if (input)
+            emitted.add(input.data.id);
+        projected.push(next);
+    }
+    return projected;
+}
+/** The sole transcript-to-recall projection. A merged queued turn retains its original inputs. */
+export function acceptedInputsFromMessages({ messages }, _options = {}) {
+    return messages.flatMap(message => {
+        if (message.role === 'user') {
+            if (message.inputPending)
+                return [];
+            // Queue constituents travel in events_json, already preserved by the existing chat store.
+            const receipts = (message.events ?? []).flatMap(event => {
+                const input = acceptedInputEvent({ event });
+                return input ? [input.data] : [];
+            });
+            return receipts.length > 0 ? receipts : [{ id: message.id, text: message.content }];
+        }
+        return projectAcceptedInputEvents({ events: message.events ?? [] }).flatMap(event => {
+            const input = acceptedInputEvent({ event });
+            if (!input)
+                return [];
+            return input.data.inputs?.map((receipt, index) => index === 0 ? { ...receipt, aliases: input.data.aliases ?? [] } : receipt) ?? [input.data];
+        });
+    });
+}
+//# sourceMappingURL=accepted-input.js.map

package/dist/core/agent-plugin-chat-state.d.ts

@@ -0,0 +1,43 @@
+/** Browser-local per-chat decisions; the person's mode remains in the host's settings ledger. */
+export interface AgentPluginChatState {
+    decision: {
+        selected: readonly string[];
+        asked?: boolean;
+    } | null;
+    excluded: readonly string[];
+}
+export interface AgentPluginUsage {
+    conversationId: string;
+    state: AgentPluginChatState;
+    plugins: readonly {
+        id: string;
+        name: string;
+    }[];
+}
+export interface ChatPluginStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+export declare const AGENT_PLUGIN_STATE_CHANGED = "jini:agent-plugin-state";
+/** Corrupt/blocked storage permits a fresh question, as clearing localStorage does. */
+export declare function readAgentPluginChatState({ conversationId }: {
+    conversationId: string;
+}, { storage }?: {
+    storage?: ChatPluginStorage | undefined;
+}): AgentPluginChatState;
+/** Persist only decision/exclusions. Existing exclusions win over an in-flight server response. */
+export declare function writeAgentPluginChatState({ conversationId, state }: {
+    conversationId: string;
+    state: AgentPluginChatState;
+}, { storage }?: {
+    storage?: ChatPluginStorage | undefined;
+}): void;
+/** Called only for the protocol's structured plugin event, before delivering it to the transcript. */
+export declare function captureAgentPluginUsage({ event }: {
+    event: {
+        kind: string;
+        name?: string;
+        data?: unknown;
+    };
+}, _options?: {}): void;
+//# sourceMappingURL=agent-plugin-chat-state.d.ts.map

package/dist/core/agent-plugin-chat-state.js

@@ -0,0 +1,48 @@
+export const AGENT_PLUGIN_STATE_CHANGED = 'jini:agent-plugin-state';
+const key = (conversationId) => `jini:chat-agent-plugins:${conversationId}`;
+function browserStorage() {
+    try {
+        return typeof window === 'undefined' ? undefined : window.localStorage;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isStringList({ value }) {
+    return Array.isArray(value) && value.every(id => typeof id === 'string');
+}
+/** A stored row is usable only when its exclusions and (null or listed) decision are all string ids. */
+function usableChatState({ value }) {
+    return value && isStringList({ value: value.excluded }) && (value.decision === null || isStringList({ value: value.decision?.selected })) ? value : null;
+}
+/** Corrupt/blocked storage permits a fresh question, as clearing localStorage does. */
+export function readAgentPluginChatState({ conversationId }, { storage = browserStorage() } = {}) {
+    try {
+        const state = usableChatState({ value: JSON.parse(storage?.getItem(key(conversationId)) ?? 'null') });
+        if (state)
+            return state;
+    }
+    catch { /* Private browsing/corrupt rows behave as a new chat decision. */ }
+    return { decision: null, excluded: [] };
+}
+/** Persist only decision/exclusions. Existing exclusions win over an in-flight server response. */
+export function writeAgentPluginChatState({ conversationId, state }, { storage = browserStorage() } = {}) {
+    const current = readAgentPluginChatState({ conversationId }, { storage });
+    const next = { decision: state.decision, excluded: [...new Set([...current.excluded, ...state.excluded])] };
+    try {
+        storage?.setItem(key(conversationId), JSON.stringify(next));
+    }
+    catch { /* Session can continue without persistence. */ }
+    if (typeof window !== 'undefined')
+        window.dispatchEvent(new CustomEvent(AGENT_PLUGIN_STATE_CHANGED, { detail: { conversationId, state: next } }));
+}
+/** Called only for the protocol's structured plugin event, before delivering it to the transcript. */
+export function captureAgentPluginUsage({ event }, _options = {}) {
+    if (event.kind !== 'ext' || event.name !== 'agent_plugins')
+        return;
+    const usage = event.data;
+    if (typeof usage?.conversationId !== 'string' || !usage.state || !Array.isArray(usage.state.excluded))
+        return;
+    writeAgentPluginChatState({ conversationId: usage.conversationId, state: usage.state });
+}
+//# sourceMappingURL=agent-plugin-chat-state.js.map

package/dist/core/assistant-client/a2ui-action-poster.js

@@ -80,34 +80,38 @@ export function createA2uiActionPoster({ baseUrl, path, fetch, reportFailure },
         }
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            const response = await fetch(endpoint, {
-                method: "POST",
-                credentials: "same-origin",
-                headers: { ...options.headers, "content-type": "application/json" },
-                body: JSON.stringify({ exchangeId, message }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const detail = await response.text().catch(() => "");
-                reportFailure({ args: [`[a2ui] action delivery failed (${response.status}) for surface ${exchangeId}`, detail] }, {});
-                return { ok: false, reason: reasonForStatus(response.status) };
-            }
-            return { ok: true };
-        }
-        catch (error) {
-            const timedOut = error instanceof Error && error.name === "AbortError";
-            reportFailure({ args: [`[a2ui] action delivery failed for surface ${exchangeId}`, timedOut ? `timed out after ${timeoutMs}ms` : error] }, {});
-            return {
-                ok: false,
-                reason: timedOut
-                    ? "This took too long to deliver and was given up on."
-                    : "Couldn't reach the server to deliver this action.",
-            };
-        }
-        finally {
-            clearTimeout(timer);
-        }
+        // Cleared on every outcome; a `.finally` rather than try/finally so no path falls through.
+        return postOnce({ endpoint, exchangeId, message, timeoutMs, reportFailure, fetch, signal: controller.signal, headers: options.headers })
+            .finally(() => clearTimeout(timer));
     };
 }
+/** One POST attempt and its classification; never rejects. @complexity O(1). */
+async function postOnce(attempt) {
+    const { exchangeId, reportFailure } = attempt;
+    try {
+        const response = await attempt.fetch(attempt.endpoint, {
+            method: "POST",
+            credentials: "same-origin",
+            headers: { ...attempt.headers, "content-type": "application/json" },
+            body: JSON.stringify({ exchangeId, message: attempt.message }),
+            signal: attempt.signal,
+        });
+        if (!response.ok) {
+            const detail = await response.text().catch(() => "");
+            reportFailure({ args: [`[a2ui] action delivery failed (${response.status}) for surface ${exchangeId}`, detail] }, {});
+            return { ok: false, reason: reasonForStatus(response.status) };
+        }
+        return { ok: true };
+    }
+    catch (error) {
+        const timedOut = error instanceof Error && error.name === "AbortError";
+        reportFailure({ args: [`[a2ui] action delivery failed for surface ${exchangeId}`, timedOut ? `timed out after ${attempt.timeoutMs}ms` : error] }, {});
+        return {
+            ok: false,
+            reason: timedOut
+                ? "This took too long to deliver and was given up on."
+                : "Couldn't reach the server to deliver this action.",
+        };
+    }
+}
 //# sourceMappingURL=a2ui-action-poster.js.map

package/dist/core/assistant-client/messages.d.ts

@@ -8,7 +8,7 @@ export interface AssistantConversation {
     updatedAt: number;
 }
 /**
- * The subset of a live transcript that is worth writing: user turns, and assistant turns whose run
+ * The subset of a live transcript that is worth writing: accepted user turns, and assistant turns whose run
  * has reached a terminal status.
  *
  * An assistant message that is still `queued` or `running` is rewritten on every delta, so

package/dist/core/assistant-client/messages.js

@@ -1,6 +1,6 @@
 import { isTerminalRunStatus } from "../messages.js";
 /**
- * The subset of a live transcript that is worth writing: user turns, and assistant turns whose run
+ * The subset of a live transcript that is worth writing: accepted user turns, and assistant turns whose run
  * has reached a terminal status.
  *
  * An assistant message that is still `queued` or `running` is rewritten on every delta, so
@@ -18,7 +18,7 @@ import { isTerminalRunStatus } from "../messages.js";
  * Deleting them here would trade a history bug for a forensics hole.
  */
 export function persistableMessages({ messages }, _options = {}) {
-    return messages.filter((message) => message.role === "user" || isTerminalRunStatus({ status: message.runStatus }));
+    return messages.filter((message) => message.role === "user" ? !message.inputPending : isTerminalRunStatus({ status: message.runStatus }));
 }
 /**
  * The key the admin's chat writers use to remember "this message is already saved": the message id,

package/dist/core/assistant-client/transport.d.ts

@@ -2,7 +2,7 @@ import type { AgentEvent } from "../events.js";
 import type { ChatMessage } from "../messages.js";
 import type { ChatTransport, RunHandlers, StartRunInput } from "../transport.js";
 import type { RunNotices } from "../run-events/entry.js";
-import type { createAgUiRunClient } from "./ag-ui-transport.js";
+import type { AgUiRunClient } from "./ag-ui-transport.js";
 import type { DurableRunBinding } from "./durable-run-subscription.js";
 /** Per-turn dispatch input; hosts may return their fuller saved settings without UI dependencies. */
 export interface AssistantExecutionConfig {
@@ -127,7 +127,7 @@ export interface AssistantTransportPorts {
         messageId: unknown;
         conversationId?: string;
     }, optional: Record<string, never>) => Promise<Response>;
-    readonly agUi: ReturnType<typeof createAgUiRunClient>;
+    readonly agUi: AgUiRunClient;
 }
 export interface ByokFrameContext {
     collected: AgentEvent[];