@teaflask/assistant 0.0.0 → 0.6.0

package/dist/core/subagent-brief.js

@@ -0,0 +1,38 @@
+import { DISPATCH_SUBAGENT_TOOL_NAME, dispatchedTaskOf, dispatchReceiptOf, } from "./subagent-rows.js";
+export function openingBriefOf(parentMessages, childSessionId) {
+    const results = _toolResultsByCallIdOf(parentMessages);
+    for (const message of parentMessages) {
+        if (message.role !== "assistant") {
+            continue;
+        }
+        for (const call of message.toolCalls ?? []) {
+            if (_isDispatchOfChild(call, results.get(call.id), childSessionId)) {
+                const task = dispatchedTaskOf(call.function.arguments);
+                return task === null || task.trim() === "" ? null : task;
+            }
+        }
+    }
+    return null;
+}
+export function withOpeningBrief(childMessages, brief, childSessionId) {
+    if (brief === null) {
+        return childMessages;
+    }
+    return [
+        { id: `brief:${childSessionId}`, role: "user", content: brief },
+        ...childMessages,
+    ];
+}
+function _toolResultsByCallIdOf(messages) {
+    const results = new Map();
+    for (const message of messages) {
+        if (message.role === "tool" && typeof message.content === "string") {
+            results.set(message.toolCallId, message.content);
+        }
+    }
+    return results;
+}
+function _isDispatchOfChild(call, result, childSessionId) {
+    return (call.function.name === DISPATCH_SUBAGENT_TOOL_NAME &&
+        dispatchReceiptOf(result)?.childSessionId === childSessionId);
+}

package/dist/core/subagent-delivery-anchors.d.ts

@@ -0,0 +1,11 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+export interface DeliveredResult {
+    ordinal: number;
+    label: string;
+    succeeded: boolean;
+}
+export declare const EMPTY_SUBAGENT_DELIVERY_ANCHORS: ReadonlyMap<string, DeliveredResult[]>;
+export declare function deliveredResultsOf(value: unknown): DeliveredResult[] | null;
+export declare function withSubagentDeliveryAnchored(previous: ReadonlyMap<string, DeliveredResult[]>, messageId: string, results: DeliveredResult[]): ReadonlyMap<string, DeliveredResult[]>;
+export declare function wellFormedDeliveryAnchorsOf(stored: ReadonlyMap<string, DeliveredResult[]>): ReadonlyMap<string, DeliveredResult[]>;
+export declare function subagentDeliveryMarkerRecorder(onDeliveryAnchored: (deliveryRunId: string, messageId: string, results: DeliveredResult[]) => void): AgentSubscriber;

package/dist/core/subagent-delivery-anchors.js

@@ -0,0 +1,90 @@
+import { SUBAGENT_RESULTS_DELIVERED_EVENT_NAME, } from "../contract/events.js";
+const LABEL_MAX_CHARS = 200;
+export const EMPTY_SUBAGENT_DELIVERY_ANCHORS = new Map();
+export function deliveredResultsOf(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const payload = value;
+    if (!Array.isArray(payload.results)) {
+        return null;
+    }
+    const results = [];
+    for (const entry of payload.results) {
+        if (typeof entry !== "object" || entry === null) {
+            continue;
+        }
+        const result = entry;
+        if (typeof result.ordinal !== "number") {
+            continue;
+        }
+        results.push({
+            ordinal: result.ordinal,
+            label: typeof result.label === "string"
+                ? result.label.slice(0, LABEL_MAX_CHARS)
+                : "",
+            succeeded: result.succeeded !== false,
+        });
+    }
+    return results.length > 0 ? results : null;
+}
+export function withSubagentDeliveryAnchored(previous, messageId, results) {
+    if (previous.has(messageId)) {
+        return previous;
+    }
+    const next = new Map(previous);
+    next.set(messageId, results);
+    return next;
+}
+export function wellFormedDeliveryAnchorsOf(stored) {
+    const seeded = new Map();
+    const entries = stored;
+    for (const [messageId, anchored] of entries) {
+        if (!Array.isArray(anchored)) {
+            continue;
+        }
+        const results = anchored.filter((entry) => typeof entry === "object" &&
+            entry !== null &&
+            typeof entry.ordinal === "number" &&
+            typeof entry.label === "string" &&
+            typeof entry.succeeded === "boolean");
+        if (results.length > 0) {
+            seeded.set(messageId, results);
+        }
+    }
+    return seeded;
+}
+export function subagentDeliveryMarkerRecorder(onDeliveryAnchored) {
+    let pending = null;
+    let currentRunId = null;
+    return {
+        onRunInitialized() {
+            pending = null;
+            currentRunId = null;
+        },
+        onRunStartedEvent({ event }) {
+            currentRunId = event.runId;
+        },
+        onCustomEvent({ event }) {
+            if (event.name !== SUBAGENT_RESULTS_DELIVERED_EVENT_NAME) {
+                return;
+            }
+            const results = deliveredResultsOf(event.value);
+            if (results !== null && currentRunId !== null) {
+                pending = { runId: currentRunId, results };
+            }
+        },
+        onMessagesChanged({ messages }) {
+            const newestMessage = messages.at(-1);
+            if (pending === null || newestMessage === undefined) {
+                return;
+            }
+            const marker = pending;
+            pending = null;
+            onDeliveryAnchored(marker.runId, newestMessage.id, marker.results);
+        },
+        onRunFinishedEvent() {
+            pending = null;
+        },
+    };
+}

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

@@ -0,0 +1,10 @@
+import type { ToolCallViewModel } from "./tool-call-display.js";
+import type { TranscriptRow } from "./transcript-rows.js";
+export declare function coworkerIndicesOf(dispatches: Iterable<{
+    ordinal: number;
+    child_session_id: string;
+}>): ReadonlyMap<string, number>;
+export declare function newestToolCallViewOf(rows: readonly TranscriptRow[]): ToolCallViewModel | null;
+export declare function sameCurrentWorkView(a: ToolCallViewModel, b: ToolCallViewModel): boolean;
+export declare function settledSpanMsOf(startedAt: string, settledAt: string | null): number | null;
+export declare function settledWorkedLabelOf(startedAt: string, settledAt: string | null): string | null;

package/dist/core/subagent-presence.js

@@ -0,0 +1,64 @@
+import { settledFoldHeadlineOf } from "./run-folds.js";
+export function coworkerIndicesOf(dispatches) {
+    const firstOrdinalBySession = new Map();
+    for (const dispatch of dispatches) {
+        const held = firstOrdinalBySession.get(dispatch.child_session_id);
+        if (held === undefined || dispatch.ordinal < held) {
+            firstOrdinalBySession.set(dispatch.child_session_id, dispatch.ordinal);
+        }
+    }
+    const ranked = [...firstOrdinalBySession.entries()].sort((a, b) => a[1] - b[1]);
+    const indices = new Map();
+    ranked.forEach(([childSessionId], position) => {
+        indices.set(childSessionId, position + 1);
+    });
+    return indices;
+}
+export function newestToolCallViewOf(rows) {
+    for (let rowIndex = rows.length - 1; rowIndex >= 0; rowIndex -= 1) {
+        const row = rows[rowIndex];
+        if (row.kind === "tool-call") {
+            const view = _liveViewOf(row);
+            if (view !== null) {
+                return view;
+            }
+        }
+    }
+    return null;
+}
+export function sameCurrentWorkView(a, b) {
+    return (a.toolName === b.toolName &&
+        a.state === b.state &&
+        a.display?.caption === b.display?.caption &&
+        a.display?.progressText === b.display?.progressText);
+}
+function _liveViewOf(row) {
+    if (row.state !== "input-available") {
+        return null;
+    }
+    return {
+        toolName: row.toolName,
+        state: row.state,
+        input: row.argsText,
+        errorText: row.errorText,
+        display: row.display,
+    };
+}
+export function settledSpanMsOf(startedAt, settledAt) {
+    if (settledAt === null) {
+        return null;
+    }
+    const started = new Date(startedAt).getTime();
+    const ended = new Date(settledAt).getTime();
+    if (!Number.isFinite(started) || !Number.isFinite(ended)) {
+        return null;
+    }
+    return Math.max(0, ended - started);
+}
+export function settledWorkedLabelOf(startedAt, settledAt) {
+    const durationMs = settledSpanMsOf(startedAt, settledAt);
+    if (durationMs === null) {
+        return null;
+    }
+    return settledFoldHeadlineOf({ kind: "measured", durationMs });
+}

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

@@ -0,0 +1,35 @@
+export interface RosterSourceDispatch {
+    ordinal: number;
+    label: string;
+    error: string | null;
+    child_session_id: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface RosterStatusPredicates<D extends RosterSourceDispatch> {
+    isRunning: (dispatch: D) => boolean;
+    hasFailed: (dispatch: D) => boolean;
+}
+export interface SubagentRosterEntry {
+    key: string;
+    childSessionId: string;
+    ordinal: number;
+    label: string;
+    running: boolean;
+    failed: boolean;
+    note: string | null;
+    startedAt: string;
+    settledAt: string | null;
+}
+export interface SubagentRoster {
+    running: SubagentRosterEntry[];
+    completed: SubagentRosterEntry[];
+    failed: SubagentRosterEntry[];
+    total: number;
+    distinctSessions: number;
+    failedSessions: number;
+}
+export declare function rosterEntriesOf<D extends RosterSourceDispatch>(dispatches: Iterable<D>, predicates: RosterStatusPredicates<D>): SubagentRosterEntry[];
+export declare function subagentRosterOf(entries: readonly SubagentRosterEntry[]): SubagentRoster;
+export declare function subagentPillLabelOf(roster: SubagentRoster): string | null;
+export declare function settledDurationLabelOf(startedAt: string, settledAt: string | null): string | null;

package/dist/core/subagent-roster.js

@@ -0,0 +1,80 @@
+import { durationLabelOf } from "./segment-timing.js";
+import { settledSpanMsOf } from "./subagent-presence.js";
+export function rosterEntriesOf(dispatches, predicates) {
+    const entries = [];
+    for (const dispatch of dispatches) {
+        const running = predicates.isRunning(dispatch);
+        const failed = predicates.hasFailed(dispatch);
+        entries.push({
+            key: `${dispatch.child_session_id}:${String(dispatch.ordinal)}`,
+            childSessionId: dispatch.child_session_id,
+            ordinal: dispatch.ordinal,
+            label: dispatch.label === "" ? "Delegated task" : dispatch.label,
+            running,
+            failed,
+            note: failed
+                ? (dispatch.error ?? "The subagent failed before it could report back.")
+                : null,
+            startedAt: dispatch.created_at,
+            settledAt: running ? null : dispatch.updated_at,
+        });
+    }
+    entries.sort((a, b) => Date.parse(a.startedAt) - Date.parse(b.startedAt) ||
+        a.ordinal - b.ordinal);
+    return entries;
+}
+export function subagentRosterOf(entries) {
+    const newestBySession = new Map();
+    for (const entry of entries) {
+        const held = newestBySession.get(entry.childSessionId);
+        if (held === undefined || entry.ordinal > held.ordinal) {
+            newestBySession.set(entry.childSessionId, entry);
+        }
+    }
+    let failedSessions = 0;
+    for (const newest of newestBySession.values()) {
+        if (newest.failed) {
+            failedSessions += 1;
+        }
+    }
+    const roster = {
+        running: [],
+        completed: [],
+        failed: [],
+        total: entries.length,
+        distinctSessions: newestBySession.size,
+        failedSessions,
+    };
+    for (const entry of entries) {
+        if (entry.running) {
+            roster.running.push(entry);
+        }
+        else if (entry.failed) {
+            roster.failed.push(entry);
+        }
+        else {
+            roster.completed.push(entry);
+        }
+    }
+    return roster;
+}
+export function subagentPillLabelOf(roster) {
+    if (roster.total === 0) {
+        return null;
+    }
+    const failedSuffix = roster.failedSessions > 0
+        ? ` · ${String(roster.failedSessions)} failed`
+        : "";
+    if (roster.running.length > 0) {
+        return `${String(roster.running.length)} running${failedSuffix}`;
+    }
+    const noun = roster.distinctSessions === 1 ? "subagent" : "subagents";
+    return `${String(roster.distinctSessions)} ${noun}${failedSuffix}`;
+}
+export function settledDurationLabelOf(startedAt, settledAt) {
+    const durationMs = settledSpanMsOf(startedAt, settledAt);
+    if (durationMs === null) {
+        return null;
+    }
+    return durationLabelOf(durationMs);
+}

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

@@ -0,0 +1,50 @@
+export declare const DISPATCH_SUBAGENT_TOOL_NAME = "dispatch_subagent";
+export interface DispatchCall {
+    toolCallId: string;
+    settled: boolean;
+    failed: boolean;
+    cancelled: boolean;
+    result: string | undefined;
+    errorText: string | undefined;
+    argsText: string;
+}
+export interface DispatchReceipt {
+    outcome: "launched" | "attached" | "already_settled";
+    ordinal: number;
+    label: string;
+    childSessionId: string | null;
+    settled: {
+        failed: boolean;
+        note: string | null;
+    } | null;
+}
+export interface SubagentGroupEntry {
+    toolCallId: string;
+    receipt: DispatchReceipt | null;
+    label: string | null;
+    running: boolean;
+    failed: boolean;
+    cancelled: boolean;
+    note: string | null;
+}
+export interface SubagentGroupRow {
+    kind: "subagent-group";
+    key: string;
+    entries: SubagentGroupEntry[];
+}
+export interface SubagentOutcomeCounts {
+    running: number;
+    failed: number;
+    cancelled: number;
+    total: number;
+}
+export declare function subagentOutcomeCountsOf(entries: readonly {
+    running: boolean;
+    failed: boolean;
+    cancelled: boolean;
+}[]): SubagentOutcomeCounts;
+export declare function subagentGroupHeadlineOf(counts: SubagentOutcomeCounts): string;
+export declare function withSubagentGroups<Row>(rows: readonly Row[], asDispatchCall: (row: Row) => DispatchCall | null, keyOf: (row: Row) => string): (Row | SubagentGroupRow)[];
+export declare function dispatchReceiptOf(result: string | undefined): DispatchReceipt | null;
+export declare function taskExcerptOf(argsText: string): string | null;
+export declare function dispatchedTaskOf(argsText: string): string | null;

package/dist/core/subagent-rows.js

@@ -0,0 +1,187 @@
+export const DISPATCH_SUBAGENT_TOOL_NAME = "dispatch_subagent";
+const MAX_LABEL_CHARS = 200;
+export function subagentOutcomeCountsOf(entries) {
+    let running = 0;
+    let failed = 0;
+    let cancelled = 0;
+    for (const entry of entries) {
+        if (entry.running) {
+            running += 1;
+        }
+        if (entry.failed) {
+            failed += 1;
+        }
+        if (entry.cancelled) {
+            cancelled += 1;
+        }
+    }
+    return { running, failed, cancelled, total: entries.length };
+}
+export function subagentGroupHeadlineOf(counts) {
+    const nounOf = (count) => (count === 1 ? "subagent" : "subagents");
+    const suffixParts = [];
+    if (counts.failed > 0) {
+        suffixParts.push(`${String(counts.failed)} failed`);
+    }
+    if (counts.cancelled > 0) {
+        suffixParts.push(`${String(counts.cancelled)} interrupted`);
+    }
+    const suffix = suffixParts.length > 0 ? ` · ${suffixParts.join(" · ")}` : "";
+    if (counts.running > 0) {
+        if (counts.running === counts.total) {
+            return `Running ${String(counts.total)} ${nounOf(counts.total)}`;
+        }
+        return `Running ${String(counts.running)} of ${String(counts.total)} ${nounOf(counts.total)}${suffix}`;
+    }
+    if (counts.cancelled === counts.total) {
+        return `${String(counts.total)} ${nounOf(counts.total)} interrupted`;
+    }
+    const ranCount = counts.total - counts.cancelled;
+    return `Ran ${String(ranCount)} ${nounOf(ranCount)}${suffix}`;
+}
+export function withSubagentGroups(rows, asDispatchCall, keyOf) {
+    const out = [];
+    let group = null;
+    for (const row of rows) {
+        const call = asDispatchCall(row);
+        if (call === null) {
+            group = null;
+            out.push(row);
+            continue;
+        }
+        if (group === null) {
+            group = {
+                kind: "subagent-group",
+                key: `subagents:${keyOf(row)}`,
+                entries: [],
+            };
+            out.push(group);
+        }
+        group.entries.push(_entryOf(call));
+    }
+    return out;
+}
+function _entryOf(call) {
+    const receipt = dispatchReceiptOf(call.result);
+    const stillDispatched = receipt !== null
+        ? receipt.settled === null && receipt.outcome !== "already_settled"
+        : !call.settled;
+    const receiptLabel = receipt !== null && receipt.label !== "" ? receipt.label : null;
+    return {
+        toolCallId: call.toolCallId,
+        receipt,
+        label: receiptLabel ?? taskExcerptOf(call.argsText),
+        running: !call.failed && !call.cancelled && stillDispatched,
+        failed: call.failed || receipt?.settled?.failed === true,
+        cancelled: call.cancelled,
+        note: receipt?.settled?.note ?? (call.failed ? (call.errorText ?? null) : null),
+    };
+}
+export function dispatchReceiptOf(result) {
+    if (result === undefined || result === "") {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result);
+    }
+    catch {
+        return _receiptFromTruncatedPrefix(result);
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    const record = parsed;
+    const outcome = record.outcome;
+    const ordinal = record.ordinal;
+    const label = record.label;
+    if (!_isOutcome(outcome) ||
+        typeof ordinal !== "number" ||
+        typeof label !== "string") {
+        return null;
+    }
+    const childSessionId = record.child_session_id;
+    return {
+        outcome,
+        ordinal,
+        label,
+        childSessionId: typeof childSessionId === "string" ? childSessionId : null,
+        settled: _settledOf(record.settled),
+    };
+}
+export function taskExcerptOf(argsText) {
+    const task = dispatchedTaskOf(argsText);
+    if (task === null) {
+        return null;
+    }
+    const collapsed = task.split(/\s+/).filter(Boolean).join(" ");
+    return collapsed === "" ? null : collapsed.slice(0, MAX_LABEL_CHARS);
+}
+export function dispatchedTaskOf(argsText) {
+    try {
+        const parsed = JSON.parse(argsText);
+        if (parsed === null || typeof parsed !== "object") {
+            return null;
+        }
+        const value = parsed.task;
+        return typeof value === "string" ? value : null;
+    }
+    catch {
+        const match = /"task"\s*:\s*"((?:[^"\\]|\\.)*)/.exec(argsText);
+        return match === null ? null : _unescaped(match[1]);
+    }
+}
+function _isOutcome(value) {
+    return (value === "launched" || value === "attached" || value === "already_settled");
+}
+const _SETTLED_STATUS_FAILED = {
+    succeeded: false,
+    failed: true,
+};
+function _settledOf(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    const status = String(record.status);
+    const failed = Object.prototype.hasOwnProperty.call(_SETTLED_STATUS_FAILED, status)
+        ? _SETTLED_STATUS_FAILED[status]
+        : undefined;
+    if (failed === undefined) {
+        return null;
+    }
+    const note = record.note;
+    return { failed, note: typeof note === "string" ? note : null };
+}
+const _TRUNCATED_RECEIPT_PREFIX = /^\{"outcome":"(launched|attached|already_settled)","ordinal":(\d+)(?:,"label":"((?:[^"\\]|\\.)*))?/;
+function _receiptFromTruncatedPrefix(result) {
+    const match = _TRUNCATED_RECEIPT_PREFIX.exec(result);
+    if (match === null) {
+        return null;
+    }
+    const outcome = match[1];
+    if (!_isOutcome(outcome)) {
+        return null;
+    }
+    const labelBody = match[3];
+    return {
+        outcome,
+        ordinal: Number(match[2]),
+        label: labelBody === undefined ? "" : (_unescaped(labelBody) ?? ""),
+        childSessionId: null,
+        settled: null,
+    };
+}
+function _unescaped(jsonStringBody) {
+    try {
+        return JSON.parse(`"${jsonStringBody}"`);
+    }
+    catch {
+        try {
+            return JSON.parse(`"${jsonStringBody.replace(/\\$/, "")}"`);
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/core/surface-registry.d.ts

@@ -0,0 +1,16 @@
+export type AssistantSurfaceKind = "full-surface" | "transient";
+export interface AssistantSurfacePresence {
+    readonly fullSurfaceMounted: boolean;
+    readonly transientOpen: boolean;
+}
+export declare class AssistantSurfaceRegistry {
+    private readonly tokens;
+    private readonly listeners;
+    private snapshot;
+    register(kind: AssistantSurfaceKind): () => void;
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): AssistantSurfacePresence;
+    private _publishIfPresenceChanged;
+    private _derivePresence;
+}
+export declare const assistantSurfaceRegistry: AssistantSurfaceRegistry;

package/dist/core/surface-registry.js

@@ -0,0 +1,56 @@
+import { closeCompanionDrawer } from "./companion-drawer-flag.js";
+const NO_SURFACES = Object.freeze({
+    fullSurfaceMounted: false,
+    transientOpen: false,
+});
+export class AssistantSurfaceRegistry {
+    tokens = new Set();
+    listeners = new Set();
+    snapshot = NO_SURFACES;
+    register(kind) {
+        if (kind === "full-surface") {
+            closeCompanionDrawer();
+        }
+        const token = { kind };
+        this.tokens.add(token);
+        this._publishIfPresenceChanged();
+        return () => {
+            this.tokens.delete(token);
+            this._publishIfPresenceChanged();
+        };
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    _publishIfPresenceChanged() {
+        const next = this._derivePresence();
+        if (next.fullSurfaceMounted === this.snapshot.fullSurfaceMounted &&
+            next.transientOpen === this.snapshot.transientOpen) {
+            return;
+        }
+        this.snapshot = next;
+        for (const listener of [...this.listeners]) {
+            listener();
+        }
+    }
+    _derivePresence() {
+        let fullSurfaceMounted = false;
+        let transientOpen = false;
+        for (const token of this.tokens) {
+            if (token.kind === "full-surface") {
+                fullSurfaceMounted = true;
+            }
+            else {
+                transientOpen = true;
+            }
+        }
+        return { fullSurfaceMounted, transientOpen };
+    }
+}
+export const assistantSurfaceRegistry = new AssistantSurfaceRegistry();

package/dist/core/suspension-queue.d.ts

@@ -0,0 +1,14 @@
+import type { ApprovalCardModel } from "./approval-inbox.js";
+import type { ElicitationCardModel } from "./elicitation-cards.js";
+export type PendingDecision = {
+    kind: "approval";
+    card: ApprovalCardModel;
+} | {
+    kind: "elicitation";
+    card: ElicitationCardModel;
+};
+export declare function decisionKeyOf(decision: PendingDecision): string;
+export declare function approvalAwaitsMember(card: ApprovalCardModel): boolean;
+export declare function elicitationAwaitsMember(card: ElicitationCardModel): boolean;
+export declare function suspensionQueueOf(approvals: readonly ApprovalCardModel[], elicitations: readonly ElicitationCardModel[], rowIndexByToolCallId: ReadonlyMap<string, number>): PendingDecision[];
+export declare function clampedCursorOf(cursor: number, queueLength: number): number;