@keyou007/agent-bot 0.1.10 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "type": "module",
   "description": "Using Codex in Lark/Feishu feels just like using native Codex.",
   "license": "GPL-3.0-only",
@@ -25,6 +25,7 @@
   },
   "files": [
     ".env.example",
+    "assets/",
     "CHANGELOG.md",
     "config.example.yaml",
     "dist/",

package/skills/agent-bot/SKILL.md

@@ -99,6 +99,8 @@ agent-bot server stop
 
 Treat `server restart` as the normal restart path. It schedules a safe restart and waits for active tasks, pending final-message delivery, and a quiet inbound-message window. The first safe-restart status card is delayed by three seconds so the active task's final response can usually be delivered first; this presentation delay does not postpone scheduler polling. While the restart is pending, its status card has a bottom `Cancel` button that conditionally cancels that exact schedule and updates the card in place.
 
+In Feishu, `/restart` schedules the same safe restart. Use `/restart --force` only when the user explicitly accepts interruption; the command accepts no other arguments.
+
 Use `agent-bot server restart --immediate` only when the user explicitly requests an immediate restart or accepts interruption. Never use `taskkill`, `Stop-Process`, or equivalent commands for routine Agent Bot restart management.
 
 `agent-bot console` opens the console UI only when the service is stopped. Do not use `--force` while the service is live unless the user explicitly accepts concurrent state access.
@@ -135,7 +137,11 @@ Use `/queue <prompt>` in Feishu to persist a separate follow-up Prompt instead o
 
 For a long-running objective in the active Feishu task, use `/goal <objective>`. Use `/goal` to inspect it, `/goal pause` or `/goal resume` to control automatic continuation, `/goal edit <objective>` to revise it, and `/goal clear` to remove it. Stopping a Goal turn through Agent Bot also pauses the Goal before sending Interrupt so it does not immediately continue.
 
-Use `/newgroup [title]` in Feishu to create a private group named `[agent] [project directory] <title>`, invite the command sender, and immediately create and bind a new task in that group. The new task inherits the source chat's current task project directory, model, reasoning effort, and permission mode without interrupting or switching the source task. When the source chat has no current task, use the selected agent and its runtime defaults. An explicit title becomes both the group suffix and the task title. When the title is omitted, use task title `新任务` and group name `[agent] [project directory] 新任务 (mm-dd)`; an explicit title never gets a date suffix. Every new group gets a deterministic scheme-C Identicon avatar: Latin project names display their first word, Chinese names display up to their first four characters, and the normalized full project path hashes into the palette and symmetric node pattern. Projectless groups use the title as the stable seed. Replace the user's home-directory prefix with `~`. The bracketed project-directory value is limited to 15 characters. Longer paths keep the final two directories when they fit, otherwise keep the final directory, truncating the tail only when the final directory itself is overlong. Use `\` on Windows and `/` on macOS/Linux. Do not automatically send a Sessions or Status card to the new group. A later `/new --dir <cwd>` or `/new --nodir` in the group may explicitly replace the inherited project shape.
+Use `/agent` in Feishu to open the unified execution-settings card on its Agent tab and `/agent <name>` to directly select the default agent. The Agent tab is present only when multiple agents are configured and remains usable before the chat has a current task. When only one Agent is configured, `/agent` reports that current Agent directly instead of sending a card. Agent selection affects future tasks and does not replace the Agent of an existing task; use `/new` after selecting when a new task is needed.
+
+Use `/newgroup [title] [--dir <cwd> | --nodir]` in Feishu to create a private group named `[agent] [project directory] <title>`, invite the command sender, and immediately create and bind a new task in that group. `/new` and `/newgroup` share the same project options: an explicit `--dir` overrides the inherited project directory, while `--nodir` forces a Projectless Codex task; reject using both together. Resolve `~`, `~/...`, and `~\...` from the current user's home directory for both commands. Projectless groups omit the project segment and use `[agent] <title>`. The new task inherits the source chat's current task project directory when neither option is present, plus its model, reasoning effort, and permission mode without interrupting or switching the source task. When the source chat has no current task, use the selected agent and its runtime defaults. An explicit title becomes both the group suffix and the task title. When the title is omitted, use task title `新任务` and group name `[agent] [project directory] 新任务 (mm-dd)`, or `[agent] 新任务 (mm-dd)` for Projectless; an explicit title never gets a date suffix. Every new group gets a deterministic scheme-C Identicon avatar: Latin project names display their first word, Chinese names display up to their first four characters, and the normalized full project path hashes into the palette and symmetric node pattern. Projectless groups use the title as the stable seed. Replace the user's home-directory prefix with `~`. The bracketed project-directory value is limited to 15 characters. Longer paths keep the final two directories when they fit, otherwise keep the final directory, truncating the tail only when the final directory itself is overlong. Use `\` on Windows and `/` on macOS/Linux. Do not automatically send a Sessions or Status card to the new group. A later `/new --dir <cwd>` or `/new --nodir` in the group may explicitly replace the inherited project shape.
+
+Provider is part of the same inherited execution-settings group as model, reasoning effort, and permission mode. Preserve all four across `/new`, `/newgroup`, `/fork`, `/forkgroup`, and the matching `/sessions` actions. New tasks with no inherited Provider must leave it unset so Codex App Server uses the default from Codex configuration. New-group welcome messages report all four settings.
 
 Group names created by `/newgroup` and `/forkgroup` are capped at 60 displayed characters. When the generated name would exceed that limit, truncate only the title portion in the Feishu group name; preserve the underlying Agent Bot task title.
 
@@ -145,11 +151,15 @@ Use `/new [title] --nodir` to force a new Codex Projectless task even when the c
 
 Every task in the Feishu `/sessions` card has `New`, `NewGroup`, `Fork`, and `ForkGroup` actions. `New` inherits the source task's project directory, model, reasoning effort, and permission mode, creates a new task, and switches the current chat to it without stopping or forking the source task. `NewGroup` applies the same inheritance in a newly created private group. `Fork` switches the current chat to a branch, while `ForkGroup` binds the branch to a newly created private group; both fork actions use the selected task's latest available completed turn without interrupting an active turn.
 
-Use `/fork [number-or-task-id]` in Feishu to branch from the current or specified Codex task and switch to the new branch. If the source task is running, Agent Bot forks from its latest completed turn and leaves the active turn running; it rejects only when the task has no completed turn yet.
+Use `/fork [number-or-task-id]` in Feishu to branch from the current or specified Codex task and switch to the new branch. If the source task is running, Agent Bot forks from its latest completed turn and leaves the active turn running; it rejects only when the task has no completed turn yet. Every fork request sends `excludeTurns: true` to Codex App Server so the response omits populated turns without removing turns from the forked history. Older App Servers that explicitly reject this experimental field are retried once without it; ambiguous failures such as timeouts or disconnects are not retried.
 
 Status cards include a `Refresh` action that reads the latest task state and updates the same card in place without switching tasks or sending another card.
 
-Use `/model` in Feishu to show an interactive Card 2.0 model selector for the current task. Each non-current model has a blue link-style `Switch` action. After selecting a model, the same card advances to that model's reasoning-mode selector; the selector lists only mode names, has a `Back` action, and applies a selected mode from the next request. `/thinking` opens the reasoning selector directly. `/model <name>` and `/thinking <level>` remain available for direct text-based selection.
+Use `/agent`, `/provider`, `/model`, `/thinking`, or `/permissions` in Feishu to open the same interactive Card 2.0 execution-settings card with the corresponding tab active. The card exposes Provider, Model, Thinking, and Permission tabs whenever a current task exists, plus an Agent tab when multiple agents are configured. Each non-current option has an English `Switch` action. Selecting an option refreshes the same card in place. Agent changes affect future tasks; the other settings apply from the next request. Model changes automatically choose a compatible reasoning effort when necessary.
+
+If the current runtime has no alternative Provider, `/provider` reports the current Provider directly instead of opening the settings card. Apply the same rule to `/agent` when only one Agent is configured.
+
+These four settings commands do not accept arguments. Never instruct a user to send a Provider, model, reasoning effort, or permission value after the command; direct them to the card callbacks instead.
 
 Keep action labels placed to the right of card content or at the bottom of a card in English. Buttons above the main card content, such as activity-history navigation, may remain in Chinese.
 

package/src/acp/AcpSessionManager.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
 import type { Logger } from "pino";
-import type { AppConfig } from "../config/schema.js";
+import type { AgentConfig } from "../config/schema.js";
 import type {
   AcpInitializeResult,
   AcpPermissionRequestParams,
@@ -13,7 +13,6 @@ import { AcpProcessManager, type ManagedAcpProcess } from "./AcpProcessManager.j
 
 export interface RuntimeSession {
   localSessionId: string;
-  processKey: string;
   agentName: string;
   cwd: string;
   acpSessionId: string;
@@ -22,6 +21,8 @@ export interface RuntimeSession {
   modes?: JsonValue;
   configOptions?: JsonValue;
   availableCommands?: JsonValue;
+  onUpdate: (session: RuntimeSession, update: Record<string, JsonValue>) => void;
+  onPermissionRequest: (session: RuntimeSession, params: AcpPermissionRequestParams) => Promise<JsonValue>;
 }
 
 export interface CreateRuntimeSessionInput {
@@ -38,9 +39,11 @@ export interface CreateRuntimeSessionInput {
 export class AcpSessionManager {
   private readonly sessions = new Map<string, RuntimeSession>();
   private readonly sessionsByAcpId = new Map<string, RuntimeSession>();
+  private processStart?: Promise<ManagedAcpProcess>;
 
   constructor(
-    private readonly config: AppConfig,
+    private readonly agentName: string,
+    private readonly agent: AgentConfig,
     private readonly processManager: AcpProcessManager,
     private readonly logger: Logger,
   ) {}
@@ -50,66 +53,19 @@ export class AcpSessionManager {
   }
 
   async create(input: CreateRuntimeSessionInput): Promise<RuntimeSession> {
-    const agent = this.config.agents[input.agentName];
-    if (!agent) {
-      throw new Error(`Unknown agent: ${input.agentName}`);
-    }
+    if (input.agentName !== this.agentName) throw new Error(`Unexpected agent: ${input.agentName}`);
 
     const cwd = path.resolve(input.cwd);
-    const processKey = input.localSessionId;
-    const managed = this.processManager.start(processKey, input.agentName, agent);
+    const managed = await this.process();
     const connection = managed.connection;
 
-    let runtime: RuntimeSession | undefined;
-
-    connection.registerHandler("session/request_permission", async (params) => {
-      if (!runtime) {
-        throw new Error("Received permission request before session was ready.");
-      }
-
-      return input.onPermissionRequest(runtime, params as unknown as AcpPermissionRequestParams);
-    });
-
-    connection.on("notification", (_method, params) => {
-      if (_method !== "session/update") {
-        return;
-      }
-
-      const updateParams = params as unknown as AcpSessionUpdateParams;
-      const target = this.sessionsByAcpId.get(updateParams.sessionId);
-      if (!target) {
-        this.logger.debug({ updateParams }, "Ignoring update for unknown ACP session.");
-        return;
-      }
-
-      this.applySessionUpdate(target, updateParams.update);
-      input.onUpdate(target, updateParams.update);
-    });
-
-    const initializeResult = await connection.request<AcpInitializeResult>("initialize", {
-      protocolVersion: 1,
-      clientCapabilities: {},
-      clientInfo: {
-        name: "agent-bot",
-        title: "Agent Bot",
-        version: "0.1.0",
-      },
-    });
-
-    if (initializeResult.authMethods?.length) {
-      const method = initializeResult.authMethods[0];
-      this.logger.info({ methodId: method.id }, "Authenticating ACP agent with first advertised method.");
-      await connection.request("authenticate", { methodId: method.id });
-    }
-
     const newSessionResult = await connection.request<AcpSessionNewResult>("session/new", {
       cwd,
       mcpServers: [],
     });
 
-    runtime = {
+    const runtime: RuntimeSession = {
       localSessionId: input.localSessionId,
-      processKey,
       agentName: input.agentName,
       cwd,
       acpSessionId: newSessionResult.sessionId,
@@ -117,6 +73,8 @@ export class AcpSessionManager {
       running: false,
       modes: newSessionResult.modes,
       configOptions: newSessionResult.configOptions,
+      onUpdate: input.onUpdate,
+      onPermissionRequest: input.onPermissionRequest,
     };
 
     this.sessions.set(input.localSessionId, runtime);
@@ -169,7 +127,13 @@ export class AcpSessionManager {
 
     this.sessions.delete(localSessionId);
     this.sessionsByAcpId.delete(session.acpSessionId);
-    this.processManager.stop(session.processKey);
+  }
+
+  shutdown(): void {
+    this.sessions.clear();
+    this.sessionsByAcpId.clear();
+    this.processStart = undefined;
+    this.processManager.stopAll();
   }
 
   async setMode(localSessionId: string, modeId: string): Promise<void> {
@@ -203,6 +167,61 @@ export class AcpSessionManager {
     return session;
   }
 
+  private async process(): Promise<ManagedAcpProcess> {
+    const existing = this.processManager.get(this.agentName);
+    if (existing) return existing;
+    if (this.processStart) return this.processStart;
+    const start = this.startProcess();
+    this.processStart = start;
+    try {
+      return await start;
+    } finally {
+      if (this.processStart === start) this.processStart = undefined;
+    }
+  }
+
+  private async startProcess(): Promise<ManagedAcpProcess> {
+    const managed = this.processManager.start(this.agentName, this.agentName, this.agent);
+    try {
+      const connection = managed.connection;
+      connection.registerHandler("session/request_permission", async (params) => {
+        const permission = params as unknown as AcpPermissionRequestParams;
+        const target = this.sessionsByAcpId.get(permission.sessionId);
+        if (!target) throw new Error(`Unknown ACP session requesting permission: ${permission.sessionId}`);
+        return target.onPermissionRequest(target, permission);
+      });
+      connection.on("notification", (method, params) => {
+        if (method !== "session/update") return;
+        const updateParams = params as unknown as AcpSessionUpdateParams;
+        const target = this.sessionsByAcpId.get(updateParams.sessionId);
+        if (!target) {
+          this.logger.debug({ updateParams }, "Ignoring update for unknown ACP session.");
+          return;
+        }
+        this.applySessionUpdate(target, updateParams.update);
+        target.onUpdate(target, updateParams.update);
+      });
+      const initializeResult = await connection.request<AcpInitializeResult>("initialize", {
+        protocolVersion: 1,
+        clientCapabilities: {},
+        clientInfo: {
+          name: "agent-bot",
+          title: "Agent Bot",
+          version: "0.1.0",
+        },
+      });
+      if (initializeResult.authMethods?.length) {
+        const method = initializeResult.authMethods[0];
+        this.logger.info({ methodId: method.id }, "Authenticating ACP agent with first advertised method.");
+        await connection.request("authenticate", { methodId: method.id });
+      }
+      return managed;
+    } catch (error) {
+      this.processManager.stop(this.agentName);
+      throw error;
+    }
+  }
+
   private applySessionUpdate(session: RuntimeSession, update: Record<string, JsonValue>): void {
     const updateType = update.sessionUpdate;
     if (updateType === "config_option_update" && "configOptions" in update) {

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,