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

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

@@ -0,0 +1,66 @@
+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);
+    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;
+    const code = value.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

@@ -0,0 +1,10 @@
+export class RemoteProtocolError extends Error {
+    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

@@ -0,0 +1,156 @@
+const detailedStages = {
+    "auth.login": new Set(["authorize", "wait", "identity", "bind"]),
+    "org.switch": new Set(["list", "bind"]),
+    "agent.send:execute": new Set(["upload", "execute", "result"]),
+    "tool.call:execute": new Set(["catalog", "upload", "intent", "submit", "wait"]),
+    "dam.upload": new Set(["inspect", "repository", "prepare", "upload", "persist", "wait"]),
+    update: new Set(["registry", "install", "sync", "verify"])
+};
+export function createTelemetryInvocation(options) {
+    const traceId = options.traceIdFactory();
+    const startedAt = options.now();
+    let definition;
+    const context = {};
+    const stages = [];
+    return {
+        traceId,
+        get selected() {
+            return definition !== undefined;
+        },
+        traceparent() {
+            return `00-${traceId}-${options.spanIdFactory()}-${traceFlags(definition)}`;
+        },
+        select(nextDefinition) {
+            definition = nextDefinition;
+        },
+        annotate(annotation) {
+            if (annotation.account_id !== undefined)
+                context.account_id = annotation.account_id;
+            if (annotation.organization_id !== undefined) {
+                context.organization_id = annotation.organization_id;
+            }
+            if (annotation.tool_name !== undefined)
+                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 };
+            }
+        },
+        async stage(name, run) {
+            const stageStartedAt = options.now();
+            try {
+                const result = await run();
+                stages.push({
+                    name,
+                    durationMs: elapsed(options.now(), stageStartedAt),
+                    outcome: "success"
+                });
+                return result;
+            }
+            catch (error) {
+                const classification = options.classifyError(error);
+                stages.push({
+                    name,
+                    durationMs: elapsed(options.now(), stageStartedAt),
+                    outcome: classification.outcome,
+                    error,
+                    ...(classification.errorCode === undefined
+                        ? {}
+                        : { errorCode: classification.errorCode }),
+                    ...(classification.httpStatus === undefined
+                        ? {}
+                        : { httpStatus: classification.httpStatus })
+                });
+                throw error;
+            }
+        },
+        finish(completion) {
+            if (!definition)
+                return [];
+            const selectedDefinition = definition;
+            const mode = selectedDefinition.mode?.();
+            const allowedStages = detailedStages[stageKey(selectedDefinition.operation, mode)];
+            const stageEvents = allowedStages
+                ? stages
+                    .filter((stage) => allowedStages.has(stage.name))
+                    .map((stage) => ({
+                    schema_version: "2",
+                    event_name: "stage_finished",
+                    trace_id: traceId,
+                    operation: selectedDefinition.operation,
+                    stage: stage.name,
+                    outcome: stage.outcome,
+                    duration_ms: stage.durationMs,
+                    ...(stage.errorCode === undefined ? {} : { error_code: stage.errorCode }),
+                    ...(stage.httpStatus === undefined ? {} : { http_status: stage.httpStatus })
+                }))
+                : [];
+            const command = {
+                schema_version: "2",
+                event_name: "command_finished",
+                trace_id: traceId,
+                operation: selectedDefinition.operation,
+                ...(mode === undefined ? {} : { mode }),
+                outcome: completion.outcome,
+                duration_ms: elapsed(options.now(), startedAt),
+                cli_version: options.cliVersion,
+                os: options.runtime.os,
+                arch: options.runtime.arch,
+                node_major: options.runtime.nodeMajor,
+                ...(context.account_id === undefined ? {} : { account_id: context.account_id }),
+                ...(context.organization_id === undefined
+                    ? {}
+                    : { 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 } }),
+                ...(completion.outcome === "failure"
+                    ? {
+                        error_code: completion.errorCode,
+                        error_message: completion.errorMessage,
+                        failure_stage: stages.find((stage) => stage.error === completion.error)?.name
+                            ?? "unknown",
+                        ...(completion.httpStatus === undefined
+                            ? {}
+                            : { http_status: completion.httpStatus }),
+                        ...(completion.remoteErrorCode === undefined
+                            ? {}
+                            : { remote_error_code: completion.remoteErrorCode }),
+                        ...(completion.remoteErrorBody === undefined
+                            ? {}
+                            : { remote_error_body: completion.remoteErrorBody })
+                    }
+                    : {})
+            };
+            return [...stageEvents, command];
+        }
+    };
+}
+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}`;
+}
+function elapsed(now, startedAt) {
+    return Math.max(0, now - startedAt);
+}

package/dist/src/telemetry/sls-sink.js

@@ -0,0 +1,31 @@
+const trackingUrl = new URL("https://gaoding-log-ai-gpu.cn-hangzhou.log.aliyuncs.com/logstores/gd-cli/track?APIVersion=0.6.0");
+const TIMEOUT_MS = 2_000;
+export function createSlsTelemetrySink(options) {
+    return {
+        async send(events) {
+            if (events.length === 0)
+                return;
+            try {
+                await options.fetch(trackingUrl, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ __logs__: events.map(wireEvent) }),
+                    redirect: "error",
+                    signal: AbortSignal.timeout(TIMEOUT_MS)
+                });
+            }
+            catch {
+                // Telemetry must never change command behavior.
+            }
+        }
+    };
+}
+function wireEvent(event) {
+    const wire = {};
+    for (const [key, value] of Object.entries(event)) {
+        if (value === undefined)
+            continue;
+        wire[key] = key === "parameters" ? JSON.stringify(value) : String(value);
+    }
+    return wire;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaoding-cli",
-  "version": "1.0.0-alpha.13",
+  "version": "1.0.0-alpha.15",
   "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,14 +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 tool call <tool> --schema
 gd-cli tool call <tool> --input request.json
 ```
 
-`tool list` 给出可用 Tool；`model list` 和 `model get` 给出当前可用 Model、费用与预估耗时等信息；`tool call --schema` 给出所选 Tool 的实时输入要求。不要把列表值固化在提示或脚本中。
+`tool list` 给出可用 Tool；`model list` 和 `model get` 给出当前可用 Model、说明、费用、预估耗时和结构化参数。`model get` 的 `parameters` 是所选 Model 的实际调用元数据：遵循 `required`、`type`、`description`，SELECT 参数使用 `options[].value`，required 参数带 `default` 时在用户未指定时显式传入默认值。`usageDescription` 描述跨字段规则，例如视频 mode 对首尾帧或素材字段的要求；这类组合不能只从单个字段推断。不要把列表值固化在提示或脚本中。
+
+按所选 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，也不要读取用户未明确授权的路径。

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

@@ -3,8 +3,10 @@
 - `stdout` 只承载命令结果；结构化命令的 JSON 可直接解析。
 - `stderr` 承载警告、授权提示和错误；不要把警告混入结果。
 - 退出码 `0` 表示成功。
-- 退出码 `1` 表示运行、服务或状态失败；读取错误码与“下一步”，处理后再重试。
+- 退出码 `1` 表示运行、服务或状态失败；只执行错误中 `error.details.next_steps` 明确给出的恢复步骤，缺失时停止并报告。
 - 退出码 `2` 表示命令或参数错误；执行对应命令的 `--help` 后修正调用。
 - 退出码 `130` 表示用户中断；立即停止，不自动重试。
 
+Agent 或 Tool 等可能消耗稿豆的请求如果可能已经提交、但完成状态未知，停止并报告，不自动重试原调用。
+
 不要从未知错误中推断内部实现，也不要输出本地凭证、请求签名或带敏感查询参数的 URL。命令失败且没有安全恢复步骤时，保留原始 stderr 的公开错误码并向用户说明。