gaoding-cli 1.0.0-alpha.5

package/dist/src/api/direct-tools.js

@@ -0,0 +1,1155 @@
+import { existsSync } from "node:fs";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { CredentialStoreV2 } from "../auth/credential-store-v2.js";
+import { composeMattingImage, fetchImageBuffer } from "../utils/matting-compose.js";
+import { isTransientNetworkError } from "../utils/transient-network-error.js";
+import { detectEntitlementIssue } from "../utils/entitlement.js";
+import { resolveEndpoints } from "../utils/endpoints.js";
+import { DamClient } from "./dam-client.js";
+import { DirectApiClient, unwrapEnvelope } from "./direct-client.js";
+import { getConfiguredModel, modelEntriesForType, publicModelByCode, resolveModelEntry, resolveModelOrder, } from "../models/model-catalog.js";
+import { readSettings, writeSettings } from "../utils/settings-store.js";
+import { assertSafeHttpUrl } from "../utils/url-safety.js";
+export class MediaResourceError extends Error {
+    url;
+    code = "MEDIA_RESOURCE_UNREACHABLE";
+    constructor(message, url) {
+        super(message);
+        this.url = url;
+        this.name = "MediaResourceError";
+    }
+}
+const FAILURE_STATUSES = new Set(["FAIL", "NOT_PASSED", "AUDITED_FAILED"]);
+const RUNNING_STATUSES = new Set(["WAITING", "RUNNING", "PENDING", "STARTED", "INIT"]);
+const MODEL_CATEGORY_CODES = {
+    image: "image-model-art",
+    video: "AI-video-generation",
+};
+export class DirectToolInvoker {
+    client;
+    dam;
+    constructor(client = new DirectApiClient()) {
+        this.client = client;
+        this.dam = new DamClient(this.client);
+    }
+    async invoke(toolName, params, options = {}) {
+        const normalizedName = normalizeToolName(toolName);
+        const handler = this.handlers[normalizedName];
+        if (!handler) {
+            throw new Error(`暂不支持直连工具: ${toolName}。可用工具: ${Object.keys(this.handlers).join(", ")}`);
+        }
+        return handler(params, options);
+    }
+    handlers = {
+        upload: async (params) => {
+            const file = requiredString(params.file ?? params.image ?? params.video, "upload 需要 --file");
+            const asset = await this.dam.uploadLocalAsset(file, {
+                allowSensitivePath: allowSensitivePath(params),
+            });
+            return completed("asset-upload", {
+                id: asset.id,
+                storage_id: asset.storage_id,
+                url: asset.url,
+                filename: asset.filename,
+                format: asset.format,
+                mime_type: asset.mime_type,
+                object_name: asset.object_name,
+                registered: false,
+                scope: "cdn",
+                source: asset.source,
+            });
+        },
+        title: async (params, options) => {
+            const prompt = requiredString(params.prompt ?? params.brief ?? params.input, "title 需要 --prompt 或 --brief");
+            const contentId = optionalString(params.content_id);
+            const summary = await this.callSyncTool("title-generation", withOptionalContentId({
+                input: prompt,
+            }, contentId), options);
+            return completed("title-generation", withOptionalContentId({
+                text: primaryText(summary),
+            }, contentId));
+        },
+        prompt: async (params, options) => {
+            const prompt = requiredString(params.prompt ?? params.brief ?? params.input, "prompt 需要 --prompt 或 --brief");
+            const media = await this.optionalRemoteImage(params);
+            assertRequiredReferenceImage(media, params, "text.prompt");
+            const payload = { prompt };
+            if (media) {
+                payload.image = media.url;
+            }
+            else if (params.image_prompt) {
+                payload.image_prompt = String(params.image_prompt);
+            }
+            else {
+                payload.image_prompt = prompt;
+            }
+            const summary = await this.callAsyncTool("autoPrompt-advise", payload, options);
+            return resultFromSummary("autoPrompt-advise", summary);
+        },
+        cutout: async (params, options) => {
+            const image = await this.requireRemoteImage(params);
+            assertMattingSupportedLocalImage(image.uploaded);
+            const requestedMode = optionalString(params.mode) ?? "auto";
+            const mode = await this.resolveMattingMode(image.url, requestedMode, options);
+            const toolMap = {
+                portrait: "matting-person",
+                product: "matting-product",
+                graphic: "matting-graphs",
+            };
+            const summary = await this.callSyncTool(toolMap[mode], { image: image.url, result_img_path: mattingResultPath() }, options);
+            const result = resultFromSummary(toolMap[mode], summary, {
+                mode,
+                requested_mode: requestedMode,
+                uploaded: image.uploaded,
+            });
+            const outputs = result.outputs;
+            if (outputs && typeof outputs.url === "string") {
+                const maskUrl = outputs.url;
+                const composeMask = shouldComposeMattingMask(params);
+                if (composeMask) {
+                    try {
+                        const [sourceBuf, maskBuf] = await Promise.all([
+                            fetchImageBuffer(image.url),
+                            fetchImageBuffer(maskUrl),
+                        ]);
+                        const composed = await composeMattingImage(sourceBuf, maskBuf);
+                        const uploaded = await this.uploadPngBuffer(composed);
+                        outputs.mask_url = maskUrl;
+                        outputs.url = uploaded.url;
+                        outputs.mime_type = uploaded.mime_type;
+                        outputs.composed = true;
+                    }
+                    catch (error) {
+                        outputs.mask_url = maskUrl;
+                        outputs.composed = false;
+                        outputs.compose_error = errorMessage(error);
+                    }
+                }
+                else {
+                    outputs.mask_url = maskUrl;
+                    outputs.composed = false;
+                }
+                if (outputs.composed !== true) {
+                    outputs.mime_type = inferMimeTypeFromUrl(maskUrl);
+                }
+                outputs.assets = buildMattingAssets(outputs, image);
+            }
+            return result;
+        },
+        generate: async (params, options) => {
+            const prompt = requiredString(params.prompt ?? params.input, "generate 需要 prompt");
+            const image = await this.optionalRemoteImage(params);
+            assertRequiredReferenceImage(image, params, "image.generate");
+            if (image)
+                await ensureReferenceImageDownloadable(image, "image");
+            return this.invokeModelOrderedAsyncTool({
+                modelType: "image",
+                params,
+                promptItems: buildPromptItems(prompt, image ? [image] : []),
+                parameters: pickStringParams(params, ["ratio", "resolution"]),
+                uploaded: image?.uploaded,
+                options,
+            });
+        },
+        video: async (params, options) => {
+            const prompt = requiredString(params.prompt ?? params.input, "video 需要 prompt");
+            const image = await this.optionalRemoteImage(params);
+            assertRequiredReferenceImage(image, params, "video.generate");
+            const videoReference = image
+                ? await this.prepareVideoReferenceImage(image, options)
+                : undefined;
+            return this.invokeModelOrderedAsyncTool({
+                modelType: "video",
+                params,
+                promptItems: buildPromptItems(prompt, videoReference ? [videoReference.media] : [], ["高清首帧参考图"]),
+                parameters: pickStringParams(params, ["ratio", "resolution", "duration"]),
+                uploaded: image?.uploaded,
+                extraOutputs: videoReference?.outputs,
+                options,
+            });
+        },
+        vectorize: async (params) => {
+            const image = await this.requireRemoteImage(params);
+            const response = await this.client.post("/open/editor/ai/tools/v10/img2svg", {
+                image_url: image.url,
+                mode: optionalString(params.mode) ?? "auto",
+            });
+            const data = unwrapEnvelope(response);
+            if (typeof data.code === "number" && data.code !== 0) {
+                throw new Error(data.message || data.msg || "图转 SVG 失败");
+            }
+            if (!data.url)
+                throw new Error("图转 SVG 失败：接口没有返回 url");
+            return completed("img2svg", {
+                url: data.url,
+                mime_type: "image/svg+xml",
+            });
+        },
+        upscale: async (params, options) => {
+            const image = await this.requireRemoteImage(params);
+            const mode = optionalString(params.mode) ?? "uhd-plus";
+            if (mode === "uhd-plus") {
+                const contentId = resolveNumericContentId(optionalString(params.content_id));
+                const summary = await this.callAsyncTool("super-resolution-plus", withOptionalContentId({
+                    image: image.url,
+                }, contentId.value), options);
+                return resultFromSummary("super-resolution-plus", summary, {
+                    mode,
+                    content_id: contentId.value,
+                    content_id_generated: contentId.generated,
+                    ...(contentId.requested && contentId.requested !== contentId.value
+                        ? { requested_content_id: contentId.requested }
+                        : {}),
+                    uploaded: image.uploaded,
+                });
+            }
+            const sceneCode = mode === "hd" ? "super-resolution" : "super-resolution-4x";
+            const create = unwrapEnvelope(await this.client.post("/gdesign/tool/ai/super-resolution", {
+                url: image.url,
+                scene_code: sceneCode,
+            }));
+            if (create.code !== 0 || !create.task_id) {
+                throw new Error(create.message || "创建超分任务失败");
+            }
+            if (options.async) {
+                return submitted(create.task_id, "super-resolution", {
+                    mode,
+                    scene_code: sceneCode,
+                });
+            }
+            return this.pollSuperResolution(create.task_id, sceneCode, options);
+        },
+    };
+    async requireRemoteImage(params) {
+        const value = params.image ?? params.image_url ?? params.image_file ?? params.file;
+        const image = await this.remoteMedia(value, params);
+        if (!image) {
+            throw new Error("需要提供图片：--image / --image-url / --image-file / --file");
+        }
+        return image;
+    }
+    async optionalRemoteImage(params) {
+        const value = params.image ?? params.image_url ?? params.image_file ?? params.file;
+        return this.remoteMedia(value, params);
+    }
+    async remoteMedia(value, params) {
+        const input = optionalString(value);
+        if (!input)
+            return null;
+        if (/^https?:\/\//i.test(input)) {
+            return {
+                url: assertSafeHttpUrl(input, { context: "媒体 URL" }),
+                source: "url",
+            };
+        }
+        const filePath = resolve(process.cwd(), input);
+        if (!existsSync(filePath)) {
+            throw new Error(`文件不存在或不是 URL: ${input}`);
+        }
+        const uploaded = await this.dam.uploadLocalAsset(filePath, {
+            allowSensitivePath: allowSensitivePath(params),
+        });
+        return {
+            url: uploaded.url,
+            source: "uploaded",
+            uploaded,
+        };
+    }
+    async uploadPngBuffer(buffer) {
+        const dir = await mkdtemp(join(tmpdir(), "gd-cli-matting-"));
+        const filePath = join(dir, `cutout-${Date.now()}.png`);
+        try {
+            await writeFile(filePath, buffer);
+            return await this.dam.uploadLocalAsset(filePath);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    }
+    async resolveMattingMode(image, requestedMode, options) {
+        if (requestedMode === "portrait" || requestedMode === "product" || requestedMode === "graphic") {
+            return requestedMode;
+        }
+        if (requestedMode !== "auto") {
+            throw new Error("cutout 仅支持 --mode auto、portrait、product、graphic");
+        }
+        const summary = await this.callSyncTool("matting-classify", { image }, options);
+        const classifyType = Number(primaryText(summary));
+        const map = {
+            0: "graphic",
+            1: "portrait",
+            2: "product",
+        };
+        const mode = map[classifyType];
+        if (!mode)
+            throw new Error(`无法识别抠图分类结果: ${classifyType}`);
+        return mode;
+    }
+    async prepareVideoReferenceImage(image, options) {
+        await ensureReferenceImageDownloadable(image, "image");
+        const upscale = await this.handlers.upscale({ image: image.url, mode: "hd" }, {
+            ...options,
+            async: false,
+            timeout: Math.max(options.timeout ?? 0, 600),
+        });
+        const hdUrl = taskOutputString(upscale, "url", "视频参考图高清化结果缺少 url");
+        const media = { url: hdUrl, source: "url" };
+        await ensureReferenceImageDownloadable(media, "video");
+        return {
+            media,
+            outputs: {
+                reference_image_url: image.url,
+                reference_image_source: image.source,
+                video_reference_image_url: hdUrl,
+                video_reference_preprocess: {
+                    tool: "image.super-res",
+                    mode: "hd",
+                    status: upscale.status,
+                    outputs: upscale.outputs,
+                },
+            },
+        };
+    }
+    async invokeModelOrderedAsyncTool(payload) {
+        const legacyStyleCode = optionalString(payload.params.style_code);
+        const explicitModel = optionalString(payload.params.model);
+        const explicitModelCode = resolveRequestedModelCode(payload.modelType, explicitModel);
+        const configuredModelCode = explicitModel === undefined
+            ? resolveRequestedModelCode(payload.modelType, getConfiguredModel(payload.modelType))
+            : undefined;
+        const sceneCodes = legacyStyleCode
+            ? [legacyStyleCode]
+            : await this.resolveDailyCachedModelOrder(payload.modelType, explicitModel);
+        const strictSingleModel = Boolean(legacyStyleCode);
+        const attemptedModels = [];
+        let lastError;
+        for (const sceneCode of sceneCodes) {
+            attemptedModels.push(sceneCode);
+            let apiPath = "/ai-agent/v1/tool-intent";
+            let resolvedTool;
+            try {
+                const toolIntent = await this.resolveToolIntent({
+                    prompt: payload.promptItems,
+                    scene_code: sceneCode,
+                    parameters: payload.parameters,
+                });
+                resolvedTool = toolIntent.sceneCode;
+                apiPath = "/gdesign/tool/v1/dify/call_async";
+                const contentId = resolveNumericContentId(optionalString(payload.params.content_id));
+                const summary = await this.callAsyncTool(toolIntent.sceneCode, withOptionalContentId({
+                    ...normalizeMediaUrlArguments(toolIntent.argumentsPayload),
+                }, contentId.value), payload.options);
+                return resultFromSummary(toolIntent.sceneCode, summary, {
+                    content_id: contentId.value,
+                    content_id_generated: contentId.generated,
+                    ...(contentId.requested && contentId.requested !== contentId.value
+                        ? { requested_content_id: contentId.requested }
+                        : {}),
+                    style_code: sceneCode,
+                    selected_model: selectedModelOutput(payload.modelType, sceneCode, {
+                        source: legacyStyleCode
+                            ? "style_code"
+                            : explicitModelCode
+                                ? "model"
+                                : configuredModelCode
+                                    ? "settings"
+                                    : "platform",
+                    }),
+                    attempted_models: attemptedModels,
+                    uploaded: payload.uploaded,
+                    ...(payload.extraOutputs ?? {}),
+                });
+            }
+            catch (error) {
+                const contextualError = maybeAttachEntitlementContext(error, buildEntitlementDiagnosticContext({
+                    apiPath,
+                    selectedModel: sceneCode,
+                    resolvedTool,
+                    attemptedModels,
+                }));
+                lastError = contextualError;
+                const isLast = attemptedModels.length >= sceneCodes.length;
+                if (strictSingleModel || isLast || !shouldRetryModelFallback(contextualError)) {
+                    throw contextualError;
+                }
+            }
+        }
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    }
+    async resolveDailyCachedModelOrder(type, explicitModel) {
+        const baseOrder = resolveModelOrder(type, explicitModel);
+        const preferredModelCode = resolvePreferredModelCode(type, explicitModel);
+        const settings = readSettings();
+        const date = todayKey();
+        const cached = settings.model_cache?.[type];
+        if (cached?.date === date && cached.codes.length > 0) {
+            return cached.source === "remote"
+                ? orderFromPlatformModelCache(type, cached.codes, preferredModelCode)
+                : orderFromModelCache(baseOrder, cached.codes);
+        }
+        const staleRemoteCodes = cached?.source === "remote"
+            ? activePlatformModelCodes(type, cached.codes.map((code) => ({ model: { code, status: 1 } })))
+            : [];
+        let remoteCodes;
+        try {
+            const models = unwrapEnvelope(await this.client.get("/mns/models", {
+                query: { codes: [MODEL_CATEGORY_CODES[type]] },
+            }));
+            const activeCodes = activePlatformModelCodes(type, models);
+            if (activeCodes.length > 0) {
+                remoteCodes = activeCodes;
+            }
+        }
+        catch {
+            // MNS 只用于模型排序，刷新失败时不能阻断生成。
+        }
+        const cacheCodes = remoteCodes
+            ?? (staleRemoteCodes.length > 0 ? staleRemoteCodes : modelEntriesForType(type).map((model) => model.code));
+        const source = remoteCodes || staleRemoteCodes.length > 0 ? "remote" : "fallback";
+        const latestSettings = readSettings();
+        writeSettings({
+            ...latestSettings,
+            model_cache: {
+                ...(latestSettings.model_cache ?? {}),
+                [type]: {
+                    date,
+                    codes: cacheCodes,
+                    source,
+                    fetched_at: remoteCodes
+                        ? new Date().toISOString()
+                        : cached?.fetched_at ?? new Date().toISOString(),
+                },
+            },
+        });
+        return source === "remote"
+            ? orderFromPlatformModelCache(type, cacheCodes, preferredModelCode)
+            : orderFromModelCache(baseOrder, cacheCodes);
+    }
+    async resolveSceneCode(explicit, categoryCode, errorMessage) {
+        if (explicit)
+            return explicit;
+        const models = unwrapEnvelope(await this.client.get("/mns/models", {
+            query: { codes: [categoryCode] },
+        }));
+        const active = models.find((item) => item.model?.code && item.model.status === 1);
+        const fallback = models.find((item) => item.model?.code);
+        const code = active?.model?.code ?? fallback?.model?.code;
+        if (!code)
+            throw new Error(errorMessage);
+        return code;
+    }
+    async resolveToolIntent(payload) {
+        const response = unwrapEnvelope(await this.client.post("/ai-agent/v1/tool-intent", payload));
+        if (!response.scene_code) {
+            throw new Error("tool-intent 没有返回 scene_code");
+        }
+        const args = typeof response.arguments === "string"
+            ? safeJsonObject(response.arguments)
+            : response.arguments;
+        if (!args || typeof args !== "object" || Array.isArray(args)) {
+            throw new Error("tool-intent 没有返回有效 arguments");
+        }
+        return {
+            sceneCode: response.scene_code,
+            argumentsPayload: args,
+        };
+    }
+    async callSyncTool(name, args, options) {
+        const response = unwrapEnvelope(await this.client.post("/gdesign/tool/v1/dify/call_sync", buildToolCallBody(name, args)));
+        assertDifyOk(response);
+        if (hasFinalPayload(response))
+            return summarize(response);
+        if (!response.task_id)
+            throw new Error("call_sync 返回缺少 task_id");
+        if (options.async)
+            return summarize(response);
+        return this.pollDifyTask(response.task_id, true, options);
+    }
+    async callAsyncTool(name, args, options) {
+        const response = unwrapEnvelope(await this.client.post("/gdesign/tool/v1/dify/call_async", buildToolCallBody(name, args)));
+        assertDifyOk(response);
+        if (hasFinalPayload(response))
+            return summarize(response);
+        if (!response.task_id)
+            throw new Error("call_async 返回缺少 task_id");
+        if (options.async)
+            return summarize(response);
+        return this.pollDifyTask(response.task_id, false, options);
+    }
+    async pollDifyTask(taskId, syncTask, options) {
+        const timeoutMs = (options.timeout ?? 120) * 1000;
+        const startedAt = Date.now();
+        let transientFailures = 0;
+        while (true) {
+            const path = syncTask
+                ? "/gdesign/tool/v1/dify/task/process"
+                : "/gdesign/tool/v1/dify/process";
+            let response;
+            try {
+                response = unwrapEnvelope(await this.client.get(path, {
+                    query: { task_id: taskId },
+                }));
+                transientFailures = 0;
+            }
+            catch (error) {
+                if (!isTransientNetworkError(error) ||
+                    transientFailures >= 3 ||
+                    Date.now() - startedAt >= timeoutMs) {
+                    throw error;
+                }
+                transientFailures += 1;
+                await sleep(1000 * transientFailures);
+                continue;
+            }
+            assertDifyOk(response);
+            const summary = summarize(response);
+            if (summary.text.length > 0 || summary.resources.length > 0)
+                return summary;
+            if (summary.task_status && FAILURE_STATUSES.has(summary.task_status)) {
+                throw new Error(difyErrorMessage(response));
+            }
+            if (summary.task_status && !RUNNING_STATUSES.has(summary.task_status))
+                return summary;
+            if (Date.now() - startedAt >= timeoutMs) {
+                throw new Error(`轮询超时，task_id=${taskId}`);
+            }
+            await sleep(syncTask ? 1000 : 2000);
+        }
+    }
+    async pollSuperResolution(taskId, sceneCode, options) {
+        const timeoutMs = (options.timeout ?? 120) * 1000;
+        const startedAt = Date.now();
+        let transientFailures = 0;
+        while (true) {
+            let data;
+            try {
+                data = unwrapEnvelope(await this.client.post("/gdesign/tool/ai/super-resolution/search", { task_id: taskId }));
+                transientFailures = 0;
+            }
+            catch (error) {
+                if (!isTransientNetworkError(error) ||
+                    transientFailures >= 3 ||
+                    Date.now() - startedAt >= timeoutMs) {
+                    throw error;
+                }
+                transientFailures += 1;
+                await sleep(1000 * transientFailures);
+                continue;
+            }
+            if (data.code !== 0)
+                throw new Error(data.message || "查询超分任务失败");
+            if (data.status === "SUCCESS" && data.result_url) {
+                return completed(taskId, {
+                    url: data.result_url,
+                    scene_code: sceneCode,
+                    mime_type: inferMimeTypeFromUrl(data.result_url),
+                });
+            }
+            if (data.status && !["PENDING", "RETRY", "STARTED"].includes(data.status)) {
+                throw new Error(data.message || `超分任务状态异常: ${data.status}`);
+            }
+            if (Date.now() - startedAt >= timeoutMs) {
+                throw new Error(`超分轮询超时，task_id=${taskId}`);
+            }
+            await sleep(2000);
+        }
+    }
+}
+function assertMattingSupportedLocalImage(uploaded) {
+    if (!uploaded)
+        return;
+    if (uploaded.format === "avif" || uploaded.format === "heic" || uploaded.format === "heif") {
+        throw new Error(`当前抠图后端不支持 ${uploaded.format.toUpperCase()} 图片。请先把 ${uploaded.filename} 转成 PNG/JPEG，或换用真实 PNG/JPEG 商品图。`);
+    }
+}
+function assertRequiredReferenceImage(media, params, toolName) {
+    const required = booleanParam(params.require_image) ||
+        booleanParam(params.reference_image_required) ||
+        booleanParam(params.must_use_reference_image);
+    if (!required || media)
+        return;
+    throw new Error([
+        `REFERENCE_IMAGE_REQUIRED: ${toolName} 当前被声明为基于参考图执行，但没有拿到真实图片。`,
+        "请提供 --image / --image-url / --image-file / --file 指向原始附件、本地图片或可访问 URL。",
+        "不要根据图片描述重新生成替代参考图；只有用户明确要求重新生成相似参考图时才允许。",
+    ].join("\n"));
+}
+function booleanParam(value) {
+    return value === true || value === "true" || value === "1" || value === 1;
+}
+function buildToolCallBody(name, args) {
+    return {
+        jsonrpc: "2.0",
+        id: 0,
+        method: "tools/call",
+        params: {
+            name,
+            arguments: args,
+        },
+    };
+}
+function withOptionalContentId(value, contentId) {
+    if (!contentId)
+        return value;
+    return {
+        ...value,
+        content_id: contentId,
+    };
+}
+export function resolveNumericContentId(requested) {
+    if (requested && isJavaLongLikeNumber(requested)) {
+        return { value: requested, generated: false, requested };
+    }
+    return {
+        value: generateNumericContentId(),
+        generated: true,
+        requested,
+    };
+}
+function isJavaLongLikeNumber(value) {
+    return /^\d{1,19}$/.test(value) && BigInt(value) <= 9223372036854775807n;
+}
+function generateNumericContentId() {
+    const suffix = Math.floor(Math.random() * 100000)
+        .toString()
+        .padStart(5, "0");
+    return `${Date.now()}${suffix}`;
+}
+function errorMessage(error) {
+    if (!error || typeof error !== "object")
+        return String(error);
+    return "message" in error && typeof error.message === "string" ? error.message : String(error);
+}
+function maybeAttachEntitlementContext(error, context) {
+    const entitlement = detectEntitlementIssue({
+        message: errorMessage(error),
+        detail: error,
+    });
+    if (!entitlement)
+        return error;
+    return attachDiagnosticContext(error, context);
+}
+function attachDiagnosticContext(error, context) {
+    const target = error instanceof Error ? error : new Error(String(error));
+    const existing = diagnosticContextFrom(error);
+    const merged = compact({
+        ...(existing ?? {}),
+        ...context,
+    });
+    if (Object.keys(merged).length > 0) {
+        target
+            .diagnostic_context = merged;
+    }
+    return target;
+}
+function diagnosticContextFrom(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const direct = value.diagnostic_context;
+    if (!direct || typeof direct !== "object" || Array.isArray(direct))
+        return undefined;
+    return direct;
+}
+function buildEntitlementDiagnosticContext(input) {
+    let endpointContext = {};
+    try {
+        const endpoints = resolveEndpoints();
+        endpointContext = {
+            environment: endpoints.active_env,
+            business_id: endpoints.business_id.value,
+            channel_id: endpoints.channel_id.value,
+        };
+    }
+    catch {
+        endpointContext = {};
+    }
+    let credentialContext = {};
+    try {
+        const creds = new CredentialStoreV2().read();
+        credentialContext = {
+            org_id: creds?.current_org?.id,
+            org_name: creds?.current_org?.name,
+            user_id: creds?.user?.id,
+        };
+    }
+    catch {
+        credentialContext = {};
+    }
+    return compact({
+        ...endpointContext,
+        ...credentialContext,
+        api_path: input.apiPath,
+        selected_model: input.selectedModel,
+        resolved_tool: input.resolvedTool,
+        attempted_models: input.attemptedModels,
+    });
+}
+function todayKey() {
+    return new Date().toISOString().slice(0, 10);
+}
+function resolveRequestedModelCode(type, value) {
+    if (!value || value.trim().toLowerCase() === "auto")
+        return undefined;
+    return resolveModelEntry(type, value).code;
+}
+function resolvePreferredModelCode(type, explicitModel) {
+    if (explicitModel !== undefined) {
+        return resolveRequestedModelCode(type, explicitModel);
+    }
+    return resolveRequestedModelCode(type, getConfiguredModel(type));
+}
+function activePlatformModelCodes(type, models) {
+    const knownCodes = new Set(modelEntriesForType(type).map((model) => model.code));
+    return uniqueStrings(models
+        .map((item) => item.model)
+        .filter((model) => Boolean(model?.code))
+        .filter((model) => model.status === undefined || model.status === 1)
+        .map((model) => model.code)
+        .filter((code) => knownCodes.has(code)));
+}
+function orderFromPlatformModelCache(type, platformCodes, preferredModelCode) {
+    const platformOrder = activePlatformModelCodes(type, platformCodes.map((code) => ({ model: { code, status: 1 } })));
+    if (platformOrder.length === 0) {
+        throw new Error(`平台没有返回可用的${modelTypeLabel(type)}模型顺序`);
+    }
+    return uniqueStrings(preferredModelCode ? [preferredModelCode, ...platformOrder] : platformOrder);
+}
+function orderFromModelCache(baseOrder, cachedCodes) {
+    const available = new Set(cachedCodes);
+    const filtered = baseOrder.filter((code) => available.has(code));
+    return filtered.length > 0 ? filtered : baseOrder;
+}
+function modelTypeLabel(type) {
+    return type === "image" ? "图像" : "视频";
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function shouldRetryModelFallback(error) {
+    if (isTransientNetworkError(error))
+        return true;
+    const message = errorMessage(error);
+    if (/没有可用的工具|tool-intent 没有返回|tool intent 没有返回|敏感|安全|审核|not[_\s-]?passed|audit|content|quota|额度|余额|point|credit|权限|permission|401|403|参数|必填|invalid|MEDIA_RESOURCE_UNREACHABLE/i.test(message)) {
+        return false;
+    }
+    return /tool-intent|scene_code|模型|model|unsupported|not support|暂不支持|第三方|三方|服务异常|timeout|超时|call_async|call_sync/i.test(message);
+}
+function selectedModelOutput(type, code, meta) {
+    return {
+        ...(publicModelByCode(type, code) ?? { code }),
+        source: meta.source,
+    };
+}
+function mattingResultPath() {
+    const suffix = Math.random().toString(16).slice(2, 10);
+    return `temp/gd-cli-matting-${Date.now()}-${suffix}.png`;
+}
+function shouldComposeMattingMask(params) {
+    if (params.raw_mask === true || params.raw_mask === "true")
+        return false;
+    if (params.compose_mask === false || params.compose_mask === "false")
+        return false;
+    return true;
+}
+function buildMattingAssets(outputs, image) {
+    const assets = [];
+    if (typeof outputs.url === "string") {
+        assets.push({
+            role: "result",
+            label: outputs.composed ? "抠图后（透明 PNG）" : "抠图后图片",
+            type: "image",
+            url: outputs.url,
+            mime_type: outputs.mime_type,
+        });
+    }
+    if (typeof outputs.mask_url === "string" && outputs.mask_url !== outputs.url) {
+        assets.push({
+            role: "mask",
+            label: "抠图 mask",
+            type: "image",
+            url: outputs.mask_url,
+        });
+    }
+    assets.push({
+        role: "source",
+        label: "抠图前原图",
+        type: "image",
+        url: image.url,
+        mime_type: image.uploaded?.mime_type,
+        filename: image.uploaded?.filename,
+    });
+    return assets;
+}
+function getContent(response) {
+    return response.result?.content ?? [];
+}
+function summarize(response) {
+    const content = getContent(response);
+    const task = content.find((item) => item.type === "task")?.task;
+    return {
+        text: content
+            .filter((item) => item.type === "text" && item.text)
+            .map((item) => item.text),
+        resources: content
+            .filter((item) => item.type === "resource" && item.resource?.uri)
+            .map((item) => ({
+            url: item.resource?.uri,
+            mime_type: item.resource?.mimeType ?? item.resource?.mineType,
+        })),
+        task_id: response.task_id,
+        dify_task_id: response.dify_task_id,
+        task_status: task?.status,
+        raw: response,
+    };
+}
+function resultFromSummary(taskIdPrefix, summary, meta = {}) {
+    if (summary.resources.length > 0 || summary.text.length > 0) {
+        const first = summary.resources[0];
+        return completed(summary.task_id ?? taskIdPrefix, {
+            ...(first ? { url: first.url, mime_type: first.mime_type } : {}),
+            ...(summary.resources.length > 1 ? { urls: summary.resources.map((r) => r.url) } : {}),
+            ...(summary.text.length > 0 ? { text: primaryText(summary) } : {}),
+            ...(summary.dify_task_id ? { dify_task_id: summary.dify_task_id } : {}),
+            ...compact(meta),
+        });
+    }
+    if (summary.task_id) {
+        return submitted(summary.task_id, "dify", {
+            dify_task_id: summary.dify_task_id,
+            task_status: summary.task_status,
+            ...compact(meta),
+        });
+    }
+    return completed(taskIdPrefix, { ...compact(meta), raw: summary.raw });
+}
+function taskOutputString(result, key, message) {
+    const outputs = result.outputs;
+    const value = outputs?.[key];
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    throw new Error(message);
+}
+function completed(taskId, outputs) {
+    return {
+        task_id: taskId,
+        status: "completed",
+        outputs: compact(outputs),
+    };
+}
+function submitted(taskId, backend, outputs = {}) {
+    return {
+        task_id: taskId,
+        status: "submitted",
+        outputs: compact({
+            task_backend: backend,
+            ...outputs,
+        }),
+        message: `任务已提交，task_id=${taskId}`,
+    };
+}
+function hasFinalPayload(response) {
+    return getContent(response).some((item) => (item.type === "text" && item.text) ||
+        (item.type === "resource" && item.resource?.uri));
+}
+function assertDifyOk(response) {
+    if (response.error) {
+        throw new Error(`${response.error.code}: ${response.error.message}`);
+    }
+    if (response.result?.error || response.result?.isError) {
+        throw new Error(difyErrorMessage(response));
+    }
+}
+function difyErrorMessage(response) {
+    const content = getContent(response);
+    return (response.error?.message ??
+        content.find((item) => item.type === "text" && item.text)?.text ??
+        content.find((item) => item.type === "task" && item.task?.message)?.task?.message ??
+        "工具调用失败");
+}
+function primaryText(summary) {
+    return summary.text.join("\n").trim();
+}
+function buildPromptItems(prompt, images, names) {
+    const items = [
+        {
+            type: "text",
+            content: prompt.trim(),
+        },
+    ];
+    images.forEach((image, index) => {
+        items.push({
+            type: "media",
+            url: image.url,
+            mime: image.uploaded?.mime_type ?? inferMimeTypeFromUrl(image.url),
+            name: names?.[index] ?? `参考图${index + 1}`,
+        });
+    });
+    return items;
+}
+async function ensureReferenceImageDownloadable(media, target) {
+    await probeReferenceImageUrl(media.url);
+    if (target === "video" && isRiskyVideoReferenceUrl(media.url)) {
+        throw new MediaResourceError("参考图当前 URL 可被本机下载，但视频生成服务无法稳定拉取这类签名或中转链接。请改用可访问的图片结果 URL，或先去掉 --image 使用文生视频。", media.url);
+    }
+}
+export async function probeReferenceImageUrl(url) {
+    const safeUrl = assertSafeHttpUrl(url, { context: "参考图 URL" });
+    let response;
+    try {
+        response = await fetch(safeUrl, {
+            method: "GET",
+            headers: {
+                "Range": "bytes=0-4095",
+                "User-Agent": "gd-cli-reference-check/1.0",
+            },
+            signal: AbortSignal.timeout(15_000),
+            redirect: "follow",
+        });
+    }
+    catch (error) {
+        throw new MediaResourceError(`参考图无法被生成服务下载：${errorMessage(error)}`, safeUrl);
+    }
+    if (!response.ok && response.status !== 206) {
+        throw new MediaResourceError(`参考图无法被生成服务下载：HTTP ${response.status}`, safeUrl);
+    }
+    const contentType = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() ?? "";
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.byteLength === 0) {
+        throw new MediaResourceError("参考图无法被生成服务下载：文件为空", safeUrl);
+    }
+    if (contentType && /^(text\/html|application\/json|text\/plain|application\/xml|text\/xml)$/.test(contentType)) {
+        throw new MediaResourceError(`参考图 URL 返回的不是图片内容：${contentType}`, safeUrl);
+    }
+    if (!contentType && !hasImageExtension(safeUrl) && !looksLikeImageBytes(bytes)) {
+        throw new MediaResourceError("参考图 URL 返回的内容不像图片文件", safeUrl);
+    }
+}
+export function isSignedDamReferenceUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return (parsed.searchParams.has("auth_key") &&
+            /(^|\.)dancf\.com$/i.test(parsed.hostname) &&
+            /gdesign-dam|dam|gd.*dam/i.test(parsed.hostname));
+    }
+    catch {
+        return false;
+    }
+}
+export function isRiskyVideoReferenceUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const host = parsed.hostname.toLowerCase();
+        if (host.includes("matting-batch.dancf.com"))
+            return false;
+        if (isSignedDamReferenceUrl(url))
+            return true;
+        if (host.includes("dify-grsai"))
+            return true;
+        if (parsed.searchParams.has("auth_key") && host.endsWith("dancf.com"))
+            return true;
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function hasImageExtension(url) {
+    try {
+        return /\.(png|jpe?g|webp|gif|bmp|tiff?|svg)(\?|$)/i.test(new URL(url).pathname);
+    }
+    catch {
+        return false;
+    }
+}
+function looksLikeImageBytes(bytes) {
+    if (bytes.length < 4)
+        return false;
+    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff)
+        return true;
+    if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47)
+        return true;
+    if (bytes.slice(0, 4).toString("ascii") === "RIFF" && bytes.slice(8, 12).toString("ascii") === "WEBP")
+        return true;
+    if (bytes.slice(0, 3).toString("ascii") === "GIF")
+        return true;
+    return false;
+}
+function pickStringParams(params, keys) {
+    const picked = {};
+    for (const key of keys) {
+        const value = optionalString(params[key]);
+        if (value)
+            picked[key] = value;
+    }
+    return Object.keys(picked).length ? picked : undefined;
+}
+export function normalizeMediaUrlArguments(args) {
+    const normalized = Object.fromEntries(Object.entries(args).map(([key, value]) => [key, normalizeMaybeUrlValue(key, value)]));
+    return withInferredPreviewUrl(normalized);
+}
+function normalizeMaybeUrlValue(key, value) {
+    if (Array.isArray(value)) {
+        const normalized = value.map((item) => typeof item === "string" ? normalizeMaybeUrlString(key, item) : item);
+        if (shouldStringifyUrlArray(key))
+            return JSON.stringify(normalized);
+        if (normalized.length === 1 && typeof normalized[0] === "string") {
+            return normalized[0];
+        }
+        if (shouldKeepUrlArray(key))
+            return normalized;
+        return normalized;
+    }
+    if (typeof value === "string") {
+        const parsedArray = shouldKeepUrlArray(key) ? parseStringArray(value) : null;
+        if (parsedArray)
+            return normalizeMaybeUrlValue(key, parsedArray);
+        return normalizeMaybeUrlString(key, value);
+    }
+    return value;
+}
+function normalizeMaybeUrlString(key, value) {
+    const stripped = stripBracketedSingleUrl(value);
+    if (/^https?:\/\//i.test(stripped)) {
+        return assertSafeHttpUrl(stripped, { context: `${key} URL` });
+    }
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(stripped) && isUrlLikeKey(key)) {
+        throw new Error(`${key} 仅支持 http/https URL`);
+    }
+    return stripped;
+}
+function parseStringArray(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("["))
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        return Array.isArray(parsed) && parsed.every((item) => typeof item === "string")
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isUrlLikeKey(key) {
+    const normalized = key.toLowerCase();
+    return normalized.includes("url") || normalized.includes("uri") || normalized === "image" || normalized === "video";
+}
+function shouldKeepUrlArray(key) {
+    const normalized = key.toLowerCase();
+    return (normalized === "images" ||
+        normalized === "videos" ||
+        normalized === "files" ||
+        normalized.endsWith("_urls") ||
+        normalized.endsWith("urls") ||
+        normalized.endsWith("_images") ||
+        normalized.endsWith("_videos") ||
+        normalized.endsWith("_files"));
+}
+function shouldStringifyUrlArray(key) {
+    const normalized = key.toLowerCase();
+    return normalized === "image_urls" || normalized.endsWith("_urls");
+}
+function withInferredPreviewUrl(args) {
+    if (typeof args.preview === "string" && /^https?:\/\//.test(args.preview))
+        return args;
+    const firstImageUrl = firstUrlFrom(args.image_urls) ?? firstUrlFrom(args.images);
+    if (!firstImageUrl)
+        return args;
+    return {
+        ...args,
+        preview: firstImageUrl,
+    };
+}
+function firstUrlFrom(value) {
+    if (typeof value === "string" && /^https?:\/\//.test(value))
+        return value;
+    if (typeof value === "string" && value.trim().startsWith("[")) {
+        try {
+            const parsed = JSON.parse(value);
+            return firstUrlFrom(parsed);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!Array.isArray(value))
+        return undefined;
+    return value.find((item) => typeof item === "string" && /^https?:\/\//.test(item));
+}
+function stripBracketedSingleUrl(value) {
+    const trimmed = value.trim();
+    const bracketed = trimmed.match(/^\[(https?:\/\/[^\]]+)\]$/);
+    return bracketed?.[1] ?? trimmed;
+}
+function requiredString(value, message) {
+    const normalized = optionalString(value);
+    if (!normalized)
+        throw new Error(message);
+    return normalized;
+}
+function optionalString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function safeJsonObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeToolName(name) {
+    const map = {
+        "text.title": "title",
+        "text.prompt": "prompt",
+        "text.prompt-advise": "prompt",
+        "prompt-advise": "prompt",
+        "image.generate": "generate",
+        "image.cutout": "cutout",
+        "image.matting": "cutout",
+        matting: "cutout",
+        "image.svg": "vectorize",
+        svg: "vectorize",
+        "image.super-res": "upscale",
+        "super-res": "upscale",
+        "asset.upload": "upload",
+        "cdn.upload": "upload",
+        "dam.upload": "upload",
+        "video.generate": "video",
+    };
+    return map[name] ?? name;
+}
+function allowSensitivePath(params) {
+    return (params.allow_sensitive_path === true ||
+        params.allowSensitivePath === true ||
+        params["allow-sensitive-path"] === true);
+}
+function inferMimeTypeFromUrl(url) {
+    const pathname = new URL(url).pathname.toLowerCase();
+    if (pathname.endsWith(".svg"))
+        return "image/svg+xml";
+    if (pathname.endsWith(".png"))
+        return "image/png";
+    if (pathname.endsWith(".webp"))
+        return "image/webp";
+    if (pathname.endsWith(".gif"))
+        return "image/gif";
+    if (/\.(mp4|webm|mov|m4v)$/i.test(pathname))
+        return "video/mp4";
+    return "image/jpeg";
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+function sleep(ms) {
+    return new Promise((resolve) => globalThis.setTimeout(resolve, ms));
+}