@jini-ai/chat 0.6.5 → 0.6.7

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 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).
+- The Done line for tokens-only runtimes uses run timestamps and the known total (9fd89d41).
+- An unknown tool on the read-only gateway points the model to discovery, never a mutation 409 (75d37c32).
+- A run that could not continue says why, and a wait for the owner is never reported as "no progress" (13e90536).
+- The model picker shows the default model by name, not its raw id (6b4b613d).
+
 ## 0.6.5 — 2026-10-15
 
 - Durable recovery no longer gives up on a finished CLI turn (8c6acfea): a saved successful Claude CLI `result` line carries `modelUsage.contextWindow`, which matched the context-limit pattern case-insensitively, so a dropped stream or restart ended the answer with "The assistant could not continue this answer" instead of continuing it. The pattern now requires a separator, and attempt diagnostics skip successful CLI result lines (`type: "result"`, `is_error: false`).

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[];