@tambo-ai/client 0.0.1

package/dist/utils/event-accumulator.js

@@ -0,0 +1,1278 @@
+"use strict";
+/**
+ * Event Accumulation Logic for Streaming API
+ *
+ * Implements a reducer that transforms AG-UI event streams into React state.
+ * Used with useReducer to accumulate events into thread state.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLACEHOLDER_THREAD_ID = exports.UnreachableCaseError = void 0;
+exports.createInitialThreadState = createInitialThreadState;
+exports.isPlaceholderThreadId = isPlaceholderThreadId;
+exports.createInitialState = createInitialState;
+exports.createInitialStateWithMessages = createInitialStateWithMessages;
+exports.streamReducer = streamReducer;
+const core_1 = require("@ag-ui/core");
+const event_1 = require("../types/event");
+const partial_json_1 = require("partial-json");
+const json_patch_1 = require("./json-patch");
+const unstrictify_1 = require("./unstrictify");
+/**
+ * Error thrown when an unreachable case is reached in a switch statement.
+ * This indicates a programming error where not all cases were handled.
+ */
+class UnreachableCaseError extends Error {
+    constructor(value) {
+        super(`Unreachable case: ${JSON.stringify(value)}`);
+        this.name = "UnreachableCaseError";
+    }
+}
+exports.UnreachableCaseError = UnreachableCaseError;
+/**
+ * Initial streaming state.
+ */
+const initialStreamingState = {
+    status: "idle",
+};
+/**
+ * Create initial thread state for a new thread.
+ * @param threadId - Unique thread identifier
+ * @returns Initial thread state
+ */
+function createInitialThreadState(threadId) {
+    const now = new Date().toISOString();
+    return {
+        thread: {
+            id: threadId,
+            messages: [],
+            status: "idle",
+            createdAt: now,
+            updatedAt: now,
+            lastRunCancelled: false,
+        },
+        streaming: initialStreamingState,
+        accumulatingToolArgs: {},
+    };
+}
+/**
+ * Placeholder thread ID used for new threads before they get a real ID from the server.
+ * This allows optimistic UI updates (showing user messages immediately) before the
+ * server responds with the actual thread ID.
+ */
+exports.PLACEHOLDER_THREAD_ID = "placeholder";
+/**
+ * Check if a thread ID is a placeholder (not a real API thread ID).
+ * @param threadId - Thread ID to check
+ * @returns True if this is a placeholder thread ID
+ */
+function isPlaceholderThreadId(threadId) {
+    return threadId === exports.PLACEHOLDER_THREAD_ID;
+}
+/**
+ * Create initial stream state with placeholder thread.
+ * @returns Initial stream state
+ */
+function createInitialState() {
+    return {
+        threadMap: {
+            [exports.PLACEHOLDER_THREAD_ID]: createInitialThreadState(exports.PLACEHOLDER_THREAD_ID),
+        },
+        currentThreadId: exports.PLACEHOLDER_THREAD_ID,
+    };
+}
+/**
+ * Create initial stream state with placeholder thread seeded with initial messages.
+ * The messages are converted from InputMessage format to TamboThreadMessage format
+ * for immediate UI display before any API call.
+ * @param initialMessages - Messages to seed the placeholder thread with
+ * @returns Initial stream state with messages in the placeholder thread
+ */
+function createInitialStateWithMessages(initialMessages) {
+    const placeholderState = createInitialThreadState(exports.PLACEHOLDER_THREAD_ID);
+    const messages = initialMessages.map((msg) => ({
+        id: `initial_${crypto.randomUUID()}`,
+        role: msg.role,
+        content: msg.content.map((c) => {
+            if (c.type === "text") {
+                return { type: "text", text: c.text };
+            }
+            return c;
+        }),
+    }));
+    return {
+        threadMap: {
+            [exports.PLACEHOLDER_THREAD_ID]: {
+                ...placeholderState,
+                thread: {
+                    ...placeholderState.thread,
+                    messages,
+                },
+            },
+        },
+        currentThreadId: exports.PLACEHOLDER_THREAD_ID,
+    };
+}
+/**
+ * Replace a message at a specific index immutably.
+ * @param messages - Current messages array
+ * @param index - Index of message to replace
+ * @param updatedMessage - New message to insert
+ * @returns New messages array with the message replaced
+ */
+function updateMessageAtIndex(messages, index, updatedMessage) {
+    return [
+        ...messages.slice(0, index),
+        updatedMessage,
+        ...messages.slice(index + 1),
+    ];
+}
+/**
+ * Replace a content block at a specific index within a message's content immutably.
+ * @param content - Current content array
+ * @param index - Index of content to replace
+ * @param updatedContent - New content to insert
+ * @returns New content array with the content replaced
+ */
+function updateContentAtIndex(content, index, updatedContent) {
+    return [
+        ...content.slice(0, index),
+        updatedContent,
+        ...content.slice(index + 1),
+    ];
+}
+/**
+ * Find a content block by ID across all messages, searching from most recent.
+ *
+ * TODO: This is O(n*m) where n = messages and m = content blocks per message.
+ * For high-frequency streaming with many messages, consider maintaining an
+ * index map of contentId -> {messageIndex, contentIndex} that gets updated
+ * when content blocks are created.
+ * @param messages - Messages to search
+ * @param contentType - Type of content to find ("component" or "tool_use")
+ * @param contentId - ID of the content block
+ * @param eventName - Name of the event (for error messages)
+ * @returns Location of the content block
+ * @throws {Error} If content not found
+ */
+function findContentById(messages, contentType, contentId, eventName) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const idx = messages[i].content.findIndex((c) => c.type === contentType && c.id === contentId);
+        if (idx !== -1) {
+            return { messageIndex: i, contentIndex: idx };
+        }
+    }
+    throw new Error(`${contentType} ${contentId} not found for ${eventName}`);
+}
+/**
+ * Create updated thread state with new messages.
+ * @param threadState - Current thread state
+ * @param messages - New messages array
+ * @returns Updated thread state
+ */
+function updateThreadMessages(threadState, messages) {
+    return {
+        ...threadState,
+        thread: {
+            ...threadState.thread,
+            messages,
+            updatedAt: new Date().toISOString(),
+        },
+    };
+}
+/**
+ * Stream reducer that accumulates events into thread state.
+ *
+ * This reducer handles all AG-UI events and Tambo custom events,
+ * transforming them into immutable state updates per thread.
+ * @param state - Current stream state
+ * @param action - Action to process
+ * @returns Updated stream state
+ */
+function streamReducer(state, action) {
+    // Handle non-event actions first
+    switch (action.type) {
+        case "INIT_THREAD": {
+            const { threadId, initialThread } = action;
+            // Don't overwrite existing thread
+            if (state.threadMap[threadId]) {
+                return state;
+            }
+            const baseState = createInitialThreadState(threadId);
+            const threadState = initialThread
+                ? {
+                    ...baseState,
+                    thread: {
+                        ...baseState.thread,
+                        ...initialThread,
+                        id: threadId,
+                    },
+                }
+                : baseState;
+            return {
+                ...state,
+                threadMap: {
+                    ...state.threadMap,
+                    [threadId]: threadState,
+                },
+            };
+        }
+        case "SET_CURRENT_THREAD": {
+            return {
+                ...state,
+                currentThreadId: action.threadId,
+            };
+        }
+        case "START_NEW_THREAD": {
+            // Atomic action: initialize thread AND set as current in one reducer pass.
+            // Always overwrites any existing thread state for this ID — the whole
+            // point of START_NEW_THREAD is to reset and start fresh (e.g. the
+            // placeholder thread must be wiped clean on every new conversation).
+            const { threadId, initialThread } = action;
+            const baseState = createInitialThreadState(threadId);
+            const threadState = initialThread
+                ? {
+                    ...baseState,
+                    thread: {
+                        ...baseState.thread,
+                        ...initialThread,
+                        id: threadId,
+                    },
+                }
+                : baseState;
+            return {
+                ...state,
+                threadMap: {
+                    ...state.threadMap,
+                    [threadId]: threadState,
+                },
+                currentThreadId: threadId,
+            };
+        }
+        case "LOAD_THREAD_MESSAGES": {
+            return handleLoadThreadMessages(state, action);
+        }
+        case "SET_LAST_COMPLETED_RUN_ID": {
+            const threadState = state.threadMap[action.threadId] ??
+                createInitialThreadState(action.threadId);
+            return {
+                ...state,
+                threadMap: {
+                    ...state.threadMap,
+                    [action.threadId]: {
+                        ...threadState,
+                        lastCompletedRunId: action.lastCompletedRunId,
+                    },
+                },
+            };
+        }
+        case "UPDATE_THREAD_NAME": {
+            const threadState = state.threadMap[action.threadId];
+            if (!threadState) {
+                return state;
+            }
+            return {
+                ...state,
+                threadMap: {
+                    ...state.threadMap,
+                    [action.threadId]: {
+                        ...threadState,
+                        thread: {
+                            ...threadState.thread,
+                            name: action.name,
+                        },
+                    },
+                },
+            };
+        }
+        case "EVENT":
+            // Fall through to event handling below
+            break;
+    }
+    // Handle EVENT action
+    const { event, threadId } = action;
+    const effectiveThreadId = event.type === core_1.EventType.RUN_STARTED ? event.threadId : threadId;
+    // Get the current thread state, auto-initializing if needed
+    // Auto-initialization handles the case where events arrive before explicit thread init
+    // (e.g., when creating a new thread and RUN_STARTED is the first event)
+    let threadState = state.threadMap[effectiveThreadId];
+    let updatedState = state;
+    if (!threadState) {
+        // Auto-initialize the thread to avoid dropping events
+        threadState = createInitialThreadState(effectiveThreadId);
+        updatedState = {
+            ...state,
+            threadMap: {
+                ...state.threadMap,
+                [effectiveThreadId]: threadState,
+            },
+        };
+    }
+    // Handle placeholder thread migration for RUN_STARTED events
+    // When a new thread is created, messages may have been added to the placeholder thread
+    // for immediate UI feedback. Now that we have the real threadId, migrate those messages.
+    if (event.type === core_1.EventType.RUN_STARTED &&
+        effectiveThreadId !== exports.PLACEHOLDER_THREAD_ID) {
+        const placeholderState = updatedState.threadMap[exports.PLACEHOLDER_THREAD_ID];
+        if (placeholderState?.thread.messages.length) {
+            // Prepend placeholder thread messages to the real thread
+            threadState = {
+                ...threadState,
+                thread: {
+                    ...threadState.thread,
+                    messages: [
+                        ...placeholderState.thread.messages,
+                        ...threadState.thread.messages,
+                    ],
+                },
+            };
+            // Reset placeholder thread to empty state
+            const resetPlaceholder = createInitialThreadState(exports.PLACEHOLDER_THREAD_ID);
+            updatedState = {
+                ...updatedState,
+                threadMap: {
+                    ...updatedState.threadMap,
+                    [exports.PLACEHOLDER_THREAD_ID]: resetPlaceholder,
+                    [effectiveThreadId]: threadState,
+                },
+                // Only switch selection if the user is currently on the placeholder thread
+                currentThreadId: isPlaceholderThreadId(updatedState.currentThreadId)
+                    ? effectiveThreadId
+                    : updatedState.currentThreadId,
+            };
+        }
+    }
+    // Process the event for this specific thread
+    let updatedThreadState;
+    // Switch on event.type - AGUIEvent is a discriminated union so TypeScript
+    // automatically narrows the type in each case branch
+    switch (event.type) {
+        case core_1.EventType.RUN_STARTED:
+            updatedThreadState = handleRunStarted(threadState, event);
+            break;
+        case core_1.EventType.RUN_FINISHED:
+            updatedThreadState = handleRunFinished(threadState, event);
+            break;
+        case core_1.EventType.RUN_ERROR:
+            updatedThreadState = handleRunError(threadState, event);
+            break;
+        case core_1.EventType.TEXT_MESSAGE_START:
+            updatedThreadState = handleTextMessageStart(threadState, event);
+            break;
+        case core_1.EventType.TEXT_MESSAGE_CONTENT:
+            updatedThreadState = handleTextMessageContent(threadState, event);
+            break;
+        case core_1.EventType.TEXT_MESSAGE_END:
+            updatedThreadState = handleTextMessageEnd(threadState, event);
+            break;
+        case core_1.EventType.TOOL_CALL_START:
+            updatedThreadState = handleToolCallStart(threadState, event);
+            break;
+        case core_1.EventType.TOOL_CALL_ARGS:
+            updatedThreadState = handleToolCallArgs(threadState, event, action.parsedToolArgs, action.toolSchemas);
+            break;
+        case core_1.EventType.TOOL_CALL_END:
+            updatedThreadState = handleToolCallEnd(threadState, event, action.toolSchemas);
+            break;
+        case core_1.EventType.TOOL_CALL_RESULT:
+            updatedThreadState = handleToolCallResult(threadState, event);
+            break;
+        case core_1.EventType.CUSTOM:
+            updatedThreadState = handleCustomEvent(threadState, event);
+            break;
+        case core_1.EventType.THINKING_TEXT_MESSAGE_START:
+            updatedThreadState = handleThinkingTextMessageStart(threadState, event);
+            break;
+        case core_1.EventType.THINKING_TEXT_MESSAGE_CONTENT:
+            updatedThreadState = handleThinkingTextMessageContent(threadState, event);
+            break;
+        case core_1.EventType.THINKING_TEXT_MESSAGE_END:
+            updatedThreadState = handleThinkingTextMessageEnd(threadState, event);
+            break;
+        // Unsupported AG-UI event types - may be added in future phases
+        case core_1.EventType.TEXT_MESSAGE_CHUNK:
+        case core_1.EventType.TOOL_CALL_CHUNK:
+        case core_1.EventType.THINKING_START:
+        case core_1.EventType.THINKING_END:
+        case core_1.EventType.STATE_SNAPSHOT:
+        case core_1.EventType.STATE_DELTA:
+        case core_1.EventType.MESSAGES_SNAPSHOT:
+        case core_1.EventType.ACTIVITY_SNAPSHOT:
+        case core_1.EventType.ACTIVITY_DELTA:
+        case core_1.EventType.RAW:
+        case core_1.EventType.STEP_STARTED:
+        case core_1.EventType.STEP_FINISHED:
+            // Log warning - these events are being ignored
+            console.warn(`[StreamReducer] Received unsupported event type: ${event.type}. ` +
+                `This event will be ignored.`);
+            return updatedState;
+        default: {
+            // Exhaustiveness check: if a new event type is added to AGUIEvent
+            // and not handled above, TypeScript will error here
+            const _exhaustiveCheck = event;
+            throw new UnreachableCaseError(_exhaustiveCheck);
+        }
+    }
+    // Return updated state with modified thread
+    return {
+        ...updatedState,
+        threadMap: {
+            ...updatedState.threadMap,
+            [effectiveThreadId]: updatedThreadState,
+        },
+    };
+}
+/**
+ * Handle RUN_STARTED event.
+ * @param threadState - Current thread state
+ * @param event - Run started event
+ * @returns Updated thread state
+ */
+function handleRunStarted(threadState, event) {
+    return {
+        ...threadState,
+        thread: {
+            ...threadState.thread,
+            status: "streaming",
+            updatedAt: new Date().toISOString(),
+            // Reset lastRunCancelled when a new run starts
+            lastRunCancelled: false,
+        },
+        streaming: {
+            status: "streaming",
+            runId: event.runId,
+            startTime: event.timestamp ?? Date.now(),
+        },
+    };
+}
+/**
+ * Handle RUN_FINISHED event.
+ * @param threadState - Current thread state
+ * @param event - Run finished event containing the completed run's ID
+ * @returns Updated thread state
+ */
+function handleRunFinished(threadState, event) {
+    return {
+        ...threadState,
+        lastCompletedRunId: event.runId ??
+            threadState.streaming.runId ??
+            threadState.lastCompletedRunId,
+        thread: {
+            ...threadState.thread,
+            status: "idle",
+            updatedAt: new Date().toISOString(),
+        },
+        streaming: {
+            ...threadState.streaming,
+            status: "idle",
+        },
+    };
+}
+/**
+ * Handle RUN_ERROR event.
+ * Sets lastRunCancelled if the error code is "CANCELLED".
+ * @param threadState - Current thread state
+ * @param event - Run error event
+ * @returns Updated thread state
+ */
+function handleRunError(threadState, event) {
+    const isCancelled = event.code === "CANCELLED";
+    return {
+        ...threadState,
+        thread: {
+            ...threadState.thread,
+            status: "idle",
+            updatedAt: new Date().toISOString(),
+            lastRunCancelled: isCancelled,
+        },
+        streaming: {
+            ...threadState.streaming,
+            status: "idle",
+            error: isCancelled
+                ? undefined
+                : {
+                    message: event.message,
+                    code: event.code,
+                },
+        },
+    };
+}
+/**
+ * Handle TEXT_MESSAGE_START event.
+ * Creates a new message or reuses an ephemeral reasoning message.
+ * @param threadState - Current thread state
+ * @param event - Text message start event
+ * @returns Updated thread state
+ */
+function handleTextMessageStart(threadState, event) {
+    const isAssistant = event.role !== "user";
+    const messages = threadState.thread.messages;
+    // For assistant messages, check if there's an ephemeral message with reasoning
+    // that we should merge into instead of creating a new message.
+    if (isAssistant) {
+        const ephemeralIndex = messages.findIndex((m) => m.role === "assistant" &&
+            m.id.startsWith("ephemeral_") &&
+            m.reasoning &&
+            m.reasoning.length > 0);
+        if (ephemeralIndex !== -1) {
+            // Update the ephemeral message with the real ID
+            const ephemeralMessage = messages[ephemeralIndex];
+            const updatedMessages = [...messages];
+            updatedMessages[ephemeralIndex] = {
+                ...ephemeralMessage,
+                id: event.messageId,
+            };
+            return {
+                ...threadState,
+                thread: {
+                    ...threadState.thread,
+                    messages: updatedMessages,
+                    updatedAt: new Date().toISOString(),
+                },
+                streaming: {
+                    ...threadState.streaming,
+                    messageId: event.messageId,
+                },
+            };
+        }
+    }
+    // Check if a message with this ID already exists (e.g., created by
+    // handleMessageParent). If so, just update streaming state to track it.
+    const existingIndex = messages.findIndex((m) => m.id === event.messageId);
+    if (existingIndex !== -1) {
+        return {
+            ...threadState,
+            thread: {
+                ...threadState.thread,
+                updatedAt: new Date().toISOString(),
+            },
+            streaming: {
+                ...threadState.streaming,
+                messageId: event.messageId,
+            },
+        };
+    }
+    // No existing message to reuse - create a new message
+    const newMessage = {
+        id: event.messageId,
+        role: isAssistant ? "assistant" : "user",
+        content: [],
+        createdAt: new Date().toISOString(),
+    };
+    return {
+        ...threadState,
+        thread: {
+            ...threadState.thread,
+            messages: [...messages, newMessage],
+            updatedAt: new Date().toISOString(),
+        },
+        streaming: {
+            ...threadState.streaming,
+            messageId: event.messageId,
+        },
+    };
+}
+/**
+ * Handle TEXT_MESSAGE_CONTENT event.
+ * Appends text content to the current message.
+ * @param threadState - Current thread state
+ * @param event - Text message content event
+ * @returns Updated thread state
+ */
+function handleTextMessageContent(threadState, event) {
+    const messageId = event.messageId;
+    const messages = threadState.thread.messages;
+    // Find the message to update
+    const messageIndex = messages.findIndex((m) => m.id === messageId);
+    if (messageIndex === -1) {
+        throw new Error(`Message ${messageId} not found for TEXT_MESSAGE_CONTENT event`);
+    }
+    const message = messages[messageIndex];
+    const content = message.content;
+    // Find or create text content block
+    const lastContent = content[content.length - 1];
+    const isTextBlock = lastContent?.type === "text";
+    const updatedContent = isTextBlock
+        ? [
+            ...content.slice(0, -1),
+            {
+                ...lastContent,
+                text: lastContent.text + event.delta,
+            },
+        ]
+        : [
+            ...content,
+            {
+                type: "text",
+                text: event.delta,
+            },
+        ];
+    const updatedMessage = {
+        ...message,
+        content: updatedContent,
+    };
+    return updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage));
+}
+/**
+ * Handle TEXT_MESSAGE_END event.
+ * Marks the message as complete.
+ * @param threadState - Current thread state
+ * @param event - Text message end event
+ * @returns Updated thread state
+ */
+function handleTextMessageEnd(threadState, event) {
+    const activeMessageId = threadState.streaming.messageId;
+    if (activeMessageId && event.messageId !== activeMessageId) {
+        throw new Error(`TEXT_MESSAGE_END messageId mismatch (thread ${threadState.thread.id}): expected ${activeMessageId}, got ${event.messageId}`);
+    }
+    return {
+        ...threadState,
+        streaming: {
+            ...threadState.streaming,
+            messageId: undefined,
+        },
+    };
+}
+/**
+ * Handle TOOL_CALL_START event.
+ * Adds a tool use content block to the current message.
+ * If no message exists, creates a synthetic assistant message to hold the tool call.
+ * @param threadState - Current thread state
+ * @param event - Tool call start event
+ * @returns Updated thread state
+ */
+function handleToolCallStart(threadState, event) {
+    const messageId = event.parentMessageId;
+    const messages = threadState.thread.messages;
+    // Find the parent message for this tool call.
+    // If parentMessageId is provided, look it up directly.
+    // Otherwise fall back to the last message, but only if it's an assistant message.
+    // If the last message isn't assistant (e.g. it's the user message and the LLM
+    // didn't produce any text before the tool call), we'll create a synthetic
+    // assistant message below.
+    let messageIndex;
+    if (messageId) {
+        messageIndex = messages.findIndex((m) => m.id === messageId);
+    }
+    else {
+        const lastIndex = messages.length - 1;
+        messageIndex =
+            lastIndex >= 0 && messages[lastIndex].role === "assistant"
+                ? lastIndex
+                : -1;
+    }
+    const newContent = {
+        type: "tool_use",
+        id: event.toolCallId,
+        name: event.toolCallName,
+        input: {},
+    };
+    // If no suitable assistant message found, create a synthetic one for the tool call
+    if (messageIndex === -1) {
+        const syntheticMessageId = messageId ?? `msg_tool_${event.toolCallId}`;
+        const syntheticMessage = {
+            id: syntheticMessageId,
+            role: "assistant",
+            content: [newContent],
+            createdAt: new Date().toISOString(),
+        };
+        return {
+            ...threadState,
+            thread: {
+                ...threadState.thread,
+                messages: [...messages, syntheticMessage],
+                updatedAt: new Date().toISOString(),
+            },
+            streaming: {
+                ...threadState.streaming,
+                messageId: syntheticMessageId,
+            },
+        };
+    }
+    const message = messages[messageIndex];
+    const updatedMessage = {
+        ...message,
+        content: [...message.content, newContent],
+    };
+    return updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage));
+}
+/**
+ * Handle TOOL_CALL_ARGS event.
+ * Accumulates JSON string deltas for tool call arguments and optimistically
+ * parses the partial JSON to update the tool_use content block in real-time.
+ * When toolSchemas is provided, the parsed args are unstrictified so the
+ * reducer always emits schema-valid values during streaming.
+ * The final authoritative parse still happens at TOOL_CALL_END.
+ * @param threadState - Current thread state
+ * @param event - Tool call args event
+ * @param parsedToolArgs - Pre-parsed args from the hook (already unstrictified)
+ * @param toolSchemas - Original tool schemas for unstrictification
+ * @returns Updated thread state
+ */
+function handleToolCallArgs(threadState, event, parsedToolArgs, toolSchemas) {
+    const toolCallId = event.toolCallId;
+    // Accumulate the JSON string delta
+    const accumulatedArgs = threadState.accumulatingToolArgs;
+    const existingArgs = accumulatedArgs[toolCallId] ?? "";
+    const newAccumulatedJson = existingArgs + event.delta;
+    const newAccumulatedArgs = { ...accumulatedArgs };
+    newAccumulatedArgs[toolCallId] = newAccumulatedJson;
+    // Use pre-parsed args if provided, otherwise parse partial JSON ourselves
+    let parsedInput = parsedToolArgs;
+    if (!parsedInput) {
+        try {
+            const parsed = (0, partial_json_1.parse)(newAccumulatedJson);
+            if (typeof parsed === "object" &&
+                parsed !== null &&
+                !Array.isArray(parsed)) {
+                parsedInput = parsed;
+            }
+        }
+        catch {
+            // Partial JSON not parseable yet — leave input unchanged
+        }
+    }
+    if (!parsedInput) {
+        return {
+            ...threadState,
+            accumulatingToolArgs: newAccumulatedArgs,
+        };
+    }
+    // Update the tool_use content block with partially parsed input
+    const messages = threadState.thread.messages;
+    const { messageIndex, contentIndex } = findContentById(messages, "tool_use", toolCallId, "TOOL_CALL_ARGS event");
+    const message = messages[messageIndex];
+    const toolUseContent = message.content[contentIndex];
+    if (toolUseContent.type !== "tool_use") {
+        throw new Error(`Content at index ${contentIndex} is not a tool_use block for TOOL_CALL_ARGS event`);
+    }
+    // Unstrictify if we have the original schema for this tool
+    if (toolSchemas) {
+        const schema = toolSchemas.get(toolUseContent.name);
+        if (schema) {
+            parsedInput = (0, unstrictify_1.unstrictifyToolCallParamsFromSchema)(schema, parsedInput);
+        }
+    }
+    const updatedContent = {
+        ...toolUseContent,
+        input: parsedInput,
+    };
+    const updatedMessage = {
+        ...message,
+        content: updateContentAtIndex(message.content, contentIndex, updatedContent),
+    };
+    return {
+        ...updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage)),
+        accumulatingToolArgs: newAccumulatedArgs,
+    };
+}
+/**
+ * Handle TOOL_CALL_END event.
+ * Parses the accumulated JSON arguments, unstrictifies them if possible,
+ * and updates the tool_use content block.
+ * @param threadState - Current thread state
+ * @param event - Tool call end event
+ * @param toolSchemas - Original tool schemas for unstrictification
+ * @returns Updated thread state
+ */
+function handleToolCallEnd(threadState, event, toolSchemas) {
+    const toolCallId = event.toolCallId;
+    const messages = threadState.thread.messages;
+    // Get accumulated JSON args string
+    const accumulatedJson = threadState.accumulatingToolArgs[toolCallId];
+    if (!accumulatedJson) {
+        // No args accumulated - tool call has empty input
+        return threadState;
+    }
+    // Parse the accumulated JSON - tool inputs are always objects
+    let parsedInput;
+    try {
+        parsedInput = JSON.parse(accumulatedJson);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse tool call arguments for ${toolCallId}: ${error instanceof Error ? error.message : String(error)}. JSON: ${accumulatedJson}`);
+    }
+    // Find the tool_use content block
+    const { messageIndex, contentIndex } = findContentById(messages, "tool_use", toolCallId, "TOOL_CALL_END event");
+    const message = messages[messageIndex];
+    const toolUseContent = message.content[contentIndex];
+    if (toolUseContent.type !== "tool_use") {
+        throw new Error(`Content at index ${contentIndex} is not a tool_use block for TOOL_CALL_END event`);
+    }
+    // Unstrictify parsed input if we have the original schema
+    if (toolSchemas) {
+        const schema = toolSchemas.get(toolUseContent.name);
+        if (schema) {
+            parsedInput = (0, unstrictify_1.unstrictifyToolCallParamsFromSchema)(schema, parsedInput);
+        }
+    }
+    // Update the tool_use content with parsed input
+    const updatedContent = {
+        ...toolUseContent,
+        input: parsedInput,
+    };
+    const updatedMessage = {
+        ...message,
+        content: updateContentAtIndex(message.content, contentIndex, updatedContent),
+    };
+    // Clear accumulated args for this tool call
+    const newAccumulatingToolArgs = { ...threadState.accumulatingToolArgs };
+    delete newAccumulatingToolArgs[toolCallId];
+    return {
+        ...updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage)),
+        accumulatingToolArgs: newAccumulatingToolArgs,
+    };
+}
+/**
+ * Handle TOOL_CALL_RESULT event.
+ * Adds tool result to the specified message.
+ * @param threadState - Current thread state
+ * @param event - Tool call result event
+ * @returns Updated thread state
+ */
+function handleToolCallResult(threadState, event) {
+    const messageId = event.messageId;
+    const messages = threadState.thread.messages;
+    // Find the message
+    const messageIndex = messages.findIndex((m) => m.id === messageId);
+    if (messageIndex === -1) {
+        throw new Error(`Message ${messageId} not found for TOOL_CALL_RESULT event`);
+    }
+    const message = messages[messageIndex];
+    // Add tool result content
+    const newContent = {
+        type: "tool_result",
+        toolUseId: event.toolCallId,
+        content: [
+            {
+                type: "text",
+                text: event.content,
+            },
+        ],
+    };
+    const updatedMessage = {
+        ...message,
+        content: [...message.content, newContent],
+    };
+    return updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage));
+}
+/**
+ * Handle custom events (Tambo-specific).
+ * @param threadState - Current thread state
+ * @param event - Custom event (already narrowed from AGUIEvent)
+ * @returns Updated thread state
+ */
+function handleCustomEvent(threadState, event) {
+    // Use centralized casting function to get properly typed Tambo event
+    const customEvent = (0, event_1.asTamboCustomEvent)(event);
+    if (!customEvent) {
+        // Unknown custom event - log and return unchanged
+        console.warn(`[StreamReducer] Unknown custom event name: ${event.name}`);
+        return threadState;
+    }
+    switch (customEvent.name) {
+        case "tambo.component.start":
+            return handleComponentStart(threadState, customEvent);
+        case "tambo.component.props_delta":
+            return handleComponentDelta(threadState, customEvent, "props");
+        case "tambo.component.state_delta":
+            return handleComponentDelta(threadState, customEvent, "state");
+        case "tambo.component.end":
+            return handleComponentEnd(threadState, customEvent);
+        case "tambo.run.awaiting_input":
+            return handleRunAwaitingInput(threadState, customEvent);
+        case "tambo.message.parent":
+            return handleMessageParent(threadState, customEvent);
+        default: {
+            // Exhaustiveness check: if a new event type is added to TamboCustomEvent
+            // and not handled here, TypeScript will error
+            const _exhaustiveCheck = customEvent;
+            throw new UnreachableCaseError(_exhaustiveCheck);
+        }
+    }
+}
+/**
+ * Handle tambo.component.start event.
+ * Adds a component content block to the message with 'started' streaming state.
+ * @param threadState - Current thread state
+ * @param event - Component start event
+ * @returns Updated thread state
+ */
+function handleComponentStart(threadState, event) {
+    const messageId = event.value.messageId;
+    let messages = threadState.thread.messages;
+    // Find the message, or create it if it doesn't exist.
+    // The backend may emit component events before TEXT_MESSAGE_START when
+    // the LLM outputs a component tool call without preceding text.
+    let messageIndex = messages.findIndex((m) => m.id === messageId);
+    if (messageIndex === -1) {
+        // Create a new assistant message for this component
+        const newMessage = {
+            id: messageId,
+            role: "assistant",
+            content: [],
+            createdAt: new Date().toISOString(),
+        };
+        messages = [...messages, newMessage];
+        messageIndex = messages.length - 1;
+        // Update thread state with the new message before adding the component
+        threadState = updateThreadMessages(threadState, messages);
+    }
+    const message = messages[messageIndex];
+    // Add component content block with 'started' streaming state
+    const newContent = {
+        type: "component",
+        id: event.value.componentId,
+        name: event.value.componentName,
+        props: {},
+        streamingState: "started",
+    };
+    const updatedMessage = {
+        ...message,
+        content: [...message.content, newContent],
+    };
+    return updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage));
+}
+/**
+ * Handle component delta events (both props_delta and state_delta).
+ * Applies JSON Patch to the specified field and sets streamingState to 'streaming'.
+ * @param threadState - Current thread state
+ * @param event - Component delta event (props or state)
+ * @param field - Which field to update ('props' or 'state')
+ * @returns Updated thread state
+ */
+function handleComponentDelta(threadState, event, field) {
+    const componentId = event.value.componentId;
+    const operations = event.value.operations;
+    const messages = threadState.thread.messages;
+    const eventName = `tambo.component.${field}_delta`;
+    // Find the component content block
+    const { messageIndex, contentIndex } = findContentById(messages, "component", componentId, `${eventName} event`);
+    const message = messages[messageIndex];
+    const componentContent = message.content[contentIndex];
+    if (componentContent.type !== "component") {
+        throw new Error(`Content at index ${contentIndex} is not a component block for ${eventName} event`);
+    }
+    // Get current value (state defaults to {} if undefined)
+    const currentValue = field === "props"
+        ? componentContent.props
+        : (componentContent.state ?? {});
+    // Apply JSON Patch
+    const updatedValue = (0, json_patch_1.applyJsonPatch)(currentValue, operations);
+    // Update field and set streaming state to 'streaming'
+    const updatedContent = {
+        ...componentContent,
+        [field]: updatedValue,
+        streamingState: "streaming",
+    };
+    const updatedMessage = {
+        ...message,
+        content: updateContentAtIndex(message.content, contentIndex, updatedContent),
+    };
+    return updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage));
+}
+/**
+ * Handle tambo.component.end event.
+ * Sets component streaming state to 'done'.
+ * @param threadState - Current thread state
+ * @param event - Component end event
+ * @returns Updated thread state
+ */
+function handleComponentEnd(threadState, event) {
+    const componentId = event.value.componentId;
+    const messages = threadState.thread.messages;
+    // Find the component content block
+    const { messageIndex, contentIndex } = findContentById(messages, "component", componentId, "tambo.component.end event");
+    const message = messages[messageIndex];
+    const componentContent = message.content[contentIndex];
+    if (componentContent.type !== "component") {
+        throw new Error(`Content at index ${contentIndex} is not a component block for tambo.component.end event`);
+    }
+    // Set streaming state to 'done'
+    const updatedContent = {
+        ...componentContent,
+        streamingState: "done",
+    };
+    const updatedMessage = {
+        ...message,
+        content: updateContentAtIndex(message.content, contentIndex, updatedContent),
+    };
+    return updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage));
+}
+/**
+ * Handle tambo.run.awaiting_input event.
+ * Sets thread status to waiting for client-side tool execution.
+ * @param threadState - Current thread state
+ * @param _event - Run awaiting input event (unused)
+ * @returns Updated thread state
+ */
+function handleRunAwaitingInput(threadState, _event) {
+    return {
+        ...threadState,
+        thread: {
+            ...threadState.thread,
+            status: "waiting",
+            updatedAt: new Date().toISOString(),
+        },
+        streaming: {
+            ...threadState.streaming,
+            status: "waiting",
+        },
+    };
+}
+/**
+ * Handle tambo.message.parent event.
+ * Sets parentMessageId on the target message, creating a new empty assistant
+ * message if one doesn't already exist with the given ID.
+ *
+ * This event fires BEFORE TEXT_MESSAGE_START, so when handleTextMessageStart
+ * later finds/creates the message with the same ID, the parentMessageId will
+ * already be set.
+ * @param threadState - Current thread state
+ * @param event - Message parent event
+ * @returns Updated thread state
+ */
+function handleMessageParent(threadState, event) {
+    const { messageId, parentMessageId } = event.value;
+    const messages = threadState.thread.messages;
+    // Find existing message or create a new empty assistant message
+    const messageIndex = messages.findIndex((m) => m.id === messageId);
+    if (messageIndex !== -1) {
+        // Message already exists - set parentMessageId on it
+        const message = messages[messageIndex];
+        const updatedMessage = {
+            ...message,
+            parentMessageId,
+        };
+        return updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage));
+    }
+    // Message doesn't exist yet - create a new empty assistant message
+    const newMessage = {
+        id: messageId,
+        role: "assistant",
+        content: [],
+        createdAt: new Date().toISOString(),
+        parentMessageId,
+    };
+    return updateThreadMessages(threadState, [...messages, newMessage]);
+}
+// ============================================================================
+// Reasoning Event Handlers (currently mapped from THINKING_TEXT_MESSAGE_* events)
+// ============================================================================
+/**
+ * Generate an ephemeral message ID for reasoning messages that arrive before TEXT_MESSAGE_START.
+ * Uses crypto.randomUUID() which is available in Node.js 19+ and modern browsers.
+ * @returns A unique ephemeral message ID string.
+ */
+function generateEphemeralMessageId() {
+    return `ephemeral_${crypto.randomUUID()}`;
+}
+/**
+ * Find or create an assistant message for reasoning events.
+ * Reasoning should only be attached to assistant messages.
+ * If no suitable assistant message exists, creates an ephemeral one.
+ * @param threadState - Current thread state
+ * @returns Object with messageIndex, messages array, and updated threadState
+ */
+function findOrCreateMessageForReasoning(threadState) {
+    const messageId = threadState.streaming.messageId;
+    let messages = threadState.thread.messages;
+    // If we have an active streaming messageId, try to find it
+    if (messageId) {
+        const messageIndex = messages.findIndex((m) => m.id === messageId);
+        if (messageIndex !== -1 && messages[messageIndex].role === "assistant") {
+            return { messageIndex, messages, threadState };
+        }
+    }
+    // Look for the last assistant message
+    const lastAssistantIndex = messages.findLastIndex((m) => m.role === "assistant");
+    // If there's an assistant message and it's the most recent message, use it
+    // (Don't attach reasoning to an old assistant message if user message came after)
+    if (lastAssistantIndex !== -1 && lastAssistantIndex === messages.length - 1) {
+        return { messageIndex: lastAssistantIndex, messages, threadState };
+    }
+    // No suitable assistant message - create an ephemeral one
+    const ephemeralId = generateEphemeralMessageId();
+    const newMessage = {
+        id: ephemeralId,
+        role: "assistant",
+        content: [],
+        createdAt: new Date().toISOString(),
+    };
+    messages = [...messages, newMessage];
+    const messageIndex = messages.length - 1;
+    // Update thread state with new message
+    threadState = {
+        ...threadState,
+        thread: {
+            ...threadState.thread,
+            messages,
+            updatedAt: new Date().toISOString(),
+        },
+        streaming: {
+            ...threadState.streaming,
+            messageId: ephemeralId,
+        },
+    };
+    return { messageIndex, messages, threadState };
+}
+/**
+ * Handle THINKING_TEXT_MESSAGE_START event (will become REASONING_MESSAGE_START).
+ * Starts a new reasoning chunk by appending an empty string to the message's reasoning array.
+ * Records the start time for duration calculation.
+ * @param threadState - Current thread state
+ * @param event - Thinking text message start event
+ * @returns Updated thread state
+ */
+function handleThinkingTextMessageStart(threadState, event) {
+    const { messageIndex, messages, threadState: updatedThreadState, } = findOrCreateMessageForReasoning(threadState);
+    threadState = updatedThreadState;
+    const message = messages[messageIndex];
+    const existingReasoning = message.reasoning ?? [];
+    const updatedMessage = {
+        ...message,
+        reasoning: [...existingReasoning, ""],
+    };
+    // Record reasoning start time if this is the first reasoning chunk
+    const reasoningStartTime = threadState.streaming.reasoningStartTime ?? event.timestamp ?? Date.now();
+    return {
+        ...updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage)),
+        streaming: {
+            ...threadState.streaming,
+            reasoningStartTime,
+        },
+    };
+}
+/**
+ * Handle THINKING_TEXT_MESSAGE_CONTENT event (will become REASONING_MESSAGE_CONTENT).
+ * Appends delta text to the last reasoning chunk.
+ * @param threadState - Current thread state
+ * @param event - Thinking text message content event
+ * @returns Updated thread state
+ */
+function handleThinkingTextMessageContent(threadState, event) {
+    const { messageIndex, messages, threadState: updatedThreadState, } = findOrCreateMessageForReasoning(threadState);
+    threadState = updatedThreadState;
+    const message = messages[messageIndex];
+    const existingReasoning = message.reasoning ?? [];
+    if (existingReasoning.length === 0) {
+        // No reasoning chunk started - start one implicitly
+        const updatedMessage = {
+            ...message,
+            reasoning: [event.delta],
+        };
+        return {
+            ...updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage)),
+            streaming: {
+                ...threadState.streaming,
+                reasoningStartTime: threadState.streaming.reasoningStartTime ??
+                    event.timestamp ??
+                    Date.now(),
+            },
+        };
+    }
+    // Append to the last reasoning chunk
+    const updatedReasoning = [
+        ...existingReasoning.slice(0, -1),
+        existingReasoning[existingReasoning.length - 1] + event.delta,
+    ];
+    const updatedMessage = {
+        ...message,
+        reasoning: updatedReasoning,
+    };
+    return updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage));
+}
+/**
+ * Handle THINKING_TEXT_MESSAGE_END event (will become REASONING_MESSAGE_END).
+ * Calculates and stores the reasoning duration.
+ * @param threadState - Current thread state
+ * @param event - Thinking text message end event
+ * @returns Updated thread state
+ */
+function handleThinkingTextMessageEnd(threadState, event) {
+    const { messageIndex, messages, threadState: updatedThreadState, } = findOrCreateMessageForReasoning(threadState);
+    threadState = updatedThreadState;
+    const message = messages[messageIndex];
+    // Calculate duration if we have a start time
+    const reasoningStartTime = threadState.streaming.reasoningStartTime;
+    const endTime = event.timestamp ?? Date.now();
+    const reasoningDurationMS = reasoningStartTime
+        ? endTime - reasoningStartTime
+        : undefined;
+    const updatedMessage = {
+        ...message,
+        reasoningDurationMS: reasoningDurationMS ?? message.reasoningDurationMS ?? undefined,
+    };
+    return updateThreadMessages(threadState, updateMessageAtIndex(messages, messageIndex, updatedMessage));
+}
+/**
+ * Handle LOAD_THREAD_MESSAGES action.
+ * Loads messages from API into stream state for an existing thread.
+ * Deduplicates by message ID, keeping existing messages (they may have in-flight updates).
+ * Sorts merged messages by createdAt to ensure chronological order.
+ * @param state - Current stream state
+ * @param action - Load thread messages action
+ * @returns Updated stream state
+ */
+function handleLoadThreadMessages(state, action) {
+    const { threadId, messages, skipIfStreaming } = action;
+    // Get or create thread state
+    let threadState = state.threadMap[threadId];
+    if (!threadState) {
+        threadState = createInitialThreadState(threadId);
+    }
+    // Skip if streaming and skipIfStreaming is true
+    if (skipIfStreaming && threadState.streaming.status === "streaming") {
+        return state;
+    }
+    const existingMessages = threadState.thread.messages;
+    // Build a set of existing message IDs for fast lookup
+    const existingIds = new Set(existingMessages.map((m) => m.id));
+    // Filter out messages that already exist (keep existing, add new).
+    // API-loaded messages are by definition fully complete, so stamp
+    // streamingState: "done" on all component content blocks. This is
+    // required by downstream hooks (usePropsStreamingStatus) which check
+    // streamingState === "done" to report isSuccess: true.
+    const newMessages = messages
+        .filter((m) => !existingIds.has(m.id))
+        .map((m) => ({
+        ...m,
+        content: m.content.map((block) => {
+            if (block.type !== "component")
+                return block;
+            if (block.streamingState !== undefined &&
+                block.streamingState !== "done") {
+                console.warn(`LOAD_THREAD_MESSAGES: component "${block.id}" has unexpected ` +
+                    `streamingState "${block.streamingState}". API-loaded messages ` +
+                    `should not have in-flight streaming state.`);
+            }
+            return { ...block, streamingState: "done" };
+        }),
+    }));
+    // Merge and sort by createdAt
+    const mergedMessages = [...existingMessages, ...newMessages].toSorted((a, b) => {
+        // Messages without createdAt go to the end
+        if (!a.createdAt && !b.createdAt)
+            return 0;
+        if (!a.createdAt)
+            return 1;
+        if (!b.createdAt)
+            return -1;
+        return a.createdAt.localeCompare(b.createdAt);
+    });
+    const updatedThreadState = {
+        ...threadState,
+        thread: {
+            ...threadState.thread,
+            messages: mergedMessages,
+            updatedAt: new Date().toISOString(),
+        },
+    };
+    return {
+        ...state,
+        threadMap: {
+            ...state.threadMap,
+            [threadId]: updatedThreadState,
+        },
+    };
+}
+//# sourceMappingURL=event-accumulator.js.map