@athenaintel/react 0.17.0 → 0.19.0

package/dist/lib/athena-urls.d.ts

@@ -5,8 +5,6 @@ export interface AthenaEnvironmentUrls {
     appUrl: string;
 }
 export declare const DEFAULT_ATHENA_ENVIRONMENT: AthenaEnvironment;
-export declare const DEFAULT_API_URL: string;
-export declare const DEFAULT_BACKEND_URL: string;
 export declare const DEFAULT_APP_URL: string;
 /** Production statewire sync endpoint — the same host the mobile app and
  *  Chrome extension ship as their production statewire base. Exported as a

package/dist/lib/posthog/wrap-posthog-client.d.ts

@@ -1,11 +1,13 @@
 import type { CaptureResult, PostHog, Properties } from 'posthog-js';
 import type { CaptureOptions } from 'posthog-js';
 import { PosthogCaptureGate } from './capture-gate';
+type PosthogCaptureExceptionFn = (error: unknown, additionalProperties?: Properties) => CaptureResult | undefined;
 export type PosthogCaptureClient = Pick<PostHog, 'capture'> & {
-    captureException?: (error: unknown, additionalProperties?: Properties) => CaptureResult | undefined;
+    captureException?: PosthogCaptureExceptionFn;
 };
 export declare function getPosthogCaptureGate(): PosthogCaptureGate;
 export declare function resetPosthogCaptureGateForTests(): void;
 export declare function wrapPosthogClient<TClient extends PosthogCaptureClient>(client: TClient): TClient;
 export declare function capturePosthogEvent(client: PosthogCaptureClient | null | undefined, event: string, properties?: Properties, options?: CaptureOptions): void;
 export declare function capturePosthogException(client: PosthogCaptureClient | null | undefined, error: Error, properties?: Properties, options?: CaptureOptions): void;
+export {};

package/dist/misc-tool-uis-B2e0Okkn.cjs

@@ -0,0 +1,43 @@
+"use strict";
+const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
+require("./trash-2-B5OaNAL7.cjs");
+require("@assistant-ui/tap");
+require("statewire");
+const toolFallback = require("./tool-fallback-kfhpJQZa.cjs");
+require("@assistant-ui/react-statewire");
+require("@assistant-ui/store");
+require("@assistant-ui/core");
+const wrench = require("./wrench-BEf72cyP.cjs");
+const InstallPackageToolUIImpl = (props) => {
+  const { toolName, args, result, status } = props;
+  if (toolFallback.classifyToolResult({ status, result }).state === "rejected") {
+    return /* @__PURE__ */ jsxRuntime.jsx(toolFallback.ToolFallback, { ...props, icon: wrench.Package });
+  }
+  const typedArgs = args ?? {};
+  const packageName = toolFallback.describePackage(typedArgs);
+  const isRunning = (status == null ? void 0 : status.type) === "running";
+  const isFailed = (status == null ? void 0 : status.type) === "incomplete" || (status == null ? void 0 : status.type) === "complete" && !toolFallback.isToolResultSuccess(result);
+  const data = toolFallback.normalizeResult(result);
+  const detail = typeof result === "string" ? result : data ? JSON.stringify(data, null, 2) : null;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    toolFallback.ToolCard,
+    {
+      icon: wrench.Package,
+      status: isFailed && (status == null ? void 0 : status.type) === "complete" ? "incomplete" : (status == null ? void 0 : status.type) ?? "complete",
+      title: isRunning ? "Installing package..." : isFailed ? "Couldn't install package" : "Installed package",
+      subtitle: packageName,
+      toolName,
+      error: (status == null ? void 0 : status.type) === "incomplete" ? String(status.error ?? "") || void 0 : void 0,
+      args: typedArgs,
+      result,
+      children: !isRunning && detail ? /* @__PURE__ */ jsxRuntime.jsx(toolFallback.ExpandableSection, { label: "Show output", children: /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "max-h-64 overflow-auto whitespace-pre-wrap break-all text-[11px] leading-snug text-muted-foreground", children: detail }) }) : null
+    }
+  );
+};
+const InstallPackageToolUI = React.memo(
+  InstallPackageToolUIImpl
+);
+InstallPackageToolUI.displayName = "InstallPackageToolUI";
+exports.InstallPackageToolUI = InstallPackageToolUI;
+//# sourceMappingURL=misc-tool-uis-B2e0Okkn.cjs.map

package/dist/misc-tool-uis-B2e0Okkn.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc-tool-uis-B2e0Okkn.cjs","sources":["../src/tools/misc-tool-uis.tsx"],"sourcesContent":["/**\n * Small dedicated cards for tools whose generic fallback rendering read\n * poorly: currently the pip installer (Olympus registers it; the SDK's own\n * registry includes it).\n */\nimport { PackageIcon } from \"lucide-react\";\nimport { memo } from \"react\";\nimport type { ToolCallMessagePartComponent } from \"@assistant-ui/react\";\nimport {\n  classifyToolResult,\n  describePackage,\n  isToolResultSuccess,\n} from \"@athenaintel/agent-runtime\";\nimport { ExpandableSection, normalizeResult, ToolCard } from \"./primitives\";\nimport { ToolFallback } from \"./tool-fallback\";\n\nconst InstallPackageToolUIImpl: ToolCallMessagePartComponent = (props) => {\n  const { toolName, args, result, status } = props;\n  // An install the user refused at the approval gate is neither installed\n  // nor failed: the generic card owns the rejected treatment.\n  if (classifyToolResult({ status, result }).state === \"rejected\") {\n    return <ToolFallback {...props} icon={PackageIcon} />;\n  }\n  const typedArgs = (args ?? {}) as Record<string, unknown>;\n  const packageName = describePackage(typedArgs);\n  const isRunning = status?.type === \"running\";\n  const isFailed =\n    status?.type === \"incomplete\" || (status?.type === \"complete\" && !isToolResultSuccess(result));\n  const data = normalizeResult(result);\n  const detail =\n    typeof result === \"string\" ? result : data ? JSON.stringify(data, null, 2) : null;\n\n  return (\n    <ToolCard\n      icon={PackageIcon}\n      status={isFailed && status?.type === \"complete\" ? \"incomplete\" : (status?.type ?? \"complete\")}\n      title={\n        isRunning\n          ? \"Installing package...\"\n          : isFailed\n            ? \"Couldn't install package\"\n            : \"Installed package\"\n      }\n      subtitle={packageName}\n      toolName={toolName}\n      error={status?.type === \"incomplete\" ? String(status.error ?? \"\") || undefined : undefined}\n      args={typedArgs}\n      result={result}\n    >\n      {!isRunning && detail ? (\n        <ExpandableSection label=\"Show output\">\n          <pre className=\"max-h-64 overflow-auto whitespace-pre-wrap break-all text-[11px] leading-snug text-muted-foreground\">\n            {detail}\n          </pre>\n        </ExpandableSection>\n      ) : null}\n    </ToolCard>\n  );\n};\n\nexport const InstallPackageToolUI = memo(\n  InstallPackageToolUIImpl,\n) as unknown as ToolCallMessagePartComponent;\nInstallPackageToolUI.displayName = \"InstallPackageToolUI\";\n"],"names":["classifyToolResult","jsx","ToolFallback","PackageIcon","describePackage","isToolResultSuccess","normalizeResult","ToolCard","ExpandableSection","memo"],"mappings":";;;;;;;;;;;AAgBA,MAAM,2BAAyD,CAAC,UAAU;AACxE,QAAM,EAAE,UAAU,MAAM,QAAQ,WAAW;AAG3C,MAAIA,aAAAA,mBAAmB,EAAE,QAAQ,QAAQ,EAAE,UAAU,YAAY;AAC/D,WAAOC,2BAAAA,IAACC,aAAAA,cAAA,EAAc,GAAG,OAAO,MAAMC,OAAAA,SAAa;AAAA,EACrD;AACA,QAAM,YAAa,QAAQ,CAAA;AAC3B,QAAM,cAAcC,aAAAA,gBAAgB,SAAS;AAC7C,QAAM,aAAY,iCAAQ,UAAS;AACnC,QAAM,YACJ,iCAAQ,UAAS,iBAAiB,iCAAQ,UAAS,cAAc,CAACC,aAAAA,oBAAoB,MAAM;AAC9F,QAAM,OAAOC,aAAAA,gBAAgB,MAAM;AACnC,QAAM,SACJ,OAAO,WAAW,WAAW,SAAS,OAAO,KAAK,UAAU,MAAM,MAAM,CAAC,IAAI;AAE/E,SACEL,2BAAAA;AAAAA,IAACM,aAAAA;AAAAA,IAAA;AAAA,MACC,MAAMJ,OAAAA;AAAAA,MACN,QAAQ,aAAY,iCAAQ,UAAS,aAAa,gBAAgB,iCAAQ,SAAQ;AAAA,MAClF,OACE,YACI,0BACA,WACE,6BACA;AAAA,MAER,UAAU;AAAA,MACV;AAAA,MACA,QAAO,iCAAQ,UAAS,eAAe,OAAO,OAAO,SAAS,EAAE,KAAK,SAAY;AAAA,MACjF,MAAM;AAAA,MACN;AAAA,MAEC,UAAA,CAAC,aAAa,SACbF,2BAAAA,IAACO,gCAAA,EAAkB,OAAM,eACvB,UAAAP,2BAAAA,IAAC,OAAA,EAAI,WAAU,uGACZ,UAAA,OAAA,CACH,GACF,IACE;AAAA,IAAA;AAAA,EAAA;AAGV;AAEO,MAAM,uBAAuBQ,MAAAA;AAAAA,EAClC;AACF;AACA,qBAAqB,cAAc;;"}

package/dist/misc-tool-uis-gAiQw0Yl.js

@@ -0,0 +1,44 @@
+import { jsx } from "react/jsx-runtime";
+import { memo } from "react";
+import "./trash-2-CCwSURL-.js";
+import "@assistant-ui/tap";
+import "statewire";
+import { k as classifyToolResult, c as ToolFallback, y as describePackage, p as isToolResultSuccess, q as normalizeResult, b as ToolCard, E as ExpandableSection } from "./tool-fallback-DkQ3DLkn.js";
+import "@assistant-ui/react-statewire";
+import "@assistant-ui/store";
+import "@assistant-ui/core";
+import { P as Package } from "./wrench-CbrOlVYm.js";
+const InstallPackageToolUIImpl = (props) => {
+  const { toolName, args, result, status } = props;
+  if (classifyToolResult({ status, result }).state === "rejected") {
+    return /* @__PURE__ */ jsx(ToolFallback, { ...props, icon: Package });
+  }
+  const typedArgs = args ?? {};
+  const packageName = describePackage(typedArgs);
+  const isRunning = (status == null ? void 0 : status.type) === "running";
+  const isFailed = (status == null ? void 0 : status.type) === "incomplete" || (status == null ? void 0 : status.type) === "complete" && !isToolResultSuccess(result);
+  const data = normalizeResult(result);
+  const detail = typeof result === "string" ? result : data ? JSON.stringify(data, null, 2) : null;
+  return /* @__PURE__ */ jsx(
+    ToolCard,
+    {
+      icon: Package,
+      status: isFailed && (status == null ? void 0 : status.type) === "complete" ? "incomplete" : (status == null ? void 0 : status.type) ?? "complete",
+      title: isRunning ? "Installing package..." : isFailed ? "Couldn't install package" : "Installed package",
+      subtitle: packageName,
+      toolName,
+      error: (status == null ? void 0 : status.type) === "incomplete" ? String(status.error ?? "") || void 0 : void 0,
+      args: typedArgs,
+      result,
+      children: !isRunning && detail ? /* @__PURE__ */ jsx(ExpandableSection, { label: "Show output", children: /* @__PURE__ */ jsx("pre", { className: "max-h-64 overflow-auto whitespace-pre-wrap break-all text-[11px] leading-snug text-muted-foreground", children: detail }) }) : null
+    }
+  );
+};
+const InstallPackageToolUI = memo(
+  InstallPackageToolUIImpl
+);
+InstallPackageToolUI.displayName = "InstallPackageToolUI";
+export {
+  InstallPackageToolUI as I
+};
+//# sourceMappingURL=misc-tool-uis-gAiQw0Yl.js.map

package/dist/misc-tool-uis-gAiQw0Yl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc-tool-uis-gAiQw0Yl.js","sources":["../src/tools/misc-tool-uis.tsx"],"sourcesContent":["/**\n * Small dedicated cards for tools whose generic fallback rendering read\n * poorly: currently the pip installer (Olympus registers it; the SDK's own\n * registry includes it).\n */\nimport { PackageIcon } from \"lucide-react\";\nimport { memo } from \"react\";\nimport type { ToolCallMessagePartComponent } from \"@assistant-ui/react\";\nimport {\n  classifyToolResult,\n  describePackage,\n  isToolResultSuccess,\n} from \"@athenaintel/agent-runtime\";\nimport { ExpandableSection, normalizeResult, ToolCard } from \"./primitives\";\nimport { ToolFallback } from \"./tool-fallback\";\n\nconst InstallPackageToolUIImpl: ToolCallMessagePartComponent = (props) => {\n  const { toolName, args, result, status } = props;\n  // An install the user refused at the approval gate is neither installed\n  // nor failed: the generic card owns the rejected treatment.\n  if (classifyToolResult({ status, result }).state === \"rejected\") {\n    return <ToolFallback {...props} icon={PackageIcon} />;\n  }\n  const typedArgs = (args ?? {}) as Record<string, unknown>;\n  const packageName = describePackage(typedArgs);\n  const isRunning = status?.type === \"running\";\n  const isFailed =\n    status?.type === \"incomplete\" || (status?.type === \"complete\" && !isToolResultSuccess(result));\n  const data = normalizeResult(result);\n  const detail =\n    typeof result === \"string\" ? result : data ? JSON.stringify(data, null, 2) : null;\n\n  return (\n    <ToolCard\n      icon={PackageIcon}\n      status={isFailed && status?.type === \"complete\" ? \"incomplete\" : (status?.type ?? \"complete\")}\n      title={\n        isRunning\n          ? \"Installing package...\"\n          : isFailed\n            ? \"Couldn't install package\"\n            : \"Installed package\"\n      }\n      subtitle={packageName}\n      toolName={toolName}\n      error={status?.type === \"incomplete\" ? String(status.error ?? \"\") || undefined : undefined}\n      args={typedArgs}\n      result={result}\n    >\n      {!isRunning && detail ? (\n        <ExpandableSection label=\"Show output\">\n          <pre className=\"max-h-64 overflow-auto whitespace-pre-wrap break-all text-[11px] leading-snug text-muted-foreground\">\n            {detail}\n          </pre>\n        </ExpandableSection>\n      ) : null}\n    </ToolCard>\n  );\n};\n\nexport const InstallPackageToolUI = memo(\n  InstallPackageToolUIImpl,\n) as unknown as ToolCallMessagePartComponent;\nInstallPackageToolUI.displayName = \"InstallPackageToolUI\";\n"],"names":["PackageIcon"],"mappings":";;;;;;;;;;AAgBA,MAAM,2BAAyD,CAAC,UAAU;AACxE,QAAM,EAAE,UAAU,MAAM,QAAQ,WAAW;AAG3C,MAAI,mBAAmB,EAAE,QAAQ,QAAQ,EAAE,UAAU,YAAY;AAC/D,WAAO,oBAAC,cAAA,EAAc,GAAG,OAAO,MAAMA,SAAa;AAAA,EACrD;AACA,QAAM,YAAa,QAAQ,CAAA;AAC3B,QAAM,cAAc,gBAAgB,SAAS;AAC7C,QAAM,aAAY,iCAAQ,UAAS;AACnC,QAAM,YACJ,iCAAQ,UAAS,iBAAiB,iCAAQ,UAAS,cAAc,CAAC,oBAAoB,MAAM;AAC9F,QAAM,OAAO,gBAAgB,MAAM;AACnC,QAAM,SACJ,OAAO,WAAW,WAAW,SAAS,OAAO,KAAK,UAAU,MAAM,MAAM,CAAC,IAAI;AAE/E,SACE;AAAA,IAAC;AAAA,IAAA;AAAA,MACC,MAAMA;AAAAA,MACN,QAAQ,aAAY,iCAAQ,UAAS,aAAa,gBAAgB,iCAAQ,SAAQ;AAAA,MAClF,OACE,YACI,0BACA,WACE,6BACA;AAAA,MAER,UAAU;AAAA,MACV;AAAA,MACA,QAAO,iCAAQ,UAAS,eAAe,OAAO,OAAO,SAAS,EAAE,KAAK,SAAY;AAAA,MACjF,MAAM;AAAA,MACN;AAAA,MAEC,UAAA,CAAC,aAAa,SACb,oBAAC,mBAAA,EAAkB,OAAM,eACvB,UAAA,oBAAC,OAAA,EAAI,WAAU,uGACZ,UAAA,OAAA,CACH,GACF,IACE;AAAA,IAAA;AAAA,EAAA;AAGV;AAEO,MAAM,uBAAuB;AAAA,EAClC;AACF;AACA,qBAAqB,cAAc;"}

package/dist/provider/AthenaContext.d.ts

@@ -1,16 +1,9 @@
-import type { AthenaTransport } from '../runtime/transport';
 import type { AthenaProviderConfig } from './config';
 import type { AthenaCitationLinkOptions, AthenaLinkClickOptions } from './citation-links';
 export interface AthenaConfig extends Pick<AthenaProviderConfig, 'apiKey' | 'token'> {
     backendUrl: string;
     appUrl: string;
     enabledToolkits: string[];
-    /** Effective chat transport — the lane the provider actually mounted (the
-     *  SDK defaults to 'statewire'; see `DEFAULT_ATHENA_TRANSPORT`). Optional
-     *  only so hand-built `AthenaConfig` literals keep compiling; capability
-     *  gates treat an absent value as the conservative legacy lane (e.g.
-     *  `allowsMidRunSend(undefined)` is false). */
-    transport?: AthenaTransport;
     linkClicks?: AthenaLinkClickOptions;
     citationLinks?: AthenaCitationLinkOptions;
 }

package/dist/provider/AthenaProvider.d.ts

@@ -1,9 +1,9 @@
 import { type ReactNode } from 'react';
 import type { Toolkit } from '@assistant-ui/react';
 import { type AthenaEnvironment } from '../lib/athena-urls';
+import type { AthenaStatewireTokenGetter } from '../runtime/statewire-auth-headers';
 import { type AthenaDiagnosticEvent, type AthenaDiagnosticLevel, type AthenaDiagnosticsConfig } from '../diagnostics/athena-diagnostics';
 import type { AthenaSdkError } from '../diagnostics/errors';
-import { type AthenaTransport } from '../runtime/transport';
 import type { AthenaProviderConfig } from './config';
 import type { AthenaCitationLinkOptions, AthenaLinkClickOptions } from './citation-links';
 import { type AthenaTheme } from '../theme';
@@ -17,35 +17,39 @@ export interface AthenaProviderProps {
     /** @deprecated Prefer `config.token`. PropelAuth token. If provided, takes priority over apiKey. If omitted, the SDK
      *  will automatically listen for a token from the parent window via PostMessage. */
     token?: string | null;
-    /** Agent selector.
+    /** Run the thread AS a published collab agent. The only accepted shape is
+     *  `collab_agent:<asset_id>`: the thread then uses that agent's prompt,
+     *  tools, and model default, and the caller must have view access to the
+     *  agent asset. Omit it (or pass a blank string) to run the Athena deep agent.
      *
-     *  - `legacy` transport: any agent name (defaults to 'athena_assist_agent'),
-     *    including `collab_agent:<asset_id>` refs.
-     *  - `statewire` transport: only `collab_agent:<asset_id>` refs apply — the
-     *    thread then runs AS that published collab agent (its prompt, tools, and
-     *    model default), and the caller must have view access to the agent
-     *    asset. Any other value is ignored with a `sdk.config.warning`
-     *    diagnostic, because the statewire host always runs the Athena deep
-     *    agent. */
+     *  Any other non-blank value throws at render — the statewire host cannot
+     *  honour named agents, and a selector that is silently dropped would let a
+     *  misconfigured deployment answer as the wrong agent. */
     agent?: string;
     /** Collab-agent channel id — a built-in channel (`email`, `sms`, …) or a
      *  user-defined custom channel id from the agent's Channels tab. Selects
      *  that channel's configuration overrides and stamps the session's origin.
-     *  Only meaningful with a `collab_agent:<asset_id>` `agent` on the
-     *  `statewire` transport; sent as `collab_channel_id`. An unknown or
-     *  disabled channel rejects the run with a structured, teaching error. */
+     *  Only meaningful together with a `collab_agent:<asset_id>` `agent`; sent
+     *  as `collab_channel_id`. An unknown or disabled channel rejects the run
+     *  with a structured, teaching error. */
     channel?: string;
-    /** LLM model identifier. Defaults to 'claude-opus-4-8-thinking-max-fast'. */
+    /** LLM model identifier. Defaults to the deep-agent default model
+     *  (`DEFAULT_STATEWIRE_MODEL`) — or, when a collab agent is selected, to
+     *  the model its author configured. */
     model?: string;
     /** Backend toolkit IDs to enable (e.g. 'document_toolkit', 'web_search_browse_toolkit'). */
     tools?: string[];
     /** Frontend tools that execute in the browser. The agent can invoke these.
      *  Merged on top of the SDK's default auto-open tools; entries here take
-     *  precedence over defaults with the same name. */
+     *  precedence over defaults with the same name. Tools with a local
+     *  `execute` are declared to the backend as `client_tools` and run through
+     *  the statewire client-tool bridge. */
     frontendTools?: Toolkit;
     /** Disable the SDK's default auto-open behavior for created/touched assets. */
     disableAutoOpen?: boolean;
-    /** @deprecated Prefer `config.apiUrl`. URL for the chat streaming endpoint. */
+    /** @deprecated Prefer `config.apiUrl`. URL on the Iris host fronting the
+     *  deployment; its origin derives the statewire sync mount when
+     *  `statewireSyncUrl` is not set. */
     apiUrl?: string;
     /** @deprecated Prefer `config.backendUrl`. URL for the Athena backend API. */
     backendUrl?: string;
@@ -53,29 +57,17 @@ export interface AthenaProviderProps {
     appUrl?: string;
     /** @deprecated Prefer `config.environment`. Athena environment preset used when URLs are not explicitly provided. */
     environment?: AthenaEnvironment;
-    /** Chat transport mode. Defaults to 'statewire' (the deep-agent statewire
-     *  sync host, `…/v2/threads`): the thread is hosted server-side and
-     *  replicated live, so history, reconnect, and run scheduling come from the
-     *  server snapshot. Works with and without `enableThreadList`.
-     *
-     *  Pass 'legacy' to opt a deployment back onto the legacy Iris `/api/chat`
-     *  assistant-transport stream. Threads are transport-scoped: conversations
-     *  created on one transport are read-only from the other.
-     *
-     *  On statewire the `agent` prop only accepts `collab_agent:<asset_id>`
-     *  refs (the host always runs the Athena deep agent), and `model` defaults
-     *  to the deep-agent default model. */
-    transport?: AthenaTransport;
     /** Resolve the latest auth token immediately before a request (for
      *  expiring clients). Takes priority over `token` when it resolves.
-     *  Only used when `transport` is 'statewire'. Prefer `config.getToken`. */
-    getToken?: () => string | null | Promise<string | null>;
-    /** Additional fields merged into runConfig.custom. Only used when
-     *  `transport` is 'statewire'. Prefer `config.extraRunConfig`. */
+     *  Prefer `config.getToken` (see its `force` contract for refused
+     *  credentials). */
+    getToken?: AthenaStatewireTokenGetter;
+    /** Additional fields merged into runConfig.custom. Prefer
+     *  `config.extraRunConfig`. */
     extraRunConfig?: Record<string, unknown>;
     /** Statewire sync base URL override (the `…/v2/threads` mount). Defaults to
-     *  the effective `apiUrl` host + `/v2/threads`. Only used when `transport`
-     *  is 'statewire'. */
+     *  the mount a Marathon host mints, then the effective `apiUrl` host +
+     *  `/v2/threads`. Prefer `config.statewireSyncUrl`. */
     statewireSyncUrl?: string;
     /** Asset IDs to include in the workbench. */
     workbench?: string[];
@@ -83,22 +75,6 @@ export interface AthenaProviderProps {
     knowledgeBase?: string[];
     /** System prompt override. */
     systemPrompt?: string;
-    /** Custom tool configurations (e.g. MCP servers).
-     *  Legacy transport only: passed through as `custom_tool_configs` in
-     *  runConfig.custom. The deep-agent statewire lane never sends it — that
-     *  runtime has no `custom_tool_configs` reader (MCP configuration is the
-     *  parsed `mcp_server_configs` key).
-     *
-     *  @example
-     *  <AthenaProvider customToolConfigs={{
-     *    mcp: {
-     *      "my-server": {
-     *        config: { transport: "streamable_http", url: "https://..." },
-     *      }
-     *    }
-     *  }}>
-     */
-    customToolConfigs?: Record<string, unknown>;
     /** Client app identifier for session filtering.
      *  Sessions created with this ID can be filtered in the thread list.
      *  E.g. "olympus", "athena-app", or a computer asset ID like "asset_<uuid>". */
@@ -147,4 +123,4 @@ export interface AthenaProviderProps {
      *  error handling, so integrations never fail silently. */
     onError?: (error: AthenaSdkError, event: AthenaDiagnosticEvent) => void;
 }
-export declare function AthenaProvider({ children, config, apiKey, token: tokenProp, agent, channel, model, tools, frontendTools, disableAutoOpen, apiUrl, backendUrl, appUrl, environment, transport, statewireSyncUrl, getToken, extraRunConfig, workbench, knowledgeBase, systemPrompt, customToolConfigs, appId, threadId: threadIdProp, enableThreadList, theme, linkClicks, citationLinks, posthog: posthogProp, debug, onDiagnostic, onError, }: AthenaProviderProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function AthenaProvider({ children, config, apiKey, token: tokenProp, agent, channel, model, tools, frontendTools, disableAutoOpen, apiUrl, backendUrl, appUrl, environment, statewireSyncUrl, getToken, extraRunConfig, workbench, knowledgeBase, systemPrompt, appId, threadId: threadIdProp, enableThreadList, theme, linkClicks, citationLinks, posthog: posthogProp, debug, onDiagnostic, onError, }: AthenaProviderProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/provider/config.d.ts

@@ -1,29 +1,33 @@
 import type { AthenaEnvironment } from '../lib/athena-urls';
-import type { AthenaTransport } from '../runtime/transport';
+import type { AthenaStatewireTokenGetter } from '../runtime/statewire-auth-headers';
 import type { PostHogConfig } from './PostHogProvider';
 export interface AthenaProviderConfig {
     /** Resolve the latest auth token immediately before a request (for expiring
-     *  clients). Only used when `transport` is 'statewire'. */
-    getToken?: () => string | null | Promise<string | null>;
-    /** Additional fields merged into runConfig.custom. Only used when
-     *  `transport` is 'statewire'. */
+     *  clients). Takes priority over `token` when it resolves.
+     *
+     *  Called with `{ force: true }` right after the statewire host refused the
+     *  previous credential (the transport's `staleAuth` signal): a getter that
+     *  caches must then mint a fresh token instead of returning the refused one.
+     *  Otherwise it is called with `{ force: false }` and may serve a cached
+     *  token. A getter that ignores the argument keeps working. */
+    getToken?: AthenaStatewireTokenGetter;
+    /** Additional fields merged into runConfig.custom. */
     extraRunConfig?: Record<string, unknown>;
     /** API key for standalone authentication when no token is provided. */
     apiKey?: string;
     /** PropelAuth token. Takes priority over apiKey when provided. */
     token?: string | null;
-    /** URL for the chat streaming endpoint. Defaults to the matching Athena environment. */
+    /** URL on the Iris host that fronts the deployment (historically the
+     *  `…/api/chat` endpoint). Its origin derives the statewire sync mount when
+     *  `statewireSyncUrl` is not set, and known Athena hosts map to the matching
+     *  app origin. Defaults to the matching Athena environment. */
     apiUrl?: string;
-    /** Chat transport mode. Defaults to 'statewire' (the deep-agent statewire
-     *  sync host); pass 'legacy' to opt back onto the legacy Iris chat stream.
-     *  Threads created on one transport are read-only from the other. */
-    transport?: AthenaTransport;
-    /** Statewire sync base URL override (the `…/v2/threads` mount). Only used
-     *  when transport is 'statewire'. Resolution order: this value, then the
-     *  `statewireSyncUrl` a Marathon host mints via `/_athena/auth` (or a
-     *  trusted parent posts), then the effective `apiUrl` host + `/v2/threads`. */
+    /** Statewire sync base URL override (the `…/v2/threads` mount). Resolution
+     *  order: this value, then the `statewireSyncUrl` a Marathon host mints via
+     *  `/_athena/auth` (or a trusted parent posts), then the effective `apiUrl`
+     *  host + `/v2/threads`. */
     statewireSyncUrl?: string;
-    /** URL for the Athena backend API — the bare Agora base or the legacy
+    /** URL for the Athena backend API — the bare Agora base or the historical
      *  `…/api/assistant-ui` endpoint (REST helpers accept both). Defaults to
      *  the host-provided value, then the matching Athena environment. */
     backendUrl?: string;

package/dist/provider/statewire-lifecycle-context.d.ts

@@ -1,10 +1,9 @@
 import type { AthenaStatewireLifecycleState } from '../runtime/statewire-lifecycle';
 /**
  * Statewire transport lifecycle (connection status, transport errors,
- * read-only flag, reconnect handle). Provided by `AthenaProvider` in
- * statewire mode; `null` on the legacy transport, so lifecycle-driven UI
- * renders nothing there.
+ * reconnect handle). Provided by `AthenaProvider`; `null` outside the
+ * provider, so lifecycle-driven UI renders nothing there.
  */
 export declare const AthenaStatewireLifecycleContext: import("react").Context<AthenaStatewireLifecycleState | null>;
-/** Read the statewire lifecycle, or null outside statewire mode. */
+/** Read the statewire lifecycle, or null outside `AthenaProvider`. */
 export declare function useAthenaStatewireLifecycle(): AthenaStatewireLifecycleState | null;

package/dist/provider/statewire-window-context.d.ts

@@ -0,0 +1,12 @@
+import type { DeepAgentToolOutputStore } from '@athenaintel/agent-runtime';
+/**
+ * The store of full tool outputs fetched back for a windowed wire's cut tool
+ * messages — the SAME instance the thread converts with
+ * (`useAthenaStatewireRuntime({ toolOutputs })`), so the edge row's lazy
+ * fetch and the converter's substitution meet. Provided by `AthenaProvider`
+ * (one per provider, cleared with the acting identity); hosts that mount the
+ * runtime themselves pass the store to `StatewireHistoryEdge` directly.
+ */
+export declare const StatewireToolOutputsContext: import("react").Context<DeepAgentToolOutputStore | null>;
+/** The provider's tool-output store, or `null` outside `AthenaProvider`. */
+export declare function useStatewireToolOutputs(): DeepAgentToolOutputStore | null;

package/dist/provider/types.d.ts

@@ -1,4 +1,3 @@
 export type { AthenaProviderProps } from './AthenaProvider';
 export type { AthenaProviderConfig } from './config';
-export type { AthenaRuntimeConfig } from '../runtime/useAthenaRuntime';
 export type { AthenaEnvironment } from '../lib/athena-urls';

package/dist/runtime/statewire-auth-headers.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Resolves the caller's current auth token immediately before a statewire
+ * attach or request. `force` is true right after the statewire host refused
+ * the previous credential (the transport's `staleAuth` signal): a getter that
+ * caches must then mint a fresh token instead of returning the one that was
+ * just refused. `force: false` (or no argument) may serve a cached token.
+ */
+export type AthenaStatewireTokenGetter = (options?: {
+    force?: boolean;
+}) => string | null | Promise<string | null>;
+export interface StatewireAuthSource {
+    /** API key for standalone authentication; used when no token resolves. */
+    apiKey?: string;
+    /** A token the host already holds; `getToken` takes priority when it resolves one. */
+    token?: string | null;
+    /** Live token resolver for expiring credentials. */
+    getToken?: AthenaStatewireTokenGetter;
+}
+/**
+ * The token a statewire attach or REST request presents: `getToken` (with the
+ * transport's `staleAuth` as `force`) when provided, falling back to the
+ * host-held `token` when the getter resolves nothing. A getter failure
+ * propagates — a request must fail rather than silently go anonymous.
+ */
+export declare function resolveStatewireAuthToken(source: StatewireAuthSource, { staleAuth }: {
+    staleAuth: boolean;
+}): Promise<string | null | undefined>;
+/**
+ * The auth headers a statewire attach or request carries — the same credential
+ * plumbing the legacy transport used: a token (resolved live through
+ * `getToken` when provided, with the transport's `staleAuth` passed as `force`)
+ * rides `Authorization: Bearer`, and an API key falls back to `X-API-KEY`. Both
+ * are accepted by the statewire host. Credential rotation reaches the next
+ * request because callers read `source` fresh per resolve.
+ */
+export declare function resolveStatewireAuthHeaders(source: StatewireAuthSource, { staleAuth }: {
+    staleAuth: boolean;
+}): Promise<Record<string, string>>;

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

@@ -16,7 +16,31 @@ export declare function athenaStatewireErrorNotice(error: unknown): AthenaStatew
 export interface AthenaStatewireLifecycleState {
     connection: DeepAgentConnectionState | null;
     error: AthenaStatewireErrorNotice | null;
-    legacyReadOnly: boolean;
     reconnect: (() => void) | null;
     dismissError: () => void;
 }
+/** The provider's reducer state behind {@link AthenaStatewireLifecycleState}. */
+export interface StatewireLifecycleReducerState {
+    connection: DeepAgentConnectionState | null;
+    error: AthenaStatewireErrorNotice | null;
+    reconnect: (() => void) | null;
+}
+export type StatewireLifecycleAction = {
+    type: 'connection';
+    connection: DeepAgentConnectionState | null;
+} | {
+    type: 'error';
+    error: AthenaStatewireErrorNotice | null;
+} | {
+    type: 'raw-connection';
+    reconnect: () => void;
+};
+export declare const initialStatewireLifecycle: StatewireLifecycleReducerState;
+/**
+ * Folds the runtime's lifecycle observations into the banner state. A healthy
+ * channel — connected, or disconnected only because the instance is quiet
+ * (`idle`) or the chat has not sent yet (`deferred`) — clears a stale
+ * send/transport error: leaving it up tells the user the chat is broken after
+ * it has come back.
+ */
+export declare function statewireLifecycleReducer(state: StatewireLifecycleReducerState, action: StatewireLifecycleAction): StatewireLifecycleReducerState;

package/dist/runtime/statewire-run-config.d.ts

@@ -1,19 +1,32 @@
-/** Deep-agent default model — matches the Olympus and mobile statewire hosts.
- *  The legacy transport keeps its own default model. */
+/** Deep-agent default model — matches the Olympus and mobile statewire hosts. */
 export declare const DEFAULT_STATEWIRE_MODEL = "claude-sonnet-5";
 /** Agent-id namespace for collab agents (`collab_agent:<asset_id>`). */
 export declare const COLLAB_AGENT_REF_PREFIX = "collab_agent:";
+/** The only shape the `agent` prop accepts, for error messages and docs. */
+export declare const COLLAB_AGENT_REF_SHAPE = "collab_agent:<asset_id>";
 /** The asset id when `agent` is a `collab_agent:<asset_id>` ref, else null. */
 export declare function parseCollabAgentRef(agent: string | undefined | null): string | null;
+/**
+ * Resolve the provider's `agent` prop to a collab-agent asset id.
+ *
+ * An omitted or blank `agent` means "no agent selected" — the thread runs the
+ * Athena deep agent — and resolves to `null`. A `collab_agent:<asset_id>` ref
+ * resolves to the asset id. Any other non-blank value throws: the statewire
+ * host cannot honour it, and a selector that is silently dropped would let a
+ * misconfigured deployment ship answers from the wrong agent.
+ */
+export declare function resolveAgentProp({ agent }: {
+    agent: string | undefined | null;
+}): string | null;
 export interface StatewireRunConfigOptions {
     /** LLM model identifier. Defaults to the deep-agent default model — unless a
      *  collab agent is selected and its author set one (the backend overlay
      *  applies the agent's model when the run sends none), in which case no
      *  model is sent so the agent's choice wins. */
     model?: string;
-    /** Agent selector. On statewire only the `collab_agent:<asset_id>` namespace
-     *  is meaningful: the run executes AS that published collab agent (prompt,
-     *  tools, model default). Any other value is ignored by the host. */
+    /** Agent selector. Only the `collab_agent:<asset_id>` shape is accepted: the
+     *  run executes AS that published collab agent (prompt, tools, model
+     *  default). Any other non-empty value throws (see {@link resolveAgentProp}). */
     agent?: string;
     /** Collab-agent channel id (built-in like `email`/`sms`, or a user-defined
      *  custom channel id) selecting that channel's configuration overrides.

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

@@ -0,0 +1,13 @@
+/**
+ * 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
+ * backend that minted it, and a shared browser must never resend one user's
+ * un-settled commands under the next user's token — so the key carries WHO is
+ * signed in as well as where. The principal is a non-secret user id;
+ * API-key-only hosts (no auth provider above) share one anonymous scope.
+ */
+export declare function statewireSessionKey({ syncUrl, principal, threadId, }: {
+    syncUrl: string;
+    principal: string;
+    threadId: string;
+}): string;

package/dist/runtime/useAthenaStatewireRuntime.d.ts

@@ -1,8 +1,17 @@
 import type { AssistantClient, Toolkit } from '@assistant-ui/react';
-import { type UseDeepAgentThreadOptions } from '@athenaintel/agent-runtime';
-import { type StatewireClientTool } from '../chat/statewire-client-tools';
+import { type DeepAgentMessageWindowDeclaration, type DeepAgentThreadSnapshotCache, type DeepAgentToolOutputStore, type RegisteredClientTool, type UseDeepAgentThreadOptions } from '@athenaintel/agent-runtime';
+import { type AthenaStatewireTokenGetter } from './statewire-auth-headers';
 import { DEFAULT_STATEWIRE_MODEL } from './statewire-run-config';
 export { DEFAULT_STATEWIRE_MODEL };
+/**
+ * The message window every SDK attach declares (`x-athena-deep-agent-window`):
+ * the hello carries the transcript's tail plus the `messagesWindow` lane
+ * instead of every message — megabytes on long threads, over the 1 MiB frame
+ * limit of stock websocket clients. Older pages load from the
+ * `StatewireHistoryEdge` row the chat UI mounts above the messages, and cut
+ * tool outputs are fetched back for the cards that show them.
+ */
+export declare const ATHENA_SDK_MESSAGE_WINDOW: DeepAgentMessageWindowDeclaration;
 export interface AthenaStatewireRuntimeConfig {
     /** Base URL of the statewire sync host (the `…/v2/threads` mount). */
     syncUrl: string;
@@ -15,12 +24,35 @@ export interface AthenaStatewireRuntimeConfig {
     apiKey?: string;
     /** Auth token. Takes priority over apiKey. */
     token?: string | null;
-    /** Resolve the latest token immediately before a request (for expiring clients). */
-    getToken?: () => string | null | Promise<string | null>;
+    /** Resolve the latest token immediately before a request (for expiring
+     *  clients). Called with `{ force: true }` right after the host refused the
+     *  previous credential (the transport's `staleAuth`), so a caching getter
+     *  mints a fresh token instead of returning the refused one. */
+    getToken?: AthenaStatewireTokenGetter;
+    /**
+     * Per-provider LRU of each thread's last wire state. A switch back to a
+     * remembered thread mounts with that snapshot and projects ready on the
+     * first frame instead of a loading treatment; the attach snapshot then
+     * replaces it. Owned above the per-thread mount so it survives switches.
+     */
+    snapshotCache?: DeepAgentThreadSnapshotCache;
+    /**
+     * The message window declared on the attach (see
+     * {@link ATHENA_SDK_MESSAGE_WINDOW}, the default). `false` keeps the full
+     * snapshot for a host that renders no history loader.
+     */
+    messageWindow?: DeepAgentMessageWindowDeclaration | false;
+    /**
+     * Full tool outputs fetched back for a windowed wire's cut tool messages;
+     * the thread re-converts when one lands. `AthenaProvider` owns one per
+     * provider and hands the same store to `StatewireHistoryEdge`.
+     */
+    toolOutputs?: DeepAgentToolOutputStore;
     /** LLM model identifier. Defaults to the deep-agent default model. */
     model?: string;
-    /** Agent selector: only `collab_agent:<asset_id>` refs are meaningful here
-     *  (the run executes AS that published collab agent). Other values warn. */
+    /** Agent selector: only `collab_agent:<asset_id>` refs are accepted (the run
+     *  executes AS that published collab agent). Any other non-empty value
+     *  throws — see `resolveAgentProp`. */
     agent?: string;
     /** Collab-agent channel id selecting that channel's overrides. */
     channel?: string;
@@ -38,10 +70,6 @@ export interface AthenaStatewireRuntimeConfig {
     knowledgeBase?: string[];
     /** System prompt override. */
     systemPrompt?: string;
-    /** Legacy-transport option accepted for shared-config compatibility, never
-     *  sent: the deep-agent runtime has no `custom_tool_configs` reader (MCP
-     *  configuration is the parsed `mcp_server_configs` key). */
-    customToolConfigs?: Record<string, unknown>;
     /** Client app identifier for session filtering. Sent as app_id in runConfig.custom. */
     appId?: string;
     /** Additional fields merged into runConfig.custom. */
@@ -52,14 +80,12 @@ export interface AthenaStatewireRuntimeConfig {
     onConnectionChange?: UseDeepAgentThreadOptions['onConnectionChange'];
     /** Raw connection observer — carries the transport's reconnect handle. */
     onRawConnectionChange?: UseDeepAgentThreadOptions['onRawConnectionChange'];
-    /** Notified when the snapshot flags a read-only pre-cutover thread. */
-    onLegacyReadOnly?: UseDeepAgentThreadOptions['onLegacyReadOnly'];
     /** Notified when a run starts/stops. */
     onRunningChange?: UseDeepAgentThreadOptions['onRunningChange'];
 }
 /** The client tools derived from the runtime's frontend toolkit — exposed so
  *  the provider can mount the client-tool bridge with the same set. */
-export declare function useStatewireClientTools(frontendToolkit: Toolkit | undefined): StatewireClientTool[];
+export declare function useStatewireClientTools(frontendToolkit: Toolkit | undefined): RegisteredClientTool[];
 /**
  * Statewire runtime for the Athena SDK — a thin shim over the shared
  * `@athenaintel/agent-runtime` `useDeepAgentRuntime`: it attaches to the
@@ -67,8 +93,8 @@ export declare function useStatewireClientTools(frontendToolkit: Toolkit | undef
  * `AssistantClient` to mount via `AuiProvider` — the same integration shape as
  * the Olympus, Chrome extension, Office, and mobile statewire hosts.
  *
- * Auth mirrors the legacy transport's credential plumbing: a token (resolved
- * live through `getToken` when provided) rides `Authorization: Bearer`, and
- * an API key falls back to `X-API-KEY` — both accepted by the statewire host.
+ * Auth: a token (resolved live through `getToken` when provided) rides
+ * `Authorization: Bearer`, and an API key falls back to `X-API-KEY` — both
+ * accepted by the statewire host.
  */
 export declare function useAthenaStatewireRuntime(config: AthenaStatewireRuntimeConfig): AssistantClient;