feat: add setSessionModel

Author: NikolaiSviridov

package-lock.json

@@ -3,26 +3,61 @@ import type {MessageConnection} from "vscode-jsonrpc/node";
 import {CodexClient} from "./CodexClient";
 import {CodexEventHandler} from "./CodexEventHandler";
 import type {JsonValue} from "./app-server/serde_json/JsonValue";
+import type {ModelInfo, SessionModelState} from "@agentclientprotocol/sdk";
+import type {ReasoningEffort} from "./app-server";
+import type {Model, ThreadStartResponse} from "./app-server/v2";
 
 export interface SessionState {
     sessionId: string,
     seenReasoningDeltas: boolean;
     pendingPrompt: AbortController | null;
+    currentModelId: string;
+    models: Model[];
+}
+
+class ModelId {
+    private constructor(
+        public readonly model: string,
+        public readonly effort: string | null // TODO: ThreadStartResponse
+    ) {}
+
+    static fromComponents(model: Model, effort: ReasoningEffort): ModelId {
+        return new ModelId(model.id, effort);
+    }
+
+    static fromThreadResponse(response: ThreadStartResponse): ModelId {
+        return new ModelId(response.model, response.reasoningEffort);
+    }
+
+    static fromString(modelId: string): ModelId {
+        const parts = modelId.split("/");
+        const model = parts[0];
+        const effort = parts[1] ?? null;
+
+        if (!model) {
+            throw new Error(`Invalid modelId format: ${modelId}`);
+        }
+        return new ModelId(model, effort);
+    }
+
+    toString(): string {
+        return this.effort ? `${this.model}/${this.effort}` : this.model;
+    }
 }
 
 export class CodexACPAgent implements acp.Agent {
     private readonly codexClient: CodexClient;
     private readonly connection: acp.AgentSideConnection;
-    private readonly config: JsonObject | null;
+    private readonly config: JsonObject;
     private readonly modelProvider: string | null;
 
     private readonly sessions: Map<string, SessionState>;
 
-    constructor(connection: acp.AgentSideConnection, codexConnection: MessageConnection, codexConfig?: JsonObject, modelProvider?: string) {
+    constructor(connection: acp.AgentSideConnection, codexConnection: MessageConnection, codexConfig: JsonObject, modelProvider?: string) {
         this.sessions = new Map();
         this.codexClient = new CodexClient(codexConnection);
         this.connection = connection;
-        this.config = codexConfig ?? null;
+        this.config = codexConfig ?? {};
         this.modelProvider = modelProvider ?? null;
     }
 
@@ -59,14 +94,30 @@ export class CodexACPAgent implements acp.Agent {
         })
 
         const sessionId = threadStartResponse.thread.id;
+        const codexModels = await this.fetchAvailableModels();
+        if (codexModels.length === 0) {
+            throw new Error("Codex did not return any models");
+        }
+
+        const currentModelId = ModelId.fromThreadResponse(threadStartResponse).toString();
         this.sessions.set(sessionId, {
             sessionId: sessionId,
             seenReasoningDeltas: false,
             pendingPrompt: null,
+            currentModelId: currentModelId,
+            models: codexModels,
         });
 
+        const availableModels = this.buildAvailableModels(codexModels);
+
+        const sessionModelState: SessionModelState = {
+            availableModels: availableModels,
+            currentModelId: currentModelId,
+        }
+
         return {
             sessionId,
+            models: sessionModelState,
         };
     }
 
@@ -84,6 +135,43 @@ export class CodexACPAgent implements acp.Agent {
         return {};
     }
 
+    async setSessionModel(params: acp.SetSessionModelRequest): Promise<acp.SetSessionModelResponse> {
+        const sessionState = this.sessions.get(params.sessionId);
+        if (!sessionState) throw new Error(`Session ${params.sessionId} not found`);
+
+        const requestedModelId= ModelId.fromString(params.modelId);
+        const requestedModelName = requestedModelId.model;
+        const requestedEffort = requestedModelId.effort;
+
+        const model = sessionState.models.find(m => m.id === requestedModelName);
+        if (!model) throw new Error(`Unknown model ${params.modelId}`);
+
+        const requestedEffortValue = requestedEffort as ReasoningEffort | undefined;
+        let reasoningEffort: ReasoningEffort;
+        if (requestedEffortValue) {
+            const matchedEffort = model.supportedReasoningEfforts.find(
+                (option) => option.reasoningEffort === requestedEffortValue
+            )?.reasoningEffort;
+
+            if (!matchedEffort) {
+                throw new Error(`Unsupported reasoning effort ${requestedEffortValue} for model ${requestedModelName}`);
+            }
+
+            reasoningEffort = matchedEffort;
+        } else {
+            reasoningEffort = model.defaultReasoningEffort;
+        }
+
+
+        await this.codexClient.setModelRequest({
+            model: model.model,
+            reasoningEffort,
+        });
+        sessionState.currentModelId = ModelId.fromComponents(model, reasoningEffort).toString();
+
+        return {};
+    }
+
     async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {
         const sessionState = this.sessions.get(params.sessionId);
         if (!sessionState) {
@@ -143,6 +231,29 @@ export class CodexACPAgent implements acp.Agent {
         await this.codexClient.close()
         this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
     }
+
+    private async fetchAvailableModels(): Promise<Model[]> {
+        const models: Model[] = [];
+        let cursor: string | null = null;
+
+        do {
+            const response = await this.codexClient.listModels({ cursor, limit: null });
+            models.push(...response.data);
+            cursor = response.nextCursor;
+        } while (cursor);
+
+        return models;
+    }
+
+    private buildAvailableModels(models: Model[]): ModelInfo[] {
+        return models.flatMap((model) =>
+            model.supportedReasoningEfforts.map((effort) => ({
+                modelId: ModelId.fromComponents(model, effort.reasoningEffort).toString(),
+                name: `${model.displayName} (${effort.reasoningEffort})`,
+                description: `${model.description} ${effort.description}`,
+            }))
+        );
+    }
 }
 
-export type JsonObject = { [key in string]?: JsonValue }
+export type JsonObject = { [key in string]?: JsonValue }

src/CodexACPAgent.ts

@@ -5,9 +5,12 @@ import type {
     InitializeParams,
     InitializeResponse,
     NewConversationParams,
-    NewConversationResponse, SendUserMessageParams, SendUserMessageResponse, ServerNotification, TaskCompleteEvent
+    NewConversationResponse, SendUserMessageParams, SendUserMessageResponse, ServerNotification,
+    SetDefaultModelParams, SetDefaultModelResponse, TaskCompleteEvent
 } from "./app-server";
 import type {
+    ModelListParams,
+    ModelListResponse,
     ThreadStartParams,
     ThreadStartResponse,
     TurnCompletedNotification,
@@ -72,6 +75,14 @@ export class CodexClient {
     private async sendRequest<R>(request: CodexRequest): Promise<R> {
         return await this.connection.sendRequest(request.method, request.params);
     }
+
+    async setModelRequest(params: SetDefaultModelParams): Promise<SetDefaultModelResponse> {
+        return await this.sendRequest({ method: "setDefaultModel", params });
+    }
+
+    async listModels(params: ModelListParams = {cursor: null, limit: null}): Promise<ModelListResponse> {
+        return await this.sendRequest({ method: "model/list", params });
+    }
 }
 
-type CodexRequest = Omit<ClientRequest, "id">;
+type CodexRequest = Omit<ClientRequest, "id">;