@browser-ai/core 2.1.2 → 2.1.4

package/dist/index.mjs

@@ -454,7 +454,267 @@ var ToolCallFenceDetector = class {
   }
 };
 
-// src/convert-to-browser-ai-messages.ts
+// ../shared/src/streaming/tool-call-stream-utils.ts
+function extractToolName(content) {
+  const jsonMatch = content.match(/\{\s*"name"\s*:\s*"([^"]+)"/);
+  if (jsonMatch) {
+    return jsonMatch[1];
+  }
+  return null;
+}
+var ARGUMENTS_FIELD_REGEX = /"arguments"\s*:\s*/g;
+var ARGUMENTS_SEARCH_OVERLAP = 32;
+function createArgumentsStreamState() {
+  return {
+    searchFrom: 0,
+    valueStartIndex: null,
+    parseIndex: 0,
+    started: false,
+    depth: 0,
+    inString: false,
+    escaped: false,
+    complete: false
+  };
+}
+function extractArgumentsDelta(content, state) {
+  if (state.complete) {
+    return "";
+  }
+  if (state.valueStartIndex === null) {
+    ARGUMENTS_FIELD_REGEX.lastIndex = state.searchFrom;
+    const match = ARGUMENTS_FIELD_REGEX.exec(content);
+    ARGUMENTS_FIELD_REGEX.lastIndex = 0;
+    if (!match || match.index === void 0) {
+      state.searchFrom = Math.max(0, content.length - ARGUMENTS_SEARCH_OVERLAP);
+      return "";
+    }
+    state.valueStartIndex = match.index + match[0].length;
+    state.parseIndex = state.valueStartIndex;
+    state.searchFrom = state.valueStartIndex;
+  }
+  if (state.parseIndex >= content.length) {
+    return "";
+  }
+  let delta = "";
+  for (let i = state.parseIndex; i < content.length; i++) {
+    const char = content[i];
+    delta += char;
+    if (!state.started) {
+      if (!/\s/.test(char)) {
+        state.started = true;
+        if (char === "{" || char === "[") {
+          state.depth = 1;
+        }
+      }
+      continue;
+    }
+    if (state.escaped) {
+      state.escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      state.escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      state.inString = !state.inString;
+      continue;
+    }
+    if (!state.inString) {
+      if (char === "{" || char === "[") {
+        state.depth += 1;
+      } else if (char === "}" || char === "]") {
+        if (state.depth > 0) {
+          state.depth -= 1;
+          if (state.depth === 0) {
+            state.parseIndex = i + 1;
+            state.complete = true;
+            return delta;
+          }
+        }
+      }
+    }
+  }
+  state.parseIndex = content.length;
+  return delta;
+}
+
+// ../shared/src/streaming/stream-processor.ts
+function generateToolCallId2() {
+  return `call_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+async function processToolCallStream(chunks, emitTextDelta, controller, options) {
+  const fenceDetector = new ToolCallFenceDetector();
+  let currentToolCallId = null;
+  let toolInputStartEmitted = false;
+  let accumulatedFenceContent = "";
+  let argumentsStreamState = createArgumentsStreamState();
+  let insideFence = false;
+  let toolCallDetected = false;
+  let toolCalls = [];
+  let trailingText = "";
+  const resetFenceState = () => {
+    currentToolCallId = null;
+    toolInputStartEmitted = false;
+    accumulatedFenceContent = "";
+    argumentsStreamState = createArgumentsStreamState();
+    insideFence = false;
+  };
+  for await (const chunk of chunks) {
+    if (toolCallDetected) {
+      continue;
+    }
+    fenceDetector.addChunk(chunk);
+    while (fenceDetector.hasContent()) {
+      const wasInsideFence = insideFence;
+      const result = fenceDetector.detectStreamingFence();
+      insideFence = result.inFence;
+      let madeProgress = false;
+      if (!wasInsideFence && result.inFence) {
+        if (result.safeContent) {
+          emitTextDelta(result.safeContent);
+          madeProgress = true;
+        }
+        currentToolCallId = generateToolCallId2();
+        toolInputStartEmitted = false;
+        accumulatedFenceContent = "";
+        argumentsStreamState = createArgumentsStreamState();
+        insideFence = true;
+        continue;
+      }
+      if (result.completeFence) {
+        madeProgress = true;
+        if (result.safeContent) {
+          accumulatedFenceContent += result.safeContent;
+        }
+        if (toolInputStartEmitted && currentToolCallId) {
+          const delta = extractArgumentsDelta(
+            accumulatedFenceContent,
+            argumentsStreamState
+          );
+          if (delta.length > 0) {
+            controller.enqueue({
+              type: "tool-input-delta",
+              id: currentToolCallId,
+              delta
+            });
+          }
+        }
+        const parsed = parseJsonFunctionCalls(result.completeFence);
+        const selectedToolCalls = parsed.toolCalls.slice(0, 1);
+        if (selectedToolCalls.length === 0) {
+          emitTextDelta(result.completeFence);
+          if (result.textAfterFence) {
+            emitTextDelta(result.textAfterFence);
+          }
+          resetFenceState();
+          continue;
+        }
+        if (currentToolCallId) {
+          selectedToolCalls[0].toolCallId = currentToolCallId;
+        }
+        for (const [index, call] of selectedToolCalls.entries()) {
+          const toolCallId = index === 0 && currentToolCallId ? currentToolCallId : call.toolCallId;
+          const toolName = call.toolName;
+          const argsJson = JSON.stringify(call.args ?? {});
+          if (toolCallId === currentToolCallId) {
+            if (!toolInputStartEmitted) {
+              controller.enqueue({
+                type: "tool-input-start",
+                id: toolCallId,
+                toolName
+              });
+              toolInputStartEmitted = true;
+            }
+            const delta = extractArgumentsDelta(
+              accumulatedFenceContent,
+              argumentsStreamState
+            );
+            if (delta.length > 0) {
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: toolCallId,
+                delta
+              });
+            }
+          } else {
+            controller.enqueue({
+              type: "tool-input-start",
+              id: toolCallId,
+              toolName
+            });
+            if (argsJson.length > 0) {
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: toolCallId,
+                delta: argsJson
+              });
+            }
+          }
+          controller.enqueue({ type: "tool-input-end", id: toolCallId });
+          controller.enqueue({
+            type: "tool-call",
+            toolCallId,
+            toolName,
+            input: argsJson,
+            providerExecuted: false
+          });
+        }
+        trailingText = result.textAfterFence ?? "";
+        toolCalls = selectedToolCalls;
+        toolCallDetected = true;
+        resetFenceState();
+        break;
+      }
+      if (insideFence) {
+        if (result.safeContent) {
+          accumulatedFenceContent += result.safeContent;
+          madeProgress = true;
+          const toolName = extractToolName(accumulatedFenceContent);
+          if (toolName && !toolInputStartEmitted && currentToolCallId) {
+            controller.enqueue({
+              type: "tool-input-start",
+              id: currentToolCallId,
+              toolName
+            });
+            toolInputStartEmitted = true;
+          }
+          if (toolInputStartEmitted && currentToolCallId) {
+            const delta = extractArgumentsDelta(
+              accumulatedFenceContent,
+              argumentsStreamState
+            );
+            if (delta.length > 0) {
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: currentToolCallId,
+                delta
+              });
+            }
+          }
+        }
+        continue;
+      }
+      if (!insideFence && result.safeContent) {
+        emitTextDelta(result.safeContent);
+        madeProgress = true;
+      }
+      if (!madeProgress) {
+        break;
+      }
+    }
+    if (toolCallDetected && options?.stopEarlyOnToolCall) {
+      break;
+    }
+  }
+  if (!toolCallDetected && fenceDetector.hasContent()) {
+    emitTextDelta(fenceDetector.getBuffer());
+    fenceDetector.clearBuffer();
+  }
+  return { toolCallDetected, toolCalls, trailingText };
+}
+
+// src/utils/convert-to-browser-ai-messages.ts
 import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
@@ -761,7 +1021,7 @@ function getExpectedInputs(prompt) {
   return Array.from(inputs).map((type) => ({ type }));
 }
 
-// src/models/session-manager.ts
+// src/chat/session-manager.ts
 import { LoadSettingError } from "@ai-sdk/provider";
 var SessionManager = class {
   /**
@@ -945,67 +1205,10 @@ var SessionManager = class {
   }
 };
 
-// src/browser-ai-language-model.ts
+// src/chat/browser-ai-language-model.ts
 function doesBrowserSupportBrowserAI() {
   return typeof LanguageModel !== "undefined";
 }
-function extractToolName(content) {
-  const jsonMatch = content.match(/\{\s*"name"\s*:\s*"([^"]+)"/);
-  if (jsonMatch) {
-    return jsonMatch[1];
-  }
-  return null;
-}
-function extractArgumentsContent(content) {
-  const match = content.match(/"arguments"\s*:\s*/);
-  if (!match || match.index === void 0) {
-    return "";
-  }
-  const startIndex = match.index + match[0].length;
-  let result = "";
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  let started = false;
-  for (let i = startIndex; i < content.length; i++) {
-    const char = content[i];
-    result += char;
-    if (!started) {
-      if (!/\s/.test(char)) {
-        started = true;
-        if (char === "{" || char === "[") {
-          depth = 1;
-        }
-      }
-      continue;
-    }
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (char === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (!inString) {
-      if (char === "{" || char === "[") {
-        depth += 1;
-      } else if (char === "}" || char === "]") {
-        if (depth > 0) {
-          depth -= 1;
-          if (depth === 0) {
-            break;
-          }
-        }
-      }
-    }
-  }
-  return result;
-}
 var BrowserAIChatLanguageModel = class {
   constructor(modelId, options = {}) {
     this.specificationVersion = "v3";
@@ -1339,226 +1542,40 @@ var BrowserAIChatLanguageModel = class {
         if (options.abortSignal) {
           options.abortSignal.addEventListener("abort", abortHandler);
         }
-        const maxIterations = 10;
-        let iteration = 0;
         try {
-          const fenceDetector = new ToolCallFenceDetector();
-          while (iteration < maxIterations && !aborted && !finished) {
-            iteration += 1;
-            const promptStream = session.promptStreaming(
-              conversationHistory,
-              streamOptions
-            );
-            currentReader = promptStream.getReader();
-            let toolCalls = [];
-            let toolBlockDetected = false;
-            let trailingTextAfterBlock = "";
-            let currentToolCallId = null;
-            let toolInputStartEmitted = false;
-            let accumulatedFenceContent = "";
-            let streamedArgumentsLength = 0;
-            let insideFence = false;
+          const promptStream = session.promptStreaming(
+            conversationHistory,
+            streamOptions
+          );
+          currentReader = promptStream.getReader();
+          const chunks = (async function* () {
             while (!aborted) {
               const { done, value } = await currentReader.read();
-              if (done) {
-                break;
-              }
-              fenceDetector.addChunk(value);
-              while (fenceDetector.hasContent()) {
-                const wasInsideFence = insideFence;
-                const result = fenceDetector.detectStreamingFence();
-                insideFence = result.inFence;
-                let madeProgress = false;
-                if (!wasInsideFence && result.inFence) {
-                  if (result.safeContent) {
-                    emitTextDelta(result.safeContent);
-                    madeProgress = true;
-                  }
-                  currentToolCallId = `call_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-                  toolInputStartEmitted = false;
-                  accumulatedFenceContent = "";
-                  streamedArgumentsLength = 0;
-                  insideFence = true;
-                  continue;
-                }
-                if (result.completeFence) {
-                  madeProgress = true;
-                  if (result.safeContent) {
-                    accumulatedFenceContent += result.safeContent;
-                  }
-                  if (toolInputStartEmitted && currentToolCallId) {
-                    const argsContent = extractArgumentsContent(
-                      accumulatedFenceContent
-                    );
-                    if (argsContent.length > streamedArgumentsLength) {
-                      const delta = argsContent.slice(streamedArgumentsLength);
-                      streamedArgumentsLength = argsContent.length;
-                      if (delta.length > 0) {
-                        controller.enqueue({
-                          type: "tool-input-delta",
-                          id: currentToolCallId,
-                          delta
-                        });
-                      }
-                    }
-                  }
-                  const parsed = parseJsonFunctionCalls(result.completeFence);
-                  const parsedToolCalls = parsed.toolCalls;
-                  const selectedToolCalls = parsedToolCalls.slice(0, 1);
-                  if (selectedToolCalls.length === 0) {
-                    toolCalls = [];
-                    toolBlockDetected = false;
-                    emitTextDelta(result.completeFence);
-                    if (result.textAfterFence) {
-                      emitTextDelta(result.textAfterFence);
-                    }
-                    currentToolCallId = null;
-                    toolInputStartEmitted = false;
-                    accumulatedFenceContent = "";
-                    streamedArgumentsLength = 0;
-                    insideFence = false;
-                    continue;
-                  }
-                  if (selectedToolCalls.length > 0 && currentToolCallId) {
-                    selectedToolCalls[0].toolCallId = currentToolCallId;
-                  }
-                  toolCalls = selectedToolCalls;
-                  toolBlockDetected = toolCalls.length > 0;
-                  for (const [index, call] of toolCalls.entries()) {
-                    const toolCallId = index === 0 && currentToolCallId ? currentToolCallId : call.toolCallId;
-                    const toolName = call.toolName;
-                    const argsJson = JSON.stringify(call.args ?? {});
-                    if (toolCallId === currentToolCallId) {
-                      if (!toolInputStartEmitted) {
-                        controller.enqueue({
-                          type: "tool-input-start",
-                          id: toolCallId,
-                          toolName
-                        });
-                        toolInputStartEmitted = true;
-                      }
-                      const argsContent = extractArgumentsContent(
-                        accumulatedFenceContent
-                      );
-                      if (argsContent.length > streamedArgumentsLength) {
-                        const delta = argsContent.slice(
-                          streamedArgumentsLength
-                        );
-                        streamedArgumentsLength = argsContent.length;
-                        if (delta.length > 0) {
-                          controller.enqueue({
-                            type: "tool-input-delta",
-                            id: toolCallId,
-                            delta
-                          });
-                        }
-                      }
-                    } else {
-                      controller.enqueue({
-                        type: "tool-input-start",
-                        id: toolCallId,
-                        toolName
-                      });
-                      if (argsJson.length > 0) {
-                        controller.enqueue({
-                          type: "tool-input-delta",
-                          id: toolCallId,
-                          delta: argsJson
-                        });
-                      }
-                    }
-                    controller.enqueue({
-                      type: "tool-input-end",
-                      id: toolCallId
-                    });
-                    controller.enqueue({
-                      type: "tool-call",
-                      toolCallId,
-                      toolName,
-                      input: argsJson,
-                      providerExecuted: false
-                    });
-                  }
-                  trailingTextAfterBlock += result.textAfterFence;
-                  madeProgress = true;
-                  if (toolBlockDetected && currentReader) {
-                    await currentReader.cancel().catch(() => void 0);
-                    break;
-                  }
-                  currentToolCallId = null;
-                  toolInputStartEmitted = false;
-                  accumulatedFenceContent = "";
-                  streamedArgumentsLength = 0;
-                  insideFence = false;
-                  continue;
-                }
-                if (insideFence) {
-                  if (result.safeContent) {
-                    accumulatedFenceContent += result.safeContent;
-                    madeProgress = true;
-                    const toolName = extractToolName(accumulatedFenceContent);
-                    if (toolName && !toolInputStartEmitted && currentToolCallId) {
-                      controller.enqueue({
-                        type: "tool-input-start",
-                        id: currentToolCallId,
-                        toolName
-                      });
-                      toolInputStartEmitted = true;
-                    }
-                    if (toolInputStartEmitted && currentToolCallId) {
-                      const argsContent = extractArgumentsContent(
-                        accumulatedFenceContent
-                      );
-                      if (argsContent.length > streamedArgumentsLength) {
-                        const delta = argsContent.slice(
-                          streamedArgumentsLength
-                        );
-                        streamedArgumentsLength = argsContent.length;
-                        if (delta.length > 0) {
-                          controller.enqueue({
-                            type: "tool-input-delta",
-                            id: currentToolCallId,
-                            delta
-                          });
-                        }
-                      }
-                    }
-                  }
-                  continue;
-                }
-                if (!insideFence && result.safeContent) {
-                  emitTextDelta(result.safeContent);
-                  madeProgress = true;
-                }
-                if (!madeProgress) {
-                  break;
-                }
-              }
-              if (toolBlockDetected) {
-                break;
-              }
+              if (done) break;
+              yield value;
             }
-            currentReader = null;
-            if (aborted) {
-              return;
-            }
-            if (!toolBlockDetected && fenceDetector.hasContent()) {
-              emitTextDelta(fenceDetector.getBuffer());
-              fenceDetector.clearBuffer();
-            }
-            if (!toolBlockDetected || toolCalls.length === 0) {
-              finishStream({ unified: "stop", raw: "stop" });
-              return;
-            }
-            if (trailingTextAfterBlock) {
-              emitTextDelta(trailingTextAfterBlock);
-            }
-            finishStream({ unified: "tool-calls", raw: "tool-calls" });
+          })();
+          const result = await processToolCallStream(
+            chunks,
+            emitTextDelta,
+            controller,
+            { stopEarlyOnToolCall: true }
+          );
+          if (result.toolCallDetected && currentReader) {
+            await currentReader.cancel().catch(() => void 0);
+          }
+          currentReader = null;
+          if (aborted) {
+            return;
+          }
+          if (!result.toolCallDetected || result.toolCalls.length === 0) {
+            finishStream({ unified: "stop", raw: "stop" });
             return;
           }
-          if (!finished && !aborted) {
-            finishStream({ unified: "other", raw: "other" });
+          if (result.trailingText) {
+            emitTextDelta(result.trailingText);
           }
+          finishStream({ unified: "tool-calls", raw: "tool-calls" });
         } catch (error) {
           controller.enqueue({ type: "error", error });
           controller.close();
@@ -1576,7 +1593,7 @@ var BrowserAIChatLanguageModel = class {
   }
 };
 
-// src/browser-ai-embedding-model.ts
+// src/embedding/browser-ai-embedding-model.ts
 import { TextEmbedder } from "@mediapipe/tasks-text";
 var BrowserAIEmbeddingModel = class {
   constructor(settings = {}) {