@browser-ai/web-llm 1.0.0 → 2.0.1

package/dist/index.mjs

@@ -2,7 +2,8 @@
 var marker = "vercel.ai.error";
 var symbol = Symbol.for(marker);
 var _a;
-var _AISDKError = class _AISDKError2 extends Error {
+var _b;
+var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
   /**
    * Creates an AI SDK Error.
    *
@@ -27,55 +28,172 @@ var _AISDKError = class _AISDKError2 extends Error {
    * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
    */
   static isInstance(error) {
-    return _AISDKError2.hasMarker(error, marker);
+    return _AISDKError.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 _b2;
+var APICallError = class extends (_b2 = AISDKError, _a2 = symbol2, _b2) {
+  constructor({
+    message,
+    url,
+    requestBodyValues,
+    statusCode,
+    responseHeaders,
+    responseBody,
+    cause,
+    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
+    statusCode === 409 || // conflict
+    statusCode === 429 || // too many requests
+    statusCode >= 500),
+    // server error
+    data
+  }) {
+    super({ name, message, cause });
+    this[_a2] = true;
+    this.url = url;
+    this.requestBodyValues = requestBodyValues;
+    this.statusCode = statusCode;
+    this.responseHeaders = responseHeaders;
+    this.responseBody = responseBody;
+    this.isRetryable = isRetryable;
+    this.data = data;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker2);
+  }
+};
 var name2 = "AI_EmptyResponseBodyError";
 var marker3 = `vercel.ai.error.${name2}`;
 var symbol3 = Symbol.for(marker3);
 var _a3;
-_a3 = symbol3;
+var _b3;
+var EmptyResponseBodyError = class extends (_b3 = AISDKError, _a3 = symbol3, _b3) {
+  // used in isInstance
+  constructor({ message = "Empty response body" } = {}) {
+    super({ name: name2, message });
+    this[_a3] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker3);
+  }
+};
+function getErrorMessage(error) {
+  if (error == null) {
+    return "unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}
 var name3 = "AI_InvalidArgumentError";
 var marker4 = `vercel.ai.error.${name3}`;
 var symbol4 = Symbol.for(marker4);
 var _a4;
-_a4 = symbol4;
+var _b4;
+var InvalidArgumentError = class extends (_b4 = AISDKError, _a4 = symbol4, _b4) {
+  constructor({
+    message,
+    cause,
+    argument
+  }) {
+    super({ name: name3, message, cause });
+    this[_a4] = true;
+    this.argument = argument;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker4);
+  }
+};
 var name4 = "AI_InvalidPromptError";
 var marker5 = `vercel.ai.error.${name4}`;
 var symbol5 = Symbol.for(marker5);
 var _a5;
-_a5 = symbol5;
+var _b5;
+var InvalidPromptError = class extends (_b5 = AISDKError, _a5 = symbol5, _b5) {
+  constructor({
+    prompt,
+    message,
+    cause
+  }) {
+    super({ name: name4, message: `Invalid prompt: ${message}`, cause });
+    this[_a5] = true;
+    this.prompt = prompt;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker5);
+  }
+};
 var name5 = "AI_InvalidResponseDataError";
 var marker6 = `vercel.ai.error.${name5}`;
 var symbol6 = Symbol.for(marker6);
 var _a6;
-_a6 = symbol6;
+var _b6;
+var InvalidResponseDataError = class extends (_b6 = AISDKError, _a6 = symbol6, _b6) {
+  constructor({
+    data,
+    message = `Invalid response data: ${JSON.stringify(data)}.`
+  }) {
+    super({ name: name5, message });
+    this[_a6] = true;
+    this.data = data;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker6);
+  }
+};
 var name6 = "AI_JSONParseError";
 var marker7 = `vercel.ai.error.${name6}`;
 var symbol7 = Symbol.for(marker7);
 var _a7;
-_a7 = symbol7;
+var _b7;
+var JSONParseError = class extends (_b7 = AISDKError, _a7 = symbol7, _b7) {
+  constructor({ text, cause }) {
+    super({
+      name: name6,
+      message: `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a7] = true;
+    this.text = text;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker7);
+  }
+};
 var name7 = "AI_LoadAPIKeyError";
 var marker8 = `vercel.ai.error.${name7}`;
 var symbol8 = Symbol.for(marker8);
 var _a8;
-_a8 = symbol8;
+var _b8;
+var LoadAPIKeyError = class extends (_b8 = AISDKError, _a8 = symbol8, _b8) {
+  // used in isInstance
+  constructor({ message }) {
+    super({ name: name7, message });
+    this[_a8] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker8);
+  }
+};
 var name8 = "AI_LoadSettingError";
 var marker9 = `vercel.ai.error.${name8}`;
 var symbol9 = Symbol.for(marker9);
 var _a9;
-var LoadSettingError = class extends AISDKError {
+var _b9;
+var LoadSettingError = class extends (_b9 = AISDKError, _a9 = symbol9, _b9) {
   // used in isInstance
   constructor({ message }) {
     super({ name: name8, message });
@@ -85,32 +203,107 @@ var LoadSettingError = class extends AISDKError {
     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 _b10;
+var NoContentGeneratedError = class extends (_b10 = AISDKError, _a10 = symbol10, _b10) {
+  // used in isInstance
+  constructor({
+    message = "No content generated."
+  } = {}) {
+    super({ name: name9, message });
+    this[_a10] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker10);
+  }
+};
 var name10 = "AI_NoSuchModelError";
 var marker11 = `vercel.ai.error.${name10}`;
 var symbol11 = Symbol.for(marker11);
 var _a11;
-_a11 = symbol11;
+var _b11;
+var NoSuchModelError = class extends (_b11 = AISDKError, _a11 = symbol11, _b11) {
+  constructor({
+    errorName = name10,
+    modelId,
+    modelType,
+    message = `No such ${modelType}: ${modelId}`
+  }) {
+    super({ name: errorName, message });
+    this[_a11] = true;
+    this.modelId = modelId;
+    this.modelType = modelType;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker11);
+  }
+};
 var name11 = "AI_TooManyEmbeddingValuesForCallError";
 var marker12 = `vercel.ai.error.${name11}`;
 var symbol12 = Symbol.for(marker12);
 var _a12;
-_a12 = symbol12;
+var _b12;
+var TooManyEmbeddingValuesForCallError = class extends (_b12 = AISDKError, _a12 = symbol12, _b12) {
+  constructor(options) {
+    super({
+      name: name11,
+      message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
+    });
+    this[_a12] = true;
+    this.provider = options.provider;
+    this.modelId = options.modelId;
+    this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
+    this.values = options.values;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker12);
+  }
+};
 var name12 = "AI_TypeValidationError";
 var marker13 = `vercel.ai.error.${name12}`;
 var symbol13 = Symbol.for(marker13);
 var _a13;
-_a13 = symbol13;
+var _b13;
+var TypeValidationError = class _TypeValidationError extends (_b13 = AISDKError, _a13 = symbol13, _b13) {
+  constructor({ value, cause }) {
+    super({
+      name: name12,
+      message: `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a13] = true;
+    this.value = value;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker13);
+  }
+  /**
+   * Wraps an error into a TypeValidationError.
+   * If the cause is already a TypeValidationError with the same value, it returns the cause.
+   * Otherwise, it creates a new TypeValidationError.
+   *
+   * @param {Object} params - The parameters for wrapping the error.
+   * @param {unknown} params.value - The value that failed validation.
+   * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @returns {TypeValidationError} A TypeValidationError instance.
+   */
+  static wrap({
+    value,
+    cause
+  }) {
+    return _TypeValidationError.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError({ value, cause });
+  }
+};
 var name13 = "AI_UnsupportedFunctionalityError";
 var marker14 = `vercel.ai.error.${name13}`;
 var symbol14 = Symbol.for(marker14);
 var _a14;
-var UnsupportedFunctionalityError = class extends AISDKError {
+var _b14;
+var UnsupportedFunctionalityError = class extends (_b14 = AISDKError, _a14 = symbol14, _b14) {
   constructor({
     functionality,
     message = `'${functionality}' functionality not supported.`
@@ -123,7 +316,6 @@ var UnsupportedFunctionalityError = class extends AISDKError {
     return AISDKError.hasMarker(error, marker14);
   }
 };
-_a14 = symbol14;
 
 // src/tool-calling/build-json-system-prompt.ts
 function buildJsonToolSystemPrompt(originalSystemPrompt, tools, options) {
@@ -267,6 +459,8 @@ function convertToolResultOutput(output) {
       return { value: output.value, isError: true };
     case "content":
       return { value: output.value, isError: false };
+    case "execution-denied":
+      return { value: output.reason, isError: true };
     default: {
       const exhaustiveCheck = output;
       return { value: exhaustiveCheck, isError: false };
@@ -379,7 +573,7 @@ function convertToWebLLMMessages(prompt) {
         }
         break;
       case "tool":
-        const toolResults = message.content.map(toToolResult);
+        const toolResults = message.content.filter((part) => part.type === "tool-result").map(toToolResult);
         const formattedResults = formatToolResults(toolResults);
         messages.push({
           role: "user",
@@ -398,17 +592,17 @@ import {
 } from "@mlc-ai/web-llm";
 
 // src/utils/warnings.ts
-function createUnsupportedSettingWarning(setting, details) {
+function createUnsupportedSettingWarning(feature, details) {
   return {
-    type: "unsupported-setting",
-    setting,
+    type: "unsupported",
+    feature,
     details
   };
 }
 function createUnsupportedToolWarning(tool, details) {
   return {
-    type: "unsupported-tool",
-    tool,
+    type: "unsupported",
+    feature: `tool:${tool.name}`,
     details
   };
 }
@@ -658,8 +852,21 @@ ${this.FENCE_END}`;
 };
 
 // src/web-llm-language-model.ts
+function isMobile() {
+  if (typeof navigator === "undefined") return false;
+  return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+    navigator.userAgent
+  );
+}
+function checkWebGPU() {
+  try {
+    return !!globalThis?.navigator?.gpu;
+  } catch {
+    return false;
+  }
+}
 function doesBrowserSupportWebLLM() {
-  return globalThis?.navigator?.gpu !== void 0;
+  return checkWebGPU();
 }
 function extractToolName(content) {
   const jsonMatch = content.match(/\{\s*"name"\s*:\s*"([^"]+)"/);
@@ -720,7 +927,7 @@ function extractArgumentsContent(content) {
 }
 var WebLLMLanguageModel = class {
   constructor(modelId, options = {}) {
-    this.specificationVersion = "v2";
+    this.specificationVersion = "v3";
     this.provider = "web-llm";
     this.isInitialized = false;
     this.supportedUrls = {
@@ -944,11 +1151,19 @@ var WebLLMLanguageModel = class {
         }
         return {
           content: parts,
-          finishReason: "tool-calls",
+          finishReason: { unified: "tool-calls", raw: "tool-calls" },
           usage: {
-            inputTokens: response.usage?.prompt_tokens,
-            outputTokens: response.usage?.completion_tokens,
-            totalTokens: response.usage?.total_tokens
+            inputTokens: {
+              total: response.usage?.prompt_tokens,
+              noCache: void 0,
+              cacheRead: void 0,
+              cacheWrite: void 0
+            },
+            outputTokens: {
+              total: response.usage?.completion_tokens,
+              text: void 0,
+              reasoning: void 0
+            }
           },
           request: { body: { messages: promptMessages, ...requestOptions } },
           warnings
@@ -960,17 +1175,31 @@ var WebLLMLanguageModel = class {
           text: textContent || rawResponse
         }
       ];
-      let finishReason = "stop";
+      let finishReason = {
+        unified: "stop",
+        raw: choice.finish_reason
+      };
       if (choice.finish_reason === "abort") {
-        finishReason = "other";
+        finishReason = { unified: "other", raw: choice.finish_reason };
       }
       return {
         content,
         finishReason,
         usage: {
-          inputTokens: response.usage?.prompt_tokens,
-          outputTokens: response.usage?.completion_tokens,
-          totalTokens: response.usage?.total_tokens
+          inputTokens: {
+            total: response.usage?.prompt_tokens,
+            noCache: void 0,
+            cacheRead: void 0,
+            cacheWrite: void 0
+          },
+          outputTokens: {
+            total: response.usage?.completion_tokens,
+            text: void 0,
+            reasoning: void 0
+          },
+          raw: {
+            total: response.usage?.total_tokens
+          }
         },
         request: { body: { messages: promptMessages, ...requestOptions } },
         warnings
@@ -986,17 +1215,20 @@ var WebLLMLanguageModel = class {
     }
   }
   /**
-   * Check the availability of the WebLLM model
-   * @returns Promise resolving to "unavailable", "available", or "available-after-download"
+   * Check the availability of the WebLLM model.
+   * Note: On mobile devices with a worker, WebGPU detection is skipped since it
+   * can't be done reliably. The actual availability will be determined at init.
+   * @returns Promise resolving to "unavailable", "available", or "downloadable"
    */
   async availability() {
-    if (!doesBrowserSupportWebLLM()) {
-      return "unavailable";
-    }
     if (this.isInitialized) {
       return "available";
     }
-    return "downloadable";
+    if (this.config.options.worker && isMobile()) {
+      return "downloadable";
+    }
+    const supported = checkWebGPU();
+    return supported ? "downloadable" : "unavailable";
   }
   /**
    * Creates an engine session with download progress monitoring.
@@ -1093,9 +1325,20 @@ var WebLLMLanguageModel = class {
             type: "finish",
             finishReason,
             usage: {
-              inputTokens: usage?.prompt_tokens,
-              outputTokens: usage?.completion_tokens,
-              totalTokens: usage?.total_tokens
+              inputTokens: {
+                total: usage?.prompt_tokens,
+                noCache: void 0,
+                cacheRead: void 0,
+                cacheWrite: void 0
+              },
+              outputTokens: {
+                total: usage?.completion_tokens,
+                text: void 0,
+                reasoning: void 0
+              },
+              raw: {
+                total: usage?.total_tokens
+              }
             }
           });
           controller.close();
@@ -1293,20 +1536,23 @@ var WebLLMLanguageModel = class {
                 emitTextDelta(fenceDetector.getBuffer());
                 fenceDetector.clearBuffer();
               }
-              let finishReason = "stop";
+              let finishReason = {
+                unified: "stop",
+                raw: "stop"
+              };
               if (choice.finish_reason === "abort") {
-                finishReason = "other";
+                finishReason = { unified: "other", raw: "abort" };
               } else {
                 const { toolCalls } = parseJsonFunctionCalls(accumulatedText);
                 if (toolCalls.length > 0) {
-                  finishReason = "tool-calls";
+                  finishReason = { unified: "tool-calls", raw: "tool-calls" };
                 }
               }
               finishStream(finishReason, chunk.usage);
             }
           }
           if (!finished) {
-            finishStream("stop");
+            finishStream({ unified: "stop", raw: "stop" });
           }
         } catch (error) {
           controller.error(error);