@devicai/ui 0.1.0

package/dist/esm/hooks/useDevicChat.js

@@ -0,0 +1,256 @@
+import { useState, useRef, useEffect, useCallback } from 'react';
+import 'react/jsx-runtime';
+import { useOptionalDevicContext } from '../provider/DevicContext.js';
+import { DevicApiClient } from '../api/client.js';
+import { usePolling } from './usePolling.js';
+import { useModelInterface } from './useModelInterface.js';
+
+/**
+ * Main hook for managing chat with a Devic assistant
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   messages,
+ *   isLoading,
+ *   sendMessage,
+ * } = useDevicChat({
+ *   assistantId: 'my-assistant',
+ *   modelInterfaceTools: [
+ *     {
+ *       toolName: 'get_user_location',
+ *       schema: { ... },
+ *       callback: async () => ({ lat: 40.7, lng: -74.0 })
+ *     }
+ *   ],
+ *   onMessageReceived: (msg) => console.log('Received:', msg),
+ * });
+ * ```
+ */
+function useDevicChat(options) {
+    const { assistantId, chatUid: initialChatUid, apiKey: propsApiKey, baseUrl: propsBaseUrl, tenantId, tenantMetadata, enabledTools, modelInterfaceTools = [], pollingInterval = 1000, onMessageSent, onMessageReceived, onToolCall, onError, onChatCreated, } = options;
+    // Get context (may be null if not wrapped in provider)
+    const context = useOptionalDevicContext();
+    // Resolve configuration
+    const apiKey = propsApiKey || context?.apiKey;
+    const baseUrl = propsBaseUrl || context?.baseUrl || 'https://api.devic.ai';
+    const resolvedTenantId = tenantId || context?.tenantId;
+    const resolvedTenantMetadata = { ...context?.tenantMetadata, ...tenantMetadata };
+    // State
+    const [messages, setMessages] = useState([]);
+    const [chatUid, setChatUid] = useState(initialChatUid || null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [status, setStatus] = useState('idle');
+    const [error, setError] = useState(null);
+    // Polling state
+    const [shouldPoll, setShouldPoll] = useState(false);
+    // Refs for callbacks
+    const onMessageReceivedRef = useRef(onMessageReceived);
+    const onErrorRef = useRef(onError);
+    const onChatCreatedRef = useRef(onChatCreated);
+    useEffect(() => {
+        onMessageReceivedRef.current = onMessageReceived;
+        onErrorRef.current = onError;
+        onChatCreatedRef.current = onChatCreated;
+    });
+    // Create API client
+    const clientRef = useRef(null);
+    if (!clientRef.current && apiKey) {
+        clientRef.current = new DevicApiClient({ apiKey, baseUrl });
+    }
+    // Update client config if it changes
+    useEffect(() => {
+        if (clientRef.current && apiKey) {
+            clientRef.current.setConfig({ apiKey, baseUrl });
+        }
+    }, [apiKey, baseUrl]);
+    // Model interface hook
+    const { toolSchemas, handleToolCalls, extractPendingToolCalls, } = useModelInterface({
+        tools: modelInterfaceTools,
+        onToolExecute: onToolCall,
+    });
+    // Polling hook
+    usePolling(shouldPoll ? chatUid : null, async () => {
+        if (!clientRef.current || !chatUid) {
+            throw new Error('Cannot poll without client or chatUid');
+        }
+        return clientRef.current.getRealtimeHistory(assistantId, chatUid);
+    }, {
+        interval: pollingInterval,
+        enabled: shouldPoll,
+        stopStatuses: ['completed', 'error', 'waiting_for_tool_response'],
+        onUpdate: async (data) => {
+            setMessages(data.chatHistory);
+            setStatus(data.status);
+            // Notify about new messages
+            const lastMessage = data.chatHistory[data.chatHistory.length - 1];
+            if (lastMessage && lastMessage.role === 'assistant') {
+                onMessageReceivedRef.current?.(lastMessage);
+            }
+            // Handle model interface - check for pending tool calls
+            if (data.status === 'waiting_for_tool_response' || data.pendingToolCalls?.length) {
+                await handlePendingToolCalls(data);
+            }
+        },
+        onStop: async (data) => {
+            setIsLoading(false);
+            setShouldPoll(false);
+            if (data?.status === 'error') {
+                const err = new Error('Chat processing failed');
+                setError(err);
+                onErrorRef.current?.(err);
+            }
+            else if (data?.status === 'waiting_for_tool_response') {
+                // Handle tool response
+                await handlePendingToolCalls(data);
+            }
+        },
+        onError: (err) => {
+            setError(err);
+            setIsLoading(false);
+            setShouldPoll(false);
+            onErrorRef.current?.(err);
+        },
+    });
+    // Handle pending tool calls from model interface
+    const handlePendingToolCalls = useCallback(async (data) => {
+        if (!clientRef.current || !chatUid)
+            return;
+        // Get pending tool calls
+        const pendingCalls = data.pendingToolCalls || extractPendingToolCalls(data.chatHistory);
+        if (pendingCalls.length === 0)
+            return;
+        try {
+            // Execute client-side tools
+            const responses = await handleToolCalls(pendingCalls);
+            if (responses.length > 0) {
+                // Send tool responses back to the API
+                await clientRef.current.sendToolResponses(assistantId, chatUid, responses);
+                // Resume polling
+                setShouldPoll(true);
+                setIsLoading(true);
+            }
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            onErrorRef.current?.(error);
+        }
+    }, [chatUid, assistantId, handleToolCalls, extractPendingToolCalls]);
+    // Send a message
+    const sendMessage = useCallback(async (message, sendOptions) => {
+        if (!clientRef.current) {
+            const err = new Error('API client not configured. Please provide an API key.');
+            setError(err);
+            onErrorRef.current?.(err);
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        setStatus('processing');
+        // Add user message optimistically
+        const userMessage = {
+            uid: `temp-${Date.now()}`,
+            role: 'user',
+            content: {
+                message,
+                files: sendOptions?.files?.map((f) => ({
+                    name: f.name,
+                    url: f.downloadUrl || '',
+                    type: f.fileType || 'other',
+                })),
+            },
+            timestamp: Date.now(),
+        };
+        setMessages((prev) => [...prev, userMessage]);
+        onMessageSent?.(userMessage);
+        try {
+            // Build request DTO
+            const dto = {
+                message,
+                chatUid: chatUid || undefined,
+                files: sendOptions?.files,
+                metadata: {
+                    ...resolvedTenantMetadata,
+                    ...sendOptions?.metadata,
+                },
+                tenantId: resolvedTenantId,
+                enabledTools,
+                // Include model interface tools if any
+                ...(toolSchemas.length > 0 && { tools: toolSchemas }),
+            };
+            // Send message in async mode
+            const response = await clientRef.current.sendMessageAsync(assistantId, dto);
+            // Update chat UID if this is a new chat
+            if (response.chatUid && response.chatUid !== chatUid) {
+                setChatUid(response.chatUid);
+                onChatCreatedRef.current?.(response.chatUid);
+            }
+            // Start polling for results
+            setShouldPoll(true);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            setIsLoading(false);
+            setStatus('error');
+            onErrorRef.current?.(error);
+            // Remove optimistic user message on error
+            setMessages((prev) => prev.filter((m) => m.uid !== userMessage.uid));
+        }
+    }, [
+        chatUid,
+        assistantId,
+        enabledTools,
+        resolvedTenantId,
+        resolvedTenantMetadata,
+        toolSchemas,
+        onMessageSent,
+    ]);
+    // Clear chat
+    const clearChat = useCallback(() => {
+        setMessages([]);
+        setChatUid(null);
+        setStatus('idle');
+        setError(null);
+        setShouldPoll(false);
+    }, []);
+    // Load existing chat
+    const loadChat = useCallback(async (loadChatUid) => {
+        if (!clientRef.current) {
+            const err = new Error('API client not configured');
+            setError(err);
+            onErrorRef.current?.(err);
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const history = await clientRef.current.getChatHistory(assistantId, loadChatUid);
+            setMessages(history.chatContent);
+            setChatUid(loadChatUid);
+            setStatus('completed');
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            onErrorRef.current?.(error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [assistantId]);
+    return {
+        messages,
+        chatUid,
+        isLoading,
+        status,
+        error,
+        sendMessage,
+        clearChat,
+        loadChat,
+    };
+}
+
+export { useDevicChat };
+//# sourceMappingURL=useDevicChat.js.map

package/dist/esm/hooks/useDevicChat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDevicChat.js","sources":["../../../src/hooks/useDevicChat.ts"],"sourcesContent":["import { useState, useCallback, useEffect, useRef } from 'react';\nimport { useOptionalDevicContext } from '../provider';\nimport { DevicApiClient } from '../api/client';\nimport { usePolling } from './usePolling';\nimport { useModelInterface } from './useModelInterface';\nimport type {\n  ChatMessage,\n  ChatFile,\n  ModelInterfaceTool,\n  RealtimeChatHistory,\n  RealtimeStatus,\n} from '../api/types';\n\nexport interface UseDevicChatOptions {\n  /**\n   * Assistant identifier\n   */\n  assistantId: string;\n\n  /**\n   * Existing chat UID to continue a conversation\n   */\n  chatUid?: string;\n\n  /**\n   * API key (overrides provider context)\n   */\n  apiKey?: string;\n\n  /**\n   * Base URL (overrides provider context)\n   */\n  baseUrl?: string;\n\n  /**\n   * Tenant ID for multi-tenant environments\n   */\n  tenantId?: string;\n\n  /**\n   * Tenant metadata\n   */\n  tenantMetadata?: Record<string, any>;\n\n  /**\n   * Tools enabled from the assistant's configured tool groups\n   */\n  enabledTools?: string[];\n\n  /**\n   * Client-side tools for model interface protocol\n   */\n  modelInterfaceTools?: ModelInterfaceTool[];\n\n  /**\n   * Polling interval for async mode (ms)\n   * @default 1000\n   */\n  pollingInterval?: number;\n\n  /**\n   * Callback when a message is sent\n   */\n  onMessageSent?: (message: ChatMessage) => void;\n\n  /**\n   * Callback when a message is received\n   */\n  onMessageReceived?: (message: ChatMessage) => void;\n\n  /**\n   * Callback when a tool is called\n   */\n  onToolCall?: (toolName: string, params: any) => void;\n\n  /**\n   * Callback when an error occurs\n   */\n  onError?: (error: Error) => void;\n\n  /**\n   * Callback when a new chat is created\n   */\n  onChatCreated?: (chatUid: string) => void;\n}\n\nexport interface UseDevicChatResult {\n  /**\n   * Current chat messages\n   */\n  messages: ChatMessage[];\n\n  /**\n   * Current chat UID\n   */\n  chatUid: string | null;\n\n  /**\n   * Whether a message is being processed\n   */\n  isLoading: boolean;\n\n  /**\n   * Current status\n   */\n  status: RealtimeStatus | 'idle';\n\n  /**\n   * Last error\n   */\n  error: Error | null;\n\n  /**\n   * Send a message\n   */\n  sendMessage: (\n    message: string,\n    options?: {\n      files?: ChatFile[];\n      metadata?: Record<string, any>;\n    }\n  ) => Promise<void>;\n\n  /**\n   * Clear the chat and start a new conversation\n   */\n  clearChat: () => void;\n\n  /**\n   * Load an existing chat\n   */\n  loadChat: (chatUid: string) => Promise<void>;\n}\n\n/**\n * Main hook for managing chat with a Devic assistant\n *\n * @example\n * ```tsx\n * const {\n *   messages,\n *   isLoading,\n *   sendMessage,\n * } = useDevicChat({\n *   assistantId: 'my-assistant',\n *   modelInterfaceTools: [\n *     {\n *       toolName: 'get_user_location',\n *       schema: { ... },\n *       callback: async () => ({ lat: 40.7, lng: -74.0 })\n *     }\n *   ],\n *   onMessageReceived: (msg) => console.log('Received:', msg),\n * });\n * ```\n */\nexport function useDevicChat(options: UseDevicChatOptions): UseDevicChatResult {\n  const {\n    assistantId,\n    chatUid: initialChatUid,\n    apiKey: propsApiKey,\n    baseUrl: propsBaseUrl,\n    tenantId,\n    tenantMetadata,\n    enabledTools,\n    modelInterfaceTools = [],\n    pollingInterval = 1000,\n    onMessageSent,\n    onMessageReceived,\n    onToolCall,\n    onError,\n    onChatCreated,\n  } = options;\n\n  // Get context (may be null if not wrapped in provider)\n  const context = useOptionalDevicContext();\n\n  // Resolve configuration\n  const apiKey = propsApiKey || context?.apiKey;\n  const baseUrl = propsBaseUrl || context?.baseUrl || 'https://api.devic.ai';\n  const resolvedTenantId = tenantId || context?.tenantId;\n  const resolvedTenantMetadata = { ...context?.tenantMetadata, ...tenantMetadata };\n\n  // State\n  const [messages, setMessages] = useState<ChatMessage[]>([]);\n  const [chatUid, setChatUid] = useState<string | null>(initialChatUid || null);\n  const [isLoading, setIsLoading] = useState(false);\n  const [status, setStatus] = useState<RealtimeStatus | 'idle'>('idle');\n  const [error, setError] = useState<Error | null>(null);\n\n  // Polling state\n  const [shouldPoll, setShouldPoll] = useState(false);\n\n  // Refs for callbacks\n  const onMessageReceivedRef = useRef(onMessageReceived);\n  const onErrorRef = useRef(onError);\n  const onChatCreatedRef = useRef(onChatCreated);\n\n  useEffect(() => {\n    onMessageReceivedRef.current = onMessageReceived;\n    onErrorRef.current = onError;\n    onChatCreatedRef.current = onChatCreated;\n  });\n\n  // Create API client\n  const clientRef = useRef<DevicApiClient | null>(null);\n  if (!clientRef.current && apiKey) {\n    clientRef.current = new DevicApiClient({ apiKey, baseUrl });\n  }\n\n  // Update client config if it changes\n  useEffect(() => {\n    if (clientRef.current && apiKey) {\n      clientRef.current.setConfig({ apiKey, baseUrl });\n    }\n  }, [apiKey, baseUrl]);\n\n  // Model interface hook\n  const {\n    toolSchemas,\n    handleToolCalls,\n    extractPendingToolCalls,\n  } = useModelInterface({\n    tools: modelInterfaceTools,\n    onToolExecute: onToolCall,\n  });\n\n  // Polling hook\n  const polling = usePolling(\n    shouldPoll ? chatUid : null,\n    async () => {\n      if (!clientRef.current || !chatUid) {\n        throw new Error('Cannot poll without client or chatUid');\n      }\n      return clientRef.current.getRealtimeHistory(assistantId, chatUid);\n    },\n    {\n      interval: pollingInterval,\n      enabled: shouldPoll,\n      stopStatuses: ['completed', 'error', 'waiting_for_tool_response'],\n      onUpdate: async (data: RealtimeChatHistory) => {\n        setMessages(data.chatHistory);\n        setStatus(data.status);\n\n        // Notify about new messages\n        const lastMessage = data.chatHistory[data.chatHistory.length - 1];\n        if (lastMessage && lastMessage.role === 'assistant') {\n          onMessageReceivedRef.current?.(lastMessage);\n        }\n\n        // Handle model interface - check for pending tool calls\n        if (data.status === 'waiting_for_tool_response' || data.pendingToolCalls?.length) {\n          await handlePendingToolCalls(data);\n        }\n      },\n      onStop: async (data) => {\n        setIsLoading(false);\n        setShouldPoll(false);\n\n        if (data?.status === 'error') {\n          const err = new Error('Chat processing failed');\n          setError(err);\n          onErrorRef.current?.(err);\n        } else if (data?.status === 'waiting_for_tool_response') {\n          // Handle tool response\n          await handlePendingToolCalls(data);\n        }\n      },\n      onError: (err) => {\n        setError(err);\n        setIsLoading(false);\n        setShouldPoll(false);\n        onErrorRef.current?.(err);\n      },\n    }\n  );\n\n  // Handle pending tool calls from model interface\n  const handlePendingToolCalls = useCallback(\n    async (data: RealtimeChatHistory) => {\n      if (!clientRef.current || !chatUid) return;\n\n      // Get pending tool calls\n      const pendingCalls = data.pendingToolCalls || extractPendingToolCalls(data.chatHistory);\n\n      if (pendingCalls.length === 0) return;\n\n      try {\n        // Execute client-side tools\n        const responses = await handleToolCalls(pendingCalls);\n\n        if (responses.length > 0) {\n          // Send tool responses back to the API\n          await clientRef.current.sendToolResponses(assistantId, chatUid, responses);\n\n          // Resume polling\n          setShouldPoll(true);\n          setIsLoading(true);\n        }\n      } catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err));\n        setError(error);\n        onErrorRef.current?.(error);\n      }\n    },\n    [chatUid, assistantId, handleToolCalls, extractPendingToolCalls]\n  );\n\n  // Send a message\n  const sendMessage = useCallback(\n    async (\n      message: string,\n      sendOptions?: {\n        files?: ChatFile[];\n        metadata?: Record<string, any>;\n      }\n    ) => {\n      if (!clientRef.current) {\n        const err = new Error(\n          'API client not configured. Please provide an API key.'\n        );\n        setError(err);\n        onErrorRef.current?.(err);\n        return;\n      }\n\n      setIsLoading(true);\n      setError(null);\n      setStatus('processing');\n\n      // Add user message optimistically\n      const userMessage: ChatMessage = {\n        uid: `temp-${Date.now()}`,\n        role: 'user',\n        content: {\n          message,\n          files: sendOptions?.files?.map((f) => ({\n            name: f.name,\n            url: f.downloadUrl || '',\n            type: f.fileType || 'other',\n          })),\n        },\n        timestamp: Date.now(),\n      };\n\n      setMessages((prev) => [...prev, userMessage]);\n      onMessageSent?.(userMessage);\n\n      try {\n        // Build request DTO\n        const dto = {\n          message,\n          chatUid: chatUid || undefined,\n          files: sendOptions?.files,\n          metadata: {\n            ...resolvedTenantMetadata,\n            ...sendOptions?.metadata,\n          },\n          tenantId: resolvedTenantId,\n          enabledTools,\n          // Include model interface tools if any\n          ...(toolSchemas.length > 0 && { tools: toolSchemas }),\n        };\n\n        // Send message in async mode\n        const response = await clientRef.current.sendMessageAsync(assistantId, dto);\n\n        // Update chat UID if this is a new chat\n        if (response.chatUid && response.chatUid !== chatUid) {\n          setChatUid(response.chatUid);\n          onChatCreatedRef.current?.(response.chatUid);\n        }\n\n        // Start polling for results\n        setShouldPoll(true);\n      } catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err));\n        setError(error);\n        setIsLoading(false);\n        setStatus('error');\n        onErrorRef.current?.(error);\n\n        // Remove optimistic user message on error\n        setMessages((prev) => prev.filter((m) => m.uid !== userMessage.uid));\n      }\n    },\n    [\n      chatUid,\n      assistantId,\n      enabledTools,\n      resolvedTenantId,\n      resolvedTenantMetadata,\n      toolSchemas,\n      onMessageSent,\n    ]\n  );\n\n  // Clear chat\n  const clearChat = useCallback(() => {\n    setMessages([]);\n    setChatUid(null);\n    setStatus('idle');\n    setError(null);\n    setShouldPoll(false);\n  }, []);\n\n  // Load existing chat\n  const loadChat = useCallback(\n    async (loadChatUid: string) => {\n      if (!clientRef.current) {\n        const err = new Error('API client not configured');\n        setError(err);\n        onErrorRef.current?.(err);\n        return;\n      }\n\n      setIsLoading(true);\n      setError(null);\n\n      try {\n        const history = await clientRef.current.getChatHistory(\n          assistantId,\n          loadChatUid\n        );\n\n        setMessages(history.chatContent);\n        setChatUid(loadChatUid);\n        setStatus('completed');\n      } catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err));\n        setError(error);\n        onErrorRef.current?.(error);\n      } finally {\n        setIsLoading(false);\n      }\n    },\n    [assistantId]\n  );\n\n  return {\n    messages,\n    chatUid,\n    isLoading,\n    status,\n    error,\n    sendMessage,\n    clearChat,\n    loadChat,\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/hooks/useModelInterface.d.ts

@@ -0,0 +1,68 @@
+import type { ModelInterfaceTool, ModelInterfaceToolSchema, ToolCall, ToolCallResponse, ChatMessage } from '../api/types';
+export interface UseModelInterfaceOptions {
+    /**
+     * Client-side tools available for model interface protocol
+     */
+    tools: ModelInterfaceTool[];
+    /**
+     * Callback when a tool is being executed
+     */
+    onToolExecute?: (toolName: string, params: any) => void;
+    /**
+     * Callback when a tool execution completes
+     */
+    onToolComplete?: (toolName: string, result: any) => void;
+    /**
+     * Callback when a tool execution fails
+     */
+    onToolError?: (toolName: string, error: Error) => void;
+}
+export interface UseModelInterfaceResult {
+    /**
+     * Tool schemas to send to the API
+     */
+    toolSchemas: ModelInterfaceToolSchema[];
+    /**
+     * Check if a tool call should be handled client-side
+     */
+    isClientTool: (toolName: string) => boolean;
+    /**
+     * Handle tool calls from the model, returns tool responses
+     */
+    handleToolCalls: (toolCalls: ToolCall[]) => Promise<ToolCallResponse[]>;
+    /**
+     * Process messages and extract pending tool calls that need client handling
+     */
+    extractPendingToolCalls: (messages: ChatMessage[]) => ToolCall[];
+}
+/**
+ * Hook for implementing the Model Interface Protocol
+ *
+ * The Model Interface Protocol allows client-side tools to be executed
+ * during an assistant conversation. When the model calls a client-side tool,
+ * this hook handles executing the tool and preparing the response.
+ *
+ * @example
+ * ```tsx
+ * const { toolSchemas, handleToolCalls } = useModelInterface({
+ *   tools: [
+ *     {
+ *       toolName: 'get_user_location',
+ *       schema: {
+ *         type: 'function',
+ *         function: {
+ *           name: 'get_user_location',
+ *           description: 'Get user current location',
+ *           parameters: { type: 'object', properties: {} }
+ *         }
+ *       },
+ *       callback: async () => {
+ *         const pos = await getCurrentPosition();
+ *         return { lat: pos.coords.latitude, lng: pos.coords.longitude };
+ *       }
+ *     }
+ *   ]
+ * });
+ * ```
+ */
+export declare function useModelInterface(options: UseModelInterfaceOptions): UseModelInterfaceResult;

package/dist/esm/hooks/useModelInterface.js

@@ -0,0 +1,128 @@
+import { useMemo, useCallback } from 'react';
+
+/**
+ * Hook for implementing the Model Interface Protocol
+ *
+ * The Model Interface Protocol allows client-side tools to be executed
+ * during an assistant conversation. When the model calls a client-side tool,
+ * this hook handles executing the tool and preparing the response.
+ *
+ * @example
+ * ```tsx
+ * const { toolSchemas, handleToolCalls } = useModelInterface({
+ *   tools: [
+ *     {
+ *       toolName: 'get_user_location',
+ *       schema: {
+ *         type: 'function',
+ *         function: {
+ *           name: 'get_user_location',
+ *           description: 'Get user current location',
+ *           parameters: { type: 'object', properties: {} }
+ *         }
+ *       },
+ *       callback: async () => {
+ *         const pos = await getCurrentPosition();
+ *         return { lat: pos.coords.latitude, lng: pos.coords.longitude };
+ *       }
+ *     }
+ *   ]
+ * });
+ * ```
+ */
+function useModelInterface(options) {
+    const { tools, onToolExecute, onToolComplete, onToolError } = options;
+    // Extract tool schemas for API
+    const toolSchemas = useMemo(() => {
+        return tools.map((tool) => tool.schema);
+    }, [tools]);
+    // Map of tool name to tool definition
+    const toolMap = useMemo(() => {
+        return new Map(tools.map((tool) => [tool.toolName, tool]));
+    }, [tools]);
+    // Check if a tool is a client-side tool
+    const isClientTool = useCallback((toolName) => {
+        return toolMap.has(toolName);
+    }, [toolMap]);
+    // Handle tool calls and execute client-side tools
+    const handleToolCalls = useCallback(async (toolCalls) => {
+        const responses = [];
+        for (const toolCall of toolCalls) {
+            const toolName = toolCall.function.name;
+            const tool = toolMap.get(toolName);
+            if (!tool) {
+                // Not a client-side tool, skip
+                continue;
+            }
+            try {
+                // Parse arguments
+                let params = {};
+                try {
+                    params = JSON.parse(toolCall.function.arguments || '{}');
+                }
+                catch {
+                    // Keep empty params if parsing fails
+                }
+                // Notify about execution
+                onToolExecute?.(toolName, params);
+                // Execute the tool callback
+                const result = await tool.callback(params);
+                // Notify about completion
+                onToolComplete?.(toolName, result);
+                // Add response
+                responses.push({
+                    tool_call_id: toolCall.id,
+                    content: result,
+                    role: 'tool',
+                });
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                // Notify about error
+                onToolError?.(toolName, error);
+                // Add error response
+                responses.push({
+                    tool_call_id: toolCall.id,
+                    content: { error: error.message },
+                    role: 'tool',
+                });
+            }
+        }
+        return responses;
+    }, [toolMap, onToolExecute, onToolComplete, onToolError]);
+    // Extract pending tool calls from messages that need client handling
+    const extractPendingToolCalls = useCallback((messages) => {
+        const pendingCalls = [];
+        // Look at the last assistant message
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const message = messages[i];
+            if (message.role === 'assistant' && message.tool_calls?.length) {
+                // Filter for client-side tools only
+                const clientToolCalls = message.tool_calls.filter((tc) => isClientTool(tc.function.name));
+                // Check if these tool calls have been responded to
+                const respondedToolIds = new Set(messages
+                    .slice(i + 1)
+                    .filter((m) => m.role === 'tool')
+                    .map((m) => m.tool_call_id));
+                // Get unresponded tool calls
+                for (const tc of clientToolCalls) {
+                    if (!respondedToolIds.has(tc.id)) {
+                        pendingCalls.push(tc);
+                    }
+                }
+                // Only check the most recent assistant message with tool calls
+                break;
+            }
+        }
+        return pendingCalls;
+    }, [isClientTool]);
+    return {
+        toolSchemas,
+        isClientTool,
+        handleToolCalls,
+        extractPendingToolCalls,
+    };
+}
+
+export { useModelInterface };
+//# sourceMappingURL=useModelInterface.js.map

package/dist/esm/hooks/useModelInterface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useModelInterface.js","sources":["../../../src/hooks/useModelInterface.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\nimport type {\n  ModelInterfaceTool,\n  ModelInterfaceToolSchema,\n  ToolCall,\n  ToolCallResponse,\n  ChatMessage,\n} from '../api/types';\n\nexport interface UseModelInterfaceOptions {\n  /**\n   * Client-side tools available for model interface protocol\n   */\n  tools: ModelInterfaceTool[];\n\n  /**\n   * Callback when a tool is being executed\n   */\n  onToolExecute?: (toolName: string, params: any) => void;\n\n  /**\n   * Callback when a tool execution completes\n   */\n  onToolComplete?: (toolName: string, result: any) => void;\n\n  /**\n   * Callback when a tool execution fails\n   */\n  onToolError?: (toolName: string, error: Error) => void;\n}\n\nexport interface UseModelInterfaceResult {\n  /**\n   * Tool schemas to send to the API\n   */\n  toolSchemas: ModelInterfaceToolSchema[];\n\n  /**\n   * Check if a tool call should be handled client-side\n   */\n  isClientTool: (toolName: string) => boolean;\n\n  /**\n   * Handle tool calls from the model, returns tool responses\n   */\n  handleToolCalls: (toolCalls: ToolCall[]) => Promise<ToolCallResponse[]>;\n\n  /**\n   * Process messages and extract pending tool calls that need client handling\n   */\n  extractPendingToolCalls: (messages: ChatMessage[]) => ToolCall[];\n}\n\n/**\n * Hook for implementing the Model Interface Protocol\n *\n * The Model Interface Protocol allows client-side tools to be executed\n * during an assistant conversation. When the model calls a client-side tool,\n * this hook handles executing the tool and preparing the response.\n *\n * @example\n * ```tsx\n * const { toolSchemas, handleToolCalls } = useModelInterface({\n *   tools: [\n *     {\n *       toolName: 'get_user_location',\n *       schema: {\n *         type: 'function',\n *         function: {\n *           name: 'get_user_location',\n *           description: 'Get user current location',\n *           parameters: { type: 'object', properties: {} }\n *         }\n *       },\n *       callback: async () => {\n *         const pos = await getCurrentPosition();\n *         return { lat: pos.coords.latitude, lng: pos.coords.longitude };\n *       }\n *     }\n *   ]\n * });\n * ```\n */\nexport function useModelInterface(\n  options: UseModelInterfaceOptions\n): UseModelInterfaceResult {\n  const { tools, onToolExecute, onToolComplete, onToolError } = options;\n\n  // Extract tool schemas for API\n  const toolSchemas = useMemo(() => {\n    return tools.map((tool) => tool.schema);\n  }, [tools]);\n\n  // Map of tool name to tool definition\n  const toolMap = useMemo(() => {\n    return new Map(tools.map((tool) => [tool.toolName, tool]));\n  }, [tools]);\n\n  // Check if a tool is a client-side tool\n  const isClientTool = useCallback(\n    (toolName: string): boolean => {\n      return toolMap.has(toolName);\n    },\n    [toolMap]\n  );\n\n  // Handle tool calls and execute client-side tools\n  const handleToolCalls = useCallback(\n    async (toolCalls: ToolCall[]): Promise<ToolCallResponse[]> => {\n      const responses: ToolCallResponse[] = [];\n\n      for (const toolCall of toolCalls) {\n        const toolName = toolCall.function.name;\n        const tool = toolMap.get(toolName);\n\n        if (!tool) {\n          // Not a client-side tool, skip\n          continue;\n        }\n\n        try {\n          // Parse arguments\n          let params: any = {};\n          try {\n            params = JSON.parse(toolCall.function.arguments || '{}');\n          } catch {\n            // Keep empty params if parsing fails\n          }\n\n          // Notify about execution\n          onToolExecute?.(toolName, params);\n\n          // Execute the tool callback\n          const result = await tool.callback(params);\n\n          // Notify about completion\n          onToolComplete?.(toolName, result);\n\n          // Add response\n          responses.push({\n            tool_call_id: toolCall.id,\n            content: result,\n            role: 'tool',\n          });\n        } catch (err) {\n          const error = err instanceof Error ? err : new Error(String(err));\n\n          // Notify about error\n          onToolError?.(toolName, error);\n\n          // Add error response\n          responses.push({\n            tool_call_id: toolCall.id,\n            content: { error: error.message },\n            role: 'tool',\n          });\n        }\n      }\n\n      return responses;\n    },\n    [toolMap, onToolExecute, onToolComplete, onToolError]\n  );\n\n  // Extract pending tool calls from messages that need client handling\n  const extractPendingToolCalls = useCallback(\n    (messages: ChatMessage[]): ToolCall[] => {\n      const pendingCalls: ToolCall[] = [];\n\n      // Look at the last assistant message\n      for (let i = messages.length - 1; i >= 0; i--) {\n        const message = messages[i];\n\n        if (message.role === 'assistant' && message.tool_calls?.length) {\n          // Filter for client-side tools only\n          const clientToolCalls = message.tool_calls.filter((tc) =>\n            isClientTool(tc.function.name)\n          );\n\n          // Check if these tool calls have been responded to\n          const respondedToolIds = new Set(\n            messages\n              .slice(i + 1)\n              .filter((m) => m.role === 'tool')\n              .map((m) => m.tool_call_id)\n          );\n\n          // Get unresponded tool calls\n          for (const tc of clientToolCalls) {\n            if (!respondedToolIds.has(tc.id)) {\n              pendingCalls.push(tc);\n            }\n          }\n\n          // Only check the most recent assistant message with tool calls\n          break;\n        }\n      }\n\n      return pendingCalls;\n    },\n    [isClientTool]\n  );\n\n  return {\n    toolSchemas,\n    isClientTool,\n    handleToolCalls,\n    extractPendingToolCalls,\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/hooks/usePolling.d.ts

@@ -0,0 +1,64 @@
+import type { RealtimeChatHistory, RealtimeStatus } from '../api/types';
+export interface UsePollingOptions {
+    /**
+     * Polling interval in milliseconds
+     * @default 1000
+     */
+    interval?: number;
+    /**
+     * Whether polling is enabled
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Statuses that should stop polling
+     * @default ['completed', 'error']
+     */
+    stopStatuses?: RealtimeStatus[];
+    /**
+     * Callback when polling stops
+     */
+    onStop?: (data: RealtimeChatHistory | null) => void;
+    /**
+     * Callback on each poll update
+     */
+    onUpdate?: (data: RealtimeChatHistory) => void;
+    /**
+     * Callback on poll error
+     */
+    onError?: (error: Error) => void;
+}
+export interface UsePollingResult {
+    /**
+     * Current polling data
+     */
+    data: RealtimeChatHistory | null;
+    /**
+     * Whether polling is currently active
+     */
+    isPolling: boolean;
+    /**
+     * Last error that occurred
+     */
+    error: Error | null;
+    /**
+     * Start polling
+     */
+    start: () => void;
+    /**
+     * Stop polling
+     */
+    stop: () => void;
+    /**
+     * Manually trigger a fetch
+     */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for polling real-time chat history
+ *
+ * @param chatUid - The chat UID to poll for
+ * @param fetchFn - Function that fetches the realtime history
+ * @param options - Polling options
+ */
+export declare function usePolling(chatUid: string | null, fetchFn: () => Promise<RealtimeChatHistory>, options?: UsePollingOptions): UsePollingResult;