converse-mcp-server 3.3.0 → 3.4.0

package/.env.example

@@ -80,9 +80,9 @@ OPENROUTER_API_KEY=your_openrouter_api_key_here
 # WARNING: Interactive policies may cause hangs in server/headless mode
 # CODEX_APPROVAL_POLICY=never
 
-# Default Codex model (default: gpt-5.6-sol)
-# Options: gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.3-codex-spark
-# CODEX_MODEL=gpt-5.6-sol
+# Default Codex backend model (default: gpt-6-astra). Per-request override: models: ["codex:<model>"]
+# Options: gpt-6-astra, gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gpt-5.5, gpt-5.3-codex-spark
+# CODEX_MODEL=gpt-6-astra
 
 # ============================================
 # Server Configuration

package/README.md

@@ -281,7 +281,9 @@ Any other model works via its full `provider/model` slug or the `openrouter:` na
 
 ### Codex Models
 
-- **codex**: OpenAI Codex agentic coding assistant
+- **codex**: OpenAI Codex agentic coding assistant (GPT-6 Astra by default)
+  - Pick another backend per request with `codex:<model>` (e.g. `codex:sol`, `codex:gpt-5.6-terra`) or globally with `CODEX_MODEL`; backends: `gpt-6-astra` (alias `astra`), `gpt-5.6-sol` (`sol`), `gpt-5.6-terra` (`terra`), `gpt-5.6-luna` (`luna`), `gpt-5.5`, `gpt-5.3-codex-spark` (`spark`)
+  - `reasoning_effort` maps onto the tiers the chosen backend accepts (GPT-6 Astra: `low` through `max`, no `none`)
   - Thread-based sessions with persistent context
   - Direct filesystem access from working directory
   - Typical response time: 6-20 seconds (longer for complex tasks)
@@ -357,6 +359,7 @@ CODEX_API_KEY=your_codex_api_key_here       # Optional if ChatGPT login availabl
 CODEX_SANDBOX_MODE=read-only                 # read-only (default), workspace-write, danger-full-access
 CODEX_SKIP_GIT_CHECK=true                    # true (default), false
 CODEX_APPROVAL_POLICY=never                  # never (default), untrusted, on-failure, on-request
+CODEX_MODEL=gpt-6-astra                      # gpt-6-astra (default), gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gpt-5.5
 ```
 
 ### Configuration Options

package/docs/API.md

@@ -456,12 +456,13 @@ Any other model works via its full `provider/model` slug (e.g. `anthropic/claude
 
 **Codex** is an agentic coding assistant with direct filesystem access:
 
-- **Model**: `codex` (underlying model: GPT-5.6)
+- **Model**: `codex` (underlying model: GPT-6 Astra by default)
+- **Backend selection**: `codex:<model>` per request (e.g. `codex:astra`, `codex:sol`, `codex:gpt-5.6-terra`), or `CODEX_MODEL` globally; unknown names pass through to the CLI verbatim
 - **Thread-based sessions**: persistent conversation history via `continuation_id` in `chat` mode
 - **Direct file access**: reads files from the working directory (paths relative to `CLIENT_CWD`)
 - **Response times**: 6-20 seconds typical (complex tasks may take minutes)
 - **Authentication**: ChatGPT login OR `CODEX_API_KEY` (NOT `OPENAI_API_KEY`)
-- `reasoning_effort` and web search are not applicable — Codex manages its own execution
+- `reasoning_effort` is clamped onto the tiers the chosen backend accepts (GPT-6 Astra: `low`–`max`, no `none`; GPT-5.6: `none`–`max`); web search is not applicable — Codex manages its own execution
 
 ### Claude Agent SDK (subscription)
 

package/docs/PROVIDERS.md

@@ -101,9 +101,11 @@ This guide documents all supported AI providers in the Converse MCP Server and t
   - `CODEX_SANDBOX_MODE` - Filesystem access control (default: read-only)
   - `CODEX_SKIP_GIT_CHECK` - Skip Git repository validation (default: true)
   - `CODEX_APPROVAL_POLICY` - Command approval behavior (default: never)
-  - `CODEX_MODEL` - Underlying model for Codex sessions (default: gpt-5.6-sol; e.g. gpt-5.6-terra, gpt-5.6-luna, gpt-5.5)
+  - `CODEX_MODEL` - Underlying model for Codex sessions (default: gpt-6-astra; e.g. gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gpt-5.5)
 - **Supported Models**:
-  - `codex` - OpenAI Codex agentic coding assistant (GPT-5.6 by default)
+  - `codex` - OpenAI Codex agentic coding assistant (GPT-6 Astra by default)
+  - `codex:<model>` - Same, with an explicit backend: `codex:astra`, `codex:sol`, `codex:terra`, `codex:luna`, `codex:gpt-5.5`, `codex:spark`, or any slug the Codex CLI knows
+  - `reasoning_effort` is clamped onto what the backend accepts (GPT-6 Astra: `low`–`max`, no `none`)
   - Thread-based sessions with persistent context
   - Direct filesystem access from working directory
   - Typical response time: 6-20 seconds (longer for complex tasks)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "converse-mcp-server",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "Converse MCP Server - Converse with other LLMs with chat and consensus tools",
   "type": "module",
   "main": "src/index.js",
@@ -93,28 +93,28 @@
     ".env.example"
   ],
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.258",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.261",
     "@anthropic-ai/sdk": "^0.123.0",
     "@github/copilot-sdk": "^1.0.11",
-    "@google/genai": "^2.20.0",
+    "@google/genai": "^2.21.0",
     "@lydell/node-pty": "1.2.0-beta.15",
     "@mistralai/mistralai": "^2.6.4",
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@openai/codex-sdk": "^0.152.1",
+    "@openai/codex-sdk": "^0.153.3",
     "cors": "^2.8.6",
     "dotenv": "^17.4.2",
     "express": "^5.2.1",
     "lru-cache": "^11.5.2",
     "nanoid": "^6.0.1",
-    "openai": "^7.9.0",
+    "openai": "^7.10.0",
     "p-limit": "^7.3.2",
     "vite": "^8.2.2"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/coverage-v8": "^5.0.0",
     "cross-env": "^10.1.0",
-    "eslint": "^10.9.1",
+    "eslint": "^10.10.0",
     "rimraf": "^6.1.3",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.0"
   }
 }

package/src/config.js

@@ -280,9 +280,9 @@ const CONFIG_SCHEMA = {
     },
     CODEX_MODEL: {
       type: 'string',
-      default: 'gpt-5.6-sol',
+      default: 'gpt-6-astra',
       description:
-        'Default Codex model (e.g., gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gpt-5.5)',
+        'Default Codex backend model (e.g., gpt-6-astra, gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gpt-5.5)',
     },
 
     // Copilot configuration

package/src/providers/codex.js

@@ -17,35 +17,75 @@ import { debugLog, debugError } from '../utils/console.js';
 import { ProviderError, ErrorCodes, StopReasons } from './interface.js';
 import { normalizeExtendedPath } from '../utils/pathUtils.js';
 
-// Supported Codex models with their configurations
+/**
+ * Every Codex reasoning tier, weakest to strongest. Used to clamp a requested
+ * tier onto the set a given backend model accepts.
+ *
+ * Codex also exposes 'ultra' above 'max', but that tier turns on automatic
+ * sub-agent delegation — a change in how the run executes, not just how deep
+ * it reasons — so nothing at the tool level maps to it and it is kept off the
+ * ladder so the clamp can never select it.
+ */
+const EFFORT_LADDER = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+
+/**
+ * Backend models Codex can run, keyed by the slug passed to the CLI as
+ * --model. The reasoning tiers are the ones each model's API accepts, verified
+ * against the API's own rejection messages (gpt-6-astra: "Supported values
+ * are: 'low', 'medium', 'high', 'xhigh', and 'max'"). The SDK's
+ * ModelReasoningEffort type is the union across models, so the backend is the
+ * authority and requests are clamped per model.
+ */
+const CODEX_BACKEND_MODELS = {
+  'gpt-6-astra': {
+    aliases: ['astra', 'gpt-6', 'gpt6', 'gpt6-astra'],
+    contextWindow: 272000,
+    supportedEfforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+  },
+  'gpt-5.6-sol': {
+    aliases: ['sol', 'gpt-5.6', 'gpt5.6', 'gpt-5.6-codex'],
+    contextWindow: 272000,
+    supportedEfforts: ['none', 'low', 'medium', 'high', 'xhigh', 'max'],
+  },
+  'gpt-5.6-terra': {
+    aliases: ['terra'],
+    contextWindow: 272000,
+    supportedEfforts: ['none', 'low', 'medium', 'high', 'xhigh', 'max'],
+  },
+  'gpt-5.6-luna': {
+    aliases: ['luna'],
+    contextWindow: 272000,
+    supportedEfforts: ['none', 'low', 'medium', 'high', 'xhigh', 'max'],
+  },
+  'gpt-5.5': {
+    aliases: ['gpt5.5'],
+    contextWindow: 272000,
+    supportedEfforts: ['low', 'medium', 'high', 'xhigh'],
+  },
+  'gpt-5.3-codex-spark': {
+    aliases: ['spark', 'codex-spark'],
+    contextWindow: 128000,
+    supportedEfforts: ['low', 'medium', 'high', 'xhigh'],
+  },
+};
+
+const DEFAULT_BACKEND_MODEL = 'gpt-6-astra';
+
+// The single user-facing model the router exposes. The backend model behind it
+// comes from CODEX_MODEL, or from a `codex:<model>` spec.
 const SUPPORTED_MODELS = {
   codex: {
     modelName: 'codex',
-    friendlyName: 'OpenAI Codex (GPT-5.6)',
-    contextWindow: 400000,
+    friendlyName: 'OpenAI Codex (GPT-6 Astra)',
+    contextWindow: CODEX_BACKEND_MODELS[DEFAULT_BACKEND_MODEL].contextWindow,
     maxOutputTokens: 128000,
     supportsStreaming: true,
     supportsImages: true, // Codex SDK 0.118+ supports images via --image (local_image input)
     supportsWebSearch: false, // Codex accesses files directly, not web
-    // Reasoning tiers this model's backend actually accepts. GPT-5.6 dropped
-    // 'minimal' and added 'none', while the SDK's ModelReasoningEffort type
-    // still advertises the pre-5.6 set — the backend is the authority, so the
-    // accepted tiers are declared per model and requests are clamped onto them.
-    supportedEfforts: ['none', 'low', 'medium', 'high', 'xhigh'],
     timeout: 1800000, // 30 minutes
     description:
-      'OpenAI Codex agentic coding assistant with local file access and tool execution (GPT-5.6)',
-    aliases: [
-      'gpt-5-codex',
-      'gpt5-codex',
-      'gpt-5.2-codex',
-      'gpt-5.3-codex',
-      'gpt5.3-codex',
-      'gpt-5.5',
-      'gpt5.5',
-      'gpt-5.6-codex',
-      'gpt5.6-codex',
-    ],
+      'OpenAI Codex agentic coding assistant with local file access and tool execution (GPT-6 Astra by default; pick another backend with codex:<model> or CODEX_MODEL)',
+    aliases: [],
   },
 };
 
@@ -195,6 +235,57 @@ function extractPromptText(input) {
     .join('\n\n');
 }
 
+/**
+ * Resolve a backend slug or alias (case-insensitive) to its catalog slug.
+ * @param {string} name
+ * @returns {string|null}
+ */
+function findBackendSlug(name) {
+  const lower = String(name || '').trim().toLowerCase();
+  if (!lower) {
+    return null;
+  }
+  if (CODEX_BACKEND_MODELS[lower]) {
+    return lower;
+  }
+  return (
+    Object.keys(CODEX_BACKEND_MODELS).find((slug) =>
+      CODEX_BACKEND_MODELS[slug].aliases.includes(lower),
+    ) || null
+  );
+}
+
+/**
+ * Catalog entry for a backend model, or null when the slug is not catalogued.
+ * @param {string} name - Backend slug or alias
+ * @returns {{ slug: string, aliases: string[], contextWindow: number, supportedEfforts: string[] }|null}
+ */
+export function getBackendModelConfig(name) {
+  const slug = findBackendSlug(name);
+  return slug ? { slug, ...CODEX_BACKEND_MODELS[slug] } : null;
+}
+
+/**
+ * Resolve the requested model spec to the backend slug passed to the CLI.
+ *
+ * `codex` uses CODEX_MODEL (default gpt-6-astra); `codex:<model>` names a
+ * backend directly, by slug or alias. Unknown names pass through verbatim so a
+ * newly released model works before it is catalogued here — the CLI rejects
+ * anything the backend does not know.
+ *
+ * @param {string} spec - Requested model, e.g. 'codex' or 'codex:sol'
+ * @param {Object} [config] - Loaded configuration
+ * @returns {string} Backend slug for the SDK's `model` option
+ */
+export function resolveBackendModel(spec, config) {
+  const raw = String(spec || '').trim();
+  const requested = raw.toLowerCase().startsWith('codex:')
+    ? raw.slice('codex:'.length).trim()
+    : '';
+  const name = requested || config?.providers?.codexmodel || DEFAULT_BACKEND_MODEL;
+  return findBackendSlug(name) || name;
+}
+
 /**
  * Get thread ID from continuation metadata.
  * Codex thread IDs are stored per call-plan in `providerThreads`, keyed by a
@@ -216,12 +307,6 @@ async function getThreadIdFromContinuation(
   }
 }
 
-/**
- * Every Codex reasoning tier, weakest to strongest. Used to clamp a requested
- * tier onto the set a given model actually accepts.
- */
-const EFFORT_LADDER = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'];
-
 /**
  * Tool-level reasoning_effort values translated to their Codex equivalent.
  * Tool enum: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'max'
@@ -232,7 +317,7 @@ const EFFORT_ALIASES = {
   low: 'low',
   medium: 'medium',
   high: 'high',
-  max: 'xhigh',
+  max: 'max',
 };
 
 /**
@@ -403,8 +488,9 @@ export const codexProvider = {
       const approvalPolicy = config.providers?.codexapprovalpolicy || 'never';
 
       // Create or resume thread
+      const backendModel = resolveBackendModel(model, config);
       const threadOptions = {
-        model: config.providers?.codexmodel,
+        model: backendModel,
         workingDirectory,
         sandboxMode,
         skipGitRepoCheck,
@@ -413,13 +499,12 @@ export const codexProvider = {
 
       if (reasoning_effort) {
         const supportedEfforts =
-          findModelConfig(model)?.supportedEfforts ||
-          SUPPORTED_MODELS.codex.supportedEfforts;
+          getBackendModelConfig(backendModel)?.supportedEfforts || EFFORT_LADDER;
         const mappedEffort = mapReasoningEffort(reasoning_effort, supportedEfforts);
         threadOptions.modelReasoningEffort = mappedEffort;
         if (mappedEffort !== EFFORT_ALIASES[reasoning_effort]) {
           debugLog(
-            `[Codex] reasoning_effort "${reasoning_effort}" not supported by ${model} — using "${mappedEffort}"`,
+            `[Codex] reasoning_effort "${reasoning_effort}" not supported by ${backendModel} — using "${mappedEffort}"`,
           );
         }
       }
@@ -470,6 +555,7 @@ export const codexProvider = {
         metadata: {
           provider: 'codex',
           model,
+          backendModel,
           threadId: threadIdFromStream || thread.id,
           usage: usage
             ? {

package/src/utils/modelRouting.js

@@ -138,9 +138,10 @@ function classifyModelSpec(spec, providers) {
   }
 
   // Other explicit namespaces pass the spec through unchanged; the target
-  // provider strips its own prefix (preserves current copilot/claude/gemini-cli
+  // provider strips its own prefix (preserves current codex/copilot/claude/gemini-cli
   // behavior).
   if (
+    lower.startsWith('codex:') ||
     lower.startsWith('copilot:') ||
     lower.startsWith('claude:') ||
     lower.startsWith('gemini:')
@@ -308,8 +309,9 @@ export function mapModelToProvider(model, providers) {
     return 'openai';
   }
 
-  // Check Codex (exact match only - don't route "gpt-5-codex" etc to Codex provider)
-  if (modelLower === 'codex') {
+  // Check Codex: bare `codex` or the `codex:<backend>` namespace (e.g. codex:astra,
+  // codex:gpt-5.6-sol). Bare "gpt-*" names never route here — they are OpenAI API models.
+  if (modelLower === 'codex' || modelLower.startsWith('codex:')) {
     return 'codex';
   }