@browser-ai/core 2.1.3 → 2.1.5

package/dist/index.js

@@ -569,16 +569,187 @@ function extractArgumentsDelta(content, state) {
   return delta;
 }
 
-// src/convert-to-browser-ai-messages.ts
+// ../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
 var import_provider = require("@ai-sdk/provider");
 function convertBase64ToUint8Array(base64) {
   try {
     const binaryString = atob(base64);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes;
+    return Uint8Array.from(binaryString, (c) => c.charCodeAt(0));
   } catch (error) {
     throw new Error(`Failed to convert base64 to Uint8Array: ${error}`);
   }
@@ -844,19 +1015,7 @@ function gatherUnsupportedSettingWarnings(options) {
 }
 
 // src/utils/prompt-utils.ts
-function hasMultimodalContent(prompt) {
-  for (const message of prompt) {
-    if (message.role === "user") {
-      for (const part of message.content) {
-        if (part.type === "file") {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-}
-function getExpectedInputs(prompt) {
+function getMultimodalInfo(prompt) {
   const inputs = /* @__PURE__ */ new Set();
   for (const message of prompt) {
     if (message.role === "user") {
@@ -871,10 +1030,14 @@ function getExpectedInputs(prompt) {
       }
     }
   }
-  return Array.from(inputs).map((type) => ({ type }));
+  const hasMultiModalInput = inputs.size > 0;
+  return {
+    hasMultiModalInput,
+    expectedInputs: hasMultiModalInput ? Array.from(inputs, (type) => ({ type })) : void 0
+  };
 }
 
-// src/models/session-manager.ts
+// src/chat/session-manager.ts
 var import_provider2 = require("@ai-sdk/provider");
 var SessionManager = class {
   /**
@@ -1045,20 +1208,11 @@ var SessionManager = class {
         };
       }
     }
-    this.sanitizeOptions(mergedOptions);
     return mergedOptions;
   }
-  /**
-   * Removes custom options that aren't part of LanguageModel.create API
-   *
-   * @param options - Options object to sanitize in-place
-   * @private
-   */
-  sanitizeOptions(options) {
-  }
 };
 
-// src/browser-ai-language-model.ts
+// src/chat/browser-ai-language-model.ts
 function doesBrowserSupportBrowserAI() {
   return typeof LanguageModel !== "undefined";
 }
@@ -1131,7 +1285,7 @@ var BrowserAIChatLanguageModel = class {
         )
       );
     }
-    const hasMultiModalInput = hasMultimodalContent(prompt);
+    const { hasMultiModalInput, expectedInputs } = getMultimodalInfo(prompt);
     const { systemMessage, messages } = convertToBrowserAIMessages(prompt);
     const promptOptions = {};
     if (responseFormat?.type === "json") {
@@ -1149,7 +1303,7 @@ var BrowserAIChatLanguageModel = class {
       warnings,
       promptOptions,
       hasMultiModalInput,
-      expectedInputs: hasMultiModalInput ? getExpectedInputs(prompt) : void 0,
+      expectedInputs,
       functionTools
     };
   }
@@ -1395,213 +1549,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 argumentsStreamState = createArgumentsStreamState();
-            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 = "";
-                  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 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 = "";
-                    argumentsStreamState = createArgumentsStreamState();
-                    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 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
-                    });
-                  }
-                  trailingTextAfterBlock += result.textAfterFence;
-                  madeProgress = true;
-                  if (toolBlockDetected && currentReader) {
-                    await currentReader.cancel().catch(() => void 0);
-                    break;
-                  }
-                  currentToolCallId = null;
-                  toolInputStartEmitted = false;
-                  accumulatedFenceContent = "";
-                  argumentsStreamState = createArgumentsStreamState();
-                  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 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 (toolBlockDetected) {
-                break;
-              }
-            }
-            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 (done) break;
+              yield value;
             }
-            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();
@@ -1619,7 +1600,7 @@ var BrowserAIChatLanguageModel = class {
   }
 };
 
-// src/browser-ai-embedding-model.ts
+// src/embedding/browser-ai-embedding-model.ts
 var import_tasks_text = require("@mediapipe/tasks-text");
 var BrowserAIEmbeddingModel = class {
   constructor(settings = {}) {