@teaflask/assistant 0.0.0 → 0.6.0

package/dist/core/conversation-refresh.js

@@ -0,0 +1,76 @@
+import { getAssistantThread } from "../transport/serving-api.js";
+import { turnHoldsAStream } from "./connection-driver.js";
+import { adoptRefreshedDetail } from "./conversation-adoption.js";
+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 (store._disposed || ticket <= store._refreshAdoptedThrough) {
+            return;
+        }
+        store._refreshAdoptedThrough = ticket;
+        adoptRefreshedDetail(store, detail);
+    }
+    catch {
+    }
+}
+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)) {
+        return;
+    }
+    let refreshInFlight = false;
+    const refreshOnce = () => {
+        if (refreshInFlight) {
+            return;
+        }
+        refreshInFlight = true;
+        void store.refreshConversation().finally(() => {
+            refreshInFlight = false;
+        });
+    };
+    refreshOnce();
+    let probesLeft = DELIVERY_CLAIM_PROBES;
+    while (probesLeft > 0 || store._deliveryProbeRearm) {
+        if (store._deliveryProbeRearm) {
+            store._deliveryProbeRearm = false;
+            probesLeft = DELIVERY_CLAIM_PROBES;
+        }
+        if (_deliveryProbeMoot(store, threadId) || turnHoldsAStream(store)) {
+            return;
+        }
+        await settlesFor(DELIVERY_CLAIM_PROBE_MS);
+        probesLeft -= 1;
+        if (_deliveryProbeMoot(store, threadId)) {
+            return;
+        }
+        refreshOnce();
+    }
+}
+function _deliveryProbeMoot(store, threadId) {
+    return store._disposed || store._active?.thread.id !== threadId;
+}
+export function settlesFor(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}

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

@@ -0,0 +1,6 @@
+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;
+export declare function stopTurnFromStore(store: AssistantConversationStore): Promise<void>;
+export declare function handleUserMessageInjectedFromStore(store: AssistantConversationStore, messageId: string): void;

package/dist/core/conversation-send.js

@@ -0,0 +1,127 @@
+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";
+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);
+    const sentPick = store._modelPick;
+    try {
+        const response = await sendAssistantMessage(store.deps.session, {
+            thread_id: store._active?.thread.id,
+            message,
+            attachment_ids: attachmentIds,
+            ...(sentPick !== null && {
+                model_pick: {
+                    model_id: sentPick.modelId,
+                    effort: sentPick.effort,
+                },
+            }),
+        });
+        enterConversationFromSend(store, response.thread, response.turn, sentPick);
+        store._composerRefocusPending = true;
+        return true;
+    }
+    catch (error) {
+        store._pendingEcho = null;
+        if (_isThreadBusyRefusal(error)) {
+            store._sendError = null;
+            await store.refreshConversation();
+            return false;
+        }
+        store._sendError = userSentenceFor(error);
+        if (error instanceof ServingApiError && _isAGateRefusal(error)) {
+            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);
+}
+export async function stopTurnFromStore(store) {
+    const active = store._active;
+    if (store._disposed ||
+        active === null ||
+        store._stopping ||
+        store._pendingSend ||
+        !busyOf(store)) {
+        return;
+    }
+    const threadId = active.thread.id;
+    store._sendError = null;
+    store._stopping = true;
+    publishStore(store);
+    try {
+        const receipt = await stopAssistantTurn(store.deps.session, threadId);
+        if (_stopLostItsThread(store, threadId)) {
+            return;
+        }
+        store._composerRefocusPending = true;
+        publishStore(store);
+        if (receipt.delivery !== "signaled") {
+            await store.refreshConversation();
+        }
+        const exhausted = await probeStopSettle({
+            refresh: store.refreshConversation,
+            stillAwaitsSettle: () => _stopStillAwaitsSettle(store, threadId),
+        });
+        if (exhausted) {
+            store._stopping = false;
+            publishStore(store);
+        }
+    }
+    catch (error) {
+        if (_stopLostItsThread(store, threadId)) {
+            return;
+        }
+        store._stopping = false;
+        store._sendError = stopFailureSentenceFor(error);
+        publishStore(store);
+        if (error instanceof Error) {
+            store.deps.reportError(error);
+        }
+    }
+}
+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");
+}
+function _isAGateRefusal(error) {
+    return (error.code === "ASSISTANT_SIGN_IN_REQUIRED" ||
+        error.code === "SUBSCRIPTION_CONNECT_REQUIRED" ||
+        error.code === "SUBSCRIPTION_CANNOT_PAY");
+}
+export function handleUserMessageInjectedFromStore(store, messageId) {
+    if (store._pendingEcho !== null &&
+        store._pendingEcho.messageId === messageId) {
+        store._pendingEcho = null;
+        publishStore(store);
+    }
+}

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

@@ -0,0 +1,125 @@
+import type { Message } from "@ag-ui/core";
+import type { VisitorTier } from "../contract/identity.js";
+import type { ServingAssistantThread, ServingAssistantTurn, ServingAttachment, TurnAttachment } from "../contract/threads.js";
+import type { StreamResumeStore } from "../transport/stream-resume.js";
+import { type AssistantActivityResult, type AssistantActivitySnapshot } from "./activity.js";
+import type { ApprovalCardModel, ApprovalDecisionInput } from "./approval-inbox.js";
+import type { ConnectionEpoch, MarkerAnchorsSnapshot } from "./connection-epoch.js";
+import type { AnsweredQuestions, ElicitationCardModel, QuestionSetCardModel } from "./elicitation-cards.js";
+import type { CoworkerExecutionWork } from "./coworker-execution-work.js";
+import { QuestionDraftStore } from "./question-drafts.js";
+import { PendingDecisionGapGate, type PendingDecisionGap } from "./pending-decision-gap.js";
+import { ConsumedInterruptFold } from "./consumed-interrupts.js";
+import { ObservableCell, type ReadonlyCell } from "./observable-cell.js";
+import type { UserTurnLedger, UserTurnMeta } from "./user-turn-ledger.js";
+import type { ActiveConversation, AttachmentDraft, ComposerContract, ComposerInput, ComposerModelPick, ConnectionSnapshot, ConversationSnapshot, ConversationStoreDeps, MintedDownloadUrl } from "./conversation-contract.js";
+export type { ActiveConversation, ApprovalDecisionInput, AttachmentDraft, ComposerContract, ComposerInput, ComposerModelPick, ConversationStoreDeps, HostCapabilities, MintedDownloadUrl, } from "./conversation-contract.js";
+export declare class AssistantConversationStore {
+    readonly deps: ConversationStoreDeps;
+    readonly conversation: ReadonlyCell<ConversationSnapshot>;
+    readonly composer: ReadonlyCell<ComposerContract>;
+    readonly connection: ReadonlyCell<ConnectionSnapshot | null>;
+    readonly approvals: ReadonlyCell<readonly ApprovalCardModel[]>;
+    readonly elicitations: ReadonlyCell<readonly ElicitationCardModel[]>;
+    readonly coworkerWork: ReadonlyCell<ReadonlyMap<number, CoworkerExecutionWork>>;
+    readonly markerAnchors: ReadonlyCell<MarkerAnchorsSnapshot>;
+    readonly activity: ReadonlyCell<AssistantActivitySnapshot>;
+    readonly messages: ReadonlyCell<readonly Message[]>;
+    readonly turnMeta: ReadonlyCell<ReadonlyMap<string, UserTurnMeta>>;
+    readonly _conversationCell: ObservableCell<ConversationSnapshot>;
+    readonly _composerCell: ObservableCell<ComposerContract>;
+    readonly _connectionCell: ObservableCell<ConnectionSnapshot | null>;
+    readonly _approvalsCell: ObservableCell<readonly ApprovalCardModel[]>;
+    readonly _elicitationsCell: ObservableCell<readonly ElicitationCardModel[]>;
+    readonly _coworkerWorkCell: ObservableCell<ReadonlyMap<number, CoworkerExecutionWork>>;
+    readonly _elicitationErrors: Map<string, string>;
+    readonly _questionAnswers: Map<string, AnsweredQuestions>;
+    readonly questionDrafts: QuestionDraftStore;
+    readonly _markerAnchorsCell: ObservableCell<MarkerAnchorsSnapshot>;
+    readonly _activityCell: ObservableCell<AssistantActivitySnapshot>;
+    readonly _messagesCell: ObservableCell<readonly Message[]>;
+    readonly _turnMetaCell: ObservableCell<ReadonlyMap<string, UserTurnMeta>>;
+    _publishedMetaLedger: UserTurnLedger | null;
+    _publishedMetaVersion: number;
+    readonly _downloadUrls: Map<string, MintedDownloadUrl>;
+    _active: ActiveConversation | null;
+    _threads: ServingAssistantThread[];
+    _sendError: string | null;
+    _turnFailure: string | null;
+    _pendingDecisionGap: PendingDecisionGap | null;
+    readonly _gapGate: PendingDecisionGapGate;
+    _inPublish: boolean;
+    _streamInterrupted: boolean;
+    _stopping: boolean;
+    _threadOpening: boolean;
+    _reconnectNonce: number;
+    _backgroundAttachNonce: number;
+    _pendingSend: boolean;
+    _pendingEcho: ComposerContract["pendingEcho"];
+    _composerRefocusPending: boolean;
+    _modelPick: ComposerModelPick | null;
+    _modelPickDirty: boolean;
+    readonly _composerInput: ObservableCell<ComposerInput>;
+    _nextUnboundScope: number;
+    _composerFocusOwned: string | null;
+    _composerCaretReturnPending: string | null;
+    _tier: VisitorTier | null;
+    _newestTurn: ServingAssistantTurn | null;
+    _awaitingTurn: ServingAssistantTurn | null;
+    _lastResult: AssistantActivityResult | null;
+    readonly _consumedInterrupts: ConsumedInterruptFold;
+    _resumeRequest: number;
+    _adoptionAsk: number;
+    _refreshTicket: number;
+    _refreshAdoptedThrough: number;
+    _historyLoadRequested: boolean;
+    private readonly _settleScheduler;
+    _deliveryProbeRunning: boolean;
+    _deliveryProbeRearm: boolean;
+    _idleRecheckTimer: ReturnType<typeof setInterval> | null;
+    _idleRecheckInFlight: boolean;
+    _disposed: boolean;
+    _epoch: ConnectionEpoch | null;
+    _epochResume: StreamResumeStore | null;
+    _epochSignature: string | null;
+    _nextEpochId: number;
+    _leaseHolders: string[];
+    _connectionRunning: boolean;
+    _connectionSyncQueued: boolean;
+    _epochConnectedOnce: boolean;
+    _automaticReconnects: number;
+    constructor(deps: ConversationStoreDeps);
+    bootstrap(): void;
+    setTier(tier: VisitorTier | null): void;
+    dispose(): void;
+    resumeStoredThread: () => void;
+    sendMessage: (message: string, attachmentIds?: string[], optimisticAttachments?: TurnAttachment[]) => Promise<boolean>;
+    markComposerRefocusHandled: () => void;
+    stopTurn: () => Promise<void>;
+    setModelPick: (pick: ComposerModelPick) => void;
+    setComposerDraft: (next: string | ((current: string) => string)) => void;
+    setComposerAttachments: (next: readonly AttachmentDraft[] | ((current: readonly AttachmentDraft[]) => readonly AttachmentDraft[])) => void;
+    noteComposerFocus: (owner: string | null) => void;
+    takeComposerCaretReturn: (surface: string) => boolean;
+    uploadAttachment: (file: File) => Promise<ServingAttachment>;
+    mintAttachmentDownloadUrl: (attachmentId: string) => Promise<MintedDownloadUrl>;
+    acquireTranscriptLease: (surface: string) => (() => void);
+    submitApprovalDecision: (card: ApprovalCardModel, decision: ApprovalDecisionInput) => Promise<void>;
+    submitQuestionAnswers: (card: QuestionSetCardModel, answers: readonly {
+        id: string;
+        text: string;
+    }[]) => Promise<void>;
+    cancelQuestionSet: (card: QuestionSetCardModel) => Promise<void>;
+    handleUserMessageInjected: (messageId: string) => void;
+    openThread: (thread: ServingAssistantThread) => void;
+    startNewConversation: () => void;
+    refreshConversation: () => Promise<void>;
+    noteDispatchSettled: () => void;
+    noteDispatchPaused: () => void;
+    handleRunSettled: () => void;
+    handleStreamError: (error: Error) => void;
+    handleStreamClosedQuietly: (stillStreaming: () => boolean) => void;
+    retryStream: () => void;
+    handleWorkflowRestarted: () => void;
+    _scheduleSettleRefresh(): void;
+}

package/dist/core/conversation-store.js

@@ -0,0 +1,241 @@
+import { IDLE_ACTIVITY, } from "./activity.js";
+import { noteDispatchSettledFromStore, refreshConversationFromStore, } from "./conversation-refresh.js";
+import { mintAttachmentDownloadUrlFromStore, uploadAttachmentFromStore, } from "./attachment-uploads.js";
+import { handleUserMessageInjectedFromStore, markComposerRefocusHandledFromStore, sendMessageFromStore, stopTurnFromStore, } from "./conversation-send.js";
+import { noteComposerFocusFromStore, setComposerAttachmentsFromStore, setComposerDraftFromStore, setModelPickFromStore, takeComposerCaretReturnFromStore, } from "./composer-input-state.js";
+import { submitApprovalDecisionFromStore } from "./approval-decision.js";
+import { invalidateInFlightResume, loadHistoryOnceExpected, openThreadFromStore, refreshThreads, resumeStoredThreadFromStore, startNewConversationFromStore, } from "./conversation-adoption.js";
+import { cancelQuestionSetFromStore, submitQuestionAnswersFromStore, } from "./elicitation-answers.js";
+import { QuestionDraftStore } from "./question-drafts.js";
+import { PendingDecisionGapGate, } from "./pending-decision-gap.js";
+import { SettleRefreshScheduler } from "./settle-refresh.js";
+import { handleStreamClosedQuietlyFromStore, handleStreamErrorFromStore, handleWorkflowRestartedFromStore, retryStreamFromStore, } from "./stream-trouble.js";
+import { acquireTranscriptLeaseFromStore } from "./transcript-lease.js";
+import { clearIdleRecheck, syncIdleRecheck } from "./idle-recheck.js";
+import { ConsumedInterruptFold } from "./consumed-interrupts.js";
+import { composerSnapshotOf, conversationSnapshotOf, publishStore, } from "./conversation-publish.js";
+import { retireEpoch } from "./epoch-sync.js";
+import { ObservableCell } from "./observable-cell.js";
+export class AssistantConversationStore {
+    deps;
+    conversation;
+    composer;
+    connection;
+    approvals;
+    elicitations;
+    coworkerWork;
+    markerAnchors;
+    activity;
+    messages;
+    turnMeta;
+    _conversationCell;
+    _composerCell;
+    _connectionCell;
+    _approvalsCell;
+    _elicitationsCell;
+    _coworkerWorkCell;
+    _elicitationErrors = new Map();
+    _questionAnswers = new Map();
+    questionDrafts = new QuestionDraftStore();
+    _markerAnchorsCell;
+    _activityCell;
+    _messagesCell;
+    _turnMetaCell;
+    _publishedMetaLedger = null;
+    _publishedMetaVersion = -1;
+    _downloadUrls = new Map();
+    _active = null;
+    _threads = [];
+    _sendError = null;
+    _turnFailure = null;
+    _pendingDecisionGap = null;
+    _gapGate = new PendingDecisionGapGate({
+        publish: (gap) => {
+            this._pendingDecisionGap = gap;
+            if (!this._inPublish) {
+                publishStore(this);
+            }
+        },
+        probe: () => {
+            void this.refreshConversation().then(() => {
+                if (!this._disposed) {
+                    publishStore(this);
+                }
+            });
+        },
+        evidenceSettled: () => this._epochConnectedOnce,
+    });
+    _inPublish = false;
+    _streamInterrupted = false;
+    _stopping = false;
+    _threadOpening = false;
+    _reconnectNonce = 0;
+    _backgroundAttachNonce = 0;
+    _pendingSend = false;
+    _pendingEcho = null;
+    _composerRefocusPending = false;
+    _modelPick = null;
+    _modelPickDirty = false;
+    _composerInput = new ObservableCell({
+        scope: "u:0",
+        draft: "",
+        attachments: [],
+    });
+    _nextUnboundScope = 1;
+    _composerFocusOwned = null;
+    _composerCaretReturnPending = null;
+    _tier = null;
+    _newestTurn = null;
+    _awaitingTurn = null;
+    _lastResult = null;
+    _consumedInterrupts = new ConsumedInterruptFold();
+    _resumeRequest = 0;
+    _adoptionAsk = 0;
+    _refreshTicket = 0;
+    _refreshAdoptedThrough = 0;
+    _historyLoadRequested = false;
+    _settleScheduler = new SettleRefreshScheduler(() => {
+        void this.refreshConversation();
+        void refreshThreads(this);
+        this.deps.onTurnSettled();
+    });
+    _deliveryProbeRunning = false;
+    _deliveryProbeRearm = false;
+    _idleRecheckTimer = null;
+    _idleRecheckInFlight = false;
+    _disposed = false;
+    _epoch = null;
+    _epochResume = null;
+    _epochSignature = null;
+    _nextEpochId = 1;
+    _leaseHolders = [];
+    _connectionRunning = false;
+    _connectionSyncQueued = false;
+    _epochConnectedOnce = false;
+    _automaticReconnects = 0;
+    constructor(deps) {
+        this.deps = deps;
+        this._conversationCell = new ObservableCell(conversationSnapshotOf(this));
+        this._composerCell = new ObservableCell(composerSnapshotOf(this));
+        this._connectionCell = new ObservableCell(null);
+        this._approvalsCell = new ObservableCell([]);
+        this._elicitationsCell = new ObservableCell([]);
+        this._coworkerWorkCell = new ObservableCell(new Map());
+        this._markerAnchorsCell = new ObservableCell({
+            resumeAnchors: new Map(),
+            turnFailedAnchors: new Map(),
+            subagentDeliveryAnchors: new Map(),
+            toolErrorAnchors: new Map(),
+            toolRefusalAnchors: new Map(),
+            toolCancelAnchors: new Set(),
+            toolOffloadAnchors: new Set(),
+            toolDecisionAnchors: new Set(),
+            toolDenialAnchors: new Set(),
+            toolCallDisplayAnchors: new Map(),
+            toolSchemaAnchors: new Map(),
+            blockTimingAnchors: new Map(),
+            turnUsageAnchors: new Map(),
+            memoryProvenanceAnchors: new Map(),
+            memoryAttributionAnchors: new Map(),
+        });
+        this._activityCell = new ObservableCell(IDLE_ACTIVITY);
+        this._messagesCell = new ObservableCell([]);
+        this._turnMetaCell = new ObservableCell(new Map());
+        this.conversation = this._conversationCell;
+        this.composer = this._composerCell;
+        this.connection = this._connectionCell;
+        this.approvals = this._approvalsCell;
+        this.elicitations = this._elicitationsCell;
+        this.coworkerWork = this._coworkerWorkCell;
+        this.markerAnchors = this._markerAnchorsCell;
+        this.activity = this._activityCell;
+        this.messages = this._messagesCell;
+        this.turnMeta = this._turnMetaCell;
+    }
+    bootstrap() {
+        this._disposed = false;
+        this.resumeStoredThread();
+        loadHistoryOnceExpected(this);
+        syncIdleRecheck(this);
+    }
+    setTier(tier) {
+        if (this._tier === tier) {
+            return;
+        }
+        this._tier = tier;
+        loadHistoryOnceExpected(this);
+        publishStore(this);
+    }
+    dispose() {
+        this._disposed = true;
+        invalidateInFlightResume(this);
+        this._settleScheduler.dispose();
+        this._gapGate.dispose();
+        clearIdleRecheck(this);
+        retireEpoch(this);
+    }
+    resumeStoredThread = () => {
+        resumeStoredThreadFromStore(this);
+    };
+    sendMessage = async (message, attachmentIds, optimisticAttachments) => sendMessageFromStore(this, message, attachmentIds, optimisticAttachments);
+    markComposerRefocusHandled = () => {
+        markComposerRefocusHandledFromStore(this);
+    };
+    stopTurn = async () => stopTurnFromStore(this);
+    setModelPick = (pick) => {
+        setModelPickFromStore(this, pick);
+    };
+    setComposerDraft = (next) => {
+        setComposerDraftFromStore(this, next);
+    };
+    setComposerAttachments = (next) => {
+        setComposerAttachmentsFromStore(this, next);
+    };
+    noteComposerFocus = (owner) => {
+        noteComposerFocusFromStore(this, owner);
+    };
+    takeComposerCaretReturn = (surface) => takeComposerCaretReturnFromStore(this, surface);
+    uploadAttachment = async (file) => uploadAttachmentFromStore(this, file);
+    mintAttachmentDownloadUrl = async (attachmentId) => mintAttachmentDownloadUrlFromStore(this, attachmentId);
+    acquireTranscriptLease = (surface) => acquireTranscriptLeaseFromStore(this, surface);
+    submitApprovalDecision = async (card, decision) => submitApprovalDecisionFromStore(this, card, decision);
+    submitQuestionAnswers = async (card, answers) => submitQuestionAnswersFromStore(this, card, answers);
+    cancelQuestionSet = async (card) => cancelQuestionSetFromStore(this, card);
+    handleUserMessageInjected = (messageId) => {
+        handleUserMessageInjectedFromStore(this, messageId);
+    };
+    openThread = (thread) => {
+        openThreadFromStore(this, thread);
+    };
+    startNewConversation = () => {
+        startNewConversationFromStore(this);
+    };
+    refreshConversation = async () => refreshConversationFromStore(this);
+    noteDispatchSettled = () => {
+        noteDispatchSettledFromStore(this);
+    };
+    noteDispatchPaused = () => {
+        void refreshConversationFromStore(this);
+    };
+    handleRunSettled = () => {
+        this._scheduleSettleRefresh();
+    };
+    handleStreamError = (error) => {
+        handleStreamErrorFromStore(this, error);
+    };
+    handleStreamClosedQuietly = (stillStreaming) => {
+        handleStreamClosedQuietlyFromStore(this, stillStreaming);
+    };
+    retryStream = () => {
+        retryStreamFromStore(this);
+    };
+    handleWorkflowRestarted = () => {
+        handleWorkflowRestartedFromStore(this);
+    };
+    _scheduleSettleRefresh() {
+        if (this._disposed) {
+            return;
+        }
+        this._settleScheduler.noteRunSettled();
+    }
+}

package/dist/core/coworker-execution-work.d.ts

@@ -0,0 +1,10 @@
+import type { ApprovalCardModel } from "./approval-inbox.js";
+import type { ExecutionEntryModel } from "./execution-inbox.js";
+export interface CoworkerExecutionWork {
+    toolName: string | null;
+    status: "pending" | "executing" | "reported" | "stale";
+    ok: boolean | null;
+    via: "browser" | "approval";
+}
+export declare function coworkerExecutionWorkOf(entries: readonly ExecutionEntryModel[], cards?: readonly ApprovalCardModel[]): ReadonlyMap<number, CoworkerExecutionWork>;
+export declare function sameCoworkerExecutionWork(a: ReadonlyMap<number, CoworkerExecutionWork>, b: ReadonlyMap<number, CoworkerExecutionWork>): boolean;

package/dist/core/coworker-execution-work.js

@@ -0,0 +1,53 @@
+const RANK = [
+    "executing",
+    "pending",
+    "reported",
+    "stale",
+];
+export function coworkerExecutionWorkOf(entries, cards = []) {
+    const byOrdinal = new Map();
+    const consider = (ordinal, work) => {
+        const held = byOrdinal.get(ordinal);
+        if (held === undefined ||
+            RANK.indexOf(work.status) < RANK.indexOf(held.status)) {
+            byOrdinal.set(ordinal, work);
+        }
+    };
+    for (const card of cards) {
+        if (card.asker.kind !== "coworker") {
+            continue;
+        }
+        consider(card.asker.ordinal, {
+            toolName: card.toolName,
+            status: _approvalWorkStatusOf(card),
+            ok: card.status.kind === "answered" ? card.status.approved : null,
+            via: "approval",
+        });
+    }
+    for (const entry of entries) {
+        if (entry.asker.kind !== "coworker") {
+            continue;
+        }
+        consider(entry.asker.ordinal, {
+            toolName: entry.toolName,
+            status: entry.status.kind,
+            ok: entry.status.kind === "reported" ? entry.status.ok : null,
+            via: "browser",
+        });
+    }
+    return byOrdinal;
+}
+function _approvalWorkStatusOf(card) {
+    switch (card.status.kind) {
+        case "actionable":
+        case "submitting":
+            return "pending";
+        case "answered":
+            return "reported";
+        case "stale":
+            return "stale";
+    }
+}
+export function sameCoworkerExecutionWork(a, b) {
+    return JSON.stringify([...a]) === JSON.stringify([...b]);
+}

package/dist/core/disposable-subscriber.d.ts

@@ -0,0 +1,6 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+export interface DisposableAgentSubscriber {
+    subscriber: AgentSubscriber;
+    dispose: () => void;
+}
+export declare function disposableSubscriber(inner: AgentSubscriber): DisposableAgentSubscriber;

package/dist/core/disposable-subscriber.js

@@ -0,0 +1,18 @@
+export function disposableSubscriber(inner) {
+    let disposed = false;
+    const subscriber = new Proxy(inner, {
+        get(target, property, receiver) {
+            const member = Reflect.get(target, property, receiver);
+            if (typeof member !== "function") {
+                return member;
+            }
+            return (...args) => disposed ? undefined : Reflect.apply(member, target, args);
+        },
+    });
+    return {
+        subscriber,
+        dispose: () => {
+            disposed = true;
+        },
+    };
+}

package/dist/core/dock-reflow.d.ts

@@ -0,0 +1,5 @@
+export interface DockReflowController {
+    push(widthPx: number, reduceMotion: boolean): void;
+    release(): void;
+}
+export declare function dockReflowFor(root: HTMLElement): DockReflowController;