@browser-ai/web-llm 1.0.0

package/dist/index.js

@@ -0,0 +1,1370 @@
+"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 name14 in all)
+    __defProp(target, name14, { get: all[name14], 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, {
+  WebLLMLanguageModel: () => WebLLMLanguageModel,
+  WebWorkerMLCEngineHandler: () => import_web_llm2.WebWorkerMLCEngineHandler,
+  doesBrowserSupportWebLLM: () => doesBrowserSupportWebLLM,
+  webLLM: () => webLLM
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../../node_modules/@ai-sdk/provider/dist/index.mjs
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a;
+var _AISDKError = class _AISDKError2 extends Error {
+  /**
+   * Creates an AI SDK Error.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {string} params.name - The name of the error.
+   * @param {string} params.message - The error message.
+   * @param {unknown} [params.cause] - The underlying cause of the error.
+   */
+  constructor({
+    name: name14,
+    message,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.name = name14;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is an AI SDK Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _AISDKError2.hasMarker(error, marker);
+  }
+  static hasMarker(error, marker15) {
+    const markerSymbol = Symbol.for(marker15);
+    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+  }
+};
+_a = symbol;
+var AISDKError = _AISDKError;
+var name = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+_a2 = symbol2;
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+_a3 = symbol3;
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+_a4 = symbol4;
+var name4 = "AI_InvalidPromptError";
+var marker5 = `vercel.ai.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+_a5 = symbol5;
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+_a6 = symbol6;
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+_a7 = symbol7;
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+_a8 = symbol8;
+var name8 = "AI_LoadSettingError";
+var marker9 = `vercel.ai.error.${name8}`;
+var symbol9 = Symbol.for(marker9);
+var _a9;
+var LoadSettingError = class extends AISDKError {
+  // used in isInstance
+  constructor({ message }) {
+    super({ name: name8, message });
+    this[_a9] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker9);
+  }
+};
+_a9 = symbol9;
+var name9 = "AI_NoContentGeneratedError";
+var marker10 = `vercel.ai.error.${name9}`;
+var symbol10 = Symbol.for(marker10);
+var _a10;
+_a10 = symbol10;
+var name10 = "AI_NoSuchModelError";
+var marker11 = `vercel.ai.error.${name10}`;
+var symbol11 = Symbol.for(marker11);
+var _a11;
+_a11 = symbol11;
+var name11 = "AI_TooManyEmbeddingValuesForCallError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+_a12 = symbol12;
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+_a13 = symbol13;
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+var UnsupportedFunctionalityError = class extends AISDKError {
+  constructor({
+    functionality,
+    message = `'${functionality}' functionality not supported.`
+  }) {
+    super({ name: name13, message });
+    this[_a14] = true;
+    this.functionality = functionality;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker14);
+  }
+};
+_a14 = symbol14;
+
+// 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/tool-calling/format-tool-results.ts
+function formatToolResults(results) {
+  if (results.length === 0) {
+    return "";
+  }
+  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
+  });
+}
+
+// src/convert-to-webllm-messages.tsx
+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 uint8ArrayToBase64(uint8array) {
+  const binary = Array.from(
+    uint8array,
+    (byte) => String.fromCharCode(byte)
+  ).join("");
+  return btoa(binary);
+}
+function convertDataToURL(data, mediaType) {
+  if (data instanceof URL) {
+    return data.toString();
+  }
+  if (typeof data === "string") {
+    return `data:${mediaType};base64,${data}`;
+  }
+  if (data instanceof Uint8Array) {
+    return `data:${mediaType};base64,${uint8ArrayToBase64(data)}`;
+  }
+  if (data instanceof ArrayBuffer) {
+    return `data:${mediaType};base64,${uint8ArrayToBase64(
+      new Uint8Array(data)
+    )}`;
+  }
+  if (typeof Buffer !== "undefined" && data instanceof Buffer) {
+    return `data:${mediaType};base64,${data.toString("base64")}`;
+  }
+  throw new UnsupportedFunctionalityError({
+    functionality: `file data type: ${typeof data}`
+  });
+}
+function convertToWebLLMMessages(prompt) {
+  const messages = [];
+  for (const message of prompt) {
+    switch (message.role) {
+      case "system":
+        messages.push({
+          role: "system",
+          content: message.content
+        });
+        break;
+      case "user":
+        const hasFileContent = message.content.some(
+          (part) => part.type === "file"
+        );
+        if (!hasFileContent) {
+          const userContent = [];
+          for (const part of message.content) {
+            if (part.type === "text") {
+              userContent.push(part.text);
+            }
+          }
+          messages.push({
+            role: "user",
+            content: userContent.join("\n")
+          });
+          break;
+        }
+        const content = [];
+        for (const part of message.content) {
+          if (part.type === "text") {
+            content.push({ type: "text", text: part.text });
+          } else if (part.type === "file") {
+            if (!part.mediaType?.startsWith("image/")) {
+              throw new UnsupportedFunctionalityError({
+                functionality: `file input with media type '${part.mediaType}'`
+              });
+            }
+            content.push({
+              type: "image_url",
+              image_url: {
+                url: convertDataToURL(part.data, part.mediaType)
+              }
+            });
+          }
+        }
+        messages.push({ role: "user", content });
+        break;
+      case "assistant":
+        let assistantContent = "";
+        const toolCallsInMessage = [];
+        for (const part of message.content) {
+          if (part.type === "text") {
+            assistantContent += part.text;
+          } else if (part.type === "tool-call") {
+            toolCallsInMessage.push({
+              toolCallId: part.toolCallId,
+              toolName: part.toolName
+            });
+          }
+        }
+        if (assistantContent) {
+          messages.push({
+            role: "assistant",
+            content: assistantContent
+          });
+        }
+        break;
+      case "tool":
+        const toolResults = message.content.map(toToolResult);
+        const formattedResults = formatToolResults(toolResults);
+        messages.push({
+          role: "user",
+          content: formattedResults
+        });
+        break;
+    }
+  }
+  return messages;
+}
+
+// src/web-llm-language-model.ts
+var import_web_llm = require("@mlc-ai/web-llm");
+
+// src/utils/warnings.ts
+function createUnsupportedSettingWarning(setting, details) {
+  return {
+    type: "unsupported-setting",
+    setting,
+    details
+  };
+}
+function createUnsupportedToolWarning(tool, details) {
+  return {
+    type: "unsupported-tool",
+    tool,
+    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");
+  const nonSystemMessages = messages.filter((msg) => msg.role !== "system");
+  if (systemMessages.length === 0) {
+    return { systemPrompt: void 0, messages };
+  }
+  const systemPrompt = systemMessages.map((msg) => msg.content).filter((content) => typeof content === "string").join("\n\n");
+  return {
+    systemPrompt: systemPrompt || void 0,
+    messages: nonSystemMessages
+  };
+}
+function prependSystemPromptToMessages(messages, systemPrompt) {
+  if (!systemPrompt.trim()) {
+    return messages;
+  }
+  const systemMessageIndex = messages.findIndex((msg) => msg.role === "system");
+  if (systemMessageIndex !== -1) {
+    const newMessages = [...messages];
+    const existingSystemMessage = messages[systemMessageIndex];
+    const existingContent = typeof existingSystemMessage.content === "string" ? existingSystemMessage.content : "";
+    newMessages[systemMessageIndex] = {
+      ...existingSystemMessage,
+      content: systemPrompt + (existingContent ? `
+
+${existingContent}` : "")
+    };
+    return newMessages;
+  }
+  return [
+    {
+      role: "system",
+      content: systemPrompt
+    },
+    ...messages
+  ];
+}
+
+// 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 doesBrowserSupportWebLLM() {
+  return globalThis?.navigator?.gpu !== void 0;
+}
+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 WebLLMLanguageModel = class {
+  constructor(modelId, options = {}) {
+    this.specificationVersion = "v2";
+    this.provider = "web-llm";
+    this.isInitialized = false;
+    this.supportedUrls = {
+      // WebLLM doesn't support URLs natively
+    };
+    this.modelId = modelId;
+    this.config = {
+      provider: this.provider,
+      modelId,
+      options
+    };
+  }
+  /**
+   * Check if the model is initialized and ready to use
+   * @returns true if the model is initialized, false otherwise
+   */
+  get isModelInitialized() {
+    return this.isInitialized;
+  }
+  async getEngine(options, onInitProgress) {
+    const availability = await this.availability();
+    if (availability === "unavailable") {
+      throw new LoadSettingError({
+        message: "WebLLM is not available. This library requires a browser with WebGPU support."
+      });
+    }
+    if (this.engine && this.isInitialized) return this.engine;
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+      if (this.engine) return this.engine;
+    }
+    this.initializationPromise = this._initializeEngine(
+      options,
+      onInitProgress
+    );
+    await this.initializationPromise;
+    if (!this.engine) {
+      throw new LoadSettingError({
+        message: "Engine initialization failed"
+      });
+    }
+    return this.engine;
+  }
+  async _initializeEngine(options, onInitProgress) {
+    try {
+      const engineConfig = {
+        ...this.config.options.engineConfig,
+        ...options,
+        initProgressCallback: onInitProgress || this.config.options.initProgressCallback
+      };
+      if (this.config.options.worker) {
+        this.engine = await (0, import_web_llm.CreateWebWorkerMLCEngine)(
+          this.config.options.worker,
+          this.modelId,
+          engineConfig
+        );
+      } else {
+        this.engine = new import_web_llm.MLCEngine(engineConfig);
+        await this.engine.reload(this.modelId);
+      }
+      this.isInitialized = true;
+    } catch (error) {
+      this.engine = void 0;
+      this.isInitialized = false;
+      this.initializationPromise = void 0;
+      throw new LoadSettingError({
+        message: `Failed to initialize WebLLM engine: ${error instanceof Error ? error.message : "Unknown error"}`
+      });
+    }
+  }
+  getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    responseFormat,
+    seed,
+    tools,
+    toolChoice
+  }) {
+    const warnings = [];
+    const functionTools = (tools ?? []).filter(isFunctionTool).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }));
+    const unsupportedTools = (tools ?? []).filter(
+      (tool) => !isFunctionTool(tool)
+    );
+    for (const tool of unsupportedTools) {
+      warnings.push(
+        createUnsupportedToolWarning(
+          tool,
+          "Only function tools are supported by WebLLM"
+        )
+      );
+    }
+    if (topK != null) {
+      warnings.push(
+        createUnsupportedSettingWarning(
+          "topK",
+          "topK is not supported by WebLLM"
+        )
+      );
+    }
+    if (stopSequences != null) {
+      warnings.push(
+        createUnsupportedSettingWarning(
+          "stopSequences",
+          "Stop sequences may not be fully implemented"
+        )
+      );
+    }
+    if (presencePenalty != null) {
+      warnings.push(
+        createUnsupportedSettingWarning(
+          "presencePenalty",
+          "Presence penalty is not fully implemented"
+        )
+      );
+    }
+    if (frequencyPenalty != null) {
+      warnings.push(
+        createUnsupportedSettingWarning(
+          "frequencyPenalty",
+          "Frequency penalty is not fully implemented"
+        )
+      );
+    }
+    if (toolChoice != null) {
+      warnings.push(
+        createUnsupportedSettingWarning(
+          "toolChoice",
+          "toolChoice is not supported by WebLLM"
+        )
+      );
+    }
+    const messages = convertToWebLLMMessages(prompt);
+    const requestOptions = {
+      messages,
+      temperature,
+      max_tokens: maxOutputTokens,
+      top_p: topP,
+      seed
+    };
+    if (responseFormat?.type === "json") {
+      requestOptions.response_format = { type: "json_object" };
+    }
+    return {
+      messages,
+      warnings,
+      requestOptions,
+      functionTools
+    };
+  }
+  /**
+   * Generates a complete text response using WebLLM
+   * @param options
+   * @returns Promise resolving to the generated content with finish reason, usage stats, and any warnings
+   * @throws {LoadSettingError} When WebLLM 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 { messages, warnings, requestOptions, functionTools } = converted;
+    const {
+      systemPrompt: originalSystemPrompt,
+      messages: messagesWithoutSystem
+    } = extractSystemPrompt(messages);
+    const systemPrompt = buildJsonToolSystemPrompt(
+      originalSystemPrompt,
+      functionTools,
+      {
+        allowParallelToolCalls: false
+      }
+    );
+    const promptMessages = prependSystemPromptToMessages(
+      messagesWithoutSystem,
+      systemPrompt
+    );
+    const engine = await this.getEngine();
+    const abortHandler = async () => {
+      await engine.interruptGenerate();
+    };
+    if (options.abortSignal) {
+      options.abortSignal.addEventListener("abort", abortHandler);
+    }
+    try {
+      const response = await engine.chat.completions.create({
+        ...requestOptions,
+        messages: promptMessages,
+        stream: false,
+        ...options.abortSignal && !this.config.options.worker && { signal: options.abortSignal }
+      });
+      const choice = response.choices[0];
+      if (!choice) {
+        throw new Error("No response choice returned from WebLLM");
+      }
+      const rawResponse = choice.message.content || "";
+      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: response.usage?.prompt_tokens,
+            outputTokens: response.usage?.completion_tokens,
+            totalTokens: response.usage?.total_tokens
+          },
+          request: { body: { messages: promptMessages, ...requestOptions } },
+          warnings
+        };
+      }
+      const content = [
+        {
+          type: "text",
+          text: textContent || rawResponse
+        }
+      ];
+      let finishReason = "stop";
+      if (choice.finish_reason === "abort") {
+        finishReason = "other";
+      }
+      return {
+        content,
+        finishReason,
+        usage: {
+          inputTokens: response.usage?.prompt_tokens,
+          outputTokens: response.usage?.completion_tokens,
+          totalTokens: response.usage?.total_tokens
+        },
+        request: { body: { messages: promptMessages, ...requestOptions } },
+        warnings
+      };
+    } catch (error) {
+      throw new Error(
+        `WebLLM generation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    } finally {
+      if (options.abortSignal) {
+        options.abortSignal.removeEventListener("abort", abortHandler);
+      }
+    }
+  }
+  /**
+   * Check the availability of the WebLLM model
+   * @returns Promise resolving to "unavailable", "available", or "available-after-download"
+   */
+  async availability() {
+    if (!doesBrowserSupportWebLLM()) {
+      return "unavailable";
+    }
+    if (this.isInitialized) {
+      return "available";
+    }
+    return "downloadable";
+  }
+  /**
+   * Creates an engine session with download progress monitoring.
+   *
+   * @example
+   * ```typescript
+   * const engine = await model.createSessionWithProgress(
+   *   (progress) => {
+   *     console.log(`Download progress: ${Math.round(progress.loaded * 100)}%`);
+   *   }
+   * );
+   * ```
+   *
+   * @param onInitProgress Optional callback receiving progress reports during model download
+   * @returns Promise resolving to a configured WebLLM engine
+   * @throws {LoadSettingError} When WebLLM is not available or model is unavailable
+   */
+  async createSessionWithProgress(onInitProgress) {
+    return this.getEngine(void 0, onInitProgress);
+  }
+  /**
+   * Generates a streaming text response using WebLLM
+   * @param options
+   * @returns Promise resolving to a readable stream of text chunks and request metadata
+   * @throws {LoadSettingError} When WebLLM 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 { messages, warnings, requestOptions, functionTools } = converted;
+    const {
+      systemPrompt: originalSystemPrompt,
+      messages: messagesWithoutSystem
+    } = extractSystemPrompt(messages);
+    const systemPrompt = buildJsonToolSystemPrompt(
+      originalSystemPrompt,
+      functionTools,
+      {
+        allowParallelToolCalls: false
+      }
+    );
+    const promptMessages = prependSystemPromptToMessages(
+      messagesWithoutSystem,
+      systemPrompt
+    );
+    const engine = await this.getEngine();
+    const useWorker = this.config.options.worker != null;
+    const abortHandler = async () => {
+      await engine.interruptGenerate();
+    };
+    if (options.abortSignal) {
+      options.abortSignal.addEventListener("abort", abortHandler);
+    }
+    const textId = "text-0";
+    const stream = new ReadableStream({
+      async start(controller) {
+        controller.enqueue({
+          type: "stream-start",
+          warnings
+        });
+        let textStarted = false;
+        let finished = false;
+        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, usage) => {
+          if (finished) return;
+          finished = true;
+          emitTextEndIfNeeded();
+          controller.enqueue({
+            type: "finish",
+            finishReason,
+            usage: {
+              inputTokens: usage?.prompt_tokens,
+              outputTokens: usage?.completion_tokens,
+              totalTokens: usage?.total_tokens
+            }
+          });
+          controller.close();
+        };
+        try {
+          const streamingRequest = {
+            ...requestOptions,
+            messages: promptMessages,
+            stream: true,
+            stream_options: { include_usage: true },
+            ...options.abortSignal && !useWorker && { signal: options.abortSignal }
+          };
+          const response = await engine.chat.completions.create(streamingRequest);
+          const fenceDetector = new ToolCallFenceDetector();
+          let accumulatedText = "";
+          let currentToolCallId = null;
+          let toolInputStartEmitted = false;
+          let accumulatedFenceContent = "";
+          let streamedArgumentsLength = 0;
+          let insideFence = false;
+          for await (const chunk of response) {
+            const choice = chunk.choices[0];
+            if (!choice) continue;
+            if (choice.delta.content) {
+              const delta = choice.delta.content;
+              accumulatedText += delta;
+              fenceDetector.addChunk(delta);
+              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 delta2 = argsContent.slice(streamedArgumentsLength);
+                      streamedArgumentsLength = argsContent.length;
+                      if (delta2.length > 0) {
+                        controller.enqueue({
+                          type: "tool-input-delta",
+                          id: currentToolCallId,
+                          delta: delta2
+                        });
+                      }
+                    }
+                  }
+                  const parsed = parseJsonFunctionCalls(result.completeFence);
+                  const parsedToolCalls = parsed.toolCalls;
+                  const selectedToolCalls = parsedToolCalls.slice(0, 1);
+                  if (selectedToolCalls.length === 0) {
+                    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;
+                  }
+                  for (const [index, call] of selectedToolCalls.entries()) {
+                    const toolCallId = index === 0 && currentToolCallId ? currentToolCallId : call.toolCallId;
+                    const toolName = call.toolName;
+                    const argsJson = JSON.stringify(call.args ?? {});
+                    if (toolCallId === currentToolCallId) {
+                      if (!toolInputStartEmitted) {
+                        controller.enqueue({
+                          type: "tool-input-start",
+                          id: toolCallId,
+                          toolName
+                        });
+                        toolInputStartEmitted = true;
+                      }
+                      const argsContent = extractArgumentsContent(
+                        accumulatedFenceContent
+                      );
+                      if (argsContent.length > streamedArgumentsLength) {
+                        const delta2 = argsContent.slice(
+                          streamedArgumentsLength
+                        );
+                        streamedArgumentsLength = argsContent.length;
+                        if (delta2.length > 0) {
+                          controller.enqueue({
+                            type: "tool-input-delta",
+                            id: toolCallId,
+                            delta: delta2
+                          });
+                        }
+                      }
+                    } 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
+                    });
+                  }
+                  if (result.textAfterFence) {
+                    emitTextDelta(result.textAfterFence);
+                  }
+                  madeProgress = true;
+                  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 delta2 = argsContent.slice(
+                          streamedArgumentsLength
+                        );
+                        streamedArgumentsLength = argsContent.length;
+                        if (delta2.length > 0) {
+                          controller.enqueue({
+                            type: "tool-input-delta",
+                            id: currentToolCallId,
+                            delta: delta2
+                          });
+                        }
+                      }
+                    }
+                  }
+                  continue;
+                }
+                if (!insideFence && result.safeContent) {
+                  emitTextDelta(result.safeContent);
+                  madeProgress = true;
+                }
+                if (!madeProgress) {
+                  break;
+                }
+              }
+            }
+            if (choice.finish_reason) {
+              if (fenceDetector.hasContent()) {
+                emitTextDelta(fenceDetector.getBuffer());
+                fenceDetector.clearBuffer();
+              }
+              let finishReason = "stop";
+              if (choice.finish_reason === "abort") {
+                finishReason = "other";
+              } else {
+                const { toolCalls } = parseJsonFunctionCalls(accumulatedText);
+                if (toolCalls.length > 0) {
+                  finishReason = "tool-calls";
+                }
+              }
+              finishStream(finishReason, chunk.usage);
+            }
+          }
+          if (!finished) {
+            finishStream("stop");
+          }
+        } catch (error) {
+          controller.error(error);
+        } finally {
+          if (options.abortSignal) {
+            options.abortSignal.removeEventListener("abort", abortHandler);
+          }
+          if (!finished) {
+            controller.close();
+          }
+        }
+      }
+    });
+    return {
+      stream,
+      request: { body: { messages: promptMessages, ...requestOptions } }
+    };
+  }
+};
+
+// src/index.ts
+var import_web_llm2 = require("@mlc-ai/web-llm");
+
+// src/web-llm-provider.ts
+function webLLM(modelId, settings) {
+  return new WebLLMLanguageModel(modelId, settings);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebLLMLanguageModel,
+  WebWorkerMLCEngineHandler,
+  doesBrowserSupportWebLLM,
+  webLLM
+});
+//# sourceMappingURL=index.js.map