nolo-cli 0.1.29 → 0.1.31

package/ai/agent/agentRunDialogLineage.ts

@@ -0,0 +1,56 @@
+export type AgentRunDialogLineageInput = {
+  continueDialogId?: string | null;
+  inheritedFromDialogKey?: string | null;
+  parentDialogId?: string | null;
+};
+
+export type NormalizedAgentRunDialogLineage = {
+  continueDialogId?: string;
+  inheritedFromDialogKey?: string;
+  parentDialogId?: string;
+  hasAuthoritativeContinueDialog: boolean;
+  hasConflictingLineage: boolean;
+};
+
+function pickOptionalString(value: unknown) {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+export function hasAuthoritativeContinueDialogId(value: unknown) {
+  return pickOptionalString(value) !== undefined;
+}
+
+export function normalizeAgentRunDialogLineage(
+  input: AgentRunDialogLineageInput
+): NormalizedAgentRunDialogLineage {
+  const continueDialogId = pickOptionalString(input.continueDialogId);
+  const inheritedFromDialogKey = pickOptionalString(input.inheritedFromDialogKey);
+  const parentDialogId = pickOptionalString(input.parentDialogId);
+  const hasAuthoritativeContinueDialog = hasAuthoritativeContinueDialogId(continueDialogId);
+
+  return {
+    continueDialogId,
+    inheritedFromDialogKey: hasAuthoritativeContinueDialog ? undefined : inheritedFromDialogKey,
+    parentDialogId: hasAuthoritativeContinueDialog ? undefined : parentDialogId,
+    hasAuthoritativeContinueDialog,
+    hasConflictingLineage:
+      hasAuthoritativeContinueDialog && Boolean(inheritedFromDialogKey || parentDialogId),
+  };
+}
+
+export function buildAgentRunDialogLineageFields(
+  input: AgentRunDialogLineageInput
+): Pick<AgentRunDialogLineageInput, "continueDialogId" | "inheritedFromDialogKey" | "parentDialogId"> {
+  const normalized = normalizeAgentRunDialogLineage(input);
+  return {
+    ...(hasAuthoritativeContinueDialogId(normalized.continueDialogId)
+      ? { continueDialogId: normalized.continueDialogId }
+      : {}),
+    ...(normalized.inheritedFromDialogKey
+      ? { inheritedFromDialogKey: normalized.inheritedFromDialogKey }
+      : {}),
+    ...(normalized.parentDialogId ? { parentDialogId: normalized.parentDialogId } : {}),
+  };
+}

package/ai/agent/agentSlice.ts

@@ -79,6 +79,24 @@ const normalizeAgentReferences = (references: any[]): ReferenceItem[] => {
   }));
 };
 
+const isLocalProviderUrl = (value: unknown) => {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  if (!normalized) return false;
+  try {
+    const hostname = new URL(normalized).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+};
+
+const shouldPersistMachineBinding = (args: {
+  apiSource?: string;
+  customProviderUrl?: unknown;
+}) =>
+  args.apiSource === "cli" ||
+  (args.apiSource === "custom" && isLocalProviderUrl(args.customProviderUrl));
+
 /**
  * 创建场景：表单数据 -> 持久化数据（全量）
  */
@@ -104,7 +122,10 @@ const processAgentCreateForm = (formData: AgentFormData, userId: string) => {
   };
 
   delete result.machineId;
-  if (formData.apiSource === "cli" && machineId) {
+  if (machineId && shouldPersistMachineBinding({
+    apiSource: formData.apiSource,
+    customProviderUrl: formData.customProviderUrl,
+  })) {
     const binding: AgentRuntimeBinding = {
       ...(result.runtimeBinding && typeof result.runtimeBinding === "object"
         ? result.runtimeBinding
@@ -165,14 +186,22 @@ const processAgentUpdateChanges = (
   }
   if ("machineId" in data) {
     const machineId = String((data as any).machineId ?? "").trim();
-    
-    // Determine effective apiSource: prefer data.apiSource, fall back to previousAgent.apiSource
+
+    // Determine effective runtime source: prefer form data, fall back to previous agent config
     const effectiveApiSource = data.apiSource ?? previousAgent?.apiSource;
-    
+    const effectiveCustomProviderUrl =
+      data.customProviderUrl ?? previousAgent?.customProviderUrl;
+
     if (machineId) {
-      // Persist runtimeBinding when effective apiSource is 'cli' or undefined
-      // undefined = tool/legacy partial update without apiSource context → preserve backward compatibility
-      if (effectiveApiSource === "cli" || effectiveApiSource === undefined) {
+      // Persist runtimeBinding for CLI agents and localhost custom providers.
+      // undefined apiSource keeps backward compatibility for legacy partial updates.
+      if (
+        effectiveApiSource === undefined ||
+        shouldPersistMachineBinding({
+          apiSource: effectiveApiSource,
+          customProviderUrl: effectiveCustomProviderUrl,
+        })
+      ) {
         const binding: AgentRuntimeBinding = {
           ...((changes.runtimeBinding && typeof changes.runtimeBinding === "object")
             ? changes.runtimeBinding
@@ -182,10 +211,16 @@ const processAgentUpdateChanges = (
         };
         changes.runtimeBinding = binding;
       }
-      // If apiSource is explicitly non-cli and machineId is supplied, do not create binding
+      // If apiSource is explicitly incompatible with machine binding, do not create binding
     } else {
-      // CLEAR branch: clear runtimeBinding when effectiveApiSource is 'cli' or undefined (backward-compatible)
-      if (effectiveApiSource === "cli" || effectiveApiSource === undefined) {
+      // CLEAR branch: clear runtimeBinding when the effective runtime shape can be machine-bound.
+      if (
+        effectiveApiSource === undefined ||
+        shouldPersistMachineBinding({
+          apiSource: effectiveApiSource,
+          customProviderUrl: effectiveCustomProviderUrl,
+        })
+      ) {
         changes.runtimeBinding = null;
       }
     }

package/ai/agent/avatarUtils.ts

@@ -12,7 +12,7 @@ export function resolveAvatarUrl(
   avatarFileId: string | undefined | null,
   server: string | undefined | null
 ): string | null {
-  if (!avatarFileId) return null;
+  if (!avatarFileId || avatarFileId === "briefcase") return null;
   if (avatarFileId.startsWith("http") || avatarFileId.startsWith("blob:")) {
     return avatarFileId;
   }

package/ai/agent/buildSystemPrompt.ts

@@ -98,8 +98,7 @@ const AGENT_ORCHESTRATION_INSTRUCTIONS = `--- Agent 编排与协作 ---
 你所在的系统支持多个子 Agent 和工作流工具，请把自己视为"总协调者"：
 
 1）子 Agent 协作
-- 如果目标 Agent 记录已经声明 delegation.serverBase / runtimeServerBase，工具会自动路由到对应 nolo server；你不需要重复填写 serverBase。
-- 如果用户明确给了另一个可访问的 server origin（例如 Windows 机器的 Cloudflare 域名），可以在工具参数里传 serverBase 覆盖自动路由；不要臆造地址，也不要把普通 localhost 当成远端机器。
+- 如果用户明确给了另一个可访问的 server origin（例如 Windows 机器的 Cloudflare 域名），可以在工具参数里显式传 serverBase 把调用发到那台 server；不要臆造地址，也不要把普通 localhost 当成远端机器。
 - 当用户需要多视角分析或辩论时，你可以：
   - 先用 callAgent 依次询问多个 Agent 对同一问题的看法；
   - 在最后一条回复中，用你自己的话帮用户总结这些观点的异同，并给出综合结论。

package/ai/agent/cliExecutor.ts

@@ -14,8 +14,8 @@
  */
 
 import { exec, execSync, spawn } from "child_process";
-import { randomUUID } from "node:crypto";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveLaunchableCodexCommand } from "../../connector-experimental/codexBinary";
@@ -50,6 +50,25 @@ export interface CliExecuteResult {
   warnings?: string[];
 }
 
+type AgyDebugArtifact = {
+  dir: string;
+  promptHash: string;
+  promptBytes: number;
+  writeResult: (args: {
+    startedAt: string;
+    finishedAt: string;
+    elapsedMs: number;
+    cwd: string;
+    timeoutMs: number;
+    args: string[];
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    outcome: "succeeded" | "timed_out" | "spawn_error" | "failed";
+    errorMessage?: string;
+  }) => void;
+};
+
 type CliSessionMessage = {
   role: "user" | "assistant";
   content: string;
@@ -171,6 +190,8 @@ function supportsNativeSystemPrompt(provider: CliProvider): boolean {
 }
 
 function supportsModel(provider: CliProvider): boolean {
+  // Antigravity CLI does not expose a model selection flag.
+  // Codex is handled separately so explicit opt-in can still pass --model through.
   return provider !== "agy";
 }
 
@@ -178,6 +199,13 @@ function supportsReasoningEffort(provider: CliProvider): boolean {
   return provider === "claude" || provider === "copilot";
 }
 
+function shouldPassCodexModel(options: CliExecuteOptions): boolean {
+  return (options.env?.NOLO_CODEX_CLI_ALLOW_MODEL ?? process.env.NOLO_CODEX_CLI_ALLOW_MODEL) === "1";
+}
+function shouldPassClaudeModel(options: CliExecuteOptions): boolean {
+  return (options.env?.NOLO_CLAUDE_CLI_ALLOW_MODEL ?? process.env.NOLO_CLAUDE_CLI_ALLOW_MODEL) === "1";
+}
+
 function collectCliCapabilityWarnings(
   provider: CliProvider,
   options: CliExecuteOptions
@@ -189,7 +217,15 @@ function collectCliCapabilityWarnings(
     warnings.push(`${label} does not support reasoning_effort; ignored.`);
   }
 
-  if (options.model !== undefined && !supportsModel(provider)) {
+  if (provider === "codex" && options.model !== undefined && !shouldPassCodexModel(options)) {
+    warnings.push(
+      "Codex CLI model selection is disabled by default because real Codex installs can reject --model with subscription/plan errors; set NOLO_CODEX_CLI_ALLOW_MODEL=1 to pass it through."
+    );
+  } else if (provider === "claude" && options.model !== undefined && !shouldPassClaudeModel(options)) {
+    warnings.push(
+      "Claude CLI model selection is disabled by default because current installs can reject --model; set NOLO_CLAUDE_CLI_ALLOW_MODEL=1 to pass it through."
+    );
+  } else if (options.model !== undefined && !supportsModel(provider)) {
     warnings.push(`${label} does not support model selection; ignored.`);
   }
 
@@ -218,16 +254,121 @@ function resolveCliExecution(
   options: CliExecuteOptions
 ): { prompt: string; options: CliExecuteOptions; warnings: string[] } {
   const warnings = collectCliCapabilityWarnings(provider, options);
-  if (supportsNativeSystemPrompt(provider) || !options.systemPrompt?.trim()) {
-    return { prompt, options, warnings };
+  const resolvedPrompt =
+    supportsNativeSystemPrompt(provider) || !options.systemPrompt?.trim()
+      ? prompt
+      : buildCliPrompt(options.systemPrompt, prompt);
+  const resolvedOptions =
+    supportsNativeSystemPrompt(provider) || !options.systemPrompt?.trim()
+      ? options
+      : {
+          ...options,
+          systemPrompt: undefined,
+        };
+  const agyPrompt = provider === "agy" ? compactAgyPrompt(resolvedPrompt) : null;
+  return {
+    prompt: agyPrompt?.prompt ?? resolvedPrompt,
+    options: resolvedOptions,
+    warnings: [...warnings, ...(agyPrompt?.warnings ?? [])],
+  };
+}
+
+const AGY_PRESERVED_PROMPT_BLOCK_HEADERS = [
+  "--- Nolo read-only CLI bridge ---",
+  "--- Nolo task-run tool bridge ---",
+] as const;
+const AGY_OPTIONAL_TASKRUN_GUIDANCE_HEADERS = [
+  "## TaskRun tool guidance (2026-05-17)",
+  "## TaskRun tool strictness (2026-05-17)",
+  "## TaskRun delegation boundary (2026-05-17)",
+] as const;
+
+function escapeRegExp(value: string) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function extractPromptBlock(source: string, header: string) {
+  const pattern = new RegExp(
+    `(?:^|\\n)(${escapeRegExp(header)}\\n[\\s\\S]*?)(?=\\n{2,}--- [^\\n]+ ---|\\n{2,}User task:|\\n{2,}--- User task ---|$)`,
+  );
+  const match = source.match(pattern);
+  if (!match) return null;
+  return {
+    block: match[1].trim(),
+    remaining: source.replace(pattern, "\n\n"),
+  };
+}
+
+function stripMarkdownSection(source: string, header: string) {
+  const pattern = new RegExp(
+    `(?:^|\\n)${escapeRegExp(header)}\\n[\\s\\S]*?(?=\\n{2,}## [^\\n]+|\\n{2,}--- [^\\n]+ ---|\\n{2,}User task:|\\n{2,}--- User task ---|$)`,
+  );
+  return source.replace(pattern, "\n\n");
+}
+
+function compactAgyPrompt(prompt: string): { prompt: string; warnings: string[] } {
+  let next = prompt;
+  let changed = false;
+  const preservedBlocks: string[] = [];
+
+  const stripBlock = (pattern: RegExp) => {
+    const updated = next.replace(pattern, "\n\n");
+    if (updated !== next) {
+      next = updated;
+      changed = true;
+    }
+  };
+
+  for (const header of AGY_PRESERVED_PROMPT_BLOCK_HEADERS) {
+    const extracted = extractPromptBlock(next, header);
+    if (!extracted) continue;
+    next = extracted.remaining;
+    preservedBlocks.push(extracted.block);
+    changed = true;
+  }
+
+  // Antigravity intermittently stalls on long runtime metadata tails. The
+  // connector already enforces permissions and owns dialog context, so trim
+  // these blocks before handing the prompt to agy.
+  stripBlock(/(?:^|\n)Conversation Reference:\n[\s\S]*?(?=\n{2,}--- Machine permission policy ---|\n{2,}--- User task ---|\n{2,}User task:|$)/);
+  stripBlock(/(?:^|\n)--- Machine permission policy ---\n[\s\S]*?(?=\n{2,}--- User task ---|\n{2,}User task:|$)/);
+  if (!preservedBlocks.some((block) => block.startsWith("--- Nolo task-run tool bridge ---"))) {
+    for (const header of AGY_OPTIONAL_TASKRUN_GUIDANCE_HEADERS) {
+      const updated = stripMarkdownSection(next, header);
+      if (updated !== next) {
+        next = updated;
+        changed = true;
+      }
+    }
+  }
+
+  let normalized = next
+    .replace(/\n\n--- User task ---\n/g, "\n\nUser task:\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+  if (preservedBlocks.length > 0) {
+    const reinjected = preservedBlocks.join("\n\n");
+    if (/^User task:\n/.test(normalized)) {
+      normalized = `${reinjected}\n\n${normalized}`;
+    } else if (/\n\nUser task:\n/.test(normalized)) {
+      normalized = normalized.replace(/\n\nUser task:\n/, `\n\n${reinjected}\n\nUser task:\n`);
+    } else {
+      normalized = `${normalized}\n\n${reinjected}`.trim();
+    }
   }
+  if (normalized !== prompt) {
+    changed = true;
+  }
+
+  if (!changed) {
+    return { prompt, warnings: [] };
+  }
+
   return {
-    prompt: buildCliPrompt(options.systemPrompt, prompt),
-    options: {
-      ...options,
-      systemPrompt: undefined,
-    },
-    warnings,
+    prompt: normalized,
+    warnings: [
+      "Antigravity CLI prompt was compacted to avoid known timeout patterns in conversation-reference and machine-permission runtime blocks.",
+    ],
   };
 }
 
@@ -416,7 +557,9 @@ function executeCodex(
       "--cd",
       cwd,
     ];
-    if (model) {
+    // Codex CLI accepts --model syntactically, but real desktop/subscription
+    // installs can fail with plan-gating errors. Keep default execution stable.
+    if (model && shouldPassCodexModel(options)) {
       args.push("--model");
       args.push(model);
     }
@@ -496,8 +639,8 @@ function executeClaude(
   } = options;
 
   return new Promise((resolve, reject) => {
-    const args = ["-p", prompt];
-    if (model) {
+    const args = ["--add-dir", cwd, "-p", prompt];
+    if (model && shouldPassClaudeModel(options)) {
       args.push("--model");
       args.push(model);
     }
@@ -564,9 +707,82 @@ function formatCliTimeout(timeoutMs: number) {
   return `${Math.max(1, Math.ceil(timeoutMs / 1000))}s`;
 }
 
-function executeAgy(
+function shortHash(value: string) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+
+function resolveAgyDebugDir(env?: Record<string, string | undefined>) {
+  const raw = env?.NOLO_AGY_DEBUG_DIR ?? process.env.NOLO_AGY_DEBUG_DIR ?? "";
+  return raw.trim();
+}
+
+function createAgyDebugArtifact(args: {
+  prompt: string;
+  attempt: number;
+  timeoutMs: number;
+  cwd: string;
+  env?: Record<string, string | undefined>;
+}): AgyDebugArtifact | null {
+  const debugRoot = resolveAgyDebugDir(args.env);
+  if (!debugRoot) return null;
+
+  const promptHash = shortHash(args.prompt);
+  const promptBytes = Buffer.byteLength(args.prompt, "utf8");
+  const dir = join(debugRoot, `${Date.now()}-agy-${promptHash}-attempt-${args.attempt + 1}`);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "prompt.txt"), args.prompt, "utf8");
+
+  return {
+    dir,
+    promptHash,
+    promptBytes,
+    writeResult: (result) => {
+      writeFileSync(join(dir, "stdout.txt"), result.stdout, "utf8");
+      writeFileSync(join(dir, "stderr.txt"), result.stderr, "utf8");
+      writeFileSync(
+        join(dir, "meta.json"),
+        `${JSON.stringify({
+          promptHash,
+          promptBytes,
+          attempt: args.attempt + 1,
+          startedAt: result.startedAt,
+          finishedAt: result.finishedAt,
+          elapsedMs: result.elapsedMs,
+          cwd: result.cwd,
+          timeoutMs: result.timeoutMs,
+          args: result.args,
+          exitCode: result.exitCode,
+          outcome: result.outcome,
+          errorMessage: result.errorMessage ?? null,
+          stdoutBytes: Buffer.byteLength(result.stdout, "utf8"),
+          stderrBytes: Buffer.byteLength(result.stderr, "utf8"),
+        }, null, 2)}\n`,
+        "utf8"
+      );
+    },
+  };
+}
+
+function isAgyTimeoutError(error: unknown) {
+  return error instanceof Error && /Antigravity CLI timed out after \d+ms/.test(error.message);
+}
+
+function resolveAgyTimeoutRetryCount(env?: Record<string, string | undefined>) {
+  const raw = env?.NOLO_AGY_TIMEOUT_RETRIES ?? process.env.NOLO_AGY_TIMEOUT_RETRIES ?? "2";
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 2;
+}
+
+const AGY_PROCESS_TIMEOUT_BUFFER_MS = 10_000;
+
+function isAgyUpstreamTimeoutText(stdout: string) {
+  return /^Error:\s+timed out waiting for response\b/i.test(stdout.trim());
+}
+
+function executeAgyOnce(
   prompt: string,
-  options: CliExecuteOptions
+  options: CliExecuteOptions,
+  attempt = 0
 ): Promise<CliExecuteResult> {
   const {
     timeout = 120_000,
@@ -576,6 +792,8 @@ function executeAgy(
 
   return new Promise((resolve, reject) => {
     const args = [
+      "--add-dir",
+      cwd,
       "--print",
       prompt,
       "--print-timeout",
@@ -586,6 +804,14 @@ function executeAgy(
     }
 
     const start = Date.now();
+    const startedAt = new Date(start).toISOString();
+    const debugArtifact = createAgyDebugArtifact({
+      prompt,
+      attempt,
+      timeoutMs: timeout,
+      cwd,
+      env: options.env,
+    });
     const proc = spawn("agy", args, {
       cwd,
       env: buildCliProcessEnv(options.env),
@@ -594,12 +820,40 @@ function executeAgy(
     let stdout = "";
     let stderr = "";
     let timer: ReturnType<typeof setTimeout> | undefined;
+    let timedOut = false;
+
+    const flushDebug = (result: {
+      exitCode: number | null;
+      outcome: "succeeded" | "timed_out" | "spawn_error" | "failed";
+      errorMessage?: string;
+    }) => {
+      debugArtifact?.writeResult({
+        startedAt,
+        finishedAt: new Date().toISOString(),
+        elapsedMs: Date.now() - start,
+        cwd,
+        timeoutMs: timeout,
+        args,
+        stdout,
+        stderr,
+        exitCode: result.exitCode,
+        outcome: result.outcome,
+        ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),
+      });
+    };
 
     if (timeout > 0) {
       timer = setTimeout(() => {
+        timedOut = true;
         proc.kill("SIGTERM");
-        reject(new Error(`Antigravity CLI timed out after ${timeout}ms`));
-      }, timeout + 1_000);
+        const error = new Error(`Antigravity CLI timed out after ${timeout}ms`);
+        flushDebug({
+          exitCode: null,
+          outcome: "timed_out",
+          errorMessage: error.message,
+        });
+        reject(error);
+      }, timeout + AGY_PROCESS_TIMEOUT_BUFFER_MS);
     }
 
     proc.stdout.on("data", (data: Buffer) => {
@@ -612,11 +866,32 @@ function executeAgy(
 
     proc.on("close", (code) => {
       if (timer) clearTimeout(timer);
+      if (timedOut) return;
       if (code !== 0 && code !== null) {
-        reject(new Error(`Antigravity CLI exited with code ${code}\nstderr: ${stderr}`));
+        const error = new Error(`Antigravity CLI exited with code ${code}\nstderr: ${stderr}`);
+        flushDebug({
+          exitCode: code,
+          outcome: "failed",
+          errorMessage: error.message,
+        });
+        reject(error);
+        return;
+      }
+      if (isAgyUpstreamTimeoutText(stdout)) {
+        const error = new Error(`Antigravity CLI timed out after ${timeout}ms`);
+        flushDebug({
+          exitCode: code,
+          outcome: "timed_out",
+          errorMessage: error.message,
+        });
+        reject(error);
         return;
       }
 
+      flushDebug({
+        exitCode: code,
+        outcome: "succeeded",
+      });
       resolve({
         text: stdout.trim(),
         raw: stdout,
@@ -626,11 +901,47 @@ function executeAgy(
 
     proc.on("error", (err) => {
       if (timer) clearTimeout(timer);
+      flushDebug({
+        exitCode: null,
+        outcome: "spawn_error",
+        errorMessage: err instanceof Error ? err.message : String(err),
+      });
       reject(err);
     });
   });
 }
 
+async function executeAgy(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const maxRetries = resolveAgyTimeoutRetryCount(options.env);
+  let attempt = 0;
+  let lastError: unknown;
+
+  while (attempt <= maxRetries) {
+    try {
+      const result = await executeAgyOnce(prompt, options, attempt);
+      if (attempt === 0) return result;
+      return {
+        ...result,
+        warnings: [
+          ...(result.warnings ?? []),
+          `Antigravity CLI succeeded after ${attempt} timeout retr${attempt === 1 ? "y" : "ies"}.`,
+        ],
+      };
+    } catch (error) {
+      lastError = error;
+      if (!isAgyTimeoutError(error) || attempt >= maxRetries) {
+        throw error;
+      }
+      attempt += 1;
+    }
+  }
+
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
 // ── 注册表（新增 CLI 工具时在这里加） ────────────────────────────────────────
 
 const EXECUTORS: Record<

package/ai/agent/createAgentSchema.ts

@@ -35,6 +35,17 @@ const referenceItemSchema = z
     type: data.type === "page" ? "knowledge" : data.type,
   }));
 
+const isLocalProviderUrl = (value?: string | null) => {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  if (!normalized) return false;
+  try {
+    const hostname = new URL(normalized).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+};
+
 // --- 核心 schema ---
 export const getCreateAgentSchema = (t: TFunction) =>
   z
@@ -222,6 +233,17 @@ export const getCreateAgentSchema = (t: TFunction) =>
         message: t("validation.modelRequired"),
         path: ["model"],
       }
+    )
+    .refine(
+      (data) => {
+        if (!data.machineId?.trim()) return true;
+        if (data.apiSource === "cli") return true;
+        return data.apiSource === "custom" && isLocalProviderUrl(data.customProviderUrl);
+      },
+      {
+        message: t("validation.machineBindingRequiresCliOrLocalCustom"),
+        path: ["machineId"],
+      }
     );
 
 export type FormData = z.infer<ReturnType<typeof getCreateAgentSchema>>;