@aihubmix/ai-sdk-provider/dist/index.mjs

> **🎉 10% discount!** Added app-code; this way, requesting all models through ai-sdk offers a 10% discount.

// src/aihubmix-provider.ts
import {
  OpenAIChatLanguageModel,
  OpenAICompletionLanguageModel,
  OpenAIEmbeddingModel,
  OpenAIImageModel,
  OpenAIResponsesLanguageModel,
  OpenAITranscriptionModel,
  OpenAISpeechModel
} from "@ai-sdk/openai/internal";
import { AnthropicMessagesLanguageModel } from "@ai-sdk/anthropic/internal";
import { GoogleGenerativeAILanguageModel } from "@ai-sdk/google/internal";
import { loadApiKey } from "@ai-sdk/provider-utils";

// src/aihubmix-tools.ts
import { z } from "zod";
var WebSearchPreviewParameters = z.object({});
function webSearchPreviewTool({
  searchContextSize,
  userLocation
} = {}) {
  return {
    type: "provider-defined",
    id: "aihubmix.web_search_preview",
    args: {
      searchContextSize,
      userLocation
    },
    parameters: WebSearchPreviewParameters
  };
}
var aihubmixTools = {
  webSearchPreview: webSearchPreviewTool
};

// src/aihubmix-provider.ts
var AihubmixTranscriptionModel = class extends OpenAITranscriptionModel {
  async doGenerate(options) {
    if (options.mediaType) {
      const mimeTypeMap = {
        "audio/mpeg": "mp3",
        "audio/mp3": "mp3",
        "audio/wav": "wav",
        "audio/flac": "flac",
        "audio/m4a": "m4a",
        "audio/mp4": "mp4",
        "audio/ogg": "ogg",
        "audio/webm": "webm",
        "audio/oga": "oga",
        "audio/mpga": "mpga"
      };
      const extension = mimeTypeMap[options.mediaType];
      if (extension) {
        const originalGetArgs = this.getArgs;
        this.getArgs = async function(args) {
          const result = await originalGetArgs.call(this, args);
          if (result.formData) {
            const fileEntry = result.formData.get("file");
            if (fileEntry && typeof fileEntry === "object" && "name" in fileEntry) {
              try {
                const newFile = new File([fileEntry], `audio.${extension}`, {
                  type: options.mediaType
                });
                result.formData.set("file", newFile);
              } catch (error) {
                console.log("Failed to create new File object:", error);
                if (fileEntry && typeof fileEntry === "object" && "arrayBuffer" in fileEntry) {
                  try {
                    const arrayBuffer = await fileEntry.arrayBuffer();
                    const newFile = new File([arrayBuffer], `audio.${extension}`, {
                      type: options.mediaType
                    });
                    result.formData.set("file", newFile);
                    console.log("Created new file from arrayBuffer with name:", `audio.${extension}`);
                  } catch (bufferError) {
                    console.log("Failed to create file from arrayBuffer:", bufferError);
                  }
                }
              }
            }
          }
          return result;
        };
      }
    }
    return super.doGenerate(options);
  }
};
function createAihubmix(options = {}) {
  const getHeaders = () => ({
    Authorization: `Bearer ${loadApiKey({
      apiKey: options.apiKey,
      environmentVariableName: "AIHUBMIX_API_KEY",
      description: "Aihubmix"
    })}`,
    "APP-Code": "WHVL9885",
    "Content-Type": "application/json"
  });
  const getTranscriptionHeaders = () => ({
    Authorization: `Bearer ${loadApiKey({
      apiKey: options.apiKey,
      environmentVariableName: "AIHUBMIX_API_KEY",
      description: "Aihubmix"
    })}`,
    "APP-Code": "WHVL9885"
  });
  const url = ({ path, modelId }) => {
    const baseURL = "https://aihubmix.com/v1";
    return `${baseURL}${path}`;
  };
  const createChatModel = (deploymentName, settings = {}) => {
    const headers = getHeaders();
    if (deploymentName.startsWith("claude-")) {
      return new AnthropicMessagesLanguageModel(deploymentName, {
        provider: "aihubmix.chat",
        baseURL: url({ path: "", modelId: deploymentName }),
        headers: {
          ...headers,
          "x-api-key": headers["Authorization"].split(" ")[1]
        },
        supportedUrls: () => ({
          "image/*": [/^https?:\/\/.*$/]
        })
      });
    }
    if ((deploymentName.startsWith("gemini") || deploymentName.startsWith("imagen")) && !deploymentName.endsWith("-nothink") && !deploymentName.endsWith("-search")) {
      return new GoogleGenerativeAILanguageModel(
        deploymentName,
        {
          provider: "aihubmix.chat",
          baseURL: "https://aihubmix.com/gemini/v1beta",
          headers: {
            ...headers,
            "x-goog-api-key": headers["Authorization"].split(" ")[1]
          },
          generateId: () => `aihubmix-${Date.now()}`,
          supportedUrls: () => ({})
        }
      );
    }
    return new OpenAIChatLanguageModel(deploymentName, {
      provider: "aihubmix.chat",
      url,
      headers: getHeaders,
      fetch: options.fetch
    });
  };
  const createCompletionModel = (modelId, settings = {}) => new OpenAICompletionLanguageModel(modelId, {
    provider: "aihubmix.completion",
    url,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createEmbeddingModel = (modelId, settings = {}) => {
    return new OpenAIEmbeddingModel(modelId, {
      provider: "aihubmix.embeddings",
      headers: getHeaders,
      url,
      fetch: options.fetch
    });
  };
  const createResponsesModel = (modelId) => new OpenAIResponsesLanguageModel(modelId, {
    provider: "aihubmix.responses",
    url,
    headers: getHeaders
  });
  const createImageModel = (modelId, settings = {}) => {
    return new OpenAIImageModel(modelId, {
      provider: "aihubmix.image",
      url,
      headers: getHeaders,
      fetch: options.fetch
    });
  };
  const createTranscriptionModel = (modelId) => new AihubmixTranscriptionModel(modelId, {
    provider: "aihubmix.transcription",
    url,
    headers: getTranscriptionHeaders,
    fetch: options.fetch
  });
  const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
    provider: "aihubmix.speech",
    url,
    headers: getHeaders,
    fetch: options.fetch
  });
  const provider = function(deploymentId, settings) {
    if (new.target) {
      throw new Error(
        "The Aihubmix model function cannot be called with the new keyword."
      );
    }
    return createChatModel(deploymentId, settings);
  };
  provider.languageModel = createChatModel;
  provider.chat = createChatModel;
  provider.completion = createCompletionModel;
  provider.responses = createResponsesModel;
  provider.embedding = createEmbeddingModel;
  provider.textEmbedding = createEmbeddingModel;
  provider.textEmbeddingModel = createEmbeddingModel;
  provider.image = createImageModel;
  provider.imageModel = createImageModel;
  provider.transcription = createTranscriptionModel;
  provider.transcriptionModel = createTranscriptionModel;
  provider.speech = createSpeechModel;
  provider.speechModel = createSpeechModel;
  provider.tools = aihubmixTools;
  return provider;
}
var aihubmix = createAihubmix();
export {
  aihubmix,
  createAihubmix
};
//# sourceMappingURL=index.mjs.map