@teaflask/assistant 0.0.0 → 0.6.0

package/dist/components/use-transcript-folds.js

@@ -0,0 +1,97 @@
+"use client";
+import { useContext } from "react";
+import { hostFillDeclines } from "../core/host-fill.js";
+import { currentTurnStartOf, foldedBlocksOf, runFoldsOf, } from "../core/run-folds.js";
+import { subagentOutcomeCountsOf } from "../core/subagent-rows.js";
+import { ElicitationsContext } from "./elicitation-context.js";
+import { resolvedSubagentEntryOf, SubagentDispatchesContext, } from "./subagent-group-row.js";
+export function useMessageListDerivations(source, { live, typing, turnOpen, markerBoundaries, turnStartIds, decisionSurfacesInShelf, frameClaimsLiveness, emptyFallback, }) {
+    const { cards: elicitationCards } = useContext(ElicitationsContext);
+    const { foldedBlocks, flatRows, displayRows } = useTranscriptFolds(source, {
+        live,
+        turnOpen,
+        markerBoundaries,
+        turnStartIds,
+    });
+    const currentTurnStart = currentTurnStartOf(displayRows, foldedBlocks, turnStartIds);
+    const blockStarts = _blockStartsOf(foldedBlocks ?? []);
+    const unrowedAnsweredAsks = decisionSurfacesInShelf
+        ? _unrowedAnsweredAsksOf(flatRows, elicitationCards)
+        : NO_UNROWED_ASKS;
+    const liveIndex = displayRows.length - 1;
+    const dispatchesJoin = useContext(SubagentDispatchesContext);
+    const hostEmptySurfaceShown = !hostFillDeclines(emptyFallback) && displayRows.length === 0;
+    const livenessClaimant = hostEmptySurfaceShown || frameClaimsLiveness
+        ? "none"
+        : _trailingLivenessClaimantOf(displayRows, live, typing, dispatchesJoin);
+    return {
+        foldedBlocks,
+        displayRows,
+        currentTurnStart,
+        blockStarts,
+        unrowedAnsweredAsks,
+        liveIndex,
+        hostEmptySurfaceShown,
+        livenessClaimant,
+    };
+}
+const NO_UNROWED_ASKS = [];
+function useTranscriptFolds(source, { live, turnOpen, markerBoundaries, turnStartIds, }) {
+    const { rows, blocks } = source;
+    const foldedBlocks = blocks !== undefined
+        ? foldedBlocksOf(blocks, {
+            openTailTurn: turnOpen ?? live,
+            markerBoundaries,
+            turnStartIds,
+        })
+        : null;
+    const flatRows = rows ?? blocks.flatMap((block) => block.rows);
+    const displayRows = foldedBlocks !== null
+        ? foldedBlocks.flatMap((block) => block.rows)
+        : runFoldsOf(flatRows, {
+            openTailTurn: turnOpen ?? live,
+        });
+    return { foldedBlocks, flatRows, displayRows };
+}
+function _blockStartsOf(blocks) {
+    const starts = [];
+    let next = 0;
+    for (const block of blocks) {
+        starts.push(next);
+        next += block.rows.length;
+    }
+    return starts;
+}
+function _unrowedAnsweredAsksOf(rows, elicitationCards) {
+    const renderedCallIds = new Set();
+    for (const row of rows) {
+        if (row.kind === "tool-call") {
+            renderedCallIds.add(row.toolCallId);
+        }
+    }
+    return elicitationCards.filter((card) => (card.toolCallId === null || !renderedCallIds.has(card.toolCallId)) &&
+        card.status === "answered");
+}
+function _trailingLivenessClaimantOf(displayRows, live, typing, dispatches) {
+    const last = displayRows.at(-1);
+    const tailClaims = last !== undefined &&
+        ((last.kind === "run-fold" && _foldClaimsLiveness(last.members, live)) ||
+            (last.kind === "assistant-text" && last.streaming) ||
+            (last.kind === "subagent-group" &&
+                subagentOutcomeCountsOf(last.entries.map((entry) => resolvedSubagentEntryOf(entry, dispatches.byOrdinal))).running > 0));
+    if (tailClaims) {
+        return "tail-row";
+    }
+    if (typing) {
+        return "typing-dot";
+    }
+    if (live) {
+        return "standalone-headline";
+    }
+    return "none";
+}
+export function _foldClaimsLiveness(members, turnLive) {
+    return (turnLive ||
+        members.some((row) => (row.kind === "reasoning" && row.streaming) ||
+            (row.kind === "tool-call" && row.state === "input-available")));
+}

package/dist/components/use-transcript.d.ts

@@ -0,0 +1,19 @@
+import type { Message } from "@ag-ui/core";
+import { type AssistantActivitySnapshot } from "../core/activity.js";
+import type { MarkerAnchorsSnapshot } from "../core/connection-epoch.js";
+import { type TranscriptRow } from "../core/transcript-rows.js";
+import type { UserTurnMeta } from "../core/user-turn-ledger.js";
+export interface TranscriptSurface {
+    rows: readonly TranscriptRow[];
+    displayRows: readonly TranscriptRow[];
+    running: boolean;
+    turnOpen: boolean;
+    decisionsPending: boolean;
+    messages: readonly Message[];
+    markerAnchors: MarkerAnchorsSnapshot;
+    activity: AssistantActivitySnapshot;
+    turnMeta: ReadonlyMap<string, UserTurnMeta>;
+}
+export declare function useTranscript(options?: {
+    surface?: string;
+}): TranscriptSurface;

package/dist/components/use-transcript.js

@@ -0,0 +1,40 @@
+"use client";
+import { useEffect, useMemo } from "react";
+import { isTerminalTurnStatus, } from "../core/activity.js";
+import { runReadsAsWorking } from "../core/run-status.js";
+import { approvalAwaitsMember, elicitationAwaitsMember, } from "../core/suspension-queue.js";
+import { transcriptRowsOf, withPendingUserEcho, } from "../core/transcript-rows.js";
+import { useConversation } from "./conversation-context.js";
+import { useAssistantSession } from "./teaflask-assistant-provider.js";
+import { useCell } from "./use-store-cell.js";
+export function useTranscript(options) {
+    const { store } = useAssistantSession();
+    const { pendingEcho } = useConversation();
+    const messages = useCell(store.messages);
+    const markerAnchors = useCell(store.markerAnchors);
+    const approvalCards = useCell(store.approvals);
+    const elicitationCards = useCell(store.elicitations);
+    const activity = useCell(store.activity);
+    const turnMeta = useCell(store.turnMeta);
+    const surface = options?.surface ?? "headless";
+    useEffect(() => store.acquireTranscriptLease(surface), [store, surface]);
+    const decisionSurfaceLive = useMemo(() => approvalCards.some(approvalAwaitsMember) ||
+        elicitationCards.some(elicitationAwaitsMember), [approvalCards, elicitationCards]);
+    const decisionsPending = decisionSurfaceLive || Boolean(activity.pendingDecisionGap);
+    const running = runReadsAsWorking(activity.newestTurnStatus, decisionsPending);
+    const turnOpen = activity.newestTurnStatus !== null &&
+        !isTerminalTurnStatus(activity.newestTurnStatus);
+    const rows = useMemo(() => transcriptRowsOf(messages, markerAnchors, running, turnMeta), [messages, markerAnchors, running, turnMeta]);
+    const displayRows = useMemo(() => withPendingUserEcho(rows, pendingEcho), [pendingEcho, rows]);
+    return {
+        rows,
+        displayRows,
+        running,
+        turnOpen,
+        decisionsPending,
+        messages,
+        markerAnchors,
+        activity,
+        turnMeta,
+    };
+}

package/dist/components/user-message.d.ts

@@ -0,0 +1,6 @@
+import type { TurnAttachment } from "../contract/threads.js";
+export declare function UserMessage({ children, attachments, createdAt, }: {
+    children: string;
+    attachments?: readonly TurnAttachment[];
+    createdAt?: string;
+}): import("react").JSX.Element;

package/dist/components/user-message.js

@@ -0,0 +1,9 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { conversationalTimeOf } from "../core/time-labels.js";
+import { AttachmentChips } from "./attachment-chips.js";
+import { CopyTextButton } from "./copy-text-button.js";
+export function UserMessage({ children, attachments = [], createdAt, }) {
+    const time = createdAt !== undefined ? conversationalTimeOf(createdAt) : null;
+    return (_jsxs("div", { className: "tf:group/user-message tf:flex tf:flex-col tf:items-end tf:gap-2 tf:ps-20", "data-role": "user", children: [_jsx(AttachmentChips, { attachments: attachments }), children !== "" ? (_jsxs(_Fragment, { children: [_jsx("div", { className: "tf:min-w-0 tf:rounded-xl tf:bg-tf-muted tf:px-4 tf:py-2 tf:text-tf-body tf:break-words tf:whitespace-pre-wrap tf:text-tf-foreground", children: children }), _jsxs("div", { className: "tf:flex tf:h-7 tf:items-center tf:justify-end tf:gap-1", children: [time !== null ? (_jsx("time", { dateTime: createdAt, title: time.full, className: "tf:text-xs tf:text-tf-muted-foreground tf:opacity-0 tf:transition-opacity tf:group-hover/user-message:opacity-100 tf:group-focus-within/user-message:opacity-100 tf:pointer-coarse:opacity-100", children: time.label })) : null, _jsx(CopyTextButton, { text: children, label: "Copy message", className: "tf:opacity-0 tf:transition-opacity tf:group-hover/user-message:opacity-100 tf:group-focus-within/user-message:opacity-100 tf:focus-visible:opacity-100 tf:pointer-coarse:opacity-100" })] })] })) : null] }));
+}

package/dist/contract/actions-adapter.d.ts

@@ -0,0 +1,26 @@
+export interface ActionIntentAction {
+    slug: string;
+    title: string;
+}
+export interface ActionIntent {
+    action: ActionIntentAction;
+    method: string;
+    pathTemplate: string;
+    pathParams: Record<string, unknown>;
+    query: Record<string, unknown>;
+    body?: unknown;
+}
+export interface CookiesActionsAdapter {
+    kind: "cookies";
+    baseUrl: string;
+}
+export interface HeadersActionsAdapter {
+    kind: "headers";
+    baseUrl: string;
+    getHeaders: (intent: ActionIntent) => Record<string, string> | Promise<Record<string, string>>;
+}
+export interface RequestActionsAdapter {
+    kind: "request";
+    execute: (intent: ActionIntent) => Promise<unknown>;
+}
+export type ActionsAdapter = CookiesActionsAdapter | HeadersActionsAdapter | RequestActionsAdapter;

package/dist/contract/actions-adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/assistant-config.d.ts

@@ -0,0 +1 @@
+export type { AssistantConfigResponse, AttachmentPolicyResponse as ServedAttachmentPolicy, ModelChoiceResponse as ServedModelChoice, RouteSuggestions as ServedRouteSuggestions, SuggestionsConfig as ServedSuggestionsConfig, ThinkingEffort as ServedThinkingEffort, } from "../generated/models/index.js";

package/dist/contract/assistant-config.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/dispatches.d.ts

@@ -0,0 +1,15 @@
+import { AgentDispatchStatus } from "../generated/models/index.js";
+export type { ServingAgentDispatchResponse as ThreadDispatch } from "../generated/models/index.js";
+export type ThreadDispatchStatus = AgentDispatchStatus;
+export declare function dispatchIsRunning(dispatch: {
+    status: ThreadDispatchStatus;
+}): boolean;
+export declare function dispatchFailed(dispatch: {
+    status: ThreadDispatchStatus;
+}): boolean;
+export declare function dispatchIsPaused(dispatch: {
+    status: ThreadDispatchStatus;
+}): boolean;
+export declare function dispatchHasSettled(dispatch: {
+    status: ThreadDispatchStatus;
+} | undefined): boolean;

package/dist/contract/dispatches.js

@@ -0,0 +1,24 @@
+import { AgentDispatchStatus } from "../generated/models/index.js";
+export function dispatchIsRunning(dispatch) {
+    return (dispatch.status === AgentDispatchStatus.dispatched ||
+        dispatch.status === AgentDispatchStatus.paused);
+}
+export function dispatchFailed(dispatch) {
+    return dispatch.status === AgentDispatchStatus.failed;
+}
+export function dispatchIsPaused(dispatch) {
+    return dispatch.status === AgentDispatchStatus.paused;
+}
+export function dispatchHasSettled(dispatch) {
+    if (dispatch === undefined) {
+        return false;
+    }
+    switch (dispatch.status) {
+        case AgentDispatchStatus.succeeded:
+        case AgentDispatchStatus.failed:
+            return true;
+        case AgentDispatchStatus.dispatched:
+        case AgentDispatchStatus.paused:
+            return false;
+    }
+}

package/dist/contract/errors.d.ts

@@ -0,0 +1,11 @@
+export type { ServingErrorCode } from "../generated/models/index.js";
+import type { ServingErrorCode } from "../generated/models/index.js";
+export type ServingErrorCodeOnTheWire = ServingErrorCode | (string & {});
+export interface ServingErrorBody {
+    code: ServingErrorCodeOnTheWire;
+    message: string;
+    details?: unknown;
+}
+export interface ServingErrorEnvelope {
+    error: ServingErrorBody;
+}

package/dist/contract/errors.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/events.d.ts

@@ -0,0 +1,20 @@
+import type { ApprovalRequestedMarker, ApprovalResolvedMarker, InterruptAnswerConsumedMarker, RunResumedMarker, SubagentResultsDeliveredMarker, ToolExecutionRequestedMarker } from "../generated/models/index.js";
+export type AssistantStreamEventType = "TEXT_MESSAGE_START" | "TEXT_MESSAGE_CONTENT" | "TEXT_MESSAGE_END" | "REASONING_START" | "REASONING_END" | "REASONING_MESSAGE_START" | "REASONING_MESSAGE_CONTENT" | "REASONING_MESSAGE_END" | "TOOL_CALL_START" | "TOOL_CALL_ARGS" | "TOOL_CALL_END" | "TOOL_CALL_RESULT" | "RUN_STARTED" | "RUN_FINISHED" | "RUN_ERROR" | "CUSTOM";
+export declare const RUN_RESUMED_EVENT_NAME: "run_resumed";
+export type RunResumedPayload = RunResumedMarker;
+export declare const APPROVAL_REQUESTED_EVENT_NAME: "approval_requested";
+export type ApprovalRequestedPayload = ApprovalRequestedMarker & Required<Pick<ApprovalRequestedMarker, "tool_args" | "tool_input_schema" | "tool_output_schema" | "round" | "gated" | "trust_available">>;
+export declare const APPROVAL_RESOLVED_EVENT_NAME: "approval_resolved";
+export type ApprovalResolvedPayload = ApprovalResolvedMarker;
+export declare const INTERRUPT_ANSWER_CONSUMED_EVENT_NAME: "interrupt_answer_consumed";
+export type InterruptAnswerConsumedPayload = InterruptAnswerConsumedMarker;
+export declare const TURN_FAILED_EVENT_NAME: "turn_failed";
+export declare const TURN_STOPPED_EVENT_NAME: "turn_stopped";
+export declare const TOOL_EXECUTION_REQUESTED_EVENT_NAME: "tool_execution_requested";
+export type ToolExecutionRequestedPayload = ToolExecutionRequestedMarker & Required<Pick<ToolExecutionRequestedMarker, "round">>;
+export declare const TOOL_RESULT_RECORDED_EVENT_NAME: "tool_result_recorded";
+export declare const TOOL_CALL_ANNOTATED_EVENT_NAME: "tool_call_annotated";
+export declare const SUBAGENT_RESULTS_DELIVERED_EVENT_NAME: "subagent_results_delivered";
+export type SubagentResultsDeliveredPayload = SubagentResultsDeliveredMarker;
+export declare const TURN_USAGE_RECORDED_EVENT_NAME: "turn_usage_recorded";
+export declare const MEMORY_UPDATED_EVENT_NAME: "memory_updated";

package/dist/contract/events.js

@@ -0,0 +1,13 @@
+import { AssistantStreamMarkerName } from "../generated/models/index.js";
+export const RUN_RESUMED_EVENT_NAME = AssistantStreamMarkerName.run_resumed;
+export const APPROVAL_REQUESTED_EVENT_NAME = AssistantStreamMarkerName.approval_requested;
+export const APPROVAL_RESOLVED_EVENT_NAME = AssistantStreamMarkerName.approval_resolved;
+export const INTERRUPT_ANSWER_CONSUMED_EVENT_NAME = AssistantStreamMarkerName.interrupt_answer_consumed;
+export const TURN_FAILED_EVENT_NAME = AssistantStreamMarkerName.turn_failed;
+export const TURN_STOPPED_EVENT_NAME = AssistantStreamMarkerName.turn_stopped;
+export const TOOL_EXECUTION_REQUESTED_EVENT_NAME = AssistantStreamMarkerName.tool_execution_requested;
+export const TOOL_RESULT_RECORDED_EVENT_NAME = AssistantStreamMarkerName.tool_result_recorded;
+export const TOOL_CALL_ANNOTATED_EVENT_NAME = AssistantStreamMarkerName.tool_call_annotated;
+export const SUBAGENT_RESULTS_DELIVERED_EVENT_NAME = AssistantStreamMarkerName.subagent_results_delivered;
+export const TURN_USAGE_RECORDED_EVENT_NAME = AssistantStreamMarkerName.turn_usage_recorded;
+export const MEMORY_UPDATED_EVENT_NAME = AssistantStreamMarkerName.memory_updated;

package/dist/contract/identity.d.ts

@@ -0,0 +1 @@
+export type { CurrentVisitorResponse as WhoamiResponse, EndUserIdentity, MintVisitorTokenRequest, MintVisitorTokenResponse, PublishableKeyMode, VisitorTier, } from "../generated/models/index.js";

package/dist/contract/identity.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/subscriptions.d.ts

@@ -0,0 +1,16 @@
+import type { SubscriptionProvider } from "../generated/models/index.js";
+export type { BeginSubscriptionAuthorizationResponse as SubscriptionAuthorization, CompleteSubscriptionAuthorizationRequest as SubscriptionAuthorizationCompletionRequest, CompleteSubscriptionAuthorizationResponse as SubscriptionAuthorizationCompletion, ServingSubscriptionStatus as SubscriptionStatus, SubscriptionCredentialState, SubscriptionProvider, } from "../generated/models/index.js";
+export declare const SUBSCRIPTION_CONNECT_MESSAGE_TYPE = "teaflask.subscription_connect";
+export type SubscriptionConnectMessage = {
+    type: typeof SUBSCRIPTION_CONNECT_MESSAGE_TYPE;
+    provider: SubscriptionProvider;
+    kind: "code";
+    code: string;
+    state: string;
+    client_id: string | null;
+} | {
+    type: typeof SUBSCRIPTION_CONNECT_MESSAGE_TYPE;
+    provider: SubscriptionProvider;
+    kind: "denied" | "failed";
+};
+export declare function subscriptionConnectMessageOf(event: MessageEvent, serverOrigin: string, provider: SubscriptionProvider): SubscriptionConnectMessage | null;

package/dist/contract/subscriptions.js

@@ -0,0 +1,35 @@
+export const SUBSCRIPTION_CONNECT_MESSAGE_TYPE = "teaflask.subscription_connect";
+export function subscriptionConnectMessageOf(event, serverOrigin, provider) {
+    if (event.origin !== serverOrigin || event.source === null) {
+        return null;
+    }
+    const data = event.data;
+    if (typeof data !== "object" || data === null) {
+        return null;
+    }
+    const record = data;
+    if (record.type !== SUBSCRIPTION_CONNECT_MESSAGE_TYPE ||
+        record.provider !== provider) {
+        return null;
+    }
+    if (record.kind === "denied" || record.kind === "failed") {
+        return {
+            type: SUBSCRIPTION_CONNECT_MESSAGE_TYPE,
+            provider,
+            kind: record.kind,
+        };
+    }
+    if (record.kind === "code" &&
+        typeof record.code === "string" &&
+        typeof record.state === "string") {
+        return {
+            type: SUBSCRIPTION_CONNECT_MESSAGE_TYPE,
+            provider,
+            kind: "code",
+            code: record.code,
+            state: record.state,
+            client_id: typeof record.client_id === "string" ? record.client_id : null,
+        };
+    }
+    return null;
+}

package/dist/contract/telemetry.d.ts

@@ -0,0 +1,30 @@
+export type ApprovalSubmitDropReason = "no_active_thread" | "card_missing" | "already_submitting" | "not_actionable_answered" | "not_actionable_stale" | "no_turn_id";
+type ApprovalCardStatusKind = "actionable" | "submitting" | "answered" | "stale";
+export interface ApprovalSubmitTelemetryEvent {
+    name: "approval_submit_attempted" | "approval_submit_sent" | "approval_submit_dropped";
+    properties: {
+        interrupt_id: string;
+        thread_id: string | null;
+        approved: boolean;
+        trusted: boolean;
+        card_status: ApprovalCardStatusKind;
+        parked: boolean;
+        drop_reason?: ApprovalSubmitDropReason;
+    };
+}
+export type StreamFailureClass = "network_rejected" | "http_error" | "no_body" | "mid_stream" | "parse_or_validation" | "client_abort";
+export interface StreamFailedTelemetryEvent {
+    name: "assistant_stream_failed";
+    properties: {
+        failure_class: StreamFailureClass;
+        status: number | null;
+        thread_id: string | null;
+        resume_cursor: string | null;
+        last_committed_sse_id: string | null;
+    };
+}
+export type AssistantTelemetryEvent = ApprovalSubmitTelemetryEvent | StreamFailedTelemetryEvent;
+export declare function streamFailureClassOf(error: Error, context: {
+    sawBodyBytes: boolean;
+}): StreamFailureClass;
+export {};

package/dist/contract/telemetry.js

@@ -0,0 +1,19 @@
+import { AGUIError } from "@ag-ui/core";
+export function streamFailureClassOf(error, context) {
+    if (error.name === "AbortError" || /\baborted?\b/i.test(error.message)) {
+        return "client_abort";
+    }
+    if (typeof error.status === "number") {
+        return "http_error";
+    }
+    if (error instanceof AGUIError || error.name === "ZodError") {
+        return "parse_or_validation";
+    }
+    if (error.message.includes("Failed to getReader")) {
+        return "no_body";
+    }
+    if (error instanceof TypeError) {
+        return context.sawBodyBytes ? "mid_stream" : "network_rejected";
+    }
+    return "mid_stream";
+}

package/dist/contract/threads.d.ts

@@ -0,0 +1,3 @@
+export type { CreateServingAttachmentUploadResponse as AttachmentUploadIntent, HighlightResult, NavigateResult, PrefillFormResult, ReadPageResult, ResolveServingTurnApprovalRequest as ResolveTurnApprovalRequest, ResolveServingTurnApprovalResponse as ResolveTurnApprovalResponse, ResolveServingTurnToolResultsRequest as ResolveTurnToolResultsRequest, ResolveServingTurnToolResultsResponse as ResolveTurnToolResultsResponse, SendServingAssistantMessageRequest as SendAssistantMessageRequest, SendServingAssistantMessageResponse as SendAssistantMessageResponse, ServingApprovalDelivery as ApprovalDelivery, ServingAssistantThreadDetailResponse as AssistantThreadDetailResponse, ServingAssistantThreadResponse as ServingAssistantThread, ServingAssistantTurnResponse as ServingAssistantTurn, ServingAttachmentResponse as ServingAttachment, ServingTurnApprovalDecision as TurnApprovalDecision, ServingTurnAttachmentResponse as TurnAttachment, StopServingTurnResponse as StopTurnResponse, ThreadModelPickResponse as ThreadModelPick, AssistantTurnStatus as TurnStatus, } from "../generated/models/index.js";
+export declare const ASSISTANT_MESSAGE_MAX_CHARS = 4000;
+export declare const ASSISTANT_MAX_ATTACHMENTS = 10;

package/dist/contract/threads.js

@@ -0,0 +1,2 @@
+export const ASSISTANT_MESSAGE_MAX_CHARS = 4000;
+export const ASSISTANT_MAX_ATTACHMENTS = 10;

package/dist/core/activity-title.d.ts

@@ -0,0 +1 @@
+export declare function activityTitleOf(label: string): string;

package/dist/core/activity-title.js

@@ -0,0 +1,8 @@
+const MAX_TITLE_CHARS = 64;
+export function activityTitleOf(label) {
+    const compact = label.trim().replace(/\s+/g, " ");
+    if (compact.length <= MAX_TITLE_CHARS) {
+        return compact;
+    }
+    return `${compact.slice(0, MAX_TITLE_CHARS - 1).trimEnd()}…`;
+}

package/dist/core/activity.d.ts

@@ -0,0 +1,27 @@
+import type { ServingAssistantTurn, TurnStatus } from "../contract/threads.js";
+import type { ApprovalCardModel } from "./approval-inbox.js";
+import type { PendingDecisionGap } from "./pending-decision-gap.js";
+export interface AssistantActivityResult {
+    turnId: string;
+    status: TurnStatus;
+    failureSentence: string | null;
+}
+export interface AssistantActivitySnapshot {
+    busy: boolean;
+    newestTurnStatus: TurnStatus | null;
+    newestTurnId: string | null;
+    pendingApprovalCount: number;
+    pendingDecisionGap: PendingDecisionGap | null;
+    lastResult: AssistantActivityResult | null;
+}
+export declare const IDLE_ACTIVITY: AssistantActivitySnapshot;
+export declare function activitySnapshotOf(args: {
+    busy: boolean;
+    newestTurn: ServingAssistantTurn | null;
+    approvalCards: readonly ApprovalCardModel[];
+    pendingDecisionGap: PendingDecisionGap | null;
+    lastResult: AssistantActivityResult | null;
+}): AssistantActivitySnapshot;
+export declare function settledResultOf(turn: ServingAssistantTurn): AssistantActivityResult | null;
+export declare function sameActivitySnapshot(a: AssistantActivitySnapshot, b: AssistantActivitySnapshot): boolean;
+export declare function isTerminalTurnStatus(status: TurnStatus): boolean;

package/dist/core/activity.js

@@ -0,0 +1,53 @@
+export const IDLE_ACTIVITY = {
+    busy: false,
+    newestTurnStatus: null,
+    newestTurnId: null,
+    pendingApprovalCount: 0,
+    pendingDecisionGap: null,
+    lastResult: null,
+};
+export function activitySnapshotOf(args) {
+    return {
+        busy: args.busy,
+        newestTurnStatus: args.newestTurn?.status ?? null,
+        newestTurnId: args.newestTurn?.id ?? null,
+        pendingApprovalCount: args.approvalCards.filter(_cardAwaitsTheHuman).length,
+        pendingDecisionGap: args.pendingDecisionGap,
+        lastResult: args.lastResult,
+    };
+}
+export function settledResultOf(turn) {
+    if (!isTerminalTurnStatus(turn.status)) {
+        return null;
+    }
+    return {
+        turnId: turn.id,
+        status: turn.status,
+        failureSentence: turn.status === "failed" ? (turn.error ?? null) : null,
+    };
+}
+export function sameActivitySnapshot(a, b) {
+    return (a.busy === b.busy &&
+        a.newestTurnStatus === b.newestTurnStatus &&
+        a.newestTurnId === b.newestTurnId &&
+        a.pendingApprovalCount === b.pendingApprovalCount &&
+        a.pendingDecisionGap === b.pendingDecisionGap &&
+        _sameResult(a.lastResult, b.lastResult));
+}
+function _sameResult(a, b) {
+    if (a === null || b === null) {
+        return a === b;
+    }
+    return (a.turnId === b.turnId &&
+        a.status === b.status &&
+        a.failureSentence === b.failureSentence);
+}
+function _cardAwaitsTheHuman(card) {
+    return card.status.kind === "actionable" || card.status.kind === "submitting";
+}
+export function isTerminalTurnStatus(status) {
+    return (status === "succeeded" ||
+        status === "failed" ||
+        status === "superseded" ||
+        status === "stopped");
+}

package/dist/core/agent-identity.d.ts

@@ -0,0 +1,2 @@
+export declare const PRIMARY_AGENT_IDENTITY_TOKEN = "teaflask";
+export declare function subagentIdentityTokenOf(childSessionId: string): string;

package/dist/core/agent-identity.js

@@ -0,0 +1,4 @@
+export const PRIMARY_AGENT_IDENTITY_TOKEN = "teaflask";
+export function subagentIdentityTokenOf(childSessionId) {
+    return `subagent:${childSessionId}`;
+}

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

@@ -0,0 +1,6 @@
+import { type ApprovalCardModel, type ApprovalDecisionInput } from "./approval-inbox.js";
+import type { ActiveConversation } from "./conversation-contract.js";
+import type { AssistantConversationStore } from "./conversation-store.js";
+import type { ElicitationCardModel } from "./elicitation-cards.js";
+export declare function submitApprovalDecisionFromStore(store: AssistantConversationStore, card: ApprovalCardModel, decision: ApprovalDecisionInput): Promise<void>;
+export declare function turnIdAnsweredBy(store: AssistantConversationStore, active: ActiveConversation, card: ElicitationCardModel): Promise<string | null>;