@teaflask/assistant 0.0.0 → 0.6.0

package/dist/core/execution-driver.js

@@ -0,0 +1,223 @@
+import { readExecutedOutcome, recordExecutedOutcome, recordExecutionClaimed, } from "../persistence/execution-ledger.js";
+import { ServingApiError } from "../transport/serving-error.js";
+import { KIND_UNSUPPORTED_OUTCOME, MEMBER_ANSWERABLE_KINDS, } from "./execution-handlers.js";
+import { coworkerExecutionRequestOf, } from "./execution-inbox.js";
+import { MAX_DELIVERY_ATTEMPTS } from "./execution-kinds.js";
+const EXECUTION_PASS_DELAY_MS = 400;
+const EXECUTION_RETRY_DELAY_MS = 2000;
+export async function runExecutionPass(context) {
+    const eligible = eligibleEntriesOf(context.inbox.entries(), context.attempts);
+    if (eligible.length === 0) {
+        return;
+    }
+    const turns = await _theTurnsOrNull(context);
+    if (turns === null || turns.length === 0) {
+        return;
+    }
+    for (const entry of eligible) {
+        await _serveEntry(context, entry, turns);
+    }
+}
+function eligibleEntriesOf(entries, attempts) {
+    return entries.filter((entry) => entry.status.kind === "pending" &&
+        !MEMBER_ANSWERABLE_KINDS.has(entry.kind) &&
+        (attempts.get(entry.interruptId) ?? 0) < MAX_DELIVERY_ATTEMPTS);
+}
+async function _serveEntry(context, entry, turns) {
+    const stored = readExecutedOutcome(context.threadId, entry.interruptId);
+    const holder = _theTurnStillHoldingThisPause(turns, entry);
+    if (stored === null && holder === null) {
+        return;
+    }
+    if (!context.inbox.beginExecution(entry.interruptId)) {
+        return;
+    }
+    context.publishEntries(context.inbox.entries());
+    const outcome = stored ?? (await _freshOutcomeOf(context, entry));
+    const target = holder ??
+        (entry.asker.kind === "coworker"
+            ? turns.find((turn) => turn.id === entry.turnId)
+            : (_theTurnOfThisEntriesRun(turns, entry) ?? turns.at(-1)));
+    if (target === undefined) {
+        _countDeliveryAttempt(context.attempts, entry.interruptId);
+        if (context.inbox.settlePostFailed(entry.interruptId)) {
+            context.publishEntries(context.inbox.entries());
+        }
+        return;
+    }
+    await _reportOutcome(context, entry, target.id, outcome);
+}
+function _theTurnStillHoldingThisPause(turns, entry) {
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const turn = turns[index];
+        if (_turnStillHoldsThisPause(turn, entry)) {
+            return turn;
+        }
+    }
+    return null;
+}
+function _theTurnOfThisEntriesRun(turns, entry) {
+    return turns.find((turn) => turn.run_id === entry.runId);
+}
+async function _freshOutcomeOf(context, entry) {
+    recordExecutionClaimed(context.threadId, entry.interruptId);
+    const handler = context.handlers.get(entry.kind);
+    const outcome = handler === undefined
+        ? KIND_UNSUPPORTED_OUTCOME
+        : await _outcomeNeverThrown(handler, entry);
+    recordExecutedOutcome(context.threadId, entry.interruptId, outcome);
+    return outcome;
+}
+async function _reportOutcome(context, entry, turnId, outcome) {
+    try {
+        const resolution = await context.postResults(turnId, {
+            results: [
+                {
+                    interrupt_id: entry.interruptId,
+                    ok: outcome.ok,
+                    ...(outcome.ok
+                        ? { result: outcome.result }
+                        : { error: { ...outcome.error } }),
+                    ...(entry.asker.kind === "coworker"
+                        ? { coworker_ordinal: entry.asker.ordinal }
+                        : {}),
+                },
+            ],
+        });
+        context.inbox.settleReported(entry.interruptId, outcome.ok);
+        if (resolution.delivery === "workflow_restarted") {
+            context.onWorkflowRestarted();
+        }
+    }
+    catch (error) {
+        if (_turnNoLongerAwaitingToolResults(error)) {
+            if (entry.asker.kind === "coworker") {
+                context.inbox.markCoworkerRequestStale(entry.interruptId);
+            }
+            else {
+                context.inbox.markRunStale(entry.runId);
+            }
+        }
+        else {
+            _countDeliveryAttempt(context.attempts, entry.interruptId);
+            context.inbox.settlePostFailed(entry.interruptId);
+        }
+    }
+    finally {
+        context.publishEntries(context.inbox.entries());
+    }
+}
+async function _outcomeNeverThrown(handler, entry) {
+    try {
+        return await handler(entry);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: {
+                code: "execution_failed",
+                message: "The page hit an unexpected error while performing this action. " +
+                    "Tell the user what was being attempted so they can do it " +
+                    `themselves. (${error instanceof Error ? error.message : String(error)})`,
+            },
+        };
+    }
+}
+async function _theTurnsOrNull(context) {
+    try {
+        return (await context.fetchThreadDetail()).turns;
+    }
+    catch {
+        return null;
+    }
+}
+function _turnStillHoldsThisPause(turn, entry) {
+    if (entry.asker.kind === "coworker") {
+        return (turn.id === entry.turnId &&
+            (turn.pending_coworker_executions ?? []).some((raw) => coworkerExecutionRequestOf(raw)?.card.interrupt_id ===
+                entry.interruptId));
+    }
+    const stillAnswerable = turn.status === "awaiting_input" || turn.status === "parked";
+    if (!stillAnswerable) {
+        return false;
+    }
+    if (turn.run_id === null) {
+        return true;
+    }
+    return (turn.run_id === entry.runId && _turnStillAwaitsThisInterrupt(turn, entry));
+}
+function _turnStillAwaitsThisInterrupt(turn, entry) {
+    return (!Array.isArray(turn.pending_interrupt_ids) ||
+        turn.pending_interrupt_ids.includes(entry.interruptId));
+}
+function _turnNoLongerAwaitingToolResults(error) {
+    return (error instanceof ServingApiError &&
+        error.code === "ASSISTANT_TURN_NOT_AWAITING_TOOL_RESULTS");
+}
+function _countDeliveryAttempt(attempts, interruptId) {
+    attempts.set(interruptId, (attempts.get(interruptId) ?? 0) + 1);
+}
+export class ExecutionDriver {
+    deps;
+    attempts = new Map();
+    passRunning = false;
+    passQueued = false;
+    timer = null;
+    disposed = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    noteEntriesChanged(entries) {
+        if (this.disposed) {
+            return;
+        }
+        this._clearTimer();
+        const eligible = eligibleEntriesOf(entries, this.attempts);
+        if (eligible.length === 0) {
+            return;
+        }
+        this.timer = setTimeout(() => {
+            void this._drainInbox();
+        }, this._someDeliveryWasAttempted(eligible)
+            ? EXECUTION_RETRY_DELAY_MS
+            : EXECUTION_PASS_DELAY_MS);
+    }
+    dispose() {
+        this.disposed = true;
+        this._clearTimer();
+    }
+    async _drainInbox() {
+        if (this.passRunning) {
+            this.passQueued = true;
+            return;
+        }
+        this.passRunning = true;
+        try {
+            do {
+                this.passQueued = false;
+                await runExecutionPass({
+                    inbox: this.deps.inbox,
+                    threadId: this.deps.threadId,
+                    handlers: this.deps.handlersOf(),
+                    attempts: this.attempts,
+                    fetchThreadDetail: this.deps.fetchThreadDetail,
+                    postResults: this.deps.postResults,
+                    publishEntries: this.deps.publishEntries,
+                    onWorkflowRestarted: this.deps.onWorkflowRestarted,
+                });
+            } while (this.passQueued);
+        }
+        finally {
+            this.passRunning = false;
+        }
+    }
+    _someDeliveryWasAttempted(eligible) {
+        return eligible.some((entry) => (this.attempts.get(entry.interruptId) ?? 0) > 0);
+    }
+    _clearTimer() {
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { ActionIntent } from "../contract/actions-adapter.js";
+import type { HttpIntentResult } from "../generated/models/index.js";
+import type { ExecutionEntryModel } from "./execution-inbox.js";
+export type ExecutionHandler = (entry: ExecutionEntryModel) => Promise<ExecutionOutcome>;
+export type HostNavigate = (path: string) => void | Promise<void>;
+export type ExecuteActionIntent = (intent: ActionIntent) => Promise<HttpIntentResult>;
+export { ASK_QUESTIONS_REQUEST_KIND, HIGHLIGHT_REQUEST_KIND, HTTP_INTENT_REQUEST_KIND, KIND_UNSUPPORTED_OUTCOME, MEMBER_ANSWERABLE_KINDS, NAVIGATE_REQUEST_KIND, PREFILL_FORM_REQUEST_KIND, READ_PAGE_REQUEST_KIND, type ExecutionOutcome, } from "./execution-kinds.js";
+import { type ExecutionOutcome } from "./execution-kinds.js";
+export declare function executionHandlersFor(navigate: HostNavigate | null, executeActionIntent: ExecuteActionIntent | null, threadId: string): ReadonlyMap<string, ExecutionHandler>;

package/dist/core/execution-handlers.js

@@ -0,0 +1,369 @@
+import { spotlightElement } from "../affordances/highlight.js";
+import { prefilledFieldsReport, } from "../affordances/prefill.js";
+import { openCompanionDrawer } from "./companion-drawer-flag.js";
+import { browserLayoutProbe } from "../reader/layout-probe.js";
+import { readPageResultOf, SnapshotUnavailableError, } from "../reader/read-page.js";
+import { resolvedElementOfRef } from "../reader/snapshot.js";
+import { actionIntentOf } from "../transport/actions-adapter.js";
+import { boundedTextOf, doorCostOfText, doorLengthCeilingOf, } from "../transport/door-budget.js";
+export { ASK_QUESTIONS_REQUEST_KIND, HIGHLIGHT_REQUEST_KIND, HTTP_INTENT_REQUEST_KIND, KIND_UNSUPPORTED_OUTCOME, MEMBER_ANSWERABLE_KINDS, NAVIGATE_REQUEST_KIND, PREFILL_FORM_REQUEST_KIND, READ_PAGE_REQUEST_KIND, } from "./execution-kinds.js";
+import { HIGHLIGHT_REQUEST_KIND, HTTP_INTENT_REQUEST_KIND, NAVIGATE_REQUEST_KIND, PREFILL_FORM_REQUEST_KIND, READ_PAGE_REQUEST_KIND, } from "./execution-kinds.js";
+const UNUSABLE_PATH_OUTCOME = {
+    ok: false,
+    error: {
+        code: "execution_failed",
+        message: "The navigation request did not carry a usable path. Tell the user " +
+            "where to go instead of retrying.",
+    },
+};
+const UNUSABLE_INTENT_OUTCOME = {
+    ok: false,
+    error: {
+        code: "execution_failed",
+        message: "The action request did not carry a usable intent. Tell the user " +
+            "what you were trying to do so they can do it themselves.",
+    },
+};
+const UNUSABLE_REF_OUTCOME = {
+    ok: false,
+    error: {
+        code: "execution_failed",
+        message: "The request did not carry a usable ref_id. Read the page and use " +
+            "a [ref=…] id from it.",
+    },
+};
+const UNUSABLE_FIELDS_OUTCOME = {
+    ok: false,
+    error: {
+        code: "execution_failed",
+        message: "The prefill request did not carry usable fields. Each entry needs " +
+            "a ref_id from your read of this page and a string value.",
+    },
+};
+const FAILURE_REASON_MAX_CHARS = 300;
+const ACTION_FAILURE_REASON_MAX_ESCAPED_CHARS = 14_000;
+const ACTION_FAILURE_ENVELOPE_RESERVE_DOOR_CHARS = 1_024;
+const ACTION_FAILURE_PAYLOAD_MAX_DOOR_CHARS = 20_000 - ACTION_FAILURE_ENVELOPE_RESERVE_DOOR_CHARS;
+const ACTION_FAILURE_REASON_MIN_ESCAPED_CHARS = 2_000;
+export function executionHandlersFor(navigate, executeActionIntent, threadId) {
+    const handlers = new Map();
+    if (navigate !== null) {
+        handlers.set(NAVIGATE_REQUEST_KIND, (entry) => _navigateOutcomeOf(navigate, entry));
+    }
+    if (executeActionIntent !== null) {
+        handlers.set(HTTP_INTENT_REQUEST_KIND, (entry) => _httpIntentOutcomeOf(executeActionIntent, entry));
+    }
+    handlers.set(READ_PAGE_REQUEST_KIND, (entry) => _readPageOutcomeOf(threadId, entry));
+    handlers.set(HIGHLIGHT_REQUEST_KIND, (entry) => Promise.resolve(_highlightOutcomeOf(entry)));
+    handlers.set(PREFILL_FORM_REQUEST_KIND, (entry) => Promise.resolve(_prefillFormOutcomeOf(entry)));
+    return handlers;
+}
+async function _navigateOutcomeOf(navigate, entry) {
+    const path = _appRelativePathOf(entry.action);
+    if (path === null) {
+        return UNUSABLE_PATH_OUTCOME;
+    }
+    try {
+        await navigate(path);
+    }
+    catch (error) {
+        return _navigationFailedOutcome(path, error);
+    }
+    openCompanionDrawer();
+    const result = { navigated: true, path };
+    return { ok: true, result: { ...result } };
+}
+function _appRelativePathOf(action) {
+    const path = action?.path;
+    if (typeof path !== "string" || !path.startsWith("/")) {
+        return null;
+    }
+    return path;
+}
+function _navigationFailedOutcome(path, error) {
+    return {
+        ok: false,
+        error: {
+            code: "execution_failed",
+            message: `Navigation to "${path}" failed in this page: ` +
+                `${_reasonSentenceOf(error)}. Do not assume the user moved; tell ` +
+                "them the path so they can go there themselves.",
+        },
+    };
+}
+async function _httpIntentOutcomeOf(executeActionIntent, entry) {
+    const intent = actionIntentOf(entry.intent);
+    if (intent === null) {
+        return UNUSABLE_INTENT_OUTCOME;
+    }
+    try {
+        const result = await executeActionIntent(intent);
+        return { ok: true, result: { ...result } };
+    }
+    catch (error) {
+        return _actionFailedOutcome(intent, error);
+    }
+}
+function _actionFailedOutcome(intent, error) {
+    const detail = _failureDetailOf(error);
+    const reason = _failureFirstLineOf(error);
+    let omitted = detail?.fieldsOmitted ?? 0;
+    let reasonBudget = Math.min(ACTION_FAILURE_REASON_MAX_ESCAPED_CHARS, doorCostOfText(reason));
+    let fields = detail?.fields;
+    for (;;) {
+        const boundedReason = boundedTextOf(reason, reasonBudget);
+        reasonBudget = doorCostOfText(boundedReason);
+        const candidate = _actionFailureErrorOf(intent, detail === null
+            ? null
+            : {
+                status: detail.status,
+                code: detail.code,
+                ...(fields === undefined ? {} : { fields }),
+                ...(omitted > 0 ? { fieldsOmitted: omitted } : {}),
+            }, boundedReason);
+        const over = doorLengthCeilingOf(JSON.stringify(candidate)) -
+            ACTION_FAILURE_PAYLOAD_MAX_DOOR_CHARS;
+        if (over <= 0 || reasonBudget === 0) {
+            return { ok: false, error: candidate };
+        }
+        if (reasonBudget > ACTION_FAILURE_REASON_MIN_ESCAPED_CHARS) {
+            reasonBudget = Math.max(ACTION_FAILURE_REASON_MIN_ESCAPED_CHARS, reasonBudget - over);
+        }
+        else if (fields !== undefined && fields.length > 1) {
+            fields = fields.slice(0, -1);
+            omitted += 1;
+        }
+        else {
+            reasonBudget = Math.max(0, reasonBudget - over);
+        }
+    }
+}
+function _actionFailureErrorOf(intent, detail, reason) {
+    return {
+        code: "execution_failed",
+        message: `"${intent.action.title}" failed in this page: ` +
+            `${_detailPrefixOf(detail)}${reason}. ` +
+            _fieldProblemsSentenceOf(detail) +
+            "Do not assume the action ran; tell " +
+            "the user what was being attempted so they can decide what to do.",
+        ...(detail === null ? {} : { detail }),
+    };
+}
+function _detailPrefixOf(detail) {
+    return detail === null
+        ? ""
+        : `HTTP ${String(detail.status)} ${detail.code} — `;
+}
+function _fieldProblemsSentenceOf(detail) {
+    if (detail?.fields === undefined || detail.fields.length === 0) {
+        return "";
+    }
+    const problems = detail.fields
+        .map((field) => field.path === ""
+        ? JSON.stringify(field.message)
+        : `${JSON.stringify(field.path)}: ${JSON.stringify(field.message)}`)
+        .join("; ");
+    const omitted = detail.fieldsOmitted === undefined || detail.fieldsOmitted <= 0
+        ? ""
+        : `; and ${String(detail.fieldsOmitted)} more`;
+    return `Field problems: ${problems}${omitted}. `;
+}
+const FAILURE_DETAIL_MAX_FIELDS = 20;
+const FAILURE_DETAIL_CODE_MAX_CHARS = 80;
+const FAILURE_DETAIL_FIELD_MAX_CHARS = 300;
+const FAILURE_CODE_TOKEN = /^\S{1,80}$/;
+function _isHttpStatus(status) {
+    return (typeof status === "number" &&
+        Number.isInteger(status) &&
+        status >= 100 &&
+        status <= 599);
+}
+function _failureDetailOf(error) {
+    if (typeof error !== "object" || error === null) {
+        return null;
+    }
+    const status = error.status;
+    const body = error.error;
+    if (!_isHttpStatus(status) ||
+        typeof body !== "object" ||
+        body === null ||
+        typeof body.code !== "string") {
+        return null;
+    }
+    const code = body.code.slice(0, FAILURE_DETAIL_CODE_MAX_CHARS);
+    if (!FAILURE_CODE_TOKEN.test(code)) {
+        return null;
+    }
+    const named = _failureFieldsOf(body.details);
+    if (named === null) {
+        return { status, code };
+    }
+    return {
+        status,
+        code,
+        fields: named.fields,
+        ...(named.omitted > 0 ? { fieldsOmitted: named.omitted } : {}),
+    };
+}
+function _failureFieldsOf(details) {
+    if (!Array.isArray(details)) {
+        return null;
+    }
+    const fields = [];
+    let omitted = 0;
+    for (const entry of details) {
+        if (typeof entry !== "object" || entry === null) {
+            continue;
+        }
+        const record = entry;
+        const message = record.message ?? record.msg;
+        if (typeof message !== "string") {
+            continue;
+        }
+        const sentenceMessage = _sentenceTextOf(message);
+        if (sentenceMessage === "") {
+            continue;
+        }
+        if (fields.length >= FAILURE_DETAIL_MAX_FIELDS) {
+            omitted += 1;
+            continue;
+        }
+        fields.push({
+            path: _fieldPathOf(record.path ?? record.loc ?? record.field),
+            message: sentenceMessage,
+        });
+    }
+    return fields.length === 0 ? null : { fields, omitted };
+}
+function _fieldPathOf(path) {
+    if (typeof path === "string") {
+        return _sentenceTextOf(path);
+    }
+    if (Array.isArray(path)) {
+        return _sentenceTextOf(path
+            .filter((part) => typeof part === "string" || typeof part === "number")
+            .map(String)
+            .join("."));
+    }
+    return "";
+}
+function _sentenceTextOf(text) {
+    return text
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, FAILURE_DETAIL_FIELD_MAX_CHARS);
+}
+function _readPageOutcomeOf(threadId, entry) {
+    try {
+        const result = readPageResultOf(threadId, entry.action, browserLayoutProbe());
+        return Promise.resolve({ ok: true, result: { ...result } });
+    }
+    catch (error) {
+        return Promise.resolve(_readPageFailedOutcome(error));
+    }
+}
+function _readPageFailedOutcome(error) {
+    if (error instanceof SnapshotUnavailableError) {
+        return {
+            ok: false,
+            error: { code: "execution_failed", message: error.message },
+        };
+    }
+    return {
+        ok: false,
+        error: {
+            code: "execution_failed",
+            message: `Reading this page failed: ${_reasonSentenceOf(error)}. ` +
+                "Ask the user to describe what they see instead.",
+        },
+    };
+}
+function _highlightOutcomeOf(entry) {
+    const refId = _refIdOf(entry.action);
+    if (refId === null) {
+        return UNUSABLE_REF_OUTCOME;
+    }
+    const resolved = resolvedElementOfRef(refId);
+    if (resolved.error !== null) {
+        return {
+            ok: false,
+            error: { code: "execution_failed", message: resolved.error },
+        };
+    }
+    try {
+        spotlightElement(resolved.element, browserLayoutProbe());
+    }
+    catch (error) {
+        return _highlightFailedOutcome(error);
+    }
+    const result = { highlighted: true, ref_id: refId };
+    return { ok: true, result: { ...result } };
+}
+function _refIdOf(action) {
+    const refId = action?.ref_id;
+    if (typeof refId !== "string" || refId.trim() === "") {
+        return null;
+    }
+    return refId;
+}
+function _highlightFailedOutcome(error) {
+    return {
+        ok: false,
+        error: {
+            code: "execution_failed",
+            message: `Highlighting on this page failed: ${_reasonSentenceOf(error)}. ` +
+                "Describe where the element is in words instead.",
+        },
+    };
+}
+function _prefillFormOutcomeOf(entry) {
+    const fields = _prefillFieldsOf(entry.action);
+    if (fields === null) {
+        return UNUSABLE_FIELDS_OUTCOME;
+    }
+    try {
+        const result = prefilledFieldsReport(fields);
+        return { ok: true, result: { ...result } };
+    }
+    catch (error) {
+        return _prefillFailedOutcome(error);
+    }
+}
+function _prefillFieldsOf(action) {
+    const fields = action?.fields;
+    if (!Array.isArray(fields) || fields.length === 0) {
+        return null;
+    }
+    const narrowed = [];
+    for (const entry of fields) {
+        if (typeof entry !== "object" || entry === null) {
+            return null;
+        }
+        const candidate = entry;
+        const refId = _refIdOf(candidate);
+        if (refId === null || typeof candidate.value !== "string") {
+            return null;
+        }
+        narrowed.push({ refId, value: candidate.value });
+    }
+    return narrowed;
+}
+function _prefillFailedOutcome(error) {
+    return {
+        ok: false,
+        error: {
+            code: "execution_failed",
+            message: `Filling this page's fields failed: ${_reasonSentenceOf(error)}. ` +
+                "Do not assume anything was filled; tell the user the values so " +
+                "they can type them in themselves.",
+        },
+    };
+}
+function _reasonSentenceOf(error) {
+    return _failureFirstLineOf(error).slice(0, FAILURE_REASON_MAX_CHARS);
+}
+function _failureFirstLineOf(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const firstLine = message.split("\n", 1)[0].trim();
+    return firstLine === "" ? "an unknown error" : firstLine;
+}

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

@@ -0,0 +1,72 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+import { type ToolExecutionRequestedPayload } from "../contract/events.js";
+import type { TurnStatus } from "../contract/threads.js";
+import { type CoworkerRequestTurn } from "./execution-request-narrowing.js";
+export { coworkerExecutionRequestOf, executionRequestedPayloadOf, type CoworkerRequestTurn, } from "./execution-request-narrowing.js";
+export type ExecutionEntryStatus = {
+    kind: "pending";
+} | {
+    kind: "executing";
+} | {
+    kind: "reported";
+    ok: boolean;
+} | {
+    kind: "stale";
+};
+type ExecutionAsker = {
+    kind: "assistant";
+} | {
+    kind: "coworker";
+    ordinal: number;
+};
+export interface ExecutionEntryModel {
+    interruptId: string;
+    toolName: string;
+    toolCallId: string | null;
+    anchored: boolean;
+    kind: string;
+    action: Record<string, unknown> | null;
+    intent: Record<string, unknown> | null;
+    round: number;
+    runId: string;
+    status: ExecutionEntryStatus;
+    asker: ExecutionAsker;
+    turnId: string | null;
+}
+export interface SettledRunView {
+    run_id: string | null;
+    status: TurnStatus;
+}
+export declare function toolResultRecordedPayloadOf(value: unknown): {
+    interruptId: string;
+    ok: boolean;
+} | null;
+export declare class ExecutionInbox {
+    private currentRunId;
+    private readonly seenRunIds;
+    private readonly seenToolCallIds;
+    private readonly coworkerAsks;
+    private entryList;
+    noteRunStarted(runId: string): boolean;
+    noteToolCallStart(toolCallId: string): boolean;
+    noteExecutionRequested(payload: ToolExecutionRequestedPayload): boolean;
+    adoptCoworkerRequests(turns: readonly CoworkerRequestTurn[]): boolean;
+    markCoworkerRequestStale(interruptId: string): boolean;
+    markCoworkerRequestsStale(): boolean;
+    noteToolResultRecorded(interruptId: string, ok: boolean): boolean;
+    noteToolCallResult(toolCallId: string): boolean;
+    noteRunFinished(): boolean;
+    reconcileWithTurns(turns: readonly SettledRunView[]): boolean;
+    noteRunError(): boolean;
+    beginExecution(interruptId: string): boolean;
+    settleReported(interruptId: string, ok: boolean): boolean;
+    settlePostFailed(interruptId: string): boolean;
+    markRunStale(runId: string): boolean;
+    entries(): readonly ExecutionEntryModel[];
+    private _hasEntry;
+    private _newestRoundOf;
+    private _staleWhere;
+    private _removeWhere;
+    private _transition;
+}
+export declare function executionInboxRecorder(inbox: ExecutionInbox, onEntriesChanged: (entries: readonly ExecutionEntryModel[]) => void): AgentSubscriber;