@teaflask/assistant 0.0.0 → 0.6.0

package/dist/core/question-receipt.js

@@ -0,0 +1,55 @@
+import { askQuestionsActionOf, } from "./elicitation-pickers.js";
+export function settledQuestionsReceiptOfCard(questions, answered) {
+    if (answered !== null && answered.kind === "cancelled") {
+        return null;
+    }
+    return { questions, answers: answered === null ? [] : answered.answers };
+}
+export function settledQuestionsReceiptOf(toolName, argsText, resultText) {
+    if (toolName !== "ask_user" ||
+        resultText === undefined ||
+        resultText === "") {
+        return null;
+    }
+    const args = _recordOf(argsText);
+    const set = args === null ? null : askQuestionsActionOf(args);
+    if (set === null) {
+        return null;
+    }
+    const result = _recordOf(resultText);
+    if (result === null) {
+        return null;
+    }
+    if (!Object.prototype.hasOwnProperty.call(result, "answers")) {
+        return null;
+    }
+    const raw = result.answers;
+    if (!Array.isArray(raw)) {
+        return null;
+    }
+    const answers = [];
+    for (const candidate of raw) {
+        if (typeof candidate !== "object" || candidate === null) {
+            return null;
+        }
+        const record = candidate;
+        if (typeof record.id !== "string" || typeof record.text !== "string") {
+            return null;
+        }
+        answers.push({ id: record.id, text: record.text });
+    }
+    return { questions: set.questions, answers };
+}
+function _recordOf(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return null;
+    }
+    return parsed;
+}

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

@@ -0,0 +1,2 @@
+export declare const REASONING_STREAMING_LABEL = "Thinking\u2026";
+export declare const REASONING_SETTLED_LABEL = "Thought about it";

package/dist/core/reasoning-copy.js

@@ -0,0 +1,2 @@
+export const REASONING_STREAMING_LABEL = "Thinking…";
+export const REASONING_SETTLED_LABEL = "Thought about it";

package/dist/core/receipt-anchors.d.ts

@@ -0,0 +1,9 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+export interface AnchoredReceipts {
+    before: string[];
+    after: string[];
+}
+export declare function receiptOf(value: unknown): string | null;
+export declare function withReceiptAnchored(previous: ReadonlyMap<string, AnchoredReceipts>, messageId: string, position: keyof AnchoredReceipts, receipts: string[]): ReadonlyMap<string, AnchoredReceipts>;
+export declare function wellFormedReceiptAnchorsOf(stored: ReadonlyMap<string, AnchoredReceipts>): ReadonlyMap<string, AnchoredReceipts>;
+export declare function receiptMarkerRecorder(eventName: string, onReceiptAnchored: (runId: string, messageId: string, position: keyof AnchoredReceipts, receipts: string[]) => void): AgentSubscriber;

package/dist/core/receipt-anchors.js

@@ -0,0 +1,88 @@
+import { WIRE_SENTENCE_MAX_CHARS } from "./wire-sentence-cap.js";
+export function receiptOf(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const payload = value;
+    if (typeof payload.receipt !== "string" || payload.receipt === "") {
+        return null;
+    }
+    return payload.receipt.slice(0, WIRE_SENTENCE_MAX_CHARS);
+}
+export function withReceiptAnchored(previous, messageId, position, receipts) {
+    const anchored = previous.get(messageId) ?? { before: [], after: [] };
+    const fresh = [...new Set(receipts)].filter((receipt) => !anchored[position].includes(receipt));
+    if (fresh.length === 0) {
+        return previous;
+    }
+    const next = new Map(previous);
+    next.set(messageId, {
+        ...anchored,
+        [position]: [...anchored[position], ...fresh],
+    });
+    return next;
+}
+export function wellFormedReceiptAnchorsOf(stored) {
+    const seeded = new Map();
+    const entries = stored;
+    for (const [messageId, anchored] of entries) {
+        const before = _wellFormedReceiptsAt(anchored, "before");
+        const after = _wellFormedReceiptsAt(anchored, "after");
+        if (before.length > 0 || after.length > 0) {
+            seeded.set(messageId, { before, after });
+        }
+    }
+    return seeded;
+}
+export function receiptMarkerRecorder(eventName, onReceiptAnchored) {
+    let pendingReceipts = [];
+    let currentRunId = null;
+    let newestMessageId = null;
+    const flush = () => {
+        if (pendingReceipts.length === 0 ||
+            newestMessageId === null ||
+            currentRunId === null) {
+            return;
+        }
+        onReceiptAnchored(currentRunId, newestMessageId, "after", pendingReceipts);
+        pendingReceipts = [];
+    };
+    return {
+        onRunInitialized() {
+            pendingReceipts = [];
+            currentRunId = null;
+            newestMessageId = null;
+        },
+        onRunStartedEvent({ event }) {
+            currentRunId = event.runId;
+        },
+        onCustomEvent({ event }) {
+            if (event.name !== eventName) {
+                return;
+            }
+            const receipt = receiptOf(event.value);
+            if (receipt !== null) {
+                pendingReceipts.push(receipt);
+            }
+        },
+        onMessagesChanged({ messages }) {
+            newestMessageId = messages.at(-1)?.id ?? null;
+        },
+        onRunFinishedEvent() {
+            flush();
+        },
+        onRunErrorEvent() {
+            flush();
+        },
+    };
+}
+function _wellFormedReceiptsAt(anchored, position) {
+    if (typeof anchored !== "object" || anchored === null) {
+        return [];
+    }
+    const receipts = anchored[position];
+    if (!Array.isArray(receipts)) {
+        return [];
+    }
+    return receipts.filter((receipt) => typeof receipt === "string" && receipt !== "");
+}

package/dist/core/run-folds.d.ts

@@ -0,0 +1,43 @@
+import { type SegmentDuration } from "./segment-timing.js";
+import { type AssistantTextRow, type MarkerBoundaries, type ReasoningRow, type ToolCallRow, type TranscriptBlock, type TranscriptRow } from "./transcript-rows.js";
+export type RunFoldMember = ReasoningRow | ToolCallRow | AssistantTextRow;
+export type RunFoldStep = {
+    kind: "reasoning";
+    view: ReasoningRow;
+} | {
+    kind: "tool-call";
+    row: ToolCallRow;
+} | {
+    kind: "narration";
+    view: AssistantTextRow;
+};
+export interface RunFoldRow {
+    kind: "run-fold";
+    key: string;
+    members: readonly RunFoldMember[];
+    steps: readonly RunFoldStep[];
+    duration: SegmentDuration;
+}
+export type FoldedTranscriptRow = Exclude<TranscriptRow, ReasoningRow> | RunFoldRow;
+export interface RunFoldsOptions {
+    openTailTurn?: boolean;
+    tailStart?: number;
+}
+export declare function runFoldsOf(rows: readonly TranscriptRow[], options?: RunFoldsOptions): FoldedTranscriptRow[];
+type TurnBoundaryRow = TranscriptRow | FoldedTranscriptRow;
+interface CountableBlock {
+    messageId: string;
+    rows: readonly TurnBoundaryRow[];
+}
+export declare function currentTurnStartOf(rows: readonly TurnBoundaryRow[], blocks: readonly CountableBlock[] | null, turnStartIds?: ReadonlySet<string>): number;
+export declare function settledFoldHeadlineOf(duration: SegmentDuration): string;
+export declare function liveFoldHeadlineOf(steps: readonly RunFoldStep[]): string;
+export interface FoldedBlock {
+    messageId: string;
+    rows: FoldedTranscriptRow[];
+}
+export declare function foldedBlocksOf(blocks: readonly TranscriptBlock[], options?: Omit<RunFoldsOptions, "tailStart"> & {
+    markerBoundaries?: MarkerBoundaries;
+    turnStartIds?: ReadonlySet<string>;
+}): FoldedBlock[];
+export {};

package/dist/core/run-folds.js

@@ -0,0 +1,211 @@
+import { REASONING_SETTLED_LABEL, REASONING_STREAMING_LABEL, } from "./reasoning-copy.js";
+import { durationLabelOf, settledFoldDurationOf, } from "./segment-timing.js";
+import { toolRowHeadlineOf } from "./tool-call-display.js";
+import { EMPTY_MARKER_BOUNDARIES, } from "./transcript-rows.js";
+export function runFoldsOf(rows, options = {}) {
+    const folded = [];
+    const tailStart = options.tailStart !== undefined
+        ? Math.max(0, Math.min(options.tailStart, rows.length))
+        : options.openTailTurn
+            ? _tailTurnStartOf(rows)
+            : rows.length;
+    _pushEpisodeFolds(rows.slice(0, tailStart), folded);
+    _pushClusterFolds(rows.slice(tailStart), folded);
+    return folded;
+}
+function _tailTurnStartOf(rows) {
+    for (let index = rows.length - 1; index >= 0; index -= 1) {
+        const kind = rows[index].kind;
+        if (kind === "user" || kind === "subagent-delivery") {
+            return index;
+        }
+    }
+    return 0;
+}
+const NO_TURN_START_IDS = new Set();
+function _declaredTurnStartOf(blocks, turnStartIds) {
+    let declaredTurnStart = 0;
+    let flatIndex = 0;
+    for (const block of blocks) {
+        if (turnStartIds.has(block.messageId)) {
+            declaredTurnStart = flatIndex;
+        }
+        flatIndex += block.rows.length;
+    }
+    return declaredTurnStart;
+}
+export function currentTurnStartOf(rows, blocks, turnStartIds = NO_TURN_START_IDS) {
+    return Math.max(_declaredTurnStartOf(blocks ?? [], turnStartIds), _tailTurnStartOf(rows));
+}
+function _pushEpisodeFolds(rows, folded) {
+    let pending = [];
+    const flush = () => {
+        let proseEnd = -1;
+        for (let index = pending.length - 1; index >= 0; index -= 1) {
+            if (pending[index].kind === "assistant-text") {
+                proseEnd = index;
+                break;
+            }
+        }
+        let proseStart = proseEnd;
+        while (proseStart > 0 &&
+            pending[proseStart - 1].kind === "assistant-text") {
+            proseStart -= 1;
+        }
+        if (proseStart > 0) {
+            folded.push(_foldOf(pending.slice(0, proseStart)));
+        }
+        else if (proseEnd < 0 && pending.length > 0) {
+            folded.push(_foldOf(pending));
+        }
+        for (let index = Math.max(proseStart, 0); index <= proseEnd; index += 1) {
+            folded.push(pending[index]);
+        }
+        if (proseEnd >= 0 && proseEnd + 1 < pending.length) {
+            folded.push(_foldOf(pending.slice(proseEnd + 1)));
+        }
+        pending = [];
+    };
+    for (const row of rows) {
+        if (row.kind === "reasoning" ||
+            row.kind === "assistant-text" ||
+            row.kind === "tool-call") {
+            pending.push(row);
+            continue;
+        }
+        flush();
+        folded.push(row);
+    }
+    flush();
+}
+function _pushClusterFolds(rows, folded) {
+    let members = [];
+    const flush = () => {
+        if (members.length === 0) {
+            return;
+        }
+        folded.push(_foldOf(members));
+        members = [];
+    };
+    for (const row of rows) {
+        if (row.kind === "reasoning") {
+            members.push(row);
+            continue;
+        }
+        if (row.kind === "tool-call") {
+            members.push(row);
+            continue;
+        }
+        flush();
+        folded.push(row);
+    }
+    flush();
+}
+export function settledFoldHeadlineOf(duration) {
+    if (duration.kind === "unknown") {
+        return "Worked";
+    }
+    return `Worked for ${durationLabelOf(duration.durationMs)}`;
+}
+export function liveFoldHeadlineOf(steps) {
+    for (let index = steps.length - 1; index >= 0; index -= 1) {
+        const step = steps[index];
+        if (step.kind === "tool-call") {
+            return toolRowHeadlineOf({
+                toolName: step.row.toolName,
+                state: step.row.state,
+                input: step.row.argsText,
+                display: step.row.display,
+            });
+        }
+        if (step.kind === "reasoning") {
+            return step.view.streaming
+                ? REASONING_STREAMING_LABEL
+                : REASONING_SETTLED_LABEL;
+        }
+    }
+    return "Working…";
+}
+function _foldOf(members) {
+    const timings = [];
+    for (const member of members) {
+        if (member.kind !== "assistant-text" && member.timing !== undefined) {
+            timings.push(member.timing);
+        }
+    }
+    const anchor = members.find((member) => member.kind !== "assistant-text") ?? members[0];
+    return {
+        kind: "run-fold",
+        key: `activity:${anchor.key}`,
+        members,
+        steps: _stepsInTranscriptOrder(members),
+        duration: settledFoldDurationOf(timings),
+    };
+}
+export function foldedBlocksOf(blocks, options = {}) {
+    const boundaries = options.markerBoundaries ?? EMPTY_MARKER_BOUNDARIES;
+    const turnStartIds = options.turnStartIds ?? NO_TURN_START_IDS;
+    const flat = [];
+    const blockIndexByKey = new Map();
+    const cuts = new Set([0]);
+    for (const [index, block] of blocks.entries()) {
+        if (boundaries.before.has(block.messageId)) {
+            cuts.add(flat.length);
+        }
+        for (const row of block.rows) {
+            blockIndexByKey.set(row.key, index);
+            flat.push(row);
+        }
+        if (boundaries.after.has(block.messageId)) {
+            cuts.add(flat.length);
+        }
+    }
+    cuts.add(flat.length);
+    const tailStart = options.openTailTurn
+        ? currentTurnStartOf(flat, blocks, turnStartIds)
+        : flat.length;
+    const ordered = [...cuts].sort((a, b) => a - b);
+    const foldedBlocks = blocks.map((block) => ({
+        messageId: block.messageId,
+        rows: [],
+    }));
+    for (let cut = 0; cut + 1 < ordered.length; cut += 1) {
+        const [start, end] = [ordered[cut], ordered[cut + 1]];
+        const folded = runFoldsOf(flat.slice(start, end), {
+            tailStart: tailStart - start,
+        });
+        for (const row of folded) {
+            const firstKey = row.kind === "run-fold" ? row.members[0].key : row.key;
+            const blockIndex = blockIndexByKey.get(firstKey) ?? 0;
+            foldedBlocks[blockIndex].rows.push(row);
+        }
+    }
+    return foldedBlocks;
+}
+function _stepsInTranscriptOrder(members) {
+    const steps = [];
+    for (const row of members) {
+        if (row.kind === "tool-call") {
+            steps.push({ kind: "tool-call", row });
+            continue;
+        }
+        if (row.kind === "assistant-text") {
+            steps.push({ kind: "narration", view: row });
+            continue;
+        }
+        const previous = steps.at(-1);
+        if (previous?.kind === "reasoning") {
+            previous.view = {
+                ...previous.view,
+                text: `${previous.view.text}\n\n${row.text}`,
+                streaming: previous.view.streaming || row.streaming,
+            };
+            continue;
+        }
+        steps.push({
+            kind: "reasoning",
+            view: { ...row, key: `reasoning:${row.key}` },
+        });
+    }
+    return steps;
+}

package/dist/core/run-status.d.ts

@@ -0,0 +1,4 @@
+import type { TurnStatus } from "../contract/threads.js";
+export type AnnouncedStatus = "working" | "waiting";
+export declare function announcedStatusOf(status: TurnStatus | null, decisionsPending: boolean): AnnouncedStatus | null;
+export declare function runReadsAsWorking(status: TurnStatus | null, decisionsPending: boolean): boolean;

package/dist/core/run-status.js

@@ -0,0 +1,12 @@
+export function announcedStatusOf(status, decisionsPending) {
+    if (status === "queued" || status === "working") {
+        return "working";
+    }
+    if (status === "awaiting_input" || status === "parked") {
+        return decisionsPending ? "waiting" : "working";
+    }
+    return null;
+}
+export function runReadsAsWorking(status, decisionsPending) {
+    return announcedStatusOf(status, decisionsPending) === "working";
+}

package/dist/core/segment-timing.d.ts

@@ -0,0 +1,13 @@
+export interface BlockTiming {
+    startedAtMs: number | null;
+    settledAtMs: number | null;
+}
+export type SegmentDuration = {
+    kind: "unknown";
+} | {
+    kind: "measured";
+    durationMs: number;
+};
+export declare function settledFoldDurationOf(members: readonly BlockTiming[]): SegmentDuration;
+export declare function durationLabelOf(durationMs: number): string;
+export declare function activeFoldElapsedOf(members: readonly BlockTiming[], nowMs: number): SegmentDuration;

package/dist/core/segment-timing.js

@@ -0,0 +1,47 @@
+const UNKNOWN = { kind: "unknown" };
+export function settledFoldDurationOf(members) {
+    let earliest = null;
+    let latest = null;
+    for (const member of members) {
+        for (const observed of [member.startedAtMs, member.settledAtMs]) {
+            if (observed === null) {
+                continue;
+            }
+            earliest = earliest === null ? observed : Math.min(earliest, observed);
+            latest = latest === null ? observed : Math.max(latest, observed);
+        }
+    }
+    if (earliest === null || latest === null) {
+        return UNKNOWN;
+    }
+    return { kind: "measured", durationMs: Math.max(0, latest - earliest) };
+}
+export function durationLabelOf(durationMs) {
+    if (durationMs < 1_000) {
+        return "<1s";
+    }
+    const totalSeconds = Math.floor(durationMs / 1_000);
+    if (totalSeconds < 60) {
+        return `${String(totalSeconds)}s`;
+    }
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 60) {
+        return `${String(totalMinutes)}m ${String(totalSeconds % 60).padStart(2, "0")}s`;
+    }
+    const hours = Math.floor(totalMinutes / 60);
+    return `${String(hours)}h ${String(totalMinutes % 60).padStart(2, "0")}m`;
+}
+export function activeFoldElapsedOf(members, nowMs) {
+    let earliest = null;
+    for (const member of members) {
+        for (const observed of [member.startedAtMs, member.settledAtMs]) {
+            if (observed !== null) {
+                earliest = earliest === null ? observed : Math.min(earliest, observed);
+            }
+        }
+    }
+    if (earliest === null) {
+        return UNKNOWN;
+    }
+    return { kind: "measured", durationMs: Math.max(0, nowMs - earliest) };
+}

package/dist/core/settle-refresh.d.ts

@@ -0,0 +1,9 @@
+export declare const SETTLE_REFRESH_DELAY_MS = 400;
+export declare class SettleRefreshScheduler {
+    private readonly onSettle;
+    private timer;
+    constructor(onSettle: () => void);
+    noteRunSettled(): void;
+    dispose(): void;
+    private clearTimer;
+}

package/dist/core/settle-refresh.js

@@ -0,0 +1,24 @@
+export const SETTLE_REFRESH_DELAY_MS = 400;
+export class SettleRefreshScheduler {
+    onSettle;
+    timer = null;
+    constructor(onSettle) {
+        this.onSettle = onSettle;
+    }
+    noteRunSettled() {
+        this.clearTimer();
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.onSettle();
+        }, SETTLE_REFRESH_DELAY_MS);
+    }
+    dispose() {
+        this.clearTimer();
+    }
+    clearTimer() {
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}

package/dist/core/step-caption.d.ts

@@ -0,0 +1,2 @@
+export declare const STEP_CAPTION_ARG_KEY = "caption";
+export declare function withoutStepCaption(args: Record<string, unknown>): Record<string, unknown>;

package/dist/core/step-caption.js

@@ -0,0 +1,7 @@
+export const STEP_CAPTION_ARG_KEY = "caption";
+export function withoutStepCaption(args) {
+    if (!(STEP_CAPTION_ARG_KEY in args)) {
+        return args;
+    }
+    return Object.fromEntries(Object.entries(args).filter(([key]) => key !== STEP_CAPTION_ARG_KEY));
+}

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

@@ -0,0 +1 @@
+export declare const STOP_NOT_DELIVERED_SENTENCE = "The stop couldn't be delivered right now. Please try again in a moment.";

package/dist/core/stop-copy.js

@@ -0,0 +1 @@
+export const STOP_NOT_DELIVERED_SENTENCE = "The stop couldn't be delivered right now. Please try again in a moment.";

package/dist/core/stop-settle.d.ts

@@ -0,0 +1,5 @@
+export declare const STOP_SETTLE_PROBES = 10;
+export declare function probeStopSettle(deps: {
+    refresh: () => Promise<void>;
+    stillAwaitsSettle: () => boolean;
+}): Promise<boolean>;

package/dist/core/stop-settle.js

@@ -0,0 +1,15 @@
+import { SETTLE_REFRESH_DELAY_MS } from "./settle-refresh.js";
+export const STOP_SETTLE_PROBES = 10;
+export async function probeStopSettle(deps) {
+    if (!deps.stillAwaitsSettle()) {
+        return false;
+    }
+    for (let probe = 0; probe < STOP_SETTLE_PROBES; probe += 1) {
+        await new Promise((resolve) => setTimeout(resolve, SETTLE_REFRESH_DELAY_MS));
+        if (!deps.stillAwaitsSettle()) {
+            return false;
+        }
+        await deps.refresh();
+    }
+    return deps.stillAwaitsSettle();
+}

package/dist/core/stream-trouble.d.ts

@@ -0,0 +1,5 @@
+import type { AssistantConversationStore } from "./conversation-store.js";
+export declare function handleStreamErrorFromStore(store: AssistantConversationStore, error: Error): void;
+export declare function handleStreamClosedQuietlyFromStore(store: AssistantConversationStore, stillStreaming: () => boolean): void;
+export declare function retryStreamFromStore(store: AssistantConversationStore): void;
+export declare function handleWorkflowRestartedFromStore(store: AssistantConversationStore): void;

package/dist/core/stream-trouble.js

@@ -0,0 +1,83 @@
+import { streamFailureClassOf } from "../contract/telemetry.js";
+import { getAssistantThread } from "../transport/serving-api.js";
+import { adoptRefreshedDetail, refreshThreads, } from "./conversation-adoption.js";
+import { settlesFor } from "./conversation-refresh.js";
+import { publishStore } from "./conversation-publish.js";
+import { SETTLE_REFRESH_DELAY_MS } from "./settle-refresh.js";
+const RESTART_RECLAIM_PROBES = 10;
+export function handleStreamErrorFromStore(store, error) {
+    store._streamInterrupted = true;
+    publishStore(store);
+    store.deps.onTelemetry({
+        name: "assistant_stream_failed",
+        properties: {
+            failure_class: streamFailureClassOf(error, {
+                sawBodyBytes: store._epoch?.agent.sawBodyBytes ?? false,
+            }),
+            status: _httpStatusOf(error),
+            thread_id: store._active?.thread.id ?? null,
+            resume_cursor: store._active?.resume.snapshot?.afterId ?? null,
+            last_committed_sse_id: store._epoch?.agent.resumeCursor ?? null,
+        },
+    });
+    store._scheduleSettleRefresh();
+    store.deps.reportError(error);
+}
+export function handleStreamClosedQuietlyFromStore(store, stillStreaming) {
+    const active = store._active;
+    if (active === null) {
+        return;
+    }
+    getAssistantThread(store.deps.session, active.thread.id)
+        .then((detail) => {
+        adoptRefreshedDetail(store, detail);
+        if (store._active?.thread.id === detail.thread.id &&
+            _workflowStillOwnsTurn(detail.turns.at(-1)?.status) &&
+            !stillStreaming()) {
+            store._streamInterrupted = true;
+            publishStore(store);
+        }
+        void refreshThreads(store);
+    })
+        .catch(() => {
+    });
+}
+export function retryStreamFromStore(store) {
+    store._streamInterrupted = false;
+    store._automaticReconnects = 0;
+    store._reconnectNonce += 1;
+    publishStore(store);
+}
+export function handleWorkflowRestartedFromStore(store) {
+    const active = store._active;
+    if (active === null) {
+        return;
+    }
+    const threadId = active.thread.id;
+    void (async () => {
+        for (let probe = 0; probe < RESTART_RECLAIM_PROBES; probe += 1) {
+            await settlesFor(SETTLE_REFRESH_DELAY_MS);
+            if (store._disposed || store._active?.thread.id !== threadId) {
+                return;
+            }
+            try {
+                const detail = await getAssistantThread(store.deps.session, threadId);
+                if (detail.turns.at(-1)?.status !== "parked") {
+                    break;
+                }
+            }
+            catch {
+            }
+        }
+        if (!store._disposed && store._active?.thread.id === threadId) {
+            store.retryStream();
+        }
+    })();
+}
+function _workflowStillOwnsTurn(status) {
+    return (status === "queued" || status === "working" || status === "awaiting_input");
+}
+function _httpStatusOf(error) {
+    const status = error.status;
+    return typeof status === "number" ? status : null;
+}

package/dist/core/subagent-brief.d.ts

@@ -0,0 +1,3 @@
+import type { Message } from "@ag-ui/core";
+export declare function openingBriefOf(parentMessages: readonly Message[], childSessionId: string): string | null;
+export declare function withOpeningBrief(childMessages: readonly Message[], brief: string | null, childSessionId: string): readonly Message[];