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

package/dist/index.mjs

@@ -17,7 +17,6 @@ import {
 import {
   combineHeaders,
   createEventSourceResponseHandler,
-  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
   createJsonResponseHandler,
   generateId,
   isParsableJson,
@@ -27,17 +26,88 @@ import {
 import { z as z2 } from "zod/v4";
 
 // src/friendli-error.ts
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { APICallError } from "@ai-sdk/provider";
+import { safeParseJSON } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
-var friendliaiErrorSchema = z.object({
+var friendliErrorResponseSchema = z.object({
   message: z.string(),
-  error: z.record(z.string(), z.any())
+  error: z.record(z.string(), z.any()).optional()
 });
+var openAIStyleErrorResponseSchema = z.object({
+  error: z.object({
+    message: z.string()
+  }).loose()
+}).loose();
+var friendliaiErrorSchema = 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 APICallError({
+        message: fallback2,
+        ...baseErrorOptions
+      })
+    };
+  }
+  const parsedError = await safeParseJSON({
+    text: responseBody,
+    schema: friendliaiErrorSchema
+  });
+  if (parsedError.success) {
+    return {
+      responseHeaders,
+      value: new 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 APICallError({
+      message: fallback,
+      cause: parsedError.error,
+      ...baseErrorOptions
+    })
+  };
 };
-var friendliaiFailedResponseHandler = createJsonErrorResponseHandler(friendliaiErrorStructure);
 
 // src/friendli-prepare-tools.ts
 import {
@@ -55,9 +125,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,16 +171,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 = createJsonErrorResponseHandler2(friendliaiErrorStructure);
+    this.failedResponseHandler = friendliaiFailedResponseHandler;
     this.supportsStructuredOutputs = (_a = config.supportsStructuredOutputs) != null ? _a : true;
   }
   get provider() {
@@ -136,18 +230,24 @@ var FriendliAIChatLanguageModel = class {
   }) {
     var _a;
     const warnings = [];
-    if (topK != null) {
-      warnings.push({ type: "unsupported-setting", setting: "topK" });
-    }
     const friendliOptions = await parseProviderOptions({
+      provider: "friendliai",
+      providerOptions,
+      schema: friendliProviderOptionsSchema
+    });
+    const legacyFriendliOptions = await 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"
       });
     }
@@ -159,6 +259,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 >>>
@@ -170,36 +278,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: 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 {
@@ -245,11 +356,17 @@ var FriendliAIChatLanguageModel = class {
       content,
       finishReason: 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 },
@@ -306,9 +423,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 });
@@ -316,26 +434,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 : 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",
-                ...getResponseMetadata(value)
+                ...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;
@@ -352,7 +523,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 = mapOpenAICompatibleFinishReason(choice.finish_reason);
             }
@@ -390,7 +561,7 @@ var FriendliAIChatLanguageModel = class {
                       message: `Expected 'id' to be a string.`
                     });
                   }
-                  if (((_a2 = toolCallDelta.function) == null ? void 0 : _a2.name) == null) {
+                  if (((_e = toolCallDelta.function) == null ? void 0 : _e.name) == null) {
                     throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
@@ -401,12 +572,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",
@@ -417,7 +588,7 @@ var FriendliAIChatLanguageModel = class {
                     if (isParsableJson(toolCall2.function.arguments)) {
                       controller.enqueue({
                         type: "tool-call",
-                        toolCallId: (_e = toolCall2.id) != null ? _e : generateId(),
+                        toolCallId: (_i = toolCall2.id) != null ? _i : generateId(),
                         toolName: toolCall2.function.name,
                         input: toolCall2.function.arguments
                       });
@@ -430,18 +601,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 && isParsableJson(toolCall.function.arguments)) {
+                if (((_o = toolCall.function) == null ? void 0 : _o.name) != null && ((_p = toolCall.function) == null ? void 0 : _p.arguments) != null && isParsableJson(toolCall.function.arguments)) {
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallId: (_l = toolCall.id) != null ? _l : generateId(),
+                    toolCallId: (_q = toolCall.id) != null ? _q : generateId(),
                     toolName: toolCall.function.name,
                     input: toolCall.function.arguments
                   });
@@ -451,7 +622,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()
@@ -466,11 +637,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
             });
@@ -482,86 +659,6 @@ var FriendliAIChatLanguageModel = class {
     };
   }
 };
-var friendliAIChatResponseSchema = z2.object({
-  id: z2.string().nullish(),
-  created: z2.number().nullish(),
-  model: z2.string().nullish(),
-  choices: z2.array(
-    z2.object({
-      message: z2.object({
-        role: z2.literal("assistant").nullish(),
-        content: z2.string().nullish(),
-        tool_calls: z2.array(
-          z2.object({
-            id: z2.string().nullish(),
-            type: z2.literal("function"),
-            function: z2.object({
-              name: z2.string(),
-              arguments: z2.union([z2.string(), z2.any()]).nullish()
-            })
-          })
-        ).nullish()
-      }),
-      finish_reason: z2.string().nullish()
-    })
-  ),
-  usage: z2.object({
-    prompt_tokens: z2.number().nullish(),
-    completion_tokens: z2.number().nullish()
-  }).nullish()
-});
-var friendliaiChatChunkSchema = z2.union([
-  z2.object({
-    id: z2.string().nullish(),
-    created: z2.number().nullish(),
-    model: z2.string().nullish(),
-    choices: z2.array(
-      z2.object({
-        delta: z2.object({
-          role: z2.enum(["assistant"]).nullish(),
-          content: z2.string().nullish(),
-          tool_calls: z2.array(
-            z2.object({
-              index: z2.number(),
-              id: z2.string().nullish(),
-              type: z2.literal("function").optional(),
-              function: z2.object({
-                name: z2.string().nullish(),
-                arguments: z2.string().nullish()
-              })
-            })
-          ).nullish()
-        }).nullish(),
-        finish_reason: z2.string().nullish()
-      })
-    ),
-    usage: z2.object({
-      prompt_tokens: z2.number().nullish(),
-      completion_tokens: z2.number().nullish()
-    }).nullish()
-  }),
-  z2.object({
-    name: z2.string(),
-    status: z2.enum(["ENDED", "STARTED", "ERRORED", "UPDATING"]),
-    message: z2.null(),
-    parameters: z2.array(
-      z2.object({
-        name: z2.string(),
-        value: z2.string()
-      })
-    ),
-    result: z2.string().nullable(),
-    error: z2.object({
-      type: z2.enum(["INVALID_PARAMETER", "UNKNOWN"]),
-      msg: z2.string()
-    }).nullable(),
-    timestamp: z2.number(),
-    usage: z2.null(),
-    tool_call_id: z2.string().nullable()
-    // temporary fix for "file:text" tool calls
-  }),
-  friendliaiErrorSchema
-]);
 var openaiCompatibleTokenUsageSchema = z2.object({
   prompt_tokens: z2.number().nullish(),
   completion_tokens: z2.number().nullish(),
@@ -629,6 +726,25 @@ var createOpenAICompatibleChatChunkSchema = (errorSchema) => z2.union([
     ),
     usage: openaiCompatibleTokenUsageSchema
   }),
+  z2.object({
+    name: z2.string(),
+    status: z2.enum(["ENDED", "STARTED", "ERRORED", "UPDATING"]),
+    message: z2.null(),
+    parameters: z2.array(
+      z2.object({
+        name: z2.string(),
+        value: z2.string()
+      })
+    ),
+    result: z2.string().nullable(),
+    error: z2.object({
+      type: z2.enum(["INVALID_PARAMETER", "UNKNOWN"]),
+      msg: z2.string()
+    }).nullable(),
+    timestamp: z2.number(),
+    usage: z2.null(),
+    tool_call_id: z2.string().nullable()
+  }),
   errorSchema
 ]);
 var friendliProviderOptionsSchema = z2.object({
@@ -641,15 +757,34 @@ var friendliProviderOptionsSchema = z2.object({
    */
   // regex: z.instanceof(RegExp).nullish(),
   regex: z2.string().nullish(),
-  chat_template_kwargs: z2.record(z2.string(), z2.any()).nullish()
+  chat_template_kwargs: z2.record(z2.string(), z2.any()).nullish(),
+  /**
+   * A scaling factor used to determine the minimum token probability threshold.
+   */
+  minP: z2.number().nullish(),
+  /**
+   * Penalizes tokens that have already appeared in the generated result.
+   */
+  repetitionPenalty: z2.number().nullish(),
+  /**
+   * A probability threshold used to identify “top choice” tokens for exclusion in XTC sampling.
+   */
+  xtcThreshold: z2.number().nullish(),
+  /**
+   * The probability that XTC (Exclude Top Choices) filtering will be applied for each sampling decision.
+   */
+  xtcProbability: z2.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",
@@ -668,61 +803,74 @@ var FriendliAIServerlessModelIds = [
 ];
 
 // src/friendli-tools.ts
-function webUrlBetaTool() {
-  return {
-    type: "provider-defined",
-    id: "friendli.web:url",
-    name: "web:url",
-    args: {}
-  };
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
+var inputSchema = z3.object({}).loose();
+var outputSchema = z3.unknown();
+var webSearchTool = createProviderToolFactoryWithOutputSchema({
+  id: "friendli.web:search",
+  inputSchema,
+  outputSchema
+});
+var webUrlTool = createProviderToolFactoryWithOutputSchema({
+  id: "friendli.web:url",
+  inputSchema,
+  outputSchema
+});
+var mathCalendarTool = createProviderToolFactoryWithOutputSchema({
+  id: "friendli.math:calendar",
+  inputSchema,
+  outputSchema
+});
+var mathStatisticsTool = createProviderToolFactoryWithOutputSchema({
+  id: "friendli.math:statistics",
+  inputSchema,
+  outputSchema
+});
+var mathCalculatorTool = createProviderToolFactoryWithOutputSchema({
+  id: "friendli.math:calculator",
+  inputSchema,
+  outputSchema
+});
+var codePythonInterpreterTool = createProviderToolFactoryWithOutputSchema({
+  id: "friendli.code:python-interpreter",
+  inputSchema,
+  outputSchema
+});
+var linkupSearchTool = 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
@@ -889,7 +1037,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) => {
@@ -903,7 +1052,7 @@ function createFriendli(options = {}) {
     });
   };
   const createTextEmbeddingModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+    throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
   };
   const createImageModel = (modelId) => {
     throw new NoSuchModelError({ modelId, modelType: "imageModel" });
@@ -919,7 +1068,7 @@ function createFriendli(options = {}) {
   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";