@teaflask/assistant 0.0.0 → 0.6.0

package/dist/core/dock-reflow.js

@@ -0,0 +1,68 @@
+const DOCK_REFLOW_TRANSITION = "margin-right 220ms cubic-bezier(0.22, 1, 0.36, 1)";
+const DOCK_REFLOW_REDUCED_TRANSITION = "margin-right 1ms";
+const REFLOW_SETTLE_FALLBACK_MS = 400;
+const _controllers = new WeakMap();
+export function dockReflowFor(root) {
+    const existing = _controllers.get(root);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const controller = _createDockReflow(root);
+    _controllers.set(root, controller);
+    return controller;
+}
+function _createDockReflow(root) {
+    let saved = null;
+    let pushed = false;
+    let settleTimer = null;
+    const cancelPendingSettle = () => {
+        if (settleTimer !== null) {
+            root.ownerDocument.defaultView?.clearTimeout(settleTimer);
+            settleTimer = null;
+        }
+    };
+    const restoreProperty = (name, value) => {
+        if (value === "") {
+            root.style.removeProperty(name);
+        }
+        else {
+            root.style.setProperty(name, value);
+        }
+    };
+    const restoreTransitionAndForget = () => {
+        if (saved !== null) {
+            restoreProperty("transition", saved.transition);
+            saved = null;
+        }
+    };
+    return {
+        push(widthPx, reduceMotion) {
+            cancelPendingSettle();
+            saved ??= {
+                marginRight: root.style.marginRight,
+                transition: root.style.transition,
+            };
+            pushed = true;
+            root.style.transition = reduceMotion
+                ? DOCK_REFLOW_REDUCED_TRANSITION
+                : DOCK_REFLOW_TRANSITION;
+            root.style.marginRight = `${String(widthPx)}px`;
+        },
+        release() {
+            if (!pushed || saved === null) {
+                return;
+            }
+            pushed = false;
+            restoreProperty("margin-right", saved.marginRight);
+            const view = root.ownerDocument.defaultView;
+            if (view === null) {
+                restoreTransitionAndForget();
+                return;
+            }
+            settleTimer = view.setTimeout(() => {
+                settleTimer = null;
+                restoreTransitionAndForget();
+            }, REFLOW_SETTLE_FALLBACK_MS);
+        },
+    };
+}

package/dist/core/elicitation-answers.d.ts

@@ -0,0 +1,7 @@
+import type { AssistantConversationStore } from "./conversation-store.js";
+import type { QuestionSetCardModel } from "./elicitation-cards.js";
+export declare function submitQuestionAnswersFromStore(store: AssistantConversationStore, card: QuestionSetCardModel, answers: readonly {
+    id: string;
+    text: string;
+}[]): Promise<void>;
+export declare function cancelQuestionSetFromStore(store: AssistantConversationStore, card: QuestionSetCardModel): Promise<void>;

package/dist/core/elicitation-answers.js

@@ -0,0 +1,71 @@
+import { resolveTurnToolResults } from "../transport/serving-api.js";
+import { ServingApiError } from "../transport/serving-error.js";
+import { ANSWER_NOT_SENT_SENTENCE } from "./approval-inbox.js";
+import { turnIdAnsweredBy } from "./approval-decision.js";
+import { publishExecutionEntries } from "./epoch-sync.js";
+import { userSentenceFor } from "./error-copy.js";
+export async function submitQuestionAnswersFromStore(store, card, answers) {
+    await _deliverQuestionSetReport(store, card, { answers: answers.map((answer) => ({ ...answer })) }, { kind: "answers", answers });
+}
+export async function cancelQuestionSetFromStore(store, card) {
+    await _deliverQuestionSetReport(store, card, { cancelled: true }, { kind: "cancelled" });
+}
+async function _deliverQuestionSetReport(store, card, result, answered) {
+    const epoch = store._epoch;
+    const active = store._active;
+    if (epoch === null || active === null) {
+        return;
+    }
+    const inbox = epoch.executionInbox;
+    if (!inbox.beginExecution(card.interruptId)) {
+        return;
+    }
+    store._elicitationErrors.delete(card.interruptId);
+    const publishIfCurrent = () => {
+        if (store._epoch === epoch) {
+            publishExecutionEntries(store, inbox.entries());
+        }
+    };
+    publishIfCurrent();
+    try {
+        const turnId = await turnIdAnsweredBy(store, active, card);
+        if (turnId === null) {
+            store._elicitationErrors.set(card.interruptId, ANSWER_NOT_SENT_SENTENCE);
+            inbox.settlePostFailed(card.interruptId);
+            return;
+        }
+        const resolution = await resolveTurnToolResults(store.deps.session, active.thread.id, turnId, { results: [{ interrupt_id: card.interruptId, ok: true, result }] });
+        store._questionAnswers.set(card.interruptId, answered);
+        inbox.settleReported(card.interruptId, true);
+        store.questionDrafts.clear(card.interruptId);
+        if (resolution.delivery === "workflow_restarted") {
+            store.handleWorkflowRestarted();
+        }
+    }
+    catch (error) {
+        if (_turnNoLongerAwaitingToolResults(error)) {
+            inbox.markRunStale(card.runId);
+            store.questionDrafts.clear(card.interruptId);
+            void store.refreshConversation();
+        }
+        else {
+            store._elicitationErrors.set(card.interruptId, _questionSetFailureSentenceOf(error));
+            inbox.settlePostFailed(card.interruptId);
+        }
+    }
+    finally {
+        publishIfCurrent();
+    }
+}
+function _turnNoLongerAwaitingToolResults(error) {
+    return (error instanceof ServingApiError &&
+        error.code === "ASSISTANT_TURN_NOT_AWAITING_TOOL_RESULTS");
+}
+function _questionSetFailureSentenceOf(error) {
+    if (error instanceof ServingApiError &&
+        error.code === "VALIDATION_ERROR" &&
+        error.message !== "") {
+        return error.message;
+    }
+    return userSentenceFor(error);
+}

package/dist/core/elicitation-cards.d.ts

@@ -0,0 +1,29 @@
+import type { ExecutionEntryModel } from "./execution-inbox.js";
+import { type QuestionModel } from "./elicitation-pickers.js";
+export type ElicitationCardStatus = "actionable" | "submitting" | "answered" | "stale";
+interface ElicitationCardBase {
+    interruptId: string;
+    runId: string;
+    toolCallId: string | null;
+    anchored: boolean;
+    round: number;
+    status: ElicitationCardStatus;
+    errorSentence: string | null;
+}
+export interface QuestionSetCardModel extends ElicitationCardBase {
+    questions: readonly QuestionModel[];
+    answered: AnsweredQuestions | null;
+}
+export type AnsweredQuestions = {
+    kind: "answers";
+    answers: readonly {
+        id: string;
+        text: string;
+    }[];
+} | {
+    kind: "cancelled";
+};
+export type ElicitationCardModel = QuestionSetCardModel;
+export declare function elicitationCardsOf(entries: readonly ExecutionEntryModel[], errorSentences: ReadonlyMap<string, string>, questionAnswers?: ReadonlyMap<string, AnsweredQuestions>): ElicitationCardModel[];
+export declare function sameElicitationCards(a: readonly ElicitationCardModel[], b: readonly ElicitationCardModel[]): boolean;
+export {};

package/dist/core/elicitation-cards.js

@@ -0,0 +1,69 @@
+import { ASK_QUESTIONS_REQUEST_KIND } from "./execution-handlers.js";
+import { askQuestionsActionOf, } from "./elicitation-pickers.js";
+const NO_QUESTION_ANSWERS = new Map();
+const NARROWED_SETS = new WeakMap();
+function narrowedQuestionSetOf(action) {
+    if (action === null) {
+        return null;
+    }
+    const cached = NARROWED_SETS.get(action);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const narrowed = askQuestionsActionOf(action);
+    NARROWED_SETS.set(action, narrowed);
+    return narrowed;
+}
+export function elicitationCardsOf(entries, errorSentences, questionAnswers = NO_QUESTION_ANSWERS) {
+    const cards = [];
+    for (const entry of entries) {
+        if (entry.kind !== ASK_QUESTIONS_REQUEST_KIND) {
+            continue;
+        }
+        const set = narrowedQuestionSetOf(entry.action);
+        if (set === null) {
+            continue;
+        }
+        cards.push({
+            interruptId: entry.interruptId,
+            runId: entry.runId,
+            toolCallId: entry.toolCallId,
+            anchored: entry.anchored,
+            round: entry.round,
+            status: _statusOf(entry),
+            errorSentence: errorSentences.get(entry.interruptId) ?? null,
+            questions: set.questions,
+            answered: questionAnswers.get(entry.interruptId) ?? null,
+        });
+    }
+    return cards;
+}
+export function sameElicitationCards(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    return a.every((card, index) => {
+        const other = b[index];
+        return (card.interruptId === other.interruptId &&
+            card.runId === other.runId &&
+            card.toolCallId === other.toolCallId &&
+            card.anchored === other.anchored &&
+            card.round === other.round &&
+            card.status === other.status &&
+            card.errorSentence === other.errorSentence &&
+            card.questions === other.questions &&
+            card.answered === other.answered);
+    });
+}
+function _statusOf(entry) {
+    switch (entry.status.kind) {
+        case "pending":
+            return "actionable";
+        case "executing":
+            return "submitting";
+        case "reported":
+            return "answered";
+        case "stale":
+            return "stale";
+    }
+}

package/dist/core/elicitation-pickers.d.ts

@@ -0,0 +1,13 @@
+export interface QuestionOptionModel {
+    text: string;
+    description: string | null;
+}
+export interface QuestionModel {
+    id: string;
+    heading: string;
+    prompt: string;
+    options: readonly QuestionOptionModel[];
+}
+export declare function askQuestionsActionOf(action: Record<string, unknown> | null): {
+    questions: QuestionModel[];
+} | null;

package/dist/core/elicitation-pickers.js

@@ -0,0 +1,71 @@
+export function askQuestionsActionOf(action) {
+    if (action === null) {
+        return null;
+    }
+    const raw = _hasOwn(action, "questions") ? action.questions : null;
+    if (!Array.isArray(raw) || raw.length === 0) {
+        return null;
+    }
+    const questions = [];
+    const seen = new Set();
+    for (const candidate of raw) {
+        if (!_isRecord(candidate)) {
+            return null;
+        }
+        const id = _hasOwn(candidate, "id") ? candidate.id : null;
+        const heading = _hasOwn(candidate, "heading") ? candidate.heading : null;
+        const prompt = _hasOwn(candidate, "prompt") ? candidate.prompt : null;
+        if (typeof id !== "string" ||
+            id === "" ||
+            seen.has(id) ||
+            typeof heading !== "string" ||
+            heading.trim() === "" ||
+            typeof prompt !== "string" ||
+            prompt.trim() === "") {
+            return null;
+        }
+        seen.add(id);
+        const rawOptions = _hasOwn(candidate, "options") ? candidate.options : [];
+        if (!Array.isArray(rawOptions)) {
+            return null;
+        }
+        const options = [];
+        const seenTexts = new Set();
+        for (const option of rawOptions) {
+            if (!_isRecord(option)) {
+                return null;
+            }
+            const text = _hasOwn(option, "text") ? option.text : null;
+            if (typeof text !== "string" || text.trim() === "") {
+                return null;
+            }
+            const folded = text.toLowerCase();
+            if (seenTexts.has(folded)) {
+                return null;
+            }
+            seenTexts.add(folded);
+            const description = _hasOwn(option, "description")
+                ? option.description
+                : null;
+            options.push({
+                text: text.replace(/\\"/g, '"'),
+                description: typeof description === "string" && description.trim() !== ""
+                    ? description.replace(/\\"/g, '"')
+                    : null,
+            });
+        }
+        questions.push({
+            id,
+            heading: heading.replace(/\\"/g, '"'),
+            prompt: prompt.replace(/\\"/g, '"'),
+            options,
+        });
+    }
+    return { questions };
+}
+function _hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+function _isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/core/epoch-sync.d.ts

@@ -0,0 +1,12 @@
+import type { ServingAssistantTurn } from "../contract/threads.js";
+import type { ApprovalCardModel } from "./approval-inbox.js";
+import type { AssistantConversationStore } from "./conversation-store.js";
+import type { ExecutionEntryModel } from "./execution-inbox.js";
+export declare function syncEpoch(store: AssistantConversationStore): void;
+export declare function retireEpoch(store: AssistantConversationStore): void;
+export declare function noteNewestTurn(store: AssistantConversationStore, turn: ServingAssistantTurn | null, switchedThread?: boolean): void;
+export declare function publishApprovalCards(store: AssistantConversationStore, cards: readonly ApprovalCardModel[]): void;
+export declare function reconcileApprovals(store: AssistantConversationStore, turns: readonly ServingAssistantTurn[]): void;
+export declare function theAnswerablePause(store: AssistantConversationStore): ServingAssistantTurn | null;
+export declare function publishExecutionEntries(store: AssistantConversationStore, entries: readonly ExecutionEntryModel[]): void;
+export declare function publishActivity(store: AssistantConversationStore): void;

package/dist/core/epoch-sync.js

@@ -0,0 +1,238 @@
+import { APPROVAL_REQUESTED_EVENT_NAME } from "../contract/events.js";
+import { activitySnapshotOf, IDLE_ACTIVITY, sameActivitySnapshot, settledResultOf, } from "./activity.js";
+import { beginConnectionEpoch, markerAnchorsOf, } from "./connection-epoch.js";
+import { busyOf, noteInterruptAnswerConsumed, publishStore, } from "./conversation-publish.js";
+import { coworkerExecutionWorkOf, sameCoworkerExecutionWork, } from "./coworker-execution-work.js";
+import { elicitationCardsOf, sameElicitationCards, } from "./elicitation-cards.js";
+import { executionHandlersFor, } from "./execution-handlers.js";
+import { restDisplayAnchorsOf } from "./tool-call-display-anchors.js";
+import { toolDenialMarkerOf } from "./tool-denial-anchors.js";
+import { approvalCardSchemasOf } from "./tool-schema-anchors.js";
+export function syncEpoch(store) {
+    const active = store._active;
+    if (active === null || store._disposed) {
+        retireEpoch(store);
+        if (store._approvalsCell.get().length > 0) {
+            publishApprovalCards(store, []);
+        }
+        if (store._coworkerWorkCell.get().size > 0) {
+            store._coworkerWorkCell.set(new Map());
+        }
+        return;
+    }
+    const signature = `${active.thread.id}|${active.thread.stream_thread_id}|${String(store._reconnectNonce)}|${String(store._backgroundAttachNonce)}`;
+    if (store._epoch !== null &&
+        store._epochSignature === signature &&
+        store._epochResume === active.resume) {
+        return;
+    }
+    retireEpoch(store);
+    const epochId = store._nextEpochId;
+    store._nextEpochId += 1;
+    store._epoch = beginConnectionEpoch(_mintEpochDeps(store, active, epochId));
+    store._epochSignature = signature;
+    store._epochResume = active.resume;
+    store._epochConnectedOnce = false;
+    publishApprovalCards(store, active.approvalInbox.cards());
+    store._elicitationErrors.clear();
+    store._questionAnswers.clear();
+    publishExecutionEntries(store, []);
+    store._epoch.withExecutionInbox((inbox) => inbox.adoptCoworkerRequests(active.coworkerRequestTurns));
+    store._messagesCell.set([...store._epoch.agent.messages]);
+    store._markerAnchorsCell.set(markerAnchorsOf(active.resume));
+    store._connectionCell.set({
+        epochId,
+        agent: store._epoch.agent,
+        threadId: active.thread.id,
+        streamThreadId: active.thread.stream_thread_id,
+    });
+}
+function _mintEpochDeps(store, active, epochId) {
+    return {
+        epochId,
+        session: store.deps.session,
+        threadId: active.thread.id,
+        streamThreadId: active.thread.stream_thread_id,
+        ledger: active.ledger,
+        resume: active.resume,
+        approvalInbox: active.approvalInbox,
+        handlersOf: () => _executionHandlers(store, active.thread.id),
+        publishApprovalCards: (cards) => {
+            if (store._epoch?.epochId === epochId) {
+                publishApprovalCards(store, cards);
+            }
+        },
+        publishExecutionEntries: (entries) => {
+            if (store._epoch?.epochId === epochId) {
+                publishExecutionEntries(store, entries);
+            }
+        },
+        publishMarkerAnchors: () => {
+            if (store._epoch?.epochId === epochId) {
+                store._markerAnchorsCell.set(markerAnchorsOf(active.resume));
+                publishStore(store);
+            }
+        },
+        publishMessages: (messages) => {
+            if (store._epoch?.epochId === epochId) {
+                store._messagesCell.set(messages);
+            }
+        },
+        noteInterruptAnswerConsumed: (runId, interruptId, round) => {
+            if (store._epoch?.epochId === epochId) {
+                noteInterruptAnswerConsumed(store, runId, interruptId, round);
+            }
+        },
+        onStreamError: store.handleStreamError,
+        refreshLedger: store.refreshConversation,
+        onUserMessageInjected: store.handleUserMessageInjected,
+        onRunSettled: store.handleRunSettled,
+        onQuietClose: store.handleStreamClosedQuietly,
+        onWorkflowRestarted: store.handleWorkflowRestarted,
+    };
+}
+export function retireEpoch(store) {
+    if (store._epoch === null) {
+        return;
+    }
+    store._epoch.dispose();
+    store._epoch = null;
+    store._epochSignature = null;
+    store._epochResume = null;
+    store._connectionCell.set(null);
+}
+export function noteNewestTurn(store, turn, switchedThread = false) {
+    if (turn?.id !== store._newestTurn?.id) {
+        store._automaticReconnects = 0;
+    }
+    if (switchedThread) {
+        store._lastResult = null;
+        store._awaitingTurn = null;
+    }
+    store._newestTurn = turn;
+    const settled = turn === null ? null : settledResultOf(turn);
+    if (settled !== null) {
+        store._lastResult = settled;
+    }
+}
+export function publishApprovalCards(store, cards) {
+    _recordApprovalCardSchemas(store, cards);
+    store._approvalsCell.set(cards);
+    _publishCoworkerWork(store);
+    publishStore(store);
+}
+function _recordApprovalCardSchemas(store, cards) {
+    const active = store._active;
+    if (active === null) {
+        return;
+    }
+    const before = active.resume.toolSchemaAnchors;
+    for (const card of cards) {
+        if (card.toolCallId === null) {
+            continue;
+        }
+        const schemas = approvalCardSchemasOf(card);
+        if (schemas !== null) {
+            active.resume.recordToolSchemas(card.toolCallId, schemas);
+        }
+    }
+    if (active.resume.toolSchemaAnchors !== before) {
+        store._markerAnchorsCell.set(markerAnchorsOf(active.resume));
+    }
+}
+export function reconcileApprovals(store, turns) {
+    const inbox = store._active?.approvalInbox;
+    if (inbox === undefined) {
+        return;
+    }
+    const pause = theAnswerablePause(store);
+    _hydratePendingApprovalDisplays(store, pause);
+    _hydratePendingApprovalAsks(store, pause);
+    const hydrated = inbox.hydratePendingApprovals(pause);
+    const reconciled = inbox.reconcileWithTurn(store._newestTurn);
+    const settled = inbox.reconcileWithTurns(turns);
+    if (hydrated || reconciled || settled) {
+        publishApprovalCards(store, inbox.cards());
+    }
+}
+export function theAnswerablePause(store) {
+    const newest = store._newestTurn;
+    if (newest !== null &&
+        (newest.status === "awaiting_input" || newest.status === "parked")) {
+        return newest;
+    }
+    return store._awaitingTurn;
+}
+function _hydratePendingApprovalDisplays(store, turn) {
+    const active = store._active;
+    if (active === null ||
+        turn === null ||
+        (turn.status !== "awaiting_input" && turn.status !== "parked") ||
+        turn.run_id === null) {
+        return;
+    }
+    const anchors = restDisplayAnchorsOf(turn.pending_approval_displays);
+    if (anchors.size === 0) {
+        return;
+    }
+    const before = active.resume.toolCallDisplayAnchors;
+    for (const [toolCallId, display] of anchors) {
+        active.resume.recordToolCallDisplay(toolCallId, display);
+    }
+    if (active.resume.toolCallDisplayAnchors !== before) {
+        store._markerAnchorsCell.set(markerAnchorsOf(active.resume));
+    }
+}
+function _hydratePendingApprovalAsks(store, turn) {
+    const active = store._active;
+    if (active === null ||
+        turn === null ||
+        (turn.status !== "awaiting_input" && turn.status !== "parked") ||
+        turn.run_id === null ||
+        !Array.isArray(turn.pending_approvals)) {
+        return;
+    }
+    for (const value of turn.pending_approvals) {
+        const marker = toolDenialMarkerOf(APPROVAL_REQUESTED_EVENT_NAME, value);
+        if (marker !== null) {
+            active.resume.recordToolDenialMarker(marker);
+        }
+    }
+}
+export function publishExecutionEntries(store, entries) {
+    const cards = elicitationCardsOf(entries, store._elicitationErrors, store._questionAnswers);
+    if (!sameElicitationCards(cards, store._elicitationsCell.get())) {
+        store._elicitationsCell.set(cards);
+    }
+    _publishCoworkerWork(store);
+    for (const card of cards) {
+        if (card.status === "answered" || card.status === "stale") {
+            store.questionDrafts.clear(card.interruptId);
+        }
+    }
+    publishStore(store);
+}
+export function publishActivity(store) {
+    const snapshot = store._active === null
+        ? IDLE_ACTIVITY
+        : activitySnapshotOf({
+            busy: busyOf(store),
+            newestTurn: store._newestTurn,
+            approvalCards: store._approvalsCell.get(),
+            pendingDecisionGap: store._pendingDecisionGap,
+            lastResult: store._lastResult,
+        });
+    if (!sameActivitySnapshot(snapshot, store._activityCell.get())) {
+        store._activityCell.set(snapshot);
+    }
+}
+function _executionHandlers(store, threadId) {
+    const capabilities = store.deps.hostCapabilitiesOf();
+    return executionHandlersFor(capabilities.navigate, capabilities.executeActionIntent, threadId);
+}
+function _publishCoworkerWork(store) {
+    const coworkerWork = coworkerExecutionWorkOf(store._epoch?.executionInbox.entries() ?? [], store._approvalsCell.get());
+    if (!sameCoworkerExecutionWork(coworkerWork, store._coworkerWorkCell.get())) {
+        store._coworkerWorkCell.set(coworkerWork);
+    }
+}

package/dist/core/error-copy.d.ts

@@ -0,0 +1,3 @@
+export declare function userSentenceFor(error: unknown): string;
+export declare function stopFailureSentenceFor(error: unknown): string;
+export declare function failureSentenceOf(error: unknown): string;

package/dist/core/error-copy.js

@@ -0,0 +1,45 @@
+import { ServingApiError } from "../transport/serving-error.js";
+import { STOP_NOT_DELIVERED_SENTENCE } from "./stop-copy.js";
+const GENERIC_FAILURE_SENTENCE = "Something went wrong sending that. Please try again.";
+export function userSentenceFor(error) {
+    if (!(error instanceof ServingApiError)) {
+        return GENERIC_FAILURE_SENTENCE;
+    }
+    switch (error.code) {
+        case "ASSISTANT_THREAD_BUSY":
+            return ("The assistant is already answering — possibly in another tab. " +
+                "Wait for it to finish.");
+        case "RATE_LIMITED":
+            return _rateLimitedSentence(error.retryAfterSeconds);
+        case "SUBSCRIPTION_CANNOT_PAY":
+            return error.message;
+        case "SUBSCRIPTION_CONNECT_REQUIRED":
+            return error.message;
+        case "ORCHESTRATION_UNAVAILABLE":
+            return "The assistant couldn't be started right now. Please try again in a moment.";
+        case "NOT_FOUND":
+            return "That conversation isn't available.";
+        case "VALIDATION_ERROR":
+            return "That message couldn't be sent. Shorten it and try again.";
+        default:
+            return error.message;
+    }
+}
+export function stopFailureSentenceFor(error) {
+    if (error instanceof ServingApiError && error.message !== "") {
+        return error.message;
+    }
+    return STOP_NOT_DELIVERED_SENTENCE;
+}
+export function failureSentenceOf(error) {
+    if (error instanceof ServingApiError) {
+        return error.message;
+    }
+    return "Something went wrong. Try again.";
+}
+function _rateLimitedSentence(retryAfterSeconds) {
+    if (retryAfterSeconds !== null && retryAfterSeconds > 0) {
+        return `You're sending messages too quickly. Try again in ${String(retryAfterSeconds)} seconds.`;
+    }
+    return "You're sending messages too quickly. Wait a moment and try again.";
+}

package/dist/core/execution-driver.d.ts

@@ -0,0 +1,37 @@
+import type { AssistantThreadDetailResponse, ResolveTurnToolResultsRequest, ResolveTurnToolResultsResponse } from "../contract/threads.js";
+import { type ExecutionHandler } from "./execution-handlers.js";
+import { type ExecutionEntryModel, type ExecutionInbox } from "./execution-inbox.js";
+export interface ExecutionPassContext {
+    inbox: ExecutionInbox;
+    threadId: string;
+    handlers: ReadonlyMap<string, ExecutionHandler>;
+    attempts: Map<string, number>;
+    fetchThreadDetail: () => Promise<AssistantThreadDetailResponse>;
+    postResults: (turnId: string, request: ResolveTurnToolResultsRequest) => Promise<ResolveTurnToolResultsResponse>;
+    publishEntries: (entries: readonly ExecutionEntryModel[]) => void;
+    onWorkflowRestarted: () => void;
+}
+export declare function runExecutionPass(context: ExecutionPassContext): Promise<void>;
+export interface ExecutionDriverDeps {
+    inbox: ExecutionInbox;
+    threadId: string;
+    handlersOf: () => ReadonlyMap<string, ExecutionHandler>;
+    fetchThreadDetail: () => Promise<AssistantThreadDetailResponse>;
+    postResults: (turnId: string, request: ResolveTurnToolResultsRequest) => Promise<ResolveTurnToolResultsResponse>;
+    publishEntries: (entries: readonly ExecutionEntryModel[]) => void;
+    onWorkflowRestarted: () => void;
+}
+export declare class ExecutionDriver {
+    private readonly deps;
+    private readonly attempts;
+    private passRunning;
+    private passQueued;
+    private timer;
+    private disposed;
+    constructor(deps: ExecutionDriverDeps);
+    noteEntriesChanged(entries: readonly ExecutionEntryModel[]): void;
+    dispose(): void;
+    private _drainInbox;
+    private _someDeliveryWasAttempted;
+    private _clearTimer;
+}