@athenaintel/react 0.16.3 → 0.18.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/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

@@ -3,7 +3,6 @@ import type { Toolkit } from '@assistant-ui/react';
 import { type AthenaEnvironment } from '../lib/athena-urls';
 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 +16,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 +56,16 @@ 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`. */
+     *  Prefer `config.getToken`. */
     getToken?: () => string | null | Promise<string | null>;
-    /** Additional fields merged into runConfig.custom. Only used when
-     *  `transport` is 'statewire'. Prefer `config.extraRunConfig`. */
+    /** 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 +73,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 +121,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,27 +1,28 @@
 import type { AthenaEnvironment } from '../lib/athena-urls';
-import type { AthenaTransport } from '../runtime/transport';
 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'. */
+     *  clients). Takes priority over `token` when it resolves. */
     getToken?: () => string | null | Promise<string | null>;
-    /** Additional fields merged into runConfig.custom. Only used when
-     *  `transport` is 'statewire'. */
+    /** 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). Defaults to
-     *  the `apiUrl` host + `/v2/threads`. Only used when transport is 'statewire'. */
+    /** 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. Defaults to the matching Athena environment. */
+    /** 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;
     /** URL for the Athena frontend app origin. Defaults to the matching Athena environment. */
     appUrl?: 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/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/auth.d.ts

@@ -1,15 +1,44 @@
 export interface ParentBridgeState {
     /** PropelAuth access token from the parent window. */
     token: string | null;
-    /** Sync server chat URL provided by the Marathon wrapper. */
+    /** Legacy Iris chat stream URL (`…/api/chat`) provided by the host. */
     apiUrl: string | null;
-    /** Athena backend URL provided by the Marathon wrapper. */
+    /** Legacy Athena backend URL (`…/api/assistant-ui`) provided by the host. */
     backendUrl: string | null;
+    /**
+     * Statewire sync mount (`…/v2/threads`) minted by the host. `null` when the
+     * host predates the statewire-native mint fields; the provider then derives
+     * it from `apiUrl`'s origin.
+     */
+    statewireSyncUrl: string | null;
+    /**
+     * Bare Agora API base (no path) minted by the host. `null` when the host
+     * only serves the legacy `backendUrl`; REST helpers strip that URL's
+     * `/api/assistant-ui` suffix themselves.
+     */
+    backendBaseUrl: string | null;
     /** Athena frontend origin provided by the parent wrapper. */
     appUrl: string | null;
     /** True once config has been received from the parent (or timeout fired). */
     ready: boolean;
 }
+declare const BRIDGE_URL_FIELDS: readonly ['apiUrl', 'backendUrl', 'statewireSyncUrl', 'backendBaseUrl', 'appUrl'];
+type BridgeUrlField = (typeof BRIDGE_URL_FIELDS)[number];
+/** The URL half of {@link ParentBridgeState} — what a host can hand the SDK. */
+export type ParentBridgeUrls = Pick<ParentBridgeState, BridgeUrlField>;
+/**
+ * Fold an `athena-config` postMessage payload over the current URL set. A
+ * field is taken only when it is a string; anything else keeps the previous
+ * value. A parent that predates the statewire-native fields therefore leaves
+ * `statewireSyncUrl`/`backendBaseUrl` at `null`, and the provider falls back
+ * to deriving them from the legacy URLs.
+ */
+export declare function mergeBridgeConfigMessage(previous: ParentBridgeUrls, payload: Partial<Record<BridgeUrlField, unknown>>): ParentBridgeUrls;
+/**
+ * Read the URL set out of a `/_athena/auth` mint body. Non-string fields are
+ * `null` — an older Marathon serves only the legacy `apiUrl`/`backendUrl`.
+ */
+export declare function readAuthMintUrls(data: Partial<Record<BridgeUrlField, unknown>>): ParentBridgeUrls;
 export interface ParentBridgeOptions {
     /**
      * Exact parent origins that are allowed to send auth/config via postMessage.
@@ -31,8 +60,11 @@ export declare const getAuthRetryDelay: (retryAttempt: number) => number;
  * 2. **Standalone (Marathon-served deploy URL)**: top-level navigation, no
  *    parent. The hook fetches `/_athena/auth` on its own origin. Marathon
  *    validates its session cookie (sent by the browser automatically) and
- *    returns `{ token, apiUrl, backendUrl, appUrl }`. A 404 means we're not
- *    on a Marathon origin — the hook falls through with empty state.
+ *    returns `{ token, statewireSyncUrl, backendBaseUrl, apiUrl, backendUrl,
+ *    appUrl }` — the statewire-native mount and bare Agora base alongside
+ *    the legacy chat-wire URLs, so old and new hosts both resolve. A 404
+ *    means we're not on a Marathon origin — the hook falls through with
+ *    empty state.
  *
  * In both modes a timeout safety net flips `ready: true` so the app never
  * blocks indefinitely.
@@ -43,3 +75,4 @@ export declare function useParentBridge({ trustedOrigins, }?: ParentBridgeOption
  * Prefer useParentBridge() for new code.
  */
 export declare function useParentAuth(): string | null;
+export {};

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

@@ -16,7 +16,6 @@ export declare function athenaStatewireErrorNotice(error: unknown): AthenaStatew
 export interface AthenaStatewireLifecycleState {
     connection: DeepAgentConnectionState | null;
     error: AthenaStatewireErrorNotice | null;
-    legacyReadOnly: boolean;
     reconnect: (() => void) | null;
     dismissError: () => void;
 }

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/useAthenaStatewireRuntime.d.ts

@@ -19,8 +19,9 @@ export interface AthenaStatewireRuntimeConfig {
     getToken?: () => string | null | Promise<string | null>;
     /** 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 +39,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,8 +49,6 @@ 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'];
 }
@@ -67,8 +62,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;