@friendliai/ai-provider 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/index.js

@@ -27,30 +27,101 @@ module.exports = __toCommonJS(index_exports);
 
 // src/friendli-provider.ts
 var import_openai_compatible = require("@ai-sdk/openai-compatible");
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_provider4 = require("@ai-sdk/provider");
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
 
 // src/friendli-chat-language-model.ts
 var import_internal = require("@ai-sdk/openai-compatible/internal");
-var import_provider2 = require("@ai-sdk/provider");
+var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 var import_v42 = require("zod/v4");
 
 // src/friendli-error.ts
+var import_provider = require("@ai-sdk/provider");
 var import_provider_utils = require("@ai-sdk/provider-utils");
 var import_v4 = require("zod/v4");
-var friendliaiErrorSchema = import_v4.z.object({
+var friendliErrorResponseSchema = import_v4.z.object({
   message: import_v4.z.string(),
-  error: import_v4.z.record(import_v4.z.string(), import_v4.z.any())
+  error: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).optional()
 });
+var openAIStyleErrorResponseSchema = import_v4.z.object({
+  error: import_v4.z.object({
+    message: import_v4.z.string()
+  }).loose()
+}).loose();
+var friendliaiErrorSchema = import_v4.z.union([
+  // OpenAI/OpenRouter style error: { "error": { "message": "..." } }
+  openAIStyleErrorResponseSchema,
+  // Friendli style error: { "message": "...", "error": { ... } }
+  friendliErrorResponseSchema
+]);
 var friendliaiErrorStructure = {
   errorSchema: friendliaiErrorSchema,
-  errorToMessage: (data) => data.message
+  errorToMessage: (data) => {
+    if (typeof data === "object" && data != null && "error" in data && typeof data.error === "object" && data.error != null && "message" in data.error && typeof data.error.message === "string") {
+      return data.error.message;
+    }
+    if (typeof data === "object" && data != null && "message" in data && typeof data.message === "string") {
+      return data.message;
+    }
+    return "Unknown error";
+  }
+};
+var friendliaiFailedResponseHandler = async ({
+  response,
+  url,
+  requestBodyValues
+}) => {
+  const responseBody = await response.text();
+  const responseHeaders = {};
+  response.headers.forEach((value, key) => {
+    responseHeaders[key] = value;
+  });
+  const baseErrorOptions = {
+    url,
+    requestBodyValues,
+    statusCode: response.status,
+    responseHeaders,
+    responseBody
+  };
+  const trimmedBody = responseBody.trim();
+  if (trimmedBody === "") {
+    const fallback2 = response.statusText || `Request failed with status ${response.status}`;
+    return {
+      responseHeaders,
+      value: new import_provider.APICallError({
+        message: fallback2,
+        ...baseErrorOptions
+      })
+    };
+  }
+  const parsedError = await (0, import_provider_utils.safeParseJSON)({
+    text: responseBody,
+    schema: friendliaiErrorSchema
+  });
+  if (parsedError.success) {
+    return {
+      responseHeaders,
+      value: new import_provider.APICallError({
+        message: friendliaiErrorStructure.errorToMessage(parsedError.value),
+        data: parsedError.value,
+        ...baseErrorOptions
+      })
+    };
+  }
+  const fallback = trimmedBody || response.statusText || `Request failed with status ${response.status}`;
+  return {
+    responseHeaders,
+    value: new import_provider.APICallError({
+      message: fallback,
+      cause: parsedError.error,
+      ...baseErrorOptions
+    })
+  };
 };
-var friendliaiFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)(friendliaiErrorStructure);
 
 // src/friendli-prepare-tools.ts
-var import_provider = require("@ai-sdk/provider");
+var import_provider2 = require("@ai-sdk/provider");
 function prepareTools({
   tools,
   toolChoice
@@ -63,9 +134,11 @@ function prepareTools({
   }
   const openaiCompatTools = [];
   for (const tool of tools) {
-    if (tool.type === "provider-defined") {
+    if (tool.type === "provider") {
       openaiCompatTools.push({
-        // NOTE: It would be better to use tool.name, but since ":" is replaced with "_", the following code is used instead
+        // NOTE: Friendli tool-assisted API expects provider tool types like "web:search".
+        // We derive it from the provider tool id (e.g. "friendli.web:search" -> "web:search")
+        // instead of tool.name (often "web_search").
         type: (_a = tool.id.split(".")[1]) != null ? _a : "unknown"
       });
     } else {
@@ -99,7 +172,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider.UnsupportedFunctionalityError({
+      throw new import_provider2.UnsupportedFunctionalityError({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -107,16 +180,38 @@ function prepareTools({
 }
 
 // src/friendli-chat-language-model.ts
+function isRecord(value) {
+  return typeof value === "object" && value != null;
+}
+function isHostedToolExecutionChunk(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.status === "string" && typeof value.name === "string" && Array.isArray(value.parameters);
+}
+function getChunkErrorMessage(value) {
+  if (!isRecord(value)) return void 0;
+  if (typeof value.message === "string") {
+    return value.message;
+  }
+  const nestedError = value.error;
+  if (isRecord(nestedError) && typeof nestedError.message === "string") {
+    return nestedError.message;
+  }
+  return void 0;
+}
+function isOpenAIChatChunk(value) {
+  if (!isRecord(value)) return false;
+  return Array.isArray(value.choices);
+}
 var FriendliAIChatLanguageModel = class {
   // type inferred via constructor
   constructor(modelId, config) {
-    this.specificationVersion = "v2";
+    this.specificationVersion = "v3";
     var _a;
     this.modelId = modelId;
     this.config = config;
     const errorStructure = friendliaiErrorStructure;
     this.chunkSchema = createOpenAICompatibleChatChunkSchema(errorStructure.errorSchema);
-    this.failedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)(friendliaiErrorStructure);
+    this.failedResponseHandler = friendliaiFailedResponseHandler;
     this.supportsStructuredOutputs = (_a = config.supportsStructuredOutputs) != null ? _a : true;
   }
   get provider() {
@@ -144,18 +239,24 @@ var FriendliAIChatLanguageModel = class {
   }) {
     var _a;
     const warnings = [];
-    if (topK != null) {
-      warnings.push({ type: "unsupported-setting", setting: "topK" });
-    }
     const friendliOptions = await (0, import_provider_utils2.parseProviderOptions)({
+      provider: "friendliai",
+      providerOptions,
+      schema: friendliProviderOptionsSchema
+    });
+    const legacyFriendliOptions = await (0, import_provider_utils2.parseProviderOptions)({
       provider: "friendli",
       providerOptions,
       schema: friendliProviderOptionsSchema
     });
+    const options = {
+      ...legacyFriendliOptions,
+      ...friendliOptions
+    };
     if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "responseFormat",
+        type: "unsupported",
+        feature: "responseFormat",
         details: "JSON response format schema is only supported with structuredOutputs"
       });
     }
@@ -167,6 +268,14 @@ var FriendliAIChatLanguageModel = class {
       tools,
       toolChoice
     });
+    const isToolsPresent = openaiTools != null && openaiTools.length > 0;
+    if (isToolsPresent && (responseFormat != null || (options == null ? void 0 : options.regex) != null)) {
+      warnings.push({
+        type: "unsupported",
+        feature: "responseFormat",
+        details: "response_format is not supported when tools are present."
+      });
+    }
     return {
       args: {
         // >>> hard-coded default options >>>
@@ -178,36 +287,39 @@ var FriendliAIChatLanguageModel = class {
         max_tokens: maxOutputTokens,
         temperature,
         top_p: topP,
+        top_k: topK,
         frequency_penalty: frequencyPenalty,
         presence_penalty: presencePenalty,
-        response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? this.supportsStructuredOutputs === true && responseFormat.schema != null ? {
+        response_format: isToolsPresent === false ? (responseFormat == null ? void 0 : responseFormat.type) === "json" ? this.supportsStructuredOutputs === true && responseFormat.schema != null ? {
           type: "json_schema",
           json_schema: {
             schema: responseFormat.schema,
             name: (_a = responseFormat.name) != null ? _a : "response",
             description: responseFormat.description
           }
-        } : { type: "json_object" } : (friendliOptions == null ? void 0 : friendliOptions.regex) != null ? {
+        } : { type: "json_object" } : (options == null ? void 0 : options.regex) != null ? {
           type: "regex",
-          schema: friendliOptions.regex
-        } : void 0,
+          schema: options.regex
+        } : void 0 : void 0,
         stop: stopSequences,
         seed,
-        ...(friendliOptions == null ? void 0 : friendliOptions.chat_template_kwargs) ? { chat_template_kwargs: friendliOptions.chat_template_kwargs } : {},
-        // ...providerOptions?.[this.providerOptionsName],
-        // reasoning_effort: compatibleOptions.reasoningEffort,
+        min_p: options == null ? void 0 : options.minP,
+        repetition_penalty: options == null ? void 0 : options.repetitionPenalty,
+        xtc_threshold: options == null ? void 0 : options.xtcThreshold,
+        xtc_probability: options == null ? void 0 : options.xtcProbability,
+        ...(options == null ? void 0 : options.chat_template_kwargs) ? { chat_template_kwargs: options.chat_template_kwargs } : {},
         // messages:
         messages: (0, import_internal.convertToOpenAICompatibleChatMessages)(prompt),
         // tools:
         tools: openaiTools,
         tool_choice: openaiToolChoice,
-        parallel_tool_calls: friendliOptions == null ? void 0 : friendliOptions.parallelToolCalls
+        parallel_tool_calls: options == null ? void 0 : options.parallelToolCalls
       },
       warnings: [...warnings, ...toolWarnings]
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     const { args, warnings } = await this.getArgs({ ...options, stream: false });
     const body = JSON.stringify(args);
     const {
@@ -253,11 +365,17 @@ var FriendliAIChatLanguageModel = class {
       content,
       finishReason: (0, import_internal.mapOpenAICompatibleFinishReason)(choice.finish_reason),
       usage: {
-        inputTokens: (_c = (_b = responseBody.usage) == null ? void 0 : _b.prompt_tokens) != null ? _c : void 0,
-        outputTokens: (_e = (_d = responseBody.usage) == null ? void 0 : _d.completion_tokens) != null ? _e : void 0,
-        totalTokens: (_g = (_f = responseBody.usage) == null ? void 0 : _f.total_tokens) != null ? _g : void 0,
-        reasoningTokens: (_j = (_i = (_h = responseBody.usage) == null ? void 0 : _h.completion_tokens_details) == null ? void 0 : _i.reasoning_tokens) != null ? _j : void 0,
-        cachedInputTokens: (_m = (_l = (_k = responseBody.usage) == null ? void 0 : _k.prompt_tokens_details) == null ? void 0 : _l.cached_tokens) != null ? _m : void 0
+        inputTokens: {
+          total: (_c = (_b = responseBody.usage) == null ? void 0 : _b.prompt_tokens) != null ? _c : void 0,
+          noCache: void 0,
+          cacheRead: (_f = (_e = (_d = responseBody.usage) == null ? void 0 : _d.prompt_tokens_details) == null ? void 0 : _e.cached_tokens) != null ? _f : void 0,
+          cacheWrite: void 0
+        },
+        outputTokens: {
+          total: (_h = (_g = responseBody.usage) == null ? void 0 : _g.completion_tokens) != null ? _h : void 0,
+          text: void 0,
+          reasoning: (_k = (_j = (_i = responseBody.usage) == null ? void 0 : _i.completion_tokens_details) == null ? void 0 : _j.reasoning_tokens) != null ? _k : void 0
+        }
       },
       // providerMetadata,
       request: { body },
@@ -314,9 +432,10 @@ var FriendliAIChatLanguageModel = class {
           start(controller) {
             controller.enqueue({ type: "stream-start", warnings });
           },
-          // TODO we lost type safety on Chunk, most likely due to the error schema. MUST FIX
+          // NOTE: Chunk values can contain OpenAI-compatible deltas, hosted tool events, and error events.
+          // We narrow with type guards for safe handling.
           transform(chunk, controller) {
-            var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+            var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -324,26 +443,79 @@ var FriendliAIChatLanguageModel = class {
             }
             const value = chunk.value;
             metadataExtractor == null ? void 0 : metadataExtractor.processChunk(chunk.rawValue);
-            if ("error" in value) {
+            if (isHostedToolExecutionChunk(value)) {
+              const toolCallId = (_a2 = value.tool_call_id) != null ? _a2 : (0, import_provider_utils2.generateId)();
+              switch (value.status) {
+                case "STARTED":
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId,
+                    toolName: value.name,
+                    input: JSON.stringify(
+                      Object.fromEntries(value.parameters.map((p) => [p.name, p.value]))
+                    ),
+                    providerExecuted: true
+                  });
+                  break;
+                case "UPDATING":
+                  break;
+                case "ENDED":
+                  controller.enqueue({
+                    type: "tool-result",
+                    toolCallId,
+                    toolName: value.name,
+                    result: (_b = value.result) != null ? _b : ""
+                  });
+                  break;
+                case "ERRORED":
+                  finishReason = "error";
+                  controller.enqueue({
+                    type: "tool-result",
+                    toolCallId,
+                    toolName: value.name,
+                    result: (_d = (_c = value.error) == null ? void 0 : _c.msg) != null ? _d : "Unknown error",
+                    isError: true
+                  });
+                  break;
+                default:
+                  finishReason = "error";
+                  controller.enqueue({
+                    type: "error",
+                    error: new Error(`Unsupported tool call status: ${value.status}`)
+                  });
+              }
+              return;
+            }
+            const chunkErrorMessage = getChunkErrorMessage(value);
+            if (chunkErrorMessage != null) {
               finishReason = "error";
-              controller.enqueue({ type: "error", error: value.error.message });
+              controller.enqueue({ type: "error", error: chunkErrorMessage });
               return;
             }
+            if (!isOpenAIChatChunk(value)) {
+              finishReason = "error";
+              controller.enqueue({
+                type: "error",
+                error: new Error("Unsupported chunk shape")
+              });
+              return;
+            }
+            const chunkValue = value;
             if (isFirstChunk) {
               isFirstChunk = false;
               controller.enqueue({
                 type: "response-metadata",
-                ...(0, import_internal.getResponseMetadata)(value)
+                ...(0, import_internal.getResponseMetadata)(chunkValue)
               });
             }
-            if (value.usage != null) {
+            if (chunkValue.usage != null) {
               const {
                 prompt_tokens,
                 completion_tokens,
                 total_tokens,
                 prompt_tokens_details,
                 completion_tokens_details
-              } = value.usage;
+              } = chunkValue.usage;
               usage.promptTokens = prompt_tokens != null ? prompt_tokens : void 0;
               usage.completionTokens = completion_tokens != null ? completion_tokens : void 0;
               usage.totalTokens = total_tokens != null ? total_tokens : void 0;
@@ -360,7 +532,7 @@ var FriendliAIChatLanguageModel = class {
                 usage.promptTokensDetails.cachedTokens = prompt_tokens_details == null ? void 0 : prompt_tokens_details.cached_tokens;
               }
             }
-            const choice = value.choices[0];
+            const choice = chunkValue.choices[0];
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
               finishReason = (0, import_internal.mapOpenAICompatibleFinishReason)(choice.finish_reason);
             }
@@ -387,19 +559,19 @@ var FriendliAIChatLanguageModel = class {
                 const index = toolCallDelta.index;
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.type !== "function") {
-                    throw new import_provider2.InvalidResponseDataError({
+                    throw new import_provider3.InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function' type.`
                     });
                   }
                   if (toolCallDelta.id == null) {
-                    throw new import_provider2.InvalidResponseDataError({
+                    throw new import_provider3.InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'id' to be a string.`
                     });
                   }
-                  if (((_a2 = toolCallDelta.function) == null ? void 0 : _a2.name) == null) {
-                    throw new import_provider2.InvalidResponseDataError({
+                  if (((_e = toolCallDelta.function) == null ? void 0 : _e.name) == null) {
+                    throw new import_provider3.InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
                     });
@@ -409,12 +581,12 @@ var FriendliAIChatLanguageModel = class {
                     type: "function",
                     function: {
                       name: toolCallDelta.function.name,
-                      arguments: (_b = toolCallDelta.function.arguments) != null ? _b : ""
+                      arguments: (_f = toolCallDelta.function.arguments) != null ? _f : ""
                     },
                     hasFinished: false
                   };
                   const toolCall2 = toolCalls[index];
-                  if (((_c = toolCall2.function) == null ? void 0 : _c.name) != null && ((_d = toolCall2.function) == null ? void 0 : _d.arguments) != null) {
+                  if (((_g = toolCall2.function) == null ? void 0 : _g.name) != null && ((_h = toolCall2.function) == null ? void 0 : _h.arguments) != null) {
                     if (toolCall2.function.arguments.length > 0) {
                       controller.enqueue({
                         type: "tool-input-delta",
@@ -425,7 +597,7 @@ var FriendliAIChatLanguageModel = class {
                     if ((0, import_provider_utils2.isParsableJson)(toolCall2.function.arguments)) {
                       controller.enqueue({
                         type: "tool-call",
-                        toolCallId: (_e = toolCall2.id) != null ? _e : (0, import_provider_utils2.generateId)(),
+                        toolCallId: (_i = toolCall2.id) != null ? _i : (0, import_provider_utils2.generateId)(),
                         toolName: toolCall2.function.name,
                         input: toolCall2.function.arguments
                       });
@@ -438,18 +610,18 @@ var FriendliAIChatLanguageModel = class {
                 if (toolCall.hasFinished) {
                   continue;
                 }
-                if (((_f = toolCallDelta.function) == null ? void 0 : _f.arguments) != null) {
-                  toolCall.function.arguments += (_h = (_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null ? _h : "";
+                if (((_j = toolCallDelta.function) == null ? void 0 : _j.arguments) != null) {
+                  toolCall.function.arguments += (_l = (_k = toolCallDelta.function) == null ? void 0 : _k.arguments) != null ? _l : "";
                 }
                 controller.enqueue({
                   type: "tool-input-delta",
                   id: toolCall.id,
-                  delta: (_i = toolCallDelta.function.arguments) != null ? _i : ""
+                  delta: (_n = (_m = toolCallDelta.function) == null ? void 0 : _m.arguments) != null ? _n : ""
                 });
-                if (((_j = toolCall.function) == null ? void 0 : _j.name) != null && ((_k = toolCall.function) == null ? void 0 : _k.arguments) != null && (0, import_provider_utils2.isParsableJson)(toolCall.function.arguments)) {
+                if (((_o = toolCall.function) == null ? void 0 : _o.name) != null && ((_p = toolCall.function) == null ? void 0 : _p.arguments) != null && (0, import_provider_utils2.isParsableJson)(toolCall.function.arguments)) {
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallId: (_l = toolCall.id) != null ? _l : (0, import_provider_utils2.generateId)(),
+                    toolCallId: (_q = toolCall.id) != null ? _q : (0, import_provider_utils2.generateId)(),
                     toolName: toolCall.function.name,
                     input: toolCall.function.arguments
                   });
@@ -459,7 +631,7 @@ var FriendliAIChatLanguageModel = class {
             }
           },
           flush(controller) {
-            var _a2, _b, _c, _d, _e;
+            var _a2, _b, _c, _d;
             const providerMetadata = {
               [providerOptionsName]: {},
               ...metadataExtractor == null ? void 0 : metadataExtractor.buildMetadata()
@@ -474,11 +646,17 @@ var FriendliAIChatLanguageModel = class {
               type: "finish",
               finishReason,
               usage: {
-                inputTokens: (_a2 = usage.promptTokens) != null ? _a2 : void 0,
-                outputTokens: (_b = usage.completionTokens) != null ? _b : void 0,
-                totalTokens: (_c = usage.totalTokens) != null ? _c : void 0,
-                reasoningTokens: (_d = usage.completionTokensDetails.reasoningTokens) != null ? _d : void 0,
-                cachedInputTokens: (_e = usage.promptTokensDetails.cachedTokens) != null ? _e : void 0
+                inputTokens: {
+                  total: (_a2 = usage.promptTokens) != null ? _a2 : void 0,
+                  noCache: void 0,
+                  cacheRead: (_b = usage.promptTokensDetails.cachedTokens) != null ? _b : void 0,
+                  cacheWrite: void 0
+                },
+                outputTokens: {
+                  total: (_c = usage.completionTokens) != null ? _c : void 0,
+                  text: void 0,
+                  reasoning: (_d = usage.completionTokensDetails.reasoningTokens) != null ? _d : void 0
+                }
               },
               providerMetadata
             });
@@ -490,86 +668,6 @@ var FriendliAIChatLanguageModel = class {
     };
   }
 };
-var friendliAIChatResponseSchema = import_v42.z.object({
-  id: import_v42.z.string().nullish(),
-  created: import_v42.z.number().nullish(),
-  model: import_v42.z.string().nullish(),
-  choices: import_v42.z.array(
-    import_v42.z.object({
-      message: import_v42.z.object({
-        role: import_v42.z.literal("assistant").nullish(),
-        content: import_v42.z.string().nullish(),
-        tool_calls: import_v42.z.array(
-          import_v42.z.object({
-            id: import_v42.z.string().nullish(),
-            type: import_v42.z.literal("function"),
-            function: import_v42.z.object({
-              name: import_v42.z.string(),
-              arguments: import_v42.z.union([import_v42.z.string(), import_v42.z.any()]).nullish()
-            })
-          })
-        ).nullish()
-      }),
-      finish_reason: import_v42.z.string().nullish()
-    })
-  ),
-  usage: import_v42.z.object({
-    prompt_tokens: import_v42.z.number().nullish(),
-    completion_tokens: import_v42.z.number().nullish()
-  }).nullish()
-});
-var friendliaiChatChunkSchema = import_v42.z.union([
-  import_v42.z.object({
-    id: import_v42.z.string().nullish(),
-    created: import_v42.z.number().nullish(),
-    model: import_v42.z.string().nullish(),
-    choices: import_v42.z.array(
-      import_v42.z.object({
-        delta: import_v42.z.object({
-          role: import_v42.z.enum(["assistant"]).nullish(),
-          content: import_v42.z.string().nullish(),
-          tool_calls: import_v42.z.array(
-            import_v42.z.object({
-              index: import_v42.z.number(),
-              id: import_v42.z.string().nullish(),
-              type: import_v42.z.literal("function").optional(),
-              function: import_v42.z.object({
-                name: import_v42.z.string().nullish(),
-                arguments: import_v42.z.string().nullish()
-              })
-            })
-          ).nullish()
-        }).nullish(),
-        finish_reason: import_v42.z.string().nullish()
-      })
-    ),
-    usage: import_v42.z.object({
-      prompt_tokens: import_v42.z.number().nullish(),
-      completion_tokens: import_v42.z.number().nullish()
-    }).nullish()
-  }),
-  import_v42.z.object({
-    name: import_v42.z.string(),
-    status: import_v42.z.enum(["ENDED", "STARTED", "ERRORED", "UPDATING"]),
-    message: import_v42.z.null(),
-    parameters: import_v42.z.array(
-      import_v42.z.object({
-        name: import_v42.z.string(),
-        value: import_v42.z.string()
-      })
-    ),
-    result: import_v42.z.string().nullable(),
-    error: import_v42.z.object({
-      type: import_v42.z.enum(["INVALID_PARAMETER", "UNKNOWN"]),
-      msg: import_v42.z.string()
-    }).nullable(),
-    timestamp: import_v42.z.number(),
-    usage: import_v42.z.null(),
-    tool_call_id: import_v42.z.string().nullable()
-    // temporary fix for "file:text" tool calls
-  }),
-  friendliaiErrorSchema
-]);
 var openaiCompatibleTokenUsageSchema = import_v42.z.object({
   prompt_tokens: import_v42.z.number().nullish(),
   completion_tokens: import_v42.z.number().nullish(),
@@ -637,6 +735,25 @@ var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v42.z.union(
     ),
     usage: openaiCompatibleTokenUsageSchema
   }),
+  import_v42.z.object({
+    name: import_v42.z.string(),
+    status: import_v42.z.enum(["ENDED", "STARTED", "ERRORED", "UPDATING"]),
+    message: import_v42.z.null(),
+    parameters: import_v42.z.array(
+      import_v42.z.object({
+        name: import_v42.z.string(),
+        value: import_v42.z.string()
+      })
+    ),
+    result: import_v42.z.string().nullable(),
+    error: import_v42.z.object({
+      type: import_v42.z.enum(["INVALID_PARAMETER", "UNKNOWN"]),
+      msg: import_v42.z.string()
+    }).nullable(),
+    timestamp: import_v42.z.number(),
+    usage: import_v42.z.null(),
+    tool_call_id: import_v42.z.string().nullable()
+  }),
   errorSchema
 ]);
 var friendliProviderOptionsSchema = import_v42.z.object({
@@ -649,15 +766,34 @@ var friendliProviderOptionsSchema = import_v42.z.object({
    */
   // regex: z.instanceof(RegExp).nullish(),
   regex: import_v42.z.string().nullish(),
-  chat_template_kwargs: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).nullish()
+  chat_template_kwargs: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).nullish(),
+  /**
+   * A scaling factor used to determine the minimum token probability threshold.
+   */
+  minP: import_v42.z.number().nullish(),
+  /**
+   * Penalizes tokens that have already appeared in the generated result.
+   */
+  repetitionPenalty: import_v42.z.number().nullish(),
+  /**
+   * A probability threshold used to identify “top choice” tokens for exclusion in XTC sampling.
+   */
+  xtcThreshold: import_v42.z.number().nullish(),
+  /**
+   * The probability that XTC (Exclude Top Choices) filtering will be applied for each sampling decision.
+   */
+  xtcProbability: import_v42.z.number().nullish()
 });
 
 // src/friendli-settings.ts
 var FriendliAIServerlessModelIds = [
+  "MiniMaxAI/MiniMax-M2",
+  "zai-org/GLM-4.6",
   "LGAI-EXAONE/EXAONE-4.0.1-32B",
   "skt/A.X-4.0",
   "skt/A.X-3.1",
   "naver-hyperclovax/HyperCLOVAX-SEED-Think-14B",
+  "deepseek-ai/DeepSeek-V3.1",
   "deepseek-ai/DeepSeek-R1-0528",
   "meta-llama/Llama-4-Maverick-17B-128E-Instruct",
   "meta-llama/Llama-4-Scout-17B-16E-Instruct",
@@ -676,65 +812,78 @@ var FriendliAIServerlessModelIds = [
 ];
 
 // src/friendli-tools.ts
-function webUrlBetaTool() {
-  return {
-    type: "provider-defined",
-    id: "friendli.web:url",
-    name: "web:url",
-    args: {}
-  };
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_v43 = require("zod/v4");
+var inputSchema = import_v43.z.object({}).loose();
+var outputSchema = import_v43.z.unknown();
+var webSearchTool = (0, import_provider_utils3.createProviderToolFactoryWithOutputSchema)({
+  id: "friendli.web:search",
+  inputSchema,
+  outputSchema
+});
+var webUrlTool = (0, import_provider_utils3.createProviderToolFactoryWithOutputSchema)({
+  id: "friendli.web:url",
+  inputSchema,
+  outputSchema
+});
+var mathCalendarTool = (0, import_provider_utils3.createProviderToolFactoryWithOutputSchema)({
+  id: "friendli.math:calendar",
+  inputSchema,
+  outputSchema
+});
+var mathStatisticsTool = (0, import_provider_utils3.createProviderToolFactoryWithOutputSchema)({
+  id: "friendli.math:statistics",
+  inputSchema,
+  outputSchema
+});
+var mathCalculatorTool = (0, import_provider_utils3.createProviderToolFactoryWithOutputSchema)({
+  id: "friendli.math:calculator",
+  inputSchema,
+  outputSchema
+});
+var codePythonInterpreterTool = (0, import_provider_utils3.createProviderToolFactoryWithOutputSchema)({
+  id: "friendli.code:python-interpreter",
+  inputSchema,
+  outputSchema
+});
+var linkupSearchTool = (0, import_provider_utils3.createProviderToolFactoryWithOutputSchema)({
+  id: "friendli.linkup:search",
+  inputSchema,
+  outputSchema
+});
+function webSearch() {
+  return webSearchTool({});
 }
-function webSearchBetaTool() {
-  return {
-    type: "provider-defined",
-    id: "friendli.web:search",
-    name: "web:search",
-    args: {}
-  };
+function webUrl() {
+  return webUrlTool({});
 }
-function mathCalendarBetaTool() {
-  return {
-    type: "provider-defined",
-    id: "friendli.math:calendar",
-    name: "math:calendar",
-    args: {}
-  };
+function mathCalendar() {
+  return mathCalendarTool({});
 }
-function mathStatisticsBetaTool() {
-  return {
-    type: "provider-defined",
-    id: "friendli.math:statistics",
-    name: "math:statistics",
-    args: {}
-  };
+function mathStatistics() {
+  return mathStatisticsTool({});
 }
-function mathCalculatorBetaTool() {
-  return {
-    type: "provider-defined",
-    id: "friendli.math:calculator",
-    name: "math:calculator",
-    args: {}
-  };
+function mathCalculator() {
+  return mathCalculatorTool({});
 }
-function codePythonInterpreterBetaTool() {
-  return {
-    type: "provider-defined",
-    id: "friendli.code:python-interpreter",
-    name: "code:python-interpreter",
-    args: {}
-  };
+function codePythonInterpreter() {
+  return codePythonInterpreterTool({});
+}
+function linkupSearch() {
+  return linkupSearchTool({});
 }
 var friendliTools = {
-  webSearchBetaTool,
-  webUrlBetaTool,
-  mathCalendarBetaTool,
-  mathStatisticsBetaTool,
-  mathCalculatorBetaTool,
-  codePythonInterpreterBetaTool
+  webSearch,
+  webUrl,
+  mathCalendar,
+  mathStatistics,
+  mathCalculator,
+  codePythonInterpreter,
+  linkupSearch
 };
 
 // src/get-available-models.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
 var DEFAULT_GRAPHQL_URL = "https://api-internal.friendli.ai/api/graphql";
 async function postGraphQL(url, body, headers) {
   const res = await fetch(url, {
@@ -770,7 +919,7 @@ async function getAvailableModelsImpl(options) {
   var _a, _b, _c, _d, _e, _f;
   let token;
   try {
-    token = (_a = options.apiKey) != null ? _a : (0, import_provider_utils3.loadApiKey)({
+    token = (_a = options.apiKey) != null ? _a : (0, import_provider_utils4.loadApiKey)({
       apiKey: void 0,
       environmentVariableName: "FRIENDLI_TOKEN",
       description: "FRIENDLI_TOKEN"
@@ -843,7 +992,7 @@ async function getAvailableModelsImpl(options) {
 // src/friendli-provider.ts
 function createFriendli(options = {}) {
   const getHeaders = () => ({
-    Authorization: `Bearer ${(0, import_provider_utils4.loadApiKey)({
+    Authorization: `Bearer ${(0, import_provider_utils5.loadApiKey)({
       apiKey: options.apiKey,
       environmentVariableName: "FRIENDLI_TOKEN",
       description: "FRIENDLI_TOKEN"
@@ -857,7 +1006,7 @@ function createFriendli(options = {}) {
       serverless_tools: "https://api.friendli.ai/serverless/tools/v1",
       dedicated: "https://api.friendli.ai/dedicated/v1"
     };
-    const customBaseURL = (0, import_provider_utils4.withoutTrailingSlash)(baseURL);
+    const customBaseURL = (0, import_provider_utils5.withoutTrailingSlash)(baseURL);
     if (typeof customBaseURL === "string" && customBaseURL !== "dedicated" && customBaseURL !== "serverless" && customBaseURL !== "serverless-tools") {
       return { baseURL: customBaseURL, type: "custom" };
     }
@@ -897,7 +1046,8 @@ function createFriendli(options = {}) {
       provider: `friendliai.${type}.chat`,
       url: ({ path }) => `${baseURL}${path}`,
       headers: getHeaders,
-      fetch: options.fetch
+      fetch: options.fetch,
+      includeUsage: options.includeUsage
     });
   };
   const createCompletionModel = (modelId) => {
@@ -911,23 +1061,23 @@ function createFriendli(options = {}) {
     });
   };
   const createTextEmbeddingModel = (modelId) => {
-    throw new import_provider3.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+    throw new import_provider4.NoSuchModelError({ modelId, modelType: "embeddingModel" });
   };
   const createImageModel = (modelId) => {
-    throw new import_provider3.NoSuchModelError({ modelId, modelType: "imageModel" });
+    throw new import_provider4.NoSuchModelError({ modelId, modelType: "imageModel" });
   };
   const createTranscriptionModel = (modelId) => {
-    throw new import_provider3.NoSuchModelError({ modelId, modelType: "languageModel" });
+    throw new import_provider4.NoSuchModelError({ modelId, modelType: "languageModel" });
   };
   const createSpeechModel = (modelId) => {
-    throw new import_provider3.NoSuchModelError({ modelId, modelType: "languageModel" });
+    throw new import_provider4.NoSuchModelError({ modelId, modelType: "languageModel" });
   };
   const provider = (modelId) => createLanguageModel(modelId);
   provider.languageModel = createLanguageModel;
   provider.chat = createLanguageModel;
   provider.completion = createCompletionModel;
   provider.embedding = createTextEmbeddingModel;
-  provider.textEmbeddingModel = createTextEmbeddingModel;
+  provider.embeddingModel = createTextEmbeddingModel;
   provider.getAvailableModels = async (opts) => {
     var _a;
     const defaultURL = "https://api-internal.friendli.ai/api/graphql";