@usecrow/client 0.1.43 → 0.1.45

package/dist/index.native.cjs

@@ -0,0 +1,3 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class C{constructor(){this.state={token:null,metadata:{},isVerified:!1},this.listeners=new Set}identify(e){const{token:t,...s}=e;this.state={token:t,metadata:s,isVerified:!1},this.notify(),console.log("[Crow] User identified")}setVerified(e){this.state={...this.state,isVerified:e},this.notify()}reset(){this.state={token:null,metadata:{},isVerified:!1},this.notify(),console.log("[Crow] User reset")}getToken(){return this.state.token}getState(){return{...this.state}}isIdentified(){return this.state.token!==null}isVerified(){return this.state.isVerified}subscribe(e){return this.listeners.add(e),()=>this.listeners.delete(e)}notify(){const e=this.getState();for(const t of this.listeners)t(e)}}class v{constructor(){this.handlers={}}register(e){for(const[t,s]of Object.entries(e))typeof s=="function"?(this.handlers[t]=s,console.log(`[Crow] Registered client tool: ${t}`)):console.warn(`[Crow] Skipping ${t}: handler is not a function`)}unregister(e){delete this.handlers[e],console.log(`[Crow] Unregistered client tool: ${e}`)}has(e){return e in this.handlers}getRegisteredTools(){return Object.keys(this.handlers)}async execute(e,t){const s=this.handlers[e];if(!s)return console.warn(`[Crow] No handler registered for tool: ${e}`),{status:"error",error:`No handler registered for tool: ${e}`};try{console.log(`[Crow] Executing client tool: ${e}`,t);const r=await s(t);return console.log(`[Crow] Tool ${e} completed:`,r),r}catch(r){const a=r instanceof Error?r.message:String(r);return console.error(`[Crow] Tool ${e} failed:`,r),{status:"error",error:a}}}}const L="crow_conv_";class S{constructor(e,t,s){this.currentId=null,this.productId=e,this.apiUrl=t,this.storage=s,this.currentId=this.loadFromStorage()}getStorageKey(){return`${L}${this.productId}`}loadFromStorage(){try{return this.storage.getItem(this.getStorageKey())}catch{return null}}saveToStorage(e){try{this.storage.setItem(this.getStorageKey(),e)}catch{}}clearStorage(){try{this.storage.removeItem(this.getStorageKey())}catch{}}getCurrentId(){return this.currentId}setCurrentId(e){this.currentId=e,e?this.saveToStorage(e):this.clearStorage()}hasRestoredConversation(){return this.currentId!==null}clear(){this.currentId=null,this.clearStorage()}async getConversations(e){try{const t=await fetch(`${this.apiUrl}/api/chat/conversations?product_id=${this.productId}&identity_token=${encodeURIComponent(e)}`);if(!t.ok)throw new Error(`HTTP error: ${t.status}`);return(await t.json()).conversations||[]}catch(t){return console.error("[Crow] Failed to load conversations:",t),[]}}async loadHistory(e,t){try{const s=await fetch(`${this.apiUrl}/api/chat/conversations/${e}/history?product_id=${this.productId}&identity_token=${encodeURIComponent(t)}`);if(!s.ok)throw new Error(`HTTP error: ${s.status}`);const r=await s.json();return this.parseHistoryMessages(r.messages||[])}catch(s){return console.error("[Crow] Failed to load conversation history:",s),[]}}async loadAnonymousHistory(e){try{const t=await fetch(`${this.apiUrl}/api/chat/conversations/${e}/history/anonymous?product_id=${this.productId}`);if(!t.ok)throw new Error(`HTTP error: ${t.status}`);const s=await t.json();return this.parseHistoryMessages(s.messages||[])}catch(t){return console.error("[Crow] Failed to load anonymous conversation history:",t),[]}}parseHistoryMessages(e){return e.filter(t=>t.role!=="tool"&&!t.content.startsWith("[Client Tool Result:")).map((t,s)=>({id:`history-${s}`,content:this.parseContent(t.content),role:t.role==="assistant"?"assistant":"user",timestamp:new Date}))}parseContent(e){try{const t=JSON.parse(e);if(Array.isArray(t)){const s=t.find(r=>r.type==="text");return(s==null?void 0:s.text)||e}}catch{}if(e.includes("'type': 'text'")){const t=e.match(/\{'text':\s*'((?:[^'\\]|\\.)*)'\s*,\s*'type':\s*'text'/);if(t)return t[1].replace(/\\n/g,`
+`).replace(/\\'/g,"'")}return e}}function I(o){if(o==="[DONE]")return{type:"done"};try{const e=JSON.parse(o);switch(e.type){case"verification_status":return{type:"verification_status",isVerified:e.is_verified===!0};case"conversation_id":return{type:"conversation_id",conversationId:e.conversation_id};case"thinking":return e.status==="complete"?{type:"thinking_complete"}:null;case"thinking_token":return{type:"thinking",content:e.content||""};case"content":return{type:"content",text:e.content||"",accumulated:""};case"citations":return{type:"citations",citations:e.citations};case"error":return{type:"error",message:e.message||"Unknown error"};case"tool_call_start":return{type:"tool_call_start",toolName:e.tool_name,displayName:e.display_name||void 0,arguments:e.arguments||{}};case"tool_call_complete":return{type:"tool_call_complete",toolName:e.tool_name,displayName:e.display_name||void 0,success:e.success};case"client_tool_call":return{type:"client_tool_call",toolName:e.tool_name,displayName:e.display_name||void 0,arguments:e.arguments||{}};case"tool_consent_required":return{type:"tool_consent_required",toolName:e.tool_name,displayName:e.display_name||void 0,arguments:e.arguments||{}};case"workflow_started":return{type:"workflow_started",name:e.name,todos:e.todos};case"todo_updated":return{type:"workflow_todo_updated",todoId:e.id,status:e.status};case"workflow_ended":return{type:"workflow_ended"};case"workflow_complete_prompt":return{type:"workflow_complete_prompt"};default:return null}}catch{return console.error("[Crow] Failed to parse SSE data:",o),null}}function*b(o){const e=o.split(`
+`);for(const t of e)t.startsWith("data: ")&&(yield t.slice(6).trim())}async function*M(o,e){var a;const t=(a=o.body)==null?void 0:a.getReader();if(!t)throw new Error("Response body is not readable");const s=new TextDecoder;let r="";try{for(;;){if(e!=null&&e.aborted){t.cancel();return}const{done:l,value:d}=await t.read();if(l)break;const h=s.decode(d);for(const u of b(h)){const c=I(u);if(c&&(c.type==="content"?(r+=c.text,yield{...c,accumulated:r}):yield c,c.type==="done"))return}}}finally{t.releaseLock()}}const $=typeof window<"u"&&typeof document<"u";async function U(){var o;try{const e=document.title,t=window.location.href,s=window.location.pathname,r=(((o=document.body)==null?void 0:o.innerText)||"").slice(0,2e3).trim();return{status:"success",data:{title:e,url:t,pathname:s,visibleText:r}}}catch(e){return{status:"error",error:e instanceof Error?e.message:"Failed to read screen"}}}const f=$?{whatsOnScreen:U}:{},g=Object.keys(f);function T(){try{const o="__crow_test__";return localStorage.setItem(o,"1"),localStorage.removeItem(o),{getItem:e=>localStorage.getItem(e),setItem:(e,t)=>localStorage.setItem(e,t),removeItem:e=>localStorage.removeItem(e)}}catch{return p()}}function p(){const o=new Map;return{getItem:e=>o.get(e)??null,setItem:(e,t)=>o.set(e,t),removeItem:e=>o.delete(e)}}const x="https://api.usecrow.org",O="claude-sonnet-4-20250514",E=typeof window<"u"&&typeof document<"u";function A(o){return o.storage?o.storage:E?T():p()}function R(o){return o.streamReader?o.streamReader:M}class N{constructor(e){this.context={},this.abortController=null,this.callbacks={},this._messages=[],this.messageListeners=new Set,this._isLoading=!1,this.loadingListeners=new Set,this.config={productId:e.productId,apiUrl:e.apiUrl||x,model:e.model||O,subdomain:e.subdomain};const t=A(e);this.readStream=R(e),this.identity=new C,this.tools=new v,this.conversations=new S(this.config.productId,this.config.apiUrl,t),(e.enableBrowserTools??(E&&g.length>0))&&(this.tools.register(f),console.log("[Crow] Default tools registered:",g.join(", "))),this.identity.subscribe(r=>{var a,l;(l=(a=this.callbacks).onVerificationStatus)==null||l.call(a,r.isVerified)})}get productId(){return this.config.productId}get apiUrl(){return this.config.apiUrl}get model(){return this.config.model}set model(e){this.config.model=e}on(e){this.callbacks={...this.callbacks,...e}}identify(e){this.identity.identify(e)}resetUser(){this.identity.reset(),this.clearMessages()}isIdentified(){return this.identity.isIdentified()}isVerified(){return this.identity.isVerified()}registerTools(e){this.tools.register(e)}unregisterTool(e){this.tools.unregister(e)}getRegisteredTools(){return this.tools.getRegisteredTools()}setContext(e){this.context={...this.context,...e}}clearContext(){this.context={}}get messages(){return[...this._messages]}get isLoading(){return this._isLoading}onMessages(e){return this.messageListeners.add(e),()=>this.messageListeners.delete(e)}onLoading(e){return this.loadingListeners.add(e),()=>this.loadingListeners.delete(e)}clearMessages(){this._messages=[],this.conversations.clear(),this.notifyMessages()}loadMessages(e){this._messages=e,this.notifyMessages()}notifyMessages(){const e=this.messages;for(const t of this.messageListeners)t(e)}setLoading(e){this._isLoading=e;for(const t of this.loadingListeners)t(e)}addMessage(e){var t,s;this._messages=[...this._messages,e],this.notifyMessages(),(s=(t=this.callbacks).onMessage)==null||s.call(t,e)}updateMessage(e,t){var s,r;this._messages=this._messages.map(a=>a.id===e?{...a,...t}:a),this.notifyMessages(),(r=(s=this.callbacks).onMessageUpdate)==null||r.call(s,e,t)}generateMessageId(e){return`${e}-${Date.now()}-${Math.random().toString(36).slice(2,9)}`}get conversationId(){return this.conversations.getCurrentId()}set conversationId(e){this.conversations.setCurrentId(e)}async getConversations(){const e=this.identity.getToken();return e?this.conversations.getConversations(e):(console.warn("[Crow] Cannot get conversations: user not identified"),[])}async loadHistory(e){const t=this.identity.getToken();return t?this.conversations.loadHistory(e,t):this.conversations.loadAnonymousHistory(e)}async switchConversation(e){const t=await this.loadHistory(e);this.conversations.setCurrentId(e),this.loadMessages(t)}async*sendMessage(e){var l,d,h,u,c,m,y,w,_,k;if(!e.trim())return;const t=this.generateMessageId("user");this.addMessage({id:t,content:e,role:"user",timestamp:new Date});const s=this.generateMessageId("assistant");this.addMessage({id:s,content:"",role:"assistant",timestamp:new Date}),this.setLoading(!0),this.abortController=new AbortController;let r="",a="";try{const i=await fetch(`${this.config.apiUrl}/api/chat/message`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({product_id:this.config.productId,message:e,conversation_id:this.conversations.getCurrentId(),identity_token:this.identity.getToken(),model:this.config.model,subdomain:this.config.subdomain,context:Object.keys(this.context).length>0?this.context:void 0}),signal:this.abortController.signal});if(!i.ok)throw new Error(`HTTP error: ${i.status}`);for await(const n of this.readStream(i,this.abortController.signal)){switch(n.type){case"content":r=n.accumulated,this.updateMessage(s,{content:r});break;case"thinking":a+=n.content,this.updateMessage(s,{thinking:a});break;case"thinking_complete":this.updateMessage(s,{thinkingComplete:!0});break;case"citations":this.updateMessage(s,{citations:n.citations});break;case"verification_status":this.identity.setVerified(n.isVerified);break;case"conversation_id":this.conversations.setCurrentId(n.conversationId);break;case"client_tool_call":await this.tools.execute(n.toolName,n.arguments),(d=(l=this.callbacks).onToolCall)==null||d.call(l,n);break;case"tool_call_start":case"tool_call_complete":(u=(h=this.callbacks).onToolCall)==null||u.call(h,n);break;case"workflow_started":case"workflow_todo_updated":case"workflow_ended":case"workflow_complete_prompt":(m=(c=this.callbacks).onWorkflow)==null||m.call(c,n);break;case"error":this.updateMessage(s,{content:n.message}),(w=(y=this.callbacks).onError)==null||w.call(y,new Error(n.message));break}yield n}}catch(i){if(i instanceof Error&&i.name==="AbortError"){r?this.updateMessage(s,{content:r}):(this._messages=this._messages.filter(n=>n.id!==s),this.notifyMessages());return}console.error("[Crow] Error:",i),this.updateMessage(s,{content:"Sorry, I encountered an error. Please try again."}),(k=(_=this.callbacks).onError)==null||k.call(_,i instanceof Error?i:new Error(String(i)))}finally{this.setLoading(!1),this.abortController=null}}async send(e){let t=null;for await(const r of this.sendMessage(e))if(r.type==="done")break;const s=this.messages;return s.length>0&&(t=s[s.length-1],t.role==="assistant")?t:null}stop(){this.abortController&&(this.abortController.abort(),this.setLoading(!1))}destroy(){this.stop(),this.messageListeners.clear(),this.loadingListeners.clear()}}exports.ConversationManager=S;exports.CrowClient=N;exports.DEFAULT_TOOLS=f;exports.DEFAULT_TOOL_NAMES=g;exports.IdentityManager=C;exports.ToolManager=v;exports.createLocalStorageAdapter=T;exports.createMemoryStorageAdapter=p;exports.parseSSEChunk=b;exports.parseSSEData=I;exports.streamResponse=M;

package/dist/index.native.d.ts

@@ -0,0 +1,517 @@
+export declare interface ActiveWorkflow {
+    name: string;
+    todos: WorkflowTodo[];
+    isComplete?: boolean;
+}
+
+export declare interface Citation {
+    document_id: string;
+    filename: string;
+    similarity?: number;
+    image_url?: string;
+    page?: number;
+}
+
+export declare interface ContextData {
+    /** Current page URL or path */
+    page?: string;
+    /** Custom context data */
+    [key: string]: unknown;
+}
+
+export declare interface Conversation {
+    id: string;
+    name: string | null;
+    created_at: string;
+    updated_at: string;
+}
+
+export declare class ConversationManager {
+    private productId;
+    private apiUrl;
+    private storage;
+    private currentId;
+    constructor(productId: string, apiUrl: string, storage: StorageAdapter);
+    /**
+     * Get storage key for this product
+     */
+    private getStorageKey;
+    /**
+     * Load conversation ID from storage
+     */
+    private loadFromStorage;
+    /**
+     * Save conversation ID to storage
+     */
+    private saveToStorage;
+    /**
+     * Clear conversation ID from storage
+     */
+    private clearStorage;
+    /**
+     * Get current conversation ID
+     */
+    getCurrentId(): string | null;
+    /**
+     * Set current conversation ID
+     */
+    setCurrentId(id: string | null): void;
+    /**
+     * Check if there's a restored conversation
+     */
+    hasRestoredConversation(): boolean;
+    /**
+     * Clear current conversation (start new)
+     */
+    clear(): void;
+    /**
+     * Fetch list of conversations for verified user
+     */
+    getConversations(identityToken: string): Promise<Conversation[]>;
+    /**
+     * Load conversation history for verified user
+     */
+    loadHistory(conversationId: string, identityToken: string): Promise<Message[]>;
+    /**
+     * Load conversation history for anonymous user
+     */
+    loadAnonymousHistory(conversationId: string): Promise<Message[]>;
+    /**
+     * Parse history messages from API format
+     */
+    private parseHistoryMessages;
+    /**
+     * Parse structured content (with thinking/text blocks) and extract just text
+     */
+    private parseContent;
+}
+
+/**
+ * localStorage-backed adapter (default for browsers).
+ * Falls back to in-memory when localStorage is unavailable.
+ */
+export declare function createLocalStorageAdapter(): StorageAdapter;
+
+/**
+ * In-memory adapter. Useful for React Native, SSR, or tests.
+ * Data does not persist across sessions.
+ */
+export declare function createMemoryStorageAdapter(): StorageAdapter;
+
+export declare class CrowClient {
+    private config;
+    private identity;
+    private tools;
+    private conversations;
+    private readStream;
+    private context;
+    private abortController;
+    private callbacks;
+    private _messages;
+    private messageListeners;
+    private _isLoading;
+    private loadingListeners;
+    constructor(config: CrowClientConfig);
+    /**
+     * Get current product ID
+     */
+    get productId(): string;
+    /**
+     * Get current API URL
+     */
+    get apiUrl(): string;
+    /**
+     * Get/set current model
+     */
+    get model(): string;
+    set model(value: string);
+    /**
+     * Register event callbacks
+     */
+    on(callbacks: CrowEventCallbacks): void;
+    /**
+     * Identify the current user with a JWT token
+     */
+    identify(options: IdentifyOptions): void;
+    /**
+     * Reset user identity (call on logout)
+     */
+    resetUser(): void;
+    /**
+     * Check if user is identified
+     */
+    isIdentified(): boolean;
+    /**
+     * Check if user is verified by server
+     */
+    isVerified(): boolean;
+    /**
+     * Register client-side tool handlers
+     */
+    registerTools(tools: ToolHandlers): void;
+    /**
+     * Unregister a tool handler
+     */
+    unregisterTool(name: string): void;
+    /**
+     * Get list of registered tool names
+     */
+    getRegisteredTools(): string[];
+    /**
+     * Set context data to be sent with messages
+     */
+    setContext(data: ContextData): void;
+    /**
+     * Clear context data
+     */
+    clearContext(): void;
+    /**
+     * Get current messages
+     */
+    get messages(): Message[];
+    /**
+     * Check if currently loading/streaming
+     */
+    get isLoading(): boolean;
+    /**
+     * Subscribe to message changes
+     */
+    onMessages(callback: (messages: Message[]) => void): () => void;
+    /**
+     * Subscribe to loading state changes
+     */
+    onLoading(callback: (isLoading: boolean) => void): () => void;
+    /**
+     * Clear all messages and start new conversation
+     */
+    clearMessages(): void;
+    /**
+     * Load messages from history
+     */
+    loadMessages(messages: Message[]): void;
+    private notifyMessages;
+    private setLoading;
+    private addMessage;
+    private updateMessage;
+    private generateMessageId;
+    /**
+     * Get current conversation ID
+     */
+    get conversationId(): string | null;
+    /**
+     * Set current conversation ID
+     */
+    set conversationId(id: string | null);
+    /**
+     * Get list of conversations for verified user
+     */
+    getConversations(): Promise<Conversation[]>;
+    /**
+     * Load conversation history
+     */
+    loadHistory(conversationId: string): Promise<Message[]>;
+    /**
+     * Switch to a different conversation
+     */
+    switchConversation(conversationId: string): Promise<void>;
+    /**
+     * Send a message and receive streaming response
+     * Returns an async generator of stream events
+     */
+    sendMessage(content: string): AsyncGenerator<StreamEvent>;
+    /**
+     * Send a message and wait for complete response (non-streaming)
+     */
+    send(content: string): Promise<Message | null>;
+    /**
+     * Stop current generation
+     */
+    stop(): void;
+    /**
+     * Destroy the client and clean up resources
+     */
+    destroy(): void;
+}
+
+export declare interface CrowClientConfig {
+    /** Your Crow product ID from the dashboard */
+    productId: string;
+    /** API URL (defaults to https://api.usecrow.org) */
+    apiUrl?: string;
+    /** Default model to use */
+    model?: string;
+    /**
+     * Storage adapter for persisting conversation state.
+     * Defaults to localStorage (browser) or in-memory if unavailable.
+     */
+    storage?: StorageAdapter;
+    /**
+     * Custom stream reader for SSE responses.
+     * Override this for React Native or other non-browser runtimes
+     * where Response.body.getReader() is not available.
+     */
+    streamReader?: StreamReader;
+    /**
+     * Whether to register browser-only default tools (whatsOnScreen).
+     * Defaults to true in browser environments, false otherwise.
+     */
+    enableBrowserTools?: boolean;
+    /** Subdomain for multi-endpoint products (routes to specific backend config) */
+    subdomain?: string;
+}
+
+export declare interface CrowEventCallbacks {
+    onMessage?: (message: Message) => void;
+    onMessageUpdate?: (messageId: string, updates: Partial<Message>) => void;
+    onToolCall?: (event: StreamEvent & {
+        type: 'tool_call_start' | 'tool_call_complete' | 'client_tool_call';
+    }) => void;
+    onWorkflow?: (event: StreamEvent & {
+        type: 'workflow_started' | 'workflow_todo_updated' | 'workflow_ended' | 'workflow_complete_prompt';
+    }) => void;
+    onVerificationStatus?: (isVerified: boolean) => void;
+    onError?: (error: Error) => void;
+    onBrowserUseConfirmation?: (event: {
+        instruction: string;
+        toolCallId: string;
+    }) => Promise<boolean>;
+    onBrowserUseQuestion?: (event: {
+        question: string;
+        sessionId: string;
+    }) => Promise<string>;
+    onBrowserUseProgress?: (event: {
+        step: number;
+        maxSteps: number;
+        action?: string;
+    }) => void;
+}
+
+export declare const DEFAULT_TOOL_NAMES: DefaultToolName[];
+
+/**
+ * Browser default tools. Empty object in non-browser runtimes.
+ */
+export declare const DEFAULT_TOOLS: ToolHandlers;
+
+export declare type DefaultToolName = 'whatsOnScreen';
+
+export declare interface IdentifyOptions {
+    /** JWT token from your backend for user verification */
+    token: string;
+    /** Optional user display name */
+    name?: string;
+    /** Optional user email */
+    email?: string;
+    /** Any additional metadata */
+    [key: string]: unknown;
+}
+
+export declare class IdentityManager {
+    private state;
+    private listeners;
+    /**
+     * Identify the current user with a JWT token
+     */
+    identify(options: IdentifyOptions): void;
+    /**
+     * Update verification status (called when server confirms)
+     */
+    setVerified(isVerified: boolean): void;
+    /**
+     * Reset user identity (call on logout)
+     */
+    reset(): void;
+    /**
+     * Get current identity token
+     */
+    getToken(): string | null;
+    /**
+     * Get current identity state
+     */
+    getState(): IdentityState;
+    /**
+     * Check if user is identified
+     */
+    isIdentified(): boolean;
+    /**
+     * Check if user is verified
+     */
+    isVerified(): boolean;
+    /**
+     * Subscribe to identity changes
+     */
+    subscribe(callback: (state: IdentityState) => void): () => void;
+    private notify;
+}
+
+export declare interface IdentityState {
+    token: string | null;
+    metadata: Record<string, unknown>;
+    isVerified: boolean;
+}
+
+export declare interface Message {
+    id: string;
+    content: string;
+    role: 'user' | 'assistant';
+    timestamp: Date;
+    /** Citations from knowledge base */
+    citations?: Citation[];
+    /** Claude's reasoning/thinking trace */
+    thinking?: string;
+    /** Whether thinking is complete */
+    thinkingComplete?: boolean;
+}
+
+/**
+ * Parse SSE chunk into lines and extract data
+ */
+export declare function parseSSEChunk(chunk: string): Generator<string>;
+
+/**
+ * Parse a single SSE data line into a StreamEvent
+ */
+export declare function parseSSEData(data: string): StreamEvent | null;
+
+/**
+ * Synchronous key-value storage interface.
+ * Matches the subset of Web Storage API used by ConversationManager.
+ */
+export declare interface StorageAdapter {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+
+export declare type StreamEvent = {
+    type: 'content';
+    text: string;
+    accumulated: string;
+} | {
+    type: 'thinking';
+    content: string;
+} | {
+    type: 'thinking_complete';
+} | {
+    type: 'citations';
+    citations: Citation[];
+} | {
+    type: 'tool_call_start';
+    toolName: string;
+    displayName?: string;
+    arguments: Record<string, unknown>;
+} | {
+    type: 'tool_call_complete';
+    toolName: string;
+    displayName?: string;
+    success: boolean;
+} | {
+    type: 'client_tool_call';
+    toolName: string;
+    displayName?: string;
+    arguments: Record<string, unknown>;
+} | {
+    type: 'tool_consent_required';
+    toolName: string;
+    displayName?: string;
+    arguments: Record<string, unknown>;
+} | {
+    type: 'workflow_started';
+    name: string;
+    todos: WorkflowTodo[];
+} | {
+    type: 'workflow_todo_updated';
+    todoId: string;
+    status: 'pending' | 'completed';
+} | {
+    type: 'workflow_ended';
+} | {
+    type: 'workflow_complete_prompt';
+} | {
+    type: 'verification_status';
+    isVerified: boolean;
+} | {
+    type: 'conversation_id';
+    conversationId: string;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'done';
+} | {
+    type: 'suggested_actions';
+    actions: SuggestedAction[];
+} | {
+    type: 'browser_use_confirmation';
+    instruction: string;
+    toolCallId: string;
+} | {
+    type: 'browser_use_question';
+    question: string;
+    sessionId: string;
+} | {
+    type: 'browser_use_progress';
+    step: number;
+    maxSteps: number;
+    action?: string;
+};
+
+/**
+ * A function that reads SSE events from an HTTP Response.
+ *
+ * Browser default: uses Response.body.getReader() + TextDecoder.
+ * React Native: uses XMLHttpRequest onprogress or text-based parsing.
+ */
+export declare type StreamReader = (response: Response, signal?: AbortSignal) => AsyncGenerator<StreamEvent>;
+
+/**
+ * Create an async generator that streams events from a Response
+ */
+export declare function streamResponse(response: Response, signal?: AbortSignal): AsyncGenerator<StreamEvent>;
+
+export declare interface SuggestedAction {
+    label: string;
+    message: string;
+}
+
+export declare type ToolHandler = (args: Record<string, unknown>) => Promise<ToolResult> | ToolResult;
+
+export declare type ToolHandlers = Record<string, ToolHandler>;
+
+export declare class ToolManager {
+    private handlers;
+    /**
+     * Register client-side tool handlers
+     */
+    register(tools: ToolHandlers): void;
+    /**
+     * Unregister a tool handler
+     */
+    unregister(name: string): void;
+    /**
+     * Check if a tool is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered tool names
+     */
+    getRegisteredTools(): string[];
+    /**
+     * Execute a client-side tool
+     */
+    execute(name: string, args: Record<string, unknown>): Promise<ToolResult>;
+}
+
+export declare interface ToolResult {
+    status: 'success' | 'error' | 'needs_input';
+    data?: unknown;
+    error?: string;
+}
+
+export declare interface WorkflowTodo {
+    id: string;
+    text: string;
+    status: 'pending' | 'completed';
+}
+
+export { }