@teaflask/assistant 0.3.0 → 0.6.0

package/dist/core/elicitation-cards.js

@@ -1,28 +1,6 @@
-// The elicitation cards: a pure
-// derivation from the execution inbox's entries to the member-facing models.
-// Member-answerable entries live in the SAME inbox as every execution
-// request, but their executor is the member, so they surface as cards
-// answered through the store's submit actions. React-free: no clocks, no
-// locale. One shape: a bounded set of questions answered as
-// text in one submission, or dismissed whole; its shared fields and the one
-// pending-decision predicate are what the queue, the row pill, the
-// decision-live fact and the pending-decision gap consume.
-//
-// THE PREMISE: MEMBER_ANSWERABLE_KINDS holds exactly
-// ASK_QUESTIONS_REQUEST_KIND, so "not the question-set kind" and "not
-// member-answerable" are one test, and the model carries NO discriminant (a
-// one-member union needs none). A second member-answerable kind would be
-// skipped by the driver and mint no card here — an invisible wait;
-// elicitation-cards.test.ts pins the set, so adding a kind goes red until
-// its card arm exists, where a discriminant returns with its second reader.
 import { ASK_QUESTIONS_REQUEST_KIND } from "./execution-handlers.js";
 import { askQuestionsActionOf, } from "./elicitation-pickers.js";
 const NO_QUESTION_ANSWERS = new Map();
-// One narrowing per wire object: the action rides one entry for its
-// whole life, so caching by it keeps `questions` reference-stable across
-// publishes — which is what lets sameElicitationCards compare it by
-// reference and the publish gate stay quiet through every unrelated
-// execution-lifecycle event.
 const NARROWED_SETS = new WeakMap();
 function narrowedQuestionSetOf(action) {
     if (action === null) {
@@ -36,10 +14,6 @@ function narrowedQuestionSetOf(action) {
     NARROWED_SETS.set(action, narrowed);
     return narrowed;
 }
-/** The member-answerable entries as cards, entry order preserved. An entry
- *  whose action does not carry its kind's shape is skipped — "ignore what
- *  you don't recognize"; the pending-decision gap then names the pause. An
- *  entry of a kind that is not member-answerable is the driver's to serve. */
 export function elicitationCardsOf(entries, errorSentences, questionAnswers = NO_QUESTION_ANSWERS) {
     const cards = [];
     for (const entry of entries) {
@@ -64,11 +38,6 @@ export function elicitationCardsOf(entries, errorSentences, questionAnswers = NO
     }
     return cards;
 }
-/** Whether two derivations describe the same cards — the publish gate's
- *  structural half. The cell compares snapshots by reference and
- *  elicitationCardsOf builds a fresh array per call, while the entries feed
- *  publishes for EVERY execution kind's lifecycle. questions and answered
- *  compare by reference: one wire object per entry, one answered per settle. */
 export function sameElicitationCards(a, b) {
     if (a.length !== b.length) {
         return false;
@@ -91,8 +60,6 @@ function _statusOf(entry) {
         case "pending":
             return "actionable";
         case "executing":
-            // The inbox's claim doubles as the submit lock: the member's
-            // answer is in flight.
             return "submitting";
         case "reported":
             return "answered";
@@ -100,4 +67,3 @@ function _statusOf(entry) {
             return "stale";
     }
 }
-//# sourceMappingURL=elicitation-cards.js.map

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

@@ -8,15 +8,6 @@ export interface QuestionModel {
     prompt: string;
     options: readonly QuestionOptionModel[];
 }
-/**
- * Narrow a builtin.ask_questions request's action payload —
- * the wire is distrusted. Own-key checks, never `in`. Strict about the
- * whole set: one malformed question returns null for the set, because
- * a panel that silently dropped a question would post an incomplete
- * answer set the door refuses; the pending-decision gap then speaks for
- * the unrenderable pause instead.
- */
 export declare function askQuestionsActionOf(action: Record<string, unknown> | null): {
     questions: QuestionModel[];
 } | null;
-//# sourceMappingURL=elicitation-pickers.d.ts.map

package/dist/core/elicitation-pickers.js

@@ -1,21 +1,3 @@
-// The ask's wire narrowing: from a builtin.ask_questions
-// request's distrusted action payload to the question set the panel
-// renders, or null. Like the other transcript narrowers, this module is
-// React-free and deterministic (no clocks, no locale, question and
-// option order preserved), own-key reads over the distrusted wire — the
-// action arrives verbatim on the execution request and is narrowed here
-// even though the server's questions/v1 door already refused malformed
-// shapes, because the client never assumes server-side validation holds
-// across versions. Public via ./transcript: the dashboard imports this
-// module rather than keeping a fork.
-/**
- * Narrow a builtin.ask_questions request's action payload —
- * the wire is distrusted. Own-key checks, never `in`. Strict about the
- * whole set: one malformed question returns null for the set, because
- * a panel that silently dropped a question would post an incomplete
- * answer set the door refuses; the pending-decision gap then speaks for
- * the unrenderable pause instead.
- */
 export function askQuestionsActionOf(action) {
     if (action === null) {
         return null;
@@ -48,9 +30,6 @@ export function askQuestionsActionOf(action) {
             return null;
         }
         const options = [];
-        // Suggestion texts are the rows' React keys and the answer itself:
-        // distinct within a question by the server's law, re-checked here
-        // because the wire is distrusted (case-insensitively, as the server).
         const seenTexts = new Set();
         for (const option of rawOptions) {
             if (!_isRecord(option)) {
@@ -68,11 +47,6 @@ export function askQuestionsActionOf(action) {
             const description = _hasOwn(option, "description")
                 ? option.description
                 : null;
-            // Every model-authored display string of the set takes the same
-            // escaped-quote normalization: heading, prompt, suggestion text
-            // AND description — the suggestion's text is also the answer that
-            // posts back, so it must read clean in the panel, in the receipt
-            // and to the model alike.
             options.push({
                 text: text.replace(/\\"/g, '"'),
                 description: typeof description === "string" && description.trim() !== ""
@@ -90,12 +64,8 @@ export function askQuestionsActionOf(action) {
     return { questions };
 }
 function _hasOwn(record, key) {
-    // An own-key read spelled to compile under lib es6 — the constraint
-    // the deleted dashboard fork imposed; the spelling stays
-    // because changing it buys nothing.
     return Object.prototype.hasOwnProperty.call(record, key);
 }
 function _isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=elicitation-pickers.js.map

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

@@ -7,13 +7,6 @@ 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;
-/** The turn holding the answerable pause, if any: the newest row when
- *  it pauses itself, else the newest ANSWERABLE row off the last full
- *  refresh (see _awaitingTurn's caveat: partial
- *  adopters don't maintain it, so between a send and the next full
- *  refresh this can lag one snapshot; every consumer is re-run at
- *  adoption, and the inbox's own guards absorb a stale read). */
 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;
-//# sourceMappingURL=epoch-sync.d.ts.map

package/dist/core/epoch-sync.js

@@ -1,10 +1,3 @@
-// The connection epoch: one epoch per (thread, stream id, reconnect
-// nonce, background-attach nonce, resume store) — minting it, retiring
-// it, and the durable-turn machinery that rides its publishes (the
-// newest-turn note, approval-card reconcile and hydration, execution
-// entries, the activity feed). The epoch-confined callbacks keep
-// dropping a retired epoch's late writes exactly as the comments below
-// rule.
 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";
@@ -15,25 +8,13 @@ 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";
-// One epoch per (thread, stream id, reconnect nonce, background-attach
-// nonce, resume store): the first three are exactly the old remount
-// key, so a send, a retry, a thread switch, or a restart reclaim
-// begins a fresh epoch — a fresh agent seeded from the resume store, a
-// fresh execution inbox (the approval inbox is thread-lived and rides
-// through), a fresh driver. The background-attach nonce
-// begins a fresh epoch WITHOUT moving the remount key — see
-// the no-remount premise at syncConnection's remint branch.
 export function syncEpoch(store) {
     const active = store._active;
     if (active === null || store._disposed) {
         retireEpoch(store);
-        // No conversation, no cards — guarded so an idle publish loop
-        // never re-sets the cell (it notifies on reference change).
         if (store._approvalsCell.get().length > 0) {
             publishApprovalCards(store, []);
         }
-        // The coworker rows' work line dies with the conversation too
-        // — same guard, same reason.
         if (store._coworkerWorkCell.get().size > 0) {
             store._coworkerWorkCell.set(new Map());
         }
@@ -52,26 +33,10 @@ export function syncEpoch(store) {
     store._epochSignature = signature;
     store._epochResume = active.resume;
     store._epochConnectedOnce = false;
-    // The pending approval asks are thread-lived: seed the cell
-    // from the carried inbox synchronously — the reconnect's replay
-    // re-delivers into it idempotently — exactly like the message list
-    // seeds from the resume snapshot below, so a remount paints the cards
-    // instantly instead of flashing them away mid-decision.
     publishApprovalCards(store, active.approvalInbox.cards());
     store._elicitationErrors.clear();
     store._questionAnswers.clear();
-    // questionDrafts is deliberately NOT cleared here: an epoch
-    // reset is a transport event — a reconnect, a workflow restart — and
-    // the member's half-typed answers must survive it. Draft lifetime is
-    // ruled in question-drafts.ts: cleared on present-and-settled
-    // evidence (publishExecutionEntries) or a thread switch.
     publishExecutionEntries(store, []);
-    // The coworker requests are conversation-lived: the fresh
-    // inbox is seeded from the ACTIVE conversation's turns window, the way
-    // the approval cards seed from its carried inbox above — a stream reset
-    // must not drop an ask nothing on the stream re-delivers, and nothing
-    // outliving the conversation may seed an epoch (the send empties the
-    // window, a switch or abandon drops it; tests/epoch-seed-census).
     store._epoch.withExecutionInbox((inbox) => inbox.adoptCoworkerRequests(active.coworkerRequestTurns));
     store._messagesCell.set([...store._epoch.agent.messages]);
     store._markerAnchorsCell.set(markerAnchorsOf(active.resume));
@@ -82,10 +47,6 @@ export function syncEpoch(store) {
         streamThreadId: active.thread.stream_thread_id,
     });
 }
-// The epoch's ~25-key deps object: every store callback the epoch may
-// ring, each publish confined to its own epoch id so a retired epoch's
-// late writes drop (the in-flight execution pass runs to completion
-// after dispose — at-most-once delivery).
 function _mintEpochDeps(store, active, epochId) {
     return {
         epochId,
@@ -96,12 +57,6 @@ function _mintEpochDeps(store, active, epochId) {
         resume: active.resume,
         approvalInbox: active.approvalInbox,
         handlersOf: () => _executionHandlers(store, active.thread.id),
-        // Every epoch publish is confined to its own epoch. Recorders
-        // unsubscribe on retireEpoch, but the execution driver's in-flight
-        // pass runs to completion AFTER dispose (at-most-once delivery), so
-        // an epoch swap mid-pass would otherwise let a retired epoch stamp
-        // the previous thread's entries onto the now-active thread's shared
-        // cells. The id check drops those late writes.
         publishApprovalCards: (cards) => {
             if (store._epoch?.epochId === epochId) {
                 publishApprovalCards(store, cards);
@@ -115,10 +70,6 @@ function _mintEpochDeps(store, active, epochId) {
         publishMarkerAnchors: () => {
             if (store._epoch?.epochId === epochId) {
                 store._markerAnchorsCell.set(markerAnchorsOf(active.resume));
-                // A freshly anchored turn_failed receipt changes what the
-                // failure banner should say (bannerFailureSentenceOf yields to
-                // the in-transcript record), and the banner rides the
-                // conversation snapshot, not the anchors cell.
                 publishStore(store);
             }
         },
@@ -152,18 +103,9 @@ export function retireEpoch(store) {
 }
 export function noteNewestTurn(store, turn, switchedThread = false) {
     if (turn?.id !== store._newestTurn?.id) {
-        // A different turn is a different story: the automatic-reconnect
-        // budget guards one stuck turn, not the conversation.
         store._automaticReconnects = 0;
     }
     if (switchedThread) {
-        // A new thread's activity must not inherit the old thread's last
-        // result: settledResultOf only WRITES on a terminal turn, so
-        // switching to a still-running thread would otherwise leave the
-        // feed pointing at the previous conversation's outcome. Clear
-        // first; the line below re-sets it iff the new newest already
-        // settled. The answerable-pause snapshot is the old thread's too
-        // (the full-detail adopters re-derive it right after this call).
         store._lastResult = null;
         store._awaitingTurn = null;
     }
@@ -174,18 +116,9 @@ export function noteNewestTurn(store, turn, switchedThread = false) {
     }
 }
 export function publishApprovalCards(store, cards) {
-    // The cards' schemas feed the schema anchors first: every
-    // card path — the stream marker, the REST pending_approvals rebuild,
-    // the submit republish — funnels through here, so an anchored call's
-    // argsSchema is resolvable by the time the paint the cards trigger
-    // reads the anchors. The card model is the wire's single narrowed
-    // home for these fields; this consumes it rather than re-deriving.
     _recordApprovalCardSchemas(store, cards);
     store._approvalsCell.set(cards);
     _publishCoworkerWork(store);
-    // Pending-approval count rides the feed, and a card arriving or
-    // closing re-judges the pending-decision gap — the full
-    // publish covers both and dedupes unchanged snapshots itself.
     publishStore(store);
 }
 function _recordApprovalCardSchemas(store, cards) {
@@ -203,43 +136,16 @@ function _recordApprovalCardSchemas(store, cards) {
             active.resume.recordToolSchemas(card.toolCallId, schemas);
         }
     }
-    // The anchors map's first-wins merge makes the re-record of an
-    // already-anchored card a no-op — identity is the publish gate, the
-    // same pattern as the display hydration below.
     if (active.resume.toolSchemaAnchors !== before) {
         store._markerAnchorsCell.set(markerAnchorsOf(active.resume));
     }
 }
-// The durable turn record re-judges the pending cards on every REST
-// read: the parked flag, a superseded ask, a settled turn —
-// all rendered from truth instead of stream inference. Hydration runs
-// first: the record's pending_approvals snapshot rebuilds any
-// card the stream never delivered, so a pending id can never publish
-// as "needs input" with an empty approval surface — then reconcile
-// judges the whole set, hydrated cards included. The window is required:
-// the settled-runs arm is the close a finished run's cards
-// get when the stream's own evidence closed none, and a caller cannot
-// leave it out by construction.
 export function reconcileApprovals(store, turns) {
     const inbox = store._active?.approvalInbox;
     if (inbox === undefined) {
         return;
     }
-    // The pause is hydrated from the ANSWERABLE turn, not the newest
-    // row (a queued message can sit newer than the pause, and
-    // hydrating from the queued row would silently disable the REST
-    // card rebuild exactly when the member must answer to unblock the
-    // queue). reconcileWithTurn deliberately keeps the NEWEST row (a
-    // terminal newest turn removes the conversation's cards), and the
-    // settled-runs arm closes any window turn's settled run behind it —
-    // a RUN_FINISHED closes nothing, so a card the stream's own evidence
-    // did not close dies on this read.
     const pause = theAnswerablePause(store);
-    // Display annotations land BEFORE the cards hydrate: a
-    // recovered call's annotation must already be resolvable when its
-    // ROW first paints, never annotation-less-then-annotated. (The
-    // banner reads none of it — the row is the
-    // annotation's one rendered home.)
     _hydratePendingApprovalDisplays(store, pause);
     _hydratePendingApprovalAsks(store, pause);
     const hydrated = inbox.hydratePendingApprovals(pause);
@@ -249,12 +155,6 @@ export function reconcileApprovals(store, turns) {
         publishApprovalCards(store, inbox.cards());
     }
 }
-/** The turn holding the answerable pause, if any: the newest row when
- *  it pauses itself, else the newest ANSWERABLE row off the last full
- *  refresh (see _awaitingTurn's caveat: partial
- *  adopters don't maintain it, so between a send and the next full
- *  refresh this can lag one snapshot; every consumer is re-run at
- *  adoption, and the inbox's own guards absorb a stale read). */
 export function theAnswerablePause(store) {
     const newest = store._newestTurn;
     if (newest !== null &&
@@ -263,23 +163,6 @@ export function theAnswerablePause(store) {
     }
     return store._awaitingTurn;
 }
-/**
- * The recovery read's display annotations: the turn
- * record's pending_approval_displays carries the same
- * tool_call_annotated content the stream replays, so a REST-recovered
- * call's ROW resolves its annotation — authored copy, icon, and the
- * view contract's key — even when no stream ever delivered the call.
- * (The approval banner reads no annotations; a call that never
- * reaches the transcript at all has no reader for
- * its hydrated display until it does — kept, because the channel is
- * the row's, not the banner's.) Recorded
- * into the resume store's anchors map, the display's single client
- * home: the merge is the map's own first-wins fold, so a later stream
- * replay of the same markers is a no-op, and the same gate as
- * hydratePendingApprovals keeps a stale read from resurrecting
- * superseded copy (an absent field is an older server, never an
- * unannotated pause).
- */
 function _hydratePendingApprovalDisplays(store, turn) {
     const active = store._active;
     if (active === null ||
@@ -300,19 +183,6 @@ function _hydratePendingApprovalDisplays(store, turn) {
         store._markerAnchorsCell.set(markerAnchorsOf(active.resume));
     }
 }
-/**
- * The recovery read's half of the denial join: the paused
- * turn's pending_approvals carry the same interrupt_id → tool_call_id
- * pairs the stream's approval_requested markers do, so a client whose
- * stream never delivered the ask (a REST-recovered pause) still holds
- * it in the ledger's ask map when the resumed stream's
- * approval_resolved lands. Same gate as hydratePendingApprovals — a
- * live pause only; a settled turn's asks arrive by full replay. Asks
- * never publish: only the DENIED half is presentation, and it can only
- * move on the durable approval_resolved marker — never on the submit
- * path's own answer — so live and replay derive the row identically
- * (Law 9).
- */
 function _hydratePendingApprovalAsks(store, turn) {
     const active = store._active;
     if (active === null ||
@@ -330,27 +200,16 @@ function _hydratePendingApprovalAsks(store, turn) {
     }
 }
 export function publishExecutionEntries(store, entries) {
-    // Entries publish for EVERY execution kind's lifecycle; the cell
-    // notifies on reference change, so an unchanged derivation (usually
-    // the empty list) must never re-set it — the cell contract's
-    // "publishers set only when state actually changed".
     const cards = elicitationCardsOf(entries, store._elicitationErrors, store._questionAnswers);
     if (!sameElicitationCards(cards, store._elicitationsCell.get())) {
         store._elicitationsCell.set(cards);
     }
     _publishCoworkerWork(store);
-    // A question set's draft is released only on PRESENT-and-settled
-    // evidence — a published card for that very interrupt reading
-    // answered or stale — never on absence: the reconnect publishes an
-    // empty entry list before the replay refills it.
     for (const card of cards) {
         if (card.status === "answered" || card.status === "stale") {
             store.questionDrafts.clear(card.interruptId);
         }
     }
-    // Entries can move without the member-answerable cards moving (a
-    // driver-claimed navigate, a reported execution) and each of those
-    // re-judges the pending-decision gap.
     publishStore(store);
 }
 export function publishActivity(store) {
@@ -371,15 +230,9 @@ function _executionHandlers(store, threadId) {
     const capabilities = store.deps.hostCapabilitiesOf();
     return executionHandlersFor(capabilities.navigate, capabilities.executeActionIntent, threadId);
 }
-// The coworker rows' work line: folded from the LIVE
-// epoch's execution entries and the carried approval cards, on either
-// publish, with the set-only-on-change discipline. The entries are read
-// off the epoch's own inbox, never cached on the store: a fresh epoch's
-// first publish then folds nothing of the conversation it replaced.
 function _publishCoworkerWork(store) {
     const coworkerWork = coworkerExecutionWorkOf(store._epoch?.executionInbox.entries() ?? [], store._approvalsCell.get());
     if (!sameCoworkerExecutionWork(coworkerWork, store._coworkerWorkCell.get())) {
         store._coworkerWorkCell.set(coworkerWork);
     }
 }
-//# sourceMappingURL=epoch-sync.js.map

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

@@ -1,8 +1,3 @@
 export declare function userSentenceFor(error: unknown): string;
 export declare function stopFailureSentenceFor(error: unknown): string;
-/** A wait in the largest sensible unit — plan windows run daily to
- *  weekly, so raw minutes would read "about 10080 minutes". Each unit is
- *  ceiled, so the promise is never early. Shared with the gate card and
- *  the standing sentences (one spelling of every wait). */
-export declare function humanizedWait(seconds: number): string;
-//# sourceMappingURL=error-copy.d.ts.map
+export declare function failureSentenceOf(error: unknown): string;

package/dist/core/error-copy.js

@@ -1,88 +1,45 @@
 import { ServingApiError } from "../transport/serving-error.js";
 import { STOP_NOT_DELIVERED_SENTENCE } from "./stop-copy.js";
-// The honest error taxonomy: one user-facing sentence per contract code
-// the surface can hit. Unknown codes fall back to the server's message,
-// which the contract guarantees is a human sentence safe to show.
 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) {
-        // Retired producer (sends queue instead) — kept for older deploys.
         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 _subscriptionCannotPaySentence(error);
+            return error.message;
         case "SUBSCRIPTION_CONNECT_REQUIRED":
-            // The server sentence is the visitor copy; the connect panel (which
-            // opens on this code) owns the richer affordance.
             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 doesn't exist anymore.";
+            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;
     }
 }
-// The stop door's failure vocabulary: a failed stop must never
-// read as a failed send ("couldn't be started", "went wrong sending
-// that" — both lies about a turn that is still running). The door's own
-// sentences are written for this surface — its 503 ships "The stop
-// couldn't be delivered right now. Please try again in a moment." — so
-// every contract sentence passes through, and the generic line (the
-// stop-copy leaf's, shared with the dashboard playground) covers only
-// transport deaths that never reached the door.
 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.";
 }
-function _subscriptionCannotPaySentence(error) {
-    // The wait is rendered exactly when the server sent Retry-After — it
-    // does so only for a reset still ahead (no closeness threshold
-    // exists) — in the largest sensible unit: plan windows run daily to
-    // weekly, so raw minutes would read "about 10080 minutes". Without
-    // the header the server's own sentence stands: the plain quota copy,
-    // or the re-checking copy for a stale bounce whose re-probe the door
-    // just kicked.
-    const retryAfterSeconds = error.retryAfterSeconds;
-    if (retryAfterSeconds !== null && retryAfterSeconds > 0) {
-        return ("Your ChatGPT plan's included usage is used up for this period. " +
-            `The conversation can continue in about ${humanizedWait(retryAfterSeconds)}.`);
-    }
-    return error.message;
-}
-const _HOUR_SECONDS = 3600;
-const _DAY_SECONDS = 24 * _HOUR_SECONDS;
-/** A wait in the largest sensible unit — plan windows run daily to
- *  weekly, so raw minutes would read "about 10080 minutes". Each unit is
- *  ceiled, so the promise is never early. Shared with the gate card and
- *  the standing sentences (one spelling of every wait). */
-export function humanizedWait(seconds) {
-    // Minutes under two hours, hours under two days, days beyond.
-    if (seconds < 2 * _HOUR_SECONDS) {
-        return _counted(Math.max(1, Math.ceil(seconds / 60)), "minute");
-    }
-    if (seconds < 2 * _DAY_SECONDS) {
-        return _counted(Math.ceil(seconds / _HOUR_SECONDS), "hour");
-    }
-    return _counted(Math.ceil(seconds / _DAY_SECONDS), "day");
-}
-function _counted(count, unit) {
-    return `${String(count)} ${unit}${count === 1 ? "" : "s"}`;
-}
-//# sourceMappingURL=error-copy.js.map

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

@@ -5,57 +5,33 @@ export interface ExecutionPassContext {
     inbox: ExecutionInbox;
     threadId: string;
     handlers: ReadonlyMap<string, ExecutionHandler>;
-    /** Delivery attempts per interrupt id — exhausted entries stay pending
-     *  for the NEXT connection's pass (re-POST is the designed recovery). */
     attempts: Map<string, number>;
     fetchThreadDetail: () => Promise<AssistantThreadDetailResponse>;
     postResults: (turnId: string, request: ResolveTurnToolResultsRequest) => Promise<ResolveTurnToolResultsResponse>;
     publishEntries: (entries: readonly ExecutionEntryModel[]) => void;
     onWorkflowRestarted: () => void;
 }
-/**
- * One drain of the inbox's pending entries. Exported so the pass logic
- * unit-tests in node — the ExecutionDriver below is only a scheduler
- * around it.
- */
 export declare function runExecutionPass(context: ExecutionPassContext): Promise<void>;
 export interface ExecutionDriverDeps {
     inbox: ExecutionInbox;
     threadId: string;
-    /** Read fresh at each pass: the host's handlers map changes identity
-     *  with the provider's re-renders (navigate ref), and the driver must
-     *  never act on a stale one. */
     handlersOf: () => ReadonlyMap<string, ExecutionHandler>;
     fetchThreadDetail: () => Promise<AssistantThreadDetailResponse>;
     postResults: (turnId: string, request: ResolveTurnToolResultsRequest) => Promise<ResolveTurnToolResultsResponse>;
     publishEntries: (entries: readonly ExecutionEntryModel[]) => void;
     onWorkflowRestarted: () => void;
 }
-/**
- * Schedules a drain whenever the inbox holds actionable entries. One pass
- * runs at a time; a signal that lands mid-pass queues exactly one
- * follow-up, so evidence arriving during a pass is never missed. The
- * timer dies with `dispose()`, but an in-flight pass runs to completion —
- * that is what carries the result POST across whatever tears the driver
- * down.
- */
 export declare class ExecutionDriver {
     private readonly deps;
-    /** Per-driver on purpose: exhausted entries stay pending for the NEXT
-     *  connection's driver (re-POST is the designed recovery). */
     private readonly attempts;
     private passRunning;
     private passQueued;
     private timer;
     private disposed;
     constructor(deps: ExecutionDriverDeps);
-    /** Call with every published entries snapshot; each call resets the
-     *  pending timer, so the drain fires one quiet delay after the latest
-     *  evidence rather than racing a replay burst. */
     noteEntriesChanged(entries: readonly ExecutionEntryModel[]): void;
     dispose(): void;
     private _drainInbox;
     private _someDeliveryWasAttempted;
     private _clearTimer;
 }
-//# sourceMappingURL=execution-driver.d.ts.map