@superatomai/application-react 0.0.1 → 0.0.3

package/dist/index.d.cts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import React, { Component as Component$1, ReactNode } from 'react';
+import * as React from 'react';
+import React__default, { Component as Component$1, ReactNode } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
 declare const ExpressionSchema$1: z.ZodObject<{
@@ -244,6 +245,36 @@ declare const UserPromptRequestMessageSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 type UserPromptRequestMessage = z.infer<typeof UserPromptRequestMessageSchema>;
+/**
+ * User prompt abort request payload schema
+ * Synced with sdk-nodejs: UserPromptAbortRequestPayloadSchema
+ */
+declare const UserPromptAbortRequestPayloadSchema: z.ZodObject<{
+    uiBlockId: z.ZodString;
+    threadId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type UserPromptAbortRequestPayload = z.infer<typeof UserPromptAbortRequestPayloadSchema>;
+/**
+ * User prompt abort request message schema
+ * Synced with sdk-nodejs: UserPromptAbortRequestMessageSchema
+ */
+declare const UserPromptAbortRequestMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"USER_PROMPT_ABORT_REQ">;
+    from: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    to: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    payload: z.ZodObject<{
+        uiBlockId: z.ZodString;
+        threadId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type UserPromptAbortRequestMessage = z.infer<typeof UserPromptAbortRequestMessageSchema>;
 /**
  * Component schema (from backend)
  * Synced with sdk-nodejs: ComponentSchema
@@ -1026,8 +1057,17 @@ declare const ClientConfigSchema: z.ZodObject<{
     maxReconnectDelay: z.ZodDefault<z.ZodNumber>;
     defaultTimeout: z.ZodDefault<z.ZodNumber>;
     debug: z.ZodDefault<z.ZodBoolean>;
+    token: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-type ClientConfig = z.input<typeof ClientConfigSchema>;
+type ClientConfig = z.input<typeof ClientConfigSchema> & {
+    /**
+     * Called before every (re)connect for a valid session token, replacing
+     * `token`. Used for SDK sign-in (see SdkSession in auth.ts). Rejecting with an
+     * error whose `fatal` is true stops reconnecting; any other rejection is
+     * retried with the normal back-off.
+     */
+    getAccessToken?: () => Promise<string>;
+};
 type ResolvedClientConfig = z.output<typeof ClientConfigSchema>;
 
 /**
@@ -1048,6 +1088,20 @@ type ResolvedClientConfig = z.output<typeof ClientConfigSchema>;
  * @returns Server response message
  */
 declare function sendUserPromptRequest(client: SuperatomClient, prompt: string, threadId: string, uiBlockId: string, userId?: string, responseMode?: 'component' | 'text', onStream?: (chunk: string) => void, timeout?: number): Promise<Message>;
+/**
+ * Abort an in-flight user prompt request.
+ *
+ * Fire-and-forget: sends a USER_PROMPT_ABORT_REQ identifying the question by its
+ * uiBlockId. The backend cancels the matching in-flight request (LLM stream,
+ * source agents, any running script) and acks with USER_PROMPT_ABORTED. There's
+ * no response to await — the caller has already marked the message "stopped" on
+ * its side; this just stops the server-side work.
+ *
+ * @param client - SuperatomClient instance
+ * @param uiBlockId - The uiBlockId of the question to cancel
+ * @param threadId - The thread the question belongs to (optional context)
+ */
+declare function abortUserPromptRequest(client: SuperatomClient, uiBlockId: string, threadId?: string): void;
 /**
  * Send a user prompt suggestions request
  * @param client - SuperatomClient instance
@@ -1740,6 +1794,99 @@ declare function queryMenus(client: SuperatomClient, options?: QueryMenusOptions
     message?: string;
 }>;
 
+/**
+ * User Conversations Service
+ * Thread list + thread history via the `user-conversations` data collection
+ * (same calls as Runtime-react's services/wsMessages/userConversations.ts)
+ */
+
+/**
+ * A single conversation thread summary, as returned by getUserThreads.
+ * `title` is the opening question of the thread (its earliest prompt).
+ */
+interface ThreadSummary {
+    threadId: string;
+    title: string;
+    messageCount: number;
+    createdAt: string;
+    updatedAt: string;
+    archived: boolean;
+    config?: {
+        dashboardId?: string;
+    } | null;
+}
+/**
+ * One persisted Q&A row inside a thread (the user_conversations table shape).
+ * The full assistant response lives inside `response`.
+ */
+interface ThreadConversationRow {
+    id: number;
+    userId: string;
+    threadid: string | null;
+    userprompt: string;
+    status?: 'success' | 'error' | 'aborted';
+    response: {
+        id?: string;
+        component?: any;
+        analysis?: string | null;
+        user_prompt?: string;
+        error?: unknown;
+        [key: string]: any;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * List the user's conversation threads, most-recently-active first.
+ * `total` is the user's full thread count (independent of the page window).
+ */
+declare function getUserThreads(client: SuperatomClient, userId: string, limit?: number, offset?: number, timeout?: number): Promise<{
+    success: boolean;
+    threads: ThreadSummary[];
+    total: number;
+    error?: string;
+}>;
+/**
+ * Delete a whole thread (all its conversations).
+ */
+declare function deleteThread(client: SuperatomClient, userId: string, threadId: string, clearCache?: boolean, timeout?: number): Promise<{
+    success: boolean;
+    error?: string;
+    message?: string;
+    deletedCount?: number;
+}>;
+/**
+ * Delete one saved question/answer, by the question that produced it.
+ *
+ * `clearCache` also drops what was cached for it (query results and embeddings),
+ * so asking the same thing again is answered from the data, not from the old
+ * result. Same call Runtime-react's trash button makes.
+ */
+declare function deleteUserConversation(client: SuperatomClient, userPrompt: string, userId?: string, clearCache?: boolean, timeout?: number): Promise<{
+    success: boolean;
+    error?: string;
+    message?: string;
+    queriesDeleted?: number;
+}>;
+/**
+ * Rename a thread's title.
+ */
+declare function updateThreadTitle(client: SuperatomClient, userId: string, threadId: string, title: string, timeout?: number): Promise<{
+    success: boolean;
+    error?: string;
+    title?: string;
+}>;
+/**
+ * Fetch a page of conversations within a thread, newest-first (offset 0 = the
+ * most recent `limit` messages). `total` is the thread's full message count.
+ */
+declare function getThreadConversations(client: SuperatomClient, userId: string, threadId: string, limit?: number, offset?: number, timeout?: number): Promise<{
+    success: boolean;
+    rows: ThreadConversationRow[];
+    total: number;
+    error?: string;
+}>;
+
 /**
  * Services Index
  * Re-exports all service functions for easy importing
@@ -1761,12 +1908,17 @@ type index_QueryReportsOptions = QueryReportsOptions;
 type index_QueryUIsOptions = QueryUIsOptions;
 type index_QueryUsersOptions = QueryUsersOptions;
 type index_Report = Report;
+type index_ThreadConversationRow = ThreadConversationRow;
+type index_ThreadSummary = ThreadSummary;
 type index_UI = UI;
 type index_UpdateBookmarkOptions = UpdateBookmarkOptions;
 type index_User = User;
+declare const index_abortUserPromptRequest: typeof abortUserPromptRequest;
 declare const index_createBookmark: typeof createBookmark;
 declare const index_deleteArtifact: typeof deleteArtifact;
 declare const index_deleteBookmark: typeof deleteBookmark;
+declare const index_deleteThread: typeof deleteThread;
+declare const index_deleteUserConversation: typeof deleteUserConversation;
 declare const index_getActions: typeof getActions;
 declare const index_getAllArtifacts: typeof getAllArtifacts;
 declare const index_getAllBookmarks: typeof getAllBookmarks;
@@ -1782,7 +1934,9 @@ declare const index_getMenu: typeof getMenu;
 declare const index_getMenusHierarchy: typeof getMenusHierarchy;
 declare const index_getReport: typeof getReport;
 declare const index_getRootMenus: typeof getRootMenus;
+declare const index_getThreadConversations: typeof getThreadConversations;
 declare const index_getUI: typeof getUI;
+declare const index_getUserThreads: typeof getUserThreads;
 declare const index_injectBundleStyles: typeof injectBundleStyles;
 declare const index_queryArtifacts: typeof queryArtifacts;
 declare const index_queryBookmarks: typeof queryBookmarks;
@@ -1797,8 +1951,9 @@ declare const index_sendComponents: typeof sendComponents;
 declare const index_sendUserPromptRequest: typeof sendUserPromptRequest;
 declare const index_sendUserPromptSuggestionsRequest: typeof sendUserPromptSuggestionsRequest;
 declare const index_updateBookmark: typeof updateBookmark;
+declare const index_updateThreadTitle: typeof updateThreadTitle;
 declare namespace index {
-  export { type index_Artifact as Artifact, type Binding$1 as Binding, BindingSchema$1 as BindingSchema, type index_Bookmark as Bookmark, type index_CreateBookmarkOptions as CreateBookmarkOptions, type DSLRendererProps$3 as DSLRendererProps, DSLRendererPropsSchema$3 as DSLRendererPropsSchema, type index_Dashboard as Dashboard, type Expression$1 as Expression, ExpressionSchema$1 as ExpressionSchema, type ForDirective$1 as ForDirective, ForDirectiveSchema$1 as ForDirectiveSchema, type index_Menu as Menu, type index_Page as Page, index_PageSchema as PageSchema, type index_QueryArtifactsFilters as QueryArtifactsFilters, type index_QueryArtifactsOptions as QueryArtifactsOptions, type index_QueryBookmarksOptions as QueryBookmarksOptions, type index_QueryDashboardsOptions as QueryDashboardsOptions, type index_QueryMenusOptions as QueryMenusOptions, type index_QueryReportsOptions as QueryReportsOptions, type QuerySpec$1 as QuerySpec, QuerySpecSchema$1 as QuerySpecSchema, type index_QueryUIsOptions as QueryUIsOptions, type index_QueryUsersOptions as QueryUsersOptions, type index_Report as Report, type DSLRendererProps$2 as ReportDSLRendererProps, type index_UI as UI, type UIComponent$1 as UIComponent, UIComponentSchema$1 as UIComponentSchema, type DSLRendererProps$1 as UIDSLRendererProps, type UIElement$1 as UIElement, UIElementSchema$1 as UIElementSchema, type index_UpdateBookmarkOptions as UpdateBookmarkOptions, type index_User as User, index_createBookmark as createBookmark, index_deleteArtifact as deleteArtifact, index_deleteBookmark as deleteBookmark, index_getActions as getActions, index_getAllArtifacts as getAllArtifacts, index_getAllBookmarks as getAllBookmarks, index_getAllDashboards as getAllDashboards, index_getAllMenus as getAllMenus, index_getAllReports as getAllReports, index_getAllUIs as getAllUIs, index_getArtifact as getArtifact, index_getBookmark as getBookmark, index_getChildMenus as getChildMenus, index_getDashboard as getDashboard, index_getMenu as getMenu, index_getMenusHierarchy as getMenusHierarchy, index_getReport as getReport, index_getRootMenus as getRootMenus, index_getUI as getUI, index_injectBundleStyles as injectBundleStyles, index_queryArtifacts as queryArtifacts, index_queryBookmarks as queryBookmarks, index_queryDashboards as queryDashboards, index_queryMenus as queryMenus, index_queryReports as queryReports, index_queryUIs as queryUIs, index_queryUsers as queryUsers, index_requestBundle as requestBundle, index_requestData as requestData, index_sendComponents as sendComponents, index_sendUserPromptRequest as sendUserPromptRequest, index_sendUserPromptSuggestionsRequest as sendUserPromptSuggestionsRequest, index_updateBookmark as updateBookmark };
+  export { type index_Artifact as Artifact, type Binding$1 as Binding, BindingSchema$1 as BindingSchema, type index_Bookmark as Bookmark, type index_CreateBookmarkOptions as CreateBookmarkOptions, type DSLRendererProps$3 as DSLRendererProps, DSLRendererPropsSchema$3 as DSLRendererPropsSchema, type index_Dashboard as Dashboard, type Expression$1 as Expression, ExpressionSchema$1 as ExpressionSchema, type ForDirective$1 as ForDirective, ForDirectiveSchema$1 as ForDirectiveSchema, type index_Menu as Menu, type index_Page as Page, index_PageSchema as PageSchema, type index_QueryArtifactsFilters as QueryArtifactsFilters, type index_QueryArtifactsOptions as QueryArtifactsOptions, type index_QueryBookmarksOptions as QueryBookmarksOptions, type index_QueryDashboardsOptions as QueryDashboardsOptions, type index_QueryMenusOptions as QueryMenusOptions, type index_QueryReportsOptions as QueryReportsOptions, type QuerySpec$1 as QuerySpec, QuerySpecSchema$1 as QuerySpecSchema, type index_QueryUIsOptions as QueryUIsOptions, type index_QueryUsersOptions as QueryUsersOptions, type index_Report as Report, type DSLRendererProps$2 as ReportDSLRendererProps, type index_ThreadConversationRow as ThreadConversationRow, type index_ThreadSummary as ThreadSummary, type index_UI as UI, type UIComponent$1 as UIComponent, UIComponentSchema$1 as UIComponentSchema, type DSLRendererProps$1 as UIDSLRendererProps, type UIElement$1 as UIElement, UIElementSchema$1 as UIElementSchema, type index_UpdateBookmarkOptions as UpdateBookmarkOptions, type index_User as User, index_abortUserPromptRequest as abortUserPromptRequest, index_createBookmark as createBookmark, index_deleteArtifact as deleteArtifact, index_deleteBookmark as deleteBookmark, index_deleteThread as deleteThread, index_deleteUserConversation as deleteUserConversation, index_getActions as getActions, index_getAllArtifacts as getAllArtifacts, index_getAllBookmarks as getAllBookmarks, index_getAllDashboards as getAllDashboards, index_getAllMenus as getAllMenus, index_getAllReports as getAllReports, index_getAllUIs as getAllUIs, index_getArtifact as getArtifact, index_getBookmark as getBookmark, index_getChildMenus as getChildMenus, index_getDashboard as getDashboard, index_getMenu as getMenu, index_getMenusHierarchy as getMenusHierarchy, index_getReport as getReport, index_getRootMenus as getRootMenus, index_getThreadConversations as getThreadConversations, index_getUI as getUI, index_getUserThreads as getUserThreads, index_injectBundleStyles as injectBundleStyles, index_queryArtifacts as queryArtifacts, index_queryBookmarks as queryBookmarks, index_queryDashboards as queryDashboards, index_queryMenus as queryMenus, index_queryReports as queryReports, index_queryUIs as queryUIs, index_queryUsers as queryUsers, index_requestBundle as requestBundle, index_requestData as requestData, index_sendComponents as sendComponents, index_sendUserPromptRequest as sendUserPromptRequest, index_sendUserPromptSuggestionsRequest as sendUserPromptSuggestionsRequest, index_updateBookmark as updateBookmark, index_updateThreadTitle as updateThreadTitle };
 }
 
 type MessageHandler = (message: Message) => void;
@@ -1823,6 +1978,8 @@ declare class SuperatomClient {
     private config;
     private connectPromise;
     private connectResolve;
+    private getAccessToken;
+    private fetchingToken;
     private heartbeatInterval;
     private pongDeadline;
     private readonly HEARTBEAT_INTERVAL_MS;
@@ -1839,6 +1996,12 @@ declare class SuperatomClient {
      * Get WebSocket URL with query parameters
      */
     private getWebSocketUrl;
+    /**
+     * Swap the session token used on the next (re)connect.
+     * Deliberately does NOT re-dial a live socket: the relay only checks the
+     * token at handshake, so an open connection stays valid.
+     */
+    setToken(token: string): void;
     /**
      * Calculate reconnection delay with exponential backoff
      */
@@ -1885,6 +2048,14 @@ declare class SuperatomClient {
      * window 'online' / 'visibilitychange' handlers.
      */
     forceReconnect(): Promise<void>;
+    /**
+     * Drop the current socket without triggering its handlers: they are detached
+     * first, so its eventual real close is a no-op (on Linux/Chrome that close
+     * can arrive 30-60s later). Returns whether it was open.
+     */
+    private discardSocket;
+    /** A connection attempt is under way — fetching the session token, or the socket handshake. */
+    private isConnecting;
     /**
      * Attach window-level listeners that catch network changes faster than
      * the socket's own onclose. The browser's onclose for a half-open TCP can
@@ -1908,6 +2079,16 @@ declare class SuperatomClient {
      * The Promise never rejects - failures are logged silently and auto-reconnect is triggered
      */
     connect(): Promise<void>;
+    /**
+     * Get a valid session token, then open the socket. The relay checks the token
+     * only at handshake, so every (re)connect must present one that is still valid.
+     *
+     * A fatal auth failure (see SuperAtomAuthError.fatal) stops reconnecting — the
+     * session reports it to the host, and retrying would only repeat it. Anything
+     * else goes through the normal back-off.
+     */
+    private openWithFreshToken;
+    private openSocket;
     /**
      * Disconnect from WebSocket server
      */
@@ -1994,6 +2175,11 @@ declare class SuperatomClient {
      * @param onStream - Optional callback for streaming text chunks (only for text mode)
      */
     sendUserPromptRequest(prompt: string, threadId: string, uiBlockId: string, userId?: string, responseMode?: 'component' | 'text', onStream?: (chunk: string) => void, timeout?: number): Promise<Message>;
+    /**
+     * Abort an in-flight user prompt request (frontend "Stop" button).
+     * Fire-and-forget — cancels the backend work for the given uiBlockId.
+     */
+    abortUserPromptRequest(uiBlockId: string, threadId?: string): void;
     /**
      * Send a user prompt suggestions request
      * Delegates to user prompt service
@@ -2007,6 +2193,8 @@ declare class SuperatomClient {
     requestBundle(options?: {
         timeout?: number;
         onProgress?: (progress: number) => void;
+        devbundlereq?: boolean;
+        /** @deprecated Use `devbundlereq` */
         devbundle?: boolean;
     }): Promise<string>;
     /**
@@ -2330,6 +2518,116 @@ declare class SuperatomClient {
     private log;
 }
 
+/**
+ * SDK sign-in with the customer's own login.
+ *
+ * The host app hands us `getToken()` — a function THEY write that asks their
+ * backend for a short-lived JWT signed with their SDK secret. We exchange it at
+ * sa-api (`POST /auth/sdk/exchange`) for OUR 15-minute access token, which the
+ * WebSocket relay accepts at handshake.
+ *
+ * There is no refresh token in this mode: the customer's own session is the
+ * long-lived one. To renew we simply call `getToken()` again and re-exchange —
+ * before every (re)connect when ours is about to expire, and on a timer a
+ * couple of minutes ahead, so a reconnect never has to wait for it.
+ *
+ * Failures are split in two:
+ *  - fatal (their token rejected, SDK not enabled, user deactivated, or
+ *    `getToken()` itself failing): reported once through `onAuthError`, and
+ *    every later call fails fast with the same error — no loop against their
+ *    backend or ours — until `reset()`.
+ *  - transient (network, sa-api 5xx / 429): thrown to the caller, whose normal
+ *    reconnect back-off retries.
+ */
+declare const DEFAULT_API_URL = "https://sa-api.superatom.ai";
+/** The signed-in user, as returned by the exchange. `id` is OUR user id. */
+interface SdkUser {
+    id: string;
+    email: string;
+    name: string;
+    /** The role this session acts with — always "member" for SDK sessions. */
+    role: string;
+    /** Their own role names, from the `roles` claim. */
+    externalRoles: string[];
+}
+type SuperAtomAuthErrorCode = 
+/** `getToken()` threw or returned no token. */
+'get_token_failed'
+/** sa-api refused the token (400 / 401 / 403). `status` and `message` say why. */
+ | 'exchange_rejected'
+/** sa-api unavailable (5xx / 429). Retried. */
+ | 'exchange_unavailable'
+/** Could not reach sa-api, or it timed out. Retried. */
+ | 'network';
+declare class SuperAtomAuthError extends Error {
+    readonly code: SuperAtomAuthErrorCode;
+    /** HTTP status from sa-api, when there was a response. */
+    readonly status?: number;
+    /** True when retrying cannot help — see the module comment. */
+    readonly fatal: boolean;
+    constructor(code: SuperAtomAuthErrorCode, message: string, options: {
+        status?: number;
+        fatal: boolean;
+        cause?: unknown;
+    });
+}
+interface SdkSessionOptions {
+    projectId: string;
+    /** Returns the customer-signed JWT. Written by the host app. */
+    getToken: () => Promise<string> | string;
+    /** Called once for each fatal failure. */
+    onAuthError?: (error: SuperAtomAuthError) => void;
+    /** Called after each successful exchange. */
+    onSession?: (user: SdkUser) => void;
+    /**
+     * Sign-in keeps failing for a retryable reason (Superatom unreachable or down),
+     * after a couple of attempts. Called again on each further failure, and with
+     * null once a sign-in succeeds.
+     */
+    onRetrying?: (error: SuperAtomAuthError | null) => void;
+    /** sa-api base URL. Default: prod. */
+    apiUrl?: string;
+    debug?: boolean;
+}
+declare class SdkSession {
+    private readonly opts;
+    private readonly apiUrl;
+    private token;
+    private expiresAt;
+    private currentUser;
+    /** The one renewal in flight — every caller shares it. */
+    private inFlight;
+    private fatalError;
+    /** Retryable failures in a row; reset by a successful exchange. */
+    private retries;
+    private renewTimer;
+    private stopped;
+    constructor(opts: SdkSessionOptions);
+    get user(): SdkUser | null;
+    /** The fatal error that stopped the session, if any. */
+    get error(): SuperAtomAuthError | null;
+    /**
+     * A token with at least a minute left — the cached one, or a fresh exchange.
+     * Rejects with SuperAtomAuthError.
+     */
+    getAccessToken(): Promise<string>;
+    /** Clear a fatal error so the next getAccessToken() tries again (e.g. after the user signs in again). */
+    reset(): void;
+    /** Stop renewing — the host unmounted or disconnected. */
+    stop(): void;
+    private renew;
+    private exchange;
+    /** Record a failure: a fatal one stops the session and is reported once. */
+    private fail;
+    /**
+     * Renew in the background ahead of expiry. Timers are paused while the machine
+     * sleeps and fire on wake; a reconnect after wake also renews first if needed.
+     */
+    private scheduleRenew;
+    private clearRenewTimer;
+    private log;
+}
+
 /**
  * Component mount function type
  */
@@ -3423,13 +3721,13 @@ interface ExtendedDSLRendererProps extends DSLRendererProps {
     onNavigate?: NavigationHandler;
     handlers?: Record<string, Function>;
 }
-declare const DSLRenderer: React.FC<ExtendedDSLRendererProps>;
+declare const DSLRenderer: React__default.FC<ExtendedDSLRendererProps>;
 
 interface ComponentDefinition {
     id: string;
     name: string;
     head: string;
-    COMP: React.ComponentType<any>;
+    COMP: React__default.ComponentType<any>;
     dependencies?: string[];
     version?: string;
 }
@@ -3449,10 +3747,10 @@ declare const useDynamicComponent: (componentType: string) => {
     isLoaded: boolean;
     error: string | null;
 };
-declare const DynamicComponent: React.FC<{
+declare const DynamicComponent: React__default.FC<{
     type: string;
     props?: any;
-    children?: React.ReactNode;
+    children?: React__default.ReactNode;
 }>;
 
 interface DSLErrorBoundaryProps {
@@ -3460,7 +3758,7 @@ interface DSLErrorBoundaryProps {
     fallback?: ReactNode;
     elementType?: string;
     elementKey?: string | number;
-    onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
+    onError?: (error: Error, errorInfo: React__default.ErrorInfo) => void;
     skipBoundary?: boolean;
 }
 interface DSLErrorBoundaryState {
@@ -3471,12 +3769,19 @@ interface DSLErrorBoundaryState {
 declare class DSLErrorBoundary extends Component$1<DSLErrorBoundaryProps, DSLErrorBoundaryState> {
     constructor(props: DSLErrorBoundaryProps);
     static getDerivedStateFromError(error: Error): DSLErrorBoundaryState;
-    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
-    render(): string | number | boolean | Iterable<React.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
+    componentDidCatch(error: Error, errorInfo: React__default.ErrorInfo): void;
+    render(): string | number | boolean | Iterable<React__default.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
 }
 declare const withConditionalErrorBoundary: (component: ReactNode, elementType: string, elementKey?: string | number, forceWrap?: boolean) => ReactNode;
 
+/**
+ * Register every component exposed on window.SUPERATOM.COMPONENTS into COMP_REGISTRY.
+ * Safe to call repeatedly — each call reflects the currently loaded bundle.
+ */
 declare function registerBundleComponents(): number;
+/**
+ * Remove all bundle components added by registerBundleComponents from COMP_REGISTRY.
+ */
 declare function resetRegistration(): void;
 
 interface ChatMessage {
@@ -3491,12 +3796,32 @@ interface ChatMessage {
     isLoading?: boolean;
     isStreaming?: boolean;
     isTextOnlyResponse?: boolean;
+    aborted?: boolean;
+    fromHistory?: boolean;
 }
 
 interface UseSuperAtomOptions {
+    /** A Superatom session token, passed directly (our own apps). Use `getToken` for SDK sign-in instead. */
     token?: string;
     userId?: string;
     projectId: string;
+    /**
+     * SDK sign-in with your own login: return a short-lived JWT for the signed-in
+     * user, signed by YOUR backend with your Superatom SDK secret. Called at start
+     * and again whenever the session needs renewing — e.g.
+     * `() => fetch('/api/superatom-token').then(r => r.text())`.
+     */
+    getToken?: () => Promise<string> | string;
+    /**
+     * Called when sign-in fails in a way retrying cannot fix: `getToken` threw, or
+     * Superatom refused the token (invalid, SDK not enabled, user deactivated).
+     * The SDK stops reconnecting; call `reconnect()` once the user can sign in again.
+     */
+    onAuthError?: (error: SuperAtomAuthError) => void;
+    /** sa-api URL. Default: prod. For testing against dev / local only. */
+    apiUrl?: string;
+    /** WebSocket URL. Default: prod. For testing against dev / local only. */
+    wsUrl?: string;
     debug?: boolean;
     streaming?: boolean;
 }
@@ -3507,8 +3832,43 @@ interface UseSuperAtomReturn {
     setInput: (value: string) => void;
     sendMessage: () => void;
     isSending: boolean;
+    /** Stop the in-flight response (keeps any partial answer, labels it "Stopped") */
+    abortRequest: () => void;
+    /** The user's conversation threads, most recent first */
+    threads: ThreadSummary[];
+    /** Thread the chat is currently in */
+    activeThreadId: string;
+    /** Open a saved thread and load its messages */
+    openThread: (threadId: string) => void;
+    /** Start a fresh chat (new thread) */
+    newChat: () => void;
+    /** A saved thread's messages are loading */
+    isLoadingThread: boolean;
+    /**
+     * The chat is ready and empty — show a greeting (e.g. `<NewChatHero>`) instead
+     * of the message list. Saves every app computing the same condition.
+     */
+    isNewChat: boolean;
+    /** Re-fetch the thread list */
+    refreshThreads: () => void;
+    /** Delete a thread and all its messages; if it's the open one, starts a new chat */
+    deleteThread: (threadId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Rename a thread */
+    renameThread: (threadId: string, title: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** The signed-in user (SDK sign-in with `getToken` only; null until signed in). */
+    user: SdkUser | null;
+    /** The sign-in failure that stopped the SDK, if any (same as passed to `onAuthError`). */
+    authError: SuperAtomAuthError | null;
+    /** Try signing in and connecting again — e.g. after the user signed in again on your side. */
+    reconnect: () => void;
 }
-declare function useSuperAtom({ token, userId, projectId, debug, streaming }: UseSuperAtomOptions): UseSuperAtomReturn;
+declare function useSuperAtom({ token, userId, projectId, getToken, onAuthError, apiUrl, wsUrl, debug, streaming, }: UseSuperAtomOptions): UseSuperAtomReturn;
 
 interface ChatInputProps {
     input: string;
@@ -3518,22 +3878,40 @@ interface ChatInputProps {
     placeholder?: string;
     primaryColor?: string;
     className?: string;
+    /** A response is in flight — swaps Send for Stop and enables Esc-to-stop */
+    isResponding?: boolean;
+    onStop?: () => void;
 }
-declare function ChatInput({ input, setInput, onSend, disabled, placeholder, primaryColor, className, }: ChatInputProps): react_jsx_runtime.JSX.Element;
+declare function ChatInput({ input, setInput, onSend, disabled, placeholder, primaryColor, className, isResponding, onStop, }: ChatInputProps): react_jsx_runtime.JSX.Element;
 
 interface MessageListProps {
     messages: ChatMessage[];
     bundleReady: boolean;
     connectingText?: string;
     emptyText?: string;
+    /**
+     * Shown in place of `emptyText` while the chat is empty — e.g. a greeting, or
+     * `<NewChatHero>` with the input inside it. With this, the whole chat is just
+     * <MessageList /> + <ChatInput />; without it, render your own empty screen
+     * using the hook's `isNewChat`.
+     */
+    emptyState?: ReactNode;
     className?: string;
+    /** A response is in flight — shows a Stop button on the latest assistant message */
+    isResponding?: boolean;
+    onStop?: () => void;
+    /** A saved thread is being opened — shows a loading state instead of the empty text */
+    isLoadingThread?: boolean;
+    loadingThreadText?: string;
 }
-declare function MessageList({ messages, bundleReady, connectingText, emptyText, className, }: MessageListProps): react_jsx_runtime.JSX.Element;
+declare function MessageList({ messages, bundleReady, connectingText, emptyText, emptyState, className, isResponding, onStop, isLoadingThread, loadingThreadText, }: MessageListProps): react_jsx_runtime.JSX.Element;
 
 interface MessageBubbleProps {
     message: ChatMessage;
+    /** When set, this message's response is in flight and a Stop button is shown */
+    onStop?: () => void;
 }
-declare function MessageBubble({ message }: MessageBubbleProps): react_jsx_runtime.JSX.Element;
+declare function MessageBubble({ message, onStop }: MessageBubbleProps): react_jsx_runtime.JSX.Element;
 
 interface MenuV1Item {
     id: string;
@@ -3561,29 +3939,73 @@ interface MenuV1Root {
 }
 
 interface SidebarProps {
-    children?: React.ReactNode;
+    children?: React__default.ReactNode;
     className?: string;
     onItemClick?: (item: MenuV1Item) => void;
+    /** Shows the "New chat" button when provided (pass `newChat` from useSuperAtom) */
+    onNewChat?: () => void;
+    /** Conversation threads for the "Chats" section (pass `threads` from useSuperAtom) */
+    threads?: ThreadSummary[];
+    /** Highlighted thread (pass `activeThreadId` from useSuperAtom) */
+    activeThreadId?: string;
+    /** Open a thread (pass `openThread` from useSuperAtom) */
+    onSelectThread?: (threadId: string) => void;
+    /** Enables "Delete chat" in each thread's menu (pass `deleteThread` from useSuperAtom) */
+    onDeleteThread?: (threadId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Enables "Rename" in each thread's menu (pass `renameThread` from useSuperAtom) */
+    onRenameThread?: (threadId: string, title: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    primaryColor?: string;
+}
+declare function Sidebar({ children, className, onItemClick, onNewChat, threads, activeThreadId, onSelectThread, onDeleteThread, onRenameThread, primaryColor, }: SidebarProps): react_jsx_runtime.JSX.Element;
+
+interface NewChatHeroProps {
+    /** The chat input to center, e.g. <ChatInput ... /> */
+    children: React__default.ReactNode;
+    title?: string;
+    subtitle?: string;
+    className?: string;
+}
+/**
+ * Centered "new chat" empty state (like most chat apps): a greeting with the
+ * chat box in the middle of the screen. Same as Runtime-react's NewChatHero.
+ * Render it instead of <MessageList /> + bottom <ChatInput /> while the chat is empty.
+ */
+declare function NewChatHero({ children, title, subtitle, className, }: NewChatHeroProps): react_jsx_runtime.JSX.Element;
+
+interface ConfirmDeleteModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    isDeleting: boolean;
+    title?: string;
+    message?: string;
 }
-declare function Sidebar({ children, className, onItemClick }: SidebarProps): react_jsx_runtime.JSX.Element;
+/** Same as Runtime-react's components/chat/ConfirmDeleteModal */
+declare function ConfirmDeleteModal({ isOpen, onClose, onConfirm, isDeleting, title, message, }: ConfirmDeleteModalProps): React.ReactPortal | null;
 
 interface MenuV1RendererProps {
     items: MenuV1Item[];
     onItemClick: (item: MenuV1Item) => void;
     isCollapsed: boolean;
 }
-declare const MenuV1Renderer: React.FC<MenuV1RendererProps>;
+declare const MenuV1Renderer: React__default.FC<MenuV1RendererProps>;
 
 interface MenuV1RendererCollapsedProps {
     items: MenuV1Item[];
     onItemClick: (item: MenuV1Item) => void;
 }
-declare const MenuV1RendererCollapsed: React.FC<MenuV1RendererCollapsedProps>;
+declare const MenuV1RendererCollapsed: React__default.FC<MenuV1RendererCollapsedProps>;
 
 /**
  * @superatomai/application-sdk
  * SuperAtom Application SDK - WebSocket client, DSL renderer, and pre-built chat UI
  */
-declare const SDK_VERSION = "0.0.1";
+declare const SDK_VERSION = "0.0.3";
 
-export { type ActionsRequestMessage, ActionsRequestMessageSchema, type ActionsRequestPayload, ActionsRequestPayloadSchema, type ActionsResponseMessage, ActionsResponseMessageSchema, type ActionsResponsePayload, ActionsResponsePayloadSchema, type Binding, BindingSchema, type BundleChunkMessage, BundleChunkMessageSchema, type BundleChunkPayload, BundleChunkPayloadSchema, type BundleErrorMessage, BundleErrorMessageSchema, type BundleErrorPayload, BundleErrorPayloadSchema, type BundleRequestMessage, BundleRequestMessageSchema, type BundleRequestPayload, BundleRequestPayloadSchema, COMP_REGISTRY, ChatInput, type ChatInputProps, type ChatMessage, type ClientConfig, ClientConfigSchema, type Component, type ComponentDefinition, type ComponentRegistryType, ComponentSchema, type ComponentsRegistry, type ComponentsSendMessage, ComponentsSendMessageSchema, type ComponentsSendPayload, ComponentsSendPayloadSchema, DSLErrorBoundary, DSLRenderer, type DSLRendererProps, DSLRendererPropsSchema, type DataRequestMessage, DataRequestMessageSchema, type DataRequestPayload, DataRequestPayloadSchema, type DataResponseMessage, DataResponseMessageSchema, type DataResponsePayload, DataResponsePayloadSchema, DynamicComponent, type Expression, ExpressionSchema, type ForDirective, ForDirectiveSchema, type MenuData, MenuDataSchema, type MenuQueryFilters, MenuQueryFiltersSchema, type MenuV1Item, MenuV1Renderer, MenuV1RendererCollapsed, type MenuV1Root, type MenusRequestMessage, MenusRequestMessageSchema, type MenusRequestPayload, MenusRequestPayloadSchema, type MenusResponseMessage, MenusResponseMessageSchema, type MenusResponsePayload, MenusResponsePayloadSchema, type Message, MessageBubble, type MessageBubbleProps, MessageList, type MessageListProps, type MessageParticipant, MessageParticipantSchema, MessageSchema, type MountFunction, type QuerySpec, QuerySpecSchema, type ResolvedClientConfig, SDK_VERSION, Sidebar, type SidebarProps, type SuperAtomGlobal, SuperatomClient, type UIComponent, UIComponentSchema, type UIElement, UIElementSchema, type UILogEntry, UILogEntrySchema, type UILogsMessage, UILogsMessageSchema, type UILogsPayload, UILogsPayloadSchema, type UseSuperAtomOptions, type UseSuperAtomReturn, type UserPromptRequestMessage, UserPromptRequestMessageSchema, type UserPromptRequestPayload, UserPromptRequestPayloadSchema, type UserPromptResponseMessage, UserPromptResponseMessageSchema, type UserPromptResponsePayload, UserPromptResponsePayloadSchema, type UserPromptSuggestionsRequestMessage, UserPromptSuggestionsRequestMessageSchema, type UserPromptSuggestionsRequestPayload, UserPromptSuggestionsRequestPayloadSchema, type UserPromptSuggestionsResponseMessage, UserPromptSuggestionsResponseMessageSchema, type UserPromptSuggestionsResponsePayload, UserPromptSuggestionsResponsePayloadSchema, getComponent, getComponentStates, getComponents, hasComponents, registerBundleComponents, resetAllFailedComponents, resetFailedComponent, resetRegistration, sanitizeDSL, index as services, setup, useDynamicComponent, useSuperAtom, validateDSL, validateUIComponent, validateUIElement, withConditionalErrorBoundary };
+export { type ActionsRequestMessage, ActionsRequestMessageSchema, type ActionsRequestPayload, ActionsRequestPayloadSchema, type ActionsResponseMessage, ActionsResponseMessageSchema, type ActionsResponsePayload, ActionsResponsePayloadSchema, type Binding, BindingSchema, type BundleChunkMessage, BundleChunkMessageSchema, type BundleChunkPayload, BundleChunkPayloadSchema, type BundleErrorMessage, BundleErrorMessageSchema, type BundleErrorPayload, BundleErrorPayloadSchema, type BundleRequestMessage, BundleRequestMessageSchema, type BundleRequestPayload, BundleRequestPayloadSchema, COMP_REGISTRY, ChatInput, type ChatInputProps, type ChatMessage, type ClientConfig, ClientConfigSchema, type Component, type ComponentDefinition, type ComponentRegistryType, ComponentSchema, type ComponentsRegistry, type ComponentsSendMessage, ComponentsSendMessageSchema, type ComponentsSendPayload, ComponentsSendPayloadSchema, ConfirmDeleteModal, type ConfirmDeleteModalProps, DEFAULT_API_URL, DSLErrorBoundary, DSLRenderer, type DSLRendererProps, DSLRendererPropsSchema, type DataRequestMessage, DataRequestMessageSchema, type DataRequestPayload, DataRequestPayloadSchema, type DataResponseMessage, DataResponseMessageSchema, type DataResponsePayload, DataResponsePayloadSchema, DynamicComponent, type Expression, ExpressionSchema, type ForDirective, ForDirectiveSchema, type MenuData, MenuDataSchema, type MenuQueryFilters, MenuQueryFiltersSchema, type MenuV1Item, MenuV1Renderer, MenuV1RendererCollapsed, type MenuV1Root, type MenusRequestMessage, MenusRequestMessageSchema, type MenusRequestPayload, MenusRequestPayloadSchema, type MenusResponseMessage, MenusResponseMessageSchema, type MenusResponsePayload, MenusResponsePayloadSchema, type Message, MessageBubble, type MessageBubbleProps, MessageList, type MessageListProps, type MessageParticipant, MessageParticipantSchema, MessageSchema, type MountFunction, NewChatHero, type NewChatHeroProps, type QuerySpec, QuerySpecSchema, type ResolvedClientConfig, SDK_VERSION, SdkSession, type SdkSessionOptions, type SdkUser, Sidebar, type SidebarProps, SuperAtomAuthError, type SuperAtomAuthErrorCode, type SuperAtomGlobal, SuperatomClient, type ThreadConversationRow, type ThreadSummary, type UIComponent, UIComponentSchema, type UIElement, UIElementSchema, type UILogEntry, UILogEntrySchema, type UILogsMessage, UILogsMessageSchema, type UILogsPayload, UILogsPayloadSchema, type UseSuperAtomOptions, type UseSuperAtomReturn, type UserPromptAbortRequestMessage, UserPromptAbortRequestMessageSchema, type UserPromptAbortRequestPayload, UserPromptAbortRequestPayloadSchema, type UserPromptRequestMessage, UserPromptRequestMessageSchema, type UserPromptRequestPayload, UserPromptRequestPayloadSchema, type UserPromptResponseMessage, UserPromptResponseMessageSchema, type UserPromptResponsePayload, UserPromptResponsePayloadSchema, type UserPromptSuggestionsRequestMessage, UserPromptSuggestionsRequestMessageSchema, type UserPromptSuggestionsRequestPayload, UserPromptSuggestionsRequestPayloadSchema, type UserPromptSuggestionsResponseMessage, UserPromptSuggestionsResponseMessageSchema, type UserPromptSuggestionsResponsePayload, UserPromptSuggestionsResponsePayloadSchema, getComponent, getComponentStates, getComponents, hasComponents, registerBundleComponents, resetAllFailedComponents, resetFailedComponent, resetRegistration, sanitizeDSL, index as services, setup, useDynamicComponent, useSuperAtom, validateDSL, validateUIComponent, validateUIElement, withConditionalErrorBoundary };