@athenaintel/react 0.41.3 → 0.42.1

package/dist/agent-runtime/src/deep-agent-transport-recipe.js.map

@@ -1 +1 @@
-{"version":3,"file":"deep-agent-transport-recipe.js","sources":["../../../../agent-runtime/src/deep-agent-transport-recipe.ts"],"sourcesContent":["import type { ResourceElement } from \"@assistant-ui/tap\";\nimport type { Statewire, StatewireClient } from \"statewire\";\nimport {\n  type DeepAgentMessageWindowDeclaration,\n  withDeclaredMessageWindow,\n} from \"./message-window\";\nimport { withDeclaredProtocolVersion } from \"./protocol\";\nimport {\n  attachRetryGate,\n  type AttachRetryGate,\n  createAttachInstrumentation,\n  type DeepAgentAttachTimingEvent,\n  type DeepAgentWakeRefusal,\n  parseRetryAfterHeaderMs,\n} from \"./statewire-attach-observer\";\nimport {\n  resolveStatewireTransportKind,\n  statewireTransport,\n  type StatewireTransportOptions,\n} from \"./statewire-transport\";\n\n/** Auth-header resolver for the transport; `staleAuth` is true right after an\n * auth rejection, so resolvers that can force-renew should honor it. */\nexport type DeepAgentHeadersResolver = (ctx: {\n  staleAuth: boolean;\n}) => Record<string, string> | Promise<Record<string, string>>;\n\n/** The statewire attach URL for a thread: the host's `…/v2/threads` mount plus the id. */\nexport function deepAgentThreadUrl({\n  baseUrl,\n  threadId,\n}: {\n  baseUrl: string;\n  threadId: string;\n}): string {\n  return `${baseUrl.replace(/\\/+$/, \"\")}/${encodeURIComponent(threadId)}`;\n}\n\nexport interface DeepAgentAttachTransportOptions {\n  /** Base URL of the deep-agent statewire host (the `…/v2/threads` mount). */\n  baseUrl: string;\n  threadId: string;\n  headers: DeepAgentHeadersResolver;\n  /** SSE when true, WebSocket otherwise (`resolveStatewireTransportKind`). */\n  sse?: boolean;\n  /** A never-started chat: the transport makes no network calls until the first command send. */\n  isNew?: boolean;\n  /** Host session store (mobile); browser hosts mount `storage.session` on the thread instead. */\n  sessionStore?: StatewireClient.SessionStorage | undefined;\n  /** Observes every headers resolve (the diagnostics recorder's stale-auth seam). */\n  onAuthResolve?: ((ctx: { staleAuth: boolean }) => void) | undefined;\n  /** Attach timing + retry hints (see `statewire-attach-observer`). */\n  onAttachTiming?: ((event: DeepAgentAttachTimingEvent) => void) | undefined;\n  /** Dial floors from server retry hints; the process-wide gate by default. */\n  retryGate?: AttachRetryGate;\n  /**\n   * The head window declared on the attach (`x-athena-deep-agent-window`,\n   * see `message-window.ts`): the hello of a client the host does not\n   * remember carries the newest `size` messages. Part of the recipe so a\n   * pooled dial asks for the same shape as the thread's own attach — a pooled\n   * hello then seeds the very state the attach will reconcile. Omitted, the\n   * shared default is declared.\n   */\n  messageWindow?: DeepAgentMessageWindowDeclaration | undefined;\n}\n\n/**\n * The ONE recipe for a deep-agent thread transport — shared by the mounted\n * thread (`useDeepAgentThread`) and the prewarm pool, so a pre-dialed\n * connection is byte-for-byte the connection the thread would have opened\n * itself: same URL, same auth + wire-contract headers, same session lane, same\n * instrumentation.\n *\n * Every attach declares this build's wire-contract version alongside the\n * host's auth headers (first WS frame / SSE request headers) — the server\n * half of version negotiation reads it in `authorize`. The headers resolve\n * also waits out any server `Retry-After` floor for the thread: both statewire\n * attach paths resolve headers before they dial, so this is the seam where a\n * hint can hold the next dial without touching the library's backoff.\n */\nexport function createDeepAgentAttachTransport<TState = unknown>({\n  baseUrl,\n  threadId,\n  headers,\n  sse = false,\n  isNew = false,\n  sessionStore,\n  onAuthResolve,\n  onAttachTiming,\n  retryGate = attachRetryGate,\n  messageWindow,\n}: DeepAgentAttachTransportOptions): ResourceElement<\n  Statewire<TState | undefined>\n> {\n  const url = deepAgentThreadUrl({ baseUrl, threadId });\n  // The instrumentation wraps the transport actually built: SSE needs the\n  // fetch wrapper that reads a refused attach's `Retry-After`.\n  const useSse = resolveStatewireTransportKind({ sse }) === \"sse\";\n  const instrumentation = createAttachInstrumentation({\n    url,\n    sse: useSse,\n    onEvent: onAttachTiming,\n    retryGate,\n  });\n  const options: StatewireTransportOptions = {\n    url,\n    ...(isNew && { isNew: true }),\n    headers: async (ctx: { staleAuth: boolean }) => {\n      await retryGate.waitForDial(url);\n      onAuthResolve?.(ctx);\n      return withDeclaredMessageWindow(\n        withDeclaredProtocolVersion(await headers(ctx)),\n        messageWindow,\n      );\n    },\n    ...(sessionStore && { sessionStore }),\n    // Structural types: this package compiles without the DOM lib, while\n    // statewire's option types name the browser `WebSocket`/`fetch`.\n    ...(instrumentation.webSocket && {\n      webSocket:\n        instrumentation.webSocket as unknown as StatewireTransportOptions[\"webSocket\"],\n    }),\n    ...(instrumentation.fetch && {\n      fetch:\n        instrumentation.fetch as unknown as StatewireTransportOptions[\"fetch\"],\n    }),\n  };\n  return statewireTransport<TState>(options, { sse: useSse });\n}\n\n/** What `POST …/prewarm` answered. */\nexport interface DeepAgentWakeResult {\n  status: number;\n  /** The host activated the thread and its history is resident. */\n  warm: boolean;\n  /**\n   * `'warm'` when the history was already memoized, `'fresh_load'` when this\n   * call loaded it; `null` when the host did not say (a refusal, or a host\n   * without the route).\n   */\n  history: \"fresh_load\" | \"warm\" | null;\n  /**\n   * The dial floor recorded for the thread off a 503/429 `Retry-After` — the\n   * header's value, except a 503 `\"worker\"` refusal, capped at\n   * {@link WAKE_WORKER_REFUSAL_FLOOR_MS}.\n   */\n  retryAfterMs: number | null;\n  /** Who refused a 503/429 (see {@link DeepAgentWakeRefusal}); `null` for any other answer. */\n  refusal: DeepAgentWakeRefusal;\n  durationMs: number;\n}\n\n/**\n * Dial floor for a 503 the pinned worker produced about one instance's\n * lifecycle. Pinned answers every retriable 503 with a blanket\n * `Retry-After: 1`, but what those name — an instance record mid-teardown\n * (\"instance closing; retry\": fence release + placement release, ≈100 ms), a\n * full activation queue — clears far sooner than that, and the thread's own\n * attach is the request that carries the next activation. Holding it a full\n * second traded a ≈100 ms gap for a ≈1 s stall on every refused wake. A 429\n * is rate limiting and keeps its hint whatever the body says.\n */\nexport const WAKE_WORKER_REFUSAL_FLOOR_MS = 250;\n\n/**\n * The pinboard's own placement-refusal vocabulary — the `error` strings of\n * `@assistant-ui/pinboard` (`src/refusals.ts` plus the two inline refusals in\n * `src/server.ts`). Mirrors `PINBOARD_PLACEMENT_REFUSAL_ERRORS` in\n * `iris/scaler/src/v2AccessLog.ts`, whose test pins it to the installed\n * library; keep the two lists identical. A body with any other `error`\n * string is `\"unknown\"`, never `\"placement\"`.\n */\nexport const PINBOARD_PLACEMENT_REFUSAL_ERRORS: ReadonlySet<string> = new Set([\n  \"no live backends for namespace\",\n  \"registry cold start, retry\",\n  \"not the serving fleet\",\n  \"no live workers for hostname\",\n  \"hostname binding displaced, retry\",\n  \"hostname bindings inconsistent, retry\",\n  \"takeover in progress, retry\",\n  \"placement held by another hostname\",\n  \"worker inflight cap exceeded, retry\",\n  \"worker refused activation, retry\",\n]);\n\n/**\n * Pinned's instance-lifecycle refusals (`pinned/hosting/directory.py`,\n * `pinned/hosting/_records.py`): each names one instance on the worker the\n * thread is already placed on and clears in the time a teardown or an\n * activation slot takes. Anything else the worker answers 503 with — \"Thread\n * history load failed\", \"The regional conversation store is temporarily\n * unavailable\", a lease that expired — is not about one instance and keeps\n * the full hint.\n */\nexport const PINNED_TRANSIENT_WORKER_REFUSALS: ReadonlySet<string> = new Set([\n  \"instance closing; retry\",\n  \"instance aborted\",\n  \"activation queue full; retry\",\n  \"host draining; retry\",\n  \"instance capacity reached; retry\",\n  \"instance past its wind-down deadline; retry\",\n]);\n\n/**\n * Classify a 503/429 body (see {@link DeepAgentWakeRefusal}): a known pinboard\n * `error` is `\"placement\"`, a known pinned `detail` is `\"worker\"`, everything\n * else — including unfamiliar strings in either field — is `\"unknown\"`.\n */\nexport function classifyWakeRefusal(\n  body: unknown,\n): Exclude<DeepAgentWakeRefusal, null> {\n  if (typeof body === \"object\" && body !== null) {\n    const record = body as Record<string, unknown>;\n    if (\n      typeof record.error === \"string\" &&\n      PINBOARD_PLACEMENT_REFUSAL_ERRORS.has(record.error)\n    ) {\n      return \"placement\";\n    }\n    if (\n      typeof record.detail === \"string\" &&\n      PINNED_TRANSIENT_WORKER_REFUSALS.has(record.detail)\n    ) {\n      return \"worker\";\n    }\n  }\n  return \"unknown\";\n}\n\n/** Structural `fetch` for the wake call — this package compiles without the DOM lib. */\nexport type DeepAgentWakeFetch = (\n  input: string,\n  init?: {\n    method?: string;\n    headers?: Record<string, string>;\n    keepalive?: boolean;\n  },\n) => Promise<{\n  ok: boolean;\n  status: number;\n  headers: { get(name: string): string | null };\n  json(): Promise<unknown>;\n}>;\n\nexport interface DeepAgentWakeOptions {\n  /** Base URL of the deep-agent statewire host (the `…/v2/threads` mount). */\n  baseUrl: string;\n  threadId: string;\n  headers: DeepAgentHeadersResolver;\n  fetch?: DeepAgentWakeFetch | undefined;\n  /** Dial floors from server retry hints; the process-wide gate by default. */\n  retryGate?: AttachRetryGate;\n  onAttachTiming?: ((event: DeepAgentAttachTimingEvent) => void) | undefined;\n  now?: () => number;\n}\n\n/**\n * Wake a thread's server instance ahead of its attach. `POST …/prewarm` runs\n * the host's `authorize` and history load — the fence adopt, graph compile and\n * checkpoint read that make a cold attach's hello take ≈1 s — and answers with\n * no thread content, only whether the history was already resident. Fire it\n * on hover intent, before a pooled attach or the click's own dial, so the\n * activation overlaps the handshake and the attach that follows finds the\n * instance warm.\n *\n * Fire-and-forget by contract: every failure resolves `null`, and a host\n * without the route (404) is reported like any other non-OK answer. A 503/429\n * `Retry-After` is recorded as a dial floor for the thread, so the attach that\n * follows waits it out instead of bouncing — in full, except a 503 that names\n * one of pinned's instance-lifecycle refusals (one instance mid-teardown on\n * the worker the thread already has; see {@link DeepAgentWakeRefusal}), whose\n * floor is capped at {@link WAKE_WORKER_REFUSAL_FLOOR_MS}.\n */\nexport async function wakeDeepAgentThread({\n  baseUrl,\n  threadId,\n  headers,\n  fetch: fetchOverride,\n  retryGate = attachRetryGate,\n  onAttachTiming,\n  now = () => Date.now(),\n}: DeepAgentWakeOptions): Promise<DeepAgentWakeResult | null> {\n  const fetchImpl =\n    fetchOverride ?? (globalThis as { fetch?: DeepAgentWakeFetch }).fetch;\n  if (typeof fetchImpl !== \"function\") return null;\n  const threadUrl = deepAgentThreadUrl({ baseUrl, threadId });\n  const emit = (event: DeepAgentAttachTimingEvent): void => {\n    try {\n      onAttachTiming?.(event);\n    } catch {\n      // Observers are best-effort.\n    }\n  };\n  const startedAt = now();\n  try {\n    const resolved = withDeclaredProtocolVersion(\n      await headers({ staleAuth: false }),\n    );\n    const response = await fetchImpl(`${threadUrl}/prewarm`, {\n      method: \"POST\",\n      headers: resolved,\n      keepalive: true,\n    });\n    const durationMs = now() - startedAt;\n    let retryAfterMs: number | null = null;\n    let refusal: DeepAgentWakeRefusal = null;\n    if (response.status === 503 || response.status === 429) {\n      let body: unknown = null;\n      try {\n        body = await response.json();\n      } catch {\n        // A refusal without a readable body is classified by nothing.\n      }\n      refusal = classifyWakeRefusal(body);\n      const hinted = parseRetryAfterHeaderMs(\n        response.headers.get(\"retry-after\"),\n        now,\n      );\n      if (hinted !== null) {\n        retryAfterMs =\n          response.status === 503 && refusal === \"worker\"\n            ? Math.min(hinted, WAKE_WORKER_REFUSAL_FLOOR_MS)\n            : hinted;\n        if (retryAfterMs > 0) {\n          retryGate.noteRetryAfter(threadUrl, retryAfterMs);\n          emit({\n            type: \"retry-after\",\n            url: threadUrl,\n            delayMs: retryAfterMs,\n            source: \"http-header\",\n          });\n        }\n      }\n    }\n    let warm = false;\n    let history: DeepAgentWakeResult[\"history\"] = null;\n    if (response.ok) {\n      try {\n        const body = (await response.json()) as {\n          warm?: unknown;\n          history?: unknown;\n        } | null;\n        warm = body?.warm === true;\n        history =\n          body?.history === \"warm\" || body?.history === \"fresh_load\"\n            ? body.history\n            : null;\n      } catch {\n        // A 200 without a JSON body still means the instance is up.\n        warm = true;\n      }\n    }\n    emit({\n      type: \"wake\",\n      url: threadUrl,\n      status: response.status,\n      durationMs,\n      history,\n      refusal,\n    });\n    return {\n      status: response.status,\n      warm,\n      history,\n      retryAfterMs,\n      refusal,\n      durationMs,\n    };\n  } catch {\n    return null;\n  }\n}\n"],"names":[],"mappings":";;;;AA4BO,SAAS,mBAAmB;AAAA,EACjC;AAAA,EACA;AACF,GAGW;AACT,SAAO,GAAG,QAAQ,QAAQ,QAAQ,EAAE,CAAC,IAAI,mBAAmB,QAAQ,CAAC;AACvE;AA4CO,SAAS,+BAAiD;AAAA,EAC/D;AAAA,EACA;AAAA,EACA;AAAA,EACA,MAAM;AAAA,EACN,QAAQ;AAAA,EACR;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY;AAAA,EACZ;AACF,GAEE;AACA,QAAM,MAAM,mBAAmB,EAAE,SAAS,UAAU;AAGpD,QAAM,SAAS,8BAA8B,EAAE,IAAA,CAAK,MAAM;AAC1D,QAAM,kBAAkB,4BAA4B;AAAA,IAClD;AAAA,IACA,KAAK;AAAA,IACL,SAAS;AAAA,IACT;AAAA,EAAA,CACD;AACD,QAAM,UAAqC;AAAA,IACzC;AAAA,IACA,GAAI,SAAS,EAAE,OAAO,KAAA;AAAA,IACtB,SAAS,OAAO,QAAgC;AAC9C,YAAM,UAAU,YAAY,GAAG;AAC/B,qDAAgB;AAChB,aAAO;AAAA,QACL,4BAA4B,MAAM,QAAQ,GAAG,CAAC;AAAA,QAC9C;AAAA,MAAA;AAAA,IAEJ;AAAA,IACA,GAAI,gBAAgB,EAAE,aAAA;AAAA;AAAA;AAAA,IAGtB,GAAI,gBAAgB,aAAa;AAAA,MAC/B,WACE,gBAAgB;AAAA,IAAA;AAAA,IAEpB,GAAI,gBAAgB,SAAS;AAAA,MAC3B,OACE,gBAAgB;AAAA,IAAA;AAAA,EACpB;AAEF,SAAO,mBAA2B,SAAS,EAAE,KAAK,QAAQ;AAC5D;"}
+{"version":3,"file":"deep-agent-transport-recipe.js","sources":["../../../../agent-runtime/src/deep-agent-transport-recipe.ts"],"sourcesContent":["import type { ResourceElement } from \"@assistant-ui/tap\";\nimport type { Statewire, StatewireClient } from \"statewire\";\nimport {\n  type DeepAgentMessageWindowDeclaration,\n  withDeclaredMessageWindow,\n} from \"./message-window\";\nimport { withDeclaredProtocolVersion } from \"./protocol\";\nimport {\n  attachRetryGate,\n  type AttachRetryGate,\n  createAttachInstrumentation,\n  type DeepAgentAttachTimingEvent,\n  type DeepAgentWakeRefusal,\n  parseRetryAfterHeaderMs,\n} from \"./statewire-attach-observer\";\nimport {\n  resolveStatewireTransportKind,\n  statewireTransport,\n  type StatewireTransportOptions,\n} from \"./statewire-transport\";\n\n/** Auth-header resolver for the transport; `staleAuth` is true right after an\n * auth rejection, so resolvers that can force-renew should honor it. */\nexport type DeepAgentHeadersResolver = (ctx: {\n  staleAuth: boolean;\n}) => Record<string, string> | Promise<Record<string, string>>;\n\n/** The statewire attach URL for a thread: the host's `…/v2/threads` mount plus the id. */\nexport function deepAgentThreadUrl({\n  baseUrl,\n  threadId,\n}: {\n  baseUrl: string;\n  threadId: string;\n}): string {\n  return `${baseUrl.replace(/\\/+$/, \"\")}/${encodeURIComponent(threadId)}`;\n}\n\nexport interface DeepAgentAttachTransportOptions {\n  /** Base URL of the deep-agent statewire host (the `…/v2/threads` mount). */\n  baseUrl: string;\n  threadId: string;\n  headers: DeepAgentHeadersResolver;\n  /** SSE when true, WebSocket otherwise (`resolveStatewireTransportKind`). */\n  sse?: boolean;\n  /** A never-started chat: the transport makes no network calls until the first command send. */\n  isNew?: boolean;\n  /** Host session store (mobile); browser hosts mount `storage.session` on the thread instead. */\n  sessionStore?: StatewireClient.SessionStorage | undefined;\n  /** Observes every headers resolve (the diagnostics recorder's stale-auth seam). */\n  onAuthResolve?: ((ctx: { staleAuth: boolean }) => void) | undefined;\n  /** Attach timing + retry hints (see `statewire-attach-observer`). */\n  onAttachTiming?: ((event: DeepAgentAttachTimingEvent) => void) | undefined;\n  /** Dial floors from server retry hints; the process-wide gate by default. */\n  retryGate?: AttachRetryGate;\n  /**\n   * The head window declared on the attach (`x-athena-deep-agent-window`,\n   * see `message-window.ts`): the hello of a client the host does not\n   * remember carries the newest `size` messages. Part of the recipe so a\n   * pooled dial asks for the same shape as the thread's own attach — a pooled\n   * hello then seeds the very state the attach will reconcile. Omitted, the\n   * shared default is declared.\n   */\n  messageWindow?: DeepAgentMessageWindowDeclaration | undefined;\n  /**\n   * The surface pages cut lanes (see `DeepAgentProtocolDeclaration`), so its\n   * attach declares the lane-cut contract version. Part of the recipe so a\n   * pooled dial declares what the thread's own attach would; omitted, the\n   * default version is declared.\n   */\n  laneHistory?: boolean | undefined;\n}\n\n/**\n * The ONE recipe for a deep-agent thread transport — shared by the mounted\n * thread (`useDeepAgentThread`) and the prewarm pool, so a pre-dialed\n * connection is byte-for-byte the connection the thread would have opened\n * itself: same URL, same auth + wire-contract headers, same session lane, same\n * instrumentation.\n *\n * Every attach declares the surface's wire-contract version alongside the\n * host's auth headers (first WS frame / SSE request headers) — the server\n * half of version negotiation reads it in `authorize`. The headers resolve\n * also waits out any server `Retry-After` floor for the thread: both statewire\n * attach paths resolve headers before they dial, so this is the seam where a\n * hint can hold the next dial without touching the library's backoff.\n */\nexport function createDeepAgentAttachTransport<TState = unknown>({\n  baseUrl,\n  threadId,\n  headers,\n  sse = false,\n  isNew = false,\n  sessionStore,\n  onAuthResolve,\n  onAttachTiming,\n  retryGate = attachRetryGate,\n  messageWindow,\n  laneHistory = false,\n}: DeepAgentAttachTransportOptions): ResourceElement<\n  Statewire<TState | undefined>\n> {\n  const url = deepAgentThreadUrl({ baseUrl, threadId });\n  // The instrumentation wraps the transport actually built: SSE needs the\n  // fetch wrapper that reads a refused attach's `Retry-After`.\n  const useSse = resolveStatewireTransportKind({ sse }) === \"sse\";\n  const instrumentation = createAttachInstrumentation({\n    url,\n    sse: useSse,\n    onEvent: onAttachTiming,\n    retryGate,\n  });\n  const options: StatewireTransportOptions = {\n    url,\n    ...(isNew && { isNew: true }),\n    headers: async (ctx: { staleAuth: boolean }) => {\n      await retryGate.waitForDial(url);\n      onAuthResolve?.(ctx);\n      return withDeclaredMessageWindow(\n        withDeclaredProtocolVersion(await headers(ctx), { laneHistory }),\n        messageWindow,\n      );\n    },\n    ...(sessionStore && { sessionStore }),\n    // Structural types: this package compiles without the DOM lib, while\n    // statewire's option types name the browser `WebSocket`/`fetch`.\n    ...(instrumentation.webSocket && {\n      webSocket:\n        instrumentation.webSocket as unknown as StatewireTransportOptions[\"webSocket\"],\n    }),\n    ...(instrumentation.fetch && {\n      fetch:\n        instrumentation.fetch as unknown as StatewireTransportOptions[\"fetch\"],\n    }),\n  };\n  return statewireTransport<TState>(options, { sse: useSse });\n}\n\n/** What `POST …/prewarm` answered. */\nexport interface DeepAgentWakeResult {\n  status: number;\n  /** The host activated the thread and its history is resident. */\n  warm: boolean;\n  /**\n   * `'warm'` when the history was already memoized, `'fresh_load'` when this\n   * call loaded it; `null` when the host did not say (a refusal, or a host\n   * without the route).\n   */\n  history: \"fresh_load\" | \"warm\" | null;\n  /**\n   * The dial floor recorded for the thread off a 503/429 `Retry-After` — the\n   * header's value, except a 503 `\"worker\"` refusal, capped at\n   * {@link WAKE_WORKER_REFUSAL_FLOOR_MS}.\n   */\n  retryAfterMs: number | null;\n  /** Who refused a 503/429 (see {@link DeepAgentWakeRefusal}); `null` for any other answer. */\n  refusal: DeepAgentWakeRefusal;\n  durationMs: number;\n}\n\n/**\n * Dial floor for a 503 the pinned worker produced about one instance's\n * lifecycle. Pinned answers every retriable 503 with a blanket\n * `Retry-After: 1`, but what those name — an instance record mid-teardown\n * (\"instance closing; retry\": fence release + placement release, ≈100 ms), a\n * full activation queue — clears far sooner than that, and the thread's own\n * attach is the request that carries the next activation. Holding it a full\n * second traded a ≈100 ms gap for a ≈1 s stall on every refused wake. A 429\n * is rate limiting and keeps its hint whatever the body says.\n */\nexport const WAKE_WORKER_REFUSAL_FLOOR_MS = 250;\n\n/**\n * The pinboard's own placement-refusal vocabulary — the `error` strings of\n * `@assistant-ui/pinboard` (`src/refusals.ts` plus the two inline refusals in\n * `src/server.ts`). Mirrors `PINBOARD_PLACEMENT_REFUSAL_ERRORS` in\n * `iris/scaler/src/v2AccessLog.ts`, whose test pins it to the installed\n * library; keep the two lists identical. A body with any other `error`\n * string is `\"unknown\"`, never `\"placement\"`.\n */\nexport const PINBOARD_PLACEMENT_REFUSAL_ERRORS: ReadonlySet<string> = new Set([\n  \"no live backends for namespace\",\n  \"registry cold start, retry\",\n  \"not the serving fleet\",\n  \"no live workers for hostname\",\n  \"hostname binding displaced, retry\",\n  \"hostname bindings inconsistent, retry\",\n  \"takeover in progress, retry\",\n  \"placement held by another hostname\",\n  \"worker inflight cap exceeded, retry\",\n  \"worker refused activation, retry\",\n]);\n\n/**\n * Pinned's instance-lifecycle refusals (`pinned/hosting/directory.py`,\n * `pinned/hosting/_records.py`): each names one instance on the worker the\n * thread is already placed on and clears in the time a teardown or an\n * activation slot takes. Anything else the worker answers 503 with — \"Thread\n * history load failed\", \"The regional conversation store is temporarily\n * unavailable\", a lease that expired — is not about one instance and keeps\n * the full hint.\n */\nexport const PINNED_TRANSIENT_WORKER_REFUSALS: ReadonlySet<string> = new Set([\n  \"instance closing; retry\",\n  \"instance aborted\",\n  \"activation queue full; retry\",\n  \"host draining; retry\",\n  \"instance capacity reached; retry\",\n  \"instance past its wind-down deadline; retry\",\n]);\n\n/**\n * Classify a 503/429 body (see {@link DeepAgentWakeRefusal}): a known pinboard\n * `error` is `\"placement\"`, a known pinned `detail` is `\"worker\"`, everything\n * else — including unfamiliar strings in either field — is `\"unknown\"`.\n */\nexport function classifyWakeRefusal(\n  body: unknown,\n): Exclude<DeepAgentWakeRefusal, null> {\n  if (typeof body === \"object\" && body !== null) {\n    const record = body as Record<string, unknown>;\n    if (\n      typeof record.error === \"string\" &&\n      PINBOARD_PLACEMENT_REFUSAL_ERRORS.has(record.error)\n    ) {\n      return \"placement\";\n    }\n    if (\n      typeof record.detail === \"string\" &&\n      PINNED_TRANSIENT_WORKER_REFUSALS.has(record.detail)\n    ) {\n      return \"worker\";\n    }\n  }\n  return \"unknown\";\n}\n\n/** Structural `fetch` for the wake call — this package compiles without the DOM lib. */\nexport type DeepAgentWakeFetch = (\n  input: string,\n  init?: {\n    method?: string;\n    headers?: Record<string, string>;\n    keepalive?: boolean;\n  },\n) => Promise<{\n  ok: boolean;\n  status: number;\n  headers: { get(name: string): string | null };\n  json(): Promise<unknown>;\n}>;\n\nexport interface DeepAgentWakeOptions {\n  /** Base URL of the deep-agent statewire host (the `…/v2/threads` mount). */\n  baseUrl: string;\n  threadId: string;\n  headers: DeepAgentHeadersResolver;\n  fetch?: DeepAgentWakeFetch | undefined;\n  /** Dial floors from server retry hints; the process-wide gate by default. */\n  retryGate?: AttachRetryGate;\n  onAttachTiming?: ((event: DeepAgentAttachTimingEvent) => void) | undefined;\n  now?: () => number;\n  /** The surface pages cut lanes: declare what its attach declares (see `DeepAgentAttachTransportOptions`). */\n  laneHistory?: boolean | undefined;\n}\n\n/**\n * Wake a thread's server instance ahead of its attach. `POST …/prewarm` runs\n * the host's `authorize` and history load — the fence adopt, graph compile and\n * checkpoint read that make a cold attach's hello take ≈1 s — and answers with\n * no thread content, only whether the history was already resident. Fire it\n * on hover intent, before a pooled attach or the click's own dial, so the\n * activation overlaps the handshake and the attach that follows finds the\n * instance warm.\n *\n * Fire-and-forget by contract: every failure resolves `null`, and a host\n * without the route (404) is reported like any other non-OK answer. A 503/429\n * `Retry-After` is recorded as a dial floor for the thread, so the attach that\n * follows waits it out instead of bouncing — in full, except a 503 that names\n * one of pinned's instance-lifecycle refusals (one instance mid-teardown on\n * the worker the thread already has; see {@link DeepAgentWakeRefusal}), whose\n * floor is capped at {@link WAKE_WORKER_REFUSAL_FLOOR_MS}.\n */\nexport async function wakeDeepAgentThread({\n  baseUrl,\n  threadId,\n  headers,\n  fetch: fetchOverride,\n  retryGate = attachRetryGate,\n  onAttachTiming,\n  now = () => Date.now(),\n  laneHistory = false,\n}: DeepAgentWakeOptions): Promise<DeepAgentWakeResult | null> {\n  const fetchImpl =\n    fetchOverride ?? (globalThis as { fetch?: DeepAgentWakeFetch }).fetch;\n  if (typeof fetchImpl !== \"function\") return null;\n  const threadUrl = deepAgentThreadUrl({ baseUrl, threadId });\n  const emit = (event: DeepAgentAttachTimingEvent): void => {\n    try {\n      onAttachTiming?.(event);\n    } catch {\n      // Observers are best-effort.\n    }\n  };\n  const startedAt = now();\n  try {\n    const resolved = withDeclaredProtocolVersion(\n      await headers({ staleAuth: false }),\n      { laneHistory },\n    );\n    const response = await fetchImpl(`${threadUrl}/prewarm`, {\n      method: \"POST\",\n      headers: resolved,\n      keepalive: true,\n    });\n    const durationMs = now() - startedAt;\n    let retryAfterMs: number | null = null;\n    let refusal: DeepAgentWakeRefusal = null;\n    if (response.status === 503 || response.status === 429) {\n      let body: unknown = null;\n      try {\n        body = await response.json();\n      } catch {\n        // A refusal without a readable body is classified by nothing.\n      }\n      refusal = classifyWakeRefusal(body);\n      const hinted = parseRetryAfterHeaderMs(\n        response.headers.get(\"retry-after\"),\n        now,\n      );\n      if (hinted !== null) {\n        retryAfterMs =\n          response.status === 503 && refusal === \"worker\"\n            ? Math.min(hinted, WAKE_WORKER_REFUSAL_FLOOR_MS)\n            : hinted;\n        if (retryAfterMs > 0) {\n          retryGate.noteRetryAfter(threadUrl, retryAfterMs);\n          emit({\n            type: \"retry-after\",\n            url: threadUrl,\n            delayMs: retryAfterMs,\n            source: \"http-header\",\n          });\n        }\n      }\n    }\n    let warm = false;\n    let history: DeepAgentWakeResult[\"history\"] = null;\n    if (response.ok) {\n      try {\n        const body = (await response.json()) as {\n          warm?: unknown;\n          history?: unknown;\n        } | null;\n        warm = body?.warm === true;\n        history =\n          body?.history === \"warm\" || body?.history === \"fresh_load\"\n            ? body.history\n            : null;\n      } catch {\n        // A 200 without a JSON body still means the instance is up.\n        warm = true;\n      }\n    }\n    emit({\n      type: \"wake\",\n      url: threadUrl,\n      status: response.status,\n      durationMs,\n      history,\n      refusal,\n    });\n    return {\n      status: response.status,\n      warm,\n      history,\n      retryAfterMs,\n      refusal,\n      durationMs,\n    };\n  } catch {\n    return null;\n  }\n}\n"],"names":[],"mappings":";;;;AA4BO,SAAS,mBAAmB;AAAA,EACjC;AAAA,EACA;AACF,GAGW;AACT,SAAO,GAAG,QAAQ,QAAQ,QAAQ,EAAE,CAAC,IAAI,mBAAmB,QAAQ,CAAC;AACvE;AAmDO,SAAS,+BAAiD;AAAA,EAC/D;AAAA,EACA;AAAA,EACA;AAAA,EACA,MAAM;AAAA,EACN,QAAQ;AAAA,EACR;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY;AAAA,EACZ;AAAA,EACA,cAAc;AAChB,GAEE;AACA,QAAM,MAAM,mBAAmB,EAAE,SAAS,UAAU;AAGpD,QAAM,SAAS,8BAA8B,EAAE,IAAA,CAAK,MAAM;AAC1D,QAAM,kBAAkB,4BAA4B;AAAA,IAClD;AAAA,IACA,KAAK;AAAA,IACL,SAAS;AAAA,IACT;AAAA,EAAA,CACD;AACD,QAAM,UAAqC;AAAA,IACzC;AAAA,IACA,GAAI,SAAS,EAAE,OAAO,KAAA;AAAA,IACtB,SAAS,OAAO,QAAgC;AAC9C,YAAM,UAAU,YAAY,GAAG;AAC/B,qDAAgB;AAChB,aAAO;AAAA,QACL,4BAA4B,MAAM,QAAQ,GAAG,GAAG,EAAE,aAAa;AAAA,QAC/D;AAAA,MAAA;AAAA,IAEJ;AAAA,IACA,GAAI,gBAAgB,EAAE,aAAA;AAAA;AAAA;AAAA,IAGtB,GAAI,gBAAgB,aAAa;AAAA,MAC/B,WACE,gBAAgB;AAAA,IAAA;AAAA,IAEpB,GAAI,gBAAgB,SAAS;AAAA,MAC3B,OACE,gBAAgB;AAAA,IAAA;AAAA,EACpB;AAEF,SAAO,mBAA2B,SAAS,EAAE,KAAK,QAAQ;AAC5D;"}

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

@@ -0,0 +1,139 @@
+/** Authenticated desktop handoffs carry references, never document/chat contents or credentials. */
+import { z } from "zod";
+export declare const DESKTOP_HANDOFF_PROTOCOL_VERSION: 1;
+export declare const DESKTOP_HANDOFF_MAX_ASSETS = 50;
+export declare const desktopHandoffAssetSchema: z.ZodObject<{
+    asset_id: z.ZodString;
+    reference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type DesktopHandoffAsset = z.infer<typeof desktopHandoffAssetSchema>;
+export declare const desktopHandoffResultSchema: z.ZodObject<{
+    desktop_version: z.ZodString;
+    protocol_version: z.ZodLiteral<1>;
+    thread_opened: z.ZodBoolean;
+    assets: z.ZodArray<z.ZodObject<{
+        asset_id: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            opened: "opened";
+            web_fallback: "web_fallback";
+        }>;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DesktopHandoffResult = z.infer<typeof desktopHandoffResultSchema>;
+export declare const desktopHandoffViewSchema: z.ZodObject<{
+    handoff_id: z.ZodString;
+    thread_id: z.ZodNullable<z.ZodString>;
+    session_asset_id: z.ZodNullable<z.ZodString>;
+    source: z.ZodLiteral<"spaces">;
+    destination: z.ZodLiteral<"desktop">;
+    environment: z.ZodEnum<{
+        localhost: "localhost";
+        production: "production";
+        staging: "staging";
+    }>;
+    state: z.ZodEnum<{
+        acknowledged: "acknowledged";
+        claimed: "claimed";
+        failed: "failed";
+        issued: "issued";
+        launched: "launched";
+    }>;
+    issued_at: z.ZodISODateTime;
+    expires_at: z.ZodISODateTime;
+    claimed_at: z.ZodNullable<z.ZodISODateTime>;
+    acknowledged_at: z.ZodNullable<z.ZodISODateTime>;
+    failure_reason: z.ZodNullable<z.ZodString>;
+    assets: z.ZodArray<z.ZodObject<{
+        asset_id: z.ZodString;
+        reference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    active_asset_id: z.ZodNullable<z.ZodString>;
+    result: z.ZodNullable<z.ZodObject<{
+        desktop_version: z.ZodString;
+        protocol_version: z.ZodLiteral<1>;
+        thread_opened: z.ZodBoolean;
+        assets: z.ZodArray<z.ZodObject<{
+            asset_id: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                opened: "opened";
+                web_fallback: "web_fallback";
+            }>;
+            reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DesktopHandoffView = z.infer<typeof desktopHandoffViewSchema>;
+export declare const desktopHandoffLaunchSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"desktop">;
+    scheme_url: z.ZodString;
+    download_url: z.ZodURL;
+    deployment_url: z.ZodURL;
+    protocol_version: z.ZodLiteral<1>;
+}, z.core.$strip>;
+export type DesktopHandoffLaunch = z.infer<typeof desktopHandoffLaunchSchema>;
+export declare const createDesktopHandoffResponseSchema: z.ZodObject<{
+    handoff: z.ZodObject<{
+        handoff_id: z.ZodString;
+        thread_id: z.ZodNullable<z.ZodString>;
+        session_asset_id: z.ZodNullable<z.ZodString>;
+        source: z.ZodLiteral<"spaces">;
+        destination: z.ZodLiteral<"desktop">;
+        environment: z.ZodEnum<{
+            localhost: "localhost";
+            production: "production";
+            staging: "staging";
+        }>;
+        state: z.ZodEnum<{
+            acknowledged: "acknowledged";
+            claimed: "claimed";
+            failed: "failed";
+            issued: "issued";
+            launched: "launched";
+        }>;
+        issued_at: z.ZodISODateTime;
+        expires_at: z.ZodISODateTime;
+        claimed_at: z.ZodNullable<z.ZodISODateTime>;
+        acknowledged_at: z.ZodNullable<z.ZodISODateTime>;
+        failure_reason: z.ZodNullable<z.ZodString>;
+        assets: z.ZodArray<z.ZodObject<{
+            asset_id: z.ZodString;
+            reference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        active_asset_id: z.ZodNullable<z.ZodString>;
+        result: z.ZodNullable<z.ZodObject<{
+            desktop_version: z.ZodString;
+            protocol_version: z.ZodLiteral<1>;
+            thread_opened: z.ZodBoolean;
+            assets: z.ZodArray<z.ZodObject<{
+                asset_id: z.ZodString;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    opened: "opened";
+                    web_fallback: "web_fallback";
+                }>;
+                reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    launch: z.ZodObject<{
+        kind: z.ZodLiteral<"desktop">;
+        scheme_url: z.ZodString;
+        download_url: z.ZodURL;
+        deployment_url: z.ZodURL;
+        protocol_version: z.ZodLiteral<1>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CreateDesktopHandoffResponse = z.infer<typeof createDesktopHandoffResponseSchema>;
+export interface CreateDesktopHandoffInput {
+    thread_id?: string | null;
+    assets: DesktopHandoffAsset[];
+    active_asset_id?: string | null;
+    source: "spaces";
+}
+/** Only a destination acknowledgement proves a launch. Timeouts prove no installation state. */
+export declare function desktopHandoffSummary({ handoff, }: {
+    handoff: DesktopHandoffView;
+}): string;

package/dist/agent-runtime/src/durable-thread-snapshot-cache.d.ts

@@ -0,0 +1,60 @@
+import { type DeepAgentThreadSnapshotCache } from "./thread-snapshot-cache";
+import { type ThreadSnapshotMirror } from "./thread-snapshot-mirror";
+/**
+ * The thread snapshot cache with a durable, encrypted mirror behind it (`thread-snapshot-mirror.ts`):
+ * a reload seeds a recently visited thread from what it last showed, and a thread can be read while
+ * the transport cannot connect at all.
+ *
+ * - **Online, nothing changes.** `take` serves the in-memory entry within its age bound (one hour by
+ *   default), exactly as the plain cache does, and the attach snapshot replaces the seed.
+ * - **Offline** (`isOffline()`: the host's own word that Athena can't be reached), `take` serves the
+ *   thread's last resting transcript this page holds (what it read, or what the mirror kept), up to
+ *   `offlineMaxAgeMs` old and past the online bound, so a person can read their recent
+ *   conversations on a plane. Never a mid-stream state: a run the connection dropped is a partial
+ *   transcript, and the resting one before it is what shows. Every offline seed, however recent, is
+ *   recorded with its capture time (`offlineSeedAt`) so the host can say the transcript is "as of"
+ *   then; only the next state the wire delivers for the thread (its attach) clears it.
+ * - **Owned.** Entries belong to one owner (`setOwner`): a change drops every entry, deletes the
+ *   previous owner's mirrored records and reads the new owner's. A snapshot captured under one
+ *   account never seeds a mount under another. `wipe` drops everything (a sign-out).
+ */
+export interface DurableThreadSnapshotCache extends DeepAgentThreadSnapshotCache {
+    peek(threadId: string): boolean;
+    /** Bind the cache to the acting owner (`null`: nobody signed in; nothing is mirrored). */
+    setOwner(ownerId: string | null): Promise<void>;
+    /**
+     * Start reading an owner's mirrored snapshots before the owner is known for sure (a host's
+     * last-owner hint at boot): `setOwner` adopts the read if that owner is the one bound, and it
+     * is discarded otherwise. Binds nothing and deletes nothing.
+     */
+    prime(ownerId: string): void;
+    /** The owner the cache is bound to. */
+    owner(): string | null;
+    /**
+     * When the seed `take` last served for `threadId` was captured, if it was served while Athena
+     * could not be reached; `null` otherwise, and again once the wire delivers the thread.
+     */
+    offlineSeedAt(threadId: string): number | null;
+    /** Calls `listener` whenever an offline seed is served or cleared; returns what stops it. */
+    subscribeOfflineSeeds(listener: () => void): () => void;
+    /** Whether the entry `take` would serve for `threadId` came back from the mirror. */
+    isRestored(threadId: string): boolean;
+    /** Resolves once the current owner's mirrored snapshots have been read (tests, telemetry). */
+    whenHydrated(): Promise<void>;
+    /** Drop every entry, in memory and in the mirror (a sign-out, a workspace switch). */
+    wipe(): Promise<void>;
+}
+export interface DurableThreadSnapshotCacheOptions {
+    mirror: ThreadSnapshotMirror;
+    /** Whether Athena can't be reached right now (the host's reachability, or the browser's). */
+    isOffline?: () => boolean;
+    maxThreads?: number;
+    /** The online age bound (the plain cache's). */
+    maxAgeMs?: number;
+    /** How old a mirrored snapshot may be and still be read offline. */
+    offlineMaxAgeMs?: number;
+    now?: () => number;
+}
+/** What a device keeps for reading offline: the offline plan's 30 days. */
+export declare const OFFLINE_SNAPSHOT_MAX_AGE_MS: number;
+export declare function createDurableThreadSnapshotCache({ mirror, isOffline, maxThreads, maxAgeMs, offlineMaxAgeMs, now, }: DurableThreadSnapshotCacheOptions): DurableThreadSnapshotCache;

package/dist/agent-runtime/src/edit-command.d.ts

@@ -0,0 +1,156 @@
+import type { StatewireThread } from '@assistant-ui/react-statewire';
+import { type DeepAgentMessageWindow } from './message-window';
+/**
+ * Wire-accurate `run/edit` construction for deep-agent retry/edit, shared by
+ * every surface that resubmits a user message.
+ *
+ * assistant-ui builds the command's `runAnchorMessageId` from the CONVERTED
+ * thread messages (`resolveEditCommand`: `messages[index - 1].id`), but the
+ * deep-agent host validates that anchor against the edited message's parent in
+ * its RAW message list (`harness_sdk.linear_thread`: the entry before it in
+ * `state["messages"]`). Those two lists do not line up:
+ *
+ * - the converter chunks an assistant turn and its tool messages into ONE
+ *   thread message carrying only the FIRST wire id, so the anchor names the
+ *   head of the previous turn instead of its last tool message;
+ * - `sanitizeLangChainMessages` drops hidden-from-frontend and unconvertible
+ *   entries, so a dropped tail message is invisible to the anchor too.
+ *
+ * Either way the host rejects the command with `wrong-anchor`
+ * (`runAnchorMessageId … is not the source's parent`) AFTER the composer's
+ * synchronous `send()` returned, so the retry/edit silently does nothing.
+ *
+ * Building the command here off the replicated raw state makes the anchor the
+ * same value the host computes.
+ *
+ * The raw list is the loaded interest window, so the first loaded message's
+ * parent is not in it while older messages exist — an edit there must not
+ * anchor on `null` (the root, rejected `wrong-anchor`); a message below the
+ * window has no parent on this client at all. {@link resolveDeepAgentEditCommand}
+ * states older page interests until the parent is loaded.
+ */
+/**
+ * Host metadata frozen at submission, settling once the async capture does.
+ * The message-metadata preparation surface — `prepareMessageMetadata`,
+ * `discardPreparedMessageMetadata`, `sendPreparedEdit` and `sendCommand`'s
+ * `preparedMetadata` option — is what the monorepo patches into
+ * `@assistant-ui/react-statewire@0.31.0` (`patches/`). It is declared
+ * structurally here rather than as `StatewireThread.Extras[...]` so that the
+ * published sources also compile against the unpatched upstream typings, where
+ * those members are absent and the edit path's optional calls never run.
+ */
+export type DeepAgentPreparedMessageMetadata = Promise<Record<string, unknown> | undefined>;
+/** The pieces of the statewire thread extras the edit path reads. */
+export interface DeepAgentStatewireExtras {
+    /** The library's dispatch; it resolves with the host's reply to the command. */
+    sendCommand: (command: StatewireThread.Command, options?: {
+        preparedMetadata?: DeepAgentPreparedMessageMetadata | undefined;
+    }) => Promise<unknown> | void;
+    /** Optional on older hosts; capture before loading an edit's history anchor. */
+    prepareMessageMetadata?: (() => DeepAgentPreparedMessageMetadata) | undefined;
+    discardPreparedMessageMetadata?: ((prepared: DeepAgentPreparedMessageMetadata) => void) | undefined;
+    sendPreparedEdit?: ((sourceId: string, prepared: DeepAgentPreparedMessageMetadata) => void) | undefined;
+    isPreparingSubmission?: boolean;
+    /** The composed thread state — its `messages` are the raw wire messages of the loaded window. */
+    state: {
+        messages?: readonly {
+            id?: unknown;
+        }[];
+    } | null;
+    /** The mounted documents (the interest window), absent on a wire without documents. */
+    documents?: StatewireThread.Extras['documents'];
+    invoke?: StatewireThread.Extras['invoke'];
+    /** The live run, when one is in flight; `epoch` advances on each dispatch. */
+    runs: {
+        runId?: string | null;
+        epoch?: number;
+    };
+    /** The host's replicated run status; absent on a surface that predates it. */
+    status?: StatewireThread.ThreadStatus;
+}
+/**
+ * The statewire extras of the nearest aui thread, or `null` when the thread is
+ * not a statewire thread (e.g. a read-only subagent transcript runtime).
+ * Gated on {@link hasStatewireThreadExtras} for the same reason the approval
+ * card is: the library's own hooks throw on a non-statewire thread.
+ */
+export declare function readDeepAgentStatewireExtras(extras: unknown): DeepAgentStatewireExtras | null;
+/**
+ * The host's parent of `sourceId`: the raw wire message directly before it
+ * (`null` when it is the first of the whole transcript). Returns `undefined`
+ * when `sourceId` is not in the raw list at all — an optimistic bubble the
+ * host has not settled yet, a message below the loaded window, or a surface
+ * whose state this module cannot read — or when it is the first loaded
+ * message while older ones exist (`hasOlder`), so the caller can load more or
+ * fall back to the library's own path instead of asserting a wrong anchor.
+ */
+export declare function resolveWireAnchorMessageId({ wireMessages, sourceId, hasOlder, }: {
+    wireMessages: readonly {
+        id?: unknown;
+    }[] | undefined;
+    sourceId: string;
+    hasOlder?: boolean;
+}): string | null | undefined;
+/**
+ * Whether `sourceId`'s parent lies below the loaded window: the message is
+ * absent from the raw list, or its first entry, while older messages exist.
+ * The caller loads older history before an edit can be anchored.
+ */
+export declare function isSourceBelowLoadedWindow({ wireMessages, sourceId, window, }: {
+    wireMessages: readonly {
+        id?: unknown;
+    }[] | undefined;
+    sourceId: string;
+    window: DeepAgentMessageWindow | null;
+}): boolean;
+/**
+ * The `run/edit` command for resubmitting `sourceId` with `text`, anchored on
+ * the host's own parent. `null` when the anchor cannot be resolved from the
+ * replicated state.
+ */
+export declare function buildDeepAgentEditCommand({ extras, sourceId, text, }: {
+    extras: DeepAgentStatewireExtras;
+    sourceId: string;
+    text: string;
+}): StatewireThread.RunEditCommand | null;
+/**
+ * State one more page of older history for a windowed thread: the next page
+ * past the loaded window's oldest message. Resolves `true` once the host has
+ * mounted it (it answers the statement after mounting), `false` when there is
+ * nothing older, the thread is not a windowed statewire thread, or no page can
+ * be stated. For a reader that needs a message below the loaded window — a
+ * search result revealing an older turn of a long conversation — and pages
+ * until it renders.
+ */
+export declare function loadOlderDeepAgentHistoryPage({ readExtras, pageSize, }: {
+    readExtras: () => DeepAgentStatewireExtras | null;
+    pageSize?: number;
+}): Promise<boolean>;
+/**
+ * Pages of older history stated while looking for an edited message's host
+ * parent. Each page is up to a window's worth of messages, so an edit reaches
+ * this many windows below what was loaded before it gives up.
+ */
+export declare const MAX_EDIT_ANCHOR_HISTORY_LOADS = 5;
+/**
+ * The anchored `run/edit` for `sourceId`, stating older page interests one at
+ * a time when the message's parent lies below the loaded window. Every page
+ * is read back from the live documents (`readExtras` — the host mounts them
+ * before it answers the statement), so the anchor is always the host's own
+ * parent id.
+ *
+ * Resolves `null` — the caller's cue for the library's composer path, whose
+ * failure it reports — when the thread is not a statewire thread, the host has
+ * not settled the message, the history is exhausted without it, or the page
+ * budget ({@link MAX_EDIT_ANCHOR_HISTORY_LOADS}) is spent. A synchronous
+ * resolution never awaits: the first read either anchors at once or decides
+ * that pages are needed.
+ */
+export declare function resolveDeepAgentEditCommand({ readExtras, sourceId, text, pageSize, maxHistoryLoads, }: {
+    /** The live thread extras — re-read per page so each anchor attempt sees the widened window. */
+    readExtras: () => DeepAgentStatewireExtras | null;
+    sourceId: string;
+    text: string;
+    pageSize?: number;
+    maxHistoryLoads?: number;
+}): Promise<StatewireThread.RunEditCommand | null>;

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

@@ -0,0 +1,174 @@
+import type { StatewireClient } from 'statewire';
+import type { DeepAgentConnectionState } from './types';
+/** Structured payload attached to a server-rejected Statewire command. */
+export interface StatewireRejectionPayload {
+    status: number;
+    detail: unknown;
+}
+/** Return a rejected command's structured `{ status, detail }` payload. */
+export declare function statewireRejectionPayload(error: unknown): StatewireRejectionPayload | null;
+/**
+ * The server's human-readable reason for a rejected command — `detail.message`
+ * (or a plain-string `detail`) — else `null`. Hosts surface it as send
+ * feedback so the user sees the actionable cause instead of the generic
+ * client-side `command rejected (<status>)`.
+ */
+export declare function statewireRejectionDetailMessage(error: unknown): string | null;
+/**
+ * A structured, retryable refusal the host recorded as the run error
+ * (`runs.error`): the dispatch never started — the pod or instance was
+ * closing (`pod_draining`) — and the entries stayed in their lanes for the
+ * thread's next placement. Distinct from a rejected COMMAND
+ * ({@link statewireRejectionPayload}): this is the shape harness-sdk writes
+ * when the run executor raises the rejection, so it lives on the replicated
+ * run entry, not on a command settle.
+ */
+export interface RetryableRunRefusal {
+    /** The structured `detail.code` (`pod_draining`). */
+    code: string;
+    /** The server's human-readable reason, when it sent one. */
+    message: string | null;
+}
+export declare function readRetryableRunRefusal(error: unknown): RetryableRunRefusal | null;
+/**
+ * The `detail.code` agora answers when a send names another channel of the
+ * collab agent a session started on (`collab_agent_bridge.py`): a session
+ * keeps its channel — the SDK app's Agent / Ask mode — for its lifetime, and
+ * the way to the other mode is a new session. Wire-frozen.
+ */
+export declare const COLLAB_AGENT_CHANNEL_SESSION_MISMATCH = "collab_agent_channel_session_mismatch";
+/**
+ * A structured refusal the host recorded as the run error when the run could
+ * not START: the run executor raised the gate's `{status, detail: {code,
+ * message}}` envelope (agora's `_status_reject`) before it accepted the
+ * dispatched input, so the message went back to its lane and the thread rests
+ * `error` with it still queued. Unlike a retryable refusal
+ * ({@link readRetryableRunRefusal}) nothing will dispatch it later: resending
+ * the same input is refused the same way, so the server's message is the only
+ * explanation the person gets.
+ */
+export interface RunStartRefusal {
+    /** The structured `detail.code` (`collab_agent_channel_session_mismatch`, …). */
+    code: string;
+    /** The server's human-readable reason, when it sent one. */
+    message: string | null;
+    /** The HTTP-style status the gate raised with, when recorded. */
+    status: number | null;
+}
+/**
+ * The non-retryable structured refusal off a replicated run error
+ * (`runs.error`), or `null` — for a run that failed while it was running (a
+ * plain `{message}`), a retryable refusal, or no error at all.
+ */
+export declare function readRunStartRefusal(error: unknown): RunStartRefusal | null;
+/** The structured `detail.code` of a rejected command, or `null`. */
+export declare function statewireRejectionCode(error: unknown): string | null;
+/**
+ * A structured, retryable refusal of a COMMAND, read off its rejection
+ * ({@link statewireRejectionPayload}): the host's `_structured_reject(...,
+ * retryable=True)` envelope — `command_auth_context_expired` when a pod
+ * replacement dropped the socket-scoped auth a replayed command needed,
+ * `pod_draining` when the host was closing. The command never ran, and the
+ * host itself says a resend after the reconnect will; `detail.code` is the
+ * wire-frozen contract clients classify on. Same shape as
+ * {@link readRetryableRunRefusal}, which reads it off a replicated run entry.
+ */
+export interface RetryableCommandRejection {
+    /** The structured `detail.code`. */
+    code: string;
+    /** The server's human-readable reason, when it sent one. */
+    message: string | null;
+}
+export declare function readRetryableCommandRejection(error: unknown): RetryableCommandRejection | null;
+/** The host's `detail.code` for a command replayed onto a pod that could not restore its auth context. */
+export declare const STATEWIRE_COMMAND_AUTH_CONTEXT_EXPIRED = "command_auth_context_expired";
+/**
+ * Whether a rejected command hit the host's fail-closed auth recovery: the
+ * command was replayed onto a replacement pod that could not restore the
+ * attach's auth context, so it was refused unrun (503, retryable). The
+ * reconnect already under way restores the context; a single resend after it
+ * is the recovery, not a failure to report.
+ */
+export declare function isStatewireCommandAuthContextExpired(error: unknown): boolean;
+/**
+ * The `detail.code` agora answers for a write to an archived (trashed)
+ * conversation (`host_rejects._conversation_archived_reject`, a 409): it
+ * takes no new turns, config writes or approval answers until it is
+ * restored, and stopping still works. Wire-frozen.
+ */
+export declare const CONVERSATION_ARCHIVED = "conversation_archived";
+/** What a person is told when that refusal comes back (the server says the same). */
+export declare const CONVERSATION_ARCHIVED_MESSAGE = "This conversation is archived. Restore it to continue.";
+/**
+ * Whether a rejected command was refused because the conversation is archived
+ * ({@link CONVERSATION_ARCHIVED}). Not retriable: nothing changes until a
+ * restore, so callers show {@link CONVERSATION_ARCHIVED_MESSAGE} rather than a
+ * "try again".
+ */
+export declare function isConversationArchivedRejection(error: unknown): boolean;
+/**
+ * Whether a rejected command hit the legacy-thread dispatch fence: the
+ * structured 409 the server answers when an out-of-band run is writing a
+ * pre-cutover thread (or its adoption failed). A per-send failure — the
+ * snapshot never carries a standing read-only flag.
+ */
+export declare function isLegacyThreadReadOnlyRejection(error: unknown): boolean;
+/**
+ * Whether a rejected command was refused because its rewind anchor no longer
+ * matches the host's parent for the edited message (`wrong-anchor`).
+ *
+ * A retry/edit resubmit is dispatched optimistically, so this rejection lands
+ * after the UI already cleared its edit affordances: the turn simply never
+ * re-runs. Callers use this to tell the user the resubmit was dropped instead
+ * of leaving a console-only failure.
+ */
+export declare function isStatewireRewindAnchorRejection(error: unknown): boolean;
+/**
+ * Whether a statewire send failure is the host's `expired` verdict
+ * (`result-unavailable`): the command's seq was at or below the host's
+ * admitted watermark and no retained result was left for it. Either the
+ * command ran and settled but the client re-asked for the answer (a resend
+ * after the stream came back) only after the host had let the retained result
+ * go, or the seq was already admitted and the command was absorbed as a
+ * duplicate without ever running — a client whose shared session record fell
+ * behind the watermark stays there until a reconnect re-syncs it. The library
+ * never reruns the command on replay, so for an idempotent read the answer is
+ * simply gone — asking again is the correct reaction, not reporting a failure;
+ * a write cannot assume it was applied.
+ */
+export declare function isStatewireExpiredVerdict(error: unknown): boolean;
+/**
+ * Whether a statewire send failure is a local channel death rather than a
+ * command error.
+ *
+ * The library's contract for `SendFailure.cause`: `"server"` is the server's
+ * own answer; every other cause is "a channel death the client settled
+ * locally" — `unmount`, `stream-gone`, and `session-lost`. A thread switch
+ * settles every in-flight command that way, so logging these at error level
+ * reports two failures for an ordinary switch and buries the ones that mean
+ * something.
+ *
+ * Channel health is already surfaced where it belongs: the connection
+ * indicator renders the connection state. This
+ * predicate only decides the log level.
+ */
+export declare function isStatewireChannelTeardown(error: unknown): boolean;
+/**
+ * The low-cardinality reason a statewire send settled as transport weather
+ * rather than a defect, or `null` when the failure is a real error.
+ *
+ * Three families qualify: a channel death the client settled locally
+ * ({@link isStatewireChannelTeardown} — the cause: `unmount`, `stream-gone`,
+ * `session-lost`), the host's `expired` verdict
+ * ({@link isStatewireExpiredVerdict} — the answer outlived the host's
+ * retention before the post-reconnect resend collected it), and a retryable
+ * structured rejection ({@link readRetryableCommandRejection} — its code: the
+ * host asked for a resend). In every case the sender's own retry or poll is
+ * the recovery and the connection indicator already shows the channel, so
+ * error reporting counts the outcome instead of paging on it. Handler
+ * failures, crashes, and non-retryable rejections stay `null`: those are
+ * defects to page on.
+ */
+export declare function statewireTransportOutcome(error: unknown): string | null;
+/** Preserve the Statewire lifecycle and sanitize host detail for display. */
+export declare function projectDeepAgentConnection(connection: StatewireClient.ConnectionState): DeepAgentConnectionState;

package/dist/agent-runtime/src/execute-output.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Reading the deepagents `execute` (shell) tool: the command's headline and
+ * the status notes the backend appends to its output. Pure, so every surface
+ * that lists shell commands (a tool card, a session's Shell pane) agrees on
+ * what succeeded.
+ */
+export interface ShellCommandSummary {
+    /** The first non-blank line of the command, trimmed. */
+    firstLine: string;
+    /** How many lines follow it. */
+    extraLines: number;
+}
+/** A shell command's first non-blank line plus how many lines follow it. */
+export declare function summarizeShellCommand(command: string): ShellCommandSummary;
+export interface ParsedExecuteOutput {
+    /** The command's output with the trailing status notes removed. */
+    body: string;
+    /** The exit code from the status note, or `null` when the output carries none. */
+    exitCode: number | null;
+    /** Whether the backend cut the output (`[Output was truncated due to size limits]`). */
+    truncated: boolean;
+}
+/**
+ * Split an `execute` result into its output and the notes agora's execute
+ * router appends (`_format_execute_output` in `asset_execute.py`, mirroring
+ * the SDK tool): `[Command succeeded with exit code 0]`, `[Command failed with
+ * exit code 1]` and `[Output was truncated due to size limits]`. A result
+ * without an exit note (an `Error: …` refusal before the command ran, an
+ * output the live window cut) reports `exitCode: null`.
+ */
+export declare function parseExecuteOutput(raw: string): ParsedExecuteOutput;