@teaflask/assistant 0.0.0 → 0.3.0

package/dist/core/approval-decision.js

@@ -0,0 +1,259 @@
+// Answering approvals: the one POST per decision, under the
+// self-narration law (attempted, sent, and every drop with its
+// reason), with the durable-turn-first target resolution the execution
+// driver also follows. turnIdAnsweredBy is exported for the elicitation
+// submit, its documented twin.
+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;
+    // Only a card that advertised the affordance may speak trust — the
+    // door degrades a stray token to a plain approval anyway; this keeps
+    // the wire honest from here.
+    const trusting = decision.trust === true && !card.gated && card.trustAvailable;
+    const telemetry = _approvalTelemetryOf(store, card, decision, trusting, active);
+    telemetry("approval_submit_attempted");
+    // No epoch gate here on purpose: the POST needs only session + thread
+    // + inbox, and a parked turn legitimately holds no socket.
+    if (active === null) {
+        // Should be impossible while a card renders (cards come from the
+        // active thread's inbox) — say so loudly instead of swallowing it.
+        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;
+    }
+    // Confine every shared-cell write to this submit's own inbox: a
+    // thread switch during the POST replaces the active conversation, and
+    // publishing the resolved OLD inbox's cards would stamp a foreign
+    // approval onto the now-active thread until its stream next publishes.
+    // Deliberately the INBOX's identity, not the epoch's or _active's: a
+    // reconnect (or any refresh) on the same thread keeps this inbox, and
+    // the submit's progress must keep rendering straight through it.
+    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)) {
+            // Timed out, or answered in another tab: the whole pause is over.
+            // Re-read the thread for its settled truth (busy flag, and the
+            // timeout sentence rides the failure banner). A coworker's 409
+            // speaks for its card alone — the turn's own pause,
+            // if any, is untouched.
+            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 }),
+            },
+        });
+    };
+}
+// beginSubmit refused: the rendered card lagged the live one, or the
+// first submit is already in flight — narrate the drop and, when the live
+// truth moved, re-read it so reconciliation visibly settles what the user
+// is seeing.
+function _explainBeginSubmitRefusal(store, inbox, card, telemetry) {
+    const liveKind = inbox.statusOf(card.interruptId);
+    if (liveKind === "submitting") {
+        // A benign double-click: the first submit is in flight and the
+        // live card already renders its spinner.
+        telemetry("approval_submit_dropped", "already_submitting");
+        return;
+    }
+    // The rendered card lagged the live one — re-read the durable
+    // truth so reconciliation visibly settles what the user is seeing.
+    telemetry("approval_submit_dropped", liveKind === "answered"
+        ? "not_actionable_answered"
+        : liveKind === "stale"
+            ? "not_actionable_stale"
+            : "card_missing");
+    if (liveKind !== null) {
+        void store.refreshConversation();
+    }
+}
+// The POST itself and its delivery arms — target resolution, the one
+// answer per POST, and what each delivery verdict means for the pause.
+async function _postApprovalDecision(store, active, inbox, card, decision, trusting, telemetry) {
+    // A coworker's card has exactly one door — its dispatching turn,
+    // whatever that turn's status (the execution driver's rule).
+    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");
+    // One answer per POST — sibling cards stay individually actionable,
+    // and the workflow resumes once every pending ask is answered.
+    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 }),
+            },
+        ],
+    });
+    // Delivery is asynchronous (the response's turn still says
+    // awaiting_input); on a live pause the stream's own resume closes
+    // the card. An answer that restarted a parked turn's workflow has
+    // no live stream to do that — reconnecting is what picks up the
+    // restarted run (and its approval_resolved receipt keeps the
+    // replayed card answered).
+    inbox.settleSubmitAnswered(card.interruptId, decision.approved, trusting);
+    if (
+    // Confined like every post-await read: the reclaim probes exist
+    // to un-freeze the conversation being VIEWED, and after a
+    // mid-POST thread switch there is nothing here to un-freeze —
+    // reopening the thread reconnects on adoption, while the probes
+    // would bounce the other thread's epoch for nothing.
+    store._active?.approvalInbox === inbox) {
+        if (resolution.delivery === "workflow_restarted") {
+            store.handleWorkflowRestarted();
+        }
+        else if (resolution.delivery === "already_consumed") {
+            // The receipt: the answer is already past the door —
+            // the turn's own once a resume consumed it and then died parked, or
+            // a coworker's once its row left paused with the decision
+            // recorded, or paused again at a newer round — nothing
+            // was restarted, so no reconnect will ever arrive to move the
+            // conversation past this pause.
+            // Re-read the turn for its
+            // current truth (the contract's instruction): the refreshed
+            // projection subtracts consumed ids, so the pause
+            // retires instead of rendering a wait nothing will resume.
+            void store.refreshConversation();
+        }
+    }
+}
+// The turn to answer, resolved durable-turn-first (the execution
+// driver's stance): the newest turn that still awaits this interrupt
+// names the POST's target — which stays correct after a park-restart,
+// when the card's stamped run id names a run the ledger never saw. One
+// refresh covers a stale read; a queued message can sit
+// NEWER than the pause, so the refreshed check also consults the
+// newest ANSWERABLE turn, not just the newest row. The CAPTURED
+// conversation's ledger remains as the fallback (absent
+// pending_interrupt_ids must never read as empty, and the door's own
+// 409 backstops a wrong guess).
+//
+// Confinement (the publishIfCurrent law): the first _newestTurn read
+// runs before any await in the submit, so it still belongs to the
+// captured conversation; every read AFTER the refresh trusts the
+// store-global turn only while the submit's inbox is still the active
+// one — a thread switch mid-refresh would otherwise resolve thread B's
+// turn id and POST it to thread A's approval URL. The captured ledger
+// is switch-proof by construction.
+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;
+}
+// The elicitation submit's twin of _turnIdAwaitingInterrupt: the
+// ledger names the pausing run when it can; a lost capture (or
+// another tab's send) refreshes and then consults the ANSWERABLE turn
+// — a queued message can sit newer than the pause, so
+// the ledger's newest record may be a QUEUED turn whose POST would
+// 409. Same confinement as the sibling: store-global turns are
+// trusted only while this submit's inbox is still the active one.
+// ledger.newestTurn() stays the last resort, 409-backstopped.
+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;
+}
+// The sibling of the execution driver's durable-turn guard: a
+// turn is answerable iff it still pauses (awaiting_input or parked — a
+// late answer restarts a parked turn) and still holds the interrupt. Two
+// tolerances mirror the driver's: a null run_id is a lost capture, where
+// the server hides the cards (the set reads empty though the pause is
+// real), so the status gate alone holds; and a server predating
+// pending_interrupt_ids sends no array at all, which degrades to the
+// status gate too — an actual empty list under a captured run means the
+// pause moved on, so absent must never read as empty. A wrong yes is
+// backstopped by the door's own 409.
+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");
+}
+//# sourceMappingURL=approval-decision.js.map

package/dist/core/approval-decision.js.map

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

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

@@ -0,0 +1,255 @@
+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";
+};
+/** Who asked: the assistant's own card rides the stream's
+ *  marker and the turn's own pending_approvals; a coworker's rides its
+ *  DISPATCHING turn's REST snapshot (pending_coworker_approvals), is
+ *  answered at that turn's door whatever the turn's status, and lives
+ *  exactly as long as the snapshot lists it. label is the dispatch's
+ *  brief excerpt — the card names the coworker with it. */
+export type ApprovalAsker = {
+    kind: "assistant";
+} | {
+    kind: "coworker";
+    ordinal: number;
+    label: string;
+};
+export interface ApprovalCardModel {
+    /** The contract's opaque interrupt id — the card key and the submit id. */
+    interruptId: string;
+    toolName: string | null;
+    /** The paused call's arguments, wire-faithful minus the reserved
+     *  `caption` key (the row's label, stripped at narrowing). Populated
+     *  but unread: the banner renders nothing argument-derived; the
+     *  transcript row carries the request. Kept like the schema pair
+     *  below: dropping a recorded consent fact from the model would be a
+     *  wire-shape decision, not a presentation one. */
+    toolArgs: Record<string, unknown>;
+    /** The paused tool's registered input schema. The generic card stays
+     *  schema-agnostic; this is the schema channel's card-side producer:
+     *  consumed by approvalCardSchemasOf (tool-schema-anchors)
+     *  through the store's card funnel, so a paused or denied call's view
+     *  still gets its argsSchema. */
+    toolInputSchema: Record<string, unknown> | null;
+    /** The paused tool's registered output schema, null when the tool
+     *  declares none; consumed the same way for the view
+     *  contract's resultSchema. */
+    toolOutputSchema: Record<string, unknown> | null;
+    prompt: string;
+    toolCallId: string | null;
+    /** True when the card's tool_call_id matched a streamed TOOL_CALL_START.
+     *  Stamped only under the `anchoring` capability; false otherwise. */
+    anchored: boolean;
+    round: number;
+    /** The server run that paused, stamped from the enclosing RUN_STARTED. */
+    runId: string;
+    /**
+     * True once the stream ended without a terminal: the turn parked and the
+     * assistant is no longer actively waiting, though the ask stays live.
+     */
+    parked: boolean;
+    /** The locked action-approval gate raised this ask (the catalog's ask
+     *  policy): strictly per-call, no session trust can waive it. Stamped
+     *  only under the `gate` capability; false otherwise. */
+    gated: boolean;
+    /** The card may offer approve-and-stop-asking (scoped to the asker's
+     *  session) — org hitl with trust enabled, never the gate. Absent on an
+     *  older wire → false, so
+     *  the affordance fails safe to hidden. Stamped only under the `trust`
+     *  capability; false otherwise — a door whose decision carries no
+     *  trust flag never grows the affordance. */
+    trustAvailable: boolean;
+    status: ApprovalCardStatus;
+    asker: ApprovalAsker;
+    /** The dispatching turn a coworker's decision is posted to; null for
+     *  the assistant's own cards, which the submit resolves by turn. */
+    turnId: string | null;
+}
+/**
+ * A decision as the surface submits it. `trust` (approve AND stop asking
+ * about this tool for the rest of the asker's session: the thread for the
+ * assistant, that coworker's dispatch for a coworker) is only meaningful on
+ * a card whose wire advertised trust_available under the `trust`
+ * capability; ignored everywhere else.
+ */
+export interface ApprovalDecisionInput {
+    approved: boolean;
+    trust?: boolean;
+    feedback?: string;
+}
+/**
+ * The optional capabilities a host wires. Every one defaults
+ * OFF: a host wiring none gets a working inbox with fewer powers — the
+ * stream opens, answers and closes cards exactly the same — never a
+ * demand for data its door cannot supply. The serving-door store turns
+ * all three on (SERVING_APPROVAL_CAPABILITIES); the dashboard's
+ * playground, whose internal door carries no trust flag and renders the
+ * cards in one flat block, wires none.
+ */
+export interface ApprovalInboxCapabilities {
+    /** Stamp `anchored` from streamed TOOL_CALL_STARTs — the suspension
+     *  queue's ordering and the row projection's settle join. Off:
+     *  noteToolCallStart records nothing and every card reads false. */
+    anchoring?: boolean;
+    /** Carry the wire's `gated` flag onto cards (the banner's "asks every
+     *  time" note). Off: every card reads false. */
+    gate?: boolean;
+    /** Carry the wire's `trust_available` flag onto cards (the banner's
+     *  approve-and-stop-asking control). Off: every card reads false, so
+     *  the affordance never renders. */
+    trust?: boolean;
+}
+/** Every capability on — the serving door's shape. */
+export declare const SERVING_APPROVAL_CAPABILITIES: Required<ApprovalInboxCapabilities>;
+/**
+ * The durable turn record as the inbox reads it — the seam a host's REST
+ * read satisfies. Every pause field is OPTIONAL on purpose: the
+ * serving turn carries all three, the dashboard's internal turn carries
+ * them optional-by-default, and an older or partial door may
+ * carry none. Absent is never read as empty — it means "no judgement",
+ * so the inbox degrades to stream evidence alone rather than demanding a
+ * record the host cannot supply.
+ */
+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;
+    /** A 409 for a coworker's decision speaks for that card alone. */
+    markCoworkerCardStale(interruptId: string): boolean;
+    /** The member's send voids every paused coworker of the thread. */
+    markCoworkerCardsStale(): boolean;
+    /**
+     * The REST recovery path: build cards from the turn record's
+     * pending_approvals snapshot — the same persisted markers the stream
+     * replays — so a failed stream fetch never strands a pending pause. Upsert
+     * only: a held card keeps its status and coordinates, nothing is removed
+     * (reconcile judges membership), the parked flag stays reconcile's job.
+     * Rounds below the run's newest are history, and a closed id never
+     * returns: a REST response that raced the stream's closing evidence would
+     * otherwise put live Approve/Deny on an ask that already executed.
+     * Independent of currentRunId: there may have been no stream at all.
+     */
+    hydratePendingApprovals(turn: ApprovalTurnRecord | null): boolean;
+    /**
+     * The coworker approvals the turn snapshot lists, adopted: a
+     * card not held opens actionable, addressed to its dispatching turn; a
+     * held card re-reads its coworker's parked flag; a coworker card no turn
+     * lists anymore is gone (its row left paused). Bypasses the marker path's
+     * round arbitration — a coworker's round is its own — and remembers
+     * nothing it removes: "not in this window" is not monotonic evidence, so
+     * a later read may re-adopt (a re-POST after a real delist is the door's
+     * already_consumed receipt).
+     */
+    adoptCoworkerApprovals(turns: readonly CoworkerApprovalTurn[]): boolean;
+    /**
+     * Re-judge the cards against the turn record — the lifetime authority,
+     * called on every REST read of the thread. Terminal turns
+     * close everything (except an in-flight submit, which settles itself);
+     * live turns stamp the parked flag from status; and where the contract
+     * makes pending_interrupt_ids meaningful (awaiting_input or parked,
+     * with a run captured), an actionable card the turn no longer holds
+     * goes visibly stale — never a silent vanish. Under queued/working the
+     * set is contractually empty, so membership is deliberately NOT judged
+     * there: a stale read racing a live marker must not kill a fresh card
+     * (stale has no return transition); the stream's own evidence closes
+     * those. Same tolerance for a card whose round is newer than the
+     * record's awaiting_round: the read predates the card.
+     */
+    reconcileWithTurn(turn: ApprovalTurnRecord | null): boolean;
+    /**
+     * The settled turns' word: the assistant's cards whose run
+     * belongs to a turn with a terminal status are gone, whatever row is
+     * newest — the close a synthesized terminal cannot fake. The removal
+     * reads the ACCUMULATED runs, so a stale read still showing the pause
+     * rebuilds nothing. THE PREMISE: a turn's run_id is captured once and a
+     * terminal status is final, so a settled run never carries a live card
+     * again. Submitting cards settle themselves; coworker cards are exempt.
+     */
+    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.";
+/** The turn holding the answerable pause, if any: the newest row when it
+ *  pauses itself, else the newest answerable row behind it (a queued
+ *  message can sit newer than the pause, and reading the queued row would
+ *  silently miss the pause exactly when the member must answer to unblock
+ *  the queue). Generic so each caller gets its own turn type back. */
+export declare function answerablePauseOf<T extends {
+    status: TurnStatus;
+}>(turns: readonly T[]): T | null;
+/**
+ * The durable turn record re-judges the pending approvals on every REST
+ * read: hydration first — the record's pending_approvals snapshot rebuilds
+ * any card the stream never delivered — then reconcile judges the whole
+ * set, hydrated cards included. Two different rows on purpose: the pause
+ * hydrates from the ANSWERABLE turn (a queued message can sit newer than
+ * the pause), while reconcile keeps the NEWEST row (a terminal newest turn
+ * is what removes the conversation's cards). The inbox's own guards absorb
+ * what the read cannot know: closed ids never hydrate back, a round below
+ * the run's newest is history, absent pause fields change nothing. The
+ * settled-runs arm runs last over the whole window: a card
+ * whose run belongs to any turn that settled is gone even while a newer
+ * turn is live. Returns whether the visible cards changed.
+ */
+export declare function reconcileApprovalsWithTurns(inbox: ApprovalInbox, turns: readonly ApprovalTurnRecord[]): boolean;
+/**
+ * The subscriber that feeds the stream into the inbox: markers open cards,
+ * receipts answer them, and the resume's own evidence or the settled turn's
+ * word closes them — a RUN_FINISHED alone closes nothing. Only the
+ * server-named run id from RUN_STARTED is trusted — the connect-run's
+ * input.runId is the client's own and never names a recorded run.
+ *
+ * It also watches for the parked contract's quiet close, with the same
+ * last-event-was-a-terminal flags as resumeSnapshotRecorder: lifecycle
+ * events route to their dedicated handlers, everything else through
+ * onEvent, and an errored or aborted pipeline routes through onRunFailed
+ * before finalize — so a finalize where nothing failed and the last
+ * applied event was not a terminal is a stream that simply ended. The
+ * flags reset per run: one agent can be connected more than once.
+ */
+export declare function approvalInboxRecorder(inbox: ApprovalInbox, onCardsChanged: (cards: readonly ApprovalCardModel[]) => void, onStreamClosedWithoutTerminal: () => void): AgentSubscriber;
+//# sourceMappingURL=approval-inbox.d.ts.map

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

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