@aomi-labs/react 0.2.4 → 0.3.1

package/dist/index.d.cts

@@ -1,93 +1,15 @@
+import { AomiSystemEvent, AomiClient } from '@aomi-labs/client';
+export { AomiChatResponse, AomiClient, AomiClientOptions, AomiCreateThreadResponse, AomiInterruptResponse, AomiMessage, AomiSSEEvent, AomiStateResponse, AomiSystemEvent, AomiSystemResponse, AomiThread } from '@aomi-labs/client';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode, SetStateAction } from 'react';
 import { ThreadMessageLike } from '@assistant-ui/react';
 import { ClassValue } from 'clsx';
 
-interface AomiMessage {
-    sender?: "user" | "agent" | "system" | string;
-    content?: string;
-    timestamp?: string;
-    is_streaming?: boolean;
-    tool_result?: [string, string] | null;
-}
-/**
- * GET /api/state
- * Fetches current session state including messages and processing status
- */
-interface ApiStateResponse {
-    messages?: AomiMessage[] | null;
-    system_events?: ApiSystemEvent[] | null;
-    title?: string | null;
-    is_processing?: boolean;
-}
-/**
- * POST /api/chat
- * Sends a chat message and returns updated session state
- */
-interface ApiChatResponse {
-    messages?: AomiMessage[] | null;
-    system_events?: ApiSystemEvent[] | null;
-    title?: string | null;
-    is_processing?: boolean;
-}
-/**
- * POST /api/system
- * Sends a system message and returns the response message
- */
-interface ApiSystemResponse {
-    res?: AomiMessage | null;
-}
-/**
- * POST /api/interrupt
- * Interrupts current processing and returns updated session state
- */
-type ApiInterruptResponse = ApiChatResponse;
-/**
- * GET /api/sessions
- * Returns array of ApiThread
- */
-interface ApiThread {
-    session_id: string;
-    title: string;
-    is_archived?: boolean;
-}
-/**
- * POST /api/sessions
- * Creates a new thread/session
- */
-interface ApiCreateThreadResponse {
-    session_id: string;
-    title?: string;
-}
-/**
- * Base SSE event - all events have session_id and type
- */
-type ApiSSEEvent = {
-    type: "title_changed" | "tool_update" | "tool_complete" | "system_notice" | string;
-    session_id: string;
-    new_title?: string;
-    [key: string]: unknown;
-};
-/**
- * Backend SystemEvent enum serializes as tagged JSON:
- * - InlineCall: {"InlineCall": {"type": "wallet_tx_request", "payload": {...}}}
- * - SystemNotice: {"SystemNotice": "message"}
- * - SystemError: {"SystemError": "message"}
- * - AsyncCallback: {"AsyncCallback": {...}} (not sent over HTTP)
- */
-type ApiSystemEvent = {
-    InlineCall: {
-        type: string;
-        payload?: unknown;
-        [key: string]: unknown;
-    };
-} | {
-    SystemNotice: string;
-} | {
-    SystemError: string;
-} | {
-    AsyncCallback: Record<string, unknown>;
+type AomiRuntimeProviderProps = {
+    children: ReactNode;
+    backendUrl?: string;
 };
+declare function AomiRuntimeProvider({ children, backendUrl, }: Readonly<AomiRuntimeProviderProps>): react_jsx_runtime.JSX.Element;
 
 type UserState = {
     address?: string;
@@ -105,53 +27,6 @@ declare function UserContextProvider({ children }: {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 
-declare class BackendApi {
-    private readonly backendUrl;
-    private sseSubscriber;
-    constructor(backendUrl: string);
-    fetchState(sessionId: string, userState?: UserState): Promise<ApiStateResponse>;
-    postChatMessage(sessionId: string, message: string, namespace: string, publicKey?: string, apiKey?: string, userState?: UserState): Promise<ApiChatResponse>;
-    postSystemMessage(sessionId: string, message: string): Promise<ApiSystemResponse>;
-    postInterrupt(sessionId: string): Promise<ApiInterruptResponse>;
-    /**
-     * Subscribe to SSE updates for a session.
-     * Uses fetch streaming and reconnects on disconnects.
-     * Returns an unsubscribe function.
-     */
-    subscribeSSE(sessionId: string, onUpdate: (event: ApiSSEEvent) => void, onError?: (error: unknown) => void): () => void;
-    fetchThreads(publicKey: string): Promise<ApiThread[]>;
-    fetchThread(sessionId: string): Promise<ApiThread>;
-    createThread(threadId: string, publicKey?: string): Promise<ApiCreateThreadResponse>;
-    archiveThread(sessionId: string): Promise<void>;
-    unarchiveThread(sessionId: string): Promise<void>;
-    deleteThread(sessionId: string): Promise<void>;
-    renameThread(sessionId: string, newTitle: string): Promise<void>;
-    getSystemEvents(sessionId: string, count?: number): Promise<ApiSystemEvent[]>;
-    /**
-     * Get allowed namespaces for the current request context.
-     */
-    getNamespaces(sessionId: string, publicKey?: string, apiKey?: string): Promise<string[]>;
-    /**
-     * Get available models.
-     */
-    getModels(sessionId: string): Promise<string[]>;
-    /**
-     * Set the model selection for a session.
-     */
-    setModel(sessionId: string, rig: string, namespace?: string, apiKey?: string): Promise<{
-        success: boolean;
-        rig: string;
-        baml: string;
-        created: boolean;
-    }>;
-}
-
-type AomiRuntimeProviderProps = {
-    children: ReactNode;
-    backendUrl?: string;
-};
-declare function AomiRuntimeProvider({ children, backendUrl, }: Readonly<AomiRuntimeProviderProps>): react_jsx_runtime.JSX.Element;
-
 type ThreadContext = {
     currentThreadId: string;
     setCurrentThreadId: (id: string) => void;
@@ -177,12 +52,12 @@ declare function ThreadContextProvider({ children, initialThreadId, }: ThreadCon
 declare function useCurrentThreadMessages(): ThreadMessageLike[];
 declare function useCurrentThreadMetadata(): ThreadMetadata | undefined;
 
-type ThreadStatus = "regular" | "archived" | "pending";
+type ThreadStatus = "regular" | "archived";
 type ThreadControlState = {
     /** Selected model for this thread (human-readable label) */
     model: string | null;
-    /** Selected namespace for this thread */
-    namespace: string | null;
+    /** Selected app for this thread */
+    app: string | null;
     /** Whether control state has changed but chat hasn't started yet */
     controlDirty: boolean;
     /** Whether this thread is currently processing (assistant generating) */
@@ -192,7 +67,7 @@ type ThreadMetadata = {
     title: string;
     status: ThreadStatus;
     lastActiveAt?: string | number;
-    /** Per-thread control state (model, namespace selection) */
+    /** Per-thread control state (model, app selection) */
     control: ThreadControlState;
 };
 /** Create default control state for a new thread */
@@ -247,6 +122,63 @@ type NotificationContextProviderProps = {
 };
 declare function NotificationContextProvider({ children, }: NotificationContextProviderProps): react_jsx_runtime.JSX.Element;
 
+type WalletRequestKind = "transaction" | "eip712_sign";
+type WalletTxPayload = {
+    to: string;
+    value?: string;
+    data?: string;
+    chainId?: number;
+};
+type WalletEip712Payload = {
+    typed_data?: {
+        domain?: {
+            chainId?: number | string;
+        };
+        types?: Record<string, Array<{
+            name: string;
+            type: string;
+        }>>;
+        primaryType?: string;
+        message?: Record<string, unknown>;
+    };
+    description?: string;
+};
+type WalletRequestStatus = "pending" | "processing";
+type WalletRequest = {
+    id: string;
+    kind: WalletRequestKind;
+    payload: WalletTxPayload | WalletEip712Payload;
+    status: WalletRequestStatus;
+    timestamp: number;
+};
+type WalletBuffer = {
+    queue: WalletRequest[];
+    nextId: number;
+};
+
+type WalletRequestResult = {
+    txHash?: string;
+    signature?: string;
+    amount?: string;
+};
+type WalletHandlerConfig = {
+    sessionId: string;
+    /** Called after a wallet request is resolved/rejected and the outbound event is sent.
+     *  Used by core.tsx to start polling for the AI's response. */
+    onRequestComplete?: () => void;
+};
+type WalletHandlerApi = {
+    /** All queued wallet requests (tx + eip712) */
+    pendingRequests: WalletRequest[];
+    /** Mark a request as being processed */
+    startProcessing: (id: string) => void;
+    /** Complete a request successfully — dequeues + sends response to backend */
+    resolveRequest: (id: string, result: WalletRequestResult) => void;
+    /** Fail a request — dequeues + sends error to backend */
+    rejectRequest: (id: string, error?: string) => void;
+};
+declare function useWalletHandler({ sessionId, onRequestComplete, }: WalletHandlerConfig): WalletHandlerApi;
+
 type AomiRuntimeApi = {
     /** Current user state (wallet connection, address, chain, etc.) */
     user: UserState;
@@ -290,10 +222,18 @@ type AomiRuntimeApi = {
     dismissNotification: (id: string) => void;
     /** Clear all notifications */
     clearAllNotifications: () => void;
+    /** All queued wallet requests (tx + eip712 signing) */
+    pendingWalletRequests: WalletRequest[];
+    /** Mark a wallet request as being processed */
+    startWalletRequest: (id: string) => void;
+    /** Complete a wallet request — dequeues + sends response to backend */
+    resolveWalletRequest: (id: string, result: WalletRequestResult) => void;
+    /** Fail a wallet request — dequeues + sends error to backend */
+    rejectWalletRequest: (id: string, error?: string) => void;
     /** Subscribe to inbound events by type. Returns unsubscribe function. */
     subscribe: (type: string, callback: EventSubscriber) => () => void;
     /** Send a system command to the backend */
-    sendSystemCommand: (event: Omit<OutboundEvent, "timestamp">) => void;
+    sendSystemCommand: (event: Omit<OutboundEvent, "timestamp">) => Promise<void>;
     /** Current SSE connection status */
     sseStatus: SSEStatus;
 };
@@ -331,48 +271,19 @@ type EventContext = {
     /** Subscribe to inbound events by type. Returns unsubscribe function. */
     subscribe: (type: string, callback: EventSubscriber) => () => void;
     /** Send an outbound event to backend immediately */
-    sendOutboundSystem: (event: Omit<OutboundEvent, "timestamp">) => void;
+    sendOutboundSystem: (event: Omit<OutboundEvent, "timestamp">) => Promise<void>;
     /** Dispatch system events from HTTP polling into the event buffer */
-    dispatchInboundSystem: (sessionId: string, events: ApiSystemEvent[]) => void;
+    dispatchInboundSystem: (sessionId: string, events: AomiSystemEvent[]) => void;
     /** Current SSE connection status */
     sseStatus: SSEStatus;
 };
 declare function useEventContext(): EventContext;
 type EventContextProviderProps = {
     children: ReactNode;
-    backendApi: BackendApi;
+    aomiClient: AomiClient;
     sessionId: string;
 };
-declare function EventContextProvider({ children, backendApi, sessionId, }: EventContextProviderProps): react_jsx_runtime.JSX.Element;
-
-type WalletTxRequest = {
-    to: string;
-    value?: string;
-    data?: string;
-    chainId?: number;
-};
-type WalletTxComplete = {
-    txHash: string;
-    status: "success" | "failed";
-    amount?: string;
-    token?: string;
-};
-type WalletConnectionStatus = "connected" | "disconnected";
-type WalletHandlerConfig = {
-    sessionId: string;
-    onTxRequest?: (request: WalletTxRequest) => void;
-};
-type WalletHanderApi = {
-    /** Send transaction completion event to backend */
-    sendTxComplete: (tx: WalletTxComplete) => void;
-    /** Send wallet connection status change and update user state */
-    sendConnectionChange: (status: WalletConnectionStatus, address?: string, chainId?: number) => void;
-    /** Pending transaction requests from AI */
-    pendingTxRequests: WalletTxRequest[];
-    /** Clear a pending request after handling */
-    clearTxRequest: (index: number) => void;
-};
-declare function useWalletHandler({ sessionId, onTxRequest, }: WalletHandlerConfig): WalletHanderApi;
+declare function EventContextProvider({ children, aomiClient, sessionId, }: EventContextProviderProps): react_jsx_runtime.JSX.Element;
 
 type Notification = {
     id: string;
@@ -429,28 +340,28 @@ type ControlState = {
     apiKey: string | null;
     /** Available models fetched from backend */
     availableModels: string[];
-    /** Authorized namespaces fetched from backend */
-    authorizedNamespaces: string[];
+    /** Authorized apps fetched from backend */
+    authorizedApps: string[];
     /** Default model (first from availableModels) */
     defaultModel: string | null;
-    /** Default namespace (from authorizedNamespaces) */
-    defaultNamespace: string | null;
+    /** Default app (from authorizedApps) */
+    defaultApp: string | null;
 };
 type ControlContextApi = {
-    /** Global state (apiKey, available models/namespaces) */
+    /** Global state (apiKey, available models/apps) */
     state: ControlState;
     /** Update global state (apiKey only) */
     setApiKey: (apiKey: string | null) => void;
     /** Fetch available models from backend */
     getAvailableModels: () => Promise<string[]>;
-    /** Fetch authorized namespaces from backend */
-    getAuthorizedNamespaces: () => Promise<string[]>;
+    /** Fetch authorized apps from backend */
+    getAuthorizedApps: () => Promise<string[]>;
     /** Get current thread's control state */
     getCurrentThreadControl: () => ThreadControlState;
     /** Select a model for the current thread (updates metadata + calls backend) */
     onModelSelect: (model: string) => Promise<void>;
-    /** Select a namespace for the current thread (updates metadata only) */
-    onNamespaceSelect: (namespace: string) => void;
+    /** Select an app for the current thread (updates metadata only) */
+    onAppSelect: (app: string) => void;
     /** Whether the current thread is processing (disables control switching) */
     isProcessing: boolean;
     /** Mark control state as synced (called after chat starts) */
@@ -459,16 +370,16 @@ type ControlContextApi = {
     getControlState: () => ControlState;
     /** Subscribe to global state changes */
     onControlStateChange: (callback: (state: ControlState) => void) => () => void;
-    /** @deprecated Use getCurrentThreadControl().namespace instead */
+    /** @deprecated Use getCurrentThreadControl().app instead */
     setState: (updates: Partial<{
-        namespace: string | null;
+        app: string | null;
         apiKey: string | null;
     }>) => void;
 };
 declare function useControl(): ControlContextApi;
 type ControlContextProviderProps = {
     children: ReactNode;
-    backendApi: BackendApi;
+    aomiClient: AomiClient;
     sessionId: string;
     publicKey?: string;
     /** Get metadata for a thread */
@@ -476,6 +387,6 @@ type ControlContextProviderProps = {
     /** Update metadata for a thread */
     updateThreadMetadata: (threadId: string, updates: Partial<ThreadMetadata>) => void;
 };
-declare function ControlContextProvider({ children, backendApi, sessionId, publicKey, getThreadMetadata, updateThreadMetadata, }: ControlContextProviderProps): react_jsx_runtime.JSX.Element;
+declare function ControlContextProvider({ children, aomiClient, sessionId, publicKey, getThreadMetadata, updateThreadMetadata, }: ControlContextProviderProps): react_jsx_runtime.JSX.Element;
 
-export { type AomiMessage, type AomiRuntimeApi, AomiRuntimeProvider, type AomiRuntimeProviderProps, type ApiChatResponse, type ApiCreateThreadResponse, type ApiInterruptResponse, type ApiSSEEvent, type ApiStateResponse, type ApiSystemEvent, type ApiSystemResponse, type ApiThread, BackendApi, type ChainInfo, type ControlContextApi, ControlContextProvider, type ControlContextProviderProps, type ControlState, type EventBuffer, type EventContext, EventContextProvider, type EventContextProviderProps, type EventSubscriber, type Notification as HandlerNotification, type InboundEvent, type Notification$1 as Notification, type NotificationApi, NotificationContextProvider, type NotificationContextProviderProps, type NotificationContextApi as NotificationContextValue, type NotificationHandlerConfig, type NotificationType, type OutboundEvent, type SSEStatus, SUPPORTED_CHAINS, type NotificationData as ShowNotificationParams, type ThreadContext, ThreadContextProvider, type ThreadControlState, type ThreadMetadata, type UserConfig, UserContextProvider, type UserState, type UserState as WalletButtonState, type WalletConnectionStatus, type WalletHanderApi, type WalletHandlerConfig, type WalletTxComplete, type WalletTxRequest, cn, formatAddress, getChainInfo, getNetworkName, initThreadControl, useAomiRuntime, useControl, useCurrentThreadMessages, useCurrentThreadMetadata, useEventContext, useNotification, useNotificationHandler, useThreadContext, useUser, useWalletHandler };
+export { type AomiRuntimeApi, AomiRuntimeProvider, type AomiRuntimeProviderProps, type ChainInfo, type ControlContextApi, ControlContextProvider, type ControlContextProviderProps, type ControlState, type EventBuffer, type EventContext, EventContextProvider, type EventContextProviderProps, type EventSubscriber, type InboundEvent, type Notification$1 as Notification, type NotificationApi, NotificationContextProvider, type NotificationContextProviderProps, type NotificationContextApi as NotificationContextValue, type NotificationHandlerConfig, type NotificationType, type OutboundEvent, type SSEStatus, SUPPORTED_CHAINS, type NotificationData as ShowNotificationParams, type ThreadContext, ThreadContextProvider, type ThreadControlState, type ThreadMetadata, type UserConfig, UserContextProvider, type UserState, type WalletBuffer, type WalletEip712Payload, type WalletHandlerApi, type WalletHandlerConfig, type WalletRequest, type WalletRequestKind, type WalletRequestResult, type WalletRequestStatus, type WalletTxPayload, cn, formatAddress, getChainInfo, getNetworkName, initThreadControl, useAomiRuntime, useControl, useCurrentThreadMessages, useCurrentThreadMetadata, useEventContext, useNotification, useNotificationHandler, useThreadContext, useUser, useWalletHandler };