@athenaintel/react 0.43.0 → 0.48.0

package/dist/agent-runtime/src/handoff-arrival.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-arrival.cjs","sources":["../../../../agent-runtime/src/handoff-arrival.ts"],"sourcesContent":["/**\n * Where a handed-off conversation arrived on this surface: a transcript divider\n * (\"Continued from your phone\") after the last message that was already there\n * when the person picked it up.\n *\n * Ephemeral and client-side. A host records an arrival when its pick-up lands\n * (`recordHandoffArrival`); its transcript anchors it to the thread's last\n * message once that history has loaded (`useHandoffArrival`) and renders the\n * divider after that message (`useHandoffArrivalAfter`). Nothing is sent to\n * Athena or persisted; a reload forgets it.\n */\nimport { createContext, useContext, useEffect, useSyncExternalStore } from 'react';\nimport { continuedFromLabel } from './thread-handoff-protocol';\n\nexport interface HandoffArrival {\n  threadId: string;\n  /** \"Continued from your phone\". */\n  label: string;\n  /**\n   * The last message present when the conversation arrived; the divider goes\n   * right after it. `null` until the transcript has anchored it.\n   */\n  afterMessageId: string | null;\n}\n\n/** Enough for every conversation one person picks up in a session. */\nexport const MAX_HANDOFF_ARRIVALS = 20;\n\n/**\n * The arrivals live on `globalThis`, not in module scope, because two copies of\n * this module can run in one page: the SDK bundles agent-runtime into its dist\n * while a host (Spaces, the Chrome extension, Midas) imports it directly. The\n * host records through its copy and the SDK transcript reads through its own.\n */\nconst HANDOFF_ARRIVALS = Symbol.for('@athenaintel/agent-runtime/handoff-arrivals');\n\ninterface ArrivalRegistry {\n  arrivals: Map<string, HandoffArrival>;\n  listeners: Set<() => void>;\n}\n\ntype ArrivalRegistryHost = typeof globalThis & { [HANDOFF_ARRIVALS]?: ArrivalRegistry };\n\n// process-local: this client only — what this surface picked up; nothing is persisted\nfunction registry(): ArrivalRegistry {\n  const host = globalThis as ArrivalRegistryHost;\n  return (host[HANDOFF_ARRIVALS] ??= { arrivals: new Map(), listeners: new Set() });\n}\n\nfunction publish(): void {\n  for (const listener of registry().listeners) listener();\n}\n\n/**\n * A pick-up landed `threadId` here from `source` (`mobile`, `chrome`, …). A\n * second pick-up of the same thread moves the divider to the new arrival.\n */\nexport function recordHandoffArrival({\n  threadId,\n  source,\n}: {\n  threadId: string;\n  source: string;\n}): void {\n  if (!threadId) return;\n  const { arrivals } = registry();\n  arrivals.delete(threadId);\n  arrivals.set(threadId, { threadId, label: continuedFromLabel(source), afterMessageId: null });\n  while (arrivals.size > MAX_HANDOFF_ARRIVALS) {\n    const oldest = arrivals.keys().next().value;\n    if (oldest === undefined) break;\n    arrivals.delete(oldest);\n  }\n  publish();\n}\n\n/** The arrival recorded for `threadId`, anchored or not. */\nexport function readHandoffArrival(threadId: string | null | undefined): HandoffArrival | null {\n  return (threadId && registry().arrivals.get(threadId)) || null;\n}\n\nexport function subscribeHandoffArrivals(listener: () => void): () => void {\n  const { listeners } = registry();\n  listeners.add(listener);\n  return () => {\n    listeners.delete(listener);\n  };\n}\n\n/** Forgets the arrival of `threadId`: the pick-up never opened the conversation here. */\nexport function clearHandoffArrival(threadId: string): void {\n  if (!registry().arrivals.delete(threadId)) return;\n  publish();\n}\n\n/** The first anchor wins: later messages are what came after the arrival. */\nexport function anchorHandoffArrival({\n  threadId,\n  afterMessageId,\n}: {\n  threadId: string;\n  afterMessageId: string;\n}): void {\n  const { arrivals } = registry();\n  const arrival = arrivals.get(threadId);\n  if (!arrival || arrival.afterMessageId !== null) return;\n  arrivals.set(threadId, { ...arrival, afterMessageId });\n  publish();\n}\n\n/**\n * The divider for the transcript of `threadId`, once anchored. The transcript\n * passes its last message id and whether its history is still loading; the\n * first time history has loaded with a message in it, the arrival anchors\n * after that message. A thread already on screen anchors at once.\n */\nexport function useHandoffArrival({\n  threadId,\n  lastMessageId,\n  loading,\n}: {\n  threadId: string | null | undefined;\n  lastMessageId: string | null | undefined;\n  loading: boolean;\n}): HandoffArrival | null {\n  const arrival = useSyncExternalStore(\n    subscribeHandoffArrivals,\n    () => readHandoffArrival(threadId),\n    () => null\n  );\n  const unanchored = arrival !== null && arrival.afterMessageId === null;\n  useEffect(() => {\n    if (!threadId || !unanchored || loading || !lastMessageId) return;\n    anchorHandoffArrival({ threadId, afterMessageId: lastMessageId });\n  }, [threadId, unanchored, loading, lastMessageId]);\n  return arrival?.afterMessageId ? arrival : null;\n}\n\n/** The anchored arrival of the transcript being rendered, for its messages. */\nexport const HandoffArrivalContext = createContext<HandoffArrival | null>(null);\n\n/** The divider label when it goes right after `messageId`; `null` otherwise. */\nexport function useHandoffArrivalAfter(messageId: string | null | undefined): string | null {\n  const arrival = useContext(HandoffArrivalContext);\n  return arrival && messageId && arrival.afterMessageId === messageId ? arrival.label : null;\n}\n\nexport function resetHandoffArrivalsForTests(): void {\n  registry().arrivals.clear();\n  publish();\n}\n"],"names":["useSyncExternalStore","useEffect","createContext","useContext"],"mappings":";;;AAkCA,MAAM,mBAAmB,OAAO,IAAI,6CAA6C;AAUjF,SAAS,WAA4B;AACnC,QAAM,OAAO;AACb,SAAQ,oDAA2B,EAAE,UAAU,oBAAI,OAAO,WAAW,oBAAI,MAAI;AAC/E;AAEA,SAAS,UAAgB;AACvB,aAAW,YAAY,WAAW,UAAW,UAAA;AAC/C;AA0BO,SAAS,mBAAmB,UAA4D;AAC7F,SAAQ,YAAY,SAAA,EAAW,SAAS,IAAI,QAAQ,KAAM;AAC5D;AAEO,SAAS,yBAAyB,UAAkC;AACzE,QAAM,EAAE,UAAA,IAAc,SAAA;AACtB,YAAU,IAAI,QAAQ;AACtB,SAAO,MAAM;AACX,cAAU,OAAO,QAAQ;AAAA,EAC3B;AACF;AASO,SAAS,qBAAqB;AAAA,EACnC;AAAA,EACA;AACF,GAGS;AACP,QAAM,EAAE,SAAA,IAAa,SAAA;AACrB,QAAM,UAAU,SAAS,IAAI,QAAQ;AACrC,MAAI,CAAC,WAAW,QAAQ,mBAAmB,KAAM;AACjD,WAAS,IAAI,UAAU,EAAE,GAAG,SAAS,gBAAgB;AACrD,UAAA;AACF;AAQO,SAAS,kBAAkB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AACF,GAI0B;AACxB,QAAM,UAAUA,WAAAA;AAAAA,IACd;AAAA,IACA,MAAM,mBAAmB,QAAQ;AAAA,IACjC,MAAM;AAAA,EAAA;AAER,QAAM,aAAa,YAAY,QAAQ,QAAQ,mBAAmB;AAClEC,aAAAA,UAAU,MAAM;AACd,QAAI,CAAC,YAAY,CAAC,cAAc,WAAW,CAAC,cAAe;AAC3D,yBAAqB,EAAE,UAAU,gBAAgB,cAAA,CAAe;AAAA,EAClE,GAAG,CAAC,UAAU,YAAY,SAAS,aAAa,CAAC;AACjD,UAAO,mCAAS,kBAAiB,UAAU;AAC7C;AAGO,MAAM,wBAAwBC,WAAAA,cAAqC,IAAI;AAGvE,SAAS,uBAAuB,WAAqD;AAC1F,QAAM,UAAUC,WAAAA,WAAW,qBAAqB;AAChD,SAAO,WAAW,aAAa,QAAQ,mBAAmB,YAAY,QAAQ,QAAQ;AACxF;;;;;;;"}

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

@@ -0,0 +1,46 @@
+export interface HandoffArrival {
+    threadId: string;
+    /** "Continued from your phone". */
+    label: string;
+    /**
+     * The last message present when the conversation arrived; the divider goes
+     * right after it. `null` until the transcript has anchored it.
+     */
+    afterMessageId: string | null;
+}
+/** Enough for every conversation one person picks up in a session. */
+export declare const MAX_HANDOFF_ARRIVALS = 20;
+/**
+ * A pick-up landed `threadId` here from `source` (`mobile`, `chrome`, …). A
+ * second pick-up of the same thread moves the divider to the new arrival.
+ */
+export declare function recordHandoffArrival({ threadId, source, }: {
+    threadId: string;
+    source: string;
+}): void;
+/** The arrival recorded for `threadId`, anchored or not. */
+export declare function readHandoffArrival(threadId: string | null | undefined): HandoffArrival | null;
+export declare function subscribeHandoffArrivals(listener: () => void): () => void;
+/** Forgets the arrival of `threadId`: the pick-up never opened the conversation here. */
+export declare function clearHandoffArrival(threadId: string): void;
+/** The first anchor wins: later messages are what came after the arrival. */
+export declare function anchorHandoffArrival({ threadId, afterMessageId, }: {
+    threadId: string;
+    afterMessageId: string;
+}): void;
+/**
+ * The divider for the transcript of `threadId`, once anchored. The transcript
+ * passes its last message id and whether its history is still loading; the
+ * first time history has loaded with a message in it, the arrival anchors
+ * after that message. A thread already on screen anchors at once.
+ */
+export declare function useHandoffArrival({ threadId, lastMessageId, loading, }: {
+    threadId: string | null | undefined;
+    lastMessageId: string | null | undefined;
+    loading: boolean;
+}): HandoffArrival | null;
+/** The anchored arrival of the transcript being rendered, for its messages. */
+export declare const HandoffArrivalContext: import("react").Context<HandoffArrival | null>;
+/** The divider label when it goes right after `messageId`; `null` otherwise. */
+export declare function useHandoffArrivalAfter(messageId: string | null | undefined): string | null;
+export declare function resetHandoffArrivalsForTests(): void;

package/dist/agent-runtime/src/handoff-arrival.js

@@ -0,0 +1,60 @@
+import { useContext, useSyncExternalStore, useEffect, createContext } from "react";
+const HANDOFF_ARRIVALS = Symbol.for("@athenaintel/agent-runtime/handoff-arrivals");
+function registry() {
+  const host = globalThis;
+  return host[HANDOFF_ARRIVALS] ?? (host[HANDOFF_ARRIVALS] = { arrivals: /* @__PURE__ */ new Map(), listeners: /* @__PURE__ */ new Set() });
+}
+function publish() {
+  for (const listener of registry().listeners) listener();
+}
+function readHandoffArrival(threadId) {
+  return threadId && registry().arrivals.get(threadId) || null;
+}
+function subscribeHandoffArrivals(listener) {
+  const { listeners } = registry();
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function anchorHandoffArrival({
+  threadId,
+  afterMessageId
+}) {
+  const { arrivals } = registry();
+  const arrival = arrivals.get(threadId);
+  if (!arrival || arrival.afterMessageId !== null) return;
+  arrivals.set(threadId, { ...arrival, afterMessageId });
+  publish();
+}
+function useHandoffArrival({
+  threadId,
+  lastMessageId,
+  loading
+}) {
+  const arrival = useSyncExternalStore(
+    subscribeHandoffArrivals,
+    () => readHandoffArrival(threadId),
+    () => null
+  );
+  const unanchored = arrival !== null && arrival.afterMessageId === null;
+  useEffect(() => {
+    if (!threadId || !unanchored || loading || !lastMessageId) return;
+    anchorHandoffArrival({ threadId, afterMessageId: lastMessageId });
+  }, [threadId, unanchored, loading, lastMessageId]);
+  return (arrival == null ? void 0 : arrival.afterMessageId) ? arrival : null;
+}
+const HandoffArrivalContext = createContext(null);
+function useHandoffArrivalAfter(messageId) {
+  const arrival = useContext(HandoffArrivalContext);
+  return arrival && messageId && arrival.afterMessageId === messageId ? arrival.label : null;
+}
+export {
+  HandoffArrivalContext,
+  anchorHandoffArrival,
+  readHandoffArrival,
+  subscribeHandoffArrivals,
+  useHandoffArrival,
+  useHandoffArrivalAfter
+};
+//# sourceMappingURL=handoff-arrival.js.map

package/dist/agent-runtime/src/handoff-arrival.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-arrival.js","sources":["../../../../agent-runtime/src/handoff-arrival.ts"],"sourcesContent":["/**\n * Where a handed-off conversation arrived on this surface: a transcript divider\n * (\"Continued from your phone\") after the last message that was already there\n * when the person picked it up.\n *\n * Ephemeral and client-side. A host records an arrival when its pick-up lands\n * (`recordHandoffArrival`); its transcript anchors it to the thread's last\n * message once that history has loaded (`useHandoffArrival`) and renders the\n * divider after that message (`useHandoffArrivalAfter`). Nothing is sent to\n * Athena or persisted; a reload forgets it.\n */\nimport { createContext, useContext, useEffect, useSyncExternalStore } from 'react';\nimport { continuedFromLabel } from './thread-handoff-protocol';\n\nexport interface HandoffArrival {\n  threadId: string;\n  /** \"Continued from your phone\". */\n  label: string;\n  /**\n   * The last message present when the conversation arrived; the divider goes\n   * right after it. `null` until the transcript has anchored it.\n   */\n  afterMessageId: string | null;\n}\n\n/** Enough for every conversation one person picks up in a session. */\nexport const MAX_HANDOFF_ARRIVALS = 20;\n\n/**\n * The arrivals live on `globalThis`, not in module scope, because two copies of\n * this module can run in one page: the SDK bundles agent-runtime into its dist\n * while a host (Spaces, the Chrome extension, Midas) imports it directly. The\n * host records through its copy and the SDK transcript reads through its own.\n */\nconst HANDOFF_ARRIVALS = Symbol.for('@athenaintel/agent-runtime/handoff-arrivals');\n\ninterface ArrivalRegistry {\n  arrivals: Map<string, HandoffArrival>;\n  listeners: Set<() => void>;\n}\n\ntype ArrivalRegistryHost = typeof globalThis & { [HANDOFF_ARRIVALS]?: ArrivalRegistry };\n\n// process-local: this client only — what this surface picked up; nothing is persisted\nfunction registry(): ArrivalRegistry {\n  const host = globalThis as ArrivalRegistryHost;\n  return (host[HANDOFF_ARRIVALS] ??= { arrivals: new Map(), listeners: new Set() });\n}\n\nfunction publish(): void {\n  for (const listener of registry().listeners) listener();\n}\n\n/**\n * A pick-up landed `threadId` here from `source` (`mobile`, `chrome`, …). A\n * second pick-up of the same thread moves the divider to the new arrival.\n */\nexport function recordHandoffArrival({\n  threadId,\n  source,\n}: {\n  threadId: string;\n  source: string;\n}): void {\n  if (!threadId) return;\n  const { arrivals } = registry();\n  arrivals.delete(threadId);\n  arrivals.set(threadId, { threadId, label: continuedFromLabel(source), afterMessageId: null });\n  while (arrivals.size > MAX_HANDOFF_ARRIVALS) {\n    const oldest = arrivals.keys().next().value;\n    if (oldest === undefined) break;\n    arrivals.delete(oldest);\n  }\n  publish();\n}\n\n/** The arrival recorded for `threadId`, anchored or not. */\nexport function readHandoffArrival(threadId: string | null | undefined): HandoffArrival | null {\n  return (threadId && registry().arrivals.get(threadId)) || null;\n}\n\nexport function subscribeHandoffArrivals(listener: () => void): () => void {\n  const { listeners } = registry();\n  listeners.add(listener);\n  return () => {\n    listeners.delete(listener);\n  };\n}\n\n/** Forgets the arrival of `threadId`: the pick-up never opened the conversation here. */\nexport function clearHandoffArrival(threadId: string): void {\n  if (!registry().arrivals.delete(threadId)) return;\n  publish();\n}\n\n/** The first anchor wins: later messages are what came after the arrival. */\nexport function anchorHandoffArrival({\n  threadId,\n  afterMessageId,\n}: {\n  threadId: string;\n  afterMessageId: string;\n}): void {\n  const { arrivals } = registry();\n  const arrival = arrivals.get(threadId);\n  if (!arrival || arrival.afterMessageId !== null) return;\n  arrivals.set(threadId, { ...arrival, afterMessageId });\n  publish();\n}\n\n/**\n * The divider for the transcript of `threadId`, once anchored. The transcript\n * passes its last message id and whether its history is still loading; the\n * first time history has loaded with a message in it, the arrival anchors\n * after that message. A thread already on screen anchors at once.\n */\nexport function useHandoffArrival({\n  threadId,\n  lastMessageId,\n  loading,\n}: {\n  threadId: string | null | undefined;\n  lastMessageId: string | null | undefined;\n  loading: boolean;\n}): HandoffArrival | null {\n  const arrival = useSyncExternalStore(\n    subscribeHandoffArrivals,\n    () => readHandoffArrival(threadId),\n    () => null\n  );\n  const unanchored = arrival !== null && arrival.afterMessageId === null;\n  useEffect(() => {\n    if (!threadId || !unanchored || loading || !lastMessageId) return;\n    anchorHandoffArrival({ threadId, afterMessageId: lastMessageId });\n  }, [threadId, unanchored, loading, lastMessageId]);\n  return arrival?.afterMessageId ? arrival : null;\n}\n\n/** The anchored arrival of the transcript being rendered, for its messages. */\nexport const HandoffArrivalContext = createContext<HandoffArrival | null>(null);\n\n/** The divider label when it goes right after `messageId`; `null` otherwise. */\nexport function useHandoffArrivalAfter(messageId: string | null | undefined): string | null {\n  const arrival = useContext(HandoffArrivalContext);\n  return arrival && messageId && arrival.afterMessageId === messageId ? arrival.label : null;\n}\n\nexport function resetHandoffArrivalsForTests(): void {\n  registry().arrivals.clear();\n  publish();\n}\n"],"names":[],"mappings":";AAkCA,MAAM,mBAAmB,OAAO,IAAI,6CAA6C;AAUjF,SAAS,WAA4B;AACnC,QAAM,OAAO;AACb,SAAQ,oDAA2B,EAAE,UAAU,oBAAI,OAAO,WAAW,oBAAI,MAAI;AAC/E;AAEA,SAAS,UAAgB;AACvB,aAAW,YAAY,WAAW,UAAW,UAAA;AAC/C;AA0BO,SAAS,mBAAmB,UAA4D;AAC7F,SAAQ,YAAY,SAAA,EAAW,SAAS,IAAI,QAAQ,KAAM;AAC5D;AAEO,SAAS,yBAAyB,UAAkC;AACzE,QAAM,EAAE,UAAA,IAAc,SAAA;AACtB,YAAU,IAAI,QAAQ;AACtB,SAAO,MAAM;AACX,cAAU,OAAO,QAAQ;AAAA,EAC3B;AACF;AASO,SAAS,qBAAqB;AAAA,EACnC;AAAA,EACA;AACF,GAGS;AACP,QAAM,EAAE,SAAA,IAAa,SAAA;AACrB,QAAM,UAAU,SAAS,IAAI,QAAQ;AACrC,MAAI,CAAC,WAAW,QAAQ,mBAAmB,KAAM;AACjD,WAAS,IAAI,UAAU,EAAE,GAAG,SAAS,gBAAgB;AACrD,UAAA;AACF;AAQO,SAAS,kBAAkB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AACF,GAI0B;AACxB,QAAM,UAAU;AAAA,IACd;AAAA,IACA,MAAM,mBAAmB,QAAQ;AAAA,IACjC,MAAM;AAAA,EAAA;AAER,QAAM,aAAa,YAAY,QAAQ,QAAQ,mBAAmB;AAClE,YAAU,MAAM;AACd,QAAI,CAAC,YAAY,CAAC,cAAc,WAAW,CAAC,cAAe;AAC3D,yBAAqB,EAAE,UAAU,gBAAgB,cAAA,CAAe;AAAA,EAClE,GAAG,CAAC,UAAU,YAAY,SAAS,aAAa,CAAC;AACjD,UAAO,mCAAS,kBAAiB,UAAU;AAC7C;AAGO,MAAM,wBAAwB,cAAqC,IAAI;AAGvE,SAAS,uBAAuB,WAAqD;AAC1F,QAAM,UAAU,WAAW,qBAAqB;AAChD,SAAO,WAAW,aAAa,QAAQ,mBAAmB,YAAY,QAAQ,QAAQ;AACxF;"}

package/dist/agent-runtime/src/index.d.ts

@@ -9,13 +9,14 @@ export { CATEGORY_EMOJI, defaultToolDisplayMeta, describeDelegation, describeNam
 export { classifyToolResult, isRecord, isRejectedToolResult, isToolResultSuccess, parseJsonRecord, readRejectedToolResult, type RejectedToolResult, resultMessage, resultRecord, stringField, type ToolCallStatusLike, toolFailure, type ToolFailure, type ToolResultClassification, type ToolResultState, } from "./tool-result";
 export { type ConversationListController, useConversationList, type UseConversationListOptions, } from "./use-conversation-list";
 export { CLIENT_TOOL_RESULT_STATUS_ERROR, CLIENT_TOOL_RESULT_STATUS_SUCCESS, CLIENT_TOOL_RESULT_STATUSES, type ClientToolResultEnvelopeContract, type ClientToolResultStatus, DEEP_AGENT_CONTEXT_PROTOCOL, DEEP_AGENT_CUT_LANE_DOCUMENT, DEEP_AGENT_DEFAULT_MESSAGE_WINDOW, DEEP_AGENT_FOLLOW_TOOL_CALL_ID_KEY, DEEP_AGENT_INTEREST_PROTOCOL, DEEP_AGENT_LANE_CUT_PROTOCOL_VERSION, DEEP_AGENT_LANE_FOLLOW_PROTOCOL_VERSION, DEEP_AGENT_MAIN_NS, DEEP_AGENT_MAX_FOLLOWED_STEPS, DEEP_AGENT_MAX_LANE_PAGE, DEEP_AGENT_HISTORY_IMAGE_COMMAND, DEEP_AGENT_HISTORY_LANE_COMMAND, DEEP_AGENT_HISTORY_LANE_IMAGE_COMMAND, DEEP_AGENT_HISTORY_LANE_PAGE_CHARS, DEEP_AGENT_HISTORY_MESSAGE_COMMAND, DEEP_AGENT_HISTORY_TOOL_OUTPUT_COMMAND, DEEP_AGENT_INLINE_IMAGE_WIRE_BUDGET, DEEP_AGENT_MAX_INTERESTS, DEEP_AGENT_MAX_MESSAGE_WINDOW, DEEP_AGENT_MESSAGE_WINDOW_HEADER, DEEP_AGENT_MIN_MESSAGE_WINDOW, DEEP_AGENT_OMITTED_IMAGE_KEY, DEEP_AGENT_OMITTED_IMAGE_PLACEHOLDER_URL, DEEP_AGENT_PROTOCOL_STATE_KEY, DEEP_AGENT_PROTOCOL_VERSION, DEEP_AGENT_PROTOCOL_VERSION_HEADER, DEEP_AGENT_REPEATS_RESULT_KEY, DEEP_AGENT_RUNNING_LANE_WIRE_MESSAGES, DEEP_AGENT_RUNTIME_MARKER, DEEP_AGENT_TRUNCATED_CONTENT_KEY, DEEP_AGENT_TRUNCATED_LANE_KEY, KNOWN_START_CHANNEL_SET, KNOWN_START_CHANNELS, type KnownStartChannel, RUN_CONFIG_COMPANION_CUSTOM_KEYS, RUN_CONFIG_CUSTOM_KEY_SET, RUN_CONFIG_CUSTOM_KEYS, RUN_CONFIG_PARSED_CUSTOM_KEYS, RUN_CONFIG_PER_SEND_CUSTOM_KEY_SET, RUN_CONFIG_PER_SEND_CUSTOM_KEYS, type RunConfigCustomKey, type RunConfigPerSendCustomKey, DEEP_AGENT_CONFIG_COMMANDS, DEEP_AGENT_CONFIG_STATE_KEY, THREAD_CONFIG_CUSTOM_KEY_SET, THREAD_CONFIG_CUSTOM_KEYS, type ThreadConfigCustomKey, } from "./generated/runconfig-contract";
-export { COLLAB_AGENT_CHANNEL_SESSION_MISMATCH, CONVERSATION_ARCHIVED, CONVERSATION_ARCHIVED_MESSAGE, isConversationArchivedRejection, isLegacyThreadReadOnlyRejection, isStatewireChannelTeardown, isStatewireCommandAuthContextExpired, isStatewireExpiredVerdict, isStatewireRewindAnchorRejection, projectDeepAgentConnection, readRetryableCommandRejection, readRetryableRunRefusal, readRunStartRefusal, type RetryableCommandRejection, type RetryableRunRefusal, type RunStartRefusal, STATEWIRE_COMMAND_AUTH_CONTEXT_EXPIRED, statewireRejectionCode, statewireRejectionDetailMessage, statewireRejectionPayload, type StatewireRejectionPayload, statewireTransportOutcome, } from "./errors";
+export { COLLAB_AGENT_CHANNEL_SESSION_MISMATCH, CONVERSATION_ARCHIVED, CONVERSATION_ARCHIVED_MESSAGE, isConversationArchivedRejection, isLegacyThreadReadOnlyRejection, isStatewireChannelTeardown, isStatewireCommandAuthContextExpired, isStatewireExpiredVerdict, isStatewireRewindAnchorRejection, projectDeepAgentConnection, readRetryableCommandRejection, readRetryableRunRefusal, readRunStartRefusal, type RetryableCommandRejection, type RetryableRunRefusal, type RunStartRefusal, STATEWIRE_COMMAND_AUTH_CONTEXT_EXPIRED, statewireRejectionCode, isVoiceCommandRejection, statewireRejectionDetailMessage, statewireRejectionPayload, type StatewireRejectionPayload, statewireTransportOutcome, } from "./errors";
 export { type ParsedExecuteOutput, parseExecuteOutput, type ShellCommandSummary, summarizeShellCommand, } from "./execute-output";
-export { type AbandonedInputRequest, type ApprovalResumeLock, asHitlApproval, canApproveForSession, DEFAULT_INTERRUPT_PAUSED_MESSAGE, fanLaneDecision, findAbandonedInterrupt, HITL_PENDING_RESUME_GRACE_MS, HITL_REJECT_REASON, HITL_RESUME_TRANSPORT_RETRIES, type HitlActionDecision, type HitlApprovalPayload, actionRequestToolCallIds, hitlResumeActionDecisions, hitlResumeApprove, hitlResumeApproveForSession, INTERRUPT_DECLINE_REASON, interruptMirrorPayload, interruptResumeDecline, hitlResumeReject, isApprovalCardInterrupt, isPendingInterrupt, isResumeTransportLoss, isSystemPauseInterrupt, laneInterruptIds, type PendingActionRequest, type PendingApprovalContext, type PendingApprovalFact, type PendingApprovalWarning, parsePendingApprovalContext, pendingActionRequests, readAbandonedInputRequests, readInterruptMessage, readInterruptMirror, readQueuedLaneDecisions, toolCallIdsAwaitingApproval, useApprovalResumeLock, type UseApprovalResumeLockOptions, } from "./interrupts";
+export { type AbandonedInputRequest, type ApprovalResumeLock, asHitlApproval, canApproveForSession, DEFAULT_INTERRUPT_PAUSED_MESSAGE, fanLaneDecision, findAbandonedInterrupt, HITL_PENDING_RESUME_GRACE_MS, HITL_REJECT_REASON, HITL_RESUME_TRANSPORT_RETRIES, type HitlActionDecision, type HitlApprovalPayload, actionRequestToolCallIds, hitlResumeActionDecisions, hitlResumeApprove, hitlResumeApproveForSession, INTERRUPT_DECLINE_REASON, interruptMirrorPayload, interruptResumeDecline, hitlResumeReject, isApprovalCardInterrupt, isPendingInterrupt, isResumeTransportLoss, isSystemPauseInterrupt, laneInterruptIds, type PendingActionRequest, type PendingApprovalContext, type PendingApprovalFact, type PendingApprovalWarning, parsePendingApprovalContext, pendingActionRequests, readAbandonedInputRequests, readInterruptMessage, readInterruptMirror, readQueuedLaneDecisions, type ResumeExtras, resumeValueApproves, toolCallIdsAwaitingApproval, useApprovalResumeLock, type UseApprovalResumeLockOptions, } from "./interrupts";
+export { type AgoraFetch, bareDecisionThreadId, type BrowserDecisionCheckOutcome, DECISION_CHECK_HEADER, type DecisionCheckClient, type DecisionCheckClientKind, type DecisionCheckDescriptor, DecisionCheckKind, MAX_DECISIONS_PER_CHECK, type PendingBrowserDecisionCheck, respondDecisionDescriptor, type RunBrowserDecisionCheckOptions, runBrowserDecisionCheck, type StatewireAnswerForCheck, statewireAnswerDescriptors, } from "./decision-checks";
 export { buildQueueEditCommand, buildStatewireQueueRows, describeQueueSendFailure, isFailedSendEntryRace, isQueueEntryUnsettled, QUEUE_AUTO_CONTINUE_DELAY_MS, type QueueEditCommand, queueEntryText, queueLaneFlags, type QueueLaneFlags, readPrioritizedQueueIds, showQueueRowSendNow, showQueueRowSteer, type StatewireQueueRow, userStopBlocksQueueAutoContinue, } from "./queue";
 export { createDeepAgentSendRecovery, type DeepAgentSendRecovery, type DeepAgentSendRecoveryOptions, shouldAutoRetryFailedSend, } from "./send-recovery";
 export { hasStatewireThreadExtras, readStatewireFailedSendLane, requireStatewireFailedActions, type StatewireFailedActions, type StatewireFailedSendEntry, type StatewireFailedSendLane, } from "./thread-extras";
-export { applyRunErrorStatus, ATHENA_ERRORS_KEY, ATHENA_HANDOFF_KEY, ATHENA_QUEUED_LANE_KEY, ATHENA_RUN_MARKER_CANCELLED, ATHENA_RUN_MARKER_FAILED, ATHENA_RUN_MARKER_KEY, ATHENA_RUN_MARKER_SOURCE_KEY, ATHENA_STOP_SOURCE_INSTANCE_CLOSED, ATHENA_STOP_SOURCE_POD_DRAIN, ATHENA_STOP_SOURCE_SEND_NOW, ATHENA_STOP_SOURCE_VOICE_STEER, ATHENA_TERMINATION_REASON_KEY, convertDeepAgentLangChainMessage, convertDeepAgentState, type ConvertDeepAgentStateOptions, type DeepAgentMessageConversionOptions, createDeepAgentMaterialize, createDeepAgentMessageConversionCache, type DeepAgentConversionMemory, deepAgentMaterialize, type DeepAgentMaterializeOptions, DeepAgentMessageConversionCache, deepAgentRowKey, isConvertibleChatMessage, isDrainRunMarker, isLangGraphState, isMessageHiddenFromFrontend, isQueuedLaneMessage, isServerUpdateStopSource, isSilentRunMarker, laneTailMessages, liftBranchIntoMetadata, liftCompactionBoundaryIntoMetadata, liftConversationStatsIntoMetadata, liftErrorsIntoMetadata, liftHandoffSummaryIntoMetadata, liftModelIntoMetadata, liftRunMarkerIntoMetadata, liftTerminationIntoMetadata, liftToolMessageMetadataIntoArtifact, liftTruncatedToolOutputIntoArtifact, convertDeepAgentMessage, markPreliminaryToolResults, messageConverter, nativeStepUsage, PENDING_ASSISTANT_MESSAGE_ID, readMessageErrorsFromSourceMessages, readRunMarkerFromSourceMessages, readSoleRunMarker, type RunMarkerInfo, sanitizeLangChainMessages, substituteToolOutput, withPendingAssistantMessage, } from "./messages";
+export { applyRunErrorStatus, ATHENA_ERRORS_KEY, ATHENA_HANDOFF_KEY, ATHENA_QUEUED_LANE_KEY, ATHENA_RUN_MARKER_CANCELLED, ATHENA_RUN_MARKER_FAILED, ATHENA_RUN_MARKER_KEY, ATHENA_RUN_MARKER_SOURCE_KEY, ATHENA_STOP_SOURCE_INSTANCE_CLOSED, ATHENA_STOP_SOURCE_POD_DRAIN, ATHENA_STOP_SOURCE_SEND_NOW, ATHENA_STOP_SOURCE_VOICE_STEER, ATHENA_TERMINATION_REASON_KEY, convertDeepAgentLangChainMessage, convertDeepAgentState, type ConvertDeepAgentStateOptions, type DeepAgentMessageConversionOptions, createDeepAgentMaterialize, createDeepAgentMessageConversionCache, type DeepAgentConversionMemory, deepAgentMaterialize, type DeepAgentMaterializeOptions, DeepAgentMessageConversionCache, deepAgentRowKey, isConvertibleChatMessage, isDrainRunMarker, isLangGraphState, isMessageHiddenFromFrontend, isQueuedLaneMessage, isServerUpdateStopSource, isSilentRunMarker, laneTailMessages, liftBranchIntoMetadata, liftCompactionBoundaryIntoMetadata, liftConversationStatsIntoMetadata, liftErrorsIntoMetadata, liftHandoffSummaryIntoMetadata, liftModelIntoMetadata, liftPlaceInstructionsIntoMetadata, liftRunMarkerIntoMetadata, liftTerminationIntoMetadata, liftToolMessageMetadataIntoArtifact, liftTruncatedToolOutputIntoArtifact, convertDeepAgentMessage, markPreliminaryToolResults, messageConverter, nativeStepUsage, PENDING_ASSISTANT_MESSAGE_ID, PLACE_INSTRUCTIONS_STAMP_KEY, readMessageErrorsFromSourceMessages, readRunMarkerFromSourceMessages, readSoleRunMarker, type RunMarkerInfo, sanitizeLangChainMessages, substituteToolOutput, withPendingAssistantMessage, } from "./messages";
 export { ATHENA_TRUNCATED_TOOL_OUTPUT_ARTIFACT_KEY, buildHistoryMessageCommand, buildToolOutputCommand, clampMessageWindowSize, type DeepAgentInterestChainEntry, type DeepAgentInterestRequest, type DeepAgentInterestResolution, type DeepAgentMessageWindow, type DeepAgentMessageWindowDeclaration, headInterestRequest, type HistoryMessageCommand, type HistoryMessageResult, interestsCovered, pageInterestRequest, pageInterestRequests, readDeepAgentInterestDocument, readDeepAgentInterestResolution, readDeepAgentMessageWindow, readHistoryMessageResult, readToolOutputResult, readTruncatedToolContent, readTruncatedToolOutputArtifact, type ToolOutputCommand, type ToolOutputResult, type TruncatedToolContent, type TruncatedToolOutputArtifact, withDeclaredMessageWindow, } from "./message-window";
 export { buildHistoryLaneCommand, type DeepAgentLaneHistoryState, type DeepAgentLaneTarget, deepAgentLaneHistoryQueryKey, type HistoryLaneCommand, type HistoryLanePage, isWholeCardRefusal, mergeLaneHistory, readHistoryLanePage, useDeepAgentLaneHistory, } from "./lane-history";
 export { buildHistoryLaneImageCommand, type DeepAgentLaneImagesState, deepAgentLaneImageQueryKey, type HistoryLaneImageChunk, type HistoryLaneImageCommand, type InlineImage, type InlineImageChunk, type LaneImageRef, laneImageKey, omittedLaneImages, readChunkedInlineImage, readHistoryLaneImageChunk, readInlineImageChunk, readLaneImage, readLaneImageTile, showLaneImages, useDeepAgentLaneImages, } from "./lane-images";
@@ -27,6 +28,8 @@ export { createDeepAgentToolOutputStore, type DeepAgentToolOutputEntry, type Dee
 export { claimDeepAgentFailedSendText, type DeepAgentFailedSend, type DeepAgentWithdrawableTurn, type DeepAgentWithdrawnFromRun, type DeepAgentWithdrawnTurns, type DeepAgentWithdrawnTurnVerdict, readDeepAgentFailedSends, readDeepAgentWithdrawableTurn, readDeepAgentWithdrawnTurnVerdict, } from "./withdrawn-turns";
 export { DEEP_AGENT_COMPOSER_MARKDOWN_KEY, isComposerMarkdownOfText, readDeepAgentComposerMarkdown, resetStagedComposerMarkdown, STAGED_COMPOSER_MARKDOWN_TTL_MS, stageComposerMarkdown, takeStagedComposerMarkdownMetadata, trimComposerDraft, withDeepAgentComposerMarkdown, withStagedComposerMarkdown, } from "./composer-markdown";
 export { ATHENA_MESSAGE_AUTHOR_KEY, type DeepAgentMessageAuthor, isSameMessageAuthor, laneEntryAuthor, readMessageAuthor, } from "./message-author";
+export { answerLabelText, ATHENA_ANSWERED_BY_KEY, ATHENA_ASSISTANT_NAME, type DeepAgentAnsweredBy, readAnsweredBy, readLangChainAnswer, readMessageAnswers, showsAnswerLabel, threadShowsAnswerLabels, } from "./answer-label";
+export { ADDRESSED_TURN_STATE_KEY, type DeepAgentAddressedOutcome, type DeepAgentAddressedTurn, NEXT_AGENT_PENDING_MESSAGE_ID, readAnswerRowKey, readDeepAgentAddressedTurn, withAnswerRows, } from "./answer-rows";
 export { AIMessage, enrichStreamMessage, getMessageText, modelNameFromMessage, type StreamMessage, ToolMessage, } from "./message-text";
 export { hideUnterminatedMarkdownLink, UNTERMINATED_LABEL_HOLD_LIMIT, UNTERMINATED_LINK_HOLD_LIMIT, } from "./streaming-markdown";
 export { DEFAULT_CUA_SCREENSHOT_SIZE, describeScreenPointError, findScreenPointLinks, fitScreenBasis, formatScreenPoint, isScreenPointHref, parseScreenPointHref, SCREEN_POINT_HREF_PREFIX, SCREEN_POINT_HOST, SCREEN_POINT_PROTOCOL, sameScreenSize, type ScreenBasisFit, type ScreenPoint, type ScreenPointParseError, type ScreenPointParseResult, screenPointFraction, type ScreenSize, serializeScreenPointHref, } from "./screen-point";
@@ -34,8 +37,8 @@ export { type DeepAgentModelContextHost, registerDeepAgentRunConfig, } from "./m
 export { type CompletedPtcParent, extractCompletedPtcParents, type PtcSubcall, ptcSubcallsFromArtifact, } from "./ptc-subcalls";
 export { isRunningToolPlaceholder, isRunningToolPlaceholderArtifact, } from "./running-tool-placeholder";
 export { convertSubagentTranscript, createSubagentLaneConversion, createSubagentTranscriptConversionCache, type SubagentLaneConversion, withLaneReport, withRepeatedResult, } from "./subagent-transcripts";
-export { countSubagentStatuses, deriveEvalSubagents, finalizeOrphanedSubagents, isTerminalSubagentStatus, nestedMessagesFromArtifact, nestedTodosFromArtifact, ORPHANED_SUBAGENT_OUTPUT, ptcSubagentsFromArtifact, readLaneUsage, readTruncatedLane, type SubagentDiscoverySnapshot, type SubagentLaneSource, type SubagentStatus, type SubagentStatusCounts, type SubagentTokenUsage, subagentAwaitingApproval, subagentToolCallAwaitingApproval, type TaskSiblingGroup, type TokenCounts, type TruncatedLane, taskSiblingGroup, taskSubagentsOfThread, taskSubagentsOfTurn, transcriptStepUsage, turnToolCallsAwaitingApproval, useTurnToolCallsAwaitingApproval, } from "./subagents";
-export { ASYNC_TASK_TOOL_NAMES, CANCEL_ASYNC_TASK_TOOL_NAME, CHECK_ASYNC_TASK_TOOL_NAME, EDIT_FILE_TOOL_NAME, EVAL_TOOL_NAME, EXECUTE_PRESENTATION_CODE_TOOL_NAME, EXECUTE_SPREADSHEET_CODE_TOOL_NAME, EXECUTE_TOOL_NAME, EXECUTE_WORD_DOCUMENT_CODE_TOOL_NAME, type FileToolArgs, LIST_ASYNC_TASKS_TOOL_NAME, PTC_PARENT_TOOL_NAMES, QUIET_TOOL_NAMES, RUN_PYTHON_CODE_TOOL_NAME, salientToolCallDetail, START_ASYNC_TASK_TOOL_NAME, SUBMIT_FEEDBACK_TOOL_NAME, TASK_TOOL_NAME, UPDATE_ASYNC_TASK_TOOL_NAME, WRITE_FILE_TOOL_NAME, } from "./tool-names";
+export { countInEvalDispatches, countSubagentStatuses, deriveEvalSubagents, finalizeOrphanedSubagents, isTerminalSubagentStatus, nestedMessagesFromArtifact, nestedTodosFromArtifact, ORPHANED_SUBAGENT_OUTPUT, ptcSubagentsFromArtifact, readLaneUsage, readTruncatedLane, type SubagentDiscoverySnapshot, type SubagentLaneSource, type SubagentStatus, type SubagentStatusCounts, type SubagentTokenUsage, subagentAwaitingApproval, subagentToolCallAwaitingApproval, type TaskSiblingGroup, type TokenCounts, type TruncatedLane, taskSiblingGroup, taskSubagentsOfThread, taskSubagentsOfTurn, transcriptStepUsage, turnToolCallsAwaitingApproval, useTurnToolCallsAwaitingApproval, } from "./subagents";
+export { ASK_AGENT_TOOL_NAME, ASYNC_TASK_TOOL_NAMES, CANCEL_ASYNC_TASK_TOOL_NAME, CHECK_ASYNC_TASK_TOOL_NAME, EDIT_FILE_TOOL_NAME, EVAL_TOOL_NAME, EXECUTE_PRESENTATION_CODE_TOOL_NAME, EXECUTE_SPREADSHEET_CODE_TOOL_NAME, EXECUTE_TOOL_NAME, EXECUTE_WORD_DOCUMENT_CODE_TOOL_NAME, type FileToolArgs, LIST_ASYNC_TASKS_TOOL_NAME, PTC_PARENT_TOOL_NAMES, QUIET_TOOL_NAMES, RUN_PYTHON_CODE_TOOL_NAME, salientToolCallDetail, START_ASYNC_TASK_TOOL_NAME, SUBMIT_FEEDBACK_TOOL_NAME, TASK_TOOL_NAME, UPDATE_ASYNC_TASK_TOOL_NAME, WRITE_FILE_TOOL_NAME, } from "./tool-names";
 export { buildOptimisticHumanContent, type OptimisticContentPart, } from "./optimistic-content";
 export { DEEP_AGENT_DEFAULT_CLIENT_PROTOCOL_VERSION, type DeepAgentProtocolDeclaration, type DeepAgentProtocolStatus, type DeepAgentWireProtocol, declaredDeepAgentProtocolVersion, isDeepAgentHostState, projectDeepAgentProtocol, readDeepAgentProtocol, withDeclaredProtocolVersion, } from "./protocol";
 export { AUTH_DENIAL_PARK_THRESHOLD, type AuthDenialTrackerState, initialAuthDenialTrackerState, observeAuthDenial, } from "./auth-denial";
@@ -62,7 +65,7 @@ export { BACK_ONLINE_MS, chatSocketCannotReach, chatSocketOutage, useBrowserOnli
 export { type DeepAgentConfigControllerInputs, type DeepAgentConfigWriteResult, type DeepAgentServerConfig, type DeepAgentServerConfigEvent, foldPendingConfigOps, isConfigSyncUnavailableRejection, isConfigWriteForbiddenRejection, readConfigVersion, readServerConfig, readThreadServerConfig, useDeepAgentConfig, useDeepAgentConfigController, type UseDeepAgentConfigOptions, type UseDeepAgentConfigResult, } from "./use-deep-agent-config";
 export { applyConfigPatch, applyToolsDisable, applyToolsEnable, diffThreadConfig, pickPerSendCustom, pickThreadConfigCustom, readDeclinedToolkitIds, readEnabledTools, type ThreadConfigCustom, type ThreadConfigPatch, } from "./config-mutations";
 export { DEEP_AGENT_CONNECTION_STATUSES, type DeepAgentConnectionState, type DeepAgentConnectionStatus, type DeepAgentLaneProjection, type DeepAgentStreamValues, type LangGraphState, type PtcSubagentEntry, type Todo, } from "./types";
-export { classifyVoiceStartError, type DeepAgentVoiceDiagnostic, type DeepAgentVoiceDiagnosticEvent, type DeepAgentVoiceFailure, type DeepAgentVoiceFailureKind, type DeepAgentVoiceFailureStage, type DeepAgentVoiceLiveKitAdapter, type DeepAgentVoiceLiveKitAnswer, type DeepAgentVoiceLiveKitSession, type DeepAgentVoiceModelOption, type DeepAgentVoicePhase, type DeepAgentVoiceRemoteStream, type DeepAgentVoiceToolCall, type DeepAgentVoiceTransport, type DeepAgentVoiceWireState, describeVoiceFailure, describeVoiceWireError, float32FromPcm16, formatVoiceElapsed, parseVoiceLiveKitAnswer, parseVoiceModelOptions, pcm16FromFloat32, useDeepAgentVoice, useVoiceElapsed, type UseDeepAgentVoiceOptions, type UseDeepAgentVoiceReturn, VOICE_LIVEKIT_ANSWER_PREFIX, VOICE_LIVEKIT_OFFER, VOICE_RELAY_ANSWER_PREFIX, VOICE_RELAY_SAMPLE_RATE, VOICE_WEBSOCKET_OFFER, voiceRelayUrl, } from "./use-deep-agent-voice";
+export { classifyVoiceStartError, type DeepAgentVoiceDiagnostic, type DeepAgentVoiceDiagnosticEvent, type DeepAgentVoiceFailure, type DeepAgentVoiceFailureKind, type DeepAgentVoiceFailureStage, type DeepAgentVoiceLiveKitAdapter, type DeepAgentVoiceLiveKitAnswer, type DeepAgentVoiceLiveKitSession, type DeepAgentVoiceModelOption, type DeepAgentVoiceOpening, type DeepAgentVoiceOwnerWireState, type DeepAgentVoicePhase, type DeepAgentVoiceRemoteStream, type DeepAgentVoiceStartOptions, type DeepAgentVoiceSurface, type DeepAgentVoiceToolCall, type DeepAgentVoiceTransferWireState, type DeepAgentVoiceTransport, type DeepAgentVoiceWireState, describeVoiceFailure, describeVoiceLiveElsewhere, describeVoiceMovedTo, describeVoiceWireError, float32FromPcm16, formatVoiceElapsed, parseVoiceLiveKitAnswer, parseVoiceModelOptions, parseVoiceOwner, pcm16FromFloat32, useDeepAgentVoice, useVoiceElapsed, useVoiceMovedNotice, type UseDeepAgentVoiceOptions, type UseDeepAgentVoiceReturn, VOICE_LIVEKIT_ANSWER_PREFIX, VOICE_CONTINUE_BY_VOICE_LABEL, VOICE_LIVEKIT_OFFER, VOICE_MOVE_CALL_HERE_LABEL, VOICE_MOVE_HERE_ACTION, VOICE_MOVED_NOTICE_MS, VOICE_RELAY_ANSWER_PREFIX, VOICE_RELAY_SAMPLE_RATE, VOICE_WEBSOCKET_OFFER, voiceRelayUrl, voiceSurfaceLabel, } from "./use-deep-agent-voice";
 export { type DeepAgentVoiceWireError } from "./types";
 export { describeVoiceUpdateToolCall, isSpokenTurnTextPart, isVoiceDelegationMessage, VOICE_DELEGATION_ID_PREFIX, VOICE_LIVE_KEY, VOICE_LIVE_TYPED_HINT, VOICE_SOURCE_DELEGATION, VOICE_SOURCE_SPOKEN, VOICE_SOURCE_TYPED, VOICE_TURN_IDS_KEY, VOICE_UPDATE_TOOL_NAME, type VoiceMessageMarker, type VoiceProvenance, type VoiceUpdateToolCall, voiceProvenanceLabel, voiceUpdateStatusLabel, } from "./voice-presentation";
 export { groupSpokenUserTurns, isSpokenUserTurn } from "./voice-turn-grouping";
@@ -71,5 +74,8 @@ export { type DeepAgentAttachSource, type DeepAgentHeadersResolver, readSessionP
 export { GITHUB_EVENT_SOURCE_KEY, type GithubWakeEvent, githubWakeEventLabel, githubWakeEventUrl, githubWakeMarkerText, githubWakeReference, isGithubWakeMessage, readGithubWakeEvent, } from "./github-wake-event";
 export { githubSubscriptionHeadline, isSubscriptionWakeMessage, readSubscriptionWakeEvent, SUBSCRIPTION_EVENT_KEY, type SubscriptionWakeChange, type SubscriptionWakeEvent, type SubscriptionWakeGithub, subscriptionPlaceWords, subscriptionWakeDetail, subscriptionWakeGithub, subscriptionWakeHeadline, } from "./subscription-wake-event";
 export { describeTerminationReason, readRuntimeMessageFromSourceMessages, readSoleRuntimeMessageKind, readTerminationReason, runtimeMessageMarkerText, TERMINATION_REASONS, type AthenaRuntimeMessage, type AthenaRuntimeMessageKind, type AthenaRuntimeMessageSeverity, type AthenaTerminationReason, type TerminationDescription, } from "./runtime-messages";
-export { buildHandoffQrSvg, buildMobileHandoffSchemeUrl, classifyHandoffTransportError, type CreateThreadHandoffInput, type CreateThreadHandoffResponse, createThreadHandoffResponseSchema, describeHandoffTransportError, type DestinationReadiness, HANDOFF_DESTINATION_LABELS, HANDOFF_DESTINATIONS, HANDOFF_URL_PARAM, type HandoffDestination, type HandoffDestinationPresentation, type HandoffEnvironment, HandoffGoneError, type HandoffLaunch, type HandoffOutcome, HandoffPermanentError, type HandoffReadinessResponse, type HandoffReadinessState, type HandoffSource, type HandoffState, type HandoffTransportErrorKind, handoffHttpError, handoffReadinessResponseSchema, handoffStateSchema, isHandoffGoneError, isHandoffPermanentError, isRetryableHandoffHttpStatus, isOfficeHandoffDestination, isServerHandoffDestination, isTerminalHandoffState, type MobileHandoffLaunch, type MobileLaunchMode, mobileHandoffLaunchSchema, OFFICE_HANDOFF_DESTINATIONS, type OfficeHandoffDestination, type OfficeHandoffLaunch, officeHandoffLaunchSchema, parseHandoffIdParam, presentHandoffDestination, readinessByDestination, SERVER_HANDOFF_DESTINATIONS, type ServerHandoffDestination, selectMobileLaunchMode, type ThreadHandoffTransport, type ThreadHandoffView, threadHandoffViewSchema, waitForHandoffOutcome, type WaitForHandoffOutcomeOptions, } from "./thread-handoff";
-export { DEFAULT_MOBILE_HANDOFF_TIMEOUT_MS, DEFAULT_OFFICE_HANDOFF_TIMEOUT_MS, type StartThreadHandoffInput, type ThreadHandoffFlowCallbacks, type ThreadHandoffFlowController, type ThreadHandoffFlowPhase, useThreadHandoffFlow, type UseThreadHandoffFlowOptions, } from "./use-thread-handoff-flow";
+export { buildHandoffQrSvg, buildMobileHandoffSchemeUrl, classifyHandoffTransportError, type CreateThreadHandoffInput, type CreateThreadHandoffResponse, createThreadHandoffResponseSchema, describeHandoffTransportError, type DestinationReadiness, HANDOFF_DESTINATION_LABELS, HANDOFF_DESTINATIONS, HANDOFF_URL_PARAM, type HandoffDestination, type HandoffDestinationPresentation, type HandoffEnvironment, HandoffGoneError, type HandoffLaunch, type HandoffOutcome, HandoffPermanentError, type HandoffReadinessResponse, type HandoffReadinessState, type HandoffSource, type HandoffState, type HandoffTransportErrorKind, handoffHttpError, handoffReadinessResponseSchema, handoffStateSchema, isHandoffGoneError, isHandoffPermanentError, isRetryableHandoffHttpStatus, isOfficeHandoffDestination, isServerHandoffDestination, isTerminalHandoffState, type MobileHandoffLaunch, type MobileLaunchMode, mobileHandoffLaunchSchema, OFFICE_HANDOFF_DESTINATIONS, type OfficeHandoffDestination, type OfficeHandoffLaunch, officeHandoffLaunchSchema, type OfficeInvitationLaunch, officeInvitationLaunchSchema, type OfficeLaunchMode, officeLaunchModeSchema, threadHandoffCreateBody, parseHandoffIdParam, presentHandoffDestination, readinessByDestination, SERVER_HANDOFF_DESTINATIONS, type ServerHandoffDestination, selectMobileLaunchMode, supportsDesktopHandoffSource, type ThreadHandoffTransport, type ThreadHandoffView, threadHandoffViewSchema, waitForHandoffOutcome, type WaitForHandoffOutcomeOptions, type ClaimThreadHandoffResponse, claimThreadHandoffResponseSchema, clampHandoffDraft, continuedFromLabel, pickUpFromLabel, pickUpOfferLabel, type DesktopThreadHandoffLaunch, desktopThreadHandoffLaunchSchema, driverSurfaceForChannel, drivingOnLabel, type HandoffLanding, handoffLandingFromView, isPickupSurface, MAX_HANDOFF_DRAFT_LENGTH, nextHandoffLaunchSchema, parseThreadHandoffCreateResponse, pendingThreadHandoffResponseSchema, pickedUpOnLabel, PICKUP_SURFACES, type PickupSurface, shouldOfferPendingHandoff, SPACES_HANDOFF_URL_PARAM, type SpacesHandoffLaunch, spacesHandoffLaunchSchema, SURFACE_HANDOFF_DESTINATIONS, type SurfaceHandoffDestination, supportsSurfaceHandoffDestinations, THREAD_HANDOFF_DESTINATION_LABELS, THREAD_HANDOFF_DESTINATIONS, threadHandoffClaimBody, threadHandoffCreateRequest, type ThreadHandoffDestination, type ThreadHandoffReceiverTransport, MAX_PENDING_EXCLUDE, pendingExcludeIds, pickupExcludeIds, pendingHandoffPath, type HandoffMode, handoffModeSchema, isVoiceHandoffDestination, } from "./thread-handoff";
+export { DEFAULT_MOBILE_HANDOFF_TIMEOUT_MS, DEFAULT_OFFICE_HANDOFF_TIMEOUT_MS, DEFAULT_PICKUP_HANDOFF_TIMEOUT_MS, type StartThreadHandoffInput, type ThreadHandoffFlowCallbacks, type ThreadHandoffFlowController, type ThreadHandoffFlowPhase, useThreadHandoffFlow, type UseThreadHandoffFlowOptions, } from "./use-thread-handoff-flow";
+export { anchorHandoffArrival, clearHandoffArrival, type HandoffArrival, HandoffArrivalContext, MAX_HANDOFF_ARRIVALS, readHandoffArrival, recordHandoffArrival, resetHandoffArrivalsForTests, subscribeHandoffArrivals, useHandoffArrival, useHandoffArrivalAfter, } from "./handoff-arrival";
+export { connectVoiceMedia, VOICE_MICROPHONE_CAPTURE } from './voice-media';
+export type { VoiceMediaDriver, VoiceMediaHandlers, VoiceMediaSession } from './voice-media';

package/dist/agent-runtime/src/interrupts.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const react = require("react");
+const require$$0 = require("react");
 const clientTools = require("./client-tools.cjs");
 const errors = require("./errors.cjs");
 const statewireState = require("./statewire-state.cjs");
@@ -171,6 +171,30 @@ function hitlResumeActionDecisions(decisions) {
     action_decisions: decisions
   };
 }
+const NON_APPROVING_ACTIONS = /* @__PURE__ */ new Set(["reject", "timeout"]);
+function resumeValueApproves(value) {
+  if (!isRecord(value)) return true;
+  const decisions = value.decisions;
+  if (Array.isArray(decisions)) {
+    return decisions.length === 0 || decisions.some(resumeValueApproves);
+  }
+  const perAction = value.action_decisions;
+  if (perAction !== void 0) {
+    if (!isRecord(perAction)) return true;
+    const answers = Object.values(perAction);
+    return answers.length === 0 || answers.some(resumeValueApproves);
+  }
+  const lanes = value.lane_decisions;
+  if (lanes !== void 0) {
+    if (!isRecord(lanes)) return true;
+    const answers = Object.values(lanes);
+    return answers.length === 0 || answers.some(resumeValueApproves);
+  }
+  const kind = value.type;
+  if (typeof kind === "string") return !NON_APPROVING_ACTIONS.has(kind);
+  const action = value.action;
+  return typeof action !== "string" || !NON_APPROVING_ACTIONS.has(action);
+}
 const INTERRUPT_DECLINE_REASON = "User declined the request.";
 function interruptResumeDecline(reason = INTERRUPT_DECLINE_REASON) {
   return { action: "reject", reason };
@@ -185,15 +209,15 @@ function useApprovalResumeLock(options) {
     onResumeRetry,
     maxTransportRetries = HITL_RESUME_TRANSPORT_RETRIES
   } = options;
-  const [pending, setPending] = react.useState(false);
-  const [attempt, setAttempt] = react.useState(0);
-  const prevRequestIdRef = react.useRef(requestId);
+  const [pending, setPending] = require$$0.useState(false);
+  const [attempt, setAttempt] = require$$0.useState(0);
+  const prevRequestIdRef = require$$0.useRef(requestId);
   if (prevRequestIdRef.current !== requestId) {
     prevRequestIdRef.current = requestId;
     if (pending) setPending(false);
   }
-  const sawResumeRunRef = react.useRef(false);
-  react.useEffect(() => {
+  const sawResumeRunRef = require$$0.useRef(false);
+  require$$0.useEffect(() => {
     if (!pending) {
       sawResumeRunRef.current = false;
       return;
@@ -207,34 +231,34 @@ function useApprovalResumeLock(options) {
       setPending(false);
     }
   }, [pending, isRunning]);
-  react.useEffect(() => {
+  require$$0.useEffect(() => {
     if (!pending || pendingResumeGraceMs === void 0) return;
     const timer = setTimeout(() => {
       if (!sawResumeRunRef.current) setPending(false);
     }, pendingResumeGraceMs);
     return () => clearTimeout(timer);
   }, [pending, requestId, pendingResumeGraceMs, attempt]);
-  const sendResumeRef = react.useRef(sendResume);
+  const sendResumeRef = require$$0.useRef(sendResume);
   sendResumeRef.current = sendResume;
-  const onResumeRejectedRef = react.useRef(onResumeRejected);
+  const onResumeRejectedRef = require$$0.useRef(onResumeRejected);
   onResumeRejectedRef.current = onResumeRejected;
-  const onResumeRetryRef = react.useRef(onResumeRetry);
+  const onResumeRetryRef = require$$0.useRef(onResumeRetry);
   onResumeRetryRef.current = onResumeRetry;
-  const maxTransportRetriesRef = react.useRef(maxTransportRetries);
+  const maxTransportRetriesRef = require$$0.useRef(maxTransportRetries);
   maxTransportRetriesRef.current = maxTransportRetries;
-  const currentRequestIdRef = react.useRef(requestId);
+  const currentRequestIdRef = require$$0.useRef(requestId);
   currentRequestIdRef.current = requestId;
-  const pendingRef = react.useRef(pending);
+  const pendingRef = require$$0.useRef(pending);
   pendingRef.current = pending;
-  const submissionRef = react.useRef(0);
-  const resume = react.useCallback(
-    (value) => {
+  const submissionRef = require$$0.useRef(0);
+  const resume = require$$0.useCallback(
+    (value, extras) => {
       if (requestId === void 0 || pendingRef.current) return void 0;
       const submission = ++submissionRef.current;
       setPending(true);
       pendingRef.current = true;
       setAttempt(0);
-      const first = sendResumeRef.current(requestId, value);
+      const first = sendResumeRef.current(requestId, value, extras);
       if (!(first instanceof Promise)) return void 0;
       const outcome = new Promise((resolve, reject) => {
         const settle = (dispatched, retries) => {
@@ -251,7 +275,7 @@ function useApprovalResumeLock(options) {
               setPending(true);
               pendingRef.current = true;
               setAttempt(next);
-              const resent = sendResumeRef.current(requestId, value);
+              const resent = sendResumeRef.current(requestId, value, extras);
               if (resent instanceof Promise) {
                 settle(resent, next);
                 return;
@@ -302,6 +326,7 @@ exports.readAbandonedInputRequests = readAbandonedInputRequests;
 exports.readInterruptMessage = readInterruptMessage;
 exports.readInterruptMirror = readInterruptMirror;
 exports.readQueuedLaneDecisions = readQueuedLaneDecisions;
+exports.resumeValueApproves = resumeValueApproves;
 exports.toolCallIdsAwaitingApproval = toolCallIdsAwaitingApproval;
 exports.useApprovalResumeLock = useApprovalResumeLock;
 //# sourceMappingURL=interrupts.cjs.map

package/dist/agent-runtime/src/interrupts.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"interrupts.cjs","sources":["../../../../agent-runtime/src/interrupts.ts"],"sourcesContent":["/**\n * Human-in-the-loop interrupt primitives shared by every statewire chat\n * surface (Olympus, the React SDK, the Office add-in, the Chrome extension,\n * mobile).\n *\n * The agora deep-agent runtime parks a gated run on an `interrupt` input\n * request whose payload carries the Athena `hitl_approval` shape\n * (`athena_deep_agent/hitl_bridge.py`). A surface answers it with\n * `{ type: 'run/input', requestId, response: { type: 'resume', value } }` —\n * the exact command the backend's resume path consumes. This module holds the\n * payload contract (narrowing, resume values) and the shared resume-lock state\n * machine; rendering stays with each surface.\n *\n * Deliberately parameterized rather than self-wiring: these helpers never call\n * `useStatewireRuns`/`useAuiState` themselves. Each surface reads its own\n * statewire hooks (which its tests already mock) and passes the values in, so\n * the shared semantics cannot drift while per-surface wiring stays testable.\n */\n\nimport type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { hasClientToolInterruptSource } from './client-tools';\nimport { statewireTransportOutcome } from './errors';\nimport { readDeepAgentStreamValues } from './statewire-state';\n\n/** Human-in-the-loop approval payload the agora deep-agent runtime parks a run\n *  on (shaped by `athena_deep_agent/hitl_bridge.py`). */\nexport interface HitlApprovalPayload {\n  source: string;\n  type: string;\n  message: string;\n  /** Risk headline/facts/warnings, when the host includes them. */\n  approval_context?: unknown;\n  context?: {\n    tool_name?: string;\n    tool_id?: string;\n    tool_call_id?: string;\n    tool_args?: Record<string, unknown>;\n    pending_action_count?: number;\n    approval_context?: unknown;\n    /**\n     * Every pending gated call (name + args), in decision order. Absent on\n     * older backends — fall back to the single `tool_name`/`tool_args` pair.\n     * Per-dispatch payloads also carry each lane's `tool_call_id` (the lane\n     * card key) and `interrupt_id` (the lane resume key).\n     */\n    action_requests?: {\n      name?: string;\n      args?: Record<string, unknown>;\n      tool_call_id?: string;\n      interrupt_id?: string;\n      /**\n       * True when \"approve all for this session\" would take effect for this\n       * tool (the workspace allows overriding its approval). Absent on older\n       * backends and on non-overridable tools: the option is not offered.\n       */\n      session_approval_allowed?: boolean;\n      /**\n       * The decision types the parked gate accepts for this call (`approve`,\n       * `reject`, `edit`). Absent on older backends: only approve / reject\n       * are known to be accepted.\n       */\n      allowed_decisions?: string[];\n      /** What the backend resolved about this call before asking (display-only). */\n      approval_context?: unknown;\n    }[];\n    /**\n     * True when each dispatch parked on its own interrupt: decisions submit\n     * per lane via `lane_decisions` and each approved lane starts immediately,\n     * instead of the legacy batch where one resume must answer every lane.\n     */\n    per_dispatch?: boolean;\n  };\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/** A pending `interrupt` input request; a present `response` key marks it answered. */\nexport function isPendingInterrupt(\n  request: StatewireThread.InputRequestState,\n): request is StatewireThread.CustomInputRequest {\n  return request.type === 'interrupt' && !('response' in request);\n}\n\n/**\n * Interrupt sources that were system pauses before the host stamped\n * `requires_user_action: false` on them (a background deep-research wait). Kept\n * only for the deploy skew between an older agora and a newer client; delete\n * once every deployment's raiser stamps the flag.\n */\nconst LEGACY_SYSTEM_PAUSE_INTERRUPT_SOURCES: ReadonlySet<string> = new Set(['deep_research_pending']);\n\n/**\n * A park nobody answers: the agent is still working (a background research\n * wait) and the backend resumes it itself. The raiser stamps\n * `requires_user_action: false`; older raisers are recognised by source.\n */\nexport function isSystemPauseInterrupt(payload: unknown): boolean {\n  if (!isRecord(payload)) return false;\n  if (payload.requires_user_action === false) return true;\n  return (\n    typeof payload.source === 'string' && LEGACY_SYSTEM_PAUSE_INTERRUPT_SOURCES.has(payload.source)\n  );\n}\n\n/**\n * A pending interrupt an approval card may answer. Two kinds are excluded —\n * client-tool parks (the client-tool bridge owns those, and a generic resume\n * would corrupt the parked tool call) and system pauses (nothing to answer; the\n * backend resumes them). The source checks are deliberately loose so a skewed\n * deploy can never route one here.\n */\nexport function isApprovalCardInterrupt(\n  request: StatewireThread.InputRequestState,\n): request is StatewireThread.CustomInputRequest {\n  if (!isPendingInterrupt(request)) return false;\n  const payload = (request as { payload?: unknown }).payload;\n  return !hasClientToolInterruptSource(payload) && !isSystemPauseInterrupt(payload);\n}\n\n/** Narrow an interrupt payload to the Athena HITL approval shape. */\nexport function asHitlApproval(value: unknown): HitlApprovalPayload | null {\n  if (!isRecord(value)) return null;\n  return value.type === 'hitl' &&\n    value.source === 'hitl_approval' &&\n    typeof value.message === 'string'\n    ? (value as unknown as HitlApprovalPayload)\n    : null;\n}\n\n/** Default paused-run copy when an interrupt payload carries no message. */\nexport const DEFAULT_INTERRUPT_PAUSED_MESSAGE =\n  'The agent is paused and waiting for input.';\n\n/** Best-effort human-readable message from any interrupt payload. */\nexport function readInterruptMessage(\n  value: unknown,\n  fallback: string = DEFAULT_INTERRUPT_PAUSED_MESSAGE,\n): string {\n  if (isRecord(value) && typeof value.message === 'string' && value.message.length > 0) {\n    return value.message;\n  }\n  return fallback;\n}\n\n/** One label/value row of a call's resolved approval facts. */\nexport interface PendingApprovalFact {\n  label: string;\n  value: string;\n}\n\n/** One caution of a call's resolved approval facts. */\nexport interface PendingApprovalWarning {\n  severity: 'info' | 'warning' | 'critical';\n  message: string;\n}\n\nexport interface PendingApprovalSlackTarget {\n  catalog_id: string;\n  conversation_id: string | null;\n  thread_ts: string | null;\n  team_url: string | null;\n  people: string[];\n}\n\n/**\n * What the backend resolved about a gated call before asking — e.g. where a\n * Slack write goes and as whom (agora `services/interrupts/approval_context.py`).\n * Display-only; the decision still answers the parked call.\n */\nexport interface PendingApprovalContext {\n  facts: PendingApprovalFact[];\n  warnings: PendingApprovalWarning[];\n  slack_target?: PendingApprovalSlackTarget;\n}\n\nconst APPROVAL_WARNING_SEVERITIES = new Set(['info', 'warning', 'critical']);\n\nfunction isNullableString(value: unknown): value is string | null {\n  return value === null || typeof value === 'string';\n}\n\nfunction isStringArray(value: unknown): value is string[] {\n  return Array.isArray(value) && value.every((entry) => typeof entry === 'string');\n}\n\nfunction parsePendingApprovalSlackTarget(value: unknown): PendingApprovalSlackTarget | undefined {\n  if (!isRecord(value) || typeof value.catalog_id !== 'string') return undefined;\n  const conversationId = value.conversation_id;\n  const threadTs = value.thread_ts;\n  const teamUrl = value.team_url;\n  const people = value.people === undefined ? [] : value.people;\n  if (\n    !isNullableString(conversationId) ||\n    !isNullableString(threadTs) ||\n    !isNullableString(teamUrl) ||\n    !isStringArray(people)\n  )\n    return undefined;\n  return {\n    catalog_id: value.catalog_id,\n    conversation_id: conversationId,\n    thread_ts: threadTs,\n    team_url: teamUrl,\n    people,\n  };\n}\n\n/** A call's `approval_context`, or `undefined` when absent or empty. */\nexport function parsePendingApprovalContext(value: unknown): PendingApprovalContext | undefined {\n  if (!isRecord(value)) return undefined;\n  const facts: PendingApprovalFact[] = Array.isArray(value.facts)\n    ? value.facts.flatMap((fact) =>\n        isRecord(fact) && typeof fact.label === 'string' && typeof fact.value === 'string'\n          ? [{ label: fact.label, value: fact.value }]\n          : [],\n      )\n    : [];\n  const warnings: PendingApprovalWarning[] = Array.isArray(value.warnings)\n    ? value.warnings.flatMap((warning) => {\n        if (!isRecord(warning) || typeof warning.message !== 'string') return [];\n        const severity =\n          typeof warning.severity === 'string' && APPROVAL_WARNING_SEVERITIES.has(warning.severity)\n            ? (warning.severity as PendingApprovalWarning['severity'])\n            : 'info';\n        return [{ severity, message: warning.message }];\n      })\n    : [];\n  const slackTarget = parsePendingApprovalSlackTarget(value.slack_target);\n  return facts.length > 0 || warnings.length > 0 || slackTarget\n    ? { facts, warnings, ...(slackTarget ? { slack_target: slackTarget } : {}) }\n    : undefined;\n}\n\nexport interface PendingActionRequest {\n  name: string;\n  args: Record<string, unknown>;\n  /** The lane's `task` tool-call id (present on per-dispatch payloads). */\n  toolCallId?: string;\n  /** The lane's langgraph interrupt id — the `lane_decisions` resume key. */\n  interruptId?: string;\n  /** Present (true) when a session-wide approval would cover later calls of this tool. */\n  sessionApprovalAllowed?: true;\n  /** Present (true) when the gate accepts an `edit` decision for this call. */\n  editAllowed?: true;\n  /** Present when the backend resolved facts about this call before asking. */\n  approvalContext?: PendingApprovalContext;\n}\n\n/**\n * Every gated call this approval covers, in decision order. One resume answers\n * ALL of them, so every entry must stay reviewable somewhere. Falls back to\n * the single first-call fields on older backends without `action_requests`.\n */\nexport function pendingActionRequests(hitl: HitlApprovalPayload | null): PendingActionRequest[] {\n  const context = hitl?.context;\n  if (!context) return [];\n  // The payload crosses the wire with only its top-level shape narrowed\n  // (`asHitlApproval`), so the nested collection must be validated before any\n  // array/property access: a malformed host value must degrade to \"no\n  // reviewable entries\", never crash the approval surface.\n  const requests: Record<string, unknown>[] = Array.isArray(context.action_requests)\n    ? context.action_requests.filter(isRecord)\n    : context.tool_name && context.tool_args\n      ? [{ name: context.tool_name, args: context.tool_args, tool_call_id: context.tool_call_id }]\n      : [];\n  return requests.map((request) => {\n    const approvalContext = parsePendingApprovalContext(request.approval_context);\n    return {\n    name: typeof request.name === 'string' ? request.name : 'tool',\n    args: isRecord(request.args) ? request.args : {},\n    ...(typeof request.tool_call_id === 'string' && { toolCallId: request.tool_call_id }),\n    ...(typeof request.interrupt_id === 'string' && { interruptId: request.interrupt_id }),\n    ...(request.session_approval_allowed === true && { sessionApprovalAllowed: true }),\n    ...(Array.isArray(request.allowed_decisions) &&\n      request.allowed_decisions.includes('edit') && { editAllowed: true }),\n    ...(approvalContext && { approvalContext }),\n    };\n  });\n}\n\n/**\n * Whether the card may offer \"approve all for this session\": every pending\n * call must be one the backend stamped as session-approvable, so a batch that\n * mixes in a tool the workspace pinned as always-prompt only offers the\n * one-time answer.\n */\nexport function canApproveForSession(actionRequests: readonly PendingActionRequest[]): boolean {\n  return (\n    actionRequests.length > 0 &&\n    actionRequests.every((request) => request.sessionApprovalAllowed === true)\n  );\n}\n\n/** An interrupt a non-resume dispatch dropped, published by the host. */\nexport interface AbandonedInputRequest {\n  id: string;\n  type: string;\n}\n\n/**\n * `useStatewireState` selector body for the host-published abandoned input\n * requests. Reads through {@link readDeepAgentStreamValues} so the selector is\n * safe on the pre-attach (`undefined`) wire state, and returns the raw array\n * reference so the subscription stays shallow-stable — derive (`.find`) on the\n * result, never inside the selector.\n */\nexport function readAbandonedInputRequests(\n  state: unknown,\n): readonly AbandonedInputRequest[] | undefined {\n  const abandoned = readDeepAgentStreamValues(state).abandonedInputRequests;\n  // Wire value: anything non-array (including a malformed host publication)\n  // reads as \"none\" rather than crashing the consuming surface. Identity-\n  // preserving for the valid case, so it stays selector-safe.\n  return Array.isArray(abandoned)\n    ? (abandoned as readonly AbandonedInputRequest[])\n    : undefined;\n}\n\n/**\n * `useStatewireState` selector body for the host's mirrored interrupt\n * (`__interrupt__`, the LangGraph `{value, resumable}` wrapper). The mirror\n * is published the moment a lane parks on its gate — while sibling lanes are\n * still streaming and the run manager has NOT yet published an answerable\n * input request. Raw reference, selector-safe; unwrap with\n * {@link interruptMirrorPayload}.\n */\nexport function readInterruptMirror(state: unknown): unknown {\n  return readDeepAgentStreamValues(state).__interrupt__;\n}\n\n/** The payload of a mirrored interrupt wrapper, or `undefined` for anything else. */\nexport function interruptMirrorPayload(mirror: unknown): unknown {\n  return isRecord(mirror) ? mirror.value : undefined;\n}\n\n/**\n * `useStatewireState` selector body for the per-dispatch lane decisions the\n * host accepted through `run/lane-input` while the run was still streaming\n * (`queuedLaneDecisions`, keyed by langgraph interrupt id). Held until the\n * run parks, then answered as a native `lane_decisions` resume; every attached\n * client reads a queued lane as decided. Raw reference, selector-safe.\n */\nexport function readQueuedLaneDecisions(\n  state: unknown,\n): Readonly<Record<string, unknown>> | undefined {\n  const queued = readDeepAgentStreamValues(state).queuedLaneDecisions;\n  return isRecord(queued) ? queued : undefined;\n}\n\n/**\n * The distinct langgraph interrupt ids a `lane_decisions` resume answers for\n * these gated calls, in first-seen order — or `null` when any call lacks its\n * stamp (a legacy batch payload only a positional resume can answer). A\n * nested HITL request gating several calls contributes one id: the lane is\n * the interrupt, and one decision fans across its calls server-side.\n */\nexport function laneInterruptIds(actionRequests: readonly PendingActionRequest[]): string[] | null {\n  if (actionRequests.length === 0) return null;\n  const ids: string[] = [];\n  for (const request of actionRequests) {\n    if (request.interruptId === undefined) return null;\n    if (!ids.includes(request.interruptId)) ids.push(request.interruptId);\n  }\n  return ids;\n}\n\nconst NO_TOOL_CALL_IDS: ReadonlySet<string> = new Set();\n\n/**\n * The gated calls still waiting on a person, by `tool_call_id`: every call of\n * the approval on screen (the parked request's, or the host's mirror while\n * sibling lanes still stream), less the lanes whose decision the host already\n * holds (`queuedLaneDecisions`, keyed by interrupt id): a lane decided live\n * waits for the run to park, not for anyone. The id is the one join between an\n * approval and the call it gates (a payload names no lane), so a call without\n * one counts for nothing.\n */\nexport function toolCallIdsAwaitingApproval({\n  actionRequests,\n  queuedLaneDecisions,\n}: {\n  actionRequests: readonly PendingActionRequest[];\n  queuedLaneDecisions?: Readonly<Record<string, unknown>>;\n}): ReadonlySet<string> {\n  let ids: Set<string> | undefined;\n  for (const request of actionRequests) {\n    if (request.toolCallId === undefined) continue;\n    if (\n      request.interruptId !== undefined &&\n      queuedLaneDecisions !== undefined &&\n      request.interruptId in queuedLaneDecisions\n    ) {\n      continue;\n    }\n    ids ??= new Set();\n    ids.add(request.toolCallId);\n  }\n  return ids ?? NO_TOOL_CALL_IDS;\n}\n\n/** One decision for every lane — the `lane_decisions` map a run-wide approve or reject sends. */\nexport function fanLaneDecision<T>({\n  interruptIds,\n  decision,\n}: {\n  interruptIds: readonly string[];\n  decision: T;\n}): Record<string, T> {\n  return Object.fromEntries(interruptIds.map((id) => [id, decision]));\n}\n\n/** The abandoned `interrupt` entry, if any — the \"approval was cancelled\" notice. */\nexport function findAbandonedInterrupt(\n  abandoned: readonly AbandonedInputRequest[] | undefined,\n): AbandonedInputRequest | undefined {\n  return abandoned?.find(\n    (request) => isRecord(request) && request.type === 'interrupt' && typeof request.id === 'string',\n  );\n}\n\n/** Canonical reason string carried by a user rejection. */\nexport const HITL_REJECT_REASON = 'User rejected the action.';\n\n/**\n * Default {@link UseApprovalResumeLockOptions.pendingResumeGraceMs} for every\n * approval surface: how long a clicked decision waits for its resume run to\n * start before the actions unlock again. Covers a `run/input` the host\n * rejected or a disconnected transport swallowed before any run began — the\n * one failure neither identity-change nor observed-run recovery can detect.\n */\nexport const HITL_PENDING_RESUME_GRACE_MS = 15_000;\n\n/**\n * Default {@link UseApprovalResumeLockOptions.maxTransportRetries}: how many\n * times a decision the transport lost (the websocket dropped or the statewire\n * session reset while the `run/input` was in flight) is re-sent on its own\n * before the user is asked to click again.\n */\nexport const HITL_RESUME_TRANSPORT_RETRIES = 3;\n\n/**\n * The dispatch died client-side without the host ever seeing it — a proven\n * session loss or a gone stream. Safe to re-send the same decision for the\n * same still-parked request. The complement (a server verdict, or the surface\n * unmounting) is not.\n */\nexport function isResumeTransportLoss(error: unknown): boolean {\n  const outcome = statewireTransportOutcome(error);\n  return outcome === 'session-lost' || outcome === 'stream-gone';\n}\n\n/** `run/input` resume value approving the gated call(s). */\nexport function hitlResumeApprove(): Record<string, string> {\n  return { action: 'approve' };\n}\n\n/**\n * `run/input` resume value approving the gated call(s) AND every later call of\n * the same tool(s) on this thread. The backend records the tools from its own\n * parked interrupt (never from this payload), so the value carries no names.\n */\nexport function hitlResumeApproveForSession(): Record<string, string> {\n  return { action: 'approve', scope: 'session' };\n}\n\n/** `run/input` resume value rejecting the gated call(s). */\nexport function hitlResumeReject(reason: string = HITL_REJECT_REASON): Record<string, string> {\n  return { action: 'reject', reason };\n}\n\n/** One gated call's own answer inside a per-action resume ({@link hitlResumeActionDecisions}). */\nexport type HitlActionDecision =\n  | { action: 'approve' }\n  | { action: 'reject'; reason: string }\n  | { action: 'edit'; edited_args: Record<string, unknown> };\n\n/**\n * The `tool_call_id` of every gated call, in decision order — or `null` when\n * any call lacks one or two calls share one, in which case no per-action\n * resume can be bound to the batch and only the batch answers above apply.\n */\nexport function actionRequestToolCallIds(\n  actionRequests: readonly PendingActionRequest[],\n): string[] | null {\n  if (actionRequests.length === 0) return null;\n  const ids: string[] = [];\n  for (const request of actionRequests) {\n    if (request.toolCallId === undefined || ids.includes(request.toolCallId)) return null;\n    ids.push(request.toolCallId);\n  }\n  return ids;\n}\n\n/**\n * `run/input` resume value deciding each gated call by its `tool_call_id` —\n * the only channel that carries an edited call. The backend binds every entry\n * to the parked request with that id, takes the tool NAME from its own\n * request (an edit can change a call's arguments, never which tool runs), and\n * refuses the whole answer — nothing runs — unless the map names exactly the\n * parked calls. `edited_args` is the complete argument set the call runs\n * with, not a patch. The envelope `action` mirrors the first entry for hosts\n * that only read the envelope; `action_decisions` is authoritative.\n */\nexport function hitlResumeActionDecisions(\n  decisions: Readonly<Record<string, HitlActionDecision>>,\n): Record<string, unknown> {\n  const [anchorId, anchor] = Object.entries(decisions)[0] ?? [];\n  return {\n    action: anchor?.action === 'reject' ? 'reject' : 'approve',\n    ...(anchorId !== undefined && { tool_call_id: anchorId }),\n    action_decisions: decisions,\n  };\n}\n\n/** Canonical reason string carried by a user declining a non-HITL park. */\nexport const INTERRUPT_DECLINE_REASON = 'User declined the request.';\n\n/**\n * `run/input` resume value declining a non-HITL park. `{ action: 'reject' }`\n * is the one value every typed raiser treats as a clean user decline\n * (`FormCancelledError` / `ToolRejectedError`); a generic `continue` would be\n * rejected by their resume schemas and surface as a tool error the agent then\n * improvises around.\n */\nexport function interruptResumeDecline(\n  reason: string = INTERRUPT_DECLINE_REASON,\n): Record<string, string> {\n  return { action: 'reject', reason };\n}\n\nexport interface UseApprovalResumeLockOptions<TValue> {\n  /** The pending interrupt's request id (`undefined` when nothing is parked). */\n  requestId: string | undefined;\n  /** The surface's thread `isRunning` read (mockable per surface). */\n  isRunning: boolean;\n  /**\n   * Dispatch the `run/input` resume for `requestId` on the surface's transport.\n   * Return the dispatch promise so a refused or lost command releases the lock\n   * at once and reaches `onResumeRejected`; a `void` return leaves the\n   * recovery paths below as the only release.\n   */\n  sendResume: (requestId: string, value: TValue) => void | Promise<unknown>;\n  /**\n   * The dispatch `sendResume` returned rejected — the host refused the\n   * `run/input` or the transport lost it. The lock is already released when\n   * this fires; the surface tells the user, since the request is back on\n   * screen with nothing else saying why.\n   */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /**\n   * A dispatch the transport lost is being re-sent for the still-parked\n   * request; `attempt` counts the retries so far (1-based). Diagnostics only —\n   * the lock stays held across the retry.\n   */\n  onResumeRetry?: (error: unknown, requestId: string, attempt: number) => void;\n  /**\n   * Automatic re-sends of a decision the transport lost\n   * ({@link isResumeTransportLoss}) while the request is still parked. `0`\n   * disables retries. Defaults to {@link HITL_RESUME_TRANSPORT_RETRIES}.\n   */\n  maxTransportRetries?: number;\n  /**\n   * Re-enable the actions when no resume run started within this window —\n   * covers a `run/input` that was rejected or lost before any run began, so\n   * neither reset path below can fire. Omit to keep the pre-existing surface\n   * behavior of staying locked until a resume run is observed.\n   */\n  pendingResumeGraceMs?: number;\n}\n\nexport interface ApprovalResumeLock<TValue> {\n  /** True after a resume until the request identity changes (or recovery fires). */\n  pending: boolean;\n  /**\n   * Send the resume value, locking the actions. No-op (returns `undefined`)\n   * while pending or unparked. Returns the dispatch promise when `sendResume`\n   * produced one, so a surface can hold its own state until the host settles.\n   */\n  resume: (value: TValue) => Promise<unknown> | undefined;\n}\n\n/**\n * Optimistic action lock shared by every approval surface: disable the\n * decision buttons the moment one is clicked, until the request identity\n * changes (it clears after the resume, or a fresh interrupt arrives). This\n * closes the double-click → duplicate-resume window.\n *\n * Recovery paths, in order of specificity:\n * 0. The dispatch itself rejected (a `sendResume` that returned a promise) —\n *    released at once, and reported through `onResumeRejected`. A rejection\n *    that is a transport loss (the socket dropped mid-flight) is re-sent up to\n *    `maxTransportRetries` times first, the lock held throughout, so a flaky\n *    connection does not hand the card back to the user for another click.\n *    The returned promise settles with the final attempt.\n * 1. Identity change — the resume landed (or a new interrupt replaced the\n *    request). Reset during render via React's \"previous value\" pattern.\n * 2. A resume run was observed starting and then settling with the request\n *    still pending (failed/cancelled resume) — clear the lock so the user can\n *    answer again.\n * 3. Optional grace window ({@link UseApprovalResumeLockOptions.pendingResumeGraceMs})\n *    for a `run/input` that never started a run at all.\n */\nexport function useApprovalResumeLock<TValue = Record<string, string>>(\n  options: UseApprovalResumeLockOptions<TValue>,\n): ApprovalResumeLock<TValue> {\n  const {\n    requestId,\n    isRunning,\n    sendResume,\n    pendingResumeGraceMs,\n    onResumeRejected,\n    onResumeRetry,\n    maxTransportRetries = HITL_RESUME_TRANSPORT_RETRIES,\n  } = options;\n\n  const [pending, setPending] = useState(false);\n  // Bumped per re-send so the grace window restarts with each attempt.\n  const [attempt, setAttempt] = useState(0);\n  const prevRequestIdRef = useRef(requestId);\n  if (prevRequestIdRef.current !== requestId) {\n    prevRequestIdRef.current = requestId;\n    if (pending) setPending(false);\n  }\n\n  // Track the resume run we kicked off (isRunning observed true→false while\n  // pending) and clear `pending` when it ends with the request unresolved.\n  const sawResumeRunRef = useRef(false);\n  useEffect(() => {\n    if (!pending) {\n      sawResumeRunRef.current = false;\n      return;\n    }\n    if (isRunning) {\n      sawResumeRunRef.current = true;\n      return;\n    }\n    if (sawResumeRunRef.current) {\n      sawResumeRunRef.current = false;\n      setPending(false);\n    }\n  }, [pending, isRunning]);\n\n  // Pre-start failure recovery: re-enable after the grace window when no\n  // resume run began; answering the still-parked request again is exactly\n  // what the user needs to be able to do.\n  useEffect(() => {\n    if (!pending || pendingResumeGraceMs === undefined) return;\n    const timer = setTimeout(() => {\n      if (!sawResumeRunRef.current) setPending(false);\n    }, pendingResumeGraceMs);\n    return () => clearTimeout(timer);\n  }, [pending, requestId, pendingResumeGraceMs, attempt]);\n\n  const sendResumeRef = useRef(sendResume);\n  sendResumeRef.current = sendResume;\n  const onResumeRejectedRef = useRef(onResumeRejected);\n  onResumeRejectedRef.current = onResumeRejected;\n  const onResumeRetryRef = useRef(onResumeRetry);\n  onResumeRetryRef.current = onResumeRetry;\n  const maxTransportRetriesRef = useRef(maxTransportRetries);\n  maxTransportRetriesRef.current = maxTransportRetries;\n  const currentRequestIdRef = useRef(requestId);\n  currentRequestIdRef.current = requestId;\n  const pendingRef = useRef(pending);\n  pendingRef.current = pending;\n  // One token per `resume` call: a settle from an earlier submission must not\n  // retry over, or release, a newer one for the same request.\n  const submissionRef = useRef(0);\n\n  const resume = useCallback(\n    (value: TValue): Promise<unknown> | undefined => {\n      if (requestId === undefined || pendingRef.current) return undefined;\n      const submission = ++submissionRef.current;\n      setPending(true);\n      pendingRef.current = true;\n      setAttempt(0);\n      const first: unknown = sendResumeRef.current(requestId, value);\n      if (!(first instanceof Promise)) return undefined;\n      // The final failure is already reported through `onResumeRejected`;\n      // callers that drop the promise must not get an unhandled rejection.\n      const outcome = new Promise<unknown>((resolve, reject) => {\n        const settle = (dispatched: Promise<unknown>, retries: number) => {\n          dispatched.then(resolve, (error: unknown) => {\n            // A late refusal for a request the lock has since moved past (the\n            // park was re-keyed, or a newer answer is in flight) must neither\n            // release that answer's lock nor be reported as a failure of it.\n            // The optimistic fold hides the answered request until the fold\n            // rolls back, so `undefined` here is not a departure.\n            const current = currentRequestIdRef.current;\n            if (\n              submission !== submissionRef.current ||\n              (current !== undefined && current !== requestId)\n            ) {\n              reject(error);\n              return;\n            }\n            if (retries < maxTransportRetriesRef.current && isResumeTransportLoss(error)) {\n              const next = retries + 1;\n              onResumeRetryRef.current?.(error, requestId, next);\n              setPending(true);\n              pendingRef.current = true;\n              setAttempt(next);\n              const resent: unknown = sendResumeRef.current(requestId, value);\n              if (resent instanceof Promise) {\n                settle(resent, next);\n                return;\n              }\n              resolve(undefined);\n              return;\n            }\n            setPending(false);\n            pendingRef.current = false;\n            onResumeRejectedRef.current?.(error, requestId);\n            reject(error);\n          });\n        };\n        settle(first, 0);\n      });\n      outcome.catch(() => {});\n      return outcome;\n    },\n    [requestId],\n  );\n\n  return { pending, resume };\n}\n"],"names":["hasClientToolInterruptSource","readDeepAgentStreamValues","statewireTransportOutcome","useState","useRef","useEffect","useCallback"],"mappings":"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"}
+{"version":3,"file":"interrupts.cjs","sources":["../../../../agent-runtime/src/interrupts.ts"],"sourcesContent":["/**\n * Human-in-the-loop interrupt primitives shared by every statewire chat\n * surface (Olympus, the React SDK, the Office add-in, the Chrome extension,\n * mobile).\n *\n * The agora deep-agent runtime parks a gated run on an `interrupt` input\n * request whose payload carries the Athena `hitl_approval` shape\n * (`athena_deep_agent/hitl_bridge.py`). A surface answers it with\n * `{ type: 'run/input', requestId, response: { type: 'resume', value } }` —\n * the exact command the backend's resume path consumes. This module holds the\n * payload contract (narrowing, resume values) and the shared resume-lock state\n * machine; rendering stays with each surface.\n *\n * Deliberately parameterized rather than self-wiring: these helpers never call\n * `useStatewireRuns`/`useAuiState` themselves. Each surface reads its own\n * statewire hooks (which its tests already mock) and passes the values in, so\n * the shared semantics cannot drift while per-surface wiring stays testable.\n */\n\nimport type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { hasClientToolInterruptSource } from './client-tools';\nimport { statewireTransportOutcome } from './errors';\nimport { readDeepAgentStreamValues } from './statewire-state';\n\n/** Human-in-the-loop approval payload the agora deep-agent runtime parks a run\n *  on (shaped by `athena_deep_agent/hitl_bridge.py`). */\nexport interface HitlApprovalPayload {\n  source: string;\n  type: string;\n  message: string;\n  /** Risk headline/facts/warnings, when the host includes them. */\n  approval_context?: unknown;\n  context?: {\n    tool_name?: string;\n    tool_id?: string;\n    tool_call_id?: string;\n    tool_args?: Record<string, unknown>;\n    pending_action_count?: number;\n    approval_context?: unknown;\n    /**\n     * Every pending gated call (name + args), in decision order. Absent on\n     * older backends — fall back to the single `tool_name`/`tool_args` pair.\n     * Per-dispatch payloads also carry each lane's `tool_call_id` (the lane\n     * card key) and `interrupt_id` (the lane resume key).\n     */\n    action_requests?: {\n      name?: string;\n      args?: Record<string, unknown>;\n      tool_call_id?: string;\n      interrupt_id?: string;\n      /**\n       * True when \"approve all for this session\" would take effect for this\n       * tool (the workspace allows overriding its approval). Absent on older\n       * backends and on non-overridable tools: the option is not offered.\n       */\n      session_approval_allowed?: boolean;\n      /**\n       * The decision types the parked gate accepts for this call (`approve`,\n       * `reject`, `edit`). Absent on older backends: only approve / reject\n       * are known to be accepted.\n       */\n      allowed_decisions?: string[];\n      /** What the backend resolved about this call before asking (display-only). */\n      approval_context?: unknown;\n    }[];\n    /**\n     * True when each dispatch parked on its own interrupt: decisions submit\n     * per lane via `lane_decisions` and each approved lane starts immediately,\n     * instead of the legacy batch where one resume must answer every lane.\n     */\n    per_dispatch?: boolean;\n  };\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/** A pending `interrupt` input request; a present `response` key marks it answered. */\nexport function isPendingInterrupt(\n  request: StatewireThread.InputRequestState,\n): request is StatewireThread.CustomInputRequest {\n  return request.type === 'interrupt' && !('response' in request);\n}\n\n/**\n * Interrupt sources that were system pauses before the host stamped\n * `requires_user_action: false` on them (a background deep-research wait). Kept\n * only for the deploy skew between an older agora and a newer client; delete\n * once every deployment's raiser stamps the flag.\n */\nconst LEGACY_SYSTEM_PAUSE_INTERRUPT_SOURCES: ReadonlySet<string> = new Set(['deep_research_pending']);\n\n/**\n * A park nobody answers: the agent is still working (a background research\n * wait) and the backend resumes it itself. The raiser stamps\n * `requires_user_action: false`; older raisers are recognised by source.\n */\nexport function isSystemPauseInterrupt(payload: unknown): boolean {\n  if (!isRecord(payload)) return false;\n  if (payload.requires_user_action === false) return true;\n  return (\n    typeof payload.source === 'string' && LEGACY_SYSTEM_PAUSE_INTERRUPT_SOURCES.has(payload.source)\n  );\n}\n\n/**\n * A pending interrupt an approval card may answer. Two kinds are excluded —\n * client-tool parks (the client-tool bridge owns those, and a generic resume\n * would corrupt the parked tool call) and system pauses (nothing to answer; the\n * backend resumes them). The source checks are deliberately loose so a skewed\n * deploy can never route one here.\n */\nexport function isApprovalCardInterrupt(\n  request: StatewireThread.InputRequestState,\n): request is StatewireThread.CustomInputRequest {\n  if (!isPendingInterrupt(request)) return false;\n  const payload = (request as { payload?: unknown }).payload;\n  return !hasClientToolInterruptSource(payload) && !isSystemPauseInterrupt(payload);\n}\n\n/** Narrow an interrupt payload to the Athena HITL approval shape. */\nexport function asHitlApproval(value: unknown): HitlApprovalPayload | null {\n  if (!isRecord(value)) return null;\n  return value.type === 'hitl' &&\n    value.source === 'hitl_approval' &&\n    typeof value.message === 'string'\n    ? (value as unknown as HitlApprovalPayload)\n    : null;\n}\n\n/** Default paused-run copy when an interrupt payload carries no message. */\nexport const DEFAULT_INTERRUPT_PAUSED_MESSAGE =\n  'The agent is paused and waiting for input.';\n\n/** Best-effort human-readable message from any interrupt payload. */\nexport function readInterruptMessage(\n  value: unknown,\n  fallback: string = DEFAULT_INTERRUPT_PAUSED_MESSAGE,\n): string {\n  if (isRecord(value) && typeof value.message === 'string' && value.message.length > 0) {\n    return value.message;\n  }\n  return fallback;\n}\n\n/** One label/value row of a call's resolved approval facts. */\nexport interface PendingApprovalFact {\n  label: string;\n  value: string;\n}\n\n/** One caution of a call's resolved approval facts. */\nexport interface PendingApprovalWarning {\n  severity: 'info' | 'warning' | 'critical';\n  message: string;\n}\n\nexport interface PendingApprovalSlackTarget {\n  catalog_id: string;\n  conversation_id: string | null;\n  thread_ts: string | null;\n  team_url: string | null;\n  people: string[];\n}\n\n/**\n * What the backend resolved about a gated call before asking — e.g. where a\n * Slack write goes and as whom (agora `services/interrupts/approval_context.py`).\n * Display-only; the decision still answers the parked call.\n */\nexport interface PendingApprovalContext {\n  facts: PendingApprovalFact[];\n  warnings: PendingApprovalWarning[];\n  slack_target?: PendingApprovalSlackTarget;\n}\n\nconst APPROVAL_WARNING_SEVERITIES = new Set(['info', 'warning', 'critical']);\n\nfunction isNullableString(value: unknown): value is string | null {\n  return value === null || typeof value === 'string';\n}\n\nfunction isStringArray(value: unknown): value is string[] {\n  return Array.isArray(value) && value.every((entry) => typeof entry === 'string');\n}\n\nfunction parsePendingApprovalSlackTarget(value: unknown): PendingApprovalSlackTarget | undefined {\n  if (!isRecord(value) || typeof value.catalog_id !== 'string') return undefined;\n  const conversationId = value.conversation_id;\n  const threadTs = value.thread_ts;\n  const teamUrl = value.team_url;\n  const people = value.people === undefined ? [] : value.people;\n  if (\n    !isNullableString(conversationId) ||\n    !isNullableString(threadTs) ||\n    !isNullableString(teamUrl) ||\n    !isStringArray(people)\n  )\n    return undefined;\n  return {\n    catalog_id: value.catalog_id,\n    conversation_id: conversationId,\n    thread_ts: threadTs,\n    team_url: teamUrl,\n    people,\n  };\n}\n\n/** A call's `approval_context`, or `undefined` when absent or empty. */\nexport function parsePendingApprovalContext(value: unknown): PendingApprovalContext | undefined {\n  if (!isRecord(value)) return undefined;\n  const facts: PendingApprovalFact[] = Array.isArray(value.facts)\n    ? value.facts.flatMap((fact) =>\n        isRecord(fact) && typeof fact.label === 'string' && typeof fact.value === 'string'\n          ? [{ label: fact.label, value: fact.value }]\n          : [],\n      )\n    : [];\n  const warnings: PendingApprovalWarning[] = Array.isArray(value.warnings)\n    ? value.warnings.flatMap((warning) => {\n        if (!isRecord(warning) || typeof warning.message !== 'string') return [];\n        const severity =\n          typeof warning.severity === 'string' && APPROVAL_WARNING_SEVERITIES.has(warning.severity)\n            ? (warning.severity as PendingApprovalWarning['severity'])\n            : 'info';\n        return [{ severity, message: warning.message }];\n      })\n    : [];\n  const slackTarget = parsePendingApprovalSlackTarget(value.slack_target);\n  return facts.length > 0 || warnings.length > 0 || slackTarget\n    ? { facts, warnings, ...(slackTarget ? { slack_target: slackTarget } : {}) }\n    : undefined;\n}\n\nexport interface PendingActionRequest {\n  name: string;\n  args: Record<string, unknown>;\n  /** The lane's `task` tool-call id (present on per-dispatch payloads). */\n  toolCallId?: string;\n  /** The lane's langgraph interrupt id — the `lane_decisions` resume key. */\n  interruptId?: string;\n  /** Present (true) when a session-wide approval would cover later calls of this tool. */\n  sessionApprovalAllowed?: true;\n  /** Present (true) when the gate accepts an `edit` decision for this call. */\n  editAllowed?: true;\n  /** Present when the backend resolved facts about this call before asking. */\n  approvalContext?: PendingApprovalContext;\n}\n\n/**\n * Every gated call this approval covers, in decision order. One resume answers\n * ALL of them, so every entry must stay reviewable somewhere. Falls back to\n * the single first-call fields on older backends without `action_requests`.\n */\nexport function pendingActionRequests(hitl: HitlApprovalPayload | null): PendingActionRequest[] {\n  const context = hitl?.context;\n  if (!context) return [];\n  // The payload crosses the wire with only its top-level shape narrowed\n  // (`asHitlApproval`), so the nested collection must be validated before any\n  // array/property access: a malformed host value must degrade to \"no\n  // reviewable entries\", never crash the approval surface.\n  const requests: Record<string, unknown>[] = Array.isArray(context.action_requests)\n    ? context.action_requests.filter(isRecord)\n    : context.tool_name && context.tool_args\n      ? [{ name: context.tool_name, args: context.tool_args, tool_call_id: context.tool_call_id }]\n      : [];\n  return requests.map((request) => {\n    const approvalContext = parsePendingApprovalContext(request.approval_context);\n    return {\n    name: typeof request.name === 'string' ? request.name : 'tool',\n    args: isRecord(request.args) ? request.args : {},\n    ...(typeof request.tool_call_id === 'string' && { toolCallId: request.tool_call_id }),\n    ...(typeof request.interrupt_id === 'string' && { interruptId: request.interrupt_id }),\n    ...(request.session_approval_allowed === true && { sessionApprovalAllowed: true }),\n    ...(Array.isArray(request.allowed_decisions) &&\n      request.allowed_decisions.includes('edit') && { editAllowed: true }),\n    ...(approvalContext && { approvalContext }),\n    };\n  });\n}\n\n/**\n * Whether the card may offer \"approve all for this session\": every pending\n * call must be one the backend stamped as session-approvable, so a batch that\n * mixes in a tool the workspace pinned as always-prompt only offers the\n * one-time answer.\n */\nexport function canApproveForSession(actionRequests: readonly PendingActionRequest[]): boolean {\n  return (\n    actionRequests.length > 0 &&\n    actionRequests.every((request) => request.sessionApprovalAllowed === true)\n  );\n}\n\n/** An interrupt a non-resume dispatch dropped, published by the host. */\nexport interface AbandonedInputRequest {\n  id: string;\n  type: string;\n}\n\n/**\n * `useStatewireState` selector body for the host-published abandoned input\n * requests. Reads through {@link readDeepAgentStreamValues} so the selector is\n * safe on the pre-attach (`undefined`) wire state, and returns the raw array\n * reference so the subscription stays shallow-stable — derive (`.find`) on the\n * result, never inside the selector.\n */\nexport function readAbandonedInputRequests(\n  state: unknown,\n): readonly AbandonedInputRequest[] | undefined {\n  const abandoned = readDeepAgentStreamValues(state).abandonedInputRequests;\n  // Wire value: anything non-array (including a malformed host publication)\n  // reads as \"none\" rather than crashing the consuming surface. Identity-\n  // preserving for the valid case, so it stays selector-safe.\n  return Array.isArray(abandoned)\n    ? (abandoned as readonly AbandonedInputRequest[])\n    : undefined;\n}\n\n/**\n * `useStatewireState` selector body for the host's mirrored interrupt\n * (`__interrupt__`, the LangGraph `{value, resumable}` wrapper). The mirror\n * is published the moment a lane parks on its gate — while sibling lanes are\n * still streaming and the run manager has NOT yet published an answerable\n * input request. Raw reference, selector-safe; unwrap with\n * {@link interruptMirrorPayload}.\n */\nexport function readInterruptMirror(state: unknown): unknown {\n  return readDeepAgentStreamValues(state).__interrupt__;\n}\n\n/** The payload of a mirrored interrupt wrapper, or `undefined` for anything else. */\nexport function interruptMirrorPayload(mirror: unknown): unknown {\n  return isRecord(mirror) ? mirror.value : undefined;\n}\n\n/**\n * `useStatewireState` selector body for the per-dispatch lane decisions the\n * host accepted through `run/lane-input` while the run was still streaming\n * (`queuedLaneDecisions`, keyed by langgraph interrupt id). Held until the\n * run parks, then answered as a native `lane_decisions` resume; every attached\n * client reads a queued lane as decided. Raw reference, selector-safe.\n */\nexport function readQueuedLaneDecisions(\n  state: unknown,\n): Readonly<Record<string, unknown>> | undefined {\n  const queued = readDeepAgentStreamValues(state).queuedLaneDecisions;\n  return isRecord(queued) ? queued : undefined;\n}\n\n/**\n * The distinct langgraph interrupt ids a `lane_decisions` resume answers for\n * these gated calls, in first-seen order — or `null` when any call lacks its\n * stamp (a legacy batch payload only a positional resume can answer). A\n * nested HITL request gating several calls contributes one id: the lane is\n * the interrupt, and one decision fans across its calls server-side.\n */\nexport function laneInterruptIds(actionRequests: readonly PendingActionRequest[]): string[] | null {\n  if (actionRequests.length === 0) return null;\n  const ids: string[] = [];\n  for (const request of actionRequests) {\n    if (request.interruptId === undefined) return null;\n    if (!ids.includes(request.interruptId)) ids.push(request.interruptId);\n  }\n  return ids;\n}\n\nconst NO_TOOL_CALL_IDS: ReadonlySet<string> = new Set();\n\n/**\n * The gated calls still waiting on a person, by `tool_call_id`: every call of\n * the approval on screen (the parked request's, or the host's mirror while\n * sibling lanes still stream), less the lanes whose decision the host already\n * holds (`queuedLaneDecisions`, keyed by interrupt id): a lane decided live\n * waits for the run to park, not for anyone. The id is the one join between an\n * approval and the call it gates (a payload names no lane), so a call without\n * one counts for nothing.\n */\nexport function toolCallIdsAwaitingApproval({\n  actionRequests,\n  queuedLaneDecisions,\n}: {\n  actionRequests: readonly PendingActionRequest[];\n  queuedLaneDecisions?: Readonly<Record<string, unknown>>;\n}): ReadonlySet<string> {\n  let ids: Set<string> | undefined;\n  for (const request of actionRequests) {\n    if (request.toolCallId === undefined) continue;\n    if (\n      request.interruptId !== undefined &&\n      queuedLaneDecisions !== undefined &&\n      request.interruptId in queuedLaneDecisions\n    ) {\n      continue;\n    }\n    ids ??= new Set();\n    ids.add(request.toolCallId);\n  }\n  return ids ?? NO_TOOL_CALL_IDS;\n}\n\n/** One decision for every lane — the `lane_decisions` map a run-wide approve or reject sends. */\nexport function fanLaneDecision<T>({\n  interruptIds,\n  decision,\n}: {\n  interruptIds: readonly string[];\n  decision: T;\n}): Record<string, T> {\n  return Object.fromEntries(interruptIds.map((id) => [id, decision]));\n}\n\n/** The abandoned `interrupt` entry, if any — the \"approval was cancelled\" notice. */\nexport function findAbandonedInterrupt(\n  abandoned: readonly AbandonedInputRequest[] | undefined,\n): AbandonedInputRequest | undefined {\n  return abandoned?.find(\n    (request) => isRecord(request) && request.type === 'interrupt' && typeof request.id === 'string',\n  );\n}\n\n/** Canonical reason string carried by a user rejection. */\nexport const HITL_REJECT_REASON = 'User rejected the action.';\n\n/**\n * Default {@link UseApprovalResumeLockOptions.pendingResumeGraceMs} for every\n * approval surface: how long a clicked decision waits for its resume run to\n * start before the actions unlock again. Covers a `run/input` the host\n * rejected or a disconnected transport swallowed before any run began — the\n * one failure neither identity-change nor observed-run recovery can detect.\n */\nexport const HITL_PENDING_RESUME_GRACE_MS = 15_000;\n\n/**\n * Default {@link UseApprovalResumeLockOptions.maxTransportRetries}: how many\n * times a decision the transport lost (the websocket dropped or the statewire\n * session reset while the `run/input` was in flight) is re-sent on its own\n * before the user is asked to click again.\n */\nexport const HITL_RESUME_TRANSPORT_RETRIES = 3;\n\n/**\n * The dispatch died client-side without the host ever seeing it — a proven\n * session loss or a gone stream. Safe to re-send the same decision for the\n * same still-parked request. The complement (a server verdict, or the surface\n * unmounting) is not.\n */\nexport function isResumeTransportLoss(error: unknown): boolean {\n  const outcome = statewireTransportOutcome(error);\n  return outcome === 'session-lost' || outcome === 'stream-gone';\n}\n\n/** `run/input` resume value approving the gated call(s). */\nexport function hitlResumeApprove(): Record<string, string> {\n  return { action: 'approve' };\n}\n\n/**\n * `run/input` resume value approving the gated call(s) AND every later call of\n * the same tool(s) on this thread. The backend records the tools from its own\n * parked interrupt (never from this payload), so the value carries no names.\n */\nexport function hitlResumeApproveForSession(): Record<string, string> {\n  return { action: 'approve', scope: 'session' };\n}\n\n/** `run/input` resume value rejecting the gated call(s). */\nexport function hitlResumeReject(reason: string = HITL_REJECT_REASON): Record<string, string> {\n  return { action: 'reject', reason };\n}\n\n/** One gated call's own answer inside a per-action resume ({@link hitlResumeActionDecisions}). */\nexport type HitlActionDecision =\n  | { action: 'approve' }\n  | { action: 'reject'; reason: string }\n  | { action: 'edit'; edited_args: Record<string, unknown> };\n\n/**\n * The `tool_call_id` of every gated call, in decision order — or `null` when\n * any call lacks one or two calls share one, in which case no per-action\n * resume can be bound to the batch and only the batch answers above apply.\n */\nexport function actionRequestToolCallIds(\n  actionRequests: readonly PendingActionRequest[],\n): string[] | null {\n  if (actionRequests.length === 0) return null;\n  const ids: string[] = [];\n  for (const request of actionRequests) {\n    if (request.toolCallId === undefined || ids.includes(request.toolCallId)) return null;\n    ids.push(request.toolCallId);\n  }\n  return ids;\n}\n\n/**\n * `run/input` resume value deciding each gated call by its `tool_call_id` —\n * the only channel that carries an edited call. The backend binds every entry\n * to the parked request with that id, takes the tool NAME from its own\n * request (an edit can change a call's arguments, never which tool runs), and\n * refuses the whole answer — nothing runs — unless the map names exactly the\n * parked calls. `edited_args` is the complete argument set the call runs\n * with, not a patch. The envelope `action` mirrors the first entry for hosts\n * that only read the envelope; `action_decisions` is authoritative.\n */\nexport function hitlResumeActionDecisions(\n  decisions: Readonly<Record<string, HitlActionDecision>>,\n): Record<string, unknown> {\n  const [anchorId, anchor] = Object.entries(decisions)[0] ?? [];\n  return {\n    action: anchor?.action === 'reject' ? 'reject' : 'approve',\n    ...(anchorId !== undefined && { tool_call_id: anchorId }),\n    action_decisions: decisions,\n  };\n}\n\n/** Answers that let nothing run: rejecting, or the timeout handler's answer. */\nconst NON_APPROVING_ACTIONS: ReadonlySet<string> = new Set(['reject', 'timeout']);\n\n/**\n * Whether a `run/input` resume value (or one lane's decision) lets anything\n * run: approving, approving for the session, an edit, or anything this cannot\n * read as a reject. Mirrors the host's `_decision_approves`, which fails\n * closed the same way, so a surface asks for a passkey check exactly where\n * the host will want one. Rejecting never needs a check (identity 0b.9,\n * call 9). A `lane_decisions` map approves when any of its lanes does.\n */\nexport function resumeValueApproves(value: unknown): boolean {\n  if (!isRecord(value)) return true;\n  const decisions = value.decisions;\n  if (Array.isArray(decisions)) {\n    return decisions.length === 0 || decisions.some(resumeValueApproves);\n  }\n  const perAction = value.action_decisions;\n  if (perAction !== undefined) {\n    if (!isRecord(perAction)) return true;\n    const answers = Object.values(perAction);\n    return answers.length === 0 || answers.some(resumeValueApproves);\n  }\n  const lanes = value.lane_decisions;\n  if (lanes !== undefined) {\n    if (!isRecord(lanes)) return true;\n    const answers = Object.values(lanes);\n    return answers.length === 0 || answers.some(resumeValueApproves);\n  }\n  const kind = value.type;\n  if (typeof kind === 'string') return !NON_APPROVING_ACTIONS.has(kind);\n  const action = value.action;\n  return typeof action !== 'string' || !NON_APPROVING_ACTIONS.has(action);\n}\n\n/**\n * What rides beside a resume value on the `run/input` command. Today only the\n * passkey decision check (`decisionCheck`, identity 0b.9): the token a person\n * minted for exactly this answer, which the host classifies and spends.\n */\nexport interface ResumeExtras {\n  readonly decisionCheck?: string;\n}\n\n/** Canonical reason string carried by a user declining a non-HITL park. */\nexport const INTERRUPT_DECLINE_REASON = 'User declined the request.';\n\n/**\n * `run/input` resume value declining a non-HITL park. `{ action: 'reject' }`\n * is the one value every typed raiser treats as a clean user decline\n * (`FormCancelledError` / `ToolRejectedError`); a generic `continue` would be\n * rejected by their resume schemas and surface as a tool error the agent then\n * improvises around.\n */\nexport function interruptResumeDecline(\n  reason: string = INTERRUPT_DECLINE_REASON,\n): Record<string, string> {\n  return { action: 'reject', reason };\n}\n\nexport interface UseApprovalResumeLockOptions<TValue> {\n  /** The pending interrupt's request id (`undefined` when nothing is parked). */\n  requestId: string | undefined;\n  /** The surface's thread `isRunning` read (mockable per surface). */\n  isRunning: boolean;\n  /**\n   * Dispatch the `run/input` resume for `requestId` on the surface's transport.\n   * Return the dispatch promise so a refused or lost command releases the lock\n   * at once and reaches `onResumeRejected`; a `void` return leaves the\n   * recovery paths below as the only release.\n   */\n  sendResume: (\n    requestId: string,\n    value: TValue,\n    extras?: ResumeExtras,\n  ) => void | Promise<unknown>;\n  /**\n   * The dispatch `sendResume` returned rejected — the host refused the\n   * `run/input` or the transport lost it. The lock is already released when\n   * this fires; the surface tells the user, since the request is back on\n   * screen with nothing else saying why.\n   */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /**\n   * A dispatch the transport lost is being re-sent for the still-parked\n   * request; `attempt` counts the retries so far (1-based). Diagnostics only —\n   * the lock stays held across the retry.\n   */\n  onResumeRetry?: (error: unknown, requestId: string, attempt: number) => void;\n  /**\n   * Automatic re-sends of a decision the transport lost\n   * ({@link isResumeTransportLoss}) while the request is still parked. `0`\n   * disables retries. Defaults to {@link HITL_RESUME_TRANSPORT_RETRIES}.\n   */\n  maxTransportRetries?: number;\n  /**\n   * Re-enable the actions when no resume run started within this window —\n   * covers a `run/input` that was rejected or lost before any run began, so\n   * neither reset path below can fire. Omit to keep the pre-existing surface\n   * behavior of staying locked until a resume run is observed.\n   */\n  pendingResumeGraceMs?: number;\n}\n\nexport interface ApprovalResumeLock<TValue> {\n  /** True after a resume until the request identity changes (or recovery fires). */\n  pending: boolean;\n  /**\n   * Send the resume value, locking the actions. No-op (returns `undefined`)\n   * while pending or unparked. Returns the dispatch promise when `sendResume`\n   * produced one, so a surface can hold its own state until the host settles.\n   */\n  resume: (value: TValue, extras?: ResumeExtras) => Promise<unknown> | undefined;\n}\n\n/**\n * Optimistic action lock shared by every approval surface: disable the\n * decision buttons the moment one is clicked, until the request identity\n * changes (it clears after the resume, or a fresh interrupt arrives). This\n * closes the double-click → duplicate-resume window.\n *\n * Recovery paths, in order of specificity:\n * 0. The dispatch itself rejected (a `sendResume` that returned a promise) —\n *    released at once, and reported through `onResumeRejected`. A rejection\n *    that is a transport loss (the socket dropped mid-flight) is re-sent up to\n *    `maxTransportRetries` times first, the lock held throughout, so a flaky\n *    connection does not hand the card back to the user for another click.\n *    The returned promise settles with the final attempt.\n * 1. Identity change — the resume landed (or a new interrupt replaced the\n *    request). Reset during render via React's \"previous value\" pattern.\n * 2. A resume run was observed starting and then settling with the request\n *    still pending (failed/cancelled resume) — clear the lock so the user can\n *    answer again.\n * 3. Optional grace window ({@link UseApprovalResumeLockOptions.pendingResumeGraceMs})\n *    for a `run/input` that never started a run at all.\n */\nexport function useApprovalResumeLock<TValue = Record<string, string>>(\n  options: UseApprovalResumeLockOptions<TValue>,\n): ApprovalResumeLock<TValue> {\n  const {\n    requestId,\n    isRunning,\n    sendResume,\n    pendingResumeGraceMs,\n    onResumeRejected,\n    onResumeRetry,\n    maxTransportRetries = HITL_RESUME_TRANSPORT_RETRIES,\n  } = options;\n\n  const [pending, setPending] = useState(false);\n  // Bumped per re-send so the grace window restarts with each attempt.\n  const [attempt, setAttempt] = useState(0);\n  const prevRequestIdRef = useRef(requestId);\n  if (prevRequestIdRef.current !== requestId) {\n    prevRequestIdRef.current = requestId;\n    if (pending) setPending(false);\n  }\n\n  // Track the resume run we kicked off (isRunning observed true→false while\n  // pending) and clear `pending` when it ends with the request unresolved.\n  const sawResumeRunRef = useRef(false);\n  useEffect(() => {\n    if (!pending) {\n      sawResumeRunRef.current = false;\n      return;\n    }\n    if (isRunning) {\n      sawResumeRunRef.current = true;\n      return;\n    }\n    if (sawResumeRunRef.current) {\n      sawResumeRunRef.current = false;\n      setPending(false);\n    }\n  }, [pending, isRunning]);\n\n  // Pre-start failure recovery: re-enable after the grace window when no\n  // resume run began; answering the still-parked request again is exactly\n  // what the user needs to be able to do.\n  useEffect(() => {\n    if (!pending || pendingResumeGraceMs === undefined) return;\n    const timer = setTimeout(() => {\n      if (!sawResumeRunRef.current) setPending(false);\n    }, pendingResumeGraceMs);\n    return () => clearTimeout(timer);\n  }, [pending, requestId, pendingResumeGraceMs, attempt]);\n\n  const sendResumeRef = useRef(sendResume);\n  sendResumeRef.current = sendResume;\n  const onResumeRejectedRef = useRef(onResumeRejected);\n  onResumeRejectedRef.current = onResumeRejected;\n  const onResumeRetryRef = useRef(onResumeRetry);\n  onResumeRetryRef.current = onResumeRetry;\n  const maxTransportRetriesRef = useRef(maxTransportRetries);\n  maxTransportRetriesRef.current = maxTransportRetries;\n  const currentRequestIdRef = useRef(requestId);\n  currentRequestIdRef.current = requestId;\n  const pendingRef = useRef(pending);\n  pendingRef.current = pending;\n  // One token per `resume` call: a settle from an earlier submission must not\n  // retry over, or release, a newer one for the same request.\n  const submissionRef = useRef(0);\n\n  const resume = useCallback(\n    (value: TValue, extras?: ResumeExtras): Promise<unknown> | undefined => {\n      if (requestId === undefined || pendingRef.current) return undefined;\n      const submission = ++submissionRef.current;\n      setPending(true);\n      pendingRef.current = true;\n      setAttempt(0);\n      const first: unknown = sendResumeRef.current(requestId, value, extras);\n      if (!(first instanceof Promise)) return undefined;\n      // The final failure is already reported through `onResumeRejected`;\n      // callers that drop the promise must not get an unhandled rejection.\n      const outcome = new Promise<unknown>((resolve, reject) => {\n        const settle = (dispatched: Promise<unknown>, retries: number) => {\n          dispatched.then(resolve, (error: unknown) => {\n            // A late refusal for a request the lock has since moved past (the\n            // park was re-keyed, or a newer answer is in flight) must neither\n            // release that answer's lock nor be reported as a failure of it.\n            // The optimistic fold hides the answered request until the fold\n            // rolls back, so `undefined` here is not a departure.\n            const current = currentRequestIdRef.current;\n            if (\n              submission !== submissionRef.current ||\n              (current !== undefined && current !== requestId)\n            ) {\n              reject(error);\n              return;\n            }\n            if (retries < maxTransportRetriesRef.current && isResumeTransportLoss(error)) {\n              const next = retries + 1;\n              onResumeRetryRef.current?.(error, requestId, next);\n              setPending(true);\n              pendingRef.current = true;\n              setAttempt(next);\n              const resent: unknown = sendResumeRef.current(requestId, value, extras);\n              if (resent instanceof Promise) {\n                settle(resent, next);\n                return;\n              }\n              resolve(undefined);\n              return;\n            }\n            setPending(false);\n            pendingRef.current = false;\n            onResumeRejectedRef.current?.(error, requestId);\n            reject(error);\n          });\n        };\n        settle(first, 0);\n      });\n      outcome.catch(() => {});\n      return outcome;\n    },\n    [requestId],\n  );\n\n  return { pending, resume };\n}\n"],"names":["hasClientToolInterruptSource","readDeepAgentStreamValues","statewireTransportOutcome","useState","useRef","useEffect","useCallback"],"mappings":"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"}

package/dist/agent-runtime/src/interrupts.d.ts

@@ -265,6 +265,23 @@ export declare function actionRequestToolCallIds(actionRequests: readonly Pendin
  * that only read the envelope; `action_decisions` is authoritative.
  */
 export declare function hitlResumeActionDecisions(decisions: Readonly<Record<string, HitlActionDecision>>): Record<string, unknown>;
+/**
+ * Whether a `run/input` resume value (or one lane's decision) lets anything
+ * run: approving, approving for the session, an edit, or anything this cannot
+ * read as a reject. Mirrors the host's `_decision_approves`, which fails
+ * closed the same way, so a surface asks for a passkey check exactly where
+ * the host will want one. Rejecting never needs a check (identity 0b.9,
+ * call 9). A `lane_decisions` map approves when any of its lanes does.
+ */
+export declare function resumeValueApproves(value: unknown): boolean;
+/**
+ * What rides beside a resume value on the `run/input` command. Today only the
+ * passkey decision check (`decisionCheck`, identity 0b.9): the token a person
+ * minted for exactly this answer, which the host classifies and spends.
+ */
+export interface ResumeExtras {
+    readonly decisionCheck?: string;
+}
 /** Canonical reason string carried by a user declining a non-HITL park. */
 export declare const INTERRUPT_DECLINE_REASON = "User declined the request.";
 /**
@@ -286,7 +303,7 @@ export interface UseApprovalResumeLockOptions<TValue> {
      * at once and reaches `onResumeRejected`; a `void` return leaves the
      * recovery paths below as the only release.
      */
-    sendResume: (requestId: string, value: TValue) => void | Promise<unknown>;
+    sendResume: (requestId: string, value: TValue, extras?: ResumeExtras) => void | Promise<unknown>;
     /**
      * The dispatch `sendResume` returned rejected — the host refused the
      * `run/input` or the transport lost it. The lock is already released when
@@ -322,7 +339,7 @@ export interface ApprovalResumeLock<TValue> {
      * while pending or unparked. Returns the dispatch promise when `sendResume`
      * produced one, so a surface can hold its own state until the host settles.
      */
-    resume: (value: TValue) => Promise<unknown> | undefined;
+    resume: (value: TValue, extras?: ResumeExtras) => Promise<unknown> | undefined;
 }
 /**
  * Optimistic action lock shared by every approval surface: disable the