@teaflask/assistant 0.0.0 → 0.6.0

package/dist/core/approval-decision.js

@@ -0,0 +1,162 @@
+import { resolveTurnApproval } from "../transport/serving-api.js";
+import { ServingApiError } from "../transport/serving-error.js";
+import { ANSWER_NOT_SENT_SENTENCE, } from "./approval-inbox.js";
+import { publishApprovalCards } from "./epoch-sync.js";
+import { userSentenceFor } from "./error-copy.js";
+export async function submitApprovalDecisionFromStore(store, card, decision) {
+    const active = store._active;
+    const trusting = decision.trust === true && !card.gated && card.trustAvailable;
+    const telemetry = _approvalTelemetryOf(store, card, decision, trusting, active);
+    telemetry("approval_submit_attempted");
+    if (active === null) {
+        telemetry("approval_submit_dropped", "no_active_thread");
+        store.deps.reportError(new Error(`Approval decision dropped: no active conversation to answer into (interrupt ${card.interruptId}).`));
+        return;
+    }
+    const inbox = active.approvalInbox;
+    if (!inbox.beginSubmit(card.interruptId)) {
+        _explainBeginSubmitRefusal(store, inbox, card, telemetry);
+        return;
+    }
+    const publishIfCurrent = () => {
+        if (store._active?.approvalInbox === inbox) {
+            publishApprovalCards(store, inbox.cards());
+        }
+    };
+    publishIfCurrent();
+    try {
+        await _postApprovalDecision(store, active, inbox, card, decision, trusting, telemetry);
+    }
+    catch (error) {
+        if (_turnNoLongerAwaiting(error)) {
+            if (card.asker.kind === "coworker") {
+                inbox.markCoworkerCardStale(card.interruptId);
+            }
+            else {
+                inbox.markPauseStale();
+            }
+            void store.refreshConversation();
+        }
+        else {
+            inbox.settleSubmitError(card.interruptId, userSentenceFor(error));
+        }
+    }
+    finally {
+        publishIfCurrent();
+    }
+}
+function _approvalTelemetryOf(store, card, decision, trusting, active) {
+    return (name, dropReason) => {
+        store.deps.onTelemetry({
+            name,
+            properties: {
+                interrupt_id: card.interruptId,
+                thread_id: active?.thread.id ?? null,
+                approved: decision.approved,
+                trusted: trusting,
+                card_status: card.status.kind,
+                parked: card.parked,
+                ...(dropReason === undefined ? {} : { drop_reason: dropReason }),
+            },
+        });
+    };
+}
+function _explainBeginSubmitRefusal(store, inbox, card, telemetry) {
+    const liveKind = inbox.statusOf(card.interruptId);
+    if (liveKind === "submitting") {
+        telemetry("approval_submit_dropped", "already_submitting");
+        return;
+    }
+    telemetry("approval_submit_dropped", liveKind === "answered"
+        ? "not_actionable_answered"
+        : liveKind === "stale"
+            ? "not_actionable_stale"
+            : "card_missing");
+    if (liveKind !== null) {
+        void store.refreshConversation();
+    }
+}
+async function _postApprovalDecision(store, active, inbox, card, decision, trusting, telemetry) {
+    const turnId = card.asker.kind === "coworker"
+        ? card.turnId
+        : await _turnIdAwaitingInterrupt(store, card, active);
+    if (turnId === null) {
+        inbox.settleSubmitError(card.interruptId, ANSWER_NOT_SENT_SENTENCE);
+        telemetry("approval_submit_dropped", "no_turn_id");
+        return;
+    }
+    telemetry("approval_submit_sent");
+    const resolution = await resolveTurnApproval(store.deps.session, active.thread.id, turnId, {
+        approvals: [
+            {
+                interrupt_id: card.interruptId,
+                approved: decision.approved,
+                ...(trusting ? { trust: true } : {}),
+                ...(decision.feedback === undefined
+                    ? {}
+                    : { feedback: decision.feedback }),
+            },
+        ],
+    });
+    inbox.settleSubmitAnswered(card.interruptId, decision.approved, trusting);
+    if (store._active?.approvalInbox === inbox) {
+        if (resolution.delivery === "workflow_restarted") {
+            store.handleWorkflowRestarted();
+        }
+        else if (resolution.delivery === "already_consumed") {
+            void store.refreshConversation();
+        }
+    }
+}
+async function _turnIdAwaitingInterrupt(store, card, active) {
+    if (_turnAwaitsInterrupt(store._newestTurn, card.interruptId)) {
+        return store._newestTurn?.id ?? null;
+    }
+    await store.refreshConversation();
+    if (store._active?.approvalInbox === active.approvalInbox) {
+        if (_turnAwaitsInterrupt(store._newestTurn, card.interruptId)) {
+            return store._newestTurn?.id ?? null;
+        }
+        if (_turnAwaitsInterrupt(store._awaitingTurn, card.interruptId)) {
+            return store._awaitingTurn?.id ?? null;
+        }
+    }
+    const ledger = active.ledger;
+    return (ledger.turnForRun(card.runId) ?? ledger.newestTurn())?.turnId ?? null;
+}
+export async function turnIdAnsweredBy(store, active, card) {
+    const ledger = active.ledger;
+    const known = ledger.turnForRun(card.runId);
+    if (known !== null) {
+        return known.turnId;
+    }
+    await store.refreshConversation();
+    const refreshed = ledger.turnForRun(card.runId);
+    if (refreshed !== null) {
+        return refreshed.turnId;
+    }
+    if (store._active?.approvalInbox === active.approvalInbox) {
+        if (_turnAwaitsInterrupt(store._newestTurn, card.interruptId)) {
+            return store._newestTurn?.id ?? null;
+        }
+        if (_turnAwaitsInterrupt(store._awaitingTurn, card.interruptId)) {
+            return store._awaitingTurn?.id ?? null;
+        }
+    }
+    return ledger.newestTurn()?.turnId ?? null;
+}
+function _turnAwaitsInterrupt(turn, interruptId) {
+    if (turn === null) {
+        return false;
+    }
+    if (turn.status !== "awaiting_input" && turn.status !== "parked") {
+        return false;
+    }
+    return (turn.run_id === null ||
+        !Array.isArray(turn.pending_interrupt_ids) ||
+        turn.pending_interrupt_ids.includes(interruptId));
+}
+function _turnNoLongerAwaiting(error) {
+    return (error instanceof ServingApiError &&
+        error.code === "ASSISTANT_TURN_NOT_AWAITING_APPROVAL");
+}

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

@@ -0,0 +1,101 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+import { type ApprovalRequestedPayload } from "../contract/events.js";
+import type { TurnStatus } from "../contract/threads.js";
+import { type CoworkerApprovalTurn } from "./approval-request-narrowing.js";
+export { approvalRequestedPayloadOf, coworkerApprovalRequestOf, type CoworkerApprovalTurn, } from "./approval-request-narrowing.js";
+export type ApprovalCardStatus = {
+    kind: "actionable";
+    errorSentence: string | null;
+} | {
+    kind: "submitting";
+} | {
+    kind: "answered";
+    approved: boolean;
+    trusted: boolean;
+} | {
+    kind: "stale";
+};
+export type ApprovalAsker = {
+    kind: "assistant";
+} | {
+    kind: "coworker";
+    ordinal: number;
+    label: string;
+};
+export interface ApprovalCardModel {
+    interruptId: string;
+    toolName: string | null;
+    toolArgs: Record<string, unknown>;
+    toolInputSchema: Record<string, unknown> | null;
+    toolOutputSchema: Record<string, unknown> | null;
+    prompt: string;
+    toolCallId: string | null;
+    anchored: boolean;
+    round: number;
+    runId: string;
+    parked: boolean;
+    gated: boolean;
+    trustAvailable: boolean;
+    status: ApprovalCardStatus;
+    asker: ApprovalAsker;
+    turnId: string | null;
+}
+export interface ApprovalDecisionInput {
+    approved: boolean;
+    trust?: boolean;
+    feedback?: string;
+}
+export interface ApprovalInboxCapabilities {
+    anchoring?: boolean;
+    gate?: boolean;
+    trust?: boolean;
+}
+export declare const SERVING_APPROVAL_CAPABILITIES: Required<ApprovalInboxCapabilities>;
+export interface ApprovalTurnRecord extends CoworkerApprovalTurn {
+    status: TurnStatus;
+    pending_interrupt_ids?: readonly string[];
+    awaiting_round?: number | null;
+    pending_approvals?: readonly unknown[];
+}
+export declare class ApprovalInbox {
+    private currentRunId;
+    private readonly seenToolCallIds;
+    private cardList;
+    private readonly closedInterruptIds;
+    private readonly settledRunIds;
+    private readonly capabilities;
+    constructor(capabilities?: ApprovalInboxCapabilities);
+    noteRunStarted(runId: string): boolean;
+    noteToolCallStart(toolCallId: string): boolean;
+    noteApprovalRequested(payload: ApprovalRequestedPayload): boolean;
+    noteApprovalResolved(interruptId: string, approved: boolean): boolean;
+    noteToolCallResult(toolCallId: string): boolean;
+    noteRunFinished(): boolean;
+    noteRunError(): boolean;
+    noteStreamClosedWithoutTerminal(): boolean;
+    beginSubmit(interruptId: string): boolean;
+    settleSubmitAnswered(interruptId: string, approved: boolean, trusted?: boolean): boolean;
+    settleSubmitError(interruptId: string, sentence: string): boolean;
+    markPauseStale(): boolean;
+    markCoworkerCardStale(interruptId: string): boolean;
+    markCoworkerCardsStale(): boolean;
+    hydratePendingApprovals(turn: ApprovalTurnRecord | null): boolean;
+    adoptCoworkerApprovals(turns: readonly CoworkerApprovalTurn[]): boolean;
+    reconcileWithTurn(turn: ApprovalTurnRecord | null): boolean;
+    reconcileWithTurns(turns: readonly Pick<ApprovalTurnRecord, "run_id" | "status">[]): boolean;
+    cards(): readonly ApprovalCardModel[];
+    statusOf(interruptId: string): ApprovalCardStatus["kind"] | null;
+    private _cardFrom;
+    private _anchoredOf;
+    private _newestRoundOf;
+    private _delistWhere;
+    private _staleWhere;
+    private _removeWhere;
+    private _transition;
+}
+export declare const ANSWER_NOT_SENT_SENTENCE = "That answer couldn't be sent. Please try again.";
+export declare function answerablePauseOf<T extends {
+    status: TurnStatus;
+}>(turns: readonly T[]): T | null;
+export declare function reconcileApprovalsWithTurns(inbox: ApprovalInbox, turns: readonly ApprovalTurnRecord[]): boolean;
+export declare function approvalInboxRecorder(inbox: ApprovalInbox, onCardsChanged: (cards: readonly ApprovalCardModel[]) => void, onStreamClosedWithoutTerminal: () => void): AgentSubscriber;

package/dist/core/approval-inbox.js

@@ -0,0 +1,399 @@
+import { APPROVAL_REQUESTED_EVENT_NAME, APPROVAL_RESOLVED_EVENT_NAME, } from "../contract/events.js";
+import { isTerminalTurnStatus } from "./activity.js";
+import { approvalRequestedPayloadOf, coworkerApprovalRequestOf, } from "./approval-request-narrowing.js";
+import { approvalResolvedPayloadOf } from "../core/approval-resolved.js";
+export { approvalRequestedPayloadOf, coworkerApprovalRequestOf, } from "./approval-request-narrowing.js";
+const ACTIONABLE = {
+    kind: "actionable",
+    errorSentence: null,
+};
+export const SERVING_APPROVAL_CAPABILITIES = { anchoring: true, gate: true, trust: true };
+export class ApprovalInbox {
+    currentRunId = null;
+    seenToolCallIds = new Set();
+    cardList = [];
+    closedInterruptIds = new Set();
+    settledRunIds = new Set();
+    capabilities;
+    constructor(capabilities = {}) {
+        this.capabilities = capabilities;
+    }
+    noteRunStarted(runId) {
+        this.currentRunId = runId;
+        return false;
+    }
+    noteToolCallStart(toolCallId) {
+        if (this.capabilities.anchoring === true) {
+            this.seenToolCallIds.add(toolCallId);
+        }
+        return false;
+    }
+    noteApprovalRequested(payload) {
+        if (this.currentRunId === null) {
+            return false;
+        }
+        const runId = this.currentRunId;
+        if (this.settledRunIds.has(runId)) {
+            return false;
+        }
+        const held = this.cardList.find((card) => card.interruptId === payload.interrupt_id);
+        if (held !== undefined) {
+            if (held.asker.kind === "coworker") {
+                return false;
+            }
+            const toolCallId = payload.tool_call_id ?? null;
+            const anchored = this._anchoredOf(toolCallId);
+            const changed = held.runId !== runId ||
+                held.round !== payload.round ||
+                held.toolCallId !== toolCallId ||
+                held.anchored !== anchored;
+            held.runId = runId;
+            held.round = payload.round;
+            held.toolCallId = toolCallId;
+            held.anchored = anchored;
+            return changed;
+        }
+        const newestRound = this._newestRoundOf(runId);
+        if (newestRound !== null && payload.round < newestRound) {
+            return false;
+        }
+        if (newestRound !== null && payload.round > newestRound) {
+            this._removeWhere((card) => card.asker.kind === "assistant" &&
+                card.runId === runId &&
+                card.round < payload.round);
+        }
+        this.cardList.push(this._cardFrom(payload, runId, null));
+        return true;
+    }
+    noteApprovalResolved(interruptId, approved) {
+        return this._transition(interruptId, ["actionable", "submitting"], {
+            kind: "answered",
+            approved,
+            trusted: false,
+        });
+    }
+    noteToolCallResult(toolCallId) {
+        return this._removeWhere((card) => card.toolCallId === toolCallId);
+    }
+    noteRunFinished() {
+        return false;
+    }
+    noteRunError() {
+        return this._removeWhere((card) => card.asker.kind === "assistant" && card.runId === this.currentRunId);
+    }
+    noteStreamClosedWithoutTerminal() {
+        let changed = false;
+        for (const card of this.cardList) {
+            if (card.asker.kind === "assistant" &&
+                !card.parked &&
+                (card.status.kind === "actionable" || card.status.kind === "submitting")) {
+                card.parked = true;
+                changed = true;
+            }
+        }
+        return changed;
+    }
+    beginSubmit(interruptId) {
+        return this._transition(interruptId, ["actionable"], {
+            kind: "submitting",
+        });
+    }
+    settleSubmitAnswered(interruptId, approved, trusted = false) {
+        return this._transition(interruptId, ["submitting"], {
+            kind: "answered",
+            approved,
+            trusted,
+        });
+    }
+    settleSubmitError(interruptId, sentence) {
+        return this._transition(interruptId, ["submitting"], {
+            kind: "actionable",
+            errorSentence: sentence,
+        });
+    }
+    markPauseStale() {
+        return this._staleWhere((card) => card.asker.kind === "assistant");
+    }
+    markCoworkerCardStale(interruptId) {
+        return this._staleWhere((card) => card.asker.kind === "coworker" && card.interruptId === interruptId);
+    }
+    markCoworkerCardsStale() {
+        return this._staleWhere((card) => card.asker.kind === "coworker");
+    }
+    hydratePendingApprovals(turn) {
+        if (turn === null ||
+            (turn.status !== "awaiting_input" && turn.status !== "parked") ||
+            turn.run_id === null ||
+            !Array.isArray(turn.pending_approvals)) {
+            return false;
+        }
+        const runId = turn.run_id;
+        let changed = false;
+        for (const value of turn.pending_approvals) {
+            const payload = approvalRequestedPayloadOf(value);
+            if (payload === null) {
+                continue;
+            }
+            if (this.closedInterruptIds.has(payload.interrupt_id)) {
+                continue;
+            }
+            if (this.cardList.some((card) => card.interruptId === payload.interrupt_id)) {
+                continue;
+            }
+            const newestRound = this._newestRoundOf(runId);
+            if (newestRound !== null && payload.round < newestRound) {
+                continue;
+            }
+            this.cardList.push(this._cardFrom(payload, runId, null));
+            changed = true;
+        }
+        return changed;
+    }
+    adoptCoworkerApprovals(turns) {
+        let changed = false;
+        const listed = new Set();
+        for (const turn of turns) {
+            if (turn.id === undefined) {
+                continue;
+            }
+            for (const raw of turn.pending_coworker_approvals ?? []) {
+                const request = coworkerApprovalRequestOf(raw);
+                if (request === null) {
+                    continue;
+                }
+                const interruptId = request.card.interrupt_id;
+                listed.add(interruptId);
+                const held = this.cardList.find((card) => card.interruptId === interruptId);
+                if (held === undefined) {
+                    this.cardList.push(this._cardFrom(request.card, turn.run_id ?? turn.id, {
+                        asker: {
+                            kind: "coworker",
+                            ordinal: request.ordinal,
+                            label: request.label,
+                        },
+                        turnId: turn.id,
+                        parked: request.parked,
+                    }));
+                    changed = true;
+                }
+                else if (held.asker.kind === "coworker" &&
+                    held.parked !== request.parked) {
+                    held.parked = request.parked;
+                    changed = true;
+                }
+            }
+        }
+        if (turns.length > 0) {
+            const delisted = this._delistWhere((card) => card.asker.kind === "coworker" && !listed.has(card.interruptId));
+            changed = delisted || changed;
+        }
+        return changed;
+    }
+    reconcileWithTurn(turn) {
+        if (turn === null) {
+            return false;
+        }
+        if (isTerminalTurnStatus(turn.status)) {
+            return this._removeWhere((card) => card.asker.kind === "assistant" && card.status.kind !== "submitting");
+        }
+        const parked = turn.status === "parked";
+        const pendingIds = _membershipIsJudgeable(turn)
+            ? turn.pending_interrupt_ids
+            : null;
+        const awaitingRound = turn.awaiting_round ?? null;
+        let changed = false;
+        for (const card of this.cardList) {
+            if (card.asker.kind === "coworker" ||
+                (card.status.kind !== "actionable" && card.status.kind !== "submitting")) {
+                continue;
+            }
+            if (card.parked !== parked) {
+                card.parked = parked;
+                changed = true;
+            }
+            if (pendingIds !== null &&
+                card.status.kind === "actionable" &&
+                !(awaitingRound !== null && card.round > awaitingRound) &&
+                !pendingIds.includes(card.interruptId)) {
+                card.status = { kind: "stale" };
+                changed = true;
+            }
+        }
+        return changed;
+    }
+    reconcileWithTurns(turns) {
+        for (const turn of turns) {
+            if (isTerminalTurnStatus(turn.status) && turn.run_id !== null) {
+                this.settledRunIds.add(turn.run_id);
+            }
+        }
+        return this._removeWhere((card) => card.asker.kind === "assistant" &&
+            card.status.kind !== "submitting" &&
+            this.settledRunIds.has(card.runId));
+    }
+    cards() {
+        return this.cardList.map((card) => ({ ...card }));
+    }
+    statusOf(interruptId) {
+        return (this.cardList.find((card) => card.interruptId === interruptId)?.status
+            .kind ?? null);
+    }
+    _cardFrom(payload, runId, ask) {
+        const toolCallId = payload.tool_call_id ?? null;
+        return {
+            interruptId: payload.interrupt_id,
+            toolName: payload.tool_name ?? null,
+            toolArgs: payload.tool_args,
+            toolInputSchema: payload.tool_input_schema ?? null,
+            toolOutputSchema: payload.tool_output_schema ?? null,
+            prompt: payload.prompt,
+            toolCallId,
+            anchored: this._anchoredOf(toolCallId),
+            round: payload.round,
+            runId,
+            parked: ask?.parked ?? false,
+            gated: this.capabilities.gate === true && payload.gated,
+            trustAvailable: this.capabilities.trust === true && payload.trust_available,
+            status: ACTIONABLE,
+            asker: ask?.asker ?? { kind: "assistant" },
+            turnId: ask?.turnId ?? null,
+        };
+    }
+    _anchoredOf(toolCallId) {
+        return toolCallId !== null && this.seenToolCallIds.has(toolCallId);
+    }
+    _newestRoundOf(runId) {
+        const rounds = this.cardList
+            .filter((card) => card.asker.kind === "assistant" && card.runId === runId)
+            .map((card) => card.round);
+        return rounds.length > 0 ? Math.max(...rounds) : null;
+    }
+    _delistWhere(doomed) {
+        const kept = this.cardList.filter((card) => !doomed(card));
+        if (kept.length === this.cardList.length) {
+            return false;
+        }
+        this.cardList = kept;
+        return true;
+    }
+    _staleWhere(doomed) {
+        let changed = false;
+        for (const card of this.cardList) {
+            if (doomed(card) &&
+                (card.status.kind === "actionable" || card.status.kind === "submitting")) {
+                card.status = { kind: "stale" };
+                changed = true;
+            }
+        }
+        return changed;
+    }
+    _removeWhere(doomed) {
+        const kept = [];
+        let changed = false;
+        for (const card of this.cardList) {
+            if (doomed(card)) {
+                this.closedInterruptIds.add(card.interruptId);
+                changed = true;
+            }
+            else {
+                kept.push(card);
+            }
+        }
+        if (!changed) {
+            return false;
+        }
+        this.cardList = kept;
+        return true;
+    }
+    _transition(interruptId, fromKinds, to) {
+        const card = this.cardList.find((known) => known.interruptId === interruptId);
+        if (card === undefined || !fromKinds.includes(card.status.kind)) {
+            return false;
+        }
+        card.status = to;
+        return true;
+    }
+}
+function _membershipIsJudgeable(turn) {
+    return ((turn.status === "awaiting_input" || turn.status === "parked") &&
+        turn.run_id !== null &&
+        Array.isArray(turn.pending_interrupt_ids));
+}
+export const ANSWER_NOT_SENT_SENTENCE = "That answer couldn't be sent. Please try again.";
+export function answerablePauseOf(turns) {
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const turn = turns[index];
+        if (turn.status === "awaiting_input" || turn.status === "parked") {
+            return turn;
+        }
+    }
+    return null;
+}
+export function reconcileApprovalsWithTurns(inbox, turns) {
+    const newest = turns[turns.length - 1] ?? null;
+    const hydrated = inbox.hydratePendingApprovals(answerablePauseOf(turns));
+    const adopted = inbox.adoptCoworkerApprovals(turns);
+    const reconciled = inbox.reconcileWithTurn(newest);
+    const settled = inbox.reconcileWithTurns(turns);
+    return hydrated || adopted || reconciled || settled;
+}
+export function approvalInboxRecorder(inbox, onCardsChanged, onStreamClosedWithoutTerminal) {
+    let endedAtTerminal = false;
+    let failed = false;
+    const publishWhen = (changed) => {
+        if (changed) {
+            onCardsChanged(inbox.cards());
+        }
+    };
+    return {
+        onRunInitialized() {
+            endedAtTerminal = false;
+            failed = false;
+        },
+        onEvent() {
+            endedAtTerminal = false;
+        },
+        onRunStartedEvent({ event }) {
+            endedAtTerminal = false;
+            publishWhen(inbox.noteRunStarted(event.runId));
+        },
+        onToolCallStartEvent({ event }) {
+            publishWhen(inbox.noteToolCallStart(event.toolCallId));
+        },
+        onCustomEvent({ event }) {
+            if (event.name === APPROVAL_REQUESTED_EVENT_NAME) {
+                const payload = approvalRequestedPayloadOf(event.value);
+                if (payload !== null) {
+                    publishWhen(inbox.noteApprovalRequested(payload));
+                }
+                return;
+            }
+            if (event.name === APPROVAL_RESOLVED_EVENT_NAME) {
+                const receipt = approvalResolvedPayloadOf(event.value);
+                if (receipt !== null) {
+                    publishWhen(inbox.noteApprovalResolved(receipt.interruptId, receipt.approved));
+                }
+            }
+        },
+        onToolCallResultEvent({ event }) {
+            publishWhen(inbox.noteToolCallResult(event.toolCallId));
+        },
+        onRunFinishedEvent() {
+            endedAtTerminal = true;
+            publishWhen(inbox.noteRunFinished());
+        },
+        onRunErrorEvent() {
+            endedAtTerminal = true;
+            publishWhen(inbox.noteRunError());
+        },
+        onRunFailed() {
+            failed = true;
+        },
+        onRunFinalized() {
+            if (!endedAtTerminal && !failed) {
+                publishWhen(inbox.noteStreamClosedWithoutTerminal());
+                onStreamClosedWithoutTerminal();
+            }
+        },
+    };
+}

package/dist/core/approval-request-narrowing.d.ts

@@ -0,0 +1,15 @@
+import type { ApprovalRequestedPayload } from "../contract/events.js";
+export interface CoworkerApprovalRequest {
+    ordinal: number;
+    label: string;
+    childSessionId: string;
+    parked: boolean;
+    card: ApprovalRequestedPayload;
+}
+export interface CoworkerApprovalTurn {
+    id?: string;
+    run_id: string | null;
+    pending_coworker_approvals?: readonly unknown[] | null;
+}
+export declare function coworkerApprovalRequestOf(value: unknown): CoworkerApprovalRequest | null;
+export declare function approvalRequestedPayloadOf(value: unknown): ApprovalRequestedPayload | null;