@browser-ai/core 1.0.0

package/dist/index.js

@@ -0,0 +1,1635 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BuiltInAIChatLanguageModel: () => BuiltInAIChatLanguageModel,
+  BuiltInAIEmbeddingModel: () => BuiltInAIEmbeddingModel,
+  builtInAI: () => builtInAI,
+  createBuiltInAI: () => createBuiltInAI,
+  doesBrowserSupportBuiltInAI: () => doesBrowserSupportBuiltInAI,
+  isBuiltInAIModelAvailable: () => isBuiltInAIModelAvailable
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/convert-to-built-in-ai-messages.ts
+var import_provider = require("@ai-sdk/provider");
+
+// 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")}
+\`\`\``;
+}
+
+// src/convert-to-built-in-ai-messages.ts
+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;
+  } catch (error) {
+    throw new Error(`Failed to convert base64 to Uint8Array: ${error}`);
+  }
+}
+function convertFileData(data, mediaType) {
+  if (data instanceof URL) {
+    return data.toString();
+  }
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (typeof data === "string") {
+    return convertBase64ToUint8Array(data);
+  }
+  const exhaustiveCheck = data;
+  throw new Error(`Unexpected data type for ${mediaType}: ${exhaustiveCheck}`);
+}
+function normalizeToolArguments(input) {
+  if (input === void 0) {
+    return {};
+  }
+  if (typeof input === "string") {
+    try {
+      return JSON.parse(input);
+    } catch {
+      return input;
+    }
+  }
+  return input ?? {};
+}
+function formatToolCallsJson(parts) {
+  if (!parts.length) {
+    return "";
+  }
+  const payloads = parts.map((call) => {
+    const payload = {
+      name: call.toolName,
+      arguments: normalizeToolArguments(call.input)
+    };
+    if (call.toolCallId) {
+      payload.id = call.toolCallId;
+    }
+    return JSON.stringify(payload);
+  });
+  return `\`\`\`tool_call
+${payloads.join("\n")}
+\`\`\``;
+}
+function convertToolResultOutput(output) {
+  switch (output.type) {
+    case "text":
+      return { value: output.value, isError: false };
+    case "json":
+      return { value: output.value, isError: false };
+    case "error-text":
+      return { value: output.value, isError: true };
+    case "error-json":
+      return { value: output.value, isError: true };
+    case "content":
+      return { value: output.value, isError: false };
+    default: {
+      const exhaustiveCheck = output;
+      return { value: exhaustiveCheck, isError: false };
+    }
+  }
+}
+function toToolResult(part) {
+  const { value, isError } = convertToolResultOutput(part.output);
+  return {
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    result: value,
+    isError
+  };
+}
+function convertToBuiltInAIMessages(prompt) {
+  const normalizedPrompt = prompt.slice();
+  let systemMessage;
+  const messages = [];
+  for (const message of normalizedPrompt) {
+    switch (message.role) {
+      case "system": {
+        systemMessage = message.content;
+        break;
+      }
+      case "user": {
+        messages.push({
+          role: "user",
+          content: message.content.map((part) => {
+            switch (part.type) {
+              case "text": {
+                return {
+                  type: "text",
+                  value: part.text
+                };
+              }
+              case "file": {
+                const { mediaType, data } = part;
+                if (mediaType?.startsWith("image/")) {
+                  const convertedData = convertFileData(data, mediaType);
+                  return {
+                    type: "image",
+                    value: convertedData
+                  };
+                } else if (mediaType?.startsWith("audio/")) {
+                  const convertedData = convertFileData(data, mediaType);
+                  return {
+                    type: "audio",
+                    value: convertedData
+                  };
+                } else {
+                  throw new import_provider.UnsupportedFunctionalityError({
+                    functionality: `file type: ${mediaType}`
+                  });
+                }
+              }
+              default: {
+                const exhaustiveCheck = part;
+                throw new import_provider.UnsupportedFunctionalityError({
+                  functionality: `content type: ${exhaustiveCheck.type ?? "unknown"}`
+                });
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        const toolCallParts = [];
+        for (const part of message.content) {
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "reasoning": {
+              text += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCallParts.push(part);
+              break;
+            }
+            case "file": {
+              throw new import_provider.UnsupportedFunctionalityError({
+                functionality: "assistant file attachments"
+              });
+            }
+            case "tool-result": {
+              throw new import_provider.UnsupportedFunctionalityError({
+                functionality: "tool-result parts in assistant messages (should be in tool messages)"
+              });
+            }
+            default: {
+              const exhaustiveCheck = part;
+              throw new import_provider.UnsupportedFunctionalityError({
+                functionality: `assistant part type: ${exhaustiveCheck.type ?? "unknown"}`
+              });
+            }
+          }
+        }
+        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;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to parse JSON tool call:", error);
+      continue;
+    }
+  }
+  textContent = textContent.replace(/\n{2,}/g, "\n");
+  return { toolCalls, textContent: textContent.trim() };
+}
+
+// src/utils/warnings.ts
+function createUnsupportedSettingWarning(setting, details) {
+  return {
+    type: "unsupported-setting",
+    setting,
+    details
+  };
+}
+function createUnsupportedToolWarning(tool, details) {
+  return {
+    type: "unsupported-tool",
+    tool,
+    details
+  };
+}
+function gatherUnsupportedSettingWarnings(options) {
+  const warnings = [];
+  if (options.maxOutputTokens != null) {
+    warnings.push(
+      createUnsupportedSettingWarning(
+        "maxOutputTokens",
+        "maxOutputTokens is not supported by Prompt API"
+      )
+    );
+  }
+  if (options.stopSequences != null) {
+    warnings.push(
+      createUnsupportedSettingWarning(
+        "stopSequences",
+        "stopSequences is not supported by Prompt API"
+      )
+    );
+  }
+  if (options.topP != null) {
+    warnings.push(
+      createUnsupportedSettingWarning(
+        "topP",
+        "topP is not supported by Prompt API"
+      )
+    );
+  }
+  if (options.presencePenalty != null) {
+    warnings.push(
+      createUnsupportedSettingWarning(
+        "presencePenalty",
+        "presencePenalty is not supported by Prompt API"
+      )
+    );
+  }
+  if (options.frequencyPenalty != null) {
+    warnings.push(
+      createUnsupportedSettingWarning(
+        "frequencyPenalty",
+        "frequencyPenalty is not supported by Prompt API"
+      )
+    );
+  }
+  if (options.seed != null) {
+    warnings.push(
+      createUnsupportedSettingWarning(
+        "seed",
+        "seed is not supported by Prompt API"
+      )
+    );
+  }
+  if (options.toolChoice != null) {
+    warnings.push(
+      createUnsupportedSettingWarning(
+        "toolChoice",
+        "toolChoice is not supported by Prompt API"
+      )
+    );
+  }
+  return warnings;
+}
+
+// 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) {
+  const inputs = /* @__PURE__ */ new Set();
+  for (const message of prompt) {
+    if (message.role === "user") {
+      for (const part of message.content) {
+        if (part.type === "file") {
+          if (part.mediaType?.startsWith("image/")) {
+            inputs.add("image");
+          } else if (part.mediaType?.startsWith("audio/")) {
+            inputs.add("audio");
+          }
+        }
+      }
+    }
+  }
+  return Array.from(inputs).map((type) => ({ type }));
+}
+function prependSystemPromptToMessages(messages, systemPrompt) {
+  if (!systemPrompt.trim()) {
+    return messages;
+  }
+  const prompts = messages.map((message) => ({ ...message }));
+  const firstUserIndex = prompts.findIndex(
+    (message) => message.role === "user"
+  );
+  if (firstUserIndex !== -1) {
+    const firstUserMessage = prompts[firstUserIndex];
+    if (Array.isArray(firstUserMessage.content)) {
+      const content = firstUserMessage.content.slice();
+      content.unshift({
+        type: "text",
+        value: `${systemPrompt}
+
+`
+      });
+      prompts[firstUserIndex] = {
+        ...firstUserMessage,
+        content
+      };
+    } else if (typeof firstUserMessage.content === "string") {
+      prompts[firstUserIndex] = {
+        ...firstUserMessage,
+        content: `${systemPrompt}
+
+${firstUserMessage.content}`
+      };
+    }
+  } else {
+    prompts.unshift({
+      role: "user",
+      content: systemPrompt
+    });
+  }
+  return prompts;
+}
+
+// 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 {
+  /**
+   * Creates a new SessionManager
+   *
+   * @param baseOptions - Base configuration options for all sessions
+   */
+  constructor(baseOptions) {
+    this.session = null;
+    this.baseOptions = baseOptions;
+  }
+  /**
+   * Gets or creates a session with the specified options
+   *
+   * If a session already exists, it will be reused unless force create is needed.
+   *
+   * @param options - Optional session creation options
+   * @returns Promise resolving to a LanguageModel session
+   * @throws {LoadSettingError} When Prompt API is not available or model is unavailable
+   *
+   * @example
+   * ```typescript
+   * const session = await manager.getSession({
+   *   systemMessage: "You are a helpful assistant",
+   *   expectedInputs: [{ type: "image" }],
+   *   temperature: 0.8
+   * });
+   * ```
+   */
+  async getSession(options) {
+    if (typeof LanguageModel === "undefined") {
+      throw new import_provider2.LoadSettingError({
+        message: "Prompt API is not available. This library requires Chrome or Edge browser with built-in AI capabilities."
+      });
+    }
+    if (this.session) {
+      return this.session;
+    }
+    const availability = await LanguageModel.availability();
+    if (availability === "unavailable") {
+      throw new import_provider2.LoadSettingError({
+        message: "Built-in model not available in this browser"
+      });
+    }
+    const sessionOptions = this.prepareSessionOptions(options);
+    this.session = await LanguageModel.create(sessionOptions);
+    return this.session;
+  }
+  /**
+   * Creates a session with download progress monitoring
+   *
+   * This is a convenience method for users who want explicit progress tracking.
+   *
+   * @param onDownloadProgress - Optional callback receiving progress (0-1) during download
+   * @returns Promise resolving to a LanguageModel session
+   * @throws {LoadSettingError} When Prompt API is not available or model is unavailable
+   *
+   * @example
+   * ```typescript
+   * const session = await manager.createSessionWithProgress(
+   *   (progress) => {
+   *     console.log(`Download: ${Math.round(progress * 100)}%`);
+   *   }
+   * );
+   * ```
+   */
+  async createSessionWithProgress(onDownloadProgress) {
+    return this.getSession({ onDownloadProgress });
+  }
+  /**
+   * Checks the availability status of the built-in AI model
+   *
+   * @returns Promise resolving to availability status
+   * - "unavailable": Model is not supported
+   * - "downloadable": Model needs to be downloaded
+   * - "downloading": Model is currently downloading
+   * - "available": Model is ready to use
+   *
+   * @example
+   * ```typescript
+   * const status = await manager.checkAvailability();
+   * if (status === "downloadable") {
+   *   console.log("Model needs to be downloaded first");
+   * }
+   * ```
+   */
+  async checkAvailability() {
+    if (typeof LanguageModel === "undefined") {
+      return "unavailable";
+    }
+    return LanguageModel.availability();
+  }
+  /**
+   * Gets the current session if it exists
+   *
+   * @returns The current session or null if none exists
+   */
+  getCurrentSession() {
+    return this.session;
+  }
+  /**
+   * Destroys the current session
+   *
+   * Use this when you want to force creation of a new session
+   * with different options on the next getSession call.
+   */
+  destroySession() {
+    if (this.session && typeof this.session.destroy === "function") {
+      this.session.destroy();
+    }
+    this.session = null;
+  }
+  /**
+   * Prepares merged session options from base config and request options
+   *
+   * @param options - Optional request-specific options
+   * @returns Merged and sanitized options ready for LanguageModel.create()
+   * @private
+   */
+  prepareSessionOptions(options) {
+    const mergedOptions = { ...this.baseOptions };
+    if (options) {
+      const {
+        systemMessage,
+        expectedInputs,
+        onDownloadProgress,
+        ...createOptions
+      } = options;
+      Object.assign(mergedOptions, createOptions);
+      if (systemMessage) {
+        mergedOptions.initialPrompts = [
+          { role: "system", content: systemMessage }
+        ];
+      }
+      if (expectedInputs && expectedInputs.length > 0) {
+        mergedOptions.expectedInputs = expectedInputs;
+      }
+      if (onDownloadProgress) {
+        mergedOptions.monitor = (m) => {
+          m.addEventListener("downloadprogress", (e) => {
+            onDownloadProgress(e.loaded);
+          });
+        };
+      }
+    }
+    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/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/built-in-ai-language-model.ts
+function doesBrowserSupportBuiltInAI() {
+  return typeof LanguageModel !== "undefined";
+}
+function isBuiltInAIModelAvailable() {
+  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 BuiltInAIChatLanguageModel = class {
+  constructor(modelId, options = {}) {
+    this.specificationVersion = "v2";
+    this.provider = "browser-ai";
+    this.supportedUrls = {
+      "image/*": [/^https?:\/\/.+$/],
+      "audio/*": [/^https?:\/\/.+$/]
+    };
+    this.modelId = modelId;
+    this.config = {
+      provider: this.provider,
+      modelId,
+      options
+    };
+    this.sessionManager = new SessionManager(options);
+  }
+  /**
+   * Gets a session with the specified options
+   * Delegates to SessionManager for all session lifecycle management
+   * @private
+   */
+  async getSession(options, expectedInputs, systemMessage, onDownloadProgress) {
+    return this.sessionManager.getSession({
+      ...options,
+      expectedInputs,
+      systemMessage,
+      onDownloadProgress
+    });
+  }
+  getArgs(callOptions) {
+    const {
+      prompt,
+      maxOutputTokens,
+      temperature,
+      topP,
+      topK,
+      frequencyPenalty,
+      presencePenalty,
+      stopSequences,
+      responseFormat,
+      seed,
+      tools,
+      toolChoice,
+      providerOptions
+    } = callOptions;
+    const warnings = [];
+    warnings.push(
+      ...gatherUnsupportedSettingWarnings({
+        maxOutputTokens,
+        stopSequences,
+        topP,
+        presencePenalty,
+        frequencyPenalty,
+        seed,
+        toolChoice
+      })
+    );
+    const functionTools = (tools ?? []).filter(isFunctionTool);
+    const unsupportedTools = (tools ?? []).filter(
+      (tool) => !isFunctionTool(tool)
+    );
+    for (const tool of unsupportedTools) {
+      warnings.push(
+        createUnsupportedToolWarning(
+          tool,
+          "Only function tools are supported by the Prompt API polyfill"
+        )
+      );
+    }
+    const hasMultiModalInput = hasMultimodalContent(prompt);
+    const { systemMessage, messages } = convertToBuiltInAIMessages(prompt);
+    const promptOptions = {};
+    if (responseFormat?.type === "json") {
+      promptOptions.responseConstraint = responseFormat.schema;
+    }
+    if (temperature !== void 0) {
+      promptOptions.temperature = temperature;
+    }
+    if (topK !== void 0) {
+      promptOptions.topK = topK;
+    }
+    return {
+      systemMessage,
+      messages,
+      warnings,
+      promptOptions,
+      hasMultiModalInput,
+      expectedInputs: hasMultiModalInput ? getExpectedInputs(prompt) : void 0,
+      functionTools
+    };
+  }
+  /**
+   * Generates a complete text response using the browser's built-in Prompt API
+   * @param options
+   * @returns Promise resolving to the generated content with finish reason, usage stats, and any warnings
+   * @throws {LoadSettingError} When the Prompt API is not available or model needs to be downloaded
+   * @throws {UnsupportedFunctionalityError} When unsupported features like file input are used
+   */
+  async doGenerate(options) {
+    const converted = this.getArgs(options);
+    const {
+      systemMessage,
+      messages,
+      warnings,
+      promptOptions,
+      expectedInputs,
+      functionTools
+    } = converted;
+    const session = await this.getSession(void 0, expectedInputs, void 0);
+    const systemPrompt = await buildJsonToolSystemPrompt(
+      systemMessage,
+      functionTools,
+      {
+        allowParallelToolCalls: false
+      }
+    );
+    const promptMessages = prependSystemPromptToMessages(
+      messages,
+      systemPrompt
+    );
+    const rawResponse = await session.prompt(promptMessages, promptOptions);
+    const { toolCalls, textContent } = parseJsonFunctionCalls(rawResponse);
+    if (toolCalls.length > 0) {
+      const toolCallsToEmit = toolCalls.slice(0, 1);
+      const parts = [];
+      if (textContent) {
+        parts.push({
+          type: "text",
+          text: textContent
+        });
+      }
+      for (const call of toolCallsToEmit) {
+        parts.push({
+          type: "tool-call",
+          toolCallId: call.toolCallId,
+          toolName: call.toolName,
+          input: JSON.stringify(call.args ?? {})
+        });
+      }
+      return {
+        content: parts,
+        finishReason: "tool-calls",
+        usage: {
+          inputTokens: void 0,
+          outputTokens: void 0,
+          totalTokens: void 0
+        },
+        request: { body: { messages: promptMessages, options: promptOptions } },
+        warnings
+      };
+    }
+    const content = [
+      {
+        type: "text",
+        text: textContent || rawResponse
+      }
+    ];
+    return {
+      content,
+      finishReason: "stop",
+      usage: {
+        inputTokens: void 0,
+        outputTokens: void 0,
+        totalTokens: void 0
+      },
+      request: { body: { messages: promptMessages, options: promptOptions } },
+      warnings
+    };
+  }
+  /**
+   * Check the availability of the built-in AI model
+   * @returns Promise resolving to "unavailable", "available", or "available-after-download"
+   */
+  async availability() {
+    return this.sessionManager.checkAvailability();
+  }
+  /**
+   * Creates a session with download progress monitoring.
+   *
+   * @example
+   * ```typescript
+   * const session = await model.createSessionWithProgress(
+   *   (progress) => {
+   *     console.log(`Download progress: ${Math.round(progress * 100)}%`);
+   *   }
+   * );
+   * ```
+   *
+   * @param onDownloadProgress Optional callback receiving progress values 0-1 during model download
+   * @returns Promise resolving to a configured LanguageModel session
+   * @throws {LoadSettingError} When the Prompt API is not available or model is unavailable
+   */
+  async createSessionWithProgress(onDownloadProgress) {
+    return this.sessionManager.createSessionWithProgress(onDownloadProgress);
+  }
+  /**
+   * Generates a streaming text response using the browser's built-in Prompt API
+   * @param options
+   * @returns Promise resolving to a readable stream of text chunks and request metadata
+   * @throws {LoadSettingError} When the Prompt API is not available or model needs to be downloaded
+   * @throws {UnsupportedFunctionalityError} When unsupported features like file input are used
+   */
+  async doStream(options) {
+    const converted = this.getArgs(options);
+    const {
+      systemMessage,
+      messages,
+      warnings,
+      promptOptions,
+      expectedInputs,
+      functionTools
+    } = converted;
+    const session = await this.getSession(void 0, expectedInputs, void 0);
+    const systemPrompt = await buildJsonToolSystemPrompt(
+      systemMessage,
+      functionTools,
+      {
+        allowParallelToolCalls: false
+      }
+    );
+    const promptMessages = prependSystemPromptToMessages(
+      messages,
+      systemPrompt
+    );
+    const streamOptions = {
+      ...promptOptions,
+      signal: options.abortSignal
+    };
+    const conversationHistory = [...promptMessages];
+    const textId = "text-0";
+    const stream = new ReadableStream({
+      start: async (controller) => {
+        controller.enqueue({
+          type: "stream-start",
+          warnings
+        });
+        let textStarted = false;
+        let finished = false;
+        let aborted = false;
+        let currentReader = null;
+        const ensureTextStart = () => {
+          if (!textStarted) {
+            controller.enqueue({
+              type: "text-start",
+              id: textId
+            });
+            textStarted = true;
+          }
+        };
+        const emitTextDelta = (delta) => {
+          if (!delta) return;
+          ensureTextStart();
+          controller.enqueue({
+            type: "text-delta",
+            id: textId,
+            delta
+          });
+        };
+        const emitTextEndIfNeeded = () => {
+          if (!textStarted) return;
+          controller.enqueue({
+            type: "text-end",
+            id: textId
+          });
+          textStarted = false;
+        };
+        const finishStream = (finishReason) => {
+          if (finished) return;
+          finished = true;
+          emitTextEndIfNeeded();
+          controller.enqueue({
+            type: "finish",
+            finishReason,
+            usage: {
+              inputTokens: session.inputUsage,
+              outputTokens: void 0,
+              totalTokens: void 0
+            }
+          });
+          controller.close();
+        };
+        const abortHandler = () => {
+          if (aborted) {
+            return;
+          }
+          aborted = true;
+          if (currentReader) {
+            currentReader.cancel().catch(() => void 0);
+          }
+          finishStream("stop");
+        };
+        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;
+            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;
+              }
+            }
+            currentReader = null;
+            if (aborted) {
+              return;
+            }
+            if (!toolBlockDetected && fenceDetector.hasContent()) {
+              emitTextDelta(fenceDetector.getBuffer());
+              fenceDetector.clearBuffer();
+            }
+            if (!toolBlockDetected || toolCalls.length === 0) {
+              finishStream("stop");
+              return;
+            }
+            if (trailingTextAfterBlock) {
+              emitTextDelta(trailingTextAfterBlock);
+            }
+            finishStream("tool-calls");
+            return;
+          }
+          if (!finished && !aborted) {
+            finishStream("other");
+          }
+        } catch (error) {
+          controller.enqueue({ type: "error", error });
+          controller.close();
+        } finally {
+          if (options.abortSignal) {
+            options.abortSignal.removeEventListener("abort", abortHandler);
+          }
+        }
+      }
+    });
+    return {
+      stream,
+      request: { body: { messages: promptMessages, options: promptOptions } }
+    };
+  }
+};
+
+// src/built-in-ai-embedding-model.ts
+var import_tasks_text = require("@mediapipe/tasks-text");
+var BuiltInAIEmbeddingModel = class {
+  constructor(settings = {}) {
+    this.specificationVersion = "v2";
+    this.provider = "google-mediapipe";
+    this.modelId = "embedding";
+    this.supportsParallelCalls = true;
+    this.maxEmbeddingsPerCall = void 0;
+    this.settings = {
+      wasmLoaderPath: "https://pub-ddcfe353995744e89b8002f16bf98575.r2.dev/text_wasm_internal.js",
+      wasmBinaryPath: "https://pub-ddcfe353995744e89b8002f16bf98575.r2.dev/text_wasm_internal.wasm",
+      modelAssetPath: "https://pub-ddcfe353995744e89b8002f16bf98575.r2.dev/universal_sentence_encoder.tflite",
+      l2Normalize: false,
+      quantize: false
+    };
+    this.getTextEmbedder = async () => {
+      return import_tasks_text.TextEmbedder.createFromOptions(
+        {
+          wasmBinaryPath: this.settings.wasmBinaryPath,
+          wasmLoaderPath: this.settings.wasmLoaderPath
+        },
+        {
+          baseOptions: {
+            modelAssetBuffer: await this.modelAssetBuffer,
+            delegate: this.settings.delegate
+          },
+          l2Normalize: this.settings.l2Normalize,
+          quantize: this.settings.quantize
+        }
+      );
+    };
+    this.doEmbed = async (options) => {
+      if (options.abortSignal?.aborted) {
+        throw new Error("Operation was aborted");
+      }
+      const embedder = await this.textEmbedder;
+      const embeddings = options.values.map((text) => {
+        const embedderResult = embedder.embed(text);
+        const [embedding] = embedderResult.embeddings;
+        return embedding?.floatEmbedding ?? [];
+      });
+      return {
+        embeddings,
+        rawResponse: {
+          model: "universal_sentence_encoder",
+          provider: "google-mediapipe",
+          processed_texts: options.values.length
+        }
+      };
+    };
+    this.settings = { ...this.settings, ...settings };
+    this.modelAssetBuffer = fetch(this.settings.modelAssetPath).then(
+      (response) => response.body.getReader()
+    );
+    this.textEmbedder = this.getTextEmbedder();
+  }
+};
+
+// src/built-in-ai-provider.ts
+var import_provider3 = require("@ai-sdk/provider");
+function createBuiltInAI(options = {}) {
+  const createChatModel = (modelId, settings) => {
+    return new BuiltInAIChatLanguageModel(modelId, settings);
+  };
+  const createEmbeddingModel = (modelId, settings) => {
+    return new BuiltInAIEmbeddingModel(settings);
+  };
+  const provider = function(modelId = "text", settings) {
+    if (new.target) {
+      throw new Error(
+        "The BuiltInAI model function cannot be called with the new keyword."
+      );
+    }
+    return createChatModel(modelId, settings);
+  };
+  provider.languageModel = createChatModel;
+  provider.chat = createChatModel;
+  provider.textEmbedding = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.imageModel = (modelId) => {
+    throw new import_provider3.NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
+  provider.speechModel = (modelId) => {
+    throw new import_provider3.NoSuchModelError({ modelId, modelType: "speechModel" });
+  };
+  provider.transcriptionModel = (modelId) => {
+    throw new import_provider3.NoSuchModelError({ modelId, modelType: "transcriptionModel" });
+  };
+  return provider;
+}
+var builtInAI = createBuiltInAI();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuiltInAIChatLanguageModel,
+  BuiltInAIEmbeddingModel,
+  builtInAI,
+  createBuiltInAI,
+  doesBrowserSupportBuiltInAI,
+  isBuiltInAIModelAvailable
+});
+//# sourceMappingURL=index.js.map