@browser-ai/web-llm 2.0.2 → 2.0.4

package/dist/index.mjs

@@ -317,7 +317,28 @@ var UnsupportedFunctionalityError = class extends (_b14 = AISDKError, _a14 = sym
   }
 };
 
-// src/tool-calling/build-json-system-prompt.ts
+// ../shared/src/utils/tool-utils.ts
+function isFunctionTool(tool) {
+  return tool.type === "function";
+}
+
+// ../shared/src/utils/warnings.ts
+function createUnsupportedSettingWarning(feature, details) {
+  return {
+    type: "unsupported",
+    feature,
+    details
+  };
+}
+function createUnsupportedToolWarning(tool, details) {
+  return {
+    type: "unsupported",
+    feature: `tool:${tool.name}`,
+    details
+  };
+}
+
+// ../shared/src/tool-calling/build-json-system-prompt.ts
 function buildJsonToolSystemPrompt(originalSystemPrompt, tools, options) {
   if (!tools || tools.length === 0) {
     return originalSystemPrompt || "";
@@ -371,34 +392,112 @@ function getParameters(tool) {
   return tool.inputSchema;
 }
 
-// src/tool-calling/parse-json-function-calls.ts
-var JSON_TOOL_CALL_FENCE_REGEX = /```tool[_-]?call\s*([\s\S]*?)```/gi;
+// ../shared/src/tool-calling/format-tool-results.ts
+function buildResultPayload(result) {
+  const payload = {
+    name: result.toolName,
+    result: result.result ?? null,
+    error: Boolean(result.isError)
+  };
+  if (result.toolCallId) {
+    payload.id = result.toolCallId;
+  }
+  return payload;
+}
+function formatToolResults(results) {
+  if (!results || results.length === 0) {
+    return "";
+  }
+  const payloads = results.map(
+    (result) => JSON.stringify(buildResultPayload(result))
+  );
+  return `\`\`\`tool_result
+${payloads.join("\n")}
+\`\`\``;
+}
+
+// ../shared/src/tool-calling/parse-json-function-calls.ts
+var DEFAULT_OPTIONS = {
+  supportXmlTags: true,
+  supportPythonStyle: true,
+  supportParametersField: true
+};
 function generateToolCallId() {
   return `call_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
 }
-function parseJsonFunctionCalls(response) {
-  const matches = Array.from(response.matchAll(JSON_TOOL_CALL_FENCE_REGEX));
-  JSON_TOOL_CALL_FENCE_REGEX.lastIndex = 0;
+function buildRegex(options) {
+  const patterns = [];
+  patterns.push("```tool[_-]?call\\s*([\\s\\S]*?)```");
+  if (options.supportXmlTags) {
+    patterns.push("<tool_call>\\s*([\\s\\S]*?)\\s*</tool_call>");
+  }
+  if (options.supportPythonStyle) {
+    patterns.push("\\[(\\w+)\\(([^)]*)\\)\\]");
+  }
+  return new RegExp(patterns.join("|"), "gi");
+}
+function parseJsonFunctionCalls(response, options = DEFAULT_OPTIONS) {
+  const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+  const regex = buildRegex(mergedOptions);
+  const matches = Array.from(response.matchAll(regex));
+  regex.lastIndex = 0;
   if (matches.length === 0) {
     return { toolCalls: [], textContent: response };
   }
   const toolCalls = [];
   let textContent = response;
   for (const match of matches) {
-    const [fullFence, innerContent] = match;
-    textContent = textContent.replace(fullFence, "");
+    const fullMatch = match[0];
+    textContent = textContent.replace(fullMatch, "");
     try {
+      if (mergedOptions.supportPythonStyle && match[0].startsWith("[")) {
+        const pythonMatch = /\[(\w+)\(([^)]*)\)\]/.exec(match[0]);
+        if (pythonMatch) {
+          const [, funcName, pythonArgs] = pythonMatch;
+          const args = {};
+          if (pythonArgs && pythonArgs.trim()) {
+            const argPairs = pythonArgs.split(",").map((s) => s.trim());
+            for (const pair of argPairs) {
+              const equalIndex = pair.indexOf("=");
+              if (equalIndex > 0) {
+                const key = pair.substring(0, equalIndex).trim();
+                let value = pair.substring(equalIndex + 1).trim();
+                if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+                  value = value.substring(1, value.length - 1);
+                }
+                args[key] = value;
+              }
+            }
+          }
+          toolCalls.push({
+            type: "tool-call",
+            toolCallId: generateToolCallId(),
+            toolName: funcName,
+            args
+          });
+          continue;
+        }
+      }
+      const innerContent = match[1] || match[2] || "";
       const trimmed = innerContent.trim();
+      if (!trimmed) continue;
       try {
         const parsed = JSON.parse(trimmed);
         const callsArray = Array.isArray(parsed) ? parsed : [parsed];
         for (const call of callsArray) {
           if (!call.name) continue;
+          let args = call.arguments || (mergedOptions.supportParametersField ? call.parameters : null) || {};
+          if (typeof args === "string") {
+            try {
+              args = JSON.parse(args);
+            } catch {
+            }
+          }
           toolCalls.push({
             type: "tool-call",
             toolCallId: call.id || generateToolCallId(),
             toolName: call.name,
-            args: call.arguments || {}
+            args
           });
         }
       } catch {
@@ -407,11 +506,18 @@ function parseJsonFunctionCalls(response) {
           try {
             const call = JSON.parse(line.trim());
             if (!call.name) continue;
+            let args = call.arguments || (mergedOptions.supportParametersField ? call.parameters : null) || {};
+            if (typeof args === "string") {
+              try {
+                args = JSON.parse(args);
+              } catch {
+              }
+            }
             toolCalls.push({
               type: "tool-call",
               toolCallId: call.id || generateToolCallId(),
               toolName: call.name,
-              args: call.arguments || {}
+              args
             });
           } catch {
             continue;
@@ -427,24 +533,245 @@ function parseJsonFunctionCalls(response) {
   return { toolCalls, textContent: textContent.trim() };
 }
 
-// src/tool-calling/format-tool-results.ts
-function formatToolResults(results) {
-  if (results.length === 0) {
-    return "";
+// ../shared/src/streaming/tool-call-detector.ts
+var DEFAULT_FENCE_PATTERNS = [
+  { start: "```tool_call", end: "```", reconstructStart: "```tool_call\n" },
+  { start: "```tool-call", end: "```", reconstructStart: "```tool-call\n" }
+];
+var EXTENDED_FENCE_PATTERNS = [
+  ...DEFAULT_FENCE_PATTERNS,
+  {
+    start: "<tool_call>",
+    end: "</tool_call>",
+    reconstructStart: "<tool_call>"
+  }
+];
+var ToolCallFenceDetector = class {
+  constructor(options = {}) {
+    this.pythonStyleRegex = /\[(\w+)\(/g;
+    this.buffer = "";
+    this.inFence = false;
+    this.fenceStartBuffer = "";
+    // Accumulated fence content
+    this.currentFencePattern = null;
+    this.fencePatterns = options.patterns ?? EXTENDED_FENCE_PATTERNS;
+    this.enablePythonStyle = options.enablePythonStyle ?? true;
+    this.fenceStarts = this.fencePatterns.map((p) => p.start);
   }
-  const lines = results.map((result) => formatSingleToolResult(result)).join("\n");
-  return `\`\`\`tool_result
-${lines}
-\`\`\``;
-}
-function formatSingleToolResult(result) {
-  return JSON.stringify({
-    id: result.toolCallId,
-    name: result.toolName,
-    result: result.result,
-    error: result.isError ?? false
-  });
-}
+  addChunk(chunk) {
+    this.buffer += chunk;
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+  clearBuffer() {
+    this.buffer = "";
+  }
+  /**
+   * Detects if there's a complete fence in the buffer
+   * @returns Detection result with fence info and safe text
+   */
+  detectFence() {
+    const {
+      index: startIdx,
+      prefix: matchedPrefix,
+      pattern
+    } = this.findFenceStart(this.buffer);
+    if (startIdx === -1) {
+      const overlap = this.computeOverlapLength(this.buffer, this.fenceStarts);
+      const safeTextLength = this.buffer.length - overlap;
+      const prefixText2 = safeTextLength > 0 ? this.buffer.slice(0, safeTextLength) : "";
+      const remaining = overlap > 0 ? this.buffer.slice(-overlap) : "";
+      this.buffer = remaining;
+      return {
+        fence: null,
+        prefixText: prefixText2,
+        remainingText: "",
+        overlapLength: overlap
+      };
+    }
+    const prefixText = this.buffer.slice(0, startIdx);
+    this.buffer = this.buffer.slice(startIdx);
+    const prefixLength = matchedPrefix?.length ?? 0;
+    const fenceEnd = pattern?.end ?? "```";
+    const closingIdx = this.buffer.indexOf(fenceEnd, prefixLength);
+    if (closingIdx === -1) {
+      return {
+        fence: null,
+        prefixText,
+        remainingText: "",
+        overlapLength: 0
+      };
+    }
+    const endPos = closingIdx + fenceEnd.length;
+    const fence = this.buffer.slice(0, endPos);
+    const remainingText = this.buffer.slice(endPos);
+    this.buffer = "";
+    return {
+      fence,
+      prefixText,
+      remainingText,
+      overlapLength: 0
+    };
+  }
+  /**
+   * Finds the first occurrence of any fence start marker
+   *
+   * @param text - Text to search in
+   * @returns Index of first fence start and which pattern matched
+   * @private
+   */
+  findFenceStart(text) {
+    let bestIndex = -1;
+    let matchedPrefix = null;
+    let matchedPattern = null;
+    for (const pattern of this.fencePatterns) {
+      const idx = text.indexOf(pattern.start);
+      if (idx !== -1 && (bestIndex === -1 || idx < bestIndex)) {
+        bestIndex = idx;
+        matchedPrefix = pattern.start;
+        matchedPattern = pattern;
+      }
+    }
+    if (this.enablePythonStyle) {
+      this.pythonStyleRegex.lastIndex = 0;
+      const pythonMatch = this.pythonStyleRegex.exec(text);
+      if (pythonMatch && (bestIndex === -1 || pythonMatch.index < bestIndex)) {
+        bestIndex = pythonMatch.index;
+        matchedPrefix = pythonMatch[0];
+        matchedPattern = {
+          start: pythonMatch[0],
+          end: ")]",
+          reconstructStart: pythonMatch[0],
+          isRegex: true
+        };
+      }
+    }
+    return { index: bestIndex, prefix: matchedPrefix, pattern: matchedPattern };
+  }
+  /**
+   * Computes the maximum overlap between the end of text and the start of any prefix
+   * @param text - Text to check for overlap
+   * @param prefixes - List of prefixes to check against
+   * @returns Length of the maximum overlap found
+   */
+  computeOverlapLength(text, prefixes) {
+    let overlap = 0;
+    for (const prefix of prefixes) {
+      const maxLength = Math.min(text.length, prefix.length - 1);
+      for (let size = maxLength; size > 0; size -= 1) {
+        if (prefix.startsWith(text.slice(-size))) {
+          overlap = Math.max(overlap, size);
+          break;
+        }
+      }
+    }
+    return overlap;
+  }
+  /**
+   * Checks if the buffer currently contains any text
+   */
+  hasContent() {
+    return this.buffer.length > 0;
+  }
+  /**
+   * Gets the buffer size
+   */
+  getBufferSize() {
+    return this.buffer.length;
+  }
+  /**
+   * Detect and stream fence content in real-time for true incremental streaming
+   * @returns Streaming result with current state and safe content to emit
+   */
+  detectStreamingFence() {
+    if (!this.inFence) {
+      const {
+        index: startIdx,
+        prefix: matchedPrefix,
+        pattern
+      } = this.findFenceStart(this.buffer);
+      if (startIdx === -1) {
+        const overlap = this.computeOverlapLength(
+          this.buffer,
+          this.fenceStarts
+        );
+        const safeTextLength = this.buffer.length - overlap;
+        const safeContent = safeTextLength > 0 ? this.buffer.slice(0, safeTextLength) : "";
+        this.buffer = this.buffer.slice(safeTextLength);
+        return {
+          inFence: false,
+          safeContent,
+          completeFence: null,
+          textAfterFence: ""
+        };
+      }
+      const prefixText = this.buffer.slice(0, startIdx);
+      const fenceStartLength = matchedPrefix?.length ?? 0;
+      this.buffer = this.buffer.slice(startIdx + fenceStartLength);
+      if (pattern && pattern.start.startsWith("```") && this.buffer.startsWith("\n")) {
+        this.buffer = this.buffer.slice(1);
+      }
+      this.inFence = true;
+      this.fenceStartBuffer = "";
+      this.currentFencePattern = pattern;
+      return {
+        inFence: true,
+        safeContent: prefixText,
+        // Emit any text before the fence
+        completeFence: null,
+        textAfterFence: ""
+      };
+    }
+    const fenceEnd = this.currentFencePattern?.end ?? "```";
+    const closingIdx = this.buffer.indexOf(fenceEnd);
+    if (closingIdx === -1) {
+      const overlap = this.computeOverlapLength(this.buffer, [fenceEnd]);
+      const safeContentLength = this.buffer.length - overlap;
+      if (safeContentLength > 0) {
+        const safeContent = this.buffer.slice(0, safeContentLength);
+        this.fenceStartBuffer += safeContent;
+        this.buffer = this.buffer.slice(safeContentLength);
+        return {
+          inFence: true,
+          safeContent,
+          completeFence: null,
+          textAfterFence: ""
+        };
+      }
+      return {
+        inFence: true,
+        safeContent: "",
+        completeFence: null,
+        textAfterFence: ""
+      };
+    }
+    const fenceContent = this.buffer.slice(0, closingIdx);
+    this.fenceStartBuffer += fenceContent;
+    const reconstructStart = this.currentFencePattern?.reconstructStart ?? "```tool_call\n";
+    const completeFence = `${reconstructStart}${this.fenceStartBuffer}${fenceEnd}`;
+    const textAfterFence = this.buffer.slice(closingIdx + fenceEnd.length);
+    this.inFence = false;
+    this.fenceStartBuffer = "";
+    this.currentFencePattern = null;
+    this.buffer = textAfterFence;
+    return {
+      inFence: false,
+      safeContent: fenceContent,
+      // Emit the last bit of fence content
+      completeFence,
+      textAfterFence
+    };
+  }
+  isInFence() {
+    return this.inFence;
+  }
+  resetStreamingState() {
+    this.inFence = false;
+    this.fenceStartBuffer = "";
+    this.currentFencePattern = null;
+  }
+};
 
 // src/convert-to-webllm-messages.tsx
 function convertToolResultOutput(output) {
@@ -591,27 +918,6 @@ import {
   MLCEngine
 } from "@mlc-ai/web-llm";
 
-// src/utils/warnings.ts
-function createUnsupportedSettingWarning(feature, details) {
-  return {
-    type: "unsupported",
-    feature,
-    details
-  };
-}
-function createUnsupportedToolWarning(tool, details) {
-  return {
-    type: "unsupported",
-    feature: `tool:${tool.name}`,
-    details
-  };
-}
-
-// src/utils/tool-utils.ts
-function isFunctionTool(tool) {
-  return tool.type === "function";
-}
-
 // src/utils/prompt-utils.ts
 function extractSystemPrompt(messages) {
   const systemMessages = messages.filter((msg) => msg.role === "system");
@@ -651,206 +957,6 @@ ${existingContent}` : "")
   ];
 }
 
-// src/streaming/tool-call-detector.ts
-var ToolCallFenceDetector = class {
-  constructor() {
-    this.FENCE_STARTS = ["```tool_call"];
-    this.FENCE_END = "```";
-    this.buffer = "";
-    this.inFence = false;
-    this.fenceStartBuffer = "";
-  }
-  addChunk(chunk) {
-    this.buffer += chunk;
-  }
-  getBuffer() {
-    return this.buffer;
-  }
-  clearBuffer() {
-    this.buffer = "";
-  }
-  /**
-   * Detects if there's a complete fence in the buffer
-   *
-   * 1. Searches for fence start markers
-   * 2. If found, looks for closing fence
-   * 3. Computes overlap for partial fences
-   * 4. Returns safe text that can be emitted
-   *
-   * @returns Detection result with fence info and safe text
-   */
-  detectFence() {
-    const { index: startIdx, prefix: matchedPrefix } = this.findFenceStart(
-      this.buffer
-    );
-    if (startIdx === -1) {
-      const overlap = this.computeOverlapLength(this.buffer, this.FENCE_STARTS);
-      const safeTextLength = this.buffer.length - overlap;
-      const prefixText2 = safeTextLength > 0 ? this.buffer.slice(0, safeTextLength) : "";
-      const remaining = overlap > 0 ? this.buffer.slice(-overlap) : "";
-      this.buffer = remaining;
-      return {
-        fence: null,
-        prefixText: prefixText2,
-        remainingText: "",
-        overlapLength: overlap
-      };
-    }
-    const prefixText = this.buffer.slice(0, startIdx);
-    this.buffer = this.buffer.slice(startIdx);
-    const prefixLength = matchedPrefix?.length ?? 0;
-    const closingIdx = this.buffer.indexOf(this.FENCE_END, prefixLength);
-    if (closingIdx === -1) {
-      return {
-        fence: null,
-        prefixText,
-        remainingText: "",
-        overlapLength: 0
-      };
-    }
-    const endPos = closingIdx + this.FENCE_END.length;
-    const fence = this.buffer.slice(0, endPos);
-    const remainingText = this.buffer.slice(endPos);
-    this.buffer = "";
-    return {
-      fence,
-      prefixText,
-      remainingText,
-      overlapLength: 0
-    };
-  }
-  /**
-   * Finds the first occurrence of any fence start marker
-   *
-   * @param text - Text to search in
-   * @returns Index of first fence start and which prefix matched
-   * @private
-   */
-  findFenceStart(text) {
-    let bestIndex = -1;
-    let matchedPrefix = null;
-    for (const prefix of this.FENCE_STARTS) {
-      const idx = text.indexOf(prefix);
-      if (idx !== -1 && (bestIndex === -1 || idx < bestIndex)) {
-        bestIndex = idx;
-        matchedPrefix = prefix;
-      }
-    }
-    return { index: bestIndex, prefix: matchedPrefix };
-  }
-  computeOverlapLength(text, prefixes) {
-    let overlap = 0;
-    for (const prefix of prefixes) {
-      const maxLength = Math.min(text.length, prefix.length - 1);
-      for (let size = maxLength; size > 0; size -= 1) {
-        if (prefix.startsWith(text.slice(-size))) {
-          overlap = Math.max(overlap, size);
-          break;
-        }
-      }
-    }
-    return overlap;
-  }
-  hasContent() {
-    return this.buffer.length > 0;
-  }
-  getBufferSize() {
-    return this.buffer.length;
-  }
-  /**
-   * Detect and stream fence content in real-time for true incremental streaming
-   *
-   * This method is designed for streaming tool calls as they arrive:
-   * 1. Detects when a fence starts and transitions to "inFence" state
-   * 2. While inFence, emits safe content that won't conflict with fence end marker
-   * 3. When fence ends, returns the complete fence for parsing
-   *
-   * @returns Streaming result with current state and safe content to emit
-   */
-  detectStreamingFence() {
-    if (!this.inFence) {
-      const { index: startIdx, prefix: matchedPrefix } = this.findFenceStart(
-        this.buffer
-      );
-      if (startIdx === -1) {
-        const overlap = this.computeOverlapLength(
-          this.buffer,
-          this.FENCE_STARTS
-        );
-        const safeTextLength = this.buffer.length - overlap;
-        const safeContent = safeTextLength > 0 ? this.buffer.slice(0, safeTextLength) : "";
-        this.buffer = this.buffer.slice(safeTextLength);
-        return {
-          inFence: false,
-          safeContent,
-          completeFence: null,
-          textAfterFence: ""
-        };
-      }
-      const prefixText = this.buffer.slice(0, startIdx);
-      const fenceStartLength = matchedPrefix?.length ?? 0;
-      this.buffer = this.buffer.slice(startIdx + fenceStartLength);
-      if (this.buffer.startsWith("\n")) {
-        this.buffer = this.buffer.slice(1);
-      }
-      this.inFence = true;
-      this.fenceStartBuffer = "";
-      return {
-        inFence: true,
-        safeContent: prefixText,
-        completeFence: null,
-        textAfterFence: ""
-      };
-    }
-    const closingIdx = this.buffer.indexOf(this.FENCE_END);
-    if (closingIdx === -1) {
-      const overlap = this.computeOverlapLength(this.buffer, [this.FENCE_END]);
-      const safeContentLength = this.buffer.length - overlap;
-      if (safeContentLength > 0) {
-        const safeContent = this.buffer.slice(0, safeContentLength);
-        this.fenceStartBuffer += safeContent;
-        this.buffer = this.buffer.slice(safeContentLength);
-        return {
-          inFence: true,
-          safeContent,
-          completeFence: null,
-          textAfterFence: ""
-        };
-      }
-      return {
-        inFence: true,
-        safeContent: "",
-        completeFence: null,
-        textAfterFence: ""
-      };
-    }
-    const fenceContent = this.buffer.slice(0, closingIdx);
-    this.fenceStartBuffer += fenceContent;
-    const completeFence = `${this.FENCE_STARTS[0]}
-${this.fenceStartBuffer}
-${this.FENCE_END}`;
-    const textAfterFence = this.buffer.slice(
-      closingIdx + this.FENCE_END.length
-    );
-    this.inFence = false;
-    this.fenceStartBuffer = "";
-    this.buffer = textAfterFence;
-    return {
-      inFence: false,
-      safeContent: fenceContent,
-      completeFence,
-      textAfterFence
-    };
-  }
-  isInFence() {
-    return this.inFence;
-  }
-  resetStreamingState() {
-    this.inFence = false;
-    this.fenceStartBuffer = "";
-  }
-};
-
 // src/web-llm-language-model.ts
 function isMobile() {
   if (typeof navigator === "undefined") return false;