nolo-cli 0.1.23 → 0.1.29

package/ai/agent/cliExecutor.ts

@@ -1,7 +1,7 @@
 /**
  * CLI Executor - 通过命令行工具执行 AI 任务
  *
- * 设计为可扩展：当前支持 Copilot CLI、Gemini CLI、Codex CLI 与 Claude CLI。
+ * 设计为可扩展：当前支持 Copilot CLI、Gemini CLI、Codex CLI、Claude CLI 与 Antigravity CLI。
  *
  * 注意：
  * - CLI provider 与普通 model 路由共享 prompt / model / 最近文本上下文这些能力面
@@ -9,21 +9,22 @@
  * - 对缺少稳定增量输出协议的 CLI，流式接口允许退化为“完成后一次性回传”
  *
  * 使用方式：
- *   import { executeCli } from "ai/agent/cliExecutor";
+ *   import { executeCli } from "../agent/cliExecutor";
   *   const result = await executeCli("copilot", prompt, { model: "claude-haiku-4.5" });
  */
 
-import { exec, spawn } from "child_process";
+import { exec, execSync, spawn } from "child_process";
 import { randomUUID } from "node:crypto";
 import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { resolveLaunchableCodexCommand } from "../../connector-experimental/codexBinary";
 import { buildCliPrompt } from "./cliPrompt";
 
 // ── 类型定义 ──────────────────────────────────────────────────────────────────
 
 /** 已支持的 CLI 工具。新增时在此联合类型追加，并在 EXECUTORS 里注册实现 */
-export type CliProvider = "copilot" | "gemini" | "codex" | "claude";
+export type CliProvider = "copilot" | "gemini" | "codex" | "claude" | "agy";
 
 export interface CliExecuteOptions {
   model?: string;
@@ -31,12 +32,22 @@ export interface CliExecuteOptions {
   cwd?: string;
   env?: Record<string, string | undefined>;
   yolo?: boolean;     // 允许所有工具，默认 true（后台任务常用）
+  systemPrompt?: string;
+  reasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max";
+  temperature?: number;
+  topP?: number;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  maxTokens?: number;
+  enableThinking?: boolean;
+  thinkingBudget?: number;
 }
 
 export interface CliExecuteResult {
   text: string;       // 解析后的纯文本回复
   raw: string;        // 原始 stdout
   elapsed: number;    // 耗时 ms
+  warnings?: string[];
 }
 
 type CliSessionMessage = {
@@ -63,16 +74,163 @@ export interface CliSessionTurnResult extends CliExecuteResult {
 
 const cliSessions = new Map<string, CliSessionState>();
 
+type ProxyEnv = {
+  HTTP_PROXY?: string;
+  HTTPS_PROXY?: string;
+  ALL_PROXY?: string;
+  NO_PROXY?: string;
+  http_proxy?: string;
+  https_proxy?: string;
+  all_proxy?: string;
+  no_proxy?: string;
+};
+
+function readMacSystemProxyEnv(): ProxyEnv {
+  if (process.platform !== "darwin") return {};
+
+  try {
+    const raw = String(execSync("scutil --proxy", { encoding: "utf8" }) || "");
+    const values = new Map<string, string>();
+    for (const line of raw.split("\n")) {
+      const match = line.match(/^\s*([A-Za-z0-9_]+)\s*:\s*(.+?)\s*$/);
+      if (!match) continue;
+      values.set(match[1], match[2].replace(/^"|"$/g, ""));
+    }
+
+    const httpEnabled = values.get("HTTPEnable") === "1";
+    const httpsEnabled = values.get("HTTPSEnable") === "1";
+    const httpHost = values.get("HTTPProxy")?.trim();
+    const httpsHost = values.get("HTTPSProxy")?.trim();
+    const httpPort = values.get("HTTPPort")?.trim();
+    const httpsPort = values.get("HTTPSPort")?.trim();
+    const noProxy = values.get("ExceptionsList")?.trim();
+
+    const httpProxy = httpEnabled && httpHost && httpPort ? `http://${httpHost}:${httpPort}` : "";
+    const httpsProxy = httpsEnabled && httpsHost && httpsPort ? `http://${httpsHost}:${httpsPort}` : "";
+    const allProxy = httpsProxy || httpProxy;
+
+    return {
+      ...(httpProxy ? { HTTP_PROXY: httpProxy, http_proxy: httpProxy } : {}),
+      ...(httpsProxy ? { HTTPS_PROXY: httpsProxy, https_proxy: httpsProxy } : {}),
+      ...(allProxy ? { ALL_PROXY: allProxy, all_proxy: allProxy } : {}),
+      ...(noProxy ? { NO_PROXY: noProxy, no_proxy: noProxy } : {}),
+    };
+  } catch {
+    return {};
+  }
+}
+
+function normalizeProxyEnv(env: Record<string, string | undefined>): Record<string, string | undefined> {
+  const explicitHttp = env.HTTP_PROXY?.trim() || env.http_proxy?.trim() || "";
+  const explicitHttps = env.HTTPS_PROXY?.trim() || env.https_proxy?.trim() || "";
+  const explicitAll = env.ALL_PROXY?.trim() || env.all_proxy?.trim() || "";
+  const explicitNoProxy = env.NO_PROXY?.trim() || env.no_proxy?.trim() || "";
+  const fallback = explicitHttp || explicitHttps || explicitAll ? {} : readMacSystemProxyEnv();
+
+  const httpProxy = explicitHttp || fallback.HTTP_PROXY || fallback.http_proxy || "";
+  const httpsProxy = explicitHttps || fallback.HTTPS_PROXY || fallback.https_proxy || httpProxy;
+  const allProxy = explicitAll || fallback.ALL_PROXY || fallback.all_proxy || httpsProxy || httpProxy;
+  const noProxy = explicitNoProxy || fallback.NO_PROXY || fallback.no_proxy || "";
+
+  return {
+    ...env,
+    ...(httpProxy ? { HTTP_PROXY: httpProxy, http_proxy: httpProxy } : {}),
+    ...(httpsProxy ? { HTTPS_PROXY: httpsProxy, https_proxy: httpsProxy } : {}),
+    ...(allProxy ? { ALL_PROXY: allProxy, all_proxy: allProxy } : {}),
+    ...(noProxy ? { NO_PROXY: noProxy, no_proxy: noProxy } : {}),
+  };
+}
+
 function buildCliProcessEnv(extraEnv?: Record<string, string | undefined>) {
   return Object.fromEntries(
-    Object.entries({
+    Object.entries(normalizeProxyEnv({
       ...process.env,
       ...extraEnv,
       NO_COLOR: "1",
-    }).filter((entry): entry is [string, string] => typeof entry[1] === "string")
+    })).filter((entry): entry is [string, string] => typeof entry[1] === "string")
   );
 }
 
+function getCliProviderLabel(provider: CliProvider): string {
+  switch (provider) {
+    case "claude":
+      return "Claude CLI";
+    case "codex":
+      return "Codex CLI";
+    case "copilot":
+      return "Copilot CLI";
+    case "agy":
+      return "Antigravity CLI";
+    case "gemini":
+      return "Gemini CLI";
+  }
+}
+
+function supportsNativeSystemPrompt(provider: CliProvider): boolean {
+  return provider === "claude";
+}
+
+function supportsModel(provider: CliProvider): boolean {
+  return provider !== "agy";
+}
+
+function supportsReasoningEffort(provider: CliProvider): boolean {
+  return provider === "claude" || provider === "copilot";
+}
+
+function collectCliCapabilityWarnings(
+  provider: CliProvider,
+  options: CliExecuteOptions
+): string[] {
+  const warnings: string[] = [];
+  const label = getCliProviderLabel(provider);
+
+  if (options.reasoningEffort !== undefined && !supportsReasoningEffort(provider)) {
+    warnings.push(`${label} does not support reasoning_effort; ignored.`);
+  }
+
+  if (options.model !== undefined && !supportsModel(provider)) {
+    warnings.push(`${label} does not support model selection; ignored.`);
+  }
+
+  const unsupportedFields: Array<[string, unknown]> = [
+    ["temperature", options.temperature],
+    ["top_p", options.topP],
+    ["frequency_penalty", options.frequencyPenalty],
+    ["presence_penalty", options.presencePenalty],
+    ["max_tokens", options.maxTokens],
+    ["enableThinking", options.enableThinking ? true : undefined],
+    ["thinkingBudget", options.thinkingBudget],
+  ];
+
+  for (const [field, value] of unsupportedFields) {
+    if (value !== undefined) {
+      warnings.push(`${label} does not support ${field}; ignored.`);
+    }
+  }
+
+  return warnings;
+}
+
+function resolveCliExecution(
+  provider: CliProvider,
+  prompt: string,
+  options: CliExecuteOptions
+): { prompt: string; options: CliExecuteOptions; warnings: string[] } {
+  const warnings = collectCliCapabilityWarnings(provider, options);
+  if (supportsNativeSystemPrompt(provider) || !options.systemPrompt?.trim()) {
+    return { prompt, options, warnings };
+  }
+  return {
+    prompt: buildCliPrompt(options.systemPrompt, prompt),
+    options: {
+      ...options,
+      systemPrompt: undefined,
+    },
+    warnings,
+  };
+}
+
 // ── 各 provider 实现 ─────────────────────────────────────────────────────────
 
 /**
@@ -85,6 +243,7 @@ function executeCopilot(
 ): Promise<CliExecuteResult> {
   const {
     model,
+    reasoningEffort,
     timeout = 120_000,
     cwd = process.cwd(),
     yolo = true,
@@ -101,6 +260,7 @@ function executeCopilot(
       "--no-color",
     ];
     if (model) args.push(`--model ${model}`);
+    if (reasoningEffort) args.push(`--reasoning-effort ${reasoningEffort}`);
     if (yolo) args.push("--yolo");
 
     const cmd = args.join(" ");
@@ -244,6 +404,7 @@ function executeCodex(
   return new Promise((resolve, reject) => {
     const tempDir = mkdtempSync(join(tmpdir(), "codex-exec-"));
     const outputFile = join(tempDir, "last-message.txt");
+    const executable = resolveLaunchableCodexCommand(options.env);
     const args = [
       "exec",
       "--skip-git-repo-check",
@@ -264,7 +425,7 @@ function executeCodex(
       args.push("danger-full-access");
     }
     const start = Date.now();
-    const proc = spawn("codex", [...args, prompt], {
+    const proc = spawn(executable, [...args, prompt], {
       cwd,
       env: buildCliProcessEnv(options.env),
       stdio: ["ignore", "pipe", "pipe"],
@@ -327,6 +488,8 @@ function executeClaude(
 ): Promise<CliExecuteResult> {
   const {
     model,
+    systemPrompt,
+    reasoningEffort,
     timeout = 120_000,
     cwd = process.cwd(),
     yolo = true,
@@ -338,6 +501,14 @@ function executeClaude(
       args.push("--model");
       args.push(model);
     }
+    if (systemPrompt?.trim()) {
+      args.push("--system-prompt");
+      args.push(systemPrompt.trim());
+    }
+    if (reasoningEffort) {
+      args.push("--effort");
+      args.push(reasoningEffort);
+    }
     if (yolo) {
       args.push("--permission-mode");
       args.push("bypassPermissions");
@@ -389,6 +560,77 @@ function executeClaude(
   });
 }
 
+function formatCliTimeout(timeoutMs: number) {
+  return `${Math.max(1, Math.ceil(timeoutMs / 1000))}s`;
+}
+
+function executeAgy(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const {
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      "--print",
+      prompt,
+      "--print-timeout",
+      formatCliTimeout(timeout),
+    ];
+    if (yolo) {
+      args.push("--dangerously-skip-permissions");
+    }
+
+    const start = Date.now();
+    const proc = spawn("agy", args, {
+      cwd,
+      env: buildCliProcessEnv(options.env),
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Antigravity CLI timed out after ${timeout}ms`));
+      }, timeout + 1_000);
+    }
+
+    proc.stdout.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Antigravity CLI exited with code ${code}\nstderr: ${stderr}`));
+        return;
+      }
+
+      resolve({
+        text: stdout.trim(),
+        raw: stdout,
+        elapsed: Date.now() - start,
+      });
+    });
+
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
 // ── 注册表（新增 CLI 工具时在这里加） ────────────────────────────────────────
 
 const EXECUTORS: Record<
@@ -399,6 +641,7 @@ const EXECUTORS: Record<
   gemini: executeGemini,
   codex: executeCodex,
   claude: executeClaude,
+  agy: executeAgy,
 };
 
 function formatCliSessionTask(messages: CliSessionMessage[]): string {
@@ -416,13 +659,10 @@ function buildCliSessionPrompt(session: CliSessionState, userInput: string): str
     { role: "user", content: userInput },
   ]);
 
-  return buildCliPrompt(
-    session.systemPrompt,
-    [
-      "以下是当前对话，请基于完整上下文继续回答最后一条用户消息。",
-      transcript,
-    ].join("\n\n"),
-  );
+  return [
+    "以下是当前对话，请基于完整上下文继续回答最后一条用户消息。",
+    transcript,
+  ].join("\n\n");
 }
 
 function getCliSessionOrThrow(sessionId: string): CliSessionState {
@@ -438,7 +678,7 @@ function getCliSessionOrThrow(sessionId: string): CliSessionState {
 /**
  * 执行 CLI 任务
  *
- * @param provider  CLI 工具类型（如 "copilot" | "gemini" | "codex" | "claude"）
+ * @param provider  CLI 工具类型（如 "copilot" | "gemini" | "codex" | "claude" | "agy"）
  * @param prompt    完整 prompt（system prompt 已由调用方拼好）
  * @param options   执行选项
  */
@@ -451,7 +691,12 @@ export async function executeCli(
   if (!executor) {
     throw new Error(`Unknown CLI provider: "${provider}". Supported: ${Object.keys(EXECUTORS).join(", ")}`);
   }
-  return executor(prompt, options);
+  const resolved = resolveCliExecution(provider, prompt, options);
+  const result = await executor(resolved.prompt, resolved.options);
+  return {
+    ...result,
+    warnings: [...resolved.warnings, ...(result.warnings ?? [])],
+  };
 }
 
 export { buildCliPrompt };
@@ -473,7 +718,17 @@ export function startCliSession(
       model: options.model,
       timeout: options.timeout,
       cwd: options.cwd,
+      env: options.env,
       yolo: options.yolo,
+      systemPrompt: options.systemPrompt,
+      reasoningEffort: options.reasoningEffort,
+      temperature: options.temperature,
+      topP: options.topP,
+      frequencyPenalty: options.frequencyPenalty,
+      presencePenalty: options.presencePenalty,
+      maxTokens: options.maxTokens,
+      enableThinking: options.enableThinking,
+      thinkingBudget: options.thinkingBudget,
     },
     messages: [],
     createdAt: Date.now(),
@@ -567,31 +822,52 @@ export function executeCliStreaming(
   prompt: string,
   options: CliExecuteOptions & { onChunk: (chunk: string) => void }
 ): Promise<CliExecuteResult> {
+  const resolved = resolveCliExecution(provider, prompt, options);
+  const executor = EXECUTORS[provider];
   if (provider === "gemini") {
-    return executeGeminiStreaming(prompt, options);
+    return executeGeminiStreaming(resolved.prompt, resolved.options as CliExecuteOptions & { onChunk: (chunk: string) => void })
+      .then((result) => ({ ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] }));
   }
   if (provider === "codex") {
-    return executeCli(provider, prompt, options).then((result) => {
-      if (result.text) options.onChunk(result.text);
-      return result;
+    return executor(resolved.prompt, resolved.options).then((result) => {
+      const merged = { ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] };
+      if (merged.text) options.onChunk(merged.text);
+      return merged;
     });
   }
   if (provider === "claude") {
-    return executeCli(provider, prompt, options).then((result) => {
-      if (result.text) options.onChunk(result.text);
-      return result;
+    return executor(resolved.prompt, resolved.options).then((result) => {
+      const merged = { ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] };
+      if (merged.text) options.onChunk(merged.text);
+      return merged;
+    });
+  }
+  if (provider === "agy") {
+    return executor(resolved.prompt, resolved.options).then((result) => {
+      const merged = { ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] };
+      if (merged.text) options.onChunk(merged.text);
+      return merged;
     });
   }
   if (provider !== "copilot") {
-    return executeCli(provider, prompt, options);
+    return executor(resolved.prompt, resolved.options).then((result) => ({
+      ...result,
+      warnings: [...resolved.warnings, ...(result.warnings ?? [])],
+    }));
   }
 
-  const { model, timeout = 120_000, cwd = process.cwd(), yolo = true, onChunk } = options;
+  const {
+    model,
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+    onChunk,
+  } = resolved.options as CliExecuteOptions & { onChunk: (chunk: string) => void };
 
   return new Promise((resolve, reject) => {
     const args = [
       "copilot", "--",
-      "-p", prompt,
+      "-p", resolved.prompt,
       "--silent",
       "--disable-builtin-mcps",
     ];
@@ -636,7 +912,12 @@ export function executeCliStreaming(
         .filter(filterNoiseLine)
         .join("\n")
         .trim();
-      resolve({ text, raw, elapsed: Date.now() - start });
+      resolve({
+        text,
+        raw,
+        elapsed: Date.now() - start,
+        warnings: [...resolved.warnings],
+      });
     });
 
     proc.on("error", (err) => {

package/ai/agent/createAgentSchema.ts

@@ -1,6 +1,6 @@
 // 路径: ai/agent/createAgentSchema.ts
 
-import { ReferenceItem } from "app/types"; // 确保 app/types 里有 ReferenceItem 定义
+import { ReferenceItem } from "../../app/types"; // 确保 app/types 里有 ReferenceItem 定义
 import { TFunction } from "i18next";
 import { z } from "zod";
 
@@ -66,10 +66,10 @@ export const getCreateAgentSchema = (t: TFunction) =>
       apiSource: z.enum(["platform", "custom", "cli"]).default("platform"),
 
       /**
-       * CLI provider（apiSource=cli 时有效）：支持 "copilot" | "gemini" | "codex" | "claude"
+       * CLI provider（apiSource=cli 时有效）：支持 "copilot" | "gemini" | "codex" | "claude" | "agy"
        */
       cliProvider: z
-        .enum(["copilot", "gemini", "codex", "claude"])
+        .enum(["copilot", "gemini", "codex", "claude", "agy"])
         .optional()
         .or(z.literal("")),
 

package/ai/agent/executeToolCall.ts

@@ -3,8 +3,8 @@
 // 提取自 runAgentClientLoop：非流式多轮循环中执行单次 tool_call 的公共逻辑。
 // streamAgentChatTurn 走 sendOpenAICompletionsRequest → toolThunks，不使用此函数。
 
-import { findToolExecutor } from "ai/tools";
-import { getToolResultErrorData } from "ai/tools/toolResultError";
+import { findToolExecutor } from "../tools";
+import { getToolResultErrorData } from "../tools/toolResultError";
 
 interface ToolCall {
   id: string;

package/ai/agent/fetchAgentContexts.ts

@@ -1,6 +1,6 @@
-import { fetchReferenceContents } from "ai/context/buildReferenceContext";
-import { resolveReferenceAssets } from "ai/agent/referenceUtils";
-import type { ReferenceItem } from "app/types";
+import { fetchReferenceContents } from "../context/buildReferenceContext";
+import { resolveReferenceAssets } from "../agent/referenceUtils";
+import type { ReferenceItem } from "../../app/types";
 
 export interface AgentContexts {
   botInstructionsContext: string;

package/ai/agent/getFullChatContextKeys.ts

@@ -1,9 +1,9 @@
 
 // packages/ai/agent/getFullChatContextKeys.ts
-import { RootState } from "app/store";
-import { selectAllMsgs } from "chat/messages/messageSlice";
-import type { DialogConfig } from "app/types";
-import { extractCustomId } from "core/prefix";
+import { RootState } from "../../app/store";
+import { selectAllMsgs } from "../../chat/messages/messageSlice";
+import type { DialogConfig } from "../../app/types";
+import { extractCustomId } from "../../core/prefix";
 
 /** 简单的数组差集工具：返回 arrA 中不在 arrB 里的元素 */
 const difference = <T>(arrA: T[], arrB: T[]): T[] => {

package/ai/agent/guidedCreation/assistant.ts

@@ -0,0 +1,82 @@
+import type { GuidedAgentDraft, GuidedAgentReferenceChoice } from "./types";
+
+export const GUIDED_AGENT_CREATION_ASSISTANT_SYSTEM_PROMPT = `你是 Nolo 的 AI 创建助手。
+
+目标：通过对话理解用户想创建的 AI，并输出结构化配置草稿。
+
+规则：
+- 只生成草稿，不要创建真实 Agent 记录。
+- 不要告诉用户你已经创建了 Agent。
+- 优先询问用途、目标用户、风格、边界、能力、资料来源、公开状态。
+- 默认用能力语言沟通，不要要求用户理解 tool id。
+- 如果用户提到资料、知识库或当前空间，只推荐 references，必须等待用户确认后才选择。
+- 输出给系统的结构化草稿必须放在最后一个 JSON 代码块中。
+- JSON 形状必须是 {"draft": {...}}。
+- draft 字段包括 name, introduction, prompt, promptSummary, provider, model, isPublic, capabilityIds, toolIds, references, tags, unresolved。
+- 如果信息不足，把缺失项写进 unresolved，并继续追问。
+`;
+
+const extractJsonBlocks = (content: string): string[] => {
+  const blocks: string[] = [];
+  const pattern = /```json\s*([\s\S]*?)```/g;
+  let match: RegExpExecArray | null;
+  while ((match = pattern.exec(content)) != null) {
+    blocks.push(match[1].trim());
+  }
+  return blocks;
+};
+
+export const parseGuidedAgentAssistantDraft = (
+  content: string
+): GuidedAgentDraft | null => {
+  const blocks = extractJsonBlocks(content);
+  const last = blocks[blocks.length - 1];
+  if (!last) return null;
+
+  try {
+    const parsed = JSON.parse(last);
+    const draft = parsed?.draft;
+    if (!draft || typeof draft !== "object") return null;
+
+    const sanitizeStringArray = (value: unknown): string[] =>
+      Array.isArray(value)
+        ? value.filter((x): x is string => typeof x === "string")
+        : [];
+
+    const rawRefs = Array.isArray(draft.references) ? draft.references : [];
+    const sanitizedReferences: GuidedAgentReferenceChoice[] = rawRefs
+      .filter((ref): ref is Record<string, unknown> =>
+        ref !== null && typeof ref === "object"
+      )
+      .filter((r) => typeof r.dbKey === "string")
+      .map((r) => {
+        const choice: GuidedAgentReferenceChoice = {
+          dbKey: r.dbKey,
+          title: typeof r.title === "string" ? r.title : "",
+          type: r.type === "instruction" ? "instruction" : "knowledge",
+          selected: r.selected === true,
+        };
+        if (typeof r.reason === "string") {
+          choice.reason = r.reason;
+        }
+        return choice;
+      });
+
+    return {
+      name: String(draft.name || ""),
+      introduction: String(draft.introduction || ""),
+      prompt: String(draft.prompt || ""),
+      promptSummary: String(draft.promptSummary || ""),
+      provider: String(draft.provider || ""),
+      model: String(draft.model || ""),
+      isPublic: draft.isPublic === true,
+      capabilityIds: sanitizeStringArray(draft.capabilityIds),
+      toolIds: sanitizeStringArray(draft.toolIds),
+      references: sanitizedReferences,
+      tags: sanitizeStringArray(draft.tags),
+      unresolved: sanitizeStringArray(draft.unresolved),
+    };
+  } catch {
+    return null;
+  }
+};