@pipecat-ai/client-react 1.1.0 → 1.2.1

package/dist/index.js

@@ -29,6 +29,13 @@ $parcel$export(module.exports, "usePipecatClientScreenShareControl", () => $5fc6
 $parcel$export(module.exports, "usePipecatClientTransportState", () => $810478f6ae107062$export$30aee278309a867b);
 $parcel$export(module.exports, "useRTVIClientEvent", () => $8a6b68ebf0332682$export$33a6ac53b8f02625);
 $parcel$export(module.exports, "VoiceVisualizer", () => $a1dfa75b13e6bb9b$export$59bf27bd43679db6);
+$parcel$export(module.exports, "useConversationContext", () => $984246ab4e966dee$export$8eec679bf8249822);
+$parcel$export(module.exports, "usePipecatConversation", () => $fe6dfdd0b8560c78$export$acb832b064cb6c09);
+$parcel$export(module.exports, "deduplicateFunctionCalls", () => $cbb62fb16c5d45ff$export$dfa183f99573a822);
+$parcel$export(module.exports, "filterEmptyMessages", () => $cbb62fb16c5d45ff$export$3d3951a55577516);
+$parcel$export(module.exports, "isMessageEmpty", () => $cbb62fb16c5d45ff$export$f4610a88b89838b);
+$parcel$export(module.exports, "mergeMessages", () => $cbb62fb16c5d45ff$export$23a96e868837e158);
+$parcel$export(module.exports, "sortByCreatedAt", () => $cbb62fb16c5d45ff$export$cbefc5865f8cbd89);
 /**
  * Copyright (c) 2024, Daily.
  *
@@ -55,13 +62,784 @@ $parcel$export(module.exports, "VoiceVisualizer", () => $a1dfa75b13e6bb9b$export
 
 
 var $d1f89db81f967f39$exports = {};
-$d1f89db81f967f39$exports = JSON.parse("{\"name\":\"@pipecat-ai/client-react\",\"version\":\"1.1.0\",\"license\":\"BSD-2-Clause\",\"main\":\"dist/index.js\",\"module\":\"dist/index.module.js\",\"types\":\"dist/index.d.ts\",\"source\":\"src/index.ts\",\"repository\":{\"type\":\"git\",\"url\":\"git+https://github.com/pipecat-ai/pipecat-client-web.git\"},\"files\":[\"dist\",\"package.json\",\"README.md\"],\"scripts\":{\"build\":\"parcel build --no-cache\",\"dev\":\"parcel watch\",\"lint\":\"eslint . --report-unused-disable-directives --max-warnings 0 --ignore-pattern 'dist/'\"},\"devDependencies\":{\"@pipecat-ai/client-js\":\"*\",\"@types/react\":\"^18.3.3\",\"@types/react-dom\":\"^18.3.0\",\"@typescript-eslint/eslint-plugin\":\"^8.32.0\",\"eslint\":\"^9.11.1\",\"eslint-config-prettier\":\"^9.1.0\",\"eslint-plugin-react-hooks\":\"^5.2.0\",\"eslint-plugin-simple-import-sort\":\"^12.1.1\",\"parcel\":\"^2.12.0\",\"react\":\"^18.3.1\",\"react-dom\":\"^18.3.1\",\"typescript\":\"^5.2.2\"},\"peerDependencies\":{\"@pipecat-ai/client-js\":\"*\",\"react\":\">=18\",\"react-dom\":\">=18\"},\"dependencies\":{\"jotai\":\"^2.9.0\"}}");
+$d1f89db81f967f39$exports = JSON.parse("{\"name\":\"@pipecat-ai/client-react\",\"version\":\"1.2.1\",\"license\":\"BSD-2-Clause\",\"main\":\"dist/index.js\",\"module\":\"dist/index.module.js\",\"types\":\"dist/index.d.ts\",\"source\":\"src/index.ts\",\"repository\":{\"type\":\"git\",\"url\":\"git+https://github.com/pipecat-ai/pipecat-client-web.git\"},\"exports\":{\".\":{\"types\":\"./dist/index.d.ts\",\"import\":\"./dist/index.module.js\",\"require\":\"./dist/index.js\"}},\"files\":[\"dist\",\"package.json\",\"README.md\"],\"scripts\":{\"build\":\"parcel build --no-cache\",\"dev\":\"parcel watch\",\"lint\":\"eslint . --report-unused-disable-directives --max-warnings 0 --ignore-pattern 'dist/'\",\"test\":\"jest\"},\"jest\":{\"preset\":\"ts-jest\",\"testEnvironment\":\"jsdom\",\"moduleNameMapper\":{\"^@/(.*)$\":\"<rootDir>/src/$1\"},\"transform\":{\"^.+\\\\.tsx?$\":[\"ts-jest\",{\"tsconfig\":{\"jsx\":\"react-jsx\",\"module\":\"commonjs\",\"moduleResolution\":\"node\",\"esModuleInterop\":true,\"allowImportingTsExtensions\":false,\"noUnusedLocals\":false,\"noUnusedParameters\":false}}]}},\"devDependencies\":{\"@jest/globals\":\"^30.2.0\",\"@pipecat-ai/client-js\":\"*\",\"@types/jest\":\"^30.0.0\",\"@types/react\":\"^18.3.3\",\"@types/react-dom\":\"^18.3.0\",\"@typescript-eslint/eslint-plugin\":\"^8.32.0\",\"eslint\":\"^9.11.1\",\"eslint-config-prettier\":\"^9.1.0\",\"eslint-plugin-react-hooks\":\"^5.2.0\",\"eslint-plugin-simple-import-sort\":\"^12.1.1\",\"jest\":\"^30.2.0\",\"jest-environment-jsdom\":\"^30.2.0\",\"parcel\":\"^2.12.0\",\"react\":\"^18.3.1\",\"react-dom\":\"^18.3.1\",\"ts-jest\":\"^29.4.6\",\"typescript\":\"^5.2.2\"},\"peerDependencies\":{\"@pipecat-ai/client-js\":\"*\",\"react\":\">=18\",\"react-dom\":\">=18\"},\"dependencies\":{\"jotai\":\"^2.9.0\"}}");
 
 
 
 
 
 
+/**
+ * Copyright (c) 2024, Daily.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */ /**
+ * Copyright (c) 2024, Daily.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */ const $ad0c8ea1ee293a79$export$7d7fdcf7579a70b2 = (text)=>{
+    return text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, "");
+};
+const $ad0c8ea1ee293a79$var$skipWhitespace = (text, start)=>{
+    let i = start;
+    while(i < text.length && /\s/.test(text[i]))i++;
+    return i;
+};
+/**
+ * Finds where `spoken` appears in `unspoken`, starting from `startPosition`.
+ * - Best-effort sequential word matching (normalized, punctuation-stripped)
+ * - Returns the original start position on mismatch (no advancement)
+ */ const $ad0c8ea1ee293a79$var$findSpokenPositionInUnspoken = (spoken, unspoken, startPosition)=>{
+    if (!spoken || !unspoken || startPosition >= unspoken.length) return startPosition;
+    // If spoken text includes a leading separator space, skip leading whitespace in unspoken.
+    let actualStart = startPosition;
+    let spokenForMatching = spoken;
+    if (spoken.startsWith(" ") && startPosition < unspoken.length) {
+        actualStart = $ad0c8ea1ee293a79$var$skipWhitespace(unspoken, startPosition);
+        spokenForMatching = spoken.trimStart();
+    } else if (startPosition === 0 && startPosition < unspoken.length) // If we're at the start, also skip leading whitespace (e.g. newlines)
+    actualStart = $ad0c8ea1ee293a79$var$skipWhitespace(unspoken, 0);
+    const remainder = unspoken.slice(actualStart);
+    // Sentence-level: if spoken exactly matches the remainder (normalized), consume the whole part
+    // so we never leave a word unspoken due to word-matching edge cases.
+    if ($ad0c8ea1ee293a79$export$7d7fdcf7579a70b2(spokenForMatching).trim() === $ad0c8ea1ee293a79$export$7d7fdcf7579a70b2(remainder).trim()) return unspoken.length;
+    const spokenWords = $ad0c8ea1ee293a79$export$7d7fdcf7579a70b2(spokenForMatching).split(/\s+/).filter(Boolean);
+    if (spokenWords.length === 0) return actualStart;
+    const unspokenWords = $ad0c8ea1ee293a79$export$7d7fdcf7579a70b2(unspoken.slice(actualStart)).split(/\s+/).filter(Boolean);
+    // Sequential match, allowing prefix match for contractions (e.g. "I" vs "I'm")
+    // and limited skipping of mismatched unspoken words (e.g. punctuation artifacts).
+    let matchedWords = 0;
+    let consecutiveSkips = 0;
+    const MAX_CONSECUTIVE_SKIPS = 2;
+    for(let i = 0; i < unspokenWords.length && matchedWords < spokenWords.length; i++){
+        const target = spokenWords[matchedWords];
+        const candidate = unspokenWords[i];
+        if (candidate === target || candidate.startsWith(target)) {
+            matchedWords++;
+            consecutiveSkips = 0;
+            continue;
+        }
+        consecutiveSkips++;
+        if (consecutiveSkips > MAX_CONSECUTIVE_SKIPS) return actualStart;
+    // Skip this unspoken word and try matching the next one
+    }
+    if (matchedWords < spokenWords.length) return actualStart;
+    // Convert word matches back into a character position in the original unspoken string.
+    const isWordChar = (char)=>/[\p{L}\p{N}]/u.test(char);
+    let wordCount = 0;
+    let i = actualStart;
+    let inWord = false;
+    while(i < unspoken.length){
+        const charIsWord = isWordChar(unspoken[i]);
+        if (charIsWord && !inWord) {
+            inWord = true;
+            wordCount++;
+            if (wordCount === matchedWords) {
+                // Consume the rest of this word
+                i++;
+                while(i < unspoken.length && isWordChar(unspoken[i]))i++;
+                // Include any punctuation after the word until the next space, then include the space
+                while(i < unspoken.length){
+                    if (unspoken[i] === " ") {
+                        i++;
+                        break;
+                    }
+                    i++;
+                }
+                return i;
+            }
+        } else if (!charIsWord && inWord) inWord = false;
+        i++;
+    }
+    return unspoken.length;
+};
+function $ad0c8ea1ee293a79$export$802e9b947136afbf(cursor, parts) {
+    if (parts.length === 0) return false;
+    for(let i = 0; i < parts.length; i++){
+        if (typeof parts[i]?.text !== "string") continue;
+        if (!cursor.partFinalFlags[i]) return true;
+    }
+    return false;
+}
+function $ad0c8ea1ee293a79$export$9b39fd8438081d6d(cursor, parts, spokenText) {
+    if (parts.length === 0) return false;
+    // Find the next part that should be spoken (skip parts already marked final/skipped)
+    let partToMatch = cursor.currentPartIndex;
+    while(partToMatch < parts.length && cursor.partFinalFlags[partToMatch])partToMatch++;
+    if (partToMatch >= parts.length) return false;
+    if (partToMatch > cursor.currentPartIndex) {
+        cursor.currentPartIndex = partToMatch;
+        cursor.currentCharIndex = 0;
+    }
+    const currentPart = parts[cursor.currentPartIndex];
+    if (typeof currentPart.text !== "string") return false;
+    const partText = currentPart.text;
+    const startChar = cursor.currentCharIndex;
+    // If the spoken text is pure punctuation (e.g. an em dash "—"), normalization
+    // strips it to empty and word-matching would fail. Treat it as successfully
+    // consumed so the cursor stays put and subsequent words continue matching.
+    if ($ad0c8ea1ee293a79$export$7d7fdcf7579a70b2(spokenText).trim().length === 0) return true;
+    const newPosition = $ad0c8ea1ee293a79$var$findSpokenPositionInUnspoken(spokenText, partText, startChar);
+    const whitespaceEnd = $ad0c8ea1ee293a79$var$skipWhitespace(partText, startChar);
+    if (newPosition > whitespaceEnd) {
+        cursor.currentCharIndex = newPosition;
+        if (newPosition >= partText.length) {
+            cursor.partFinalFlags[cursor.currentPartIndex] = true;
+            if (cursor.currentPartIndex < parts.length - 1) {
+                cursor.currentPartIndex++;
+                cursor.currentCharIndex = 0;
+            }
+        }
+        return true;
+    }
+    // Intra-part scan-ahead recovery: if matching failed at the current position,
+    // scan forward word-by-word within the same part. This prevents the cursor
+    // from getting permanently stuck mid-part when a single word mismatch occurs
+    // (e.g. TTS variation, punctuation boundary like `apexes."Sometimes`).
+    if (startChar > 0) {
+        const MAX_SCAN_WORDS = 8;
+        let scanPos = startChar;
+        for(let scan = 0; scan < MAX_SCAN_WORDS; scan++){
+            // Advance past current word
+            while(scanPos < partText.length && !/\s/.test(partText[scanPos]))scanPos++;
+            // Advance past whitespace to next word
+            while(scanPos < partText.length && /\s/.test(partText[scanPos]))scanPos++;
+            if (scanPos >= partText.length) break;
+            const retryPos = $ad0c8ea1ee293a79$var$findSpokenPositionInUnspoken(spokenText, partText, scanPos);
+            const scanWsEnd = $ad0c8ea1ee293a79$var$skipWhitespace(partText, scanPos);
+            if (retryPos > scanWsEnd) {
+                cursor.currentCharIndex = retryPos;
+                if (retryPos >= partText.length) {
+                    cursor.partFinalFlags[cursor.currentPartIndex] = true;
+                    if (cursor.currentPartIndex < parts.length - 1) {
+                        cursor.currentPartIndex++;
+                        cursor.currentCharIndex = 0;
+                    }
+                }
+                return true;
+            }
+        }
+    }
+    // Mismatch recovery: try to find the spoken text in a later part.
+    for(let nextPartIdx = cursor.currentPartIndex + 1; nextPartIdx < parts.length; nextPartIdx++){
+        const nextPart = parts[nextPartIdx];
+        if (typeof nextPart.text !== "string") continue;
+        const match = $ad0c8ea1ee293a79$var$findSpokenPositionInUnspoken(spokenText, nextPart.text, 0);
+        const nextWhitespaceEnd = $ad0c8ea1ee293a79$var$skipWhitespace(nextPart.text, 0);
+        if (match > nextWhitespaceEnd) {
+            // Mark skipped parts as final and jump to the matched part
+            for(let i = cursor.currentPartIndex; i < nextPartIdx; i++)cursor.partFinalFlags[i] = true;
+            cursor.currentPartIndex = nextPartIdx;
+            cursor.currentCharIndex = match;
+            return true;
+        }
+    }
+    // If we're stuck at the start, mark the current part as skipped to avoid deadlock.
+    if (startChar === 0 && cursor.currentPartIndex < parts.length - 1) {
+        cursor.partFinalFlags[cursor.currentPartIndex] = true;
+        cursor.currentPartIndex++;
+        cursor.currentCharIndex = 0;
+        return true;
+    }
+    return false;
+}
+
+
+/**
+ * Copyright (c) 2024, Daily.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */ 
+const $28e6b30207a0392e$export$92a4076839a978d0 = (0, $5Zyvw$jotai.atom)([]);
+const $28e6b30207a0392e$export$bd01e11bc95333a1 = (0, $5Zyvw$jotai.atom)(new Map());
+const $28e6b30207a0392e$export$b0cd27059c88d0ab = (0, $5Zyvw$jotai.atom)(new Map());
+const $28e6b30207a0392e$export$57b1a1df06a7e728 = (0, $5Zyvw$jotai.atom)(null);
+
+
+/**
+ * Copyright (c) 2024, Daily.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */ // ES2020-compatible polyfills for findLast / findLastIndex
+function $f4fa178c5adc67bb$export$8855a8be7bd3e9f8(arr, predicate) {
+    for(let i = arr.length - 1; i >= 0; i--){
+        if (predicate(arr[i], i, arr)) return i;
+    }
+    return -1;
+}
+function $f4fa178c5adc67bb$export$296de88ccac4bedb(arr, predicate) {
+    const idx = $f4fa178c5adc67bb$export$8855a8be7bd3e9f8(arr, predicate);
+    return idx === -1 ? undefined : arr[idx];
+}
+
+
+/** Max time gap (ms) between consecutive same-role messages for merging. */ const $cbb62fb16c5d45ff$var$MERGE_WINDOW_MS = 30000;
+/**
+ * Unicode characters used by `FilterIncompleteTurns` on the server to mark
+ * turn completion status. The LLM emits one of these as the very first
+ * character of every response:
+ *
+ *   ✓ (U+2713) — complete turn
+ *   ○ (U+25CB) — incomplete short
+ *   ◐ (U+25D0) — incomplete long
+ *
+ * They must be stripped before the text reaches conversation state.
+ */ const $cbb62fb16c5d45ff$var$TURN_COMPLETION_MARKERS = new Set([
+    "\u2713",
+    "\u25CB",
+    "\u25D0"
+]);
+function $cbb62fb16c5d45ff$export$146b18879fa8cfd7(text) {
+    if (text.length === 0) return text;
+    if ($cbb62fb16c5d45ff$var$TURN_COMPLETION_MARKERS.has(text[0])) // Remove marker and optional single trailing space
+    return text[1] === " " ? text.slice(2) : text.slice(1);
+    return text;
+}
+const $cbb62fb16c5d45ff$export$cbefc5865f8cbd89 = (a, b)=>{
+    return a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : 0;
+};
+const $cbb62fb16c5d45ff$export$f4610a88b89838b = (message)=>{
+    if (message.role === "function_call") return false;
+    const parts = message.parts || [];
+    if (parts.length === 0) return true;
+    return parts.every((p)=>{
+        if (typeof p.text === "string") return p.text.trim().length === 0;
+        // Check BotOutputText objects
+        if (typeof p.text === "object" && p.text !== null && "spoken" in p.text && "unspoken" in p.text) {
+            const botText = p.text;
+            return botText.spoken.trim().length === 0 && botText.unspoken.trim().length === 0;
+        }
+        // For ReactNode, consider it non-empty
+        return false;
+    });
+};
+const $cbb62fb16c5d45ff$export$3d3951a55577516 = (messages)=>{
+    return messages.filter((message, index, array)=>{
+        if (!$cbb62fb16c5d45ff$export$f4610a88b89838b(message)) return true;
+        // For empty messages, keep only if no following non-empty message with same role
+        const nextMessageWithSameRole = array.slice(index + 1).find((m)=>m.role === message.role && !$cbb62fb16c5d45ff$export$f4610a88b89838b(m));
+        return !nextMessageWithSameRole;
+    });
+};
+const $cbb62fb16c5d45ff$export$23a96e868837e158 = (messages)=>{
+    const mergedMessages = [];
+    for(let i = 0; i < messages.length; i++){
+        const currentMessage = messages[i];
+        const lastMerged = mergedMessages[mergedMessages.length - 1];
+        const timeDiff = lastMerged ? Math.abs(new Date(currentMessage.createdAt).getTime() - new Date(lastMerged.createdAt).getTime()) : Infinity;
+        const shouldMerge = lastMerged && lastMerged.role === currentMessage.role && currentMessage.role !== "system" && currentMessage.role !== "function_call" && timeDiff < $cbb62fb16c5d45ff$var$MERGE_WINDOW_MS;
+        if (shouldMerge) mergedMessages[mergedMessages.length - 1] = {
+            ...lastMerged,
+            parts: [
+                ...lastMerged.parts || [],
+                ...currentMessage.parts || []
+            ],
+            updatedAt: currentMessage.updatedAt || currentMessage.createdAt,
+            final: currentMessage.final !== false
+        };
+        else mergedMessages.push(currentMessage);
+    }
+    return mergedMessages;
+};
+const $cbb62fb16c5d45ff$var$statusPriority = {
+    started: 0,
+    in_progress: 1,
+    completed: 2
+};
+const $cbb62fb16c5d45ff$export$dfa183f99573a822 = (messages)=>{
+    const bestByToolCallId = new Map();
+    const toRemove = new Set();
+    for(let i = 0; i < messages.length; i++){
+        const msg = messages[i];
+        const tcid = msg.functionCall?.tool_call_id;
+        if (msg.role !== "function_call" || !tcid) continue;
+        const existingIdx = bestByToolCallId.get(tcid);
+        if (existingIdx !== undefined) {
+            const existingPriority = $cbb62fb16c5d45ff$var$statusPriority[messages[existingIdx].functionCall.status] ?? 0;
+            const currentPriority = $cbb62fb16c5d45ff$var$statusPriority[msg.functionCall.status] ?? 0;
+            if (currentPriority >= existingPriority) {
+                toRemove.add(existingIdx);
+                bestByToolCallId.set(tcid, i);
+            } else toRemove.add(i);
+        } else bestByToolCallId.set(tcid, i);
+    }
+    if (toRemove.size === 0) return messages;
+    return messages.filter((_, i)=>!toRemove.has(i));
+};
+const $cbb62fb16c5d45ff$var$normalizeMessagesForUI = (messages)=>{
+    return $cbb62fb16c5d45ff$export$23a96e868837e158($cbb62fb16c5d45ff$export$dfa183f99573a822($cbb62fb16c5d45ff$export$3d3951a55577516([
+        ...messages
+    ].sort($cbb62fb16c5d45ff$export$cbefc5865f8cbd89))));
+};
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+const $cbb62fb16c5d45ff$var$callCallbacks = (callbacksMap, type, message)=>{
+    callbacksMap.forEach((callbacks)=>{
+        try {
+            callbacks[type]?.(message);
+        } catch (error) {
+            console.error(`Error in ${type} callback:`, error);
+        }
+    });
+};
+function $cbb62fb16c5d45ff$export$f2820c5e040afe17(get, set, id, callbacks) {
+    const map = new Map(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)));
+    map.set(id, callbacks);
+    set((0, $28e6b30207a0392e$export$b0cd27059c88d0ab), map);
+}
+function $cbb62fb16c5d45ff$export$46ae1ba121fdc956(get, set, id) {
+    const map = new Map(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)));
+    map.delete(id);
+    set((0, $28e6b30207a0392e$export$b0cd27059c88d0ab), map);
+}
+function $cbb62fb16c5d45ff$export$f2434643f2abff11(_get, set) {
+    set((0, $28e6b30207a0392e$export$92a4076839a978d0), []);
+    set((0, $28e6b30207a0392e$export$bd01e11bc95333a1), new Map());
+}
+function $cbb62fb16c5d45ff$export$16fdb433d434f08(get, set, messageData) {
+    const now = new Date();
+    const message = {
+        ...messageData,
+        createdAt: now.toISOString(),
+        updatedAt: now.toISOString()
+    };
+    const current = get((0, $28e6b30207a0392e$export$92a4076839a978d0));
+    const updatedMessages = [
+        ...current,
+        message
+    ];
+    const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(updatedMessages);
+    $cbb62fb16c5d45ff$var$callCallbacks(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)), "onMessageCreated", message);
+    set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+}
+function $cbb62fb16c5d45ff$export$a05f96a2aa40873e(get, set, role, updates) {
+    const messages = [
+        ...get((0, $28e6b30207a0392e$export$92a4076839a978d0))
+    ];
+    const lastMessageIndex = (0, $f4fa178c5adc67bb$export$8855a8be7bd3e9f8)(messages, (msg)=>msg.role === role);
+    if (lastMessageIndex === -1) return;
+    const existing = messages[lastMessageIndex];
+    const updatedMessage = {
+        ...existing,
+        ...updates,
+        updatedAt: new Date().toISOString()
+    };
+    messages[lastMessageIndex] = updatedMessage;
+    const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(messages);
+    $cbb62fb16c5d45ff$var$callCallbacks(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)), "onMessageUpdated", updatedMessage);
+    set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+}
+function $cbb62fb16c5d45ff$export$78bd074993ab081f(get, set, role) {
+    const messages = [
+        ...get((0, $28e6b30207a0392e$export$92a4076839a978d0))
+    ];
+    const lastMessageIndex = (0, $f4fa178c5adc67bb$export$8855a8be7bd3e9f8)(messages, (msg)=>msg.role === role);
+    if (lastMessageIndex === -1) return;
+    const lastMessage = messages[lastMessageIndex];
+    // Check if message is empty
+    if ($cbb62fb16c5d45ff$export$f4610a88b89838b(lastMessage)) // Remove empty message only if it has no text in streams either
+    messages.splice(lastMessageIndex, 1);
+    else {
+        // Finalize message and its last part
+        const parts = [
+            ...lastMessage.parts || []
+        ];
+        if (parts.length > 0) parts[parts.length - 1] = {
+            ...parts[parts.length - 1],
+            final: true
+        };
+        messages[lastMessageIndex] = {
+            ...lastMessage,
+            parts: parts,
+            final: true,
+            updatedAt: new Date().toISOString()
+        };
+        $cbb62fb16c5d45ff$var$callCallbacks(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)), "onMessageUpdated", messages[lastMessageIndex]);
+    }
+    const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(messages);
+    set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+}
+function $cbb62fb16c5d45ff$export$cd74f809c89ea10c(get, set, role) {
+    const messages = [
+        ...get((0, $28e6b30207a0392e$export$92a4076839a978d0))
+    ];
+    const lastMessageIndex = (0, $f4fa178c5adc67bb$export$8855a8be7bd3e9f8)(messages, (msg)=>msg.role === role);
+    if (lastMessageIndex === -1) return;
+    const lastMessage = messages[lastMessageIndex];
+    if ($cbb62fb16c5d45ff$export$f4610a88b89838b(lastMessage)) {
+        messages.splice(lastMessageIndex, 1);
+        const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(messages);
+        set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+    }
+}
+function $cbb62fb16c5d45ff$export$c3a007efc2f315a0(get, set, messageData) {
+    const now = new Date();
+    const current = get((0, $28e6b30207a0392e$export$92a4076839a978d0));
+    // If the most recent message is an active (non-final) assistant message,
+    // backdate the injected message so it sorts before the assistant's createdAt.
+    // This prevents the injected message from splitting the bot's response across
+    // two bubbles and breaking the karaoke cursor.
+    const lastMessage = current[current.length - 1];
+    const lastAssistant = lastMessage?.role === "assistant" ? lastMessage : undefined;
+    let timestamp;
+    if (lastAssistant && lastAssistant.final === false && messageData.role === "system") {
+        const assistantTime = new Date(lastAssistant.createdAt);
+        timestamp = new Date(assistantTime.getTime() - 1).toISOString();
+    } else timestamp = now.toISOString();
+    const message = {
+        role: messageData.role,
+        final: true,
+        parts: [
+            ...messageData.parts
+        ],
+        createdAt: timestamp,
+        updatedAt: now.toISOString()
+    };
+    const updatedMessages = [
+        ...current,
+        message
+    ];
+    const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(updatedMessages);
+    $cbb62fb16c5d45ff$var$callCallbacks(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)), "onMessageCreated", message);
+    set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+}
+function $cbb62fb16c5d45ff$export$57de01211e3df548(get, set, text, final) {
+    const now = new Date();
+    const messages = [
+        ...get((0, $28e6b30207a0392e$export$92a4076839a978d0))
+    ];
+    // Find last user message
+    const lastUserIndex = (0, $f4fa178c5adc67bb$export$8855a8be7bd3e9f8)(messages, (m)=>m.role === "user");
+    if (lastUserIndex !== -1 && !messages[lastUserIndex].final) {
+        // Update existing user message
+        const target = {
+            ...messages[lastUserIndex]
+        };
+        const parts = Array.isArray(target.parts) ? [
+            ...target.parts
+        ] : [];
+        const lastPart = parts[parts.length - 1];
+        if (!lastPart || lastPart.final) // Start a new part
+        parts.push({
+            text: text,
+            final: final,
+            createdAt: now.toISOString()
+        });
+        else // Update in-progress part
+        parts[parts.length - 1] = {
+            ...lastPart,
+            text: text,
+            final: final
+        };
+        const updatedMessage = {
+            ...target,
+            parts: parts,
+            updatedAt: now.toISOString()
+        };
+        messages[lastUserIndex] = updatedMessage;
+        const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(messages);
+        $cbb62fb16c5d45ff$var$callCallbacks(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)), "onMessageUpdated", updatedMessage);
+        set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+        return;
+    }
+    // Create a new user message initialized with this transcript
+    const newMessage = {
+        role: "user",
+        final: false,
+        parts: [
+            {
+                text: text,
+                final: final,
+                createdAt: now.toISOString()
+            }
+        ],
+        createdAt: now.toISOString(),
+        updatedAt: now.toISOString()
+    };
+    const updatedMessages = [
+        ...messages,
+        newMessage
+    ];
+    const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(updatedMessages);
+    $cbb62fb16c5d45ff$var$callCallbacks(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)), "onMessageCreated", newMessage);
+    set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+}
+function $cbb62fb16c5d45ff$export$d78810e35f742a16(get, set, text, final, spoken, aggregatedBy) {
+    // Strip turn-completion markers emitted by FilterIncompleteTurns before
+    // the text enters conversation state.
+    text = $cbb62fb16c5d45ff$export$146b18879fa8cfd7(text);
+    if (text.length === 0) return;
+    const now = new Date();
+    const messages = [
+        ...get((0, $28e6b30207a0392e$export$92a4076839a978d0))
+    ];
+    const botOutputMessageState = new Map(get((0, $28e6b30207a0392e$export$bd01e11bc95333a1)));
+    const lastAssistantIndex = (0, $f4fa178c5adc67bb$export$8855a8be7bd3e9f8)(messages, (msg)=>msg.role === "assistant");
+    let messageId;
+    let isNewMessage = false;
+    if (lastAssistantIndex === -1) {
+        // Create new assistant message
+        isNewMessage = true;
+        messageId = now.toISOString();
+        const newMessage = {
+            role: "assistant",
+            final: final,
+            parts: [],
+            createdAt: messageId,
+            updatedAt: messageId
+        };
+        messages.push(newMessage);
+        // Initialize message state
+        botOutputMessageState.set(messageId, {
+            currentPartIndex: 0,
+            currentCharIndex: 0,
+            partFinalFlags: []
+        });
+    } else {
+        // Update existing assistant message
+        const lastMessage = messages[lastAssistantIndex];
+        messageId = lastMessage.createdAt;
+        messages[lastAssistantIndex] = {
+            ...lastMessage,
+            final: final ? true : lastMessage.final,
+            updatedAt: now.toISOString()
+        };
+        // Ensure message state exists
+        if (!botOutputMessageState.has(messageId)) botOutputMessageState.set(messageId, {
+            currentPartIndex: 0,
+            currentCharIndex: 0,
+            partFinalFlags: []
+        });
+    }
+    const messageState = botOutputMessageState.get(messageId);
+    const message = messages[lastAssistantIndex === -1 ? messages.length - 1 : lastAssistantIndex];
+    const parts = [
+        ...message.parts || []
+    ];
+    if (!spoken) {
+        // UNSPOKEN EVENT: Create/update message parts immediately
+        // Only append when both current and last part are word-level; sentence-level
+        // and other types each get their own part so spoken events can match 1:1.
+        const isDefaultType = aggregatedBy === "sentence" || aggregatedBy === "word" || !aggregatedBy;
+        const lastPart = parts[parts.length - 1];
+        const shouldAppend = lastPart && aggregatedBy === "word" && lastPart.aggregatedBy === "word" && typeof lastPart.text === "string";
+        if (shouldAppend) {
+            // Append to last part (word-level only)
+            const lastPartText = lastPart.text;
+            const separator = lastPartText && !lastPartText.endsWith(" ") && !text.startsWith(" ") ? " " : "";
+            parts[parts.length - 1] = {
+                ...lastPart,
+                text: lastPartText + separator + text
+            };
+        } else {
+            // Create new part (sentence-level, custom types, or first word chunk)
+            // Default to inline; custom types get displayMode from metadata in the hook
+            const defaultDisplayMode = isDefaultType ? "inline" : undefined;
+            const newPart = {
+                text: text,
+                final: false,
+                createdAt: now.toISOString(),
+                aggregatedBy: aggregatedBy,
+                displayMode: defaultDisplayMode
+            };
+            parts.push(newPart);
+            // Extend partFinalFlags array
+            messageState.partFinalFlags.push(false);
+        }
+        // Update message with new parts
+        messages[lastAssistantIndex === -1 ? messages.length - 1 : lastAssistantIndex] = {
+            ...message,
+            parts: parts
+        };
+    } else {
+        // SPOKEN EVENT: advance cursor into existing text, or add as new part if
+        // there is none (bots that only send spoken: true, never unspoken).
+        const advanced = parts.length > 0 && (0, $ad0c8ea1ee293a79$export$9b39fd8438081d6d)(messageState, parts, text);
+        if (!advanced) {
+            // No unspoken content to advance: add this text as a part already fully spoken
+            const isDefaultType = aggregatedBy === "sentence" || aggregatedBy === "word" || !aggregatedBy;
+            const defaultDisplayMode = isDefaultType ? "inline" : undefined;
+            const newPart = {
+                text: text,
+                final: false,
+                createdAt: now.toISOString(),
+                aggregatedBy: aggregatedBy,
+                displayMode: defaultDisplayMode
+            };
+            parts.push(newPart);
+            messageState.partFinalFlags.push(true);
+            messageState.currentPartIndex = parts.length - 1;
+            messageState.currentCharIndex = text.length;
+            messages[lastAssistantIndex === -1 ? messages.length - 1 : lastAssistantIndex] = {
+                ...message,
+                parts: parts
+            };
+        }
+    }
+    const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(messages);
+    const cbs = get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab));
+    const updatedMsg = messages[lastAssistantIndex === -1 ? messages.length - 1 : lastAssistantIndex];
+    if (isNewMessage) $cbb62fb16c5d45ff$var$callCallbacks(cbs, "onMessageCreated", updatedMsg);
+    else $cbb62fb16c5d45ff$var$callCallbacks(cbs, "onMessageUpdated", updatedMsg);
+    set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+    set((0, $28e6b30207a0392e$export$bd01e11bc95333a1), botOutputMessageState);
+}
+function $cbb62fb16c5d45ff$export$e450805545c7dd86(get, set, data) {
+    const messages = get((0, $28e6b30207a0392e$export$92a4076839a978d0));
+    // If a tool_call_id is provided, check for an existing entry to avoid duplicates
+    if (data.tool_call_id) {
+        const existingIndex = (0, $f4fa178c5adc67bb$export$8855a8be7bd3e9f8)(messages, (msg)=>msg.role === "function_call" && msg.functionCall?.tool_call_id === data.tool_call_id);
+        if (existingIndex !== -1) return;
+    }
+    const now = new Date();
+    // If the most recent message is an active (non-final) assistant message,
+    // backdate the function call so it sorts before the assistant's createdAt.
+    // This prevents the function call from splitting the bot's response across
+    // two bubbles and breaking the karaoke cursor.
+    const lastMessage = messages[messages.length - 1];
+    let timestamp;
+    if (lastMessage?.role === "assistant" && lastMessage.final === false) {
+        const assistantTime = new Date(lastMessage.createdAt);
+        timestamp = new Date(assistantTime.getTime() - 1).toISOString();
+    } else timestamp = now.toISOString();
+    const message = {
+        role: "function_call",
+        final: false,
+        parts: [],
+        createdAt: timestamp,
+        updatedAt: now.toISOString(),
+        functionCall: {
+            function_name: data.function_name,
+            tool_call_id: data.tool_call_id,
+            args: data.args,
+            status: "started"
+        }
+    };
+    const updatedMessages = [
+        ...messages,
+        message
+    ];
+    const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(updatedMessages);
+    $cbb62fb16c5d45ff$var$callCallbacks(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)), "onMessageCreated", message);
+    set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+}
+function $cbb62fb16c5d45ff$export$1908264de3a8afe4(get, set, tool_call_id, updates) {
+    const messages = [
+        ...get((0, $28e6b30207a0392e$export$92a4076839a978d0))
+    ];
+    const index = (0, $f4fa178c5adc67bb$export$8855a8be7bd3e9f8)(messages, (msg)=>msg.role === "function_call" && msg.functionCall?.tool_call_id === tool_call_id);
+    if (index === -1) return false;
+    const existing = messages[index];
+    const updated = {
+        ...existing,
+        updatedAt: new Date().toISOString(),
+        final: updates.status === "completed" ? true : existing.final,
+        functionCall: {
+            ...existing.functionCall,
+            ...updates
+        }
+    };
+    messages[index] = updated;
+    const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(messages);
+    $cbb62fb16c5d45ff$var$callCallbacks(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)), "onMessageUpdated", updated);
+    set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+    return true;
+}
+function $cbb62fb16c5d45ff$export$54b3765e641b1813(get, set, updates) {
+    const messages = [
+        ...get((0, $28e6b30207a0392e$export$92a4076839a978d0))
+    ];
+    const index = (0, $f4fa178c5adc67bb$export$8855a8be7bd3e9f8)(messages, (msg)=>msg.role === "function_call" && msg.functionCall?.status === "started" && !msg.functionCall?.tool_call_id);
+    if (index === -1) return false;
+    const existing = messages[index];
+    const updated = {
+        ...existing,
+        updatedAt: new Date().toISOString(),
+        functionCall: {
+            ...existing.functionCall,
+            ...updates
+        }
+    };
+    messages[index] = updated;
+    const processedMessages = $cbb62fb16c5d45ff$var$normalizeMessagesForUI(messages);
+    $cbb62fb16c5d45ff$var$callCallbacks(get((0, $28e6b30207a0392e$export$b0cd27059c88d0ab)), "onMessageUpdated", updated);
+    set((0, $28e6b30207a0392e$export$92a4076839a978d0), processedMessages);
+    return true;
+}
+function $cbb62fb16c5d45ff$export$809efdca1a10761a(get, set, data) {
+    const messages = get((0, $28e6b30207a0392e$export$92a4076839a978d0));
+    const lastFc = (0, $f4fa178c5adc67bb$export$296de88ccac4bedb)(messages, (m)=>m.role === "function_call");
+    // Check if InProgress already created an entry (events arrived out of order).
+    if (lastFc?.functionCall && lastFc.functionCall.status !== "started" && Date.now() - new Date(lastFc.updatedAt ?? lastFc.createdAt).getTime() < 2000) {
+        if (data.function_name && !lastFc.functionCall.function_name && lastFc.functionCall.tool_call_id) $cbb62fb16c5d45ff$export$1908264de3a8afe4(get, set, lastFc.functionCall.tool_call_id, {
+            function_name: data.function_name
+        });
+        return;
+    }
+    $cbb62fb16c5d45ff$export$e450805545c7dd86(get, set, {
+        function_name: data.function_name
+    });
+}
+function $cbb62fb16c5d45ff$export$568cde5f4aa4dcba(get, set, data) {
+    // Tier 1: Try to update the last "started" entry (from LLMFunctionCallStarted)
+    const updated = $cbb62fb16c5d45ff$export$54b3765e641b1813(get, set, {
+        function_name: data.function_name,
+        tool_call_id: data.tool_call_id,
+        args: data.args,
+        status: "in_progress"
+    });
+    if (!updated) {
+        // Tier 2: Try updating an existing entry by tool_call_id
+        const found = $cbb62fb16c5d45ff$export$1908264de3a8afe4(get, set, data.tool_call_id, {
+            function_name: data.function_name,
+            args: data.args,
+            status: "in_progress"
+        });
+        if (!found) {
+            // Tier 3: No existing entry at all; create a new one as in_progress
+            $cbb62fb16c5d45ff$export$e450805545c7dd86(get, set, {
+                function_name: data.function_name,
+                tool_call_id: data.tool_call_id,
+                args: data.args
+            });
+            $cbb62fb16c5d45ff$export$1908264de3a8afe4(get, set, data.tool_call_id, {
+                status: "in_progress"
+            });
+        }
+    }
+}
+function $cbb62fb16c5d45ff$export$a3cea3f7508e820b(get, set, data) {
+    // Tier 1: Try updating by tool_call_id
+    const found = $cbb62fb16c5d45ff$export$1908264de3a8afe4(get, set, data.tool_call_id, {
+        function_name: data.function_name,
+        status: "completed",
+        result: data.result,
+        cancelled: data.cancelled
+    });
+    if (!found) {
+        // Tier 2: No match by tool_call_id (e.g. InProgress was skipped).
+        const matched = $cbb62fb16c5d45ff$export$54b3765e641b1813(get, set, {
+            function_name: data.function_name,
+            tool_call_id: data.tool_call_id
+        });
+        if (matched) $cbb62fb16c5d45ff$export$1908264de3a8afe4(get, set, data.tool_call_id, {
+            status: "completed",
+            result: data.result,
+            cancelled: data.cancelled
+        });
+    }
+}
+
+
+
+/**
+ * Copyright (c) 2024, Daily.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */ 
+
+
 /**
  * Copyright (c) 2024, Daily.
  *
@@ -90,6 +868,239 @@ const $8a6b68ebf0332682$export$33a6ac53b8f02625 = (event, handler)=>{
 };
 
 
+
+
+
+
+/**
+ * Checks if a version meets a minimum version requirement.
+ * Inlined to avoid adding a `semver` dependency.
+ */ function $40515932ecd2dc41$var$isMinVersion(currentVersion, minVersion) {
+    // Strip pre-release suffix (e.g. "1.1.0-beta.1" -> "1.1.0")
+    const parts = currentVersion.split("-")[0].split(".").map(Number);
+    for(let i = 0; i < 3; i++){
+        if ((parts[i] || 0) > minVersion[i]) return true;
+        if ((parts[i] || 0) < minVersion[i]) return false;
+    }
+    return true; // equal
+}
+/** Delay (ms) before finalizing the assistant message after bot stops speaking. */ const $40515932ecd2dc41$var$BOT_STOPPED_FINALIZE_DELAY_MS = 2500;
+function $40515932ecd2dc41$export$52680e26621bab39() {
+    const userStoppedTimeout = (0, $5Zyvw$react.useRef)(undefined);
+    const botStoppedSpeakingTimeoutRef = (0, $5Zyvw$react.useRef)(undefined);
+    const assistantStreamResetRef = (0, $5Zyvw$react.useRef)(0);
+    const botOutputLastChunkRef = (0, $5Zyvw$react.useRef)({
+        spoken: "",
+        unspoken: ""
+    });
+    // Clean up pending timeouts on unmount
+    (0, $5Zyvw$react.useEffect)(()=>{
+        return ()=>{
+            clearTimeout(userStoppedTimeout.current);
+            clearTimeout(botStoppedSpeakingTimeoutRef.current);
+        };
+    }, []);
+    // -- helpers ---------------------------------------------------------------
+    const finalizeLastAssistantMessageIfPending = (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set)=>{
+        clearTimeout(botStoppedSpeakingTimeoutRef.current);
+        botStoppedSpeakingTimeoutRef.current = undefined;
+        const messages = get((0, $28e6b30207a0392e$export$92a4076839a978d0));
+        const lastAssistant = (0, $f4fa178c5adc67bb$export$296de88ccac4bedb)(messages, (m)=>m.role === "assistant");
+        if (lastAssistant && !lastAssistant.final) (0, $cbb62fb16c5d45ff$export$78bd074993ab081f)(get, set, "assistant");
+    }, []));
+    const ensureAssistantMessage = (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set)=>{
+        const messages = get((0, $28e6b30207a0392e$export$92a4076839a978d0));
+        const lastAssistantIndex = (0, $f4fa178c5adc67bb$export$8855a8be7bd3e9f8)(messages, (msg)=>msg.role === "assistant");
+        const lastAssistant = lastAssistantIndex !== -1 ? messages[lastAssistantIndex] : undefined;
+        if (!lastAssistant || lastAssistant.final) {
+            // If the message was finalized but still has unspoken content, it was
+            // finalized prematurely (e.g. BotStoppedSpeaking timer fired during a
+            // TTS pause mid-response). Un-finalize it instead of creating a new
+            // message bubble — but only when no user message followed.
+            if (lastAssistant?.final && lastAssistantIndex === messages.length - 1) {
+                const messageId = lastAssistant.createdAt;
+                const botOutputState = get((0, $28e6b30207a0392e$export$bd01e11bc95333a1));
+                const cursor = botOutputState.get(messageId);
+                if (cursor && (0, $ad0c8ea1ee293a79$export$802e9b947136afbf)(cursor, lastAssistant.parts || [])) {
+                    (0, $cbb62fb16c5d45ff$export$a05f96a2aa40873e)(get, set, "assistant", {
+                        final: false
+                    });
+                    return false;
+                }
+            }
+            (0, $cbb62fb16c5d45ff$export$16fdb433d434f08)(get, set, {
+                role: "assistant",
+                final: false,
+                parts: []
+            });
+            assistantStreamResetRef.current += 1;
+            return true;
+        }
+        return false;
+    }, []));
+    // -- event handlers --------------------------------------------------------
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).Connected, (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set)=>{
+        (0, $cbb62fb16c5d45ff$export$f2434643f2abff11)(get, set);
+        set((0, $28e6b30207a0392e$export$57b1a1df06a7e728), null);
+        clearTimeout(botStoppedSpeakingTimeoutRef.current);
+        botStoppedSpeakingTimeoutRef.current = undefined;
+        botOutputLastChunkRef.current = {
+            spoken: "",
+            unspoken: ""
+        };
+    }, [])));
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).BotReady, (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((_get, set, botData)=>{
+        const rtviVersion = botData.version;
+        const supportsBotOutput = $40515932ecd2dc41$var$isMinVersion(rtviVersion, [
+            1,
+            1,
+            0
+        ]);
+        set((0, $28e6b30207a0392e$export$57b1a1df06a7e728), supportsBotOutput);
+    }, [])));
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).BotOutput, (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set, data)=>{
+        // A BotOutput event means the response is still active; cancel any
+        // pending finalize timer from BotStoppedSpeaking.
+        clearTimeout(botStoppedSpeakingTimeoutRef.current);
+        botStoppedSpeakingTimeoutRef.current = undefined;
+        ensureAssistantMessage();
+        // Handle spacing for BotOutput chunks
+        let textToAdd = data.text;
+        const lastChunk = data.spoken ? botOutputLastChunkRef.current.spoken : botOutputLastChunkRef.current.unspoken;
+        // Add space separator if needed between BotOutput chunks
+        if (lastChunk) textToAdd = " " + textToAdd;
+        // Update the appropriate last chunk tracker
+        if (data.spoken) botOutputLastChunkRef.current.spoken = textToAdd;
+        else botOutputLastChunkRef.current.unspoken = textToAdd;
+        // Update both spoken and unspoken text streams
+        const isFinal = data.aggregated_by === "sentence";
+        (0, $cbb62fb16c5d45ff$export$d78810e35f742a16)(get, set, textToAdd, isFinal, data.spoken, data.aggregated_by);
+    }, [
+        ensureAssistantMessage
+    ])));
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).BotStoppedSpeaking, (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set)=>{
+        // Don't finalize immediately; start a timer. Bot may start speaking again (pause).
+        clearTimeout(botStoppedSpeakingTimeoutRef.current);
+        const messages = get((0, $28e6b30207a0392e$export$92a4076839a978d0));
+        const lastAssistant = (0, $f4fa178c5adc67bb$export$296de88ccac4bedb)(messages, (m)=>m.role === "assistant");
+        if (!lastAssistant || lastAssistant.final) return;
+        botStoppedSpeakingTimeoutRef.current = setTimeout(()=>{
+            botStoppedSpeakingTimeoutRef.current = undefined;
+            // Snap the speech-progress cursor to the end of all parts.
+            // The bot finished speaking normally (not interrupted), so all
+            // text should render as "spoken". Without this, text from the
+            // last sentence can remain grey if the spoken BotOutput event
+            // didn't match the unspoken text exactly.
+            const msgs = get((0, $28e6b30207a0392e$export$92a4076839a978d0));
+            const cursorMap = new Map(get((0, $28e6b30207a0392e$export$bd01e11bc95333a1)));
+            const last = (0, $f4fa178c5adc67bb$export$296de88ccac4bedb)(msgs, (m)=>m.role === "assistant");
+            if (last) {
+                const cursor = cursorMap.get(last.createdAt);
+                if (cursor && last.parts && last.parts.length > 0) {
+                    const lastPartIdx = last.parts.length - 1;
+                    const lastPartText = last.parts[lastPartIdx]?.text;
+                    cursor.currentPartIndex = lastPartIdx;
+                    cursor.currentCharIndex = typeof lastPartText === "string" ? lastPartText.length : 0;
+                    for(let i = 0; i <= lastPartIdx; i++)cursor.partFinalFlags[i] = true;
+                    set((0, $28e6b30207a0392e$export$bd01e11bc95333a1), cursorMap);
+                }
+            }
+            (0, $cbb62fb16c5d45ff$export$78bd074993ab081f)(get, set, "assistant");
+        }, $40515932ecd2dc41$var$BOT_STOPPED_FINALIZE_DELAY_MS);
+    }, [])));
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).BotStartedSpeaking, (0, $5Zyvw$react.useCallback)(()=>{
+        // Bot is speaking again; reset the finalize timer (bot was just pausing).
+        clearTimeout(botStoppedSpeakingTimeoutRef.current);
+        botStoppedSpeakingTimeoutRef.current = undefined;
+    }, []));
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).UserStartedSpeaking, (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set)=>{
+        // User started a new turn; bot's turn is done. Fast-forward: finalize immediately.
+        finalizeLastAssistantMessageIfPending();
+        clearTimeout(userStoppedTimeout.current);
+        // Only finalize the previous user message if the bot has responded since
+        // the user last spoke. This prevents finalizing during VAD gaps (brief
+        // breathing pauses within the same user turn where UserStoppedSpeaking/
+        // UserStartedSpeaking fire without an actual turn change).
+        const messages = get((0, $28e6b30207a0392e$export$92a4076839a978d0));
+        const lastUserIdx = (0, $f4fa178c5adc67bb$export$8855a8be7bd3e9f8)(messages, (m)=>m.role === "user");
+        if (lastUserIdx !== -1 && !messages[lastUserIdx].final) {
+            const hasBotActivityAfterUser = messages.slice(lastUserIdx + 1).some((m)=>m.role === "assistant");
+            if (hasBotActivityAfterUser) (0, $cbb62fb16c5d45ff$export$78bd074993ab081f)(get, set, "user");
+        }
+    }, [
+        finalizeLastAssistantMessageIfPending
+    ])));
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).UserTranscript, (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set, data)=>{
+        const text = data.text ?? "";
+        const final = Boolean(data.final);
+        (0, $cbb62fb16c5d45ff$export$57de01211e3df548)(get, set, text, final);
+        // If we got any transcript, cancel pending cleanup
+        clearTimeout(userStoppedTimeout.current);
+    }, [])));
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).UserStoppedSpeaking, (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set)=>{
+        clearTimeout(userStoppedTimeout.current);
+        // If no transcript ends up arriving, ensure any accidental empty placeholder is removed.
+        userStoppedTimeout.current = setTimeout(()=>{
+            // Re-read state at timeout time
+            const messages = get((0, $28e6b30207a0392e$export$92a4076839a978d0));
+            const lastUser = (0, $f4fa178c5adc67bb$export$296de88ccac4bedb)(messages, (m)=>m.role === "user");
+            const hasParts = Array.isArray(lastUser?.parts) && lastUser.parts.length > 0;
+            if (!lastUser || !hasParts) (0, $cbb62fb16c5d45ff$export$cd74f809c89ea10c)(get, set, "user");
+            else if (!lastUser.final) (0, $cbb62fb16c5d45ff$export$78bd074993ab081f)(get, set, "user");
+        }, 3000);
+    }, [])));
+    // LLM Function Call lifecycle events
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).LLMFunctionCallStarted, (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set, data)=>{
+        (0, $cbb62fb16c5d45ff$export$809efdca1a10761a)(get, set, {
+            function_name: data.function_name
+        });
+    }, [])));
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).LLMFunctionCallInProgress, (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set, data)=>{
+        (0, $cbb62fb16c5d45ff$export$568cde5f4aa4dcba)(get, set, {
+            function_name: data.function_name,
+            tool_call_id: data.tool_call_id,
+            args: data.arguments
+        });
+    }, [])));
+    (0, $8a6b68ebf0332682$export$33a6ac53b8f02625)((0, $5Zyvw$pipecataiclientjs.RTVIEvent).LLMFunctionCallStopped, (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set, data)=>{
+        (0, $cbb62fb16c5d45ff$export$a3cea3f7508e820b)(get, set, {
+            function_name: data.function_name,
+            tool_call_id: data.tool_call_id,
+            result: data.result,
+            cancelled: data.cancelled
+        });
+    }, [])));
+}
+
+
+const $984246ab4e966dee$export$4d68d6035e4164b1 = /*#__PURE__*/ (0, $5Zyvw$react.createContext)(null);
+const $984246ab4e966dee$export$e372a2172e7d18e8 = ({ children: children })=>{
+    (0, $40515932ecd2dc41$export$52680e26621bab39)();
+    const injectMessage = (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set, message)=>{
+        (0, $cbb62fb16c5d45ff$export$c3a007efc2f315a0)(get, set, message);
+    }, []));
+    const botOutputSupported = (0, $5Zyvw$jotai.useAtomValue)((0, $28e6b30207a0392e$export$57b1a1df06a7e728));
+    return (0, $5Zyvw$reactjsxruntime.jsx)($984246ab4e966dee$export$4d68d6035e4164b1.Provider, {
+        value: {
+            injectMessage: injectMessage,
+            botOutputSupported: botOutputSupported
+        },
+        children: children
+    });
+};
+$984246ab4e966dee$export$e372a2172e7d18e8.displayName = "PipecatConversationProvider";
+const $984246ab4e966dee$export$8eec679bf8249822 = ()=>{
+    const context = (0, $5Zyvw$react.useContext)($984246ab4e966dee$export$4d68d6035e4164b1);
+    if (!context) throw new Error("useConversationContext must be used within a PipecatClientProvider");
+    return context;
+};
+
+
+
+
+
+
+
 const $44c6278d186dd94f$export$d6bdcccacef16204 = /*#__PURE__*/ (0, $5Zyvw$react.createContext)({
     enableCam: ()=>{
         throw new Error("PipecatClientCamStateContext: enableCam() called outside of provider");
@@ -224,7 +1235,9 @@ const $8df0e777e4d7dd49$export$bb43666ced7a20d0 = ({ children: children, client:
                     off: off
                 },
                 children: (0, $5Zyvw$reactjsxruntime.jsx)((0, $44c6278d186dd94f$export$4777554fda61c378), {
-                    children: children
+                    children: (0, $5Zyvw$reactjsxruntime.jsx)((0, $984246ab4e966dee$export$e372a2172e7d18e8), {
+                        children: children
+                    })
                 })
             })
         })
@@ -870,4 +1883,125 @@ $a1dfa75b13e6bb9b$export$59bf27bd43679db6.displayName = "VoiceVisualizer";
 
 
 
+/**
+ * Copyright (c) 2024, Daily.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */ 
+
+
+
+
+
+const $fe6dfdd0b8560c78$export$acb832b064cb6c09 = ({ onMessageCreated: onMessageCreated, onMessageUpdated: onMessageUpdated, onMessageAdded: onMessageAdded, aggregationMetadata: aggregationMetadata } = {})=>{
+    const { injectMessage: injectMessage } = (0, $984246ab4e966dee$export$8eec679bf8249822)();
+    // Generate a unique ID for this hook instance
+    const callbackId = (0, $5Zyvw$react.useId)();
+    // Resolve deprecated onMessageAdded → onMessageCreated
+    const resolvedCreated = onMessageCreated ?? onMessageAdded;
+    // Register and unregister the callbacks
+    const doRegister = (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set)=>{
+        (0, $cbb62fb16c5d45ff$export$f2820c5e040afe17)(get, set, callbackId, {
+            onMessageCreated: resolvedCreated,
+            onMessageUpdated: onMessageUpdated
+        });
+    }, [
+        callbackId,
+        resolvedCreated,
+        onMessageUpdated
+    ]));
+    const doUnregister = (0, $5Zyvw$jotaiutils.useAtomCallback)((0, $5Zyvw$react.useCallback)((get, set)=>{
+        (0, $cbb62fb16c5d45ff$export$46ae1ba121fdc956)(get, set, callbackId);
+    }, [
+        callbackId
+    ]));
+    (0, $5Zyvw$react.useEffect)(()=>{
+        doRegister();
+        return ()=>{
+            doUnregister();
+        };
+    }, [
+        doRegister,
+        doUnregister
+    ]);
+    // Get the raw state from atoms
+    const messages = (0, $5Zyvw$jotai.useAtomValue)((0, $28e6b30207a0392e$export$92a4076839a978d0));
+    const botOutputMessageState = (0, $5Zyvw$jotai.useAtomValue)((0, $28e6b30207a0392e$export$bd01e11bc95333a1));
+    // Memoize the filtered messages to prevent infinite loops
+    const filteredMessages = (0, $5Zyvw$react.useMemo)(()=>{
+        const getMetadata = (part)=>{
+            return part.aggregatedBy ? aggregationMetadata?.[part.aggregatedBy] : undefined;
+        };
+        // Process messages: convert string parts to BotOutputText based on position state
+        const processedMessages = messages.map((message)=>{
+            if (message.role === "assistant") {
+                const messageId = message.createdAt;
+                const messageState = botOutputMessageState.get(messageId);
+                if (!messageState) // No state yet, return message as-is
+                return message;
+                const parts = message.parts || [];
+                // Find the actual current part index (skip parts that aren't meant to be spoken)
+                let actualCurrentPartIndex = messageState.currentPartIndex;
+                while(actualCurrentPartIndex < parts.length){
+                    const part = parts[actualCurrentPartIndex];
+                    if (typeof part?.text !== "string") break;
+                    const isSpoken = getMetadata(part)?.isSpoken !== false;
+                    if (isSpoken) break;
+                    actualCurrentPartIndex++;
+                }
+                if (parts.length > 0 && actualCurrentPartIndex >= parts.length) actualCurrentPartIndex = parts.length - 1;
+                // Convert parts to BotOutputText format based on position state
+                const processedParts = parts.map((part, partIndex)=>{
+                    // If part text is not a string, it's already processed (e.g., ReactNode)
+                    if (typeof part.text !== "string") return part;
+                    const metadata = getMetadata(part);
+                    const displayMode = part.displayMode ?? metadata?.displayMode ?? "inline";
+                    const isSpoken = metadata?.isSpoken !== false;
+                    const partText = displayMode === "block" && !isSpoken ? part.text.trim() : part.text;
+                    if (!isSpoken) return {
+                        ...part,
+                        displayMode: displayMode,
+                        text: {
+                            spoken: "",
+                            unspoken: partText
+                        }
+                    };
+                    // Use cursor split for the part at actualCurrentPartIndex for every message,
+                    // so previous (e.g. interrupted) messages keep partially spoken state.
+                    const isPartAtCursor = partIndex === actualCurrentPartIndex;
+                    const currentCharIndex = messageState.currentCharIndex;
+                    const spokenText = isPartAtCursor ? partText.slice(0, currentCharIndex) : partIndex < actualCurrentPartIndex ? partText : "";
+                    const unspokenText = isPartAtCursor ? partText.slice(currentCharIndex) : partIndex < actualCurrentPartIndex ? "" : partText;
+                    return {
+                        ...part,
+                        displayMode: displayMode,
+                        text: {
+                            spoken: spokenText,
+                            unspoken: unspokenText
+                        }
+                    };
+                });
+                return {
+                    ...message,
+                    parts: processedParts
+                };
+            }
+            return message;
+        });
+        // Messages are already normalized (sorted, filtered, deduped, merged) on write.
+        return processedMessages;
+    }, [
+        messages,
+        botOutputMessageState,
+        aggregationMetadata
+    ]);
+    return {
+        messages: filteredMessages,
+        injectMessage: injectMessage
+    };
+};
+
+
+
+
 //# sourceMappingURL=index.js.map