@athenaintel/react 0.57.2 → 0.59.0

package/dist/agent-runtime/src/statewire-held-sends.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"statewire-held-sends.cjs","sources":["../../../../agent-runtime/src/statewire-held-sends.ts"],"sourcesContent":["import type { StatewireClient } from 'statewire';\nimport { chatOutboxWireAnchorId } from './chat-outbox-thread';\nimport { MESSAGE_RUN_METHODS, RUN_SEND_METHOD, upgradeLegacyRunCommand } from './run-send';\nimport { DEEP_AGENT_STATEWIRE_PROTOCOL } from './statewire-transport';\n\n/**\n * Failed run sends on statewire 0.24's outbox.\n *\n * statewire 0.24 has no failed list: a command the server judged (or the\n * client lost) becomes a durable `settled` update, delivered once through\n * `onCommandChange`. A run send the user should still see is put back into\n * the outbox HELD, with the failure in its `localMeta.error`\n * ({@link reholdFailedSettle}); react-statewire then folds it into\n * `runs.held`, and the user retries ({@link retryHeldRunSend}) or discards\n * ({@link discardHeldRunSend}) it. Send recovery re-queues the sends the\n * server never judged the same way, unheld.\n *\n * Every function here reads the outbox and the thread structurally, so the\n * runtime compiles against unpatched statewire typings.\n */\n\n/** The outbox verbs this module uses (`StatewireClient.Outbox`, structurally). */\nexport interface DeepAgentOutbox {\n  readonly entries: readonly StatewireClient.OutboxEntry[];\n  update: StatewireClient.Outbox['update'];\n  insert: StatewireClient.Outbox['insert'];\n  remove: StatewireClient.Outbox['remove'];\n}\n\n/** The outbox off a statewire thread's extras (`extras.outbox`), or `null` when it has none. */\nexport function readStatewireOutbox(extras: unknown): DeepAgentOutbox | null {\n  const outbox = (extras as { outbox?: Partial<DeepAgentOutbox> } | null)?.outbox;\n  if (\n    !outbox ||\n    !Array.isArray(outbox.entries) ||\n    typeof outbox.update !== 'function' ||\n    typeof outbox.insert !== 'function' ||\n    typeof outbox.remove !== 'function'\n  )\n    return null;\n  return outbox as DeepAgentOutbox;\n}\n\n/** A send failure as a held entry carries it in `localMeta.error`. */\nexport type DeepAgentSendFailure = StatewireClient.SendFailure;\n\n\ntype RunCommandParams = {\n  type?: unknown;\n  runId?: unknown;\n  message?: { id?: unknown } | null;\n  sourceId?: unknown;\n  runAnchorMessageId?: unknown;\n  [key: string]: unknown;\n};\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction isSendFailure(value: unknown): value is DeepAgentSendFailure {\n  return isRecord(value) && typeof value.fate === 'string' && typeof value.cause === 'string';\n}\n\n/** The failure a held entry's `localMeta` carries, if it was held for one. */\nexport function heldSendFailure(localMeta: unknown): DeepAgentSendFailure | undefined {\n  return isRecord(localMeta) && isSendFailure(localMeta.error) ? localMeta.error : undefined;\n}\n\n/** `localMeta` with the failure set (`error`), keeping what the send carried. */\nexport function withSendFailure(localMeta: unknown, error: DeepAgentSendFailure): Record<string, unknown> {\n  return { ...(isRecord(localMeta) ? localMeta : {}), error };\n}\n\n/** `localMeta` without its failure; `undefined` when nothing else is left. */\nexport function withoutSendFailure(localMeta: unknown): unknown {\n  if (!isRecord(localMeta) || !('error' in localMeta)) return localMeta;\n  const { error: _error, ...rest } = localMeta;\n  return Object.keys(rest).length > 0 ? rest : undefined;\n}\n\n/**\n * A run command as the current contract says it: a 2026-09-13 statement an\n * earlier build stored (`run/enqueue`, `run/steer`, …) becomes its `run/send`.\n */\nfunction currentRunCommand(command: { method: string; params: readonly unknown[] }): {\n  method: string;\n  params: readonly unknown[];\n} {\n  return upgradeLegacyRunCommand(command) ?? command;\n}\n\n/** The client-minted message id a run send carries, off its command params. */\nexport function runSendMessageId(command: {\n  method: string;\n  params?: readonly unknown[];\n}): string | null {\n  const current = currentRunCommand({ method: command.method, params: command.params ?? [] });\n  if (!MESSAGE_RUN_METHODS.has(current.method)) return null;\n  const id = (current.params[0] as RunCommandParams | undefined)?.message?.id;\n  return typeof id === 'string' ? id : null;\n}\n\n/**\n * The thread as a re-anchor reads it: the raw wire messages of the loaded\n * window and the live run (react-statewire's `extras.state.messages` and\n * `extras.runs.runId`, or the deep-agent state `onCommandChange` hands over).\n */\nexport interface DeepAgentRunSendThread {\n  wireMessages: readonly unknown[] | null | undefined;\n  runId: string | null;\n}\n\n/** The re-anchor view of a deep-agent state (`{ messages, runs }`), read structurally. */\nexport function runSendThreadOfState(state: unknown): DeepAgentRunSendThread {\n  const value = isRecord(state) ? state : {};\n  const runs = Array.isArray(value.runs) ? value.runs : [];\n  const runId = (runs[0] as { runId?: unknown } | undefined)?.runId;\n  return {\n    wireMessages: Array.isArray(value.messages) ? value.messages : null,\n    runId: typeof runId === 'string' ? runId : null,\n  };\n}\n\n/** The re-anchor view off a statewire thread's extras, read structurally. */\nexport function runSendThreadOfExtras(extras: unknown): DeepAgentRunSendThread {\n  const value = isRecord(extras) ? extras : {};\n  const state = isRecord(value.state) ? value.state : {};\n  const runId = isRecord(value.runs) ? value.runs.runId : undefined;\n  return {\n    wireMessages: Array.isArray(state.messages) ? state.messages : null,\n    runId: typeof runId === 'string' ? runId : null,\n  };\n}\n\nfunction mintRunId(): string {\n  const host = globalThis as { crypto?: { randomUUID?: () => string } };\n  return host.crypto?.randomUUID?.() ?? `run-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;\n}\n\n/**\n * A run send's command re-anchored against the thread as it is now, the way\n * react-statewire anchors a fresh send: a send into the live run keeps its\n * statement; any other send becomes a `run/send` into the live run (queued\n * behind it, where an earlier run/enqueue put it) or one that starts a run at\n * the host's tail (`auto`). An edit keeps its source\n * and re-asserts the source's parent. `null` when the command is not a\n * message-carrying run send, or an edit's source is not in the loaded window.\n */\nexport function reanchorRunSend(\n  command: { method: string; params: readonly unknown[] },\n  thread: DeepAgentRunSendThread,\n): { method: string; params: unknown[] } | null {\n  if (!MESSAGE_RUN_METHODS.has(command.method)) return null;\n  const params = command.params[0] as RunCommandParams | undefined;\n  if (!isRecord(params) || !isRecord(params.message)) return null;\n  const rest = command.params.slice(1);\n  if (command.method === 'run/edit') {\n    if (typeof params.sourceId !== 'string') return null;\n    // The host checks the anchor against the source's parent in its raw list\n    // (`edit-command.ts`). A source first in the loaded window may have its\n    // parent below it, so only a parent seen here re-anchors the edit.\n    const wire = (thread.wireMessages ?? []) as readonly ({ id?: unknown } | null)[];\n    const index = wire.findIndex((message) => message?.id === params.sourceId);\n    const runAnchorMessageId = index > 0 ? wire[index - 1]?.id : undefined;\n    if (typeof runAnchorMessageId !== 'string') return null;\n    return {\n      method: 'run/edit',\n      params: [{ ...params, runId: thread.runId ?? mintRunId(), runAnchorMessageId }, ...rest],\n    };\n  }\n  if (thread.runId !== null && params.runId === thread.runId) {\n    return { method: command.method, params: [params, ...rest] };\n  }\n  const { runAnchorMessageId: _anchor, ...unanchored } = params;\n  const fields =\n    thread.runId !== null\n      ? { runId: thread.runId }\n      : {\n          runId: mintRunId(),\n          runAnchorMessageId:\n            thread.wireMessages && thread.wireMessages.length > 0\n              ? chatOutboxWireAnchorId(thread.wireMessages)\n              : null,\n        };\n  return {\n    method: RUN_SEND_METHOD,\n    params: [\n      {\n        ...unanchored,\n        type: RUN_SEND_METHOD,\n        behavior: thread.runId !== null ? 'queue' : 'auto',\n        ...fields,\n      },\n      ...rest,\n    ],\n  };\n}\n\n/** The settled update a re-queue consumes (`Statewire.CommandUpdate`, structurally). */\nexport interface DeepAgentSettledUpdate {\n  readonly protocol?: string;\n  id?: string;\n  method: string;\n  params: readonly unknown[];\n  status: string;\n  failure?: DeepAgentSendFailure;\n  localMeta?: unknown;\n}\n\n/**\n * Puts a failed message-carrying run send back into the outbox, consuming the\n * `settled` update in the same write (`insert({ from })`), so a redelivery\n * never inserts twice. `held: true` re-holds it for the user with the failure\n * in `localMeta.error`; `held: false` re-queues it (send recovery) without\n * one. The command is re-anchored against `thread` when given.\n *\n * Returns the new entry's id, or `null` when the update is not a failed\n * message-carrying run send (nothing is inserted; the caller acks it).\n */\nexport function requeueFailedRunSend({\n  outbox,\n  update,\n  held,\n  thread,\n}: {\n  outbox: Pick<DeepAgentOutbox, 'insert'>;\n  update: DeepAgentSettledUpdate;\n  held: boolean;\n  thread?: DeepAgentRunSendThread | undefined;\n}): string | null {\n  if (update.status !== 'settled' || update.failure === undefined) return null;\n  if (runSendMessageId(update) === null) return null;\n  const sent = currentRunCommand({ method: update.method, params: update.params });\n  const command = (thread && reanchorRunSend(sent, thread)) ?? {\n    method: sent.method,\n    params: [...sent.params],\n  };\n  const localMeta = held\n    ? withSendFailure(update.localMeta, update.failure)\n    : withoutSendFailure(update.localMeta);\n  return outbox.insert({\n    ...(update.id !== undefined && { from: update.id }),\n    protocol: update.protocol ?? DEEP_AGENT_STATEWIRE_PROTOCOL,\n    command,\n    held,\n    ...(localMeta !== undefined && { localMeta }),\n  });\n}\n\n/**\n * The generic failure re-hold: a settled failure of a message-carrying run\n * send goes back into the outbox held, with `localMeta.error`, for the user\n * to retry, edit or discard. Wire it into a durable `onCommandChange` for the\n * failures nothing else re-queues.\n */\nexport function reholdFailedSettle(\n  outbox: Pick<DeepAgentOutbox, 'insert'>,\n  update: DeepAgentSettledUpdate,\n): string | null {\n  return requeueFailedRunSend({ outbox, update, held: true });\n}\n\n/** The held outbox entry that carries `messageId`'s run send. */\nexport function findHeldRunSend(\n  outbox: Pick<DeepAgentOutbox, 'entries'>,\n  messageId: string,\n): StatewireClient.OutboxEntry | undefined {\n  return outbox.entries.find(\n    (entry) => entry.state === 'held' && runSendMessageId(entry.command) === messageId,\n  );\n}\n\nfunction unknownHeldSend(messageId: string): Error {\n  return new Error(`statewire: unknown failed entry \"${messageId}\"`);\n}\n\n/**\n * Held entries a retry or discard in this page already acted on. On shared\n * storage the verbs apply under the journal lock, so the entry stays visible\n * (still held) until then; a second click must not act on it again. Entry ids\n * are random per command, so one page-wide set serves every thread.\n */\nconst claimedHeldSends = new Set<string>();\n\n/** Claims a held entry for one retry or discard; `false` when it was claimed already. */\nfunction claimHeldSend(entryId: string): boolean {\n  if (claimedHeldSends.has(entryId)) return false;\n  claimedHeldSends.add(entryId);\n  return true;\n}\n\n/**\n * Sends a held run send again: re-anchored against `thread`, its failure\n * cleared, released in place. A send whose statement changes (a steer into a\n * run that ended becomes an enqueue) is inserted in the held entry's place\n * and the held one removed. Throws `statewire: unknown failed entry` when no\n * held entry carries the message (it landed or was discarded meanwhile).\n */\nexport function retryHeldRunSend({\n  outbox,\n  messageId,\n  thread,\n}: {\n  outbox: DeepAgentOutbox;\n  messageId: string;\n  thread: DeepAgentRunSendThread;\n}): void {\n  const entry = findHeldRunSend(outbox, messageId);\n  if (entry === undefined || !claimHeldSend(entry.id)) throw unknownHeldSend(messageId);\n  const next = reanchorRunSend(entry.command, thread) ?? {\n    method: entry.command.method,\n    params: [...entry.command.params],\n  };\n  const localMeta = withoutSendFailure(entry.localMeta);\n  try {\n    if (next.method === entry.command.method) {\n      outbox.update(entry.id, () => ({ held: false, localMeta, command: { params: next.params } }));\n      return;\n    }\n    outbox.insert({\n      protocol: entry.protocol,\n      command: next,\n      before: entry.id,\n      ...(localMeta !== undefined && { localMeta }),\n    });\n    outbox.remove(entry.id);\n  } catch (error) {\n    claimedHeldSends.delete(entry.id);\n    throw error;\n  }\n}\n\n/** Drops a held run send. Throws `statewire: unknown failed entry` when none carries the message. */\nexport function discardHeldRunSend({\n  outbox,\n  messageId,\n}: {\n  outbox: Pick<DeepAgentOutbox, 'entries' | 'remove'>;\n  messageId: string;\n}): void {\n  const entry = findHeldRunSend(outbox, messageId);\n  if (entry === undefined || !claimHeldSend(entry.id)) throw unknownHeldSend(messageId);\n  try {\n    outbox.remove(entry.id);\n  } catch (error) {\n    claimedHeldSends.delete(entry.id);\n    throw error;\n  }\n}\n"],"names":["upgradeLegacyRunCommand","MESSAGE_RUN_METHODS","chatOutboxWireAnchorId","RUN_SEND_METHOD","DEEP_AGENT_STATEWIRE_PROTOCOL"],"mappings":"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"}

package/dist/agent-runtime/src/statewire-held-sends.d.ts

@@ -0,0 +1,119 @@
+import type { StatewireClient } from 'statewire';
+/**
+ * Failed run sends on statewire 0.24's outbox.
+ *
+ * statewire 0.24 has no failed list: a command the server judged (or the
+ * client lost) becomes a durable `settled` update, delivered once through
+ * `onCommandChange`. A run send the user should still see is put back into
+ * the outbox HELD, with the failure in its `localMeta.error`
+ * ({@link reholdFailedSettle}); react-statewire then folds it into
+ * `runs.held`, and the user retries ({@link retryHeldRunSend}) or discards
+ * ({@link discardHeldRunSend}) it. Send recovery re-queues the sends the
+ * server never judged the same way, unheld.
+ *
+ * Every function here reads the outbox and the thread structurally, so the
+ * runtime compiles against unpatched statewire typings.
+ */
+/** The outbox verbs this module uses (`StatewireClient.Outbox`, structurally). */
+export interface DeepAgentOutbox {
+    readonly entries: readonly StatewireClient.OutboxEntry[];
+    update: StatewireClient.Outbox['update'];
+    insert: StatewireClient.Outbox['insert'];
+    remove: StatewireClient.Outbox['remove'];
+}
+/** The outbox off a statewire thread's extras (`extras.outbox`), or `null` when it has none. */
+export declare function readStatewireOutbox(extras: unknown): DeepAgentOutbox | null;
+/** A send failure as a held entry carries it in `localMeta.error`. */
+export type DeepAgentSendFailure = StatewireClient.SendFailure;
+/** The failure a held entry's `localMeta` carries, if it was held for one. */
+export declare function heldSendFailure(localMeta: unknown): DeepAgentSendFailure | undefined;
+/** `localMeta` with the failure set (`error`), keeping what the send carried. */
+export declare function withSendFailure(localMeta: unknown, error: DeepAgentSendFailure): Record<string, unknown>;
+/** `localMeta` without its failure; `undefined` when nothing else is left. */
+export declare function withoutSendFailure(localMeta: unknown): unknown;
+/** The client-minted message id a run send carries, off its command params. */
+export declare function runSendMessageId(command: {
+    method: string;
+    params?: readonly unknown[];
+}): string | null;
+/**
+ * The thread as a re-anchor reads it: the raw wire messages of the loaded
+ * window and the live run (react-statewire's `extras.state.messages` and
+ * `extras.runs.runId`, or the deep-agent state `onCommandChange` hands over).
+ */
+export interface DeepAgentRunSendThread {
+    wireMessages: readonly unknown[] | null | undefined;
+    runId: string | null;
+}
+/** The re-anchor view of a deep-agent state (`{ messages, runs }`), read structurally. */
+export declare function runSendThreadOfState(state: unknown): DeepAgentRunSendThread;
+/** The re-anchor view off a statewire thread's extras, read structurally. */
+export declare function runSendThreadOfExtras(extras: unknown): DeepAgentRunSendThread;
+/**
+ * A run send's command re-anchored against the thread as it is now, the way
+ * react-statewire anchors a fresh send: a send into the live run keeps its
+ * statement; any other send becomes a `run/send` into the live run (queued
+ * behind it, where an earlier run/enqueue put it) or one that starts a run at
+ * the host's tail (`auto`). An edit keeps its source
+ * and re-asserts the source's parent. `null` when the command is not a
+ * message-carrying run send, or an edit's source is not in the loaded window.
+ */
+export declare function reanchorRunSend(command: {
+    method: string;
+    params: readonly unknown[];
+}, thread: DeepAgentRunSendThread): {
+    method: string;
+    params: unknown[];
+} | null;
+/** The settled update a re-queue consumes (`Statewire.CommandUpdate`, structurally). */
+export interface DeepAgentSettledUpdate {
+    readonly protocol?: string;
+    id?: string;
+    method: string;
+    params: readonly unknown[];
+    status: string;
+    failure?: DeepAgentSendFailure;
+    localMeta?: unknown;
+}
+/**
+ * Puts a failed message-carrying run send back into the outbox, consuming the
+ * `settled` update in the same write (`insert({ from })`), so a redelivery
+ * never inserts twice. `held: true` re-holds it for the user with the failure
+ * in `localMeta.error`; `held: false` re-queues it (send recovery) without
+ * one. The command is re-anchored against `thread` when given.
+ *
+ * Returns the new entry's id, or `null` when the update is not a failed
+ * message-carrying run send (nothing is inserted; the caller acks it).
+ */
+export declare function requeueFailedRunSend({ outbox, update, held, thread, }: {
+    outbox: Pick<DeepAgentOutbox, 'insert'>;
+    update: DeepAgentSettledUpdate;
+    held: boolean;
+    thread?: DeepAgentRunSendThread | undefined;
+}): string | null;
+/**
+ * The generic failure re-hold: a settled failure of a message-carrying run
+ * send goes back into the outbox held, with `localMeta.error`, for the user
+ * to retry, edit or discard. Wire it into a durable `onCommandChange` for the
+ * failures nothing else re-queues.
+ */
+export declare function reholdFailedSettle(outbox: Pick<DeepAgentOutbox, 'insert'>, update: DeepAgentSettledUpdate): string | null;
+/** The held outbox entry that carries `messageId`'s run send. */
+export declare function findHeldRunSend(outbox: Pick<DeepAgentOutbox, 'entries'>, messageId: string): StatewireClient.OutboxEntry | undefined;
+/**
+ * Sends a held run send again: re-anchored against `thread`, its failure
+ * cleared, released in place. A send whose statement changes (a steer into a
+ * run that ended becomes an enqueue) is inserted in the held entry's place
+ * and the held one removed. Throws `statewire: unknown failed entry` when no
+ * held entry carries the message (it landed or was discarded meanwhile).
+ */
+export declare function retryHeldRunSend({ outbox, messageId, thread, }: {
+    outbox: DeepAgentOutbox;
+    messageId: string;
+    thread: DeepAgentRunSendThread;
+}): void;
+/** Drops a held run send. Throws `statewire: unknown failed entry` when none carries the message. */
+export declare function discardHeldRunSend({ outbox, messageId, }: {
+    outbox: Pick<DeepAgentOutbox, 'entries' | 'remove'>;
+    messageId: string;
+}): void;

package/dist/agent-runtime/src/statewire-held-sends.js

@@ -0,0 +1,191 @@
+import { chatOutboxWireAnchorId } from "./chat-outbox-thread.js";
+import { MESSAGE_RUN_METHODS, upgradeLegacyRunCommand, RUN_SEND_METHOD } from "./run-send.js";
+import { DEEP_AGENT_STATEWIRE_PROTOCOL } from "./statewire-transport.js";
+function readStatewireOutbox(extras) {
+  const outbox = extras == null ? void 0 : extras.outbox;
+  if (!outbox || !Array.isArray(outbox.entries) || typeof outbox.update !== "function" || typeof outbox.insert !== "function" || typeof outbox.remove !== "function")
+    return null;
+  return outbox;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSendFailure(value) {
+  return isRecord(value) && typeof value.fate === "string" && typeof value.cause === "string";
+}
+function heldSendFailure(localMeta) {
+  return isRecord(localMeta) && isSendFailure(localMeta.error) ? localMeta.error : void 0;
+}
+function withSendFailure(localMeta, error) {
+  return { ...isRecord(localMeta) ? localMeta : {}, error };
+}
+function withoutSendFailure(localMeta) {
+  if (!isRecord(localMeta) || !("error" in localMeta)) return localMeta;
+  const { error: _error, ...rest } = localMeta;
+  return Object.keys(rest).length > 0 ? rest : void 0;
+}
+function currentRunCommand(command) {
+  return upgradeLegacyRunCommand(command) ?? command;
+}
+function runSendMessageId(command) {
+  var _a, _b;
+  const current = currentRunCommand({ method: command.method, params: command.params ?? [] });
+  if (!MESSAGE_RUN_METHODS.has(current.method)) return null;
+  const id = (_b = (_a = current.params[0]) == null ? void 0 : _a.message) == null ? void 0 : _b.id;
+  return typeof id === "string" ? id : null;
+}
+function runSendThreadOfState(state) {
+  var _a;
+  const value = isRecord(state) ? state : {};
+  const runs = Array.isArray(value.runs) ? value.runs : [];
+  const runId = (_a = runs[0]) == null ? void 0 : _a.runId;
+  return {
+    wireMessages: Array.isArray(value.messages) ? value.messages : null,
+    runId: typeof runId === "string" ? runId : null
+  };
+}
+function runSendThreadOfExtras(extras) {
+  const value = isRecord(extras) ? extras : {};
+  const state = isRecord(value.state) ? value.state : {};
+  const runId = isRecord(value.runs) ? value.runs.runId : void 0;
+  return {
+    wireMessages: Array.isArray(state.messages) ? state.messages : null,
+    runId: typeof runId === "string" ? runId : null
+  };
+}
+function mintRunId() {
+  var _a, _b;
+  const host = globalThis;
+  return ((_b = (_a = host.crypto) == null ? void 0 : _a.randomUUID) == null ? void 0 : _b.call(_a)) ?? `run-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function reanchorRunSend(command, thread) {
+  var _a;
+  if (!MESSAGE_RUN_METHODS.has(command.method)) return null;
+  const params = command.params[0];
+  if (!isRecord(params) || !isRecord(params.message)) return null;
+  const rest = command.params.slice(1);
+  if (command.method === "run/edit") {
+    if (typeof params.sourceId !== "string") return null;
+    const wire = thread.wireMessages ?? [];
+    const index = wire.findIndex((message) => (message == null ? void 0 : message.id) === params.sourceId);
+    const runAnchorMessageId = index > 0 ? (_a = wire[index - 1]) == null ? void 0 : _a.id : void 0;
+    if (typeof runAnchorMessageId !== "string") return null;
+    return {
+      method: "run/edit",
+      params: [{ ...params, runId: thread.runId ?? mintRunId(), runAnchorMessageId }, ...rest]
+    };
+  }
+  if (thread.runId !== null && params.runId === thread.runId) {
+    return { method: command.method, params: [params, ...rest] };
+  }
+  const { runAnchorMessageId: _anchor, ...unanchored } = params;
+  const fields = thread.runId !== null ? { runId: thread.runId } : {
+    runId: mintRunId(),
+    runAnchorMessageId: thread.wireMessages && thread.wireMessages.length > 0 ? chatOutboxWireAnchorId(thread.wireMessages) : null
+  };
+  return {
+    method: RUN_SEND_METHOD,
+    params: [
+      {
+        ...unanchored,
+        type: RUN_SEND_METHOD,
+        behavior: thread.runId !== null ? "queue" : "auto",
+        ...fields
+      },
+      ...rest
+    ]
+  };
+}
+function requeueFailedRunSend({
+  outbox,
+  update,
+  held,
+  thread
+}) {
+  if (update.status !== "settled" || update.failure === void 0) return null;
+  if (runSendMessageId(update) === null) return null;
+  const sent = currentRunCommand({ method: update.method, params: update.params });
+  const command = (thread && reanchorRunSend(sent, thread)) ?? {
+    method: sent.method,
+    params: [...sent.params]
+  };
+  const localMeta = held ? withSendFailure(update.localMeta, update.failure) : withoutSendFailure(update.localMeta);
+  return outbox.insert({
+    ...update.id !== void 0 && { from: update.id },
+    protocol: update.protocol ?? DEEP_AGENT_STATEWIRE_PROTOCOL,
+    command,
+    held,
+    ...localMeta !== void 0 && { localMeta }
+  });
+}
+function findHeldRunSend(outbox, messageId) {
+  return outbox.entries.find(
+    (entry) => entry.state === "held" && runSendMessageId(entry.command) === messageId
+  );
+}
+function unknownHeldSend(messageId) {
+  return new Error(`statewire: unknown failed entry "${messageId}"`);
+}
+const claimedHeldSends = /* @__PURE__ */ new Set();
+function claimHeldSend(entryId) {
+  if (claimedHeldSends.has(entryId)) return false;
+  claimedHeldSends.add(entryId);
+  return true;
+}
+function retryHeldRunSend({
+  outbox,
+  messageId,
+  thread
+}) {
+  const entry = findHeldRunSend(outbox, messageId);
+  if (entry === void 0 || !claimHeldSend(entry.id)) throw unknownHeldSend(messageId);
+  const next = reanchorRunSend(entry.command, thread) ?? {
+    method: entry.command.method,
+    params: [...entry.command.params]
+  };
+  const localMeta = withoutSendFailure(entry.localMeta);
+  try {
+    if (next.method === entry.command.method) {
+      outbox.update(entry.id, () => ({ held: false, localMeta, command: { params: next.params } }));
+      return;
+    }
+    outbox.insert({
+      protocol: entry.protocol,
+      command: next,
+      before: entry.id,
+      ...localMeta !== void 0 && { localMeta }
+    });
+    outbox.remove(entry.id);
+  } catch (error) {
+    claimedHeldSends.delete(entry.id);
+    throw error;
+  }
+}
+function discardHeldRunSend({
+  outbox,
+  messageId
+}) {
+  const entry = findHeldRunSend(outbox, messageId);
+  if (entry === void 0 || !claimHeldSend(entry.id)) throw unknownHeldSend(messageId);
+  try {
+    outbox.remove(entry.id);
+  } catch (error) {
+    claimedHeldSends.delete(entry.id);
+    throw error;
+  }
+}
+export {
+  discardHeldRunSend,
+  findHeldRunSend,
+  heldSendFailure,
+  readStatewireOutbox,
+  reanchorRunSend,
+  requeueFailedRunSend,
+  retryHeldRunSend,
+  runSendMessageId,
+  runSendThreadOfExtras,
+  runSendThreadOfState,
+  withSendFailure,
+  withoutSendFailure
+};
+//# sourceMappingURL=statewire-held-sends.js.map

package/dist/agent-runtime/src/statewire-held-sends.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statewire-held-sends.js","sources":["../../../../agent-runtime/src/statewire-held-sends.ts"],"sourcesContent":["import type { StatewireClient } from 'statewire';\nimport { chatOutboxWireAnchorId } from './chat-outbox-thread';\nimport { MESSAGE_RUN_METHODS, RUN_SEND_METHOD, upgradeLegacyRunCommand } from './run-send';\nimport { DEEP_AGENT_STATEWIRE_PROTOCOL } from './statewire-transport';\n\n/**\n * Failed run sends on statewire 0.24's outbox.\n *\n * statewire 0.24 has no failed list: a command the server judged (or the\n * client lost) becomes a durable `settled` update, delivered once through\n * `onCommandChange`. A run send the user should still see is put back into\n * the outbox HELD, with the failure in its `localMeta.error`\n * ({@link reholdFailedSettle}); react-statewire then folds it into\n * `runs.held`, and the user retries ({@link retryHeldRunSend}) or discards\n * ({@link discardHeldRunSend}) it. Send recovery re-queues the sends the\n * server never judged the same way, unheld.\n *\n * Every function here reads the outbox and the thread structurally, so the\n * runtime compiles against unpatched statewire typings.\n */\n\n/** The outbox verbs this module uses (`StatewireClient.Outbox`, structurally). */\nexport interface DeepAgentOutbox {\n  readonly entries: readonly StatewireClient.OutboxEntry[];\n  update: StatewireClient.Outbox['update'];\n  insert: StatewireClient.Outbox['insert'];\n  remove: StatewireClient.Outbox['remove'];\n}\n\n/** The outbox off a statewire thread's extras (`extras.outbox`), or `null` when it has none. */\nexport function readStatewireOutbox(extras: unknown): DeepAgentOutbox | null {\n  const outbox = (extras as { outbox?: Partial<DeepAgentOutbox> } | null)?.outbox;\n  if (\n    !outbox ||\n    !Array.isArray(outbox.entries) ||\n    typeof outbox.update !== 'function' ||\n    typeof outbox.insert !== 'function' ||\n    typeof outbox.remove !== 'function'\n  )\n    return null;\n  return outbox as DeepAgentOutbox;\n}\n\n/** A send failure as a held entry carries it in `localMeta.error`. */\nexport type DeepAgentSendFailure = StatewireClient.SendFailure;\n\n\ntype RunCommandParams = {\n  type?: unknown;\n  runId?: unknown;\n  message?: { id?: unknown } | null;\n  sourceId?: unknown;\n  runAnchorMessageId?: unknown;\n  [key: string]: unknown;\n};\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction isSendFailure(value: unknown): value is DeepAgentSendFailure {\n  return isRecord(value) && typeof value.fate === 'string' && typeof value.cause === 'string';\n}\n\n/** The failure a held entry's `localMeta` carries, if it was held for one. */\nexport function heldSendFailure(localMeta: unknown): DeepAgentSendFailure | undefined {\n  return isRecord(localMeta) && isSendFailure(localMeta.error) ? localMeta.error : undefined;\n}\n\n/** `localMeta` with the failure set (`error`), keeping what the send carried. */\nexport function withSendFailure(localMeta: unknown, error: DeepAgentSendFailure): Record<string, unknown> {\n  return { ...(isRecord(localMeta) ? localMeta : {}), error };\n}\n\n/** `localMeta` without its failure; `undefined` when nothing else is left. */\nexport function withoutSendFailure(localMeta: unknown): unknown {\n  if (!isRecord(localMeta) || !('error' in localMeta)) return localMeta;\n  const { error: _error, ...rest } = localMeta;\n  return Object.keys(rest).length > 0 ? rest : undefined;\n}\n\n/**\n * A run command as the current contract says it: a 2026-09-13 statement an\n * earlier build stored (`run/enqueue`, `run/steer`, …) becomes its `run/send`.\n */\nfunction currentRunCommand(command: { method: string; params: readonly unknown[] }): {\n  method: string;\n  params: readonly unknown[];\n} {\n  return upgradeLegacyRunCommand(command) ?? command;\n}\n\n/** The client-minted message id a run send carries, off its command params. */\nexport function runSendMessageId(command: {\n  method: string;\n  params?: readonly unknown[];\n}): string | null {\n  const current = currentRunCommand({ method: command.method, params: command.params ?? [] });\n  if (!MESSAGE_RUN_METHODS.has(current.method)) return null;\n  const id = (current.params[0] as RunCommandParams | undefined)?.message?.id;\n  return typeof id === 'string' ? id : null;\n}\n\n/**\n * The thread as a re-anchor reads it: the raw wire messages of the loaded\n * window and the live run (react-statewire's `extras.state.messages` and\n * `extras.runs.runId`, or the deep-agent state `onCommandChange` hands over).\n */\nexport interface DeepAgentRunSendThread {\n  wireMessages: readonly unknown[] | null | undefined;\n  runId: string | null;\n}\n\n/** The re-anchor view of a deep-agent state (`{ messages, runs }`), read structurally. */\nexport function runSendThreadOfState(state: unknown): DeepAgentRunSendThread {\n  const value = isRecord(state) ? state : {};\n  const runs = Array.isArray(value.runs) ? value.runs : [];\n  const runId = (runs[0] as { runId?: unknown } | undefined)?.runId;\n  return {\n    wireMessages: Array.isArray(value.messages) ? value.messages : null,\n    runId: typeof runId === 'string' ? runId : null,\n  };\n}\n\n/** The re-anchor view off a statewire thread's extras, read structurally. */\nexport function runSendThreadOfExtras(extras: unknown): DeepAgentRunSendThread {\n  const value = isRecord(extras) ? extras : {};\n  const state = isRecord(value.state) ? value.state : {};\n  const runId = isRecord(value.runs) ? value.runs.runId : undefined;\n  return {\n    wireMessages: Array.isArray(state.messages) ? state.messages : null,\n    runId: typeof runId === 'string' ? runId : null,\n  };\n}\n\nfunction mintRunId(): string {\n  const host = globalThis as { crypto?: { randomUUID?: () => string } };\n  return host.crypto?.randomUUID?.() ?? `run-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;\n}\n\n/**\n * A run send's command re-anchored against the thread as it is now, the way\n * react-statewire anchors a fresh send: a send into the live run keeps its\n * statement; any other send becomes a `run/send` into the live run (queued\n * behind it, where an earlier run/enqueue put it) or one that starts a run at\n * the host's tail (`auto`). An edit keeps its source\n * and re-asserts the source's parent. `null` when the command is not a\n * message-carrying run send, or an edit's source is not in the loaded window.\n */\nexport function reanchorRunSend(\n  command: { method: string; params: readonly unknown[] },\n  thread: DeepAgentRunSendThread,\n): { method: string; params: unknown[] } | null {\n  if (!MESSAGE_RUN_METHODS.has(command.method)) return null;\n  const params = command.params[0] as RunCommandParams | undefined;\n  if (!isRecord(params) || !isRecord(params.message)) return null;\n  const rest = command.params.slice(1);\n  if (command.method === 'run/edit') {\n    if (typeof params.sourceId !== 'string') return null;\n    // The host checks the anchor against the source's parent in its raw list\n    // (`edit-command.ts`). A source first in the loaded window may have its\n    // parent below it, so only a parent seen here re-anchors the edit.\n    const wire = (thread.wireMessages ?? []) as readonly ({ id?: unknown } | null)[];\n    const index = wire.findIndex((message) => message?.id === params.sourceId);\n    const runAnchorMessageId = index > 0 ? wire[index - 1]?.id : undefined;\n    if (typeof runAnchorMessageId !== 'string') return null;\n    return {\n      method: 'run/edit',\n      params: [{ ...params, runId: thread.runId ?? mintRunId(), runAnchorMessageId }, ...rest],\n    };\n  }\n  if (thread.runId !== null && params.runId === thread.runId) {\n    return { method: command.method, params: [params, ...rest] };\n  }\n  const { runAnchorMessageId: _anchor, ...unanchored } = params;\n  const fields =\n    thread.runId !== null\n      ? { runId: thread.runId }\n      : {\n          runId: mintRunId(),\n          runAnchorMessageId:\n            thread.wireMessages && thread.wireMessages.length > 0\n              ? chatOutboxWireAnchorId(thread.wireMessages)\n              : null,\n        };\n  return {\n    method: RUN_SEND_METHOD,\n    params: [\n      {\n        ...unanchored,\n        type: RUN_SEND_METHOD,\n        behavior: thread.runId !== null ? 'queue' : 'auto',\n        ...fields,\n      },\n      ...rest,\n    ],\n  };\n}\n\n/** The settled update a re-queue consumes (`Statewire.CommandUpdate`, structurally). */\nexport interface DeepAgentSettledUpdate {\n  readonly protocol?: string;\n  id?: string;\n  method: string;\n  params: readonly unknown[];\n  status: string;\n  failure?: DeepAgentSendFailure;\n  localMeta?: unknown;\n}\n\n/**\n * Puts a failed message-carrying run send back into the outbox, consuming the\n * `settled` update in the same write (`insert({ from })`), so a redelivery\n * never inserts twice. `held: true` re-holds it for the user with the failure\n * in `localMeta.error`; `held: false` re-queues it (send recovery) without\n * one. The command is re-anchored against `thread` when given.\n *\n * Returns the new entry's id, or `null` when the update is not a failed\n * message-carrying run send (nothing is inserted; the caller acks it).\n */\nexport function requeueFailedRunSend({\n  outbox,\n  update,\n  held,\n  thread,\n}: {\n  outbox: Pick<DeepAgentOutbox, 'insert'>;\n  update: DeepAgentSettledUpdate;\n  held: boolean;\n  thread?: DeepAgentRunSendThread | undefined;\n}): string | null {\n  if (update.status !== 'settled' || update.failure === undefined) return null;\n  if (runSendMessageId(update) === null) return null;\n  const sent = currentRunCommand({ method: update.method, params: update.params });\n  const command = (thread && reanchorRunSend(sent, thread)) ?? {\n    method: sent.method,\n    params: [...sent.params],\n  };\n  const localMeta = held\n    ? withSendFailure(update.localMeta, update.failure)\n    : withoutSendFailure(update.localMeta);\n  return outbox.insert({\n    ...(update.id !== undefined && { from: update.id }),\n    protocol: update.protocol ?? DEEP_AGENT_STATEWIRE_PROTOCOL,\n    command,\n    held,\n    ...(localMeta !== undefined && { localMeta }),\n  });\n}\n\n/**\n * The generic failure re-hold: a settled failure of a message-carrying run\n * send goes back into the outbox held, with `localMeta.error`, for the user\n * to retry, edit or discard. Wire it into a durable `onCommandChange` for the\n * failures nothing else re-queues.\n */\nexport function reholdFailedSettle(\n  outbox: Pick<DeepAgentOutbox, 'insert'>,\n  update: DeepAgentSettledUpdate,\n): string | null {\n  return requeueFailedRunSend({ outbox, update, held: true });\n}\n\n/** The held outbox entry that carries `messageId`'s run send. */\nexport function findHeldRunSend(\n  outbox: Pick<DeepAgentOutbox, 'entries'>,\n  messageId: string,\n): StatewireClient.OutboxEntry | undefined {\n  return outbox.entries.find(\n    (entry) => entry.state === 'held' && runSendMessageId(entry.command) === messageId,\n  );\n}\n\nfunction unknownHeldSend(messageId: string): Error {\n  return new Error(`statewire: unknown failed entry \"${messageId}\"`);\n}\n\n/**\n * Held entries a retry or discard in this page already acted on. On shared\n * storage the verbs apply under the journal lock, so the entry stays visible\n * (still held) until then; a second click must not act on it again. Entry ids\n * are random per command, so one page-wide set serves every thread.\n */\nconst claimedHeldSends = new Set<string>();\n\n/** Claims a held entry for one retry or discard; `false` when it was claimed already. */\nfunction claimHeldSend(entryId: string): boolean {\n  if (claimedHeldSends.has(entryId)) return false;\n  claimedHeldSends.add(entryId);\n  return true;\n}\n\n/**\n * Sends a held run send again: re-anchored against `thread`, its failure\n * cleared, released in place. A send whose statement changes (a steer into a\n * run that ended becomes an enqueue) is inserted in the held entry's place\n * and the held one removed. Throws `statewire: unknown failed entry` when no\n * held entry carries the message (it landed or was discarded meanwhile).\n */\nexport function retryHeldRunSend({\n  outbox,\n  messageId,\n  thread,\n}: {\n  outbox: DeepAgentOutbox;\n  messageId: string;\n  thread: DeepAgentRunSendThread;\n}): void {\n  const entry = findHeldRunSend(outbox, messageId);\n  if (entry === undefined || !claimHeldSend(entry.id)) throw unknownHeldSend(messageId);\n  const next = reanchorRunSend(entry.command, thread) ?? {\n    method: entry.command.method,\n    params: [...entry.command.params],\n  };\n  const localMeta = withoutSendFailure(entry.localMeta);\n  try {\n    if (next.method === entry.command.method) {\n      outbox.update(entry.id, () => ({ held: false, localMeta, command: { params: next.params } }));\n      return;\n    }\n    outbox.insert({\n      protocol: entry.protocol,\n      command: next,\n      before: entry.id,\n      ...(localMeta !== undefined && { localMeta }),\n    });\n    outbox.remove(entry.id);\n  } catch (error) {\n    claimedHeldSends.delete(entry.id);\n    throw error;\n  }\n}\n\n/** Drops a held run send. Throws `statewire: unknown failed entry` when none carries the message. */\nexport function discardHeldRunSend({\n  outbox,\n  messageId,\n}: {\n  outbox: Pick<DeepAgentOutbox, 'entries' | 'remove'>;\n  messageId: string;\n}): void {\n  const entry = findHeldRunSend(outbox, messageId);\n  if (entry === undefined || !claimHeldSend(entry.id)) throw unknownHeldSend(messageId);\n  try {\n    outbox.remove(entry.id);\n  } catch (error) {\n    claimedHeldSends.delete(entry.id);\n    throw error;\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/agent-runtime/src/statewire-state.cjs

@@ -17,8 +17,12 @@ function pairDeepAgentStateWithThread({
 }) {
   stateThreadIds.set(state, threadId);
 }
+function readDeepAgentStateThreadId(state) {
+  return typeof state === "object" && state !== null ? stateThreadIds.get(state) ?? null : null;
+}
 exports.DEEP_AGENT_PRE_STREAM_STATE = DEEP_AGENT_PRE_STREAM_STATE;
 exports.isDeepAgentStateHydrated = isDeepAgentStateHydrated;
 exports.pairDeepAgentStateWithThread = pairDeepAgentStateWithThread;
+exports.readDeepAgentStateThreadId = readDeepAgentStateThreadId;
 exports.readDeepAgentStreamValues = readDeepAgentStreamValues;
 //# sourceMappingURL=statewire-state.cjs.map

package/dist/agent-runtime/src/statewire-state.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"statewire-state.cjs","sources":["../../../../agent-runtime/src/statewire-state.ts"],"sourcesContent":["import type { DeepAgentStreamValues } from './types';\n\n/**\n * Typed pre-stream default for the deep-agent statewire state.\n *\n * The statewire client's replicated state is `undefined` (and can transiently\n * be `null`/non-object on a replay boundary) until an attach snapshot applies —\n * `@assistant-ui/react-statewire` derives its `\"loading\"` thread status from\n * exactly that absence, so the raw wire value must keep carrying it. Consumers\n * of OUR conversion layer, however, should never have to null-check the whole\n * state: they read through {@link readDeepAgentStreamValues}, which substitutes\n * this constant while the state is not hydrated.\n *\n * Module-level constant on purpose: selector fallbacks must be referentially\n * stable (`useStatewireState` compares selector results with `Object.is`, so a\n * fresh `[]`/`{}` per call re-renders forever). Frozen so a consumer cannot\n * mutate the shared default.\n */\nconst preStreamState: DeepAgentStreamValues = { messages: [], todos: [] };\nObject.freeze(preStreamState.messages);\nObject.freeze(preStreamState.todos);\nexport const DEEP_AGENT_PRE_STREAM_STATE: DeepAgentStreamValues = Object.freeze(preStreamState);\n\n/**\n * Read the deep-agent stream values off a raw statewire state, substituting\n * {@link DEEP_AGENT_PRE_STREAM_STATE} while the state is not an object yet\n * (pre-attach, or a replay boundary republishing `undefined`).\n *\n * Identity-preserving: a hydrated state returns the same object reference it\n * was given and the pre-stream branch always returns the same module constant,\n * so this is safe to call inside `useStatewireState` selectors.\n */\nexport function readDeepAgentStreamValues(state: unknown): DeepAgentStreamValues {\n  return typeof state === 'object' && state !== null\n    ? (state as DeepAgentStreamValues)\n    : DEEP_AGENT_PRE_STREAM_STATE;\n}\n\n/**\n * Whether a state (raw, or already normalized through\n * {@link readDeepAgentStreamValues}) carries a real wire payload. `false`\n * exactly while the pre-stream default stands in — the explicit signal for\n * code that must distinguish \"empty thread\" from \"no snapshot yet\".\n */\nexport function isDeepAgentStateHydrated(state: unknown): boolean {\n  return typeof state === 'object' && state !== null && state !== DEEP_AGENT_PRE_STREAM_STATE;\n}\n\n/**\n * The thread whose attach produced each state `useDeepAgentThread`'s\n * converter publishes.\n *\n * A thread switch commits the incoming thread's per-attach children (keyed by\n * thread) in the same render that hands the assistant-ui client the new thread\n * element, but the client's projected thread state only changes once that\n * element's resource re-renders: a child's first render still reads the\n * OUTGOING attach's state. A binding that writes a lane of that state into the\n * new thread's storage — the server config lane, mirrored into the panel config\n * and the version that narrows every send — would hand the new thread the\n * previous thread's values. Pairing each state with its thread lets such a\n * binding ignore a state its own thread did not produce.\n *\n * Kept beside the state rather than on it: the state is the replicated wire\n * document that the snapshot cache remembers and other readers compare, so a\n * client-only key would ride every one of them.\n */\nconst stateThreadIds = new WeakMap<object, string>();\n\n/** Record that `threadId`'s attach produced `state` (the converter's output). */\nexport function pairDeepAgentStateWithThread({\n  state,\n  threadId,\n}: {\n  state: object;\n  threadId: string;\n}): void {\n  stateThreadIds.set(state, threadId);\n}\n\n/**\n * The thread whose attach produced `state`, or `null` for a state no deep-agent\n * converter published (the pre-stream default, a state built elsewhere).\n */\nexport function readDeepAgentStateThreadId(state: unknown): string | null {\n  return typeof state === 'object' && state !== null ? (stateThreadIds.get(state) ?? null) : null;\n}\n"],"names":[],"mappings":";;AAkBA,MAAM,iBAAwC,EAAE,UAAU,IAAI,OAAO,CAAA,EAAC;AACtE,OAAO,OAAO,eAAe,QAAQ;AACrC,OAAO,OAAO,eAAe,KAAK;AAC3B,MAAM,8BAAqD,OAAO,OAAO,cAAc;AAWvF,SAAS,0BAA0B,OAAuC;AAC/E,SAAO,OAAO,UAAU,YAAY,UAAU,OACzC,QACD;AACN;AAQO,SAAS,yBAAyB,OAAyB;AAChE,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU;AAClE;AAoBA,MAAM,qCAAqB,QAAA;AAGpB,SAAS,6BAA6B;AAAA,EAC3C;AAAA,EACA;AACF,GAGS;AACP,iBAAe,IAAI,OAAO,QAAQ;AACpC;;;;;"}
+{"version":3,"file":"statewire-state.cjs","sources":["../../../../agent-runtime/src/statewire-state.ts"],"sourcesContent":["import type { DeepAgentStreamValues } from './types';\n\n/**\n * Typed pre-stream default for the deep-agent statewire state.\n *\n * The statewire client's replicated state is `undefined` (and can transiently\n * be `null`/non-object on a replay boundary) until an attach snapshot applies —\n * `@assistant-ui/react-statewire` derives its `\"loading\"` thread status from\n * exactly that absence, so the raw wire value must keep carrying it. Consumers\n * of OUR conversion layer, however, should never have to null-check the whole\n * state: they read through {@link readDeepAgentStreamValues}, which substitutes\n * this constant while the state is not hydrated.\n *\n * Module-level constant on purpose: selector fallbacks must be referentially\n * stable (`useStatewireState` compares selector results with `Object.is`, so a\n * fresh `[]`/`{}` per call re-renders forever). Frozen so a consumer cannot\n * mutate the shared default.\n */\nconst preStreamState: DeepAgentStreamValues = { messages: [], todos: [] };\nObject.freeze(preStreamState.messages);\nObject.freeze(preStreamState.todos);\nexport const DEEP_AGENT_PRE_STREAM_STATE: DeepAgentStreamValues = Object.freeze(preStreamState);\n\n/**\n * Read the deep-agent stream values off a raw statewire state, substituting\n * {@link DEEP_AGENT_PRE_STREAM_STATE} while the state is not an object yet\n * (pre-attach, or a replay boundary republishing `undefined`).\n *\n * Identity-preserving: a hydrated state returns the same object reference it\n * was given and the pre-stream branch always returns the same module constant,\n * so this is safe to call inside `useStatewireState` selectors.\n */\nexport function readDeepAgentStreamValues(state: unknown): DeepAgentStreamValues {\n  return typeof state === 'object' && state !== null\n    ? (state as DeepAgentStreamValues)\n    : DEEP_AGENT_PRE_STREAM_STATE;\n}\n\n/**\n * Whether a state (raw, or already normalized through\n * {@link readDeepAgentStreamValues}) carries a real wire payload. `false`\n * exactly while the pre-stream default stands in — the explicit signal for\n * code that must distinguish \"empty thread\" from \"no snapshot yet\".\n */\nexport function isDeepAgentStateHydrated(state: unknown): boolean {\n  return typeof state === 'object' && state !== null && state !== DEEP_AGENT_PRE_STREAM_STATE;\n}\n\n/**\n * The thread whose attach produced each state `useDeepAgentThread`'s\n * converter publishes.\n *\n * A thread switch commits the incoming thread's per-attach children (keyed by\n * thread) in the same render that hands the assistant-ui client the new thread\n * element, but the client's projected thread state only changes once that\n * element's resource re-renders: a child's first render still reads the\n * OUTGOING attach's state. A binding that writes a lane of that state into the\n * new thread's storage — the server config lane, mirrored into the panel config\n * and the version that narrows every send — would hand the new thread the\n * previous thread's values. Pairing each state with its thread lets such a\n * binding ignore a state its own thread did not produce.\n *\n * Kept beside the state rather than on it: the state is the replicated wire\n * document that the snapshot cache remembers and other readers compare, so a\n * client-only key would ride every one of them.\n */\nconst stateThreadIds = new WeakMap<object, string>();\n\n/** Record that `threadId`'s attach produced `state` (the converter's output). */\nexport function pairDeepAgentStateWithThread({\n  state,\n  threadId,\n}: {\n  state: object;\n  threadId: string;\n}): void {\n  stateThreadIds.set(state, threadId);\n}\n\n/**\n * The thread whose attach produced `state`, or `null` for a state no deep-agent\n * converter published (the pre-stream default, a state built elsewhere).\n */\nexport function readDeepAgentStateThreadId(state: unknown): string | null {\n  return typeof state === 'object' && state !== null ? (stateThreadIds.get(state) ?? null) : null;\n}\n"],"names":[],"mappings":";;AAkBA,MAAM,iBAAwC,EAAE,UAAU,IAAI,OAAO,CAAA,EAAC;AACtE,OAAO,OAAO,eAAe,QAAQ;AACrC,OAAO,OAAO,eAAe,KAAK;AAC3B,MAAM,8BAAqD,OAAO,OAAO,cAAc;AAWvF,SAAS,0BAA0B,OAAuC;AAC/E,SAAO,OAAO,UAAU,YAAY,UAAU,OACzC,QACD;AACN;AAQO,SAAS,yBAAyB,OAAyB;AAChE,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU;AAClE;AAoBA,MAAM,qCAAqB,QAAA;AAGpB,SAAS,6BAA6B;AAAA,EAC3C;AAAA,EACA;AACF,GAGS;AACP,iBAAe,IAAI,OAAO,QAAQ;AACpC;AAMO,SAAS,2BAA2B,OAA+B;AACxE,SAAO,OAAO,UAAU,YAAY,UAAU,OAAQ,eAAe,IAAI,KAAK,KAAK,OAAQ;AAC7F;;;;;;"}

package/dist/agent-runtime/src/statewire-state.js

@@ -15,10 +15,14 @@ function pairDeepAgentStateWithThread({
 }) {
   stateThreadIds.set(state, threadId);
 }
+function readDeepAgentStateThreadId(state) {
+  return typeof state === "object" && state !== null ? stateThreadIds.get(state) ?? null : null;
+}
 export {
   DEEP_AGENT_PRE_STREAM_STATE,
   isDeepAgentStateHydrated,
   pairDeepAgentStateWithThread,
+  readDeepAgentStateThreadId,
   readDeepAgentStreamValues
 };
 //# sourceMappingURL=statewire-state.js.map

package/dist/agent-runtime/src/statewire-state.js.map

@@ -1 +1 @@
-{"version":3,"file":"statewire-state.js","sources":["../../../../agent-runtime/src/statewire-state.ts"],"sourcesContent":["import type { DeepAgentStreamValues } from './types';\n\n/**\n * Typed pre-stream default for the deep-agent statewire state.\n *\n * The statewire client's replicated state is `undefined` (and can transiently\n * be `null`/non-object on a replay boundary) until an attach snapshot applies —\n * `@assistant-ui/react-statewire` derives its `\"loading\"` thread status from\n * exactly that absence, so the raw wire value must keep carrying it. Consumers\n * of OUR conversion layer, however, should never have to null-check the whole\n * state: they read through {@link readDeepAgentStreamValues}, which substitutes\n * this constant while the state is not hydrated.\n *\n * Module-level constant on purpose: selector fallbacks must be referentially\n * stable (`useStatewireState` compares selector results with `Object.is`, so a\n * fresh `[]`/`{}` per call re-renders forever). Frozen so a consumer cannot\n * mutate the shared default.\n */\nconst preStreamState: DeepAgentStreamValues = { messages: [], todos: [] };\nObject.freeze(preStreamState.messages);\nObject.freeze(preStreamState.todos);\nexport const DEEP_AGENT_PRE_STREAM_STATE: DeepAgentStreamValues = Object.freeze(preStreamState);\n\n/**\n * Read the deep-agent stream values off a raw statewire state, substituting\n * {@link DEEP_AGENT_PRE_STREAM_STATE} while the state is not an object yet\n * (pre-attach, or a replay boundary republishing `undefined`).\n *\n * Identity-preserving: a hydrated state returns the same object reference it\n * was given and the pre-stream branch always returns the same module constant,\n * so this is safe to call inside `useStatewireState` selectors.\n */\nexport function readDeepAgentStreamValues(state: unknown): DeepAgentStreamValues {\n  return typeof state === 'object' && state !== null\n    ? (state as DeepAgentStreamValues)\n    : DEEP_AGENT_PRE_STREAM_STATE;\n}\n\n/**\n * Whether a state (raw, or already normalized through\n * {@link readDeepAgentStreamValues}) carries a real wire payload. `false`\n * exactly while the pre-stream default stands in — the explicit signal for\n * code that must distinguish \"empty thread\" from \"no snapshot yet\".\n */\nexport function isDeepAgentStateHydrated(state: unknown): boolean {\n  return typeof state === 'object' && state !== null && state !== DEEP_AGENT_PRE_STREAM_STATE;\n}\n\n/**\n * The thread whose attach produced each state `useDeepAgentThread`'s\n * converter publishes.\n *\n * A thread switch commits the incoming thread's per-attach children (keyed by\n * thread) in the same render that hands the assistant-ui client the new thread\n * element, but the client's projected thread state only changes once that\n * element's resource re-renders: a child's first render still reads the\n * OUTGOING attach's state. A binding that writes a lane of that state into the\n * new thread's storage — the server config lane, mirrored into the panel config\n * and the version that narrows every send — would hand the new thread the\n * previous thread's values. Pairing each state with its thread lets such a\n * binding ignore a state its own thread did not produce.\n *\n * Kept beside the state rather than on it: the state is the replicated wire\n * document that the snapshot cache remembers and other readers compare, so a\n * client-only key would ride every one of them.\n */\nconst stateThreadIds = new WeakMap<object, string>();\n\n/** Record that `threadId`'s attach produced `state` (the converter's output). */\nexport function pairDeepAgentStateWithThread({\n  state,\n  threadId,\n}: {\n  state: object;\n  threadId: string;\n}): void {\n  stateThreadIds.set(state, threadId);\n}\n\n/**\n * The thread whose attach produced `state`, or `null` for a state no deep-agent\n * converter published (the pre-stream default, a state built elsewhere).\n */\nexport function readDeepAgentStateThreadId(state: unknown): string | null {\n  return typeof state === 'object' && state !== null ? (stateThreadIds.get(state) ?? null) : null;\n}\n"],"names":[],"mappings":"AAkBA,MAAM,iBAAwC,EAAE,UAAU,IAAI,OAAO,CAAA,EAAC;AACtE,OAAO,OAAO,eAAe,QAAQ;AACrC,OAAO,OAAO,eAAe,KAAK;AAC3B,MAAM,8BAAqD,OAAO,OAAO,cAAc;AAWvF,SAAS,0BAA0B,OAAuC;AAC/E,SAAO,OAAO,UAAU,YAAY,UAAU,OACzC,QACD;AACN;AAQO,SAAS,yBAAyB,OAAyB;AAChE,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU;AAClE;AAoBA,MAAM,qCAAqB,QAAA;AAGpB,SAAS,6BAA6B;AAAA,EAC3C;AAAA,EACA;AACF,GAGS;AACP,iBAAe,IAAI,OAAO,QAAQ;AACpC;"}
+{"version":3,"file":"statewire-state.js","sources":["../../../../agent-runtime/src/statewire-state.ts"],"sourcesContent":["import type { DeepAgentStreamValues } from './types';\n\n/**\n * Typed pre-stream default for the deep-agent statewire state.\n *\n * The statewire client's replicated state is `undefined` (and can transiently\n * be `null`/non-object on a replay boundary) until an attach snapshot applies —\n * `@assistant-ui/react-statewire` derives its `\"loading\"` thread status from\n * exactly that absence, so the raw wire value must keep carrying it. Consumers\n * of OUR conversion layer, however, should never have to null-check the whole\n * state: they read through {@link readDeepAgentStreamValues}, which substitutes\n * this constant while the state is not hydrated.\n *\n * Module-level constant on purpose: selector fallbacks must be referentially\n * stable (`useStatewireState` compares selector results with `Object.is`, so a\n * fresh `[]`/`{}` per call re-renders forever). Frozen so a consumer cannot\n * mutate the shared default.\n */\nconst preStreamState: DeepAgentStreamValues = { messages: [], todos: [] };\nObject.freeze(preStreamState.messages);\nObject.freeze(preStreamState.todos);\nexport const DEEP_AGENT_PRE_STREAM_STATE: DeepAgentStreamValues = Object.freeze(preStreamState);\n\n/**\n * Read the deep-agent stream values off a raw statewire state, substituting\n * {@link DEEP_AGENT_PRE_STREAM_STATE} while the state is not an object yet\n * (pre-attach, or a replay boundary republishing `undefined`).\n *\n * Identity-preserving: a hydrated state returns the same object reference it\n * was given and the pre-stream branch always returns the same module constant,\n * so this is safe to call inside `useStatewireState` selectors.\n */\nexport function readDeepAgentStreamValues(state: unknown): DeepAgentStreamValues {\n  return typeof state === 'object' && state !== null\n    ? (state as DeepAgentStreamValues)\n    : DEEP_AGENT_PRE_STREAM_STATE;\n}\n\n/**\n * Whether a state (raw, or already normalized through\n * {@link readDeepAgentStreamValues}) carries a real wire payload. `false`\n * exactly while the pre-stream default stands in — the explicit signal for\n * code that must distinguish \"empty thread\" from \"no snapshot yet\".\n */\nexport function isDeepAgentStateHydrated(state: unknown): boolean {\n  return typeof state === 'object' && state !== null && state !== DEEP_AGENT_PRE_STREAM_STATE;\n}\n\n/**\n * The thread whose attach produced each state `useDeepAgentThread`'s\n * converter publishes.\n *\n * A thread switch commits the incoming thread's per-attach children (keyed by\n * thread) in the same render that hands the assistant-ui client the new thread\n * element, but the client's projected thread state only changes once that\n * element's resource re-renders: a child's first render still reads the\n * OUTGOING attach's state. A binding that writes a lane of that state into the\n * new thread's storage — the server config lane, mirrored into the panel config\n * and the version that narrows every send — would hand the new thread the\n * previous thread's values. Pairing each state with its thread lets such a\n * binding ignore a state its own thread did not produce.\n *\n * Kept beside the state rather than on it: the state is the replicated wire\n * document that the snapshot cache remembers and other readers compare, so a\n * client-only key would ride every one of them.\n */\nconst stateThreadIds = new WeakMap<object, string>();\n\n/** Record that `threadId`'s attach produced `state` (the converter's output). */\nexport function pairDeepAgentStateWithThread({\n  state,\n  threadId,\n}: {\n  state: object;\n  threadId: string;\n}): void {\n  stateThreadIds.set(state, threadId);\n}\n\n/**\n * The thread whose attach produced `state`, or `null` for a state no deep-agent\n * converter published (the pre-stream default, a state built elsewhere).\n */\nexport function readDeepAgentStateThreadId(state: unknown): string | null {\n  return typeof state === 'object' && state !== null ? (stateThreadIds.get(state) ?? null) : null;\n}\n"],"names":[],"mappings":"AAkBA,MAAM,iBAAwC,EAAE,UAAU,IAAI,OAAO,CAAA,EAAC;AACtE,OAAO,OAAO,eAAe,QAAQ;AACrC,OAAO,OAAO,eAAe,KAAK;AAC3B,MAAM,8BAAqD,OAAO,OAAO,cAAc;AAWvF,SAAS,0BAA0B,OAAuC;AAC/E,SAAO,OAAO,UAAU,YAAY,UAAU,OACzC,QACD;AACN;AAQO,SAAS,yBAAyB,OAAyB;AAChE,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU;AAClE;AAoBA,MAAM,qCAAqB,QAAA;AAGpB,SAAS,6BAA6B;AAAA,EAC3C;AAAA,EACA;AACF,GAGS;AACP,iBAAe,IAAI,OAAO,QAAQ;AACpC;AAMO,SAAS,2BAA2B,OAA+B;AACxE,SAAO,OAAO,UAAU,YAAY,UAAU,OAAQ,eAAe,IAAI,KAAK,KAAK,OAAQ;AAC7F;"}

package/dist/agent-runtime/src/statewire-transport.cjs

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const statewire = require("statewire");
+const chatOutboxPolicy = require("./chat-outbox-policy.cjs");
 const DEEP_AGENT_STATEWIRE_PROTOCOL = "athena";
-const DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = "2026-09-13";
+const DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = "2026-11-04";
+const DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION = "2026-09-13";
 const DEEP_AGENT_STATEWIRE_WIRE_VERSION = {
-  version: "2026-09-30"
+  version: "2026-11-01"
 };
+const canOvertake = { [DEEP_AGENT_STATEWIRE_PROTOCOL]: chatOutboxPolicy.athenaCanOvertake };
 function resolveStatewireTransportKind({ sse }) {
   return sse ? "sse" : "websocket";
 }
@@ -19,13 +22,16 @@ const statewireTransport = (options, { sse = false } = {}) => resolveStatewireTr
   protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,
   wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,
   applicationProtocols,
+  canOvertake,
   ...options
 }) : statewire.StatewireWebsocket({
   protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,
   wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,
   applicationProtocols,
+  canOvertake,
   ...options
 });
+exports.DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION = DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION;
 exports.DEEP_AGENT_STATEWIRE_PROTOCOL = DEEP_AGENT_STATEWIRE_PROTOCOL;
 exports.DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION;
 exports.DEEP_AGENT_STATEWIRE_WIRE_VERSION = DEEP_AGENT_STATEWIRE_WIRE_VERSION;

package/dist/agent-runtime/src/statewire-transport.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"statewire-transport.cjs","sources":["../../../../agent-runtime/src/statewire-transport.ts"],"sourcesContent":["import { type Statewire, type StatewireClient, StatewireHttp, StatewireWebsocket } from 'statewire';\nimport type { DeepAgentStreamValues } from './types';\n\nexport type StatewireTransportOptions = StatewireClient.HttpOptions &\n  StatewireClient.WebsocketOptions;\n\n/**\n * The application protocol the deep-agent transport stamps on every command.\n * The thread client must declare the same protocol: statewire's core applies\n * its optimistic folds only to commands of its own protocol, so a mismatch\n * leaves a send invisible until the server's frame lands.\n */\nexport const DEEP_AGENT_STATEWIRE_PROTOCOL = 'athena';\n\n/** Durable Athena commands keep their schema version across wire upgrades. */\nexport const DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = '2026-09-13';\n\n/**\n * The wire contract every deep-agent transport offers. Athena's hosts (Python\n * statewire 0.20) speak 2026-09-30 natively, so no legacy context range is\n * advertised.\n */\nexport const DEEP_AGENT_STATEWIRE_WIRE_VERSION: NonNullable<\n  StatewireTransportOptions['wireVersion']\n> = {\n  version: '2026-09-30',\n};\n\nexport type StatewireTransportKind = 'sse' | 'websocket';\n\n/**\n * The transport a host gets: SSE when it asks for SSE, WebSocket otherwise.\n * Whatever instruments the transport must read this too, so it matches the\n * transport actually built.\n */\nexport function resolveStatewireTransportKind({ sse }: { sse: boolean }): StatewireTransportKind {\n  return sse ? 'sse' : 'websocket';\n}\n\nconst applicationProtocols = [\n  {\n    name: DEEP_AGENT_STATEWIRE_PROTOCOL,\n    version: DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION,\n  },\n];\n\n/**\n * Build the deep-agent statewire transport: WebSocket by default, SSE when the\n * host app's toggle asks for it ({@link resolveStatewireTransportKind}). The\n * toggle source is host-specific (env var, extension flag, config store), so\n * the caller resolves it to a boolean.\n *\n * `TState` defaults to the deep-agent wire shape: the thread mounts that make\n * up nearly every caller get a typed state without naming it, and the other\n * mounts (the conversation index) name theirs.\n */\nexport const statewireTransport = <\n  TState = DeepAgentStreamValues,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: StatewireTransportOptions,\n  { sse = false }: { sse?: boolean } = {}\n) =>\n  resolveStatewireTransportKind({ sse }) === 'sse'\n    ? StatewireHttp<TState, TCommands>({\n        protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,\n        wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,\n        applicationProtocols,\n        ...options,\n      })\n    : StatewireWebsocket<TState, TCommands>({\n        protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,\n        wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,\n        applicationProtocols,\n        ...options,\n      });\n"],"names":["StatewireHttp","StatewireWebsocket"],"mappings":";;;AAYO,MAAM,gCAAgC;AAGtC,MAAM,wCAAwC;AAO9C,MAAM,oCAET;AAAA,EACF,SAAS;AACX;AASO,SAAS,8BAA8B,EAAE,OAAiD;AAC/F,SAAO,MAAM,QAAQ;AACvB;AAEA,MAAM,uBAAuB;AAAA,EAC3B;AAAA,IACE,MAAM;AAAA,IACN,SAAS;AAAA,EAAA;AAEb;AAYO,MAAM,qBAAqB,CAIhC,SACA,EAAE,MAAM,MAAA,IAA6B,OAErC,8BAA8B,EAAE,IAAA,CAAK,MAAM,QACvCA,UAAAA,cAAiC;AAAA,EAC/B,UAAU;AAAA,EACV,aAAa;AAAA,EACb;AAAA,EACA,GAAG;AACL,CAAC,IACDC,UAAAA,mBAAsC;AAAA,EACpC,UAAU;AAAA,EACV,aAAa;AAAA,EACb;AAAA,EACA,GAAG;AACL,CAAC;;;;;;"}
+{"version":3,"file":"statewire-transport.cjs","sources":["../../../../agent-runtime/src/statewire-transport.ts"],"sourcesContent":["import { type Statewire, type StatewireClient, StatewireHttp, StatewireWebsocket } from 'statewire';\nimport { athenaCanOvertake } from './chat-outbox-policy';\nimport type { DeepAgentStreamValues } from './types';\n\nexport type StatewireTransportOptions = StatewireClient.HttpOptions &\n  StatewireClient.WebsocketOptions;\n\n/**\n * The application protocol the deep-agent transport stamps on every command.\n * The thread client must declare the same protocol: statewire's core applies\n * its optimistic folds only to commands of its own protocol, so a mismatch\n * leaves a send invisible until the server's frame lands.\n */\nexport const DEEP_AGENT_STATEWIRE_PROTOCOL = 'athena';\n\n/**\n * The athena command contract this client speaks: 2026-11-04 sends every user\n * message as `run/send` with a behavior. Hosts adapt attaches that negotiate\n * 2026-09-13 (`run/enqueue`, `run/steer`, `run/steer-live`, `run/prioritize`),\n * so installed clients keep working; this client offers only 2026-11-04.\n */\nexport const DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = '2026-11-04';\n\n/** The athena contract before `run/send`; statements stored under it are upgraded on load. */\nexport const DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION = '2026-09-13';\n\n/**\n * The wire contract every deep-agent transport offers: 2026-11-01 only. The\n * client always sends the attach results cursor and never re-sends a stamped\n * seq, which a 2026-09-30 attach refuses, so no older range is offered.\n * Athena's hosts (Python statewire 0.21.1 on) serve 2026-09-30 through\n * 2026-11-01, so older clients keep attaching.\n */\nexport const DEEP_AGENT_STATEWIRE_WIRE_VERSION: NonNullable<\n  StatewireTransportOptions['wireVersion']\n> = {\n  version: '2026-11-01',\n};\n\n/**\n * The outbox ordering of Athena's lane (`chat-outbox-policy.ts`): a message\n * never passes a held or waiting one; stop, tool results and input replies\n * pass everything. A host's own `canOvertake` option wins.\n */\nconst canOvertake = { [DEEP_AGENT_STATEWIRE_PROTOCOL]: athenaCanOvertake };\n\nexport type StatewireTransportKind = 'sse' | 'websocket';\n\n/**\n * The transport a host gets: SSE when it asks for SSE, WebSocket otherwise.\n * Whatever instruments the transport must read this too, so it matches the\n * transport actually built.\n */\nexport function resolveStatewireTransportKind({ sse }: { sse: boolean }): StatewireTransportKind {\n  return sse ? 'sse' : 'websocket';\n}\n\nconst applicationProtocols = [\n  {\n    name: DEEP_AGENT_STATEWIRE_PROTOCOL,\n    version: DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION,\n  },\n];\n\n/**\n * Build the deep-agent statewire transport: WebSocket by default, SSE when the\n * host app's toggle asks for it ({@link resolveStatewireTransportKind}). The\n * toggle source is host-specific (env var, extension flag, config store), so\n * the caller resolves it to a boolean.\n *\n * `TState` defaults to the deep-agent wire shape: the thread mounts that make\n * up nearly every caller get a typed state without naming it, and the other\n * mounts (the conversation index) name theirs.\n */\nexport const statewireTransport = <\n  TState = DeepAgentStreamValues,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: StatewireTransportOptions,\n  { sse = false }: { sse?: boolean } = {}\n) =>\n  resolveStatewireTransportKind({ sse }) === 'sse'\n    ? StatewireHttp<TState, TCommands>({\n        protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,\n        wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,\n        applicationProtocols,\n        canOvertake,\n        ...options,\n      })\n    : StatewireWebsocket<TState, TCommands>({\n        protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,\n        wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,\n        applicationProtocols,\n        canOvertake,\n        ...options,\n      });\n"],"names":["athenaCanOvertake","StatewireHttp","StatewireWebsocket"],"mappings":";;;;AAaO,MAAM,gCAAgC;AAQtC,MAAM,wCAAwC;AAG9C,MAAM,+CAA+C;AASrD,MAAM,oCAET;AAAA,EACF,SAAS;AACX;AAOA,MAAM,cAAc,EAAE,CAAC,6BAA6B,GAAGA,mCAAA;AAShD,SAAS,8BAA8B,EAAE,OAAiD;AAC/F,SAAO,MAAM,QAAQ;AACvB;AAEA,MAAM,uBAAuB;AAAA,EAC3B;AAAA,IACE,MAAM;AAAA,IACN,SAAS;AAAA,EAAA;AAEb;AAYO,MAAM,qBAAqB,CAIhC,SACA,EAAE,MAAM,MAAA,IAA6B,OAErC,8BAA8B,EAAE,IAAA,CAAK,MAAM,QACvCC,UAAAA,cAAiC;AAAA,EAC/B,UAAU;AAAA,EACV,aAAa;AAAA,EACb;AAAA,EACA;AAAA,EACA,GAAG;AACL,CAAC,IACDC,UAAAA,mBAAsC;AAAA,EACpC,UAAU;AAAA,EACV,aAAa;AAAA,EACb;AAAA,EACA;AAAA,EACA,GAAG;AACL,CAAC;;;;;;;"}

package/dist/agent-runtime/src/statewire-transport.d.ts

@@ -8,12 +8,21 @@ export type StatewireTransportOptions = StatewireClient.HttpOptions & StatewireC
  * leaves a send invisible until the server's frame lands.
  */
 export declare const DEEP_AGENT_STATEWIRE_PROTOCOL = "athena";
-/** Durable Athena commands keep their schema version across wire upgrades. */
-export declare const DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = "2026-09-13";
 /**
- * The wire contract every deep-agent transport offers. Athena's hosts (Python
- * statewire 0.20) speak 2026-09-30 natively, so no legacy context range is
- * advertised.
+ * The athena command contract this client speaks: 2026-11-04 sends every user
+ * message as `run/send` with a behavior. Hosts adapt attaches that negotiate
+ * 2026-09-13 (`run/enqueue`, `run/steer`, `run/steer-live`, `run/prioritize`),
+ * so installed clients keep working; this client offers only 2026-11-04.
+ */
+export declare const DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = "2026-11-04";
+/** The athena contract before `run/send`; statements stored under it are upgraded on load. */
+export declare const DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION = "2026-09-13";
+/**
+ * The wire contract every deep-agent transport offers: 2026-11-01 only. The
+ * client always sends the attach results cursor and never re-sends a stamped
+ * seq, which a 2026-09-30 attach refuses, so no older range is offered.
+ * Athena's hosts (Python statewire 0.21.1 on) serve 2026-09-30 through
+ * 2026-11-01, so older clients keep attaching.
  */
 export declare const DEEP_AGENT_STATEWIRE_WIRE_VERSION: NonNullable<StatewireTransportOptions['wireVersion']>;
 export type StatewireTransportKind = 'sse' | 'websocket';

package/dist/agent-runtime/src/statewire-transport.js

@@ -1,9 +1,12 @@
 import { StatewireHttp, StatewireWebsocket } from "statewire";
+import { athenaCanOvertake } from "./chat-outbox-policy.js";
 const DEEP_AGENT_STATEWIRE_PROTOCOL = "athena";
-const DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = "2026-09-13";
+const DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = "2026-11-04";
+const DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION = "2026-09-13";
 const DEEP_AGENT_STATEWIRE_WIRE_VERSION = {
-  version: "2026-09-30"
+  version: "2026-11-01"
 };
+const canOvertake = { [DEEP_AGENT_STATEWIRE_PROTOCOL]: athenaCanOvertake };
 function resolveStatewireTransportKind({ sse }) {
   return sse ? "sse" : "websocket";
 }
@@ -17,14 +20,17 @@ const statewireTransport = (options, { sse = false } = {}) => resolveStatewireTr
   protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,
   wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,
   applicationProtocols,
+  canOvertake,
   ...options
 }) : StatewireWebsocket({
   protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,
   wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,
   applicationProtocols,
+  canOvertake,
   ...options
 });
 export {
+  DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION,
   DEEP_AGENT_STATEWIRE_PROTOCOL,
   DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION,
   DEEP_AGENT_STATEWIRE_WIRE_VERSION,

package/dist/agent-runtime/src/statewire-transport.js.map

@@ -1 +1 @@
-{"version":3,"file":"statewire-transport.js","sources":["../../../../agent-runtime/src/statewire-transport.ts"],"sourcesContent":["import { type Statewire, type StatewireClient, StatewireHttp, StatewireWebsocket } from 'statewire';\nimport type { DeepAgentStreamValues } from './types';\n\nexport type StatewireTransportOptions = StatewireClient.HttpOptions &\n  StatewireClient.WebsocketOptions;\n\n/**\n * The application protocol the deep-agent transport stamps on every command.\n * The thread client must declare the same protocol: statewire's core applies\n * its optimistic folds only to commands of its own protocol, so a mismatch\n * leaves a send invisible until the server's frame lands.\n */\nexport const DEEP_AGENT_STATEWIRE_PROTOCOL = 'athena';\n\n/** Durable Athena commands keep their schema version across wire upgrades. */\nexport const DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = '2026-09-13';\n\n/**\n * The wire contract every deep-agent transport offers. Athena's hosts (Python\n * statewire 0.20) speak 2026-09-30 natively, so no legacy context range is\n * advertised.\n */\nexport const DEEP_AGENT_STATEWIRE_WIRE_VERSION: NonNullable<\n  StatewireTransportOptions['wireVersion']\n> = {\n  version: '2026-09-30',\n};\n\nexport type StatewireTransportKind = 'sse' | 'websocket';\n\n/**\n * The transport a host gets: SSE when it asks for SSE, WebSocket otherwise.\n * Whatever instruments the transport must read this too, so it matches the\n * transport actually built.\n */\nexport function resolveStatewireTransportKind({ sse }: { sse: boolean }): StatewireTransportKind {\n  return sse ? 'sse' : 'websocket';\n}\n\nconst applicationProtocols = [\n  {\n    name: DEEP_AGENT_STATEWIRE_PROTOCOL,\n    version: DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION,\n  },\n];\n\n/**\n * Build the deep-agent statewire transport: WebSocket by default, SSE when the\n * host app's toggle asks for it ({@link resolveStatewireTransportKind}). The\n * toggle source is host-specific (env var, extension flag, config store), so\n * the caller resolves it to a boolean.\n *\n * `TState` defaults to the deep-agent wire shape: the thread mounts that make\n * up nearly every caller get a typed state without naming it, and the other\n * mounts (the conversation index) name theirs.\n */\nexport const statewireTransport = <\n  TState = DeepAgentStreamValues,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: StatewireTransportOptions,\n  { sse = false }: { sse?: boolean } = {}\n) =>\n  resolveStatewireTransportKind({ sse }) === 'sse'\n    ? StatewireHttp<TState, TCommands>({\n        protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,\n        wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,\n        applicationProtocols,\n        ...options,\n      })\n    : StatewireWebsocket<TState, TCommands>({\n        protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,\n        wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,\n        applicationProtocols,\n        ...options,\n      });\n"],"names":[],"mappings":";AAYO,MAAM,gCAAgC;AAGtC,MAAM,wCAAwC;AAO9C,MAAM,oCAET;AAAA,EACF,SAAS;AACX;AASO,SAAS,8BAA8B,EAAE,OAAiD;AAC/F,SAAO,MAAM,QAAQ;AACvB;AAEA,MAAM,uBAAuB;AAAA,EAC3B;AAAA,IACE,MAAM;AAAA,IACN,SAAS;AAAA,EAAA;AAEb;AAYO,MAAM,qBAAqB,CAIhC,SACA,EAAE,MAAM,MAAA,IAA6B,OAErC,8BAA8B,EAAE,IAAA,CAAK,MAAM,QACvC,cAAiC;AAAA,EAC/B,UAAU;AAAA,EACV,aAAa;AAAA,EACb;AAAA,EACA,GAAG;AACL,CAAC,IACD,mBAAsC;AAAA,EACpC,UAAU;AAAA,EACV,aAAa;AAAA,EACb;AAAA,EACA,GAAG;AACL,CAAC;"}
+{"version":3,"file":"statewire-transport.js","sources":["../../../../agent-runtime/src/statewire-transport.ts"],"sourcesContent":["import { type Statewire, type StatewireClient, StatewireHttp, StatewireWebsocket } from 'statewire';\nimport { athenaCanOvertake } from './chat-outbox-policy';\nimport type { DeepAgentStreamValues } from './types';\n\nexport type StatewireTransportOptions = StatewireClient.HttpOptions &\n  StatewireClient.WebsocketOptions;\n\n/**\n * The application protocol the deep-agent transport stamps on every command.\n * The thread client must declare the same protocol: statewire's core applies\n * its optimistic folds only to commands of its own protocol, so a mismatch\n * leaves a send invisible until the server's frame lands.\n */\nexport const DEEP_AGENT_STATEWIRE_PROTOCOL = 'athena';\n\n/**\n * The athena command contract this client speaks: 2026-11-04 sends every user\n * message as `run/send` with a behavior. Hosts adapt attaches that negotiate\n * 2026-09-13 (`run/enqueue`, `run/steer`, `run/steer-live`, `run/prioritize`),\n * so installed clients keep working; this client offers only 2026-11-04.\n */\nexport const DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION = '2026-11-04';\n\n/** The athena contract before `run/send`; statements stored under it are upgraded on load. */\nexport const DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION = '2026-09-13';\n\n/**\n * The wire contract every deep-agent transport offers: 2026-11-01 only. The\n * client always sends the attach results cursor and never re-sends a stamped\n * seq, which a 2026-09-30 attach refuses, so no older range is offered.\n * Athena's hosts (Python statewire 0.21.1 on) serve 2026-09-30 through\n * 2026-11-01, so older clients keep attaching.\n */\nexport const DEEP_AGENT_STATEWIRE_WIRE_VERSION: NonNullable<\n  StatewireTransportOptions['wireVersion']\n> = {\n  version: '2026-11-01',\n};\n\n/**\n * The outbox ordering of Athena's lane (`chat-outbox-policy.ts`): a message\n * never passes a held or waiting one; stop, tool results and input replies\n * pass everything. A host's own `canOvertake` option wins.\n */\nconst canOvertake = { [DEEP_AGENT_STATEWIRE_PROTOCOL]: athenaCanOvertake };\n\nexport type StatewireTransportKind = 'sse' | 'websocket';\n\n/**\n * The transport a host gets: SSE when it asks for SSE, WebSocket otherwise.\n * Whatever instruments the transport must read this too, so it matches the\n * transport actually built.\n */\nexport function resolveStatewireTransportKind({ sse }: { sse: boolean }): StatewireTransportKind {\n  return sse ? 'sse' : 'websocket';\n}\n\nconst applicationProtocols = [\n  {\n    name: DEEP_AGENT_STATEWIRE_PROTOCOL,\n    version: DEEP_AGENT_STATEWIRE_PROTOCOL_VERSION,\n  },\n];\n\n/**\n * Build the deep-agent statewire transport: WebSocket by default, SSE when the\n * host app's toggle asks for it ({@link resolveStatewireTransportKind}). The\n * toggle source is host-specific (env var, extension flag, config store), so\n * the caller resolves it to a boolean.\n *\n * `TState` defaults to the deep-agent wire shape: the thread mounts that make\n * up nearly every caller get a typed state without naming it, and the other\n * mounts (the conversation index) name theirs.\n */\nexport const statewireTransport = <\n  TState = DeepAgentStreamValues,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: StatewireTransportOptions,\n  { sse = false }: { sse?: boolean } = {}\n) =>\n  resolveStatewireTransportKind({ sse }) === 'sse'\n    ? StatewireHttp<TState, TCommands>({\n        protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,\n        wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,\n        applicationProtocols,\n        canOvertake,\n        ...options,\n      })\n    : StatewireWebsocket<TState, TCommands>({\n        protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,\n        wireVersion: DEEP_AGENT_STATEWIRE_WIRE_VERSION,\n        applicationProtocols,\n        canOvertake,\n        ...options,\n      });\n"],"names":[],"mappings":";;AAaO,MAAM,gCAAgC;AAQtC,MAAM,wCAAwC;AAG9C,MAAM,+CAA+C;AASrD,MAAM,oCAET;AAAA,EACF,SAAS;AACX;AAOA,MAAM,cAAc,EAAE,CAAC,6BAA6B,GAAG,kBAAA;AAShD,SAAS,8BAA8B,EAAE,OAAiD;AAC/F,SAAO,MAAM,QAAQ;AACvB;AAEA,MAAM,uBAAuB;AAAA,EAC3B;AAAA,IACE,MAAM;AAAA,IACN,SAAS;AAAA,EAAA;AAEb;AAYO,MAAM,qBAAqB,CAIhC,SACA,EAAE,MAAM,MAAA,IAA6B,OAErC,8BAA8B,EAAE,IAAA,CAAK,MAAM,QACvC,cAAiC;AAAA,EAC/B,UAAU;AAAA,EACV,aAAa;AAAA,EACb;AAAA,EACA;AAAA,EACA,GAAG;AACL,CAAC,IACD,mBAAsC;AAAA,EACpC,UAAU;AAAA,EACV,aAAa;AAAA,EACb;AAAA,EACA;AAAA,EACA,GAAG;AACL,CAAC;"}