@memberjunction/ai-agent-manager 2.112.0 → 2.113.1

package/src/agents/architect-agent.ts

@@ -1,7 +1,7 @@
 import { BaseAgent, PayloadManager } from '@memberjunction/ai-agents';
 import { ExecuteAgentParams, BaseAgentNextStep, AgentSpec } from '@memberjunction/ai-core-plus';
 import { AIAgentRunEntityExtended, AIAgentRunStepEntityExtended, ActionEntity, AIPromptEntity } from '@memberjunction/core-entities';
-import { Metadata, RunView } from '@memberjunction/global';
+import { Metadata, RunView } from '@memberjunction/core';
 import { RegisterClass } from '@memberjunction/global';
 
 /**
@@ -22,442 +22,435 @@ import { RegisterClass } from '@memberjunction/global';
  */
 @RegisterClass(BaseAgent, 'AgentArchitectAgent')
 export class AgentArchitectAgent extends BaseAgent {
-  /**
-   * Applies payload changes if any are requested in the next step
-   */
-  protected applyPayloadChanges<P>(payload: P, nextStep: BaseAgentNextStep<P>): P {
-    if (nextStep.payloadChangeRequest) {
-      const pm = new PayloadManager();
-      const result = pm.applyAgentChangeRequest<P>(payload, nextStep.payloadChangeRequest);
-      return result.result || payload;
-    }
-    return payload;
-  }
-
-  protected override async validateSuccessNextStep<P>(
-    params: ExecuteAgentParams,
-    nextStep: BaseAgentNextStep<P>,
-    currentPayload: P,
-    agentRun: AIAgentRunEntityExtended,
-    currentStep: AIAgentRunStepEntityExtended
-  ): Promise<BaseAgentNextStep<P>> {
-    // First call base validation
-    const baseValidation = await super.validateSuccessNextStep(params, nextStep, currentPayload, agentRun, currentStep);
-    if (baseValidation.step === 'Retry') {
-      return baseValidation;
+
+    /**
+     * Applies payload changes if any are requested in the next step
+     */
+    protected applyPayloadChanges<P>(payload: P, nextStep: BaseAgentNextStep<P>): P {
+        if (nextStep.payloadChangeRequest) {
+            const pm = new PayloadManager();
+            const result = pm.applyAgentChangeRequest<P>(payload, nextStep.payloadChangeRequest);
+            return result.result || payload;
+        }
+        return payload;
     }
 
-    // Apply payload changes to get the spec that would be sent forward
-    const payloadWithChanges = this.applyPayloadChanges<P>(currentPayload, nextStep);
+    protected override async validateSuccessNextStep<P>(
+        params: ExecuteAgentParams,
+        nextStep: BaseAgentNextStep<P>,
+        currentPayload: P,
+        agentRun: AIAgentRunEntityExtended,
+        currentStep: AIAgentRunStepEntityExtended
+    ): Promise<BaseAgentNextStep<P>> {
+        // First call base validation
+        const baseValidation = await super.validateSuccessNextStep(params, nextStep, currentPayload, agentRun, currentStep);
+        if (baseValidation.step === 'Retry') {
+            return baseValidation;
+        }
 
-    // The payload IS the AgentSpec
-    const agentSpec = payloadWithChanges as AgentSpec;
+        // Apply payload changes to get the spec that would be sent forward
+        const payloadWithChanges = this.applyPayloadChanges<P>(currentPayload, nextStep);
 
-    console.log('🏗️ Architect Agent: Validating AgentSpec:', agentSpec ? `Name="${agentSpec.Name}"` : 'agentSpec is null/undefined');
+        // The payload IS the AgentSpec
+        const agentSpec = payloadWithChanges as AgentSpec;
 
-    // Validate the AgentSpec
-    const validation = await this.validateAgentSpec(agentSpec, params);
+        console.log('🏗️ Architect Agent: Validating AgentSpec:', agentSpec ? `Name="${agentSpec.Name}"` : 'agentSpec is null/undefined');
 
-    if (validation.errors.length > 0) {
-      console.log('❌ Architect Agent: Validation failed with errors:', validation.errors);
-      // Return retry with detailed error messages
-      return {
-        ...nextStep,
-        step: 'Retry',
-        retryInstructions: this.formatValidationErrors(validation.errors),
-        newPayload: nextStep.newPayload,
-      };
-    }
+        // Validate the AgentSpec
+        const validation = await this.validateAgentSpec(agentSpec, params);
 
-    // If spec was auto-corrected, update the payload with corrected spec
-    if (validation.correctedSpec) {
-      console.log('✓ Architect Agent: Auto-corrected AgentSpec, updating payload');
-      return {
-        ...nextStep,
-        newPayload: validation.correctedSpec as P,
-      };
-    }
-
-    console.log('✅ Architect Agent: AgentSpec validation passed');
-    return nextStep;
-  }
-
-  /**
-   * Validates an AgentSpec object
-   * Returns errors array and potentially a corrected spec
-   */
-  protected async validateAgentSpec(spec: AgentSpec, params: ExecuteAgentParams): Promise<{ errors: string[]; correctedSpec?: AgentSpec }> {
-    const errors: string[] = [];
-    let corrected = false;
-
-    // Check if spec exists
-    if (!spec) {
-      errors.push(
-        '❌ AgentSpec is null or undefined. Ensure you place the AgentSpec in payload.agentSpec (inside a payloadChangeRequest with newElements or replaceElements)'
-      );
-      return { errors };
-    }
-
-    const correctedSpec = { ...spec };
+        if (validation.errors.length > 0) {
+            console.log('❌ Architect Agent: Validation failed with errors:', validation.errors);
+            // Return retry with detailed error messages
+            return {
+                ...nextStep,
+                step: 'Retry',
+                retryInstructions: this.formatValidationErrors(validation.errors),
+                newPayload: nextStep.newPayload
+            };
+        }
 
-    // 1. Validate required fields
-    if (!correctedSpec.Name || correctedSpec.Name.trim().length === 0) {
-      errors.push('❌ AgentSpec.Name is required and cannot be empty');
-    }
+        // If spec was auto-corrected, update the payload with corrected spec
+        if (validation.correctedSpec) {
+            console.log('✓ Architect Agent: Auto-corrected AgentSpec, updating payload');
+            return {
+                ...nextStep,
+                newPayload: validation.correctedSpec as P
+            };
+        }
 
-    if (!correctedSpec.StartingPayloadValidationMode) {
-      // Auto-correct: add default
-      correctedSpec.StartingPayloadValidationMode = 'Fail';
-      corrected = true;
-      console.log('✓ Auto-corrected: Added default StartingPayloadValidationMode = "Fail"');
-    } else if (correctedSpec.StartingPayloadValidationMode !== 'Fail' && correctedSpec.StartingPayloadValidationMode !== 'Warn') {
-      errors.push(
-        `❌ StartingPayloadValidationMode must be either "Fail" or "Warn", got: "${correctedSpec.StartingPayloadValidationMode}"`
-      );
+        console.log('✅ Architect Agent: AgentSpec validation passed');
+        return nextStep;
     }
 
-    // 2. Validate Actions if specified
-    if (correctedSpec.Actions && correctedSpec.Actions.length > 0) {
-      const actionValidation = await this.validateActions(correctedSpec.Actions, params);
-      if (actionValidation.errors.length > 0) {
-        errors.push(...actionValidation.errors);
-      }
-    }
+    /**
+     * Validates an AgentSpec object
+     * Returns errors array and potentially a corrected spec
+     */
+    protected async validateAgentSpec(
+        spec: AgentSpec,
+        params: ExecuteAgentParams
+    ): Promise<{ errors: string[]; correctedSpec?: AgentSpec }> {
+        const errors: string[] = [];
+        let corrected = false;
+
+        // Check if spec exists
+        if (!spec) {
+            errors.push('❌ AgentSpec is null or undefined. Ensure you place the AgentSpec in payload.agentSpec (inside a payloadChangeRequest with newElements or replaceElements)');
+            return { errors };
+        }
 
-    // 3. Validate SubAgents if specified
-    if (correctedSpec.SubAgents && correctedSpec.SubAgents.length > 0) {
-      const subAgentValidation = this.validateSubAgents(correctedSpec.SubAgents);
-      if (subAgentValidation.errors.length > 0) {
-        errors.push(...subAgentValidation.errors);
-      }
-      if (subAgentValidation.corrected) {
-        corrected = true;
-      }
-    }
+        const correctedSpec = { ...spec };
 
-    // 4. Validate TypeID and Status
-    const specWithType = correctedSpec as any;
-    if (!specWithType.TypeID) {
-      errors.push('❌ TypeID is required - must be "@lookup:MJ: AI Agent Types.Name=Loop" or "@lookup:MJ: AI Agent Types.Name=Flow"');
-    }
+        // 1. Validate required fields
+        if (!correctedSpec.Name || correctedSpec.Name.trim().length === 0) {
+            errors.push('❌ AgentSpec.Name is required and cannot be empty');
+        }
 
-    if (!specWithType.Status) {
-      // Auto-correct: add default
-      specWithType.Status = 'Active';
-      corrected = true;
-      console.log('✓ Auto-corrected: Added default Status = "Active"');
-    } else if (!['Active', 'Inactive', 'Pending'].includes(specWithType.Status)) {
-      errors.push(`❌ Status must be "Active", "Inactive", or "Pending", got: "${specWithType.Status}"`);
-    }
+        if (!correctedSpec.StartingPayloadValidationMode) {
+            // Auto-correct: add default
+            correctedSpec.StartingPayloadValidationMode = 'Fail';
+            corrected = true;
+            console.log('✓ Auto-corrected: Added default StartingPayloadValidationMode = "Fail"');
+        } else if (correctedSpec.StartingPayloadValidationMode !== 'Fail' && correctedSpec.StartingPayloadValidationMode !== 'Warn') {
+            errors.push(`❌ StartingPayloadValidationMode must be either "Fail" or "Warn", got: "${correctedSpec.StartingPayloadValidationMode}"`);
+        }
 
-    // 5. Validate agent type-specific requirements
-    const isLoopAgent = specWithType.TypeID?.includes('Loop');
-    const isFlowAgent = specWithType.TypeID?.includes('Flow');
+        // 2. Validate Actions if specified
+        if (correctedSpec.Actions && correctedSpec.Actions.length > 0) {
+            const actionValidation = await this.validateActions(correctedSpec.Actions, params);
+            if (actionValidation.errors.length > 0) {
+                errors.push(...actionValidation.errors);
+            }
+        }
 
-    if (isLoopAgent) {
-      // Loop agents require at least one prompt
-      if (!correctedSpec.Prompts || correctedSpec.Prompts.length === 0) {
-        errors.push('❌ Loop agents require at least ONE prompt in the Prompts array');
-      }
-    }
+        // 3. Validate SubAgents if specified
+        if (correctedSpec.SubAgents && correctedSpec.SubAgents.length > 0) {
+            const subAgentValidation = this.validateSubAgents(correctedSpec.SubAgents);
+            if (subAgentValidation.errors.length > 0) {
+                errors.push(...subAgentValidation.errors);
+            }
+            if (subAgentValidation.corrected) {
+                corrected = true;
+            }
+        }
 
-    if (isFlowAgent) {
-      // CRITICAL: Flow agents MUST have empty Prompts array (no agent-level prompts)
-      if (correctedSpec.Prompts && correctedSpec.Prompts.length > 0) {
-        errors.push(
-          '❌ Flow agents MUST have empty Prompts array. If LLM is needed, use a Prompt step OR a Loop sub-agent instead of agent-level prompts.'
-        );
-      }
-
-      // Flow agents require Steps and Paths
-      if (!correctedSpec.Steps || correctedSpec.Steps.length === 0) {
-        errors.push('❌ Flow agents require at least ONE step in the Steps array');
-      }
-      // Paths are technically optional (single-step flows), but validate if present
-      if (correctedSpec.Steps && correctedSpec.Steps.length > 1) {
-        if (!correctedSpec.Paths || correctedSpec.Paths.length === 0) {
-          errors.push('❌ Flow agents with multiple steps require at least ONE path in the Paths array');
+        // 4. Validate TypeID and Status
+        const specWithType = correctedSpec as any;
+        if (!specWithType.TypeID) {
+            errors.push('❌ TypeID is required - must be "@lookup:MJ: AI Agent Types.Name=Loop" or "@lookup:MJ: AI Agent Types.Name=Flow"');
         }
-      }
 
-      // Validate that at least one step is marked as StartingStep
-      if (correctedSpec.Steps && correctedSpec.Steps.length > 0) {
-        const hasStartingStep = correctedSpec.Steps.some((step) => step.StartingStep === true);
-        if (!hasStartingStep) {
-          errors.push('❌ Flow agents require at least ONE step with StartingStep: true');
+        if (!specWithType.Status) {
+            // Auto-correct: add default
+            specWithType.Status = 'Active';
+            corrected = true;
+            console.log('✓ Auto-corrected: Added default Status = "Active"');
+        } else if (!['Active', 'Inactive', 'Pending'].includes(specWithType.Status)) {
+            errors.push(`❌ Status must be "Active", "Inactive", or "Pending", got: "${specWithType.Status}"`);
         }
 
-        // Validate each step based on its type
-        for (let i = 0; i < correctedSpec.Steps.length; i++) {
-          const step = correctedSpec.Steps[i];
+        // 5. Validate agent type-specific requirements
+        const isLoopAgent = specWithType.TypeID?.includes('Loop');
+        const isFlowAgent = specWithType.TypeID?.includes('Flow');
 
-          // Validate Action steps
-          if (step.StepType === 'Action') {
-            if (!step.ActionID) {
-              errors.push(`❌ Action step "${step.Name}" (index ${i}) must have ActionID field`);
+        if (isLoopAgent) {
+            // Loop agents require at least one prompt
+            if (!correctedSpec.Prompts || correctedSpec.Prompts.length === 0) {
+                errors.push('❌ Loop agents require at least ONE prompt in the Prompts array');
             }
+        }
 
-            // Validate ActionInputMapping if provided (supports both string and object)
-            if (step.ActionInputMapping) {
-              try {
-                if (typeof step.ActionInputMapping === 'string') {
-                  JSON.parse(step.ActionInputMapping);
-                }
-                // else it's already an object, which is valid and will be stringified later
-              } catch (e: any) {
-                errors.push(`❌ Step "${step.Name}" (index ${i}) has invalid ActionInputMapping JSON: ${e?.message || String(e)}`);
-              }
+        if (isFlowAgent) {
+            // CRITICAL: Flow agents MUST have empty Prompts array (no agent-level prompts)
+            if (correctedSpec.Prompts && correctedSpec.Prompts.length > 0) {
+                errors.push('❌ Flow agents MUST have empty Prompts array. If LLM is needed, use a Prompt step OR a Loop sub-agent instead of agent-level prompts.');
             }
 
-            // Validate ActionOutputMapping if provided (supports both string and object)
-            if (step.ActionOutputMapping) {
-              try {
-                if (typeof step.ActionOutputMapping === 'string') {
-                  JSON.parse(step.ActionOutputMapping);
+            // Flow agents require Steps and Paths
+            if (!correctedSpec.Steps || correctedSpec.Steps.length === 0) {
+                errors.push('❌ Flow agents require at least ONE step in the Steps array');
+            }
+            // Paths are technically optional (single-step flows), but validate if present
+            if (correctedSpec.Steps && correctedSpec.Steps.length > 1) {
+                if (!correctedSpec.Paths || correctedSpec.Paths.length === 0) {
+                    errors.push('❌ Flow agents with multiple steps require at least ONE path in the Paths array');
                 }
-                // else it's already an object, which is valid and will be stringified later
-              } catch (e: any) {
-                errors.push(`❌ Step "${step.Name}" (index ${i}) has invalid ActionOutputMapping JSON: ${e?.message || String(e)}`);
-              }
             }
-          }
-
-          // Validate Prompt steps
-          if (step.StepType === 'Prompt') {
-            // If PromptID is empty or not provided, PromptText is required for inline creation
-            if (!step.PromptID || step.PromptID === '') {
-              if (!step.PromptText || step.PromptText.trim() === '') {
-                errors.push(
-                  `❌ Prompt step "${step.Name}" (index ${i}) has empty PromptID but missing PromptText. For inline prompt creation, PromptText is required.`
-                );
-              }
-              // PromptName and PromptDescription are recommended but not required
-              if (!step.PromptName) {
-                console.log(
-                  `⚠️ Warning: Prompt step "${step.Name}" (index ${i}) is missing PromptName (will default to "[Step Name] Prompt")`
-                );
-              }
+
+            // Validate that at least one step is marked as StartingStep
+            if (correctedSpec.Steps && correctedSpec.Steps.length > 0) {
+                const hasStartingStep = correctedSpec.Steps.some(step => step.StartingStep === true);
+                if (!hasStartingStep) {
+                    errors.push('❌ Flow agents require at least ONE step with StartingStep: true');
+                }
+
+                // Validate each step based on its type
+                for (let i = 0; i < correctedSpec.Steps.length; i++) {
+                    const step = correctedSpec.Steps[i];
+
+                    // Validate Action steps
+                    if (step.StepType === 'Action') {
+                        if (!step.ActionID) {
+                            errors.push(`❌ Action step "${step.Name}" (index ${i}) must have ActionID field`);
+                        }
+
+                        // Validate ActionInputMapping if provided (supports both string and object)
+                        if (step.ActionInputMapping) {
+                            try {
+                                if (typeof step.ActionInputMapping === 'string') {
+                                    JSON.parse(step.ActionInputMapping);
+                                }
+                                // else it's already an object, which is valid and will be stringified later
+                            } catch (e: any) {
+                                errors.push(`❌ Step "${step.Name}" (index ${i}) has invalid ActionInputMapping JSON: ${e?.message || String(e)}`);
+                            }
+                        }
+
+                        // Validate ActionOutputMapping if provided (supports both string and object)
+                        if (step.ActionOutputMapping) {
+                            try {
+                                if (typeof step.ActionOutputMapping === 'string') {
+                                    JSON.parse(step.ActionOutputMapping);
+                                }
+                                // else it's already an object, which is valid and will be stringified later
+                            } catch (e: any) {
+                                errors.push(`❌ Step "${step.Name}" (index ${i}) has invalid ActionOutputMapping JSON: ${e?.message || String(e)}`);
+                            }
+                        }
+                    }
+
+                    // Validate Prompt steps
+                    if (step.StepType === 'Prompt') {
+                        // If PromptID is empty or not provided, PromptText is required for inline creation
+                        if (!step.PromptID || step.PromptID === '') {
+                            if (!step.PromptText || step.PromptText.trim() === '') {
+                                errors.push(`❌ Prompt step "${step.Name}" (index ${i}) has empty PromptID but missing PromptText. For inline prompt creation, PromptText is required.`);
+                            }
+                            // PromptName and PromptDescription are recommended but not required
+                            if (!step.PromptName) {
+                                console.log(`⚠️ Warning: Prompt step "${step.Name}" (index ${i}) is missing PromptName (will default to "[Step Name] Prompt")`);
+                            }
+                        }
+                        // If PromptID is provided (existing prompt), other fields are optional
+                    }
+
+                    // Validate Sub-Agent steps
+                    if (step.StepType === 'Sub-Agent') {
+                        // SubAgentID can be empty "" for new sub-agents (will be linked by name matching)
+                        // No validation needed here - linking happens in AgentSpecSync
+                    }
+                }
             }
-            // If PromptID is provided (existing prompt), other fields are optional
-          }
-
-          // Validate Sub-Agent steps
-          if (step.StepType === 'Sub-Agent') {
-            // SubAgentID can be empty "" for new sub-agents (will be linked by name matching)
-            // No validation needed here - linking happens in AgentSpecSync
-          }
         }
-      }
-    }
 
-    // 6. Validate optional but important fields
-    if (correctedSpec.FinalPayloadValidationMode && !['Fail', 'Retry', 'Warn'].includes(correctedSpec.FinalPayloadValidationMode)) {
-      errors.push(`❌ FinalPayloadValidationMode must be "Fail", "Retry", or "Warn", got: "${correctedSpec.FinalPayloadValidationMode}"`);
-    }
+        // 6. Validate optional but important fields
+        if (correctedSpec.FinalPayloadValidationMode &&
+            !['Fail', 'Retry', 'Warn'].includes(correctedSpec.FinalPayloadValidationMode)) {
+            errors.push(`❌ FinalPayloadValidationMode must be "Fail", "Retry", or "Warn", got: "${correctedSpec.FinalPayloadValidationMode}"`);
+        }
+
+        if (correctedSpec.InvocationMode &&
+            !['Any', 'Agent', 'User', 'Never'].includes(correctedSpec.InvocationMode)) {
+            errors.push(`❌ InvocationMode must be "Any", "Agent", "User", or "Never", got: "${correctedSpec.InvocationMode}"`);
+        }
 
-    if (correctedSpec.InvocationMode && !['Any', 'Agent', 'User', 'Never'].includes(correctedSpec.InvocationMode)) {
-      errors.push(`❌ InvocationMode must be "Any", "Agent", "User", or "Never", got: "${correctedSpec.InvocationMode}"`);
+        return {
+            errors,
+            correctedSpec: corrected ? correctedSpec : undefined
+        };
     }
 
-    return {
-      errors,
-      correctedSpec: corrected ? correctedSpec : undefined,
-    };
-  }
+    /**
+     * Validates that action IDs exist in the database
+     */
+    protected async validateActions(
+        actions: AgentSpec['Actions'],
+        params: ExecuteAgentParams
+    ): Promise<{ errors: string[] }> {
+        const errors: string[] = [];
+
+        if (!actions || actions.length === 0) {
+            return { errors };
+        }
 
-  /**
-   * Validates that action IDs exist in the database
-   */
-  protected async validateActions(actions: AgentSpec['Actions'], params: ExecuteAgentParams): Promise<{ errors: string[] }> {
-    const errors: string[] = [];
+        try {
+            const rv = new RunView();
+            const actionIds = actions
+                .map(a => a.ActionID)
+                .filter(id => id && id.trim().length > 0);
 
-    if (!actions || actions.length === 0) {
-      return { errors };
-    }
+            if (actionIds.length === 0) {
+                errors.push('❌ All actions must have an ActionID');
+                return { errors };
+            }
 
-    try {
-      const rv = new RunView();
-      const actionIds = actions.map((a) => a.ActionID).filter((id) => id && id.trim().length > 0);
+            // Query database for these action IDs
+            const filter = actionIds.map(id => `ID='${id}'`).join(' OR ');
+            const result = await rv.RunView<ActionEntity>({
+                EntityName: 'Actions',
+                ExtraFilter: filter,
+                ResultType: 'entity_object'
+            }, params.contextUser);
+
+            if (!result.Success) {
+                errors.push(`❌ Failed to validate actions: ${result.ErrorMessage}`);
+                return { errors };
+            }
 
-      if (actionIds.length === 0) {
-        errors.push('❌ All actions must have an ActionID');
-        return { errors };
-      }
-
-      // Query database for these action IDs
-      const filter = actionIds.map((id) => `ID='${id}'`).join(' OR ');
-      const result = await rv.RunView<ActionEntity>(
-        {
-          EntityName: 'Actions',
-          ExtraFilter: filter,
-          ResultType: 'entity_object',
-        },
-        params.contextUser
-      );
-
-      if (!result.Success) {
-        errors.push(`❌ Failed to validate actions: ${result.ErrorMessage}`);
-        return { errors };
-      }
+            const foundIds = new Set(result.Results.map(a => a.ID));
 
-      const foundIds = new Set(result.Results.map((a) => a.ID));
+            // Check which actions weren't found
+            for (const action of actions) {
+                if (!action.ActionID) {
+                    errors.push('❌ Action is missing ActionID field');
+                    continue;
+                }
 
-      // Check which actions weren't found
-      for (const action of actions) {
-        if (!action.ActionID) {
-          errors.push('❌ Action is missing ActionID field');
-          continue;
-        }
+                if (!foundIds.has(action.ActionID)) {
+                    errors.push(`❌ Action with ID "${action.ActionID}" not found in database. Please use "Find Candidate Actions" or "List Actions" to get valid action IDs.`);
+                }
+            }
 
-        if (!foundIds.has(action.ActionID)) {
-          errors.push(
-            `❌ Action with ID "${action.ActionID}" not found in database. Please use "Find Candidate Actions" or "List Actions" to get valid action IDs.`
-          );
+        } catch (error: any) {
+            errors.push(`❌ Error validating actions: ${error?.message || String(error)}`);
         }
-      }
-    } catch (error: any) {
-      errors.push(`❌ Error validating actions: ${error?.message || String(error)}`);
+
+        return { errors };
     }
 
-    return { errors };
-  }
+    /**
+     * Validates SubAgent structure recursively
+     */
+    protected validateSubAgents(
+        subAgents: AgentSpec['SubAgents']
+    ): { errors: string[]; corrected: boolean } {
+        const errors: string[] = [];
+        let corrected = false;
+
+        if (!subAgents || subAgents.length === 0) {
+            return { errors, corrected };
+        }
 
-  /**
-   * Validates SubAgent structure recursively
-   */
-  protected validateSubAgents(subAgents: AgentSpec['SubAgents']): { errors: string[]; corrected: boolean } {
-    const errors: string[] = [];
-    let corrected = false;
+        for (let i = 0; i < subAgents.length; i++) {
+            const subAgent = subAgents[i];
 
-    if (!subAgents || subAgents.length === 0) {
-      return { errors, corrected };
-    }
+            // Validate Type field
+            if (!subAgent.Type) {
+                errors.push(`❌ SubAgent at index ${i} is missing required "Type" field (must be "child" or "related")`);
+                continue;
+            }
 
-    for (let i = 0; i < subAgents.length; i++) {
-      const subAgent = subAgents[i];
-
-      // Validate Type field
-      if (!subAgent.Type) {
-        errors.push(`❌ SubAgent at index ${i} is missing required "Type" field (must be "child" or "related")`);
-        continue;
-      }
-
-      if (subAgent.Type !== 'child' && subAgent.Type !== 'related') {
-        errors.push(`❌ SubAgent at index ${i} has invalid Type "${subAgent.Type}" (must be "child" or "related")`);
-        continue;
-      }
-
-      // Validate SubAgent.SubAgent field
-      if (!subAgent.SubAgent) {
-        errors.push(`❌ SubAgent at index ${i} is missing required "SubAgent" field`);
-        continue;
-      }
-
-      // SubAgent.ID can be empty string "" for NEW sub-agents (Builder creates them recursively)
-      // Only validate that ID is not null/undefined
-      if (subAgent.SubAgent.ID === null || subAgent.SubAgent.ID === undefined) {
-        errors.push(
-          `❌ SubAgent at index ${i} has null/undefined SubAgent.ID (use empty string "" for new sub-agents, or provide existing agent GUID)`
-        );
-      }
-
-      // Validate SubAgent.SubAgent.Name
-      if (!subAgent.SubAgent.Name || subAgent.SubAgent.Name.trim().length === 0) {
-        errors.push(`❌ SubAgent at index ${i} is missing SubAgent.Name`);
-      }
-
-      // Validate TypeID for sub-agent
-      if (!subAgent.SubAgent.TypeID) {
-        errors.push(`❌ SubAgent[${i}] "${subAgent.SubAgent.Name}" is missing TypeID field`);
-      } else {
-        // Validate Loop/Flow specific requirements for sub-agents
-        const isLoopSubAgent = subAgent.SubAgent.TypeID.includes('Loop');
-        const isFlowSubAgent = subAgent.SubAgent.TypeID.includes('Flow');
-
-        if (isLoopSubAgent) {
-          // Loop sub-agents require at least one prompt
-          if (!subAgent.SubAgent.Prompts || subAgent.SubAgent.Prompts.length === 0) {
-            errors.push(`❌ Loop SubAgent[${i}] "${subAgent.SubAgent.Name}" requires at least ONE prompt in Prompts array`);
-          }
-        }
+            if (subAgent.Type !== 'child' && subAgent.Type !== 'related') {
+                errors.push(`❌ SubAgent at index ${i} has invalid Type "${subAgent.Type}" (must be "child" or "related")`);
+                continue;
+            }
 
-        if (isFlowSubAgent) {
-          // Flow sub-agents MUST have empty Prompts array
-          if (subAgent.SubAgent.Prompts && subAgent.SubAgent.Prompts.length > 0) {
-            errors.push(
-              `❌ Flow SubAgent[${i}] "${subAgent.SubAgent.Name}" MUST have empty Prompts array. Use Prompt steps or Loop sub-agents for LLM functionality.`
-            );
-          }
-
-          // Flow sub-agents require Steps
-          if (!subAgent.SubAgent.Steps || subAgent.SubAgent.Steps.length === 0) {
-            errors.push(`❌ Flow SubAgent[${i}] "${subAgent.SubAgent.Name}" requires at least ONE step in Steps array`);
-          }
-        }
-      }
-
-      // Auto-correct: Add default StartingPayloadValidationMode if missing
-      if (!subAgent.SubAgent.StartingPayloadValidationMode) {
-        subAgent.SubAgent.StartingPayloadValidationMode = 'Fail';
-        corrected = true;
-        console.log(`✓ Auto-corrected: Added SubAgent[${i}].SubAgent.StartingPayloadValidationMode = "Fail"`);
-      }
-
-      // Auto-correct: Add default Status if missing
-      if (!subAgent.SubAgent.Status) {
-        subAgent.SubAgent.Status = 'Active';
-        corrected = true;
-        console.log(`✓ Auto-corrected: Added SubAgent[${i}].SubAgent.Status = "Active"`);
-      }
-
-      // Validate related-specific fields
-      if (subAgent.Type === 'related') {
-        // AgentRelationshipID can be empty for new relationships, it will be created on save
-
-        // IMPORTANT: Related agents REQUIRE existing agent ID
-        if (!subAgent.SubAgent.ID || subAgent.SubAgent.ID === '') {
-          errors.push(
-            `❌ Related SubAgent[${i}] "${subAgent.SubAgent.Name}" must have existing agent ID. Use Find Candidate Agents to get the ID.`
-          );
-        }
+            // Validate SubAgent.SubAgent field
+            if (!subAgent.SubAgent) {
+                errors.push(`❌ SubAgent at index ${i} is missing required "SubAgent" field`);
+                continue;
+            }
 
-        // IMPORTANT: Related agents REQUIRE mapping fields
-        if (!subAgent.SubAgentInputMapping && !subAgent.SubAgentOutputMapping) {
-          errors.push(
-            `❌ Related SubAgent[${i}] "${subAgent.SubAgent.Name}" must have at least SubAgentInputMapping or SubAgentOutputMapping`
-          );
-        }
-      }
-
-      // Recursively validate nested sub-agents
-      if (subAgent.SubAgent.SubAgents && subAgent.SubAgent.SubAgents.length > 0) {
-        const nestedValidation = this.validateSubAgents(subAgent.SubAgent.SubAgents);
-        if (nestedValidation.errors.length > 0) {
-          // Prefix nested errors with parent context
-          const prefixedErrors = nestedValidation.errors.map((err) => `SubAgent[${i}] "${subAgent.SubAgent.Name}" -> ${err}`);
-          errors.push(...prefixedErrors);
-        }
-        if (nestedValidation.corrected) {
-          corrected = true;
-        }
-      }
-    }
+            // SubAgent.ID can be empty string "" for NEW sub-agents (Builder creates them recursively)
+            // Only validate that ID is not null/undefined
+            if (subAgent.SubAgent.ID === null || subAgent.SubAgent.ID === undefined) {
+                errors.push(`❌ SubAgent at index ${i} has null/undefined SubAgent.ID (use empty string "" for new sub-agents, or provide existing agent GUID)`);
+            }
+
+            // Validate SubAgent.SubAgent.Name
+            if (!subAgent.SubAgent.Name || subAgent.SubAgent.Name.trim().length === 0) {
+                errors.push(`❌ SubAgent at index ${i} is missing SubAgent.Name`);
+            }
+
+            // Validate TypeID for sub-agent
+            if (!subAgent.SubAgent.TypeID) {
+                errors.push(`❌ SubAgent[${i}] "${subAgent.SubAgent.Name}" is missing TypeID field`);
+            } else {
+                // Validate Loop/Flow specific requirements for sub-agents
+                const isLoopSubAgent = subAgent.SubAgent.TypeID.includes('Loop');
+                const isFlowSubAgent = subAgent.SubAgent.TypeID.includes('Flow');
+
+                if (isLoopSubAgent) {
+                    // Loop sub-agents require at least one prompt
+                    if (!subAgent.SubAgent.Prompts || subAgent.SubAgent.Prompts.length === 0) {
+                        errors.push(`❌ Loop SubAgent[${i}] "${subAgent.SubAgent.Name}" requires at least ONE prompt in Prompts array`);
+                    }
+                }
 
-    return { errors, corrected };
-  }
+                if (isFlowSubAgent) {
+                    // Flow sub-agents MUST have empty Prompts array
+                    if (subAgent.SubAgent.Prompts && subAgent.SubAgent.Prompts.length > 0) {
+                        errors.push(`❌ Flow SubAgent[${i}] "${subAgent.SubAgent.Name}" MUST have empty Prompts array. Use Prompt steps or Loop sub-agents for LLM functionality.`);
+                    }
 
-  /**
-   * Formats validation errors into a clear, actionable message
-   */
-  protected formatValidationErrors(errors: string[]): string {
-    if (errors.length === 0) {
-      return '';
+                    // Flow sub-agents require Steps
+                    if (!subAgent.SubAgent.Steps || subAgent.SubAgent.Steps.length === 0) {
+                        errors.push(`❌ Flow SubAgent[${i}] "${subAgent.SubAgent.Name}" requires at least ONE step in Steps array`);
+                    }
+                }
+            }
+
+            // Auto-correct: Add default StartingPayloadValidationMode if missing
+            if (!subAgent.SubAgent.StartingPayloadValidationMode) {
+                subAgent.SubAgent.StartingPayloadValidationMode = 'Fail';
+                corrected = true;
+                console.log(`✓ Auto-corrected: Added SubAgent[${i}].SubAgent.StartingPayloadValidationMode = "Fail"`);
+            }
+
+            // Auto-correct: Add default Status if missing
+            if (!subAgent.SubAgent.Status) {
+                subAgent.SubAgent.Status = 'Active';
+                corrected = true;
+                console.log(`✓ Auto-corrected: Added SubAgent[${i}].SubAgent.Status = "Active"`);
+            }
+
+            // Validate related-specific fields
+            if (subAgent.Type === 'related') {
+                // AgentRelationshipID can be empty for new relationships, it will be created on save
+
+                // IMPORTANT: Related agents REQUIRE existing agent ID
+                if (!subAgent.SubAgent.ID || subAgent.SubAgent.ID === '') {
+                    errors.push(`❌ Related SubAgent[${i}] "${subAgent.SubAgent.Name}" must have existing agent ID. Use Find Candidate Agents to get the ID.`);
+                }
+
+                // IMPORTANT: Related agents REQUIRE mapping fields
+                if (!subAgent.SubAgentInputMapping && !subAgent.SubAgentOutputMapping) {
+                    errors.push(`❌ Related SubAgent[${i}] "${subAgent.SubAgent.Name}" must have at least SubAgentInputMapping or SubAgentOutputMapping`);
+                }
+            }
+
+            // Recursively validate nested sub-agents
+            if (subAgent.SubAgent.SubAgents && subAgent.SubAgent.SubAgents.length > 0) {
+                const nestedValidation = this.validateSubAgents(subAgent.SubAgent.SubAgents);
+                if (nestedValidation.errors.length > 0) {
+                    // Prefix nested errors with parent context
+                    const prefixedErrors = nestedValidation.errors.map(
+                        err => `SubAgent[${i}] "${subAgent.SubAgent.Name}" -> ${err}`
+                    );
+                    errors.push(...prefixedErrors);
+                }
+                if (nestedValidation.corrected) {
+                    corrected = true;
+                }
+            }
+        }
+
+        return { errors, corrected };
     }
 
-    const header = '## AgentSpec Validation Errors\n\nThe generated AgentSpec has the following issues that must be fixed:\n\n';
-    const errorList = errors.map((err, idx) => `${idx + 1}. ${err}`).join('\n');
-    const footer = '\n\n**Please fix these issues and regenerate the AgentSpec.**';
+    /**
+     * Formats validation errors into a clear, actionable message
+     */
+    protected formatValidationErrors(errors: string[]): string {
+        if (errors.length === 0) {
+            return '';
+        }
 
-    return header + errorList + footer;
-  }
+        const header = '## AgentSpec Validation Errors\n\nThe generated AgentSpec has the following issues that must be fixed:\n\n';
+        const errorList = errors.map((err, idx) => `${idx + 1}. ${err}`).join('\n');
+        const footer = '\n\n**Please fix these issues and regenerate the AgentSpec.**';
+
+        return header + errorList + footer;
+    }
 }