pass the model

packages/bridge/src/spawner.ts

@@ -15,6 +15,7 @@
 import { createTraceableError } from '@agent-relay/utils/error-tracking';
 import { createLogger } from '@agent-relay/utils/logger';
 import { mapModelToCli } from '@agent-relay/utils/model-mapping';
+import { isModelSwitchSupported, buildModelSwitchCommand, validateModelForCli } from '@agent-relay/utils/model-commands';
 import { findRelayPtyBinary as findRelayPtyBinaryUtil, getLastSearchPaths } from '@agent-relay/utils/relay-pty-path';
 import { RelayPtyOrchestrator, type RelayPtyOrchestratorConfig } from '@agent-relay/wrapper';
 import { OpenCodeWrapper, type OpenCodeWrapperConfig, OpenCodeApi } from '@agent-relay/wrapper';
@@ -92,6 +93,8 @@
   spawnedAt: number;
   pid?: number;
   logFile?: string;
+  /** Current model if known */
+  model?: string;
 }
 
 /** Stored listener references for cleanup */
@@ -578,7 +581,7 @@
       }
 
       // Clear workers.json to start fresh
       fs.writeFileSync(this.workersPath, JSON.stringify({ workers: [] }, null, 2));
 
       if (orphansKilled > 0) {
         log.info(`Cleaned up ${orphansKilled} orphaned worker(s) from previous run`);
@@ -826,7 +829,7 @@
    * Spawn a new worker agent using relay-pty
    */
   async spawn(request: SpawnRequest): Promise<SpawnResult> {
-    const { name, cli, task, team, spawnerName, userId, includeWorkflowConventions, interactive } = request;
+    const { name, cli, task, team, spawnerName, userId, includeWorkflowConventions, interactive, model: modelOverride } = request;
     const debug = process.env.DEBUG_SPAWN === '1';
 
     // Validate agent name to prevent path traversal attacks
@@ -917,6 +920,11 @@
         log.warn(`Could not resolve path for '${commandName}', spawn may fail`);
       }
 
+      // Track the effective model for this spawn.
+      // Model override from spawn request applies to ALL CLIs.
+      // CLI-specific blocks below may refine this (e.g., Claude agent profile lookup).
+      let spawnModel: string | undefined = modelOverride;
+
       // Pre-configure MCP permissions for all supported CLIs
       // This creates/updates CLI-specific settings files with agent-relay permissions
       ensureMcpPermissions(this.projectRoot, commandName, debug);
@@ -954,8 +962,15 @@
           ? mapModelToCli(modelFromProfile)
           : mapModelToCli(); // defaults to claude:sonnet
 
-        // Extract effective model name for logging
-        const effectiveModel = modelFromProfile || 'opus';
+        // Extract effective model name for logging and tracking
+        // Model override from spawn request takes precedence over agent profile
+        const effectiveModel = modelOverride || modelFromProfile || 'opus';
+        spawnModel = effectiveModel;
+
+        // If model override provided, add --model before buildClaudeArgs so it takes precedence
+        if (modelOverride && !args.includes('--model')) {
+          args.push('--model', modelOverride);
+        }
 
         const configuredArgs = buildClaudeArgs(name, args, this.projectRoot);
         // Replace args with configured version (includes --model and --agent if found)
@@ -984,6 +999,12 @@
         }
       }
 
+      // Pass model override to non-Claude CLIs via --model flag
+      // Claude handles this separately in its agent config block above
+      if (modelOverride && !isClaudeCli && !args.includes('--model') && !args.includes('-m')) {
+        args.push('--model', modelOverride);
+      }
+
       // Check if MCP tools are available
       // Must verify BOTH conditions (matching inbox hook behavior from commit 18bab59):
       // 1. MCP config exists (user or project scope)
@@ -1329,6 +1350,7 @@
             pty: openCodeWrapper as unknown as AgentWrapper,
             logFile: openCodeWrapper.logPath,
             listeners,
+            model: spawnModel,
           };
           this.activeWorkers.set(name, workerInfo);
           this.saveWorkersMetadata();
@@ -1538,6 +1560,7 @@
         pty,
         logFile: pty.logPath,
         listeners, // Store for cleanup
+        model: spawnModel,
       };
       this.activeWorkers.set(name, workerInfo);
       this.saveWorkersMetadata();
@@ -1766,6 +1789,7 @@
       spawnerName: w.spawnerName,
       spawnedAt: w.spawnedAt,
       pid: w.pid,
+      model: w.model,
     }));
   }
 
@@ -1789,6 +1813,7 @@
       team: worker.team,
       spawnedAt: worker.spawnedAt,
       pid: worker.pid,
+      model: worker.model,
     };
   }
 
@@ -1823,6 +1848,72 @@
     return true;
   }
 
+  /**
+   * Switch the model of a running worker agent.
+   * Waits for the agent to be idle, then sends the CLI-specific model switch command.
+   *
+   * @param name - Worker name
+   * @param model - Target model identifier (e.g., 'opus', 'sonnet', 'haiku')
+   * @param timeoutMs - Max time to wait for agent idle (default: 30000)
+   * @returns Result of the model switch attempt
+   */
+  async setWorkerModel(
+    name: string,
+    model: string,
+    timeoutMs = 30000,
+  ): Promise<{ success: boolean; previousModel?: string; normalizedModel?: string; error?: string }> {
+    const worker = this.activeWorkers.get(name);
+    if (!worker) {
+      return { success: false, error: `Agent "${name}" not found` };
+    }
+
+    // Validate CLI supports model switching
+    if (!isModelSwitchSupported(worker.cli)) {
+      return { success: false, error: `CLI "${worker.cli}" does not support mid-session model switching` };
+    }
+
+    // Validate and normalize model name
+    const validation = validateModelForCli(worker.cli, model);
+    if (!validation.valid) {
+      return { success: false, error: validation.error };
+    }
+    const normalizedModel = validation.normalizedModel ?? model;
+
+    // Build the command using normalized model
+    const command = buildModelSwitchCommand(worker.cli, normalizedModel);
+    if (!command) {
+      return { success: false, error: `Failed to build model switch command for "${worker.cli}"` };
+    }
+
+    // Wait for agent idle via readiness detection
+    const pty = worker.pty;
+    if ('waitUntilReadyForMessages' in pty && typeof pty.waitUntilReadyForMessages === 'function') {
+      const ready = await pty.waitUntilReadyForMessages(timeoutMs, 200);
+      if (!ready) {
+        return {
+          success: false,
+          error: `Agent "${name}" did not become idle within ${timeoutMs}ms. The agent may be processing a task. Try again later.`,
+        };
+      }
+    } else {
+      log.warn(`PTY for ${name} does not support idle detection; sending model switch without waiting`);
+    }
+
+    // Send the command via write() (raw stdin)
+    try {
+      const previousModel = worker.model;
+      await pty.write(command);
+      worker.model = normalizedModel;
+      this.saveWorkersMetadata();
+
+      log.info(`Model switched for ${name}: ${previousModel ?? 'unknown'} -> ${normalizedModel}`);
+      return { success: true, previousModel, normalizedModel };
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, error: `Failed to send model switch command: ${message}` };
+    }
+  }
+
   /**
    * Wait for an agent to appear in the connected list and registry (connected-agents.json + agents.json).
    */
@@ -1929,6 +2020,7 @@
         spawnedAt: w.spawnedAt,
         pid: w.pid,
         logFile: w.logFile,
+        model: w.model,
       }));
 
       fs.writeFileSync(this.workersPath, JSON.stringify({ workers }, null, 2));

packages/bridge/src/types.ts

@@ -39,6 +39,8 @@ export interface SpawnRequest {
   cli: string;
   /** Initial task to inject */
   task: string;
+  /** Model override (e.g., 'opus', 'sonnet', 'haiku'). Takes precedence over agent profile. */
+  model?: string;
   /** Optional team name to organize agents under */
   team?: string;
   /** Working directory for the agent (defaults to detected workspace) */
@@ -93,6 +95,8 @@ export interface WorkerInfo {
   spawnedAt: number;
   /** PID of the pty process */
   pid?: number;
+  /** Current model if known (e.g., 'opus', 'sonnet', 'haiku') */
+  model?: string;
 }
 
 /** SpeakOn trigger types for shadow agents */

packages/daemon/src/server.ts

@@ -38,6 +38,7 @@ import {
   type MetricsResponsePayload,
   type AgentReadyPayload,
   type SendInputPayload,
+  type SetModelPayload,
   type ListWorkersPayload,
 } from '@agent-relay/protocol/types';
 import type { ChannelJoinPayload, ChannelLeavePayload, ChannelMessagePayload } from '@agent-relay/protocol/channels';
@@ -1345,6 +1346,17 @@ export class Daemon {
         break;
       }
 
+      case 'SET_MODEL': {
+        if (!this.spawnManager) {
+          this.sendErrorEnvelope(connection, 'SpawnManager not enabled. Configure spawnManager: true in daemon config.');
+          break;
+        }
+        const setModelEnvelope = envelope as Envelope<SetModelPayload>;
+        log.info(`SET_MODEL request: from=${connection.agentName} agent=${setModelEnvelope.payload.name} model=${setModelEnvelope.payload.model}`);
+        this.spawnManager.handleSetModel(connection, setModelEnvelope);
+        break;
+      }
+
       case 'LIST_WORKERS': {
         if (!this.spawnManager) {
           this.sendErrorEnvelope(connection, 'SpawnManager not enabled. Configure spawnManager: true in daemon config.');

packages/daemon/src/spawn-manager-set-model.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SpawnManager } from './spawn-manager.js';
+import type { Envelope, SetModelPayload } from '@agent-relay/protocol/types';
+
+/**
+ * Mock connection that captures sent envelopes.
+ */
+function createMockConnection(agentName: string) {
+  return {
+    id: `conn-${agentName}`,
+    agentName,
+    sessionId: `session-${agentName}`,
+    send: vi.fn(),
+    close: vi.fn(),
+  };
+}
+
+function createSetModelEnvelope(
+  name: string,
+  model: string,
+  timeoutMs?: number,
+): Envelope<SetModelPayload> {
+  return {
+    v: 1,
+    type: 'SET_MODEL',
+    id: `env-${Date.now()}`,
+    ts: Date.now(),
+    payload: { name, model, timeoutMs },
+  };
+}
+
+describe('SpawnManager.handleSetModel', () => {
+  let manager: SpawnManager;
+  let mockSetWorkerModel: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    manager = new SpawnManager({
+      projectRoot: '/tmp/test-project',
+    });
+
+    // Mock the spawner's setWorkerModel method
+    mockSetWorkerModel = vi.fn();
+    (manager as any).spawner.setWorkerModel = mockSetWorkerModel;
+  });
+
+  it('should send success result when model switch succeeds', async () => {
+    const connection = createMockConnection('Lead');
+    const envelope = createSetModelEnvelope('Worker1', 'haiku');
+
+    mockSetWorkerModel.mockResolvedValue({
+      success: true,
+      previousModel: 'sonnet',
+    });
+
+    await manager.handleSetModel(connection as any, envelope);
+
+    expect(mockSetWorkerModel).toHaveBeenCalledWith('Worker1', 'haiku', 30000);
+    expect(connection.send).toHaveBeenCalledTimes(1);
+
+    const result = connection.send.mock.calls[0][0];
+    expect(result.type).toBe('SET_MODEL_RESULT');
+    expect(result.payload.success).toBe(true);
+    expect(result.payload.name).toBe('Worker1');
+    expect(result.payload.model).toBe('haiku');
+    expect(result.payload.previousModel).toBe('sonnet');
+    expect(result.payload.error).toBeUndefined();
+  });
+
+  it('should send failure result when model switch fails', async () => {
+    const connection = createMockConnection('Lead');
+    const envelope = createSetModelEnvelope('Worker1', 'haiku');
+
+    mockSetWorkerModel.mockResolvedValue({
+      success: false,
+      error: 'Agent "Worker1" did not become idle within 30000ms',
+    });
+
+    await manager.handleSetModel(connection as any, envelope);
+
+    const result = connection.send.mock.calls[0][0];
+    expect(result.type).toBe('SET_MODEL_RESULT');
+    expect(result.payload.success).toBe(false);
+    expect(result.payload.error).toContain('did not become idle');
+  });
+
+  it('should pass custom timeout from payload', async () => {
+    const connection = createMockConnection('Lead');
+    const envelope = createSetModelEnvelope('Worker1', 'opus', 60000);
+
+    mockSetWorkerModel.mockResolvedValue({ success: true });
+
+    await manager.handleSetModel(connection as any, envelope);
+
+    expect(mockSetWorkerModel).toHaveBeenCalledWith('Worker1', 'opus', 60000);
+  });
+
+  it('should handle spawner throwing an error', async () => {
+    const connection = createMockConnection('Lead');
+    const envelope = createSetModelEnvelope('Worker1', 'opus');
+
+    mockSetWorkerModel.mockRejectedValue(new Error('PTY process crashed'));
+
+    await manager.handleSetModel(connection as any, envelope);
+
+    const result = connection.send.mock.calls[0][0];
+    expect(result.type).toBe('SET_MODEL_RESULT');
+    expect(result.payload.success).toBe(false);
+    expect(result.payload.error).toBe('PTY process crashed');
+  });
+
+  it('should send failure when agent not found', async () => {
+    const connection = createMockConnection('Lead');
+    const envelope = createSetModelEnvelope('NonExistent', 'haiku');
+
+    mockSetWorkerModel.mockResolvedValue({
+      success: false,
+      error: 'Agent "NonExistent" not found',
+    });
+
+    await manager.handleSetModel(connection as any, envelope);
+
+    const result = connection.send.mock.calls[0][0];
+    expect(result.payload.success).toBe(false);
+    expect(result.payload.error).toContain('not found');
+  });
+
+  it('should send failure for unsupported CLI', async () => {
+    const connection = createMockConnection('Lead');
+    const envelope = createSetModelEnvelope('CodexWorker', 'gpt-4o');
+
+    mockSetWorkerModel.mockResolvedValue({
+      success: false,
+      error: 'CLI "codex" does not support mid-session model switching',
+    });
+
+    await manager.handleSetModel(connection as any, envelope);
+
+    const result = connection.send.mock.calls[0][0];
+    expect(result.payload.success).toBe(false);
+    expect(result.payload.error).toContain('does not support');
+  });
+});