@ai-ml.api/aimlapi-vercel-ai
Version:
AI SDK provider for AI/ML API: 300+ models via OpenAI-compatible API.
196 lines (191 loc) • 7.22 kB
JavaScript
;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var index_exports = {};
__export(index_exports, {
aimlapi: () => aimlapi,
createAIMLAPI: () => createAIMLAPI
});
module.exports = __toCommonJS(index_exports);
// src/aimlapi-provider.ts
var import_openai_compatible = require("@ai-sdk/openai-compatible");
var import_provider = require("@ai-sdk/provider");
var import_provider_utils2 = require("@ai-sdk/provider-utils");
// src/aimlapi-error.ts
var import_zod = require("zod");
var aimlapiErrorSchema = import_zod.z.object({
error: import_zod.z.object({
message: import_zod.z.string(),
code: import_zod.z.string().optional(),
type: import_zod.z.string().optional()
})
});
// src/aimlapi-image-model.ts
var import_provider_utils = require("@ai-sdk/provider-utils");
var import_zod2 = require("zod");
var AimlapiImageModel = class {
constructor(modelId, settings = {}, config) {
this.modelId = modelId;
this.settings = settings;
this.config = config;
}
specificationVersion = "v2";
maxImagesPerCall = 1;
get provider() {
return this.config.provider;
}
async doGenerate({ prompt, n, aspectRatio, size, seed, providerOptions, headers, abortSignal }) {
const warnings = [];
const modelSupportsAspectRatio = true;
if (!modelSupportsAspectRatio && aspectRatio != null) {
warnings.push({
type: "unsupported-setting",
setting: "aspectRatio",
details: "This model does not support `aspectRatio`. Use `size` instead."
});
}
if (size != null && aspectRatio != null) {
warnings.push({
type: "other",
message: "Both `size` and `aspectRatio` were provided. The API will prioritize `size`."
});
}
const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
const splitSize = size?.split("x");
const resolvedProviderHeaders = await (0, import_provider_utils.resolve)(this.config.headers);
const { value: response, responseHeaders } = await (0, import_provider_utils.postJsonToApi)({
url: `${this.config.baseURL}/images/generations`,
headers: (0, import_provider_utils.combineHeaders)(resolvedProviderHeaders, headers),
body: {
model: this.modelId,
prompt,
seed,
n,
...splitSize && {
width: parseInt(splitSize[0], 10),
height: parseInt(splitSize[1], 10)
},
...aspectRatio && { aspect_ratio: aspectRatio },
// Don't force base64: some models will return the url anyway
...providerOptions?.aimlapi ?? {}
},
successfulResponseHandler: (0, import_provider_utils.createJsonResponseHandler)(aimlapiImageResponseSchema),
failedResponseHandler: (0, import_provider_utils.createJsonErrorResponseHandler)({
errorSchema: aimlapiErrorSchema,
errorToMessage: (e) => e.error.message,
isRetryable: (res, e) => {
if (res.status === 429) return true;
if (res.status >= 500) return true;
if (e?.error?.code === "overloaded" || e?.error?.code === "timeout") return true;
return false;
}
}),
abortSignal,
fetch: this.config.fetch
});
return {
images: response.normalized,
warnings,
response: {
timestamp: currentDate,
modelId: this.modelId,
headers: responseHeaders
}
};
}
};
var aimlapiImageResponseSchema = import_zod2.z.union([
// Option A: OpenAI-compatible base64
import_zod2.z.object({
data: import_zod2.z.array(import_zod2.z.object({ b64_json: import_zod2.z.string() }))
}).transform((v) => ({ normalized: v.data.map((d) => d.b64_json) })),
// Option B: AIMLAPI format with images (url or b64_json)
import_zod2.z.object({
images: import_zod2.z.array(
import_zod2.z.object({
b64_json: import_zod2.z.string().optional(),
url: import_zod2.z.string().url().optional()
})
)
}).transform((v) => ({
normalized: v.images.map((i) => i.b64_json ?? i.url ?? "").filter((x) => x.length > 0)
}))
]);
// src/aimlapi-provider.ts
var import_zod3 = require("zod");
var defaultBaseURL = "https://api.aimlapi.com/v1";
var aimlapiErrorStructure = {
errorSchema: aimlapiErrorSchema,
errorToMessage: (data) => data.error.message
// isRetryable: (res) => res.status === 429 || res.status >= 500,
};
function createAIMLAPI(options = {}) {
const rawBaseURL = options.baseURL ?? defaultBaseURL;
const strictBaseURL = (0, import_provider_utils2.withoutTrailingSlash)(rawBaseURL) ?? defaultBaseURL;
const getHeadersLoose = () => ({
Authorization: `Bearer ${(0, import_provider_utils2.loadApiKey)({
apiKey: options.apiKey,
environmentVariableName: "AIMLAPI_API_KEY",
description: "AIMLAPI API key"
})}`,
"X-Title": "vercel",
...typeof options.headers === "function" ? options.headers() : options.headers
});
const getHeadersStrict = () => Object.fromEntries(
Object.entries(getHeadersLoose()).filter(
([, v]) => v !== void 0
)
);
const getCommonModelConfig = (modelType) => ({
provider: `aimlapi.${modelType}`,
url: ({ path }) => `${strictBaseURL}${path}`,
headers: getHeadersStrict,
fetch: options.fetch,
errorStructure: aimlapiErrorStructure
});
const createChat = (modelId) => new import_openai_compatible.OpenAICompatibleChatLanguageModel(modelId, getCommonModelConfig("chat"));
const createCompletion = (modelId) => new import_openai_compatible.OpenAICompatibleCompletionLanguageModel(
modelId,
getCommonModelConfig("completion")
);
const createEmbedding = (modelId) => new import_openai_compatible.OpenAICompatibleEmbeddingModel(
modelId,
getCommonModelConfig("embedding")
);
const createImage = (modelId, settings = {}) => new AimlapiImageModel(modelId, settings, {
provider: "aimlapi.image",
baseURL: strictBaseURL,
headers: getHeadersStrict,
fetch: options.fetch
});
const providerFunc = (modelId) => createChat(modelId);
providerFunc.chat = createChat;
providerFunc.completion = createCompletion;
providerFunc.languageModel = createChat;
providerFunc.textEmbeddingModel = createEmbedding;
providerFunc.imageModel = createImage;
return providerFunc;
}
var aimlapi = createAIMLAPI();
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
aimlapi,
createAIMLAPI
});
//# sourceMappingURL=index.js.map