@gaoding/cli 0.0.0 → 1.0.0-alpha.25

package/dist/src/features/tool/mns-catalog-adapter.js

@@ -0,0 +1,265 @@
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+export const ROOT_SCENE_CODES = [
+    "image-model-art",
+    "AI-image-generation-art",
+    "AI-video-generation",
+    "AI-text-generation"
+];
+const rootTools = {
+    "image-model-art": "image.generate",
+    "AI-image-generation-art": "image.generate",
+    "AI-video-generation": "video.generate",
+    "AI-text-generation": "text.generate"
+};
+const toolOrder = {
+    "image.generate": 0,
+    "video.generate": 1,
+    "text.generate": 2
+};
+const multiUriKeys = new Set([
+    "image_urls",
+    "reference_images",
+    "file_urls",
+    "video_urls",
+    "audio_urls"
+]);
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function text(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function requiredText(value) {
+    const result = text(value);
+    if (result === undefined)
+        throw new Error("invalid string");
+    return result;
+}
+function number(value, fallback = 0) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function cleanText(value) {
+    const result = text(value);
+    if (result === undefined)
+        return undefined;
+    return text(result.replace(/\{icon:\{[^{}]*\}\}/g, ""));
+}
+function collectScenes(raw) {
+    const roots = new Map();
+    for (const value of raw) {
+        const item = record(value);
+        if (item === undefined)
+            throw new Error("invalid scene");
+        roots.set(requiredText(item.code), item);
+    }
+    const scenes = [];
+    const seen = new Set();
+    function visit(value, tool) {
+        const code = requiredText(value.code);
+        if (!seen.has(code)) {
+            seen.add(code);
+            scenes.push({ code, tool, sort: number(value.sort) });
+        }
+        if (value.children === undefined || value.children === null)
+            return;
+        if (!Array.isArray(value.children))
+            throw new Error("invalid children");
+        for (const child of value.children) {
+            const childRecord = record(child);
+            if (childRecord === undefined)
+                throw new Error("invalid child");
+            visit(childRecord, tool);
+        }
+    }
+    for (const rootCode of ROOT_SCENE_CODES) {
+        const root = roots.get(rootCode);
+        if (root !== undefined)
+            visit(root, rootTools[rootCode]);
+    }
+    if (scenes.length === 0)
+        throw new Error("empty scenes");
+    return scenes;
+}
+function parameter(value) {
+    const field = record(value);
+    if (field === undefined)
+        throw new Error("invalid parameter");
+    if (field.is_open !== true)
+        return undefined;
+    const name = requiredText(field.key);
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name))
+        return undefined;
+    const sourceType = requiredText(field.type);
+    const type = multiUriKeys.has(name)
+        ? "uri[]"
+        : name === "start_frame" || name === "end_frame" || sourceType === "IMAGE"
+            ? "uri"
+            : sourceType === "NUMBER"
+                ? "number"
+                : sourceType === "TEXT" || sourceType === "INPUT" || sourceType === "SELECT"
+                    ? "string"
+                    : undefined;
+    if (type === undefined)
+        throw new Error("unsupported parameter");
+    let options;
+    if (sourceType === "SELECT") {
+        if (!Array.isArray(field.options))
+            throw new Error("invalid options");
+        options = field.options.map((value) => {
+            const option = record(value);
+            if (option === undefined)
+                throw new Error("invalid option");
+            const label = text(option.label);
+            return {
+                value: requiredText(option.value),
+                ...(label === undefined ? {} : { label })
+            };
+        });
+        if (options.length === 0)
+            throw new Error("empty options");
+    }
+    const description = text(field.description) ?? text(field.label);
+    const defaultValue = field.default_value;
+    const hasDefault = defaultValue !== undefined
+        && defaultValue !== null
+        && !(typeof defaultValue === "string" && defaultValue.trim() === "");
+    return {
+        name,
+        type,
+        required: field.required === true,
+        ...(description === undefined ? {} : { description }),
+        ...(hasDefault
+            ? { default: defaultValue }
+            : {}),
+        ...(options === undefined ? {} : { options })
+    };
+}
+function range(values, unit) {
+    if (values.length === 0)
+        return undefined;
+    const bounds = { minimum: Math.min(...values), maximum: Math.max(...values) };
+    return unit === "gaodou" ? { unit, ...bounds } : { unit, ...bounds };
+}
+function normalizeModel(value, scenes) {
+    const item = record(value);
+    const model = record(item?.model);
+    if (item === undefined || model === undefined || !Array.isArray(item.skus)) {
+        throw new Error("invalid model");
+    }
+    const activeSkus = item.skus.map(record).filter((sku) => sku !== undefined && sku.status === 1);
+    if (activeSkus.length === 0)
+        return undefined;
+    const code = requiredText(model.code);
+    const title = requiredText(model.name);
+    if (!Array.isArray(model.scene_categories))
+        throw new Error("invalid categories");
+    const matches = model.scene_categories
+        .map((category) => scenes.get(requiredText(record(category)?.code)))
+        .filter((scene) => scene !== undefined)
+        .toSorted((left, right) => toolOrder[left.tool] - toolOrder[right.tool]
+        || left.sort - right.sort);
+    const scene = matches[0];
+    if (scene === undefined)
+        throw new Error("unknown scene");
+    if (typeof model.input_field_settings !== "string")
+        throw new Error("missing settings");
+    const settings = JSON.parse(model.input_field_settings);
+    if (!Array.isArray(settings))
+        throw new Error("invalid settings");
+    const parameters = settings
+        .map(parameter)
+        .filter((item) => item !== undefined);
+    const description = cleanText(model.description);
+    const usageDescription = cleanText(model.tool_description);
+    const outputMediaTypes = Array.isArray(model.output_mime_types)
+        ? model.output_mime_types.map(text).filter((item) => item !== undefined)
+        : [];
+    const costs = activeSkus
+        .map((sku) => sku.point_cost)
+        .filter((value) => typeof value === "number"
+        && Number.isFinite(value) && value >= 0);
+    const times = activeSkus
+        .map((sku) => sku.estimated_time)
+        .filter((value) => typeof value === "number"
+        && Number.isFinite(value) && value >= 0);
+    const cost = range(costs, "gaodou");
+    const estimatedTime = range(times, "second");
+    return {
+        tool: scene.tool,
+        model: code,
+        title,
+        ...(description === undefined ? {} : { description }),
+        ...(usageDescription === undefined ? {} : { usageDescription }),
+        ...(outputMediaTypes.length === 0 ? {} : { outputMediaTypes }),
+        parameters,
+        ...(cost?.unit === "gaodou" ? { cost } : {}),
+        ...(estimatedTime?.unit === "second" ? { estimatedTime } : {}),
+        sceneSort: scene.sort,
+        modelSort: number(model.sort)
+    };
+}
+export function createMnsCatalogAdapter(dependencies) {
+    return {
+        async load({ access, signal }) {
+            signal.throwIfAborted();
+            try {
+                const rawScenes = await dependencies.transport.getJson({
+                    path: "/mns/scene-categories",
+                    query: { codes: ROOT_SCENE_CODES.join(",") },
+                    credential: access.credential,
+                    organizationId: access.organizationId,
+                    signal
+                });
+                if (!Array.isArray(rawScenes))
+                    throw new Error("invalid scene response");
+                const scenes = collectScenes(rawScenes);
+                const rawModels = await dependencies.transport.getJson({
+                    path: "/mns/models",
+                    query: { codes: scenes.map((scene) => scene.code).join(",") },
+                    credential: access.credential,
+                    organizationId: access.organizationId,
+                    signal
+                });
+                if (!Array.isArray(rawModels))
+                    throw new Error("invalid model response");
+                const sceneMap = new Map(scenes.map((scene) => [scene.code, scene]));
+                const models = [];
+                const seen = new Set();
+                let invalidCount = 0;
+                for (const rawModel of rawModels) {
+                    try {
+                        const model = normalizeModel(rawModel, sceneMap);
+                        if (model === undefined || seen.has(model.model))
+                            continue;
+                        seen.add(model.model);
+                        models.push(model);
+                    }
+                    catch {
+                        invalidCount += 1;
+                    }
+                }
+                models.sort((left, right) => toolOrder[left.tool] - toolOrder[right.tool]
+                    || left.sceneSort - right.sceneSort
+                    || left.modelSort - right.modelSort
+                    || (left.model < right.model ? -1 : left.model > right.model ? 1 : 0));
+                return {
+                    models,
+                    warnings: invalidCount === 0
+                        ? []
+                        : [`已忽略 ${invalidCount} 个无效模型配置。`]
+                };
+            }
+            catch (error) {
+                signal.throwIfAborted();
+                if (error instanceof RemoteRequestError)
+                    throw error;
+                throw new RemoteRequestError();
+            }
+        }
+    };
+}

package/dist/src/features/tool/tool-api-adapter.js

@@ -0,0 +1,352 @@
+import { randomInt } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+import { remoteErrorEvidence } from "../../platform/remote-error-evidence.js";
+import { RemoteProtocolError } from "../../platform/remote-protocol.js";
+const MAX_JAVA_LONG = 9223372036854775807n;
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function fail() {
+    throw new RemoteRequestError();
+}
+function protocolFailure(value) {
+    throw new RemoteProtocolError(remoteErrorEvidence(value));
+}
+function nonBlank(value) {
+    if (typeof value !== "string" || value.trim() === "")
+        return fail();
+    return value;
+}
+function parseRecord(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (!isRecord(parsed))
+            return fail();
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof RemoteRequestError)
+            throw error;
+        return fail();
+    }
+}
+function contentId(value) {
+    if (!/^\d+$/u.test(value))
+        return fail();
+    const numeric = BigInt(value);
+    if (numeric > MAX_JAVA_LONG)
+        return fail();
+    return value;
+}
+function parseIntent(value) {
+    if (!isRecord(value))
+        return fail();
+    return {
+        name: nonBlank(value.name),
+        arguments: parseRecord(nonBlank(value.arguments))
+    };
+}
+function isEmptyOptionalMedia(value) {
+    return value === undefined
+        || value === null
+        || value === ""
+        || (Array.isArray(value) && value.length === 0)
+        || (typeof value === "string" && value.trim() === "[]");
+}
+function withoutEmptyOptionalMedia(value, optionalMediaParameters) {
+    const normalized = { ...value };
+    for (const name of optionalMediaParameters) {
+        if (isEmptyOptionalMedia(normalized[name]))
+            delete normalized[name];
+    }
+    return normalized;
+}
+function submittedTask(value) {
+    if (!isRecord(value) || !isRecord(value.result))
+        return protocolFailure(value);
+    if (value.result.isError === true) {
+        throw new ToolTaskFailedError(remoteErrorEvidence(value));
+    }
+    if (value.result.isError !== false)
+        return protocolFailure(value);
+    if (typeof value.task_id !== "string" || value.task_id.trim() === "") {
+        return protocolFailure(value);
+    }
+    return value.task_id;
+}
+function resourceName(uri) {
+    let url;
+    try {
+        url = new URL(uri);
+    }
+    catch {
+        return protocolFailure(uri);
+    }
+    const segment = url.pathname.split("/").filter(Boolean).at(-1);
+    if (segment === undefined)
+        return protocolFailure(uri);
+    try {
+        const decoded = decodeURIComponent(segment);
+        if (decoded.trim() === "")
+            return protocolFailure(uri);
+        return decoded;
+    }
+    catch {
+        return protocolFailure(uri);
+    }
+}
+function normalizeContent(value) {
+    if (!isRecord(value))
+        return protocolFailure(value);
+    if (value.type === "text") {
+        if (typeof value.text !== "string" || value.text.trim() === "") {
+            return protocolFailure(value);
+        }
+        return { type: "text", text: value.text };
+    }
+    if (value.type !== "resource" || !isRecord(value.resource)) {
+        return protocolFailure(value);
+    }
+    if ("blob" in value.resource || "text" in value.resource)
+        return protocolFailure(value);
+    if (typeof value.resource.uri !== "string" || value.resource.uri.trim() === "") {
+        return protocolFailure(value);
+    }
+    const uri = value.resource.uri;
+    const mimeType = value.resource.mimeType;
+    if (mimeType !== undefined && (typeof mimeType !== "string" || mimeType.trim() === "")) {
+        return protocolFailure(value);
+    }
+    return {
+        type: "resource_link",
+        uri,
+        name: resourceName(uri),
+        ...(mimeType === undefined ? {} : { mimeType })
+    };
+}
+export class ToolTaskFailedError extends Error {
+    remoteCode;
+    remoteBody;
+    constructor(evidence = {}) {
+        super("稿定工具任务执行失败。");
+        this.name = "ToolTaskFailedError";
+        this.remoteCode = evidence.remoteCode;
+        this.remoteBody = evidence.remoteBody;
+    }
+}
+function failedPoll(error, difyTaskId) {
+    return {
+        state: "failed",
+        error,
+        ...(difyTaskId === undefined ? {} : { difyTaskId })
+    };
+}
+function optionalInnerDifyTaskId(value) {
+    if (typeof value !== "string" || value.trim() === "")
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        if (!isRecord(parsed))
+            return undefined;
+        const difyTaskId = parsed.dify_task_id;
+        return typeof difyTaskId === "string" && difyTaskId.trim() !== ""
+            ? difyTaskId
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isJsonRpcError(value) {
+    if (value.jsonrpc !== "2.0"
+        || Object.prototype.hasOwnProperty.call(value, "result")
+        || !isRecord(value.error)) {
+        return false;
+    }
+    return typeof value.error.code === "number"
+        && Number.isInteger(value.error.code)
+        && typeof value.error.message === "string"
+        && value.error.message.trim() !== "";
+}
+function pollResult(value, taskId) {
+    if (!Array.isArray(value))
+        return protocolFailure(value);
+    const item = value.find((candidate) => isRecord(candidate) && candidate.task_id === taskId);
+    if (!isRecord(item))
+        return { state: "pending" };
+    if (typeof item.code !== "string" || item.code.trim() === "") {
+        return protocolFailure(item);
+    }
+    if (item.code !== "200") {
+        return failedPoll(new ToolTaskFailedError(remoteErrorEvidence(item)), optionalInnerDifyTaskId(item.result));
+    }
+    if (typeof item.result !== "string" || item.result.trim() === "") {
+        return protocolFailure(item);
+    }
+    let inner;
+    try {
+        const parsed = JSON.parse(item.result);
+        if (!isRecord(parsed))
+            return protocolFailure(item);
+        inner = parsed;
+    }
+    catch (error) {
+        if (error instanceof RemoteProtocolError)
+            throw error;
+        return protocolFailure(item);
+    }
+    const difyTaskId = inner.dify_task_id;
+    if (difyTaskId !== undefined
+        && (typeof difyTaskId !== "string" || difyTaskId.trim() === "")) {
+        return protocolFailure(inner);
+    }
+    if (Object.prototype.hasOwnProperty.call(inner, "error")) {
+        return isJsonRpcError(inner)
+            ? failedPoll(new ToolTaskFailedError(remoteErrorEvidence(inner)), difyTaskId)
+            : failedPoll(new RemoteProtocolError(remoteErrorEvidence(inner)), difyTaskId);
+    }
+    if (!isRecord(inner.result)) {
+        return failedPoll(new RemoteProtocolError(remoteErrorEvidence(inner)), difyTaskId);
+    }
+    if (inner.result.isError === true) {
+        return failedPoll(new ToolTaskFailedError(remoteErrorEvidence(inner)), difyTaskId);
+    }
+    if (inner.result.isError !== false) {
+        return failedPoll(new RemoteProtocolError(remoteErrorEvidence(inner)), difyTaskId);
+    }
+    const content = inner.result.content;
+    if (content === undefined || (Array.isArray(content) && content.length === 0)) {
+        return {
+            state: "pending",
+            ...(difyTaskId === undefined ? {} : { difyTaskId })
+        };
+    }
+    if (!Array.isArray(content)) {
+        return failedPoll(new RemoteProtocolError(remoteErrorEvidence(inner)), difyTaskId);
+    }
+    try {
+        return {
+            state: "complete",
+            content: content.map(normalizeContent),
+            ...(difyTaskId === undefined ? {} : { difyTaskId })
+        };
+    }
+    catch (error) {
+        if (error instanceof RemoteProtocolError)
+            return failedPoll(error, difyTaskId);
+        throw error;
+    }
+}
+async function safePost(transport, request) {
+    try {
+        return await transport.postJson(request);
+    }
+    catch (error) {
+        if (request.signal.aborted)
+            throw request.signal.reason;
+        if (error instanceof RemoteRequestError || error instanceof RemoteProtocolError)
+            throw error;
+        throw new RemoteRequestError();
+    }
+}
+async function defaultSleep(milliseconds, signal) {
+    signal.throwIfAborted();
+    try {
+        await delay(milliseconds, undefined, { signal });
+    }
+    catch {
+        if (signal.aborted)
+            throw signal.reason;
+        throw new RemoteRequestError();
+    }
+}
+function defaultContentId() {
+    return (BigInt(Date.now()) * 100000n + BigInt(randomInt(100_000))).toString();
+}
+export function createToolApiAdapter(dependencies) {
+    const createContentId = dependencies.contentIdFactory ?? defaultContentId;
+    const sleep = dependencies.sleep ?? defaultSleep;
+    return {
+        async execute({ invocation, access, signal }) {
+            signal.throwIfAborted();
+            const managedContentId = contentId(createContentId());
+            const resolved = invocation.kind === "direct"
+                ? { name: invocation.name, arguments: invocation.arguments }
+                : await dependencies.telemetry.stage("intent", async () => {
+                    const intent = parseIntent(await safePost(dependencies.transport, {
+                        path: "/ai-agent/v1/tool-intent",
+                        body: {
+                            prompt: invocation.prompt,
+                            scene_code: invocation.model,
+                            parameters: invocation.parameters
+                        },
+                        credential: access.credential,
+                        organizationId: access.organizationId,
+                        signal
+                    }));
+                    return {
+                        ...intent,
+                        arguments: withoutEmptyOptionalMedia(intent.arguments, invocation.optionalMediaParameters)
+                    };
+                });
+            signal.throwIfAborted();
+            const taskId = await dependencies.telemetry.stage("submit", async () => {
+                dependencies.telemetry.annotate({ content_id: managedContentId });
+                return submittedTask(await safePost(dependencies.transport, {
+                    path: "/gdesign/tool/v1/dify/call_async",
+                    body: {
+                        jsonrpc: "2.0",
+                        id: 0,
+                        method: "tools/call",
+                        params: {
+                            name: resolved.name,
+                            arguments: { ...resolved.arguments, content_id: managedContentId }
+                        }
+                    },
+                    credential: access.credential,
+                    organizationId: access.organizationId,
+                    signal
+                }));
+            });
+            dependencies.telemetry.annotate({ task_id: taskId });
+            return dependencies.telemetry.stage("wait", async () => {
+                let transientFailures = 0;
+                while (true) {
+                    signal.throwIfAborted();
+                    let response;
+                    try {
+                        response = await safePost(dependencies.transport, {
+                            path: "/gdesign/tool/v1/dify/process/batch",
+                            body: { task_ids: [taskId] },
+                            credential: access.credential,
+                            organizationId: access.organizationId,
+                            signal
+                        });
+                        transientFailures = 0;
+                    }
+                    catch (error) {
+                        if (signal.aborted)
+                            throw signal.reason;
+                        if (!(error instanceof RemoteRequestError) || !error.transient)
+                            throw error;
+                        transientFailures += 1;
+                        if (transientFailures > 3)
+                            throw error;
+                        await sleep(transientFailures * 1_000, signal);
+                        continue;
+                    }
+                    const poll = pollResult(response, taskId);
+                    if (poll.difyTaskId !== undefined) {
+                        dependencies.telemetry.annotate({ dify_task_id: poll.difyTaskId });
+                    }
+                    if (poll.state === "failed")
+                        throw poll.error;
+                    if (poll.state === "complete")
+                        return poll.content;
+                    await sleep(2_000, signal);
+                }
+            });
+        }
+    };
+}