@axiom-lattice/react-sdk 2.1.85 → 2.1.87

package/dist/index.d.mts

@@ -211,6 +211,18 @@ interface UseAgentStateOptions {
 }
 /**
  * Agent state hook return value
+ *
+ * @example
+ * ```tsx
+ * const { agentState, isLoading, error, startPolling, stopPolling, refresh } =
+ *   useAgentState("assistant-123", "thread-456", { pollingInterval: 2000 });
+ *
+ * // Manual refresh
+ * await refresh();
+ *
+ * // Access agent messages
+ * const messages = agentState?.values?.messages ?? [];
+ * ```
  */
 interface UseAgentStateReturn {
     /**
@@ -275,6 +287,17 @@ interface UseApiOptions {
 }
 /**
  * Return type for useApi hook
+ *
+ * @example
+ * ```tsx
+ * const { get, post, put, del, isLoading, error } = useApi();
+ *
+ * // GET resources
+ * const threads = await get<Thread[]>("/api/threads");
+ *
+ * // POST with body
+ * const result = await post<ChatResponse>("/api/chat", { message: "Hello" });
+ * ```
  */
 interface UseApiReturn {
     /**
@@ -331,6 +354,23 @@ interface UseApiReturn {
  * @param assistantId - Assistant ID to chat with
  * @param options - Chat options
  * @returns Chat state and operations
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   messages,
+ *   isLoading,
+ *   sendMessage,
+ *   stopStreaming,
+ *   loadMessages,
+ *   clearMessages,
+ * } = useChat("thread-1", "assistant-1", {
+ *   initialMessages: [],
+ *   enableResumeStream: true,
+ * });
+ *
+ * await sendMessage({ input: { message: "Hello!" } });
+ * ```
  */
 declare function useChat<T extends UseChatOptions>(threadId: string | null, assistantId: string, options?: T): (T["enableReturnStateWhenStreamCompleted"] extends true ? ChatStateWithAgent : ChatState) & {
     sendMessage: (data: {
@@ -378,6 +418,7 @@ declare function useChat<T extends UseChatOptions>(threadId: string | null, assi
  * - Optionally returning agent state when streaming completes
  *
  * @template T - UseChatOptions type
+ * @param options - Optional chat configuration including streaming, resume stream, and initial messages
  * @returns Agent thread state and operations from AgentThreadContext
  */
 declare function useAgentChat<T extends UseChatOptions>(options?: T): ChatStateWithAgent & {
@@ -448,6 +489,18 @@ declare function useAgentGraph(assistantId: string): {
  */
 declare function useApi(options?: UseApiOptions): UseApiReturn;
 
+/**
+ * Fetches and manages evaluation projects.
+ *
+ * @returns Project list, loading state, error, and CRUD operations
+ *
+ * @example
+ * ```tsx
+ * const { projects, loading, create, update, remove, refresh } = useEvalProjects();
+ *
+ * await create({ name: "My Project" });
+ * ```
+ */
 declare function useEvalProjects(): {
     projects: unknown[];
     loading: boolean;
@@ -458,6 +511,19 @@ declare function useEvalProjects(): {
     refresh: () => Promise<void>;
 };
 
+/**
+ * Fetches and manages evaluation suites within a project.
+ *
+ * @param projectId - The project ID to fetch suites for
+ * @returns Suite list, loading state, error, and CRUD operations
+ *
+ * @example
+ * ```tsx
+ * const { suites, loading, create, remove } = useEvalSuites("proj-123");
+ *
+ * await create("proj-123", { name: "Accuracy Suite" });
+ * ```
+ */
 declare function useEvalSuites(projectId: string): {
     suites: unknown[];
     loading: boolean;
@@ -468,6 +534,20 @@ declare function useEvalSuites(projectId: string): {
     refresh: () => Promise<void>;
 };
 
+/**
+ * Fetches and manages evaluation cases within a suite.
+ *
+ * @param projectId - The project ID the suite belongs to
+ * @param suiteId - The suite ID to fetch cases for
+ * @returns Case list, loading state, error, and CRUD operations
+ *
+ * @example
+ * ```tsx
+ * const { cases, loading, create } = useEvalCases("proj-123", "suite-456");
+ *
+ * await create("proj-123", "suite-456", { question: "What is 2+2?", answer: "4" });
+ * ```
+ */
 declare function useEvalCases(projectId: string, suiteId: string): {
     cases: unknown[];
     loading: boolean;
@@ -478,6 +558,19 @@ declare function useEvalCases(projectId: string, suiteId: string): {
     refresh: () => Promise<void>;
 };
 
+/**
+ * Fetches and manages evaluation runs, optionally scoped to a project.
+ *
+ * @param projectId - Optional project ID to filter runs by project
+ * @returns Run list, loading state, error, and operations (start, abort, remove)
+ *
+ * @example
+ * ```tsx
+ * const { runs, loading, start, abort } = useEvalRuns("proj-123");
+ *
+ * const result = await start("proj-123");
+ * ```
+ */
 declare function useEvalRuns(projectId?: string): {
     runs: unknown[];
     loading: boolean;
@@ -490,6 +583,18 @@ declare function useEvalRuns(projectId?: string): {
     refresh: () => Promise<void>;
 };
 
+/**
+ * Streams real-time progress of an evaluation run via SSE.
+ *
+ * @param runId - The evaluation run ID to stream, or `null` to disable streaming
+ * @returns Status, progress counters, connection state, and a stop function
+ *
+ * @example
+ * ```tsx
+ * const { status, progress, connected, stopStreaming } = useEvalRunStream("run-789");
+ * // progress: { completed: 5, total: 10, passed: 4, failed: 1 }
+ * ```
+ */
 declare function useEvalRunStream(runId: string | null): {
     status: string;
     progress: {
@@ -581,14 +686,34 @@ interface AgentThreadProviderProps<T extends UseChatOptions> {
     onStreamCompleted?: () => void;
 }
 /**
- * Provider component for AgentThreadContext
- * Manages all agent thread state and operations
+ * Provider component for AgentThreadContext.
+ * Manages all agent thread state and operations including message streaming, interrupts,
+ * queue management, and agent state polling.
+ *
+ * @param props - {@link AgentThreadProviderProps}
+ * @param props.threadId - The ID of the thread to manage. If `null`, the provider renders nothing.
+ * @param props.assistantId - The assistant ID to associate with this thread. Falls back to the client's assistant ID if omitted.
+ * @param props.options - Configuration options for chat behavior (streaming, resume stream polling, initial messages, etc.).
+ * @param props.children - React children to render within the thread context.
+ * @param props.onToolCompleted - Callback invoked each time a tool call completes, receiving the tool name.
+ * @param props.onStreamCompleted - Callback invoked when the SSE stream completes for any message.
+ *
+ * @returns A React context provider wrapping children with {@link AgentThreadContext.Provider}, or `null` if no `threadId` is provided.
  */
 declare function AgentThreadProvider<T extends UseChatOptions>({ threadId, assistantId, options, children, onToolCompleted, onStreamCompleted, }: AgentThreadProviderProps<T>): react_jsx_runtime.JSX.Element | null;
 /**
- * Hook to access AgentThreadContext
- * @returns Agent thread context value
- * @throws Error if used outside of AgentThreadProvider
+ * Hook to access AgentThreadContext.
+ *
+ * @param T - The {@link UseChatOptions} type parameter, allowing typed access to options.
+ * @returns Agent thread context value of type {@link AgentThreadContextValue}.
+ * @throws {Error} If used outside of an {@link AgentThreadProvider}.
+ *
+ * @example
+ * ```tsx
+ * const { state, sendMessage, stopStreaming, abortAgent } = useAgentThreadContext();
+ *
+ * await sendMessage({ input: { message: 'Hello!' } });
+ * ```
  */
 declare function useAgentThreadContext<T extends UseChatOptions>(): AgentThreadContextValue<T>;
 
@@ -597,10 +722,17 @@ interface UserTenantInfo {
     role: string;
     tenant?: Tenant;
 }
+interface PersonalAssistantInfo {
+    assistantId: string;
+    projectId: string;
+    workspaceId: string;
+}
 interface AuthContextValue {
     user: User | null;
     tenants: UserTenantInfo[];
     currentTenant: Tenant | null;
+    personalAssistant: PersonalAssistantInfo | null;
+    setPersonalAssistant: (info: PersonalAssistantInfo | null) => void;
     isAuthenticated: boolean;
     isLoading: boolean;
     error: string | null;
@@ -619,6 +751,30 @@ interface AuthContextValue {
     clearError: () => void;
     changePassword: (currentPassword: string, newPassword: string) => Promise<void>;
 }
+/**
+ * Hook to access authentication context. Must be used within an {@link AuthProvider}.
+ *
+ * @description
+ * Provides the full auth state and all auth operations (login, register, logout, tenant selection, etc.).
+ * Throws an error if no {@link AuthProvider} is found in the component tree. For optional auth,
+ * use {@link useAuthOptional} instead.
+ *
+ * @returns The current {@link AuthContextValue} containing user, tenants, auth state, and auth actions.
+ *
+ * @throws {Error} If used outside of an {@link AuthProvider}.
+ *
+ * @example
+ * ```tsx
+ * const { user, isAuthenticated, login, logout } = useAuth();
+ *
+ * const handleLogin = async () => {
+ *   const result = await login('user@example.com', 'password');
+ *   if (result.requiresTenantSelection) {
+ *     // Show tenant picker
+ *   }
+ * };
+ * ```
+ */
 declare const useAuth: () => AuthContextValue;
 /**
  * Optional version of useAuth that returns null instead of throwing when AuthProvider is not present.
@@ -632,13 +788,54 @@ declare const useAuth: () => AuthContextValue;
  * const user = useAuthOptional()?.user;
  */
 declare const useAuthOptional: () => AuthContextValue | null;
+/**
+ * Props for {@link AuthProvider}.
+ */
 interface AuthProviderProps {
+    /** Child components that will have access to the auth context. */
     children: ReactNode;
+    /** Base URL of the gateway API (e.g., `http://localhost:3000`). */
     baseURL: string;
+    /** Called after a successful login with the user and their tenant memberships. */
     onLoginSuccess?: (user: User, tenants: UserTenantInfo[]) => void;
+    /** Called after a tenant is successfully selected, passing the selected tenant. */
     onTenantSelected?: (tenant: Tenant) => void;
+    /** Called after the user logs out. */
     onLogout?: () => void;
 }
+/**
+ * Authentication context provider. Wraps the application to provide auth state and operations
+ * to all descendant components via {@link useAuth} and {@link useAuthOptional}.
+ *
+ * @description
+ * Manages the full authentication lifecycle including:
+ * - **Login / Register**: Sends credentials to the gateway API and stores the returned user, tenants, and token in `sessionStorage`.
+ * - **Session restoration**: On mount, reads previously stored user data from `sessionStorage` and also refreshes the tenant list to catch any admin-side role assignments.
+ * - **Tenant selection**: Calls the gateway API to select a tenant and stores the tenant data.
+ * - **Logout**: Clears all auth state and `sessionStorage`.
+ * - **Change password**: Proxies to the gateway password change endpoint.
+ * - **Token expiration**: Automatically logs out when the gateway returns a 401 with an expired token message.
+ *
+ * @param props - {@link AuthProviderProps}
+ * @param props.children - React children to render within the auth context.
+ * @param props.baseURL - Base URL of the gateway API.
+ * @param props.onLoginSuccess - Optional callback invoked after a successful login.
+ * @param props.onTenantSelected - Optional callback invoked after tenant selection.
+ * @param props.onLogout - Optional callback invoked on logout.
+ *
+ * @returns A React context provider wrapping children with {@link AuthContext.Provider}.
+ *
+ * @example
+ * ```tsx
+ * <AuthProvider
+ *   baseURL="http://localhost:3000"
+ *   onLoginSuccess={(user) => console.log('Logged in:', user.email)}
+ *   onLogout={() => window.location.reload()}
+ * >
+ *   <App />
+ * </AuthProvider>
+ * ```
+ */
 declare const AuthProvider: React__default.FC<AuthProviderProps>;
 
 /**
@@ -733,6 +930,22 @@ interface UseTenantsReturn {
     refresh: () => Promise<void>;
     getTenantById: (id: string) => Tenant | undefined;
 }
+/**
+ * Fetches and manages a list of tenants from the API.
+ *
+ * @param options - Configuration options
+ * @param options.baseURL - The base URL of the API gateway
+ * @param options.token - Optional authentication token
+ * @returns Tenant list, loading state, error, refresh function, and lookup helper
+ *
+ * @example
+ * ```tsx
+ * const { tenants, isLoading, error, refresh, getTenantById } = useTenants({
+ *   baseURL: "https://api.example.com",
+ *   token: "your-auth-token",
+ * });
+ * ```
+ */
 declare function useTenants(options: UseTenantsOptions): UseTenantsReturn;
 interface UseUsersOptions {
     baseURL: string;
@@ -746,78 +959,256 @@ interface UseUsersReturn {
     refresh: () => Promise<void>;
     searchByEmail: (email: string) => Promise<_axiom_lattice_protocols.User | null>;
 }
+/**
+ * Fetches and manages a list of users within a tenant.
+ *
+ * @param options - Configuration options
+ * @param options.baseURL - The base URL of the API gateway
+ * @param options.tenantId - The tenant ID to fetch users for
+ * @param options.token - Optional authentication token
+ * @returns User list, loading state, error, refresh function, and email search helper
+ *
+ * @example
+ * ```tsx
+ * const { users, isLoading, error, searchByEmail } = useUsers({
+ *   baseURL: "https://api.example.com",
+ *   tenantId: "tenant-123",
+ * });
+ *
+ * const user = await searchByEmail("user@example.com");
+ * ```
+ */
 declare function useUsers(options: UseUsersOptions): UseUsersReturn;
 
+/**
+ * Props for the {@link Chating} component — the core chat interface.
+ *
+ * Controls appearance, sender behavior, empty-state customization, and
+ * optional context injection for the agent.
+ */
 interface ChatingProps {
+    /** Agent display name shown in the header. */
     name?: string;
+    /** Agent description shown in the header. */
     description?: string;
+    /** Fallback message used when the user submits only attachments without text. */
     default_submit_message?: string;
+    /** Avatar URL or component for the agent. */
     avatar?: string;
+    /** Placeholder content rendered inside the attachment upload area. */
     attachment_placeholder?: React__default.ReactNode;
+    /** Custom upload endpoint URL. Defaults to the workspace or thread sandbox upload endpoint. */
     uploadAction?: string;
+    /** Quick prompt items displayed between messages. */
     senderPromptsItems?: GetProp<typeof Prompts, "items">;
+    /** Extra content rendered in the header area. */
     extra?: React__default.ReactNode;
+    /** Additional metadata items for the header. */
     extraMeta?: Array<{
         id: string;
     }>;
+    /** Whether to show the agent header bar. Default: true. */
     showHeader?: boolean;
+    /** Whether to show the message sender input. Default: true. */
     showSender?: boolean;
+    /** Whether to show the Human-in-the-Loop (HITL) container. Default: true. */
     showHITL?: boolean;
+    /** Whether to show a refresh button in the header. */
     showRefreshButton?: boolean;
     /**
-     * Whether to show the model selector in the sender footer
-     * When provided, overrides the shell config's enableModelSelector
+     * Whether to show the model selector in the sender footer.
+     * When provided, overrides the shell config's enableModelSelector.
      */
     showModelSelector?: boolean;
-    /** Show database picker in sender footer. Overrides shell config enableDatabaseSlot */
+    /** Show database picker in sender footer. Overrides shell config enableDatabaseSlot. */
     showDatabaseSlot?: boolean;
-    /** Show skill picker in sender footer. Overrides shell config enableSkillSlot */
+    /** Show skill picker in sender footer. Overrides shell config enableSkillSlot. */
     showSkillSlot?: boolean;
-    /** Show agent picker in sender footer. Overrides shell config enableAgentSlot */
+    /** Show agent picker in sender footer. Overrides shell config enableAgentSlot. */
     showAgentSlot?: boolean;
-    /** Show metrics data source picker in sender footer. Overrides shell config enableMetricsDataSourceSlot */
+    /** Show metrics data source picker in sender footer. Overrides shell config enableMetricsDataSourceSlot. */
     showMetricsDataSourceSlot?: boolean;
+    /** Whether to show the greeting empty state when no messages exist. Default: true. */
     showEmptyState?: boolean;
+    /** Custom greeting element displayed in the empty state. */
     emptyStateGreeting?: React__default.ReactNode;
+    /** Empty state question line. Default: "Ready to turn..." */
     emptyStateQuestion?: string;
+    /** Show skill category prompts in empty state. Default: true. */
+    showSkillPrompts?: boolean;
+    /** Show business analysis prompts in empty state. Default: true. */
+    showQuickAnalysis?: boolean;
+    /** Welcome prefix text (e.g., "Hey"). */
     welcomePrefix?: string;
-    /** Context string injected before the first user message (e.g. workflow context) */
+    /** Context string injected before the first user message (e.g. workflow context). */
     systemContext?: string;
-    /** Auto-send this message when agent becomes idle (thread ready, not loading) */
+    /** Auto-send this message when agent becomes idle (thread ready, not loading). */
     initialMessage?: string | null;
-    /** Called after initialMessage has been sent */
+    /** Called after initialMessage has been sent. */
     onInitialMessageSent?: () => void;
 }
+/**
+ * Core chat interface component — manages sender input, message display,
+ * and agent-streaming state for a single assistant thread.
+ *
+ * Features:
+ * - Empty state with greeting and skill/analysis prompt categories
+ * - Message sender with file attachment, skill/agent/database pickers, and model selector
+ * - Typing cursor animation during streaming
+ * - HITL interrupt handling and pending-message display
+ * - Auto-send of {@link ChatingProps.systemContext} and {@link ChatingProps.initialMessage}
+ * - Transition animations between empty and active states
+ *
+ * @param props - See {@link ChatingProps}.
+ * @returns The full chat UI for the active thread.
+ *
+ * @example
+ * ```tsx
+ * import { Chating } from "@axiom-lattice/react-sdk";
+ *
+ * <Chating
+ *   name="Data Analyst"
+ *   showHeader
+ *   showSender
+ *   showModelSelector
+ *   emptyStateQuestion="What data would you like to analyze?"
+ *   systemContext="You are analyzing sales data from Q4 2024."
+ * />
+ * ```
+ *
+ * @remarks
+ * - Requires the following ancestor context providers: {@link AgentThreadProvider},
+ *   {@link ChatUIContextProvider}, {@link LatticeChatShellContextProvider},
+ *   {@link ConversationContextProvider}, {@link AssistantContextProvider}.
+ * - Prop-level feature toggles (e.g. `showModelSelector`) take priority over
+ *   shell-config-level toggles.
+ * - Uses {@link useAgentChat} for all agent communication.
+ */
 declare const Chating: React__default.FC<ChatingProps>;
 
+/**
+ * Props for the {@link LatticeChat} component.
+ *
+ * Extends {@link ChatingProps} with thread/assistant identification
+ * and optional menu/header slots.
+ */
 type AgentChatProps = {
+    /** The ID of the currently active thread. If absent, a placeholder is shown prompting users to create a conversation. */
     thread_id?: string;
+    /** The assistant ID that backs the chat. Required — feeds the {@link AgentThreadProvider}. */
     assistant_id: string;
+    /** Optional menu rendered in the left sidebar column. */
     menu?: React__default.ReactNode;
+    /** Optional header rendered above the main chat area. */
     header?: React__default.ReactNode;
+    /** Optional right-side header content. Replaces the default folder toggle button. Use {@link FilePanelToggle} to include it. */
+    headerRight?: React__default.ReactNode;
+    /** Show workspace project selector in header. Default true. */
+    showProjectSelector?: boolean;
+    /** Content shown when no thread is active. Default: "Please create a conversation first". */
+    emptyPlaceholder?: React__default.ReactNode;
 } & ChatingProps;
+/**
+ * Top-level chat component for a single assistant thread.
+ *
+ * Wraps the chat UI in:
+ * - {@link AgentThreadProvider} for thread state
+ * - {@link ChatUIContextProvider} for UI panel toggles
+ * - A responsive {@link ColumnLayout} with menu, main chat, detail panel, and tools panel
+ *
+ * When `thread_id` is empty, a prompt to create a conversation is displayed.
+ *
+ * @example
+ * ```tsx
+ * import { LatticeChat } from "@axiom-lattice/react-sdk";
+ *
+ * <LatticeChat
+ *   assistant_id="asst_abc123"
+ *   thread_id="thread_xyz"
+ *   showHeader
+ *   showSender
+ * />
+ * ```
+ *
+ * @remarks
+ * - Requires a parent `<LatticeChatShell>` for shell-level configuration (API URL, feature toggles).
+ * - The `ChatingProps` are forwarded to the internal {@link Chating} component.
+ */
 declare const LatticeChat: React__default.FC<AgentChatProps>;
 
+/**
+ * Model runtime configuration passed to the agent when a model is selected.
+ */
 interface ModelConfig {
+    /** The model key as registered on the server (e.g., "gpt-4o"). */
     modelKey: string;
+    /** Sampling temperature (0-2). Higher values produce more random output. */
     temperature?: number;
+    /** Maximum tokens in the generated response. */
     maxTokens?: number;
+    /** Nucleus sampling parameter (0-1). */
     topP?: number;
+    /** Penalty for repeating tokens (-2 to 2). */
     frequencyPenalty?: number;
+    /** Penalty for introducing new topics (-2 to 2). */
     presencePenalty?: number;
 }
+/**
+ * Model metadata returned by the `/api/models` endpoint.
+ */
 interface ModelInfo {
+    /** Unique model key (used as the selection value). */
     key: string;
+    /** Provider identifier (e.g., "openai", "azure"). */
     provider: string;
+    /** Model name as known by the provider (e.g., "gpt-4o"). */
     model: string;
+    /** Human-readable display name for the dropdown. */
     displayName?: string;
 }
+/**
+ * Props for the {@link ModelSelector} component.
+ */
 interface ModelSelectorProps {
+    /** Currently selected model configuration (controlled). */
     value?: ModelConfig | null;
+    /** Called when the user selects a model. */
     onChange?: (config: ModelConfig | null) => void;
+    /** Default model key used when the fetch response includes a matching model. */
     defaultModelKey?: string;
+    /** Inline styles applied to the Select element. */
     style?: React__default.CSSProperties;
 }
+/**
+ * A borderless Ant Design `Select` dropdown for choosing the LLM model.
+ *
+ * Fetches available models from `/api/models` on first render and caches the result.
+ * When a default model key matches a model in the list, it is auto-selected.
+ * The selection is reported via the {@link ModelSelectorProps.onChange} callback,
+ * which typically feeds into `updateCustomRunConfig` in the {@link Chating} component.
+ *
+ * @param value - Currently selected model config (controlled).
+ * @param onChange - Callback when the selection changes.
+ * @param defaultModelKey - Model key to auto-select if found in the model list.
+ * @param style - Inline styles for the Select wrapper.
+ * @returns A compact model selector with hover-highlight background.
+ *
+ * @example
+ * ```tsx
+ * import { ModelSelector } from "@axiom-lattice/react-sdk";
+ *
+ * <ModelSelector
+ *   value={modelConfig}
+ *   onChange={(config) => updateCustomRunConfig({ modelConfig: config })}
+ *   defaultModelKey="gpt-4o"
+ * />
+ * ```
+ *
+ * @remarks
+ * - Supports both controlled (`value` prop) and uncontrolled (internal state) usage.
+ * - Fetch is performed only once per component mount via a ref guard.
+ * - The dropdown is intentionally borderless to blend into the sender footer.
+ */
 declare const ModelSelector: React__default.FC<ModelSelectorProps>;
 
 declare const MDResponse: React__default.MemoExoticComponent<({ content, context, embeddedLink, interactive, userData, noGenUI, }: {
@@ -832,33 +1223,95 @@ declare const MDViewFormItem: ({ value }: {
     value?: string;
 }) => react_jsx_runtime.JSX.Element;
 
+/**
+ * Props passed to every GenUI element component.
+ *
+ * Each element registered in the GenUI element registry receives these props,
+ * with the `data` field carrying the element-specific payload from the agent.
+ *
+ * @typeParam T - The shape of the element-specific data payload
+ */
 type ElementProps<T = any> = {
+    /** Key identifying which GenUI element component to render */
     component_key: string;
+    /** Optional context for the current conversation */
     context?: {
+        /** The thread ID associated with this element */
         thread_id?: string;
+        /** The assistant ID associated with this element */
         assistant_id?: string;
     };
+    /** Element-specific data payload from the agent */
     data: T;
+    /** Whether the element supports user interaction (defaults to false) */
     interactive?: boolean;
+    /** Whether to open this element in the side app panel by default */
     default_open_in_side_app?: boolean;
 };
+/**
+ * Metadata for a registered GenUI element.
+ *
+ * Defines how an element is rendered and optionally what action to perform
+ * when the user interacts with it.
+ */
 interface ElementMeta {
+    /** The main card-view React component for this element */
     card_view: React.FC<ElementProps>;
+    /** Optional side-app panel React component for expanded viewing */
     side_app_view?: React.FC<ElementProps>;
+    /** Optional action callback invoked when the user interacts with the element */
     action?: (data: any) => void;
 }
+/**
+ * Data structure representing a tool call made by the agent.
+ *
+ * Rendered by GenUI tool card elements to display tool invocations,
+ * their arguments, and their results.
+ */
 interface ToolCallData {
+    /** Unique identifier for this tool call */
     id: string;
+    /** Name of the tool being called */
     name: string;
+    /** Arguments passed to the tool */
     args: Record<string, any>;
+    /** Distinguishes tool calls from other message types */
     type: "tool_call";
+    /** The tool's response, if available */
     response?: string;
+    /** Execution status of the tool call */
     status?: "success" | "pending" | "error";
 }
 
 declare const getElement: (language: string | undefined) => ElementMeta | null;
 declare const regsiterElement: (language: string, ElementMeta: ElementMeta) => ElementMeta;
 
+/**
+ * Tabbed side-app browser that renders GenUI components in the right panel.
+ *
+ * Manages a tab strip of registered side-app views. When a new component is
+ * selected via {@link SideAppBrowserContext}, a tab is added (or activated if
+ * it already exists). Tabs are closable and switchable. An "all tabs" dropdown
+ * appears when there are 2+ tabs. Uses {@link ChatUIContext} to read/write the
+ * active side-app card and open/close the panel.
+ *
+ * @param region - Which panel region this browser is attached to.
+ *   `"side"` for the right detail panel (default), `"content"` for the main content area.
+ * @returns The tabbed side-app viewer, or an empty state if no tabs are open.
+ *
+ * @example
+ * ```tsx
+ * import { SideAppViewBrowser } from "@axiom-lattice/react-sdk";
+ *
+ * <SideAppViewBrowser region="side" />
+ * ```
+ *
+ * @remarks
+ * - Internally renders {@link SideAppBrowserContext.Provider} so that child
+ *   components can programmatically open new side-apps via `openApp()`.
+ * - Component resolution uses {@link getElement} from the GenUI element registry.
+ * - Designed to work with {@link ColumnLayout} as the `detail` panel.
+ */
 declare const SideAppViewBrowser: React__default.FC<{
     region?: "side" | "content";
 }>;
@@ -909,9 +1362,54 @@ declare const ChatUIContext: React__default.Context<{
     contentAppSelectedCard: PanelCard | null;
     setContentAppSelectedCard: (card: PanelCard | null) => void;
 }>;
+/**
+ * Chat UI context provider. Manages visibility and selected cards for chat panel areas
+ * (detail, tools, side app, content app) and the sidebar menu collapsed state.
+ *
+ * @description
+ * Tracks the open/closed state and the currently selected {@link PanelCard} for each panel:
+ * - **Detail panel**: A slide-out detail view that displays a chosen card's content.
+ * - **Tools panel**: A tools sidebar/drawer for tool-specific cards.
+ * - **Side app**: Aliases to the detail panel (shared state).
+ * - **Content app**: An inline content area for embedded app cards.
+ * - **Menu collapsed**: Whether the sidebar navigation menu is collapsed.
+ *
+ * Provides action helpers (`openDetail`, `closeDetail`, `openTools`, `toggleTools`, etc.)
+ * that set both visibility and selected card atomically.
+ *
+ * @param props - Provider props.
+ * @param props.children - React children to render within the UI context.
+ *
+ * @returns A React context provider wrapping children with {@link ChatUIContext.Provider}.
+ *
+ * @example
+ * ```tsx
+ * <ChatUIContextProvider>
+ *   <ChatLayout />
+ * </ChatUIContextProvider>
+ * ```
+ */
 declare const ChatUIContextProvider: ({ children, }: {
     children: React__default.ReactNode;
 }) => react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the chat UI context. Must be used within a {@link ChatUIContextProvider}.
+ *
+ * @description
+ * Returns panel visibility state, selected panel cards, and action functions for controlling
+ * the chat interface panels (detail, tools, side app, content app) and menu collapsed state.
+ *
+ * @returns The current chat UI context value containing panel state and control functions.
+ *
+ * @example
+ * ```tsx
+ * const { detailVisible, openDetail, closeDetail, toggleTools, menuCollapsed } = useChatUIContext();
+ *
+ * const handleCardClick = (card: PanelCard) => {
+ *   openDetail(card);
+ * };
+ * ```
+ */
 declare const useChatUIContext: () => {
     detailVisible: boolean;
     setDetailVisible: (visible: boolean) => void;
@@ -1052,8 +1550,33 @@ interface ConversationContextProviderProps {
  */
 declare function generateLabelFromMessage(message: string): string;
 /**
- * Provider component for ConversationContext
- * Manages conversation thread state for assistants
+ * Provider component for ConversationContext.
+ * Manages conversation thread state for the currently selected assistant.
+ *
+ * @description
+ * Coordinates with {@link AssistantContext} to load threads for the current assistant.
+ * Key behaviors:
+ * - **Thread loading**: Fetches threads from the API when the assistant changes. If no threads
+ *   exist, a new thread is automatically created.
+ * - **Auto-selection**: Selects the most recently updated thread as the active thread when loading.
+ * - **Cross-thread config**: Maintains an assistant-level `customRunConfig` shared across all threads
+ *   (useful for metrics datasource and other assistant-wide settings).
+ * - **Thread operations**: Provides full CRUD operations (create, update, delete, list, select)
+ *   backed by the client SDK.
+ *
+ * Requires {@link AssistantContextProvider} ancestor and {@link LatticeChatShellContextProvider}.
+ *
+ * @param props - {@link ConversationContextProviderProps}
+ * @param props.children - React children to render within the conversation context.
+ *
+ * @returns A React context provider wrapping children with {@link ConversationContext.Provider}.
+ *
+ * @example
+ * ```tsx
+ * <ConversationContextProvider>
+ *   <ThreadList />
+ * </ConversationContextProvider>
+ * ```
  */
 declare const ConversationContextProvider: ({ children, }: ConversationContextProviderProps) => react_jsx_runtime.JSX.Element;
 /**
@@ -1143,8 +1666,34 @@ interface AssistantContextProviderProps {
     initialAssistantId?: string | null;
 }
 /**
- * Provider component for AssistantContext
- * Manages assistant state and operations
+ * Provider component for AssistantContext.
+ * Manages assistant state and operations including CRUD, selection, and auto-loading.
+ *
+ * @description
+ * Coordinates with the client SDK to provide assistant management:
+ * - **Auto-load**: When `autoLoad` is `true` (default), fetches the assistant list on mount.
+ * - **Auto-selection**: If `initialAssistantId` is provided, selects that assistant after loading.
+ *   Otherwise, auto-selects the first available assistant.
+ * - **Re-selection**: If the currently selected assistant is removed from the list (e.g., deleted),
+ *   falls back to selecting the first available assistant.
+ * - **CRUD operations**: Provides `createAssistant`, `updateAssistant`, `deleteAssistant`, and
+ *   `getAssistant` backed by the SDK, keeping local state in sync.
+ *
+ * Requires an {@link AxiomLatticeProvider} ancestor for the API client.
+ *
+ * @param props - {@link AssistantContextProviderProps}
+ * @param props.children - React children to render within the assistant context.
+ * @param props.autoLoad - Whether to automatically load assistants on mount. Defaults to `true`.
+ * @param props.initialAssistantId - Optional assistant ID to auto-select on load.
+ *
+ * @returns A React context provider wrapping children with {@link AssistantContext.Provider}.
+ *
+ * @example
+ * ```tsx
+ * <AssistantContextProvider initialAssistantId="asst_123">
+ *   <AssistantSelector />
+ * </AssistantContextProvider>
+ * ```
  */
 declare const AssistantContextProvider: ({ children, autoLoad, initialAssistantId, }: AssistantContextProviderProps) => react_jsx_runtime.JSX.Element;
 /**
@@ -1376,6 +1925,13 @@ interface LatticeChatShellConfig {
      * Defaults to false
      */
     enableWorkspace?: boolean;
+    /**
+     * Whether to load custom menu items from the database (API /api/menu-items).
+     * When enabled, WorkspaceResourceManager fetches per-tenant custom menu items
+     * and merges them with built-in defaults.
+     * Defaults to true.
+     */
+    enableCustomMenu?: boolean;
     /**
      * Resource folders configuration for workspace
      * Each folder represents a section in the workspace assets panel
@@ -1550,33 +2106,107 @@ declare const LatticeChatShellContextProvider: ({ children, initialConfig, persi
  */
 declare const useLatticeChatShellContext: () => LatticeChatShellContextValue;
 
+/**
+ * Represents a single message in the chat UI.
+ *
+ * Used by the chat components to render messages, display thinking states,
+ * and handle tool call results. Can also contain nested child messages
+ * via the {@link items} property for grouped interactions.
+ */
 interface UIMessage {
+    /** Unique identifier for the message */
     id: string;
+    /** The run ID associated with this message, if part of an agent run */
     run_id?: string;
+    /** The text content of this message */
     content: string;
+    /** Display name of the sender (e.g. agent name) */
     name?: string;
+    /** Files attached to this message */
     files?: AttachFile[];
+    /** The role of the message sender */
     role: "human" | "ai" | "tool";
+    /** Nested child messages, used for tool call results or sub-tasks */
     items?: UIMessage[];
+    /** The type determines how the message is rendered in the chat UI */
     type: "message" | "action" | "message_chunk" | "start_thinking" | "thinking_chunk" | "end_thinking";
+    /** Parent message ID for nested/threaded messages */
     parent_id?: number | string;
+    /** Current status of the message (e.g. "complete", "streaming") */
     status?: string;
+    /** ID of the associated thinking block, if this is a thinking message */
     think_id?: string;
+    /** Type of thinking block (e.g. "reasoning") */
     think_type?: string;
 }
+/**
+ * Represents a file attachment in a chat message.
+ */
 interface AttachFile {
+    /** Display name of the attached file */
     name: string;
+    /** Unique identifier for the attached file */
     id: string;
 }
 
+/**
+ * Props for the {@link ColumnLayout} component.
+ *
+ * Defines the five content slots: menu sidebar, main chat, detail panel,
+ * tools panel, logo, and header.
+ */
 interface ColumnLayoutProps {
+    /** Left sidebar menu content. Hidden when collapsed. */
     menu?: React__default.ReactNode;
+    /** Primary content area (e.g., the chat thread). Required. */
     main: React__default.ReactNode;
+    /** Right detail panel content (e.g., side-app viewer). */
     detail?: React__default.ReactNode;
+    /** Right tools panel content (e.g., file browser). */
     tools?: React__default.ReactNode;
+    /** Logo or branding rendered at the top of the menu sidebar. */
     logo?: React__default.ReactNode;
+    /** Header bar rendered above the main content area on desktop and mobile. */
     header?: React__default.ReactNode;
 }
+/**
+ * Responsive three-column (plus tools) layout for the chat interface.
+ *
+ * Consists of:
+ * - **Menu** — collapsible left sidebar, auto-collapses on mobile or when
+ *   the detail panel is open.
+ * - **Main content** — central chat area.
+ * - **Detail panel** — right side panel for side-app views (sizable).
+ * - **Tools panel** — right panel for file browsing and workspace tools.
+ *
+ * Panel visibility and sizing is driven by {@link useChatUIContext}. On mobile,
+ * a hamburger toggle is rendered in the header to expand/collapse the menu.
+ *
+ * @param menu - Left sidebar menu content.
+ * @param main - Primary content area (required).
+ * @param detail - Right detail panel content.
+ * @param tools - Right tools panel content.
+ * @param logo - Logo rendered in the menu sidebar.
+ * @param header - Header bar content.
+ * @returns The responsive column layout element.
+ *
+ * @example
+ * ```tsx
+ * import { ColumnLayout } from "@axiom-lattice/react-sdk";
+ *
+ * <ColumnLayout
+ *   menu={<ChatSidebar />}
+ *   main={<Chating />}
+ *   detail={<SideAppViewBrowser />}
+ *   tools={<ToolPanelFiles />}
+ *   header={<AgentHeader />}
+ * />
+ * ```
+ *
+ * @remarks
+ * - Must be rendered inside a {@link ChatUIContextProvider}.
+ * - CSS class `fina_chat` is applied to the root div for external targeting.
+ */
 declare const ColumnLayout: React__default.FC<ColumnLayoutProps>;
 
 interface ExplorerFile {
@@ -1594,18 +2224,47 @@ interface FileExplorerProps {
 }
 declare const FileExplorer: React__default.FC<ElementProps>;
 
+/**
+ * Props for the {@link AgentConversations} component.
+ */
 interface AgentConversationsProps {
     /**
-     * Whether users can create new threads from the UI
-     * Defaults to true
+     * Whether users can create new threads from the UI.
+     * Defaults to true.
      */
     enableThreadCreation?: boolean;
     /**
-     * Whether the thread list should be rendered
-     * Defaults to true
+     * Whether the thread list should be rendered.
+     * Defaults to true.
      */
     enableThreadList?: boolean;
 }
+/**
+ * Thread list sidebar component showing conversation history for the current agent.
+ *
+ * Uses Ant Design X `Conversations` component to display threads fetched from
+ * {@link useConversationContext}. Supports creating new threads when
+ * `enableThreadCreation` is true.
+ *
+ * @param enableThreadCreation - Whether the "New Chat" button is shown. Default: true.
+ * @param enableThreadList - Whether the thread list is rendered at all. Default: true.
+ * @returns The conversations list or `null` if thread list is disabled.
+ *
+ * @example
+ * ```tsx
+ * import { AgentConversations } from "@axiom-lattice/react-sdk";
+ *
+ * <AgentConversations
+ *   enableThreadCreation={false}
+ *   enableThreadList
+ * />
+ * ```
+ *
+ * @remarks
+ * - Requires ancestor context providers: {@link ConversationContextProvider} and
+ *   {@link AssistantContextProvider}.
+ * - Returns `null` when `enableThreadList` is false.
+ */
 declare const AgentConversations: React__default.FC<AgentConversationsProps>;
 
 declare const MetricsConfigDrawerContent: React__default.FC;
@@ -1613,10 +2272,10 @@ declare const MetricsConfigDrawerContent: React__default.FC;
 /**
  * Built-in default menu items for the workspace shell.
  *
- * Contains 12 route/action items organized in groups:
+ * Contains 11 route/action items organized in groups:
  * - Projects
  * - DataSource: Metrics, Database
- * - Process: Automations, Runtime, Inbox, Eval
+ * - Process: Workflows, Runtime, Inbox, Eval
  * - Settings: Assistants, Skills, MCP, Tools
  * - Account: Switch tenant
  *
@@ -1637,6 +2296,12 @@ interface WorkspaceResourceManagerProps {
 declare const WorkspaceResourceManager: React__default.FC<WorkspaceResourceManagerProps>;
 declare const WorkspaceResourceUIContext: React__default.FC<WorkspaceResourceManagerProps>;
 
+/**
+ * Props for the {@link LatticeChatShell} component.
+ *
+ * Extends {@link LatticeChatShellContextProviderProps} (minus `children`) with
+ * feature toggles that control chat UI surface capabilities.
+ */
 type LatticeChatShellProps = Omit<LatticeChatShellContextProviderProps, "children"> & {
     /**
      * Whether users can create new assistants (default: true)
@@ -1656,14 +2321,46 @@ type LatticeChatShellProps = Omit<LatticeChatShellContextProviderProps, "childre
     enableModelSelector?: boolean;
 };
 /**
- * Lattice Chat Shell component
- * Provides a complete chat interface with conversation management
- * Uses LatticeChatShellContext for configuration (baseURL, etc.)
+ * Lattice Chat Shell — the top-level provider component for the full chat interface.
+ *
+ * Sets up the required context hierarchy:
+ * - {@link LatticeChatShellContextProvider} — config layer (baseURL, feature toggles)
+ * - Optionally {@link WorkspaceContextProvider} when `enableWorkspace` is true
+ * - {@link AssistantContextProvider} — assistant loading
+ * - {@link ConversationContextProvider} — thread management
+ * - {@link AgentServerSetting} — server configuration modal
+ *
+ * Children render {@link LatticeChatView} which contains the chat sidebar and
+ * the {@link LatticeChat} thread interface.
+ *
+ * @param props - See {@link LatticeChatShellProps}.
+ * @returns A React provider tree wrapping the chat UI.
+ *
+ * @example
+ * ```tsx
+ * import { LatticeChatShell } from "@axiom-lattice/react-sdk";
+ *
+ * <LatticeChatShell
+ *   initialConfig={{ baseURL: "https://api.example.com", assistantId: "asst_1" }}
+ *   enableAssistantCreation={false}
+ *   enableWorkspace
+ *   enableModelSelector
+ * />
+ * ```
+ *
+ * @remarks
+ * - `enableWorkspace` in props takes priority over `initialConfig.enableWorkspace`.
+ * - This component should wrap all chat-related components in the application.
  */
 declare const LatticeChatShell: React__default.FC<LatticeChatShellProps>;
 
+/**
+ * Props for the {@link ChatSidebar} component.
+ */
 interface ChatSidebarProps {
+    /** Callback invoked when the user clicks the settings menu item. */
     onSettingsClick?: () => void;
+    /** Whether the sidebar starts collapsed. */
     defaultCollapsed?: boolean;
     /** @deprecated Use `sideMenuItems` on `LatticeChatShellConfig` instead. */
     customMenuItems?: SideMenuItemConfig[];
@@ -1682,20 +2379,68 @@ interface ChatSidebarProps {
  * Or omit `sideMenuItems` entirely to use these defaults as-is.
  */
 declare const DEFAULT_MENU_ITEMS: SideMenuItemConfig[];
+/**
+ * Navigation sidebar for the chat interface.
+ *
+ * Renders a vertical {@link Menu} with configurable sidebar menu items
+ * (defaults to {@link DEFAULT_MENU_ITEMS}) and a user avatar popover with
+ * change-password and logout actions. Supports inline drawers for items like
+ * thread history, and non-inline drawers rendered via Ant Design `Drawer`.
+ *
+ * @param props - See {@link ChatSidebarProps}.
+ * @returns The sidebar element containing the menu and user-footer area.
+ *
+ * @example
+ * ```tsx
+ * import { ChatSidebar } from "@axiom-lattice/react-sdk";
+ *
+ * <ChatSidebar
+ *   onSettingsClick={() => showSettingsModal()}
+ * />
+ * ```
+ *
+ * @remarks
+ * - Sidebar mode (expanded/icon), toggle visibility, and new-analysis button
+ *   visibility are controlled by {@link LatticeChatShellContext} config fields:
+ *   `sidebarMode`, `sidebarShowToggle`, `sidebarShowNewAnalysis`.
+ * - Inline drawers (e.g. thread history) are handled within the {@link Menu}
+ *   component; non-inline drawers render as separate `Drawer` elements.
+ * - User authentication comes from {@link useAuth}.
+ */
 declare const ChatSidebar: React__default.FC<ChatSidebarProps>;
 
 declare const ChannelInstallationsDrawerContent: React__default.FC;
 
+/**
+ * Props for the {@link ScheduleButton} component.
+ */
 interface ScheduleButtonProps {
     /**
-     * Custom tooltip text
+     * Custom tooltip text displayed on hover.
      */
     tooltipText?: string;
 }
 /**
- * ScheduleButton - A button component to view scheduled tasks for the current thread
- * Shows a badge with the count of active scheduled tasks
- * Opens a side panel with the full schedule viewer when clicked
+ * A toolbar button that shows the count of active scheduled tasks for the
+ * current agent thread and opens an agenda viewer in the side panel on click.
+ *
+ * Fetches scheduled tasks via {@link useClient} on mount and whenever the
+ * thread ID changes. The button is hidden when no tasks exist.
+ *
+ * @param tooltipText - Tooltip text shown on hover (default: "Agenda").
+ * @returns The schedule button, or `null` if there is no thread ID or no tasks.
+ *
+ * @example
+ * ```tsx
+ * import { ScheduleButton } from "@axiom-lattice/react-sdk";
+ *
+ * <ScheduleButton tooltipText="Scheduled Reports" />
+ * ```
+ *
+ * @remarks
+ * - Requires ancestor context for {@link useAgentChat} and {@link ChatUIContextProvider}.
+ * - Only active tasks (status PENDING or PAUSED) contribute to the badge count.
+ * - Opens a side-app with `component_key: "schedule_viewer"`.
  */
 declare const ScheduleButton: React__default.FC<ScheduleButtonProps>;
 
@@ -1775,6 +2520,101 @@ interface SkillNodeData extends Record<string, unknown> {
  */
 declare const SkillNode: React__default.FC<NodeProps<Node<SkillNodeData>>>;
 
+interface DSLNode {
+    id: string;
+    type: "agent" | "map" | "terminal";
+    name: string;
+    description?: string;
+    ref?: string;
+    config?: Record<string, unknown>;
+    input?: {
+        template: string;
+    };
+    output?: {
+        key?: string;
+        schema?: Record<string, unknown>;
+    };
+    source?: string;
+    node?: {
+        type: string;
+        ref: string;
+        input?: {
+            template: string;
+        };
+    };
+    status?: "success" | "failed" | "cancelled";
+    itemKey?: string;
+    ask?: boolean;
+    condition?: string;
+    /** When set, this node belongs to a parallel group. */
+    parentGroup?: string;
+}
+interface DSLEdge {
+    from: string;
+    to?: string | string[];
+}
+interface ExpandedDSL {
+    version: string;
+    name: string;
+    nodes: DSLNode[];
+    edges: DSLEdge[];
+}
+
+interface RunStep {
+    id: string;
+    stepType: string;
+    stepName: string;
+    threadId?: string | null;
+    edgeFrom?: string;
+    edgeTo?: string;
+    edgePurpose?: string;
+    input?: Record<string, unknown>;
+    output?: Record<string, unknown>;
+    status: string;
+    errorMessage?: string;
+    startedAt: string;
+    completedAt?: string;
+    durationMs?: number;
+}
+interface WorkflowCanvasProps {
+    dsl: ExpandedDSL;
+    steps?: RunStep[];
+    assistantId?: string;
+    onNodeClick?: (nodeId: string) => void;
+    height?: number | string;
+}
+declare const WorkflowCanvas: React__default.FC<WorkflowCanvasProps>;
+
+interface RunState {
+    status: "running" | "completed" | "failed" | "interrupted" | "skipped";
+    stepType?: string;
+    durationMs?: number;
+    selected?: boolean;
+}
+interface WorkflowNodeData extends Record<string, unknown> {
+    nodeType: "agent" | "map" | "terminal";
+    name: string;
+    description?: string;
+    ref?: string;
+    outputKey?: string;
+    nodeSchema?: unknown;
+    config?: Record<string, unknown>;
+    status?: string;
+    source?: string;
+    innerRef?: string;
+    reduceRef?: string;
+    inputTemplate?: string;
+    /** true when node has ask_user_to_clarify middleware (needs+if DSL) */
+    ask?: boolean;
+    /** if condition expression (shown in design view) */
+    condition?: string;
+    runState?: RunState;
+    pending?: boolean;
+}
+declare const WorkflowNode: React__default.FC<NodeProps<Node<WorkflowNodeData>>>;
+
+declare const WorkflowAutomationView: React__default.FC;
+
 interface CreateAssistantModalProps {
     open: boolean;
     onCancel: () => void;
@@ -1782,28 +2622,138 @@ interface CreateAssistantModalProps {
 }
 declare const CreateAssistantModal: React__default.FC<CreateAssistantModalProps>;
 
+/**
+ * Top-level evaluation panel component.
+ *
+ * Provides a multi-page interface for managing agent evaluation:
+ * - **Dashboard**: Overview of test suites, cases, and recent runs with stats cards.
+ * - **Suites**: List of test suites with options to create, view, and run all.
+ * - **Suite Detail**: View and manage test cases within a single suite.
+ * - **Run Results**: View detailed results of a specific evaluation run.
+ *
+ * Automatically selects the first project when projects load. Uses a
+ * lightweight page-based navigation model (`dashboard -> suites -> suite -> run`).
+ *
+ * @example
+ * ```tsx
+ * import { EvalPanel } from "@axiom-lattice/react-sdk";
+ *
+ * function App() {
+ *   return (
+ *     <AxiomLatticeProvider config={config}>
+ *       <EvalPanel />
+ *     </AxiomLatticeProvider>
+ *   );
+ * }
+ * ```
+ */
 declare const EvalPanel: React__default.FC;
 
+/**
+ * Props for {@link EvalSuiteCardList}.
+ */
 interface Props {
+    /** The evaluation project ID to load suites from */
     projectId: string;
+    /** Callback invoked when the user selects a suite card */
     onSelectSuite: (projectId: string, suiteId: string) => void;
 }
+/**
+ * Displays evaluation test suites as a grid of cards.
+ *
+ * Each card shows the suite name, case count, and a delete action.
+ * Handles loading, empty, and populated states.
+ *
+ * @example
+ * ```tsx
+ * <EvalSuiteCardList
+ *   projectId="proj-123"
+ *   onSelectSuite={(pid, sid) => navigate(`/suites/${sid}`)}
+ * />
+ * ```
+ */
 declare const EvalSuiteCardList: React__default.FC<Props>;
 
+/**
+ * Props for {@link EvalSuiteDetail}.
+ */
 interface EvalSuiteDetailProps {
+    /** The evaluation project ID */
     projectId: string;
+    /** The suite ID to display */
     suiteId: string;
+    /** Callback to navigate back to the suite list */
     onBack: () => void;
+    /** Callback invoked when a run is started, receiving the run ID */
     onRun: (runId: string) => void;
 }
+/**
+ * Detail view for a single evaluation suite.
+ *
+ * Displays a breadcrumb header, a table of test cases with input messages,
+ * agent references, rubric counts, and delete actions. Includes a modal form
+ * for adding new test cases with agent selection, output type, and expected
+ * content assertion.
+ *
+ * @example
+ * ```tsx
+ * <EvalSuiteDetail
+ *   projectId="proj-123"
+ *   suiteId="suite-456"
+ *   onBack={() => setPage("suites")}
+ *   onRun={(runId) => setRunId(runId)}
+ * />
+ * ```
+ */
 declare const EvalSuiteDetail: React__default.FC<EvalSuiteDetailProps>;
 
+/**
+ * Props for {@link EvalRunResults}.
+ */
 interface EvalRunResultsProps {
+    /** The run ID whose results to display */
     runId: string;
+    /** Callback to navigate back to the previous page */
     onBack: () => void;
 }
+/**
+ * Displays detailed results for a single evaluation run.
+ *
+ * Shows a summary card with total/passed/failed counts, average score,
+ * and pass rate. Renders an expandable table of per-case results including
+ * pass/fail status, suite name, input message, judge summary, dimension
+ * scores with progress bars, and overall score.
+ *
+ * Supports live streaming progress during active runs and a delete action.
+ *
+ * @example
+ * ```tsx
+ * <EvalRunResults
+ *   runId="run-789"
+ *   onBack={() => setPage("dashboard")}
+ * />
+ * ```
+ */
 declare const EvalRunResults: React__default.FC<EvalRunResultsProps>;
 
+interface PersonalAssistantPageProps {
+}
+declare const PersonalAssistantPage: React__default.FC<PersonalAssistantPageProps>;
+
+type LatticeAgentWorkspaceProps = AgentChatProps & {
+    workspaceId?: string;
+    projectId?: string;
+};
+declare const LatticeAgentWorkspace: React__default.FC<LatticeAgentWorkspaceProps>;
+
+/**
+ * Toggle button for the file/directory tool panel.
+ *
+ * Must be rendered within a {@link ChatUIContextProvider} (which
+ * {@link LatticeChat} provides automatically).
+ */
+declare const FilePanelToggle: React__default.FC;
+
 interface SkillCategoryPromptsProps {
     senderRef: React__default.RefObject<any>;
     visible?: boolean;
@@ -2314,4 +3264,4 @@ type IframeMessage = {
 };
 declare function generateIframeSrcdoc(): string;
 
-export { type AgentChatProps, AgentConversations, type AgentConversationsProps, type AgentState, AgentThreadProvider, type AgentThreadProviderProps, AssistantContext, AssistantContextProvider, type AssistantContextProviderProps, type AssistantContextValue, AssistantFlow, type AssistantFlowProps, AssistantNode, type AssistantNodeData, type AssistantState, type AttachFile, type AuthContextValue, AuthProvider, AxiomLatticeProvider, type AxiomLatticeProviderProps, type BalanceResult, ChangePasswordModal, type ChangePasswordModalProps, ChannelInstallationsDrawerContent, type ChatResponse, ChatSidebar, type ChatSidebarProps, type ChatState, type ChatStateWithAgent, ChatUIContext, ChatUIContextProvider, Chating, type ChatingProps, type ClientConfig, ColumnLayout, type ColumnLayoutProps, ConversationContext, ConversationContextProvider, type ConversationContextProviderProps, type ConversationContextValue, type ConversationThread, CreateAssistantModal, DEFAULT_MENU_ITEMS, DEFAULT_MIDDLEWARE_TYPES, DEFAULT_WORKSPACE_MENU_ITEMS, type ElementMeta, type ElementProps, EvalPanel, EvalRunResults, EvalSuiteCardList, EvalSuiteDetail, type ExplorerFile, FileExplorer, type FileExplorerProps, type IframeMessage, LatticeChat, LatticeChatShell, type LatticeChatShellConfig, LatticeChatShellContext, LatticeChatShellContextProvider, type LatticeChatShellContextProviderProps, type LatticeChatShellContextValue, type LatticeChatShellProps, LoginForm, type LoginFormProps, LoginPage, MDResponse, MDViewFormItem, MetricsConfigDrawerContent, type MiddlewareConfigDefinition, type MiddlewareConfigSchema, type MiddlewareConfigSchemaProperty, type MiddlewareToolDefinition, type MiddlewareTypeDefinition, type ModelConfig, type ModelInfo, ModelSelector, type ModelSelectorProps, type PanelCard, type PendingMessage, ProtectedRoute, type ProtectedRouteProps, type QuickPromptCategory, type QuickPromptItem, RegisterForm, type RegisterFormProps, type ResourceFolderConfig, type SanitizerConfig, ScheduleButton, type ScheduleButtonProps, SideAppBrowserContext, type SideAppBrowserContextValue, SideAppViewBrowser, type SideMenuItemConfig, type SideMenuItemType, SkillCategoryPrompts, type SkillCategoryPromptsProps, SkillFlow, type SkillFlowProps, SkillNode, type SkillNodeData, type StreamEventHandlerOptions, type StreamingError, StreamingHTMLRenderer, type StreamingHTMLRendererProps, TenantSelector, type TenantSelectorProps, type ThreadState, type ToolCallData, type UIMessage, type UseAgentStateOptions, type UseAgentStateReturn, type UseApiOptions, type UseApiReturn, type UseAxiomLatticeOptions, type UseChatOptions, type UseTenantsOptions, type UseTenantsReturn, type UseUsersOptions, type UseUsersReturn, UserProfile, type UserProfileProps, type UserTenantInfo, WorkspaceResourceManager, type WorkspaceResourceManagerProps, WorkspaceResourceUIContext, animation, axiomAntdTheme, axiomAntdThemeDark, axiomTokens, colors, generateIframeSrcdoc, generateLabelFromMessage, getAxiomAntdTheme, getElement, radius, regsiterElement, shadows, spacing, typography, useAgentChat, useAgentGraph, useAgentState, useAgentThreadContext, useApi, useAssistantContext, useAuth, useAuthOptional, useAxiomLattice, useAxiomTheme, useChat, useChatUIContext, useClient, useConversationContext, useEvalCases, useEvalProjects, useEvalRunStream, useEvalRuns, useEvalSuites, useLatticeChatShellContext, useSideAppBrowser, useSideAppOpener, useTenants, useUsers };
+export { type AgentChatProps, AgentConversations, type AgentConversationsProps, type AgentState, AgentThreadProvider, type AgentThreadProviderProps, AssistantContext, AssistantContextProvider, type AssistantContextProviderProps, type AssistantContextValue, AssistantFlow, type AssistantFlowProps, AssistantNode, type AssistantNodeData, type AssistantState, type AttachFile, type AuthContextValue, AuthProvider, AxiomLatticeProvider, type AxiomLatticeProviderProps, type BalanceResult, ChangePasswordModal, type ChangePasswordModalProps, ChannelInstallationsDrawerContent, type ChatResponse, ChatSidebar, type ChatSidebarProps, type ChatState, type ChatStateWithAgent, ChatUIContext, ChatUIContextProvider, Chating, type ChatingProps, type ClientConfig, ColumnLayout, type ColumnLayoutProps, ConversationContext, ConversationContextProvider, type ConversationContextProviderProps, type ConversationContextValue, type ConversationThread, CreateAssistantModal, DEFAULT_MENU_ITEMS, DEFAULT_MIDDLEWARE_TYPES, DEFAULT_WORKSPACE_MENU_ITEMS, type ElementMeta, type ElementProps, EvalPanel, EvalRunResults, EvalSuiteCardList, EvalSuiteDetail, type ExplorerFile, FileExplorer, type FileExplorerProps, FilePanelToggle, type IframeMessage, LatticeAgentWorkspace, LatticeChat, LatticeChatShell, type LatticeChatShellConfig, LatticeChatShellContext, LatticeChatShellContextProvider, type LatticeChatShellContextProviderProps, type LatticeChatShellContextValue, type LatticeChatShellProps, LoginForm, type LoginFormProps, LoginPage, MDResponse, MDViewFormItem, MetricsConfigDrawerContent, type MiddlewareConfigDefinition, type MiddlewareConfigSchema, type MiddlewareConfigSchemaProperty, type MiddlewareToolDefinition, type MiddlewareTypeDefinition, type ModelConfig, type ModelInfo, ModelSelector, type ModelSelectorProps, type PanelCard, type PendingMessage, PersonalAssistantPage, ProtectedRoute, type ProtectedRouteProps, type QuickPromptCategory, type QuickPromptItem, RegisterForm, type RegisterFormProps, type ResourceFolderConfig, type SanitizerConfig, ScheduleButton, type ScheduleButtonProps, SideAppBrowserContext, type SideAppBrowserContextValue, SideAppViewBrowser, type SideMenuItemConfig, type SideMenuItemType, SkillCategoryPrompts, type SkillCategoryPromptsProps, SkillFlow, type SkillFlowProps, SkillNode, type SkillNodeData, type StreamEventHandlerOptions, type StreamingError, StreamingHTMLRenderer, type StreamingHTMLRendererProps, TenantSelector, type TenantSelectorProps, type ThreadState, type ToolCallData, type UIMessage, type UseAgentStateOptions, type UseAgentStateReturn, type UseApiOptions, type UseApiReturn, type UseAxiomLatticeOptions, type UseChatOptions, type UseTenantsOptions, type UseTenantsReturn, type UseUsersOptions, type UseUsersReturn, UserProfile, type UserProfileProps, type UserTenantInfo, WorkflowAutomationView, WorkflowCanvas, type WorkflowCanvasProps, WorkflowNode, type WorkflowNodeData, WorkspaceResourceManager, type WorkspaceResourceManagerProps, WorkspaceResourceUIContext, animation, axiomAntdTheme, axiomAntdThemeDark, axiomTokens, colors, generateIframeSrcdoc, generateLabelFromMessage, getAxiomAntdTheme, getElement, radius, regsiterElement, shadows, spacing, typography, useAgentChat, useAgentGraph, useAgentState, useAgentThreadContext, useApi, useAssistantContext, useAuth, useAuthOptional, useAxiomLattice, useAxiomTheme, useChat, useChatUIContext, useClient, useConversationContext, useEvalCases, useEvalProjects, useEvalRunStream, useEvalRuns, useEvalSuites, useLatticeChatShellContext, useSideAppBrowser, useSideAppOpener, useTenants, useUsers };