@jini-ai/chat 0.6.19 → 0.6.21

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.6.21
+
+- Per-chat memory churn stopped: run checkpoints are size-scaled (`checkpointIntervalMs({ bytes })`: 1 s, 3 s from 1 MB, 10 s from 5 MB) and written as guarded SQL deltas (append or text-tail splice under a length+tail receipt), falling back to a full checkpoint on mismatch. A completed checkpoint is never retried unchanged.
+- Leaner reads: message-scoped run heads, lean transcripts for acceptance and recovery, a conditional history read keyed on the connection-wide version, and `hasActiveRuns()` as a single-row probe.
+- Mid-run sends are deduplicated by accepted-input id (two sends with equal text are both kept); Cmd/Ctrl+Enter sends instead of cancelling; "Sending…" clears once the send is accepted; the queued label uses the status pill.
+
 ## 0.6.19
 
 - A direct MCP call (`mcp__<server>__X`, any CLI) shows as one row even when the MCP server normalized its arguments before the bridge saw them: once the CLI's own result has arrived, the call pairs by name with the bridge's `X` row between the two. Equal-input pairing still runs first across the turn; refusals and open calls never pair by name.

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

@@ -18,7 +18,11 @@ export interface AcceptedChatInput {
 }
 /** 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.
+ * The earlier in-run receipt owns the bubble when an unconsumed fallback also became a user row.
+ * @param messages The already loaded transcript; never fetched or mutated here.
+ * @returns Display rows with queued fallback copies removed by accepted id and aliases, never text.
+ * @complexity O(m + e + i + a) time/space for messages, receipt events, inputs and aliases; no I/O.
+ * @example projectAcceptedInputMessages({ messages });
  */
 export declare function projectAcceptedInputMessages({ messages }: {
     messages: readonly ChatMessage[];
@@ -69,7 +73,11 @@ export declare function acceptedInputUserEvent({ input, inputs, toolUseId, after
 export declare function projectAcceptedInputEvents({ events }: {
     events: readonly AgentEvent[];
 }, options?: AcceptedInputProjectionOptions): AgentEvent[];
-/** The sole transcript-to-recall projection. A merged queued turn retains its original inputs. */
+/** The sole transcript-to-recall projection. A merged queued turn retains its original inputs.
+ * @returns Accepted inputs once by id/alias, in send order; pending input is excluded.
+ * @complexity O(m + e + i + a) time/space for messages, events, inputs and aliases; no I/O.
+ * @example acceptedInputsFromMessages({ messages });
+ */
 export declare function acceptedInputsFromMessages({ messages }: {
     messages: readonly ChatMessage[];
 }, _options?: {}): AcceptedChatInput[];

package/dist/core/accepted-input.js

@@ -3,28 +3,65 @@ import { questionAnswerFromResult, questionAnswerLabel } from './question-answer
 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.
+ * The earlier in-run receipt owns the bubble when an unconsumed fallback also became a user row.
+ * @param messages The already loaded transcript; never fetched or mutated here.
+ * @returns Display rows with queued fallback copies removed by accepted id and aliases, never text.
+ * @complexity O(m + e + i + a) time/space for messages, receipt events, inputs and aliases; no I/O.
+ * @example projectAcceptedInputMessages({ messages });
  */
 export function projectAcceptedInputMessages({ messages }, _options = {}) {
+    const seen = new Set();
     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)
+        if (message.role !== 'user') {
+            for (const input of inputsFromMessage({ message }))
+                claimAcceptedInput({ input, seen });
             return [message];
-        const turn = { ...message };
-        delete turn.attachments;
-        delete turn.folders;
-        delete turn.secretRedaction;
+        }
+        return expandUserInputMessage({ message, seen });
+    });
+}
+/** Keep the original row fields and per-input files when splitting a batched fallback.
+ * @complexity O(e + i) time/space for the row's events and accepted inputs; no effects.
+ */
+function expandUserInputMessage({ message, seen }, _options = {}) {
+    const inputs = inputsFromMessage({ message: { ...message, inputPending: false } });
+    // Ordinary user rows have no receipt metadata to split.
+    if (!(message.events ?? []).some(event => acceptedInputEvent({ event }))) {
+        return claimAcceptedInput({ input: inputs[0], seen }) ? [message] : [];
+    }
+    return inputs.flatMap((input, index) => {
+        if (!claimAcceptedInput({ input, seen }))
+            return [];
         // 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,
-            folders: input.folders ?? (index === inputs.length - 1 ? message.folders ?? [] : []),
-            attachments: input.attachments ?? (index === inputs.length - 1 ? message.attachments ?? [] : []), ...(input.secretRedaction ? { secretRedaction: input.secretRedaction } : {}) }));
+        const legacyFiles = index === inputs.length - 1 ? message : {};
+        return [userInputRow({ message, input, legacyFiles })];
     });
 }
+/** Expand one accepted input without copying another input's files or redaction metadata.
+ * @returns A display-only row; stored messages and their receipt events remain unchanged.
+ * @complexity O(1) time/space, retaining attachment and folder arrays by reference.
+ */
+function userInputRow({ message, input, legacyFiles }, _options = {}) {
+    const turn = { ...message };
+    delete turn.attachments;
+    delete turn.folders;
+    delete turn.secretRedaction;
+    return { ...turn, id: input.id, content: input.text,
+        folders: input.folders ?? legacyFiles.folders ?? [],
+        attachments: input.attachments ?? legacyFiles.attachments ?? [],
+        ...(input.secretRedaction ? { secretRedaction: input.secretRedaction } : {}) };
+}
+/** Claim the stable identity and all aliases even on a duplicate, so later aliases stay deduplicated.
+ * @returns Whether this is the first occurrence; mutates only the projection's local identity set.
+ * @complexity O(a) time/space for one input's aliases.
+ */
+function claimAcceptedInput({ input, seen }, _options = {}) {
+    const ids = [input.id, ...(input.aliases ?? [])];
+    const duplicate = ids.some(id => seen.has(id));
+    for (const id of ids)
+        seen.add(id);
+    return !duplicate;
+}
 /** 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)
@@ -237,26 +274,43 @@ function projectEvents({ events }, options) {
     }
     return projected;
 }
-/** The sole transcript-to-recall projection. A merged queued turn retains its original inputs. */
+/** The sole transcript-to-recall projection. A merged queued turn retains its original inputs.
+ * @returns Accepted inputs once by id/alias, in send order; pending input is excluded.
+ * @complexity O(m + e + i + a) time/space for messages, events, inputs and aliases; no I/O.
+ * @example acceptedInputsFromMessages({ messages });
+ */
 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, ...(message.folders ? { folders: message.folders } : {}) }];
-        }
-        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];
-        });
+    const seen = new Set();
+    return messages.flatMap(message => inputsFromMessage({ message }))
+        .filter(input => claimAcceptedInput({ input, seen }));
+}
+/** Read one message's accepted identities, retaining queue constituents and wire aliases.
+ * @complexity O(e + i) time/space for the message's events and expanded inputs; no effects.
+ */
+function inputsFromMessage({ message }, _options = {}) {
+    if (message.inputPending)
+        return [];
+    // Queue constituents travel in events_json, already preserved by the existing chat store.
+    const receipts = projectAcceptedInputEvents({ events: message.events ?? [] }).flatMap(event => {
+        const input = acceptedInputEvent({ event });
+        if (!input)
+            return [];
+        return receiptInputs({ receipt: input });
     });
+    if (message.role !== 'user' || receipts.length > 0)
+        return receipts;
+    return [{ id: message.id, text: message.content, ...(message.folders ? { folders: message.folders } : {}) }];
+}
+/** Expand a batched receipt while retaining the first input's local and transport aliases.
+ * @returns The accepted constituents, or the single receipt; does not mutate either.
+ * @complexity O(i + a) time/space for constituents and first-input aliases.
+ */
+function receiptInputs({ receipt }, _options = {}) {
+    if (!receipt.data.inputs)
+        return [receipt.data];
+    return receipt.data.inputs.map((input, index) => index === 0 ? {
+        ...input, aliases: [...(input.aliases ?? []), ...(receipt.data.aliases ?? [])],
+    } : input);
 }
 /** Preserve folder metadata through existing event JSON storage; no attachment lifecycle or schema.
  * Existing per-input receipts already own queued variants and must retain their identities.

package/dist/core/assistant-client/durable-run-subscription.js

@@ -87,12 +87,14 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         stopTimer?.();
         stopTimer = undefined;
         const recover = recoveryPending;
+        let retryRecovery = recover;
         // Consume only when a read starts: faults during its await latch one follow-up recovery.
         recoveryPending = false;
         try {
             const message = await ports.read({ runId, ...(messageId ? { messageId } : {}) }, { recover });
             if (stopped || !message)
                 return;
+            retryRecovery = false;
             if (message === "gone") {
                 stop();
                 handlers.onDone([]);
@@ -101,6 +103,10 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
             applySavedMessage(message);
         }
         finally {
+            // Recovery must return a body before conditional polls resume: a failed recovery followed
+            // by unchanged (304) polls would otherwise leave a quiet run's dropped stream closed.
+            if (retryRecovery)
+                recoveryPending = true;
             reading = false;
             if (!stopped) {
                 // Always schedule: an error arriving during read must not create a tight recovery loop.

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

@@ -4,7 +4,7 @@ export type { AssistantTransportPorts, AssistantTransportOptions, AssistantTrans
 export type { AgUiClient, AgUiClientPorts, AgUiRunClient, AgUiEventContext } from "./ag-ui-transport.js";
 export { followDurableRun } from "./durable-run-subscription.js";
 export type { DurableRunBinding, DurableSubscriptionPorts } from "./durable-run-subscription.js";
-export { activeRunStub, messageWriteKey, persistableMessages } from "./messages.js";
+export { activeRunStub, messageWriteKey, persistableMessages, createConditionalHistoryRead } from "./messages.js";
 export type { AssistantConversation } from "./messages.js";
 export { createChatAttachmentValidator } from "./attachment-liveness.js";
 export type { ChatAttachmentValidatorInput, ChatAttachmentValidatorOptions } from "./attachment-liveness.js";

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

@@ -1,7 +1,7 @@
 /** Daemon/BYOK/AG-UI chat client lifecycles. Host routes, identity and authenticated I/O are ports. */
 export { createAssistantTransportClient } from "./transport.js";
 export { followDurableRun } from "./durable-run-subscription.js";
-export { activeRunStub, messageWriteKey, persistableMessages } from "./messages.js";
+export { activeRunStub, messageWriteKey, persistableMessages, createConditionalHistoryRead } from "./messages.js";
 export { createChatAttachmentValidator } from "./attachment-liveness.js";
 export { createA2uiActionPoster } from "./a2ui-action-poster.js";
 //# sourceMappingURL=entry.js.map

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

@@ -70,4 +70,25 @@ export declare function messageWriteKey({ message }: {
 export declare function activeRunStub({ messages }: {
     messages: ChatMessage[];
 }, _options?: Record<string, never>): ChatMessage | null;
+/** Retain only the last history response by reference, while reauthorizing every refresh at the
+ * server. An unchanged reply reuses it without reading/parsing the whole conversation again.
+ * @param required.read Host HTTP adapter; version is opaque and scoped to one conversation.
+ * @returns An async history reader. Port failures clear its snapshot and propagate.
+ * @throws If an adapter returns unchanged without an earlier snapshot (a port contract violation).
+ * @complexity O(1) local work; one retained snapshot reference, with no message/event copies.
+ * @example const load = createConditionalHistoryRead({ read }); await load({ conversationId });
+ */
+export declare function createConditionalHistoryRead({ read }: {
+    read: (required: {
+        conversationId: string;
+    }, optional: {
+        version?: string | undefined;
+    }) => Promise<{
+        messages?: ChatMessage[];
+        version?: string | undefined;
+        unchanged?: boolean;
+    }>;
+}, _options?: {}): ({ conversationId }: {
+    conversationId: string;
+}, _optional?: {}) => Promise<ChatMessage[]>;
 //# sourceMappingURL=messages.d.ts.map

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

@@ -65,4 +65,35 @@ export function activeRunStub({ messages }, _options = {}) {
         return null;
     return isTerminalRunStatus({ status: last.runStatus }) ? null : last;
 }
+/** Retain only the last history response by reference, while reauthorizing every refresh at the
+ * server. An unchanged reply reuses it without reading/parsing the whole conversation again.
+ * @param required.read Host HTTP adapter; version is opaque and scoped to one conversation.
+ * @returns An async history reader. Port failures clear its snapshot and propagate.
+ * @throws If an adapter returns unchanged without an earlier snapshot (a port contract violation).
+ * @complexity O(1) local work; one retained snapshot reference, with no message/event copies.
+ * @example const load = createConditionalHistoryRead({ read }); await load({ conversationId });
+ */
+export function createConditionalHistoryRead({ read }, _options = {}) {
+    let saved;
+    return async ({ conversationId }, _optional = {}) => {
+        const previous = saved?.conversationId === conversationId ? saved : undefined;
+        try {
+            const result = await read({ conversationId }, { version: previous?.version });
+            if (result.unchanged) {
+                if (!previous)
+                    throw new Error('Unchanged history requires an earlier snapshot');
+                return previous.messages;
+            }
+            // Same coercion/reason as a conversation list: initialMessages must never be undefined.
+            // A successful transport guarantees JSON syntax, not the response object's field shape.
+            const messages = Array.isArray(result.messages) ? result.messages : [];
+            saved = { conversationId, messages, version: result.version };
+            return messages;
+        }
+        catch (error) {
+            saved = undefined;
+            throw error;
+        }
+    };
+}
 //# sourceMappingURL=messages.js.map

package/dist/core/checkpoint-interval.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Select the checkpoint delay for an approximate saved-projection size.
+ * @param required.bytes Approximate payload size in bytes; thresholds use decimal MB.
+ * @returns 1 s below 1 MB, 3 s from 1 MB, and 10 s from 5 MB. Pure; no side effects.
+ * @complexity O(1) time and space.
+ */
+export declare function checkpointIntervalMs({ bytes }: {
+    bytes: number;
+}, _options?: {}): number;
+/** Count durable progress without materializing the saved projection. Thinking and extension
+ * receipts must survive a crash even before the next answer/tool. Status chatter and duplicate
+ * tool echoes must not trigger another multi-MB compaction.
+ * @param required.events Current renderable projection; never mutated.
+ * @returns Text/thinking characters, extension count and unique tool identities.
+ * @complexity O(events) time and O(unique tool identities) space.
+ * @example checkpointProgress({ events: [{ kind: 'thinking', text: 'Working' }] });
+ */
+export declare function checkpointProgress({ events }: {
+    events: readonly import('./events.js').AgentEvent[];
+}, _options?: {}): {
+    textCharacters: number;
+    extensionEvents: number;
+    tools: Set<string>;
+};
+//# sourceMappingURL=checkpoint-interval.d.ts.map

package/dist/core/checkpoint-interval.js

@@ -0,0 +1,38 @@
+/**
+ * Select the checkpoint delay for an approximate saved-projection size.
+ * @param required.bytes Approximate payload size in bytes; thresholds use decimal MB.
+ * @returns 1 s below 1 MB, 3 s from 1 MB, and 10 s from 5 MB. Pure; no side effects.
+ * @complexity O(1) time and space.
+ */
+export function checkpointIntervalMs({ bytes }, _options = {}) {
+    if (bytes >= 5_000_000)
+        return 10_000;
+    if (bytes >= 1_000_000)
+        return 3_000;
+    return 1_000;
+}
+/** Count durable progress without materializing the saved projection. Thinking and extension
+ * receipts must survive a crash even before the next answer/tool. Status chatter and duplicate
+ * tool echoes must not trigger another multi-MB compaction.
+ * @param required.events Current renderable projection; never mutated.
+ * @returns Text/thinking characters, extension count and unique tool identities.
+ * @complexity O(events) time and O(unique tool identities) space.
+ * @example checkpointProgress({ events: [{ kind: 'thinking', text: 'Working' }] });
+ */
+export function checkpointProgress({ events }, _options = {}) {
+    let textCharacters = 0;
+    let extensionEvents = 0;
+    const tools = new Set();
+    for (const event of events) {
+        if (event.kind === 'text' || event.kind === 'thinking')
+            textCharacters += event.text.length;
+        if (event.kind === 'ext')
+            extensionEvents++;
+        if (event.kind === 'tool_use')
+            tools.add(`tool_use:${event.id}`);
+        if (event.kind === 'tool_result')
+            tools.add(`tool_result:${event.toolUseId}`);
+    }
+    return { textCharacters, extensionEvents, tools };
+}
+//# sourceMappingURL=checkpoint-interval.js.map

package/dist/core/durable-runs/ledger-contracts.d.ts

@@ -20,8 +20,34 @@ export interface ChatRunRecoveryOptions {
      * Called outside storage transactions so a daemon request cannot hold the database lock. */
     readonly recover?: (input: InterruptedChatTurn) => Promise<boolean>;
 }
+/** Watch-owned receipt for the last exact incoming projection. SQL lengths count characters,
+ * not UTF-16 code units. A saved-only tool barrier invalidates this receipt. */
+export interface CheckpointState {
+    /** Native row/connection version guards equal-length changes outside the bounded suffix. */
+    readonly version: string;
+    readonly length: number;
+    /** SQL character count, avoiding a second full content parameter in CAS. */
+    readonly contentLength: number;
+    /** SQL characters in the complete last serialized event plus closing array bracket. */
+    readonly tailLength: number;
+    readonly content: string;
+    readonly events: readonly import("../events.js").AgentEvent[];
+    /** At most 256 UTF-16 units of the saved suffix; never the whole last tool result. */
+    readonly tail: string;
+}
+export interface CheckpointOptions {
+    readonly expected?: number | undefined;
+    readonly previous?: CheckpointState | undefined;
+    /** Undefined means the authoritative merge retained saved-only events: use the full path next. */
+    readonly onPersisted?: (state: CheckpointState | undefined) => void;
+}
 export interface ChatRunLedger {
     readonly durable?: DurableRunStore;
+    /** Read-only existence probe across all owners. Only queued/running assistant rows block idle
+     * shutdown; no transcript payloads, recovery or writes. Rejects on storage failure (host stays busy).
+     * @example if (await ledger.hasActiveRuns({}, {})) return;
+     */
+    hasActiveRuns(required?: {}, optional?: {}): Promise<boolean>;
     /**
      * Runs `write` only while `run`'s row holds no terminal status (an unknown row, another run id, or
      * a row still `queued`/`running` all count as unsettled), with no settle able to land in between.
@@ -43,7 +69,7 @@ export interface ChatRunLedger {
      * A no-op once the row is terminal or belongs to another run. Resolves `true` when it wrote, or
      * when the row already held exactly this checkpoint (accepted without rewriting the row).
      */
-    checkpoint(progress: RunProgress, optional?: {}): Promise<boolean>;
+    checkpoint(progress: RunProgress, optional?: CheckpointOptions): Promise<boolean>;
     /** Serving-only discovery of unfinished rows. The injected recovery coordinator owns adopted
      * runs; rows it cannot adopt are canceled, preserving saved work. Returns handled rows.
      * Export apps must not invoke discovery while a serving daemon is still alive. */

package/dist/core/durable-runs/ports.d.ts

@@ -27,10 +27,34 @@ export interface DurableRun extends RunRef {
 /** A run without its conversation transcript: what a fence, lock or tool guard reads. `message`
  * still carries the run's own saved events; only `load`/`accept`/`cancelPending` read every message. */
 export type DurableRunHead = Omit<DurableRun, "transcript">;
+/** Raw current-message projection. An absent messageJson means the cursor is unchanged. */
+export interface DurableRunPoll {
+    readonly cursor: string;
+    readonly conversationId?: string;
+    readonly messageJson?: string;
+}
 export interface DurableRunStore {
+    /** Owner-scoped, unlocked poll. No transcript read or event parse; unchanged omits payloads. */
+    poll?(required: {
+        messageId: string;
+        principalId: string;
+        workspaceId: string;
+    }, optional: {
+        cursor?: string;
+    }): Promise<DurableRunPoll | null>;
+    /** `includeTranscriptEvents:false` omits prior assistant payloads, keeping current-run events
+     * and user receipts that preserve queued inputs and folder references. Defaults to a full read. */
     load(required: {
         messageId: string;
-    }, optional: {}): Promise<DurableRun | null>;
+    }, optional: {
+        includeTranscriptEvents?: boolean;
+    }): Promise<DurableRun | null>;
+    /** Follow the current attempt by message id without loading its conversation. */
+    head?(required: {
+        messageId: string;
+    }, optional: {
+        events?: boolean;
+    }): Promise<DurableRunHead | null>;
     /** Reads only this run's message and attempt rows; `load` when the transcript is needed. */
     find(required: {
         runId: string;

package/dist/core/index.d.ts

@@ -39,4 +39,5 @@ export { turnUsage, conversationUsage, replySegments, isReplyBoundary, MID_RUN_U
 export { formatUsageCost } from './usage-format.js';
 export * from './accepted-input.js';
 export * from './question-answer.js';
+export { checkpointIntervalMs, checkpointProgress } from './checkpoint-interval.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -38,4 +38,5 @@ export { turnUsage, conversationUsage, replySegments, isReplyBoundary, MID_RUN_U
 export { formatUsageCost } from './usage-format.js';
 export * from './accepted-input.js';
 export * from './question-answer.js';
+export { checkpointIntervalMs, checkpointProgress } from './checkpoint-interval.js';
 //# sourceMappingURL=index.js.map

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

@@ -14,9 +14,12 @@ import type { AgentEvent } from './events.js';
  *   `k` is the number of distinct `tool_use` ids seen — one linear pass with
  *   a `Set` membership check.
  */
-export declare function dedupeToolUsesById({ events }: {
+export declare function dedupeToolUsesById(required: {
     events: AgentEvent[] | undefined;
-}): AgentEvent[];
+}, optional?: {}): AgentEvent[];
+export declare function dedupeToolUsesById(required: {
+    events: readonly AgentEvent[] | undefined;
+}, optional?: {}): readonly 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

package/dist/core/tool-events.js

@@ -1,21 +1,6 @@
 import { canonicalJson } from '@jini-ai/core/records';
 import { toolPresentation } from './tool-presentation.js';
-/**
- * Drop repeated `tool_use` events that share an `id`. A retried/duplicated
- * stream can replay the same tool-call id (e.g. reconnect-and-replay landing
- * an event twice); rendering it twice would show a phantom second call.
- * Non-`tool_use` events (and the first occurrence of each id) pass through
- * unchanged and in original order.
- *
- * @param events - The event list to dedupe, or `undefined` for an empty conversation turn.
- * @returns A new array with later duplicate `tool_use` events removed, or the
- *   original array reference when nothing needed to change (cheap no-op for
- *   the common case).
- * @complexity O(n) time / O(k) extra space, where `n` is `events.length` and
- *   `k` is the number of distinct `tool_use` ids seen — one linear pass with
- *   a `Set` membership check.
- */
-export function dedupeToolUsesById({ events }) {
+export function dedupeToolUsesById({ events }, _optional) {
     if (!events || events.length === 0)
         return [];
     const seen = new Set();

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

@@ -30,9 +30,9 @@ export interface ComposerProps {
     /** Cancels the in-flight run. Required when `running` is true; ignored otherwise. */
     onCancel?: () => void;
     /**
-     * Cmd/Ctrl+Enter: end the run in flight and send this draft next. Optional — without it the
-     * modifier falls through to the ordinary Enter path, so a host that has not opted in keeps
-     * exactly its previous behavior.
+     * Cmd/Ctrl+Enter: optional host send shortcut. ChatPane shares the ordinary mid-run delivery
+     * path so sending keeps the current run going. Without this callback the modifier falls
+     * through to ordinary Enter, so a host that has not opted in keeps its previous behavior.
      */
     onInterrupt?: () => void;
     /**

package/dist/react/components/Composer.js

@@ -273,9 +273,9 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
     function submitFromEnter(event) {
         if (disabled || !composer.canSubmit)
             return;
-        // Cmd/Ctrl+Enter ends the current run and sends this next; plain Enter queues behind it.
-        // `sendDisabled` is deliberately NOT consulted on the interrupt path — while a run streams it
-        // is set precisely BECAUSE of that run, which is the one case this modifier exists to act on.
+        // Cmd/Ctrl+Enter uses the host shortcut; ChatPane routes it through the ordinary send guards.
+        // `sendDisabled` is deliberately NOT consulted here: hosts can offer a shortcut while a run
+        // itself blocks ordinary sends. ChatPane queues or delivers live without cancelling the run.
         if ((event.metaKey || event.ctrlKey) && onInterrupt) {
             onInterrupt();
             return;

package/dist/react/components/MessageList.js

@@ -38,7 +38,8 @@ export const MessageList = memo(function MessageList({ messages: sourceMessages,
                 message,
                 isLast: message.id === messages[messages.length - 1]?.id,
                 // A reply's start is accepted together with its user turn (`inputPending` clears then).
-                sending: messages[index - 1]?.inputPending === true,
+                // A run id also proves acceptance after reload, when a legacy pending flag can survive.
+                sending: message.runId === undefined && messages[index - 1]?.inputPending === true,
                 isStreaming,
                 usageSummary: usageByMessage.get(message.id),
             }, rowProps)), (pendingPrompts ?? (pendingPrompt ? [pendingPrompt] : [])).map((prompt, index) => (_jsx(QueuedMessage, { prompt: prompt, renderAttachment: rowProps.renderAttachment }, prompt.id ?? index))), awayFromLatest && _jsx(JumpToLatest, { onJump: jumpToLatest })] }));

package/dist/react/components/MidRunUserMessage.js

@@ -49,7 +49,7 @@ function MidRunInput({ input, queued, transcriptRow }) {
     const t = useT();
     const attachments = input.attachments ?? [];
     const gallery = useAttachmentGallery({ attachments });
-    return (_jsxs("div", { className: `jini-message jini-message-user${transcriptRow ? '' : ' jini-message-user--mid-run'}`, "data-agent-role": "region", "data-agent-label": "A message from the user, sent while the agent was working", children: [queued && _jsx("div", { className: "jini-message-user__queued", role: "status", children: t('Queued — read after the current step') }), input.folders?.length ? _jsx("div", { className: "jini-message-attachments", children: _jsx(FolderChips, { folders: input.folders }) }) : null, _jsx("div", { className: "jini-message-content", children: input.text }), attachments.length > 0 && _jsx("div", { className: "jini-message-attachments", children: attachments.map(attachment => _jsx(SentAttachmentButton, { attachment: attachment, onOpen: gallery.open }, attachment.path)) }), _jsx("div", { className: "jini-message-actions jini-message-actions--user", children: _jsx(CopyMessageButton, { text: input.text, label: t('Copy message') }) }), gallery.opened !== null && _jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })] }));
+    return (_jsxs("div", { className: `jini-message jini-message-user${transcriptRow ? '' : ' jini-message-user--mid-run'}`, "data-agent-role": "region", "data-agent-label": "A message from the user, sent while the agent was working", children: [queued && _jsx("div", { className: "jini-chat-pane__status jini-message-user__queued", role: "status", children: t('Queued — read after the current step') }), input.folders?.length ? _jsx("div", { className: "jini-message-attachments", children: _jsx(FolderChips, { folders: input.folders }) }) : null, _jsx("div", { className: "jini-message-content", children: input.text }), attachments.length > 0 && _jsx("div", { className: "jini-message-attachments", children: attachments.map(attachment => _jsx(SentAttachmentButton, { attachment: attachment, onOpen: gallery.open }, attachment.path)) }), _jsx("div", { className: "jini-message-actions jini-message-actions--user", children: _jsx(CopyMessageButton, { text: input.text, label: t('Copy message') }) }), gallery.opened !== null && _jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })] }));
 }
 /**
  * Registers {@link MidRunUserMessage} against the ext-event registry.

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

@@ -225,7 +225,7 @@ function ChatPaneComposerArea({ fileDrop, uploadAttachments, pane, disabled, una
                 // rather than refusing it, so the operator can keep writing while the agent thinks.
                 disabled: disabled || unavailable, 
                 // The one blocker `send()` handles itself. Every other refusal still greys out the button.
-                sendDisabled: !pane.canSend && pane.sendBlocker !== 'streaming', ...definedProps({ source: { sendDisabledReason, sendDisabledReasonId: sendDisabledReason ? sendDisabledReasonId : undefined } }), running: pane.conversation.isStreaming, onCancel: pane.conversation.cancel, onInterrupt: pane.interruptSend, ...definedProps({ source: { placeholder } }), slots: { ...slots, footerAccessories: _jsxs(_Fragment, { children: [sendDisabledReason ? _jsx("small", { id: sendDisabledReasonId, className: "jini-composer-send-blocker", children: sendDisabledReason }) : null, slots.footerAccessories] }) }, ...resolveComposerAttachmentPicker(uploadAttachments, pane, attachmentAccept), ...resolveComposerWorkingDirectory(workingDirectoryAccess, workingDirectoryControlPlacement, pane) }), _jsx(ChatPaneWorkingDirectoryBlock, { workingDirectoryAccess: workingDirectoryAccess, workingDirectoryControlPlacement: workingDirectoryControlPlacement, pane: pane, t: t })] }));
+                sendDisabled: !pane.canSend && pane.sendBlocker !== 'streaming', ...definedProps({ source: { sendDisabledReason, sendDisabledReasonId: sendDisabledReason ? sendDisabledReasonId : undefined } }), running: pane.conversation.isStreaming, onCancel: pane.conversation.cancel, ...definedProps({ source: { placeholder } }), slots: { ...slots, footerAccessories: _jsxs(_Fragment, { children: [sendDisabledReason ? _jsx("small", { id: sendDisabledReasonId, className: "jini-composer-send-blocker", children: sendDisabledReason }) : null, slots.footerAccessories] }) }, ...resolveComposerAttachmentPicker(uploadAttachments, pane, attachmentAccept), ...resolveComposerWorkingDirectory(workingDirectoryAccess, workingDirectoryControlPlacement, pane) }), _jsx(ChatPaneWorkingDirectoryBlock, { workingDirectoryAccess: workingDirectoryAccess, workingDirectoryControlPlacement: workingDirectoryControlPlacement, pane: pane, t: t })] }));
 }
 const EMPTY_SUGGESTIONS = [];
 const CHAT_PANE_DEFAULTS = {

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.d.ts

@@ -115,10 +115,11 @@ export interface UseChatPaneResult extends UseChatPaneWorkingDirectoryResult {
      */
     sendAsNewMessage: () => Promise<void>;
     /**
-     * Cancels the run in flight and sends the composer draft as soon as it stops — the modifier-key
-     * counterpart to {@link send}, which queues behind the run instead of ending it. Implemented as
-     * queue-then-cancel rather than cancel-then-send so both paths share one flush, and so a cancel
-     * that never lands cannot strand the prompt.
+     * @deprecated Use send and let Composer apply sendDisabled to keyboard shortcuts.
+     * Legacy name for the modifier-key send shortcut; uses {@link send} and keeps the run going.
+     * Previously queue-then-cancel rather than cancel-then-send kept both paths on one flush so a
+     * cancel that never landed could not strand the prompt. Sharing send now also preserves that
+     * queue ownership, while a capable run reads the input after its current step.
      */
     interruptSend: () => void;
     reset: () => void;

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

@@ -756,15 +756,9 @@ export function useChatPane(options) {
         guard.clearNotice();
         await sendOrdinaryTurn(prompt);
     }, [composer, guard.clearNotice, sendOrdinaryTurn]);
-    const interruptSend = useCallback(() => {
-        const prompt = composerPrompt(composer);
-        if (!prompt || composerDeliveryBlocked({ delivering: deliveringTypedAnswerRef.current, starting: startingPromptRef.current, composer, submitted: submittedComposerRef.current }))
-            return;
-        guard.clearNotice();
-        enqueueTurn({ turn: guard.redact({ text: prompt }, {}) });
-        composer.setDraft('');
-        conversation.cancel();
-    }, [composer, conversation, enqueueTurn, guard.clearNotice, guard.redact]);
+    // A send shortcut must honor the same mid-run delivery contract as the Send button.
+    // Unsupported agents wait behind the current reply; only the explicit Stop action cancels it.
+    const interruptSend = useCallback(() => { void send(); }, [send]);
     /** Abort only uploads owned by the removed inputs; late completions must not refill the composer. */
     const discardQueuedUploads = useCallback(({ id }, _options = {}) => {
         for (const [controller, owner] of queuedUploadOwnersRef.current) {