Revert "feat: move model related data to meta"

This reverts commit b5f470c.

Author: NikolaiSviridov

src/CodexAcpClient.ts

@@ -13,10 +13,10 @@ import type {Disposable} from "vscode-jsonrpc";
 import type {
     ClientInfo,
     ReasoningEffort,
-    ServerNotification,
-    ServiceTier,
+    ServerNotification
 } from "./app-server";
 import type {JsonValue} from "./app-server/serde_json/JsonValue";
+import {ModelId} from "./ModelId";
 import {AgentMode} from "./AgentMode";
 import path from "node:path";
 import {logger} from "./Logger";
@@ -215,10 +215,10 @@ export class CodexAcpClient {
             threadId: request.sessionId,
         });
         const codexModels = await this.fetchAvailableModels();
-        const modelSelection = this.createModelSelection(codexModels, response.model, response.reasoningEffort, response.serviceTier);
+        const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
         return {
             sessionId: request.sessionId,
-            ...modelSelection,
+            currentModelId: currentModelId,
             models: codexModels,
         }
     }
@@ -237,10 +237,10 @@ export class CodexAcpClient {
             threadId: request.sessionId,
         });
         const codexModels = await this.fetchAvailableModels();
-        const modelSelection = this.createModelSelection(codexModels, response.model, response.reasoningEffort, response.serviceTier);
+        const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
         return {
             sessionId: request.sessionId,
-            ...modelSelection,
+            currentModelId: currentModelId,
             models: codexModels,
             thread: response.thread,
         };
@@ -266,10 +266,10 @@ export class CodexAcpClient {
         if (codexModels.length === 0) {
             throw new Error("Codex did not return any models");
         }
-        const modelSelection = this.createModelSelection(codexModels, response.model, response.reasoningEffort, response.serviceTier);
+        const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
         return {
             sessionId: response.thread.id,
-            ...modelSelection,
+            currentModelId: currentModelId,
             models: codexModels,
         };
     }
@@ -364,15 +364,10 @@ export class CodexAcpClient {
     }
 
     /**
-     * Resolves a model selection using the provided ID and reasoning effort.
-     * Falls back to model defaults if parameters are missing.
+     * Resolves a ModelId using the provided ID and reasoning effort.
+     * Falls back to model defaults if parameters are missing or unsupported.
      */
-    createModelSelection(
-        availableModels: Model[],
-        modelId: string | null,
-        reasoningEffort: ReasoningEffort | null,
-        serviceTier: ServiceTier | null,
-    ): ModelSelection {
+    createModelId(availableModels: Model[], modelId: string | null, reasoningEffort: ReasoningEffort | null): ModelId {
         const selectedModel =
             availableModels.find(m => m.id === modelId) ??
             availableModels.find(m => m.isDefault);
@@ -381,11 +376,7 @@ export class CodexAcpClient {
             throw new Error(`Model selection failed: No model found for ID "${modelId}" and no default model is defined.`);
         }
 
-        return {
-            currentModelId: selectedModel.id,
-            currentReasoningEffort: reasoningEffort ?? selectedModel.defaultReasoningEffort,
-            currentServiceTier: serviceTier ?? null,
-        };
+        return ModelId.create(selectedModel.id, reasoningEffort ?? selectedModel.defaultReasoningEffort);
     }
 
     async subscribeToSessionEvents(
@@ -402,11 +393,12 @@ export class CodexAcpClient {
     async sendPrompt(
         request: acp.PromptRequest,
         agentMode: AgentMode,
-        modelSelection: ModelSelection,
+        modelId: ModelId,
         disableSummary: boolean,
         cwd: string,
     ): Promise<TurnCompletedNotification> {
         const input = buildPromptItems(request.prompt);
+        const effort = modelId.effort as ReasoningEffort | null; //TODO remove unsafe conversion
 
         await this.refreshSkills(cwd, request._meta);
         return await this.codexClient.runTurn({
@@ -418,9 +410,9 @@ export class CodexAcpClient {
             summary: disableSummary ? "none" : null,
             personality: null,
             cwd: null,
-            effort: modelSelection.currentReasoningEffort,
-            model: modelSelection.currentModelId,
-            serviceTier: modelSelection.currentServiceTier,
+            effort: effort,
+            model: modelId.model,
+            serviceTier: modelId.serviceTier,
         });
     }
 
@@ -613,17 +605,13 @@ export type JsonObject = { [key in string]?: JsonValue }
 export type SessionMetadata = {
     sessionId: string,
     currentModelId: string,
-    currentReasoningEffort: ReasoningEffort,
-    currentServiceTier: ServiceTier | null,
     models: Model[],
 }
 
 export type SessionMetadataWithThread = SessionMetadata & {
     thread: Thread,
 }
 
-export type ModelSelection = Pick<SessionMetadata, "currentModelId" | "currentReasoningEffort" | "currentServiceTier">;
-
 function buildPromptItems(prompt: acp.ContentBlock[]): UserInput[] {
     return prompt.map((block): UserInput | null => {
         switch (block.type) {

src/CodexAcpServer.ts

@@ -4,10 +4,10 @@ import {CodexEventHandler} from "./CodexEventHandler";
 import {CodexApprovalHandler} from "./CodexApprovalHandler";
 import {CodexElicitationHandler} from "./CodexElicitationHandler";
 import {type CodexAuthRequest, getCodexAuthMethods} from "./CodexAuthMethod";
-import {CodexAcpClient, type ModelSelection, type SessionMetadata, type SessionMetadataWithThread} from "./CodexAcpClient";
+import {CodexAcpClient, type SessionMetadata, type SessionMetadataWithThread} from "./CodexAcpClient";
 import type {McpStartupResult} from "./CodexAppServerClient";
 import {ACPSessionConnection, type UpdateSessionEvent} from "./ACPSessionConnection";
-import type {InputModality, ReasoningEffort, ServiceTier} from "./app-server";
+import type {InputModality, ReasoningEffort} from "./app-server";
 import type {
     Account,
     CollabAgentToolCallStatus,
@@ -18,6 +18,7 @@ import type {
     UserInput
 } from "./app-server/v2";
 import type {RateLimitsMap} from "./RateLimitsMap";
+import {ModelId} from "./ModelId";
 import {AgentMode} from "./AgentMode";
 import type {TokenCount} from "./TokenCount";
 import {toPromptUsage} from "./TokenCount";
@@ -35,8 +36,6 @@ import {
 export interface SessionState {
     sessionId: string,
     currentModelId: string,
-    currentReasoningEffort: ReasoningEffort,
-    currentServiceTier: ServiceTier | null,
     supportedReasoningEfforts: Array<ReasoningEffortOption>,
     supportedInputModalities: Array<InputModality>,
     agentMode: AgentMode,
@@ -161,14 +160,12 @@ export class CodexAcpServer implements acp.Agent {
         }
 
         const account = await this.getActiveAccount();
-        const {sessionId, currentModelId, currentReasoningEffort, currentServiceTier, models} = sessionMetadata;
+        const {sessionId, currentModelId, models} = sessionMetadata;
         const sessionMcpServers = this.resolveSessionMcpServers(requestedMcpServers, "sessionId" in request);
         const currentModel = this.findCurrentModel(models, currentModelId);
         const sessionState: SessionState = {
             sessionId: sessionId,
             currentModelId: currentModelId,
-            currentReasoningEffort: currentReasoningEffort,
-            currentServiceTier: currentServiceTier,
             supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
             supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
             agentMode: AgentMode.getInitialAgentMode(),
@@ -192,7 +189,7 @@ export class CodexAcpServer implements acp.Agent {
         }
 
         this.publishAvailableCommandsAsync(sessionId);
-        const sessionModelState: SessionModelState = this.createModelState(models, sessionState);
+        const sessionModelState: SessionModelState = this.createModelState(models, currentModelId);
         const sessionModeState: SessionModeState = sessionState.agentMode.toSessionModeState();
 
         return [sessionId, sessionModelState, sessionModeState];
@@ -313,32 +310,34 @@ export class CodexAcpServer implements acp.Agent {
         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 models = await this.codexAcpClient.fetchAvailableModels();
-        const model = models.find(m => m.id === params.modelId);
+        const model = models.find(m => m.id === requestedModelName);
         if (!model) throw new Error(`Unknown model ${params.modelId}`);
+        if (requestedModelId.serviceTier === "fast" && !model.additionalSpeedTiers.includes("fast")) {
+            throw new Error(`Unsupported service tier fast for model ${requestedModelName}`);
+        }
 
-        const requestedEffort = readStringMeta(params._meta, "reasoningEffort") as ReasoningEffort | null;
-        let reasoningEffort = model.defaultReasoningEffort;
-        if (requestedEffort !== null) {
+        const requestedEffortValue = requestedEffort as ReasoningEffort | undefined;
+        let reasoningEffort: ReasoningEffort;
+        if (requestedEffortValue) {
             const matchedEffort = model.supportedReasoningEfforts.find(
-                (option) => option.reasoningEffort === requestedEffort
+                (option) => option.reasoningEffort === requestedEffortValue
             )?.reasoningEffort;
 
             if (!matchedEffort) {
-                throw new Error(`Unsupported reasoning effort ${requestedEffort} for model ${model.id}`);
+                throw new Error(`Unsupported reasoning effort ${requestedEffortValue} for model ${requestedModelName}`);
             }
 
             reasoningEffort = matchedEffort;
+        } else {
+            reasoningEffort = model.defaultReasoningEffort;
         }
 
-        const requestedServiceTier = readStringMeta(params._meta, "serviceTier") as ServiceTier | null;
-        if (requestedServiceTier !== null && !model.additionalSpeedTiers.includes(requestedServiceTier)) {
-            throw new Error(`Unsupported service tier ${requestedServiceTier} for model ${model.id}`);
-        }
-
-        sessionState.currentModelId = model.id;
-        sessionState.currentReasoningEffort = reasoningEffort;
-        sessionState.currentServiceTier = requestedServiceTier;
+        sessionState.currentModelId = ModelId.fromComponents(model, reasoningEffort, requestedModelId.serviceTier).toString();
         sessionState.supportedReasoningEfforts = model.supportedReasoningEfforts;
         sessionState.supportedInputModalities = model.inputModalities;
 
@@ -350,28 +349,35 @@ export class CodexAcpServer implements acp.Agent {
     }
 
     private findCurrentModel(models: Model[], currentModelId: string): Model | undefined {
-        return models.find(m => m.id === currentModelId);
+        const modelId = ModelId.fromString(currentModelId);
+        return models.find(m => m.id === modelId.model);
     }
 
-    private createModelState(availableModels: Model[], selection: ModelSelection): SessionModelState {
+    private createModelState(availableModels: Model[], selectedModelId: string): SessionModelState {
         const allowedModels = availableModels
-            .map((model) => ({
-                modelId: model.id,
-                name: model.displayName,
-                description: model.description,
-                _meta: {
-                    supportedReasoningEfforts: model.supportedReasoningEfforts,
-                    defaultReasoningEffort: model.defaultReasoningEffort,
-                    serviceTiers: model.additionalSpeedTiers,
-                },
-            }));
+            .flatMap((model) =>
+                model.supportedReasoningEfforts.flatMap((effort) => {
+                    const standardModel = {
+                        modelId: ModelId.fromComponents(model, effort.reasoningEffort).toString(),
+                        name: `${model.displayName} (${effort.reasoningEffort})`,
+                        description: `${model.description} ${effort.description}`,
+                    };
+                    if (!model.additionalSpeedTiers.includes("fast")) {
+                        return [standardModel];
+                    }
+                    return [
+                        standardModel,
+                        {
+                            modelId: ModelId.fromComponents(model, effort.reasoningEffort, "fast").toString(),
+                            name: `${model.displayName} (${effort.reasoningEffort}, fast)`,
+                            description: `${model.description} ${effort.description} Fast service tier.`,
+                        },
+                    ];
+                })
+            );
         return {
             availableModels: allowedModels,
-            currentModelId: selection.currentModelId,
-            _meta: {
-                currentReasoningEffort: selection.currentReasoningEffort,
-                currentServiceTier: selection.currentServiceTier,
-            },
+            currentModelId: selectedModelId,
         }
     }
 
@@ -395,14 +401,12 @@ export class CodexAcpServer implements acp.Agent {
         );
 
         const account = await this.getActiveAccount();
-        const {sessionId, currentModelId, currentReasoningEffort, currentServiceTier, models, thread} = sessionMetadata;
+        const {sessionId, currentModelId, models, thread} = sessionMetadata;
         const sessionMcpServers = this.resolveSessionMcpServers(requestedMcpServers, true);
         const currentModel = this.findCurrentModel(models, currentModelId);
         const sessionState: SessionState = {
             sessionId: sessionId,
             currentModelId: currentModelId,
-            currentReasoningEffort: currentReasoningEffort,
-            currentServiceTier: currentServiceTier,
             supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
             supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
             agentMode: AgentMode.getInitialAgentMode(),
@@ -426,7 +430,7 @@ export class CodexAcpServer implements acp.Agent {
         }
 
         await this.availableCommands.publish(sessionId);
-        const sessionModelState: SessionModelState = this.createModelState(models, sessionState);
+        const sessionModelState: SessionModelState = this.createModelState(models, currentModelId);
         const sessionModeState: SessionModeState = sessionState.agentMode.toSessionModeState();
 
         return {
@@ -763,6 +767,7 @@ export class CodexAcpServer implements acp.Agent {
                 };
             }
 
+            const modelId = ModelId.fromString(sessionState.currentModelId);
             const modelLacksReasoning = sessionState.supportedReasoningEfforts.length > 0
                 && sessionState.supportedReasoningEfforts.every(e => e.reasoningEffort === "none");
 
@@ -779,7 +784,7 @@ export class CodexAcpServer implements acp.Agent {
             }
             const agentMode = sessionState.agentMode;
             const turnCompleted = await this.runWithProcessCheck(
-                () => this.codexAcpClient.sendPrompt(params, agentMode, sessionState, disableSummary, sessionState.cwd));
+                () => this.codexAcpClient.sendPrompt(params, agentMode, modelId, disableSummary, sessionState.cwd));
 
             // Check if turn was interrupted (cancelled)
             if (turnCompleted.turn.status === "interrupted") {
@@ -823,7 +828,7 @@ export class CodexAcpServer implements acp.Agent {
     private buildQuotaMeta(sessionState: SessionState): { quota: QuotaMeta } {
         const lastTokenUsage = sessionState.lastTokenUsage;
 
-        const modelName = sessionState.currentModelId;
+        const modelName = ModelId.fromString(sessionState.currentModelId).model;
 
         // FIXME: currently all tokens are reported for the current model
         const modelUsage = (lastTokenUsage != null)
@@ -896,14 +901,3 @@ export class CodexAcpServer implements acp.Agent {
 function getRequestedMcpServerNames(mcpServers: Array<acp.McpServer>): Array<string> {
     return Array.from(new Set(mcpServers.map(server => server.name)));
 }
-
-function readStringMeta(meta: { [key: string]: unknown } | null | undefined, key: string): string | null {
-    const value = meta?.[key];
-    if (value === undefined || value === null) {
-        return null;
-    }
-    if (typeof value !== "string") {
-        throw RequestError.invalidParams(`Expected _meta.${key} to be a string`);
-    }
-    return value;
-}