@friendliai/ai-provider 1.0.0-beta.1 → 1.0.0

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_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
@@ -65,7 +136,9 @@ function prepareTools({
   for (const tool of tools) {
     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,6 +180,28 @@ 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) {
@@ -116,7 +211,7 @@ var FriendliAIChatLanguageModel = class {
     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,14 +239,20 @@ var FriendliAIChatLanguageModel = class {
   }) {
     var _a;
     const warnings = [];
-    if (topK != null) {
-      warnings.push({ type: "unsupported", feature: "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",
@@ -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;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
     const { args, warnings } = await this.getArgs({ ...options, stream: false });
     const body = JSON.stringify(args);
     const {
@@ -251,18 +363,21 @@ var FriendliAIChatLanguageModel = class {
     }
     return {
       content,
-      finishReason: (0, import_internal.mapOpenAICompatibleFinishReason)(choice.finish_reason),
+      finishReason: {
+        unified: (0, import_internal.mapOpenAICompatibleFinishReason)(choice.finish_reason),
+        raw: (_b = choice.finish_reason) != null ? _b : void 0
+      },
       usage: {
         inputTokens: {
-          total: (_c = (_b = responseBody.usage) == null ? void 0 : _b.prompt_tokens) != null ? _c : void 0,
+          total: (_d = (_c = responseBody.usage) == null ? void 0 : _c.prompt_tokens) != null ? _d : 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,
+          cacheRead: (_g = (_f = (_e = responseBody.usage) == null ? void 0 : _e.prompt_tokens_details) == null ? void 0 : _f.cached_tokens) != null ? _g : void 0,
           cacheWrite: void 0
         },
         outputTokens: {
-          total: (_h = (_g = responseBody.usage) == null ? void 0 : _g.completion_tokens) != null ? _h : void 0,
+          total: (_i = (_h = responseBody.usage) == null ? void 0 : _h.completion_tokens) != null ? _i : 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
+          reasoning: (_l = (_k = (_j = responseBody.usage) == null ? void 0 : _j.completion_tokens_details) == null ? void 0 : _k.reasoning_tokens) != null ? _l : void 0
         }
       },
       // providerMetadata,
@@ -298,7 +413,8 @@ var FriendliAIChatLanguageModel = class {
       fetch: this.config.fetch
     });
     const toolCalls = [];
-    let finishReason = "unknown";
+    let finishReason = "other";
+    let rawFinishReason;
     const usage = {
       completionTokens: void 0,
       completionTokensDetails: {
@@ -320,9 +436,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, _m, _n, _o, _p;
+            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 });
@@ -330,7 +447,7 @@ var FriendliAIChatLanguageModel = class {
             }
             const value = chunk.value;
             metadataExtractor == null ? void 0 : metadataExtractor.processChunk(chunk.rawValue);
-            if ("status" in value) {
+            if (isHostedToolExecutionChunk(value)) {
               const toolCallId = (_a2 = value.tool_call_id) != null ? _a2 : (0, import_provider_utils2.generateId)();
               switch (value.status) {
                 case "STARTED":
@@ -373,26 +490,36 @@ var FriendliAIChatLanguageModel = class {
               }
               return;
             }
-            if ("error" in value) {
+            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;
@@ -409,8 +536,9 @@ 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) {
+              rawFinishReason = choice.finish_reason;
               finishReason = (0, import_internal.mapOpenAICompatibleFinishReason)(choice.finish_reason);
             }
             if ((choice == null ? void 0 : choice.delta) == null) {
@@ -436,19 +564,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 (((_e = toolCallDelta.function) == null ? void 0 : _e.name) == null) {
-                    throw new import_provider2.InvalidResponseDataError({
+                    throw new import_provider3.InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
                     });
@@ -493,12 +621,12 @@ var FriendliAIChatLanguageModel = class {
                 controller.enqueue({
                   type: "tool-input-delta",
                   id: toolCall.id,
-                  delta: (_m = toolCallDelta.function.arguments) != null ? _m : ""
+                  delta: (_n = (_m = toolCallDelta.function) == null ? void 0 : _m.arguments) != null ? _n : ""
                 });
-                if (((_n = toolCall.function) == null ? void 0 : _n.name) != null && ((_o = toolCall.function) == null ? void 0 : _o.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: (_p = toolCall.id) != null ? _p : (0, import_provider_utils2.generateId)(),
+                    toolCallId: (_q = toolCall.id) != null ? _q : (0, import_provider_utils2.generateId)(),
                     toolName: toolCall.function.name,
                     input: toolCall.function.arguments
                   });
@@ -521,7 +649,10 @@ var FriendliAIChatLanguageModel = class {
             }
             controller.enqueue({
               type: "finish",
-              finishReason,
+              finishReason: {
+                unified: finishReason,
+                raw: rawFinishReason
+              },
               usage: {
                 inputTokens: {
                   total: (_a2 = usage.promptTokens) != null ? _a2 : void 0,
@@ -545,86 +676,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(),
@@ -723,7 +774,23 @@ 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
@@ -754,53 +821,64 @@ var FriendliAIServerlessModelIds = [
 
 // src/friendli-tools.ts
 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 {
-    type: "provider",
-    id: "friendli.web:search",
-    args: {},
-    inputSchema: (0, import_provider_utils3.jsonSchema)({ type: "object", properties: {} })
-  };
+  return webSearchTool({});
 }
 function webUrl() {
-  return {
-    type: "provider",
-    id: "friendli.web:url",
-    args: {},
-    inputSchema: (0, import_provider_utils3.jsonSchema)({ type: "object", properties: {} })
-  };
+  return webUrlTool({});
 }
 function mathCalendar() {
-  return {
-    type: "provider",
-    id: "friendli.math:calendar",
-    args: {},
-    inputSchema: (0, import_provider_utils3.jsonSchema)({ type: "object", properties: {} })
-  };
+  return mathCalendarTool({});
 }
 function mathStatistics() {
-  return {
-    type: "provider",
-    id: "friendli.math:statistics",
-    args: {},
-    inputSchema: (0, import_provider_utils3.jsonSchema)({ type: "object", properties: {} })
-  };
+  return mathStatisticsTool({});
 }
 function mathCalculator() {
-  return {
-    type: "provider",
-    id: "friendli.math:calculator",
-    args: {},
-    inputSchema: (0, import_provider_utils3.jsonSchema)({ type: "object", properties: {} })
-  };
+  return mathCalculatorTool({});
 }
 function codePythonInterpreter() {
-  return {
-    type: "provider",
-    id: "friendli.code:python-interpreter",
-    args: {},
-    inputSchema: (0, import_provider_utils3.jsonSchema)({ type: "object", properties: {} })
-  };
+  return codePythonInterpreterTool({});
+}
+function linkupSearch() {
+  return linkupSearchTool({});
 }
 var friendliTools = {
   webSearch,
@@ -808,7 +886,8 @@ var friendliTools = {
   mathCalendar,
   mathStatistics,
   mathCalculator,
-  codePythonInterpreter
+  codePythonInterpreter,
+  linkupSearch
 };
 
 // src/get-available-models.ts
@@ -975,7 +1054,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) => {
@@ -989,16 +1069,16 @@ function createFriendli(options = {}) {
     });
   };
   const createTextEmbeddingModel = (modelId) => {
-    throw new import_provider3.NoSuchModelError({ modelId, modelType: "embeddingModel" });
+    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;