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 { applyComposerConversation } from './composer-conversation.js';
import { runComposerToolLoop } from "./composer-tool-loop.js";
import { readEventStream } from "./event-stream.js";
import {
DEEPSEEK_ENDPOINT,
deepSeekErrorDetails,
executeAgentTurn as executeDeepSeekTurn,
normalizeAiSettings,
planComposerTurn as planDeepSeekTurn
} from "./deepseek.js";
import {
normalizeComposerAiProfile,
normalizeComposerSettings,
normalizePlannerResult,
plannerRequestPayload,
validateGeneratedPrompt
} from "./composer.js";
import {
compileAgentAutoExecutionPrompt,
compileAgentExecutionPrompt,
compileAgentPlanningPrompt
} from "./composer-agent.js";
import { composerAutoResponseProtocolFacts, createComposerAutoResponseProjector } from "./composer-auto-response.js";
import { normalizeVisionSettings, OPENAI_RESPONSES_ENDPOINT, OPENAI_VIDEOS_ENDPOINT } from "./vision.js";
import { LIBRARY_TRANSFER_LIMITS } from "./resource-limits.js";
import { boundedMediaBlobFromResponse, fetchBoundedMedia } from "./bounded-media.js";
import { createAiProviderModule } from "./ai-provider-module.js";
import { getAiModelCapability } from "./ai-model-capabilities.js";
import { availableAiModelChoicesForTask } from "./ai-provider-registry.js";
import {
compatibleImageSizesFor,
compatibleProviderPresetForEndpoint
} from "./compatible-provider-presets.js";
const REQUEST_TIMEOUT_MS = 120_000;
const IMAGE_REQUEST_TIMEOUT_MS = 240_000;
const OPENAI_FILES_ENDPOINT = "https://api.openai.com/v1/files";
const XAI_CHAT_ENDPOINT = "https://api.x.ai/v1/chat/completions";
const XAI_IMAGE_GENERATIONS_ENDPOINT = "https://api.x.ai/v1/images/generations";
const XAI_VIDEOS_ENDPOINT = "https://api.x.ai/v1/videos";
const RESPONSES_IMAGE_SIZES = Object.freeze([
{ value: "auto", label: "自动", aspectRatio: "auto", resolution: "auto" },
{ value: "1024x1024", label: "方形 · 1024×1024", aspectRatio: "1:1", resolution: "1024x1024" },
{ value: "1536x1024", label: "横向 · 1536×1024", aspectRatio: "3:2", resolution: "1536x1024" },
{ value: "1024x1536", label: "纵向 · 1024×1536", aspectRatio: "2:3", resolution: "1024x1536" }
]);
const RESPONSES_IMAGE_QUALITIES = Object.freeze([
{ value: "auto", label: "自动" },
{ value: "low", label: "低" },
{ value: "medium", label: "中" },
{ value: "high", label: "高" }
]);
export class ComposerServiceError extends Error {
constructor(message, status = 0, options = {}) {
super(message, options);
this.name = "ComposerServiceError";
this.status = Number(status) || 0;
this.kind = options.kind || serviceErrorKind(this.status);
this.retryable = options.retryable ?? [0, 408, 429, 500, 502, 503, 504].includes(this.status);
this.referenceLimit = normalizeReferenceLimit(options.referenceLimit);
}
}
export function composerServiceErrorDetails(error) {
if (error?.code === 'RESOURCE_BUDGET_REACHED') return {
kind: 'budget', message: error.message, retryable: Boolean(error.checkpoint && !error.checkpoint.uncertainCallId), actualStages: []
};
if (error?.name === "AbortError") {
return {
kind: "stopped",
message: "已停止,本次不完整输出没有保存",
retryable: false,
actualStages: Array.isArray(error.actualStages) ? error.actualStages : []
};
}
if (error instanceof ComposerServiceError) {
return {
kind: error.kind,
message: error.message,
retryable: error.retryable,
referenceLimit: error.referenceLimit,
actualStages: Array.isArray(error.actualStages) ? error.actualStages : []
};
}
return { ...deepSeekErrorDetails(error), actualStages: Array.isArray(error?.actualStages) ? error.actualStages : [] };
}
export function composerServiceCatalog(aiSettingsValue = {}, visionSettingsValue = {}) {
const ai = normalizeAiSettings(aiSettingsValue);
const vision = normalizeVisionSettings(visionSettingsValue);
const compatibleLabel = serviceLabelForEndpoint(vision.compatible.endpoint);
const xai = normalizeXaiComposerSettings(visionSettingsValue?.xai);
const deepseekProfile = { ...visionSettingsValue?.providerProfiles?.deepseek, id: "deepseek" };
const deepseekModels = [...new Set([
"deepseek-flash", "deepseek-v4-pro", deepseekProfile?.models?.creativePlanning
].map((value) => String(value ?? "").trim()).filter(Boolean))];
const catalog = [
...deepseekModels.map((model) => ({
serviceId: "deepseek",
model,
label: model === "deepseek-flash" ? "DeepSeek Flash"
: model === "deepseek-v4-pro" ? "DeepSeek Pro" : `DeepSeek · ${model}`,
shortLabel: model === "deepseek-flash" ? "Flash" : model === "deepseek-v4-pro" ? "Pro" : "DeepSeek",
configured: Boolean(ai.apiKey && ai.consent),
vision: providerModelSupports(deepseekProfile, model, "imageAnalysis"),
planning: model === deepseekProfile?.models?.creativePlanning || providerModelSupports(deepseekProfile, model, "creativePlanning"),
reasoning: model === deepseekProfile?.models?.creativePlanning || providerModelSupports(deepseekProfile, model, "creativePlanning"),
imageGeneration: false,
videoGeneration: false
})),
{
serviceId: "openai",
model: vision.openai.model,
label: `OpenAI · ${vision.openai.model || "未选择模型"}`,
shortLabel: "OpenAI",
configured: Boolean(vision.openai.apiKey && vision.consent && vision.openai.model),
vision: true,
planning: true,
reasoning: true,
imageGeneration: Boolean(vision.openai.apiKey && vision.consent && vision.openai.model),
videoGeneration: openAiVideoConfigured(vision)
},
{
serviceId: "compatible",
model: vision.compatible.model,
label: `${compatibleLabel} · ${vision.compatible.model || "未选择模型"}`,
shortLabel: compatibleLabel,
configured: compatibleConfigured(vision),
vision: true,
planning: true,
reasoning: compatibleReasoningSupported(vision.compatible),
imageGeneration: compatibleImageConfigured(vision.compatible),
videoGeneration: false
},
{
serviceId: "xai",
model: xai.textModel,
label: `xAI · ${xai.textModel || "未选择模型"}`,
shortLabel: "xAI",
configured: Boolean(xai.mediaConsent && xai.apiKey && xai.textModel),
vision: true,
planning: true,
reasoning: false,
imageGeneration: Boolean(xai.mediaConsent && xai.apiKey && xai.textModel && xai.imageModel),
videoGeneration: Boolean(xai.mediaConsent && xai.apiKey && xai.textModel && xai.videoModel)
}
];
const specialProviderIds = new Set(["deepseek", "openai", "xai", "custom-media"]);
for (const profile of Object.values(visionSettingsValue?.providerProfiles ?? {})) {
const providerId = String(profile?.id ?? "").trim();
if (!providerId || specialProviderIds.has(providerId)) continue;
if (!profile.capabilities?.some((taskId) => ["creativePlanning", "imageGeneration", "videoGeneration"].includes(taskId))) continue;
const models = [...new Set([profile.models?.creativePlanning, profile.models?.imageGeneration, profile.models?.videoGeneration]
.map((value) => String(value ?? "").trim()).filter(Boolean))];
for (const model of models.length ? models : [""]) {
catalog.push({
serviceId: providerId,
model,
label: `${profile.label || providerId} · ${model || "未选择模型"}`,
shortLabel: profile.label || providerId,
configured: Boolean(profile.consent && profile.apiKey && model),
vision: providerModelSupports(profile, model, "imageAnalysis"),
planning: model === profile.models?.creativePlanning || providerModelSupports(profile, model, "creativePlanning"),
reasoning: false,
imageGeneration: Boolean(profile.consent && profile.apiKey && providerModelSupports(profile, model, "imageGeneration")),
videoGeneration: Boolean(profile.consent && profile.apiKey && providerModelSupports(profile, model, "videoGeneration"))
});
}
}
for (const choice of availableAiModelChoicesForTask("creativePlanning", {
providers: visionSettingsValue?.providerProfiles ?? {}
})) {
const serviceId = choice.providerId === "custom-media" ? "compatible" : choice.providerId;
const existing = catalog.find((item) => item.serviceId === serviceId && item.model === choice.modelId);
if (existing) {
existing.configured = true;
existing.planning = true;
continue;
}
catalog.push({
serviceId,
model: choice.modelId,
label: `${choice.providerLabel} · ${choice.modelName}`,
shortLabel: choice.providerLabel,
configured: true,
vision: false,
planning: true,
reasoning: false,
imageGeneration: false,
videoGeneration: false
});
}
return catalog.map((item) => {
const providerId = item.serviceId === "compatible" ? "custom-media" : item.serviceId;
const provider = visionSettingsValue?.providerProfiles?.[providerId];
const capability = getAiModelCapability(providerId, item.model)
?? (provider?.discoveredModels ?? []).find((model) => model.id === item.model);
const modalities = capability?.inputModalities ?? [];
const visionInput = modalities.length ? modalities.includes("image")
: capability?.tasks?.includes("imageAnalysis") || item.vision;
return { ...item, vision: Boolean(visionInput), videoInput: modalities.includes("video"),
nativeTools: capability?.supportedParameters?.includes("tools") || ["deepseek", "openai", "zhipu"].includes(providerId) };
});
}
export function composerLibraryToolService(session, aiSettings, visionSettings) {
const generation = normalizeComposerAiProfile(session?.generationAiProfile);
const directImage = session?.outputMode === "create_image" && !composerGenerationRequiresPromptAssembly(generation, visionSettings, session);
const ownVideoPlanner = session?.outputMode === "create_video" && ["openai", "xai"].includes(generation.serviceId);
const service = selectedComposerService(directImage || ownVideoPlanner ? generation : session?.aiProfile, aiSettings, visionSettings);
if (directImage) {
const supportsLocalFunctions = generation.serviceId === "openai"
|| (generation.serviceId === "compatible" && normalizeVisionSettings(visionSettings).compatible.imageGeneration.protocol === "responses_tool");
return { ...service, nativeTools: service.nativeTools && supportsLocalFunctions };
}
return service;
}
export function composerServiceCapabilities(profileValue, visionSettingsValue = {}) {
const profile = normalizeComposerAiProfile(profileValue);
if (profile.serviceId === "unassigned") return { serviceId: "unassigned", model: "", image: null, video: null };
const settings = normalizeVisionSettings(visionSettingsValue);
const xai = normalizeXaiComposerSettings(visionSettingsValue?.xai);
if (profile.serviceId === "deepseek") return { serviceId: "deepseek", model: profile.model, image: null, video: null };
if (profile.serviceId === "openai") {
const configured = Boolean(settings.consent && settings.openai.apiKey && (profile.model || settings.openai.model));
const provider = visionSettingsValue?.providerProfiles?.openai;
const model = profile.model || settings.openai.model;
const references = modelReferenceCapability(provider, model, { supported: true, maxItems: null });
return {
serviceId: "openai",
model,
image: responsesImageCapability(configured, references),
video: openAiVideoCapability(settings)
};
}
if (profile.serviceId === "xai") {
const configured = Boolean(xai.mediaConsent && xai.apiKey && (profile.model || xai.textModel));
const provider = visionSettingsValue?.providerProfiles?.xai;
const references = modelReferenceCapability(provider, xai.imageModel, { supported: false, maxItems: null });
return {
serviceId: "xai",
model: profile.model || xai.textModel,
image: {
generate: configured && Boolean(xai.imageModel),
references,
edit: { whole: false, local: false },
parameters: []
},
video: xaiVideoCapability(configured, xai)
};
}
const registryProvider = visionSettingsValue?.providerProfiles?.[profile.serviceId];
if (registryProvider && !["openai", "xai", "custom-media"].includes(profile.serviceId)) {
const provider = registryProvider;
const model = profile.model;
const descriptor = providerModelDescriptor(provider, model);
const configured = Boolean(provider?.consent && provider?.apiKey && model && descriptor?.tasks?.includes("videoGeneration"));
const image = ["gemini", "openrouter"].includes(profile.serviceId) ? (() => {
const imageModel = profile.model;
const imageDescriptor = providerModelDescriptor(provider, imageModel);
const references = modelReferenceCapability(provider, imageModel, {
supported: imageDescriptor?.inputModalities?.includes("image") === true,
maxItems: null
});
return {
generate: Boolean(provider?.consent && provider?.apiKey && imageModel && imageDescriptor?.tasks?.includes("imageGeneration")),
references,
edit: { whole: imageDescriptor?.inputModalities?.includes("image") === true, local: false },
parameters: profile.serviceId === "gemini" ? providerImageParameters(imageDescriptor) : []
};
})() : null;
return {
serviceId: profile.serviceId,
model,
image,
video: {
generate: configured,
protocol: provider?.protocol,
inputs: {
text: true,
firstFrame: descriptor?.inputModalities?.includes("image") === true,
lastFrame: ["minimax_videos"].includes(provider?.protocol) && descriptor?.inputModalities?.includes("image") === true,
referenceImages: modelReferenceCapability(provider, model, {
supported: descriptor ? descriptor.inputModalities?.includes("image") === true : null,
maxItems: descriptor?.inputModalities?.includes("image") === true
? provider?.protocol === "minimax_videos" ? 2 : 1
: null
}),
referenceVideo: false, edit: false, extend: false, motion: false
},
parameters: providerVideoParameters(descriptor)
}
};
}
const provider = settings.compatible;
const configured = compatibleImageConfigured(provider);
if (provider.imageGeneration.protocol === "responses_tool") {
return {
serviceId: "compatible",
model: profile.model || provider.model,
image: responsesImageCapability(configured),
video: null
};
}
if (provider.imageGeneration.protocol !== "images_generations") {
return { serviceId: "compatible", model: profile.model || provider.model, image: null, video: null };
}
const image = provider.imageGeneration;
const referenceCapability = compatibleImageReferenceCapability(visionSettingsValue, image.model);
const supportedSizes = compatibleImageSizesFor(provider.endpoint, image);
const sizeOptions = supportedSizes.map(imageSizeOption);
const qualityOptions = image.qualities.map((quality) => ({ value: quality, label: quality }));
return {
serviceId: "compatible",
model: image.model || profile.model || provider.model,
image: {
generate: configured && !compatibleImageConfigurationIssue(image, supportedSizes),
references: {
supported: referenceCapability.supported ?? Boolean(image.editsEndpoint),
maxItems: referenceCapability.maxItems,
source: referenceCapability.source
},
edit: { whole: Boolean(image.editsEndpoint), local: Boolean(image.editsEndpoint) },
parameters: [
imageParameter("size", "画幅与分辨率", sizeOptions, image.sizes[0] || supportedSizes[0]),
imageParameter("quality", "质量", qualityOptions, image.qualities[0])
].filter((parameter) => parameter.options.length)
},
video: null
};
}
export function composerVideoAvailability(profileValue, visionSettingsValue = {}, session = {}) {
if (session?.targetType !== "video") return { available: false, message: "视频生成只在视频任务中显示" };
const capability = composerServiceCapabilities(profileValue, visionSettingsValue).video;
if (!capability?.generate) return { available: false, message: "当前服务没有声明可用的视频生成能力" };
const state = normalizeVideoGenerationRequest(profileValue, visionSettingsValue, session.generationParameters);
if (state.issues.length) return { available: false, message: state.issues.join(";") };
const imageCount = referenceImageCount(session);
const references = capability.inputs.referenceImages;
if (imageCount && references.supported === false) {
return { available: false, message: "当前视频模型不接收原图" };
}
if (Number.isInteger(references.maxItems) && imageCount > references.maxItems) {
return { available: false, message: `当前视频服务最多接收 ${references.maxItems} 张首帧参考图` };
}
return { available: true, message: imageCount ? "将首张参考图作为视频起始参考" : "由当前视频服务直接生成并下载到本机临时结果" };
}
export function normalizeVideoGenerationRequest(profileValue, visionSettingsValue = {}, parametersValue = {}) {
const capability = composerServiceCapabilities(profileValue, visionSettingsValue).video;
if (!capability?.generate) return { parameters: {}, ignored: [], issues: ["当前服务未声明可用的视频生成能力"] };
const source = parametersValue && typeof parametersValue === "object" ? parametersValue : {};
const parameters = {};
const issues = [];
for (const field of capability.parameters) {
const requested = String(source[field.key] ?? "").trim();
const selected = requested || field.defaultValue;
if (!selected) continue;
if (!field.options.some((option) => option.value === selected)) {
issues.push(`${field.label}“${selected}”不受当前服务支持`);
continue;
}
parameters[field.key] = selected;
}
const declared = new Set(capability.parameters.map((field) => field.key));
const ignored = Object.entries(source)
.filter(([key, value]) => !declared.has(key) && String(value ?? "").trim())
.map(([key]) => key);
return { parameters, ignored, issues };
}
export function normalizeImageGenerationRequest(profileValue, visionSettingsValue = {}, parametersValue = {}) {
const capability = composerServiceCapabilities(profileValue, visionSettingsValue).image;
if (!capability?.generate) return { parameters: {}, ignored: [], issues: ["当前服务未声明可用的图片生成能力"] };
const source = parametersValue && typeof parametersValue === "object" ? parametersValue : {};
const parameters = {};
const issues = [];
for (const field of capability.parameters) {
const requested = String(source[field.key] ?? "").trim();
const selected = requested || field.defaultValue;
if (!selected) continue;
if (!field.options.some((option) => option.value === selected)) {
issues.push(`${field.label}“${selected}”不受当前服务支持`);
continue;
}
parameters[field.key] = selected;
}
const declared = new Set(capability.parameters.map((field) => field.key));
const ignored = Object.entries(source)
.filter(([key, value]) => !declared.has(key) && String(value ?? "").trim())
.map(([key]) => key);
return { parameters, ignored, issues };
}
export function composerImageAvailability(profileValue, visionSettingsValue = {}, session = {}) {
if (session?.targetType === "video") return { available: false, message: "视频创作只输出提示词" };
const settings = normalizeVisionSettings(visionSettingsValue);
const profile = normalizeComposerAiProfile(profileValue);
const catalog = composerServiceCatalog({}, visionSettingsValue);
const service = catalog.find((item) => item.serviceId === profile.serviceId && item.model === profile.model)
?? catalog.find((item) => item.serviceId === profile.serviceId);
if (!service || service.serviceId === "deepseek") return { available: false, message: "当前服务只输出文字提示词" };
if (service.serviceId === "xai") {
if (!service.imageGeneration) return { available: false, message: "xAI 创建图片还缺少 API Key、文字模型或图片模型" };
if (referenceImageCount(session)) return { available: false, message: "当前 xAI 生图接口未声明参考图输入;请移除图片参考或改用其他服务" };
return { available: true, message: "由 xAI 直接创建图片并保存到本轮结果" };
}
if (service.serviceId === "openrouter") {
const capability = composerServiceCapabilities(profileValue, visionSettingsValue).image;
if (!capability?.generate) return { available: false, message: "OpenRouter 生图还缺少已声明图片输出能力的模型、API Key 或发送授权" };
if (session.imageReferenceMode === "prompt_only") return { available: false, message: "当前 OpenRouter 独立图片接口不能在整理提示词阶段读取原图;请选择带图生成或全程纯文字" };
if (referenceImageCount(session) && session.imageReferenceMode === "conditioned" && capability.references.supported === false) {
return { available: false, message: "所选 OpenRouter 模型未声明参考图输入能力" };
}
return { available: true, message: "由 OpenRouter 独立图片接口生成;不会静默改用其他模型" };
}
if (service.serviceId === "gemini") {
const capability = composerServiceCapabilities(profileValue, visionSettingsValue).image;
if (!capability?.generate) return { available: false, message: "Gemini 生图还缺少已分配的 Nano Banana 模型、API Key 或发送授权" };
const count = referenceImageCount(session);
if (count && session.imageReferenceMode === "conditioned" && capability.references.supported === false) {
return { available: false, message: "所选 Gemini 图片模型未声明参考图输入能力" };
}
if (session.imageReferenceMode === "conditioned" && Number.isInteger(capability.references.maxItems) && count > capability.references.maxItems) {
return { available: false, message: `当前有 ${count} 张参考图,所选 Gemini 模型最多读取 ${capability.references.maxItems} 张,请先减少参考` };
}
return imageParameterAvailability(profileValue, visionSettingsValue, session, "由 Google Gemini 官方 Interactions 接口直接生成;不会静默改用其他模型");
}
if (service.serviceId === "openai") {
const capability = composerServiceCapabilities(profileValue, visionSettingsValue).image;
if (referenceImageCount(session) && session.imageReferenceMode === "conditioned" && capability?.references?.supported === false) {
return { available: false, message: "所选 OpenAI 模型明确不支持原图参考;请选择最终生图不垫图或全程纯文字" };
}
return service.imageGeneration
? imageParameterAvailability(profileValue, visionSettingsValue, session, "由 OpenAI 直接生成并保存到本轮结果")
: { available: false, message: "创建图片还缺少 OpenAI API Key 或模型" };
}
const image = settings.compatible.imageGeneration;
if (image.protocol === "responses_tool") {
return service.imageGeneration
? imageParameterAvailability(profileValue, visionSettingsValue, session, `由 ${service.shortLabel} 直接生成并保存到本轮结果`)
: { available: false, message: "创建图片还缺少兼容服务的接口、模型或 API Key" };
}
const issue = compatibleImageConfigurationIssue(image, compatibleImageSizesFor(settings.compatible.endpoint, image));
if (issue) return { available: false, message: issue };
const count = referenceImageCount(session);
const micu = service.shortLabel === "米醋";
const capability = composerServiceCapabilities(profileValue, visionSettingsValue).image;
if (session.imageReferenceMode === "conditioned" && count && capability?.references?.supported === false) {
return { available: false, message: "当前图片模型明确不接收原图;请选择最终生图不垫图或全程纯文字" };
}
if (session.imageReferenceMode === "conditioned" && Number.isInteger(capability?.references?.maxItems) && count > capability.references.maxItems) {
return { available: false, message: `当前有 ${count} 张参考图,所选模型最多读取 ${capability.references.maxItems} 张,请先减少参考` };
}
if (count && !image.editsEndpoint) return { available: false, message: "带参考图创建还缺少图片编辑接口" };
const requestState = normalizeImageGenerationRequest(profileValue, visionSettingsValue, session?.generationParameters);
if (micu && count && exceedsReferenceImageSize(requestState.parameters.size)) return { available: false, message: "米醋参考图模式最高支持 2K,请调整本轮输出尺寸" };
return imageParameterAvailability(profileValue, visionSettingsValue, session, `由 ${service.shortLabel} 直接生成并保存到本轮结果`);
}
export function composerGenerationRequiresPromptAssembly(profileValue, visionSettingsValue = {}, session = {}) {
if (session?.outputMode === "create_video") return true;
if (session?.outputMode !== "create_image") return false;
const profile = normalizeComposerAiProfile(profileValue);
const settings = normalizeVisionSettings(visionSettingsValue);
const registryProvider = visionSettingsValue?.providerProfiles?.[profile.serviceId];
const protocol = profile.serviceId === "compatible"
? settings.compatible.imageGeneration.protocol
: profile.serviceId === "xai"
? "images_generations"
: profile.serviceId === "openrouter"
? "openrouter_images"
: profile.serviceId === "gemini"
? "gemini_interactions"
: profile.serviceId === "openai"
? "responses_tool"
: String(registryProvider?.imageGeneration?.protocol ?? "");
return session?.imageReferenceMode !== "conditioned"
|| ["images_generations", "openrouter_images"].includes(protocol);
}
function imageParameterAvailability(profileValue, settings, session, message) {
const state = normalizeImageGenerationRequest(profileValue, settings, session?.generationParameters);
return state.issues.length
? { available: false, message: state.issues.join(";") }
: { available: true, message };
}
export function composerImageEditCapabilities(profileValue, visionSettingsValue = {}) {
const profile = normalizeComposerAiProfile(profileValue);
const settings = normalizeVisionSettings(visionSettingsValue);
if (profile.serviceId === "openai") {
const available = Boolean(settings.consent && settings.openai.apiKey && (profile.model || settings.openai.model));
return { whole: available, local: available };
}
if (profile.serviceId === "gemini") {
const capability = composerServiceCapabilities(profile, visionSettingsValue).image;
return { whole: capability?.generate === true && capability.edit?.whole === true, local: false };
}
if (profile.serviceId !== "compatible") return { whole: false, local: false };
const provider = settings.compatible;
const verifiedMicu = serviceLabelForEndpoint(provider.endpoint) === "米醋"
&& provider.imageGeneration.protocol === "images_generations"
&& Boolean(provider.imageGeneration.editsEndpoint && provider.imageGeneration.apiKey && provider.imageGeneration.model);
return { whole: verifiedMicu, local: verifiedMicu };
}
export function selectedComposerService(profileValue, aiSettingsValue, visionSettingsValue) {
const profile = normalizeComposerAiProfile(profileValue);
if (profile.serviceId === "unassigned") {
return {
serviceId: "unassigned",
model: "",
label: "未选择模型",
shortLabel: "未选择模型",
configured: false,
vision: false,
planning: false,
reasoning: false,
imageGeneration: false,
videoGeneration: false
};
}
const catalog = composerServiceCatalog(aiSettingsValue, visionSettingsValue);
return catalog.find((item) => item.serviceId === profile.serviceId && item.model === profile.model)
?? catalog.find((item) => item.serviceId === profile.serviceId)
?? catalog[0];
}
export async function planComposerTurnWithService(input, settingsValue, options = {}) {
const profile = normalizeComposerAiProfile(input.session?.aiProfile);
if (profile.serviceId === "unassigned") {
throw new ComposerServiceError("创作规划未配置,请在 AI 服务的任务路由中选择模型", 422, { retryable: false });
}
if (usesProjectedDeepseekSettings(profile, settingsValue.ai)) return planDeepSeekTurn(input, settingsValue.ai, options);
const service = requireVisualService(profile, settingsValue.vision, "规划");
if (service.planning === false) {
throw new ComposerServiceError(`${service.label} 的所选模型未声明创作规划能力,请重新分配模型`, 422, { retryable: false });
}
const request = plannerRequestPayload(input.session, input.userMessage, input.composerSettings);
const systemInstruction = compileAgentPlanningPrompt({
settings: input.composerSettings,
targetType: request.targetType,
routeMode: request.routeMode,
outputLanguage: request.outputLanguage,
productionReviewEnabled: request.productionReviewEnabled
});
const result = await requestStructured(service, systemInstruction, [{ type: "text", text: JSON.stringify(request) }], {
signal: options.signal,
fetchImpl: options.fetchImpl
});
const latestUserMessage = [...request.messages].reverse().find((item) => item.role === "user")?.content ?? "";
const planned = normalizePlannerResult(parseObject(result.content, "创作服务没有返回有效的 Agent 计划"), {
route: request.routeMode === "auto" ? "compose" : request.routeMode,
instruction: latestUserMessage
});
if (request.routeMode !== "auto" && planned.route !== request.routeMode) {
throw new ComposerServiceError("Agent 改写了用户手动选择的任务,本次规划未采用", 422, { retryable: false });
}
return { ...planned, usage: result.usage, model: result.model, finishReason: result.finishReason };
}
export async function executeComposerTurnWithService(input, settingsValue, preparedImages = [], options = {}) {
const planningProfile = normalizeComposerAiProfile(input.session?.aiProfile);
const toolService = composerLibraryToolService(input.session, settingsValue.ai, settingsValue.vision);
if (!toolService.nativeTools || !options.toolRuntime?.specs.length) options = { ...options, toolRuntime: undefined };
const generationMode = ["create_image", "create_video"].includes(input.session?.outputMode);
if (generationMode && options.toolRuntime) {
const runtime = options.toolRuntime;
options = { ...options, toolRuntime: { ...runtime, execute: async (...args) => {
const result = await runtime.execute(...args);
if (input.session.imageReferenceMode === "conditioned" && result.images?.length) {
for(const image of result.images) {
const index=preparedImages.findIndex(item=>item.visualId===image.visualId);
if(index>=0) preparedImages[index]=image;
}
const additional = result.images.filter(image => !preparedImages.some(item => item.visualId === image.visualId));
preparedImages.push(...additional);
input.session = { ...input.session, referenceSnapshots: [...input.session.referenceSnapshots, ...additional.map(image => ({
entryId: result.data.caseId, alias: `@${image.label}`, title: image.label, referenceKind: "vision", referenceText: "",
imageRefs: [{ visualId: image.visualId }], assetRefs: [], referenceSources: []
}))] };
}
return result;
} } };
}
const executionProfile = generationMode
? normalizeComposerAiProfile(input.session?.generationAiProfile)
: planningProfile;
const selected = selectedComposerService(generationMode && input.session?.imageReferenceMode !== "prompt_only" ? executionProfile : planningProfile, settingsValue.ai, settingsValue.vision);
const sendsOriginals = referenceImageCount(input.session) > 0
|| (input.session?.videoReferenceMode !== "text_only" && (input.session?.referenceSnapshots ?? [])
.some(reference => reference.assetRefs?.some(asset => asset.kind === "video")));
if (!generationMode && !selected.vision && !sendsOriginals && usesProjectedDeepseekSettings(executionProfile, settingsValue.ai)) {
return executeDeepSeekTurn(input, settingsValue.ai, options);
}
const visionRuntime = { ...settingsValue.vision };
if (executionProfile.serviceId === "deepseek" && !visionRuntime.providerProfiles?.deepseek?.id) {
const ai = normalizeAiSettings(settingsValue.ai);
if (ai.activeProvider === "deepseek") visionRuntime.providerProfiles = { ...visionRuntime.providerProfiles, deepseek: {
id: "deepseek", label: "DeepSeek", protocol: "chat_completions", endpoint: DEEPSEEK_ENDPOINT,
apiKey: ai.apiKey, consent: ai.consent
}};
}
const service = requireVisualService(executionProfile, visionRuntime, "创作");
if (input.session?.outputMode === "create_video") {
return generateVideoTurn(input, service, settingsValue, preparedImages, options);
}
if (input.session?.outputMode === "create_image") {
return generateImageTurn(input, service, preparedImages, { ...options, visionSettings: settingsValue.vision, aiSettings: settingsValue.ai });
}
return executeVisualTextTurn(input, service, preparedImages, options);
}
async function generateVideoTurn(input, service, settingsValue, preparedImages, options) {
const visionSettingsValue = settingsValue.vision;
const generationProfile = input.session?.generationAiProfile ?? input.session?.aiProfile;
if (["gemini", "openrouter", "minimax", "volcengine"].includes(service.serviceId)) {
return generateProviderVideoTurn(input, service, settingsValue, preparedImages, options);
}
if (service.serviceId === "xai") {
return generateXaiVideoTurn(input, service, visionSettingsValue, preparedImages, options);
}
const remote = normalizeRemoteVideo(options.remoteVideo, "openai");
const state = remote
? { parameters: remote.requestParameters, issues: [] }
: normalizeVideoGenerationRequest(generationProfile, visionSettingsValue, input.session?.generationParameters);
if (state.issues.length) throw new ComposerServiceError(state.issues.join(";"), 422, { retryable: false });
if (preparedImages.length > 1) throw new ComposerServiceError("当前视频服务最多接收 1 张首帧参考图", 422, { retryable: false });
const settings = normalizeVisionSettings(visionSettingsValue);
if (!settings.openai.apiKey) throw new ComposerServiceError("恢复视频任务还缺少 OpenAI API Key", 422, { retryable: true });
let finalPrompt = remote?.finalPrompt || "";
let remoteId = remote?.remoteId || "";
let promptResult = null;
const userImageCount = preparedImages.length;
if (!remoteId) {
promptResult = await executeVisualTextTurn({
...input,
session: { ...input.session, outputMode: "text_prompt" }
}, service, preparedImages, { ...options, stream: false });
if (promptResult.kind !== "prompt") throw new ComposerServiceError("视频任务没有生成可提交的最终提示词", 422, { retryable: false });
finalPrompt = promptResult.finalPrompt;
const form = new FormData();
form.append("model", settings.openai.videoGeneration.model);
form.append("prompt", finalPrompt);
form.append("size", state.parameters.size);
form.append("seconds", state.parameters.duration);
if (userImageCount && preparedImages[0]?.dataUrl) {
const blob = imageBlobFromDataUrl(preparedImages[0].dataUrl);
form.append("input_reference", blob, `first-frame.${imageExtension(blob.type) || "png"}`);
}
options.onPhase?.("generation");
const payload = await videoJsonRequest(OPENAI_VIDEOS_ENDPOINT, settings.openai.apiKey, "POST", form, options);
remoteId = String(payload?.id ?? "").trim();
if (!remoteId) throw new ComposerServiceError("视频服务没有返回任务编号", 503);
await options.onRemoteVideo?.({ serviceId: "openai", remoteId, finalPrompt, requestParameters: state.parameters });
}
const completed = await pollOpenAiVideo(remoteId, settings.openai.apiKey, options);
options.onPhase?.("downloading");
const blob = await videoBlobRequest(`${OPENAI_VIDEOS_ENDPOINT}/${encodeURIComponent(remoteId)}/content`, settings.openai.apiKey, options);
return {
route: "compose",
kind: "video",
finalPrompt,
videos: [{ blob, remoteId, responseStatus: String(completed.status ?? "completed") }],
outputLanguage: promptResult?.outputLanguage || input.session?.outputLanguage || "auto",
usage: promptResult?.usage || {},
serviceId: "openai",
model: String(completed.model ?? settings.openai.videoGeneration.model),
requestModel: settings.openai.videoGeneration.model,
requestParameters: state.parameters,
finishReason: String(completed.status ?? "completed")
};
}
async function generateXaiVideoTurn(input, service, visionSettingsValue, preparedImages, options) {
const remote = normalizeRemoteVideo(options.remoteVideo, "xai");
const state = remote
? { parameters: remote.requestParameters, issues: [] }
: normalizeVideoGenerationRequest(input.session?.generationAiProfile ?? input.session?.aiProfile, visionSettingsValue, input.session?.generationParameters);
if (state.issues.length) throw new ComposerServiceError(state.issues.join(";"), 422, { retryable: false });
if (preparedImages.length) {
throw new ComposerServiceError("当前已验证的 xAI 视频生成接口未启用首帧参考图,请移除图片参考后再生成", 422, { retryable: false });
}
const xai = normalizeXaiComposerSettings(visionSettingsValue?.xai);
if (!xai.apiKey || !xai.videoModel) {
throw new ComposerServiceError("xAI 视频生成还缺少 API Key 或视频模型", 422, { retryable: false });
}
let finalPrompt = remote?.finalPrompt || "";
let remoteId = remote?.remoteId || "";
let promptResult = null;
if (!remoteId) {
promptResult = await executeVisualTextTurn({
...input,
session: { ...input.session, outputMode: "text_prompt" }
}, service, [], { ...options, stream: false });
if (promptResult.kind !== "prompt") throw new ComposerServiceError("视频任务没有生成可提交的最终提示词", 422, { retryable: false });
finalPrompt = promptResult.finalPrompt;
options.onPhase?.("generation");
const submitted = await videoJsonRequest(`${XAI_VIDEOS_ENDPOINT}/generations`, xai.apiKey, "POST", {
model: xai.videoModel,
prompt: finalPrompt
}, options, "xAI 视频服务");
remoteId = String(submitted?.request_id ?? "").trim();
if (!remoteId) throw new ComposerServiceError("xAI 视频服务没有返回任务编号", 503);
await options.onRemoteVideo?.({ serviceId: "xai", remoteId, finalPrompt, requestParameters: state.parameters });
}
const completed = await pollXaiVideo(remoteId, xai.apiKey, options);
const resultUrl = validateXaiVideoResultUrl(completed?.video?.url);
options.onPhase?.("downloading");
const blob = await videoBlobRequest(resultUrl, "", options, "xAI 视频成品");
return {
route: "compose",
kind: "video",
finalPrompt,
videos: [{ blob, remoteId, responseStatus: String(completed.status ?? "done") }],
outputLanguage: promptResult?.outputLanguage || input.session?.outputLanguage || "auto",
usage: promptResult?.usage || {},
serviceId: "xai",
model: String(completed.model ?? xai.videoModel),
requestModel: xai.videoModel,
requestParameters: state.parameters,
finishReason: String(completed.status ?? "done")
};
}
async function generateProviderVideoTurn(input, service, settingsValue, preparedImages, options) {
const profile = settingsValue.vision?.providerProfiles?.[service.serviceId];
if (!profile?.apiKey || !profile?.consent) {
throw new ComposerServiceError(`${profile?.label || service.serviceId} 还缺少 API Key 或媒体发送授权`, 422, { retryable: false });
}
const generationProfile = input.session?.generationAiProfile ?? input.session?.aiProfile;
const capability = composerServiceCapabilities(generationProfile, settingsValue.vision).video;
const referenceCapability = capability?.inputs?.referenceImages ?? { supported: null, maxItems: null };
if (preparedImages.length && referenceCapability.supported === false) {
throw new ComposerServiceError("当前视频模型不接收原图", 422, { retryable: false });
}
if (Number.isInteger(referenceCapability.maxItems) && preparedImages.length > referenceCapability.maxItems) {
throw new ComposerServiceError(`当前服务最多接收 ${referenceCapability.maxItems} 张参考图`, 422, { retryable: false });
}
const remote = normalizeRemoteVideo(options.remoteVideo, service.serviceId);
const state = remote
? { parameters: remote.requestParameters, issues: [] }
: normalizeVideoGenerationRequest(generationProfile, settingsValue.vision, input.session?.generationParameters);
if (state.issues.length) throw new ComposerServiceError(state.issues.join(";"), 422, { retryable: false });
const module = createAiProviderModule({
fetchImpl: async (...args) => {
const pending = Promise.resolve((options.fetchImpl ?? fetch)(...args));
pending.catch(() => undefined);
await notifyRequestStart(options);
return pending;
},
signal: options.signal,
timeoutMs: REQUEST_TIMEOUT_MS
});
module.configureProvider(profile);
let finalPrompt = remote?.finalPrompt || "";
let job = remote?.job || null;
let promptResult = null;
// Video images are frame slots; only the user's chosen references fill them, never images the planner viewed via tools.
const userImageCount = preparedImages.length;
if (!job) {
promptResult = await assembleImagePrompt(input, preparedImages, {
...options,
stream: false,
visionSettings: settingsValue.vision,
aiSettings: settingsValue.ai
});
if (promptResult.kind !== "prompt") throw new ComposerServiceError("视频任务没有生成可提交的最终提示词", 422, { retryable: false });
finalPrompt = promptResult.finalPrompt;
options.onPhase?.("generation");
job = await module.submit("videoGeneration", {
provider: profile,
model: service.model,
prompt: finalPrompt,
parameters: {
...state.parameters,
...(state.parameters.size && !state.parameters.resolution ? { resolution: state.parameters.size } : {})
},
images: preparedImages.slice(0, userImageCount).map((image, index) => ({
role: index === 0 ? "firstFrame" : "lastFrame",
url: image.dataUrl
}))
});
await options.onRemoteVideo?.({
serviceId: service.serviceId,
remoteId: job.remoteId,
finalPrompt,
requestParameters: state.parameters,
job
});
}
let completed = await module.poll(job);
while (completed.status !== "completed") {
await waitForVideoPoll(options.pollIntervalMs, options.signal);
completed = await module.poll(completed);
}
options.onPhase?.("downloading");
const downloaded = await module.download(completed);
if (downloaded.blob.size > LIBRARY_TRANSFER_LIMITS.maxVideoBytes) {
throw new ComposerServiceError("视频成品超过本地素材库单文件上限", 413, { retryable: false });
}
return {
route: "compose",
kind: "video",
finalPrompt,
videos: [{ blob: downloaded.blob, remoteId: job.remoteId, responseStatus: completed.status }],
outputLanguage: promptResult?.outputLanguage || input.session?.outputLanguage || "auto",
usage: promptResult?.usage || {},
serviceId: service.serviceId,
model: service.model,
requestModel: service.model,
requestParameters: state.parameters,
providerUsage: normalizeChatUsage(completed.providerPayload?.usage),
cost: Number(completed.providerPayload?.usage?.cost),
routing: completed.providerPayload?.openrouter_metadata && typeof completed.providerPayload.openrouter_metadata === "object" ? {
provider: String(completed.providerPayload.openrouter_metadata.provider ?? ""),
model: String(completed.providerPayload.openrouter_metadata.model ?? service.model)
} : null,
finishReason: completed.status
};
}
async function pollOpenAiVideo(remoteId, apiKey, options) {
let payload = await videoJsonRequest(`${OPENAI_VIDEOS_ENDPOINT}/${encodeURIComponent(remoteId)}`, apiKey, "GET", null, options);
while (!["completed", "failed", "canceled"].includes(String(payload?.status ?? "").toLocaleLowerCase("en-US"))) {
await waitForVideoPoll(options.pollIntervalMs, options.signal);
payload = await videoJsonRequest(`${OPENAI_VIDEOS_ENDPOINT}/${encodeURIComponent(remoteId)}`, apiKey, "GET", null, options);
}
if (String(payload.status).toLocaleLowerCase("en-US") !== "completed") {
throw new ComposerServiceError(String(payload?.error?.message ?? "视频生成未完成"), 422, { retryable: true });
}
return payload;
}
async function pollXaiVideo(remoteId, apiKey, options) {
let payload = await videoJsonRequest(`${XAI_VIDEOS_ENDPOINT}/${encodeURIComponent(remoteId)}`, apiKey, "GET", null, options, "xAI 视频服务");
while (!["done", "failed", "canceled"].includes(String(payload?.status ?? "").toLocaleLowerCase("en-US"))) {
await waitForVideoPoll(options.pollIntervalMs, options.signal);
payload = await videoJsonRequest(`${XAI_VIDEOS_ENDPOINT}/${encodeURIComponent(remoteId)}`, apiKey, "GET", null, options, "xAI 视频服务");
}
if (String(payload.status).toLocaleLowerCase("en-US") !== "done") {
throw new ComposerServiceError(String(payload?.error?.message ?? "xAI 视频生成未完成"), 422, { retryable: true });
}
return payload;
}
async function videoJsonRequest(url, apiKey, method, body, options, label = "OpenAI 视频服务") {
const response = await videoRequest(url, apiKey, method, body, options, label);
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw responseError(label, response.status, payload, { secrets: [apiKey] });
return payload;
}
async function videoBlobRequest(url, apiKey, options, label = "OpenAI 视频服务") {
const response = await videoRequest(url, apiKey, "GET", null, options, label);
if (!response.ok) {
const payload = await response.json().catch(() => ({}));
if ([404, 410].includes(response.status)) {
throw new ComposerServiceError("远程视频成品已经过期,需要重新生成", response.status, {
kind: "expired",
retryable: true
});
}
throw responseError(label, response.status, payload, { secrets: [apiKey] });
}
try {
return await boundedMediaBlobFromResponse(response, {
kind: "video",
maxBytes: LIBRARY_TRANSFER_LIMITS.maxVideoBytes
});
} catch (error) {
throw new ComposerServiceError(error.message || "视频服务没有返回有效视频文件", 503, { retryable: true, cause: error });
}
}
async function videoRequest(url, apiKey, method, body, options, label = "OpenAI 视频服务") {
const controller = new AbortController();
const onAbort = () => controller.abort();
if (options.signal?.aborted) controller.abort();
options.signal?.addEventListener("abort", onAbort, { once: true });
const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
try {
const multipart = typeof FormData !== "undefined" && body instanceof FormData;
const json = body && !multipart;
const pending = Promise.resolve((options.fetchImpl ?? fetch)(url, {
method,
headers: {
...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
...(json ? { "Content-Type": "application/json" } : {})
},
...(body ? { body: json ? JSON.stringify(body) : body } : {}),
redirect: "error",
signal: controller.signal
}));
pending.catch(() => undefined);
await notifyRequestStart(options);
return await pending;
} catch (error) {
if (error?.name === "AbortError") throw error;
throw new ComposerServiceError(`无法连接${label},请检查网络和权限`, 0, { cause: error });
} finally {
clearTimeout(timeoutId);
options.signal?.removeEventListener("abort", onAbort);
}
}
function waitForVideoPoll(intervalValue, signal) {
const delay = Number.isFinite(Number(intervalValue)) ? Math.max(0, Number(intervalValue)) : 2_000;
if (!delay) return Promise.resolve();
return new Promise((resolve, reject) => {
const timer = setTimeout(resolve, delay);
signal?.addEventListener("abort", () => {
clearTimeout(timer);
reject(new DOMException("Aborted", "AbortError"));
}, { once: true });
});
}
function validateXaiVideoResultUrl(value) {
let url;
try { url = new URL(String(value ?? "").trim()); }
catch { throw new ComposerServiceError("xAI 视频服务没有返回有效的成品地址", 503, { retryable: true }); }
const hostname = url.hostname.toLocaleLowerCase("en-US");
if (url.protocol !== "https:" || !(hostname === "x.ai" || hostname.endsWith(".x.ai")) || url.username || url.password) {
throw new ComposerServiceError("xAI 视频成品地址不属于已授权的 xAI 域名", 422, { retryable: true });
}
return url.href;
}
function normalizeRemoteVideo(value, expectedServiceId = "") {
const serviceId = ["openai", "xai", "gemini", "openrouter", "minimax", "volcengine"].includes(value?.serviceId) ? value.serviceId : "";
if (!serviceId || (expectedServiceId && serviceId !== expectedServiceId)) return null;
const remoteId = String(value?.remoteId ?? "").trim();
const finalPrompt = String(value?.finalPrompt ?? "").trim();
const requestParameters = Object.fromEntries(["size", "duration", "resolution", "aspectRatio"]
.map((key) => [key, String(value?.requestParameters?.[key] ?? "").trim()])
.filter(([, parameter]) => parameter));
const job = value?.job && typeof value.job === "object" ? structuredClone(value.job) : null;
return remoteId && finalPrompt ? { serviceId, remoteId, finalPrompt, requestParameters, job } : null;
}
async function executeVisualTextTurn(input, service, preparedImages, options) {
const request = executionRequest(input);
const route = request.route;
const automatic = route === "auto";
const promptInput = {
settings: input.composerSettings,
route,
targetType: request.targetType,
outputLanguage: request.outputLanguage,
productionReviewEnabled: request.productionReviewEnabled
};
const systemInstruction = automatic
? compileAgentAutoExecutionPrompt(promptInput)
: compileAgentExecutionPrompt(promptInput);
const content = multimodalContent(input.session, request, preparedImages, service.protocol, options.preparedVideos);
const projector = automatic ? createComposerAutoResponseProjector(options.onDelta) : null;
const result = await requestText(service, systemInstruction, content, {
signal: options.signal,
fetchImpl: options.fetchImpl,
onRequestStart: options.onRequestStart,
onDelta: automatic ? (_delta, cumulative) => projector.push(cumulative) : options.onDelta,
stream: options.stream !== false,
toolRuntime: options.toolRuntime,
conversation: request
});
if (automatic) {
const parsed = projector.push(result.content, { final: true });
const protocolFacts = composerAutoResponseProtocolFacts(parsed);
if (parsed.status === "needs_clarification") {
return {
...protocolFacts,
route: parsed.route,
kind: "question",
text: parsed.visibleText,
outputLanguage: request.outputLanguage,
usage: result.usage,
model: result.model,
finishReason: result.finishReason
};
}
if (parsed.route === "compose") {
return {
...protocolFacts,
route: parsed.route,
kind: "prompt",
finalPrompt: validateGeneratedPrompt(parsed.visibleText),
outputLanguage: request.outputLanguage,
usage: result.usage,
model: result.model,
finishReason: result.finishReason
};
}
return {
...protocolFacts,
route: parsed.route,
kind: parsed.route === "analyze_materials" ? "analysis" : "chat",
text: parsed.visibleText,
outputLanguage: request.outputLanguage,
usage: result.usage,
model: result.model,
finishReason: result.finishReason
};
}
if (route === "compose") {
return {
route,
kind: "prompt",
finalPrompt: validateGeneratedPrompt(result.content),
outputLanguage: request.outputLanguage,
usage: result.usage,
model: result.model,
finishReason: result.finishReason
};
}
return {
route,
kind: route === "analyze_materials" ? "analysis" : "chat",
text: result.content,
outputLanguage: request.outputLanguage,
usage: result.usage,
model: result.model,
finishReason: result.finishReason
};
}
async function generateImageTurn(input, service, preparedImages, options) {
const request = executionRequest({ ...input, route: "compose" });
if (request.targetType !== "image") throw new ComposerServiceError("创建图片只适用于图片创作", 422, { retryable: false });
const systemInstruction = compileAgentExecutionPrompt({
settings: input.composerSettings,
route: "compose",
targetType: "image",
outputLanguage: request.outputLanguage,
productionReviewEnabled: request.productionReviewEnabled
});
const imageEdit = normalizeImageEdit(input.imageEdit);
const referenceMode = ["prompt_only", "text_only"].includes(input.session?.imageReferenceMode)
? input.session.imageReferenceMode
: "conditioned";
if (imageEdit && referenceMode !== "conditioned") {
throw new ComposerServiceError("局部修改和扩图必须使用当前底图参与生成", 422, { retryable: false });
}
if (service.serviceId === "openrouter") {
return generateOpenRouterImageTurn(input, service, preparedImages, referenceMode, options);
}
if (service.serviceId === "gemini" && imageEdit?.mode === "local") {
throw new ComposerServiceError("Gemini Interactions 当前不支持上传局部遮罩编辑;请改用整图语义修改", 422, { retryable: false });
}
const requestState = normalizeImageGenerationRequest(input.session?.generationAiProfile, options.visionSettings ?? {}, input.session?.generationParameters);
if (requestState.issues.length) throw new ComposerServiceError(requestState.issues.join(";"), 422, { retryable: false });
const requestParameters = requestState.parameters;
const baseContent = multimodalContent(input.session, request, preparedImages, service.protocol, options.preparedVideos);
const content = imageEdit ? imageEditContent(baseContent, imageEdit, service.protocol) : baseContent;
if (service.imageGeneration.protocol === "gemini_interactions") {
return generateGeminiImageTurn(input, service, request, content, referenceMode, imageEdit, requestParameters, preparedImages, options);
}
if (service.imageGeneration.protocol === "responses_tool") {
const instructions = [
systemInstruction,
"本轮最终结果是图片。若需要案例资料,先完成必要查询与读取,然后必须调用 image_generation,依据用户要求和明确指定的原图创建图片。"
].join("\n\n");
if (referenceMode === "conditioned") {
const result = imageEdit?.mode === "local"
? await requestOpenAiMaskedImage(service, instructions, baseContent, imageEdit, requestParameters, options)
: await requestResponsesImage(service, instructions, content, request.instruction, requestParameters, options);
return { route: "compose", kind: "image", serviceId: service.serviceId, outputLanguage: request.outputLanguage, requestParameters, ...result };
}
const promptResult = await assembleImagePrompt(input, preparedImages, options);
const finalPrompt = promptResult.finalPrompt;
const imageResult = await requestResponsesImage(
service,
instructions,
[{ type: "text", text: finalPrompt }],
finalPrompt,
requestParameters,
options
);
return {
route: "compose",
kind: "image",
serviceId: service.serviceId,
outputLanguage: request.outputLanguage,
requestParameters,
...imageResult,
finalPrompt,
usage: addUsage(promptResult.usage, imageResult.usage)
};
}
if (service.imageGeneration.protocol !== "images_generations") {
throw new ComposerServiceError("当前创作服务没有配置可用的生图接口", 422, { retryable: false });
}
let referenceImages = [
...(imageEdit ? [{
label: "当前结果底图",
dataUrl: imageEdit.baseImage.dataUrl,
referenceIndex: -1,
imageIndex: -1,
editBase: true
}] : []),
...(referenceMode === "conditioned" ? referenceImagesForEdits(input.session, preparedImages) : [])
];
assertImagesEndpointRequest(service, referenceImages, requestParameters);
const promptResult = await assembleImagePrompt(input, preparedImages, options);
if (referenceMode === "conditioned") {
const additional = referenceImagesForEdits(input.session, preparedImages);
referenceImages = [...referenceImages.filter(item => item.editBase), ...additional];
assertImagesEndpointRequest(service, referenceImages, requestParameters);
}
const finalPrompt = promptResult.finalPrompt;
const imageResult = await requestImagesEndpoint(service, finalPrompt, referenceImages, requestParameters, options, imageEdit);
return {
route: "compose",
kind: "image",
finalPrompt,
images: imageResult.images,
outputLanguage: request.outputLanguage,
usage: addUsage(promptResult.usage, imageResult.usage),
serviceId: service.serviceId,
model: imageResult.model,
requestModel: service.imageGeneration.model,
requestParameters,
finishReason: imageResult.finishReason
};
}
async function generateGeminiImageTurn(input, service, request, conditionedContent, referenceMode, imageEdit, requestParameters, preparedImages, options) {
let finalPrompt = String(request.instruction ?? "").trim();
let content = conditionedContent;
if (!imageEdit && referenceMode !== "conditioned") {
const promptResult = await assembleImagePrompt(input, preparedImages, options);
finalPrompt = promptResult.finalPrompt;
content = [{ type: "text", text: finalPrompt }];
}
const imageBlocks = content.filter((item) => item.type === "image");
const maximum = service.provider
? modelReferenceCapability(service.provider, service.imageGeneration.model, { supported: null, maxItems: null }).maxItems
: null;
if (Number.isInteger(maximum) && imageBlocks.length > maximum) {
throw new ComposerServiceError(`所选 Gemini 模型最多读取 ${maximum} 张参考图,请先减少参考`, 422, {
kind: "reference_limit",
retryable: false,
referenceLimit: { actual: imageBlocks.length, maximum }
});
}
const interactionInput = content.some(item => ["image", "video"].includes(item.type))
? content.map((item) => ["image", "video"].includes(item.type) ? geminiMediaInput(item) : { type: "text", text: item.text })
: finalPrompt;
const responseFormat = { type: "image" };
if (requestParameters.aspectRatio) responseFormat.aspect_ratio = requestParameters.aspectRatio;
if (requestParameters.imageSize) responseFormat.image_size = requestParameters.imageSize;
const body = {
model: service.imageGeneration.model,
input: interactionInput,
response_format: responseFormat
};
const response = await requestRaw(
service.imageGeneration.endpoint,
"",
body,
options,
IMAGE_REQUEST_TIMEOUT_MS,
"Google Gemini 图片服务",
{ "x-goog-api-key": service.imageGeneration.apiKey }
);
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw responseError("Google Gemini 图片服务", response.status, payload, {
secrets: [service.imageGeneration.apiKey]
});
const parsed = geminiInteractionImages(payload);
if (!parsed.images.length) {
throw new ComposerServiceError("Google Gemini 图片服务完成请求但没有返回有效图片", 422, { retryable: false });
}
return {
route: "compose",
kind: "image",
finalPrompt: parsed.text || finalPrompt || "创建图片",
images: parsed.images,
outputLanguage: request.outputLanguage,
usage: normalizeGeminiInteractionsUsage(payload.usage),
serviceId: "gemini",
model: String(payload.model ?? service.imageGeneration.model),
requestModel: service.imageGeneration.model,
requestParameters,
finishReason: String(payload.status ?? "completed")
};
}
function geminiMediaInput(item) {
const match = String(item.dataUrl ?? "").match(/^data:((?:image|video)\/[a-z0-9.+-]+);base64,([A-Za-z0-9+/=]+)$/i);
if (!match || !match[1].startsWith(`${item.type}/`)) throw new ComposerServiceError("Gemini 参考原件数据无效,本次没有发送不完整参考", 422, { retryable: false });
return { type: item.type, mime_type: match[1].toLocaleLowerCase("en-US"), data: match[2] };
}
function geminiInteractionImages(payload) {
const blocks = (Array.isArray(payload?.steps) ? payload.steps : [])
.filter((step) => step?.type === "model_output")
.flatMap((step) => Array.isArray(step.content) ? step.content : []);
if (payload?.output_image && (!payload.output_image.type || payload.output_image.type === "image")) {
const outputImage = { type: "image", ...payload.output_image };
const alreadyIncluded = blocks.some((block) => block?.type === "image"
&& block.data === outputImage.data && block.mime_type === outputImage.mime_type);
if (!alreadyIncluded) blocks.push(outputImage);
}
const images = [];
const texts = [];
for (const block of blocks) {
if (block?.type === "text" && String(block.text ?? "").trim()) {
texts.push(String(block.text).trim());
continue;
}
if (block?.type !== "image") continue;
const encoded = String(block.data ?? "").trim();
const mimeType = String(block.mime_type ?? "").trim().toLocaleLowerCase("en-US");
if (!encoded || !/^image\/(?:png|jpeg|webp|heic|heif|gif|bmp|tiff)$/.test(mimeType)) continue;
try {
images.push({ blob: base64Image(encoded, mimeType), mimeType, source: "base64" });
} catch {}
}
return { images, text: texts.join("\n").trim() };
}
async function generateOpenRouterImageTurn(input, service, preparedImages, referenceMode, options) {
if (input.imageEdit?.mode === "local") throw new ComposerServiceError("所选 OpenRouter 模型未声明局部遮罩编辑能力", 422, { retryable: false });
if (referenceMode === "prompt_only") {
throw new ComposerServiceError("当前 OpenRouter 独立图片接口不能在提示词整理阶段读取原图", 422, { retryable: false });
}
const promptResult = await assembleImagePrompt(input, preparedImages, options);
const finalPrompt = promptResult.finalPrompt;
const references = referenceMode === "conditioned" ? referenceImagesForEdits(input.session, preparedImages) : [];
const body = {
model: service.imageGeneration.model,
prompt: finalPrompt,
...(references.length ? { input_references: references.map((image) => ({ type: "image_url", image_url: { url: image.dataUrl } })) } : {})
};
const response = await requestRaw(service.imageGeneration.endpoint, service.apiKey, body, options, IMAGE_REQUEST_TIMEOUT_MS, "OpenRouter 图片服务");
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw responseError("OpenRouter 图片服务", response.status, payload, { secrets: [service.apiKey] });
const images = (Array.isArray(payload.data) ? payload.data : []).flatMap((item) => {
const encoded = String(item?.b64_json ?? "").trim();
if (!encoded) return [];
const mimeType = String(item?.media_type ?? "image/png").trim();
const blob = imageBlobFromDataUrl(`data:${mimeType};base64,${encoded}`);
return [{ blob, mimeType, source: "base64" }];
});
if (!images.length) throw new ComposerServiceError("OpenRouter 没有返回有效图片", 503, { retryable: true });
return {
route: "compose", kind: "image", finalPrompt, images,
outputLanguage: promptResult.outputLanguage || input.session?.outputLanguage || "auto",
usage: addUsage(promptResult.usage, normalizeChatUsage(payload.usage)),
serviceId: "openrouter",
model: String(payload.model ?? service.imageGeneration.model),
requestModel: service.imageGeneration.model,
requestParameters: {},
providerUsage: normalizeChatUsage(payload.usage),
cost: Number(payload?.usage?.cost),
routing: payload?.openrouter_metadata && typeof payload.openrouter_metadata === "object" ? {
provider: String(payload.openrouter_metadata.provider ?? ""),
model: String(payload.openrouter_metadata.model ?? payload.model ?? "")
} : null,
finishReason: "completed"
};
}
async function assembleImagePrompt(input, preparedImages, options) {
const promptInput = {
...input,
session: { ...input.session, outputMode: "text_prompt" }
};
const result = await executeComposerTurnWithService(promptInput, {
ai: options.aiSettings, vision: options.visionSettings
}, preparedImages, { ...options, stream: false });
if (result.kind !== "prompt") throw new ComposerServiceError("图片任务没有生成可提交的最终提示词", 422, { retryable: false });
return result;
}
function executionRequest(input) {
const request = plannerRequestPayload(input.session, input.userMessage, input.composerSettings);
const instruction = String(input.instruction ?? "").trim()
|| [...request.messages].reverse().find((item) => item.role === "user")?.content
|| "";
return {
...request,
route: ["auto", "compose", "analyze_materials", "chat"].includes(input.route) ? input.route : "chat",
instruction,
references: (input.session?.referenceSnapshots ?? []).map((item) => ({
alias: item.alias,
referenceKind: item.referenceKind,
referenceText: item.referenceText || item.originalText || "",
sources: item.referenceKind === "video_sources"
? (item.referenceSources ?? []).map(({ kind, label }) => ({ kind, label }))
: [],
imageCount: item.imageRefs?.length || 0
}))
};
}
function multimodalContent(session, request, preparedImages, protocol, preparedVideos = []) {
const content = [{ type: "text", text: JSON.stringify(request) }];
const images = new Map((Array.isArray(preparedImages) ? preparedImages : []).map((item) => [item.visualId, item]));
const videos = new Map((Array.isArray(preparedVideos) ? preparedVideos : []).map((item) => [item.assetId, item]));
for (const reference of session?.referenceSnapshots ?? []) {
if (reference.referenceKind === "video_sources") {
if (session?.videoReferenceMode === "text_only") continue;
content.push({ type: "text", text: `${reference.alias}\n[本地视频参考]` });
for (const [index, assetRef] of (reference.assetRefs ?? []).filter((item) => item.kind === "video").entries()) {
const video = videos.get(assetRef.assetId);
if (!video?.dataUrl) throw new ComposerServiceError(`${reference.alias}/视频${index + 1} 读取失败,本次没有发送不完整参考`, 422, { retryable: true });
content.push({ type: "text", text: `${reference.alias}/视频${index + 1}` });
content.push({ type: "video", dataUrl: video.dataUrl, mimeType: video.mimeType });
}
continue;
}
const textOnly = session?.imageReferenceMode === "text_only";
const savedReconstructions = (reference.assets ?? []).map((asset, index) => String(asset?.reconstructionPrompt ?? "").trim()
? `[图片${index + 1}重建提示词]\n${String(asset.reconstructionPrompt).trim()}` : "").filter(Boolean).join("\n\n");
if (savedReconstructions) content.push({ type: "text", text: `${reference.alias}\n[案例已有 V2 高保真提示词]\n${savedReconstructions}` });
if (textOnly) continue;
(reference.imageRefs ?? []).forEach((imageRef, index) => {
const image = images.get(imageRef.visualId);
if (!image?.dataUrl) throw new ComposerServiceError(`${reference.alias}/图片${index + 1} 读取失败,本次没有发送不完整参考`, 422, { retryable: true });
content.push({ type: "text", text: `${reference.alias}/图片${index + 1}` });
content.push({ type: "image", dataUrl: image.dataUrl, detail: "high", protocol });
});
}
return content;
}
async function requestStructured(service, instructions, content, options = {}) {
const jsonContent = [{ type: "text", text: "Return valid json." }, ...content];
if (service.protocol === "responses") {
const body = responsesBody(service, instructions, jsonContent, false);
body.text = { format: { type: "json_object" } };
return parseResponsesPayload(await requestJson(service, body, options), service);
}
const body = chatBody(service, instructions, jsonContent, false);
if (service.structuredOutput !== "prompt_only") body.response_format = { type: "json_object" };
return parseChatPayload(await requestJson(service, body, options), service);
}
async function requestText(service, instructions, content, options = {}) {
if (options.toolRuntime?.specs.length) {
const body = service.protocol === "responses"
? responsesBody(service, instructions, content, options.stream !== false)
: chatBody(service, instructions, content, options.stream !== false);
if (options.conversation) applyComposerConversation(body, options.conversation, service.protocol);
if (body.stream && service.protocol !== "responses") body.stream_options = { include_usage: true };
return runComposerToolLoop({ body, protocol: service.protocol === "responses" ? "responses" : "chat_completions",
runtime: { ...options.toolRuntime, contextLength: getAiModelCapability(service.providerId ?? service.serviceId ?? service.id, body.model)?.contextLength,
chatImagePart: image => chatImagePart(service, image) },
signal: options.signal, onDelta: options.onDelta,
request: async (nextBody, { signal }) => {
const response = await requestRaw(service.endpoint, service.apiKey, nextBody, { ...options, signal }, REQUEST_TIMEOUT_MS, service.label);
if (!response.ok) throw responseError(service.label, response.status, await response.json().catch(() => ({})), { secrets: [service.apiKey] });
return response;
}
});
}
if (options.stream === false) {
const body = service.protocol === "responses"
? responsesBody(service, instructions, content, false)
: chatBody(service, instructions, content, false);
if (options.conversation) applyComposerConversation(body, options.conversation, service.protocol);
const payload = await requestJson(service, body, options);
return service.protocol === "responses" ? parseResponsesPayload(payload, service) : parseChatPayload(payload, service);
}
const body = service.protocol === "responses"
? responsesBody(service, instructions, content, true)
: chatBody(service, instructions, content, true);
if (options.conversation) applyComposerConversation(body, options.conversation, service.protocol);
const response = await requestRaw(service.endpoint, service.apiKey, body, options, REQUEST_TIMEOUT_MS, service.label);
const contentType = String(response.headers?.get?.("content-type") ?? "");
if (!contentType.includes("text/event-stream")) {
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw responseError(service.label, response.status, payload, { secrets: [service.apiKey] });
const result = service.protocol === "responses" ? parseResponsesPayload(payload, service) : parseChatPayload(payload, service);
options.onDelta?.(result.content, result.content);
return result;
}
if (!response.ok) throw responseError(service.label, response.status, await response.json().catch(() => ({})), { secrets: [service.apiKey] });
return service.protocol === "responses"
? readResponsesSse(response, service, options.onDelta, options.signal)
: readChatSse(response, service, options.onDelta, options.signal);
}
async function requestResponsesImage(service, instructions, content, fallbackPrompt, requestParameters, options, imageTool = { type: "image_generation" }) {
const body = responsesBody(service, instructions, content, false);
body.tools = [{ ...imageTool, ...requestParameters }];
const loopResult = options.toolRuntime?.specs.length ? await runComposerToolLoop({
body, protocol: "responses",
runtime: options.toolRuntime, signal: options.signal, allowImageOutput: true,
request: async (nextBody, { signal }) => {
const response = await requestRaw(service.endpoint, service.apiKey, nextBody, { ...options, signal }, IMAGE_REQUEST_TIMEOUT_MS, service.label);
if (!response.ok) throw responseError(service.label, response.status, await response.json().catch(() => ({})), { secrets: [service.apiKey] });
return response;
}
}) : null;
const payload = loopResult ? { output: loopResult.outputItems, output_text: loopResult.content, model: loopResult.model }
: await requestJson(service, body, options, IMAGE_REQUEST_TIMEOUT_MS);
const calls = (Array.isArray(payload?.output) ? payload.output : []).filter((item) => item?.type === "image_generation_call");
const images = calls.flatMap((call) => call.result ? [{ blob: base64Image(call.result, "image/png"), revisedPrompt: String(call.revised_prompt ?? "").trim() }] : []);
if (!images.length) throw new ComposerServiceError(`${service.label} 没有返回生成图片`, 422, { retryable: true });
const text = String(payload.output_text ?? extractResponsesText(payload) ?? "").trim();
const revisedPrompt = images.find((item) => item.revisedPrompt)?.revisedPrompt || text;
return {
finalPrompt: revisedPrompt || String(fallbackPrompt ?? "").trim() || "创建图片",
images,
usage: loopResult?.usage ?? normalizeResponsesUsage(payload.usage),
model: String(payload.model ?? ""),
requestModel: service.model,
finishReason: "completed"
};
}
async function requestOpenAiMaskedImage(service, instructions, content, imageEdit, requestParameters, options) {
const uploadedIds = [];
try {
const baseFileId = await uploadOpenAiImage(service, imageEdit.baseImage.dataUrl, "edit-base", options);
uploadedIds.push(baseFileId);
const maskFileId = await uploadOpenAiImage(service, imageEdit.mask.dataUrl, "edit-mask", options);
uploadedIds.push(maskFileId);
const maskedContent = [
content[0],
{ type: "image", fileId: baseFileId, detail: "high", protocol: service.protocol },
{ type: "text", text: imageEditInstruction(imageEdit) },
...content.slice(1)
];
return await requestResponsesImage(
service,
instructions,
maskedContent,
imageEdit.modification,
requestParameters,
options,
{ type: "image_generation", input_image_mask: { file_id: maskFileId } }
);
} finally {
const cleanupOptions = { fetchImpl: options.fetchImpl };
await Promise.allSettled(uploadedIds.map((fileId) => deleteOpenAiFile(service, fileId, cleanupOptions)));
}
}
async function requestImagesEndpoint(service, prompt, referenceImages, requestParameters, options, imageEdit = null) {
const image = service.imageGeneration;
if (referenceImages.length) return requestImageEdits(service, prompt, referenceImages, requestParameters, options, imageEdit);
const body = {
model: image.model,
prompt,
n: 1,
...requestParameters,
...(service.serviceId === "xai" ? {} : { response_format: "b64_json" })
};
const response = await requestRaw(image.endpoint, image.apiKey, body, options, IMAGE_REQUEST_TIMEOUT_MS, service.label);
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw responseError(service.label, response.status, payload, {
credentialHint: credentialHint(image.apiKey),
secrets: [image.apiKey]
});
const values = Array.isArray(payload?.data) ? payload.data : [];
const images = [];
for (const item of values) {
if (item?.b64_json) images.push({ blob: base64Image(item.b64_json, "image/png"), revisedPrompt: String(item.revised_prompt ?? "").trim() });
else if (item?.url) images.push({ blob: await downloadGeneratedImage(item.url, options), revisedPrompt: String(item.revised_prompt ?? "").trim() });
}
if (!images.length) throw new ComposerServiceError(`${service.label} 生图接口没有返回图片`, 422, { retryable: true });
return {
images,
usage: normalizeChatUsage(payload.usage),
model: String(payload.model ?? ""),
finishReason: "completed"
};
}
async function requestImageEdits(service, prompt, referenceImages, requestParameters, options, imageEdit = null) {
const image = service.imageGeneration;
const body = new FormData();
body.append("model", image.model);
body.append("prompt", [
"参考图按以下顺序上传,请严格保持每张图片与对应职责的关系:",
referenceImages.map((item, index) => `图${index + 1} = ${item.label}`).join("\n"),
"最终提示词:",
prompt
].join("\n"));
body.append("n", "1");
for (const [key, value] of Object.entries(requestParameters)) body.append(key, value);
body.append("response_format", "b64_json");
referenceImages.forEach((item, index) => {
const blob = imageBlobFromDataUrl(item.dataUrl);
const stem = item.editBase ? "edit-base" : `reference-${item.referenceIndex + 1}-image-${item.imageIndex + 1}`;
const field = referenceImages.length === 1 ? "image" : "image[]";
body.append(field, blob, `${stem}.${imageExtension(blob.type) || `image-${index + 1}`}`);
});
if (imageEdit?.mode === "local") {
const maskBlob = imageBlobFromDataUrl(imageEdit.mask.dataUrl);
body.append("mask", maskBlob, "edit-mask.png");
}
const response = await requestRaw(image.editsEndpoint, image.apiKey, body, options, IMAGE_REQUEST_TIMEOUT_MS, service.label);
return parseImagesEndpointResponse(service, response, options);
}
async function parseImagesEndpointResponse(service, response, options) {
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw responseError(service.label, response.status, payload, {
credentialHint: credentialHint(service.imageGeneration?.apiKey),
secrets: [service.imageGeneration?.apiKey]
});
const values = Array.isArray(payload?.data) ? payload.data : [];
const images = [];
for (const item of values) {
if (item?.b64_json) images.push({ blob: base64Image(item.b64_json, "image/png"), revisedPrompt: String(item.revised_prompt ?? "").trim() });
else if (item?.url) images.push({ blob: await downloadGeneratedImage(item.url, options), revisedPrompt: String(item.revised_prompt ?? "").trim() });
}
if (!images.length) throw new ComposerServiceError(`${service.label} 生图接口没有返回图片`, 422, { retryable: true });
return {
images,
usage: normalizeChatUsage(payload.usage),
model: String(payload.model ?? ""),
finishReason: "completed"
};
}
function responsesBody(service, instructions, content, stream) {
return {
model: service.model,
store: false,
stream,
instructions,
input: [{ role: "user", content: content.map((item) => item.type === "image"
? { type: "input_image", ...(item.fileId ? { file_id: item.fileId } : { image_url: item.dataUrl }), detail: item.detail }
: item.type === "video" ? { type: "input_video", video_url: item.dataUrl }
: { type: "input_text", text: item.text }) }],
...(service.reasoningEffort ? { reasoning: { effort: service.reasoningEffort } } : {})
};
}
function chatBody(service, instructions, content, stream) {
return {
...(service.serviceId === "deepseek" ? { thinking: {type:service.thinking ? "enabled" : "disabled"},
...(service.thinking ? {reasoning_effort:"high"} : {}), ...(stream ? {stream_options:{include_usage:true}} : {}) } : {}),
model: service.model,
stream,
messages: [
{ role: "system", content: instructions },
{ role: "user", content: content.map((item) => item.type === "image"
? chatImagePart(service, item)
: item.type === "video" ? chatVideoPart(service, item) : { type: "text", text: item.text }) }
]
};
}
function chatImagePart(service, item) {
if (service.mediaInput?.imageBase64 === "raw") {
const raw = String(item.dataUrl ?? "").split(",", 2)[1] || "";
return { type: "image_url", image_url: { url: raw } };
}
return { type: "image_url", image_url: { url: item.dataUrl, detail: item.detail } };
}
function chatVideoPart(service, item) {
const dataUrl = String(item.dataUrl ?? "");
const url = service.mediaInput?.localVideo === "base64"
? dataUrl.split(",", 2)[1] || ""
: dataUrl;
return { type: "video_url", video_url: { url } };
}
async function requestJson(service, body, options = {}, timeoutMs = REQUEST_TIMEOUT_MS) {
const response = await requestRaw(service.endpoint, service.apiKey, body, options, timeoutMs, service.label);
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw responseError(service.label, response.status, payload, { secrets: [service.apiKey] });
return payload;
}
async function requestRaw(url, apiKey, body, options, timeoutMs, label, extraHeaders = {}) {
const multipart = typeof FormData !== "undefined" && body instanceof FormData;
const controller = new AbortController();
let timedOut = false;
const onAbort = () => controller.abort();
if (options.signal?.aborted) controller.abort();
options.signal?.addEventListener("abort", onAbort, { once: true });
const requestedTimeout = Object.hasOwn(options ?? {}, "timeoutMs") ? options.timeoutMs : timeoutMs;
const timeoutId = Number.isFinite(requestedTimeout) && requestedTimeout > 0
? setTimeout(() => { timedOut = true; controller.abort(); }, requestedTimeout)
: null;
try {
const pending = Promise.resolve((options.fetchImpl ?? fetch)(url, {
method: "POST",
headers: { ...(multipart ? {} : { "Content-Type": "application/json" }), ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}), ...extraHeaders },
body: multipart ? body : JSON.stringify(body),
redirect: "error",
signal: controller.signal
}));
pending.catch(() => undefined);
await notifyRequestStart(options);
return await pending;
} catch (error) {
if (timedOut) throw new ComposerServiceError(`${label} 请求超时,本次结果未保存`, 408, { cause: error });
if (error?.name === "AbortError" || error?.code === 'RESOURCE_BUDGET_REACHED') throw error;
throw new ComposerServiceError(`无法连接 ${label},请检查网络、地址和权限`, 0, { cause: error });
} finally {
if (timeoutId !== null) clearTimeout(timeoutId);
options.signal?.removeEventListener("abort", onAbort);
}
}
async function notifyRequestStart(options = {}) {
try {
await options.onRequestStart?.();
} catch (error) {
options.onRequestStartError?.(error);
}
}
function requireVisualService(profileValue, visionSettingsValue, action) {
const profile = normalizeComposerAiProfile(profileValue);
const settings = normalizeVisionSettings(visionSettingsValue);
if (profile.serviceId === "xai") {
const xai = normalizeXaiComposerSettings(visionSettingsValue?.xai);
if (!xai.apiKey || !(profile.model || xai.textModel)) throw new ComposerServiceError("请先完成 xAI API Key 和文字模型配置", 422, { retryable: false });
if (!xai.mediaConsent) throw new ComposerServiceError(`请先确认:主动${action}时会把本轮文字与所选图片发送到 xAI`, 422, { retryable: false });
return {
serviceId: "xai",
label: "xAI",
protocol: "chat_completions",
endpoint: XAI_CHAT_ENDPOINT,
apiKey: xai.apiKey,
model: profile.model || xai.textModel,
reasoningEffort: "",
imageGeneration: {
protocol: "images_generations",
endpoint: XAI_IMAGE_GENERATIONS_ENDPOINT,
editsEndpoint: "",
apiKey: xai.apiKey,
model: xai.imageModel,
sizes: [],
qualities: [],
parametersOptional: true
},
videoGeneration: {
protocol: "xai_videos",
endpoint: XAI_VIDEOS_ENDPOINT,
apiKey: xai.apiKey,
model: xai.videoModel
}
};
}
const registryProviderId = profile.serviceId === "compatible" ? "custom-media" : profile.serviceId;
const registryProvider = visionSettingsValue?.providerProfiles?.[registryProviderId];
if (registryProvider?.id && !["openai", "xai"].includes(registryProviderId)) {
const provider = registryProvider;
const model = profile.model;
const modelCapability = getAiModelCapability(registryProviderId, model);
const discoveredCapability = (provider.discoveredModels ?? []).find((item) => item.id === model);
const imageGenerationModel = String(provider.imageGeneration?.model || provider.models?.imageGeneration || "").trim();
const imageGenerationReady = model === imageGenerationModel
&& provider.imageGeneration?.protocol
&& provider.imageGeneration.protocol !== "none"
&& provider.imageGeneration?.endpoint
&& (provider.imageGeneration?.apiKey || isLoopback(provider.imageGeneration.endpoint));
if ((!provider?.apiKey && !imageGenerationReady) || !model) {
throw new ComposerServiceError(`请先完成 ${provider?.label || profile.serviceId} 的 API Key 和所选模型配置`, 422, { retryable: false });
}
if (!provider.consent) throw new ComposerServiceError(`请先确认:主动${action}时会把本轮文字与所选图片发送到 ${provider.label || profile.serviceId}`, 422, { retryable: false });
const planning = availableAiModelChoicesForTask("creativePlanning", {
providers: { [registryProviderId]: provider }
}).some((choice) => choice.modelId === model);
const chatCompatible = ["openrouter", "gemini"].includes(profile.serviceId);
const endpoint = profile.serviceId === "openrouter"
? `${String(provider.endpoint).replace(/\/$/, "")}/chat/completions`
: profile.serviceId === "gemini"
? `${String(provider.endpoint).replace(/\/$/, "")}/v1beta/openai/chat/completions`
: provider.endpoint;
return {
serviceId: profile.serviceId,
label: provider.label || profile.serviceId,
protocol: chatCompatible ? "chat_completions" : provider.protocol,
endpoint,
apiKey: provider.apiKey,
model,
planning,
reasoningEffort: "",
...(profile.serviceId === "deepseek" ? { thinking: profile.thinking } : {}),
structuredOutput: modelCapability?.structuredOutput ?? provider.structuredOutput,
mediaInput: { ...(provider.mediaInput ?? {}), ...(modelCapability?.mediaInput ?? {}) },
videoInput: (modelCapability?.inputModalities ?? discoveredCapability?.inputModalities ?? []).includes("video"),
provider,
imageGeneration: profile.serviceId === "openrouter" ? {
protocol: "openrouter_images",
endpoint: `${String(provider.endpoint).replace(/\/$/, "")}/images`,
model
} : profile.serviceId === "gemini" ? {
protocol: "gemini_interactions",
endpoint: geminiInteractionsEndpoint(provider.endpoint),
apiKey: provider.apiKey,
model
} : provider.imageGeneration?.protocol && provider.imageGeneration.protocol !== "none"
? {
protocol: provider.imageGeneration.protocol,
endpoint: provider.imageGeneration.endpoint,
editsEndpoint: provider.imageGeneration.editsEndpoint,
apiKey: provider.imageGeneration.apiKey || provider.apiKey,
model: imageGenerationModel,
sizes: compatibleImageSizesFor(provider.endpoint, provider.imageGeneration),
qualities: structuredClone(provider.imageGeneration.qualities ?? [])
}
: null
};
}
if (!settings.consent) throw new ComposerServiceError(`请先确认:主动${action}时会把所选案例图片和文字发送到当前视觉服务`, 422, { retryable: false });
if (profile.serviceId === "openai") {
if (!settings.openai.apiKey || !settings.openai.model) throw new ComposerServiceError("请先完成 OpenAI 视觉服务配置", 422, { retryable: false });
return {
serviceId: "openai",
label: "OpenAI",
protocol: "responses",
endpoint: OPENAI_RESPONSES_ENDPOINT,
apiKey: settings.openai.apiKey,
model: profile.model || settings.openai.model,
reasoningEffort: profile.thinking ? "high" : "",
imageGeneration: { protocol: "responses_tool" }
};
}
const provider = settings.compatible;
if (!provider.endpoint || !provider.model || (!provider.apiKey && !isLoopback(provider.endpoint))) {
throw new ComposerServiceError("请先完成兼容视觉服务配置", 422, { retryable: false });
}
assertCredentialOrigin(provider.endpoint, provider.apiKey, provider.credentialOrigin);
const image = provider.imageGeneration;
if (image.protocol === "images_generations") {
if (image.endpoint) assertCredentialOrigin(image.endpoint, image.apiKey, image.credentialOrigin);
if (image.editsEndpoint) assertCredentialOrigin(image.editsEndpoint, image.apiKey, image.credentialOrigin);
}
return {
serviceId: "compatible",
label: serviceLabelForEndpoint(provider.endpoint),
protocol: provider.protocol,
endpoint: provider.endpoint,
apiKey: provider.apiKey,
model: profile.model || provider.model,
reasoningEffort: profile.thinking && compatibleReasoningSupported(provider) ? "high" : "",
imageGeneration: image.protocol === "responses_tool"
? { protocol: "responses_tool" }
: {
protocol: image.protocol,
endpoint: image.endpoint,
editsEndpoint: image.editsEndpoint,
apiKey: image.apiKey,
model: image.model,
sizes: compatibleImageSizesFor(provider.endpoint, image),
qualities: structuredClone(image.qualities),
referenceImages: compatibleImageReferenceCapability(visionSettingsValue, image.model)
}
};
}
function compatibleConfigured(vision) {
const provider = vision.compatible;
return Boolean(vision.consent && provider.endpoint && provider.model && (provider.apiKey || isLoopback(provider.endpoint)));
}
function usesProjectedDeepseekSettings(profile, settingsValue) {
if (profile.serviceId !== "deepseek") return false;
const settings = normalizeAiSettings(settingsValue);
return settings.activeProvider === "deepseek" && settings.analysisModel === profile.model;
}
function responsesImageCapability(configured, references = { supported: true, maxItems: null }) {
return {
generate: configured,
references,
edit: { whole: true, local: true },
parameters: [
imageParameter("size", "画幅与分辨率", RESPONSES_IMAGE_SIZES, "auto"),
imageParameter("quality", "质量", RESPONSES_IMAGE_QUALITIES, "auto")
]
};
}
function openAiVideoConfigured(settings) {
const video = settings.openai.videoGeneration;
return Boolean(settings.consent && settings.openai.apiKey && video.model && video.sizes.length && video.durations.length);
}
function openAiVideoCapability(settings) {
const video = settings.openai.videoGeneration;
const configured = openAiVideoConfigured(settings);
return {
generate: configured,
protocol: "openai_videos",
inputs: {
text: true,
firstFrame: true,
lastFrame: false,
referenceImages: { supported: true, maxItems: 1 },
referenceVideo: false,
edit: false,
extend: false,
motion: false
},
parameters: [
imageParameter("size", "画幅与分辨率", video.sizes.map(imageSizeOption), video.sizes[0]),
imageParameter("duration", "时长", video.durations.map((value) => ({ value, label: `${value} 秒` })), video.durations[0])
]
};
}
function xaiVideoCapability(configured, xai) {
return {
generate: configured && Boolean(xai.videoModel),
protocol: "xai_videos",
inputs: {
text: true,
firstFrame: false,
lastFrame: false,
referenceImages: { supported: false, maxItems: null },
referenceVideo: false,
edit: false,
extend: false,
motion: false
},
// The public REST schema currently documents the model and prompt as the
// stable creation contract. Optional output controls are not exposed until
// the account capability can be validated rather than guessed.
parameters: []
};
}
function providerModelDescriptor(profile, modelId) {
const id = String(modelId ?? "").trim();
return (profile?.discoveredModels ?? []).find((model) => model.id === id) ?? null;
}
function providerModelSupports(profile, modelId, taskId) {
const id = String(modelId ?? "").trim();
const known = profile?.id === "deepseek" ? getAiModelCapability(profile.id, id) : null;
if (known) return known.tasks.includes(taskId);
const descriptor = providerModelDescriptor(profile, id);
if (descriptor) return descriptor.tasks?.includes(taskId) === true;
return profile?.capabilities?.includes(taskId) === true
&& String(profile?.models?.[taskId] ?? "").trim() === id;
}
function compatibleImageReferenceCapability(visionSettingsValue, modelId) {
const profile = visionSettingsValue?.providerProfiles?.["custom-media"]
?? visionSettingsValue?.providerProfiles?.custom;
return modelReferenceCapability(profile, modelId, { supported: null, maxItems: null });
}
function modelReferenceCapability(profile, modelId, fallback = { supported: null, maxItems: null }) {
const value = (profile?.id === "deepseek" ? getAiModelCapability(profile.id, modelId)?.referenceImages : null) ?? providerModelDescriptor(profile, modelId)?.referenceImages;
const maximum = value?.maxItems === null || value?.maxItems === undefined || value?.maxItems === ""
? null
: Number(value.maxItems);
const supported = value?.supported === true ? true : value?.supported === false ? false : fallback.supported;
return {
supported,
maxItems: supported !== false && Number.isInteger(maximum) && maximum > 0 ? maximum : fallback.maxItems,
source: ["declared", "verified", "observed_error"].includes(value?.source) ? value.source : "unknown"
};
}
function providerVideoParameters(descriptor) {
const parameters = [];
if (descriptor?.supportedResolutions?.length) {
parameters.push(imageParameter("size", "分辨率", descriptor.supportedResolutions.map((value) => ({ value, label: value })), descriptor.supportedResolutions[0]));
}
if (descriptor?.supportedAspectRatios?.length) {
parameters.push(imageParameter("aspectRatio", "画幅比例", descriptor.supportedAspectRatios.map((value) => ({ value, label: value })), descriptor.supportedAspectRatios[0]));
}
return parameters;
}
function providerImageParameters(descriptor) {
const parameters = [];
const supported = new Set(descriptor?.supportedParameters ?? []);
if (supported.has("aspect_ratio") && descriptor?.supportedAspectRatios?.length) {
parameters.push(imageParameter("aspectRatio", "画幅比例", descriptor.supportedAspectRatios.map((value) => ({ value, label: value })), descriptor.supportedAspectRatios[0]));
}
if (supported.has("image_size") && descriptor?.supportedResolutions?.length) {
parameters.push(imageParameter("imageSize", "图片尺寸", descriptor.supportedResolutions.map((value) => ({ value, label: value })), descriptor.supportedResolutions[0]));
}
return parameters;
}
function geminiInteractionsEndpoint(value) {
try { return new URL("/v1beta/interactions", value).href; }
catch { throw new ComposerServiceError("Gemini 官方接口地址无效", 422, { retryable: false }); }
}
function imageParameter(key, label, options, defaultValue) {
return {
key,
label,
defaultValue: String(defaultValue ?? "").trim(),
options: options.map((option) => ({ ...option }))
};
}
function imageSizeOption(value) {
const size = String(value ?? "").trim();
const match = size.match(/^(\d+)\s*[x×]\s*(\d+)$/i);
if (!match) return { value: size, label: size, aspectRatio: "", resolution: size };
const width = Number(match[1]);
const height = Number(match[2]);
const divisor = greatestCommonDivisor(width, height);
return {
value: size,
label: `${width === height ? "方形" : width > height ? "横向" : "纵向"} · ${width}×${height}`,
aspectRatio: `${width / divisor}:${height / divisor}`,
resolution: `${width}x${height}`
};
}
function greatestCommonDivisor(left, right) {
let a = Math.max(1, Math.trunc(Math.abs(left)));
let b = Math.max(1, Math.trunc(Math.abs(right)));
while (b) [a, b] = [b, a % b];
return a;
}
function compatibleImageConfigured(provider) {
const image = provider.imageGeneration;
if (image.protocol === "responses_tool") {
const endpoint = image.endpoint || provider.endpoint;
const model = image.model || provider.model;
const apiKey = image.apiKey || provider.apiKey;
return Boolean(endpoint && model && (apiKey || isLoopback(endpoint)));
}
return !compatibleImageConfigurationIssue(image, compatibleImageSizesFor(provider.endpoint, image));
}
function compatibleImageConfigurationIssue(image = {}, supportedSizes = image.sizes) {
if (image.protocol !== "images_generations") return "当前服务没有配置可用的生图协议";
if (!image.endpoint) return "创建图片还缺少生图接口";
if (!image.apiKey && !isLoopback(image.endpoint)) return "创建图片还缺少生图 API Key";
if (!image.model) return "创建图片还缺少生图模型";
if (!image.parametersOptional && (!Array.isArray(supportedSizes) || !supportedSizes.length)) return "创建图片还缺少服务支持的尺寸选项";
return "";
}
function normalizeXaiComposerSettings(value = {}) {
return {
apiKey: String(value?.apiKey ?? "").trim(),
textModel: String(value?.textModel ?? "").trim(),
imageModel: String(value?.imageModel ?? "").trim(),
videoModel: String(value?.videoModel ?? "").trim(),
mediaConsent: value?.mediaConsent === true
};
}
function compatibleReasoningSupported(provider = {}) {
if (provider.protocol !== "responses") return false;
return Boolean(compatibleProviderPresetForEndpoint(provider.endpoint));
}
function referenceImageCount(session) {
if (session?.imageReferenceMode === "text_only") return 0;
return (session?.referenceSnapshots ?? []).reduce((total, item) => total + (item.imageRefs?.length || 0), 0);
}
function exceedsReferenceImageSize(value) {
const size = String(value ?? "").trim();
if (/4k/i.test(size)) return true;
const match = size.match(/^(\d+)\s*[x×]\s*(\d+)$/i);
return Boolean(match && (Number(match[1]) > 2048 || Number(match[2]) > 2048));
}
function referenceImagesForEdits(session, preparedImages) {
const imagesById = new Map((Array.isArray(preparedImages) ? preparedImages : []).map((item) => [item.visualId, item]));
return (session?.referenceSnapshots ?? []).flatMap((reference, referenceIndex) =>
(reference.imageRefs ?? []).map((imageRef, imageIndex) => {
const image = imagesById.get(imageRef.visualId);
if (!image?.dataUrl) throw new ComposerServiceError(`${reference.alias}/图片${imageIndex + 1} 读取失败,本次没有发送不完整参考`, 422, { retryable: true });
return { label: `${reference.alias}/图片${imageIndex + 1}`, dataUrl: image.dataUrl, referenceIndex, imageIndex };
}));
}
function assertImagesEndpointRequest(service, referenceImages, requestParameters = {}) {
const image = service.imageGeneration;
const issue = compatibleImageConfigurationIssue(image);
if (issue) throw new ComposerServiceError(issue, 422, { retryable: false });
const maxItems = image.referenceImages?.maxItems;
if (Number.isInteger(maxItems) && referenceImages.length > maxItems) {
const includesEditBase = referenceImages.some((item) => item.editBase);
throw new ComposerServiceError(includesEditBase
? `所选模型的 ${maxItems} 图上限包含当前底图;最多 ${maxItems} 张,请先减少原始参考`
: `所选模型最多读取 ${maxItems} 张参考图,请先减少参考`, 422, {
retryable: false,
kind: "reference_limit",
referenceLimit: { actual: referenceImages.length, maximum: maxItems }
});
}
if (!referenceImages.length) return;
if (!image.editsEndpoint) throw new ComposerServiceError("带参考图创建还缺少图片编辑接口", 422, { retryable: false });
if (service.label === "米醋" && exceedsReferenceImageSize(requestParameters.size)) throw new ComposerServiceError("米醋参考图模式最高支持 2K,请调整本轮输出尺寸", 422, { retryable: false });
}
function imageEditContent(content, imageEdit, protocol) {
return [
content[0],
{ type: "text", text: imageEditInstruction(imageEdit) },
{ type: "image", dataUrl: imageEdit.baseImage.dataUrl, detail: "high", protocol },
...content.slice(1)
];
}
function imageEditInstruction(imageEdit) {
return [
"[当前结果底图,优先级最高]",
imageEdit.originalPrompt ? `原提示词:${imageEdit.originalPrompt}` : "",
`修改范围:${imageEdit.mode === "local" ? "只修改透明遮罩区域" : "整张图片"}`,
`修改要求:${imageEdit.modification}`,
"没有被修改要求覆盖的画面内容应保持稳定。"
].filter(Boolean).join("\n");
}
function normalizeImageEdit(value) {
if (!value) return null;
const mode = value.mode === "local" ? "local" : "whole";
const baseDataUrl = String(value.baseImage?.dataUrl ?? "").trim();
const modification = String(value.modification ?? "").trim();
if (!baseDataUrl || !modification) throw new ComposerServiceError("图片编辑缺少底图或修改要求", 422, { retryable: false });
const maskDataUrl = String(value.mask?.dataUrl ?? "").trim();
if (mode === "local" && !maskDataUrl) throw new ComposerServiceError("局部修改缺少有效遮罩", 422, { retryable: false });
return {
mode,
parentVisualId: String(value.parentVisualId ?? value.baseImage?.visualId ?? "").trim(),
originalPrompt: String(value.originalPrompt ?? "").trim(),
modification,
baseImage: { visualId: String(value.baseImage?.visualId ?? "").trim(), dataUrl: baseDataUrl },
mask: mode === "local" ? { dataUrl: maskDataUrl } : null
};
}
async function uploadOpenAiImage(service, dataUrl, stem, options) {
const body = new FormData();
const blob = imageBlobFromDataUrl(dataUrl);
body.append("purpose", "vision");
body.append("file", blob, `${stem}.${imageExtension(blob.type) || "png"}`);
const response = await requestOpenAiFile(service, OPENAI_FILES_ENDPOINT, "POST", body, options);
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw responseError(service.label, response.status, payload, { secrets: [service.apiKey] });
const fileId = String(payload?.id ?? "").trim();
if (!fileId) throw new ComposerServiceError("OpenAI 没有返回临时图片文件 ID", 503);
return fileId;
}
async function deleteOpenAiFile(service, fileId, options) {
const response = await requestOpenAiFile(service, `${OPENAI_FILES_ENDPOINT}/${encodeURIComponent(fileId)}`, "DELETE", null, options);
if (!response.ok) throw new ComposerServiceError("OpenAI 临时图片清理失败", response.status);
}
async function requestOpenAiFile(service, url, method, body, options) {
const controller = new AbortController();
const onAbort = () => controller.abort();
if (options.signal?.aborted) controller.abort();
options.signal?.addEventListener("abort", onAbort, { once: true });
const timeoutId = setTimeout(() => controller.abort(), IMAGE_REQUEST_TIMEOUT_MS);
try {
return await (options.fetchImpl ?? fetch)(url, {
method,
headers: { Authorization: `Bearer ${service.apiKey}` },
...(body ? { body } : {}),
redirect: "error",
signal: controller.signal
});
} finally {
clearTimeout(timeoutId);
options.signal?.removeEventListener("abort", onAbort);
}
}
function serviceLabelForEndpoint(value) {
return compatibleProviderPresetForEndpoint(value)?.label || "兼容服务";
}
function isLoopback(value) {
try { return ["localhost", "127.0.0.1", "[::1]"].includes(new URL(value).hostname.toLocaleLowerCase("en-US")); }
catch { return false; }
}
function assertCredentialOrigin(endpoint, apiKey, credentialOrigin) {
if (!apiKey) return;
let origin;
try { origin = new URL(endpoint).origin; }
catch { throw new ComposerServiceError("兼容接口地址无效", 422, { retryable: false }); }
if (origin !== credentialOrigin) throw new ComposerServiceError("兼容接口域名已变化,请重新填写该服务的 API Key", 422, { retryable: false });
}
function parseResponsesPayload(payload, service) {
assertTextCompletion(payload?.status, service, payload?.error);
const content = String(payload?.output_text ?? extractResponsesText(payload) ?? "").trim();
if (!content) throw new ComposerServiceError(`${service.label} 没有返回可用内容`, 503);
return {
content,
usage: normalizeResponsesUsage(payload.usage),
model: String(payload?.model ?? service.model),
finishReason: String(payload?.status ?? "completed")
};
}
function parseChatPayload(payload, service) {
const choice = payload?.choices?.[0];
assertTextCompletion(choice?.finish_reason, service, payload?.error);
const content = String(choice?.message?.content ?? "").trim();
if (!content) throw new ComposerServiceError(`${service.label} 没有返回可用内容`, 503);
return {
content,
usage: normalizeChatUsage(payload.usage),
model: String(payload?.model ?? service.model),
finishReason: String(choice?.finish_reason ?? "")
};
}
async function readResponsesSse(response, service, onDelta = () => undefined, signal) {
return readSse(response, (event, state) => {
if (["error", "response.failed", "response.incomplete"].includes(event.type)) {
throw new ComposerServiceError(`${service.label} 回复失败或中断,已保留收到的内容,请明确重试`, 422);
}
if (event.type === "response.output_text.delta") {
state.content += String(event.delta ?? "");
onDelta(String(event.delta ?? ""), state.content);
}
if (event.type === "response.completed") {
state.model = String(event.response?.model ?? state.model);
state.usage = normalizeResponsesUsage(event.response?.usage);
state.finishReason = String(event.response?.status ?? "completed");
}
}, service, signal);
}
async function readChatSse(response, service, onDelta = () => undefined, signal) {
return readSse(response, (event, state) => {
if (event?.error) throw new ComposerServiceError(`${service.label} 回复失败,已保留收到的内容,请明确重试`, 502);
const choice = event?.choices?.[0];
const delta = String(choice?.delta?.content ?? "");
if (delta) {
state.content += delta;
onDelta(delta, state.content);
}
if (choice?.finish_reason) state.finishReason = String(choice.finish_reason);
if (event?.usage) state.usage = normalizeChatUsage(event.usage);
if (event?.model) state.model = String(event.model);
}, service, signal);
}
async function readSse(response, applyEvent, service, signal) {
if (!response?.body?.getReader) throw new ComposerServiceError(`${service.label} 没有返回流式内容`, 503);
const state = { content: "", usage: emptyUsage(), model: service.model, finishReason: "" };
let receivedDone = false;
for await (const data of readEventStream(response, { signal })) {
if (!data.trim()) continue;
if (data === "[DONE]") { receivedDone = true; continue; }
let event;
try { event = JSON.parse(data); }
catch { throw new ComposerServiceError(`${service.label} 流式内容不完整,已保留收到的内容,请明确重试`, 502); }
applyEvent(event, state);
}
assertTextCompletion(state.finishReason, service);
if ((!state.finishReason && !receivedDone) || !state.content.trim()) {
throw new ComposerServiceError(`${service.label} 没有返回完整内容,已保留收到的内容,请明确重试`, 503);
}
return state;
}
function assertTextCompletion(reason, service, error) {
if (error) throw new ComposerServiceError(`${service.label} 回复失败,请明确重试`, 502);
if (reason === "length") throw new ComposerServiceError(`${service.label} 输出被截断,请明确重试`, 422, { retryable: true });
if (reason && !["stop", "completed"].includes(reason)) {
throw new ComposerServiceError(`${service.label} 回复被阻止或中断,请明确重试`, 422);
}
}
function extractResponsesText(payload) {
for (const output of Array.isArray(payload?.output) ? payload.output : []) {
for (const item of Array.isArray(output?.content) ? output.content : []) {
if (item?.type === "output_text" && item.text) return item.text;
}
}
return "";
}
function normalizeResponsesUsage(value = {}) {
return {
promptTokens: finite(value.input_tokens),
completionTokens: finite(value.output_tokens),
totalTokens: finite(value.total_tokens),
cacheHitTokens: finite(value.input_tokens_details?.cached_tokens),
cacheMissTokens: 0
};
}
function normalizeGeminiInteractionsUsage(value = {}) {
return {
promptTokens: finite(value.total_input_tokens),
completionTokens: finite(value.total_output_tokens),
totalTokens: finite(value.total_tokens),
cacheHitTokens: finite(value.total_cached_tokens),
cacheMissTokens: Math.max(0, finite(value.total_input_tokens) - finite(value.total_cached_tokens))
};
}
function normalizeChatUsage(value = {}) {
return {
promptTokens: finite(value.prompt_tokens),
completionTokens: finite(value.completion_tokens),
totalTokens: finite(value.total_tokens),
cacheHitTokens: finite(value.prompt_cache_hit_tokens),
cacheMissTokens: finite(value.prompt_cache_miss_tokens)
};
}
function emptyUsage() {
return { promptTokens: 0, completionTokens: 0, totalTokens: 0, cacheHitTokens: 0, cacheMissTokens: 0 };
}
function addUsage(left = {}, right = {}) {
return Object.fromEntries(Object.keys(emptyUsage()).map((key) => [key, finite(left[key]) + finite(right[key])]));
}
function finite(value) {
const number = Number(value);
return Number.isFinite(number) && number > 0 ? Math.round(number) : 0;
}
function parseObject(content, message) {
const cleaned = String(content ?? "").trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
try {
const parsed = JSON.parse(cleaned);
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
return parsed;
} catch {
throw new ComposerServiceError(message, 422, { retryable: true });
}
}
function responseError(label, status, payload, options = {}) {
const detail = redactSecrets(String(payload?.error?.message ?? payload?.message ?? "").trim(), options.secrets);
const referenceLimit = referenceLimitFromMessage(detail);
const micuRouting = micuImageRoutingError(label, detail, options.credentialHint);
if (micuRouting) {
return new ComposerServiceError(micuRouting, status, {
kind: "configuration",
retryable: false
});
}
return new ComposerServiceError(`${label} 请求失败${detail ? `:${detail}` : `(HTTP ${status})`}`, status, referenceLimit ? {
kind: "reference_limit",
retryable: false,
referenceLimit
} : {});
}
function redactSecrets(value, secrets = []) {
return (Array.isArray(secrets) ? secrets : []).reduce((text, secretValue) => {
const secret = String(secretValue ?? "").trim();
return secret ? text.split(secret).join("[已隐藏凭据]") : text;
}, String(value ?? ""));
}
function micuImageRoutingError(label, detail, keyHint = "") {
if (label !== "米醋" || !/gpt-image-2(?:-pro)?/i.test(detail) || !/(?:无可用渠道|distributor)/i.test(detail)) return "";
const group = detail.match(/分组\s+([^\s]+)\s+下模型/i)?.[1] ?? "";
const requestId = detail.match(/request id:\s*([^)\s]+)/i)?.[1] ?? "";
const sentCredential = keyHint ? `本轮发送的是独立图片生成 Key(尾号 ${keyHint}),` : "本轮发送的是独立图片生成 Key,";
const currentGroup = group ? `米醋服务器将它识别为 ${group} 分组,` : "米醋服务器判定它的分组与模型不匹配,";
const supportReference = requestId ? `(request id: ${requestId})` : "";
return `米醋请求未进入生图渠道:${sentCredential}${currentGroup}而 gpt-image-2 需要 vip_2_image(Image2)。PromptDirector 不能改变服务端 Key 分组;模型目录里能看到 gpt-image-2 也不代表这把 Key 已获生图授权。请在米醋后台核对这把 Key 的分组,或把以上 request id 交给米醋客服确认。这与本轮分辨率和参考图模式无关。${supportReference}`;
}
function credentialHint(value) {
const key = String(value ?? "").trim();
return key.length >= 4 ? key.slice(-4) : "";
}
function referenceLimitFromMessage(value) {
const text = String(value ?? "").trim();
const comparison = text.match(/(?:reference images?|参考图)[^\d]{0,40}(\d+)\s*>\s*(\d+)\s*(?:max|maximum|最多)/i)
?? text.match(/(\d+)\s*>\s*(\d+)\s*(?:max|maximum)/i);
if (comparison) return { actual: Number(comparison[1]), maximum: Number(comparison[2]) };
const maximum = text.match(/(?:reference images?|参考图)[^\d]{0,40}(?:max(?:imum)?|最多|上限)[^\d]{0,12}(\d+)/i);
return maximum ? { actual: null, maximum: Number(maximum[1]) } : null;
}
function normalizeReferenceLimit(value) {
const maximum = Number(value?.maximum);
const actual = Number(value?.actual);
if (!Number.isInteger(maximum) || maximum <= 0) return null;
return { maximum, actual: Number.isInteger(actual) && actual >= 0 ? actual : null };
}
function serviceErrorKind(status) {
if (status === 0) return "network";
if (status === 408) return "timeout";
if (status === 429) return "rate_limit";
if (status >= 500) return "service";
return "response";
}
function base64Image(value, mimeType) {
let bytes;
try {
const binary = atob(String(value ?? ""));
bytes = new Uint8Array(binary.length);
for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
} catch {
throw new ComposerServiceError("生图服务返回了无效图片数据", 422, { retryable: true });
}
if (!bytes.length || bytes.length > LIBRARY_TRANSFER_LIMITS.maxImageBytes) {
throw new ComposerServiceError("生成图片为空或超过本地单图容量上限", 422, { retryable: false });
}
return new Blob([bytes], { type: mimeType });
}
function imageBlobFromDataUrl(value) {
const match = String(value ?? "").match(/^data:(image\/(?:png|jpeg|webp));base64,([A-Za-z0-9+/=]+)$/i);
if (!match) throw new ComposerServiceError("参考图数据无效,本次没有发送不完整参考", 422, { retryable: true });
return base64Image(match[2], match[1].toLocaleLowerCase("en-US"));
}
function imageExtension(mimeType) {
if (mimeType === "image/jpeg") return "jpg";
if (mimeType === "image/png") return "png";
if (mimeType === "image/webp") return "webp";
return "";
}
async function downloadGeneratedImage(value, options = {}) {
let url;
try { url = new URL(String(value ?? "")); }
catch { throw new ComposerServiceError("生图服务返回了无效图片地址", 422, { retryable: true }); }
if (url.protocol !== "https:") throw new ComposerServiceError("生图服务返回的图片地址不是 HTTPS", 422, { retryable: false });
options.onPhase?.("downloading");
try {
const blob = await fetchBoundedMedia(url, {
kind: "image",
maxBytes: LIBRARY_TRANSFER_LIMITS.maxImageBytes,
timeoutMs: IMAGE_REQUEST_TIMEOUT_MS,
signal: options.signal,
fetchImpl: options.fetchImpl,
accept: "image/png,image/jpeg,image/webp"
});
if (!["image/png", "image/jpeg", "image/webp"].includes(blob.type)) {
throw new Error("生成服务返回了暂不支持的图片格式");
}
return blob;
} catch (error) {
if (error instanceof ComposerServiceError) throw error;
throw new ComposerServiceError(error.message || "生成图片下载失败", 422, { retryable: false, cause: error });
}
}