Don't flatten tool call for direct spawning agents, use same prompt & params as spawn_agents

Author: jahooma

common/src/tools/params/tool/spawn-agents.ts

@@ -37,7 +37,7 @@ The prompt field is a simple string, while params is a JSON object that gets val
 
 Each agent available is already defined as another tool, or, dynamically defined later in the conversation.
 
-You can call agents either as direct tool calls (e.g., \`example-agent\`) or use \`spawn_agents\`. Both formats work, but **prefer using spawn_agents** because it allows you to spawn multiple agents in parallel for better performance. When using direct tool calls, the schema is flat (prompt is a field alongside other params), whereas spawn_agents uses nested \`prompt\` and \`params\` fields.
+You can call agents either as direct tool calls (e.g., \`example-agent\`) or use \`spawn_agents\`. Both formats work, but **prefer using spawn_agents** because it allows you to spawn multiple agents in parallel for better performance. Both use the same schema with nested \`prompt\` and \`params\` fields.
 
 **IMPORTANT**: Many agents have REQUIRED fields in their params schema. Check the agent's schema before spawning - if params has required fields, you MUST include them in the params object. For example, code-searcher requires \`searchQueries\`, commander requires \`command\`.
 

packages/agent-runtime/src/templates/prompts.ts

@@ -20,36 +20,24 @@ export function getAgentShortName(agentType: AgentTemplateType): string {
 }
 
 /**
- * Builds a flat input schema for an agent tool by combining prompt and params.
- * E.g., { prompt?: string, ...paramsFields }
+ * Builds an input schema for an agent tool with prompt and params as top-level fields.
+ * This matches the spawn_agents schema structure: { prompt?: string, params?: object }
  */
-export function buildAgentFlatInputSchema(
+export function buildAgentToolInputSchema(
   agentTemplate: AgentTemplate,
 ): z.ZodType {
   const { inputSchema } = agentTemplate
 
-  // Start with an empty object schema
+  // Build schema with prompt and params as top-level fields (consistent with spawn_agents)
+  // Preserve the original optionality from the inputSchema
   let schemaFields: Record<string, z.ZodType> = {}
 
-  // Add prompt field if defined
   if (inputSchema?.prompt) {
-    schemaFields.prompt = inputSchema.prompt.optional()
+    schemaFields.prompt = inputSchema.prompt
   }
 
-  // Merge params fields directly into the schema (flat structure)
   if (inputSchema?.params) {
-    // Try to get the shape from the params schema directly if it's a ZodObject
-    // This preserves the full nested structure instead of converting to z.any()
-    const paramsShape = getZodObjectShape(inputSchema.params)
-
-    if (paramsShape) {
-      // We have the original Zod shape, use it directly
-      for (const [key, fieldSchema] of Object.entries(paramsShape)) {
-        // Skip if we already have a prompt field
-        if (key === 'prompt') continue
-        schemaFields[key] = fieldSchema as z.ZodType
-      }
-    }
+    schemaFields.params = inputSchema.params
   }
 
   return z
@@ -60,30 +48,6 @@ export function buildAgentFlatInputSchema(
     )
 }
 
-/**
- * Extracts the shape from a Zod schema if it's a ZodObject.
- * Handles wrapped types like ZodOptional, ZodNullable, ZodDefault, etc.
- */
-function getZodObjectShape(
-  schema: z.ZodType,
-): Record<string, z.ZodType> | null {
-  // ZodObject has a public .shape property in Zod v4
-  if (
-    'shape' in schema &&
-    typeof schema.shape === 'object' &&
-    schema.shape !== null
-  ) {
-    return schema.shape as Record<string, z.ZodType>
-  }
-
-  // Handle wrapped types (optional, nullable, default, etc.) via internal def
-  const def = (schema as any)?._zod?.def
-  if (def?.inner) {
-    return getZodObjectShape(def.inner)
-  }
-
-  return null
-}
 
 /**
  * Builds AI SDK tool definitions for spawnable agents.
@@ -113,7 +77,7 @@ export async function buildAgentToolSet(
     if (!agentTemplate) continue
 
     const shortName = getAgentShortName(agentType)
-    const inputSchema = buildAgentFlatInputSchema(agentTemplate)
+    const inputSchema = buildAgentToolInputSchema(agentTemplate)
 
     // Use the same structure as other tools in toolParams
     toolSet[shortName] = {

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

@@ -527,20 +527,19 @@ export function tryTransformAgentToolCall(params: {
     (agentType) => getAgentShortName(agentType) === toolName,
   )
 
-  // Convert to spawn_agents call
+  // Convert to spawn_agents call - input already has prompt and params as top-level fields
+  // (consistent with spawn_agents schema)
+  const agentEntry: Record<string, unknown> = {
+    agent_type: fullAgentType || toolName,
+  }
+  if (typeof input.prompt === 'string') {
+    agentEntry.prompt = input.prompt
+  }
+  if (input.params && typeof input.params === 'object') {
+    agentEntry.params = input.params
+  }
   const spawnAgentsInput = {
-    agents: [
-      {
-        agent_type: fullAgentType || toolName,
-        ...(typeof input.prompt === 'string' && { prompt: input.prompt }),
-        // Put all other fields into params
-        ...(Object.keys(input).filter((k) => k !== 'prompt').length > 0 && {
-          params: Object.fromEntries(
-            Object.entries(input).filter(([k]) => k !== 'prompt'),
-          ),
-        }),
-      },
-    ],
+    agents: [agentEntry],
   }
 
   return { toolName: 'spawn_agents', input: spawnAgentsInput }