Apply Codex reasoning defaults in dashboard spawn flows

package.json

@@ -42,7 +42,12 @@
   },
   "dependencies": {
     "@agent-relay/bridge": "^2.3.14",
-    "@agent-relay/utils": "^3.1.22",
+    "@agent-relay/config": "^3.2.5",
+    "@agent-relay/protocol": "^2.3.14",
+    "@agent-relay/sdk": "^3.2.5",
+    "@agent-relay/storage": "^2.3.14",
+    "@agent-relay/trajectory": "^3.2.5",
+    "@agent-relay/utils": "^3.2.5",
     "@agent-relay/wrapper": "^2.3.14",
     "yaml": "^2.8.2"
   }

packages/dashboard-server/package.json

@@ -33,12 +33,12 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@agent-relay/config": "3.1.22",
-    "@agent-relay/protocol": "2.3.14",
-    "@agent-relay/sdk": "3.1.22",
-    "@agent-relay/storage": "2.3.14",
-    "@agent-relay/trajectory": "3.1.22",
-    "@agent-relay/utils": "3.1.22",
+    "@agent-relay/config": "^3.2.5",
+    "@agent-relay/protocol": "^2.3.14",
+    "@agent-relay/sdk": "^3.2.5",
+    "@agent-relay/storage": "^2.3.14",
+    "@agent-relay/trajectory": "^3.2.5",
+    "@agent-relay/utils": "^3.2.5",
     "@relaycast/sdk": "^0.5.1",
     "@relaycast/types": "^0.5.1",
     "express": "^5.2.1",

packages/dashboard-server/src/proxy-server.test.ts

@@ -286,6 +286,31 @@ describe('Dashboard Server', () => {
       expect(data.ok).toBe(true);
     });
 
+    it('should expose Codex reasoning metadata from /api/models', async () => {
+      const address = server.server.address();
+      if (!address || typeof address === 'string') {
+        throw new Error('Server address not available');
+      }
+      const port = address.port;
+
+      const response = await fetch(`http://localhost:${port}/api/models`);
+      const data = await response.json();
+
+      expect(response.ok).toBe(true);
+      expect(data.success).toBe(true);
+      expect(Array.isArray(data.modelOptions?.Codex)).toBe(true);
+
+      const codexMini = data.modelOptions.Codex.find((model: { value: string }) => model.value === 'gpt-5.1-codex-mini');
+      expect(codexMini).toBeDefined();
+      expect(codexMini.defaultReasoningEffort).toBe('high');
+      expect(codexMini.reasoningEfforts).toEqual(['medium', 'high']);
+
+      const codexFrontier = data.modelOptions.Codex.find((model: { value: string }) => model.value === 'gpt-5.4');
+      expect(codexFrontier).toBeDefined();
+      expect(codexFrontier.defaultReasoningEffort).toBe('xhigh');
+      expect(codexFrontier.reasoningEfforts).toEqual(['low', 'medium', 'high', 'xhigh']);
+    });
+
     it('should proxy /api/brokers/* routes in proxy mode', async () => {
       const address = server.server.address();
       if (!address || typeof address === 'string') {

packages/dashboard-server/src/routes/models.ts

@@ -1,17 +1,86 @@
 import type { Application } from 'express';
 
+type ReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh';
+
+type ModelOption = {
+  value: string;
+  label: string;
+  reasoningEfforts?: ReasoningEffort[];
+  defaultReasoningEffort?: ReasoningEffort;
+};
+
+type ModelOptionsResponse = Record<string, ModelOption[]>;
+type DefaultModelsResponse = Record<string, string>;
+type ConfigModule = typeof import('@agent-relay/config') & {
+  getDefaultReasoningEffort?: (cli: string, model: string) => ReasoningEffort | undefined;
+  getSupportedReasoningEfforts?: (cli: string, model: string) => ReasoningEffort[] | undefined;
+};
+
+function inferCodexReasoningEfforts(model: string): ReasoningEffort[] | undefined {
+  if (model === 'gpt-5.1-codex-mini') {
+    return ['medium', 'high'];
+  }
+
+  if (model.startsWith('gpt-5')) {
+    return ['low', 'medium', 'high', 'xhigh'];
+  }
+
+  return undefined;
+}
+
+function enrichCodexModelOptions(
+  modelOptions: ModelOptionsResponse,
+  config: ConfigModule,
+): ModelOptionsResponse {
+  const codexOptions = Array.isArray(modelOptions.Codex) ? modelOptions.Codex : null;
+  if (!codexOptions) {
+    return modelOptions;
+  }
+
+  const enrichedCodexOptions = codexOptions.map((option) => {
+    const reasoningEfforts =
+      option.reasoningEfforts
+      ?? config.getSupportedReasoningEfforts?.('codex', option.value)
+      ?? inferCodexReasoningEfforts(option.value);
+
+    if (!reasoningEfforts || reasoningEfforts.length === 0) {
+      return option;
+    }
+
+    const defaultReasoningEffort =
+      option.defaultReasoningEffort
+      ?? config.getDefaultReasoningEffort?.('codex', option.value)
+      ?? reasoningEfforts[reasoningEfforts.length - 1];
+
+    return {
+      ...option,
+      reasoningEfforts,
+      defaultReasoningEffort,
+    };
+  });
+
+  return {
+    ...modelOptions,
+    Codex: enrichedCodexOptions,
+  };
+}
+
 /**
  * Model options route.
  * Serves model options from @agent-relay/config (generated from cli-registry.yaml).
  */
 export function registerModelsRoutes(app: Application): void {
   app.get('/api/models', async (_req, res) => {
     try {
-      const { ModelOptions, DefaultModels } = await import('@agent-relay/config');
+      const config = await import('@agent-relay/config') as ConfigModule;
+      const modelOptions = enrichCodexModelOptions(
+        config.ModelOptions as ModelOptionsResponse,
+        config,
+      );
       return res.json({
         success: true,
-        modelOptions: ModelOptions,
-        defaultModels: DefaultModels,
+        modelOptions,
+        defaultModels: config.DefaultModels as DefaultModelsResponse,
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);

packages/dashboard/src/adapters/cloudFetchAdapter.test.ts

@@ -0,0 +1,49 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createCloudApiAdapter, setCloudCsrfToken } from './cloudFetchAdapter';
+
+describe('createCloudApiAdapter', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    setCloudCsrfToken(null);
+  });
+
+  it('includes reasoningEffort in workspace spawn requests when provided', async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      headers: new Headers(),
+      json: async () => ({
+        name: 'codex-1',
+        sandboxId: 'sandbox-1',
+        status: 'online',
+        cli: 'codex',
+        workspaceId: 'ws-1',
+        createdAt: '2026-03-17T00:00:00.000Z',
+      }),
+    }));
+
+    vi.stubGlobal('fetch', fetchMock);
+
+    const adapter = createCloudApiAdapter();
+    await adapter.spawnAgent('ws-1', {
+      name: 'codex-1',
+      provider: 'codex',
+      model: 'gpt-5.4',
+      reasoningEffort: 'xhigh',
+      cwd: 'repo-a',
+    });
+
+    expect(fetchMock).toHaveBeenCalledOnce();
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(String(url)).toBe('/api/workspaces/ws-1/agents');
+    expect(init?.method).toBe('POST');
+    expect(JSON.parse(String(init?.body))).toEqual({
+      name: 'codex-1',
+      provider: 'codex',
+      model: 'gpt-5.4',
+      reasoningEffort: 'xhigh',
+      cwd: 'repo-a',
+    });
+  });
+});

packages/dashboard/src/adapters/types.ts

@@ -471,6 +471,7 @@ export interface CloudApiAdapter {
       task?: string;
       cwd?: string;
       model?: string;
+      reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh';
     }
   ): Promise<
     CloudApiResult<{