@friendliai/ai-provider 1.0.0-beta.1 → 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 {
@@ -57,7 +127,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,6 +171,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) {
@@ -108,7 +202,7 @@ var FriendliAIChatLanguageModel = class {
     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,14 +230,20 @@ var FriendliAIChatLanguageModel = class {
   }) {
     var _a;
     const warnings = [];
-    if (topK != null) {
-      warnings.push({ type: "unsupported", feature: "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",
@@ -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,30 +278,33 @@ 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]
     };
@@ -312,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, _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 });
@@ -322,7 +434,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 : generateId();
               switch (value.status) {
                 case "STARTED":
@@ -365,26 +477,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",
-                ...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;
@@ -401,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);
             }
@@ -485,12 +607,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 && 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: (_p = toolCall.id) != null ? _p : generateId(),
+                    toolCallId: (_q = toolCall.id) != null ? _q : generateId(),
                     toolName: toolCall.function.name,
                     input: toolCall.function.arguments
                   });
@@ -537,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(),
@@ -715,7 +757,23 @@ 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
@@ -745,54 +803,65 @@ var FriendliAIServerlessModelIds = [
 ];
 
 // src/friendli-tools.ts
-import { jsonSchema } from "@ai-sdk/provider-utils";
+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 {
-    type: "provider",
-    id: "friendli.web:search",
-    args: {},
-    inputSchema: jsonSchema({ type: "object", properties: {} })
-  };
+  return webSearchTool({});
 }
 function webUrl() {
-  return {
-    type: "provider",
-    id: "friendli.web:url",
-    args: {},
-    inputSchema: jsonSchema({ type: "object", properties: {} })
-  };
+  return webUrlTool({});
 }
 function mathCalendar() {
-  return {
-    type: "provider",
-    id: "friendli.math:calendar",
-    args: {},
-    inputSchema: jsonSchema({ type: "object", properties: {} })
-  };
+  return mathCalendarTool({});
 }
 function mathStatistics() {
-  return {
-    type: "provider",
-    id: "friendli.math:statistics",
-    args: {},
-    inputSchema: jsonSchema({ type: "object", properties: {} })
-  };
+  return mathStatisticsTool({});
 }
 function mathCalculator() {
-  return {
-    type: "provider",
-    id: "friendli.math:calculator",
-    args: {},
-    inputSchema: jsonSchema({ type: "object", properties: {} })
-  };
+  return mathCalculatorTool({});
 }
 function codePythonInterpreter() {
-  return {
-    type: "provider",
-    id: "friendli.code:python-interpreter",
-    args: {},
-    inputSchema: jsonSchema({ type: "object", properties: {} })
-  };
+  return codePythonInterpreterTool({});
+}
+function linkupSearch() {
+  return linkupSearchTool({});
 }
 var friendliTools = {
   webSearch,
@@ -800,7 +869,8 @@ var friendliTools = {
   mathCalendar,
   mathStatistics,
   mathCalculator,
-  codePythonInterpreter
+  codePythonInterpreter,
+  linkupSearch
 };
 
 // src/get-available-models.ts
@@ -967,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) => {