@ai-sdk/luma
Version:
The **Luma provider** for the [AI SDK](https://ai-sdk.dev/docs) contains support for Luma AI's state-of-the-art image generation models - Photon and Photon Flash.
239 lines (235 loc) • 8.3 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 src_exports = {};
__export(src_exports, {
createLuma: () => createLuma,
luma: () => luma
});
module.exports = __toCommonJS(src_exports);
// src/luma-provider.ts
var import_provider2 = require("@ai-sdk/provider");
var import_provider_utils2 = require("@ai-sdk/provider-utils");
// src/luma-image-model.ts
var import_provider = require("@ai-sdk/provider");
var import_provider_utils = require("@ai-sdk/provider-utils");
var import_v4 = require("zod/v4");
var DEFAULT_POLL_INTERVAL_MILLIS = 500;
var DEFAULT_MAX_POLL_ATTEMPTS = 6e4 / DEFAULT_POLL_INTERVAL_MILLIS;
var LumaImageModel = class {
constructor(modelId, config) {
this.modelId = modelId;
this.config = config;
this.specificationVersion = "v2";
this.maxImagesPerCall = 1;
this.pollIntervalMillis = DEFAULT_POLL_INTERVAL_MILLIS;
this.maxPollAttempts = DEFAULT_MAX_POLL_ATTEMPTS;
}
get provider() {
return this.config.provider;
}
async doGenerate({
prompt,
n,
size,
aspectRatio,
seed,
providerOptions,
headers,
abortSignal
}) {
var _a, _b, _c, _d;
const warnings = [];
if (seed != null) {
warnings.push({
type: "unsupported-setting",
setting: "seed",
details: "This model does not support the `seed` option."
});
}
if (size != null) {
warnings.push({
type: "unsupported-setting",
setting: "size",
details: "This model does not support the `size` option. Use `aspectRatio` instead."
});
}
const { pollIntervalMillis, maxPollAttempts, ...providerRequestOptions } = (_a = providerOptions.luma) != null ? _a : {};
const currentDate = (_d = (_c = (_b = this.config._internal) == null ? void 0 : _b.currentDate) == null ? void 0 : _c.call(_b)) != null ? _d : /* @__PURE__ */ new Date();
const fullHeaders = (0, import_provider_utils.combineHeaders)(this.config.headers(), headers);
const { value: generationResponse, responseHeaders } = await (0, import_provider_utils.postJsonToApi)({
url: this.getLumaGenerationsUrl(),
headers: fullHeaders,
body: {
prompt,
...aspectRatio ? { aspect_ratio: aspectRatio } : {},
model: this.modelId,
...providerRequestOptions
},
abortSignal,
fetch: this.config.fetch,
failedResponseHandler: this.createLumaErrorHandler(),
successfulResponseHandler: (0, import_provider_utils.createJsonResponseHandler)(
lumaGenerationResponseSchema
)
});
const imageUrl = await this.pollForImageUrl(
generationResponse.id,
fullHeaders,
abortSignal,
providerOptions.luma
);
const downloadedImage = await this.downloadImage(imageUrl, abortSignal);
return {
images: [downloadedImage],
warnings,
response: {
modelId: this.modelId,
timestamp: currentDate,
headers: responseHeaders
}
};
}
async pollForImageUrl(generationId, headers, abortSignal, imageSettings) {
var _a, _b, _c;
const url = this.getLumaGenerationsUrl(generationId);
const maxPollAttempts = (_a = imageSettings == null ? void 0 : imageSettings.maxPollAttempts) != null ? _a : this.maxPollAttempts;
const pollIntervalMillis = (_b = imageSettings == null ? void 0 : imageSettings.pollIntervalMillis) != null ? _b : this.pollIntervalMillis;
for (let i = 0; i < maxPollAttempts; i++) {
const { value: statusResponse } = await (0, import_provider_utils.getFromApi)({
url,
headers,
abortSignal,
fetch: this.config.fetch,
failedResponseHandler: this.createLumaErrorHandler(),
successfulResponseHandler: (0, import_provider_utils.createJsonResponseHandler)(
lumaGenerationResponseSchema
)
});
switch (statusResponse.state) {
case "completed":
if (!((_c = statusResponse.assets) == null ? void 0 : _c.image)) {
throw new import_provider.InvalidResponseDataError({
data: statusResponse,
message: `Image generation completed but no image was found.`
});
}
return statusResponse.assets.image;
case "failed":
throw new import_provider.InvalidResponseDataError({
data: statusResponse,
message: `Image generation failed.`
});
}
await (0, import_provider_utils.delay)(pollIntervalMillis);
}
throw new Error(
`Image generation timed out after ${this.maxPollAttempts} attempts.`
);
}
createLumaErrorHandler() {
return (0, import_provider_utils.createJsonErrorResponseHandler)({
errorSchema: lumaErrorSchema,
errorToMessage: (error) => {
var _a;
return (_a = error.detail[0].msg) != null ? _a : "Unknown error";
}
});
}
getLumaGenerationsUrl(generationId) {
return `${this.config.baseURL}/dream-machine/v1/generations/${generationId != null ? generationId : "image"}`;
}
async downloadImage(url, abortSignal) {
const { value: response } = await (0, import_provider_utils.getFromApi)({
url,
// No specific headers should be needed for this request as it's a
// generated image provided by Luma.
abortSignal,
failedResponseHandler: (0, import_provider_utils.createStatusCodeErrorResponseHandler)(),
successfulResponseHandler: (0, import_provider_utils.createBinaryResponseHandler)(),
fetch: this.config.fetch
});
return response;
}
};
var lumaGenerationResponseSchema = import_v4.z.object({
id: import_v4.z.string(),
state: import_v4.z.enum(["queued", "dreaming", "completed", "failed"]),
failure_reason: import_v4.z.string().nullish(),
assets: import_v4.z.object({
image: import_v4.z.string()
// URL of the generated image
}).nullish()
});
var lumaErrorSchema = import_v4.z.object({
detail: import_v4.z.array(
import_v4.z.object({
type: import_v4.z.string(),
loc: import_v4.z.array(import_v4.z.string()),
msg: import_v4.z.string(),
input: import_v4.z.string(),
ctx: import_v4.z.object({
expected: import_v4.z.string()
}).nullish()
})
)
});
// src/luma-provider.ts
var defaultBaseURL = "https://api.lumalabs.ai";
function createLuma(options = {}) {
var _a;
const baseURL = (0, import_provider_utils2.withoutTrailingSlash)((_a = options.baseURL) != null ? _a : defaultBaseURL);
const getHeaders = () => ({
Authorization: `Bearer ${(0, import_provider_utils2.loadApiKey)({
apiKey: options.apiKey,
environmentVariableName: "LUMA_API_KEY",
description: "Luma"
})}`,
...options.headers
});
const createImageModel = (modelId) => new LumaImageModel(modelId, {
provider: "luma.image",
baseURL: baseURL != null ? baseURL : defaultBaseURL,
headers: getHeaders,
fetch: options.fetch
});
return {
image: createImageModel,
imageModel: createImageModel,
languageModel: () => {
throw new import_provider2.NoSuchModelError({
modelId: "languageModel",
modelType: "languageModel"
});
},
textEmbeddingModel: () => {
throw new import_provider2.NoSuchModelError({
modelId: "textEmbeddingModel",
modelType: "textEmbeddingModel"
});
}
};
}
var luma = createLuma();
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
createLuma,
luma
});
//# sourceMappingURL=index.js.map