@browser-ai/core 2.0.3 → 2.0.4

package/dist/index.js

@@ -28,10 +28,82 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/convert-to-browser-ai-messages.ts
-var import_provider = require("@ai-sdk/provider");
+// ../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 || "";
+  }
+  const parallelInstruction = "Only request one tool call at a time. Wait for tool results before asking for another tool.";
+  const toolSchemas = tools.map((tool) => {
+    const schema = getParameters(tool);
+    return {
+      name: tool.name,
+      description: tool.description ?? "No description provided.",
+      parameters: schema || { type: "object", properties: {} }
+    };
+  });
+  const toolsJson = JSON.stringify(toolSchemas, null, 2);
+  const instructionBody = `You are a helpful AI assistant with access to tools.
+
+# Available Tools
+${toolsJson}
+
+# Tool Calling Instructions
+${parallelInstruction}
 
-// src/tool-calling/format-tool-results.ts
+To call a tool, output JSON in this exact format inside a \`\`\`tool_call code fence:
+
+\`\`\`tool_call
+{"name": "tool_name", "arguments": {"param1": "value1", "param2": "value2"}}
+\`\`\`
+
+Tool responses will be provided in \`\`\`tool_result fences. Each line contains JSON like:
+\`\`\`tool_result
+{"id": "call_123", "name": "tool_name", "result": {...}, "error": false}
+\`\`\`
+Use the \`result\` payload (and treat \`error\` as a boolean flag) when continuing the conversation.
+
+Important:
+- Use exact tool and parameter names from the schema above
+- Arguments must be a valid JSON object matching the tool's parameters
+- You can include brief reasoning before or after the tool call
+- If no tool is needed, respond directly without tool_call fences`;
+  if (originalSystemPrompt?.trim()) {
+    return `${originalSystemPrompt.trim()}
+
+${instructionBody}`;
+  }
+  return instructionBody;
+}
+function getParameters(tool) {
+  if ("parameters" in tool) {
+    return tool.parameters;
+  }
+  return tool.inputSchema;
+}
+
+// ../shared/src/tool-calling/format-tool-results.ts
 function buildResultPayload(result) {
   const payload = {
     name: result.toolName,
@@ -55,7 +127,365 @@ ${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 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 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
+          });
+        }
+      } catch {
+        const lines = trimmed.split("\n").filter((line) => line.trim());
+        for (const line of lines) {
+          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
+            });
+          } catch {
+            continue;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to parse JSON tool call:", error);
+      continue;
+    }
+  }
+  textContent = textContent.replace(/\n{2,}/g, "\n");
+  return { toolCalls, textContent: textContent.trim() };
+}
+
+// ../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);
+  }
+  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-browser-ai-messages.ts
+var import_provider = require("@ai-sdk/provider");
 function convertBase64ToUint8Array(base64) {
   try {
     const binaryString = atob(base64);
@@ -229,168 +659,44 @@ function convertToBrowserAIMessages(prompt) {
           }
         }
         const toolCallJson = formatToolCallsJson(toolCallParts);
-        const contentSegments = [];
-        if (text.trim().length > 0) {
-          contentSegments.push(text);
-        } else if (text.length > 0) {
-          contentSegments.push(text);
-        }
-        if (toolCallJson) {
-          contentSegments.push(toolCallJson);
-        }
-        const content = contentSegments.length > 0 ? contentSegments.join("\n") : "";
-        messages.push({
-          role: "assistant",
-          content
-        });
-        break;
-      }
-      case "tool": {
-        const toolParts = message.content;
-        const results = toolParts.map(toToolResult);
-        const toolResultsJson = formatToolResults(results);
-        messages.push({
-          role: "user",
-          content: toolResultsJson
-        });
-        break;
-      }
-      default: {
-        const exhaustiveCheck = message;
-        throw new Error(
-          `Unsupported role: ${exhaustiveCheck.role ?? "unknown"}`
-        );
-      }
-    }
-  }
-  return { systemMessage, messages };
-}
-
-// src/tool-calling/build-json-system-prompt.ts
-function buildJsonToolSystemPrompt(originalSystemPrompt, tools, options) {
-  if (!tools || tools.length === 0) {
-    return originalSystemPrompt || "";
-  }
-  const parallelInstruction = "Only request one tool call at a time. Wait for tool results before asking for another tool.";
-  const toolSchemas = tools.map((tool) => {
-    const schema = getParameters(tool);
-    return {
-      name: tool.name,
-      description: tool.description ?? "No description provided.",
-      parameters: schema || { type: "object", properties: {} }
-    };
-  });
-  const toolsJson = JSON.stringify(toolSchemas, null, 2);
-  const instructionBody = `You are a helpful AI assistant with access to tools.
-
-# Available Tools
-${toolsJson}
-
-# Tool Calling Instructions
-${parallelInstruction}
-
-To call a tool, output JSON in this exact format inside a \`\`\`tool_call code fence:
-
-\`\`\`tool_call
-{"name": "tool_name", "arguments": {"param1": "value1", "param2": "value2"}}
-\`\`\`
-
-Tool responses will be provided in \`\`\`tool_result fences. Each line contains JSON like:
-\`\`\`tool_result
-{"id": "call_123", "name": "tool_name", "result": {...}, "error": false}
-\`\`\`
-Use the \`result\` payload (and treat \`error\` as a boolean flag) when continuing the conversation.
-
-Important:
-- Use exact tool and parameter names from the schema above
-- Arguments must be a valid JSON object matching the tool's parameters
-- You can include brief reasoning before or after the tool call
-- If no tool is needed, respond directly without tool_call fences`;
-  if (originalSystemPrompt?.trim()) {
-    return `${originalSystemPrompt.trim()}
-
-${instructionBody}`;
-  }
-  return instructionBody;
-}
-function getParameters(tool) {
-  if ("parameters" in tool) {
-    return tool.parameters;
-  }
-  return tool.inputSchema;
-}
-
-// src/tool-calling/parse-json-function-calls.ts
-var JSON_TOOL_CALL_FENCE_REGEX = /```tool[_-]?call\s*([\s\S]*?)```/gi;
-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;
-  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, "");
-    try {
-      const trimmed = innerContent.trim();
-      try {
-        const parsed = JSON.parse(trimmed);
-        const callsArray = Array.isArray(parsed) ? parsed : [parsed];
-        for (const call of callsArray) {
-          if (!call.name) continue;
-          toolCalls.push({
-            type: "tool-call",
-            toolCallId: call.id || generateToolCallId(),
-            toolName: call.name,
-            args: call.arguments || {}
-          });
-        }
-      } catch {
-        const lines = trimmed.split("\n").filter((line) => line.trim());
-        for (const line of lines) {
-          try {
-            const call = JSON.parse(line.trim());
-            if (!call.name) continue;
-            toolCalls.push({
-              type: "tool-call",
-              toolCallId: call.id || generateToolCallId(),
-              toolName: call.name,
-              args: call.arguments || {}
-            });
-          } catch {
-            continue;
-          }
+        const contentSegments = [];
+        if (text.trim().length > 0) {
+          contentSegments.push(text);
+        } else if (text.length > 0) {
+          contentSegments.push(text);
+        }
+        if (toolCallJson) {
+          contentSegments.push(toolCallJson);
         }
+        const content = contentSegments.length > 0 ? contentSegments.join("\n") : "";
+        messages.push({
+          role: "assistant",
+          content
+        });
+        break;
+      }
+      case "tool": {
+        const toolParts = message.content;
+        const results = toolParts.map(toToolResult);
+        const toolResultsJson = formatToolResults(results);
+        messages.push({
+          role: "user",
+          content: toolResultsJson
+        });
+        break;
+      }
+      default: {
+        const exhaustiveCheck = message;
+        throw new Error(
+          `Unsupported role: ${exhaustiveCheck.role ?? "unknown"}`
+        );
       }
-    } catch (error) {
-      console.warn("Failed to parse JSON tool call:", error);
-      continue;
     }
   }
-  textContent = textContent.replace(/\n{2,}/g, "\n");
-  return { toolCalls, textContent: textContent.trim() };
+  return { systemMessage, messages };
 }
 
 // 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
-  };
-}
 function gatherUnsupportedSettingWarnings(options) {
   const warnings = [];
   if (options.maxOutputTokens != null) {
@@ -483,11 +789,6 @@ function getExpectedInputs(prompt) {
   return Array.from(inputs).map((type) => ({ type }));
 }
 
-// src/utils/tool-utils.ts
-function isFunctionTool(tool) {
-  return tool.type === "function";
-}
-
 // src/models/session-manager.ts
 var import_provider2 = require("@ai-sdk/provider");
 var SessionManager = class {
@@ -658,258 +959,6 @@ var SessionManager = class {
   }
 };
 
-// src/streaming/tool-call-detector.ts
-var ToolCallFenceDetector = class {
-  constructor() {
-    this.FENCE_STARTS = ["```tool_call"];
-    this.FENCE_END = "```";
-    this.buffer = "";
-    // Streaming state
-    this.inFence = false;
-    this.fenceStartBuffer = "";
-  }
-  // Accumulated fence content
-  /**
-   * Adds a chunk of text to the internal buffer
-   *
-   * @param chunk - Text chunk from the stream
-   */
-  addChunk(chunk) {
-    this.buffer += chunk;
-  }
-  /**
-   * Gets the current buffer content
-   */
-  getBuffer() {
-    return this.buffer;
-  }
-  /**
-   * Clears the internal buffer
-   */
-  clearBuffer() {
-    this.buffer = "";
-  }
-  /**
-   * Detects if there's a complete fence in the buffer
-   *
-   * This method:
-   * 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 };
-  }
-  /**
-   * Computes the maximum overlap between the end of text and the start of any prefix
-   *
-   * This is crucial for streaming: if the buffer ends with "``", we can't emit it
-   * because the next chunk might be "`tool_call", completing a fence marker.
-   *
-   * @param text - Text to check for overlap
-   * @param prefixes - List of prefixes to check against
-   * @returns Length of the maximum overlap found
-   *
-   * @example
-   * ```typescript
-   * computeOverlapLength("hello ``", ["```tool_call"])
-   * // Returns: 2 (because "``" matches start of "```tool_call")
-   *
-   * computeOverlapLength("hello `", ["```tool_call"])
-   * // Returns: 1
-   *
-   * computeOverlapLength("hello world", ["```tool_call"])
-   * // Returns: 0 (no overlap)
-   * ```
-   *
-   * @private
-   */
-  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
-   *
-   * 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,
-        // Emit any text before the fence
-        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,
-      // Emit the last bit of fence content
-      completeFence,
-      textAfterFence
-    };
-  }
-  /**
-   * Check if currently inside a fence
-   */
-  isInFence() {
-    return this.inFence;
-  }
-  /**
-   * Reset streaming state
-   */
-  resetStreamingState() {
-    this.inFence = false;
-    this.fenceStartBuffer = "";
-  }
-};
-
 // src/browser-ai-language-model.ts
 function doesBrowserSupportBrowserAI() {
   return typeof LanguageModel !== "undefined";