gaoding-cli 1.0.0-alpha.10

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

@@ -0,0 +1,262 @@
+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",
+    "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 === "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.label) ?? text(field.description);
+    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,200 @@
+import { randomInt } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+const MAX_JAVA_LONG = 9223372036854775807n;
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function fail() {
+    throw new RemoteRequestError();
+}
+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 submittedTask(value) {
+    if (!isRecord(value) || !isRecord(value.result) || value.result.isError !== false)
+        return fail();
+    return nonBlank(value.task_id);
+}
+function resourceName(uri) {
+    let url;
+    try {
+        url = new URL(uri);
+    }
+    catch {
+        return fail();
+    }
+    const segment = url.pathname.split("/").filter(Boolean).at(-1);
+    if (segment === undefined)
+        return fail();
+    try {
+        return nonBlank(decodeURIComponent(segment));
+    }
+    catch {
+        return fail();
+    }
+}
+function normalizeContent(value) {
+    if (!isRecord(value))
+        return fail();
+    if (value.type === "text") {
+        return { type: "text", text: nonBlank(value.text) };
+    }
+    if (value.type !== "resource" || !isRecord(value.resource))
+        return fail();
+    if ("blob" in value.resource || "text" in value.resource)
+        return fail();
+    const uri = nonBlank(value.resource.uri);
+    const mimeType = value.resource.mimeType;
+    if (mimeType !== undefined && (typeof mimeType !== "string" || mimeType.trim() === "")) {
+        return fail();
+    }
+    return {
+        type: "resource_link",
+        uri,
+        name: resourceName(uri),
+        ...(mimeType === undefined ? {} : { mimeType })
+    };
+}
+function pollResult(value, taskId) {
+    if (!Array.isArray(value))
+        return fail();
+    const item = value.find((candidate) => isRecord(candidate) && candidate.task_id === taskId);
+    if (!isRecord(item) || item.code !== "200")
+        return fail();
+    const inner = parseRecord(nonBlank(item.result));
+    if (!isRecord(inner.result) || inner.result.isError !== false)
+        return fail();
+    const content = inner.result.content;
+    if (content === undefined)
+        return undefined;
+    if (!Array.isArray(content))
+        return fail();
+    if (content.length === 0)
+        return undefined;
+    return content.map(normalizeContent);
+}
+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)
+            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 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
+            }));
+            signal.throwIfAborted();
+            const taskId = submittedTask(await safePost(dependencies.transport, {
+                path: "/gdesign/tool/v1/dify/call_async",
+                body: {
+                    jsonrpc: "2.0",
+                    id: 0,
+                    method: "tools/call",
+                    params: {
+                        name: intent.name,
+                        arguments: { ...intent.arguments, content_id: managedContentId }
+                    }
+                },
+                credential: access.credential,
+                organizationId: access.organizationId,
+                signal
+            }));
+            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 result = pollResult(response, taskId);
+                if (result !== undefined)
+                    return result;
+                await sleep(2_000, signal);
+            }
+        }
+    };
+}

package/dist/src/features/tool/use-cases.js

@@ -0,0 +1,126 @@
+import { parseSafeRemoteAssetUrl, UrlSafetyError } from "../../platform/url-safety.js";
+import { findToolModel, projectModelDetail, projectModelList, projectToolList, ToolInputError } from "./catalog.js";
+import { assertModelArguments, buildToolArgumentsSchema } from "./dynamic-schema.js";
+const mediaTypes = {
+    avif: "image/avif",
+    gif: "image/gif",
+    heic: "image/heic",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    mov: "video/quicktime",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    png: "image/png",
+    wav: "audio/wav",
+    webm: "video/webm",
+    webp: "image/webp"
+};
+function inferRemoteMediaType(url) {
+    const segment = url.pathname.split("/").filter(Boolean).at(-1) ?? "";
+    let filename = segment;
+    try {
+        filename = decodeURIComponent(segment);
+    }
+    catch {
+        // The extension remains usable when the path contains malformed escapes.
+    }
+    const extension = filename.split(".").at(-1)?.toLowerCase();
+    return extension === undefined || extension === filename.toLowerCase()
+        ? "application/octet-stream"
+        : mediaTypes[extension] ?? "application/octet-stream";
+}
+function remoteMedia(value, name) {
+    try {
+        const url = parseSafeRemoteAssetUrl(value);
+        return {
+            type: "media",
+            url: value,
+            mime: inferRemoteMediaType(url),
+            name
+        };
+    }
+    catch (error) {
+        if (error instanceof UrlSafetyError)
+            throw new ToolInputError();
+        throw error;
+    }
+}
+export function createToolUseCases(dependencies) {
+    async function load(access, signal) {
+        signal.throwIfAborted();
+        const catalog = await dependencies.catalog.load({ access, signal });
+        signal.throwIfAborted();
+        for (const warning of catalog.warnings)
+            dependencies.warn(warning);
+        return catalog;
+    }
+    return {
+        async listTools({ access, signal }) {
+            return projectToolList(await load(access, signal));
+        },
+        async listModels({ input, access, signal }) {
+            return projectModelList(await load(access, signal), input.tool);
+        },
+        async getModel({ input, access, signal }) {
+            return projectModelDetail(await load(access, signal), input.model);
+        },
+        async getArgumentsSchema({ name, access, signal }) {
+            return buildToolArgumentsSchema(await load(access, signal), name);
+        },
+        async call({ input, access, signal }) {
+            const catalog = await load(access, signal);
+            const modelName = input.arguments.model;
+            if (typeof modelName !== "string")
+                throw new ToolInputError();
+            const model = findToolModel(catalog, input.name, modelName);
+            assertModelArguments(model, input.arguments);
+            const prompt = [];
+            const parameters = {};
+            for (const parameter of model.parameters) {
+                signal.throwIfAborted();
+                const value = input.arguments[parameter.name];
+                if (value === undefined)
+                    continue;
+                if (parameter.type === "string") {
+                    if (parameter.name === "prompt") {
+                        prompt.push({ type: "text", content: value });
+                    }
+                    else {
+                        parameters[parameter.name] = value;
+                    }
+                    continue;
+                }
+                const values = parameter.type === "uri[]" ? value : [value];
+                for (const mediaUrl of values) {
+                    signal.throwIfAborted();
+                    if (mediaUrl.startsWith("file:")) {
+                        const uploaded = await dependencies.uploader.upload({ url: mediaUrl }, access, signal);
+                        signal.throwIfAborted();
+                        prompt.push({
+                            type: "media",
+                            url: uploaded.url,
+                            mime: uploaded.mediaType,
+                            name: parameter.name
+                        });
+                    }
+                    else {
+                        prompt.push(remoteMedia(mediaUrl, parameter.name));
+                    }
+                }
+            }
+            signal.throwIfAborted();
+            const content = await dependencies.execution.execute({
+                invocation: { model: model.model, prompt, parameters },
+                access,
+                signal
+            });
+            return {
+                content,
+                usage: {
+                    model: model.model,
+                    ...(model.cost === undefined ? {} : { cost: model.cost })
+                }
+            };
+        }
+    };
+}