@athenaintel/react 0.41.3 → 0.42.1

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

@@ -0,0 +1,74 @@
+import type { StatewireClient } from 'statewire';
+/**
+ * Allocation-light lifecycle recorder for the deep-agent statewire transport.
+ *
+ * `useDeepAgentThread` feeds it from the seams it already owns — the raw
+ * connection each converter pass, every command-lifecycle update, transport
+ * errors, and stale-auth header resolves — and it distills them into a small
+ * ring buffer of transition events:
+ *
+ * - `connection/dialing` · `connection/connected` (with attach latency + attempts)
+ * - `connection/retrying` (cause, attempt, lastError) · `connection/gone` · `connection/idle` · `connection/deferred`
+ * - `command/settled` (fate: `durable` or the failure fate, with settle latency)
+ * - `auth/stale-renewal` (a header resolve forced by a refused credential)
+ * - `transport/error`
+ *
+ * The recorder itself persists nothing: the host passes `onRecord` to mirror
+ * entries into its own persistence (Olympus wires it into the persisted
+ * diagnostics framework). Hosts should only construct one when their
+ * diagnostics channel is enabled — an absent recorder costs a single optional
+ * call at each seam. When present, the hot paths (`observeConnection` runs on
+ * every converter pass) compare plain fields and allocate only on an actual
+ * transition.
+ */
+export interface StatewireDiagnosticsEntry {
+    /** ms since page navigation start (`performance.now()`), or epoch ms fallback. */
+    at: number;
+    event: string;
+    data?: Record<string, unknown>;
+}
+/** The command-lifecycle fields the recorder reads; structural subset of `Statewire.CommandUpdate`. */
+export interface StatewireDiagnosticsCommandUpdate {
+    method: string;
+    /** The wire statement's params (a run send carries its message first). */
+    params?: readonly unknown[];
+    seq: number;
+    status: 'queued' | 'posted' | 'applied' | 'settled';
+    failure?: {
+        fate: string;
+        cause?: string;
+        code?: string;
+        message?: string;
+    };
+}
+export interface StatewireDiagnosticsRecorderOptions {
+    /** Ring-buffer capacity; oldest entries are overwritten. */
+    maxEntries?: number;
+    /** Injectable clock (tests). Defaults to `performance.now()`. */
+    now?: () => number;
+    /** Persistence sink, invoked once per recorded entry (exceptions swallowed). */
+    onRecord?: (entry: StatewireDiagnosticsEntry) => void;
+}
+export interface StatewireDiagnosticsRecorder {
+    /** Record an arbitrary host event (outbox replays, boundary crashes, …). */
+    record(event: string, data?: Record<string, unknown>): void;
+    /**
+     * Fold a connection into the transition log; call as often as you like —
+     * unchanged states are free. Takes the raw statewire connection so any host
+     * observer can feed it, and reads it only through
+     * `projectDeepAgentConnection` — the one seam over the wire vocabulary.
+     */
+    observeConnection(connection: StatewireClient.ConnectionState): void;
+    /** Fold a command-lifecycle update; records settle fates with latency. */
+    observeCommand(update: StatewireDiagnosticsCommandUpdate): void;
+    /** Fold a headers resolve; records only stale-auth renewals. */
+    observeAuthResolve(ctx: {
+        staleAuth: boolean;
+    }): void;
+    /** Record a transport error surfaced through `onError`. */
+    observeError(error: unknown): void;
+    /** Entries in arrival order (oldest first). */
+    getEntries(): StatewireDiagnosticsEntry[];
+    clear(): void;
+}
+export declare function createStatewireDiagnosticsRecorder(options?: StatewireDiagnosticsRecorderOptions): StatewireDiagnosticsRecorder;

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

@@ -0,0 +1,29 @@
+import type { DeepAgentStreamValues } from './types';
+export declare const DEEP_AGENT_PRE_STREAM_STATE: DeepAgentStreamValues;
+/**
+ * Read the deep-agent stream values off a raw statewire state, substituting
+ * {@link DEEP_AGENT_PRE_STREAM_STATE} while the state is not an object yet
+ * (pre-attach, or a replay boundary republishing `undefined`).
+ *
+ * Identity-preserving: a hydrated state returns the same object reference it
+ * was given and the pre-stream branch always returns the same module constant,
+ * so this is safe to call inside `useStatewireState` selectors.
+ */
+export declare function readDeepAgentStreamValues(state: unknown): DeepAgentStreamValues;
+/**
+ * Whether a state (raw, or already normalized through
+ * {@link readDeepAgentStreamValues}) carries a real wire payload. `false`
+ * exactly while the pre-stream default stands in — the explicit signal for
+ * code that must distinguish "empty thread" from "no snapshot yet".
+ */
+export declare function isDeepAgentStateHydrated(state: unknown): boolean;
+/** Record that `threadId`'s attach produced `state` (the converter's output). */
+export declare function pairDeepAgentStateWithThread({ state, threadId, }: {
+    state: object;
+    threadId: string;
+}): void;
+/**
+ * The thread whose attach produced `state`, or `null` for a state no deep-agent
+ * converter published (the pre-stream default, a state built elsewhere).
+ */
+export declare function readDeepAgentStateThreadId(state: unknown): string | null;

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

@@ -1 +1 @@
-{"version":3,"file":"statewire-suspended.cjs","sources":["../../../../agent-runtime/src/statewire-suspended.ts"],"sourcesContent":["import { resource } from '@assistant-ui/tap';\nimport type { ResourceElement } from '@assistant-ui/tap';\nimport { useRef, useState } from 'react';\nimport type { Statewire, StatewireClient } from 'statewire';\nimport { StatewireSendError } from 'statewire';\n\nexport interface SuspendedStatewireOptions {\n  /** Why the transport is parked; surfaced as the connection message. */\n  message: string;\n  /**\n   * Invoked when a surface asks the parked connection to `reconnect()` (the\n   * connection indicator's retry affordance). Hosts that park for a reason\n   * only they can clear (e.g. the user has no workspace) omit it.\n   */\n  onReconnectRequested?: (() => void) | undefined;\n}\n\nconst suspendedCommands = <\n  TCommands extends Statewire.Commands,\n>(): Statewire.CommandsProxy<TCommands> =>\n  new Proxy({} as Statewire.CommandsProxy<TCommands>, {\n    get: (_target, method) => {\n      if (typeof method !== 'string') return undefined;\n      // Settle like a locally-dead channel: hosts already classify\n      // non-\"server\" causes as channel teardown (quiet log, no user error).\n      return () =>\n        Promise.reject(new StatewireSendError({ fate: 'aborted', cause: 'stream-gone' }));\n    },\n  });\n\nconst useSuspendedStatewire = <TCommands extends Statewire.Commands = Statewire.Commands>(\n  options: SuspendedStatewireOptions\n): Statewire<undefined, TCommands> => {\n  const latest = useRef(options);\n  latest.current = options;\n  // `state` stays undefined so the thread keeps serving its `initialState`\n  // (the same contract a live transport has before its attach snapshot).\n  const [value] = useState((): Statewire<undefined, TCommands> => {\n    const connection: StatewireClient.Connection & { readonly message: string } = {\n      status: 'standby',\n      reason: 'deferred',\n      get message() {\n        return latest.current.message;\n      },\n      reconnect: () => latest.current.onReconnectRequested?.(),\n      degraded: false,\n    };\n    return {\n      state: undefined,\n      commands: suspendedCommands<TCommands>(),\n      connection,\n      // Context updates while parked are local and must never start a dial.\n      // The live transport receives the current snapshot when it replaces us.\n      setContext: () => {},\n      isBusy: false,\n    };\n  });\n  return value;\n};\n\n/**\n * A statewire transport that never dials.\n *\n * Swapped in for the live WS/SSE transport when attaching is known to be\n * pointless — the host gates it (no workspace) or repeated `unauthorized`\n * denials parked it — so the thread element stays mounted for assistant-ui\n * consumers while the reconnect loop stops entirely.\n */\nexport const StatewireSuspended = resource(useSuspendedStatewire) as <\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: SuspendedStatewireOptions\n) => ResourceElement<Statewire<undefined, TCommands>>;\n"],"names":["StatewireSendError","useRef","useState","resource"],"mappings":";;;;;AAiBA,MAAM,oBAAoB,MAGxB,IAAI,MAAM,IAA0C;AAAA,EAClD,KAAK,CAAC,SAAS,WAAW;AACxB,QAAI,OAAO,WAAW,SAAU,QAAO;AAGvC,WAAO,MACL,QAAQ,OAAO,IAAIA,UAAAA,mBAAmB,EAAE,MAAM,WAAW,OAAO,cAAA,CAAe,CAAC;AAAA,EACpF;AACF,CAAC;AAEH,MAAM,wBAAwB,CAC5B,YACoC;AACpC,QAAM,SAASC,MAAAA,OAAO,OAAO;AAC7B,SAAO,UAAU;AAGjB,QAAM,CAAC,KAAK,IAAIC,MAAAA,SAAS,MAAuC;AAC9D,UAAM,aAAwE;AAAA,MAC5E,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,IAAI,UAAU;AACZ,eAAO,OAAO,QAAQ;AAAA,MACxB;AAAA,MACA,WAAW,MAAA;;AAAM,kCAAO,SAAQ,yBAAf;AAAA;AAAA,MACjB,UAAU;AAAA,IAAA;AAEZ,WAAO;AAAA,MACL,OAAO;AAAA,MACP,UAAU,kBAAA;AAAA,MACV;AAAA;AAAA;AAAA,MAGA,YAAY,MAAM;AAAA,MAAC;AAAA,MACnB,QAAQ;AAAA,IAAA;AAAA,EAEZ,CAAC;AACD,SAAO;AACT;AAUO,MAAM,qBAAqBC,IAAAA,SAAS,qBAAqB;;"}
+{"version":3,"file":"statewire-suspended.cjs","sources":["../../../../agent-runtime/src/statewire-suspended.ts"],"sourcesContent":["import { resource } from '@assistant-ui/tap';\nimport type { ResourceElement } from '@assistant-ui/tap';\nimport { useRef, useState } from 'react';\nimport type { Statewire, StatewireClient } from 'statewire';\nimport { StatewireSendError } from 'statewire';\n\nexport interface SuspendedStatewireOptions {\n  /**\n   * Why the transport is parked; surfaced as the connection message. Omitted\n   * for a park that is part of normal startup rather than a refusal (a\n   * `pending` session lane, whose principal is still loading): the connection\n   * then carries no message and reads like a never-started chat, which hosts\n   * render as ready rather than paused.\n   */\n  message?: string | undefined;\n  /**\n   * Invoked when a surface asks the parked connection to `reconnect()` (the\n   * connection indicator's retry affordance). Hosts that park for a reason\n   * only they can clear (e.g. the user has no workspace) omit it.\n   */\n  onReconnectRequested?: (() => void) | undefined;\n}\n\nconst suspendedCommands = <\n  TCommands extends Statewire.Commands,\n>(): Statewire.CommandsProxy<TCommands> =>\n  new Proxy({} as Statewire.CommandsProxy<TCommands>, {\n    get: (_target, method) => {\n      if (typeof method !== 'string') return undefined;\n      // Settle like a locally-dead channel: hosts already classify\n      // non-\"server\" causes as channel teardown (quiet log, no user error).\n      return () =>\n        Promise.reject(new StatewireSendError({ fate: 'aborted', cause: 'stream-gone' }));\n    },\n  });\n\nconst useSuspendedStatewire = <TCommands extends Statewire.Commands = Statewire.Commands>(\n  options: SuspendedStatewireOptions\n): Statewire<undefined, TCommands> => {\n  const latest = useRef(options);\n  latest.current = options;\n  // `state` stays undefined so the thread keeps serving its `initialState`\n  // (the same contract a live transport has before its attach snapshot).\n  const [value] = useState((): Statewire<undefined, TCommands> => {\n    const connection: StatewireClient.Connection & { readonly message: string | undefined } = {\n      status: 'standby',\n      reason: 'deferred',\n      get message() {\n        return latest.current.message;\n      },\n      reconnect: () => latest.current.onReconnectRequested?.(),\n      degraded: false,\n    };\n    return {\n      state: undefined,\n      commands: suspendedCommands<TCommands>(),\n      connection,\n      // Context updates while parked are local and must never start a dial.\n      // The live transport receives the current snapshot when it replaces us.\n      setContext: () => {},\n      isBusy: false,\n    };\n  });\n  return value;\n};\n\n/**\n * A statewire transport that never dials.\n *\n * Swapped in for the live WS/SSE transport when attaching is known to be\n * pointless — the host gates it (no workspace) or repeated `unauthorized`\n * denials parked it — so the thread element stays mounted for assistant-ui\n * consumers while the reconnect loop stops entirely.\n */\nexport const StatewireSuspended = resource(useSuspendedStatewire) as <\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: SuspendedStatewireOptions\n) => ResourceElement<Statewire<undefined, TCommands>>;\n"],"names":["StatewireSendError","useRef","useState","resource"],"mappings":";;;;;AAuBA,MAAM,oBAAoB,MAGxB,IAAI,MAAM,IAA0C;AAAA,EAClD,KAAK,CAAC,SAAS,WAAW;AACxB,QAAI,OAAO,WAAW,SAAU,QAAO;AAGvC,WAAO,MACL,QAAQ,OAAO,IAAIA,UAAAA,mBAAmB,EAAE,MAAM,WAAW,OAAO,cAAA,CAAe,CAAC;AAAA,EACpF;AACF,CAAC;AAEH,MAAM,wBAAwB,CAC5B,YACoC;AACpC,QAAM,SAASC,MAAAA,OAAO,OAAO;AAC7B,SAAO,UAAU;AAGjB,QAAM,CAAC,KAAK,IAAIC,MAAAA,SAAS,MAAuC;AAC9D,UAAM,aAAoF;AAAA,MACxF,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,IAAI,UAAU;AACZ,eAAO,OAAO,QAAQ;AAAA,MACxB;AAAA,MACA,WAAW,MAAA;;AAAM,kCAAO,SAAQ,yBAAf;AAAA;AAAA,MACjB,UAAU;AAAA,IAAA;AAEZ,WAAO;AAAA,MACL,OAAO;AAAA,MACP,UAAU,kBAAA;AAAA,MACV;AAAA;AAAA;AAAA,MAGA,YAAY,MAAM;AAAA,MAAC;AAAA,MACnB,QAAQ;AAAA,IAAA;AAAA,EAEZ,CAAC;AACD,SAAO;AACT;AAUO,MAAM,qBAAqBC,IAAAA,SAAS,qBAAqB;;"}

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

@@ -0,0 +1,27 @@
+import type { ResourceElement } from '@assistant-ui/tap';
+import type { Statewire } from 'statewire';
+export interface SuspendedStatewireOptions {
+    /**
+     * Why the transport is parked; surfaced as the connection message. Omitted
+     * for a park that is part of normal startup rather than a refusal (a
+     * `pending` session lane, whose principal is still loading): the connection
+     * then carries no message and reads like a never-started chat, which hosts
+     * render as ready rather than paused.
+     */
+    message?: string | undefined;
+    /**
+     * Invoked when a surface asks the parked connection to `reconnect()` (the
+     * connection indicator's retry affordance). Hosts that park for a reason
+     * only they can clear (e.g. the user has no workspace) omit it.
+     */
+    onReconnectRequested?: (() => void) | undefined;
+}
+/**
+ * A statewire transport that never dials.
+ *
+ * Swapped in for the live WS/SSE transport when attaching is known to be
+ * pointless — the host gates it (no workspace) or repeated `unauthorized`
+ * denials parked it — so the thread element stays mounted for assistant-ui
+ * consumers while the reconnect loop stops entirely.
+ */
+export declare const StatewireSuspended: <TCommands extends Statewire.Commands = Statewire.Commands>(options: SuspendedStatewireOptions) => ResourceElement<Statewire<undefined, TCommands>>;

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

@@ -1 +1 @@
-{"version":3,"file":"statewire-suspended.js","sources":["../../../../agent-runtime/src/statewire-suspended.ts"],"sourcesContent":["import { resource } from '@assistant-ui/tap';\nimport type { ResourceElement } from '@assistant-ui/tap';\nimport { useRef, useState } from 'react';\nimport type { Statewire, StatewireClient } from 'statewire';\nimport { StatewireSendError } from 'statewire';\n\nexport interface SuspendedStatewireOptions {\n  /** Why the transport is parked; surfaced as the connection message. */\n  message: string;\n  /**\n   * Invoked when a surface asks the parked connection to `reconnect()` (the\n   * connection indicator's retry affordance). Hosts that park for a reason\n   * only they can clear (e.g. the user has no workspace) omit it.\n   */\n  onReconnectRequested?: (() => void) | undefined;\n}\n\nconst suspendedCommands = <\n  TCommands extends Statewire.Commands,\n>(): Statewire.CommandsProxy<TCommands> =>\n  new Proxy({} as Statewire.CommandsProxy<TCommands>, {\n    get: (_target, method) => {\n      if (typeof method !== 'string') return undefined;\n      // Settle like a locally-dead channel: hosts already classify\n      // non-\"server\" causes as channel teardown (quiet log, no user error).\n      return () =>\n        Promise.reject(new StatewireSendError({ fate: 'aborted', cause: 'stream-gone' }));\n    },\n  });\n\nconst useSuspendedStatewire = <TCommands extends Statewire.Commands = Statewire.Commands>(\n  options: SuspendedStatewireOptions\n): Statewire<undefined, TCommands> => {\n  const latest = useRef(options);\n  latest.current = options;\n  // `state` stays undefined so the thread keeps serving its `initialState`\n  // (the same contract a live transport has before its attach snapshot).\n  const [value] = useState((): Statewire<undefined, TCommands> => {\n    const connection: StatewireClient.Connection & { readonly message: string } = {\n      status: 'standby',\n      reason: 'deferred',\n      get message() {\n        return latest.current.message;\n      },\n      reconnect: () => latest.current.onReconnectRequested?.(),\n      degraded: false,\n    };\n    return {\n      state: undefined,\n      commands: suspendedCommands<TCommands>(),\n      connection,\n      // Context updates while parked are local and must never start a dial.\n      // The live transport receives the current snapshot when it replaces us.\n      setContext: () => {},\n      isBusy: false,\n    };\n  });\n  return value;\n};\n\n/**\n * A statewire transport that never dials.\n *\n * Swapped in for the live WS/SSE transport when attaching is known to be\n * pointless — the host gates it (no workspace) or repeated `unauthorized`\n * denials parked it — so the thread element stays mounted for assistant-ui\n * consumers while the reconnect loop stops entirely.\n */\nexport const StatewireSuspended = resource(useSuspendedStatewire) as <\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: SuspendedStatewireOptions\n) => ResourceElement<Statewire<undefined, TCommands>>;\n"],"names":[],"mappings":";;;AAiBA,MAAM,oBAAoB,MAGxB,IAAI,MAAM,IAA0C;AAAA,EAClD,KAAK,CAAC,SAAS,WAAW;AACxB,QAAI,OAAO,WAAW,SAAU,QAAO;AAGvC,WAAO,MACL,QAAQ,OAAO,IAAI,mBAAmB,EAAE,MAAM,WAAW,OAAO,cAAA,CAAe,CAAC;AAAA,EACpF;AACF,CAAC;AAEH,MAAM,wBAAwB,CAC5B,YACoC;AACpC,QAAM,SAAS,OAAO,OAAO;AAC7B,SAAO,UAAU;AAGjB,QAAM,CAAC,KAAK,IAAI,SAAS,MAAuC;AAC9D,UAAM,aAAwE;AAAA,MAC5E,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,IAAI,UAAU;AACZ,eAAO,OAAO,QAAQ;AAAA,MACxB;AAAA,MACA,WAAW,MAAA;;AAAM,kCAAO,SAAQ,yBAAf;AAAA;AAAA,MACjB,UAAU;AAAA,IAAA;AAEZ,WAAO;AAAA,MACL,OAAO;AAAA,MACP,UAAU,kBAAA;AAAA,MACV;AAAA;AAAA;AAAA,MAGA,YAAY,MAAM;AAAA,MAAC;AAAA,MACnB,QAAQ;AAAA,IAAA;AAAA,EAEZ,CAAC;AACD,SAAO;AACT;AAUO,MAAM,qBAAqB,SAAS,qBAAqB;"}
+{"version":3,"file":"statewire-suspended.js","sources":["../../../../agent-runtime/src/statewire-suspended.ts"],"sourcesContent":["import { resource } from '@assistant-ui/tap';\nimport type { ResourceElement } from '@assistant-ui/tap';\nimport { useRef, useState } from 'react';\nimport type { Statewire, StatewireClient } from 'statewire';\nimport { StatewireSendError } from 'statewire';\n\nexport interface SuspendedStatewireOptions {\n  /**\n   * Why the transport is parked; surfaced as the connection message. Omitted\n   * for a park that is part of normal startup rather than a refusal (a\n   * `pending` session lane, whose principal is still loading): the connection\n   * then carries no message and reads like a never-started chat, which hosts\n   * render as ready rather than paused.\n   */\n  message?: string | undefined;\n  /**\n   * Invoked when a surface asks the parked connection to `reconnect()` (the\n   * connection indicator's retry affordance). Hosts that park for a reason\n   * only they can clear (e.g. the user has no workspace) omit it.\n   */\n  onReconnectRequested?: (() => void) | undefined;\n}\n\nconst suspendedCommands = <\n  TCommands extends Statewire.Commands,\n>(): Statewire.CommandsProxy<TCommands> =>\n  new Proxy({} as Statewire.CommandsProxy<TCommands>, {\n    get: (_target, method) => {\n      if (typeof method !== 'string') return undefined;\n      // Settle like a locally-dead channel: hosts already classify\n      // non-\"server\" causes as channel teardown (quiet log, no user error).\n      return () =>\n        Promise.reject(new StatewireSendError({ fate: 'aborted', cause: 'stream-gone' }));\n    },\n  });\n\nconst useSuspendedStatewire = <TCommands extends Statewire.Commands = Statewire.Commands>(\n  options: SuspendedStatewireOptions\n): Statewire<undefined, TCommands> => {\n  const latest = useRef(options);\n  latest.current = options;\n  // `state` stays undefined so the thread keeps serving its `initialState`\n  // (the same contract a live transport has before its attach snapshot).\n  const [value] = useState((): Statewire<undefined, TCommands> => {\n    const connection: StatewireClient.Connection & { readonly message: string | undefined } = {\n      status: 'standby',\n      reason: 'deferred',\n      get message() {\n        return latest.current.message;\n      },\n      reconnect: () => latest.current.onReconnectRequested?.(),\n      degraded: false,\n    };\n    return {\n      state: undefined,\n      commands: suspendedCommands<TCommands>(),\n      connection,\n      // Context updates while parked are local and must never start a dial.\n      // The live transport receives the current snapshot when it replaces us.\n      setContext: () => {},\n      isBusy: false,\n    };\n  });\n  return value;\n};\n\n/**\n * A statewire transport that never dials.\n *\n * Swapped in for the live WS/SSE transport when attaching is known to be\n * pointless — the host gates it (no workspace) or repeated `unauthorized`\n * denials parked it — so the thread element stays mounted for assistant-ui\n * consumers while the reconnect loop stops entirely.\n */\nexport const StatewireSuspended = resource(useSuspendedStatewire) as <\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: SuspendedStatewireOptions\n) => ResourceElement<Statewire<undefined, TCommands>>;\n"],"names":[],"mappings":";;;AAuBA,MAAM,oBAAoB,MAGxB,IAAI,MAAM,IAA0C;AAAA,EAClD,KAAK,CAAC,SAAS,WAAW;AACxB,QAAI,OAAO,WAAW,SAAU,QAAO;AAGvC,WAAO,MACL,QAAQ,OAAO,IAAI,mBAAmB,EAAE,MAAM,WAAW,OAAO,cAAA,CAAe,CAAC;AAAA,EACpF;AACF,CAAC;AAEH,MAAM,wBAAwB,CAC5B,YACoC;AACpC,QAAM,SAAS,OAAO,OAAO;AAC7B,SAAO,UAAU;AAGjB,QAAM,CAAC,KAAK,IAAI,SAAS,MAAuC;AAC9D,UAAM,aAAoF;AAAA,MACxF,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,IAAI,UAAU;AACZ,eAAO,OAAO,QAAQ;AAAA,MACxB;AAAA,MACA,WAAW,MAAA;;AAAM,kCAAO,SAAQ,yBAAf;AAAA;AAAA,MACjB,UAAU;AAAA,IAAA;AAEZ,WAAO;AAAA,MACL,OAAO;AAAA,MACP,UAAU,kBAAA;AAAA,MACV;AAAA;AAAA;AAAA,MAGA,YAAY,MAAM;AAAA,MAAC;AAAA,MACnB,QAAQ;AAAA,IAAA;AAAA,EAEZ,CAAC;AACD,SAAO;AACT;AAUO,MAAM,qBAAqB,SAAS,qBAAqB;"}

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

@@ -0,0 +1,40 @@
+import { type Statewire, type StatewireClient } from 'statewire';
+import type { DeepAgentStreamValues } from './types';
+export type StatewireTransportOptions = StatewireClient.HttpOptions & StatewireClient.WebsocketOptions;
+/**
+ * The application protocol the deep-agent transport stamps on every command.
+ * The thread client must declare the same protocol: statewire's core applies
+ * its optimistic folds only to commands of its own protocol, so a mismatch
+ * 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.
+ */
+export declare const DEEP_AGENT_STATEWIRE_WIRE_VERSION: NonNullable<StatewireTransportOptions['wireVersion']>;
+export type StatewireTransportKind = 'sse' | 'websocket';
+/**
+ * The transport a host gets: SSE when it asks for SSE, WebSocket otherwise.
+ * Whatever instruments the transport must read this too, so it matches the
+ * transport actually built.
+ */
+export declare function resolveStatewireTransportKind({ sse }: {
+    sse: boolean;
+}): StatewireTransportKind;
+/**
+ * Build the deep-agent statewire transport: WebSocket by default, SSE when the
+ * host app's toggle asks for it ({@link resolveStatewireTransportKind}). The
+ * toggle source is host-specific (env var, extension flag, config store), so
+ * the caller resolves it to a boolean.
+ *
+ * `TState` defaults to the deep-agent wire shape: the thread mounts that make
+ * up nearly every caller get a typed state without naming it, and the other
+ * mounts (the conversation index) name theirs.
+ */
+export declare const statewireTransport: <TState = DeepAgentStreamValues, TCommands extends Statewire.Commands = Statewire.Commands>(options: StatewireTransportOptions, { sse }?: {
+    sse?: boolean;
+}) => import("@assistant-ui/tap").ResourceElement<Statewire<TState | undefined, TCommands>>;

package/dist/agent-runtime/src/streaming-markdown.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Hide a markdown link the stream has not finished writing.
+ *
+ * The agent mentions and cites assets as markdown links —
+ * `[@Considerations/Notes](https://…/dashboard/spaces/?asset_ids=asset_…&type=document&anchor=pm_node&node_id=…&excerpt=…)`
+ * — which every chat surface renders as a mention chip once the link is
+ * complete. While it is still arriving, a markdown parser sees a bracketed
+ * label followed by a bare URL: the label shows as raw text and the half URL
+ * linkifies into a live link whose target changes with every batch, for as
+ * long as the destination takes to stream (an `excerpt` parameter can run to
+ * hundreds of characters). Then the closing `)` lands and the run is rebuilt
+ * as a chip.
+ *
+ * While a part is streaming, cut the text at the start of a trailing link
+ * whose `)` has not arrived; it reappears whole, as a chip, in the batch that
+ * closes it. Every link and image destination is held — a web citation
+ * flickers the same way — and so is every bracket still undecided on the
+ * line: an unfinished `[label`, and a closed `[label]` at the very end of the
+ * text, which waits one batch for its `(`. Holding the label too is what
+ * makes the visible text only ever grow — a link never shows as a label and
+ * then retracts when its destination starts — and that append-only property
+ * is what keeps Olympus's incremental streaming apply on its cheap path.
+ * Brackets match innermost-first, as CommonMark does, and the hold starts at
+ * the outermost undecided bracket the size bound allows, so an unmatched
+ * bracket in prose hides at most a phrase, briefly, and never masks a later
+ * mention. A construct that crosses a line break or runs past its bound is
+ * released so a malformed link cannot hide the rest of the message; fenced
+ * code (including fences inside blockquotes), indented code and inline code
+ * are left untouched; and settled text is never passed through this
+ * function, so a link the model genuinely left open shows raw once the part
+ * completes.
+ *
+ * Shared by every chat surface (Olympus, the React SDK hosts, mobile) so the
+ * hold behaves identically wherever a transcript streams. Pure string work,
+ * linear in the text.
+ */
+/** An open bracket further back than this is prose, not a label being streamed. */
+export declare const UNTERMINATED_LABEL_HOLD_LIMIT = 200;
+/** A link (label and destination) longer than this is broken, not streaming. */
+export declare const UNTERMINATED_LINK_HOLD_LIMIT = 1500;
+/**
+ * The streamed text with a trailing, still-undecided markdown link or image
+ * removed. Text without such a construct is returned as is, and the result is
+ * always a prefix of `text`.
+ */
+export declare function hideUnterminatedMarkdownLink(text: string): string;

package/dist/agent-runtime/src/subagent-transcripts.cjs

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("@assistant-ui/core/react");
+const runconfigContract = require("./generated/runconfig-contract.cjs");
+const messageText = require("./message-text.cjs");
+const messages = require("./messages.cjs");
+const toolNames = require("./tool-names.cjs");
+function laneTranscriptOf(artifact) {
+  if (typeof artifact !== "object" || artifact === null) return void 0;
+  const state = artifact.subgraph_state;
+  if (typeof state !== "object" || state === null) return void 0;
+  const messages2 = state.messages;
+  return Array.isArray(messages2) ? messages2 : void 0;
+}
+const restoredTranscripts = /* @__PURE__ */ new WeakMap();
+function withRepeatedResult(transcript, content) {
+  const last = transcript[transcript.length - 1];
+  if (last === void 0 || last[runconfigContract.DEEP_AGENT_REPEATS_RESULT_KEY] !== true || typeof content !== "string" && !Array.isArray(content)) {
+    return transcript;
+  }
+  const cached = restoredTranscripts.get(transcript);
+  if (cached !== void 0 && cached.content === content) return cached.transcript;
+  const restored = [...transcript.slice(0, -1), { ...last, content }];
+  restoredTranscripts.set(transcript, { content, transcript: restored });
+  return restored;
+}
+const convertibleChunkTurns = /* @__PURE__ */ new WeakMap();
+function asConvertibleTurn(message) {
+  const type = message.type;
+  if (type !== "AIMessageChunk") return message;
+  const cached = convertibleChunkTurns.get(message);
+  if (cached !== void 0) return cached;
+  const turn = { ...message, type: "ai" };
+  convertibleChunkTurns.set(message, turn);
+  return turn;
+}
+function answeringTurn(step) {
+  var _a;
+  const turn = asConvertibleTurn(step);
+  return turn.type === "ai" && (((_a = turn.tool_calls) == null ? void 0 : _a.length) ?? 0) === 0 ? turn : null;
+}
+const isTextBlock = (block) => typeof block === "object" && block !== null && "type" in block && block.type === "text";
+function shownText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let text = "";
+  for (const block of content) {
+    if (isTextBlock(block) && typeof block.text === "string") text += block.text;
+  }
+  return text;
+}
+function blankTurn(step) {
+  const turn = answeringTurn(step);
+  if (turn === null || shownText(turn.content).trim() !== "") return null;
+  return typeof turn.content === "string" || turn.content.every(isTextBlock) ? turn : null;
+}
+const reportedLanes = /* @__PURE__ */ new WeakMap();
+function withLaneReport(transcript, report) {
+  if (report === void 0 || report.trim() === "" || transcript.length === 0) return transcript;
+  let at = transcript.length - 1;
+  let closing = transcript[at];
+  while (closing !== void 0 && blankTurn(closing) !== null) {
+    at -= 1;
+    closing = transcript[at];
+  }
+  const answered = closing !== void 0 && answeringTurn(closing) !== null && shownText(closing.content).trim() !== "";
+  if (answered) return transcript;
+  const cached = reportedLanes.get(transcript);
+  if (cached !== void 0 && cached.report === report) return cached.transcript;
+  const last = transcript[transcript.length - 1];
+  const blank = last === void 0 ? null : blankTurn(last);
+  const closed = blank !== null ? [...transcript.slice(0, -1), { ...blank, content: report }] : [...transcript, { id: `${(last == null ? void 0 : last.id) ?? "lane"}:report`, type: "ai", content: report }];
+  reportedLanes.set(transcript, { report, transcript: closed });
+  return closed;
+}
+function transcriptSources(transcript) {
+  return messages.sanitizeLangChainMessages(transcript.map(asConvertibleTurn));
+}
+const reportedTranscripts = /* @__PURE__ */ new WeakSet();
+function reportUnconvertibleTranscript(transcript, error) {
+  if (reportedTranscripts.has(transcript)) return;
+  reportedTranscripts.add(transcript);
+  console.warn("[agent-runtime] a subagent transcript could not be converted", error);
+}
+function sameJson(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => sameJson(item, b[index]));
+  }
+  const left = a;
+  const right = b;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) && sameJson(left[key], right[key])
+  );
+}
+function steadyStepObjects() {
+  let held = /* @__PURE__ */ new Map();
+  return (transcript) => {
+    const next = /* @__PURE__ */ new Map();
+    let kept = false;
+    const steadied = transcript.map((entry) => {
+      const id = entry.id;
+      if (typeof id !== "string") return entry;
+      const before = held.get(id);
+      const step = before !== void 0 && sameJson(before, entry) ? before : entry;
+      next.set(id, step);
+      if (step !== entry) kept = true;
+      return step;
+    });
+    held = next;
+    return kept ? steadied : transcript;
+  };
+}
+function createSubagentLaneConversion() {
+  const memory = createSubagentTranscriptConversionCache();
+  const steady = steadyStepObjects();
+  let last = null;
+  return (transcript, running) => {
+    if (last !== null && last.transcript === transcript && last.running === running) {
+      return last.messages;
+    }
+    let messages2;
+    try {
+      messages2 = memory.convert(transcriptSources(steady(transcript)), running);
+    } catch (error) {
+      reportUnconvertibleTranscript(transcript, error);
+    }
+    last = { transcript, running, messages: messages2 };
+    return messages2;
+  };
+}
+function subagentTranscriptAttacher() {
+  const lanes = /* @__PURE__ */ new Map();
+  const attachedRows = /* @__PURE__ */ new WeakMap();
+  const attachedParts = /* @__PURE__ */ new WeakMap();
+  const laneMessages = (toolCallId, transcript, running) => {
+    let lane = lanes.get(toolCallId);
+    if (lane === void 0) {
+      lane = createSubagentLaneConversion();
+      lanes.set(toolCallId, lane);
+    }
+    return lane(transcript, running);
+  };
+  const attach = (row) => {
+    if (row.role !== "assistant") return row;
+    const cached = attachedRows.get(row);
+    if (cached !== void 0) return cached;
+    let content = null;
+    for (const [index, part] of row.content.entries()) {
+      if (part.type !== "tool-call" || part.toolName !== toolNames.TASK_TOOL_NAME) continue;
+      const nested = laneTranscriptOf(part.artifact);
+      if (nested === void 0) continue;
+      const running = part.isPreliminary === true;
+      const restored = withRepeatedResult(nested, part.result);
+      const transcript = running || part.isError === true ? restored : withLaneReport(restored, messageText.getMessageText({ content: part.result }));
+      const messages2 = laneMessages(part.toolCallId, transcript, running);
+      if (messages2 === void 0) continue;
+      const kept = attachedParts.get(part);
+      const attached = kept !== void 0 && kept.messages === messages2 ? kept.part : { ...part, messages: messages2 };
+      attachedParts.set(part, { messages: messages2, part: attached });
+      content ?? (content = [...row.content]);
+      content[index] = attached;
+    }
+    const attachedRow = content === null ? row : { ...row, content };
+    attachedRows.set(row, attachedRow);
+    return attachedRow;
+  };
+  return (rows) => {
+    const attached = rows.map(attach);
+    if (lanes.size === 0) return attached;
+    const held = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      if (row.role !== "assistant") continue;
+      for (const part of row.content) {
+        if (part.type !== "tool-call" || part.toolName !== toolNames.TASK_TOOL_NAME) continue;
+        held.add(part.toolCallId);
+      }
+    }
+    for (const toolCallId of lanes.keys()) {
+      if (!held.has(toolCallId)) lanes.delete(toolCallId);
+    }
+    return attached;
+  };
+}
+function createSubagentTranscriptConversionCache() {
+  const thread = messages.createDeepAgentMessageConversionCache();
+  const attach = subagentTranscriptAttacher();
+  let previousRows = null;
+  let previous = [];
+  return {
+    convert(messages2, isRunning) {
+      const rows = thread.convert(messages2, isRunning);
+      if (rows === previousRows) return previous;
+      previousRows = rows;
+      const next = attach(rows);
+      const unchanged = next.length === previous.length && next.every((row, index) => row === previous[index]);
+      if (!unchanged) previous = next;
+      return previous;
+    }
+  };
+}
+react.createExternalMessageConversionCache();
+exports.createSubagentLaneConversion = createSubagentLaneConversion;
+exports.createSubagentTranscriptConversionCache = createSubagentTranscriptConversionCache;
+exports.withLaneReport = withLaneReport;
+exports.withRepeatedResult = withRepeatedResult;
+//# sourceMappingURL=subagent-transcripts.cjs.map

package/dist/agent-runtime/src/subagent-transcripts.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-transcripts.cjs","sources":["../../../../agent-runtime/src/subagent-transcripts.ts"],"sourcesContent":["/**\n * A subagent's transcript as assistant-ui's native nested thread.\n *\n * The backend nests a `task` subagent's transcript in its card's ToolMessage,\n * at `artifact.subgraph_state.messages`: the newest steps on the running\n * placeholder, the whole transcript on the real result. The conversion cache\n * built here converts that transcript through the thread's own pipeline and\n * sets it as the `task` tool-call part's `messages`, assistant-ui's channel for\n * a tool call's nested conversation. `ReadonlyThreadProvider` (the provider\n * under `MessagePartPrimitive.Messages`) renders it as a read-only thread under\n * the parent's tool UIs, and `thread.tasks` derives child work from it.\n *\n * Hosts opt in (`useDeepAgentThread({ createConversionCache })`). It builds on\n * the shared conversion memory from outside, so the shared converter, which\n * ships in every surface's startup bundle (the Office pane's startup and total\n * budgets have no room to spare), stays as it is, and a surface that draws no\n * subagent transcript pays nothing for it.\n */\nimport type {\n  ThreadAssistantMessagePart,\n  ThreadMessage,\n  ToolCallMessagePart,\n} from '@assistant-ui/core';\nimport {\n  convertExternalMessages,\n  createExternalMessageConversionCache,\n} from '@assistant-ui/core/react';\nimport type { LangChainMessage } from '@assistant-ui/react-langgraph';\nimport { DEEP_AGENT_REPEATS_RESULT_KEY } from './generated/runconfig-contract';\nimport { getMessageText } from './message-text';\nimport {\n  convertDeepAgentLangChainMessage,\n  createDeepAgentMessageConversionCache,\n  type DeepAgentConversionMemory,\n  markPreliminaryToolResults,\n  sanitizeLangChainMessages,\n} from './messages';\nimport { TASK_TOOL_NAME } from './tool-names';\n\n/** The transcript nested on a `task` card's artifact, or `undefined` when it carries none. */\nfunction laneTranscriptOf(artifact: unknown): readonly LangChainMessage[] | undefined {\n  if (typeof artifact !== 'object' || artifact === null) return undefined;\n  const state: unknown = (artifact as { subgraph_state?: unknown }).subgraph_state;\n  if (typeof state !== 'object' || state === null) return undefined;\n  const messages: unknown = (state as { messages?: unknown }).messages;\n  return Array.isArray(messages) ? (messages as LangChainMessage[]) : undefined;\n}\n\nconst restoredTranscripts = new WeakMap<\n  readonly LangChainMessage[],\n  { readonly content: unknown; readonly transcript: readonly LangChainMessage[] }\n>();\n\n/**\n * A card's nested transcript with its report restored. On a cut finished card\n * the last step can ride with empty content and `DEEP_AGENT_REPEATS_RESULT_KEY`:\n * its text is the subagent's report, the card's own `content`, which the card\n * carries anyway. The step gets that content back. Any other transcript comes\n * back as it is. Memoized per transcript, so a lane's conversion sees one array.\n */\nexport function withRepeatedResult(\n  transcript: readonly LangChainMessage[],\n  content: unknown\n): readonly LangChainMessage[] {\n  const last = transcript[transcript.length - 1];\n  if (\n    last === undefined ||\n    (last as Record<string, unknown>)[DEEP_AGENT_REPEATS_RESULT_KEY] !== true ||\n    (typeof content !== 'string' && !Array.isArray(content))\n  ) {\n    return transcript;\n  }\n  const cached = restoredTranscripts.get(transcript);\n  if (cached !== undefined && cached.content === content) return cached.transcript;\n  const restored = [...transcript.slice(0, -1), { ...last, content } as LangChainMessage];\n  restoredTranscripts.set(transcript, { content, transcript: restored });\n  return restored;\n}\n\ntype AssistantLangChainMessage = Extract<LangChainMessage, { type: 'ai' }>;\n\nconst convertibleChunkTurns = new WeakMap<LangChainMessage, LangChainMessage>();\n\n/**\n * A nested assistant turn stored under the chunk class name (the legacy\n * assistant-stream fold keeps `AIMessageChunk`) as the `ai` message it is: the\n * shipped converter maps only `ai`, and would drop the turn.\n */\nfunction asConvertibleTurn(message: LangChainMessage): LangChainMessage {\n  const type: string = message.type;\n  if (type !== 'AIMessageChunk') return message;\n  const cached = convertibleChunkTurns.get(message);\n  if (cached !== undefined) return cached;\n  const turn: LangChainMessage = { ...(message as AssistantLangChainMessage), type: 'ai' };\n  convertibleChunkTurns.set(message, turn);\n  return turn;\n}\n\n/** A lane step as the assistant turn it is when it calls nothing; `null` for any other step. */\nfunction answeringTurn(step: LangChainMessage): AssistantLangChainMessage | null {\n  const turn = asConvertibleTurn(step);\n  return turn.type === 'ai' && (turn.tool_calls?.length ?? 0) === 0 ? turn : null;\n}\n\nconst isTextBlock = (block: unknown): block is { type: 'text'; text?: unknown } =>\n  typeof block === 'object' && block !== null && 'type' in block && block.type === 'text';\n\n/** The text a step's content shows: the string, or its text blocks joined. */\nfunction shownText(content: unknown): string {\n  if (typeof content === 'string') return content;\n  if (!Array.isArray(content)) return '';\n  let text = '';\n  for (const block of content) {\n    if (isTextBlock(block) && typeof block.text === 'string') text += block.text;\n  }\n  return text;\n}\n\n/** A turn that calls nothing and shows nothing: no text, and no block of another kind. */\nfunction blankTurn(step: LangChainMessage): AssistantLangChainMessage | null {\n  const turn = answeringTurn(step);\n  if (turn === null || shownText(turn.content).trim() !== '') return null;\n  return typeof turn.content === 'string' || turn.content.every(isTextBlock) ? turn : null;\n}\n\nconst reportedLanes = new WeakMap<\n  readonly LangChainMessage[],\n  { readonly report: string; readonly transcript: readonly LangChainMessage[] }\n>();\n\n/**\n * A finished lane's transcript, closed by its report. A `task` card's content\n * is its subagent's report, the text of the lane's last turn. A transcript\n * that ends on that turn (an assistant step that calls nothing and says\n * something, which {@link withRepeatedResult} restores when it rides marked)\n * comes back as it is, even when blank steps follow it. A lane stored without\n * it shows the report as its closing answer: a lane whose last step is a blank\n * assistant step (lanes that finished before the host marked a repeated\n * report) gets the report in that step, its id and stamps kept, and a lane\n * that ends on a tool result or a turn that calls tools gets a closing step\n * after its last one. An empty report or transcript changes nothing. For\n * display only: the wire and the stored lane are untouched. Memoized per\n * transcript, so a lane's conversion sees one array.\n */\nexport function withLaneReport(\n  transcript: readonly LangChainMessage[],\n  report: string | undefined\n): readonly LangChainMessage[] {\n  if (report === undefined || report.trim() === '' || transcript.length === 0) return transcript;\n  // The lane's closing turn: its last step past any blank ones.\n  let at = transcript.length - 1;\n  let closing = transcript[at];\n  while (closing !== undefined && blankTurn(closing) !== null) {\n    at -= 1;\n    closing = transcript[at];\n  }\n  const answered =\n    closing !== undefined &&\n    answeringTurn(closing) !== null &&\n    shownText(closing.content).trim() !== '';\n  if (answered) return transcript;\n  const cached = reportedLanes.get(transcript);\n  if (cached !== undefined && cached.report === report) return cached.transcript;\n  const last = transcript[transcript.length - 1];\n  const blank = last === undefined ? null : blankTurn(last);\n  const closed: readonly LangChainMessage[] =\n    blank !== null\n      ? [...transcript.slice(0, -1), { ...blank, content: report }]\n      : [...transcript, { id: `${last?.id ?? 'lane'}:report`, type: 'ai', content: report }];\n  reportedLanes.set(transcript, { report, transcript: closed });\n  return closed;\n}\n\n/** A nested transcript as the thread's own pipeline reads it (see {@link sanitizeLangChainMessages}). */\nfunction transcriptSources(transcript: readonly LangChainMessage[]): LangChainMessage[] {\n  return sanitizeLangChainMessages(transcript.map(asConvertibleTurn));\n}\n\nconst reportedTranscripts = new WeakSet<readonly LangChainMessage[]>();\n\n/**\n * A nested transcript the shipped converter refused (it throws on, e.g., a\n * result whose tool name differs from its call's): reported once, and its card\n * goes without a nested thread instead of taking the whole thread down.\n */\nfunction reportUnconvertibleTranscript(\n  transcript: readonly LangChainMessage[],\n  error: unknown\n): void {\n  if (reportedTranscripts.has(transcript)) return;\n  reportedTranscripts.add(transcript);\n  console.warn('[agent-runtime] a subagent transcript could not be converted', error);\n}\n\n/** Whether two values the wire carries (JSON: no functions, no cycles) are equal. */\nfunction sameJson(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;\n  if (Array.isArray(a) || Array.isArray(b)) {\n    return (\n      Array.isArray(a) &&\n      Array.isArray(b) &&\n      a.length === b.length &&\n      a.every((item, index) => sameJson(item, b[index]))\n    );\n  }\n  const left = a as Record<string, unknown>;\n  const right = b as Record<string, unknown>;\n  const keys = Object.keys(left);\n  return (\n    keys.length === Object.keys(right).length &&\n    keys.every(\n      (key) =>\n        Object.prototype.hasOwnProperty.call(right, key) && sameJson(left[key], right[key])\n    )\n  );\n}\n\n/**\n * Keeps a lane's unchanged steps as the objects it already converted. The host\n * replaces a card's whole document whenever the card changes, so every step it\n * carries arrives as a new object, and the conversion memory, which tells the\n * steps a turn continues by object, would see a new turn each time the card's\n * cut drops its oldest step and the turn's first step changes. A step whose id\n * and content are unchanged is the object held for that id. O(the steps' size).\n */\nfunction steadyStepObjects(): (\n  transcript: readonly LangChainMessage[]\n) => readonly LangChainMessage[] {\n  let held = new Map<string, LangChainMessage>();\n  return (transcript) => {\n    const next = new Map<string, LangChainMessage>();\n    let kept = false;\n    const steadied = transcript.map((entry) => {\n      const id = entry.id;\n      if (typeof id !== 'string') return entry;\n      const before = held.get(id);\n      const step = before !== undefined && sameJson(before, entry) ? before : entry;\n      next.set(id, step);\n      if (step !== entry) kept = true;\n      return step;\n    });\n    held = next;\n    return kept ? steadied : transcript;\n  };\n}\n\n/** One lane's transcript, converted: `undefined` when the converter refused it. */\nexport type SubagentLaneConversion = (\n  transcript: readonly LangChainMessage[],\n  running: boolean\n) => readonly ThreadMessage[] | undefined;\n\n/**\n * One `task` lane's own conversion memory, for whatever converts that lane:\n * its unchanged steps keep their converted objects while it streams (a step the\n * wire sends again unchanged included, see {@link steadyStepObjects}), and its\n * turn keeps its row key (`deepAgentRowKey`) and part keys when the turn's head\n * moves — the oldest steps of a cut card falling off as the lane runs, or older\n * steps a transcript drawer pages in. A surface that keeps its disclosures under\n * that key keeps them open through both. A transcript array converted last time\n * is not converted again.\n */\nexport function createSubagentLaneConversion(): SubagentLaneConversion {\n  const memory = createSubagentTranscriptConversionCache();\n  const steady = steadyStepObjects();\n  let last: {\n    readonly transcript: readonly LangChainMessage[];\n    readonly running: boolean;\n    readonly messages: readonly ThreadMessage[] | undefined;\n  } | null = null;\n  return (transcript, running) => {\n    if (last !== null && last.transcript === transcript && last.running === running) {\n      return last.messages;\n    }\n    let messages: readonly ThreadMessage[] | undefined;\n    try {\n      messages = memory.convert(transcriptSources(steady(transcript)), running);\n    } catch (error) {\n      reportUnconvertibleTranscript(transcript, error);\n    }\n    last = { transcript, running, messages };\n    return messages;\n  };\n}\n\n/**\n * Sets each `task` part of a pass's converted rows to carry its nested\n * transcript as `messages`, for one attach. Each lane has its own conversion\n * memory, so its unchanged steps keep their converted objects while it\n * streams, as the thread's own messages do, and a lane whose transcript array\n * did not change is not converted again. A row, and a part whose lane did not\n * change, keep their identity: the same row always comes back as the same\n * object. A lane's memory lives only while a row of the pass holds its `task`\n * call: a lane a rewind removes, a branch switch hides or the window leaves\n * behind is let go with its transcript, and converted afresh if it returns.\n */\nfunction subagentTranscriptAttacher(): (rows: readonly ThreadMessage[]) => ThreadMessage[] {\n  const lanes = new Map<string, SubagentLaneConversion>();\n  const attachedRows = new WeakMap<ThreadMessage, ThreadMessage>();\n  const attachedParts = new WeakMap<\n    ToolCallMessagePart,\n    { readonly messages: readonly ThreadMessage[]; readonly part: ToolCallMessagePart }\n  >();\n\n  const laneMessages = (\n    toolCallId: string,\n    transcript: readonly LangChainMessage[],\n    running: boolean\n  ): readonly ThreadMessage[] | undefined => {\n    let lane = lanes.get(toolCallId);\n    if (lane === undefined) {\n      lane = createSubagentLaneConversion();\n      lanes.set(toolCallId, lane);\n    }\n    return lane(transcript, running);\n  };\n\n  const attach = (row: ThreadMessage): ThreadMessage => {\n    if (row.role !== 'assistant') return row;\n    const cached = attachedRows.get(row);\n    if (cached !== undefined) return cached;\n    let content: ThreadAssistantMessagePart[] | null = null;\n    for (const [index, part] of row.content.entries()) {\n      if (part.type !== 'tool-call' || part.toolName !== TASK_TOOL_NAME) continue;\n      const nested = laneTranscriptOf(part.artifact);\n      if (nested === undefined) continue;\n      // A running lane's placeholder is preliminary: its newest nested turn streams.\n      const running = part.isPreliminary === true;\n      const restored = withRepeatedResult(nested, part.result);\n      const transcript =\n        running || part.isError === true\n          ? restored\n          : withLaneReport(restored, getMessageText({ content: part.result }));\n      const messages = laneMessages(part.toolCallId, transcript, running);\n      if (messages === undefined) continue;\n      const kept = attachedParts.get(part);\n      const attached =\n        kept !== undefined && kept.messages === messages ? kept.part : { ...part, messages };\n      attachedParts.set(part, { messages, part: attached });\n      content ??= [...row.content];\n      content[index] = attached;\n    }\n    const attachedRow: ThreadMessage = content === null ? row : { ...row, content };\n    attachedRows.set(row, attachedRow);\n    return attachedRow;\n  };\n\n  return (rows) => {\n    const attached = rows.map(attach);\n    if (lanes.size === 0) return attached;\n    const held = new Set<string>();\n    for (const row of rows) {\n      if (row.role !== 'assistant') continue;\n      for (const part of row.content) {\n        if (part.type !== 'tool-call' || part.toolName !== TASK_TOOL_NAME) continue;\n        held.add(part.toolCallId);\n      }\n    }\n    for (const toolCallId of lanes.keys()) {\n      if (!held.has(toolCallId)) lanes.delete(toolCallId);\n    }\n    return attached;\n  };\n}\n\n/**\n * A conversion memory for one attach (see\n * `useDeepAgentThread({ createConversionCache })`): the shared one's rows, with\n * each `task` tool-call part carrying its subagent's converted transcript as\n * `messages`. A pass that changes no row hands back the previous list itself.\n */\nexport function createSubagentTranscriptConversionCache(): DeepAgentConversionMemory {\n  const thread = createDeepAgentMessageConversionCache();\n  const attach = subagentTranscriptAttacher();\n  let previousRows: ThreadMessage[] | null = null;\n  let previous: ThreadMessage[] = [];\n  return {\n    convert(messages, isRunning) {\n      const rows = thread.convert(messages, isRunning);\n      if (rows === previousRows) return previous;\n      previousRows = rows;\n      const next = attach(rows);\n      const unchanged =\n        next.length === previous.length && next.every((row, index) => row === previous[index]);\n      if (!unchanged) previous = next;\n      return previous;\n    },\n  };\n}\n\n/**\n * Shared by every in-eval transcript: entries are keyed by source message, so\n * none outlives the wire state holding it and threads cannot collide.\n */\nconst inEvalTranscriptCache = createExternalMessageConversionCache();\nconst IN_EVAL_TRANSCRIPT_METADATA = {};\nconst inEvalTranscripts = new WeakMap<\n  readonly LangChainMessage[],\n  { readonly running: boolean; readonly messages: readonly ThreadMessage[] }\n>();\n\nconst NO_MESSAGES: readonly ThreadMessage[] = [];\n\n/**\n * An in-eval dispatch's live transcript (a `ptc_subagents` entry's `messages`)\n * as a nested thread, converted like a `task` lane's. Memoized per transcript\n * array; a step the lane did not change keeps its converted object. A\n * transcript the converter refuses reads as empty.\n */\nexport function convertSubagentTranscript(\n  transcript: readonly LangChainMessage[],\n  running: boolean\n): readonly ThreadMessage[] {\n  const cached = inEvalTranscripts.get(transcript);\n  if (cached !== undefined && cached.running === running) return cached.messages;\n  let messages: readonly ThreadMessage[] = NO_MESSAGES;\n  try {\n    messages = convertExternalMessages(\n      transcriptSources(transcript),\n      convertDeepAgentLangChainMessage,\n      running,\n      IN_EVAL_TRANSCRIPT_METADATA,\n      inEvalTranscriptCache\n    ).map(markPreliminaryToolResults);\n  } catch (error) {\n    reportUnconvertibleTranscript(transcript, error);\n  }\n  inEvalTranscripts.set(transcript, { running, messages });\n  return messages;\n}\n"],"names":["messages","DEEP_AGENT_REPEATS_RESULT_KEY","sanitizeLangChainMessages","TASK_TOOL_NAME","getMessageText","createDeepAgentMessageConversionCache","createExternalMessageConversionCache"],"mappings":"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"}

package/dist/agent-runtime/src/subagent-transcripts.d.ts

@@ -0,0 +1,71 @@
+/**
+ * A subagent's transcript as assistant-ui's native nested thread.
+ *
+ * The backend nests a `task` subagent's transcript in its card's ToolMessage,
+ * at `artifact.subgraph_state.messages`: the newest steps on the running
+ * placeholder, the whole transcript on the real result. The conversion cache
+ * built here converts that transcript through the thread's own pipeline and
+ * sets it as the `task` tool-call part's `messages`, assistant-ui's channel for
+ * a tool call's nested conversation. `ReadonlyThreadProvider` (the provider
+ * under `MessagePartPrimitive.Messages`) renders it as a read-only thread under
+ * the parent's tool UIs, and `thread.tasks` derives child work from it.
+ *
+ * Hosts opt in (`useDeepAgentThread({ createConversionCache })`). It builds on
+ * the shared conversion memory from outside, so the shared converter, which
+ * ships in every surface's startup bundle (the Office pane's startup and total
+ * budgets have no room to spare), stays as it is, and a surface that draws no
+ * subagent transcript pays nothing for it.
+ */
+import type { ThreadMessage } from '@assistant-ui/core';
+import type { LangChainMessage } from '@assistant-ui/react-langgraph';
+import { type DeepAgentConversionMemory } from './messages';
+/**
+ * A card's nested transcript with its report restored. On a cut finished card
+ * the last step can ride with empty content and `DEEP_AGENT_REPEATS_RESULT_KEY`:
+ * its text is the subagent's report, the card's own `content`, which the card
+ * carries anyway. The step gets that content back. Any other transcript comes
+ * back as it is. Memoized per transcript, so a lane's conversion sees one array.
+ */
+export declare function withRepeatedResult(transcript: readonly LangChainMessage[], content: unknown): readonly LangChainMessage[];
+/**
+ * A finished lane's transcript, closed by its report. A `task` card's content
+ * is its subagent's report, the text of the lane's last turn. A transcript
+ * that ends on that turn (an assistant step that calls nothing and says
+ * something, which {@link withRepeatedResult} restores when it rides marked)
+ * comes back as it is, even when blank steps follow it. A lane stored without
+ * it shows the report as its closing answer: a lane whose last step is a blank
+ * assistant step (lanes that finished before the host marked a repeated
+ * report) gets the report in that step, its id and stamps kept, and a lane
+ * that ends on a tool result or a turn that calls tools gets a closing step
+ * after its last one. An empty report or transcript changes nothing. For
+ * display only: the wire and the stored lane are untouched. Memoized per
+ * transcript, so a lane's conversion sees one array.
+ */
+export declare function withLaneReport(transcript: readonly LangChainMessage[], report: string | undefined): readonly LangChainMessage[];
+/** One lane's transcript, converted: `undefined` when the converter refused it. */
+export type SubagentLaneConversion = (transcript: readonly LangChainMessage[], running: boolean) => readonly ThreadMessage[] | undefined;
+/**
+ * One `task` lane's own conversion memory, for whatever converts that lane:
+ * its unchanged steps keep their converted objects while it streams (a step the
+ * wire sends again unchanged included, see {@link steadyStepObjects}), and its
+ * turn keeps its row key (`deepAgentRowKey`) and part keys when the turn's head
+ * moves — the oldest steps of a cut card falling off as the lane runs, or older
+ * steps a transcript drawer pages in. A surface that keeps its disclosures under
+ * that key keeps them open through both. A transcript array converted last time
+ * is not converted again.
+ */
+export declare function createSubagentLaneConversion(): SubagentLaneConversion;
+/**
+ * A conversion memory for one attach (see
+ * `useDeepAgentThread({ createConversionCache })`): the shared one's rows, with
+ * each `task` tool-call part carrying its subagent's converted transcript as
+ * `messages`. A pass that changes no row hands back the previous list itself.
+ */
+export declare function createSubagentTranscriptConversionCache(): DeepAgentConversionMemory;
+/**
+ * An in-eval dispatch's live transcript (a `ptc_subagents` entry's `messages`)
+ * as a nested thread, converted like a `task` lane's. Memoized per transcript
+ * array; a step the lane did not change keeps its converted object. A
+ * transcript the converter refuses reads as empty.
+ */
+export declare function convertSubagentTranscript(transcript: readonly LangChainMessage[], running: boolean): readonly ThreadMessage[];