@athenaintel/react 0.41.2 → 0.42.1

package/dist/references/src/types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Reference types — Level 1 + Level 2 + Level 3 of the reference system.
+ *
+ * Six top-level types discriminated by `referenced`:
+ *   - asset          → files, documents, videos, spreadsheets
+ *   - callable       → tools, toolkits, workspace items
+ *   - person         → workspace members
+ *   - group          → workspace groups (a reference only — never a share or a notification)
+ *   - external_url   → arbitrary URLs (also the fallback)
+ *   - navigation     → in-app routes (Spaces, Drive tab state, etc.)
+ */
+import type { Anchor } from './anchors/types';
+export declare const Referenced: {
+    readonly Asset: 'asset';
+    readonly Callable: 'callable';
+    readonly Person: 'person';
+    readonly Group: 'group';
+    readonly ExternalUrl: 'external_url';
+    readonly Navigation: 'navigation';
+};
+export type Referenced = (typeof Referenced)[keyof typeof Referenced];
+export declare const CallableKind: {
+    readonly Tool: 'tool';
+    readonly Toolkit: 'toolkit';
+    readonly WorkspaceItem: 'workspace_item';
+};
+export type CallableKind = (typeof CallableKind)[keyof typeof CallableKind];
+export type AssetMeta = {
+    title?: string;
+    excerpt?: string;
+    assetType?: string;
+    provider?: string;
+    providerLocation?: string;
+    sheetName?: string;
+};
+export type CallableMeta = {
+    title?: string;
+    description?: string;
+    icon?: string;
+};
+export type PersonMeta = {
+    name?: string;
+    avatar?: string;
+    phone?: string;
+};
+export type GroupMeta = {
+    name?: string;
+};
+export type ExternalUrlMeta = {
+    title?: string;
+    description?: string;
+    excerpt?: string;
+    thumbnailUrl?: string;
+};
+export type NavigationMeta = {
+    title?: string;
+    description?: string;
+};
+/**
+ * Which state of the source the reference points at (Level 2, alongside the
+ * anchor's *where*). Absent means `latest` — the historical default.
+ *
+ * Discriminated by `kind` to match `VersionPolicy` in `@athenaintel/source-binding`.
+ */
+export type AssetVersionRef = {
+    kind: 'latest';
+} | {
+    kind: 'pinned';
+    versionId: string;
+}
+/** Point in time; `keryxClock` makes reconstruction exact rather than approximate. */
+ | {
+    kind: 'as_of';
+    at: string;
+    keryxClock?: number;
+};
+export type AssetReference = {
+    referenced: 'asset';
+    id: string;
+    anchor?: Anchor;
+    version?: AssetVersionRef;
+    meta?: AssetMeta;
+};
+export type CallableReference = {
+    referenced: 'callable';
+    kind: CallableKind;
+    name: string;
+    config?: Record<string, unknown>;
+    meta?: CallableMeta;
+};
+export type PersonReference = {
+    referenced: 'person';
+    id: string;
+    email: string;
+    meta?: PersonMeta;
+};
+/**
+ * A workspace group (`group_<uuid>`). Mentioning one is a reference to the
+ * group, not to its members: it grants nothing and notifies nobody.
+ */
+export type GroupReference = {
+    referenced: 'group';
+    id: string;
+    meta?: GroupMeta;
+};
+export type ExternalUrlReference = {
+    referenced: 'external_url';
+    url: string;
+    meta?: ExternalUrlMeta;
+};
+export type NavigationReference = {
+    referenced: 'navigation';
+    /** Relative app path, e.g. `/dashboard/spaces?asset_ids=drive&drive=folder_id` */
+    path: string;
+    meta?: NavigationMeta;
+};
+export type Reference = AssetReference | CallableReference | PersonReference | GroupReference | ExternalUrlReference | NavigationReference;
+export declare function isAssetReference(ref: Reference): ref is AssetReference;
+export declare function isCallableReference(ref: Reference): ref is CallableReference;
+export declare function isPersonReference(ref: Reference): ref is PersonReference;
+export declare function isGroupReference(ref: Reference): ref is GroupReference;
+export declare function isExternalUrlReference(ref: Reference): ref is ExternalUrlReference;
+export declare function isNavigationReference(ref: Reference): ref is NavigationReference;
+/** True when the asset reference includes an anchor (i.e., it's a citation). */
+export declare function isCitation(ref: AssetReference): boolean;

package/dist/references/src/version-ref.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Asset version references — *which state* of a source a reference points at.
+ *
+ * An anchor says *where* in a document a reference points; a version ref says
+ * *when*. Without one, an anchor silently re-resolves against whatever the
+ * source says today, which is the drift problem versioned citations solve.
+ *
+ * The discriminator is `kind`, matching the shipped `VersionPolicy` in
+ * `@athenaintel/source-binding` so the two stay one concept.
+ */
+import type { AssetReference, AssetVersionRef } from './types';
+/** Split a legacy versioned asset id into its base id and version segment. */
+export declare function splitVersionedAssetId(assetId: string): {
+    baseId: string;
+    version: string;
+} | undefined;
+/** Decode a version ref from URL params, or `undefined` when unversioned. */
+export declare function parseVersionRefFromParams(params: URLSearchParams): AssetVersionRef | undefined;
+/** Encode a version ref to URL params. `latest` is the default, so it is a no-op. */
+export declare function serializeVersionRefToParams(version: AssetVersionRef): URLSearchParams;
+/**
+ * Move a legacy `id@versionId` into the `version` field, leaving `id` a plain
+ * asset id. Callers can then read `ref.version` instead of re-deriving it with
+ * `id.split('@')`, which is how versions got silently dropped.
+ *
+ * Already-normalized references and unversioned ids pass through untouched.
+ */
+export declare function normalizeAssetReference(ref: AssetReference): AssetReference;
+/** The pinned version id a reference resolves to, if it names a fixed state. */
+export declare function getPinnedVersionId(ref: AssetReference): string | undefined;

package/dist/runtime/statewire-lifecycle.d.ts

@@ -1,4 +1,4 @@
-import type { DeepAgentConnectionState } from '@athenaintel/agent-runtime';
+import type { DeepAgentConnectionState } from '../agent-runtime/src/index';
 /** A user-visible notice mapped from a statewire transport error. */
 export interface AthenaStatewireErrorNotice {
     kind: 'paywall' | 'read-only' | 'command';

package/dist/runtime/statewire-model-lane.d.ts

@@ -1,4 +1,4 @@
-import type { DeepAgentServerConfig, ThreadConfigCustom } from '@athenaintel/agent-runtime';
+import type { DeepAgentServerConfig, ThreadConfigCustom } from '../agent-runtime/src/index';
 /**
  * The model a thread's server config lane (`state.config.custom`) pins, as the
  * host app should read it, plus whether there is a lane at all.

package/dist/runtime/statewire-server-lane-context.d.ts

@@ -1,4 +1,4 @@
-import type { DeepAgentServerConfig } from '@athenaintel/agent-runtime';
+import type { DeepAgentServerConfig } from '../agent-runtime/src/index';
 /**
  * The thread's server config lane as the statewire host last sent it on this
  * attach, read off the transport's own state (`onStateChange`) rather than the

package/dist/runtime/statewire-session-key.cjs

@@ -7,5 +7,12 @@ function statewireSessionKey({
 }) {
   return `${syncUrl}:${principal || "anon"}:${threadId}`;
 }
+function statewireSessionPrincipal(auth) {
+  var _a;
+  const userId = (_a = auth == null ? void 0 : auth.user) == null ? void 0 : _a.userId;
+  if (userId) return userId;
+  return (auth == null ? void 0 : auth.isLoading) ? null : "";
+}
 exports.statewireSessionKey = statewireSessionKey;
+exports.statewireSessionPrincipal = statewireSessionPrincipal;
 //# sourceMappingURL=statewire-session-key.cjs.map

package/dist/runtime/statewire-session-key.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"statewire-session-key.cjs","sources":["../../src/runtime/statewire-session-key.ts"],"sourcesContent":["/**\n * Scope of the persisted statewire command lane: the sync host, the signed-in\n * principal, and the thread. A thread id is only meaningful against the\n * backend that minted it, and a shared browser must never resend one user's\n * un-settled commands under the next user's token — so the key carries WHO is\n * signed in as well as where. The principal is a non-secret user id;\n * API-key-only hosts (no auth provider above) share one anonymous scope.\n */\nexport function statewireSessionKey({\n  syncUrl,\n  principal,\n  threadId,\n}: {\n  syncUrl: string;\n  principal: string;\n  threadId: string;\n}): string {\n  return `${syncUrl}:${principal || 'anon'}:${threadId}`;\n}\n"],"names":[],"mappings":";;AAQO,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF,GAIW;AACT,SAAO,GAAG,OAAO,IAAI,aAAa,MAAM,IAAI,QAAQ;AACtD;;"}
+{"version":3,"file":"statewire-session-key.cjs","sources":["../../src/runtime/statewire-session-key.ts"],"sourcesContent":["import type { AthenaAuthState } from '../auth/types';\n\n/**\n * Scope of the persisted statewire command lane: the sync host, the signed-in\n * principal, and the thread. A thread id is only meaningful against the\n * backend that minted it, and a shared browser must never resend one user's\n * un-settled commands under the next user's token — so the key carries WHO is\n * signed in as well as where. The principal is a non-secret user id;\n * API-key-only hosts (no auth provider above) share one anonymous scope.\n */\nexport function statewireSessionKey({\n  syncUrl,\n  principal,\n  threadId,\n}: {\n  syncUrl: string;\n  principal: string;\n  threadId: string;\n}): string {\n  return `${syncUrl}:${principal || 'anon'}:${threadId}`;\n}\n\n/**\n * The principal a thread's persisted command lane is scoped by\n * ({@link statewireSessionKey}): the signed-in user's id (also while the\n * sign-in provider refreshes and still names them), `''` (the one anonymous\n * scope) with no sign-in provider above or none signed in, and `null` while\n * the sign-in provider is still resolving who is signed in.\n *\n * A lane belongs to one principal for the life of the thread's mount: a\n * session mounted on a stand-in key keeps its client id, clock and journal when\n * the key changes, and leaves that record behind with the same client id, so a\n * later page load resends its journal below the server's watermark for the id\n * (`expired`). The lane therefore stays `pending` while this is `null` (see\n * `useAthenaStatewireRuntime`).\n */\nexport function statewireSessionPrincipal(\n  auth: Pick<AthenaAuthState, 'isLoading' | 'user'> | null,\n): string | null {\n  const userId = auth?.user?.userId;\n  if (userId) return userId;\n  return auth?.isLoading ? null : '';\n}\n"],"names":[],"mappings":";;AAUO,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF,GAIW;AACT,SAAO,GAAG,OAAO,IAAI,aAAa,MAAM,IAAI,QAAQ;AACtD;AAgBO,SAAS,0BACd,MACe;;AACf,QAAM,UAAS,kCAAM,SAAN,mBAAY;AAC3B,MAAI,OAAQ,QAAO;AACnB,UAAO,6BAAM,aAAY,OAAO;AAClC;;;"}

package/dist/runtime/statewire-session-key.d.ts

@@ -1,3 +1,4 @@
+import type { AthenaAuthState } from '../auth/types';
 /**
  * Scope of the persisted statewire command lane: the sync host, the signed-in
  * principal, and the thread. A thread id is only meaningful against the
@@ -11,3 +12,18 @@ export declare function statewireSessionKey({ syncUrl, principal, threadId, }: {
     principal: string;
     threadId: string;
 }): string;
+/**
+ * The principal a thread's persisted command lane is scoped by
+ * ({@link statewireSessionKey}): the signed-in user's id (also while the
+ * sign-in provider refreshes and still names them), `''` (the one anonymous
+ * scope) with no sign-in provider above or none signed in, and `null` while
+ * the sign-in provider is still resolving who is signed in.
+ *
+ * A lane belongs to one principal for the life of the thread's mount: a
+ * session mounted on a stand-in key keeps its client id, clock and journal when
+ * the key changes, and leaves that record behind with the same client id, so a
+ * later page load resends its journal below the server's watermark for the id
+ * (`expired`). The lane therefore stays `pending` while this is `null` (see
+ * `useAthenaStatewireRuntime`).
+ */
+export declare function statewireSessionPrincipal(auth: Pick<AthenaAuthState, 'isLoading' | 'user'> | null): string | null;

package/dist/runtime/statewire-session-key.js

@@ -5,7 +5,14 @@ function statewireSessionKey({
 }) {
   return `${syncUrl}:${principal || "anon"}:${threadId}`;
 }
+function statewireSessionPrincipal(auth) {
+  var _a;
+  const userId = (_a = auth == null ? void 0 : auth.user) == null ? void 0 : _a.userId;
+  if (userId) return userId;
+  return (auth == null ? void 0 : auth.isLoading) ? null : "";
+}
 export {
-  statewireSessionKey
+  statewireSessionKey,
+  statewireSessionPrincipal
 };
 //# sourceMappingURL=statewire-session-key.js.map

package/dist/runtime/statewire-session-key.js.map

@@ -1 +1 @@
-{"version":3,"file":"statewire-session-key.js","sources":["../../src/runtime/statewire-session-key.ts"],"sourcesContent":["/**\n * Scope of the persisted statewire command lane: the sync host, the signed-in\n * principal, and the thread. A thread id is only meaningful against the\n * backend that minted it, and a shared browser must never resend one user's\n * un-settled commands under the next user's token — so the key carries WHO is\n * signed in as well as where. The principal is a non-secret user id;\n * API-key-only hosts (no auth provider above) share one anonymous scope.\n */\nexport function statewireSessionKey({\n  syncUrl,\n  principal,\n  threadId,\n}: {\n  syncUrl: string;\n  principal: string;\n  threadId: string;\n}): string {\n  return `${syncUrl}:${principal || 'anon'}:${threadId}`;\n}\n"],"names":[],"mappings":"AAQO,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF,GAIW;AACT,SAAO,GAAG,OAAO,IAAI,aAAa,MAAM,IAAI,QAAQ;AACtD;"}
+{"version":3,"file":"statewire-session-key.js","sources":["../../src/runtime/statewire-session-key.ts"],"sourcesContent":["import type { AthenaAuthState } from '../auth/types';\n\n/**\n * Scope of the persisted statewire command lane: the sync host, the signed-in\n * principal, and the thread. A thread id is only meaningful against the\n * backend that minted it, and a shared browser must never resend one user's\n * un-settled commands under the next user's token — so the key carries WHO is\n * signed in as well as where. The principal is a non-secret user id;\n * API-key-only hosts (no auth provider above) share one anonymous scope.\n */\nexport function statewireSessionKey({\n  syncUrl,\n  principal,\n  threadId,\n}: {\n  syncUrl: string;\n  principal: string;\n  threadId: string;\n}): string {\n  return `${syncUrl}:${principal || 'anon'}:${threadId}`;\n}\n\n/**\n * The principal a thread's persisted command lane is scoped by\n * ({@link statewireSessionKey}): the signed-in user's id (also while the\n * sign-in provider refreshes and still names them), `''` (the one anonymous\n * scope) with no sign-in provider above or none signed in, and `null` while\n * the sign-in provider is still resolving who is signed in.\n *\n * A lane belongs to one principal for the life of the thread's mount: a\n * session mounted on a stand-in key keeps its client id, clock and journal when\n * the key changes, and leaves that record behind with the same client id, so a\n * later page load resends its journal below the server's watermark for the id\n * (`expired`). The lane therefore stays `pending` while this is `null` (see\n * `useAthenaStatewireRuntime`).\n */\nexport function statewireSessionPrincipal(\n  auth: Pick<AthenaAuthState, 'isLoading' | 'user'> | null,\n): string | null {\n  const userId = auth?.user?.userId;\n  if (userId) return userId;\n  return auth?.isLoading ? null : '';\n}\n"],"names":[],"mappings":"AAUO,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF,GAIW;AACT,SAAO,GAAG,OAAO,IAAI,aAAa,MAAM,IAAI,QAAQ;AACtD;AAgBO,SAAS,0BACd,MACe;AA5BV;AA6BL,QAAM,UAAS,kCAAM,SAAN,mBAAY;AAC3B,MAAI,OAAQ,QAAO;AACnB,UAAO,6BAAM,aAAY,OAAO;AAClC;"}

package/dist/runtime/statewire-session-lane.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+function createStatewireSessionLaneGate({
+  pending
+}) {
+  let current = pending;
+  let waiters = [];
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    isPending: () => current,
+    whenKnown: () => current ? new Promise((resolve) => {
+      waiters.push(resolve);
+    }) : Promise.resolve(),
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setPending: (next) => {
+      if (next === current) return;
+      current = next;
+      if (!next) {
+        const known = waiters;
+        waiters = [];
+        for (const resolve of known) resolve();
+      }
+      for (const listener of [...listeners]) listener();
+    }
+  };
+}
+const StatewireSessionLaneContext = react.createContext(null);
+function useStatewireSessionLane() {
+  return react.useContext(StatewireSessionLaneContext);
+}
+const subscribeToNothing = () => () => {
+};
+function useStatewireSessionLanePending() {
+  const lane = useStatewireSessionLane();
+  const read = () => (lane == null ? void 0 : lane.isPending()) ?? false;
+  return react.useSyncExternalStore((lane == null ? void 0 : lane.subscribe) ?? subscribeToNothing, read, read);
+}
+exports.StatewireSessionLaneContext = StatewireSessionLaneContext;
+exports.createStatewireSessionLaneGate = createStatewireSessionLaneGate;
+exports.useStatewireSessionLane = useStatewireSessionLane;
+exports.useStatewireSessionLanePending = useStatewireSessionLanePending;
+//# sourceMappingURL=statewire-session-lane.cjs.map

package/dist/runtime/statewire-session-lane.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"statewire-session-lane.cjs","sources":["../../src/runtime/statewire-session-lane.ts"],"sourcesContent":["import { createContext, useContext, useSyncExternalStore } from 'react';\n\n/**\n * Whether the chat's persisted command lane is known. The lane is scoped by the\n * signed-in principal (`statewireSessionPrincipal`), so while the sign-in\n * provider above is still resolving who is signed in the lane is pending: the\n * thread's transport is parked and a command dispatched into it is refused\n * unsent. A send made meanwhile waits on this instead and goes out on the\n * signed-in user's lane once it is known.\n */\nexport interface StatewireSessionLane {\n  /** True while the lane waits for the signed-in principal. */\n  isPending: () => boolean;\n  /** Resolves once the lane is known (at once when it already is). */\n  whenKnown: () => Promise<void>;\n  /** Called whenever `isPending()` changes. */\n  subscribe: (listener: () => void) => () => void;\n}\n\n/** The provider's side of {@link StatewireSessionLane}: the mounted runtime reports its lane. */\nexport interface StatewireSessionLaneGate extends StatewireSessionLane {\n  /** Report the lane of the runtime that has just committed it. */\n  setPending: (pending: boolean) => void;\n}\n\nexport function createStatewireSessionLaneGate({\n  pending,\n}: {\n  pending: boolean;\n}): StatewireSessionLaneGate {\n  let current = pending;\n  let waiters: Array<() => void> = [];\n  const listeners = new Set<() => void>();\n  return {\n    isPending: () => current,\n    whenKnown: () =>\n      current\n        ? new Promise<void>((resolve) => {\n            waiters.push(resolve);\n          })\n        : Promise.resolve(),\n    subscribe: (listener) => {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n    setPending: (next) => {\n      if (next === current) return;\n      current = next;\n      if (!next) {\n        const known = waiters;\n        waiters = [];\n        for (const resolve of known) resolve();\n      }\n      for (const listener of [...listeners]) listener();\n    },\n  };\n}\n\nexport const StatewireSessionLaneContext = createContext<StatewireSessionLane | null>(null);\n\n/** The provider's session lane, or `null` outside `AthenaProvider` (no lane to wait for). */\nexport function useStatewireSessionLane(): StatewireSessionLane | null {\n  return useContext(StatewireSessionLaneContext);\n}\n\nconst subscribeToNothing = (): (() => void) => () => {};\n\n/** Whether the provider's session lane still waits for the signed-in principal (`false` outside one). */\nexport function useStatewireSessionLanePending(): boolean {\n  const lane = useStatewireSessionLane();\n  const read = () => lane?.isPending() ?? false;\n  return useSyncExternalStore(lane?.subscribe ?? subscribeToNothing, read, read);\n}\n"],"names":["createContext","useContext","useSyncExternalStore"],"mappings":";;;AAyBO,SAAS,+BAA+B;AAAA,EAC7C;AACF,GAE6B;AAC3B,MAAI,UAAU;AACd,MAAI,UAA6B,CAAA;AACjC,QAAM,gCAAgB,IAAA;AACtB,SAAO;AAAA,IACL,WAAW,MAAM;AAAA,IACjB,WAAW,MACT,UACI,IAAI,QAAc,CAAC,YAAY;AAC7B,cAAQ,KAAK,OAAO;AAAA,IACtB,CAAC,IACD,QAAQ,QAAA;AAAA,IACd,WAAW,CAAC,aAAa;AACvB,gBAAU,IAAI,QAAQ;AACtB,aAAO,MAAM;AACX,kBAAU,OAAO,QAAQ;AAAA,MAC3B;AAAA,IACF;AAAA,IACA,YAAY,CAAC,SAAS;AACpB,UAAI,SAAS,QAAS;AACtB,gBAAU;AACV,UAAI,CAAC,MAAM;AACT,cAAM,QAAQ;AACd,kBAAU,CAAA;AACV,mBAAW,WAAW,MAAO,SAAA;AAAA,MAC/B;AACA,iBAAW,YAAY,CAAC,GAAG,SAAS,EAAG,UAAA;AAAA,IACzC;AAAA,EAAA;AAEJ;AAEO,MAAM,8BAA8BA,MAAAA,cAA2C,IAAI;AAGnF,SAAS,0BAAuD;AACrE,SAAOC,MAAAA,WAAW,2BAA2B;AAC/C;AAEA,MAAM,qBAAqB,MAAoB,MAAM;AAAC;AAG/C,SAAS,iCAA0C;AACxD,QAAM,OAAO,wBAAA;AACb,QAAM,OAAO,OAAM,6BAAM,gBAAe;AACxC,SAAOC,MAAAA,sBAAqB,6BAAM,cAAa,oBAAoB,MAAM,IAAI;AAC/E;;;;;"}

package/dist/runtime/statewire-session-lane.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Whether the chat's persisted command lane is known. The lane is scoped by the
+ * signed-in principal (`statewireSessionPrincipal`), so while the sign-in
+ * provider above is still resolving who is signed in the lane is pending: the
+ * thread's transport is parked and a command dispatched into it is refused
+ * unsent. A send made meanwhile waits on this instead and goes out on the
+ * signed-in user's lane once it is known.
+ */
+export interface StatewireSessionLane {
+    /** True while the lane waits for the signed-in principal. */
+    isPending: () => boolean;
+    /** Resolves once the lane is known (at once when it already is). */
+    whenKnown: () => Promise<void>;
+    /** Called whenever `isPending()` changes. */
+    subscribe: (listener: () => void) => () => void;
+}
+/** The provider's side of {@link StatewireSessionLane}: the mounted runtime reports its lane. */
+export interface StatewireSessionLaneGate extends StatewireSessionLane {
+    /** Report the lane of the runtime that has just committed it. */
+    setPending: (pending: boolean) => void;
+}
+export declare function createStatewireSessionLaneGate({ pending, }: {
+    pending: boolean;
+}): StatewireSessionLaneGate;
+export declare const StatewireSessionLaneContext: import("react").Context<StatewireSessionLane | null>;
+/** The provider's session lane, or `null` outside `AthenaProvider` (no lane to wait for). */
+export declare function useStatewireSessionLane(): StatewireSessionLane | null;
+/** Whether the provider's session lane still waits for the signed-in principal (`false` outside one). */
+export declare function useStatewireSessionLanePending(): boolean;

package/dist/runtime/statewire-session-lane.js

@@ -0,0 +1,48 @@
+import { createContext, useSyncExternalStore, useContext } from "react";
+function createStatewireSessionLaneGate({
+  pending
+}) {
+  let current = pending;
+  let waiters = [];
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    isPending: () => current,
+    whenKnown: () => current ? new Promise((resolve) => {
+      waiters.push(resolve);
+    }) : Promise.resolve(),
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setPending: (next) => {
+      if (next === current) return;
+      current = next;
+      if (!next) {
+        const known = waiters;
+        waiters = [];
+        for (const resolve of known) resolve();
+      }
+      for (const listener of [...listeners]) listener();
+    }
+  };
+}
+const StatewireSessionLaneContext = createContext(null);
+function useStatewireSessionLane() {
+  return useContext(StatewireSessionLaneContext);
+}
+const subscribeToNothing = () => () => {
+};
+function useStatewireSessionLanePending() {
+  const lane = useStatewireSessionLane();
+  const read = () => (lane == null ? void 0 : lane.isPending()) ?? false;
+  return useSyncExternalStore((lane == null ? void 0 : lane.subscribe) ?? subscribeToNothing, read, read);
+}
+export {
+  StatewireSessionLaneContext,
+  createStatewireSessionLaneGate,
+  useStatewireSessionLane,
+  useStatewireSessionLanePending
+};
+//# sourceMappingURL=statewire-session-lane.js.map

package/dist/runtime/statewire-session-lane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statewire-session-lane.js","sources":["../../src/runtime/statewire-session-lane.ts"],"sourcesContent":["import { createContext, useContext, useSyncExternalStore } from 'react';\n\n/**\n * Whether the chat's persisted command lane is known. The lane is scoped by the\n * signed-in principal (`statewireSessionPrincipal`), so while the sign-in\n * provider above is still resolving who is signed in the lane is pending: the\n * thread's transport is parked and a command dispatched into it is refused\n * unsent. A send made meanwhile waits on this instead and goes out on the\n * signed-in user's lane once it is known.\n */\nexport interface StatewireSessionLane {\n  /** True while the lane waits for the signed-in principal. */\n  isPending: () => boolean;\n  /** Resolves once the lane is known (at once when it already is). */\n  whenKnown: () => Promise<void>;\n  /** Called whenever `isPending()` changes. */\n  subscribe: (listener: () => void) => () => void;\n}\n\n/** The provider's side of {@link StatewireSessionLane}: the mounted runtime reports its lane. */\nexport interface StatewireSessionLaneGate extends StatewireSessionLane {\n  /** Report the lane of the runtime that has just committed it. */\n  setPending: (pending: boolean) => void;\n}\n\nexport function createStatewireSessionLaneGate({\n  pending,\n}: {\n  pending: boolean;\n}): StatewireSessionLaneGate {\n  let current = pending;\n  let waiters: Array<() => void> = [];\n  const listeners = new Set<() => void>();\n  return {\n    isPending: () => current,\n    whenKnown: () =>\n      current\n        ? new Promise<void>((resolve) => {\n            waiters.push(resolve);\n          })\n        : Promise.resolve(),\n    subscribe: (listener) => {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n    setPending: (next) => {\n      if (next === current) return;\n      current = next;\n      if (!next) {\n        const known = waiters;\n        waiters = [];\n        for (const resolve of known) resolve();\n      }\n      for (const listener of [...listeners]) listener();\n    },\n  };\n}\n\nexport const StatewireSessionLaneContext = createContext<StatewireSessionLane | null>(null);\n\n/** The provider's session lane, or `null` outside `AthenaProvider` (no lane to wait for). */\nexport function useStatewireSessionLane(): StatewireSessionLane | null {\n  return useContext(StatewireSessionLaneContext);\n}\n\nconst subscribeToNothing = (): (() => void) => () => {};\n\n/** Whether the provider's session lane still waits for the signed-in principal (`false` outside one). */\nexport function useStatewireSessionLanePending(): boolean {\n  const lane = useStatewireSessionLane();\n  const read = () => lane?.isPending() ?? false;\n  return useSyncExternalStore(lane?.subscribe ?? subscribeToNothing, read, read);\n}\n"],"names":[],"mappings":";AAyBO,SAAS,+BAA+B;AAAA,EAC7C;AACF,GAE6B;AAC3B,MAAI,UAAU;AACd,MAAI,UAA6B,CAAA;AACjC,QAAM,gCAAgB,IAAA;AACtB,SAAO;AAAA,IACL,WAAW,MAAM;AAAA,IACjB,WAAW,MACT,UACI,IAAI,QAAc,CAAC,YAAY;AAC7B,cAAQ,KAAK,OAAO;AAAA,IACtB,CAAC,IACD,QAAQ,QAAA;AAAA,IACd,WAAW,CAAC,aAAa;AACvB,gBAAU,IAAI,QAAQ;AACtB,aAAO,MAAM;AACX,kBAAU,OAAO,QAAQ;AAAA,MAC3B;AAAA,IACF;AAAA,IACA,YAAY,CAAC,SAAS;AACpB,UAAI,SAAS,QAAS;AACtB,gBAAU;AACV,UAAI,CAAC,MAAM;AACT,cAAM,QAAQ;AACd,kBAAU,CAAA;AACV,mBAAW,WAAW,MAAO,SAAA;AAAA,MAC/B;AACA,iBAAW,YAAY,CAAC,GAAG,SAAS,EAAG,UAAA;AAAA,IACzC;AAAA,EAAA;AAEJ;AAEO,MAAM,8BAA8B,cAA2C,IAAI;AAGnF,SAAS,0BAAuD;AACrE,SAAO,WAAW,2BAA2B;AAC/C;AAEA,MAAM,qBAAqB,MAAoB,MAAM;AAAC;AAG/C,SAAS,iCAA0C;AACxD,QAAM,OAAO,wBAAA;AACb,QAAM,OAAO,OAAM,6BAAM,gBAAe;AACxC,SAAO,sBAAqB,6BAAM,cAAa,oBAAoB,MAAM,IAAI;AAC/E;"}

package/dist/runtime/statewire-thread-config-lane.d.ts

@@ -1,4 +1,4 @@
-import type { ThreadConfigCustom } from '@athenaintel/agent-runtime';
+import type { ThreadConfigCustom } from '../agent-runtime/src/index';
 /**
  * The thread-config keys the provider's props own, in the order a
  * `config/patch` lists them.

package/dist/runtime/useAthenaStatewireRuntime.cjs

@@ -10,6 +10,7 @@ const statewireSessionKey = require("./statewire-session-key.cjs");
 const statewireRunConfig = require("./statewire-run-config.cjs");
 const runconfigContract = require("../agent-runtime/src/generated/runconfig-contract.cjs");
 const useDeepAgentRuntime = require("../agent-runtime/src/use-deep-agent-runtime.cjs");
+const subagentTranscripts = require("../agent-runtime/src/subagent-transcripts.cjs");
 const errors = require("../agent-runtime/src/errors.cjs");
 const protocol = require("../agent-runtime/src/protocol.cjs");
 const composerMarkdown = require("../agent-runtime/src/composer-markdown.cjs");
@@ -25,7 +26,6 @@ function useStatewireClientTools(frontendToolkit) {
   );
 }
 function useAthenaStatewireRuntime(config) {
-  var _a;
   const {
     syncUrl,
     threadId,
@@ -47,17 +47,18 @@ function useAthenaStatewireRuntime(config) {
     extraRunConfig,
     snapshotCache,
     messageWindow = ATHENA_SDK_MESSAGE_WINDOW,
+    subagentLaneHistory = false,
     toolOutputs,
     onError,
     onConnectionChange,
     onRawConnectionChange,
     onRunningChange,
+    onCommandChange,
     onServerState
   } = config;
   statewireRunConfig.resolveAgentProp({ agent });
   const clientTools = useStatewireClientTools(frontendToolkit);
-  const authContext = react.useContext(AthenaAuthContext.AthenaAuthContext);
-  const principal = ((_a = authContext == null ? void 0 : authContext.user) == null ? void 0 : _a.userId) ?? "";
+  const principal = statewireSessionKey.statewireSessionPrincipal(react.useContext(AthenaAuthContext.AthenaAuthContext));
   const attachSpanRef = react.useRef(null);
   const attachThreadRef = react.useRef(null);
   if (attachThreadRef.current !== threadId) {
@@ -103,8 +104,11 @@ function useAthenaStatewireRuntime(config) {
     // id is only meaningful against the backend that minted it, and a stored
     // lane must never resend against another signed-in user. (Consumers
     // server-render this SDK; the core's availability probe keeps those
-    // sessions process-local, as before the seam existed.)
-    session: {
+    // sessions process-local, as before the seam existed.) Until the sign-in
+    // provider knows who is signed in, the lane is pending: the transport
+    // stays parked and nothing is mounted on a stand-in key the session could
+    // not move off (`statewireSessionPrincipal`).
+    session: principal === null ? { kind: "pending" } : {
       kind: "local-storage",
       key: (id) => statewireSessionKey.statewireSessionKey({ syncUrl, principal, threadId: id })
     },
@@ -114,6 +118,12 @@ function useAthenaStatewireRuntime(config) {
     // older ranges in and fetches cut tool outputs into `toolOutputs`.
     messageWindow,
     toolOutputs,
+    // Each `task` card's nested transcript becomes its tool-call part's
+    // `messages` (assistant-ui's nested-thread channel), which the subagent
+    // card (`SubagentTaskToolUI`) shows.
+    createConversionCache: subagentTranscripts.createSubagentTranscriptConversionCache,
+    // The lane-cut contract only where the chat pages lanes (see `subagentLaneHistory`).
+    laneHistory: subagentLaneHistory,
     capabilities: { edit: true, reload: true, continue: true },
     // The composer stages the draft each send came from right before it
     // sends; the message carries it as its composer markdown, so its bubble
@@ -145,6 +155,7 @@ function useAthenaStatewireRuntime(config) {
     },
     onRawConnectionChange,
     onRunningChange,
+    ...onCommandChange && { onCommandChange },
     // Each model-context notification pulls the latest getter through the
     // core's per-render ref; the value-stable key re-registers (and so
     // notifies) only when the built runConfig actually changed. On a thread

package/dist/runtime/useAthenaStatewireRuntime.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useAthenaStatewireRuntime.cjs","sources":["../../src/runtime/useAthenaStatewireRuntime.ts"],"sourcesContent":["import type { AssistantClient, Toolkit } from '@assistant-ui/react';\nimport { Tools, useAui } from '@assistant-ui/react';\nimport {\n  DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n  type DeepAgentMessageWindowDeclaration,\n  type DeepAgentStreamValues,\n  type DeepAgentThreadElement,\n  type DeepAgentThreadSnapshotCache,\n  type DeepAgentToolOutputStore,\n  isDeepAgentHostState,\n  isStatewireChannelTeardown,\n  logUnhandledStatewireError,\n  type RegisteredClientTool,\n  useDeepAgentRuntime,\n  type UseDeepAgentThreadOptions,\n  withStagedComposerMarkdown,\n} from '@athenaintel/agent-runtime';\nimport { useContext, useMemo, useRef } from 'react';\nimport { AthenaAuthContext } from '../auth/AthenaAuthContext';\nimport {\n  collectStatewireClientTools,\n  statewireClientToolWireEntries,\n} from '../chat/statewire-client-tools';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport {\n  type AthenaStatewireTokenGetter,\n  resolveStatewireAuthHeaders,\n} from './statewire-auth-headers';\nimport { statewireSessionKey } from './statewire-session-key';\n\ntype AthenaDiagnosticsSpanStarter = typeof athenaDiagnostics.span;\nimport {\n  buildStatewireRunConfig,\n  DEFAULT_STATEWIRE_MODEL,\n  resolveAgentProp,\n} from './statewire-run-config';\n\nexport { DEFAULT_STATEWIRE_MODEL };\n\n/**\n * The head interest every SDK attach states (`athena/interest`): the host\n * mounts the transcript's tail as message documents instead of every message\n * — megabytes on long threads, over the 1 MiB frame limit of stock websocket\n * clients. Older pages load from the `StatewireHistoryEdge` row the chat UI\n * mounts above the messages, and cut tool outputs are fetched back for the\n * cards that show them.\n */\nexport const ATHENA_SDK_MESSAGE_WINDOW: DeepAgentMessageWindowDeclaration = {\n  size: DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n};\n\nexport interface AthenaStatewireRuntimeConfig {\n  /** Base URL of the statewire sync host (the `…/v2/threads` mount). */\n  syncUrl: string;\n  /** Thread ID the statewire session attaches to. */\n  threadId: string;\n  /** True only for a never-started local chat. Existing (or pre-assigned)\n   *  threads load until their server snapshot arrives. */\n  isNewChat?: boolean;\n  /** API key for authentication. Used when no auth token is provided. */\n  apiKey?: string;\n  /** Auth token. Takes priority over apiKey. */\n  token?: string | null;\n  /** Resolve the latest token immediately before a request (for expiring\n   *  clients). Called with `{ force: true }` right after the host refused the\n   *  previous credential (the transport's `staleAuth`), so a caching getter\n   *  mints a fresh token instead of returning the refused one. */\n  getToken?: AthenaStatewireTokenGetter;\n  /**\n   * Per-provider LRU of each thread's last wire state. A switch back to a\n   * remembered thread mounts with that snapshot and projects ready on the\n   * first frame instead of a loading treatment; the attach snapshot then\n   * replaces it. Owned above the per-thread mount so it survives switches.\n   */\n  snapshotCache?: DeepAgentThreadSnapshotCache;\n  /** The head interest stated on the attach (see {@link ATHENA_SDK_MESSAGE_WINDOW}, the default). */\n  messageWindow?: DeepAgentMessageWindowDeclaration;\n  /**\n   * Full tool outputs fetched back for a windowed wire's cut tool messages;\n   * the thread re-converts when one lands. `AthenaProvider` owns one per\n   * provider and hands the same store to `StatewireHistoryEdge`.\n   */\n  toolOutputs?: DeepAgentToolOutputStore;\n  /** LLM model identifier. Defaults to the deep-agent default model. */\n  model?: string;\n  /** Agent selector: only `collab_agent:<asset_id>` refs are accepted (the run\n   *  executes AS that published collab agent). Any other non-empty value\n   *  throws — see `resolveAgentProp`. */\n  agent?: string;\n  /** Collab-agent channel id selecting that channel's overrides. */\n  channel?: string;\n  /** The agent's mode picked for this thread (`AthenaProvider` `modes`). */\n  mode?: string;\n  /** Backend toolkit IDs to enable. */\n  tools?: string[];\n  /** Frontend tool IDs to include in enabled_tools. */\n  frontendToolIds?: string[];\n  /** Frontend tools registered on the assistant client. Tools with a local\n   *  `execute` are also declared as `client_tools` and executed through the\n   *  statewire client-tool bridge. */\n  frontendToolkit?: Toolkit;\n  /** Asset IDs to include in the workbench. */\n  workbench?: string[];\n  /** Knowledge base IDs for RAG context. */\n  knowledgeBase?: string[];\n  /** System prompt override. */\n  systemPrompt?: string;\n  /** Client app identifier for session filtering. Sent as app_id in runConfig.custom. */\n  appId?: string;\n  /** Additional fields merged into runConfig.custom. */\n  extraRunConfig?: Record<string, unknown>;\n  /** Called on statewire transport errors (send rejections, stream failures). */\n  onError?: (error: Error) => void;\n  /** Projected connection status changes (deduped; null on unmount). */\n  onConnectionChange?: UseDeepAgentThreadOptions['onConnectionChange'];\n  /** Raw connection observer — carries the transport's reconnect handle. */\n  onRawConnectionChange?: UseDeepAgentThreadOptions['onRawConnectionChange'];\n  /** Notified when a run starts/stops. */\n  onRunningChange?: UseDeepAgentThreadOptions['onRunningChange'];\n  /**\n   * Observes the host's own state: called with the attach snapshot and then on\n   * every later frame (`isDeepAgentHostState`) — never with the placeholder or\n   * remembered snapshot a thread renders before its snapshot applies, which\n   * can be after the connection reports `connected`. Called per streamed\n   * token, so keep it cheap.\n   */\n  onServerState?: (state: DeepAgentStreamValues) => void;\n}\n\nconst EMPTY_TOOLKIT: Toolkit = {};\nconst EMPTY_TOOL_IDS: string[] = [];\n\n/** The client tools derived from the runtime's frontend toolkit — exposed so\n *  the provider can mount the client-tool bridge with the same set. */\nexport function useStatewireClientTools(\n  frontendToolkit: Toolkit | undefined,\n): RegisteredClientTool[] {\n  return useMemo(\n    () => collectStatewireClientTools(frontendToolkit ?? EMPTY_TOOLKIT),\n    [frontendToolkit],\n  );\n}\n\n/**\n * Statewire runtime for the Athena SDK — a thin shim over the shared\n * `@athenaintel/agent-runtime` `useDeepAgentRuntime`: it attaches to the\n * agora-hosted deep-agent thread at `${syncUrl}/${threadId}` and returns the\n * `AssistantClient` to mount via `AuiProvider` — the same integration shape as\n * the Olympus, Chrome extension, Office, and mobile statewire hosts.\n *\n * Auth: a token (resolved live through `getToken` when provided) rides\n * `Authorization: Bearer`, and an API key falls back to `X-API-KEY` — both\n * accepted by the statewire host.\n */\nexport function useAthenaStatewireRuntime(\n  config: AthenaStatewireRuntimeConfig,\n): AssistantClient {\n  const {\n    syncUrl,\n    threadId,\n    isNewChat = false,\n    apiKey,\n    token,\n    getToken,\n    model,\n    agent,\n    channel,\n    mode,\n    tools = EMPTY_TOOL_IDS,\n    frontendToolIds = EMPTY_TOOL_IDS,\n    frontendToolkit = EMPTY_TOOLKIT,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    snapshotCache,\n    messageWindow = ATHENA_SDK_MESSAGE_WINDOW,\n    toolOutputs,\n    onError,\n    onConnectionChange,\n    onRawConnectionChange,\n    onRunningChange,\n    onServerState,\n  } = config;\n\n  // Fail loud at mount, not at first send: the statewire host always runs the\n  // Athena deep agent, so an `agent` outside the collab_agent namespace can\n  // never apply. Throwing here (render time) is what makes a misconfigured\n  // integration visible instead of quietly answering as the wrong agent.\n  resolveAgentProp({ agent });\n\n  const clientTools = useStatewireClientTools(frontendToolkit);\n\n  // The persisted command lane is keyed by WHO is signed in as well as by host\n  // and thread (see `statewireSessionKey`).\n  const authContext = useContext(AthenaAuthContext);\n  const principal = authContext?.user?.userId ?? '';\n\n  // Attach → first server snapshot span, keyed per thread attach.\n  const attachSpanRef = useRef<ReturnType<AthenaDiagnosticsSpanStarter> | null>(null);\n  const attachThreadRef = useRef<string | null>(null);\n  if (attachThreadRef.current !== threadId) {\n    attachThreadRef.current = threadId;\n    attachSpanRef.current = athenaDiagnostics.span(\n      `statewire.attach:${threadId}`,\n      'statewire.attach.start',\n      { thread_id: threadId, is_new_chat: isNewChat },\n    );\n  }\n\n  // Built every render so its JSON signature can key the model-context\n  // registration below: consumers commonly pass fresh array literals per\n  // render, which must not thrash registration, while a changed value (a new\n  // `model`, channel, tool list, system prompt, …) must re-sync the context\n  // before the next send. The core pulls this value only on model-context\n  // notifications, which a key change triggers.\n  const runConfigValue = buildStatewireRunConfig({\n    model,\n    agent,\n    channel,\n    mode,\n    tools,\n    frontendToolIds,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    clientTools: statewireClientToolWireEntries(clientTools),\n  });\n  const runConfigKey = JSON.stringify(runConfigValue);\n\n  const auiTools = useMemo(() => Tools({ toolkit: frontendToolkit }), [frontendToolkit]);\n  // Web client for the shared runtime core (a `use*` name so the\n  // rules-of-hooks lint sees the `useAui` call inside a custom hook; the core\n  // invokes it unconditionally every render).\n  const useSdkClient = (thread: DeepAgentThreadElement) => useAui({ thread, tools: auiTools });\n\n  return useDeepAgentRuntime({\n    surface: 'AthenaSDK',\n    threadId,\n    baseUrl: syncUrl,\n    // Option closures are re-read per render by the core, so credential\n    // rotation (new `token`/`getToken`/`apiKey` props) reaches the next\n    // request without remounting the thread. The transport's `staleAuth`\n    // (true right after a refused credential) is forwarded as `force`.\n    headers: (ctx) => resolveStatewireAuthHeaders({ apiKey, token, getToken }, ctx),\n    isNewChat,\n    // Queued entries render in the SDK's queue panel, so only the steer lane\n    // projects into the message tail.\n    laneProjection: 'steer-only',\n    // Durable session: a reload resumes the lane and resends whatever the\n    // server has not marked durable. Scoped by host AND principal — a thread\n    // id is only meaningful against the backend that minted it, and a stored\n    // lane must never resend against another signed-in user. (Consumers\n    // server-render this SDK; the core's availability probe keeps those\n    // sessions process-local, as before the seam existed.)\n    session: {\n      kind: 'local-storage',\n      key: (id) => statewireSessionKey({ syncUrl, principal, threadId: id }),\n    },\n    snapshotCache,\n    // Head interest (see `ATHENA_SDK_MESSAGE_WINDOW`): the tail of the\n    // transcript instead of every message; the chat UI's history edge pages\n    // older ranges in and fetches cut tool outputs into `toolOutputs`.\n    messageWindow,\n    toolOutputs,\n    capabilities: { edit: true, reload: true, continue: true },\n    // The composer stages the draft each send came from right before it\n    // sends; the message carries it as its composer markdown, so its bubble\n    // shows the text exactly as typed (`UserMessageText`).\n    getMessageMetadata: withStagedComposerMarkdown({ threadId }),\n    useClient: useSdkClient,\n    onStateChange: (state) => {\n      // Statewire publishes what the thread renders before its attach snapshot\n      // through here too (the placeholder, a remembered snapshot, and a replay\n      // boundary's pre-stream default), and on a thread mid-run it reports\n      // `connected` before the snapshot applies: only a state the host sent\n      // counts, whatever the connection says.\n      if (!isDeepAgentHostState(state)) return;\n      // The attach's first one ends the attach span (time-to-history).\n      const endSpan = attachSpanRef.current;\n      if (endSpan) {\n        attachSpanRef.current = null;\n        endSpan('statewire.snapshot', { data: { thread_id: threadId } });\n      }\n      onServerState?.(state);\n    },\n    onConnectionChange: (connection) => {\n      athenaDiagnostics.gauge('statewire.connection', connection?.status ?? null);\n      if (connection?.status === 'stopped') {\n        athenaDiagnostics.emit('statewire.connection', {\n          level: 'warn',\n          data: {\n            status: connection.status,\n            reason: connection.reason,\n            message: connection.message,\n          },\n        });\n      }\n      onConnectionChange?.(connection);\n    },\n    onRawConnectionChange,\n    onRunningChange,\n    // Each model-context notification pulls the latest getter through the\n    // core's per-render ref; the value-stable key re-registers (and so\n    // notifies) only when the built runConfig actually changed. On a thread\n    // with a server config lane, agora keeps only the per-send keys of what\n    // this carries; `StatewireThreadConfigLaneSync` writes a changed model,\n    // system prompt, tool list, workbench or knowledge base to the lane itself.\n    runConfig: {\n      get: () => runConfigValue,\n      key: runConfigKey,\n    },\n    onError: (error) => {\n      if (!isStatewireChannelTeardown(error)) {\n        athenaDiagnostics.error(\n          'statewire.error',\n          error,\n          {\n            code: 'statewire_rejected',\n            message: 'The statewire host rejected a command',\n            hint: 'Inspect error.detail — agora rejections carry a structured {code, message}.',\n          },\n          { thread_id: threadId },\n        );\n      }\n      if (onError) {\n        onError(error);\n        return;\n      }\n      logUnhandledStatewireError('AthenaSDK', error);\n    },\n  });\n}\n"],"names":["DEEP_AGENT_DEFAULT_MESSAGE_WINDOW","useMemo","collectStatewireClientTools","resolveAgentProp","useContext","AthenaAuthContext","useRef","athenaDiagnostics","buildStatewireRunConfig","statewireClientToolWireEntries","Tools","useAui","useDeepAgentRuntime","resolveStatewireAuthHeaders","statewireSessionKey","withStagedComposerMarkdown","isDeepAgentHostState","isStatewireChannelTeardown","logUnhandledStatewireError"],"mappings":"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"}
+{"version":3,"file":"useAthenaStatewireRuntime.cjs","sources":["../../src/runtime/useAthenaStatewireRuntime.ts"],"sourcesContent":["import type { AssistantClient, Toolkit } from '@assistant-ui/react';\nimport { Tools, useAui } from '@assistant-ui/react';\nimport {\n  createSubagentTranscriptConversionCache,\n  DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n  type DeepAgentMessageWindowDeclaration,\n  type DeepAgentStreamValues,\n  type DeepAgentThreadElement,\n  type DeepAgentThreadSnapshotCache,\n  type DeepAgentToolOutputStore,\n  isDeepAgentHostState,\n  isStatewireChannelTeardown,\n  logUnhandledStatewireError,\n  type RegisteredClientTool,\n  useDeepAgentRuntime,\n  type UseDeepAgentThreadOptions,\n  withStagedComposerMarkdown,\n} from '@athenaintel/agent-runtime';\nimport { useContext, useMemo, useRef } from 'react';\nimport { AthenaAuthContext } from '../auth/AthenaAuthContext';\nimport {\n  collectStatewireClientTools,\n  statewireClientToolWireEntries,\n} from '../chat/statewire-client-tools';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport {\n  type AthenaStatewireTokenGetter,\n  resolveStatewireAuthHeaders,\n} from './statewire-auth-headers';\nimport { statewireSessionKey, statewireSessionPrincipal } from './statewire-session-key';\n\ntype AthenaDiagnosticsSpanStarter = typeof athenaDiagnostics.span;\nimport {\n  buildStatewireRunConfig,\n  DEFAULT_STATEWIRE_MODEL,\n  resolveAgentProp,\n} from './statewire-run-config';\n\nexport { DEFAULT_STATEWIRE_MODEL };\n\n/**\n * The head interest every SDK attach states (`athena/interest`): the host\n * mounts the transcript's tail as message documents instead of every message\n * — megabytes on long threads, over the 1 MiB frame limit of stock websocket\n * clients. Older pages load from the `StatewireHistoryEdge` row the chat UI\n * mounts above the messages, and cut tool outputs are fetched back for the\n * cards that show them.\n */\nexport const ATHENA_SDK_MESSAGE_WINDOW: DeepAgentMessageWindowDeclaration = {\n  size: DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n};\n\nexport interface AthenaStatewireRuntimeConfig {\n  /** Base URL of the statewire sync host (the `…/v2/threads` mount). */\n  syncUrl: string;\n  /** Thread ID the statewire session attaches to. */\n  threadId: string;\n  /** True only for a never-started local chat. Existing (or pre-assigned)\n   *  threads load until their server snapshot arrives. */\n  isNewChat?: boolean;\n  /** API key for authentication. Used when no auth token is provided. */\n  apiKey?: string;\n  /** Auth token. Takes priority over apiKey. */\n  token?: string | null;\n  /** Resolve the latest token immediately before a request (for expiring\n   *  clients). Called with `{ force: true }` right after the host refused the\n   *  previous credential (the transport's `staleAuth`), so a caching getter\n   *  mints a fresh token instead of returning the refused one. */\n  getToken?: AthenaStatewireTokenGetter;\n  /**\n   * Per-provider LRU of each thread's last wire state. A switch back to a\n   * remembered thread mounts with that snapshot and projects ready on the\n   * first frame instead of a loading treatment; the attach snapshot then\n   * replaces it. Owned above the per-thread mount so it survives switches.\n   */\n  snapshotCache?: DeepAgentThreadSnapshotCache;\n  /** The head interest stated on the attach (see {@link ATHENA_SDK_MESSAGE_WINDOW}, the default). */\n  messageWindow?: DeepAgentMessageWindowDeclaration;\n  /**\n   * Whether the chat this runtime serves loads a subagent lane's earlier steps\n   * on request, as `AthenaChat`'s subagent card does (\"Load earlier steps\").\n   * When true, its attaches declare the deep-agent lane-cut contract\n   * (protocol 2): the host sends a finished subagent's card cut to its newest\n   * steps, as it sends a running one, and the card reads the rest. Default\n   * `false`, so a chat that does not page lanes declares the default contract\n   * and finished lanes arrive whole; a host whose `AthenaChat` renders every\n   * `task` call in the subagent card turns it on through `AthenaProvider`'s\n   * `subagentLaneHistory`. Read once per attach.\n   */\n  subagentLaneHistory?: boolean;\n  /**\n   * Full tool outputs fetched back for a windowed wire's cut tool messages;\n   * the thread re-converts when one lands. `AthenaProvider` owns one per\n   * provider and hands the same store to `StatewireHistoryEdge`.\n   */\n  toolOutputs?: DeepAgentToolOutputStore;\n  /** LLM model identifier. Defaults to the deep-agent default model. */\n  model?: string;\n  /** Agent selector: only `collab_agent:<asset_id>` refs are accepted (the run\n   *  executes AS that published collab agent). Any other non-empty value\n   *  throws — see `resolveAgentProp`. */\n  agent?: string;\n  /** Collab-agent channel id selecting that channel's overrides. */\n  channel?: string;\n  /** The agent's mode picked for this thread (`AthenaProvider` `modes`). */\n  mode?: string;\n  /** Backend toolkit IDs to enable. */\n  tools?: string[];\n  /** Frontend tool IDs to include in enabled_tools. */\n  frontendToolIds?: string[];\n  /** Frontend tools registered on the assistant client. Tools with a local\n   *  `execute` are also declared as `client_tools` and executed through the\n   *  statewire client-tool bridge. */\n  frontendToolkit?: Toolkit;\n  /** Asset IDs to include in the workbench. */\n  workbench?: string[];\n  /** Knowledge base IDs for RAG context. */\n  knowledgeBase?: string[];\n  /** System prompt override. */\n  systemPrompt?: string;\n  /** Client app identifier for session filtering. Sent as app_id in runConfig.custom. */\n  appId?: string;\n  /** Additional fields merged into runConfig.custom. */\n  extraRunConfig?: Record<string, unknown>;\n  /** Called on statewire transport errors (send rejections, stream failures). */\n  onError?: (error: Error) => void;\n  /** Projected connection status changes (deduped; null on unmount). */\n  onConnectionChange?: UseDeepAgentThreadOptions['onConnectionChange'];\n  /** Raw connection observer — carries the transport's reconnect handle. */\n  onRawConnectionChange?: UseDeepAgentThreadOptions['onRawConnectionChange'];\n  /** Notified when a run starts/stops. */\n  onRunningChange?: UseDeepAgentThreadOptions['onRunningChange'];\n  /** Every statewire command-lifecycle update (the chat outbox lets a handed-over message go on it). */\n  onCommandChange?: UseDeepAgentThreadOptions['onCommandChange'];\n  /**\n   * Observes the host's own state: called with the attach snapshot and then on\n   * every later frame (`isDeepAgentHostState`) — never with the placeholder or\n   * remembered snapshot a thread renders before its snapshot applies, which\n   * can be after the connection reports `connected`. Called per streamed\n   * token, so keep it cheap.\n   */\n  onServerState?: (state: DeepAgentStreamValues) => void;\n}\n\nconst EMPTY_TOOLKIT: Toolkit = {};\nconst EMPTY_TOOL_IDS: string[] = [];\n\n/** The client tools derived from the runtime's frontend toolkit — exposed so\n *  the provider can mount the client-tool bridge with the same set. */\nexport function useStatewireClientTools(\n  frontendToolkit: Toolkit | undefined,\n): RegisteredClientTool[] {\n  return useMemo(\n    () => collectStatewireClientTools(frontendToolkit ?? EMPTY_TOOLKIT),\n    [frontendToolkit],\n  );\n}\n\n/**\n * Statewire runtime for the Athena SDK — a thin shim over the shared\n * `@athenaintel/agent-runtime` `useDeepAgentRuntime`: it attaches to the\n * agora-hosted deep-agent thread at `${syncUrl}/${threadId}` and returns the\n * `AssistantClient` to mount via `AuiProvider` — the same integration shape as\n * the Olympus, Chrome extension, Office, and mobile statewire hosts.\n *\n * Auth: a token (resolved live through `getToken` when provided) rides\n * `Authorization: Bearer`, and an API key falls back to `X-API-KEY` — both\n * accepted by the statewire host.\n */\nexport function useAthenaStatewireRuntime(\n  config: AthenaStatewireRuntimeConfig,\n): AssistantClient {\n  const {\n    syncUrl,\n    threadId,\n    isNewChat = false,\n    apiKey,\n    token,\n    getToken,\n    model,\n    agent,\n    channel,\n    mode,\n    tools = EMPTY_TOOL_IDS,\n    frontendToolIds = EMPTY_TOOL_IDS,\n    frontendToolkit = EMPTY_TOOLKIT,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    snapshotCache,\n    messageWindow = ATHENA_SDK_MESSAGE_WINDOW,\n    subagentLaneHistory = false,\n    toolOutputs,\n    onError,\n    onConnectionChange,\n    onRawConnectionChange,\n    onRunningChange,\n    onCommandChange,\n    onServerState,\n  } = config;\n\n  // Fail loud at mount, not at first send: the statewire host always runs the\n  // Athena deep agent, so an `agent` outside the collab_agent namespace can\n  // never apply. Throwing here (render time) is what makes a misconfigured\n  // integration visible instead of quietly answering as the wrong agent.\n  resolveAgentProp({ agent });\n\n  const clientTools = useStatewireClientTools(frontendToolkit);\n\n  // The persisted command lane is keyed by WHO is signed in as well as by host\n  // and thread (see `statewireSessionKey`); `null` while the sign-in provider\n  // above is still resolving who that is.\n  const principal = statewireSessionPrincipal(useContext(AthenaAuthContext));\n\n  // Attach → first server snapshot span, keyed per thread attach.\n  const attachSpanRef = useRef<ReturnType<AthenaDiagnosticsSpanStarter> | null>(null);\n  const attachThreadRef = useRef<string | null>(null);\n  if (attachThreadRef.current !== threadId) {\n    attachThreadRef.current = threadId;\n    attachSpanRef.current = athenaDiagnostics.span(\n      `statewire.attach:${threadId}`,\n      'statewire.attach.start',\n      { thread_id: threadId, is_new_chat: isNewChat },\n    );\n  }\n\n  // Built every render so its JSON signature can key the model-context\n  // registration below: consumers commonly pass fresh array literals per\n  // render, which must not thrash registration, while a changed value (a new\n  // `model`, channel, tool list, system prompt, …) must re-sync the context\n  // before the next send. The core pulls this value only on model-context\n  // notifications, which a key change triggers.\n  const runConfigValue = buildStatewireRunConfig({\n    model,\n    agent,\n    channel,\n    mode,\n    tools,\n    frontendToolIds,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    clientTools: statewireClientToolWireEntries(clientTools),\n  });\n  const runConfigKey = JSON.stringify(runConfigValue);\n\n  const auiTools = useMemo(() => Tools({ toolkit: frontendToolkit }), [frontendToolkit]);\n  // Web client for the shared runtime core (a `use*` name so the\n  // rules-of-hooks lint sees the `useAui` call inside a custom hook; the core\n  // invokes it unconditionally every render).\n  const useSdkClient = (thread: DeepAgentThreadElement) => useAui({ thread, tools: auiTools });\n\n  return useDeepAgentRuntime({\n    surface: 'AthenaSDK',\n    threadId,\n    baseUrl: syncUrl,\n    // Option closures are re-read per render by the core, so credential\n    // rotation (new `token`/`getToken`/`apiKey` props) reaches the next\n    // request without remounting the thread. The transport's `staleAuth`\n    // (true right after a refused credential) is forwarded as `force`.\n    headers: (ctx) => resolveStatewireAuthHeaders({ apiKey, token, getToken }, ctx),\n    isNewChat,\n    // Queued entries render in the SDK's queue panel, so only the steer lane\n    // projects into the message tail.\n    laneProjection: 'steer-only',\n    // Durable session: a reload resumes the lane and resends whatever the\n    // server has not marked durable. Scoped by host AND principal — a thread\n    // id is only meaningful against the backend that minted it, and a stored\n    // lane must never resend against another signed-in user. (Consumers\n    // server-render this SDK; the core's availability probe keeps those\n    // sessions process-local, as before the seam existed.) Until the sign-in\n    // provider knows who is signed in, the lane is pending: the transport\n    // stays parked and nothing is mounted on a stand-in key the session could\n    // not move off (`statewireSessionPrincipal`).\n    session:\n      principal === null\n        ? { kind: 'pending' }\n        : {\n            kind: 'local-storage',\n            key: (id) => statewireSessionKey({ syncUrl, principal, threadId: id }),\n          },\n    snapshotCache,\n    // Head interest (see `ATHENA_SDK_MESSAGE_WINDOW`): the tail of the\n    // transcript instead of every message; the chat UI's history edge pages\n    // older ranges in and fetches cut tool outputs into `toolOutputs`.\n    messageWindow,\n    toolOutputs,\n    // Each `task` card's nested transcript becomes its tool-call part's\n    // `messages` (assistant-ui's nested-thread channel), which the subagent\n    // card (`SubagentTaskToolUI`) shows.\n    createConversionCache: createSubagentTranscriptConversionCache,\n    // The lane-cut contract only where the chat pages lanes (see `subagentLaneHistory`).\n    laneHistory: subagentLaneHistory,\n    capabilities: { edit: true, reload: true, continue: true },\n    // The composer stages the draft each send came from right before it\n    // sends; the message carries it as its composer markdown, so its bubble\n    // shows the text exactly as typed (`UserMessageText`).\n    getMessageMetadata: withStagedComposerMarkdown({ threadId }),\n    useClient: useSdkClient,\n    onStateChange: (state) => {\n      // Statewire publishes what the thread renders before its attach snapshot\n      // through here too (the placeholder, a remembered snapshot, and a replay\n      // boundary's pre-stream default), and on a thread mid-run it reports\n      // `connected` before the snapshot applies: only a state the host sent\n      // counts, whatever the connection says.\n      if (!isDeepAgentHostState(state)) return;\n      // The attach's first one ends the attach span (time-to-history).\n      const endSpan = attachSpanRef.current;\n      if (endSpan) {\n        attachSpanRef.current = null;\n        endSpan('statewire.snapshot', { data: { thread_id: threadId } });\n      }\n      onServerState?.(state);\n    },\n    onConnectionChange: (connection) => {\n      athenaDiagnostics.gauge('statewire.connection', connection?.status ?? null);\n      if (connection?.status === 'stopped') {\n        athenaDiagnostics.emit('statewire.connection', {\n          level: 'warn',\n          data: {\n            status: connection.status,\n            reason: connection.reason,\n            message: connection.message,\n          },\n        });\n      }\n      onConnectionChange?.(connection);\n    },\n    onRawConnectionChange,\n    onRunningChange,\n    ...(onCommandChange && { onCommandChange }),\n    // Each model-context notification pulls the latest getter through the\n    // core's per-render ref; the value-stable key re-registers (and so\n    // notifies) only when the built runConfig actually changed. On a thread\n    // with a server config lane, agora keeps only the per-send keys of what\n    // this carries; `StatewireThreadConfigLaneSync` writes a changed model,\n    // system prompt, tool list, workbench or knowledge base to the lane itself.\n    runConfig: {\n      get: () => runConfigValue,\n      key: runConfigKey,\n    },\n    onError: (error) => {\n      if (!isStatewireChannelTeardown(error)) {\n        athenaDiagnostics.error(\n          'statewire.error',\n          error,\n          {\n            code: 'statewire_rejected',\n            message: 'The statewire host rejected a command',\n            hint: 'Inspect error.detail — agora rejections carry a structured {code, message}.',\n          },\n          { thread_id: threadId },\n        );\n      }\n      if (onError) {\n        onError(error);\n        return;\n      }\n      logUnhandledStatewireError('AthenaSDK', error);\n    },\n  });\n}\n"],"names":["DEEP_AGENT_DEFAULT_MESSAGE_WINDOW","useMemo","collectStatewireClientTools","resolveAgentProp","statewireSessionPrincipal","useContext","AthenaAuthContext","useRef","athenaDiagnostics","buildStatewireRunConfig","statewireClientToolWireEntries","Tools","useAui","useDeepAgentRuntime","resolveStatewireAuthHeaders","statewireSessionKey","createSubagentTranscriptConversionCache","withStagedComposerMarkdown","isDeepAgentHostState","isStatewireChannelTeardown","logUnhandledStatewireError"],"mappings":"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"}

package/dist/runtime/useAthenaStatewireRuntime.d.ts

@@ -1,5 +1,5 @@
 import type { AssistantClient, Toolkit } from '@assistant-ui/react';
-import { type DeepAgentMessageWindowDeclaration, type DeepAgentStreamValues, type DeepAgentThreadSnapshotCache, type DeepAgentToolOutputStore, type RegisteredClientTool, type UseDeepAgentThreadOptions } from '@athenaintel/agent-runtime';
+import { type DeepAgentMessageWindowDeclaration, type DeepAgentStreamValues, type DeepAgentThreadSnapshotCache, type DeepAgentToolOutputStore, type RegisteredClientTool, type UseDeepAgentThreadOptions } from '../agent-runtime/src/index';
 import { type AthenaStatewireTokenGetter } from './statewire-auth-headers';
 import { DEFAULT_STATEWIRE_MODEL } from './statewire-run-config';
 export { DEFAULT_STATEWIRE_MODEL };
@@ -38,6 +38,18 @@ export interface AthenaStatewireRuntimeConfig {
     snapshotCache?: DeepAgentThreadSnapshotCache;
     /** The head interest stated on the attach (see {@link ATHENA_SDK_MESSAGE_WINDOW}, the default). */
     messageWindow?: DeepAgentMessageWindowDeclaration;
+    /**
+     * Whether the chat this runtime serves loads a subagent lane's earlier steps
+     * on request, as `AthenaChat`'s subagent card does ("Load earlier steps").
+     * When true, its attaches declare the deep-agent lane-cut contract
+     * (protocol 2): the host sends a finished subagent's card cut to its newest
+     * steps, as it sends a running one, and the card reads the rest. Default
+     * `false`, so a chat that does not page lanes declares the default contract
+     * and finished lanes arrive whole; a host whose `AthenaChat` renders every
+     * `task` call in the subagent card turns it on through `AthenaProvider`'s
+     * `subagentLaneHistory`. Read once per attach.
+     */
+    subagentLaneHistory?: boolean;
     /**
      * Full tool outputs fetched back for a windowed wire's cut tool messages;
      * the thread re-converts when one lands. `AthenaProvider` owns one per
@@ -80,6 +92,8 @@ export interface AthenaStatewireRuntimeConfig {
     onRawConnectionChange?: UseDeepAgentThreadOptions['onRawConnectionChange'];
     /** Notified when a run starts/stops. */
     onRunningChange?: UseDeepAgentThreadOptions['onRunningChange'];
+    /** Every statewire command-lifecycle update (the chat outbox lets a handed-over message go on it). */
+    onCommandChange?: UseDeepAgentThreadOptions['onCommandChange'];
     /**
      * Observes the host's own state: called with the attach snapshot and then on
      * every later frame (`isDeepAgentHostState`) — never with the placeholder or