@keyou007/agent-bot 0.1.12 → 0.1.13-alpha.0

package/src/cli/help.ts

@@ -3,13 +3,13 @@ import { cliLanguage, type CliLanguage } from "./i18n.js";
 export function renderCliHelp(version: string, language: CliLanguage = cliLanguage): string {
   if (language === "zh") {
     return `Agent Bot ${version}
-通过飞书使用本地 Codex 和 ACP Agent。
+通过飞书使用本地 Codex、TraeX 和兼容 ACP 的 Agent。
 
 用法：
   agentbot [选项] <命令>
 
 常用命令：
-  init                              初始化飞书应用并启动服务
+  init                              检查并选择 Agent，初始化飞书应用和服务
   init --reset                      重置并重新配置显式指定的 Profile
   console                           打开本地控制台
   server start                      在后台启动 Agent Bot
@@ -51,13 +51,13 @@ export function renderCliHelp(version: string, language: CliLanguage = cliLangua
   }
 
   return `Agent Bot ${version}
-Use local Codex and ACP agents from Lark/Feishu.
+Use Codex, TraeX, and compatible ACP agents from Lark/Feishu.
 
 Usage:
   agentbot [options] <command>
 
 Common commands:
-  init                              Initialize the Lark app and start the service
+  init                              Check and select an Agent; initialize the Lark app and service
   init --reset                      Reset and reconfigure an explicit profile
   console                           Open the local console
   server start                      Start Agent Bot in the background

package/src/cli.ts

@@ -2,6 +2,7 @@
 import fs from "node:fs";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
 import { loadConfig, loadConfigWithoutEnvironmentMutation } from "./config/loadConfig.js";
 import { sendControlRequest, isServerReachable } from "./cli/LocalControlClient.js";
 import {
@@ -14,8 +15,10 @@ import {
   acquireInitializationLock,
   cleanupFeishuCredentialTemporaryFiles,
   initializeAgentBot,
+  readConfiguredAgentSelection,
   readFeishuCredentials,
   shouldCreateFeishuApp,
+  writeDefaultAgent,
   writeFeishuCredentials,
   type InitializationResult,
   type InitializationStatus,
@@ -38,6 +41,18 @@ import {
 } from "./cli/FeishuAppConfiguration.js";
 import { renderCliHelp } from "./cli/help.js";
 import { cliLanguage, cliText, localizeCliErrorMessage } from "./cli/i18n.js";
+import {
+  inspectSupportedAgent,
+  inspectSupportedAgents,
+  runSupportedAgentMaintenance,
+  type SupportedAgentInspection,
+} from "./cli/AgentPrerequisites.js";
+import {
+  parseMaintenanceSelection,
+  resolveDefaultAgentChoice,
+  selectableDefaultAgents,
+  type SelectableDefaultAgent,
+} from "./cli/DefaultAgentSelection.js";
 import { formatServerStatus, withConfiguredFeishuAppId } from "./cli/serverStatus.js";
 import { resolveSystemSkillsRoot, SkillRegistry, type SkillRegistrationStatus } from "./cli/SkillRegistry.js";
 import { readPackageVersion } from "./cli/packageVersion.js";
@@ -50,6 +65,7 @@ import {
   type ServerStartResult,
 } from "./cli/ServerStarter.js";
 import { taskChatRoute } from "./cli/taskChatRoute.js";
+import { refreshedSystemEnvironment } from "./supervision/systemEnvironment.js";
 import {
   parseTaskForkGroupOptions,
   parseTaskNewGroupOptions,
@@ -112,6 +128,11 @@ async function main(input: string[]): Promise<void> {
 type FeishuInitializationStatus = "created" | "existing" | "skipped";
 
 interface InitCommandResult extends InitializationResult {
+  agents: InitializedAgent[];
+  defaultAgent: {
+    name: string;
+    status: "selected" | "existing";
+  };
   feishu: {
     status: FeishuInitializationStatus;
     appId?: string;
@@ -120,6 +141,13 @@ interface InitCommandResult extends InitializationResult {
   server: InitializationServerResult;
 }
 
+interface InitializedAgent extends SupportedAgentInspection {
+  assistance?: {
+    status: "completed" | "skipped" | "unavailable" | "failed";
+    error?: string;
+  };
+}
+
 async function initCommand(
   input: string[],
   configPath: string | undefined,
@@ -135,13 +163,15 @@ async function initCommand(
     if (options.reset) await assertResetProfileServerStopped(configPath);
     paths = initializeAgentBot({ configPath, reset: options.reset });
     if (!options.json) printInitializationPaths(paths);
+    const agents = await initializeSupportedAgents(options.json);
+    const defaultAgent = await selectDefaultAgent(paths.config.path, agents, options.json);
     initializationLock ??= acquireInitializationLock(paths.home.path);
     cleanupFeishuCredentialTemporaryFiles(paths.env.path);
     const feishu = await initializeFeishu(
       paths,
       options,
     );
-    initialized = { ...paths, feishu };
+    initialized = { ...paths, agents, defaultAgent, feishu };
   } finally {
     initializationLock?.release();
   }
@@ -156,6 +186,259 @@ async function initCommand(
   else printInitializationServerResult(server);
 }
 
+async function initializeSupportedAgents(json: boolean): Promise<InitializedAgent[]> {
+  const output = json ? process.stderr : process.stdout;
+  output.write(cliText(
+    "\nAgent setup\nChecking Codex and TraeX...\n",
+    "\nAgent 设置\n正在检查 Codex 和 TraeX...\n",
+  ));
+  const inspections = await inspectSupportedAgents();
+  for (const inspection of inspections) printAgentInspection(inspection, output);
+  const actionable = inspections.filter((inspection) => inspection.action);
+  if (actionable.length === 0) return inspections;
+
+  output.write(cliText("\nAvailable actions:\n", "\n可执行的操作：\n"));
+  for (const [index, inspection] of actionable.entries()) {
+    output.write(cliText(
+      `  ${index + 1}. ${inspection.action?.kind === "install" ? "Install" : "Upgrade"} ${inspection.name}: ${inspection.action?.command}\n`,
+      `  ${index + 1}. ${inspection.action?.kind === "install" ? "安装" : "升级"} ${inspection.name}：${inspection.action?.command}\n`,
+    ));
+  }
+
+  let selected = new Set<number>();
+  if (!process.stdin.isTTY) {
+    output.write(cliText(
+      "No interactive terminal is available. Run the commands above manually if needed.\n",
+      "当前没有交互式终端，如有需要请手动执行上面的命令。\n",
+    ));
+  } else {
+    selected = new Set(await promptForAgentMaintenance(actionable.length));
+    if (selected.size === 0) {
+      output.write(cliText("No Agent changes selected.\n", "已跳过 Agent 安装和升级。\n"));
+    }
+  }
+
+  const initialized: InitializedAgent[] = [];
+  for (const inspection of inspections) {
+    if (!inspection.action) {
+      initialized.push(inspection);
+      continue;
+    }
+    const actionIndex = actionable.indexOf(inspection);
+    if (!selected.has(actionIndex)) {
+      initialized.push({
+        ...inspection,
+        assistance: { status: process.stdin.isTTY ? "skipped" : "unavailable" },
+      });
+      continue;
+    }
+
+    output.write(cliText(
+      `\nRunning ${inspection.name} ${inspection.action.kind}: ${inspection.action.command}\n`,
+      `\n正在${inspection.action.kind === "install" ? "安装" : "升级"} ${inspection.name}：${inspection.action.command}\n`,
+    ));
+    const maintenance = await runSupportedAgentMaintenance(inspection.id, inspection.action.kind);
+    if (maintenance.status !== 0 || maintenance.error) {
+      const error = maintenance.error ?? cliText(
+        `Command exited with code ${maintenance.status ?? "unknown"}.`,
+        `命令退出码为 ${maintenance.status ?? "未知"}。`,
+      );
+      output.write(cliText(
+        `${inspection.name} ${inspection.action.kind} did not complete; initialization will continue.\n`,
+        `${inspection.name}${inspection.action.kind === "install" ? "安装" : "升级"}未完成，初始化将继续。\n`,
+      ));
+      initialized.push({ ...inspection, assistance: { status: "failed", error } });
+      continue;
+    }
+
+    refreshCurrentProcessPath();
+    const refreshed = await inspectSupportedAgent(inspection.id);
+    if (refreshed.installedVersion) {
+      output.write(cliText(
+        `${inspection.name} is ready (${refreshed.installedVersion}).\n`,
+        `${inspection.name} 已就绪（${refreshed.installedVersion}）。\n`,
+      ));
+    } else {
+      output.write(cliText(
+        `${inspection.name} command completed, but the CLI is not visible in this process. Open a new terminal and run agentbot init again.\n`,
+        `${inspection.name} 命令已完成，但当前进程仍无法找到该 CLI。请打开新终端后重新运行 agentbot init。\n`,
+      ));
+    }
+    initialized.push({ ...refreshed, assistance: { status: "completed" } });
+  }
+  return initialized;
+}
+
+async function selectDefaultAgent(
+  configPath: string,
+  inspections: InitializedAgent[],
+  json: boolean,
+): Promise<InitCommandResult["defaultAgent"]> {
+  const output = json ? process.stderr : process.stdout;
+  const configured = readConfiguredAgentSelection(configPath);
+  const choices = selectableDefaultAgents(configured.agents, inspections);
+  if (!process.stdin.isTTY) {
+    if (!configured.defaultAgent || !configured.agents.some((agent) => agent.name === configured.defaultAgent)) {
+      throw new Error(cliText(
+        "A default Agent is not configured. Run agentbot init in an interactive terminal and select one.",
+        "尚未配置默认 Agent。请在交互式终端中运行 agentbot init 并选择一个 Agent。",
+      ));
+    }
+    output.write(cliText(
+      `Default Agent: ${configured.defaultAgent} (kept because no interactive terminal is available)\n`,
+      `默认 Agent：${configured.defaultAgent}（当前没有交互式终端，已保留现有设置）\n`,
+    ));
+    return { name: configured.defaultAgent, status: "existing" };
+  }
+  if (choices.length === 0) {
+    throw new Error(cliText(
+      "No available configured Agent can be selected. Install Codex or TraeX, then run agentbot init again.",
+      "没有可选择的已配置 Agent。请安装 Codex 或 TraeX，然后重新运行 agentbot init。",
+    ));
+  }
+
+  output.write(cliText("\nSelect the default Agent:\n", "\n请选择默认 Agent：\n"));
+  for (const [index, choice] of choices.entries()) {
+    const version = choice.installedVersion ? ` (${choice.installedVersion})` : "";
+    const current = choice.name === configured.defaultAgent
+      ? cliText(" [current]", " [当前]")
+      : "";
+    output.write(`  ${index + 1}. ${choice.name} - ${choice.title}${version}${current}\n`);
+  }
+  const selected = choices[await promptForDefaultAgent(choices, configured.defaultAgent)];
+  if (!selected) throw new Error(cliText("Default Agent selection failed.", "默认 Agent 选择失败。"));
+  const updated = writeDefaultAgent(configPath, selected.name);
+  output.write(updated
+    ? cliText(`Saved default Agent: ${selected.name}\n`, `已保存默认 Agent：${selected.name}\n`)
+    : cliText(`Default Agent unchanged: ${selected.name}\n`, `默认 Agent 保持不变：${selected.name}\n`));
+  return { name: selected.name, status: updated ? "selected" : "existing" };
+}
+
+function promptForAgentMaintenance(choiceCount: number): Promise<number[]> {
+  const readline = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (selection: number[]): void => {
+      settled = true;
+      readline.close();
+      resolve(selection);
+    };
+    const ask = (): void => {
+      readline.question(cliText(
+        "Enter action numbers separated by commas, type all, or press Enter to skip: ",
+        "请输入要执行的操作编号（多个用逗号分隔），输入 all 选择全部，直接回车跳过：",
+      ), (answer) => {
+        const selection = parseMaintenanceSelection(answer, choiceCount);
+        if (selection) {
+          finish(selection);
+          return;
+        }
+        process.stderr.write(cliText(
+          `Enter numbers from 1 to ${choiceCount}, all, or press Enter to skip.\n`,
+          `请输入 1 到 ${choiceCount} 之间的编号、all，或直接回车跳过。\n`,
+        ));
+        ask();
+      });
+    };
+    listenForPromptCancellation(readline, () => {
+      settled = true;
+      reject(new Error(cliText("Initialization was cancelled.", "初始化已取消。")));
+    }, () => settled);
+    ask();
+  });
+}
+
+function promptForDefaultAgent(
+  choices: SelectableDefaultAgent[],
+  currentAgent?: string,
+): Promise<number> {
+  const readline = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (index: number): void => {
+      settled = true;
+      readline.close();
+      resolve(index);
+    };
+    const ask = (): void => {
+      const currentAvailable = choices.some((choice) => choice.name === currentAgent);
+      readline.question(cliText(
+        `Enter a number or Agent name${currentAvailable ? ` [${currentAgent}]` : ""}: `,
+        `请输入编号或 Agent 标准名${currentAvailable ? ` [${currentAgent}]` : ""}：`,
+      ), (answer) => {
+        const index = resolveDefaultAgentChoice(answer, choices, currentAgent);
+        if (index !== undefined) {
+          finish(index);
+          return;
+        }
+        process.stderr.write(cliText(
+          `Enter a number from 1 to ${choices.length} or an Agent standard name.\n`,
+          `请输入 1 到 ${choices.length} 之间的编号，或 Agent 标准名。\n`,
+        ));
+        ask();
+      });
+    };
+    listenForPromptCancellation(readline, () => {
+      settled = true;
+      reject(new Error(cliText("Initialization was cancelled.", "初始化已取消。")));
+    }, () => settled);
+    ask();
+  });
+}
+
+function listenForPromptCancellation(
+  readline: ReturnType<typeof createInterface>,
+  cancel: () => void,
+  isSettled: () => boolean,
+): void {
+  readline.once("SIGINT", () => {
+    if (!isSettled()) cancel();
+    readline.close();
+  });
+  readline.once("close", () => {
+    if (!isSettled()) cancel();
+  });
+}
+
+function printAgentInspection(
+  inspection: SupportedAgentInspection,
+  output: NodeJS.WriteStream,
+): void {
+  if (inspection.state === "missing") {
+    output.write(cliText(
+      `  ${inspection.name}: not installed\n`,
+      `  ${inspection.name}：未安装\n`,
+    ));
+    return;
+  }
+  if (inspection.state === "outdated") {
+    output.write(cliText(
+      `  ${inspection.name}: ${inspection.installedVersion}; update available (${inspection.latestVersion})\n`,
+      `  ${inspection.name}：${inspection.installedVersion}；可升级到 ${inspection.latestVersion}\n`,
+    ));
+    return;
+  }
+  if (inspection.latestCheckFailed) {
+    output.write(cliText(
+      `  ${inspection.name}: ${inspection.installedVersion}; latest-version check unavailable\n`,
+      `  ${inspection.name}：${inspection.installedVersion}；无法检查最新版本\n`,
+    ));
+    return;
+  }
+  output.write(cliText(
+    `  ${inspection.name}: ${inspection.installedVersion} (up to date)\n`,
+    `  ${inspection.name}：${inspection.installedVersion}（已是最新）\n`,
+  ));
+}
+
+function refreshCurrentProcessPath(): void {
+  const refreshed = refreshedSystemEnvironment();
+  if (!refreshed.refreshed) return;
+  const pathEntry = Object.entries(refreshed.environment)
+    .find(([name]) => name.toLowerCase() === "path");
+  if (pathEntry?.[1]) process.env.PATH = pathEntry[1];
+}
+
 async function initializeFeishu(
   paths: InitializationResult,
   options: InitCommandOptions,
@@ -167,6 +450,9 @@ async function initializeFeishu(
       ...(existing.appId ? { appId: existing.appId } : {}),
     };
   }
+  if (!options.json) {
+    process.stdout.write(cliText("\nLark setup\n", "\n飞书设置\n"));
+  }
 
   const controller = new AbortController();
   const onInterrupt = (): void => controller.abort(new Error(cliText(
@@ -202,8 +488,8 @@ async function initializeFeishu(
 
     if (!options.json) {
       process.stdout.write(cliText(
-        "\nChecking Lark app permissions, events, and callbacks...\n",
-        "\n正在检查飞书应用权限、事件和回调...\n",
+        "Checking app permissions, events, and callbacks...\n",
+        "正在检查应用权限、事件和回调...\n",
       ));
     }
     const manualPermissionSkip = new AbortController();
@@ -624,8 +910,8 @@ function printSkillStatus(status: SkillRegistrationStatus): void {
 
 function printInitializationPaths(result: InitializationResult): void {
   process.stdout.write(cliText(
-    "Preparing the Agent Bot user environment...\n",
-    "正在准备 Agent Bot 用户环境...\n",
+    "Profile setup\n",
+    "Profile 设置\n",
   ));
   if (result.reset) {
     process.stdout.write(`${cliText("Reset backup: ", "重置备份：")}${result.reset.backupPath}\n`);
@@ -642,6 +928,7 @@ function printInitializationResult(result: Omit<InitCommandResult, "server">): v
     "\nAgent Bot initialization completed.\n",
     "\nAgent Bot 初始化完成。\n",
   ));
+  process.stdout.write(`${cliText("Default Agent: ", "默认 Agent：")}${result.defaultAgent.name}\n`);
   if (result.feishu.status === "created") {
     process.stdout.write(cliText(
       `Lark app: created and credentials saved (${result.feishu.appId})\n`,
@@ -852,6 +1139,7 @@ function feishuFeatureWarnings(missing: FeishuConfigurationChallenge["missing"])
 
 function initializationStatusLabel(status: InitializationStatus): string {
   if (status === "created") return cliText("created", "已创建");
+  if (status === "updated") return cliText("updated with missing settings", "已补全缺失配置");
   if (status === "reset") return cliText("reset from template", "已从模板重置");
   return cliText("already exists; unchanged", "已存在，未修改");
 }

package/src/codex/AppServerConnection.ts

@@ -108,7 +108,7 @@ export class AppServerConnection {
       try {
         message = JSON.parse(line) as AppServerMessage;
       } catch (error) {
-        this.logger.warn({ line, error }, "Ignoring non-JSON Codex App Server stdout line.");
+        this.logger.warn({ line, error }, "Ignoring non-JSON App Server stdout line.");
         return;
       }
       this.handleMessage(message);
@@ -128,7 +128,7 @@ export class AppServerConnection {
       for (const listener of this.notificationListeners) listener(message.method, message.params);
       return;
     }
-    this.logger.warn({ message }, "Ignoring unknown Codex App Server message shape.");
+    this.logger.warn({ message }, "Ignoring unknown App Server message shape.");
   }
 
   private handleResponse(message: AppServerResponse): void {
@@ -139,7 +139,7 @@ export class AppServerConnection {
           responseId: message.id,
           responseKind: "error" in message ? "error" : "result",
         },
-        "Received Codex App Server response for unknown request.",
+        "Received App Server response for unknown request.",
       );
       return;
     }

package/src/codex/CodexProcessManager.ts

@@ -27,15 +27,15 @@ export class CodexProcessManager implements AppServerClientProvider {
     const client = new AppServerConnection(child, this.logger.child({ component: "codex-app-server" }));
     this.client = client;
     readline.createInterface({ input: child.stderr, crlfDelay: Infinity }).on("line", (line) => {
-      this.logger.debug({ line }, "Codex App Server stderr.");
+      this.logger.debug({ line }, "App Server stderr.");
     });
-    child.once("error", (error) => this.logger.error({ error }, "Codex App Server process error."));
+    child.once("error", (error) => this.logger.error({ error }, "App Server process error."));
     child.once("exit", (code, signal) => {
-      this.logger.warn({ code, signal }, "Codex App Server process exited.");
+      this.logger.warn({ code, signal }, "App Server process exited.");
       client.close();
       if (this.client === client) this.client = undefined;
       if (this.child === child) this.child = undefined;
-      const error = new Error(`Codex App Server exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`);
+      const error = new Error(`App Server exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`);
       for (const listener of this.disconnectListeners) listener(error);
     });
     await client.request("initialize", {

package/src/codex/CodexRuntime.ts

@@ -163,7 +163,7 @@ export class CodexRuntime implements AgentRuntime {
       if (!isUnsupportedExcludeTurnsError(error)) throw error;
       this.logger.warn(
         { error },
-        "Codex App Server does not support thread/fork excludeTurns; retrying without it.",
+        "App Server does not support thread/fork excludeTurns; retrying without it.",
       );
       response = await client.request<ThreadResponse>("thread/fork", forkParams, FORK_REQUEST_TIMEOUT_MS);
     }
@@ -343,7 +343,7 @@ export class CodexRuntime implements AgentRuntime {
     );
     this.logger.info(
       { ...(sessionId ? { sessionId } : {}), threadId: remoteSessionId, turnId },
-      "Codex accepted the turn interrupt request.",
+      "App Server accepted the turn interrupt request.",
     );
   }
 
@@ -554,7 +554,7 @@ export class CodexRuntime implements AgentRuntime {
       const session = [...this.sessions.values()].find((candidate) => candidate.remoteSessionId === threadId);
       if (session?.activeTurnId && status && status !== "active") {
         void this.synchronizeSession(session.localSessionId).catch((error: unknown) => {
-          this.logger.warn({ error, sessionId: session.localSessionId, status }, "Failed to reconcile Codex thread status.");
+          this.logger.warn({ error, sessionId: session.localSessionId, status }, "Failed to reconcile App Server thread status.");
         });
       }
       return;
@@ -566,7 +566,7 @@ export class CodexRuntime implements AgentRuntime {
     if (session.terminalTurnIds.has(mapped.turnId)) {
       this.logger.debug(
         { sessionId: session.localSessionId, turnId: mapped.turnId, method },
-        "Ignoring a replayed terminal Codex turn event.",
+        "Ignoring a replayed terminal App Server turn event.",
       );
       return;
     }
@@ -586,7 +586,7 @@ export class CodexRuntime implements AgentRuntime {
             notificationTurnId: mapped.turnId,
             notificationStartedAt: mapped.startedAt,
           },
-          "Ignoring a replayed historical Codex turn start.",
+          "Ignoring a replayed historical App Server turn start.",
         );
         return;
       }
@@ -597,10 +597,10 @@ export class CodexRuntime implements AgentRuntime {
     if (!session.activeTurnId || session.activeTurnId !== mapped.turnId) {
       this.logger.debug(
         { sessionId: session.localSessionId, activeTurnId: session.activeTurnId, notificationTurnId: mapped.turnId, method },
-        "Ignoring out-of-order Codex notification and scheduling reconciliation.",
+        "Ignoring out-of-order App Server notification and scheduling reconciliation.",
       );
       void this.synchronizeSession(session.localSessionId).catch((error: unknown) => {
-        this.logger.warn({ error, sessionId: session.localSessionId }, "Failed to reconcile out-of-order Codex notification.");
+        this.logger.warn({ error, sessionId: session.localSessionId }, "Failed to reconcile out-of-order App Server notification.");
       });
       return;
     }
@@ -671,9 +671,12 @@ export class CodexRuntime implements AgentRuntime {
       if (mapped.status === "cancelled") {
         this.emit({ type: "turn_cancelled", sessionId, turnId: mapped.turnId });
       } else if (mapped.status === "failed") {
-        this.emit({ type: "turn_failed", sessionId, turnId: mapped.turnId, message: mapped.error ?? "Codex turn failed." });
+        this.emit({ type: "turn_failed", sessionId, turnId: mapped.turnId, message: mapped.error ?? "App Server turn failed." });
       } else {
-        const finalResponse = appendGeneratedImageMarkdown(session.finalText, session.generatedImagePaths);
+        const finalResponse = appendModelSwitchGuidance(
+          appendGeneratedImageMarkdown(session.finalText, session.generatedImagePaths),
+          session.model,
+        );
         this.emit({
           type: "turn_completed",
           sessionId,
@@ -703,7 +706,7 @@ export class CodexRuntime implements AgentRuntime {
       turnId,
       request: {
         id: requestId,
-        title: stringValue(params.command) ?? "Codex approval request",
+        title: stringValue(params.command) ?? "Agent approval request",
         command: stringValue(params.command),
         reason: stringValue(params.reason),
         options: [
@@ -781,7 +784,7 @@ export class CodexRuntime implements AgentRuntime {
           type: "turn_failed",
           sessionId: session.localSessionId,
           turnId: activeTurnId,
-          message: "Codex no longer reports this execution in the thread history.",
+          message: "The App Server no longer reports this execution in the thread history.",
         });
       }
       return;
@@ -828,7 +831,7 @@ export class CodexRuntime implements AgentRuntime {
         type: "turn_failed",
         sessionId: session.localSessionId,
         turnId: turn.id,
-        message: turn.error?.message ?? "Codex turn failed.",
+        message: turn.error?.message ?? "App Server turn failed.",
       });
       return;
     }
@@ -836,9 +839,12 @@ export class CodexRuntime implements AgentRuntime {
       ...session.generatedImagePaths,
       ...extractGeneratedImagePaths(turn),
     ]);
-    const finalResponse = appendGeneratedImageMarkdown(
-      extractFinalResponse(turn) || session.finalText,
-      generatedImagePaths,
+    const finalResponse = appendModelSwitchGuidance(
+      appendGeneratedImageMarkdown(
+        extractFinalResponse(turn) || session.finalText,
+        generatedImagePaths,
+      ),
+      session.model,
     );
     session.finalText = finalResponse;
     session.generatedImagePaths = [];
@@ -888,13 +894,13 @@ export class CodexRuntime implements AgentRuntime {
 
   private requireSession(sessionId: string): CodexSession {
     const session = this.sessions.get(sessionId);
-    if (!session) throw new Error(`Unknown Codex session: ${sessionId}`);
+    if (!session) throw new Error(`Unknown App Server session: ${sessionId}`);
     return session;
   }
 
   private requireActiveTurn(sessionId: string, turnId: string): CodexSession {
     const session = this.requireSession(sessionId);
-    if (session.activeTurnId !== turnId) throw new Error(`Codex turn is no longer active: ${turnId}`);
+    if (session.activeTurnId !== turnId) throw new Error(`App Server turn is no longer active: ${turnId}`);
     return session;
   }
 
@@ -917,7 +923,7 @@ export class CodexRuntime implements AgentRuntime {
         type: "turn_failed",
         sessionId: session.localSessionId,
         turnId,
-        message: `Codex App Server disconnected: ${error.message}`,
+        message: `App Server disconnected: ${error.message}`,
       });
     }
     for (const [requestId, pending] of this.approvals) {
@@ -978,6 +984,20 @@ function permissionParams(mode: PermissionMode): { approvalPolicy: "never" | "on
     : { approvalPolicy: "on-request", sandbox: "workspace-write" };
 }
 
+const MODEL_SWITCH_GUIDANCE = "请发送 `/model` 切换到其他模型后重试。";
+
+function appendModelSwitchGuidance(response: string, model?: string): string {
+  if (!hasKnownCodeModeFailure(response) || response.includes(MODEL_SWITCH_GUIDANCE)) return response;
+  const modelLabel = model?.trim() ? ` \`${model.trim()}\`` : "";
+  const guidance = `> 当前模型${modelLabel} 的本地工具执行通道异常。${MODEL_SWITCH_GUIDANCE}`;
+  return response.trimEnd() ? `${response.trimEnd()}\n\n${guidance}` : guidance;
+}
+
+function hasKnownCodeModeFailure(response: string): boolean {
+  return /code-mode host closed its stdout/i.test(response)
+    || /exec expects an object containing raw JavaScript in [`'"]?input[`'"]?/i.test(response);
+}
+
 function threadLifecycleParams(cwd: string): {
   developerInstructions: string;
 } {

package/src/config/loadConfig.ts

@@ -43,30 +43,6 @@ agents:
       - "stdio://"
     env: {}
 
-  coco:
-    title: "Coco"
-    command: "coco"
-    args:
-      - "acp"
-      - "serve"
-    env: {}
-
-  coco-yolo:
-    title: "Coco YOLO"
-    command: "coco"
-    args:
-      - "acp"
-      - "serve"
-      - "--yolo"
-    env: {}
-
-  example:
-    title: "Example ACP Agent"
-    command: "node"
-    args:
-      - "./examples/example-acp-agent.js"
-    env: {}
-
 defaults:
   agent: "codex"
   cwd: "."

package/src/console/ConsoleConnector.ts

@@ -12,8 +12,8 @@ export class ConsoleConnector {
 
   start(): void {
     if (this.reader) return;
-    this.logger.info("Starting local Codex test console.");
-    console.log("Codex console ready. Type /help or enter a prompt.");
+    this.logger.info("Starting the local Agent Bot console.");
+    console.log("Agent Bot console ready. Type /help or enter a prompt.");
     const reader = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "agentbot> " });
     this.reader = reader;
     reader.prompt();