@apertis/ai-sdk-provider 0.1.1 → 1.1.0

package/dist/index.cjs

@@ -26,7 +26,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/apertis-provider.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
 
 // src/apertis-chat-language-model.ts
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
@@ -115,17 +115,18 @@ var openAIChatChunkSchema = import_zod2.z.object({
 
 // src/utils/map-finish-reason.ts
 function mapApertisFinishReason(finishReason) {
+  const raw = finishReason ?? void 0;
   switch (finishReason) {
     case "stop":
-      return "stop";
+      return { unified: "stop", raw };
     case "length":
-      return "length";
+      return { unified: "length", raw };
     case "tool_calls":
-      return "tool-calls";
+      return { unified: "tool-calls", raw };
     case "content_filter":
-      return "content-filter";
+      return { unified: "content-filter", raw };
     default:
-      return "unknown";
+      return { unified: "other", raw };
   }
 }
 
@@ -144,13 +145,29 @@ function convertToOpenAIMessages(prompt) {
             switch (part.type) {
               case "text":
                 return { type: "text", text: part.text };
-              case "image":
-                return {
-                  type: "image_url",
-                  image_url: {
-                    url: part.image instanceof URL ? part.image.toString() : `data:${part.mimeType ?? "image/png"};base64,${Buffer.from(part.image).toString("base64")}`
+              case "file": {
+                if (part.mediaType?.startsWith("image/")) {
+                  let url;
+                  if (part.data instanceof URL) {
+                    url = part.data.toString();
+                  } else if (typeof part.data === "string") {
+                    if (part.data.startsWith("http://") || part.data.startsWith("https://")) {
+                      url = part.data;
+                    } else {
+                      url = `data:${part.mediaType};base64,${part.data}`;
+                    }
+                  } else {
+                    url = `data:${part.mediaType};base64,${Buffer.from(part.data).toString("base64")}`;
                   }
-                };
+                  return {
+                    type: "image_url",
+                    image_url: { url }
+                  };
+                }
+                throw new Error(
+                  `Unsupported file type: ${part.mediaType}. Only image/* is supported.`
+                );
+              }
               default:
                 throw new Error(
                   `Unsupported user content part type: ${part.type}`
@@ -161,12 +178,10 @@ function convertToOpenAIMessages(prompt) {
         break;
       case "assistant": {
         const textContent = message.content.filter((p) => p.type === "text").map((p) => p.text).join("");
-        const toolCalls = message.content.filter(
-          (p) => p.type === "tool-call"
-        ).map((tc) => {
+        const toolCalls = message.content.filter((p) => p.type === "tool-call").map((tc) => {
           let arguments_str = "{}";
           try {
-            arguments_str = JSON.stringify(tc.args);
+            arguments_str = typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input);
           } catch {
             arguments_str = "{}";
           }
@@ -185,12 +200,17 @@ function convertToOpenAIMessages(prompt) {
       }
       case "tool":
         for (const result of message.content) {
+          if (result.type !== "tool-result") continue;
           let content = "{}";
-          if (typeof result.result === "string") {
-            content = result.result;
+          const output = result.output;
+          if (typeof output === "string") {
+            content = output;
+          } else if (Array.isArray(output)) {
+            const textParts = output.filter((p) => p.type === "text").map((p) => p.text);
+            content = textParts.join("");
           } else {
             try {
-              content = JSON.stringify(result.result);
+              content = JSON.stringify(output);
             } catch {
               content = "{}";
             }
@@ -215,7 +235,7 @@ function convertToOpenAITools(tools) {
     function: {
       name: tool.name,
       description: tool.description,
-      parameters: tool.parameters
+      parameters: tool.inputSchema
     }
   }));
 }
@@ -229,7 +249,11 @@ function convertToOpenAIToolChoice(toolChoice) {
     case "required":
       return "required";
     case "tool":
-      return { type: "function", function: { name: toolChoice.toolName } };
+      if (!toolChoice.toolName) return void 0;
+      return {
+        type: "function",
+        function: { name: toolChoice.toolName }
+      };
     default:
       return void 0;
   }
@@ -242,15 +266,17 @@ var ApertisChatLanguageModel = class {
     this.settings = settings;
     this.config = config;
   }
-  specificationVersion = "v1";
-  defaultObjectGenerationMode = "json";
-  supportsImageUrls = true;
+  specificationVersion = "v3";
+  /**
+   * Supported URL patterns for different media types.
+   * Supports HTTP(S) image URLs for direct URL passing.
+   */
+  supportedUrls = {
+    "image/*": [/^https?:\/\/.+$/]
+  };
   get provider() {
     return this.config.provider;
   }
-  get supportsStructuredOutputs() {
-    return true;
-  }
   async doGenerate(options) {
     const body = this.buildRequestBody(options, false);
     const { value: response } = await (0, import_provider_utils2.postJsonToApi)({
@@ -265,20 +291,41 @@ var ApertisChatLanguageModel = class {
       abortSignal: options.abortSignal
     });
     const choice = response.choices[0];
+    const content = [];
+    if (choice.message.content) {
+      content.push({
+        type: "text",
+        text: choice.message.content
+      });
+    }
+    if (choice.message.tool_calls) {
+      for (const tc of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: tc.id,
+          toolName: tc.function.name,
+          input: tc.function.arguments
+        });
+      }
+    }
     return {
-      text: choice.message.content ?? void 0,
-      toolCalls: choice.message.tool_calls?.map((tc) => ({
-        toolCallType: "function",
-        toolCallId: tc.id,
-        toolName: tc.function.name,
-        args: tc.function.arguments
-      })),
+      content,
       finishReason: mapApertisFinishReason(choice.finish_reason),
       usage: {
-        promptTokens: response.usage?.prompt_tokens ?? 0,
-        completionTokens: response.usage?.completion_tokens ?? 0
+        inputTokens: {
+          total: response.usage?.prompt_tokens ?? 0,
+          noCache: void 0,
+          cacheRead: void 0,
+          cacheWrite: void 0
+        },
+        outputTokens: {
+          total: response.usage?.completion_tokens ?? 0,
+          text: void 0,
+          reasoning: void 0
+        }
       },
-      rawCall: { rawPrompt: options.prompt, rawSettings: body }
+      warnings: [],
+      request: { body }
     };
   }
   async doStream(options) {
@@ -295,6 +342,7 @@ var ApertisChatLanguageModel = class {
       abortSignal: options.abortSignal
     });
     const toolCallBuffers = /* @__PURE__ */ new Map();
+    let textId = null;
     const transformStream = new TransformStream({
       transform(parseResult, controller) {
         if (!parseResult.success) {
@@ -304,9 +352,17 @@ var ApertisChatLanguageModel = class {
         const choice = chunk.choices[0];
         if (!choice) return;
         if (choice.delta.content) {
+          if (!textId) {
+            textId = (0, import_provider_utils2.generateId)();
+            controller.enqueue({
+              type: "text-start",
+              id: textId
+            });
+          }
           controller.enqueue({
             type: "text-delta",
-            textDelta: choice.delta.content
+            id: textId,
+            delta: choice.delta.content
           });
         }
         if (choice.delta.tool_calls) {
@@ -323,14 +379,19 @@ var ApertisChatLanguageModel = class {
           }
         }
         if (choice.finish_reason) {
+          if (textId) {
+            controller.enqueue({
+              type: "text-end",
+              id: textId
+            });
+          }
           for (const [, buffer] of toolCallBuffers) {
             if (buffer.name) {
               controller.enqueue({
                 type: "tool-call",
-                toolCallType: "function",
                 toolCallId: buffer.id,
                 toolName: buffer.name,
-                args: buffer.arguments
+                input: buffer.arguments
               });
             }
           }
@@ -339,21 +400,35 @@ var ApertisChatLanguageModel = class {
             type: "finish",
             finishReason: mapApertisFinishReason(choice.finish_reason),
             usage: {
-              promptTokens: chunk.usage?.prompt_tokens ?? 0,
-              completionTokens: chunk.usage?.completion_tokens ?? 0
+              inputTokens: {
+                total: chunk.usage?.prompt_tokens ?? 0,
+                noCache: void 0,
+                cacheRead: void 0,
+                cacheWrite: void 0
+              },
+              outputTokens: {
+                total: chunk.usage?.completion_tokens ?? 0,
+                text: void 0,
+                reasoning: void 0
+              }
             }
           });
         }
       },
       flush(controller) {
+        if (textId) {
+          controller.enqueue({
+            type: "text-end",
+            id: textId
+          });
+        }
         for (const [, buffer] of toolCallBuffers) {
           if (buffer.name) {
             controller.enqueue({
               type: "tool-call",
-              toolCallType: "function",
               toolCallId: buffer.id,
               toolName: buffer.name,
-              args: buffer.arguments
+              input: buffer.arguments
             });
           }
         }
@@ -361,13 +436,12 @@ var ApertisChatLanguageModel = class {
     });
     return {
       stream: response.pipeThrough(transformStream),
-      rawCall: { rawPrompt: options.prompt, rawSettings: body }
+      request: { body }
     };
   }
   buildRequestBody(options, stream) {
-    const tools = options.mode.type === "regular" ? this.filterFunctionTools(options.mode.tools) : void 0;
-    const toolChoice = options.mode.type === "regular" ? options.mode.toolChoice : void 0;
-    const responseFormat = options.mode.type === "object-json" ? { type: "json_object" } : void 0;
+    const tools = this.filterFunctionTools(options.tools);
+    const responseFormat = options.responseFormat?.type === "json" ? { type: "json_object" } : void 0;
     const body = {
       model: this.modelId,
       messages: convertToOpenAIMessages(options.prompt),
@@ -376,7 +450,8 @@ var ApertisChatLanguageModel = class {
     if (stream) body.stream_options = { include_usage: true };
     if (options.temperature !== void 0)
       body.temperature = options.temperature;
-    if (options.maxTokens !== void 0) body.max_tokens = options.maxTokens;
+    if (options.maxOutputTokens !== void 0)
+      body.max_tokens = options.maxOutputTokens;
     if (options.topP !== void 0) body.top_p = options.topP;
     if (options.frequencyPenalty !== void 0)
       body.frequency_penalty = options.frequencyPenalty;
@@ -386,7 +461,7 @@ var ApertisChatLanguageModel = class {
     if (options.seed !== void 0) body.seed = options.seed;
     const convertedTools = convertToOpenAITools(tools);
     if (convertedTools !== void 0) body.tools = convertedTools;
-    const convertedToolChoice = convertToOpenAIToolChoice(toolChoice);
+    const convertedToolChoice = convertToOpenAIToolChoice(options.toolChoice);
     if (convertedToolChoice !== void 0)
       body.tool_choice = convertedToolChoice;
     if (responseFormat !== void 0) body.response_format = responseFormat;
@@ -405,12 +480,325 @@ var ApertisChatLanguageModel = class {
   }
 };
 
+// src/apertis-completion-language-model.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+
+// src/schemas/completion-response.ts
+var import_zod3 = require("zod");
+var openAICompletionResponseSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  object: import_zod3.z.literal("text_completion"),
+  created: import_zod3.z.number(),
+  model: import_zod3.z.string(),
+  choices: import_zod3.z.array(
+    import_zod3.z.object({
+      text: import_zod3.z.string(),
+      index: import_zod3.z.number(),
+      logprobs: import_zod3.z.object({
+        tokens: import_zod3.z.array(import_zod3.z.string()).optional(),
+        token_logprobs: import_zod3.z.array(import_zod3.z.number()).optional(),
+        top_logprobs: import_zod3.z.array(import_zod3.z.record(import_zod3.z.number())).optional(),
+        text_offset: import_zod3.z.array(import_zod3.z.number()).optional()
+      }).nullable().optional(),
+      finish_reason: import_zod3.z.string().nullable().optional()
+    })
+  ),
+  usage: import_zod3.z.object({
+    prompt_tokens: import_zod3.z.number(),
+    completion_tokens: import_zod3.z.number(),
+    total_tokens: import_zod3.z.number()
+  }).optional()
+});
+var openAICompletionChunkSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  object: import_zod3.z.literal("text_completion"),
+  created: import_zod3.z.number(),
+  model: import_zod3.z.string(),
+  choices: import_zod3.z.array(
+    import_zod3.z.object({
+      text: import_zod3.z.string(),
+      index: import_zod3.z.number(),
+      logprobs: import_zod3.z.object({
+        tokens: import_zod3.z.array(import_zod3.z.string()).optional(),
+        token_logprobs: import_zod3.z.array(import_zod3.z.number()).optional(),
+        top_logprobs: import_zod3.z.array(import_zod3.z.record(import_zod3.z.number())).optional(),
+        text_offset: import_zod3.z.array(import_zod3.z.number()).optional()
+      }).nullable().optional(),
+      finish_reason: import_zod3.z.string().nullable().optional()
+    })
+  ),
+  usage: import_zod3.z.object({
+    prompt_tokens: import_zod3.z.number(),
+    completion_tokens: import_zod3.z.number(),
+    total_tokens: import_zod3.z.number()
+  }).optional().nullable()
+});
+
+// src/apertis-completion-language-model.ts
+var ApertisCompletionLanguageModel = class {
+  constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  specificationVersion = "v3";
+  supportedUrls = {};
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate(options) {
+    const body = this.buildRequestBody(options, false);
+    const { value: response } = await (0, import_provider_utils3.postJsonToApi)({
+      url: `${this.config.baseURL}/completions`,
+      headers: this.config.headers(),
+      body,
+      failedResponseHandler: apertisFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+        openAICompletionResponseSchema
+      ),
+      fetch: this.config.fetch,
+      abortSignal: options.abortSignal
+    });
+    const choice = response.choices[0];
+    const content = [];
+    if (choice.text) {
+      content.push({
+        type: "text",
+        text: choice.text
+      });
+    }
+    return {
+      content,
+      finishReason: this.mapFinishReason(choice.finish_reason),
+      usage: {
+        inputTokens: {
+          total: response.usage?.prompt_tokens ?? 0,
+          noCache: void 0,
+          cacheRead: void 0,
+          cacheWrite: void 0
+        },
+        outputTokens: {
+          total: response.usage?.completion_tokens ?? 0,
+          text: void 0,
+          reasoning: void 0
+        }
+      },
+      warnings: [],
+      request: { body }
+    };
+  }
+  async doStream(options) {
+    const body = this.buildRequestBody(options, true);
+    const { value: response } = await (0, import_provider_utils3.postJsonToApi)({
+      url: `${this.config.baseURL}/completions`,
+      headers: this.config.headers(),
+      body,
+      failedResponseHandler: apertisFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(
+        openAICompletionChunkSchema
+      ),
+      fetch: this.config.fetch,
+      abortSignal: options.abortSignal
+    });
+    let textId = null;
+    const transformStream = new TransformStream({
+      transform(parseResult, controller) {
+        if (!parseResult.success) {
+          return;
+        }
+        const chunk = parseResult.value;
+        const choice = chunk.choices[0];
+        if (!choice) return;
+        if (choice.text) {
+          if (!textId) {
+            textId = (0, import_provider_utils3.generateId)();
+            controller.enqueue({
+              type: "text-start",
+              id: textId
+            });
+          }
+          controller.enqueue({
+            type: "text-delta",
+            id: textId,
+            delta: choice.text
+          });
+        }
+        if (choice.finish_reason) {
+          if (textId) {
+            controller.enqueue({
+              type: "text-end",
+              id: textId
+            });
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason: {
+              unified: choice.finish_reason === "stop" ? "stop" : choice.finish_reason === "length" ? "length" : "other",
+              raw: choice.finish_reason ?? void 0
+            },
+            usage: {
+              inputTokens: {
+                total: chunk.usage?.prompt_tokens ?? 0,
+                noCache: void 0,
+                cacheRead: void 0,
+                cacheWrite: void 0
+              },
+              outputTokens: {
+                total: chunk.usage?.completion_tokens ?? 0,
+                text: void 0,
+                reasoning: void 0
+              }
+            }
+          });
+        }
+      },
+      flush(controller) {
+        if (textId) {
+          controller.enqueue({
+            type: "text-end",
+            id: textId
+          });
+        }
+      }
+    });
+    return {
+      stream: response.pipeThrough(transformStream),
+      request: { body }
+    };
+  }
+  buildRequestBody(options, stream) {
+    const prompt = this.convertPromptToText(options.prompt);
+    const body = {
+      model: this.modelId,
+      prompt,
+      stream
+    };
+    if (stream) body.stream_options = { include_usage: true };
+    if (options.maxOutputTokens !== void 0)
+      body.max_tokens = options.maxOutputTokens;
+    if (options.temperature !== void 0)
+      body.temperature = options.temperature;
+    if (options.topP !== void 0) body.top_p = options.topP;
+    if (options.frequencyPenalty !== void 0)
+      body.frequency_penalty = options.frequencyPenalty;
+    if (options.presencePenalty !== void 0)
+      body.presence_penalty = options.presencePenalty;
+    if (options.stopSequences !== void 0) body.stop = options.stopSequences;
+    if (options.seed !== void 0) body.seed = options.seed;
+    if (this.settings.echo !== void 0) body.echo = this.settings.echo;
+    if (this.settings.logprobs !== void 0)
+      body.logprobs = this.settings.logprobs;
+    if (this.settings.suffix !== void 0) body.suffix = this.settings.suffix;
+    if (this.settings.user !== void 0) body.user = this.settings.user;
+    return body;
+  }
+  convertPromptToText(prompt) {
+    const parts = [];
+    for (const message of prompt) {
+      if (message.role === "system") {
+        parts.push(message.content);
+      } else if (message.role === "user") {
+        for (const part of message.content) {
+          if (part.type === "text") {
+            parts.push(part.text);
+          }
+        }
+      } else if (message.role === "assistant") {
+        for (const part of message.content) {
+          if (part.type === "text") {
+            parts.push(part.text);
+          }
+        }
+      }
+    }
+    return parts.join("\n\n");
+  }
+  mapFinishReason(finishReason) {
+    const raw = finishReason ?? void 0;
+    switch (finishReason) {
+      case "stop":
+        return { unified: "stop", raw };
+      case "length":
+        return { unified: "length", raw };
+      default:
+        return { unified: "other", raw };
+    }
+  }
+};
+
+// src/apertis-embedding-model.ts
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+
+// src/schemas/embedding-response.ts
+var import_zod4 = require("zod");
+var openAIEmbeddingResponseSchema = import_zod4.z.object({
+  object: import_zod4.z.literal("list"),
+  data: import_zod4.z.array(
+    import_zod4.z.object({
+      object: import_zod4.z.literal("embedding"),
+      embedding: import_zod4.z.array(import_zod4.z.number()),
+      index: import_zod4.z.number()
+    })
+  ),
+  model: import_zod4.z.string(),
+  usage: import_zod4.z.object({
+    prompt_tokens: import_zod4.z.number(),
+    total_tokens: import_zod4.z.number()
+  }).optional()
+});
+
+// src/apertis-embedding-model.ts
+var ApertisEmbeddingModel = class {
+  constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+    this.maxEmbeddingsPerCall = settings.maxEmbeddingsPerCall ?? 2048;
+    this.supportsParallelCalls = settings.supportsParallelCalls ?? true;
+  }
+  specificationVersion = "v3";
+  maxEmbeddingsPerCall;
+  supportsParallelCalls;
+  get provider() {
+    return this.config.provider;
+  }
+  async doEmbed(options) {
+    const body = {
+      model: this.modelId,
+      input: options.values,
+      encoding_format: "float"
+    };
+    if (this.settings.dimensions !== void 0) {
+      body.dimensions = this.settings.dimensions;
+    }
+    if (this.settings.user !== void 0) {
+      body.user = this.settings.user;
+    }
+    const { value: response } = await (0, import_provider_utils4.postJsonToApi)({
+      url: `${this.config.baseURL}/embeddings`,
+      headers: this.config.headers(),
+      body,
+      failedResponseHandler: apertisFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+        openAIEmbeddingResponseSchema
+      ),
+      fetch: this.config.fetch,
+      abortSignal: options.abortSignal
+    });
+    return {
+      embeddings: response.data.map((item) => item.embedding),
+      usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
+      warnings: []
+    };
+  }
+};
+
 // src/apertis-provider.ts
 function createApertis(options = {}) {
-  const baseURL = (0, import_provider_utils3.withoutTrailingSlash)(options.baseURL) ?? "https://api.apertis.ai/v1";
+  const baseURL = (0, import_provider_utils5.withoutTrailingSlash)(options.baseURL) ?? "https://api.apertis.ai/v1";
   const getHeaders = () => ({
     ...options.headers,
-    Authorization: `Bearer ${(0, import_provider_utils3.loadApiKey)({
+    Authorization: `Bearer ${(0, import_provider_utils5.loadApiKey)({
       apiKey: options.apiKey,
       environmentVariableName: "APERTIS_API_KEY",
       description: "Apertis API key"
@@ -423,11 +811,30 @@ function createApertis(options = {}) {
     headers: getHeaders,
     fetch: options.fetch
   });
+  const createCompletionModel = (modelId, settings = {}) => new ApertisCompletionLanguageModel(modelId, settings, {
+    provider: "apertis.completion",
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createEmbeddingModel = (modelId, settings = {}) => new ApertisEmbeddingModel(modelId, settings, {
+    provider: "apertis.embedding",
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
   const provider = Object.assign(
     (modelId, settings) => createChatModel(modelId, settings),
     {
+      specificationVersion: "v3",
       chat: createChatModel,
-      languageModel: createChatModel
+      languageModel: (modelId) => createChatModel(modelId),
+      completion: createCompletionModel,
+      embeddingModel: (modelId) => createEmbeddingModel(modelId),
+      textEmbeddingModel: createEmbeddingModel,
+      imageModel: () => {
+        throw new Error("Image models are not supported by Apertis");
+      }
     }
   );
   return provider;