@athenaintel/react 0.41.2 → 0.42.1

package/dist/agent-runtime/src/subagents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagents.js","sources":["../../../../agent-runtime/src/subagents.ts"],"sourcesContent":["/**\n * Subagent discovery: every subagent lane a deep-agent thread has spawned, as\n * the card view model the surfaces that draw subagent lanes render. Two\n * dispatch paths feed lanes keyed by dispatch id:\n *\n * - top-level `task` tool calls, read from the call's own tool-call part\n *   ({@link taskSubagentsOfTurn}): the part's result and `isPreliminary` say\n *   where the lane is, and its `messages` (the nested thread\n *   `createSubagentTranscriptConversionCache` converts) are the transcript;\n * - in-eval `task()` dispatches ({@link deriveEvalSubagents}), whose only\n *   signals are the live `ptc_subagents` state channel and the summaries a\n *   finished `eval` ToolMessage persists in `artifact.ptc_subagents`.\n */\nimport {\n  getExternalStoreMessages,\n  type ThreadMessage,\n  type ToolCallMessagePart,\n} from '@assistant-ui/core';\nimport type { LangChainMessage, LangChainToolCall } from '@assistant-ui/react-langgraph';\nimport { useAuiState } from '@assistant-ui/store';\nimport { useMemo } from 'react';\nimport {\n  DEEP_AGENT_LANE_USAGE_KEY,\n  DEEP_AGENT_TRUNCATED_LANE_KEY,\n} from './generated/runconfig-contract';\nimport { getMessageText } from './message-text';\nimport { convertSubagentTranscript, withRepeatedResult } from './subagent-transcripts';\nimport { EVAL_TOOL_NAME, TASK_TOOL_NAME } from './tool-names';\nimport type { PtcSubagentEntry, Todo } from './types';\n\n/**\n * Where a subagent lane is:\n *\n * - `queued` — the dispatch has not started: a `task` call with no result yet\n *   (waiting for a dispatch slot or an approval; the backend shows the running\n *   card once the dispatch holds its slot), or an in-eval dispatch waiting for\n *   one of the bridge's concurrency slots.\n * - `running` — a `task` call's result is still the backend's running\n *   placeholder (its part is `isPreliminary`), and the nested transcript fills\n *   in live; or an in-eval dispatch's lifecycle says it runs.\n * - `complete` / `error` — the real result replaced the placeholder; `error`\n *   when it is an error result.\n */\nexport type SubagentStatus = 'queued' | 'running' | 'complete' | 'error';\n\n/** True for the settled lifecycle states (`complete` / `error`). */\nexport function isTerminalSubagentStatus(status: SubagentStatus): boolean {\n  return status === 'complete' || status === 'error';\n}\n\n/** Aggregate lane lifecycle counts for one fan-out (orchestration strip + header chip). */\nexport interface SubagentStatusCounts {\n  total: number;\n  queued: number;\n  running: number;\n  complete: number;\n  failed: number;\n  /** complete + failed — the settled count progress displays use. */\n  terminal: number;\n}\n\nexport function countSubagentStatuses(\n  snapshots: readonly SubagentDiscoverySnapshot[]\n): SubagentStatusCounts {\n  const counts: SubagentStatusCounts = {\n    total: snapshots.length,\n    queued: 0,\n    running: 0,\n    complete: 0,\n    failed: 0,\n    terminal: 0,\n  };\n  for (const snapshot of snapshots) {\n    if (snapshot.status === 'queued') counts.queued += 1;\n    else if (snapshot.status === 'running') counts.running += 1;\n    else if (snapshot.status === 'complete') counts.complete += 1;\n    else counts.failed += 1;\n  }\n  counts.terminal = counts.complete + counts.failed;\n  return counts;\n}\n\n/**\n * Discovery snapshot for one subagent invocation. Mirrors LangChain's\n * `SubagentDiscoverySnapshot`: `id` is the `task` tool-call id that spawned the\n * subagent (the dispatch id for an in-eval dispatch), so cards nest under the\n * coordinator turn that delegated the work.\n */\nexport interface SubagentDiscoverySnapshot {\n  /** The `task` tool-call id that spawned the subagent. */\n  id: string;\n  /** Subagent type/name, from the `task` call's `subagent_type` arg. */\n  name: string;\n  /** The one-line task brief from the `task` call's `description` arg. */\n  description: string;\n  /** Lifecycle state — see {@link SubagentStatus}. */\n  status: SubagentStatus;\n  /** The call's result text (empty while it is the running placeholder). */\n  output?: string;\n  /** Number of nested tool calls the subagent made. */\n  toolCallCount: number;\n  /**\n   * The subagent's transcript as a nested thread: a `task` part's native\n   * `messages`, or an in-eval dispatch's live transcript converted the same way.\n   */\n  messages: readonly ThreadMessage[];\n  /** Messages in the transcript as the wire carries them, before conversion joins a turn's steps. */\n  messageCount: number;\n  /**\n   * Nested messages the wire left off: a cut card carries its newest steps\n   * ({@link readTruncatedLane}) — a running card always, a finished one on a\n   * version-2 view — and the rest pages in through `history/lane`; an in-eval\n   * dispatch's streamed transcript is cut the same way, running or finished.\n   * Absent when the transcript rides whole.\n   */\n  omittedMessageCount?: number;\n  /**\n   * Where the lane's steps ride, what `history/lane` pages the rest of the lane\n   * under (`useDeepAgentLaneHistory`): a `task` lane's card, an in-eval lane's\n   * registry entry while it streams its steps, or, once they no longer ride,\n   * its subagent checkpoint (`checkpointed`), when agora recorded where that is\n   * (`ns`). Absent for any other in-eval lane with no streamed steps (a summary\n   * written before agora recorded the namespace, an older host).\n   */\n  source?: SubagentLaneSource;\n  /** The subagent's own plan, nested by the backend on the task artifact (`subgraph_state.todos`). */\n  todos?: Todo[];\n  /** The newest tool call in the transcript — the card's \"last action\" ticker. */\n  lastToolCall?: LangChainToolCall;\n  /** The newest assistant text in the transcript — the card's thought preview. */\n  currentText: string;\n  /**\n   * The `eval` tool-call id that dispatched this subagent, when it was spawned\n   * from INSIDE the code interpreter (`task()` in the REPL) rather than by a\n   * top-level `task` tool call. The eval card uses it to render lanes for its\n   * own dispatches.\n   */\n  evalId?: string;\n  /**\n   * Backend-reported runtime for a finished in-eval dispatch (from the terminal\n   * lifecycle event). Authoritative over client-side timing — it survives a page\n   * refresh, where local first-seen timestamps are gone.\n   */\n  durationMs?: number;\n  /** The model that produced the transcript, from its newest assistant turn's model stamp. */\n  model?: string;\n  /**\n   * The lane's token use: the whole lane's as the host counts it\n   * (`DEEP_AGENT_LANE_USAGE_KEY`), else the sum of the native step usage\n   * (`metadata.steps[].usage`) of the steps the transcript holds. Absent while\n   * no step reports any.\n   */\n  usage?: SubagentTokenUsage;\n}\n\n/** A subagent lane's token use. */\nexport interface SubagentTokenUsage {\n  /** Input tokens, the prompt cache's reads and writes included. */\n  readonly inputTokens: number;\n  readonly outputTokens: number;\n  /**\n   * Less than the lane will have used: the lane still runs (its newest step may\n   * not have reported yet), or no host total arrived and the sum covers only\n   * the steps held of a lane cut to its newest ones.\n   */\n  readonly partial: boolean;\n}\n\n/** Input and output tokens of some model calls. */\nexport interface TokenCounts {\n  readonly inputTokens: number;\n  readonly outputTokens: number;\n}\n\nfunction subagentNameFromArgs(args: Readonly<Record<string, unknown>> | undefined): string {\n  if (!args) return 'subagent';\n  return String(args.subagent_type ?? args.subagentType ?? args.subagent ?? 'subagent');\n}\n\n/**\n * The subagent's streamed transcript as the wire carries it, read from a task\n * ToolMessage's `artifact.subgraph_state.messages` (the shape the backend nests\n * it under — see the route's `_subagent_subgraph_state`).\n */\nexport function nestedMessagesFromArtifact(artifact: unknown): LangChainMessage[] {\n  const a = artifact as { subgraph_state?: { messages?: LangChainMessage[] } } | undefined;\n  return a?.subgraph_state?.messages ?? [];\n}\n\n/** What the wire left off a cut `task` card's nested transcript. */\nexport interface TruncatedLane {\n  /** Nested messages the host holds for the lane. */\n  messages: number;\n  /** Tool calls across all of them. */\n  toolCalls: number;\n  /**\n   * The card is a finished lane's, cut for a version-2 view. Only a host that\n   * serves `history/lane` cuts a finished card.\n   */\n  finished: boolean;\n}\n\n/**\n * Where a lane's steps ride, and what `history/lane` pages the rest of them\n * under: a `task` lane's card, by its message id, or an in-eval dispatch's\n * `ptc_subagents` registry entry, by its dispatch id.\n */\nexport type SubagentLaneSource = {\n  /** The steps as the wire carries them (a card's report restored, {@link withRepeatedResult}). */\n  readonly transcript: readonly LangChainMessage[];\n  /** The cut marker; absent while every step rides. */\n  readonly truncated?: TruncatedLane;\n  /**\n   * No steps ride, and `history/lane {lane}` pages the subagent's own steps\n   * from its checkpoint: an in-eval lane a later run in this activation left\n   * only its summary and `ns`, or a reopened session's lane (its registry gone,\n   * the summary its eval persisted records `ns`).\n   */\n  readonly checkpointed?: true;\n} & (\n  | {\n      /** The card's message id: the running placeholder's, then the result's. */\n      readonly messageId: string;\n      readonly lane?: undefined;\n    }\n  | {\n      /** The dispatch id: the in-eval lane's registry key. */\n      readonly lane: string;\n      readonly messageId?: undefined;\n    }\n);\n\nconst isCount = (value: unknown): value is number =>\n  typeof value === 'number' && Number.isInteger(value) && value >= 0;\n\n/**\n * The cut marker off a `task` card's raw wire message: the host carries only\n * the lane's newest nested steps and names the whole transcript here\n * (`DEEP_AGENT_TRUNCATED_LANE_KEY`), on a running card and, for a version-2\n * view, on a finished one. `null` when the transcript rides whole.\n */\nexport function readTruncatedLane(toolMessage: unknown): TruncatedLane | null {\n  if (typeof toolMessage !== 'object' || toolMessage === null) return null;\n  const marker = (toolMessage as Record<string, unknown>)[DEEP_AGENT_TRUNCATED_LANE_KEY];\n  if (typeof marker !== 'object' || marker === null) return null;\n  const { messages, tool_calls: toolCalls, finished } = marker as Record<string, unknown>;\n  return isCount(messages) && isCount(toolCalls)\n    ? { messages, toolCalls, finished: finished === true }\n    : null;\n}\n\n/**\n * The whole lane's token use the host carries on a `task` card's raw wire\n * message or an in-eval lane's `ptc_subagents` entry\n * (`DEEP_AGENT_LANE_USAGE_KEY`), however much of the lane the wire carries.\n * `null` when it carries none (an older host, or no step reported usage).\n */\nexport function readLaneUsage(wire: unknown): TokenCounts | null {\n  if (typeof wire !== 'object' || wire === null) return null;\n  const usage = (wire as Record<string, unknown>)[DEEP_AGENT_LANE_USAGE_KEY];\n  if (typeof usage !== 'object' || usage === null) return null;\n  const { input_tokens: inputTokens, output_tokens: outputTokens } = usage as Record<\n    string,\n    unknown\n  >;\n  return isCount(inputTokens) && isCount(outputTokens) ? { inputTokens, outputTokens } : null;\n}\n\n/**\n * A lane's token use: the host's total when it sent one, else what the native\n * steps of the transcript held add up to, partial while the lane runs or when\n * that transcript is cut. `undefined` while neither counts anything.\n */\nfunction laneTokenUsage(\n  wire: unknown,\n  steps: TokenCounts | undefined,\n  status: SubagentStatus,\n  cut: boolean\n): SubagentTokenUsage | undefined {\n  const settled = isTerminalSubagentStatus(status);\n  const whole = readLaneUsage(wire);\n  if (whole !== null) return { ...whole, partial: !settled };\n  return steps === undefined ? undefined : { ...steps, partial: !settled || cut };\n}\n\nconst transcriptStepUsageCache = new WeakMap<readonly ThreadMessage[], TokenCounts | null>();\n\n/**\n * What the model calls of a converted transcript used, from assistant-ui's\n * native step usage (`metadata.steps[].usage`, one step per model call a turn\n * joined). `undefined` when no step reports usage. Memoized per transcript\n * array, which the conversion caches keep while the transcript is unchanged.\n */\nexport function transcriptStepUsage(messages: readonly ThreadMessage[]): TokenCounts | undefined {\n  const cached = transcriptStepUsageCache.get(messages);\n  if (cached !== undefined) return cached ?? undefined;\n  let inputTokens = 0;\n  let outputTokens = 0;\n  let counted = false;\n  for (const message of messages) {\n    for (const step of message.metadata.steps ?? []) {\n      if (step.usage === undefined) continue;\n      inputTokens += step.usage.inputTokens;\n      outputTokens += step.usage.outputTokens;\n      counted = true;\n    }\n  }\n  const usage = counted ? { inputTokens, outputTokens } : null;\n  transcriptStepUsageCache.set(messages, usage);\n  return usage ?? undefined;\n}\n\n/**\n * The subagent's own plan, read from a task ToolMessage's\n * `artifact.subgraph_state.todos` (the backend mirrors the subagent's isolated\n * `todos` state channel there — see the route's `_forward_subagent_todos`).\n * `undefined` (not `[]`) when the subagent never wrote a plan, so the UI can\n * distinguish \"no plan\" from \"plan with zero items\".\n */\nexport function nestedTodosFromArtifact(artifact: unknown): Todo[] | undefined {\n  const a = artifact as { subgraph_state?: { todos?: unknown } } | undefined;\n  const todos = a?.subgraph_state?.todos;\n  return Array.isArray(todos) ? (todos as Todo[]) : undefined;\n}\n\n/**\n * The persisted in-eval dispatch summaries from an `eval` ToolMessage's\n * `artifact.ptc_subagents` (written by the backend when the eval ends). Unlike\n * the live `ptc_subagents` state channel — which dies with the stream — these\n * survive checkpoint reload, so reopened sessions can still render each\n * dispatch's terminal status, duration, output, and error.\n */\nexport function ptcSubagentsFromArtifact(artifact: unknown): PtcSubagentEntry[] {\n  const a = artifact as { ptc_subagents?: unknown } | undefined;\n  const entries = a?.ptc_subagents;\n  if (!Array.isArray(entries)) return [];\n  return entries.filter(\n    (entry): entry is PtcSubagentEntry =>\n      !!entry &&\n      typeof entry === 'object' &&\n      typeof (entry as { id?: unknown }).id === 'string' &&\n      !!(entry as { id?: string }).id\n  );\n}\n\n/**\n * What one transcript contributes to a lane: the newest assistant text\n * (thought preview), the newest tool call and the count (\"last action\"\n * ticker), the producing model, and the plan recovered from the newest\n * `write_todos` call — the fallback for in-eval lanes, whose isolated `todos`\n * state channel never reaches the wire (the task path nests todos on the\n * artifact instead); the call args carry the same list, so the progress ring\n * can still fill. A pure function of the transcript array.\n */\ninterface TranscriptDerivation {\n  currentText: string;\n  model: string | undefined;\n  lastToolCall: LangChainToolCall | undefined;\n  toolCallCount: number;\n  todos: Todo[] | undefined;\n}\n\nconst EMPTY_TRANSCRIPT_DERIVATION: TranscriptDerivation = {\n  currentText: '',\n  model: undefined,\n  lastToolCall: undefined,\n  toolCallCount: 0,\n  todos: undefined,\n};\n\n/**\n * Per-transcript cache for {@link deriveTranscript}: a lane's converted\n * transcript keeps its array while the lane does not change (the conversion\n * caches hand back the previous array), so only lanes still streaming are\n * read again.\n */\nconst transcriptDerivationCache = new WeakMap<readonly ThreadMessage[], TranscriptDerivation>();\n\nfunction deriveTranscript(transcript: readonly ThreadMessage[]): TranscriptDerivation {\n  if (transcript.length === 0) return EMPTY_TRANSCRIPT_DERIVATION;\n  const cached = transcriptDerivationCache.get(transcript);\n  if (cached !== undefined) return cached;\n  let currentText = '';\n  let model: string | undefined;\n  let lastToolCall: LangChainToolCall | undefined;\n  let toolCallCount = 0;\n  let todos: Todo[] | undefined;\n  for (const message of transcript) {\n    if (message.role !== 'assistant') continue;\n    // A joined turn's `metadata.custom` merges its steps' stamps, the later\n    // step's winning (`joinExternalMessages`), so this is the newest stamp.\n    const turnModel: unknown = message.metadata?.custom?.model;\n    if (typeof turnModel === 'string' && turnModel) model = turnModel;\n    for (const part of message.content) {\n      if (part.type === 'text') {\n        if (part.text) currentText = part.text;\n        continue;\n      }\n      if (part.type !== 'tool-call') continue;\n      toolCallCount += 1;\n      lastToolCall = { id: part.toolCallId, name: part.toolName, args: part.args };\n      if (part.toolName !== 'write_todos') continue;\n      const list: unknown = part.args.todos;\n      if (Array.isArray(list)) todos = list as Todo[];\n    }\n  }\n  const derivation: TranscriptDerivation = {\n    currentText,\n    model,\n    lastToolCall,\n    toolCallCount,\n    todos,\n  };\n  transcriptDerivationCache.set(transcript, derivation);\n  return derivation;\n}\n\nconst NO_TRANSCRIPT: readonly ThreadMessage[] = [];\n\n/**\n * The lane of one `task` tool-call part. `toolMessage` is the raw ToolMessage\n * answering it, which carries the wire's cut marker for a running lane.\n */\nfunction taskSubagent(\n  part: ToolCallMessagePart,\n  toolMessage: LangChainMessage | undefined\n): SubagentDiscoverySnapshot {\n  const args: Readonly<Record<string, unknown>> = part.args;\n  const transcript = part.messages ?? NO_TRANSCRIPT;\n  const derived = deriveTranscript(transcript);\n  const messageCount = nestedMessagesFromArtifact(part.artifact).length;\n  const lane = readTruncatedLane(toolMessage);\n  const todos = nestedTodosFromArtifact(part.artifact);\n  const status: SubagentStatus =\n    part.result === undefined\n      ? 'queued'\n      : part.isPreliminary === true\n        ? 'running'\n        : part.isError === true\n          ? 'error'\n          : 'complete';\n  const usage = laneTokenUsage(\n    toolMessage,\n    transcriptStepUsage(transcript),\n    status,\n    lane !== null && lane.messages > messageCount\n  );\n  return {\n    id: part.toolCallId,\n    name: subagentNameFromArgs(args),\n    description: typeof args.description === 'string' ? args.description : '',\n    status,\n    ...(part.result !== undefined && { output: getMessageText({ content: part.result }) }),\n    toolCallCount: Math.max(derived.toolCallCount, lane?.toolCalls ?? 0),\n    messages: transcript,\n    messageCount,\n    ...(lane !== null && { omittedMessageCount: Math.max(0, lane.messages - messageCount) }),\n    ...(typeof toolMessage?.id === 'string' && {\n      source: {\n        messageId: toolMessage.id,\n        transcript: withRepeatedResult(nestedMessagesFromArtifact(part.artifact), part.result),\n        ...(lane !== null && { truncated: lane }),\n      },\n    }),\n    ...(todos !== undefined && { todos }),\n    ...(derived.lastToolCall !== undefined && { lastToolCall: derived.lastToolCall }),\n    currentText: derived.currentText,\n    ...(derived.model !== undefined && { model: derived.model }),\n    ...(usage !== undefined && { usage }),\n  };\n}\n\n/** The raw ToolMessage answering each tool call of a converted turn, from the sources bound to it. */\nfunction toolMessagesOfTurn(message: ThreadMessage): Map<string, LangChainMessage> {\n  const byCall = new Map<string, LangChainMessage>();\n  for (const source of getExternalStoreMessages<LangChainMessage>(message)) {\n    if (source.type === 'tool') byCall.set(source.tool_call_id, source);\n  }\n  return byCall;\n}\n\n/**\n * Per-part lane cache: a re-converted turn keeps the part object of every call\n * whose ToolMessage did not change (the conversion cache's `keepUnchangedParts`),\n * so a streaming lane re-derives only itself.\n */\nconst taskSubagentByPart = new WeakMap<ToolCallMessagePart, SubagentDiscoverySnapshot>();\nconst taskSubagentsByTurn = new WeakMap<ThreadMessage, ReadonlyMap<string, SubagentDiscoverySnapshot>>();\n\n/**\n * The lane of every `task` call in one converted turn (a `ThreadMessage`, or the\n * message state assistant-ui publishes for it), keyed by tool-call id in call\n * order. Memoized per turn and per part.\n */\nexport function taskSubagentsOfTurn(\n  message: ThreadMessage\n): ReadonlyMap<string, SubagentDiscoverySnapshot> {\n  const cached = taskSubagentsByTurn.get(message);\n  if (cached !== undefined) return cached;\n  const lanes = new Map<string, SubagentDiscoverySnapshot>();\n  if (message.role === 'assistant') {\n    let toolMessages: Map<string, LangChainMessage> | null = null;\n    for (const part of message.content) {\n      if (part.type !== 'tool-call' || part.toolName !== TASK_TOOL_NAME) continue;\n      let lane = taskSubagentByPart.get(part);\n      if (lane === undefined) {\n        toolMessages ??= toolMessagesOfTurn(message);\n        lane = taskSubagent(part, toolMessages.get(part.toolCallId));\n        taskSubagentByPart.set(part, lane);\n      }\n      lanes.set(part.toolCallId, lane);\n    }\n  }\n  taskSubagentsByTurn.set(message, lanes);\n  return lanes;\n}\n\n/** The lane of every `task` call in a converted thread, in transcript order. */\nexport function taskSubagentsOfThread(\n  messages: readonly ThreadMessage[]\n): SubagentDiscoverySnapshot[] {\n  return messages.flatMap((message) => [...taskSubagentsOfTurn(message).values()]);\n}\n\n/**\n * Point a lane at an in-eval dispatch's live transcript, converted into a nested\n * thread, with the live fields it derives. Never regresses a known tool-call\n * count: a countless later event must not reset a lane to \"0 tool calls\".\n */\nfunction applyLaneTranscript(\n  snap: SubagentDiscoverySnapshot,\n  transcript: readonly LangChainMessage[]\n): void {\n  snap.messages = convertSubagentTranscript(transcript, snap.status === 'running');\n  snap.messageCount = transcript.length;\n  const derived = deriveTranscript(snap.messages);\n  if (derived.currentText) snap.currentText = derived.currentText;\n  if (derived.model) snap.model = derived.model;\n  if (derived.lastToolCall) snap.lastToolCall = derived.lastToolCall;\n  snap.toolCallCount = Math.max(snap.toolCallCount, derived.toolCallCount);\n  // An in-eval lane has no artifact todos channel: recover the plan from its\n  // `write_todos` calls.\n  snap.todos = snap.todos ?? derived.todos;\n}\n\n/**\n * The lanes of in-eval dispatches, from two sources: the *persisted* summaries\n * each finished `eval` ToolMessage carries in `artifact.ptc_subagents`\n * (terminal truth; the only source after a session reopen), then the *live*\n * `ptc_subagents` state channel (`ptcSubagents`) for dispatches still\n * streaming. A live entry never downgrades a terminal snapshot back to\n * `running` — a stale lifecycle entry whose terminal event was lost must not\n * resurrect a perpetually-running lane the persisted summary already settled.\n * A lane whose steps no longer ride but whose subagent checkpoint namespace is\n * recorded (`ns`) is `checkpointed`, and `history/lane {lane}` pages its\n * steps: a live entry a later run stripped to its summary, or a persisted\n * summary with no live entry (the registry died with the activation that\n * streamed it). A live entry speaks for its lane over the summary.\n */\nexport function deriveEvalSubagents(\n  messages: readonly LangChainMessage[],\n  ptcSubagents?: Record<string, PtcSubagentEntry>\n): Map<string, SubagentDiscoverySnapshot> {\n  const byDispatchId = new Map<string, SubagentDiscoverySnapshot>();\n  // Persisted in-eval dispatch summaries (terminal truth; survives reopen).\n  for (const m of messages) {\n    if (m.type !== 'tool' || m.name !== EVAL_TOOL_NAME) continue;\n    for (const entry of ptcSubagentsFromArtifact(m.artifact)) {\n      mergePtcSubagentEntry(byDispatchId, entry, {\n        // The eval ended when these summaries were written, so any lane the\n        // backend could not settle is a cancelled dispatch, never \"running\".\n        status: entry.status === 'complete' ? 'complete' : 'error',\n        fallbackEvalId: m.tool_call_id,\n      });\n      noteCheckpointedLane(byDispatchId.get(entry.id), entry);\n    }\n  }\n  // Live lifecycle entries (the only signal while an eval is still streaming).\n  if (ptcSubagents) {\n    for (const entry of Object.values(ptcSubagents)) {\n      if (!entry || typeof entry !== 'object' || typeof entry.id !== 'string' || !entry.id) {\n        continue;\n      }\n      // This activation's registry speaks for the lane: the steps it streams,\n      // else its own namespace, else nothing to page.\n      const existing = byDispatchId.get(entry.id);\n      if (existing?.source?.checkpointed === true) existing.source = undefined;\n      mergePtcSubagentEntry(byDispatchId, entry, {\n        status:\n          entry.status === 'complete'\n            ? 'complete'\n            : entry.status === 'error'\n              ? 'error'\n              : entry.status === 'queued'\n                ? 'queued'\n                : 'running',\n      });\n      noteCheckpointedLane(byDispatchId.get(entry.id), entry);\n    }\n  }\n  return byDispatchId;\n}\n\n/** Lifecycle progression order — a merge may only move a lane forward. */\nfunction subagentStatusRank(status: SubagentStatus): number {\n  if (status === 'queued') return 0;\n  if (status === 'running') return 1;\n  return 2;\n}\n\nfunction mergePtcSubagentEntry(\n  byDispatchId: Map<string, SubagentDiscoverySnapshot>,\n  entry: PtcSubagentEntry,\n  options: { status: SubagentStatus; fallbackEvalId?: string }\n): void {\n  const { status, fallbackEvalId } = options;\n  const existing = byDispatchId.get(entry.id);\n  if (existing) {\n    // A lane only ever moves FORWARD (queued → running → terminal): a stale\n    // entry whose later event was lost must not resurrect a running lane to\n    // queued or a finished lane to running — and a settled terminal outcome\n    // never flips to the other terminal (first settled source wins).\n    if (\n      status === existing.status ||\n      subagentStatusRank(status) > subagentStatusRank(existing.status)\n    ) {\n      existing.status = status;\n    }\n    const evalId = entry.eval_id ?? fallbackEvalId;\n    if (evalId) existing.evalId = evalId;\n    if (typeof entry.duration_ms === 'number') existing.durationMs = entry.duration_ms;\n    // A count only arrives on terminal events; never let a countless later\n    // event (or an older backend) regress a known count.\n    if (typeof entry.tool_call_count === 'number') {\n      existing.toolCallCount = Math.max(existing.toolCallCount, entry.tool_call_count);\n    }\n    if (Array.isArray(entry.messages) && entry.messages.length > 0) {\n      applyLaneTranscript(existing, entry.messages);\n    }\n    applyLaneCut(existing, entry);\n    applyLaneUsage(existing, entry);\n    // Prefer the real output (Athena's in-eval output bridge); fall back to the\n    // error string only when no (non-empty) output was captured. Same\n    // empty-string/nullish rule as the create branch below.\n    if (entry.output) existing.output = entry.output;\n    else if (entry.error && !existing.output) existing.output = entry.error;\n    return;\n  }\n  // `||` (not `??`) so an empty-string output falls back to the error, matching\n  // the merge branch's truthy check above.\n  const initialOutput = entry.output || entry.error;\n  const evalId = entry.eval_id ?? fallbackEvalId;\n  const created: SubagentDiscoverySnapshot = {\n    id: entry.id,\n    name: String(entry.subagent_type ?? 'subagent'),\n    description: entry.label ?? entry.description ?? '',\n    status,\n    toolCallCount: typeof entry.tool_call_count === 'number' ? entry.tool_call_count : 0,\n    messages: NO_TRANSCRIPT,\n    messageCount: 0,\n    currentText: '',\n    ...(evalId ? { evalId } : {}),\n    ...(typeof entry.duration_ms === 'number' ? { durationMs: entry.duration_ms } : {}),\n    ...(initialOutput ? { output: initialOutput } : {}),\n  };\n  if (Array.isArray(entry.messages) && entry.messages.length > 0) {\n    applyLaneTranscript(created, entry.messages);\n  }\n  applyLaneCut(created, entry);\n  applyLaneUsage(created, entry);\n  byDispatchId.set(entry.id, created);\n}\n\n/**\n * Where an in-eval dispatch's streamed steps ride, and what the wire left off\n * them, read off its entry's cut marker (`DEEP_AGENT_TRUNCATED_LANE_KEY`) as a\n * `task` card's is: the steps left off, and the whole lane's tool calls.\n */\nfunction applyLaneCut(snap: SubagentDiscoverySnapshot, entry: PtcSubagentEntry): void {\n  const lane = readTruncatedLane(entry);\n  if (Array.isArray(entry.messages) && entry.messages.length > 0) {\n    snap.source = {\n      lane: entry.id,\n      transcript: entry.messages,\n      ...(lane !== null && { truncated: lane }),\n    };\n  }\n  if (lane === null) return;\n  snap.omittedMessageCount = Math.max(0, lane.messages - snap.messageCount);\n  snap.toolCallCount = Math.max(snap.toolCallCount, lane.toolCalls);\n}\n\nconst NO_LANE_STEPS: readonly LangChainMessage[] = [];\n\n/**\n * An entry that recorded its subagent's checkpoint namespace (`ns`, a registry\n * entry or the summary an eval persisted, since agora writes it) pages its\n * lane from that checkpoint when no streamed steps carry it.\n */\nfunction noteCheckpointedLane(\n  snap: SubagentDiscoverySnapshot | undefined,\n  entry: PtcSubagentEntry\n): void {\n  if (snap === undefined || snap.source !== undefined) return;\n  if (typeof entry.ns !== 'string' || !entry.ns) return;\n  snap.source = { lane: entry.id, transcript: NO_LANE_STEPS, checkpointed: true };\n}\n\n/**\n * An in-eval lane's token use, from its entry's host total or the native steps\n * of its live transcript. A merge that brings neither keeps what the lane has.\n */\nfunction applyLaneUsage(snap: SubagentDiscoverySnapshot, entry: PtcSubagentEntry): void {\n  const usage = laneTokenUsage(\n    entry,\n    transcriptStepUsage(snap.messages),\n    snap.status,\n    (snap.omittedMessageCount ?? 0) > 0\n  );\n  if (usage !== undefined) snap.usage = usage;\n}\n\n/**\n * The first call of a nested thread with one of `toolCallIds`: the calls a\n * subagent made are the tool-call parts of its transcript, ids included.\n */\nfunction findToolCall({\n  messages,\n  toolCallIds,\n}: {\n  messages: readonly ThreadMessage[] | undefined;\n  toolCallIds: ReadonlySet<string>;\n}): ToolCallMessagePart | undefined {\n  if (messages === undefined) return undefined;\n  for (const message of messages) {\n    if (message.role !== 'assistant') continue;\n    for (const part of message.content) {\n      if (part.type === 'tool-call' && toolCallIds.has(part.toolCallId)) return part;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Whether a subagent lane waits on a person's approval, given the gated calls\n * still waiting on one (`toolCallIdsAwaitingApproval`): its own dispatch is the\n * gated call (a per-dispatch `task` gate), or a call it made is (a gated tool\n * raised inside the delegated subagent). The approval names the gated call's\n * `tool_call_id` and never the lane, and a lane's transcript carries the calls\n * it made with their ids, so the call id is the join. A settled lane waits on\n * nobody.\n */\nexport function subagentAwaitingApproval({\n  lane,\n  toolCallIds,\n}: {\n  lane: Pick<SubagentDiscoverySnapshot, 'id' | 'status' | 'messages'>;\n  /** The gated calls still waiting on a decision (`toolCallIdsAwaitingApproval`). */\n  toolCallIds: ReadonlySet<string>;\n}): boolean {\n  if (toolCallIds.size === 0 || isTerminalSubagentStatus(lane.status)) return false;\n  return (\n    toolCallIds.has(lane.id) ||\n    findToolCall({ messages: lane.messages, toolCallIds }) !== undefined\n  );\n}\n\n/**\n * The call a subagent made that waits on a person's approval (a gated tool\n * raised inside the delegated subagent), read off its transcript — what the\n * lane card names while it waits. `undefined` when the lane made none, which\n * includes a lane whose own dispatch is the gated call.\n */\nexport function subagentToolCallAwaitingApproval({\n  lane,\n  toolCallIds,\n}: {\n  lane: Pick<SubagentDiscoverySnapshot, 'status' | 'messages'>;\n  /** The gated calls still waiting on a decision (`toolCallIdsAwaitingApproval`). */\n  toolCallIds: ReadonlySet<string>;\n}): LangChainToolCall | undefined {\n  if (toolCallIds.size === 0 || isTerminalSubagentStatus(lane.status)) return undefined;\n  const part = findToolCall({ messages: lane.messages, toolCallIds });\n  return part === undefined\n    ? undefined\n    : { id: part.toolCallId, name: part.toolName, args: part.args };\n}\n\n/**\n * The calls of one converted turn that wait on a person's approval, in turn\n * order: a gated call of the turn itself, or a `task` call not yet settled\n * (no result, or the running placeholder) whose lane holds a gated call — the\n * steps the turn's step list reads as waiting rather than running or done.\n */\nexport function turnToolCallsAwaitingApproval({\n  message,\n  toolCallIds,\n}: {\n  message: ThreadMessage;\n  /** The gated calls still waiting on a decision (`toolCallIdsAwaitingApproval`). */\n  toolCallIds: ReadonlySet<string>;\n}): string[] {\n  if (toolCallIds.size === 0 || message.role !== 'assistant') return [];\n  const ids: string[] = [];\n  for (const part of message.content) {\n    if (part.type !== 'tool-call') continue;\n    if (toolCallIds.has(part.toolCallId)) {\n      ids.push(part.toolCallId);\n      continue;\n    }\n    if (part.toolName !== TASK_TOOL_NAME) continue;\n    const settled = part.result !== undefined && part.isPreliminary !== true;\n    if (!settled && findToolCall({ messages: part.messages, toolCallIds }) !== undefined) {\n      ids.push(part.toolCallId);\n    }\n  }\n  return ids;\n}\n\nconst NO_WAITING_TOOL_CALLS: ReadonlySet<string> = new Set();\n/** Joins call ids into one selector value; an id never holds it. */\nconst TOOL_CALL_ID_SEPARATOR = '\\n';\n\n/**\n * {@link turnToolCallsAwaitingApproval} for the message in scope: what a\n * turn's step list takes as `waitingToolCallIds`, given the run's waiting\n * calls (`toolCallIdsAwaitingApproval`). Selected as a joined string, so a\n * streamed token re-renders the caller only when the waiting steps change, and\n * the set keeps its identity while they do not. Olympus's activity card and\n * the SDK chat's turns both read it.\n */\nexport function useTurnToolCallsAwaitingApproval(\n  toolCallIds: ReadonlySet<string>\n): ReadonlySet<string> {\n  const key = useAuiState((s) =>\n    toolCallIds.size === 0\n      ? ''\n      : turnToolCallsAwaitingApproval({ message: s.message, toolCallIds }).join(\n          TOOL_CALL_ID_SEPARATOR\n        )\n  );\n  return useMemo(\n    () => (key === '' ? NO_WAITING_TOOL_CALLS : new Set(key.split(TOOL_CALL_ID_SEPARATOR))),\n    [key]\n  );\n}\n\n/** Result text shown for a dispatch whose owning run ended before it finished. */\nexport const ORPHANED_SUBAGENT_OUTPUT =\n  'Interrupted — the run that dispatched this subagent ended before it finished.';\n\n/**\n * Settle snapshots orphaned by their dispatching context: once the owner (e.g.\n * the `eval` tool call whose in-eval `task()` issued them) is itself terminal,\n * nothing can ever deliver a `complete`/`error` lifecycle event for a lane still\n * `queued`/`running` — the dispatch coroutines were cancelled with the eval. Those\n * lanes are coerced to `error` with an interruption message so the UI can't show\n * perpetual \"Running · no activity\" ghosts. Returns the input array unchanged\n * (same reference) when there is nothing to settle.\n */\nexport function finalizeOrphanedSubagents(\n  snapshots: readonly SubagentDiscoverySnapshot[],\n  ownerTerminal: boolean\n): readonly SubagentDiscoverySnapshot[] {\n  if (!ownerTerminal || snapshots.every((s) => isTerminalSubagentStatus(s.status))) {\n    return snapshots;\n  }\n  return snapshots.map((s) =>\n    isTerminalSubagentStatus(s.status)\n      ? s\n      : { ...s, status: 'error', output: s.output || ORPHANED_SUBAGENT_OUTPUT }\n  );\n}\n\n/**\n * The `task` tool calls sharing `toolCallId`'s parent AI message — the parallel\n * fan-out siblings, in declaration order. Parallel `task` calls always live on ONE\n * AI message's `tool_calls`, so \"same parent message\" IS the parallelism boundary;\n * sequential delegations sit on separate AI messages and form singleton groups.\n * The FIRST sibling is the group's `anchorId`: its tool-part render draws the whole\n * side-by-side group and the other siblings render nothing, keeping the layout\n * change fully inside the `task` tool UI. Falls back to a singleton group when the\n * parent AI message isn't among `messages` (a turn's bound sources, or a raw\n * transcript).\n */\nexport interface TaskSiblingGroup {\n  /** Sibling `task` tool-call ids in declaration order. */\n  ids: string[];\n  /** The first sibling — the one tool-part render that owns the group's UI. */\n  anchorId: string;\n}\n\nexport function taskSiblingGroup(\n  messages: readonly LangChainMessage[],\n  toolCallId: string\n): TaskSiblingGroup {\n  for (const m of messages) {\n    if (m.type !== 'ai' || !m.tool_calls) continue;\n    if (!m.tool_calls.some((tc) => tc.id === toolCallId)) continue;\n    const ids = m.tool_calls\n      .filter((tc) => tc.name === TASK_TOOL_NAME && tc.id)\n      .map((tc) => tc.id as string);\n    if (ids.length > 0) return { ids, anchorId: ids[0] ?? toolCallId };\n    break;\n  }\n  return { ids: [toolCallId], anchorId: toolCallId };\n}\n"],"names":[],"mappings":"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"}

package/dist/agent-runtime/src/subscription-wake-event.d.ts

@@ -0,0 +1,111 @@
+/**
+ * The asset-subscription delivery that woke a conversation, read from the user
+ * turn the delivery started.
+ *
+ * When an asset subscription fires, agora starts a turn on its conversation
+ * with the delivery text the model reads (`render_delivery`), and stamps the
+ * facts a person needs beside it under `athena_subscription_event` in the
+ * message metadata — server-authoritative like `author`, never sent to the
+ * model. The shipped converter exposes that metadata as the thread message's
+ * `metadata.custom`, so a surface renders the turn as a compact marker
+ * ("Brendon Geils set B4 to Target") instead of a user bubble quoting the
+ * delivery text. Olympus draws the same facts as its event card with citation
+ * chips; this is the text every other surface shows. The envelope is for
+ * RENDERING only: a surface that ignores it degrades to a plain bubble, never
+ * to a lost instruction.
+ */
+/** `metadata.custom` key agora stamps on a subscription's delivery turn. */
+export declare const SUBSCRIPTION_EVENT_KEY = "athena_subscription_event";
+/** A changed cell or range, and its value now when agora read it. */
+export interface SubscriptionWakeChange {
+    /** Where: "B4", "Sheet1!B2:B11", "page 5"; `null` for a place the marker has no words for. */
+    place: string | null;
+    /** The value now; `null` when agora read none (a busy run's tray, a failed or capped read). */
+    value: string | null;
+}
+export interface SubscriptionWakeEvent {
+    subscriptionId: string;
+    /** `event`: something happened on an asset. `schedule`: a check-in the person set. */
+    kind: 'event' | 'schedule';
+    assetTitle: string | null;
+    eventTypes: string[];
+    eventCount: number | null;
+    /** Who did it, in words: their name, "You", "An agent", "Athena", "Someone", with others counted. */
+    actor: string;
+    changes: SubscriptionWakeChange[];
+    /** Changed places past the ones `changes` lists (agora caps the list): counted, never named. */
+    moreChanges: number;
+    /** The ranges the subscription names ("B2:B11"); empty for the whole asset. */
+    subscribed: string[];
+    /** Where a comment event's thread sits, when its anchor names a place. */
+    commentPlace: string | null;
+    /** Whether a comment-resolved event resolved (true) or reopened (false); `null` when unsaid. */
+    commentResolved: boolean | null;
+    /** When the person set a scheduled check-in. */
+    scheduleSetAt: string | null;
+    /** A scheduled check-in's own words. */
+    note: string | null;
+    runsLeft: number | null;
+    deliveredAt: string | null;
+    /** A GitHub event's subject (the envelope's `connector`); `null` for any other event. */
+    github: SubscriptionWakeGithub | null;
+}
+/** A GitHub event's subject as agora's chip carries it: ids and a state word, never text. */
+export interface SubscriptionWakeGithub {
+    /** `owner/repo`. */
+    repo: string | null;
+    /** The pull request or issue; `null` when the event names none (a check on no pull request). */
+    number: number | null;
+    /** `merged` or `closed`, a review's state, or a check's conclusion, lowercased. */
+    state: string | null;
+}
+/**
+ * Where a reference-standard anchor in agora's wire form points, in words:
+ * a range or cell (with its sheet when the anchor names one), a page, a
+ * slide; `null` for any other place.
+ */
+export declare function subscriptionPlaceWords(anchor: unknown): string | null;
+/**
+ * The GitHub subject of an envelope's `connector`, or `null` when the
+ * connector is absent or another provider's (Slack).
+ */
+export declare function subscriptionWakeGithub(connector: unknown): SubscriptionWakeGithub | null;
+/**
+ * The delivery behind a thread message's `metadata.custom`, or `undefined`
+ * when the message is not a subscription's delivery (or carries no
+ * subscription id). Every other field is read leniently: a field of the wrong
+ * shape reads as absent.
+ */
+export declare function readSubscriptionWakeEvent(custom: Record<string, unknown> | null | undefined): SubscriptionWakeEvent | undefined;
+/**
+ * Whether a thread message is a subscription's delivery. Returns a primitive,
+ * so it is safe as a `useAuiState` selector.
+ */
+export declare function isSubscriptionWakeMessage(custom: Record<string, unknown> | null | undefined): boolean;
+/**
+ * The words for a delivery whose events are all GitHub's, from its first
+ * event (the one the chip describes; the detail line counts the rest), or
+ * `null` for any other delivery. Olympus's event card says the same.
+ */
+export declare function githubSubscriptionHeadline({ eventTypes, github, }: {
+    eventTypes: readonly string[];
+    github: SubscriptionWakeGithub | null;
+}): string | null;
+/**
+ * The marker's line: who did what, where — "Brendon Geils set B4 to Target",
+ * "Brendon Geils changed B4" when agora read no value, "Ana Lopez commented
+ * on B7", "Brendon Geils set B4 to Target and commented on B7" for a batch
+ * that carried both — for GitHub, what happened to the pull request ("A
+ * check failed on #47506") — or, for a schedule, "Scheduled check-in you set
+ * on Oct 8" (`now` decides "today" and "yesterday").
+ */
+export declare function subscriptionWakeHeadline({ event, now, }: {
+    event: SubscriptionWakeEvent;
+    now?: Date;
+}): string;
+/**
+ * The line under it: "Series A Investors · subscribed to B2:B11 · 99 runs
+ * left · 3 events" for an asset event; a check-in's note for a schedule.
+ * `null` when there is nothing to add.
+ */
+export declare function subscriptionWakeDetail(event: SubscriptionWakeEvent): string | null;

package/dist/agent-runtime/src/thread-extras.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The statewire hooks read the NEAREST aui thread's extras and throw when those
+ * aren't statewire extras — which is the case inside nested read-only runtimes
+ * (e.g. a transcript drawer) and on legacy (non-statewire) threads. Duck-type
+ * the pieces the statewire components actually consume; a wider shape check
+ * would silently hide live affordances if the library ever drops an unrelated
+ * field.
+ */
+export declare function hasStatewireThreadExtras(extras: unknown): boolean;
+export interface StatewireFailedActions {
+    retryFailed: (messageId: string) => void;
+    discardFailed: (messageId: string) => void;
+}
+/** One projected failed run send: the message id plus the failure that
+ * retained it (`runs.failed` entry, structurally). */
+export interface StatewireFailedSendEntry {
+    id: string;
+    sendFailure: {
+        fate: string;
+        /**
+         * Set on an `aborted` send that was never attempted because an earlier
+         * send in the same detach batch WAS attempted and settled `lost`: the
+         * library cannot know whether that predecessor ran, so the successor
+         * must not be re-dispatched ahead of it (`StatewireClient.SendFailure`).
+         */
+        predecessorLost?: boolean;
+    };
+}
+/** The failed-send lane surface the send-recovery controller consumes. */
+export interface StatewireFailedSendLane {
+    failed: readonly StatewireFailedSendEntry[];
+    /** Re-dispatches the entry against the current thread — same message id,
+     * re-anchored — and removes it from the lane. Throws for unknown ids. */
+    retryFailed: (messageId: string) => void;
+}
+/**
+ * The failed-send lane off a statewire thread's extras, or `null` when the
+ * extras are not a statewire thread's (nested read-only runtimes, legacy
+ * threads) — same duck-typing posture as {@link hasStatewireThreadExtras}.
+ */
+export declare function readStatewireFailedSendLane(extras: unknown): StatewireFailedSendLane | null;
+/** The failed-send lane actions off a statewire thread's extras, or throw. */
+export declare function requireStatewireFailedActions(extras: unknown): StatewireFailedActions;

package/dist/agent-runtime/src/thread-handoff.d.ts

@@ -0,0 +1,364 @@
+import { z } from 'zod';
+export declare const HANDOFF_DESTINATIONS: readonly ['chrome', 'mobile', 'word', 'powerpoint', 'excel'];
+export type HandoffDestination = (typeof HANDOFF_DESTINATIONS)[number];
+export declare const OFFICE_HANDOFF_DESTINATIONS: readonly ['word', 'powerpoint', 'excel'];
+export type OfficeHandoffDestination = (typeof OFFICE_HANDOFF_DESTINATIONS)[number];
+/** Destinations agora brokers; Chrome is launched page-side by the extension. */
+export declare const SERVER_HANDOFF_DESTINATIONS: readonly ["mobile", "word", "powerpoint", "excel"];
+export type ServerHandoffDestination = (typeof SERVER_HANDOFF_DESTINATIONS)[number];
+export type HandoffSource = 'spaces' | 'chrome' | 'mobile' | 'word' | 'powerpoint' | 'excel';
+export declare const handoffEnvironmentSchema: z.ZodEnum<{
+    localhost: "localhost";
+    production: "production";
+    staging: "staging";
+}>;
+export type HandoffEnvironment = z.infer<typeof handoffEnvironmentSchema>;
+export declare const handoffStateSchema: z.ZodEnum<{
+    acknowledged: "acknowledged";
+    claimed: "claimed";
+    failed: "failed";
+    issued: "issued";
+    launched: "launched";
+}>;
+export type HandoffState = z.infer<typeof handoffStateSchema>;
+export declare const handoffReadinessStateSchema: z.ZodEnum<{
+    not_registered: "not_registered";
+    registered: "registered";
+    stale: "stale";
+    unknown: "unknown";
+    unsupported: "unsupported";
+}>;
+export type HandoffReadinessState = z.infer<typeof handoffReadinessStateSchema>;
+export declare const destinationReadinessSchema: z.ZodObject<{
+    destination: z.ZodEnum<{
+        chrome: "chrome";
+        excel: "excel";
+        mobile: "mobile";
+        powerpoint: "powerpoint";
+        word: "word";
+    }>;
+    state: z.ZodEnum<{
+        not_registered: "not_registered";
+        registered: "registered";
+        stale: "stale";
+        unknown: "unknown";
+        unsupported: "unsupported";
+    }>;
+    last_seen_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    marketplace_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type DestinationReadiness = z.infer<typeof destinationReadinessSchema>;
+export declare const handoffReadinessResponseSchema: z.ZodObject<{
+    environment: z.ZodEnum<{
+        localhost: "localhost";
+        production: "production";
+        staging: "staging";
+    }>;
+    destinations: z.ZodArray<z.ZodObject<{
+        destination: z.ZodEnum<{
+            chrome: "chrome";
+            excel: "excel";
+            mobile: "mobile";
+            powerpoint: "powerpoint";
+            word: "word";
+        }>;
+        state: z.ZodEnum<{
+            not_registered: "not_registered";
+            registered: "registered";
+            stale: "stale";
+            unknown: "unknown";
+            unsupported: "unsupported";
+        }>;
+        last_seen_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        marketplace_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type HandoffReadinessResponse = z.infer<typeof handoffReadinessResponseSchema>;
+export declare const threadHandoffViewSchema: z.ZodObject<{
+    handoff_id: z.ZodString;
+    thread_id: z.ZodString;
+    session_asset_id: z.ZodNullable<z.ZodString>;
+    source: z.ZodString;
+    destination: z.ZodEnum<{
+        chrome: "chrome";
+        excel: "excel";
+        mobile: "mobile";
+        powerpoint: "powerpoint";
+        word: "word";
+    }>;
+    environment: z.ZodEnum<{
+        localhost: "localhost";
+        production: "production";
+        staging: "staging";
+    }>;
+    state: z.ZodEnum<{
+        acknowledged: "acknowledged";
+        claimed: "claimed";
+        failed: "failed";
+        issued: "issued";
+        launched: "launched";
+    }>;
+    issued_at: z.ZodString;
+    expires_at: z.ZodString;
+    claimed_at: z.ZodNullable<z.ZodString>;
+    acknowledged_at: z.ZodNullable<z.ZodString>;
+    failure_reason: z.ZodNullable<z.ZodString>;
+    push_delivered: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ThreadHandoffView = z.infer<typeof threadHandoffViewSchema>;
+export declare const mobileHandoffLaunchSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"mobile">;
+    push_attempted: z.ZodBoolean;
+    push_delivered: z.ZodBoolean;
+    device_count: z.ZodNumber;
+    link_url: z.ZodString;
+    scheme_url: z.ZodString;
+}, z.core.$strip>;
+export type MobileHandoffLaunch = z.infer<typeof mobileHandoffLaunchSchema>;
+export declare const officeHandoffLaunchSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"office">;
+    host: z.ZodEnum<{
+        excel: "excel";
+        powerpoint: "powerpoint";
+        word: "word";
+    }>;
+    desktop_url: z.ZodString;
+    template_url: z.ZodString;
+    web_url: z.ZodString;
+    marketplace_url: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type OfficeHandoffLaunch = z.infer<typeof officeHandoffLaunchSchema>;
+export declare const chromeHandoffLaunchSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"chrome">;
+}, z.core.$strip>;
+export declare const handoffLaunchSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"mobile">;
+    push_attempted: z.ZodBoolean;
+    push_delivered: z.ZodBoolean;
+    device_count: z.ZodNumber;
+    link_url: z.ZodString;
+    scheme_url: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"office">;
+    host: z.ZodEnum<{
+        excel: "excel";
+        powerpoint: "powerpoint";
+        word: "word";
+    }>;
+    desktop_url: z.ZodString;
+    template_url: z.ZodString;
+    web_url: z.ZodString;
+    marketplace_url: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"chrome">;
+}, z.core.$strip>], "kind">;
+export type HandoffLaunch = z.infer<typeof handoffLaunchSchema>;
+export declare const createThreadHandoffResponseSchema: z.ZodObject<{
+    handoff: z.ZodObject<{
+        handoff_id: z.ZodString;
+        thread_id: z.ZodString;
+        session_asset_id: z.ZodNullable<z.ZodString>;
+        source: z.ZodString;
+        destination: z.ZodEnum<{
+            chrome: "chrome";
+            excel: "excel";
+            mobile: "mobile";
+            powerpoint: "powerpoint";
+            word: "word";
+        }>;
+        environment: z.ZodEnum<{
+            localhost: "localhost";
+            production: "production";
+            staging: "staging";
+        }>;
+        state: z.ZodEnum<{
+            acknowledged: "acknowledged";
+            claimed: "claimed";
+            failed: "failed";
+            issued: "issued";
+            launched: "launched";
+        }>;
+        issued_at: z.ZodString;
+        expires_at: z.ZodString;
+        claimed_at: z.ZodNullable<z.ZodString>;
+        acknowledged_at: z.ZodNullable<z.ZodString>;
+        failure_reason: z.ZodNullable<z.ZodString>;
+        push_delivered: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strip>;
+    launch: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"mobile">;
+        push_attempted: z.ZodBoolean;
+        push_delivered: z.ZodBoolean;
+        device_count: z.ZodNumber;
+        link_url: z.ZodString;
+        scheme_url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"office">;
+        host: z.ZodEnum<{
+            excel: "excel";
+            powerpoint: "powerpoint";
+            word: "word";
+        }>;
+        desktop_url: z.ZodString;
+        template_url: z.ZodString;
+        web_url: z.ZodString;
+        marketplace_url: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"chrome">;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+export type CreateThreadHandoffResponse = z.infer<typeof createThreadHandoffResponseSchema>;
+export interface CreateThreadHandoffInput {
+    threadId: string;
+    destination: ServerHandoffDestination;
+    source: HandoffSource;
+}
+/**
+ * Surface-specific HTTP adapter. Olympus binds it to `apiClient`; the
+ * extension binds it to its authenticated fetch. Both must resolve (not
+ * reject) with parsed responses so the flow can attribute failures.
+ */
+export interface ThreadHandoffTransport {
+    getReadiness: (options: {
+        signal?: AbortSignal;
+    }) => Promise<HandoffReadinessResponse>;
+    createHandoff: (input: CreateThreadHandoffInput) => Promise<CreateThreadHandoffResponse>;
+    getHandoff: (options: {
+        handoffId: string;
+        signal?: AbortSignal;
+    }) => Promise<ThreadHandoffView>;
+}
+export declare const HANDOFF_DESTINATION_LABELS: Record<HandoffDestination, string>;
+export declare const isOfficeHandoffDestination: (destination: HandoffDestination) => destination is OfficeHandoffDestination;
+export declare const isServerHandoffDestination: (destination: HandoffDestination) => destination is ServerHandoffDestination;
+/** Index a readiness response by destination; missing rows read as `unknown`. */
+export declare const readinessByDestination: (response: HandoffReadinessResponse | null | undefined) => Record<HandoffDestination, DestinationReadiness>;
+/**
+ * How a mobile handoff should be presented before the phone answers.
+ *
+ * - `app`: a fresh push token exists — the phone gets a notification and the
+ *   QR is only offered as a secondary path.
+ * - `qr`: no usable device is known — lead with the QR / link.
+ */
+export type MobileLaunchMode = 'app' | 'qr';
+export declare const selectMobileLaunchMode: (readiness: DestinationReadiness | null | undefined) => MobileLaunchMode;
+/**
+ * What a "Continue in…" row should say for a destination given its readiness.
+ * Shared so Spaces and the extension render identical copy.
+ */
+export interface HandoffDestinationPresentation {
+    destination: HandoffDestination;
+    label: string;
+    /** Secondary line under the label; `null` when the row needs no caveat. */
+    detail: string | null;
+    /**
+     * `install` rows do not create a handoff — they point at install help;
+     * `unavailable` rows are disabled.
+     */
+    action: 'handoff' | 'install' | 'unavailable';
+}
+export declare const presentHandoffDestination: ({ destination, readiness, }: {
+    destination: HandoffDestination;
+    readiness: DestinationReadiness | null | undefined;
+}) => HandoffDestinationPresentation;
+/**
+ * QR symbol for a handoff link as a single SVG path in module units, so any
+ * surface can render `<svg viewBox="0 0 {size} {size}"><path d={path} /></svg>`
+ * without a canvas or an image request.
+ */
+export declare const buildHandoffQrSvg: ({ text }: {
+    text: string;
+}) => {
+    size: number;
+    path: string;
+};
+export type HandoffOutcome = {
+    status: 'acknowledged';
+    handoff: ThreadHandoffView;
+} | {
+    status: 'failed';
+    handoff: ThreadHandoffView | null;
+    reason: string;
+} | {
+    status: 'timeout';
+    handoff: ThreadHandoffView | null;
+} | {
+    status: 'cancelled';
+    handoff: ThreadHandoffView | null;
+};
+export declare const isTerminalHandoffState: (state: HandoffState) => boolean;
+export interface WaitForHandoffOutcomeOptions {
+    transport: Pick<ThreadHandoffTransport, 'getHandoff'>;
+    handoffId: string;
+    /** Wall-clock budget; mobile pushes typically land in seconds, Office launches in tens of seconds. */
+    timeoutMs: number;
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+    onUpdate?: (handoff: ThreadHandoffView) => void;
+    /** Injected for tests. */
+    now?: () => number;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+/**
+ * Poll one handoff until the destination acknowledges, the server marks it
+ * failed, the budget elapses, or the caller aborts. Each request is bound to
+ * the remaining budget so a stalled response cannot outlive the deadline.
+ * Retryable transport errors are retried within the budget; permanent ones
+ * (auth, wrong deployment, malformed payload) fail immediately with their
+ * actionable message. The last known view is reported.
+ */
+export declare function waitForHandoffOutcome({ transport, handoffId, timeoutMs, pollIntervalMs, signal, onUpdate, now, sleep, }: WaitForHandoffOutcomeOptions): Promise<HandoffOutcome>;
+/** Error raised by a transport when the server no longer knows the handoff (404). */
+export declare class HandoffGoneError extends Error {
+    constructor(handoffId: string);
+}
+export declare const isHandoffGoneError: (error: unknown) => error is HandoffGoneError;
+/**
+ * Transport failure that polling the same handoff can never recover from:
+ * the session is signed out, the token belongs to another deployment, the
+ * server rejected the request, or the payload did not match the schema.
+ */
+export declare class HandoffPermanentError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare const isHandoffPermanentError: (error: unknown) => error is HandoffPermanentError;
+export type HandoffTransportErrorKind = 'gone' | 'permanent' | 'retryable';
+/**
+ * Shared classification for both transports: only network failures and
+ * retryable server statuses keep the poll alive. Schema mismatches surface as
+ * `ZodError` from either adapter and are permanent.
+ */
+export declare const classifyHandoffTransportError: (error: unknown) => HandoffTransportErrorKind;
+/** 5xx, timeouts and rate limits may clear on the next poll; any other 4xx will not. */
+export declare const isRetryableHandoffHttpStatus: (status: number) => boolean;
+/**
+ * Map a non-2xx status to the transport error the poll loop understands.
+ * `detail` is the server's actionable message when it sent one.
+ */
+export declare const handoffHttpError: ({ handoffId, status, detail, }: {
+    handoffId: string;
+    status: number;
+    detail: string | null;
+}) => Error;
+export declare const describeHandoffTransportError: (error: unknown) => string;
+/** `?handoff=<id>` — the query parameter mobile-web and QR links carry. */
+export declare const HANDOFF_URL_PARAM = "handoff";
+/**
+ * Read a handoff id from a URL. Ids are server-issued, URL-safe tokens; anything
+ * else is rejected so a tampered link never reaches the claim path.
+ */
+export declare const parseHandoffIdParam: (value: string | null | undefined) => string | null;
+/** Athena Mobile's custom URL scheme (`mobile-app-react-native/app.json` → `scheme`). */
+export declare const MOBILE_APP_SCHEME = "athenavisionapplication";
+/**
+ * Custom-scheme launch for a handoff — what a phone's browser opens when the
+ * Universal/App Link landed on mobile web instead of in the app. Mirrors
+ * agora's `_mobile_scheme_url`; carries only the opaque handoff id.
+ */
+export declare const buildMobileHandoffSchemeUrl: ({ handoffId }: {
+    handoffId: string;
+}) => string;