Spot it. Save it. Free, local-first Chrome extension for images, videos and prompts. Explore 2,000+ curated cases and connect your library to AI Agents via MCP. 提示词导演
JavaScript ai-artai-videochrome-extensionclaude-codecodexhiggsfieldjimenglocal-firstmcpmidjourneymoodboardprompt-engineeringprompt-libraryprompt-managerreference-libraryseedancevisual-bookmarksweb-clipper
import { boundedMediaBlobFromResponse } from "./bounded-media.js";
import { getAiModelCapability, listAiModelCapabilities } from "./ai-model-capabilities.js";
import { getAiProviderPreset } from "./ai-provider-presets.js";
const TEXT_TASKS = Object.freeze(["textTags", "skillExtraction", "creativePlanning"]);
const ALL_TASKS = Object.freeze([...TEXT_TASKS, "imageAnalysis", "videoAnalysis", "imageGeneration", "videoGeneration"]);
const DISCOVERY_ADAPTERS = Object.freeze({
identity: discoverIdentityModels,
kimi: discoverKimi,
xai: discoverXai,
openrouter: discoverOpenRouter,
gemini: discoverGemini,
configured_video: discoverConfiguredVideo
});
export function createAiProviderModule(options = {}) {
const fetchImpl = options.fetchImpl ?? globalThis.fetch;
if (typeof fetchImpl !== "function") throw new Error("当前环境不支持模型发现请求");
const catalogs = new Map();
const cachedDiscoveries = new Map();
const providerProfiles = new Map();
const requestOptions = { signal: options.signal, timeoutMs: options.timeoutMs };
return {
configureProvider(profileValue) {
const profile = normalizeProfile(profileValue);
providerProfiles.set(profile.id, profile);
return { providerId: profile.id };
},
discoverModels,
verifyModelAccess,
describeCapabilities,
execute: (task, request) => executeTask(fetchImpl, providerProfiles, task, request, requestOptions),
submit: (task, request) => submitTask(fetchImpl, providerProfiles, task, request, requestOptions),
poll: (job) => pollJob(fetchImpl, providerProfiles, job, requestOptions),
download: (job) => downloadJob(fetchImpl, providerProfiles, job, requestOptions),
resume: (job) => resumeJob(fetchImpl, providerProfiles, job, requestOptions)
};
async function discoverModels(profileValue = {}, requestOptions = {}) {
const profile = normalizeProfile(profileValue);
providerProfiles.set(profile.id, profile);
const previous = cachedDiscoveries.get(profile.id);
const discovery = await discoverProviderModels(fetchImpl, profile, {
etag: requestOptions.etag || previous?.cache?.etag || ""
});
const result = discovery.notModified ? (previous ?? {
providerId: profile.id,
discoveredAt: profile.discovery?.discoveredAt || new Date().toISOString(),
models: profile.discoveredModels,
cache: { etag: requestOptions.etag || "", cacheControl: profile.discovery?.cacheControl || "" },
source: profile.discovery?.source || "provider_cache"
}) : {
providerId: profile.id,
discoveredAt: new Date().toISOString(),
models: mergeModels(discovery.models, configuredModels(profile).map((model) => {
const discovered = discovery.models.find((item) => item.id === model.id);
return {
...model,
status: discovered?.status ?? (Array.isArray(discovery.models) && !profile.id.startsWith("custom")
? "unavailable"
: model.status)
};
})),
cache: discovery.cache,
source: discovery.source
};
catalogs.set(profile.id, new Map(result.models.map((model) => [model.id, model])));
cachedDiscoveries.set(profile.id, result);
return structuredClone(result);
}
async function verifyModelAccess(profileValue = {}, modelIdValue = "") {
const modelId = clean(modelIdValue);
if (!modelId) throw new Error("缺少要校验的模型名称");
const result = await discoverModels({ ...profileValue, models: {} }, { etag: "" });
const providerModels = result.models.filter((model) =>
model.status !== "unavailable" && model.source.includes("provider_models")
);
const available = providerModels.some((model) => model.id === modelId);
return {
providerId: result.providerId,
modelId,
available,
verification: available ? "catalog_visible" : "not_catalog_visible",
executionVerified: false,
visibleModelIds: providerModels.map((model) => model.id)
};
}
function describeCapabilities(providerId, modelId) {
const model = catalogs.get(clean(providerId))?.get(clean(modelId));
if (!model) throw new Error("尚未发现该模型的能力信息");
return structuredClone(model);
}
}
async function discoverProviderModels(fetchImpl, profile, cache) {
const preset = getAiProviderPreset(profile.id);
const adapterId = clean(profile.discovery?.adapter) || preset?.discovery?.adapter || "identity";
const adapter = DISCOVERY_ADAPTERS[adapterId];
if (!adapter) throw new Error(`${profile.id} 的模型发现方式 ${adapterId} 尚未适配`);
const result = await adapter(fetchImpl, profile, cache);
if (result.notModified) return result;
const allowedTasks = preset ? new Set(preset.capabilities) : null;
const officialModels = preset?.catalogCompleteness === "partial"
? listAiModelCapabilities(profile.id).map((capability) => modelDescriptor({ id: capability.id }, {
status: "unverified",
confidence: "declared",
tasks: capability.tasks,
inputModalities: capability.inputModalities,
outputModalities: capability.outputModalities,
supportedParameters: capability.supportedParameters,
supportedResolutions: capability.supportedResolutions,
supportedAspectRatios: capability.supportedAspectRatios,
referenceImages: capability.referenceImages,
concurrencyLimit: capability.concurrencyLimit,
contextLength: capability.contextLength,
source: "official_capabilities"
}))
: [];
return {
...result,
models: mergeModels(result.models, officialModels).map((model) => ({
...model,
tasks: allowedTasks ? model.tasks.filter((task) => allowedTasks.has(task)) : model.tasks
}))
};
}
async function discoverIdentityModels(fetchImpl, profile, cache) {
const url = modelsEndpoint(profile.endpoint);
const response = await modelRequest(fetchImpl, url, profile, cache);
if (response.notModified) return response;
const list = requiredArrayFrom(response.payload, `${profile.id} 返回了当前版本尚未适配的模型列表结构`, "data", "models");
return {
models: list.map((item) => {
const architecture = item?.architecture && typeof item.architecture === "object" ? item.architecture : item;
const inputModalities = normalizeModalities(architecture.input_modalities ?? architecture.inputModalities);
const outputModalities = normalizeModalities(architecture.output_modalities ?? architecture.outputModalities);
const hasDeclaredModalities = inputModalities.length > 0 && outputModalities.length > 0;
const id = clean(item.id ?? item.name).replace(/^models\//, "");
const official = getAiModelCapability(profile.id, id);
return modelDescriptor(item, {
confidence: official || hasDeclaredModalities ? "declared" : "manual_unverified",
tasks: official?.tasks ?? (hasDeclaredModalities ? tasksFromModalities(inputModalities, outputModalities) : []),
inputModalities: official?.inputModalities ?? inputModalities,
outputModalities: official?.outputModalities ?? outputModalities,
supportedParameters: official?.supportedParameters,
supportedResolutions: official?.supportedResolutions,
supportedAspectRatios: official?.supportedAspectRatios,
referenceImages: official?.referenceImages,
concurrencyLimit: official?.concurrencyLimit,
source: official ? "provider_models+official_capabilities" : "provider_models"
});
}),
cache: response.cache,
source: "provider_models"
};
}
async function discoverKimi(fetchImpl, profile, cache) {
const response = await modelRequest(fetchImpl, modelsEndpoint(profile.endpoint), profile, cache);
if (response.notModified) return response;
const list = requiredArrayFrom(response.payload, "Kimi 返回了当前版本尚未适配的模型列表结构", "data", "models");
return {
models: list.map((item) => {
const inputModalities = [
"text",
...(item.supports_image_in === true ? ["image"] : []),
...(item.supports_video_in === true ? ["video"] : [])
];
return modelDescriptor(item, {
confidence: "declared",
tasks: tasksFromModalities(inputModalities, ["text"]),
inputModalities,
outputModalities: ["text"],
source: "kimi_models"
});
}),
cache: response.cache,
source: "kimi_models"
};
}
async function discoverConfiguredVideo(_fetchImpl, profile) {
return {
models: configuredProtocolModels(profile, ["videoGeneration"]),
cache: {},
source: "configured_protocol"
};
}
async function discoverXai(fetchImpl, profile, cache) {
const base = apiBase(profile.endpoint, "/v1");
const definitions = [
["language-models", "language_models"],
["image-generation-models", "image_generation_models"],
["video-generation-models", "video_generation_models"]
];
const responses = [];
for (const [path, source] of definitions) {
const response = await modelRequest(fetchImpl, `${base}/${path}`, profile, path === "language-models" ? cache : {});
if (response.notModified) return response;
responses.push({ ...response, source });
}
return {
models: responses.flatMap(({ payload, source }) => requiredArrayFrom(payload, "xAI 返回了当前版本尚未适配的模型列表结构", "models", "data").map((item) =>
declaredModel(item, { source })
)),
cache: responses[0]?.cache ?? {},
source: "xai_model_catalogs"
};
}
async function discoverOpenRouter(fetchImpl, profile, cache) {
const base = apiBase(profile.endpoint, "/api/v1");
const general = await modelRequest(fetchImpl, `${base}/models?output_modalities=all`, profile, cache);
if (general.notModified) return general;
const image = await modelRequest(fetchImpl, `${base}/images/models`, profile, {});
const video = await modelRequest(fetchImpl, `${base}/videos/models`, profile, {});
const generalModels = requiredArrayFrom(general.payload, "OpenRouter 返回了当前版本尚未适配的模型列表结构", "data", "models").map((item) =>
declaredModel(item, { source: "openrouter_models" })
);
const videoModels = requiredArrayFrom(video.payload, "OpenRouter 视频模型结构暂未适配", "data", "models").map((item) =>
declaredModel({
...item,
architecture: item.architecture ?? { input_modalities: ["text", "image"], output_modalities: ["video"] }
}, { source: "openrouter_video_models", forceTasks: ["videoGeneration"] })
);
const imageModels = requiredArrayFrom(image.payload, "OpenRouter 图片模型结构暂未适配", "data", "models").map((item) =>
declaredModel({
...item,
architecture: item.architecture ?? { input_modalities: ["text"], output_modalities: ["image"] }
}, { source: "openrouter_image_models", forceTasks: ["imageGeneration"] })
);
return {
models: mergeModels(generalModels, imageModels, videoModels),
cache: general.cache,
source: "openrouter_catalogs"
};
}
async function discoverGemini(fetchImpl, profile, cache) {
const base = apiBase(profile.endpoint, "");
const url = `${base.replace(/\/$/, "")}/v1beta/models`;
const response = await modelRequest(fetchImpl, url, profile, cache,
profile.apiKey ? { "x-goog-api-key": profile.apiKey } : {});
if (response.notModified) return response;
return {
models: requiredArrayFrom(response.payload, "Gemini 返回了当前版本尚未适配的模型列表结构", "models", "data").map((item) => {
const methods = stringArray(item.supportedGenerationMethods ?? item.supported_generation_methods);
const tasks = methods.includes("generateContent") ? [...TEXT_TASKS] : [];
if (methods.includes("predictLongRunning")) tasks.push("videoGeneration");
const id = clean(item.id ?? item.name).replace(/^models\//, "");
const officialCapability = getAiModelCapability("gemini", id);
if (officialCapability) tasks.push(...officialCapability.tasks);
return modelDescriptor(item, {
confidence: "declared",
tasks,
inputModalities: officialCapability?.inputModalities,
outputModalities: officialCapability?.outputModalities,
source: officialCapability ? "gemini_models+google_official_capabilities" : "gemini_models",
supportedMethods: methods,
supportedParameters: officialCapability?.supportedParameters,
parameterDescriptors: officialCapability?.parameterDescriptors,
supportedResolutions: officialCapability?.supportedResolutions,
supportedAspectRatios: officialCapability?.supportedAspectRatios,
referenceImages: officialCapability?.referenceImages
});
}),
cache: response.cache,
source: "gemini_models"
};
}
function declaredModel(item, options = {}) {
const architecture = item?.architecture && typeof item.architecture === "object" ? item.architecture : item;
const inputModalities = normalizeModalities(architecture.input_modalities ?? architecture.inputModalities);
const outputModalities = normalizeModalities(architecture.output_modalities ?? architecture.outputModalities);
const tasks = options.forceTasks ?? tasksFromModalities(inputModalities, outputModalities);
return modelDescriptor(item, {
confidence: "declared",
tasks,
inputModalities,
outputModalities,
source: options.source
});
}
function modelDescriptor(item = {}, options = {}) {
const id = clean(item.id ?? item.name).replace(/^models\//, "");
const parameterDescriptors = item.supported_parameters && !Array.isArray(item.supported_parameters) && typeof item.supported_parameters === "object"
? structuredClone(item.supported_parameters)
: null;
const descriptor = {
id,
name: clean(item.displayName ?? item.display_name ?? item.name ?? item.id) || id,
status: clean(options.status ?? item.status) || "available",
confidence: options.confidence ?? "manual_unverified",
source: options.source ?? "unknown",
tasks: uniqueTaskIds(options.tasks),
inputModalities: normalizeModalities(options.inputModalities),
outputModalities: normalizeModalities(options.outputModalities),
supportedParameters: options.supportedParameters ?? (parameterDescriptors
? Object.keys(parameterDescriptors)
: stringArray(item.supported_parameters ?? item.supportedParameters ?? item.allowed_passthrough_parameters)),
parameterDescriptors: options.parameterDescriptors ?? parameterDescriptors,
supportedMethods: stringArray(options.supportedMethods),
contextLength: positiveNumber(options.contextLength ?? item.context_length ?? item.contextLength),
pricing: cloneObject(item.pricing ?? item.pricing_skus),
supportedResolutions: options.supportedResolutions ?? stringArray(item.supported_resolutions ?? item.supportedResolutions ?? parameterDescriptors?.resolution?.values),
supportedAspectRatios: options.supportedAspectRatios ?? stringArray(item.supported_aspect_ratios ?? item.supportedAspectRatios ?? parameterDescriptors?.aspect_ratio?.values),
referenceImages: options.referenceImages ? structuredClone(options.referenceImages) : undefined,
concurrencyLimit: options.concurrencyLimit ? structuredClone(options.concurrencyLimit) : undefined
};
return descriptor;
}
function configuredModels(profile) {
const byId = new Map();
for (const task of ALL_TASKS) {
const id = clean(profile.models?.[task]);
if (!id) continue;
const current = byId.get(id) ?? modelDescriptor({ id }, {
confidence: "manual_unverified",
tasks: [],
source: "user_configuration"
});
current.configuredTasks = uniqueTaskIds([...(current.configuredTasks ?? []), task]);
byId.set(id, current);
}
return [...byId.values()];
}
function configuredProtocolModels(profile, tasks) {
const ids = [...new Set(tasks.map((task) => clean(profile.models?.[task])).filter(Boolean))];
return ids.map((id) => modelDescriptor({ id }, {
confidence: "protocol_inferred",
tasks,
inputModalities: ["text", "image"],
outputModalities: ["video"],
source: "configured_protocol"
}));
}
function mergeModels(...collections) {
const merged = new Map();
for (const collection of collections.flat()) {
if (!collection?.id) continue;
const before = merged.get(collection.id);
if (!before) {
merged.set(collection.id, structuredClone(collection));
continue;
}
const collectionHasStrongerMetadata = confidenceRank(collection.confidence) >= confidenceRank(before.confidence);
const metadataPrimary = collectionHasStrongerMetadata ? collection : before;
const metadataSecondary = collectionHasStrongerMetadata ? before : collection;
const trustedModels = [before, collection].filter((item) => item.confidence !== "manual_unverified");
merged.set(collection.id, {
...before,
...collection,
status: mergedModelStatus(before, collection),
confidence: strongerConfidence(before.confidence, collection.confidence),
source: mergedModelSource(before, collection),
name: metadataPrimary.name || metadataSecondary.name,
tasks: uniqueTaskIds([...(before.tasks ?? []), ...(collection.tasks ?? [])]),
configuredTasks: uniqueTaskIds([...(before.configuredTasks ?? []), ...(collection.configuredTasks ?? [])]),
inputModalities: uniqueStrings([...(before.inputModalities ?? []), ...(collection.inputModalities ?? [])]),
outputModalities: uniqueStrings([...(before.outputModalities ?? []), ...(collection.outputModalities ?? [])]),
supportedParameters: uniqueStrings([...(before.supportedParameters ?? []), ...(collection.supportedParameters ?? [])]),
parameterDescriptors: cloneObject(metadataPrimary.parameterDescriptors ?? metadataSecondary.parameterDescriptors),
supportedMethods: uniqueStrings(trustedModels.flatMap((item) => item.supportedMethods ?? [])),
supportedResolutions: uniqueStrings([...(before.supportedResolutions ?? []), ...(collection.supportedResolutions ?? [])]),
supportedAspectRatios: uniqueStrings([...(before.supportedAspectRatios ?? []), ...(collection.supportedAspectRatios ?? [])]),
referenceImages: cloneObject(metadataPrimary.referenceImages ?? metadataSecondary.referenceImages),
contextLength: metadataPrimary.contextLength ?? metadataSecondary.contextLength,
pricing: metadataPrimary.pricing ?? metadataSecondary.pricing
});
}
return [...merged.values()];
}
function mergedModelStatus(before, collection) {
const providerVisible = [before, collection].some((item) =>
item.status === "available" && item.source?.includes("provider_models")
);
return providerVisible ? "available" : collection.status ?? before.status;
}
function mergedModelSource(before, collection) {
const sources = [before.source, collection.source].filter(Boolean);
if (sources.some((source) => source.includes("provider_models")) && sources.includes("official_capabilities")) {
return "provider_models+official_capabilities";
}
return collection.confidence === "manual_unverified" && before.confidence !== "manual_unverified"
? before.source
: collection.source;
}
function strongerConfidence(left, right) {
return confidenceRank(right) > confidenceRank(left) ? right : left;
}
function confidenceRank(value) {
return ({ manual_unverified: 0, protocol_inferred: 1, declared: 2 })[value] ?? 0;
}
async function modelRequest(fetchImpl, url, profile, cache = {}, extraHeaders = {}) {
validateRemoteUrl(url);
const headers = { Accept: "application/json", ...extraHeaders };
if (profile.apiKey && !headers.Authorization && !headers["x-goog-api-key"]) headers.Authorization = `Bearer ${profile.apiKey}`;
if (cache.etag) headers["If-None-Match"] = cache.etag;
const response = await fetchImpl(url, { method: "GET", headers });
if (response.status === 304) return { notModified: true };
if (!response.ok) {
throw new Error(redactCredential(await providerError(response, `${profile.id} 模型列表读取失败`), profile.apiKey));
}
return {
payload: await response.json(),
cache: {
etag: response.headers.get("etag") || "",
cacheControl: response.headers.get("cache-control") || ""
}
};
}
function modelsEndpoint(endpoint) {
const url = validatedUrl(endpoint);
const path = url.pathname.replace(/\/$/, "");
if (/\/(chat\/completions|responses|images\/generations)$/.test(path)) {
const prefix = path.replace(/\/(chat\/completions|responses|images\/generations)$/, "");
url.pathname = `${prefix || ""}/models`;
} else if (!path.endsWith("/models")) {
url.pathname = `${path}/models`.replace(/\/+/g, "/");
}
url.search = "";
return url.toString();
}
function apiBase(endpoint, expectedSuffix) {
const url = validatedUrl(endpoint);
let path = url.pathname.replace(/\/$/, "");
path = path.replace(/\/(chat\/completions|responses|models)$/, "");
if (expectedSuffix && !path.endsWith(expectedSuffix)) path = `${path}${expectedSuffix}`;
url.pathname = path;
url.search = "";
return url.toString().replace(/\/$/, "");
}
function tasksFromModalities(inputModalities, outputModalities) {
const tasks = [];
if (inputModalities.includes("text") && outputModalities.includes("text")) tasks.push(...TEXT_TASKS);
if (inputModalities.includes("image") && outputModalities.includes("text")) tasks.push("imageAnalysis");
if (inputModalities.includes("video") && outputModalities.includes("text")) tasks.push("videoAnalysis");
if (outputModalities.includes("image")) tasks.push("imageGeneration");
if (outputModalities.includes("video")) tasks.push("videoGeneration");
return uniqueTaskIds(tasks);
}
async function executeTask(fetchImpl, providerProfiles, task, request = {}, requestOptions = {}) {
ensureTask(task, ["textTags", "skillExtraction", "creativePlanning", "imageAnalysis", "videoAnalysis"]);
if (typeof request.adapter?.execute === "function") return request.adapter.execute(task, request);
const profile = rememberProvider(providerProfiles, request.provider);
if (!["chat_completions", "openrouter", "xai"].includes(profile.protocol)) throw new Error("该服务的同步执行协议尚未适配");
const endpoint = profile.protocol === "openrouter"
? `${apiBase(profile.endpoint, "/api/v1")}/chat/completions`
: chatCompletionsEndpoint(profile.endpoint);
const payload = await authorizedJsonRequest(fetchImpl, endpoint, profile.apiKey, "POST", request.body ?? {
model: clean(request.model), messages: request.messages
}, {}, requestOptions);
return { providerId: profile.id, model: payload.model || request.model, payload };
}
async function submitTask(fetchImpl, providerProfiles, task, request = {}, requestOptions = {}) {
ensureTask(task, ["imageGeneration", "videoGeneration"]);
if (typeof request.adapter?.submit === "function") return request.adapter.submit(task, request);
if (task !== "videoGeneration") throw new Error("该服务的异步提交协议尚未适配");
const profile = rememberProvider(providerProfiles, request.provider);
const model = required(request.model, "视频生成缺少模型");
const prompt = required(request.prompt, "视频生成缺少提示词");
let endpoint;
let body;
if (profile.protocol === "minimax_videos") {
endpoint = `${apiBase(profile.endpoint, "/v1")}/video_generation`;
body = compactObject({
model, prompt, duration: request.parameters?.duration, resolution: request.parameters?.resolution,
first_frame_image: frameUrl(request.images, "firstFrame"), last_frame_image: frameUrl(request.images, "lastFrame")
});
} else if (profile.protocol === "ark_videos") {
endpoint = `${apiBase(profile.endpoint, "/api/v3")}/contents/generations/tasks`;
body = { model, content: [{ type: "text", text: prompt }, ...referenceContents(request.images)] };
} else if (["xai", "xai_videos"].includes(profile.protocol)) {
endpoint = `${apiBase(profile.endpoint, "/v1")}/videos/generations`;
body = { model, prompt };
} else if (profile.protocol === "gemini") {
endpoint = `${apiBase(profile.endpoint, "")}/v1beta/models/${encodeURIComponent(model)}:predictLongRunning`;
body = { instances: [{ prompt }], ...(request.parameters ? { parameters: request.parameters } : {}) };
} else if (profile.protocol === "openrouter") {
endpoint = `${apiBase(profile.endpoint, "/api/v1")}/videos`;
body = compactObject({
model,
prompt,
duration: request.parameters?.duration,
resolution: request.parameters?.resolution,
aspect_ratio: request.parameters?.aspectRatio,
size: request.parameters?.size,
frame_images: openRouterFrameImages(request.images)
});
} else {
throw new Error("该视频服务的提交协议尚未适配");
}
const extraHeaders = profile.protocol === "gemini" ? { "x-goog-api-key": profile.apiKey } : {};
const payload = await authorizedJsonRequest(fetchImpl, endpoint, profile.apiKey, "POST", body, extraHeaders, requestOptions);
const remoteId = clean(payload.task_id ?? payload.id ?? payload.request_id ?? payload.name);
if (!remoteId) throw new Error("视频服务没有返回任务编号");
return {
providerId: profile.id, protocol: profile.protocol, remoteId, requestModel: model,
status: "submitted", submittedAt: new Date().toISOString(),
pollUrl: safeOptionalUrl(payload.polling_url ?? payload.poll_url ?? payload.status_url)
};
}
async function pollJob(fetchImpl, providerProfiles, job = {}, requestOptions = {}) {
if (typeof job.adapter?.poll === "function") return job.adapter.poll(job);
const profile = providerProfiles.get(clean(job.providerId));
if (!profile) throw new Error("恢复任务前需要重新载入对应厂商配置");
const remoteId = required(job.remoteId, "任务缺少远端编号");
let endpoint;
if (job.protocol === "minimax_videos") endpoint = `${apiBase(profile.endpoint, "/v1")}/query/video_generation?task_id=${encodeURIComponent(remoteId)}`;
else if (job.protocol === "ark_videos") endpoint = `${apiBase(profile.endpoint, "/api/v3")}/contents/generations/tasks/${encodeURIComponent(remoteId)}`;
else if (["xai", "xai_videos"].includes(job.protocol)) endpoint = `${apiBase(profile.endpoint, "/v1")}/videos/${encodeURIComponent(remoteId)}`;
else if (job.protocol === "gemini") endpoint = `${apiBase(profile.endpoint, "")}/v1beta/${remoteId.replace(/^\//, "")}`;
else if (job.protocol === "openrouter" && job.pollUrl) endpoint = job.pollUrl;
else if (job.protocol === "openrouter") endpoint = `${apiBase(profile.endpoint, "/api/v1")}/videos/${encodeURIComponent(remoteId)}`;
else throw new Error("该任务的轮询协议尚未适配");
if (!sameOrigin(endpoint, profile.endpoint)) throw new Error("任务轮询地址与已授权厂商来源不一致");
const extraHeaders = job.protocol === "gemini" ? { "x-goog-api-key": profile.apiKey } : {};
const payload = await authorizedJsonRequest(fetchImpl, endpoint, profile.apiKey, "GET", null, extraHeaders, requestOptions);
return normalizePolledJob(job, payload, profile.apiKey);
}
async function downloadJob(fetchImpl, providerProfiles, job = {}, requestOptions = {}) {
if (typeof job.adapter?.download === "function") return job.adapter.download(job);
const profile = providerProfiles.get(clean(job.providerId));
if (!profile) throw new Error("下载任务前需要重新载入对应厂商配置");
let downloadUrl = safeOptionalUrl(job.downloadUrl);
if (!downloadUrl && job.protocol === "minimax_videos" && job.fileId) {
const endpoint = `${apiBase(profile.endpoint, "/v1")}/files/retrieve?file_id=${encodeURIComponent(job.fileId)}`;
const payload = await authorizedJsonRequest(fetchImpl, endpoint, profile.apiKey, "GET", null, {}, requestOptions);
downloadUrl = safeOptionalUrl(payload?.file?.download_url);
}
if (!downloadUrl) throw new Error("视频任务还没有可下载的结果地址");
const headers = {};
const gemini = job.protocol === "gemini";
let requestUrl = downloadUrl;
if (sameOrigin(downloadUrl, profile.endpoint) && profile.apiKey) {
// Gemini file downloads redirect to a storage host. Fetch keeps custom headers across
// redirects, so the key travels in the Gemini URL query, which the redirect target replaces.
if (gemini) {
const keyed = new URL(downloadUrl);
keyed.searchParams.set("key", profile.apiKey);
requestUrl = keyed.href;
} else headers.Authorization = `Bearer ${profile.apiKey}`;
}
const control = createRequestControl(requestOptions);
try {
const response = await fetchImpl(requestUrl, {
method: "GET",
headers,
credentials: "omit",
redirect: gemini ? "follow" : "error",
referrerPolicy: "no-referrer",
cache: "no-store",
signal: control.signal
});
if (!response.ok) throw new Error(`视频下载失败(HTTP ${response.status})`);
const blob = await boundedMediaBlobFromResponse(response, { kind: "video", controller: control.controller });
return { ...job, downloadUrl, blob };
} finally {
control.cleanup();
}
}
async function resumeJob(fetchImpl, providerProfiles, job = {}, requestOptions = {}) {
if (typeof job.adapter?.resume === "function") return job.adapter.resume(job);
return pollJob(fetchImpl, providerProfiles, job, requestOptions);
}
function rememberProvider(providerProfiles, value) {
const profile = normalizeProfile(value);
providerProfiles.set(profile.id, profile);
return profile;
}
function normalizePolledJob(job, payload, apiKey = "") {
const raw = clean(payload.status ?? (payload.done === true ? "completed" : "pending")).toLowerCase();
const failed = ["fail", "failed", "expired", "cancelled", "canceled"].includes(raw) || Boolean(payload.error);
const completed = ["success", "succeeded", "done", "completed"].includes(raw) || payload.done === true;
if (failed) {
const message = clean(payload.error_message ?? payload.error?.message) || "视频生成失败";
throw new Error(redactCredential(message, apiKey));
}
return {
...job,
status: completed ? "completed" : "running",
fileId: clean(payload.file_id ?? job.fileId),
downloadUrl: safeOptionalUrl(payload?.unsigned_urls?.[0] ?? payload?.content?.video_url ?? payload?.video?.url ?? payload?.response?.generateVideoResponse?.generatedSamples?.[0]?.video?.uri ?? payload?.response?.generatedVideos?.[0]?.video?.uri ?? job.downloadUrl),
providerPayload: payload && typeof payload === "object" ? structuredClone(payload) : {}
};
}
function ensureTask(task, allowed) {
if (!allowed.includes(task)) throw new Error("任务类型与执行方式不匹配");
}
async function authorizedJsonRequest(fetchImpl, url, apiKey, method, body = null, extraHeaders = {}, requestOptions = {}) {
validateRemoteUrl(url);
const headers = { Accept: "application/json", ...extraHeaders };
if (apiKey && !headers["x-goog-api-key"]) headers.Authorization = `Bearer ${apiKey}`;
if (body !== null) headers["Content-Type"] = "application/json";
const control = createRequestControl(requestOptions);
try {
const response = await fetchImpl(url, {
method,
headers,
...(body !== null ? { body: JSON.stringify(body) } : {}),
credentials: "omit",
redirect: "error",
referrerPolicy: "no-referrer",
signal: control.signal
});
if (!response.ok) {
throw new Error(redactCredential(await providerError(response, "AI 服务请求失败"), apiKey));
}
return await response.json();
} finally {
control.cleanup();
}
}
function createRequestControl(options = {}) {
const controller = new AbortController();
const abort = () => controller.abort(options.signal?.reason);
if (options.signal?.aborted) abort();
else options.signal?.addEventListener?.("abort", abort, { once: true });
const timeoutMs = Number(options.timeoutMs);
const timeout = Number.isSafeInteger(timeoutMs) && timeoutMs > 0
? setTimeout(() => controller.abort(), timeoutMs)
: 0;
return {
controller,
signal: controller.signal,
cleanup() {
if (timeout) clearTimeout(timeout);
options.signal?.removeEventListener?.("abort", abort);
}
};
}
function sameOrigin(left, right) {
return validatedUrl(left).origin === validatedUrl(right).origin;
}
function redactCredential(message, credential) {
const secret = clean(credential);
return secret ? String(message).split(secret).join("已隐藏凭据") : String(message);
}
function chatCompletionsEndpoint(endpoint) {
const url = validatedUrl(endpoint);
if (!url.pathname.endsWith("/chat/completions")) url.pathname = `${url.pathname.replace(/\/$/, "")}/chat/completions`;
return url.toString();
}
function frameUrl(images, role) {
return clean((Array.isArray(images) ? images : []).find((image) => image?.role === role)?.url);
}
function referenceContents(images) {
return (Array.isArray(images) ? images : []).flatMap((image) => {
const url = clean(image?.url);
return url ? [{ type: "image_url", image_url: { url } }] : [];
});
}
function openRouterFrameImages(images) {
const values = (Array.isArray(images) ? images : []).flatMap((image) => {
const url = clean(image?.url);
if (!url) return [];
return [{
type: "image_url",
image_url: { url },
frame_type: image?.role === "lastFrame" ? "last_frame" : "first_frame"
}];
});
return values.length ? values : undefined;
}
function compactObject(value) {
return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined && item !== null && item !== ""));
}
function safeOptionalUrl(value) {
const text = clean(value);
if (!text) return "";
validateRemoteUrl(text);
return text;
}
function required(value, message) {
const text = clean(value);
if (!text) throw new Error(message);
return text;
}
function normalizeProfile(value = {}) {
const id = clean(value.id);
if (!id) throw new Error("缺少 AI 厂商标识");
const endpoint = clean(value.endpoint);
if (!endpoint) throw new Error("缺少 AI 厂商接口地址");
return {
id,
endpoint,
apiKey: clean(value.apiKey),
protocol: clean(value.protocol) || "native",
models: value.models && typeof value.models === "object" ? structuredClone(value.models) : {},
discoveredModels: Array.isArray(value.discoveredModels) ? structuredClone(value.discoveredModels) : [],
discovery: value.discovery && typeof value.discovery === "object" ? structuredClone(value.discovery) : {}
};
}
function validatedUrl(value) {
const url = new URL(value);
validateRemoteUrl(url.toString());
return url;
}
function validateRemoteUrl(value) {
const url = new URL(value);
const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
if (url.protocol !== "https:" && !(loopback && url.protocol === "http:")) throw new Error("模型接口必须使用 HTTPS");
if (url.username || url.password) throw new Error("模型接口地址不能包含账号或密码");
}
async function providerError(response, fallback) {
try {
const payload = await response.json();
return clean(payload?.error?.message ?? payload?.message) || `${fallback}(HTTP ${response.status})`;
} catch {
return `${fallback}(HTTP ${response.status})`;
}
}
function arrayFrom(value, ...keys) {
for (const key of keys) if (Array.isArray(value?.[key])) return value[key];
return [];
}
function requiredArrayFrom(value, message, ...keys) {
for (const key of keys) if (Array.isArray(value?.[key])) return value[key];
throw new Error(message);
}
function normalizeModalities(value) {
return uniqueStrings(stringArray(value).map((item) => item.toLowerCase().replace(/^modalit(y|ies)_/, "")));
}
function stringArray(value) {
return Array.isArray(value) ? uniqueStrings(value.map(clean).filter(Boolean)) : [];
}
function uniqueStrings(value) {
return [...new Set(value.map(clean).filter(Boolean))];
}
function uniqueTaskIds(value) {
const set = new Set(value);
return ALL_TASKS.filter((task) => set.has(task));
}
function positiveNumber(value) {
const number = Number(value);
return Number.isFinite(number) && number > 0 ? number : null;
}
function cloneObject(value) {
return value && typeof value === "object" ? structuredClone(value) : null;
}
function clean(value) {
return String(value ?? "").trim();
}