gaoding-cli 1.0.0-alpha.14 → 1.0.0-alpha.16

package/README.md

@@ -29,10 +29,9 @@ gd-cli agent send --schema
 gd-cli tool list
 gd-cli model list --tool <tool>
 gd-cli model get <model>
-gd-cli model get <model> --schema
 ```
 
-选定 Model 后，`model get --schema` 给出该 Model 的实际运行时输入；`tool call --schema` 给出整个 Tool 的参数并集。运行 `gd-cli --help` 查看当前命令；运行任一命令的 `--help` 查看参数。`gd-cli update` 固定检查 npm `latest`，支持更新 npm、pnpm 全局安装并同步 Agent Skill。
+选定 Model 后，以 `model get` 返回的 `parameters` 与 `usageDescription` 构造实际输入；`tool call --schema` 只给出整个 Tool 的参数并集。运行 `gd-cli --help` 查看当前命令；运行任一命令的 `--help` 查看参数。`gd-cli update` 固定检查 npm `latest`，支持更新 npm、pnpm 全局安装并同步 Agent Skill。
 
 ## License
 

package/dist/bin/gd-cli.js

@@ -1,13 +1,23 @@
 #!/usr/bin/env node
-import { createCli, executeCli } from "../src/bootstrap/create-cli.js";
-import { createProductionRuntime } from "../src/bootstrap/create-runtime.js";
-import { mapCliError } from "../src/cli/errors.js";
-import { redact } from "../src/platform/redact.js";
 const controller = new AbortController();
 const interrupt = () => controller.abort(new Error("SIGINT"));
 process.once("SIGINT", interrupt);
 let runtime;
+let mapCliError;
+let redact;
 try {
+    // Register SIGINT before loading the CLI graph so a cold-start interrupt is
+    // converted into the same abort path as an interrupt during stdin reading.
+    const [cliModule, runtimeModule, errorsModule, redactModule] = await Promise.all([
+        import("../src/bootstrap/create-cli.js"),
+        import("../src/bootstrap/create-runtime.js"),
+        import("../src/cli/errors.js"),
+        import("../src/platform/redact.js")
+    ]);
+    const { createCli, executeCli } = cliModule;
+    const { createProductionRuntime } = runtimeModule;
+    mapCliError = errorsModule.mapCliError;
+    redact = redactModule.redact;
     runtime = createProductionRuntime();
     const program = createCli(runtime, { signal: controller.signal });
     process.exitCode = await executeCli({
@@ -20,21 +30,30 @@ try {
     });
 }
 catch (error) {
-    const outcome = redact(mapCliError(error, { aborted: controller.signal.aborted }));
-    if (runtime) {
-        runtime.presenter.error(outcome, { json: process.argv.includes("--json") });
-    }
-    else if (outcome.kind === "interrupted") {
-        process.stderr.write("已取消。\n");
-    }
-    else if (process.argv.includes("--json")) {
-        process.stderr.write(`${JSON.stringify({ error: outcome.failure })}\n`);
+    // Dynamic module loading can fail before the error mapper is available.
+    // Keep that rare startup failure bounded and avoid an unhandled rejection.
+    if (mapCliError === undefined || redact === undefined) {
+        process.stderr.write("INTERNAL_ERROR: CLI 启动失败。\n");
+        process.exitCode = 1;
     }
     else {
-        process.stderr.write(`${outcome.failure.code}: ${outcome.failure.message}\n`);
+        const outcome = redact(mapCliError(error, { aborted: controller.signal.aborted }));
+        if (runtime) {
+            runtime.presenter.error(outcome, { json: process.argv.includes("--json") });
+        }
+        else if (outcome.kind === "interrupted") {
+            process.stderr.write("已取消。\n");
+        }
+        else if (process.argv.includes("--json")) {
+            process.stderr.write(`${JSON.stringify({ error: outcome.failure })}\n`);
+        }
+        else {
+            process.stderr.write(`${outcome.failure.code}: ${outcome.failure.message}\n`);
+        }
+        process.exitCode = outcome.exitCode;
     }
-    process.exitCode = outcome.exitCode;
 }
 finally {
     process.removeListener("SIGINT", interrupt);
 }
+export {};

package/dist/src/bootstrap/create-cli.js

@@ -2,7 +2,7 @@ import { Command, CommanderError } from "commander";
 import { assertAllLeafCommandsBound, configureActionEnvironment } from "../cli/action-binding.js";
 import { registerAgentCommands } from "../cli/agent-commands.js";
 import { registerAuthCommands } from "../cli/auth-commands.js";
-import { isHelpOutcome, mapCliError } from "../cli/errors.js";
+import { classifyTelemetryError, isHelpOutcome, mapCliError } from "../cli/errors.js";
 import { registerOrgCommands } from "../cli/org-commands.js";
 import { registerToolCommands } from "../cli/tool-commands.js";
 import { registerModelCommands } from "../cli/model-commands.js";
@@ -10,7 +10,6 @@ import { registerEditorCommands } from "../cli/editor-commands.js";
 import { registerDamCommands } from "../cli/dam-commands.js";
 import { registerUpdateCommand } from "../cli/update-command.js";
 import { redact } from "../platform/redact.js";
-import { RemoteRequestError } from "../platform/signed-http-transport.js";
 export { assertAllLeafCommandsBound, bindAction } from "../cli/action-binding.js";
 export function createCli(runtime, options) {
     const program = new Command()
@@ -60,12 +59,13 @@ export async function executeCli(options) {
             }
         }
         const outcome = redact(mapCliError(error, { aborted: options.signal.aborted }));
-        const invocationId = options.telemetry.selected
-            ? options.telemetry.invocationId
+        const telemetryError = classifyTelemetryError(error);
+        const traceId = options.telemetry.selected
+            ? options.telemetry.traceId
             : undefined;
         options.presenter.error(outcome, {
             json: options.argv.includes("--json"),
-            ...(invocationId ? { invocationId } : {})
+            ...(traceId ? { traceId } : {})
         });
         await sendFinished(options, outcome.kind === "interrupted"
             ? { outcome: "interrupted", error }
@@ -74,9 +74,15 @@ export async function executeCli(options) {
                 error,
                 errorCode: outcome.failure.code,
                 errorMessage: outcome.failure.message,
-                ...(error instanceof RemoteRequestError && error.status !== undefined
-                    ? { httpStatus: error.status }
-                    : {})
+                ...(telemetryError.httpStatus === undefined
+                    ? {}
+                    : { httpStatus: telemetryError.httpStatus }),
+                ...(telemetryError.remoteErrorCode === undefined
+                    ? {}
+                    : { remoteErrorCode: telemetryError.remoteErrorCode }),
+                ...(telemetryError.remoteErrorBody === undefined
+                    ? {}
+                    : { remoteErrorBody: telemetryError.remoteErrorBody })
             });
         return outcome.exitCode;
     }

package/dist/src/bootstrap/create-runtime.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import { dirname } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
@@ -53,7 +53,8 @@ export function createProductionRuntime(options = {}) {
     const telemetry = createTelemetryInvocation({
         cliVersion: primarySkill.version,
         now: () => now().getTime(),
-        idFactory: randomUUID,
+        traceIdFactory: () => randomBytes(16).toString("hex"),
+        spanIdFactory: () => randomBytes(8).toString("hex"),
         runtime: {
             os: process.platform,
             arch: process.arch,
@@ -81,28 +82,33 @@ export function createProductionRuntime(options = {}) {
     const orgTransport = createSignedHttpTransport({
         baseUrl: endpoints.orgApi,
         fetch,
-        now
+        now,
+        traceparent: () => telemetry.traceparent()
     });
     const agentTransport = createSignedHttpTransport({
         baseUrl: endpoints.agentApi,
         fetch,
-        now
+        now,
+        traceparent: () => telemetry.traceparent()
     });
     const mnsTransport = createSignedHttpTransport({
         baseUrl: endpoints.mnsApi,
         fetch,
-        now
+        now,
+        traceparent: () => telemetry.traceparent()
     });
     const toolTransport = createSignedHttpTransport({
         baseUrl: endpoints.toolApi,
         fetch,
-        now
+        now,
+        traceparent: () => telemetry.traceparent()
     });
     const damTransport = createSignedHttpTransport({
         baseUrl: endpoints.damApi,
         fetch,
         now,
-        channelId: "32"
+        channelId: "32",
+        traceparent: () => telemetry.traceparent()
     });
     const sso = createSsoService({
         ssoApi: endpoints.ssoApi,

package/dist/src/cli/errors.js

@@ -5,6 +5,7 @@ import { SsoRequestError } from "../features/auth/sso-service.js";
 import { DeviceAuthorizationExpiredError } from "../features/auth/use-cases.js";
 import { AgentInputError } from "../features/agent/use-cases.js";
 import { ToolInputError } from "../features/tool/catalog.js";
+import { ToolTaskFailedError } from "../features/tool/tool-api-adapter.js";
 import { ObjectStorageUploadError } from "../features/dam/object-storage.js";
 import { DamAssetNotFoundError } from "../features/dam/dam-api-adapter.js";
 import { DamInputError } from "../features/dam/use-cases.js";
@@ -64,6 +65,9 @@ export function mapCliError(error, options) {
     if (error instanceof RemoteProtocolError) {
         return failure("REMOTE_PROTOCOL_INCOMPATIBLE", "稿定服务返回了当前 CLI 无法安全处理的结果；为避免重复创作，已停止处理。", 1);
     }
+    if (error instanceof ToolTaskFailedError) {
+        return failure("TOOL_TASK_FAILED", "稿定工具任务执行失败。", 1);
+    }
     if (error instanceof DamAssetNotFoundError) {
         return failure("DAM_ASSET_NOT_FOUND", "未找到指定的 DAM 素材。", 1);
     }
@@ -87,12 +91,23 @@ export function mapCliError(error, options) {
 }
 export function classifyTelemetryError(error) {
     const outcome = mapCliError(error, { aborted: false });
+    const remoteError = error instanceof RemoteRequestError
+        || error instanceof RemoteProtocolError
+        || error instanceof ToolTaskFailedError
+        ? error
+        : undefined;
     return {
         outcome: outcome.kind === "interrupted" ? "interrupted" : "failure",
         ...(outcome.kind === "failure" ? { errorCode: outcome.failure.code } : {}),
         ...(error instanceof RemoteRequestError && error.status !== undefined
             ? { httpStatus: error.status }
-            : {})
+            : {}),
+        ...(remoteError?.remoteCode === undefined
+            ? {}
+            : { remoteErrorCode: remoteError.remoteCode }),
+        ...(remoteError?.remoteBody === undefined
+            ? {}
+            : { remoteErrorBody: remoteError.remoteBody })
     };
 }
 function failure(code, message, exitCode, nextSteps) {

package/dist/src/cli/model-commands.js

@@ -32,7 +32,6 @@ export function registerModelCommands(program, runtime) {
     const get = model.command("get")
         .description("查看模型完整信息")
         .argument("<model>", "模型机器标识")
-        .option("--schema", "输出所选模型的实际运行时输入 Schema")
         .allowExcessArguments(false);
     bindAction(get, "organization", async (context, signal) => {
         const modelName = get.processedArgs[0];
@@ -46,18 +45,6 @@ export function registerModelCommands(program, runtime) {
             credential: context.state.credential,
             organizationId: context.state.organization.id
         };
-        if (get.opts().schema === true) {
-            const schema = await runtime.tool.getModelArgumentsSchema({
-                model: modelName,
-                access,
-                signal
-            });
-            runtime.telemetry.annotate({ model_id: modelName });
-            await runtime.telemetry.stage("output", async () => {
-                runtime.io.writeOut(`${JSON.stringify(schema)}\n`);
-            });
-            return;
-        }
         const result = await runtime.tool.getModel({
             input,
             access,
@@ -69,9 +56,6 @@ export function registerModelCommands(program, runtime) {
             runtime.io.writeOut(`${JSON.stringify(result)}\n`);
         });
     }, {
-        operation: "model.get",
-        mode: () => get.opts().schema === true
-            ? "schema"
-            : "detail"
+        operation: "model.get"
     });
 }

package/dist/src/cli/presenter.js

@@ -30,8 +30,8 @@ export function createPresenter(options) {
                 options.writeError(`${JSON.stringify({
                     error: {
                         ...outcome.failure,
-                        ...(presentation.invocationId
-                            ? { invocation_id: presentation.invocationId }
+                        ...(presentation.traceId
+                            ? { trace_id: presentation.traceId }
                             : {})
                     }
                 })}\n`);
@@ -42,8 +42,8 @@ export function createPresenter(options) {
             if (nextSteps.length > 0) {
                 options.writeError(`下一步: ${nextSteps.join("，")}\n`);
             }
-            if (presentation.invocationId) {
-                options.writeError(`诊断 ID: ${presentation.invocationId}\n`);
+            if (presentation.traceId) {
+                options.writeError(`诊断 ID: ${presentation.traceId}\n`);
             }
         }
     };

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();
@@ -42,10 +47,33 @@ function parseIntent(value) {
         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) || 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 +81,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 +125,118 @@ 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 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 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 (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)
-        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 +245,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,33 +271,45 @@ export function createToolApiAdapter(dependencies) {
         async execute({ invocation, access, signal }) {
             signal.throwIfAborted();
             const managedContentId = contentId(createContentId());
-            const intent = await dependencies.telemetry.stage("intent", async () => 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
-            })));
+            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 () => 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
-            })));
+            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) {
@@ -191,9 +336,14 @@ export function createToolApiAdapter(dependencies) {
                         await sleep(transientFailures * 1_000, signal);
                         continue;
                     }
-                    const result = pollResult(response, taskId);
-                    if (result !== undefined)
-                        return result;
+                    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);
                 }
             });

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

@@ -1,6 +1,6 @@
 import { parseSafeRemoteAssetUrl, UrlSafetyError } from "../../platform/url-safety.js";
-import { findModel, findToolModel, projectModelDetail, projectModelList, projectToolList, ToolInputError } from "./catalog.js";
-import { assertModelArguments, buildModelArgumentsSchema, buildToolArgumentsSchema } from "./dynamic-schema.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",
@@ -67,9 +67,6 @@ export function createToolUseCases(dependencies) {
         async getArgumentsSchema({ name, access, signal }) {
             return buildToolArgumentsSchema(await load(access, signal), name);
         },
-        async getModelArgumentsSchema({ model, access, signal }) {
-            return buildModelArgumentsSchema(findModel(await load(access, signal), model));
-        },
         async call({ input, access, signal }) {
             const catalog = await load(access, signal);
             const model = await dependencies.telemetry.stage("input", () => {
@@ -89,6 +86,7 @@ export function createToolUseCases(dependencies) {
             });
             const prompt = [];
             const requestParameters = {};
+            const directArguments = {};
             const prepare = async () => {
                 for (const parameter of model.parameters) {
                     signal.throwIfAborted();
@@ -98,14 +96,17 @@ export function createToolUseCases(dependencies) {
                     if (parameter.type === "string") {
                         if (parameter.name === "prompt") {
                             prompt.push({ type: "text", content: value });
+                            directArguments[parameter.name] = value;
                         }
                         else {
                             requestParameters[parameter.name] = value;
+                            directArguments[parameter.name] = value;
                         }
                         continue;
                     }
                     if (parameter.type === "number") {
                         requestParameters[parameter.name] = value;
+                        directArguments[parameter.name] = value;
                         continue;
                     }
                     const values = parameter.type === "uri[]" ? value : [value];
@@ -141,8 +142,26 @@ export function createToolUseCases(dependencies) {
                 await prepare();
             }
             signal.throwIfAborted();
+            const requiresIntent = prompt.some((item) => item.type === "media")
+                || Object.values(requestParameters).some((value) => value === "");
+            const invocation = requiresIntent
+                ? {
+                    kind: "intent",
+                    model: model.model,
+                    prompt,
+                    parameters: requestParameters,
+                    optionalMediaParameters: model.parameters
+                        .filter((parameter) => ((parameter.type === "uri" || parameter.type === "uri[]")
+                        && !parameter.required))
+                        .map((parameter) => parameter.name)
+                }
+                : {
+                    kind: "direct",
+                    name: model.model,
+                    arguments: directArguments
+                };
             const content = await dependencies.execution.execute({
-                invocation: { model: model.model, prompt, parameters: requestParameters },
+                invocation,
                 access,
                 signal
             });

package/dist/src/platform/remote-error-evidence.js

@@ -0,0 +1,80 @@
+import { redact, redactSensitiveText } from "./redact.js";
+const maximumLength = 8_192;
+const truncationMarker = "[TRUNCATED]";
+export function remoteErrorEvidence(value) {
+    const normalized = parseJson(value);
+    const remoteCode = topLevelCode(normalized) ?? jsonRpcErrorCode(normalized);
+    const sanitized = sanitize(normalized);
+    if (sanitized === undefined) {
+        return remoteCode === undefined ? {} : { remoteCode };
+    }
+    const remoteBody = sanitized.length <= maximumLength
+        ? sanitized
+        : `${sanitized.slice(0, maximumLength - truncationMarker.length)}${truncationMarker}`;
+    return {
+        ...(remoteCode === undefined ? {} : { remoteCode }),
+        remoteBody
+    };
+}
+function parseJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function topLevelCode(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    if (!Object.prototype.hasOwnProperty.call(value, "code"))
+        return undefined;
+    return normalizeCode(value.code);
+}
+function jsonRpcErrorCode(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.jsonrpc !== "2.0"
+        || record.error === null
+        || typeof record.error !== "object"
+        || Array.isArray(record.error)) {
+        return undefined;
+    }
+    return normalizeCode(record.error.code);
+}
+function normalizeCode(code) {
+    if (typeof code === "string")
+        return redactRemoteText(code);
+    return typeof code === "number" ? String(code) : undefined;
+}
+function sanitize(value) {
+    if (typeof value === "string")
+        return redactRemoteText(value);
+    try {
+        return JSON.stringify(redactCookieAssignments(redact(value)));
+    }
+    catch {
+        return undefined;
+    }
+}
+function redactRemoteText(value) {
+    return redactCookieAssignment(redactSensitiveText(value));
+}
+function redactCookieAssignments(value) {
+    if (typeof value === "string")
+        return redactCookieAssignment(value);
+    if (value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value))
+        return value.map(redactCookieAssignments);
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        redactCookieAssignments(item)
+    ]));
+}
+function redactCookieAssignment(value) {
+    return value.replace(/\b(cookie)\s*=\s*[^\s,;}&]+/giu, "$1=[REDACTED]");
+}

package/dist/src/platform/remote-protocol.js

@@ -1,6 +1,10 @@
 export class RemoteProtocolError extends Error {
-    constructor() {
+    remoteCode;
+    remoteBody;
+    constructor(evidence = {}) {
         super("稿定服务响应与当前 CLI 不兼容。");
         this.name = "RemoteProtocolError";
+        this.remoteCode = evidence.remoteCode;
+        this.remoteBody = evidence.remoteBody;
     }
 }

package/dist/src/platform/signed-http-transport.js

@@ -1,12 +1,18 @@
+import { remoteErrorEvidence } from "./remote-error-evidence.js";
+import { RemoteProtocolError } from "./remote-protocol.js";
 import { canonicalizeQuery, signRequest } from "./signature.js";
 export class RemoteRequestError extends Error {
     status;
     transient;
-    constructor(status, transient = false) {
+    remoteCode;
+    remoteBody;
+    constructor(status, transient = false, evidence = {}) {
         super(status === undefined ? "无法连接稿定服务。" : `稿定服务请求失败（HTTP ${status}）。`);
         this.name = "RemoteRequestError";
         this.status = status;
         this.transient = transient;
+        this.remoteCode = evidence.remoteCode;
+        this.remoteBody = evidence.remoteBody;
     }
 }
 const TRANSIENT_NETWORK_CODES = new Set([
@@ -56,6 +62,8 @@ export function createSignedHttpTransport(options) {
             }),
             "X-Timestamp": String(timestamp)
         };
+        if (options.traceparent !== undefined)
+            headers.traceparent = options.traceparent();
         if (options.channelId !== undefined)
             headers["X-Channel-Id"] = options.channelId;
         if (body !== undefined)
@@ -83,14 +91,22 @@ export function createSignedHttpTransport(options) {
         }
     }
     async function json(response) {
-        if (!response.ok)
-            throw new RemoteRequestError(response.status);
+        let body;
         try {
-            return await response.json();
+            body = await response.text();
         }
         catch {
             throw new RemoteRequestError(response.status);
         }
+        const evidence = remoteErrorEvidence(body);
+        if (!response.ok)
+            throw new RemoteRequestError(response.status, false, evidence);
+        try {
+            return JSON.parse(body);
+        }
+        catch {
+            throw new RemoteProtocolError(evidence);
+        }
     }
     return {
         async getJson(request) {
@@ -101,7 +117,17 @@ export function createSignedHttpTransport(options) {
         },
         async postStream(request) {
             const response = await send("POST", request, request.accept, JSON.stringify(request.body), false);
-            if (!response.ok || !response.body)
+            if (!response.ok) {
+                let body;
+                try {
+                    body = await response.text();
+                }
+                catch {
+                    throw new RemoteRequestError(response.status);
+                }
+                throw new RemoteRequestError(response.status, false, remoteErrorEvidence(body));
+            }
+            if (!response.body)
                 throw new RemoteRequestError(response.status);
             return response.body;
         }

package/dist/src/telemetry/invocation.js

@@ -7,16 +7,19 @@ const detailedStages = {
     update: new Set(["registry", "install", "sync", "verify"])
 };
 export function createTelemetryInvocation(options) {
-    const invocationId = options.idFactory();
+    const traceId = options.traceIdFactory();
     const startedAt = options.now();
     let definition;
     const context = {};
     const stages = [];
     return {
-        invocationId,
+        traceId,
         get selected() {
             return definition !== undefined;
         },
+        traceparent() {
+            return `00-${traceId}-${options.spanIdFactory()}-${traceFlags(definition)}`;
+        },
         select(nextDefinition) {
             definition = nextDefinition;
         },
@@ -30,6 +33,13 @@ export function createTelemetryInvocation(options) {
                 context.tool_name = annotation.tool_name;
             if (annotation.model_id !== undefined)
                 context.model_id = annotation.model_id;
+            if (annotation.content_id !== undefined)
+                context.content_id = annotation.content_id;
+            if (annotation.task_id !== undefined)
+                context.task_id = annotation.task_id;
+            if (annotation.dify_task_id !== undefined) {
+                context.dify_task_id = annotation.dify_task_id;
+            }
             if (annotation.parameters !== undefined) {
                 context.parameters = { ...annotation.parameters };
             }
@@ -72,9 +82,9 @@ export function createTelemetryInvocation(options) {
                 ? stages
                     .filter((stage) => allowedStages.has(stage.name))
                     .map((stage) => ({
-                    schema_version: "1",
+                    schema_version: "2",
                     event_name: "stage_finished",
-                    invocation_id: invocationId,
+                    trace_id: traceId,
                     operation: selectedDefinition.operation,
                     stage: stage.name,
                     outcome: stage.outcome,
@@ -84,9 +94,9 @@ export function createTelemetryInvocation(options) {
                 }))
                 : [];
             const command = {
-                schema_version: "1",
+                schema_version: "2",
                 event_name: "command_finished",
-                invocation_id: invocationId,
+                trace_id: traceId,
                 operation: selectedDefinition.operation,
                 ...(mode === undefined ? {} : { mode }),
                 outcome: completion.outcome,
@@ -101,6 +111,11 @@ export function createTelemetryInvocation(options) {
                     : { organization_id: context.organization_id }),
                 ...(context.tool_name === undefined ? {} : { tool_name: context.tool_name }),
                 ...(context.model_id === undefined ? {} : { model_id: context.model_id }),
+                ...(context.content_id === undefined ? {} : { content_id: context.content_id }),
+                ...(context.task_id === undefined ? {} : { task_id: context.task_id }),
+                ...(context.dify_task_id === undefined
+                    ? {}
+                    : { dify_task_id: context.dify_task_id }),
                 ...(context.parameters === undefined
                     ? {}
                     : { parameters: { ...context.parameters } }),
@@ -112,7 +127,13 @@ export function createTelemetryInvocation(options) {
                             ?? "unknown",
                         ...(completion.httpStatus === undefined
                             ? {}
-                            : { http_status: completion.httpStatus })
+                            : { http_status: completion.httpStatus }),
+                        ...(completion.remoteErrorCode === undefined
+                            ? {}
+                            : { remote_error_code: completion.remoteErrorCode }),
+                        ...(completion.remoteErrorBody === undefined
+                            ? {}
+                            : { remote_error_body: completion.remoteErrorBody })
                     }
                     : {})
             };
@@ -120,6 +141,13 @@ export function createTelemetryInvocation(options) {
         }
     };
 }
+function traceFlags(definition) {
+    if (definition === undefined)
+        return "00";
+    const paidExecution = (definition.operation === "agent.send"
+        || definition.operation === "tool.call") && definition.mode?.() === "execute";
+    return paidExecution ? "01" : "00";
+}
 function stageKey(operation, mode) {
     return mode === undefined ? operation : `${operation}:${mode}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaoding-cli",
-  "version": "1.0.0-alpha.14",
+  "version": "1.0.0-alpha.16",
   "description": "Gaoding command-line interface for agents and people.",
   "type": "module",
   "license": "MIT",

package/skills/gd-cli/references/creation.md

@@ -3,7 +3,7 @@
 ## 选择入口
 
 - 目标开放、需要稿定 Agent 完成创作时，使用 `gd-cli agent send`。
-- 已知要调用具体图片、视频或文本能力时，依次发现 Tool、选择 Model、读取输入 Schema，再调用 Tool。
+- 已知要调用具体图片、视频或文本能力时，依次发现 Tool、选择 Model、读取 Model detail，再调用 Tool。
 - 不猜 Tool 名、Model 名或参数；以当前命令输出为准。
 
 ## Agent 创作
@@ -25,16 +25,25 @@ gd-cli agent send --input request.json
 gd-cli tool list
 gd-cli model list --tool <tool>
 gd-cli model get <model>
-gd-cli model get <model> --schema
 gd-cli tool call <tool> --input request.json
 ```
 
-`tool list` 给出可用 Tool；`model list` 和 `model get` 给出当前可用 Model、说明、费用与预估耗时；`model get --schema` 给出所选 Model 的实时运行时输入 Schema。不要把列表值固化在提示或脚本中。
+`tool list` 给出可用 Tool；`model list` 和 `model get` 给出当前可用 Model、说明、费用、预估耗时和结构化参数。`model get` 的 `parameters` 是所选 Model 的实际调用元数据：遵循 `required`、`type`、`description`，SELECT 参数使用 `options[].value`，required 参数带 `default` 时在用户未指定时显式传入默认值。`usageDescription` 描述跨字段规则，例如视频 mode 对首尾帧或素材字段的要求；这类组合不能只从单个字段推断。不要把列表值固化在提示或脚本中。
 
-按所选 Model Schema 构造 JSON：提供全部 required 字段；SELECT 参数使用 `options[].value`；required 字段带 default 且用户未指定时，在输入中显式使用该 default。存在 width、height、resolution 等专用字段时，将用户要求写入对应结构化参数，不要只写在 prompt 中。`tool call <tool> --schema` 返回整个 Tool 下所有 Model 的参数并集，只用于 Tool 级发现，不替代选定 Model 的 Schema。
+按所选 Model detail 构造 JSON：提供全部 required 字段；SELECT 参数使用 `options[].value`；required 字段带 default 且用户未指定时，在输入中显式使用该 default。存在 width、height、resolution 等专用字段时，将用户要求写入对应结构化参数，不要只写在 prompt 中。`tool call <tool> --schema` 返回整个 Tool 下所有 Model 的参数并集，只用于 Tool 级发现；选定 Model 后以 `model get` 的参数和 `usageDescription` 为准。
+
+务必将 `model get <model>` 返回的 `model` 原样放在请求 JSON 的顶层 `model` 字段（即运行时的 `arguments.model`），与所选 Model 的参数字段并列；不要只复制 `parameters`。例如：
+
+```json
+{
+  "model": "<model>",
+  "prompt": "<required prompt>",
+  "<parameter>": "<value>"
+}
+```
 
 成功结果包含 `content` 和 `usage`。`content` 是文本或资源链接；`usage` 包含所选模型及模型目录公布的稿豆价格区间，不表示实际扣费。
 
 ## 本地媒体
 
-按所选 Schema 在输入中提交本地媒体引用。CLI 会在内部通过 DAM 完成临时上传并把公网 URL 传给创作服务；不要自行伪造 URL，也不要读取用户未明确授权的路径。
+按所选 Model detail 在输入中提交本地媒体引用。CLI 会在内部通过 DAM 完成临时上传并把公网 URL 传给创作服务；不要自行伪造 URL，也不要读取用户未明确授权的路径。