gaoding-cli 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/src/features/tool/dynamic-schema.js

@@ -11,6 +11,8 @@ function parameterSchema(parameter) {
     if (parameter.type === "uri[]") {
         return { type: "array", items: { type: "string", format: "uri" }, ...common };
     }
+    if (parameter.type === "number")
+        return { type: "number", ...common };
     return {
         type: "string",
         ...(parameter.options === undefined
@@ -67,29 +69,37 @@ export function buildToolArgumentsSchema(catalog, tool) {
         additionalProperties: false
     };
 }
-const ajv = new Ajv2020({ allErrors: true, strict: true });
-const addFormats = addFormatsImport;
-addFormats(ajv);
-function validator(model) {
+export function buildModelArgumentsSchema(model) {
     const properties = {
-        model: { type: "string" }
+        model: {
+            type: "string",
+            const: model.model,
+            description: "要调用的模型机器标识。"
+        }
     };
     for (const parameter of model.parameters) {
         properties[parameter.name] = parameterSchema(parameter);
     }
-    return ajv.compile({
+    return {
         type: "object",
         properties,
         required: [
             "model",
-            ...model.parameters.filter((parameter) => parameter.required).map((parameter) => parameter.name)
+            ...model.parameters
+                .filter((parameter) => parameter.required)
+                .map((parameter) => parameter.name)
         ],
         additionalProperties: false
-    });
+    };
+}
+const ajv = new Ajv2020({ allErrors: true, strict: true });
+const addFormats = addFormatsImport;
+addFormats(ajv);
+function validator(model) {
+    return ajv.compile(buildModelArgumentsSchema(model));
 }
 export function assertModelArguments(model, value) {
     if (typeof value !== "object" || value === null
-        || value.model !== model.model
         || !validator(model)(value)) {
         throw new ToolInputError();
     }

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

@@ -18,6 +18,7 @@ const toolOrder = {
 };
 const multiUriKeys = new Set([
     "image_urls",
+    "reference_images",
     "file_urls",
     "video_urls",
     "audio_urls"
@@ -98,9 +99,11 @@ function parameter(value) {
         ? "uri[]"
         : name === "start_frame" || name === "end_frame" || sourceType === "IMAGE"
             ? "uri"
-            : sourceType === "TEXT" || sourceType === "INPUT" || sourceType === "SELECT"
-                ? "string"
-                : undefined;
+            : sourceType === "NUMBER"
+                ? "number"
+                : sourceType === "TEXT" || sourceType === "INPUT" || sourceType === "SELECT"
+                    ? "string"
+                    : undefined;
     if (type === undefined)
         throw new Error("unsupported parameter");
     let options;
@@ -120,7 +123,7 @@ function parameter(value) {
         if (options.length === 0)
             throw new Error("empty options");
     }
-    const description = text(field.label) ?? text(field.description);
+    const description = text(field.description) ?? text(field.label);
     const defaultValue = field.default_value;
     const hasDefault = defaultValue !== undefined
         && defaultValue !== null

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

@@ -1,6 +1,8 @@
 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);
@@ -8,6 +10,9 @@ function isRecord(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();
@@ -43,9 +48,17 @@ function parseIntent(value) {
     };
 }
 function submittedTask(value) {
-    if (!isRecord(value) || !isRecord(value.result) || value.result.isError !== false)
-        return fail();
-    return nonBlank(value.task_id);
+    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;
@@ -53,32 +66,42 @@ function resourceName(uri) {
         url = new URL(uri);
     }
     catch {
-        return fail();
+        return protocolFailure(uri);
     }
     const segment = url.pathname.split("/").filter(Boolean).at(-1);
     if (segment === undefined)
-        return fail();
+        return protocolFailure(uri);
     try {
-        return nonBlank(decodeURIComponent(segment));
+        const decoded = decodeURIComponent(segment);
+        if (decoded.trim() === "")
+            return protocolFailure(uri);
+        return decoded;
     }
     catch {
-        return fail();
+        return protocolFailure(uri);
     }
 }
 function normalizeContent(value) {
     if (!isRecord(value))
-        return fail();
+        return protocolFailure(value);
     if (value.type === "text") {
-        return { type: "text", text: nonBlank(value.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 (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);
+        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 fail();
+        return protocolFailure(value);
     }
     return {
         type: "resource_link",
@@ -87,23 +110,102 @@ function normalizeContent(value) {
         ...(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 pollResult(value, taskId) {
     if (!Array.isArray(value))
-        return fail();
+        return protocolFailure(value);
     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();
+    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 (!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)
-        return undefined;
-    if (!Array.isArray(content))
-        return fail();
-    if (content.length === 0)
-        return undefined;
-    return content.map(normalizeContent);
+    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 {
@@ -112,7 +214,7 @@ async function safePost(transport, request) {
     catch (error) {
         if (request.signal.aborted)
             throw request.signal.reason;
-        if (error instanceof RemoteRequestError)
+        if (error instanceof RemoteRequestError || error instanceof RemoteProtocolError)
             throw error;
         throw new RemoteRequestError();
     }
@@ -138,7 +240,7 @@ export function createToolApiAdapter(dependencies) {
         async execute({ invocation, access, signal }) {
             signal.throwIfAborted();
             const managedContentId = contentId(createContentId());
-            const intent = parseIntent(await safePost(dependencies.transport, {
+            const intent = await dependencies.telemetry.stage("intent", async () => parseIntent(await safePost(dependencies.transport, {
                 path: "/ai-agent/v1/tool-intent",
                 body: {
                     prompt: invocation.prompt,
@@ -148,53 +250,64 @@ export function createToolApiAdapter(dependencies) {
                 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 }
+            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: intent.name,
+                            arguments: { ...intent.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;
                     }
-                },
-                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;
+                    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);
                 }
-                const result = pollResult(response, taskId);
-                if (result !== undefined)
-                    return result;
-                await sleep(2_000, signal);
-            }
+            });
         }
     };
 }

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

@@ -48,7 +48,7 @@ function remoteMedia(value, name) {
 export function createToolUseCases(dependencies) {
     async function load(access, signal) {
         signal.throwIfAborted();
-        const catalog = await dependencies.catalog.load({ access, signal });
+        const catalog = await dependencies.telemetry.stage("catalog", () => (dependencies.catalog.load({ access, signal })));
         signal.throwIfAborted();
         for (const warning of catalog.warnings)
             dependencies.warn(warning);
@@ -69,48 +69,77 @@ export function createToolUseCases(dependencies) {
         },
         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 model = await dependencies.telemetry.stage("input", () => {
+                const modelName = input.arguments.model;
+                if (typeof modelName !== "string")
+                    throw new ToolInputError();
+                const selected = findToolModel(catalog, input.name, modelName);
+                assertModelArguments(selected, input.arguments);
+                return selected;
+            });
+            const { model: ignoredModel, ...parameters } = input.arguments;
+            void ignoredModel;
+            dependencies.telemetry.annotate({
+                tool_name: model.tool,
+                model_id: model.model,
+                parameters
+            });
             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 });
+            const requestParameters = {};
+            const prepare = async () => {
+                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 {
+                            requestParameters[parameter.name] = value;
+                        }
+                        continue;
                     }
-                    else {
-                        parameters[parameter.name] = value;
+                    if (parameter.type === "number") {
+                        requestParameters[parameter.name] = value;
+                        continue;
                     }
-                    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);
+                    const values = parameter.type === "uri[]" ? value : [value];
+                    for (const mediaUrl of values) {
                         signal.throwIfAborted();
-                        prompt.push({
-                            type: "media",
-                            url: uploaded.url,
-                            mime: uploaded.mediaType,
-                            name: parameter.name
-                        });
-                    }
-                    else {
-                        prompt.push(remoteMedia(mediaUrl, parameter.name));
+                        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));
+                        }
                     }
                 }
+            };
+            const hasLocalMedia = model.parameters.some((parameter) => {
+                const value = input.arguments[parameter.name];
+                return parameter.type === "uri"
+                    ? typeof value === "string" && value.startsWith("file:")
+                    : parameter.type === "uri[]"
+                        && Array.isArray(value) && value.some((url) => url.startsWith("file:"));
+            });
+            if (hasLocalMedia) {
+                await dependencies.telemetry.stage("upload", prepare);
+            }
+            else {
+                await prepare();
             }
             signal.throwIfAborted();
             const content = await dependencies.execution.execute({
-                invocation: { model: model.model, prompt, parameters },
+                invocation: { model: model.model, prompt, parameters: requestParameters },
                 access,
                 signal
             });

package/dist/src/features/update/update-service.js

@@ -57,20 +57,22 @@ export function createUpdateService(options) {
     return {
         async run(signal) {
             signal.throwIfAborted();
-            const latest = await fetchLatest(fetchPackage, signal);
+            const latest = await options.telemetry.stage("registry", () => (fetchLatest(fetchPackage, signal)));
             signal.throwIfAborted();
             const skillOptions = {
                 env,
                 ...(options.homeDirectory ? { homeDirectory: options.homeDirectory } : {})
             };
             if (!gt(latest, options.currentVersion)) {
-                try {
-                    await syncSkills(options.bundledSkills, skillOptions);
-                }
-                catch (error) {
-                    rethrowAbort(signal);
-                    throw new UpdateError("UPDATE_FAILED", `gd-cli ${options.currentVersion} 无需更新，但 Agent Skill 同步失败。`, ["请解决冲突后重新执行 gd-cli update。"]);
-                }
+                await options.telemetry.stage("sync", async () => {
+                    try {
+                        await syncSkills(options.bundledSkills, skillOptions);
+                    }
+                    catch (error) {
+                        rethrowAbort(signal);
+                        throw new UpdateError("UPDATE_FAILED", `gd-cli ${options.currentVersion} 无需更新，但 Agent Skill 同步失败。`, ["请解决冲突后重新执行 gd-cli update。"]);
+                    }
+                });
                 return { version: options.currentVersion, updated: false };
             }
             const binaryPath = options.binaryPath ?? process.argv[1] ?? "";
@@ -89,25 +91,29 @@ export function createUpdateService(options) {
             const args = source.manager === "npm"
                 ? ["install", "--global", "--allow-scripts=gaoding-cli", `gaoding-cli@${latest}`]
                 : ["add", "--global", "--allow-build=gaoding-cli", `gaoding-cli@${latest}`];
-            try {
-                await runProcess(command, args, signal);
-            }
-            catch (error) {
-                rethrowAbort(signal);
-                throw new UpdateError("UPDATE_FAILED", `gd-cli 更新到 ${latest} 失败。`, nextSteps);
-            }
+            await options.telemetry.stage("install", async () => {
+                try {
+                    await runProcess(command, args, signal);
+                }
+                catch (error) {
+                    rethrowAbort(signal);
+                    throw new UpdateError("UPDATE_FAILED", `gd-cli 更新到 ${latest} 失败。`, nextSteps);
+                }
+            });
             signal.throwIfAborted();
             const targetSkills = options.bundledSkills.map((skill) => ({
                 ...skill,
                 version: latest
             }));
-            try {
-                await verifySkills(targetSkills, skillOptions);
-            }
-            catch (error) {
-                rethrowAbort(signal);
-                throw new UpdateError("UPDATE_PARTIAL", `gd-cli 已更新到 ${latest}，但 Agent Skill 验收失败。`, ["请重新执行 gd-cli update。"]);
-            }
+            await options.telemetry.stage("verify", async () => {
+                try {
+                    await verifySkills(targetSkills, skillOptions);
+                }
+                catch (error) {
+                    rethrowAbort(signal);
+                    throw new UpdateError("UPDATE_PARTIAL", `gd-cli 已更新到 ${latest}，但 Agent Skill 验收失败。`, ["请重新执行 gd-cli update。"]);
+                }
+            });
             return { version: latest, updated: true };
         }
     };

package/dist/src/platform/json-input.js

@@ -52,6 +52,9 @@ function readStream(stream, signal) {
         };
         const onAbort = () => {
             cleanup();
+            const destroy = stream.destroy;
+            if (typeof destroy === "function")
+                destroy.call(stream);
             reject(signal.reason);
         };
         stream.on("data", onData);