Fix publishing to allow undefined system prompt. Use validateAgents!

Author: jahooma

common/src/templates/agent-validation.ts

@@ -54,16 +54,19 @@ export function collectAgentIds(
  */
 export function validateAgents(agentTemplates: Record<string, any> = {}): {
   templates: Record<string, AgentTemplate>
+  dynamicTemplates: Record<string, DynamicAgentTemplate>
   validationErrors: DynamicAgentValidationError[]
 } {
   const templates: Record<string, AgentTemplate> = {}
+  const dynamicTemplates: Record<string, DynamicAgentTemplate> = {}
   const validationErrors: DynamicAgentValidationError[] = []
 
   const hasAgentTemplates = Object.keys(agentTemplates).length > 0
 
   if (!hasAgentTemplates) {
     return {
       templates,
+      dynamicTemplates,
       validationErrors,
     }
   }
@@ -107,6 +110,8 @@ export function validateAgents(agentTemplates: Record<string, any> = {}): {
       }
       templates[validationResult.agentTemplate!.id] =
         validationResult.agentTemplate!
+      dynamicTemplates[validationResult.dynamicAgentTemplate!.id] =
+        validationResult.dynamicAgentTemplate!
     } catch (error) {
       const errorMessage =
         error instanceof Error ? error.message : 'Unknown error'
@@ -130,6 +135,7 @@ export function validateAgents(agentTemplates: Record<string, any> = {}): {
 
   return {
     templates,
+    dynamicTemplates,
     validationErrors,
   }
 }
@@ -155,6 +161,7 @@ export function validateSingleAgent(
 ): {
   success: boolean
   agentTemplate?: AgentTemplate
+  dynamicAgentTemplate?: DynamicAgentTemplate
   error?: string
 } {
   const {
@@ -276,13 +283,17 @@ export function validateSingleAgent(
     // Convert to internal AgentTemplate format
     const agentTemplate: AgentTemplate = {
       ...validatedConfig,
+      systemPrompt: validatedConfig.systemPrompt ?? '',
+      instructionsPrompt: validatedConfig.instructionsPrompt ?? '',
+      stepPrompt: validatedConfig.stepPrompt ?? '',
       outputSchema,
       inputSchema,
     }
 
     return {
       success: true,
       agentTemplate,
+      dynamicAgentTemplate: validatedConfig,
     }
   } catch (error) {
     const errorMessage =

common/src/types/api/agents/publish.ts

@@ -1,9 +1,7 @@
 import { z } from 'zod/v4'
 
-import { DynamicAgentTemplateSchema } from '../../../types/dynamic-agent-template'
-
 export const publishAgentsRequestSchema = z.object({
-  data: DynamicAgentTemplateSchema.array(),
+  data: z.record(z.string(), z.any()).array(),
   authToken: z.string(),
 })
 export type PublishAgentsRequest = z.infer<typeof publishAgentsRequestSchema>

npm-app/src/cli-handlers/publish.ts

@@ -63,14 +63,12 @@ import { pluralize } from '@codebuff/common/util/string'
       return
     }
 
-    const matchingTemplates: Record<string, DynamicAgentTemplate> = {}
+    const matchingTemplates: Record<string, any> = {}
     for (const agentId of agentIds) {
       // Find the specific agent
-      const matchingTemplate = Object.entries(agentTemplates).find(
-        ([key, template]) =>
-          key === agentId ||
-          template.id === agentId ||
-          template.displayName === agentId,
+      const matchingTemplate = Object.values(agentTemplates).find(
+        (template) =>
+          template.id === agentId || template.displayName === agentId,
       )
 
       if (!matchingTemplate) {
@@ -81,10 +79,10 @@ import { pluralize } from '@codebuff/common/util/string'
         return
       }
 
-      matchingTemplates[matchingTemplate[0]] = matchingTemplate[1]
+      matchingTemplates[matchingTemplate.id] = matchingTemplate
     }
     console.log(yellow(`Publishing:`))
-    for (const [key, template] of Object.entries(matchingTemplates)) {
+    for (const template of Object.values(matchingTemplates)) {
       console.log(`  - ${template.displayName} (${template.id})`)
     }
 
@@ -154,7 +152,7 @@ import { pluralize } from '@codebuff/common/util/string'
  * Publish agent templates to the backend
  */
 async function publishAgentTemplates(
-  data: DynamicAgentTemplate[],
+  data: Record<string, any>[],
   authToken: string,
 ): Promise<PublishAgentsResponse & { statusCode?: number }> {
   try {

web/src/app/api/agents/publish/route.ts

@@ -59,7 +59,32 @@ export async function POST(request: NextRequest) {
     }
 
     const { data, authToken } = parseResult.data
-    const agents = data as DynamicAgentTemplate[] // data is now an array of agents
+    const agentDefinitions = data
+
+    // First use validateAgents to convert to DynamicAgentTemplate types
+    const agentMap = agentDefinitions.reduce(
+      (acc: Record<string, any>, agent: any) => {
+        acc[agent.id] = agent
+        return acc
+      },
+      {} as Record<string, any>
+    )
+
+    const { validationErrors, dynamicTemplates } = validateAgents(agentMap)
+    const agents = Object.values(dynamicTemplates)
+
+    if (validationErrors.length > 0) {
+      const errorDetails = validationErrors.map((err) => err.message).join('\n')
+
+      return NextResponse.json(
+        {
+          error: 'Agent config validation failed',
+          details: errorDetails,
+          validationErrors,
+        },
+        { status: 400 }
+      )
+    }
 
     // Try cookie-based auth first, then fall back to authToken validation using proper function
     let userId: string | undefined
@@ -107,34 +132,6 @@ export async function POST(request: NextRequest) {
 
     const requestedPublisherId = publisherIds[0]!
 
-    // Validate all agents
-    const agentMap = agents.reduce(
-      (
-        acc: Record<string, DynamicAgentTemplate>,
-        agent: DynamicAgentTemplate
-      ) => {
-        acc[agent.id] = agent
-        return acc
-      },
-      {} as Record<string, DynamicAgentTemplate>
-    )
-
-    const validationResult = validateAgents(agentMap)
-
-    if (validationResult.validationErrors.length > 0) {
-      const errorDetails = validationResult.validationErrors
-        .map((err) => err.message)
-        .join('\n')
-
-      return NextResponse.json(
-        {
-          error: 'Agent config validation failed',
-          details: errorDetails,
-          validationErrors: validationResult.validationErrors,
-        },
-        { status: 400 }
-      )
-    }
 
     // Verify user has access to the requested publisher
     const publisherResult = await db