@teaflask/assistant 0.0.0 → 0.3.0

package/dist/core/conversation-contract.d.ts

@@ -0,0 +1,95 @@
+import type { ServedThinkingEffort } from "../contract/assistant-config.js";
+import type { AssistantTelemetryEvent } from "../contract/telemetry.js";
+import type { ServingAssistantThread, ServingAssistantTurn, TurnAttachment } from "../contract/threads.js";
+import type { ServingReplayStreamAgent } from "../transport/replay-stream-agent.js";
+import type { ServingApiError } from "../transport/serving-error.js";
+import type { StreamResumeStore } from "../transport/stream-resume.js";
+import type { TokenSession } from "../transport/token-session.js";
+import type { ApprovalInbox } from "./approval-inbox.js";
+import type { AttachmentDraft } from "./composer-policy.js";
+import type { ExecuteActionIntent, HostNavigate } from "./execution-handlers.js";
+import type { ReadonlyCell } from "./observable-cell.js";
+import type { PendingDecisionGap } from "./pending-decision-gap.js";
+import type { UserTurnLedger } from "./user-turn-ledger.js";
+export interface ActiveConversation {
+    thread: ServingAssistantThread;
+    ledger: UserTurnLedger;
+    resume: StreamResumeStore;
+    approvalInbox: ApprovalInbox;
+    coworkerRequestTurns: readonly ServingAssistantTurn[];
+}
+/** The composer's contract with the page, travelling by context (it renders
+ *  standalone and inside the transcript) as one snapshot of its own inputs. */
+export interface ComposerContract {
+    busy: boolean;
+    pendingSend: boolean;
+    sendMessage: (message: string, attachmentIds?: string[], optimisticAttachments?: TurnAttachment[]) => Promise<boolean>;
+    pendingEcho: {
+        messageId: string;
+        text: string;
+        attachments: TurnAttachment[];
+    } | null;
+    composerRefocusPending: boolean;
+    markComposerRefocusHandled: () => void;
+    stopping: boolean;
+    stopTurn: () => Promise<void>;
+    modelPick: ComposerModelPick | null;
+    setModelPick: (pick: ComposerModelPick) => void;
+    composerInput: ReadonlyCell<ComposerInput>;
+    setDraft: (next: string | ((current: string) => string)) => void;
+    setAttachments: (next: readonly AttachmentDraft[] | ((current: readonly AttachmentDraft[]) => readonly AttachmentDraft[])) => void;
+    noteComposerFocus: (owner: string | null) => void;
+    takeComposerCaretReturn: (surface: string) => boolean;
+}
+/** The composer's unsaved input, the composer-only cell's snapshot. */
+export interface ComposerInput {
+    scope: string;
+    draft: string;
+    attachments: readonly AttachmentDraft[];
+}
+/** One chip selection. A null modelId is a real state — no model pin: the
+ *  configured model answers under the picked effort (the way back). */
+export interface ComposerModelPick {
+    modelId: string | null;
+    effort: ServedThinkingEffort | null;
+}
+export type { AttachmentDraft } from "./composer-policy.js";
+export type { ApprovalDecisionInput } from "./approval-inbox.js";
+export interface ConversationSnapshot {
+    active: ActiveConversation | null;
+    threads: ServingAssistantThread[];
+    historyExpected: boolean;
+    threadOpening: boolean;
+    reconnectNonce: number;
+    sendError: string | null;
+    turnFailure: string | null;
+    showInterruptionBanner: boolean;
+    pendingDecisionGap: PendingDecisionGap | null;
+}
+export interface HostCapabilities {
+    navigate: HostNavigate | null;
+    executeActionIntent: ExecuteActionIntent | null;
+}
+export interface ConversationStoreDeps {
+    session: TokenSession;
+    publishableKey: string;
+    identityProvided: boolean;
+    hostCapabilitiesOf: () => HostCapabilities;
+    reportError: (error: Error) => void;
+    onTelemetry: (event: AssistantTelemetryEvent) => void;
+    onGateRefusal: (error: ServingApiError) => void;
+    onTurnSettled: () => void;
+}
+/** What a mounted transcript needs from the live connection epoch. */
+export interface ConnectionSnapshot {
+    epochId: number;
+    agent: ServingReplayStreamAgent;
+    threadId: string;
+    streamThreadId: string;
+}
+/** A presigned display URL and the moment it stops being safe for an <img>. */
+export interface MintedDownloadUrl {
+    url: string;
+    expiresAtMs: number;
+}
+//# sourceMappingURL=conversation-contract.d.ts.map

package/dist/core/conversation-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-contract.d.ts","sourceRoot":"","sources":["../../src/core/conversation-contract.ts"],"names":[],"mappings":"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"}

package/dist/core/conversation-contract.js

@@ -0,0 +1,4 @@
+// The conversation store's contract surface: the names a host or chrome
+// component uses to talk to AssistantConversationStore.
+export {};
+//# sourceMappingURL=conversation-contract.js.map

package/dist/core/conversation-contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-contract.js","sourceRoot":"","sources":["../../src/core/conversation-contract.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,wDAAwD"}

package/dist/core/conversation-publish.d.ts

@@ -0,0 +1,9 @@
+import type { ComposerContract, ConversationSnapshot } from "./conversation-contract.js";
+import type { AssistantConversationStore } from "./conversation-store.js";
+export declare function publishStore(store: AssistantConversationStore): void;
+export declare function scheduleConnectionSync(store: AssistantConversationStore): void;
+export declare function conversationSnapshotOf(store: AssistantConversationStore): ConversationSnapshot;
+export declare function noteInterruptAnswerConsumed(store: AssistantConversationStore, runId: string, interruptId: string, round: number): void;
+export declare function composerSnapshotOf(store: AssistantConversationStore): ComposerContract;
+export declare function busyOf(store: AssistantConversationStore): boolean;
+//# sourceMappingURL=conversation-publish.d.ts.map

package/dist/core/conversation-publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-publish.d.ts","sourceRoot":"","sources":["../../src/core/conversation-publish.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAc1E,wBAAgB,YAAY,CAAC,KAAK,EAAE,0BAA0B,GAAG,IAAI,CA0BpE;AAOD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,0BAA0B,GAChC,IAAI,CASN;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,0BAA0B,GAChC,oBAAoB,CAoBtB;AAiCD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,0BAA0B,EACjC,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GACZ,IAAI,CAIN;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,0BAA0B,GAChC,gBAAgB,CAkBlB;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAUjE"}

package/dist/core/conversation-publish.js

@@ -0,0 +1,165 @@
+// Publishing: the one place snapshots rebuild and cells emit — a cell's
+// identity changes iff its content did (the useSyncExternalStore
+// contract), the epoch/connection/idle syncs key off the same pass, and
+// the pending-decision gap re-judges on every publish. The re-entrancy
+// latch (_inPublish) stays a store field — the gap gate's judge-driven
+// transitions fire inside publishStore.
+import { syncConnection } from "./connection-driver.js";
+import { historyExpected, sameModelPick } from "./conversation-adoption.js";
+import { publishActivity, syncEpoch, theAnswerablePause, } from "./epoch-sync.js";
+import { syncIdleRecheck } from "./idle-recheck.js";
+import { pendingDecisionGapOf } from "./pending-decision-gap.js";
+import { bannerFailureSentenceOf } from "./turn-failure-copy.js";
+// Rebuilds both snapshots and emits only the ones that actually moved,
+// so a cell's identity changes iff its content did — the contract
+// useSyncExternalStore's cached-snapshot semantics depend on. The
+// connection epoch keys off the same state, so it syncs here too.
+export function publishStore(store) {
+    // The re-entrancy latch is the gap gate's: a judge-driven transition
+    // fires inside this function (below), where writing _pendingDecisionGap
+    // suffices — the snapshot build reads it. Only the gate's timer-driven
+    // transitions, firing outside any publish, trigger their own.
+    store._inPublish = true;
+    try {
+        syncEpoch(store);
+        _updatePendingDecisionGap(store);
+        _publishTurnMeta(store);
+        const conversation = conversationSnapshotOf(store);
+        if (!_sameConversationSnapshot(conversation, store._conversationCell.get())) {
+            store._conversationCell.set(conversation);
+        }
+        const composer = composerSnapshotOf(store);
+        if (!_sameComposerSnapshot(composer, store._composerCell.get())) {
+            store._composerCell.set(composer);
+        }
+        publishActivity(store);
+        scheduleConnectionSync(store);
+        syncIdleRecheck(store);
+    }
+    finally {
+        store._inPublish = false;
+    }
+}
+// The connect decision is deferred to a coalesced microtask so a
+// presence transition that resolves within the same synchronous tick —
+// a keyed transcript REMOUNT releases then re-acquires back-to-back —
+// is seen settled before the store acts. The check re-reads live at
+// fire time.
+export function scheduleConnectionSync(store) {
+    if (store._connectionSyncQueued || store._disposed) {
+        return;
+    }
+    store._connectionSyncQueued = true;
+    queueMicrotask(() => {
+        store._connectionSyncQueued = false;
+        syncConnection(store);
+    });
+}
+export function conversationSnapshotOf(store) {
+    return {
+        active: store._active,
+        threads: store._threads,
+        historyExpected: historyExpected(store),
+        threadOpening: store._threadOpening,
+        reconnectNonce: store._reconnectNonce,
+        sendError: store._sendError,
+        turnFailure: bannerFailureSentenceOf(store._turnFailure, store._active?.resume.turnFailedAnchors),
+        // Never during a stop: a member who pressed stop did the
+        // interrupting themselves, and any interruption recorded inside the
+        // ~2s stop window (the dying stream's own error path) is that stop's
+        // mechanics, not connection trouble worth a banner.
+        showInterruptionBanner: store._streamInterrupted && busyOf(store) && !store._stopping,
+        pendingDecisionGap: store._pendingDecisionGap,
+    };
+}
+// Re-judges the pending-decision gap against the current
+// truth: the turn's server-named interrupt ids vs every holder this
+// client has — approval cards (hydrate-before-reconcile already ran on
+// any REST adoption), elicitation cards, and the execution inbox's
+// entries. Runs on every publish so any path that moves cards, entries
+// or the turn re-judges; the derivation itself is pure and cheap. The
+// quiet→loud grace, the once-per-signature probe, and the loud
+// tracking all live in the shared PendingDecisionGapGate (its docblock
+// enumerates the transitions); this store's premises for the gate's
+// three deps are recorded at the _gapGate field.
+function _updatePendingDecisionGap(store) {
+    if (store._disposed) {
+        return;
+    }
+    // The gap watchdog judges the PAUSE (the queuing class): with a
+    // message queued newer than the pause, the newest row reads
+    // "queued" and the derivation would go quiet in exactly the
+    // missing-card state it exists to alarm on. Falls back to the
+    // newest row so the no-pause shapes keep their null verdict.
+    const pause = theAnswerablePause(store) ?? store._newestTurn;
+    store._gapGate.judge(pendingDecisionGapOf(pause, store._active?.approvalInbox.cards() ?? [], store._elicitationsCell.get(), store._epoch?.executionInbox.entries() ?? [], store._consumedInterrupts.idsOf(pause?.run_id, pause?.awaiting_round)));
+}
+export function noteInterruptAnswerConsumed(store, runId, interruptId, round) {
+    if (store._consumedInterrupts.note(runId, interruptId, round)) {
+        publishStore(store);
+    }
+}
+export function composerSnapshotOf(store) {
+    return {
+        busy: busyOf(store),
+        pendingSend: store._pendingSend,
+        sendMessage: store.sendMessage,
+        pendingEcho: store._pendingEcho,
+        composerRefocusPending: store._composerRefocusPending,
+        markComposerRefocusHandled: store.markComposerRefocusHandled,
+        stopping: store._stopping,
+        stopTurn: store.stopTurn,
+        modelPick: store._modelPick,
+        setModelPick: store.setModelPick,
+        composerInput: store._composerInput,
+        setDraft: store.setComposerDraft,
+        setAttachments: store.setComposerAttachments,
+        noteComposerFocus: store.noteComposerFocus,
+        takeComposerCaretReturn: store.takeComposerCaretReturn,
+    };
+}
+export function busyOf(store) {
+    // The composer lock, Stop button and interruption banner follow the
+    // turn record: a parked turn is never busy, whatever a
+    // stale thread.busy says — there is no run to stop, and the visitor's
+    // next message is the designed withdraw path.
+    return (((store._active?.thread.busy ?? false) &&
+        store._newestTurn?.status !== "parked") ||
+        store._pendingSend);
+}
+function _publishTurnMeta(store) {
+    const ledger = store._active?.ledger ?? null;
+    const version = ledger?.version ?? -1;
+    if (ledger === store._publishedMetaLedger &&
+        version === store._publishedMetaVersion) {
+        return;
+    }
+    store._publishedMetaLedger = ledger;
+    store._publishedMetaVersion = version;
+    store._turnMetaCell.set(ledger !== null ? ledger.metaByMessageId() : new Map());
+}
+function _sameConversationSnapshot(a, b) {
+    return (a.active === b.active &&
+        a.threads === b.threads &&
+        a.historyExpected === b.historyExpected &&
+        a.threadOpening === b.threadOpening &&
+        a.reconnectNonce === b.reconnectNonce &&
+        a.sendError === b.sendError &&
+        a.turnFailure === b.turnFailure &&
+        a.showInterruptionBanner === b.showInterruptionBanner &&
+        // Reference identity is sound: the store keeps the published gap
+        // reference-stable while its signature holds.
+        a.pendingDecisionGap === b.pendingDecisionGap);
+}
+function _sameComposerSnapshot(a, b) {
+    return (a.busy === b.busy &&
+        a.pendingSend === b.pendingSend &&
+        a.pendingEcho === b.pendingEcho &&
+        a.composerRefocusPending === b.composerRefocusPending &&
+        a.stopping === b.stopping &&
+        // composerInput is deliberately absent: it is the same cell object
+        // on every snapshot — its VALUE moves per keystroke, and only the
+        // composer's own useCell subscription pays for that.
+        sameModelPick(a.modelPick, b.modelPick));
+}
+//# sourceMappingURL=conversation-publish.js.map

package/dist/core/conversation-publish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-publish.js","sourceRoot":"","sources":["../../src/core/conversation-publish.ts"],"names":[],"mappings":"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"}

package/dist/core/conversation-refresh.d.ts

@@ -0,0 +1,14 @@
+import type { AssistantConversationStore } from "./conversation-store.js";
+export declare function refreshConversationFromStore(store: AssistantConversationStore): Promise<void>;
+/** A surface's roster poll observed a dispatch settle — the
+ *  one frontend-visible signal that a delivery turn may be about to
+ *  open on this thread. Re-reads the conversation in a bounded burst
+ *  until the claim shows up (a queued/working newest turn; adoption's
+ *  publish attaches the stream through the ordinary connect sync), the
+ *  thread changes, or the window exhausts QUIETLY — the entity may
+ *  have declined the wake, and a no-show is not an error. Coalescing: a
+ *  second settle mid-burst restarts the probe budget instead of
+ *  stacking a burst. */
+export declare function noteDispatchSettledFromStore(store: AssistantConversationStore): void;
+export declare function settlesFor(delayMs: number): Promise<void>;
+//# sourceMappingURL=conversation-refresh.d.ts.map

package/dist/core/conversation-refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-refresh.d.ts","sourceRoot":"","sources":["../../src/core/conversation-refresh.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAW1E,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED;;;;;;;;wBAQwB;AACxB,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,0BAA0B,GAChC,IAAI,CAUN;AA4DD,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzD"}

package/dist/core/conversation-refresh.js

@@ -0,0 +1,110 @@
+// Keeping the REST truth fresh: the conversation re-read every settle
+// signal funnels through (ticket-ordered so a stale read never overwrites
+// fresher truth), and the delivery-claim probe after a dispatch settle.
+import { getAssistantThread } from "../transport/serving-api.js";
+import { turnHoldsAStream } from "./connection-driver.js";
+import { adoptRefreshedDetail } from "./conversation-adoption.js";
+// The delivery-claim probe: a
+// dispatch settle only WAKES the thread's conversation entity — the
+// backend commits the delivery turn row asynchronously afterward, and may
+// decline outright. So the settle's re-read probes briefly for the opened
+// turn and goes quiet on a no-show; the idle re-read is the backstop. Its
+// own constants (the STOP_SETTLE_PROBES convention): retunable alone.
+const DELIVERY_CLAIM_PROBES = 8;
+const DELIVERY_CLAIM_PROBE_MS = 1_000;
+export async function refreshConversationFromStore(store) {
+    const active = store._active;
+    if (active === null) {
+        return;
+    }
+    store._refreshTicket += 1;
+    const ticket = store._refreshTicket;
+    try {
+        const detail = await getAssistantThread(store.deps.session, active.thread.id);
+        if (ticket <= store._refreshAdoptedThrough) {
+            // A later-issued refresh already adopted fresher truth (the
+            // monotonic-adoption premise at _refreshTicket).
+            return;
+        }
+        store._refreshAdoptedThrough = ticket;
+        adoptRefreshedDetail(store, detail);
+    }
+    catch {
+        // A blip here self-heals: the next settled run refreshes again.
+    }
+}
+/** A surface's roster poll observed a dispatch settle — the
+ *  one frontend-visible signal that a delivery turn may be about to
+ *  open on this thread. Re-reads the conversation in a bounded burst
+ *  until the claim shows up (a queued/working newest turn; adoption's
+ *  publish attaches the stream through the ordinary connect sync), the
+ *  thread changes, or the window exhausts QUIETLY — the entity may
+ *  have declined the wake, and a no-show is not an error. Coalescing: a
+ *  second settle mid-burst restarts the probe budget instead of
+ *  stacking a burst. */
+export function noteDispatchSettledFromStore(store) {
+    if (store._deliveryProbeRunning) {
+        store._deliveryProbeRearm = true;
+        return;
+    }
+    store._deliveryProbeRunning = true;
+    void _probeForDeliveryClaim(store).finally(() => {
+        store._deliveryProbeRunning = false;
+        store._deliveryProbeRearm = false;
+    });
+}
+async function _probeForDeliveryClaim(store) {
+    const threadId = store._active?.thread.id;
+    if (store._disposed || threadId === undefined) {
+        return;
+    }
+    if (turnHoldsAStream(store)) {
+        // The turn is live: the settle's consequences arrive on the stream
+        // (or the connect sync is already attaching) — nothing to probe.
+        return;
+    }
+    // THE LATCH'S CLOCK IS THE BEAT TIMER ALONE: the reads are fired
+    // single-flight and never awaited, so a stalled GET can never latch
+    // _deliveryProbeRunning (the premise: docs/connection-lifecycle.md).
+    let refreshInFlight = false;
+    const refreshOnce = () => {
+        if (refreshInFlight) {
+            return;
+        }
+        refreshInFlight = true;
+        // refreshConversation never rejects (its catch is the self-heal).
+        void store.refreshConversation().finally(() => {
+            refreshInFlight = false;
+        });
+    };
+    refreshOnce();
+    let probesLeft = DELIVERY_CLAIM_PROBES;
+    while (probesLeft > 0 || store._deliveryProbeRearm) {
+        if (store._deliveryProbeRearm) {
+            // Another settle landed mid-burst: its claim gets a full window.
+            store._deliveryProbeRearm = false;
+            probesLeft = DELIVERY_CLAIM_PROBES;
+        }
+        if (_deliveryProbeMoot(store, threadId) || turnHoldsAStream(store)) {
+            // Disposed or switched: this probe's thread is gone. Holds a
+            // stream: adopted — the publish's connect sync attached (or is
+            // attaching) and the stream owns the story from here.
+            return;
+        }
+        await settlesFor(DELIVERY_CLAIM_PROBE_MS);
+        probesLeft -= 1;
+        if (_deliveryProbeMoot(store, threadId)) {
+            return;
+        }
+        refreshOnce();
+    }
+}
+/** Whether the delivery-claim probe's thread is no longer this store's
+ *  story — re-read behind every await (the stopTurn posture). */
+function _deliveryProbeMoot(store, threadId) {
+    return store._disposed || store._active?.thread.id !== threadId;
+}
+export function settlesFor(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+//# sourceMappingURL=conversation-refresh.js.map

package/dist/core/conversation-refresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-refresh.js","sourceRoot":"","sources":["../../src/core/conversation-refresh.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,0EAA0E;AAC1E,wEAAwE;AAExE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGlE,8BAA8B;AAC9B,oEAAoE;AACpE,0EAA0E;AAC1E,0EAA0E;AAC1E,0EAA0E;AAC1E,sEAAsE;AACtE,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAChC,MAAM,uBAAuB,GAAG,KAAK,CAAC;AAEtC,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,KAAiC;IAEjC,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC;IAC7B,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,OAAO;IACT,CAAC;IACD,KAAK,CAAC,cAAc,IAAI,CAAC,CAAC;IAC1B,MAAM,MAAM,GAAG,KAAK,CAAC,cAAc,CAAC;IACpC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,kBAAkB,CACrC,KAAK,CAAC,IAAI,CAAC,OAAO,EAClB,MAAM,CAAC,MAAM,CAAC,EAAE,CACjB,CAAC;QACF,IAAI,MAAM,IAAI,KAAK,CAAC,sBAAsB,EAAE,CAAC;YAC3C,4DAA4D;YAC5D,iDAAiD;YACjD,OAAO;QACT,CAAC;QACD,KAAK,CAAC,sBAAsB,GAAG,MAAM,CAAC;QACtC,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC;IAAC,MAAM,CAAC;QACP,gEAAgE;IAClE,CAAC;AACH,CAAC;AAED;;;;;;;;wBAQwB;AACxB,MAAM,UAAU,4BAA4B,CAC1C,KAAiC;IAEjC,IAAI,KAAK,CAAC,qBAAqB,EAAE,CAAC;QAChC,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC;QACjC,OAAO;IACT,CAAC;IACD,KAAK,CAAC,qBAAqB,GAAG,IAAI,CAAC;IACnC,KAAK,sBAAsB,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;QAC9C,KAAK,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACpC,KAAK,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACpC,CAAC,CAAC,CAAC;AACL,CAAC;AAED,KAAK,UAAU,sBAAsB,CACnC,KAAiC;IAEjC,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC;IAC1C,IAAI,KAAK,CAAC,SAAS,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC9C,OAAO;IACT,CAAC;IACD,IAAI,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,mEAAmE;QACnE,iEAAiE;QACjE,OAAO;IACT,CAAC;IACD,iEAAiE;IACjE,oEAAoE;IACpE,qEAAqE;IACrE,IAAI,eAAe,GAAG,KAAK,CAAC;IAC5B,MAAM,WAAW,GAAG,GAAG,EAAE;QACvB,IAAI,eAAe,EAAE,CAAC;YACpB,OAAO;QACT,CAAC;QACD,eAAe,GAAG,IAAI,CAAC;QACvB,kEAAkE;QAClE,KAAK,KAAK,CAAC,mBAAmB,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE;YAC5C,eAAe,GAAG,KAAK,CAAC;QAC1B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IACF,WAAW,EAAE,CAAC;IACd,IAAI,UAAU,GAAG,qBAAqB,CAAC;IACvC,OAAO,UAAU,GAAG,CAAC,IAAI,KAAK,CAAC,mBAAmB,EAAE,CAAC;QACnD,IAAI,KAAK,CAAC,mBAAmB,EAAE,CAAC;YAC9B,iEAAiE;YACjE,KAAK,CAAC,mBAAmB,GAAG,KAAK,CAAC;YAClC,UAAU,GAAG,qBAAqB,CAAC;QACrC,CAAC;QACD,IAAI,kBAAkB,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;YACnE,6DAA6D;YAC7D,+DAA+D;YAC/D,sDAAsD;YACtD,OAAO;QACT,CAAC;QACD,MAAM,UAAU,CAAC,uBAAuB,CAAC,CAAC;QAC1C,UAAU,IAAI,CAAC,CAAC;QAChB,IAAI,kBAAkB,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,CAAC;YACxC,OAAO;QACT,CAAC;QACD,WAAW,EAAE,CAAC;IAChB,CAAC;AACH,CAAC;AAED;iEACiE;AACjE,SAAS,kBAAkB,CACzB,KAAiC,EACjC,QAAgB;IAEhB,OAAO,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,KAAK,QAAQ,CAAC;AAClE,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,OAAe;IACxC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;AAChE,CAAC"}

package/dist/core/conversation-send.d.ts

@@ -0,0 +1,12 @@
+import type { TurnAttachment } from "../contract/threads.js";
+import type { AssistantConversationStore } from "./conversation-store.js";
+export declare function sendMessageFromStore(store: AssistantConversationStore, message: string, attachmentIds?: string[], optimisticAttachments?: TurnAttachment[]): Promise<boolean>;
+export declare function markComposerRefocusHandledFromStore(store: AssistantConversationStore): void;
+/** Ends the live turn as a quiet receipt. Thread-scoped on
+ *  purpose: the serving door's thread pointer names the live turn
+ *  (liveness, never recency), so the store never picks one. Deliberately
+ *  never touches _streamInterrupted — a stop is a thing the member did,
+ *  and the interruption banner would be a lie. */
+export declare function stopTurnFromStore(store: AssistantConversationStore): Promise<void>;
+export declare function handleUserMessageInjectedFromStore(store: AssistantConversationStore, messageId: string): void;
+//# sourceMappingURL=conversation-send.d.ts.map

package/dist/core/conversation-send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-send.d.ts","sourceRoot":"","sources":["../../src/core/conversation-send.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAQ7D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAQ1E,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,0BAA0B,EACjC,OAAO,EAAE,MAAM,EACf,aAAa,GAAE,MAAM,EAAO,EAC5B,qBAAqB,GAAE,cAAc,EAAO,GAC3C,OAAO,CAAC,OAAO,CAAC,CA+DlB;AAED,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,0BAA0B,GAChC,IAAI,CAGN;AAID;;;;kDAIkD;AAClD,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,IAAI,CAAC,CAsEf;AAuCD,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,0BAA0B,EACjC,SAAS,EAAE,MAAM,GAChB,IAAI,CAQN"}

package/dist/core/conversation-send.js

@@ -0,0 +1,189 @@
+// Sending and stopping the live turn: the one send POST every surface
+// goes through — optimistic echo, model pick capture, the honest refusal
+// taxonomy — and the stop that ends a live turn as a quiet receipt.
+import { sendAssistantMessage, stopAssistantTurn, } from "../transport/serving-api.js";
+import { ServingApiError } from "../transport/serving-error.js";
+import { enterConversationFromSend } from "./conversation-adoption.js";
+import { busyOf, publishStore } from "./conversation-publish.js";
+import { stopFailureSentenceFor, userSentenceFor } from "./error-copy.js";
+import { probeStopSettle } from "./stop-settle.js";
+// The optimistic user message's id mint — module-level so ids stay
+// unique across every conversation this page ever opens.
+let nextOptimisticMessageId = 1;
+export async function sendMessageFromStore(store, message, attachmentIds = [], optimisticAttachments = []) {
+    store._sendError = null;
+    store._turnFailure = null;
+    store._streamInterrupted = false;
+    store._stopping = false;
+    store._pendingSend = true;
+    store._pendingEcho = {
+        messageId: `optimistic-user-${String(nextOptimisticMessageId++)}`,
+        text: message,
+        attachments: optimisticAttachments,
+    };
+    publishStore(store);
+    // Captured before the await: the shelf stays live during a send, so
+    // a selection changed mid-flight must survive the landing (it rides
+    // the NEXT send) — only the pick this send actually carried settles.
+    const sentPick = store._modelPick;
+    try {
+        const response = await sendAssistantMessage(store.deps.session, {
+            thread_id: store._active?.thread.id,
+            message,
+            attachment_ids: attachmentIds,
+            // Present = set exactly this (idempotent for an unchanged pick);
+            // absent = keep — the contract's set-pick semantics.
+            ...(sentPick !== null && {
+                model_pick: {
+                    model_id: sentPick.modelId,
+                    effort: sentPick.effort,
+                },
+            }),
+        });
+        enterConversationFromSend(store, response.thread, response.turn, sentPick);
+        // The send just remounted the composer (it rides the transcript,
+        // which reconnects by remounting), dropping the caret; the fresh
+        // instance takes it back once the turn settles.
+        store._composerRefocusPending = true;
+        return true;
+    }
+    catch (error) {
+        store._pendingEcho = null;
+        if (_isThreadBusyRefusal(error)) {
+            // This is a synchronization correction, not a destructive error:
+            // another surface (or a late settle) still owns the turn. Re-read
+            // and reconnect to that work; the composer's false return restores
+            // the attempted message as a draft (scope-guarded — only into the
+            // conversation that sent it).
+            store._sendError = null;
+            await store.refreshConversation();
+            return false;
+        }
+        store._sendError = userSentenceFor(error);
+        if (error instanceof ServingApiError && _isAGateRefusal(error)) {
+            // The refusal's recovery is the gate (the composer's takeover
+            // card) — the entry adopts it; the banner stands down for it.
+            store._sendError = null;
+            store.deps.onGateRefusal(error);
+        }
+        if (error instanceof Error) {
+            store.deps.reportError(error);
+        }
+        return false;
+    }
+    finally {
+        store._pendingSend = false;
+        publishStore(store);
+    }
+}
+export function markComposerRefocusHandledFromStore(store) {
+    store._composerRefocusPending = false;
+    publishStore(store);
+}
+// --- stopping the live turn ---
+/** Ends the live turn as a quiet receipt. Thread-scoped on
+ *  purpose: the serving door's thread pointer names the live turn
+ *  (liveness, never recency), so the store never picks one. Deliberately
+ *  never touches _streamInterrupted — a stop is a thing the member did,
+ *  and the interruption banner would be a lie. */
+export async function stopTurnFromStore(store) {
+    const active = store._active;
+    if (store._disposed ||
+        active === null ||
+        store._stopping ||
+        // No turn exists yet while the send POST is in flight; the send's
+        // own failure path is the recovery there.
+        store._pendingSend ||
+        !busyOf(store)) {
+        return;
+    }
+    const threadId = active.thread.id;
+    // Each attempt owns its own narration, exactly like sendMessage: a
+    // previous attempt's failure sentence must not outlive the retry
+    // that worked.
+    store._sendError = null;
+    store._stopping = true;
+    publishStore(store);
+    try {
+        const receipt = await stopAssistantTurn(store.deps.session, threadId);
+        if (_stopLostItsThread(store, threadId)) {
+            return;
+        }
+        // The composer re-enables when busy flips false; the caret comes
+        // back with it, exactly like a landed send.
+        store._composerRefocusPending = true;
+        publishStore(store);
+        if (receipt.delivery !== "signaled") {
+            // turn_settled / already_settled: the door settled the turn (or
+            // found the answer already won the race) — REST is terminal now.
+            // A read blip here falls through to the probe loop below.
+            await store.refreshConversation();
+        }
+        // Signaled: the workflow's stop exit lands turn_stopped plus a
+        // quiet RUN_FINISHED on the stream (~2s), and the normal settle
+        // machinery adopts it. The bounded probe is the no-stream corner's
+        // fallback (handleWorkflowRestarted's shape); a settle adopted by
+        // the stream clears _stopping and ends the loop early.
+        const exhausted = await probeStopSettle({
+            refresh: store.refreshConversation,
+            stillAwaitsSettle: () => _stopStillAwaitsSettle(store, threadId),
+        });
+        // Exhausted: the probe window is a fallback, not a promise. A
+        // settle that never showed up must not keep narrating "Stopping…"
+        // — release the lock so the stop square re-arms (the door answers
+        // a receipt to a second press) and a genuinely dead stream's
+        // interruption banner (its Retry is the only way back) can
+        // surface. A stop that lands later still renders honestly through
+        // the ordinary settle machinery. This never resurfaces the banner
+        // after a SUCCESSFUL stop: success means busy flipped false inside
+        // the window, and a false busy hides the banner on its own.
+        if (exhausted) {
+            store._stopping = false;
+            publishStore(store);
+        }
+    }
+    catch (error) {
+        if (_stopLostItsThread(store, threadId)) {
+            return;
+        }
+        store._stopping = false;
+        // The stop door's own vocabulary, never the send door's: a failed
+        // stop is not a failed send.
+        store._sendError = stopFailureSentenceFor(error);
+        publishStore(store);
+        if (error instanceof Error) {
+            store.deps.reportError(error);
+        }
+    }
+}
+// Read fresh behind every await on purpose: dispose, thread switches,
+// and the settle machinery all move these fields while a stop sleeps,
+// and the function boundary keeps TS narrowing (which cannot see those
+// writers) from constant-folding the re-checks.
+function _stopLostItsThread(store, threadId) {
+    return store._disposed || store._active?.thread.id !== threadId;
+}
+function _stopStillAwaitsSettle(store, threadId) {
+    return !_stopLostItsThread(store, threadId) && store._stopping;
+}
+function _isThreadBusyRefusal(error) {
+    return (error instanceof ServingApiError && error.code === "ASSISTANT_THREAD_BUSY");
+}
+// The gate-shaped refusal codes: their recovery renders in the
+// composer's place (core/connect-gate.ts), so the send banner stands
+// down for them — everything else stays the banner's story.
+function _isAGateRefusal(error) {
+    return (error.code === "ASSISTANT_SIGN_IN_REQUIRED" ||
+        error.code === "SUBSCRIPTION_CONNECT_REQUIRED" ||
+        error.code === "SUBSCRIPTION_CANNOT_PAY");
+}
+// Replay injected the optimistic echo's own message: the bridge has done
+// its job and the row now renders from the transcript itself.
+export function handleUserMessageInjectedFromStore(store, messageId) {
+    if (store._pendingEcho !== null &&
+        store._pendingEcho.messageId === messageId) {
+        store._pendingEcho = null;
+        publishStore(store);
+    }
+}
+//# sourceMappingURL=conversation-send.js.map