@keyou007/agent-bot 0.1.10 → 0.1.12

package/src/cli/taskGroupOptions.ts

@@ -0,0 +1,149 @@
+import { cliLanguage, cliText, type CliLanguage } from "./i18n.js";
+
+export interface TaskNewGroupOptions {
+  reference: string;
+  title?: string;
+  cwd?: string;
+  agentName?: string;
+  projectless: boolean;
+  json: boolean;
+}
+
+export interface TaskForkGroupOptions {
+  reference: string;
+  title?: string;
+  json: boolean;
+}
+
+export function parseTaskNewGroupOptions(
+  input: string[],
+  language: CliLanguage = cliLanguage,
+): TaskNewGroupOptions {
+  const positionals: string[] = [];
+  let cwd: string | undefined;
+  let agentName: string | undefined;
+  let projectless = false;
+  let json = false;
+  for (let index = 0; index < input.length; index += 1) {
+    const argument = input[index]!;
+    if (argument === "--json") {
+      json = true;
+      continue;
+    }
+    if (argument === "--nodir") {
+      if (projectless) throw optionError("newgroup", "--nodir", language);
+      if (cwd !== undefined) throw conflictingProjectOptions(language);
+      projectless = true;
+      continue;
+    }
+    if (argument === "--dir") {
+      if (projectless) throw conflictingProjectOptions(language);
+      if (cwd !== undefined) throw optionError("newgroup", "--dir", language);
+      const directory = input[index + 1];
+      if (!directory || directory.startsWith("--")) {
+        throw new Error(cliText(
+          "task newgroup requires a project directory after --dir.",
+          "task newgroup 需要在 --dir 后指定项目目录。",
+          language,
+        ));
+      }
+      cwd = directory;
+      index += 1;
+      continue;
+    }
+    if (argument === "--agent") {
+      if (agentName !== undefined) throw optionError("newgroup", "--agent", language);
+      const name = input[index + 1];
+      if (!name?.trim() || name.startsWith("--")) {
+        throw new Error(cliText(
+          "task newgroup requires an Agent standard name after --agent.",
+          "task newgroup 需要在 --agent 后指定 Agent 标准名。",
+          language,
+        ));
+      }
+      agentName = name.trim();
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("--")) throw unsupportedOption("newgroup", argument, language);
+    positionals.push(argument);
+  }
+  const [reference, ...titleParts] = positionals;
+  requireTaskReference("newgroup", reference, language);
+  return {
+    reference,
+    title: titleParts.join(" ").trim() || undefined,
+    cwd,
+    ...(agentName ? { agentName } : {}),
+    projectless,
+    json,
+  };
+}
+
+export function parseTaskForkGroupOptions(
+  input: string[],
+  language: CliLanguage = cliLanguage,
+): TaskForkGroupOptions {
+  const positionals: string[] = [];
+  let json = false;
+  for (const argument of input) {
+    if (argument === "--json") {
+      json = true;
+      continue;
+    }
+    if (argument.startsWith("--")) throw unsupportedOption("forkgroup", argument, language);
+    positionals.push(argument);
+  }
+  const [reference, ...titleParts] = positionals;
+  requireTaskReference("forkgroup", reference, language);
+  return {
+    reference,
+    title: titleParts.join(" ").trim() || undefined,
+    json,
+  };
+}
+
+function requireTaskReference(
+  action: "newgroup" | "forkgroup",
+  reference: string | undefined,
+  language: CliLanguage,
+): asserts reference is string {
+  if (reference && !reference.startsWith("--")) return;
+  throw new Error(cliText(
+    `task ${action} requires a source task number or task ID.`,
+    `task ${action} 需要源任务序号或任务 ID。`,
+    language,
+  ));
+}
+
+function optionError(
+  action: "newgroup",
+  option: "--agent" | "--dir" | "--nodir",
+  language: CliLanguage,
+): Error {
+  return new Error(cliText(
+    `task ${action} accepts ${option} only once.`,
+    `task ${action} 只能指定一次 ${option}。`,
+    language,
+  ));
+}
+
+function conflictingProjectOptions(language: CliLanguage): Error {
+  return new Error(cliText(
+    "task newgroup cannot combine --dir and --nodir.",
+    "task newgroup 的 --dir 和 --nodir 不能同时使用。",
+    language,
+  ));
+}
+
+function unsupportedOption(
+  action: "newgroup" | "forkgroup",
+  option: string,
+  language: CliLanguage,
+): Error {
+  return new Error(cliText(
+    `task ${action} does not support option: ${option}.`,
+    `task ${action} 不支持参数：${option}。`,
+    language,
+  ));
+}

package/src/cli.ts

@@ -7,6 +7,7 @@ import { sendControlRequest, isServerReachable } from "./cli/LocalControlClient.
 import {
   controlEndpoint,
   type ControlResponse,
+  type TaskGroupControlData,
   type TaskStatusControlData,
 } from "./cli/controlProtocol.js";
 import {
@@ -49,6 +50,10 @@ import {
   type ServerStartResult,
 } from "./cli/ServerStarter.js";
 import { taskChatRoute } from "./cli/taskChatRoute.js";
+import {
+  parseTaskForkGroupOptions,
+  parseTaskNewGroupOptions,
+} from "./cli/taskGroupOptions.js";
 import { StateStore, type SessionRecord } from "./state/StateStore.js";
 import {
   nodeDiagnosticReportArguments,
@@ -99,8 +104,8 @@ async function main(input: string[]): Promise<void> {
     return;
   }
   throw new Error(cliText(
-    `Unknown command: ${command}. Run agent-bot --help for usage.`,
-    `未知命令：${command}。运行 agent-bot --help 查看用法。`,
+    `Unknown command: ${command}. Run agentbot --help for usage.`,
+    `未知命令：${command}。运行 agentbot --help 查看用法。`,
   ));
 }
 
@@ -246,8 +251,8 @@ async function assertResetProfileServerStopped(configPath?: string): Promise<voi
     if (await isServerReachable(endpoint)) {
       throw new Error(
         cliText(
-          "Cannot reset a running profile. Stop it with agent-bot --profile <directory> server stop, then try again.",
-          "无法重置正在运行的 Profile。请先执行 agent-bot --profile <目录> server stop，然后重试。",
+          "Cannot reset a running profile. Stop it with agentbot --profile <directory> server stop, then try again.",
+          "无法重置正在运行的 Profile。请先执行 agentbot --profile <目录> server stop，然后重试。",
         ),
       );
     }
@@ -410,6 +415,51 @@ async function taskCommand(input: string[]): Promise<void> {
       process.stdout.write(cliText("Prompt submitted.\n", "提示词已提交。\n"));
       return;
     }
+    if (action === "newgroup") {
+      const options = parseTaskNewGroupOptions(rest);
+      const session = resolveTask(allSessions, options.reference);
+      const targetAgentName = options.agentName ?? session.agentName;
+      const targetAgent = config.agents[targetAgentName];
+      if (!targetAgent) {
+        throw new Error(cliText(
+          `Unknown Agent standard name: ${targetAgentName}.`,
+          `未知的 Agent 标准名：${targetAgentName}。`,
+        ));
+      }
+      if (options.projectless && targetAgent.kind !== "app-server") {
+        throw new Error(cliText(
+          "task newgroup --nodir is only available for App Server agents.",
+          "task newgroup --nodir 仅适用于 App Server Agent。",
+        ));
+      }
+      requireCliGroupUser(config.feishu.userOpenId);
+      const response = await sendControlRequest(controlEndpoint(config.storage.sqlitePath), {
+        action: "task_new_group",
+        localSessionId: session.localSessionId,
+        ...(options.title ? { title: options.title } : {}),
+        ...(options.cwd ? { cwd: options.cwd } : {}),
+        ...(options.agentName ? { agentName: options.agentName } : {}),
+        ...(options.projectless ? { projectless: true } : {}),
+      }, 120_000);
+      const result = taskGroupControlData(response);
+      if (options.json) printJson(result);
+      else printTaskGroupResult(result, "newgroup");
+      return;
+    }
+    if (action === "forkgroup") {
+      const options = parseTaskForkGroupOptions(rest);
+      const session = resolveTask(allSessions, options.reference);
+      requireCliGroupUser(config.feishu.userOpenId);
+      const response = await sendControlRequest(controlEndpoint(config.storage.sqlitePath), {
+        action: "task_fork_group",
+        localSessionId: session.localSessionId,
+        ...(options.title ? { title: options.title } : {}),
+      }, 120_000);
+      const result = taskGroupControlData(response);
+      if (options.json) printJson(result);
+      else printTaskGroupResult(result, "forkgroup");
+      return;
+    }
     const sessions = filterSessions(allSessions, rest);
     if (action === "list") {
       if (rest.includes("--json")) printJson(sessions);
@@ -840,6 +890,50 @@ function ensureOk(response: ControlResponse): void {
       ));
 }
 
+function requireCliGroupUser(userOpenId: string | undefined): asserts userOpenId is string {
+  if (userOpenId?.startsWith("ou_")) return;
+  throw new Error(cliText(
+    "The profile has no authorizing Lark user to invite. Run agentbot init again or configure FEISHU_USER_OPEN_ID.",
+    "当前 Profile 没有可邀请的飞书授权用户。请重新运行 agentbot init，或配置 FEISHU_USER_OPEN_ID。",
+  ));
+}
+
+function taskGroupControlData(response: ControlResponse): TaskGroupControlData {
+  ensureOk(response);
+  const data = response.data as Partial<TaskGroupControlData> | undefined;
+  if (
+    !data
+    || typeof data.sourceLocalSessionId !== "string"
+    || !data.group
+    || typeof data.group.chatId !== "string"
+    || typeof data.group.contextKey !== "string"
+    || typeof data.group.name !== "string"
+    || !data.task
+    || typeof data.task.localSessionId !== "string"
+  ) {
+    throw new Error(cliText(
+      "Agent Bot returned an invalid task-group result.",
+      "Agent Bot 返回了无效的任务群结果。",
+    ));
+  }
+  return data as TaskGroupControlData;
+}
+
+function printTaskGroupResult(
+  result: TaskGroupControlData,
+  action: "newgroup" | "forkgroup",
+): void {
+  process.stdout.write(cliText(
+    `${action === "forkgroup" ? "Fork group" : "Lark group"} created: ${result.group.name}\n`,
+    `${action === "forkgroup" ? "Fork 群" : "飞书群"}已创建：${result.group.name}\n`,
+  ));
+  process.stdout.write(`${cliText("Chat ID: ", "群 ID：")}${result.group.chatId}\n`);
+  process.stdout.write(`${cliText("Task ID: ", "任务 ID：")}${result.task.localSessionId}\n`);
+  if (result.task.remoteSessionId) {
+    process.stdout.write(`${cliText("Agent task ID: ", "Agent 任务 ID：")}${result.task.remoteSessionId}\n`);
+  }
+}
+
 function optionValue(args: string[], name: string): string | undefined {
   const index = args.indexOf(name);
   return index >= 0 ? args[index + 1] : undefined;

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";
@@ -32,12 +35,13 @@ const WINDOWS_SCREENSHOT_DEVELOPER_INSTRUCTIONS = [
   "Call Graphics.CopyFromScreen with those physical coordinates and validate that the saved bitmap dimensions exactly equal the selected physical capture bounds.",
 ].join(" ");
 
-const SESSION_REQUEST_TIMEOUT_MS = 30_000;
+const SESSION_REQUEST_TIMEOUT_MS = 60_000;
 const CONTROL_REQUEST_TIMEOUT_MS = 10_000;
 const SYNC_REQUEST_TIMEOUT_MS = 5_000;
 // A timed-out fork keeps running in App Server and can create an orphan thread.
 // Wait for its response; connection closure still rejects the request.
 const FORK_REQUEST_TIMEOUT_MS = 0;
+type ThreadListSortKey = "recency_at" | "updated_at";
 
 export interface AppServerClient {
   request<T = unknown>(method: string, params?: unknown, timeoutMs?: number): Promise<T>;
@@ -81,6 +85,7 @@ export class CodexRuntime implements AgentRuntime {
   private readonly unsubscribeDisconnect?: () => void;
   private readonly sessionSyncs = new Map<string, Promise<RuntimeSession>>();
   private readonly localActivityDetector?: CodexLocalActivityDetector;
+  private threadListSortKey: ThreadListSortKey = "recency_at";
 
   constructor(
     private readonly provider: AppServerClientProvider,
@@ -100,6 +105,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 +128,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 +143,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", {
@@ -194,18 +217,18 @@ export class CodexRuntime implements AgentRuntime {
     limit?: number;
   } = {}): Promise<RemoteSessionPage> {
     const client = await this.client();
-    const response = await client.request<ThreadListResponse>(
-      "thread/list",
-      {
-        cursor: input.cursor,
-        limit: input.limit ?? 20,
-        sortKey: "recency_at",
-        sortDirection: "desc",
-        archived: false,
-        searchTerm: input.searchTerm,
-      },
-      CONTROL_REQUEST_TIMEOUT_MS,
-    );
+    let response: ThreadListResponse;
+    try {
+      response = await this.requestThreadList(client, input, this.threadListSortKey);
+    } catch (error) {
+      if (this.threadListSortKey !== "recency_at" || !isUnsupportedRecencySortError(error)) throw error;
+      this.threadListSortKey = "updated_at";
+      this.logger.warn(
+        { error },
+        "App Server does not support thread/list recency_at sorting; retrying with updated_at.",
+      );
+      response = await this.requestThreadList(client, input, this.threadListSortKey);
+    }
     const sessions = await Promise.all(response.data.map(async (thread) => {
       const listed = remoteSessionSummary(thread);
       if (listed.status === "active" || listed.lastTurnStatus === "inProgress") return listed;
@@ -229,6 +252,25 @@ export class CodexRuntime implements AgentRuntime {
     };
   }
 
+  private requestThreadList(
+    client: AppServerClient,
+    input: { searchTerm?: string; cursor?: string; limit?: number },
+    sortKey: ThreadListSortKey,
+  ): Promise<ThreadListResponse> {
+    return client.request<ThreadListResponse>(
+      "thread/list",
+      {
+        cursor: input.cursor,
+        limit: input.limit ?? 20,
+        sortKey,
+        sortDirection: "desc",
+        archived: false,
+        searchTerm: input.searchTerm,
+      },
+      CONTROL_REQUEST_TIMEOUT_MS,
+    );
+  }
+
   async readRemoteSession(remoteSessionId: string): Promise<RemoteSessionSummary> {
     const response = await (await this.client()).request<ThreadReadResponse>(
       "thread/read",
@@ -375,6 +417,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 +476,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 +733,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 +865,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 +929,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 +948,7 @@ interface CodexThreadSnapshot {
   name?: string | null;
   preview?: string;
   cwd?: string;
+  modelProvider?: string;
   source?: unknown;
   createdAt?: number;
   updatedAt?: number;
@@ -933,6 +1029,31 @@ 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 isUnsupportedRecencySortError(error: unknown): boolean {
+  if (!(error instanceof AppServerRequestError) || error.method !== "thread/list") return false;
+  const data = typeof error.data === "string"
+    ? error.data
+    : error.data === undefined
+      ? ""
+      : JSON.stringify(error.data);
+  const details = `${error.serverMessage} ${data}`;
+  return /recency_at/i.test(details)
+    && /unknown|unrecognized|unexpected|unsupported|not supported|invalid/i.test(details);
+}
+
 function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary {
   const lastTurn = thread.turns?.at(-1);
   const lastCompletedTurn = [...(thread.turns ?? [])]
@@ -956,6 +1077,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,