@keyou007/agent-bot 0.1.9 → 0.1.11

package/src/codex/AppServerConnection.ts

@@ -26,6 +26,21 @@ interface PendingRequest {
 
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 
+export class AppServerRequestError extends Error {
+  readonly data: unknown;
+
+  constructor(
+    readonly method: string,
+    readonly code: number,
+    readonly serverMessage: string,
+    data?: unknown,
+  ) {
+    super(`${method} failed: ${serverMessage}`);
+    this.name = "AppServerRequestError";
+    this.data = data;
+  }
+}
+
 export class AppServerConnection {
   private nextId = 1;
   private closed = false;
@@ -131,7 +146,12 @@ export class AppServerConnection {
     this.pending.delete(message.id);
     if (pending.timeout) clearTimeout(pending.timeout);
     if ("error" in message) {
-      pending.reject(new Error(`${pending.method} failed: ${message.error.message}`));
+      pending.reject(new AppServerRequestError(
+        pending.method,
+        message.error.code,
+        message.error.message,
+        message.error.data,
+      ));
     } else {
       pending.resolve(message.result);
     }

package/src/codex/CodexLocalActivityDetector.ts

@@ -16,12 +16,14 @@ interface ThreadPathRow {
 
 interface ThreadSettingsRow {
   id: string;
+  model_provider?: string | null;
   model: string | null;
   reasoning_effort: string | null;
   approval_mode: string | null;
 }
 
 export interface CodexLocalThreadSettings {
+  modelProvider?: string;
   model?: string;
   reasoningEffort?: string;
   permissionMode?: PermissionMode;
@@ -79,10 +81,15 @@ export class CodexLocalActivityDetector {
         fileMustExist: true,
       });
       const placeholders = ids.map(() => "?").join(", ");
+      const columns = new Set(
+        (database.pragma("table_info(threads)") as Array<{ name: string }>).map((column) => column.name),
+      );
+      const providerColumn = columns.has("model_provider") ? ", model_provider" : "";
       const rows = database.prepare(
-        `SELECT id, model, reasoning_effort, approval_mode FROM threads WHERE id IN (${placeholders})`,
+        `SELECT id${providerColumn}, model, reasoning_effort, approval_mode FROM threads WHERE id IN (${placeholders})`,
       ).all(...ids) as ThreadSettingsRow[];
       return new Map(rows.map((row) => [row.id, {
+        ...(row.model_provider?.trim() ? { modelProvider: row.model_provider.trim() } : {}),
         ...(row.model?.trim() ? { model: row.model.trim() } : {}),
         ...(row.reasoning_effort?.trim() ? { reasoningEffort: row.reasoning_effort.trim() } : {}),
         ...(row.approval_mode?.trim()

package/src/codex/CodexProcessManager.ts

@@ -40,6 +40,7 @@ export class CodexProcessManager implements AppServerClientProvider {
     });
     await client.request("initialize", {
       clientInfo: { name: "agent-bot", title: "Agent Bot", version: "0.1.0" },
+      capabilities: { experimentalApi: true },
     });
     client.notify("initialized", {});
     return client;

package/src/codex/CodexRuntime.ts

@@ -5,6 +5,7 @@ import type {
   CreateRuntimeSessionInput,
   ForkRuntimeSessionInput,
   ModelOption,
+  ModelProviderOption,
   PermissionMode,
   RemoteSessionActivity,
   RemoteSessionPage,
@@ -13,12 +14,14 @@ import type {
   RuntimeGoal,
   RuntimeGoalUpdate,
   RuntimeEvent,
+  RuntimeExecutionSettings,
   RuntimePrompt,
   RuntimeSession,
   RuntimeSessionMetadata,
 } from "../runtime/types.js";
 import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
+import { AppServerRequestError } from "./AppServerConnection.js";
 import { mapCodexNotification } from "./CodexEventMapper.js";
 import { CodexLocalActivityDetector } from "./CodexLocalActivityDetector.js";
 import { detectProjectlessWorkspace } from "./ProjectlessWorkspace.js";
@@ -100,6 +103,7 @@ export class CodexRuntime implements AgentRuntime {
     const response = await client.request<ThreadResponse>("thread/start", {
       cwd: input.cwd,
       model: input.model,
+      ...(input.modelProvider ? { modelProvider: input.modelProvider } : {}),
       threadSource: "user",
       ...threadLifecycleParams(input.cwd),
       ...permissionParams(input.permissionMode),
@@ -122,8 +126,10 @@ export class CodexRuntime implements AgentRuntime {
     const client = await this.client();
     const response = await client.request<ThreadResponse>("thread/resume", {
       threadId: input.remoteSessionId,
+      excludeTurns: true,
       cwd: input.cwd,
       model: input.model,
+      ...(input.modelProvider ? { modelProvider: input.modelProvider } : {}),
       ...threadLifecycleParams(input.cwd),
       ...permissionParams(input.permissionMode),
     }, SESSION_REQUEST_TIMEOUT_MS);
@@ -135,15 +141,30 @@ export class CodexRuntime implements AgentRuntime {
 
   async forkSession(input: ForkRuntimeSessionInput): Promise<RuntimeSession> {
     const client = await this.client();
-    const response = await client.request<ThreadResponse>("thread/fork", {
+    const forkParams = {
       threadId: input.remoteSessionId,
       lastTurnId: input.lastTurnId,
       cwd: input.cwd,
       model: input.model,
+      ...(input.modelProvider ? { modelProvider: input.modelProvider } : {}),
       threadSource: "user",
       ...threadLifecycleParams(input.cwd),
       ...permissionParams(input.permissionMode),
-    }, FORK_REQUEST_TIMEOUT_MS);
+    };
+    let response: ThreadResponse;
+    try {
+      response = await client.request<ThreadResponse>("thread/fork", {
+        ...forkParams,
+        excludeTurns: true,
+      }, FORK_REQUEST_TIMEOUT_MS);
+    } catch (error) {
+      if (!isUnsupportedExcludeTurnsError(error)) throw error;
+      this.logger.warn(
+        { error },
+        "Codex App Server does not support thread/fork excludeTurns; retrying without it.",
+      );
+      response = await client.request<ThreadResponse>("thread/fork", forkParams, FORK_REQUEST_TIMEOUT_MS);
+    }
     const requestedTitle = normalizeTaskTitle(input.title);
     if (requestedTitle) {
       await client.request("thread/name/set", {
@@ -375,6 +396,28 @@ export class CodexRuntime implements AgentRuntime {
     this.requireSession(sessionId).permissionMode = mode;
   }
 
+  async setExecutionSettings(
+    sessionId: string,
+    settings: RuntimeExecutionSettings,
+  ): Promise<RuntimeSession> {
+    const session = this.requireSession(sessionId);
+    const response = await (await this.client()).request<ThreadResponse>("thread/resume", {
+      threadId: session.remoteSessionId,
+      excludeTurns: true,
+      cwd: session.cwd,
+      modelProvider: settings.modelProvider,
+      model: settings.model,
+      ...threadLifecycleParams(session.cwd),
+      ...permissionParams(settings.permissionMode),
+    }, SESSION_REQUEST_TIMEOUT_MS);
+    session.modelProvider = response.modelProvider ?? settings.modelProvider;
+    session.model = response.model ?? settings.model;
+    session.reasoningEffort = settings.reasoningEffort;
+    session.permissionMode = settings.permissionMode;
+    session.needsResume = false;
+    return session;
+  }
+
   async respondToApproval(
     sessionId: string,
     requestId: string,
@@ -412,6 +455,33 @@ export class CodexRuntime implements AgentRuntime {
     }));
   }
 
+  async listModelProviders(): Promise<ModelProviderOption[]> {
+    const response = await (await this.client()).request<{ config?: Record<string, unknown> }>(
+      "config/read",
+      {},
+      CONTROL_REQUEST_TIMEOUT_MS,
+    );
+    const config = response.config ?? {};
+    const defaultProvider = stringValue(config.model_provider)?.trim();
+    const configuredProviders = isRecord(config.model_providers) ? config.model_providers : {};
+    const providers = new Map<string, ModelProviderOption>();
+    for (const [id, value] of Object.entries(configuredProviders)) {
+      if (!id.trim()) continue;
+      const displayName = isRecord(value) ? stringValue(value.name)?.trim() : undefined;
+      providers.set(id, {
+        id,
+        ...(displayName ? { displayName } : {}),
+        ...(id === defaultProvider ? { isDefault: true } : {}),
+      });
+    }
+    if (defaultProvider && !providers.has(defaultProvider)) {
+      providers.set(defaultProvider, { id: defaultProvider, isDefault: true });
+    }
+    return [...providers.values()].sort((left, right) =>
+      Number(Boolean(right.isDefault)) - Number(Boolean(left.isDefault)) || left.id.localeCompare(right.id),
+    );
+  }
+
   onEvent(listener: (event: RuntimeEvent) => void): () => void {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
@@ -642,8 +712,10 @@ export class CodexRuntime implements AgentRuntime {
     if (!session.needsResume) return;
     await client.request("thread/resume", {
       threadId: session.remoteSessionId,
+      excludeTurns: true,
       cwd: session.cwd,
       model: session.model,
+      ...(session.modelProvider ? { modelProvider: session.modelProvider } : {}),
       ...threadLifecycleParams(session.cwd),
       ...permissionParams(session.permissionMode),
     }, SESSION_REQUEST_TIMEOUT_MS);
@@ -772,6 +844,7 @@ export class CodexRuntime implements AgentRuntime {
       title: normalizeTaskTitle(response.thread.name)
         ?? normalizeTaskTitle(response.thread.preview)
         ?? input.title,
+      modelProvider: input.modelProvider ?? response.modelProvider,
       model: input.model ?? response.model,
       reasoningEffort,
       permissionMode: input.permissionMode,
@@ -835,6 +908,7 @@ export class CodexRuntime implements AgentRuntime {
 
 interface ThreadResponse {
   thread: { id: string; name?: string | null; preview?: string };
+  modelProvider?: string;
   model?: string;
   reasoningEffort?: string | null;
 }
@@ -853,6 +927,7 @@ interface CodexThreadSnapshot {
   name?: string | null;
   preview?: string;
   cwd?: string;
+  modelProvider?: string;
   source?: unknown;
   createdAt?: number;
   updatedAt?: number;
@@ -933,6 +1008,19 @@ function uniqueStrings(values: string[]): string[] {
   return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
 }
 
+function isUnsupportedExcludeTurnsError(error: unknown): boolean {
+  if (!(error instanceof AppServerRequestError) || error.method !== "thread/fork") return false;
+  const data = typeof error.data === "string"
+    ? error.data
+    : error.data === undefined
+      ? ""
+      : JSON.stringify(error.data);
+  const details = `${error.serverMessage} ${data}`;
+  if (!details.toLowerCase().replaceAll(/[^a-z]/g, "").includes("excludeturns")) return false;
+  return error.code === -32602
+    || /unknown|unrecognized|unexpected|unsupported|not supported|experimental/i.test(details);
+}
+
 function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary {
   const lastTurn = thread.turns?.at(-1);
   const lastCompletedTurn = [...(thread.turns ?? [])]
@@ -956,6 +1044,7 @@ function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary
     cwd: thread.cwd ?? "",
     source: codexSourceLabel(thread.source),
     status,
+    modelProvider: thread.modelProvider,
     createdAt: thread.createdAt,
     updatedAt: thread.updatedAt,
     recencyAt: thread.recencyAt ?? undefined,

package/src/commands/CommandRouter.ts

@@ -1,5 +1,37 @@
 import type { Command } from "./commandTypes.js";
 
+const COMMAND_NAMES = [
+  "agent",
+  "fork",
+  "forkgroup",
+  "goal",
+  "help",
+  "model",
+  "new",
+  "newgroup",
+  "nosteer",
+  "permissions",
+  "provider",
+  "queue",
+  "restart",
+  "sessions",
+  "status",
+  "stop",
+  "switch",
+  "thinking",
+  "title",
+] as const;
+
+type CommandName = (typeof COMMAND_NAMES)[number];
+
+const COMMAND_INITIALISMS: Partial<Record<CommandName, string>> = {
+  forkgroup: "fg",
+  newgroup: "ng",
+  nosteer: "ns",
+};
+
+const DISABLED_COMMAND_NAMES = new Set(["mode", "modes"]);
+
 export class CommandRouter {
   parse(text: string): Command {
     const trimmed = text.trim();
@@ -13,28 +45,20 @@ export class CommandRouter {
     }
 
     const [rawCommand, ...args] = splitArgs(trimmed);
-    const command = rawCommand.slice(1).toLowerCase();
+    const command = resolveCommandName(rawCommand);
 
     switch (command) {
-      case "agents":
-        return { type: "agent" };
       case "new":
         return parseNewCommand(args);
       case "newgroup":
         return parseNewGroupCommand(args);
       case "forkgroup":
-        return {
-          type: "forkgroup",
-          title: args.join(" ").trim() || undefined,
-        };
+        return parseForkGroupCommand(args);
       case "fork":
-        if (args.length > 1) throw new Error("/fork 只接受一个可选的任务序号或任务 ID。");
-        return args[0] ? { type: "fork", sessionId: args[0] } : { type: "fork" };
+        return parseForkCommand(args);
       case "title":
         if (args.length === 0) throw new Error("请输入新标题，例如：/title 修复会话列表。");
         return { type: "title", title: args.join(" ") };
-      case "ask":
-        return { type: "ask", text: trimmed.slice(rawCommand.length).trim() };
       case "queue":
       case "nosteer": {
         const prompt = trimmed.slice(rawCommand.length).trim();
@@ -47,8 +71,6 @@ export class CommandRouter {
         return args[0] ? { type: "switch", sessionId: args[0] } : { type: "switch" };
       case "agent":
         return args[0] ? { type: "agent", agent: args[0] } : { type: "agent" };
-      case "use":
-        return requireArg(args[0], "agent name", (agent) => ({ type: "use", agent, cwd: args[1] }));
       case "stop":
         return { type: "stop" };
       case "status":
@@ -68,47 +90,88 @@ export class CommandRouter {
         return { type: "goal", action: "set", objective: args.join(" ") };
       }
       case "restart":
-        return { type: "restart" };
-      case "modes":
-        return { type: "modes" };
-      case "mode":
-        return requireArg(args[0], "mode value", (value) => ({ type: "mode", value }));
+        if (args.length === 0) return { type: "restart" };
+        if (args.length === 1 && args[0] === "--force") return { type: "restart", force: true };
+        throw new Error("/restart 只接受一个可选的 --force 参数。");
       case "model":
-        return { type: "model", model: args[0] };
+        return settingsCommand("/model", args, { type: "model" });
+      case "provider":
+        return settingsCommand("/provider", args, { type: "provider" });
       case "thinking":
-        return { type: "thinking", effort: args[0] };
-      case "permissions": {
-        const mode = args[0];
-        if (mode !== undefined && mode !== "auto" && mode !== "confirm") {
-          throw new Error("权限模式只能是 auto 或 confirm。");
-        }
-        return { type: "permissions", mode };
-      }
+        return settingsCommand("/thinking", args, { type: "thinking" });
+      case "permissions":
+        return settingsCommand("/permissions", args, { type: "permissions" });
       case "help":
         return { type: "help" };
-      default:
-        throw new Error(`未知命令：${rawCommand}。发送 /help 查看可用命令。`);
     }
   }
 }
 
-function requireArg<T>(value: string | undefined, name: string, create: (value: string) => T): T {
-  if (!value) {
-    throw new Error(`Missing ${name}.`);
+function resolveCommandName(rawCommand: string): CommandName {
+  const input = rawCommand.slice(1).toLowerCase();
+  if (!input) throw unknownCommand(rawCommand);
+  if (DISABLED_COMMAND_NAMES.has(input)) throw unknownCommand(rawCommand);
+
+  const exact = COMMAND_NAMES.find((command) => command === input);
+  if (exact) return exact;
+
+  const matches = COMMAND_NAMES.filter(
+    (command) => command.startsWith(input) || COMMAND_INITIALISMS[command] === input,
+  );
+  if (matches.length === 1) return matches[0]!;
+  if (matches.length > 1) {
+    throw new Error(
+      `命令前缀 ${rawCommand} 不唯一，可匹配：${matches.map((command) => `/${command}`).join("、")}。请输入更长的命令前缀。`,
+    );
   }
+  throw unknownCommand(rawCommand);
+}
 
-  return create(value);
+function unknownCommand(rawCommand: string): Error {
+  return new Error(`未知命令：${rawCommand}。发送 /help 查看可用命令。`);
+}
+
+function settingsCommand<T extends Command>(name: string, args: string[], command: T): T {
+  if (args.length > 0) {
+    throw new Error(`${name} 不接受参数，请在设置卡片中完成选择。`);
+  }
+  return command;
 }
 
 function parseNewCommand(args: string[]): Extract<Command, { type: "new" }> {
+  const options = parseNewTaskOptions("/new", args, "工作目录", "D:\\dev\\project");
+  return {
+    type: "new",
+    title: options.title,
+    cwd: options.cwd,
+    ...(options.projectless ? { projectless: true } : {}),
+  };
+}
+
+function parseNewGroupCommand(args: string[]): Extract<Command, { type: "newgroup" }> {
+  const options = parseNewTaskOptions("/newgroup", args, "项目目录", "~/dev/project");
+  return {
+    type: "newgroup",
+    title: options.title,
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    ...(options.projectless ? { projectless: true } : {}),
+  };
+}
+
+function parseNewTaskOptions(
+  commandName: "/new" | "/newgroup",
+  args: string[],
+  directoryLabel: string,
+  exampleDirectory: string,
+): { title?: string; cwd?: string; projectless: boolean } {
   const titleParts: string[] = [];
   let cwd: string | undefined;
   let projectless = false;
   for (let index = 0; index < args.length; index += 1) {
     const argument = args[index]!;
     if (argument === "--nodir") {
-      if (projectless) throw new Error("/new 只能指定一次 --nodir。");
-      if (cwd !== undefined) throw new Error("/new 的 --dir 和 --nodir 不能同时使用。");
+      if (projectless) throw new Error(`${commandName} 只能指定一次 --nodir。`);
+      if (cwd !== undefined) throw new Error(`${commandName} 的 --dir 和 --nodir 不能同时使用。`);
       projectless = true;
       continue;
     }
@@ -116,33 +179,47 @@ function parseNewCommand(args: string[]): Extract<Command, { type: "new" }> {
       titleParts.push(argument);
       continue;
     }
-    if (projectless) throw new Error("/new 的 --dir 和 --nodir 不能同时使用。");
-    if (cwd !== undefined) throw new Error("/new 只能指定一次 --dir。");
+    if (projectless) throw new Error(`${commandName} 的 --dir 和 --nodir 不能同时使用。`);
+    if (cwd !== undefined) throw new Error(`${commandName} 只能指定一次 --dir。`);
     const directory = args[index + 1];
-    if (!directory || directory === "--dir") {
-      throw new Error("请在 --dir 后指定工作目录，例如：/new 修复会话列表 --dir D:\\dev\\project。");
+    if (!directory || directory === "--dir" || directory === "--nodir") {
+      throw new Error(
+        `请在 --dir 后指定${directoryLabel}，例如：${commandName} 修复会话列表 --dir ${exampleDirectory}。`,
+      );
     }
     cwd = directory;
     index += 1;
   }
   return {
-    type: "new",
     title: titleParts.join(" ").trim() || undefined,
     cwd,
-    ...(projectless ? { projectless: true } : {}),
+    projectless,
   };
 }
 
-function parseNewGroupCommand(args: string[]): Extract<Command, { type: "newgroup" }> {
-  if (args.includes("--dir")) {
-    throw new Error("/newgroup 只创建飞书群，不支持 --dir；请在新群中使用 /new --dir <cwd> 创建任务。");
-  }
+function parseForkCommand(args: string[]): Extract<Command, { type: "fork" }> {
+  rejectOptions("/fork", args);
+  if (args.length > 1) throw new Error("/fork 只接受一个可选的任务序号或任务 ID。");
   return {
-    type: "newgroup",
+    type: "fork",
+    ...(args[0] ? { sessionId: args[0] } : {}),
+  };
+}
+
+function parseForkGroupCommand(args: string[]): Extract<Command, { type: "forkgroup" }> {
+  rejectOptions("/forkgroup", args);
+  return {
+    type: "forkgroup",
     title: args.join(" ").trim() || undefined,
   };
 }
 
+function rejectOptions(command: string, args: string[]): void {
+  for (const argument of args) {
+    if (argument.startsWith("--")) throw new Error(`${command} 不支持参数：${argument}。`);
+  }
+}
+
 function splitArgs(input: string): string[] {
   const args: string[] = [];
   let current = "";

package/src/commands/commandTypes.ts

@@ -1,28 +1,23 @@
-import type { PermissionMode } from "../runtime/types.js";
-
 export type Command =
   | { type: "shell"; command: string }
   | { type: "new"; title?: string; cwd?: string; projectless?: boolean }
-  | { type: "newgroup"; title?: string }
+  | { type: "newgroup"; title?: string; cwd?: string; projectless?: boolean }
   | { type: "forkgroup"; title?: string }
   | { type: "fork"; sessionId?: string }
   | { type: "title"; title: string }
-  | { type: "ask"; text: string }
   | { type: "nosteer"; text: string }
   | { type: "sessions"; searchTerm?: string }
   | { type: "switch"; sessionId?: string }
   | { type: "agent"; agent?: string }
-  | { type: "use"; agent: string; cwd?: string }
   | { type: "stop" }
   | { type: "status"; sessionId?: string }
   | { type: "goal"; action: "show" }
   | { type: "goal"; action: "set" | "edit"; objective: string }
   | { type: "goal"; action: "pause" | "resume" | "clear" }
-  | { type: "restart" }
-  | { type: "modes" }
-  | { type: "mode"; value: string }
-  | { type: "model"; model?: string }
-  | { type: "thinking"; effort?: string }
-  | { type: "permissions"; mode?: PermissionMode }
+  | { type: "restart"; force?: boolean }
+  | { type: "model" }
+  | { type: "provider" }
+  | { type: "thinking" }
+  | { type: "permissions" }
   | { type: "help" }
   | { type: "prompt"; text: string };

package/src/console/ConsoleTurnPresenter.ts

@@ -39,7 +39,7 @@ export class ConsoleTurnPresenter implements TurnPresenter {
     } else if (event.type === "tool_started") {
       await this.outbound.sendText(contextKey, `> ${event.tool.title}`);
     } else if (event.type === "approval_requested") {
-      await this.outbound.sendText(contextKey, `Approval required: ${event.request.title}. Use Feishu or /permissions auto.`);
+      await this.outbound.sendText(contextKey, `Approval required: ${event.request.title}. Use Feishu's Permission settings card.`);
     } else if (event.type === "turn_completed" && !this.delivered.has(event.turnId)) {
       this.delivered.add(event.turnId);
       await this.outbound.sendMarkdown(contextKey, event.finalResponse || "(completed without text)");