@curaious/uno-converse 0.1.7

package/dist/index.cjs

@@ -0,0 +1,870 @@
+'use strict';
+
+var axios = require('axios');
+var react = require('react');
+
+// Message Roles
+exports.Role = void 0;
+(function (Role) {
+    Role["User"] = "user";
+    Role["Developer"] = "developer";
+    Role["System"] = "system";
+    Role["Assistant"] = "assistant";
+})(exports.Role || (exports.Role = {}));
+// Message Types
+exports.MessageType = void 0;
+(function (MessageType) {
+    MessageType["Message"] = "message";
+    MessageType["FunctionCall"] = "function_call";
+    MessageType["FunctionCallOutput"] = "function_call_output";
+    MessageType["Reasoning"] = "reasoning";
+    MessageType["ImageGenerationCall"] = "image_generation_call";
+    MessageType["FunctionCallApprovalResponse"] = "function_call_approval_response";
+})(exports.MessageType || (exports.MessageType = {}));
+// Content Types
+exports.ContentType = void 0;
+(function (ContentType) {
+    ContentType["InputText"] = "input_text";
+    ContentType["OutputText"] = "output_text";
+    ContentType["SummaryText"] = "summary_text";
+    ContentType["InputImage"] = "input_image";
+})(exports.ContentType || (exports.ContentType = {}));
+// Chunk Types
+exports.ChunkType = void 0;
+(function (ChunkType) {
+    ChunkType["ChunkTypeRunCreated"] = "run.created";
+    ChunkType["ChunkTypeRunInProgress"] = "run.in_progress";
+    ChunkType["ChunkTypeRunPaused"] = "run.paused";
+    ChunkType["ChunkTypeRunCompleted"] = "run.completed";
+    ChunkType["ChunkTypeResponseCreated"] = "response.created";
+    ChunkType["ChunkTypeResponseInProgress"] = "response.in_progress";
+    ChunkType["ChunkTypeResponseCompleted"] = "response.completed";
+    ChunkType["ChunkTypeOutputItemAdded"] = "response.output_item.added";
+    ChunkType["ChunkTypeOutputItemDone"] = "response.output_item.done";
+    ChunkType["ChunkTypeContentPartAdded"] = "response.content_part.added";
+    ChunkType["ChunkTypeContentPartDone"] = "response.content_part.done";
+    ChunkType["ChunkTypeOutputTextDelta"] = "response.output_text.delta";
+    ChunkType["ChunkTypeOutputTextDone"] = "response.output_text.done";
+    ChunkType["ChunkTypeFunctionCallArgumentsDelta"] = "response.function_call_arguments.delta";
+    ChunkType["ChunkTypeFunctionCallArgumentsDone"] = "response.function_call_arguments.done";
+    ChunkType["ChunkTypeReasoningSummaryPartAdded"] = "response.reasoning_summary_part.added";
+    ChunkType["ChunkTypeReasoningSummaryPartDone"] = "response.reasoning_summary_part.done";
+    ChunkType["ChunkTypeReasoningSummaryTextDelta"] = "response.reasoning_summary_text.delta";
+    ChunkType["ChunkTypeReasoningSummaryTextDone"] = "response.reasoning_summary_text.done";
+    // Image generation
+    ChunkType["ChunkTypeImageGenerationCallInProgress"] = "response.image_generation_call.in_progress";
+    ChunkType["ChunkTypeImageGenerationCallGenerating"] = "response.image_generation_call.generating";
+    ChunkType["ChunkTypeImageGenerationCallPartialImage"] = "response.image_generation_call.partial_image";
+    // Extra
+    ChunkType["ChunkTypeFunctionCallOutput"] = "function_call_output";
+})(exports.ChunkType || (exports.ChunkType = {}));
+// Type guards
+function isEasyMessage(msg) {
+    return msg.type === exports.MessageType.Message && 'content' in msg && (typeof msg.content === 'string' || Array.isArray(msg.content));
+}
+function isInputMessage(msg) {
+    return msg.type === exports.MessageType.Message && 'content' in msg && Array.isArray(msg.content);
+}
+function isFunctionCallMessage(msg) {
+    return msg.type === exports.MessageType.FunctionCall;
+}
+function isFunctionCallOutputMessage(msg) {
+    return msg.type === exports.MessageType.FunctionCallOutput;
+}
+function isReasoningMessage(msg) {
+    return msg.type === exports.MessageType.Reasoning;
+}
+function isImageGenerationCallMessage(msg) {
+    return msg.type === exports.MessageType.ImageGenerationCall;
+}
+
+/**
+ * Processes streaming chunks from the LLM response.
+ * Builds up messages incrementally as chunks arrive.
+ *
+ * @example
+ * ```ts
+ * const processor = new ChunkProcessor(
+ *   'conv-123',
+ *   'thread-456',
+ *   (conversation) => {
+ *     // Update UI with new conversation state
+ *     setConversation(conversation);
+ *   }
+ * );
+ *
+ * // Process incoming chunks
+ * processor.processChunk(jsonData);
+ *
+ * // Get final conversation when done
+ * const finalConversation = processor.getConversation();
+ * ```
+ */
+class ChunkProcessor {
+    constructor(conversationId, threadId, onChange) {
+        this.messages = [];
+        this.currentOutputItem = null;
+        this.conversation = {
+            conversation_id: conversationId,
+            thread_id: threadId,
+            message_id: '',
+            messages: [],
+            meta: {},
+        };
+        this._onChange = onChange;
+    }
+    /**
+     * Get all processed messages
+     */
+    getMessages() {
+        return this.messages;
+    }
+    /**
+     * Get the current conversation state
+     */
+    getConversation() {
+        return this.conversation;
+    }
+    emitChange() {
+        this.conversation.messages = [...this.messages];
+        this._onChange({ ...this.conversation });
+    }
+    /**
+     * Process a raw JSON chunk from the SSE stream
+     */
+    processChunk(data) {
+        try {
+            const chunk = JSON.parse(data);
+            this.handleChunk(chunk);
+        }
+        catch (e) {
+            console.error('Failed to parse chunk:', e, data);
+        }
+    }
+    handleChunk(chunk) {
+        switch (chunk.type) {
+            // Run lifecycle
+            case exports.ChunkType.ChunkTypeRunCreated:
+            case exports.ChunkType.ChunkTypeRunInProgress:
+            case exports.ChunkType.ChunkTypeRunCompleted:
+            case exports.ChunkType.ChunkTypeRunPaused:
+                this.conversation.meta.run_state = chunk.run_state;
+                this.conversation.message_id = chunk.run_state.id;
+                if (chunk.type !== exports.ChunkType.ChunkTypeRunCreated && chunk.type !== exports.ChunkType.ChunkTypeRunInProgress) {
+                    this.emitChange();
+                }
+                break;
+            // Response lifecycle
+            case exports.ChunkType.ChunkTypeResponseCreated:
+            case exports.ChunkType.ChunkTypeResponseInProgress:
+                break;
+            case exports.ChunkType.ChunkTypeResponseCompleted:
+                if (chunk.response?.usage) {
+                    this.conversation.meta.usage = chunk.response.usage;
+                    this.emitChange();
+                }
+                break;
+            // Output item lifecycle
+            case exports.ChunkType.ChunkTypeOutputItemAdded:
+                this.handleOutputItemAdded(chunk);
+                break;
+            case exports.ChunkType.ChunkTypeOutputItemDone:
+                break;
+            // Content parts
+            case exports.ChunkType.ChunkTypeContentPartAdded:
+                this.handleContentPartAdded(chunk);
+                break;
+            case exports.ChunkType.ChunkTypeContentPartDone:
+                break;
+            // Text deltas
+            case exports.ChunkType.ChunkTypeOutputTextDelta:
+                this.handleOutputTextDelta(chunk);
+                break;
+            case exports.ChunkType.ChunkTypeOutputTextDone:
+                break;
+            // Reasoning summary
+            case exports.ChunkType.ChunkTypeReasoningSummaryPartAdded:
+                this.handleReasoningSummaryPartAdded(chunk);
+                break;
+            case exports.ChunkType.ChunkTypeReasoningSummaryPartDone:
+                break;
+            case exports.ChunkType.ChunkTypeReasoningSummaryTextDelta:
+                this.handleReasoningSummaryTextDelta(chunk);
+                break;
+            case exports.ChunkType.ChunkTypeReasoningSummaryTextDone:
+                break;
+            // Function calls
+            case exports.ChunkType.ChunkTypeFunctionCallArgumentsDelta:
+                this.handleFunctionCallArgumentsDelta(chunk);
+                break;
+            case exports.ChunkType.ChunkTypeFunctionCallArgumentsDone:
+                break;
+            case exports.ChunkType.ChunkTypeFunctionCallOutput:
+                this.handleFunctionCallOutput(chunk);
+                break;
+            // Image Generation Calls
+            case exports.ChunkType.ChunkTypeImageGenerationCallInProgress:
+                break;
+            case exports.ChunkType.ChunkTypeImageGenerationCallGenerating:
+                break;
+            case exports.ChunkType.ChunkTypeImageGenerationCallPartialImage:
+                this.handleImageGenerationCallPartialImage(chunk);
+                break;
+        }
+    }
+    handleOutputItemAdded(chunk) {
+        if (!chunk.item)
+            return;
+        switch (chunk.item.type) {
+            case "message":
+                this.currentOutputItem = {
+                    id: chunk.item.id,
+                    type: "message",
+                    role: chunk.item.role || "assistant",
+                    content: [],
+                };
+                break;
+            case "function_call":
+                this.currentOutputItem = {
+                    id: chunk.item.id,
+                    type: "function_call",
+                    name: chunk.item.name || "",
+                    call_id: chunk.item.call_id || "",
+                    arguments: "",
+                };
+                break;
+            case "reasoning":
+                this.currentOutputItem = {
+                    id: chunk.item.id,
+                    type: "reasoning",
+                    summary: [],
+                };
+                break;
+            case "image_generation_call":
+                this.currentOutputItem = {
+                    id: chunk.item.id,
+                    type: "image_generation_call",
+                    status: chunk.item.status,
+                };
+                break;
+        }
+        if (this.currentOutputItem) {
+            this.messages.push(this.currentOutputItem);
+            this.emitChange();
+        }
+    }
+    handleContentPartAdded(chunk) {
+        if (!this.currentOutputItem || this.currentOutputItem.type !== "message")
+            return;
+        const message = this.currentOutputItem;
+        if (chunk.part?.type === exports.ContentType.OutputText) {
+            message.content = message.content || [];
+            message.content.push({
+                type: exports.ContentType.OutputText,
+                text: "",
+            });
+            this.emitChange();
+        }
+    }
+    handleOutputTextDelta(chunk) {
+        if (!this.currentOutputItem || this.currentOutputItem.type !== "message")
+            return;
+        const message = this.currentOutputItem;
+        const contents = message.content;
+        if (!contents?.length || !chunk.delta)
+            return;
+        const lastContent = contents[contents.length - 1];
+        if (lastContent && 'text' in lastContent) {
+            lastContent.text += chunk.delta;
+            this.emitChange();
+        }
+    }
+    handleReasoningSummaryPartAdded(chunk) {
+        if (!this.currentOutputItem || this.currentOutputItem.type !== "reasoning")
+            return;
+        const reasoning = this.currentOutputItem;
+        if (chunk.part?.type === exports.ContentType.SummaryText) {
+            reasoning.summary = reasoning.summary || [];
+            reasoning.summary.push({
+                type: exports.ContentType.SummaryText,
+                text: "",
+            });
+            this.emitChange();
+        }
+    }
+    handleReasoningSummaryTextDelta(chunk) {
+        if (!this.currentOutputItem || this.currentOutputItem.type !== "reasoning")
+            return;
+        const reasoning = this.currentOutputItem;
+        const summaries = reasoning.summary;
+        if (!summaries?.length || !chunk.delta)
+            return;
+        const lastSummary = summaries[summaries.length - 1];
+        if (lastSummary) {
+            lastSummary.text += chunk.delta;
+            this.emitChange();
+        }
+    }
+    handleFunctionCallArgumentsDelta(chunk) {
+        if (!this.currentOutputItem || this.currentOutputItem.type !== "function_call")
+            return;
+        const functionCall = this.currentOutputItem;
+        functionCall.arguments += chunk.delta || "";
+        this.emitChange();
+    }
+    handleFunctionCallOutput(chunk) {
+        this.currentOutputItem = chunk;
+        this.messages.push(this.currentOutputItem);
+        this.emitChange();
+    }
+    handleImageGenerationCallPartialImage(chunk) {
+        if (!this.currentOutputItem || this.currentOutputItem.type !== "image_generation_call")
+            return;
+        const image = this.currentOutputItem;
+        image.result = chunk.partial_image_b64;
+        image.quality = chunk.quality;
+        image.size = chunk.size;
+        image.output_format = chunk.output_format;
+        image.background = chunk.background;
+        this.emitChange();
+    }
+}
+
+/**
+ * Streams Server-Sent Events (SSE) from a URL.
+ * Parses SSE frames and calls onChunk for each data payload.
+ *
+ * @param url - The URL to stream from
+ * @param requestOptions - Fetch request options
+ * @param callbacks - SSE event callbacks
+ * @param abortSignal - Optional signal to abort the stream
+ *
+ * @example
+ * ```ts
+ * await streamSSE(
+ *   'https://api.example.com/stream',
+ *   { method: 'POST', body: JSON.stringify({ message: 'Hello' }) },
+ *   {
+ *     onChunk: (data) => console.log('Received:', data),
+ *     onComplete: () => console.log('Done'),
+ *     onError: (err) => console.error('Error:', err),
+ *   }
+ * );
+ * ```
+ */
+async function streamSSE(url, requestOptions, callbacks, abortSignal) {
+    try {
+        const response = await fetch(url, {
+            ...requestOptions,
+            signal: abortSignal,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        if (!response.body) {
+            throw new Error('Response body is null');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            // Parse SSE frames: split on double newline
+            let idx;
+            while ((idx = buffer.indexOf('\n\n')) !== -1) {
+                const frame = buffer.slice(0, idx);
+                buffer = buffer.slice(idx + 2);
+                // Join all data: lines in the frame
+                const data = frame
+                    .split('\n')
+                    .filter(line => line.startsWith('data:'))
+                    .map(line => line.slice(5).trim())
+                    .join('\n');
+                if (data) {
+                    callbacks.onChunk(data);
+                }
+            }
+        }
+        // Final flush of decoder state
+        decoder.decode();
+        callbacks.onComplete?.();
+    }
+    catch (error) {
+        if (error.name === 'AbortError') {
+            return;
+        }
+        callbacks.onError?.(error);
+    }
+}
+
+/**
+ * Simple ID generator for message IDs
+ */
+function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+/**
+ * A comprehensive hook for managing conversations, threads, messages, and streaming
+ * with Uno Agent Server.
+ *
+ * @example
+ * ```tsx
+ * import { useConversation } from '@praveen001/uno-converse';
+ *
+ * function ChatComponent() {
+ *   const {
+ *     allMessages,
+ *     isStreaming,
+ *     sendMessage,
+ *     startNewChat,
+ *   } = useConversation({
+ *     namespace: 'my-app',
+ *     projectName: 'my-project',
+ *     baseUrl: 'https://my-uno-server.com/api/agent-server',
+ *     getHeaders: () => ({
+ *       'Authorization': `Bearer ${getToken()}`,
+ *     }),
+ *   });
+ *
+ *   const handleSend = async (text: string) => {
+ *     await sendMessage(
+ *       [{ type: 'message', id: '1', content: text }],
+ *       {
+ *         namespace: 'my-app',
+ *         agentName: 'my-agent',
+ *       }
+ *     );
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {allMessages.map(msg => (
+ *         <MessageComponent key={msg.message_id} message={msg} />
+ *       ))}
+ *       {isStreaming && <LoadingIndicator />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+function useConversation(options) {
+    const { namespace, projectName, baseUrl, getHeaders, autoLoad = true } = options;
+    // Create axios instance with request interceptor for custom headers
+    const axiosInstance = react.useMemo(() => {
+        const instance = axios.create({
+            baseURL: baseUrl,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        // Add request interceptor to inject custom headers
+        if (getHeaders) {
+            instance.interceptors.request.use(async (config) => {
+                const customHeaders = await getHeaders();
+                Object.assign(config.headers, customHeaders);
+                return config;
+            });
+        }
+        return instance;
+    }, [baseUrl, getHeaders]);
+    // Project state
+    const [projectId, setProjectId] = react.useState('');
+    const [projectLoading, setProjectLoading] = react.useState(false);
+    // Conversation list state
+    const [conversations, setConversations] = react.useState([]);
+    const [conversationsLoading, setConversationsLoading] = react.useState(false);
+    // Thread state
+    const [threads, setThreads] = react.useState([]);
+    const [threadsLoading, setThreadsLoading] = react.useState(false);
+    // Message state
+    const [messages, setMessages] = react.useState([]);
+    const [streamingMessage, setStreamingMessage] = react.useState(null);
+    const [messagesLoading, setMessagesLoading] = react.useState(false);
+    const [isStreaming, setIsStreaming] = react.useState(false);
+    const [isThinking, setIsThinking] = react.useState(false);
+    // Current selection
+    const [currentConversationId, setCurrentConversationId] = react.useState(null);
+    const [currentThreadId, setCurrentThreadId] = react.useState(null);
+    const [previousMessageId, setPreviousMessageId] = react.useState('');
+    // Refs
+    const processorRef = react.useRef(null);
+    const abortControllerRef = react.useRef(null);
+    // ============================================
+    // API Helper Functions
+    // ============================================
+    /**
+     * Build query params with project_id if available
+     */
+    const buildParams = react.useCallback((params) => {
+        const result = {};
+        if (projectId) {
+            result.project_id = projectId;
+        }
+        if (params) {
+            Object.assign(result, params);
+        }
+        return result;
+    }, [projectId]);
+    /**
+     * Get headers for streaming requests (combines default + custom headers)
+     */
+    const getRequestHeaders = react.useCallback(async () => {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        // Add custom headers if getHeaders function is provided
+        if (getHeaders) {
+            const customHeaders = await getHeaders();
+            Object.assign(headers, customHeaders);
+        }
+        return headers;
+    }, [getHeaders]);
+    // ============================================
+    // Project Management
+    // ============================================
+    /**
+     * Fetch the project ID using the project name
+     */
+    const fetchProjectId = react.useCallback(async () => {
+        if (!projectName) {
+            return;
+        }
+        setProjectLoading(true);
+        try {
+            const response = await axiosInstance.get('/project/id', {
+                params: { name: projectName },
+            });
+            const id = typeof response.data === 'string' ? response.data : response.data.data;
+            setProjectId(id || '');
+        }
+        catch (error) {
+            console.error('Failed to fetch project ID:', error);
+            throw error;
+        }
+        finally {
+            setProjectLoading(false);
+        }
+    }, [axiosInstance, projectName]);
+    // ============================================
+    // Conversation Management
+    // ============================================
+    /**
+     * Load all conversations for the namespace
+     */
+    const loadConversations = react.useCallback(async () => {
+        setConversationsLoading(true);
+        try {
+            const response = await axiosInstance.get('/conversations', {
+                params: buildParams({ namespace }),
+            });
+            const data = 'data' in response.data ? response.data.data : response.data;
+            setConversations(data || []);
+        }
+        catch (error) {
+            console.error('Failed to load conversations:', error);
+            throw error;
+        }
+        finally {
+            setConversationsLoading(false);
+        }
+    }, [axiosInstance, buildParams, namespace]);
+    /**
+     * Select a conversation and load its threads
+     */
+    const selectConversation = react.useCallback((conversationId) => {
+        setCurrentConversationId(conversationId);
+        // Threads will be loaded via useEffect
+    }, []);
+    // ============================================
+    // Thread Management
+    // ============================================
+    /**
+     * Load threads for a conversation
+     */
+    const loadThreads = react.useCallback(async (conversationId) => {
+        setThreadsLoading(true);
+        try {
+            const response = await axiosInstance.get('/threads', {
+                params: buildParams({ conversation_id: conversationId, namespace }),
+            });
+            const loadedThreads = 'data' in response.data ? response.data.data : response.data;
+            // Sort by created_at descending
+            loadedThreads.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+            setThreads(loadedThreads);
+            // Auto-select the latest thread
+            if (loadedThreads.length > 0) {
+                setCurrentThreadId(loadedThreads[0].thread_id);
+            }
+        }
+        catch (error) {
+            console.error('Failed to load threads:', error);
+            throw error;
+        }
+        finally {
+            setThreadsLoading(false);
+        }
+    }, [axiosInstance, buildParams, namespace]);
+    /**
+     * Select a thread and load its messages
+     */
+    const selectThread = react.useCallback((threadId) => {
+        setCurrentThreadId(threadId);
+        // Messages will be loaded via useEffect
+    }, []);
+    // ============================================
+    // Message Management
+    // ============================================
+    /**
+     * Load messages for a thread
+     */
+    const loadMessages = react.useCallback(async (threadId) => {
+        setMessagesLoading(true);
+        try {
+            const response = await axiosInstance.get('/messages', {
+                params: buildParams({ thread_id: threadId, namespace }),
+            });
+            const loadedMessages = 'data' in response.data ? response.data.data : response.data;
+            // Extract last message ID for continuation
+            if (loadedMessages.length > 0) {
+                const lastMsgId = loadedMessages[loadedMessages.length - 1].message_id;
+                setPreviousMessageId(lastMsgId);
+            }
+            else {
+                setPreviousMessageId('');
+            }
+            setMessages(loadedMessages);
+        }
+        catch (error) {
+            console.error('Failed to load messages:', error);
+            throw error;
+        }
+        finally {
+            setMessagesLoading(false);
+        }
+    }, [axiosInstance, buildParams, namespace]);
+    /**
+     * Send a user message and stream the response
+     */
+    const sendMessage = react.useCallback(async (userMessages, config) => {
+        const messageId = generateId();
+        // Check if this is a tool approval response (resuming a run)
+        const isToolApproval = userMessages.length === 1 &&
+            userMessages[0].type === exports.MessageType.FunctionCallApprovalResponse;
+        // Only add user message for regular messages, not for tool approvals
+        if (!isToolApproval) {
+            const userConversation = {
+                conversation_id: currentConversationId || '',
+                thread_id: currentThreadId || '',
+                message_id: messageId + '-user',
+                messages: userMessages,
+                meta: {},
+            };
+            setMessages(prev => [...prev, userConversation]);
+        }
+        // Initialize the chunk processor for the assistant response
+        processorRef.current = new ChunkProcessor(currentConversationId || '', currentThreadId || '', (conversation) => {
+            setIsThinking(isThinking);
+            setStreamingMessage({ ...conversation, isStreaming: true });
+        });
+        setIsStreaming(true);
+        setIsThinking(true);
+        // Build URL with query parameters
+        const params = new URLSearchParams();
+        if (projectId) {
+            params.append('project_id', projectId);
+        }
+        params.append('agent_name', config.agentName);
+        let url = `${baseUrl}/converse?${params.toString()}`;
+        if (!!config.baseUrl) {
+            url = config.baseUrl;
+        }
+        // Prepare request body
+        const body = JSON.stringify({
+            namespace: config.namespace,
+            previous_message_id: previousMessageId,
+            message: userMessages[0],
+            context: config.context || {},
+        });
+        // Abort any existing stream
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+        }
+        abortControllerRef.current = new AbortController();
+        try {
+            // Get headers (supports async getHeaders function)
+            const requestHeaders = await getRequestHeaders();
+            await streamSSE(url, {
+                method: 'POST',
+                body,
+                headers: {
+                    ...requestHeaders,
+                    ...(config.headers || {}),
+                },
+            }, {
+                onChunk: (data) => {
+                    processorRef.current?.processChunk(data);
+                },
+                onComplete: () => {
+                    // Move streaming message to messages list
+                    if (processorRef.current) {
+                        const finalConversation = processorRef.current.getConversation();
+                        if (isToolApproval) {
+                            // For tool approvals, update the last message instead of appending
+                            setMessages(prev => {
+                                const newMessages = [...prev];
+                                if (newMessages.length > 0) {
+                                    const lastMsg = newMessages[newMessages.length - 1];
+                                    newMessages[newMessages.length - 1] = {
+                                        ...lastMsg,
+                                        messages: [...lastMsg.messages, ...finalConversation.messages],
+                                        meta: finalConversation.meta,
+                                        isStreaming: false,
+                                    };
+                                }
+                                return newMessages;
+                            });
+                        }
+                        else {
+                            setMessages(prev => [...prev, { ...finalConversation, isStreaming: false }]);
+                        }
+                        setStreamingMessage(null);
+                        setPreviousMessageId(finalConversation.message_id);
+                    }
+                },
+                onError: (error) => {
+                    console.error('Streaming error:', error);
+                    setStreamingMessage(null);
+                },
+            }, abortControllerRef.current.signal);
+            // If this was a new conversation, fetch the conversation info
+            if (previousMessageId === '' && processorRef.current) {
+                try {
+                    const response = await axiosInstance.get(`/messages/${processorRef.current.getConversation().message_id}`, { params: buildParams({ namespace }) });
+                    const messageData = 'data' in response.data ? response.data.data : response.data;
+                    const newConversationId = messageData?.conversation_id;
+                    if (newConversationId) {
+                        // Add new conversation to list
+                        setConversations(prev => [{
+                                conversation_id: newConversationId,
+                                name: "New Conversation",
+                                namespace_id: namespace,
+                                created_at: new Date().toISOString(),
+                                last_updated: new Date().toISOString(),
+                            }, ...prev.filter(c => c.conversation_id !== newConversationId)]);
+                        setCurrentConversationId(newConversationId);
+                    }
+                }
+                catch (e) {
+                    console.error('Failed to get conversation ID:', e);
+                }
+            }
+        }
+        finally {
+            setIsStreaming(false);
+            abortControllerRef.current = null;
+        }
+    }, [currentConversationId, currentThreadId, previousMessageId, namespace, baseUrl, projectId, axiosInstance, buildParams, getRequestHeaders]);
+    // ============================================
+    // Utility Actions
+    // ============================================
+    /**
+     * Start a new chat (reset all state)
+     */
+    const startNewChat = react.useCallback(() => {
+        // Abort any ongoing stream
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+            abortControllerRef.current = null;
+        }
+        setCurrentConversationId(null);
+        setCurrentThreadId(null);
+        setThreads([]);
+        setMessages([]);
+        setStreamingMessage(null);
+        setPreviousMessageId('');
+        setIsStreaming(false);
+        setIsThinking(false);
+        processorRef.current = null;
+    }, []);
+    // ============================================
+    // Effects for auto-loading
+    // ============================================
+    // Fetch project ID on mount
+    react.useEffect(() => {
+        if (autoLoad && projectName) {
+            fetchProjectId();
+        }
+    }, [autoLoad, projectName, fetchProjectId]);
+    // Load conversations after project ID is fetched
+    react.useEffect(() => {
+        if (autoLoad && projectId) {
+            loadConversations();
+        }
+    }, [autoLoad, projectId, loadConversations]);
+    // Load threads when conversation changes
+    react.useEffect(() => {
+        if (currentConversationId) {
+            loadThreads(currentConversationId);
+        }
+    }, [currentConversationId, loadThreads]);
+    // Load messages when thread changes
+    react.useEffect(() => {
+        if (currentThreadId) {
+            loadMessages(currentThreadId);
+        }
+    }, [currentThreadId, loadMessages]);
+    // ============================================
+    // Computed values
+    // ============================================
+    const currentThread = threads.find(t => t.thread_id === currentThreadId) || null;
+    const allMessages = streamingMessage
+        ? [...messages, streamingMessage]
+        : messages;
+    return {
+        // Project state
+        projectId,
+        projectLoading,
+        // Conversation list state
+        conversations,
+        conversationsLoading,
+        // Thread state
+        threads,
+        threadsLoading,
+        currentThread,
+        // Message state
+        messages,
+        streamingMessage,
+        messagesLoading,
+        isStreaming,
+        isThinking,
+        // Current selection
+        currentConversationId,
+        currentThreadId,
+        // Actions - Conversations
+        loadConversations,
+        selectConversation,
+        // Actions - Threads
+        loadThreads,
+        selectThread,
+        // Actions - Messages
+        sendMessage,
+        // Actions - Utility
+        startNewChat,
+        // Combined messages
+        allMessages,
+    };
+}
+
+exports.ChunkProcessor = ChunkProcessor;
+exports.isEasyMessage = isEasyMessage;
+exports.isFunctionCallMessage = isFunctionCallMessage;
+exports.isFunctionCallOutputMessage = isFunctionCallOutputMessage;
+exports.isImageGenerationCallMessage = isImageGenerationCallMessage;
+exports.isInputMessage = isInputMessage;
+exports.isReasoningMessage = isReasoningMessage;
+exports.streamSSE = streamSSE;
+exports.useConversation = useConversation;
+//# sourceMappingURL=index.cjs.map