nolo-cli 0.1.23 → 0.1.26

package/ai/agent/_executeModel.ts

@@ -9,6 +9,7 @@ import { generateRequestBody } from "ai/llm/generateRequestBody";
 import { getApiEndpoint } from "ai/llm/providers";
 import { selectCurrentServer } from "app/settings/settingSlice";
 import { selectCurrentToken } from "auth/authSlice";
+import { applyChatCompletionsStreamMode } from "integrations/openai/chatCompletionStreamMode";
 
 import { sendOpenAICompletionsRequest } from "../chat/sendOpenAICompletionsRequest";
 import { performFetchRequest } from "../chat/fetchUtils";
@@ -73,13 +74,13 @@ export const _executeModel = async (
       messages = [{ role: "user", content: args.content }];
     }
 
-    const bodyData = generateRequestBody({
+    const requestBody = generateRequestBody({
       agentConfig: resolvedConfig,
       messages,
       userInput: content,
       contexts: agentContexts,
     });
-    bodyData.stream = isStreaming;
+    const bodyData = applyChatCompletionsStreamMode(requestBody, isStreaming);
 
     if (isStreaming) {
       await sendOpenAICompletionsRequest({
@@ -97,7 +98,32 @@ export const _executeModel = async (
         currentServer: selectCurrentServer(state),
         token: selectCurrentToken(state),
       });
+      if (!response.ok) {
+        let message = `Model request failed with HTTP ${response.status}`;
+        try {
+          const errorBody = await response.json();
+          const upstreamMessage =
+            typeof errorBody?.error?.message === "string"
+              ? errorBody.error.message
+              : typeof errorBody?.message === "string"
+                ? errorBody.message
+                : "";
+          if (upstreamMessage.trim()) message = upstreamMessage.trim();
+        } catch {
+          // Keep the status-based message when the response body is not JSON.
+        }
+        throw new Error(message);
+      }
       const result = await response.json();
+      const content = result?.choices?.[0]?.message?.content;
+      if (typeof content !== "string") {
+        const upstreamMessage =
+          typeof result?.error?.message === "string" ? result.error.message : "";
+        throw new Error(
+          upstreamMessage.trim() ||
+          "Model response missing choices[0].message.content"
+        );
+      }
       if (args.billingDialogKey && result?.usage) {
         await updateTokensAction(
           {
@@ -109,7 +135,7 @@ export const _executeModel = async (
           thunkApi
         );
       }
-      return result.choices[0].message.content;
+      return content;
     }
   } catch (error: any) {
     console.error(`_executeModel failed`, error);

package/ai/agent/buildSystemPrompt.ts

@@ -198,6 +198,8 @@ const CODE_EDITING_FIDELITY_INSTRUCTIONS = `--- 代码编辑真值规则 ---
 当任务涉及 readFile / writeFile / applyEdit / applyLineEdits 等代码编辑工具时，必须遵守以下规则：
 
 - 先读取目标文件的最新内容，再决定修改。
+- 读取本地或代码仓库文件时，必须调用 readFile。不要用 read、readDoc、readPage 读取本地路径；这些工具用于知识库页面/文档 ID。
+- 执行本地 shell/bash 命令时，必须调用 execShell。
 - 如果用户提供了 URL、文档页或产品页，且你需要据此改代码，必须先抓取这些网页，再开始编辑。
 - 如果用户已经提供可用 URL，就不要再搜索替代来源；只有这些 URL 无法满足任务时，才允许降级到搜索，并在最终回复中说明。
 - 网页中直接出现的模型名、价格、上下文窗口、发布日期、能力描述、是否支持 function calling / vision 等字段，视为本次修改的权威来源。
@@ -219,6 +221,16 @@ const TABLE_SHARE_INSTRUCTIONS = `--- 表格创建与分享 ---
 - 传入表的 dbKey，或 tenantId + tableId；
 - 完成后直接返回 /share/... 链接。`;
 
+const AGENT_CREATION_DRAFT_INSTRUCTIONS = `--- Agent 创建草稿流程 ---
+当用户想创建、定制、配置自己的 Agent / AI 助手时，必须走草稿优先流程：
+
+- 不要直接创建真实 Agent 记录，也不要声称已经创建完成。
+- 先基于当前对话和用户刚说的话整理一个可预览草稿，调用 prepareAgentDraft。
+- 草稿应尽量包含名称、用途简介、prompt 摘要、完整 prompt、能力、知识引用建议、公开状态和仍需确认的问题。
+- 用户表达模糊时，也先给出合理的初版草稿；信息不足时每次只问一个关键问题。
+- 对知识引用、公开状态、高风险工具能力，必须等待用户确认后再视为已选。
+- 草稿足够完整后，引导用户点击“预览并创建”，进入 /create/agent 做最终确认。`;
+
 // ============================================================================
 // 无 prompt 时的澄清模式
 // ============================================================================
@@ -453,6 +465,10 @@ export const buildSystemPromptContext = (options: {
     ? TABLE_SHARE_INSTRUCTIONS
     : "";
 
+  const agentCreationDraftSection = agentTools.includes("prepareAgentDraft")
+    ? AGENT_CREATION_DRAFT_INSTRUCTIONS
+    : "";
+
   // 知识管理：有页面读写工具时注入通用知识管理说明
   const knowledgeManagementSection = agentTools.some((t) =>
     ["createDoc", "updateDoc", "read", "readDoc", "readPage"].includes(t)
@@ -519,6 +535,7 @@ export const buildSystemPromptContext = (options: {
     { id: "web-access", owner: "platform", content: webAccessSection },
     { id: "local-file-organization", owner: "platform", content: localFileOrganizationSection },
     { id: "table-share", owner: "platform", content: tableShareSection },
+    { id: "agent-creation-draft", owner: "platform", content: agentCreationDraftSection },
     { id: "menu-usage", owner: "platform", content: menuUsageSection },
     { id: "clarification-mode", owner: "platform", content: clarifyingSection },
     { id: "knowledge-management", owner: "platform", content: knowledgeManagementSection },

package/ai/agent/cliChatClient.ts

@@ -8,6 +8,15 @@ type CliChatAction = "start" | "turn" | "get" | "close";
 type CliChatRequestBase = {
   cliProvider?: CliProvider;
   model?: string;
+  systemPrompt?: string;
+  reasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max";
+  temperature?: number;
+  topP?: number;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  maxTokens?: number;
+  enableThinking?: boolean;
+  thinkingBudget?: number;
 };
 
 function getCliChatRequestConfig(thunkApi: any) {
@@ -41,10 +50,18 @@ export async function startCliChatSession(
 ) {
   const response = await postCliChat(thunkApi, {
     action: "start" satisfies CliChatAction,
-    cliProvider: args.cliProvider,
-    model: args.model,
-    systemPrompt: args.systemPrompt,
-  });
+      cliProvider: args.cliProvider,
+      model: args.model,
+      systemPrompt: args.systemPrompt,
+      reasoningEffort: args.reasoningEffort,
+      temperature: args.temperature,
+      topP: args.topP,
+      frequencyPenalty: args.frequencyPenalty,
+      presencePenalty: args.presencePenalty,
+      maxTokens: args.maxTokens,
+      enableThinking: args.enableThinking,
+      thinkingBudget: args.thinkingBudget,
+    });
   return response.json();
 }
 
@@ -108,11 +125,28 @@ export function createCliChatTurnStream(
           sessionId: args.sessionId,
           prompt: args.prompt,
           model: args.model,
+          reasoningEffort: args.reasoningEffort,
+          temperature: args.temperature,
+          topP: args.topP,
+          frequencyPenalty: args.frequencyPenalty,
+          presencePenalty: args.presencePenalty,
+          maxTokens: args.maxTokens,
+          enableThinking: args.enableThinking,
+          thinkingBudget: args.thinkingBudget,
         }
       : {
           prompt: args.prompt,
           model: args.model,
           cliProvider: args.cliProvider,
+          systemPrompt: args.systemPrompt,
+          reasoningEffort: args.reasoningEffort,
+          temperature: args.temperature,
+          topP: args.topP,
+          frequencyPenalty: args.frequencyPenalty,
+          presencePenalty: args.presencePenalty,
+          maxTokens: args.maxTokens,
+          enableThinking: args.enableThinking,
+          thinkingBudget: args.thinkingBudget,
         },
     signal,
   );

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 / 最近文本上下文这些能力面
@@ -13,7 +13,7 @@
   *   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";
@@ -23,7 +23,7 @@ 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 +31,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 +73,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 +242,7 @@ function executeCopilot(
 ): Promise<CliExecuteResult> {
   const {
     model,
+    reasoningEffort,
     timeout = 120_000,
     cwd = process.cwd(),
     yolo = true,
@@ -101,6 +259,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(" ");
@@ -327,6 +486,8 @@ function executeClaude(
 ): Promise<CliExecuteResult> {
   const {
     model,
+    systemPrompt,
+    reasoningEffort,
     timeout = 120_000,
     cwd = process.cwd(),
     yolo = true,
@@ -338,6 +499,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 +558,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 +639,7 @@ const EXECUTORS: Record<
   gemini: executeGemini,
   codex: executeCodex,
   claude: executeClaude,
+  agy: executeAgy,
 };
 
 function formatCliSessionTask(messages: CliSessionMessage[]): string {
@@ -416,13 +657,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 +676,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 +689,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 +716,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 +820,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 +910,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

@@ -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("")),