@athenaintel/react 0.10.33 → 0.10.35

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

@@ -0,0 +1,32 @@
+export type AthenaEnvironment = 'production' | 'staging';
+export interface AthenaEnvironmentUrls {
+    apiUrl: string;
+    backendUrl: string;
+    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;
+export declare function getAthenaEnvironmentUrls({ environment, }?: {
+    environment?: AthenaEnvironment;
+}): AthenaEnvironmentUrls;
+/**
+ * Resolve the Iris chat endpoint that fronts a known Agora backend.
+ *
+ * Unknown custom backends deliberately return `null`: callers can preserve a
+ * direct-Agora fallback instead of accidentally sending a custom environment's
+ * bearer token and traffic through production Iris.
+ */
+export declare function deriveAthenaApiUrl({ backendUrl, }: {
+    backendUrl?: string | null;
+}): string | null;
+export declare function deriveAthenaAppUrl({ apiUrl, backendUrl, }: {
+    apiUrl?: string | null;
+    backendUrl?: string | null;
+}): string | null;
+export declare function createAthenaSpacesUrl({ appUrl, assetIds, sessionId, }: {
+    appUrl?: string;
+    assetIds?: string | string[];
+    sessionId?: string;
+}): string;

package/dist/lib/posthog/capture-gate.d.ts

@@ -0,0 +1,72 @@
+import type { CaptureOptions, Properties } from 'posthog-js';
+export type CaptureGateSuppressReason = 'global_budget' | 'event_budget' | 'dedupe';
+export type CaptureGateOutcome = {
+    action: 'emit';
+} | {
+    action: 'coalesce';
+    reason: CaptureGateSuppressReason;
+    bucketKey: string;
+};
+export interface CaptureGateEventOverride {
+    maxPerWindow: number;
+    windowMs: number;
+    dedupeWindowMs?: number;
+}
+export interface CaptureGateConfig {
+    globalMaxPerWindow: number;
+    globalWindowMs: number;
+    criticalReservePerWindow: number;
+    defaultEventMaxPerWindow: number;
+    defaultEventWindowMs: number;
+    defaultDedupeWindowMs: number;
+    /** Flush coalesced buckets on this interval (ms). */
+    flushIntervalMs: number;
+    /** Flush a bucket early once it reaches this many suppressed occurrences. */
+    flushCoalesceThreshold: number;
+    eventOverrides: Record<string, CaptureGateEventOverride>;
+}
+export interface CoalescedCapturePayload {
+    bucketKey: string;
+    event: string;
+    properties: Properties;
+    coalescedCount: number;
+    firstAt: number;
+    lastAt: number;
+    suppressionReason: CaptureGateSuppressReason;
+}
+export interface CaptureGateSnapshot {
+    coalescedPending: number;
+    coalescedPendingByEvent: Record<string, number>;
+    emittedTotal: number;
+    coalescedTotal: number;
+    flushedCoalescedTotal: number;
+}
+export declare const DEFAULT_CAPTURE_GATE_CONFIG: CaptureGateConfig;
+export declare function isCriticalPosthogEvent(event: string): boolean;
+export declare function shouldBypassCaptureGate(options?: CaptureOptions): boolean;
+export declare function withCaptureGateBypass(options?: CaptureOptions): CaptureOptions;
+export declare function buildCaptureFingerprint(event: string, properties?: Properties): string;
+export declare function buildCoalescedCaptureProperties(payload: CoalescedCapturePayload): Properties;
+export declare class PosthogCaptureGate {
+    private readonly config;
+    private readonly globalWindow;
+    private readonly eventWindows;
+    private readonly activeDedupe;
+    private readonly coalesceBuckets;
+    private emittedTotal;
+    private coalescedTotal;
+    private flushedCoalescedTotal;
+    constructor(config?: CaptureGateConfig);
+    resetForTests(): void;
+    getSnapshot(): CaptureGateSnapshot;
+    evaluateCapture(event: string, properties?: Properties, options?: CaptureOptions, now?: number): CaptureGateOutcome;
+    /** Returns payloads ready to flush (does not mutate buckets until caller confirms). */
+    collectFlushCandidates(now?: number): CoalescedCapturePayload[];
+    /** Remove flushed bucket keys after successful emit. */
+    acknowledgeFlushed(payloads: CoalescedCapturePayload[]): void;
+    /** After coalescing, flush immediately if the bucket crossed the early threshold. */
+    takeBucketIfReady(bucketKey: string, now?: number): CoalescedCapturePayload | null;
+    /** Force-flush every pending bucket (e.g. page hide). */
+    collectAllPending(): CoalescedCapturePayload[];
+    private recordCoalesce;
+}

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

@@ -0,0 +1,11 @@
+import type { CaptureResult, PostHog, Properties } from 'posthog-js';
+import type { CaptureOptions } from 'posthog-js';
+import { PosthogCaptureGate } from './capture-gate';
+export type PosthogCaptureClient = Pick<PostHog, 'capture'> & {
+    captureException?: (error: unknown, additionalProperties?: Properties) => CaptureResult | undefined;
+};
+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;

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+export { cn } from "cnfast";
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/mentions/composer-keybinds.d.ts

@@ -0,0 +1,5 @@
+import { Extension } from "@tiptap/core";
+export interface ComposerKeybindsOptions {
+    onSubmit: () => void;
+}
+export declare const ComposerKeybinds: Extension<ComposerKeybindsOptions, any>;

package/dist/mentions/mention-extension.d.ts

@@ -0,0 +1,6 @@
+import { Node } from "@tiptap/core";
+export declare const MentionExtension: Node<any, {
+    markdown: {
+        serialize: (state: any, node: any) => void;
+    };
+}>;

package/dist/mentions/mention-icons.d.ts

@@ -0,0 +1,4 @@
+export declare function MentionIconGlyph({ icon, className, }: {
+    icon?: string;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/mentions/mention-node-view.d.ts

@@ -0,0 +1,2 @@
+import { type NodeViewProps } from "@tiptap/react";
+export declare function MentionNodeView({ node }: NodeViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/mentions/mention-suggestion-list.d.ts

@@ -0,0 +1,14 @@
+import type { MenuItem } from "./types";
+import type { MentionSuggestionsStore } from "./use-mention-suggestions";
+export interface MentionSuggestionListProps {
+    store: MentionSuggestionsStore;
+    query: string;
+    command: (item: MenuItem) => void;
+    closeMenu: (dismissedByUser?: boolean) => void;
+}
+export interface MentionSuggestionListHandle {
+    onKeyDown: (props: {
+        event: KeyboardEvent;
+    }) => boolean;
+}
+export declare const MentionSuggestionList: import("react").ForwardRefExoticComponent<MentionSuggestionListProps & import("react").RefAttributes<MentionSuggestionListHandle>>;

package/dist/mentions/mention-suggestion-popup.d.ts

@@ -0,0 +1,15 @@
+import type { MentionSuggestionsStore } from "./use-mention-suggestions";
+export interface MentionSuggestionPopupProps {
+    store: MentionSuggestionsStore;
+    query: string;
+    command: (props: any) => void;
+    clientRect: (() => DOMRect) | null;
+    closeMenu: (dismissedByUser?: boolean) => void;
+    isHidden?: boolean;
+}
+export interface MentionSuggestionPopupHandle {
+    onKeyDown: (props: {
+        event: KeyboardEvent;
+    }) => boolean;
+}
+export declare const MentionSuggestionPopup: import("react").ForwardRefExoticComponent<MentionSuggestionPopupProps & import("react").RefAttributes<MentionSuggestionPopupHandle>>;

package/dist/mentions/mention-suggestions-extension.d.ts

@@ -0,0 +1,11 @@
+import { Extension } from "@tiptap/core";
+import type { MentionSuggestionsStore } from "./use-mention-suggestions";
+export interface MentionSuggestionsOptions {
+    store: MentionSuggestionsStore;
+}
+export interface MentionSuggestionsStorage {
+    mentionSuggestionsActive: boolean;
+    query: string;
+    dismissedWithEsc: boolean;
+}
+export declare const MentionSuggestionsExtension: Extension<MentionSuggestionsOptions, MentionSuggestionsStorage>;

package/dist/mentions/mention-types.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod";
+export interface MentionConfig {
+    type: string;
+    schema: z.ZodSchema;
+    parser: (url: string) => Record<string, any> | null;
+    encoder: (data: any, mentionType?: string) => string;
+    style: {
+        icon: string;
+    };
+}
+export interface MentionNodeAttrs {
+    type: string;
+    name: string;
+    params: Record<string, any>;
+}
+export declare const MENTION_TYPES: Record<string, MentionConfig>;
+export declare function getMentionConfig(type: string | null | undefined): MentionConfig | null;
+/**
+ * Detect mention type from a URL string
+ */
+export declare function detectMentionTypeFromUrl(url: string): string | null;

package/dist/mentions/mention-utils.d.ts

@@ -0,0 +1,23 @@
+import type { Editor } from "@tiptap/core";
+import { type MentionNodeAttrs } from "./mention-types";
+/** Pattern for [@Name](url) format */
+export declare const MENTION_PATTERN: RegExp;
+/**
+ * Insert a mention node into the editor with schema validation
+ */
+export declare function insertMention(editor: Editor, mentionType: string, name: string, rawParams: Record<string, any>, range: {
+    from: number;
+    to: number;
+}): boolean;
+/**
+ * Creates a Markdown link for mentions: [@Name](mention://type?params)
+ */
+export declare function makeMarkdownMention(attrs: MentionNodeAttrs): string;
+/**
+ * Creates mention URL from node attributes using the config encoder
+ */
+export declare function makeMentionUrl(attrs: MentionNodeAttrs): string;
+/**
+ * Parse mention attributes from a name and URL
+ */
+export declare function parseMentionAttrsFromUrl(name: string, url: string): MentionNodeAttrs | null;

package/dist/mentions/scope-registry.d.ts

@@ -0,0 +1,21 @@
+import type { FetchState, MenuItem, MenuScope, SourceFn } from "./types";
+export interface ScopeRegistryEntry {
+    sourceFn: SourceFn;
+    fetchStates: Map<string, FetchState>;
+}
+export interface ScopeRegistry {
+    entries: Map<MenuScope, ScopeRegistryEntry>;
+}
+export declare function createScopeRegistry(): ScopeRegistry;
+export declare function registerSource(registry: ScopeRegistry, scope: MenuScope, sourceFn: SourceFn): void;
+export declare function getEntry(registry: ScopeRegistry, scope: MenuScope): ScopeRegistryEntry | undefined;
+export declare function getFetchState(registry: ScopeRegistry, scope: MenuScope, query: string): FetchState | undefined;
+export declare function updateFetchState(registry: ScopeRegistry, scope: MenuScope, query: string, state: FetchState): void;
+/** Item cache: deduplicates items by ID, tracks scope membership */
+export interface ItemCache {
+    items: Map<string, MenuItem>;
+}
+export declare function createItemCache(): ItemCache;
+export declare function addItems(cache: ItemCache, items: MenuItem[], scope: MenuScope): void;
+export declare function getFilteredItems(cache: ItemCache, scope: MenuScope, query: string): MenuItem[];
+export declare function clearScope(cache: ItemCache, scope: MenuScope): void;

package/dist/mentions/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Core types for mention suggestions data layer
+ * Simplified from Olympus — only Tool and Toolkit types
+ */
+export type MenuScope = string;
+export interface MenuItem {
+    id: string;
+    name: string;
+    type: "menu" | "tool" | "toolkit";
+    fallbackIcon: string;
+    description?: string;
+    visibleInScopes: Set<MenuScope>;
+    navigatesToScope?: MenuScope;
+    isNavigationOnly?: boolean;
+}
+export interface MenuItemsSelector {
+    items: MenuItem[];
+    isFetching: boolean;
+    hasMore: boolean;
+}
+export interface FetchState {
+    isFetching: boolean;
+    hasNextPage: boolean;
+    error: Error | null;
+    meta: unknown;
+}
+export interface SourceResult {
+    items: MenuItem[];
+    pagination?: {
+        hasMore: boolean;
+        totalCount?: number;
+    };
+}
+export interface SourceContext {
+    scope: MenuScope;
+    query: string;
+    fetchState: FetchState;
+}
+export type SourceFn = (context: SourceContext) => Promise<SourceResult>;

package/dist/mentions/use-mention-suggestions.d.ts

@@ -0,0 +1,28 @@
+import { Store } from "@tanstack/react-store";
+import type { MenuItem } from "./types";
+import { type ItemCache, type ScopeRegistry } from "./scope-registry";
+export interface MentionTool {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    type: "tool" | "toolkit";
+}
+export interface MentionSuggestionsState {
+    registry: ScopeRegistry;
+    cache: ItemCache;
+}
+export type MentionSuggestionsStore = Store<MentionSuggestionsState>;
+export type MentionRootCategory = "toolkits" | "team";
+export interface UseMentionSuggestionsOptions {
+    rootCategories?: readonly MentionRootCategory[];
+}
+export declare function useMentionSuggestions(tools: MentionTool[], options?: UseMentionSuggestionsOptions): MentionSuggestionsStore;
+/**
+ * Select items from store for a given scope and query
+ */
+export declare function selectItems(store: MentionSuggestionsStore, scope: string, query: string): {
+    items: MenuItem[];
+    isFetching: boolean;
+    hasMore: boolean;
+};

package/dist/provider/AthenaContext.d.ts

@@ -0,0 +1,11 @@
+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[];
+    linkClicks?: AthenaLinkClickOptions;
+    citationLinks?: AthenaCitationLinkOptions;
+}
+export declare const AthenaContext: import("react").Context<AthenaConfig | null>;
+export declare function useAthenaConfig(): AthenaConfig;

package/dist/provider/AthenaProvider.d.ts

@@ -0,0 +1,86 @@
+import { type ReactNode } from 'react';
+import type { Toolkit } from '@assistant-ui/react';
+import { type AthenaEnvironment } from '../lib/athena-urls';
+import type { AthenaProviderConfig } from './config';
+import type { AthenaCitationLinkOptions, AthenaLinkClickOptions } from './citation-links';
+import { type AthenaTheme } from '../theme';
+import { type PostHogConfig } from './PostHogProvider';
+export interface AthenaProviderProps {
+    children: ReactNode;
+    /** Preferred structured config for auth and Athena endpoint settings. */
+    config?: AthenaProviderConfig;
+    /** @deprecated Prefer `config.apiKey`. API key for authentication in standalone mode. */
+    apiKey?: string;
+    /** @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 name to use. Defaults to 'athena_assist_agent'. */
+    agent?: string;
+    /** LLM model identifier. Defaults to 'claude-opus-4-6-thinking-max-fast'. */
+    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. */
+    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. */
+    apiUrl?: string;
+    /** @deprecated Prefer `config.backendUrl`. URL for the Athena backend API. */
+    backendUrl?: string;
+    /** @deprecated Prefer `config.appUrl`. URL for the Athena frontend app origin. */
+    appUrl?: string;
+    /** @deprecated Prefer `config.environment`. Athena environment preset used when URLs are not explicitly provided. */
+    environment?: AthenaEnvironment;
+    /** 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 (e.g. MCP servers).
+     *  Passed through as `custom_tool_configs` in runConfig.custom.
+     *
+     *  @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>". */
+    appId?: string;
+    /** Thread ID override. Auto-generated if not provided. */
+    threadId?: string;
+    /** Enable thread list management (sidebar thread switching). */
+    enableThreadList?: boolean;
+    /** Theme configuration. Pass a preset from `themes` or a custom `AthenaTheme` object.
+     *  Injects CSS variables on a wrapper element — no CSS files needed.
+     *
+     *  @example
+     *  import { themes } from '@athenaintel/react';
+     *  <AthenaProvider theme={themes.dark}>
+     *
+     *  @example
+     *  <AthenaProvider theme={{ primary: '#8b5cf6', radius: '1rem' }}>
+     *
+     *  @example
+     *  <AthenaProvider theme={{ ...themes.dark, primary: '#22c55e' }}>
+     */
+    theme?: AthenaTheme;
+    /** Customize how rendered chat links behave. */
+    linkClicks?: AthenaLinkClickOptions;
+    /** @deprecated Prefer `linkClicks`. Customize how Athena citation links rendered in chat messages behave. */
+    citationLinks?: AthenaCitationLinkOptions;
+    /** PostHog analytics configuration. When omitted or keys are missing, PostHog is silently disabled.
+     *  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;

package/dist/provider/PostHogProvider.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from 'react';
+export interface PostHogConfig {
+    /** PostHog API key. When falsy, PostHog is disabled and the provider is a no-op. */
+    apiKey?: string;
+    /** PostHog ingestion host. Defaults to 'https://us.i.posthog.com'. */
+    host?: string;
+    /** Enable debug mode (logs PostHog internals to the console). */
+    debug?: boolean;
+}
+export declare function getPostHogInstance<TClient = unknown>(): TClient | null;
+export declare function PostHogProvider({ children, config, }: {
+    children: ReactNode;
+    config?: PostHogConfig;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/provider/citation-links.d.ts

@@ -0,0 +1,61 @@
+import type { AssetType } from '../assets/asset-panel-store';
+export type AthenaLinkKind = 'athena-citation' | 'athena-app' | 'external';
+export interface AthenaLinkClickHandleInput {
+    href: string;
+    linkText?: string | null;
+    target?: string | null;
+    nativeEvent?: MouseEvent | null;
+}
+export interface AthenaCitationLinkMetadata {
+    assetId: string;
+    assetIds: string[];
+    assetType: AssetType | null;
+}
+export interface AthenaLinkClickContext {
+    href: string;
+    url: URL;
+    target: string | null;
+    linkText: string | null;
+    isAssetPanelAvailable: boolean;
+    kind: AthenaLinkKind;
+    citation: AthenaCitationLinkMetadata | null;
+    nativeEvent: MouseEvent | null;
+    openInAssetPanel?: () => void;
+    openInBrowser: (target?: string | null) => void;
+}
+export interface AthenaLinkClickOptions {
+    /**
+     * Whether Athena citation links should be intercepted by the SDK.
+     * Defaults to `true`.
+     */
+    interceptAthenaCitations?: boolean;
+    /**
+     * Optional override invoked when any rendered chat link is clicked.
+     * Return `true` to mark the click as handled and skip the default SDK behavior.
+     */
+    onClick?: (context: AthenaLinkClickContext) => boolean | void;
+}
+export interface AthenaCitationLinkClickContext extends AthenaLinkClickContext {
+    kind: 'athena-citation';
+    citation: AthenaCitationLinkMetadata;
+    assetId: string;
+    assetIds: string[];
+    assetType: AssetType | null;
+    openInAssetPanel: () => void;
+}
+/**
+ * @deprecated Prefer `AthenaLinkClickOptions`. This remains supported as a citation-only alias.
+ */
+export interface AthenaCitationLinkOptions {
+    interceptAthenaCitations?: boolean;
+    onClick?: (context: AthenaCitationLinkClickContext) => boolean | void;
+}
+export type AthenaLinkClickHandler = (input: AthenaLinkClickHandleInput) => boolean;
+/**
+ * @deprecated Prefer `AthenaLinkClickHandleInput`.
+ */
+export type AthenaCitationLinkHandleInput = AthenaLinkClickHandleInput;
+/**
+ * @deprecated Prefer `AthenaLinkClickHandler`.
+ */
+export type AthenaCitationLinkHandler = AthenaLinkClickHandler;

package/dist/provider/config.d.ts

@@ -0,0 +1,20 @@
+import type { AthenaEnvironment } from '../lib/athena-urls';
+import type { PostHogConfig } from './PostHogProvider';
+export interface AthenaProviderConfig {
+    /** 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. */
+    apiUrl?: 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. */
+    appUrl?: string;
+    /** Exact parent origins allowed to send embedded auth/config via postMessage. */
+    trustedParentOrigins?: string[];
+    /** Athena environment preset used when URLs are not explicitly provided. */
+    environment?: AthenaEnvironment;
+    /** PostHog analytics configuration. When omitted or keys are missing, PostHog is disabled. */
+    posthog?: PostHogConfig;
+}

package/dist/provider/types.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,45 @@
+export interface ParentBridgeState {
+    /** PropelAuth access token from the parent window. */
+    token: string | null;
+    /** Sync server chat URL provided by the Marathon wrapper. */
+    apiUrl: string | null;
+    /** Athena backend URL provided by the Marathon wrapper. */
+    backendUrl: 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;
+}
+export interface ParentBridgeOptions {
+    /**
+     * Exact parent origins that are allowed to send auth/config via postMessage.
+     * Useful for private-cloud or custom-domain deployments.
+     */
+    trustedOrigins?: string[];
+}
+export declare const getTokenRefreshDelay: (expiresAt: unknown, nowMs: number) => number;
+export declare const getAuthRetryDelay: (retryAttempt: number) => number;
+/**
+ * Listens for auth tokens AND environment config from the host environment.
+ *
+ * Two transport modes, picked automatically:
+ *
+ * 1. **Iframe (legacy / Olympus inline preview)**: a parent window posts
+ *    `athena-config` and `athena-auth` via PostMessage. The hook also posts
+ *    `athena-auth-ready` so the parent knows when to (re-)send.
+ *
+ * 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.
+ *
+ * In both modes a timeout safety net flips `ready: true` so the app never
+ * blocks indefinitely.
+ */
+export declare function useParentBridge({ trustedOrigins, }?: ParentBridgeOptions): ParentBridgeState;
+/**
+ * Legacy hook — returns just the auth token from the parent bridge.
+ * Prefer useParentBridge() for new code.
+ */
+export declare function useParentAuth(): string | null;

package/dist/runtime/converter.d.ts

@@ -0,0 +1,5 @@
+import type { ThreadMessage } from '@assistant-ui/react';
+import { type AthenaLangChainMessage } from './schemas';
+export declare const PTC_SUBCALL_DID_NOT_COMPLETE_MESSAGE = "Sub-call did not complete before the parent tool returned.";
+export declare const autoCloseInFlightSubgraphMessages: (msgs: readonly unknown[]) => unknown[];
+export declare const convertLangChainToThreadMessages: (messages: AthenaLangChainMessage[], isRunning?: boolean, metadata?: {}) => ThreadMessage[];

package/dist/runtime/external-message-converter.d.ts

@@ -0,0 +1,21 @@
+import { type ThreadMessage, type ThreadMessageLike, type ToolExecutionStatus } from '@assistant-ui/react';
+export declare namespace useExternalMessageConverter {
+    type Message = (ThreadMessageLike & {
+        readonly convertConfig?: {
+            readonly joinStrategy?: 'concat-content' | 'none';
+        };
+    }) | {
+        role: 'tool';
+        toolCallId: string;
+        toolName?: string | undefined;
+        result: any;
+        artifact?: any;
+        isError?: boolean;
+        messages?: readonly ThreadMessage[];
+    };
+    type Metadata = {
+        readonly toolStatuses?: Record<string, ToolExecutionStatus>;
+    };
+    type Callback<T> = (message: T, metadata: Metadata) => Message | Message[] | null | undefined;
+}
+export declare const convertExternalMessages: <T extends WeakKey>(messages: T[], callback: useExternalMessageConverter.Callback<T>, isRunning: boolean, metadata: useExternalMessageConverter.Metadata) => ThreadMessage[];

package/dist/runtime/schemas.d.ts

@@ -0,0 +1,24 @@
+import type { LangChainMessage } from '@assistant-ui/react-langgraph';
+export type AthenaAiLangChainMessage = Extract<LangChainMessage, {
+    type: 'ai';
+}> & {
+    usage_metadata?: Record<string, unknown>;
+    response_metadata?: Record<string, unknown>;
+};
+export type AthenaLangChainMessage = Exclude<LangChainMessage, {
+    type: 'ai';
+}> | AthenaAiLangChainMessage;
+export declare const parseLangChainMessage: (msg: unknown) => AthenaLangChainMessage | null;
+export declare const parseMessages: (messages: unknown) => AthenaLangChainMessage[];
+export declare const parseInterrupt: (interrupt: unknown) => {
+    value: unknown;
+    resumable: boolean;
+} | null;
+export declare const parseLangGraphState: (state: unknown) => {
+    messages: AthenaLangChainMessage[];
+    __interrupt__: {
+        value?: unknown;
+        resumable: boolean;
+    } | null;
+    [key: string]: unknown;
+};