@athenaintel/react 0.10.40 → 0.10.41-rc.1

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

@@ -8,6 +8,36 @@ 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
+ *  constant for explicit configuration; it is deliberately NOT used as an
+ *  implicit fallback (see {@link resolveStatewireSyncUrl}). */
+export declare const DEFAULT_STATEWIRE_SYNC_URL = "https://iris.prd.athenaintel.com/v2/threads";
+/**
+ * Derive the statewire sync endpoint (the `…/v2/threads` mount) that lives on
+ * the same host as the Iris chat streaming endpoint: staging
+ * `https://iris.stg.athenaintel.com/api/chat` maps to
+ * `https://iris.stg.athenaintel.com/v2/threads`, and likewise for production
+ * and workspace Iris hosts. Unparseable inputs return `null` so callers can
+ * fall back explicitly.
+ */
+export declare function deriveStatewireSyncUrl({ apiUrl, }: {
+    apiUrl?: string | null;
+}): string | null;
+/**
+ * Resolve the statewire sync endpoint for a provider configuration: an
+ * explicit `statewireSyncUrl` wins, otherwise it is derived from the
+ * effective `apiUrl` host.
+ *
+ * When neither yields a URL this throws instead of falling back to an Athena
+ * default — mirroring `deriveAthenaApiUrl`'s null-for-unknown-hosts rule, so
+ * a misconfigured custom deployment can never silently send its bearer token
+ * or API key to Athena production.
+ */
+export declare function resolveStatewireSyncUrl({ statewireSyncUrl, apiUrl, }: {
+    statewireSyncUrl?: string;
+    apiUrl?: string | null;
+}): string;
 export declare function getAthenaEnvironmentUrls({ environment, }?: {
     environment?: AthenaEnvironment;
 }): AthenaEnvironmentUrls;

package/dist/provider/AthenaContext.d.ts

@@ -1,9 +1,13 @@
+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. Statewire supports mid-run sends (the server
+     *  queues them), so composer gating differs per transport. */
+    transport: AthenaTransport;
     linkClicks?: AthenaLinkClickOptions;
     citationLinks?: AthenaCitationLinkOptions;
 }

package/dist/provider/AthenaProvider.d.ts

@@ -1,6 +1,7 @@
 import { type ReactNode } from 'react';
 import type { Toolkit } from '@assistant-ui/react';
 import { type AthenaEnvironment } from '../lib/athena-urls';
+import { type AthenaTransport } from '../runtime/transport';
 import type { AthenaProviderConfig } from './config';
 import type { AthenaCitationLinkOptions, AthenaLinkClickOptions } from './citation-links';
 import { type AthenaTheme } from '../theme';
@@ -34,6 +35,26 @@ 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 'legacy' (the Iris `/api/chat`
+     *  assistant-transport stream). Pass 'statewire' to attach to the
+     *  deep-agent statewire sync host (`…/v2/threads`) instead — 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`.
+     *
+     *  The `agent` prop is legacy-only (the statewire host always runs the
+     *  Athena deep agent), and `model` defaults to the deep-agent default
+     *  model in this mode. */
+    transport?: AthenaTransport;
+    /** Resolve the latest auth token immediately before a request (for
+     *  expiring clients). Takes priority over `token` when it resolves. */
+    getToken?: () => string | null | Promise<string | null>;
+    /** Additional fields merged into runConfig.custom (statewire transport). */
+    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'. */
+    statewireSyncUrl?: string;
     /** Asset IDs to include in the workbench. */
     workbench?: string[];
     /** Knowledge base IDs for RAG context. */
@@ -83,4 +104,4 @@ export interface AthenaProviderProps {
      *  Prefer `config.posthog` for structured configuration. */
     posthog?: PostHogConfig;
 }
-export declare function AthenaProvider({ children, config, apiKey, token: tokenProp, agent, model, tools, frontendTools, disableAutoOpen, apiUrl, backendUrl, appUrl, environment, workbench, knowledgeBase, systemPrompt, customToolConfigs, appId, threadId: threadIdProp, enableThreadList, theme, linkClicks, citationLinks, posthog: posthogProp, }: AthenaProviderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+export declare function AthenaProvider({ children, config, apiKey, token: tokenProp, agent, 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, }: AthenaProviderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;

package/dist/provider/config.d.ts

@@ -1,4 +1,5 @@
 import type { AthenaEnvironment } from '../lib/athena-urls';
+import type { AthenaTransport } from '../runtime/transport';
 import type { PostHogConfig } from './PostHogProvider';
 export interface AthenaProviderConfig {
     /** API key for standalone authentication when no token is provided. */
@@ -7,6 +8,12 @@ export interface AthenaProviderConfig {
     token?: string | null;
     /** URL for the chat streaming endpoint. Defaults to the matching Athena environment. */
     apiUrl?: string;
+    /** Chat transport mode. Defaults to 'legacy'; pass 'statewire' to attach to
+     *  the deep-agent statewire sync host instead of the legacy chat stream. */
+    transport?: AthenaTransport;
+    /** Statewire sync base URL override (the `…/v2/threads` mount). Defaults to
+     *  the `apiUrl` host + `/v2/threads`. Only used when transport is 'statewire'. */
+    statewireSyncUrl?: string;
     /** URL for the Athena backend API. Defaults to the matching Athena environment. */
     backendUrl?: string;
     /** URL for the Athena frontend app origin. Defaults to the matching Athena environment. */

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

@@ -0,0 +1,10 @@
+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.
+ */
+export declare const AthenaStatewireLifecycleContext: import("react").Context<AthenaStatewireLifecycleState | null>;
+/** Read the statewire lifecycle, or null outside statewire mode. */
+export declare function useAthenaStatewireLifecycle(): AthenaStatewireLifecycleState | null;

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

@@ -0,0 +1,22 @@
+import type { DeepAgentConnectionState } from '@athenaintel/agent-runtime';
+/** A user-visible notice mapped from a statewire transport error. */
+export interface AthenaStatewireErrorNotice {
+    kind: 'paywall' | 'read-only' | 'command';
+    title: string;
+    message: string;
+}
+/**
+ * Map the statewire failure envelope to a concise, actionable notice.
+ * Returns null for expected channel teardowns (thread switch, unmount),
+ * which must not surface as errors.
+ */
+export declare function athenaStatewireErrorNotice(error: unknown): AthenaStatewireErrorNotice | null;
+/** Shared lifecycle state for the statewire transport, provided by
+ *  `AthenaProvider` in statewire mode and read by the chat banners. */
+export interface AthenaStatewireLifecycleState {
+    connection: DeepAgentConnectionState | null;
+    error: AthenaStatewireErrorNotice | null;
+    legacyReadOnly: boolean;
+    reconnect: (() => void) | null;
+    dismissError: () => void;
+}

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

@@ -0,0 +1,38 @@
+/** Deep-agent default model — matches the Olympus and mobile statewire hosts.
+ *  The legacy transport keeps its own default model. */
+export declare const DEFAULT_STATEWIRE_MODEL = "claude-sonnet-5";
+export interface StatewireRunConfigOptions {
+    /** LLM model identifier. Defaults to the deep-agent default model. */
+    model?: string;
+    /** Backend toolkit IDs to enable. */
+    tools?: string[];
+    /** Frontend tool IDs to include in enabled_tools. */
+    frontendToolIds?: string[];
+    /** Asset IDs to include in the workbench. */
+    workbench?: string[];
+    /** Knowledge base IDs for RAG context. */
+    knowledgeBase?: string[];
+    /** System prompt override. */
+    systemPrompt?: string;
+    /** Custom tool configurations, passed through as custom_tool_configs. */
+    customToolConfigs?: Record<string, unknown>;
+    /** Client app identifier, passed through as app_id. */
+    appId?: string;
+    /** Client-executed tool declarations, passed through as client_tools. The
+     *  deep-agent runtime binds each as an interrupt-backed tool the client
+     *  answers via the statewire client-tool bridge. */
+    clientTools?: Record<string, unknown>[];
+    /** Additional fields merged into runConfig.custom. */
+    extraRunConfig?: Record<string, unknown>;
+}
+/**
+ * Build the `runConfig` a deep-agent statewire run is driven by. Commands
+ * travel bare on the statewire channel, so this payload rides the ambient
+ * model context (`config.runConfig`) instead of the request body.
+ *
+ * The flattened `custom` fields drive the run, while `panel_config` carries a
+ * minimal panel state the backend persists per thread and replays on the
+ * statewire snapshot — so a session started from the SDK stays configured
+ * when reopened elsewhere.
+ */
+export declare function buildStatewireRunConfig(options?: StatewireRunConfigOptions): Record<string, unknown>;

package/dist/runtime/transport.d.ts

@@ -0,0 +1,26 @@
+export declare const ATHENA_TRANSPORTS: {
+    readonly legacy: 'legacy';
+    readonly statewire: 'statewire';
+};
+/** Chat transport mode: `legacy` (Iris `/api/chat` assistant-transport) or
+ *  `statewire` (Iris `/v2/threads` deep-agent statewire sync). */
+export type AthenaTransport = (typeof ATHENA_TRANSPORTS)[keyof typeof ATHENA_TRANSPORTS];
+/** Consumers opt in to statewire explicitly; the default stays legacy until
+ *  statewire has been validated live across SDK hosts. */
+export declare const DEFAULT_ATHENA_TRANSPORT: AthenaTransport;
+export interface ResolvedAthenaTransport {
+    transport: AthenaTransport;
+    /** Human-readable reason when the requested transport could not be honored. */
+    fallbackReason: string | null;
+}
+/**
+ * Resolve the effective chat transport for a provider configuration.
+ *
+ * Both provider modes (standalone and thread-list) support both transports;
+ * the resolver exists so a future incompatible combination can fall back
+ * with a reported reason instead of silently running the wrong transport.
+ */
+export declare function resolveAthenaTransport({ transport, }: {
+    transport?: AthenaTransport;
+    enableThreadList?: boolean;
+}): ResolvedAthenaTransport;

package/dist/runtime/useAthenaStatewireRuntime.d.ts

@@ -0,0 +1,67 @@
+import type { AssistantClient, Toolkit } from '@assistant-ui/react';
+import { type UseDeepAgentThreadOptions } from '@athenaintel/agent-runtime';
+import { type StatewireClientTool } from '../chat/statewire-client-tools';
+import { DEFAULT_STATEWIRE_MODEL } from './statewire-run-config';
+export { DEFAULT_STATEWIRE_MODEL };
+export interface AthenaStatewireRuntimeConfig {
+    /** Base URL of the statewire sync host (the `…/v2/threads` mount). */
+    syncUrl: string;
+    /** Thread ID the statewire session attaches to. */
+    threadId: string;
+    /** True only for a never-started local chat. Existing (or pre-assigned)
+     *  threads load until their server snapshot arrives. */
+    isNewChat?: boolean;
+    /** API key for authentication. Used when no auth token is provided. */
+    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>;
+    /** LLM model identifier. Defaults to the deep-agent default model. */
+    model?: string;
+    /** Backend toolkit IDs to enable. */
+    tools?: string[];
+    /** Frontend tool IDs to include in enabled_tools. */
+    frontendToolIds?: string[];
+    /** Frontend tools registered on the assistant client. Tools with a local
+     *  `execute` are also declared as `client_tools` and executed through the
+     *  statewire client-tool bridge. */
+    frontendToolkit?: Toolkit;
+    /** Asset IDs to include in the workbench. */
+    workbench?: string[];
+    /** Knowledge base IDs for RAG context. */
+    knowledgeBase?: string[];
+    /** System prompt override. */
+    systemPrompt?: string;
+    /** Custom tool configurations. Passed as custom_tool_configs in runConfig. */
+    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. */
+    extraRunConfig?: Record<string, unknown>;
+    /** Called on statewire transport errors (send rejections, stream failures). */
+    onError?: (error: Error) => void;
+    /** Projected connection status changes (deduped; null on unmount). */
+    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[];
+/**
+ * Statewire runtime for the Athena SDK: attaches to the agora-hosted
+ * deep-agent thread at `${syncUrl}/${threadId}` through the shared
+ * `@athenaintel/agent-runtime` core, and returns the `AssistantClient` to
+ * mount via `AuiProvider` — the same integration shape as the Chrome
+ * extension 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.
+ */
+export declare function useAthenaStatewireRuntime(config: AthenaStatewireRuntimeConfig): AssistantClient;

package/dist/threads/api.d.ts

@@ -10,6 +10,10 @@ export interface ThreadSummary {
     last_message: string | null;
     message_count: number;
     state: string | null;
+    start_channel?: string | null;
+    last_channel?: string | null;
+    /** Whether the calling user has seen this thread since it last changed. */
+    is_unread?: boolean;
 }
 export interface ThreadListResponse {
     threads: ThreadSummary[];
@@ -26,7 +30,17 @@ export declare function listThreads(backendUrl: string, auth: AuthConfig, opts?:
     offset?: number;
     exclude_triggered?: boolean;
     app_id?: string;
+    start_channel?: string;
 }): Promise<ThreadListResponse>;
+export interface ThreadReadStateResponse {
+    thread_id: string;
+    is_unread: boolean;
+}
+/** Store the calling user's read receipt for a thread. */
+export declare function setThreadReadState(backendUrl: string, auth: AuthConfig, opts: {
+    threadId: string;
+    isUnread: boolean;
+}): Promise<ThreadReadStateResponse>;
 export declare function createThread(backendUrl: string, auth: AuthConfig, opts?: {
     systemPrompt?: string;
     enabledTools?: string[];

package/dist/threads/statewire-thread-list.d.ts

@@ -0,0 +1,42 @@
+import { type ReactNode } from 'react';
+export interface AthenaStatewireThreadSummary {
+    id: string;
+    title: string | null;
+}
+/**
+ * Thread-list state for the statewire transport. The list itself is the same
+ * persisted Agora session list the legacy adapter reads; the ACTIVE thread is
+ * a plain id the statewire runtime attaches to — switching threads remounts
+ * the statewire session against the new `…/v2/threads/{id}` URL (the same
+ * model the mobile app uses).
+ */
+export interface AthenaStatewireThreadListState {
+    threads: AthenaStatewireThreadSummary[];
+    isLoading: boolean;
+    activeThreadId: string;
+    /** True while the active thread is a locally-minted chat with no server history. */
+    isNewChat: boolean;
+    selectThread: (threadId: string) => void;
+    newThread: () => void;
+    refresh: () => void;
+}
+export declare const AthenaStatewireThreadListContext: import("react").Context<AthenaStatewireThreadListState | null>;
+/** Read the statewire thread-list state, or null outside that mode. */
+export declare function useAthenaStatewireThreadList(): AthenaStatewireThreadListState | null;
+/**
+ * Provides the statewire thread-list state, with an SDK-scoped QueryClient so
+ * consumers do not need their own QueryClientProvider.
+ */
+export declare function AthenaStatewireThreadListProvider({ backendUrl, apiKey, token, appId, initialThreadId, children, }: {
+    backendUrl: string;
+    apiKey?: string;
+    token?: string | null;
+    appId?: string;
+    initialThreadId?: string;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Refreshes the thread list until a freshly-started thread's server-generated
+ * title appears. Mount inside the statewire runtime scope (needs aui state).
+ */
+export declare function StatewireThreadTitlePoller(): null;

package/dist/threads/useActiveThreadStateHydration.d.ts

@@ -3,12 +3,10 @@ interface ActiveThreadStateHydrationConfig {
     apiKey?: string;
     token?: string | null;
 }
-type HydratableThreadState = {
-    metadata?: {
-        remoteId?: string;
-    };
-    threadId: string;
+type HydratableThreadListItemState = {
+    remoteId?: string | undefined;
+    id: string;
 };
-export declare const selectHydratableThreadId: (state: HydratableThreadState) => string | null;
+export declare const selectHydratableThreadId: (state: HydratableThreadListItemState) => string | null;
 export declare function useActiveThreadStateHydration({ backendUrl, apiKey, token, }: ActiveThreadStateHydrationConfig): void;
 export {};

package/dist/threads/useAthenaThreadManager.d.ts

@@ -6,7 +6,6 @@
  *
  * Must be used inside `<AthenaProvider enableThreadList>`.
  */
-import { type ThreadListState } from '@assistant-ui/react';
 export interface AthenaThreadManagerState {
     /** The backend thread ID of the currently active thread, or null if not yet synced. */
     activeThreadId: string | null;
@@ -19,7 +18,13 @@ export interface AthenaThreadManagerState {
     /** Create and switch to a new empty thread. */
     switchToNewThread: () => Promise<void>;
 }
-type ActiveThreadState = Pick<ThreadListState, 'mainThreadId' | 'threadItems'>;
+type ActiveThreadState = {
+    mainThreadId: string;
+    threadItems: readonly {
+        id: string;
+        remoteId?: string | undefined;
+    }[];
+};
 export declare const selectActiveThreadRemoteId: (state: ActiveThreadState) => string | null;
 export declare function useAthenaThreadManager(): AthenaThreadManagerState | null;
 export {};

package/dist/tools/tool-uis.d.ts

@@ -47,6 +47,14 @@ export declare const DescribeDatabaseToolUI: ToolCallMessagePartComponent;
 export declare const ListDatabaseTablesToolUI: ToolCallMessagePartComponent;
 export declare const GetDatabaseTableSchemaToolUI: ToolCallMessagePartComponent;
 export declare const RunSqlToolUI: ToolCallMessagePartComponent;
+/**
+ * A rejected `update_sheet_range` write (data-validation violation, no-op, or
+ * other failure) comes back as `success: false` rather than raising, so build a
+ * concise, user-facing reason for the tool card instead of a false "Updated"
+ * success. Prefers naming the offending cells and their allowed values, then
+ * falls back to the backend error string, then a generic message.
+ */
+export declare function buildSheetUpdateFailureMessage(data: Record<string, unknown> | null, range: string): string;
 export declare const UpdateSheetRangeToolUI: ToolCallMessagePartComponent;
 export declare const BulkFormatSheetRangeToolUI: ToolCallMessagePartComponent;
 export declare const SetRowColumnDimensionsToolUI: ToolCallMessagePartComponent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenaintel/react",
-  "version": "0.10.40",
+  "version": "0.10.41-rc.1",
   "description": "Athena React SDK — Build AI-powered chat applications with the Athena platform",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -46,9 +46,13 @@
     }
   },
   "dependencies": {
-    "@assistant-ui/react": "0.14.24",
-    "@assistant-ui/react-langgraph": "0.14.10",
+    "@assistant-ui/core": "0.3.15",
+    "@assistant-ui/react": "0.15.16",
+    "@assistant-ui/react-langgraph": "0.14.24",
+    "@assistant-ui/react-statewire": "^0.17.0",
+    "@assistant-ui/tap": "0.9.14",
     "@floating-ui/react": "^0.27.7",
+    "@tanstack/react-query": "5.99.2",
     "@tanstack/react-store": "^0.9.1",
     "@tiptap/core": "^2.11",
     "@tiptap/extension-link": "^2.11",
@@ -61,16 +65,18 @@
     "@tiptap/react": "^2.11",
     "@tiptap/starter-kit": "^2.11",
     "@tiptap/suggestion": "^2.11",
-    "assistant-stream": "0.3.24",
+    "assistant-stream": "0.3.39",
     "class-variance-authority": "^0.7.1",
     "cnfast": "0.0.8",
     "lucide-react": "^0.575.0",
     "radix-ui": "^1.4.3",
+    "statewire": "^0.9.1",
     "tiptap-markdown": "^0.9.0",
     "zod": "^3.24.0",
     "zustand": "^5.0.11"
   },
   "devDependencies": {
+    "@athenaintel/agent-runtime": "workspace:*",
     "@propelauth/react": "^2.1.1",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",