Add explicit case to fallback to commander-lite if commander doesn't work

Author: jahooma

packages/agent-runtime/src/tools/handlers/tool/spawn-agent-utils.ts

@@ -159,6 +159,70 @@ export function getMatchingSpawn(
   return null
 }
 
+/**
+ * Synchronously transforms spawn_agents input to use 'commander-lite' instead of 'commander'
+ * when the parent agent doesn't have access to 'commander' but does have access to 'commander-lite'.
+ * This should be called BEFORE the tool call is streamed to the UI.
+ */
+export function transformSpawnAgentsInput(
+  input: Record<string, unknown>,
+  spawnableAgents: AgentTemplateType[],
+): Record<string, unknown> {
+  const agents = input.agents
+  if (!Array.isArray(agents)) {
+    return input
+  }
+
+  let hasTransformation = false
+  const transformedAgents = agents.map((agent) => {
+    if (typeof agent !== 'object' || agent === null) {
+      return agent
+    }
+
+    const agentEntry = agent as Record<string, unknown>
+    const agentTypeStr = agentEntry.agent_type
+    if (typeof agentTypeStr !== 'string') {
+      return agent
+    }
+
+    // Check if this is 'commander'
+    const { agentId } = parseAgentId(agentTypeStr)
+    if (agentId !== 'commander') {
+      return agent
+    }
+
+    // Check if 'commander' is available in spawnableAgents
+    const commanderType = getMatchingSpawn(spawnableAgents, agentTypeStr)
+    if (commanderType) {
+      // Commander is available, no transformation needed
+      return agent
+    }
+
+    // Check if 'commander-lite' is available as a fallback
+    const commanderLiteType = getMatchingSpawn(spawnableAgents, 'commander-lite')
+    if (!commanderLiteType) {
+      // Neither available, let validation handle the error
+      return agent
+    }
+
+    // Transform commander -> commander-lite
+    hasTransformation = true
+    return {
+      ...agentEntry,
+      agent_type: commanderLiteType,
+    }
+  })
+
+  if (!hasTransformation) {
+    return input
+  }
+
+  return {
+    ...input,
+    agents: transformedAgents,
+  }
+}
+
 /**
  * Validates agent template and permissions
  */

packages/agent-runtime/src/tools/tool-executor.ts

@@ -7,6 +7,7 @@ import { MCP_TOOL_SEPARATOR } from '../mcp-constants'
 import { getMCPToolData } from '../mcp'
 import { getAgentShortName } from '../templates/prompts'
 import { codebuffToolHandlers } from './handlers/list'
+import { transformSpawnAgentsInput } from './handlers/tool/spawn-agent-utils'
 import { ensureZodSchema } from './prompts'
 
 import type { AgentTemplateType } from '@codebuff/common/types/session-state'
@@ -187,12 +188,19 @@ export function executeToolCall<T extends ToolName>(
     return previousToolCallFinished
   }
 
+  // Transform spawn_agents input to use commander-lite fallback before streaming
+  // This ensures the UI shows the correct agent type from the start
+  const transformedInput =
+    toolName === 'spawn_agents'
+      ? transformSpawnAgentsInput(input, agentTemplate.spawnableAgents)
+      : input
+
   // Only emit tool_call event after permission check passes
   onResponseChunk({
     type: 'tool_call',
     toolCallId,
     toolName,
-    input,
+    input: transformedInput,
     agentId: agentState.agentId,
     parentAgentId: agentState.parentId,
     includeToolCall: !excludeToolFromMessageHistory,
@@ -204,8 +212,16 @@ export function executeToolCall<T extends ToolName>(
   const handler = codebuffToolHandlers[
     toolName
   ] as unknown as CodebuffToolHandlerFunction<T>
+
+  // Use transformed input for spawn_agents so the handler receives the correct agent types
+  const finalToolCall =
+    toolName === 'spawn_agents'
+      ? { ...toolCall, input: transformedInput }
+      : toolCall
+
   const toolResultPromise = handler({
     ...params,
+    toolCall: finalToolCall,
     previousToolCallFinished,
     writeToClient: onResponseChunk,
     requestClientToolCall: (async (
@@ -222,7 +238,6 @@ export function executeToolCall<T extends ToolName>(
       })
       return clientToolResult.output as CodebuffToolOutput<T>
     }) as any,
-    toolCall,
   })
 
   return toolResultPromise.then(async ({ output, creditsUsed }) => {