@agent-relay/dashboard 2.0.93 → 2.0.94

package/src/components/SpawnModal.test.tsx

@@ -220,4 +220,131 @@ describe('SpawnModal', () => {
       expect(config.cwd).toBe('/custom/path');
     });
   });
+
+  describe('model selection', () => {
+    it('falls back to a supported Codex model and applies the default reasoning effort override', async () => {
+      const onSpawn = vi.fn().mockResolvedValue(true);
+
+      renderSpawnModal({
+        onSpawn,
+        agentDefaults: {
+          defaultCliType: 'codex',
+          defaultModels: {
+            codex: 'gpt-5.1-codex-mini',
+          },
+        },
+        modelOptions: {
+          codex: [
+            {
+              value: 'gpt-5.4',
+              label: 'GPT-5.4',
+              reasoningEfforts: ['low', 'medium', 'high', 'xhigh'],
+              defaultReasoningEffort: 'xhigh',
+            },
+            {
+              value: 'gpt-5.1-codex-max',
+              label: 'GPT-5.1 Codex Max',
+              reasoningEfforts: ['low', 'medium', 'high', 'xhigh'],
+              defaultReasoningEffort: 'xhigh',
+            },
+          ],
+        },
+        registryDefaultModels: {
+          codex: 'gpt-5.4',
+        },
+      });
+
+      const modelSelect = await screen.findByLabelText('Model') as HTMLSelectElement;
+      expect(modelSelect.value).toBe('gpt-5.4');
+
+      fireEvent.submit(getForm());
+
+      await waitFor(() => {
+        expect(onSpawn).toHaveBeenCalled();
+      });
+
+      const config = onSpawn.mock.calls[0][0];
+      expect(config.command).toBe('codex --model gpt-5.4 -c model_reasoning_effort="xhigh"');
+    });
+
+    it('applies the Codex mini reasoning effort override when mini is selected', async () => {
+      const onSpawn = vi.fn().mockResolvedValue(true);
+
+      renderSpawnModal({
+        onSpawn,
+        agentDefaults: {
+          defaultCliType: 'codex',
+          defaultModels: {
+            codex: 'gpt-5.1-codex-mini',
+          },
+        },
+        modelOptions: {
+          codex: [
+            {
+              value: 'gpt-5.1-codex-mini',
+              label: 'GPT-5.1 Codex Mini',
+              reasoningEfforts: ['medium', 'high'],
+              defaultReasoningEffort: 'high',
+            },
+            {
+              value: 'gpt-5.4',
+              label: 'GPT-5.4',
+              reasoningEfforts: ['low', 'medium', 'high', 'xhigh'],
+              defaultReasoningEffort: 'xhigh',
+            },
+          ],
+        },
+        registryDefaultModels: {
+          codex: 'gpt-5.4',
+        },
+      });
+
+      const modelSelect = await screen.findByLabelText('Model') as HTMLSelectElement;
+      expect(modelSelect.value).toBe('gpt-5.1-codex-mini');
+
+      fireEvent.submit(getForm());
+
+      await waitFor(() => {
+        expect(onSpawn).toHaveBeenCalled();
+      });
+
+      const config = onSpawn.mock.calls[0][0];
+      expect(config.command).toBe('codex --model gpt-5.1-codex-mini -c model_reasoning_effort="high"');
+    });
+
+    it('falls back to a supported OpenCode model when a saved default is no longer offered', async () => {
+      const onSpawn = vi.fn().mockResolvedValue(true);
+
+      renderSpawnModal({
+        onSpawn,
+        agentDefaults: {
+          defaultCliType: 'opencode',
+          defaultModels: {
+            opencode: 'openai/gpt-5.1-codex',
+          },
+        },
+        modelOptions: {
+          opencode: [
+            { value: 'openai/gpt-5.2', label: 'GPT-5.2' },
+            { value: 'openai/gpt-5.1-codex-max', label: 'GPT-5.1 Codex Max' },
+          ],
+        },
+        registryDefaultModels: {
+          opencode: 'openai/gpt-5.2',
+        },
+      });
+
+      const modelSelect = await screen.findByLabelText('Model') as HTMLSelectElement;
+      expect(modelSelect.value).toBe('openai/gpt-5.2');
+
+      fireEvent.submit(getForm());
+
+      await waitFor(() => {
+        expect(onSpawn).toHaveBeenCalled();
+      });
+
+      const config = onSpawn.mock.calls[0][0];
+      expect(config.command).toBe('opencode --model openai/gpt-5.2');
+    });
+  });
 });

package/src/components/SpawnModal.tsx

@@ -7,6 +7,7 @@
 
 import React, { useState, useRef, useEffect, useCallback, useMemo } from 'react';
 import { useDashboardConfig } from '../adapters';
+import { buildCommandWithModel, resolveSupportedModel } from '../lib/model-options';
 
 /**
  * Model options are fetched from the server (/api/models) which sources them
@@ -67,6 +68,8 @@ export interface SpawnModalProps {
 export interface ModelOption {
   value: string;
   label: string;
+  reasoningEfforts?: Array<'low' | 'medium' | 'high' | 'xhigh'>;
+  defaultReasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh';
 }
 
 const EMPTY_MODEL_OPTIONS: ModelOption[] = [];
@@ -173,10 +176,8 @@ export function SpawnModal({
   }, [modelOptions]);
 
   const getDefaultModelForCli = useCallback((cli: string): string => {
-    return agentDefaults?.defaultModels?.[cli]
-      ?? registryDefaultModels?.[cli]
-      ?? getModelsForCli(cli)[0]?.value
-      ?? '';
+    const options = getModelsForCli(cli);
+    return resolveSupportedModel(options, agentDefaults?.defaultModels?.[cli], registryDefaultModels?.[cli]);
   }, [agentDefaults, registryDefaultModels, getModelsForCli]);
 
   const [selectedTemplate, setSelectedTemplate] = useState(AGENT_TEMPLATES[0]);
@@ -197,8 +198,14 @@ export function SpawnModal({
 
   /** Get selected model for the current template */
   const getSelectedModel = useCallback((cli: string): string => {
-    return selectedModels[cli] ?? getDefaultModelForCli(cli);
-  }, [selectedModels, getDefaultModelForCli]);
+    const options = getModelsForCli(cli);
+    return resolveSupportedModel(
+      options,
+      selectedModels[cli],
+      agentDefaults?.defaultModels?.[cli],
+      registryDefaultModels?.[cli],
+    );
+  }, [selectedModels, agentDefaults, registryDefaultModels, getModelsForCli]);
 
   const setModelForCli = useCallback((cli: string, model: string) => {
     setSelectedModels(prev => ({ ...prev, [cli]: model }));
@@ -213,11 +220,16 @@ export function SpawnModal({
     if (template?.supportsModelSelection) {
       const model = getSelectedModel(selectedTemplate.id);
       if (model) {
-        return `${selectedTemplate.command} --model ${model}`;
+        return buildCommandWithModel(
+          selectedTemplate.command,
+          selectedTemplate.id,
+          model,
+          getModelsForCli(selectedTemplate.id),
+        );
       }
     }
     return selectedTemplate.command;
-  }, [selectedTemplate, customCommand, getSelectedModel]);
+  }, [selectedTemplate, customCommand, getSelectedModel, getModelsForCli]);
 
   const shadowMode = useMemo(() => deriveShadowMode(effectiveCommand), [effectiveCommand]);
 

package/src/components/settings/SettingsPage.tsx

@@ -12,6 +12,7 @@
 
 import React, { useState, useEffect, useCallback } from 'react';
 import { useDashboardConfig, type DashboardFeatures } from '../../adapters';
+import { resolveSupportedModel } from '../../lib/model-options';
 import type { Settings, CliType } from './types';
 import type { ModelOption } from '../SpawnModal';
 
@@ -410,7 +411,11 @@ export function SettingsPage({
                           description={`Default model when spawning ${label} agents`}
                         >
                           <select
-                            value={settings.agentDefaults?.defaultModels?.[id] ?? registryDefaultModels?.[id] ?? models[0]?.value ?? ''}
+                            value={resolveSupportedModel(
+                              models,
+                              settings.agentDefaults?.defaultModels?.[id],
+                              registryDefaultModels?.[id],
+                            )}
                             onChange={(e) => updateSettings((prev) => ({
                               ...prev,
                               agentDefaults: {

package/src/lib/model-options.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+
+import { parseSpawnCommand } from './model-options';
+
+describe('parseSpawnCommand', () => {
+  it('extracts provider, model, and Codex reasoning effort from the modal command', () => {
+    expect(parseSpawnCommand('codex --model gpt-5.4 -c model_reasoning_effort="xhigh"')).toEqual({
+      provider: 'codex',
+      model: 'gpt-5.4',
+      reasoningEffort: 'xhigh',
+    });
+  });
+
+  it('handles inline model syntax and commands without reasoning effort overrides', () => {
+    expect(parseSpawnCommand('opencode --model=openai/gpt-5.2')).toEqual({
+      provider: 'opencode',
+      model: 'openai/gpt-5.2',
+      reasoningEffort: undefined,
+    });
+  });
+});

package/src/lib/model-options.ts

@@ -0,0 +1,119 @@
+import type { ModelOption } from '../components/SpawnModal';
+
+export type ReasoningEffort = NonNullable<ModelOption['defaultReasoningEffort']>;
+
+const REASONING_EFFORTS: ReasoningEffort[] = ['low', 'medium', 'high', 'xhigh'];
+
+function isReasoningEffort(value: string): value is ReasoningEffort {
+  return REASONING_EFFORTS.includes(value as ReasoningEffort);
+}
+
+function stripWrappingQuotes(value: string): string {
+  if (value.length >= 2) {
+    const first = value[0];
+    const last = value[value.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+      return value.slice(1, -1);
+    }
+  }
+
+  return value;
+}
+
+function tokenizeCommand(command: string): string[] {
+  return command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+}
+
+function hasOptionValue(options: ModelOption[], value: string | undefined): value is string {
+  return typeof value === 'string' && options.some((option) => option.value === value);
+}
+
+function getModelOption(options: ModelOption[], value: string | undefined): ModelOption | undefined {
+  return typeof value === 'string'
+    ? options.find((option) => option.value === value)
+    : undefined;
+}
+
+export function resolveSupportedModel(options: ModelOption[], ...candidates: Array<string | undefined>): string {
+  if (options.length === 0) {
+    return candidates.find((candidate): candidate is string => typeof candidate === 'string' && candidate.length > 0) ?? '';
+  }
+
+  for (const candidate of candidates) {
+    if (hasOptionValue(options, candidate)) {
+      return candidate;
+    }
+  }
+
+  return options[0]?.value ?? '';
+}
+
+export function getDefaultReasoningEffortForModel(
+  options: ModelOption[],
+  model: string | undefined,
+): ReasoningEffort | undefined {
+  return getModelOption(options, model)?.defaultReasoningEffort;
+}
+
+export function parseSpawnCommand(command: string): {
+  provider: string;
+  model?: string;
+  reasoningEffort?: ReasoningEffort;
+} {
+  const tokens = tokenizeCommand(command.trim());
+  const provider = tokens[0] ?? '';
+  let model: string | undefined;
+  let reasoningEffort: ReasoningEffort | undefined;
+
+  for (let index = 1; index < tokens.length; index += 1) {
+    const token = tokens[index];
+
+    if (token === '--model') {
+      const next = tokens[index + 1];
+      if (typeof next === 'string' && next.length > 0) {
+        model = stripWrappingQuotes(next);
+      }
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith('--model=')) {
+      const value = stripWrappingQuotes(token.slice('--model='.length));
+      if (value) {
+        model = value;
+      }
+      continue;
+    }
+
+    const configToken = token === '-c' ? tokens[index + 1] : token;
+    if (typeof configToken === 'string' && configToken.startsWith('model_reasoning_effort=')) {
+      const value = stripWrappingQuotes(configToken.slice('model_reasoning_effort='.length));
+      if (isReasoningEffort(value)) {
+        reasoningEffort = value;
+      }
+      if (token === '-c') {
+        index += 1;
+      }
+    }
+  }
+
+  return { provider, model, reasoningEffort };
+}
+
+export function buildCommandWithModel(
+  baseCommand: string,
+  cli: string,
+  model: string,
+  options: ModelOption[],
+): string {
+  const parts = [baseCommand, '--model', model];
+  const reasoningEffort = cli === 'codex'
+    ? getDefaultReasoningEffortForModel(options, model)
+    : undefined;
+
+  if (reasoningEffort) {
+    parts.push('-c', 'model_reasoning_effort="' + reasoningEffort + '"');
+  }
+
+  return parts.join(' ');
+}

package/src/providers/AgentProvider.tsx

@@ -17,6 +17,7 @@ import { useRecentRepos } from '../components/hooks/useRecentRepos';
 import { useWorkspaceRepos } from '../components/hooks/useWorkspaceRepos';
 import { useCloudWorkspace } from './CloudWorkspaceProvider';
 import { api, convertApiDecision, getCsrfToken } from '../lib/api';
+import { parseSpawnCommand } from '../lib/model-options';
 import { mergeAgentsForDashboard } from '../lib/agent-merge';
 import type { DashboardData } from '../components/hooks/useWebSocket';
 
@@ -493,16 +494,14 @@ export function AgentProvider({ children, data, isConnected }: AgentProviderProp
     setIsSpawning(true);
     setSpawnError(null);
     try {
-      const commandParts = config.command.trim().split(/\s+/);
-      const provider = commandParts[0];
-      const modelIdx = commandParts.indexOf('--model');
-      const model = modelIdx !== -1 && commandParts[modelIdx + 1] ? commandParts[modelIdx + 1] : undefined;
+      const { provider, model, reasoningEffort } = parseSpawnCommand(config.command);
 
       if (hasWorkspaceApi && apiAdapter && activeCloudWorkspaceId) {
         const result = await apiAdapter.spawnAgent(activeCloudWorkspaceId, {
           name: config.name,
           provider,
           model,
+          reasoningEffort,
           cwd: config.cwd,
         });
         if (!result.success) {