@athenaintel/react 0.41.2 → 0.42.1

package/dist/agent-runtime/src/tool-result.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Tool-result classification shared by every tool card and activity timeline
+ * (the React SDK fallback, Olympus, the Chrome extension, the Office add-in,
+ * mobile). One rule set for "did this call succeed?", so a result that reads
+ * as a failure on one surface cannot read as a success on another.
+ *
+ * The rules, in order:
+ *
+ * 0. A `running` status is a running call, whatever result it carries: a part
+ *    only has both while its result is interim (`isPreliminary` — the
+ *    backend's running-tool placeholder, see `running-tool-placeholder.ts`),
+ *    and assistant-ui gives such a part its message's status. A settled
+ *    result always comes with `complete`.
+ * 1. An `incomplete` status is a failure; a `cancelled` reason reads as
+ *    "Cancelled".
+ * 2. A string result opening with "⏸️ Interrupted —" is a **paused** call (the
+ *    runtime parked it), not a failure.
+ * 2b. A result that records the user's refusal at the approval gate (see
+ *    {@link readRejectedToolResult}) is a **rejected** call — neither a success
+ *    nor a failure. It is read before the failure rules because the HITL
+ *    runtime answers a refused call with an error-status tool message whose
+ *    content is the refusal, which would otherwise read as a plain failure.
+ *    Never applied to a pass-through payload: page JavaScript relays whatever
+ *    the page returned, and a `{ status: "rejected" }` from a fetched API is
+ *    the page's business, not a human decision.
+ * 3. A result record whose `success` or `ok` is `false` is a failure, with
+ *    the best message available (`error`, `message`, `reason`, or a
+ *    `data.humanIntervention` detail). Athena tools report failures this way
+ *    — the sheet tools answer `{ success: false, message: "…" }` — so a bare
+ *    flag must read as a failure. The one exception is a **pass-through
+ *    payload** (`passThroughPayload: true`): page JavaScript relays whatever
+ *    the page returned, and `{ success: false, message: "Payment required" }`
+ *    from a fetched API is the page's business, not the tool failing, so there
+ *    the flag counts only alongside an error detail (`error`, `errorCode`,
+ *    `error_code`, or a `humanIntervention` message / reason / code). The
+ *    Chrome extension opts its `chrome_javascript` tool in; everything else
+ *    takes the default.
+ * 4. A result record with a non-empty `error` string is a failure regardless
+ *    of flags — every Athena tool contract uses that field only on failure.
+ * 5. A plain-string result opening with an explicit error prefix (`Error:`,
+ *    `Tool execution failed`, `Failed to route tool call`) is a failure —
+ *    device-tunnel failures arrive in successful ToolMessages, so the prefix
+ *    is the authoritative signal there. A bare leading "Error" word is not
+ *    (an "Error handling guide" is content). A batch report that stopped at a
+ *    step reads its header and failing step.
+ * 6. assistant-ui's own `isError` flag is a failure with the best message
+ *    available.
+ * 7. `requires-action` and a result-less non-complete status read as such;
+ *    everything else is a success.
+ */
+/** The status shape a tool-call message part carries (structurally typed so this module stays UI-library-free). */
+export interface ToolCallStatusLike {
+    type: 'running' | 'complete' | 'incomplete' | 'requires-action';
+    reason?: string;
+    error?: unknown;
+}
+export interface ToolFailure {
+    message: string;
+    code?: string;
+}
+export type ToolResultClassification = {
+    state: 'running';
+} | {
+    state: 'complete';
+} | {
+    state: 'requires-action';
+} | {
+    state: 'paused';
+    notice: string;
+} | {
+    state: 'rejected';
+    rejection: RejectedToolResult;
+} | {
+    state: 'error';
+    failure: ToolFailure;
+};
+export type ToolResultState = ToolResultClassification['state'];
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Parse a JSON string into a record, or `null` when it is not one. */
+export declare function parseJsonRecord(value: string): Record<string, unknown> | null;
+/** The result as a record: parsed when it arrived as a JSON string. */
+export declare function resultRecord(result: unknown): Record<string, unknown> | null;
+/** The first non-blank string among `keys` on `record`, or `null`. */
+export declare function stringField(record: Record<string, unknown> | null | undefined, keys: readonly string[]): string | null;
+/** The `message` a result carries, when it does (the row's completion summary). */
+export declare function resultMessage(result: unknown): string | null;
+/** The failure a tool call reports, or `null` when it succeeded (rules 1, 3-6). */
+export declare function toolFailure({ status, result, isError, passThroughPayload, }: {
+    status?: ToolCallStatusLike;
+    result?: unknown;
+    isError?: boolean;
+    /** The result is an application payload relayed verbatim (rule 3): a flag needs an error detail to count. */
+    passThroughPayload?: boolean;
+}): ToolFailure | null;
+/** Classify a tool call for rendering (see the module docs for the rules). */
+export declare function classifyToolResult({ status, result, isError, passThroughPayload, }: {
+    status?: ToolCallStatusLike;
+    result?: unknown;
+    isError?: boolean;
+    /** The result is an application payload relayed verbatim (rule 3): a flag needs an error detail to count. */
+    passThroughPayload?: boolean;
+}): ToolResultClassification;
+/** True when a completed call reads as a success under the shared rules. */
+export declare function isToolResultSuccess(result: unknown): boolean;
+/**
+ * A gated tool call the user rejected still "completes": both HITL runtimes
+ * answer the rejected call with a `ToolMessage` whose text is the rejection
+ * ("Tool call rejected by user. Reason: …"), and device tools may answer with
+ * a structured decision (`{ status: 'rejected' }`, `{ action: 'reject' }`,
+ * `{ decision: 'rejected' }`). Anything that labels a finished call has to
+ * read that, or a rejected email send reports itself as sent. The read is
+ * content-based, so it is scoped to where a rejection can appear: the opening
+ * of a string result, never deep inside returned content, and never a
+ * pass-through page payload (see {@link classifyToolResult}).
+ */
+export interface RejectedToolResult {
+    /** The feedback the user typed, when they gave one. */
+    reason: string | null;
+}
+/**
+ * Read a rejection out of a completed tool call's result, or `null` when the
+ * call actually ran (or failed for a non-approval reason).
+ */
+export declare function readRejectedToolResult(result: unknown): RejectedToolResult | null;
+/** True when a completed call's result records that the user rejected it. */
+export declare function isRejectedToolResult(result: unknown): boolean;

package/dist/agent-runtime/src/tool-result.js

@@ -97,6 +97,7 @@ function classifyToolResult({
   isError,
   passThroughPayload
 }) {
+  if ((status == null ? void 0 : status.type) === "running") return { state: "running" };
   const notice = pausedNotice(result);
   if (notice) return { state: "paused", notice };
   const rejection = passThroughPayload ? null : readRejectedToolResult(result);

package/dist/agent-runtime/src/tool-result.js.map

@@ -1 +1 @@
-{"version":3,"file":"tool-result.js","sources":["../../../../agent-runtime/src/tool-result.ts"],"sourcesContent":["/**\n * Tool-result classification shared by every tool card and activity timeline\n * (the React SDK fallback, Olympus, the Chrome extension, the Office add-in,\n * mobile). One rule set for \"did this call succeed?\", so a result that reads\n * as a failure on one surface cannot read as a success on another.\n *\n * The rules, in order:\n *\n * 1. An `incomplete` status is a failure; a `cancelled` reason reads as\n *    \"Cancelled\".\n * 2. A string result opening with \"⏸️ Interrupted —\" is a **paused** call (the\n *    runtime parked it), not a failure.\n * 2b. A result that records the user's refusal at the approval gate (see\n *    {@link readRejectedToolResult}) is a **rejected** call — neither a success\n *    nor a failure. It is read before the failure rules because the HITL\n *    runtime answers a refused call with an error-status tool message whose\n *    content is the refusal, which would otherwise read as a plain failure.\n *    Never applied to a pass-through payload: page JavaScript relays whatever\n *    the page returned, and a `{ status: \"rejected\" }` from a fetched API is\n *    the page's business, not a human decision.\n * 3. A result record whose `success` or `ok` is `false` is a failure, with\n *    the best message available (`error`, `message`, `reason`, or a\n *    `data.humanIntervention` detail). Athena tools report failures this way\n *    — the sheet tools answer `{ success: false, message: \"…\" }` — so a bare\n *    flag must read as a failure. The one exception is a **pass-through\n *    payload** (`passThroughPayload: true`): page JavaScript relays whatever\n *    the page returned, and `{ success: false, message: \"Payment required\" }`\n *    from a fetched API is the page's business, not the tool failing, so there\n *    the flag counts only alongside an error detail (`error`, `errorCode`,\n *    `error_code`, or a `humanIntervention` message / reason / code). The\n *    Chrome extension opts its `chrome_javascript` tool in; everything else\n *    takes the default.\n * 4. A result record with a non-empty `error` string is a failure regardless\n *    of flags — every Athena tool contract uses that field only on failure.\n * 5. A plain-string result opening with an explicit error prefix (`Error:`,\n *    `Tool execution failed`, `Failed to route tool call`) is a failure —\n *    device-tunnel failures arrive in successful ToolMessages, so the prefix\n *    is the authoritative signal there. A bare leading \"Error\" word is not\n *    (an \"Error handling guide\" is content). A batch report that stopped at a\n *    step reads its header and failing step.\n * 6. assistant-ui's own `isError` flag is a failure with the best message\n *    available.\n * 7. `requires-action` and a result-less non-complete status read as such;\n *    everything else is a success.\n */\n\n/** The status shape a tool-call message part carries (structurally typed so this module stays UI-library-free). */\nexport interface ToolCallStatusLike {\n  type: 'running' | 'complete' | 'incomplete' | 'requires-action';\n  reason?: string;\n  error?: unknown;\n}\n\nexport interface ToolFailure {\n  message: string;\n  code?: string;\n}\n\nexport type ToolResultClassification =\n  | { state: 'running' }\n  | { state: 'complete' }\n  | { state: 'requires-action' }\n  | { state: 'paused'; notice: string }\n  | { state: 'rejected'; rejection: RejectedToolResult }\n  | { state: 'error'; failure: ToolFailure };\n\nexport type ToolResultState = ToolResultClassification['state'];\n\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/** Parse a JSON string into a record, or `null` when it is not one. */\nexport function parseJsonRecord(value: string): Record<string, unknown> | null {\n  try {\n    const parsed: unknown = JSON.parse(value);\n    return isRecord(parsed) ? parsed : null;\n  } catch {\n    return null;\n  }\n}\n\n/** The result as a record: parsed when it arrived as a JSON string. */\nexport function resultRecord(result: unknown): Record<string, unknown> | null {\n  if (typeof result === 'string') return parseJsonRecord(result);\n  return isRecord(result) ? result : null;\n}\n\n/** The first non-blank string among `keys` on `record`, or `null`. */\nexport function stringField(\n  record: Record<string, unknown> | null | undefined,\n  keys: readonly string[],\n): string | null {\n  if (!record) return null;\n  for (const key of keys) {\n    const value = record[key];\n    if (typeof value === 'string' && value.trim()) return value;\n  }\n  return null;\n}\n\n/** The `message` a result carries, when it does (the row's completion summary). */\nexport function resultMessage(result: unknown): string | null {\n  return stringField(resultRecord(result), ['message']);\n}\n\nconst FAILURE_DETAIL_KEYS = ['error', 'errorCode', 'error_code'] as const;\nconst INTERVENTION_DETAIL_KEYS = ['message', 'reason', 'errorCode', 'error_code'] as const;\nconst FAILURE_CODE_KEYS = ['errorCode', 'error_code', 'code'] as const;\nconst FAILURE_MESSAGE_KEYS = ['error', 'message', 'reason'] as const;\n\nfunction batchReportFailure(trimmed: string): string | null {\n  const lines = trimmed.split('\\n');\n  const header = lines[0]?.trim() ?? '';\n  if (!/^[\\w.-]*batch: \\d+\\/\\d+ ok — STOPPED at step \\d+/.test(header)) {\n    return null;\n  }\n  const stepError = lines\n    .map((line) => line.trim())\n    .find(\n      (line) =>\n        /^\\d+\\.\\s/.test(line) && (line.includes(' ERROR — ') || line.endsWith(' ERROR')),\n    );\n  return stepError ? `${header}\\n${stepError}` : header;\n}\n\nconst STRING_ERROR_PREFIX = /^(?:Error:|Tool execution failed\\b|Failed to route tool call\\b)\\s*/;\n\nfunction plainStringError(result: unknown): string | null {\n  if (typeof result !== 'string') return null;\n  const trimmed = result.trim();\n  if (!trimmed || parseJsonRecord(trimmed)) return null;\n  if (STRING_ERROR_PREFIX.test(trimmed)) {\n    return trimmed.replace(STRING_ERROR_PREFIX, '').trim() || trimmed;\n  }\n  return batchReportFailure(trimmed);\n}\n\nfunction pausedNotice(result: unknown): string | null {\n  if (typeof result !== 'string') return null;\n  const trimmed = result.trim();\n  return /^⏸️?\\s*Interrupted —/.test(trimmed) ? trimmed : null;\n}\n\nfunction stringifyUnknown(value: unknown): string | null {\n  if (value == null) return null;\n  if (typeof value === 'string') return value;\n  if (value instanceof Error) return value.message;\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value);\n  }\n}\n\n/** The failure a tool call reports, or `null` when it succeeded (rules 1, 3-6). */\nexport function toolFailure({\n  status,\n  result,\n  isError,\n  passThroughPayload = false,\n}: {\n  status?: ToolCallStatusLike;\n  result?: unknown;\n  isError?: boolean;\n  /** The result is an application payload relayed verbatim (rule 3): a flag needs an error detail to count. */\n  passThroughPayload?: boolean;\n}): ToolFailure | null {\n  if (status?.type === 'incomplete') {\n    const errorText = stringifyUnknown(status.error);\n    return {\n      message:\n        errorText ??\n        (status.reason === 'cancelled' ? 'Cancelled' : `Tool stopped: ${status.reason}`),\n    };\n  }\n\n  const record = resultRecord(result);\n  const data = isRecord(record?.data) ? record.data : null;\n  const humanIntervention = isRecord(data?.humanIntervention) ? data.humanIntervention : null;\n  const failureDetail =\n    stringField(record, FAILURE_DETAIL_KEYS) ??\n    stringField(humanIntervention, INTERVENTION_DETAIL_KEYS);\n  const flagged = record?.success === false || record?.ok === false;\n  const flaggedFailure = flagged && (!passThroughPayload || failureDetail !== null);\n  const errorField = stringField(record, ['error']) !== null;\n  const stringError = plainStringError(result);\n\n  if (!isError && !flaggedFailure && !errorField && !stringError) return null;\n\n  const code =\n    stringField(record, FAILURE_CODE_KEYS) ??\n    stringField(humanIntervention, FAILURE_CODE_KEYS) ??\n    undefined;\n  const message =\n    stringField(record, FAILURE_MESSAGE_KEYS) ??\n    stringField(humanIntervention, FAILURE_MESSAGE_KEYS) ??\n    stringError ??\n    (typeof result === 'string' && !parseJsonRecord(result) ? result : null) ??\n    'Tool execution failed';\n\n  return { message, code };\n}\n\n/** Classify a tool call for rendering (see the module docs for the rules). */\nexport function classifyToolResult({\n  status,\n  result,\n  isError,\n  passThroughPayload,\n}: {\n  status?: ToolCallStatusLike;\n  result?: unknown;\n  isError?: boolean;\n  /** The result is an application payload relayed verbatim (rule 3): a flag needs an error detail to count. */\n  passThroughPayload?: boolean;\n}): ToolResultClassification {\n  const notice = pausedNotice(result);\n  if (notice) return { state: 'paused', notice };\n\n  const rejection = passThroughPayload ? null : readRejectedToolResult(result);\n  if (rejection) return { state: 'rejected', rejection };\n\n  const failure = toolFailure({ status, result, isError, passThroughPayload });\n  if (failure) return { state: 'error', failure };\n  if (status?.type === 'requires-action') return { state: 'requires-action' };\n  if (result === undefined && status?.type !== 'complete') {\n    return { state: 'running' };\n  }\n  return { state: 'complete' };\n}\n\n/** True when a completed call reads as a success under the shared rules. */\nexport function isToolResultSuccess(result: unknown): boolean {\n  return classifyToolResult({ status: { type: 'complete' }, result }).state === 'complete';\n}\n\n/**\n * A gated tool call the user rejected still \"completes\": both HITL runtimes\n * answer the rejected call with a `ToolMessage` whose text is the rejection\n * (\"Tool call rejected by user. Reason: …\"), and device tools may answer with\n * a structured decision (`{ status: 'rejected' }`, `{ action: 'reject' }`,\n * `{ decision: 'rejected' }`). Anything that labels a finished call has to\n * read that, or a rejected email send reports itself as sent. The read is\n * content-based, so it is scoped to where a rejection can appear: the opening\n * of a string result, never deep inside returned content, and never a\n * pass-through page payload (see {@link classifyToolResult}).\n */\nexport interface RejectedToolResult {\n  /** The feedback the user typed, when they gave one. */\n  reason: string | null;\n}\n\n/**\n * Phrasings the HITL runtimes use for a *human* rejection. Matching on these\n * rather than the word \"reject\" keeps deterministic failures out — argument\n * validation answers a call with \"Tool call rejected — ValidationError: …\",\n * which never involved the user and stays a plain failure.\n */\nconst USER_REJECTION_PATTERNS: readonly RegExp[] = [/rejected by (?:the )?user/i, /user rejected/i];\n\n/**\n * A rejection IS the tool message, so the phrasing opens it: \"The user rejected\n * this action. …\" (`hitl_bridge.py`), \"Tool call rejected by user. Reason: …\",\n * \"Tool 'x' execution rejected by user. …\", \"[INTERRUPT] Custom interrupt\n * '<uuid>' rejected by user. …\". Content a tool merely *returned* — a page read\n * or a document whose text happens to say a user rejected something — carries\n * the phrase deeper in, so only a match starting within this many characters\n * of the first line counts.\n */\nconst USER_REJECTION_LEAD_CHARS = 100;\n\n/** Whether `result` opens with a human-rejection phrasing (see {@link USER_REJECTION_LEAD_CHARS}). */\nfunction opensWithUserRejection(result: string): boolean {\n  const firstLine = result.trimStart().split('\\n', 1)[0] ?? '';\n  return USER_REJECTION_PATTERNS.some((pattern) => {\n    const index = firstLine.search(pattern);\n    return index !== -1 && index < USER_REJECTION_LEAD_CHARS;\n  });\n}\n\n/** Reject-with-no-feedback placeholder the legacy approval editor sends. */\nconst NO_REASON = 'no reason provided';\n\n/**\n * Model-facing guidance the legacy HITL node appends on the same line after\n * the reason (\"… Reason: <reason> Acknowledge in one short sentence. Do not\n * retry…\"). It is instruction for the model, not the user's feedback.\n */\nconst TRAILING_GUIDANCE = /\\s*Acknowledge in one short sentence\\..*$/i;\n\n/**\n * How LangChain's HITL middleware answers a refused call: \"User rejected the\n * tool call for `x` with reason: <message>\", where <message> is the one the\n * deep-agent bridge (`hitl_bridge.py`) handed it.\n */\nconst MIDDLEWARE_ENVELOPE = /^User rejected the tool call for `[^`]*` with reason:\\s*/i;\n\n/**\n * The bridge's refusal, which opens its message. Inside the middleware envelope\n * it is scaffolding, not feedback; the member's own reason, when they gave one,\n * follows it as \"Reason: …\". Outside the envelope the text after \"Reason:\" is\n * the member's, whatever it says.\n */\nconst BRIDGE_REFUSAL = /^The user rejected this action\\.\\s*/i;\n\n/** Everything after \"Reason:\"; feedback typed in the approval editor can span lines. */\nconst REASON_TAIL = /Reason:\\s*([\\s\\S]+)/i;\n\nfunction readRejectionReason(result: string): string | null {\n  const text = result.trim();\n  const envelope = MIDDLEWARE_ENVELOPE.exec(text);\n  let reason: string | undefined;\n  if (envelope) {\n    const message = text.slice(envelope[0].length).replace(TRAILING_GUIDANCE, '').trim();\n    reason = BRIDGE_REFUSAL.test(message)\n      ? message.replace(BRIDGE_REFUSAL, '').match(/^Reason:\\s*([\\s\\S]+)/i)?.[1]\n      : message;\n  } else {\n    reason = text.match(REASON_TAIL)?.[1]?.replace(TRAILING_GUIDANCE, '');\n  }\n  reason = reason?.trim();\n  if (!reason || reason.toLowerCase() === NO_REASON) return null;\n  return reason;\n}\n\n/**\n * Read a rejection out of a completed tool call's result, or `null` when the\n * call actually ran (or failed for a non-approval reason).\n */\nexport function readRejectedToolResult(result: unknown): RejectedToolResult | null {\n  if (typeof result === 'string') {\n    if (!opensWithUserRejection(result)) return null;\n    return { reason: readRejectionReason(result) };\n  }\n  if (!isRecord(result)) return null;\n  if (result.status === 'rejected' || result.action === 'reject' || result.decision === 'rejected') {\n    return { reason: stringField(result, ['reason']) };\n  }\n  return null;\n}\n\n/** True when a completed call's result records that the user rejected it. */\nexport function isRejectedToolResult(result: unknown): boolean {\n  return readRejectedToolResult(result) !== null;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"tool-result.js","sources":["../../../../agent-runtime/src/tool-result.ts"],"sourcesContent":["/**\n * Tool-result classification shared by every tool card and activity timeline\n * (the React SDK fallback, Olympus, the Chrome extension, the Office add-in,\n * mobile). One rule set for \"did this call succeed?\", so a result that reads\n * as a failure on one surface cannot read as a success on another.\n *\n * The rules, in order:\n *\n * 0. A `running` status is a running call, whatever result it carries: a part\n *    only has both while its result is interim (`isPreliminary` — the\n *    backend's running-tool placeholder, see `running-tool-placeholder.ts`),\n *    and assistant-ui gives such a part its message's status. A settled\n *    result always comes with `complete`.\n * 1. An `incomplete` status is a failure; a `cancelled` reason reads as\n *    \"Cancelled\".\n * 2. A string result opening with \"⏸️ Interrupted —\" is a **paused** call (the\n *    runtime parked it), not a failure.\n * 2b. A result that records the user's refusal at the approval gate (see\n *    {@link readRejectedToolResult}) is a **rejected** call — neither a success\n *    nor a failure. It is read before the failure rules because the HITL\n *    runtime answers a refused call with an error-status tool message whose\n *    content is the refusal, which would otherwise read as a plain failure.\n *    Never applied to a pass-through payload: page JavaScript relays whatever\n *    the page returned, and a `{ status: \"rejected\" }` from a fetched API is\n *    the page's business, not a human decision.\n * 3. A result record whose `success` or `ok` is `false` is a failure, with\n *    the best message available (`error`, `message`, `reason`, or a\n *    `data.humanIntervention` detail). Athena tools report failures this way\n *    — the sheet tools answer `{ success: false, message: \"…\" }` — so a bare\n *    flag must read as a failure. The one exception is a **pass-through\n *    payload** (`passThroughPayload: true`): page JavaScript relays whatever\n *    the page returned, and `{ success: false, message: \"Payment required\" }`\n *    from a fetched API is the page's business, not the tool failing, so there\n *    the flag counts only alongside an error detail (`error`, `errorCode`,\n *    `error_code`, or a `humanIntervention` message / reason / code). The\n *    Chrome extension opts its `chrome_javascript` tool in; everything else\n *    takes the default.\n * 4. A result record with a non-empty `error` string is a failure regardless\n *    of flags — every Athena tool contract uses that field only on failure.\n * 5. A plain-string result opening with an explicit error prefix (`Error:`,\n *    `Tool execution failed`, `Failed to route tool call`) is a failure —\n *    device-tunnel failures arrive in successful ToolMessages, so the prefix\n *    is the authoritative signal there. A bare leading \"Error\" word is not\n *    (an \"Error handling guide\" is content). A batch report that stopped at a\n *    step reads its header and failing step.\n * 6. assistant-ui's own `isError` flag is a failure with the best message\n *    available.\n * 7. `requires-action` and a result-less non-complete status read as such;\n *    everything else is a success.\n */\n\n/** The status shape a tool-call message part carries (structurally typed so this module stays UI-library-free). */\nexport interface ToolCallStatusLike {\n  type: 'running' | 'complete' | 'incomplete' | 'requires-action';\n  reason?: string;\n  error?: unknown;\n}\n\nexport interface ToolFailure {\n  message: string;\n  code?: string;\n}\n\nexport type ToolResultClassification =\n  | { state: 'running' }\n  | { state: 'complete' }\n  | { state: 'requires-action' }\n  | { state: 'paused'; notice: string }\n  | { state: 'rejected'; rejection: RejectedToolResult }\n  | { state: 'error'; failure: ToolFailure };\n\nexport type ToolResultState = ToolResultClassification['state'];\n\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/** Parse a JSON string into a record, or `null` when it is not one. */\nexport function parseJsonRecord(value: string): Record<string, unknown> | null {\n  try {\n    const parsed: unknown = JSON.parse(value);\n    return isRecord(parsed) ? parsed : null;\n  } catch {\n    return null;\n  }\n}\n\n/** The result as a record: parsed when it arrived as a JSON string. */\nexport function resultRecord(result: unknown): Record<string, unknown> | null {\n  if (typeof result === 'string') return parseJsonRecord(result);\n  return isRecord(result) ? result : null;\n}\n\n/** The first non-blank string among `keys` on `record`, or `null`. */\nexport function stringField(\n  record: Record<string, unknown> | null | undefined,\n  keys: readonly string[],\n): string | null {\n  if (!record) return null;\n  for (const key of keys) {\n    const value = record[key];\n    if (typeof value === 'string' && value.trim()) return value;\n  }\n  return null;\n}\n\n/** The `message` a result carries, when it does (the row's completion summary). */\nexport function resultMessage(result: unknown): string | null {\n  return stringField(resultRecord(result), ['message']);\n}\n\nconst FAILURE_DETAIL_KEYS = ['error', 'errorCode', 'error_code'] as const;\nconst INTERVENTION_DETAIL_KEYS = ['message', 'reason', 'errorCode', 'error_code'] as const;\nconst FAILURE_CODE_KEYS = ['errorCode', 'error_code', 'code'] as const;\nconst FAILURE_MESSAGE_KEYS = ['error', 'message', 'reason'] as const;\n\nfunction batchReportFailure(trimmed: string): string | null {\n  const lines = trimmed.split('\\n');\n  const header = lines[0]?.trim() ?? '';\n  if (!/^[\\w.-]*batch: \\d+\\/\\d+ ok — STOPPED at step \\d+/.test(header)) {\n    return null;\n  }\n  const stepError = lines\n    .map((line) => line.trim())\n    .find(\n      (line) =>\n        /^\\d+\\.\\s/.test(line) && (line.includes(' ERROR — ') || line.endsWith(' ERROR')),\n    );\n  return stepError ? `${header}\\n${stepError}` : header;\n}\n\nconst STRING_ERROR_PREFIX = /^(?:Error:|Tool execution failed\\b|Failed to route tool call\\b)\\s*/;\n\nfunction plainStringError(result: unknown): string | null {\n  if (typeof result !== 'string') return null;\n  const trimmed = result.trim();\n  if (!trimmed || parseJsonRecord(trimmed)) return null;\n  if (STRING_ERROR_PREFIX.test(trimmed)) {\n    return trimmed.replace(STRING_ERROR_PREFIX, '').trim() || trimmed;\n  }\n  return batchReportFailure(trimmed);\n}\n\nfunction pausedNotice(result: unknown): string | null {\n  if (typeof result !== 'string') return null;\n  const trimmed = result.trim();\n  return /^⏸️?\\s*Interrupted —/.test(trimmed) ? trimmed : null;\n}\n\nfunction stringifyUnknown(value: unknown): string | null {\n  if (value == null) return null;\n  if (typeof value === 'string') return value;\n  if (value instanceof Error) return value.message;\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value);\n  }\n}\n\n/** The failure a tool call reports, or `null` when it succeeded (rules 1, 3-6). */\nexport function toolFailure({\n  status,\n  result,\n  isError,\n  passThroughPayload = false,\n}: {\n  status?: ToolCallStatusLike;\n  result?: unknown;\n  isError?: boolean;\n  /** The result is an application payload relayed verbatim (rule 3): a flag needs an error detail to count. */\n  passThroughPayload?: boolean;\n}): ToolFailure | null {\n  if (status?.type === 'incomplete') {\n    const errorText = stringifyUnknown(status.error);\n    return {\n      message:\n        errorText ??\n        (status.reason === 'cancelled' ? 'Cancelled' : `Tool stopped: ${status.reason}`),\n    };\n  }\n\n  const record = resultRecord(result);\n  const data = isRecord(record?.data) ? record.data : null;\n  const humanIntervention = isRecord(data?.humanIntervention) ? data.humanIntervention : null;\n  const failureDetail =\n    stringField(record, FAILURE_DETAIL_KEYS) ??\n    stringField(humanIntervention, INTERVENTION_DETAIL_KEYS);\n  const flagged = record?.success === false || record?.ok === false;\n  const flaggedFailure = flagged && (!passThroughPayload || failureDetail !== null);\n  const errorField = stringField(record, ['error']) !== null;\n  const stringError = plainStringError(result);\n\n  if (!isError && !flaggedFailure && !errorField && !stringError) return null;\n\n  const code =\n    stringField(record, FAILURE_CODE_KEYS) ??\n    stringField(humanIntervention, FAILURE_CODE_KEYS) ??\n    undefined;\n  const message =\n    stringField(record, FAILURE_MESSAGE_KEYS) ??\n    stringField(humanIntervention, FAILURE_MESSAGE_KEYS) ??\n    stringError ??\n    (typeof result === 'string' && !parseJsonRecord(result) ? result : null) ??\n    'Tool execution failed';\n\n  return { message, code };\n}\n\n/** Classify a tool call for rendering (see the module docs for the rules). */\nexport function classifyToolResult({\n  status,\n  result,\n  isError,\n  passThroughPayload,\n}: {\n  status?: ToolCallStatusLike;\n  result?: unknown;\n  isError?: boolean;\n  /** The result is an application payload relayed verbatim (rule 3): a flag needs an error detail to count. */\n  passThroughPayload?: boolean;\n}): ToolResultClassification {\n  if (status?.type === 'running') return { state: 'running' };\n\n  const notice = pausedNotice(result);\n  if (notice) return { state: 'paused', notice };\n\n  const rejection = passThroughPayload ? null : readRejectedToolResult(result);\n  if (rejection) return { state: 'rejected', rejection };\n\n  const failure = toolFailure({ status, result, isError, passThroughPayload });\n  if (failure) return { state: 'error', failure };\n  if (status?.type === 'requires-action') return { state: 'requires-action' };\n  if (result === undefined && status?.type !== 'complete') {\n    return { state: 'running' };\n  }\n  return { state: 'complete' };\n}\n\n/** True when a completed call reads as a success under the shared rules. */\nexport function isToolResultSuccess(result: unknown): boolean {\n  return classifyToolResult({ status: { type: 'complete' }, result }).state === 'complete';\n}\n\n/**\n * A gated tool call the user rejected still \"completes\": both HITL runtimes\n * answer the rejected call with a `ToolMessage` whose text is the rejection\n * (\"Tool call rejected by user. Reason: …\"), and device tools may answer with\n * a structured decision (`{ status: 'rejected' }`, `{ action: 'reject' }`,\n * `{ decision: 'rejected' }`). Anything that labels a finished call has to\n * read that, or a rejected email send reports itself as sent. The read is\n * content-based, so it is scoped to where a rejection can appear: the opening\n * of a string result, never deep inside returned content, and never a\n * pass-through page payload (see {@link classifyToolResult}).\n */\nexport interface RejectedToolResult {\n  /** The feedback the user typed, when they gave one. */\n  reason: string | null;\n}\n\n/**\n * Phrasings the HITL runtimes use for a *human* rejection. Matching on these\n * rather than the word \"reject\" keeps deterministic failures out — argument\n * validation answers a call with \"Tool call rejected — ValidationError: …\",\n * which never involved the user and stays a plain failure.\n */\nconst USER_REJECTION_PATTERNS: readonly RegExp[] = [/rejected by (?:the )?user/i, /user rejected/i];\n\n/**\n * A rejection IS the tool message, so the phrasing opens it: \"The user rejected\n * this action. …\" (`hitl_bridge.py`), \"Tool call rejected by user. Reason: …\",\n * \"Tool 'x' execution rejected by user. …\", \"[INTERRUPT] Custom interrupt\n * '<uuid>' rejected by user. …\". Content a tool merely *returned* — a page read\n * or a document whose text happens to say a user rejected something — carries\n * the phrase deeper in, so only a match starting within this many characters\n * of the first line counts.\n */\nconst USER_REJECTION_LEAD_CHARS = 100;\n\n/** Whether `result` opens with a human-rejection phrasing (see {@link USER_REJECTION_LEAD_CHARS}). */\nfunction opensWithUserRejection(result: string): boolean {\n  const firstLine = result.trimStart().split('\\n', 1)[0] ?? '';\n  return USER_REJECTION_PATTERNS.some((pattern) => {\n    const index = firstLine.search(pattern);\n    return index !== -1 && index < USER_REJECTION_LEAD_CHARS;\n  });\n}\n\n/** Reject-with-no-feedback placeholder the legacy approval editor sends. */\nconst NO_REASON = 'no reason provided';\n\n/**\n * Model-facing guidance the legacy HITL node appends on the same line after\n * the reason (\"… Reason: <reason> Acknowledge in one short sentence. Do not\n * retry…\"). It is instruction for the model, not the user's feedback.\n */\nconst TRAILING_GUIDANCE = /\\s*Acknowledge in one short sentence\\..*$/i;\n\n/**\n * How LangChain's HITL middleware answers a refused call: \"User rejected the\n * tool call for `x` with reason: <message>\", where <message> is the one the\n * deep-agent bridge (`hitl_bridge.py`) handed it.\n */\nconst MIDDLEWARE_ENVELOPE = /^User rejected the tool call for `[^`]*` with reason:\\s*/i;\n\n/**\n * The bridge's refusal, which opens its message. Inside the middleware envelope\n * it is scaffolding, not feedback; the member's own reason, when they gave one,\n * follows it as \"Reason: …\". Outside the envelope the text after \"Reason:\" is\n * the member's, whatever it says.\n */\nconst BRIDGE_REFUSAL = /^The user rejected this action\\.\\s*/i;\n\n/** Everything after \"Reason:\"; feedback typed in the approval editor can span lines. */\nconst REASON_TAIL = /Reason:\\s*([\\s\\S]+)/i;\n\nfunction readRejectionReason(result: string): string | null {\n  const text = result.trim();\n  const envelope = MIDDLEWARE_ENVELOPE.exec(text);\n  let reason: string | undefined;\n  if (envelope) {\n    const message = text.slice(envelope[0].length).replace(TRAILING_GUIDANCE, '').trim();\n    reason = BRIDGE_REFUSAL.test(message)\n      ? message.replace(BRIDGE_REFUSAL, '').match(/^Reason:\\s*([\\s\\S]+)/i)?.[1]\n      : message;\n  } else {\n    reason = text.match(REASON_TAIL)?.[1]?.replace(TRAILING_GUIDANCE, '');\n  }\n  reason = reason?.trim();\n  if (!reason || reason.toLowerCase() === NO_REASON) return null;\n  return reason;\n}\n\n/**\n * Read a rejection out of a completed tool call's result, or `null` when the\n * call actually ran (or failed for a non-approval reason).\n */\nexport function readRejectedToolResult(result: unknown): RejectedToolResult | null {\n  if (typeof result === 'string') {\n    if (!opensWithUserRejection(result)) return null;\n    return { reason: readRejectionReason(result) };\n  }\n  if (!isRecord(result)) return null;\n  if (result.status === 'rejected' || result.action === 'reject' || result.decision === 'rejected') {\n    return { reason: stringField(result, ['reason']) };\n  }\n  return null;\n}\n\n/** True when a completed call's result records that the user rejected it. */\nexport function isRejectedToolResult(result: unknown): boolean {\n  return readRejectedToolResult(result) !== null;\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,159 @@
+import type { LangChainMessage } from '@assistant-ui/react-langgraph';
+import type { StatewireThread } from '@assistant-ui/react-statewire';
+import type { StatewireClient } from 'statewire';
+import type { DeepAgentVoiceWireError } from './voice-wire-types';
+export type { DeepAgentVoiceWireError } from './voice-wire-types';
+/** The deepagents `write_todos` item shape (also the `todos` state-channel element). */
+export interface Todo {
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'cancelled' | 'failed';
+}
+/**
+ * One in-eval subagent dispatch, from the backend's `ptc_subagents` state
+ * channel (route `_forward_ptc_subagent_event`). These lifecycle events are the
+ * only live signal for interpreter-dispatched subagents — their transcripts
+ * never reach the parent `messages` stream — so lanes derive status from here.
+ */
+export interface PtcSubagentEntry {
+    id: string;
+    status?: 'queued' | 'running' | 'complete' | 'error';
+    subagent_type?: string | null;
+    label?: string | null;
+    description?: string | null;
+    eval_id?: string;
+    duration_ms?: number;
+    error?: string;
+    /**
+     * Final output text of a finished dispatch, from Athena's in-eval output
+     * bridge (the SDK's `complete` lifecycle event omits it). Absent on older
+     * backends.
+     */
+    output?: string;
+    /**
+     * Tool calls the dispatch executed, from Athena's `complete` lifecycle event
+     * (counted backend-side from the subagent's final state). Absent on older
+     * backends and when the dispatch produced no readable artifact — in-eval
+     * lanes previously hardcoded 0 here.
+     */
+    tool_call_count?: number;
+    /**
+     * The dispatch's live streamed transcript (Athena's in-eval transcript
+     * bridge, `phase: "message"` lifecycle events folded backend-side) — the
+     * same message-dict shape as a task ToolMessage's
+     * `artifact.subgraph_state.messages`. Wire-only: absent after a reopen and
+     * on older backends.
+     */
+    messages?: LangChainMessage[];
+    /**
+     * What the wire left off `messages`: the host carries the dispatch's newest
+     * steps, cut like a running `task` card's, and counts the whole lane here,
+     * `finished` once the lane settled (a finished in-eval lane stays cut).
+     * Absent while `messages` holds every step, and on older backends.
+     */
+    athena_lane_truncated?: {
+        messages: number;
+        tool_calls: number;
+        finished?: boolean;
+    };
+    /**
+     * The whole lane's token use, however much of the lane `messages` carries:
+     * the input counting the prompt cache's reads and writes, the cache counts
+     * being parts of it. Absent while no step reported usage, after a reopen, and
+     * on older backends (read through `readLaneUsage`).
+     */
+    athena_lane_usage?: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_input_tokens: number;
+        cache_creation_input_tokens: number;
+    };
+    /**
+     * The checkpoint namespace the dispatch's subagent writes under, recorded
+     * from its streamed steps (agora's `LANE_NS_KEY`), on a registry entry and on
+     * the summary an eval persists. A lane whose steps no longer ride (a later
+     * run stripped its registry entry, or a reopen left only its summary) pages
+     * from that checkpoint with `history/lane {lane}`. Absent on summaries
+     * written before agora recorded it.
+     */
+    ns?: string | null;
+}
+/** The raw deep-agent transport state, typed for the fields the runtime reads. */
+export interface DeepAgentStreamValues {
+    messages?: LangChainMessage[];
+    todos?: Todo[];
+    /**
+     * The most recent Live API rejection during the live voice session, or
+     * `null`/absent when there has been none. Surfaces render it as a notice
+     * line; the session itself stays live.
+     */
+    voiceLastError?: DeepAgentVoiceWireError | null;
+    /**
+     * Live in-eval subagent dispatch lifecycle, keyed by dispatch id (the
+     * backend's `ptc_subagents` channel). Read by `deriveEvalSubagents` — an in-eval
+     * dispatch has no top-level `task` tool call, so this is its only live lane
+     * source.
+     */
+    ptc_subagents?: Record<string, PtcSubagentEntry>;
+    /**
+     * The assets each running studio execution created so far, keyed by its tool call id: agora
+     * lists one as soon as it has verified the SDK's report, and drops the call's entry when the
+     * execution returns (`agora.runtime.ptc_live_creations`). Read by the studio follow-along, which
+     * opens such an asset while the call still writes to it.
+     */
+    ptc_created_assets?: Record<string, ReadonlyArray<{
+        asset_id: string;
+        asset_type: string;
+    }>>;
+    /** The replicated run mounts (lib-owned; see `runs: true` on the thread options). */
+    runs?: readonly StatewireThread.RunState[];
+    /**
+     * The ids of queued entries the user prioritized (⚡, `run/prioritize`), as
+     * the host records them durably: the live run ends at its next model-call
+     * boundary while one of them heads the queue lane. Absent until a thread
+     * first prioritizes; read through `readPrioritizedQueueIds`.
+     */
+    prioritizedQueueIds?: readonly string[];
+    /**
+     * Whether the backend has minted the thread's `session` asset (the row a
+     * host reads as `asset_<threadId>`). Absent — not `false` — while the flag
+     * is unknown: the attach snapshot publishes it (as `null` when the probe
+     * could not tell), and a new thread's preload seeds `false` because its
+     * asset cannot exist before its first run.
+     */
+    sessionPersisted?: boolean | null;
+    /**
+     * Server-advertised wire-contract version (`protocol` lane). Absent on
+     * snapshots from pre-negotiation hosts; read through
+     * `readDeepAgentProtocol` / `projectDeepAgentProtocol`, which ignore the
+     * `minClientVersion` key hosts still publish for older installed clients.
+     */
+    protocol?: {
+        version: number;
+    };
+    __interrupt__?: unknown;
+    [key: string]: unknown;
+}
+/** An object carrying a `messages` array — the app-owned slice of the state. */
+export interface LangGraphState {
+    messages: LangChainMessage[];
+    /** Live per-thread lease status; `queued` means this turn has not started. */
+    run_lifecycle?: {
+        status: 'queued' | 'running' | 'failed' | 'cancelled';
+        wait_timeout_seconds?: number;
+    };
+    todos?: Todo[];
+}
+/** Statewire lifecycle statuses exposed to every Athena surface. */
+export declare const DEEP_AGENT_CONNECTION_STATUSES: readonly ["standby", "connecting", "connected", "retrying", "stopped"];
+export type DeepAgentConnectionStatus = StatewireClient.ConnectionState['status'];
+/** Statewire connection with sanitized host or local suspension detail. */
+export type DeepAgentConnectionState = StatewireClient.ConnectionState & {
+    message?: string;
+};
+/**
+ * Which run lanes project into the converter's message tail. Surfaces without
+ * a queue panel project both lanes so a queued message stays visible until its
+ * dispatch; surfaces with a queue panel project only the steer lane (queued
+ * entries render in the panel instead).
+ */
+export type DeepAgentLaneProjection = 'both' | 'steer-only';

package/dist/agent-runtime/src/use-conversation-list.d.ts

@@ -0,0 +1,76 @@
+import { type QueryClient } from '@tanstack/react-query';
+import { type ConversationListFetcher, type ConversationListFilter, type ConversationSummary } from './conversation-list';
+export interface UseConversationListOptions {
+    /**
+     * Transport adapter for one page (GraphQL `listConversations`, the REST
+     * thread list, …). Captured in a ref — identity changes do not re-key the
+     * cache, so pair a changing fetcher with a changing `scopeKey`.
+     */
+    fetchPage: ConversationListFetcher;
+    filter?: ConversationListFilter;
+    pageSize?: number;
+    /**
+     * Cache identity beyond the filter. MUST include everything that changes
+     * whose list this is — principal/user id, backend base URL — so a
+     * credential swap can never serve another identity's rows from the cache.
+     */
+    scopeKey?: string;
+    enabled?: boolean;
+    staleTime?: number;
+    gcTime?: number;
+    refetchOnMount?: boolean | 'always';
+    refetchOnWindowFocus?: boolean;
+    /**
+     * Newest-page freshness is push-based by default (the conversation-index
+     * statewire invalidates these caches), so no timer runs unless asked.
+     */
+    refetchInterval?: number | false;
+    retry?: boolean | number | ((failureCount: number, error: Error) => boolean);
+    /**
+     * The client to cache in. Defaults to the one in context; a hook that may
+     * render outside any `QueryClientProvider` (and stays disabled there)
+     * passes its own.
+     */
+    queryClient?: QueryClient;
+}
+export interface ConversationListController {
+    /** Merged newest-first rows: live first page + retained history pages. */
+    conversations: ConversationSummary[];
+    /** Advisory total from the live first page, when the transport counts. */
+    totalCount: number | null;
+    isLoading: boolean;
+    isFetching: boolean;
+    /** True once the live first page has resolved at least once. */
+    hasResolvedFirstPage: boolean;
+    hasNextPage: boolean;
+    isFetchingNextPage: boolean;
+    /** True while the last next-page request failed (cleared by a successful one). */
+    isFetchNextPageError: boolean;
+    fetchNextPage: () => Promise<unknown>;
+    /** Refetch the live first page (history pages stay frozen). */
+    refresh: () => Promise<unknown>;
+    /** Invalidate every conversation-list cache in this scope (all filters). */
+    invalidate: () => Promise<void>;
+    /** Optimistically show a new conversation at the top of THIS filter view. */
+    prependConversation: (item: ConversationSummary) => void;
+    /** Optimistically drop a conversation from THIS filter view. */
+    removeConversation: (threadId: string) => void;
+    /** Optimistically patch a conversation's row in THIS filter view. */
+    patchConversation: (threadId: string, patch: Partial<ConversationSummary>) => void;
+}
+/**
+ * The shared headless conversation-list pager (chat-stack unification —
+ * thread-list-contract-convergence).
+ *
+ * Implements, once, the two-tier TanStack Query pattern Olympus and mobile
+ * each hand-rolled:
+ *
+ * - a LIVE first-page query — the only observer that refetches on
+ *   invalidation/focus, so push-driven freshness costs one page, and
+ * - a permanently-disabled infinite "history" query whose pages are fetched
+ *   only by explicit `fetchNextPage()` calls and retained without replay
+ *   (invalidation/polling never refetches every loaded page).
+ *
+ * Rows merge newest-first with the live page winning duplicate threads.
+ */
+export declare function useConversationList(options: UseConversationListOptions): ConversationListController;

package/dist/agent-runtime/src/use-deep-agent-chat-outbox.cjs

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+const chatOutbox = require("./chat-outbox.cjs");
+const chatOutboxThread = require("./chat-outbox-thread.cjs");
+function useDeepAgentChatOutbox({
+  client,
+  threadId,
+  isNewChat,
+  store,
+  reachability,
+  foreground,
+  restore,
+  openThread,
+  onEvent,
+  checkAttachments,
+  enabled = true,
+  countdownMs
+}) {
+  const clientRef = react.useRef(client);
+  clientRef.current = client;
+  const restoreRef = react.useRef(restore);
+  restoreRef.current = restore;
+  const openThreadRef = react.useRef(openThread);
+  openThreadRef.current = openThread;
+  const canOpenThreads = openThread !== void 0;
+  const onEventRef = react.useRef(onEvent);
+  onEventRef.current = onEvent;
+  const checkAttachmentsRef = react.useRef(checkAttachments);
+  checkAttachmentsRef.current = checkAttachments;
+  const checksAttachments = checkAttachments !== void 0;
+  const reachabilityRef = react.useRef(reachability);
+  reachabilityRef.current = reachability;
+  const foregroundRef = react.useRef(foreground);
+  foregroundRef.current = foreground;
+  const [threadListeners] = react.useState(() => /* @__PURE__ */ new Set());
+  react.useEffect(() => {
+    if (!enabled) return void 0;
+    return client.subscribe(() => {
+      for (const listener of threadListeners) listener();
+    });
+  }, [client, threadListeners, enabled]);
+  const [stableSignals] = react.useState(() => {
+    const forward = (pick) => ({
+      get: () => pick().get(),
+      subscribe: (listener) => pick().subscribe(listener)
+    });
+    return {
+      reachability: forward(() => reachabilityRef.current),
+      foreground: forward(() => foregroundRef.current)
+    };
+  });
+  const isNewChatRef = react.useRef(isNewChat);
+  isNewChatRef.current = isNewChat;
+  const [outbox, setOutbox] = react.useState(null);
+  react.useEffect(() => {
+    if (!enabled || !threadId) {
+      setOutbox(null);
+      return void 0;
+    }
+    const created = chatOutbox.createChatOutbox({
+      threadId,
+      // Read at each hold: a chat that starts while mounted stamps its later messages as started.
+      isNewChat: () => isNewChatRef.current,
+      store,
+      reachability: stableSignals.reachability,
+      foreground: stableSignals.foreground,
+      thread: {
+        ...chatOutboxThread.createStatewireChatOutboxPort({ client: () => clientRef.current }),
+        subscribe: (listener) => {
+          threadListeners.add(listener);
+          return () => {
+            threadListeners.delete(listener);
+          };
+        }
+      },
+      restore: (entry) => restoreRef.current(entry),
+      ...canOpenThreads && {
+        openThread: (target) => {
+          var _a;
+          return (_a = openThreadRef.current) == null ? void 0 : _a.call(openThreadRef, target);
+        }
+      },
+      onEvent: (event) => {
+        var _a;
+        return (_a = onEventRef.current) == null ? void 0 : _a.call(onEventRef, event);
+      },
+      ...checksAttachments && {
+        checkAttachments: (attachments) => {
+          var _a;
+          return ((_a = checkAttachmentsRef.current) == null ? void 0 : _a.call(checkAttachmentsRef, attachments)) ?? Promise.resolve("ok");
+        }
+      },
+      ...countdownMs !== void 0 && { countdownMs }
+    });
+    setOutbox(created);
+    return () => {
+      created.dispose();
+      setOutbox((current) => current === created ? null : current);
+    };
+  }, [enabled, threadId, store, countdownMs, canOpenThreads, checksAttachments]);
+  return outbox !== null && outbox.threadId === threadId ? outbox : null;
+}
+const EMPTY_SNAPSHOT = {
+  rows: [],
+  countdownEndsAt: null,
+  durable: true,
+  loaded: true,
+  elsewhere: []
+};
+const noopSubscribe = () => () => void 0;
+function useChatOutboxSnapshot(outbox) {
+  return react.useSyncExternalStore(
+    outbox ? outbox.subscribe : noopSubscribe,
+    () => (outbox == null ? void 0 : outbox.getSnapshot()) ?? EMPTY_SNAPSHOT,
+    () => (outbox == null ? void 0 : outbox.getSnapshot()) ?? EMPTY_SNAPSHOT
+  );
+}
+function useChatOutboxReachable(outbox) {
+  const subscribe = react.useCallback(
+    (listener) => outbox ? outbox.reachability.subscribe(listener) : () => void 0,
+    [outbox]
+  );
+  const reachable = () => (outbox == null ? void 0 : outbox.reachability.get()) ?? true;
+  return react.useSyncExternalStore(subscribe, reachable, reachable);
+}
+const DeepAgentChatOutboxContext = react.createContext(null);
+function useDeepAgentChatOutboxContext() {
+  return react.useContext(DeepAgentChatOutboxContext);
+}
+exports.DeepAgentChatOutboxContext = DeepAgentChatOutboxContext;
+exports.useChatOutboxReachable = useChatOutboxReachable;
+exports.useChatOutboxSnapshot = useChatOutboxSnapshot;
+exports.useDeepAgentChatOutbox = useDeepAgentChatOutbox;
+exports.useDeepAgentChatOutboxContext = useDeepAgentChatOutboxContext;
+//# sourceMappingURL=use-deep-agent-chat-outbox.cjs.map

package/dist/agent-runtime/src/use-deep-agent-chat-outbox.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-deep-agent-chat-outbox.cjs","sources":["../../../../agent-runtime/src/use-deep-agent-chat-outbox.ts"],"sourcesContent":["import { createContext, useCallback, useContext, useEffect, useRef, useState, useSyncExternalStore } from \"react\";\nimport type { ChatOutboxAttachmentCheck } from \"./chat-outbox-attachments\";\nimport {\n  type ChatOutbox,\n  type ChatOutboxCommandUpdate,\n  type ChatOutboxEvent,\n  type ChatOutboxSignal,\n  type ChatOutboxSnapshot,\n  createChatOutbox,\n} from \"./chat-outbox\";\nimport type { ChatOutboxEntry, ChatOutboxStore } from \"./chat-outbox-store\";\nimport { type ChatOutboxClientHost, createStatewireChatOutboxPort } from \"./chat-outbox-thread\";\n\nexport interface UseDeepAgentChatOutboxOptions {\n  /** The thread's assistant-ui client (`useDeepAgentRuntime`'s result). */\n  client: ChatOutboxClientHost;\n  threadId: string;\n  /** The conversation has never started (a new chat). */\n  isNewChat: boolean;\n  /**\n   * This person's outbox store, one per person for the life of the page or app (a message the\n   * device cannot keep waits in its memory, across thread switches); `null` keeps waiting messages\n   * in this outbox alone.\n   */\n  store: ChatOutboxStore | null;\n  /** Athena's reachability (the host's own model: the browser online AND agora answering). */\n  reachability: ChatOutboxSignal;\n  /** The app is in front (a visible tab, an active app, a focused desktop window). */\n  foreground: ChatOutboxSignal;\n  /** Give a cancelled message's text back to the composer. */\n  restore: (entry: ChatOutboxEntry) => void;\n  /**\n   * Open another of the person's conversations holding waiting messages (the tray's Open); omit\n   * it where the host cannot switch conversations.\n   */\n  openThread?: (target: { threadId: string; newChat: boolean }) => void;\n  onEvent?: (event: ChatOutboxEvent) => void;\n  /**\n   * Asks Athena whether a waiting message's attachments can still be opened, right before it goes\n   * (`createChatOutboxAttachmentCheck`); omitted, attachments go unchecked.\n   */\n  checkAttachments?: ChatOutboxAttachmentCheck;\n  /** Off: no outbox (a read-only or suspended surface); sends behave as before. */\n  enabled?: boolean;\n  /** The countdown before a waiting message is sent (tests); defaults to `CHAT_OUTBOX_COUNTDOWN_MS`. */\n  countdownMs?: number;\n}\n\n/**\n * The chat outbox for the mounted thread (`chat-outbox.ts`), one per thread and store: a thread\n * switch disposes it and makes the next thread's. The host forwards statewire's command lifecycle\n * to {@link ChatOutbox.observeCommand} (its `useDeepAgentRuntime` `onCommandChange`), shares the\n * instance through {@link DeepAgentChatOutboxContext}, and has its composer call\n * {@link ChatOutbox.shouldHold} / {@link ChatOutbox.hold} before sending.\n */\nexport function useDeepAgentChatOutbox({\n  client,\n  threadId,\n  isNewChat,\n  store,\n  reachability,\n  foreground,\n  restore,\n  openThread,\n  onEvent,\n  checkAttachments,\n  enabled = true,\n  countdownMs,\n}: UseDeepAgentChatOutboxOptions): ChatOutbox | null {\n  const clientRef = useRef(client);\n  clientRef.current = client;\n  const restoreRef = useRef(restore);\n  restoreRef.current = restore;\n  const openThreadRef = useRef(openThread);\n  openThreadRef.current = openThread;\n  const canOpenThreads = openThread !== undefined;\n  const onEventRef = useRef(onEvent);\n  onEventRef.current = onEvent;\n  const checkAttachmentsRef = useRef(checkAttachments);\n  checkAttachmentsRef.current = checkAttachments;\n  const checksAttachments = checkAttachments !== undefined;\n  const reachabilityRef = useRef(reachability);\n  reachabilityRef.current = reachability;\n  const foregroundRef = useRef(foreground);\n  foregroundRef.current = foreground;\n  // The client's notifications reach the port through this set, so a client whose identity\n  // changes mid-thread is followed without remaking the outbox (and losing its countdown).\n  const [threadListeners] = useState(() => new Set<() => void>());\n  // A host without an outbox (`enabled` false) is never subscribed to.\n  useEffect(() => {\n    if (!enabled) return undefined;\n    return client.subscribe(() => {\n      for (const listener of threadListeners) listener();\n    });\n  }, [client, threadListeners, enabled]);\n  // Signals read through refs for the same reason: a host rebuilding its signal objects per render\n  // never remakes the outbox.\n  const [stableSignals] = useState(() => {\n    const forward = (pick: () => ChatOutboxSignal): ChatOutboxSignal => ({\n      get: () => pick().get(),\n      subscribe: (listener) => pick().subscribe(listener),\n    });\n    return {\n      reachability: forward(() => reachabilityRef.current),\n      foreground: forward(() => foregroundRef.current),\n    };\n  });\n  const isNewChatRef = useRef(isNewChat);\n  isNewChatRef.current = isNewChat;\n\n  const [outbox, setOutbox] = useState<ChatOutbox | null>(null);\n  // Made in an effect, not during render: the outbox subscribes to its signals and reads its\n  // store, and a render React throws away must not leave those behind.\n  // biome-ignore lint/correctness/useExhaustiveDependencies: one outbox per thread and store; everything else is read through refs.\n  useEffect(() => {\n    if (!enabled || !threadId) {\n      setOutbox(null);\n      return undefined;\n    }\n    const created = createChatOutbox({\n      threadId,\n      // Read at each hold: a chat that starts while mounted stamps its later messages as started.\n      isNewChat: () => isNewChatRef.current,\n      store,\n      reachability: stableSignals.reachability,\n      foreground: stableSignals.foreground,\n      thread: {\n        ...createStatewireChatOutboxPort({ client: () => clientRef.current }),\n        subscribe: (listener) => {\n          threadListeners.add(listener);\n          return () => {\n            threadListeners.delete(listener);\n          };\n        },\n      },\n      restore: (entry) => restoreRef.current(entry),\n      ...(canOpenThreads && {\n        openThread: (target: { threadId: string; newChat: boolean }) => openThreadRef.current?.(target),\n      }),\n      onEvent: (event) => onEventRef.current?.(event),\n      ...(checksAttachments && {\n        checkAttachments: (attachments: Parameters<ChatOutboxAttachmentCheck>[0]) =>\n          checkAttachmentsRef.current?.(attachments) ?? Promise.resolve(\"ok\" as const),\n      }),\n      ...(countdownMs !== undefined && { countdownMs }),\n    });\n    setOutbox(created);\n    return () => {\n      created.dispose();\n      setOutbox((current) => (current === created ? null : current));\n    };\n  }, [enabled, threadId, store, countdownMs, canOpenThreads, checksAttachments]);\n  // During a thread switch's first render the previous thread's outbox is still in state.\n  return outbox !== null && outbox.threadId === threadId ? outbox : null;\n}\n\nconst EMPTY_SNAPSHOT: ChatOutboxSnapshot = {\n  rows: [],\n  countdownEndsAt: null,\n  durable: true,\n  loaded: true,\n  elsewhere: [],\n};\nconst noopSubscribe = () => () => undefined;\n\n/** The outbox's rows and countdown, re-rendering on every change (`null` outbox: nothing waits). */\nexport function useChatOutboxSnapshot(outbox: ChatOutbox | null): ChatOutboxSnapshot {\n  return useSyncExternalStore(\n    outbox ? outbox.subscribe : noopSubscribe,\n    () => outbox?.getSnapshot() ?? EMPTY_SNAPSHOT,\n    () => outbox?.getSnapshot() ?? EMPTY_SNAPSHOT,\n  );\n}\n\n/**\n * Whether Athena can be reached, as the thread's outbox reads it: `true` without an outbox (a host\n * that keeps none sends and edits as before). What a sent message's Edit is offered on; a boolean,\n * so a reader re-renders only when it flips.\n */\nexport function useChatOutboxReachable(outbox: ChatOutbox | null): boolean {\n  const subscribe = useCallback(\n    (listener: () => void) => (outbox ? outbox.reachability.subscribe(listener) : () => undefined),\n    [outbox],\n  );\n  const reachable = () => outbox?.reachability.get() ?? true;\n  return useSyncExternalStore(subscribe, reachable, reachable);\n}\n\n/** The mounted thread's chat outbox, shared from its runtime provider to its composer and tray. */\nexport const DeepAgentChatOutboxContext = createContext<ChatOutbox | null>(null);\n\nexport function useDeepAgentChatOutboxContext(): ChatOutbox | null {\n  return useContext(DeepAgentChatOutboxContext);\n}\n\n/** Forward statewire's command lifecycle to an outbox held in a ref (the runtime is made first). */\nexport function forwardChatOutboxCommand(\n  outbox: { current: ChatOutbox | null },\n  update: ChatOutboxCommandUpdate,\n): void {\n  outbox.current?.observeCommand(update);\n}\n"],"names":["useRef","useState","useEffect","createChatOutbox","createStatewireChatOutboxPort","useSyncExternalStore","useCallback","createContext","useContext"],"mappings":";;;;;AAuDO,SAAS,uBAAuB;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,UAAU;AAAA,EACV;AACF,GAAqD;AACnD,QAAM,YAAYA,MAAAA,OAAO,MAAM;AAC/B,YAAU,UAAU;AACpB,QAAM,aAAaA,MAAAA,OAAO,OAAO;AACjC,aAAW,UAAU;AACrB,QAAM,gBAAgBA,MAAAA,OAAO,UAAU;AACvC,gBAAc,UAAU;AACxB,QAAM,iBAAiB,eAAe;AACtC,QAAM,aAAaA,MAAAA,OAAO,OAAO;AACjC,aAAW,UAAU;AACrB,QAAM,sBAAsBA,MAAAA,OAAO,gBAAgB;AACnD,sBAAoB,UAAU;AAC9B,QAAM,oBAAoB,qBAAqB;AAC/C,QAAM,kBAAkBA,MAAAA,OAAO,YAAY;AAC3C,kBAAgB,UAAU;AAC1B,QAAM,gBAAgBA,MAAAA,OAAO,UAAU;AACvC,gBAAc,UAAU;AAGxB,QAAM,CAAC,eAAe,IAAIC,MAAAA,SAAS,MAAM,oBAAI,KAAiB;AAE9DC,QAAAA,UAAU,MAAM;AACd,QAAI,CAAC,QAAS,QAAO;AACrB,WAAO,OAAO,UAAU,MAAM;AAC5B,iBAAW,YAAY,gBAAiB,UAAA;AAAA,IAC1C,CAAC;AAAA,EACH,GAAG,CAAC,QAAQ,iBAAiB,OAAO,CAAC;AAGrC,QAAM,CAAC,aAAa,IAAID,MAAAA,SAAS,MAAM;AACrC,UAAM,UAAU,CAAC,UAAoD;AAAA,MACnE,KAAK,MAAM,KAAA,EAAO,IAAA;AAAA,MAClB,WAAW,CAAC,aAAa,KAAA,EAAO,UAAU,QAAQ;AAAA,IAAA;AAEpD,WAAO;AAAA,MACL,cAAc,QAAQ,MAAM,gBAAgB,OAAO;AAAA,MACnD,YAAY,QAAQ,MAAM,cAAc,OAAO;AAAA,IAAA;AAAA,EAEnD,CAAC;AACD,QAAM,eAAeD,MAAAA,OAAO,SAAS;AACrC,eAAa,UAAU;AAEvB,QAAM,CAAC,QAAQ,SAAS,IAAIC,MAAAA,SAA4B,IAAI;AAI5DC,QAAAA,UAAU,MAAM;AACd,QAAI,CAAC,WAAW,CAAC,UAAU;AACzB,gBAAU,IAAI;AACd,aAAO;AAAA,IACT;AACA,UAAM,UAAUC,WAAAA,iBAAiB;AAAA,MAC/B;AAAA;AAAA,MAEA,WAAW,MAAM,aAAa;AAAA,MAC9B;AAAA,MACA,cAAc,cAAc;AAAA,MAC5B,YAAY,cAAc;AAAA,MAC1B,QAAQ;AAAA,QACN,GAAGC,iBAAAA,8BAA8B,EAAE,QAAQ,MAAM,UAAU,SAAS;AAAA,QACpE,WAAW,CAAC,aAAa;AACvB,0BAAgB,IAAI,QAAQ;AAC5B,iBAAO,MAAM;AACX,4BAAgB,OAAO,QAAQ;AAAA,UACjC;AAAA,QACF;AAAA,MAAA;AAAA,MAEF,SAAS,CAAC,UAAU,WAAW,QAAQ,KAAK;AAAA,MAC5C,GAAI,kBAAkB;AAAA,QACpB,YAAY,CAAC;;AAAmD,qCAAc,YAAd,uCAAwB;AAAA;AAAA,MAAM;AAAA,MAEhG,SAAS,CAAC,UAAA;;AAAU,gCAAW,YAAX,oCAAqB;AAAA;AAAA,MACzC,GAAI,qBAAqB;AAAA,QACvB,kBAAkB,CAAC,gBAAA;;AACjB,4CAAoB,YAApB,6CAA8B,iBAAgB,QAAQ,QAAQ,IAAa;AAAA;AAAA,MAAA;AAAA,MAE/E,GAAI,gBAAgB,UAAa,EAAE,YAAA;AAAA,IAAY,CAChD;AACD,cAAU,OAAO;AACjB,WAAO,MAAM;AACX,cAAQ,QAAA;AACR,gBAAU,CAAC,YAAa,YAAY,UAAU,OAAO,OAAQ;AAAA,IAC/D;AAAA,EACF,GAAG,CAAC,SAAS,UAAU,OAAO,aAAa,gBAAgB,iBAAiB,CAAC;AAE7E,SAAO,WAAW,QAAQ,OAAO,aAAa,WAAW,SAAS;AACpE;AAEA,MAAM,iBAAqC;AAAA,EACzC,MAAM,CAAA;AAAA,EACN,iBAAiB;AAAA,EACjB,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,WAAW,CAAA;AACb;AACA,MAAM,gBAAgB,MAAM,MAAM;AAG3B,SAAS,sBAAsB,QAA+C;AACnF,SAAOC,MAAAA;AAAAA,IACL,SAAS,OAAO,YAAY;AAAA,IAC5B,OAAM,iCAAQ,kBAAiB;AAAA,IAC/B,OAAM,iCAAQ,kBAAiB;AAAA,EAAA;AAEnC;AAOO,SAAS,uBAAuB,QAAoC;AACzE,QAAM,YAAYC,MAAAA;AAAAA,IAChB,CAAC,aAA0B,SAAS,OAAO,aAAa,UAAU,QAAQ,IAAI,MAAM;AAAA,IACpF,CAAC,MAAM;AAAA,EAAA;AAET,QAAM,YAAY,OAAM,iCAAQ,aAAa,UAAS;AACtD,SAAOD,2BAAqB,WAAW,WAAW,SAAS;AAC7D;AAGO,MAAM,6BAA6BE,MAAAA,cAAiC,IAAI;AAExE,SAAS,gCAAmD;AACjE,SAAOC,MAAAA,WAAW,0BAA0B;AAC9C;;;;;;"}