import { GetAgentFactory } from '@memberjunction/ai-agents';
import { UserInfo } from '@memberjunction/core';

// Get agent factory and create agents
const factory = GetAgentFactory();
const baseAgent = await factory.CreateAgent("Customer Support", null, contextUser);
const conductorAgent = await factory.CreateAgent("Conductor", null, contextUser);

// Create runner and execute with separation of concerns
const runner = new AgentRunner(conductorAgent, contextUser);
const result = await runner.Run({
  agent: baseAgent,
  goal: "Help customer with their order",
  data: { customerQuery: "Where is my order?" },
  conversationMessages: [...],
  onProgress: (progress) => console.log(progress.message),
  cancellationToken: controller.signal
});

if (result.success) {
  console.log("Task completed:", result.finalDecision?.finalResponse);
  console.log("Decisions made:", result.decisionHistory?.length);
  console.log("Actions executed:", result.actionResults?.length);
}

import { GetAgentFactory } from '@memberjunction/ai-agents';
import { AIEngine } from '@memberjunction/aiengine';
import { AgentRunner } from '@memberjunction/ai-agents';
import { UserInfo } from '@memberjunction/core';

// Initialize AI Engine to access agents and types
await AIEngine.Instance.Config(false, contextUser);

// Get agent factory and create agents
const factory = GetAgentFactory();
const baseAgent = await factory.CreateAgent('Customer Support', null, contextUser);
const conductorAgent = await factory.CreateAgent('Conductor', null, contextUser);

// Create and run with separation of concerns architecture
const runner = new AgentRunner(conductorAgent, contextUser);
const result = await runner.Run({
    agent: baseAgent,
    goal: 'Help customer with their order',
    data: {
        customerQuery: 'I need help with my order',
        customerId: 'cust-123'
    },
    conversationMessages: [
        { role: 'user', content: 'I need help with my order' }
    ]
});

if (result.success) {
    console.log('Task completed:', result.finalDecision?.finalResponse);
    console.log('Execution summary:', result.metadata);
}

import { GetAgentFactory, AgentRunner } from '@memberjunction/ai-agents';

// Hierarchical agents are handled through conductor decision-making
// Parent agents delegate to child agents based on AI decisions

// Get factory and create hierarchical agents
const factory = GetAgentFactory();
const managerAgent = await factory.CreateAgent('Customer Service Manager', null, contextUser);
const conductorAgent = await factory.CreateAgent('Conductor', null, contextUser);

// Create runner and execute - conductor will make autonomous delegation decisions
const runner = new AgentRunner(conductorAgent, contextUser);
const result = await runner.Run({
    agent: managerAgent,
    goal: 'Resolve complex customer issue',
    data: {
        customerQuery: 'Complex billing and technical issue',
        priority: 'high'
    },
    conversationMessages: [...],
    onProgress: (progress) => {
        if (progress.step === 'prompt_execution') {
            console.log('Agent coordinating execution:', progress.metadata);
        }
    }
});

// The conductor's decision history shows which sub-agents were chosen
result.decisionHistory?.forEach((decision, i) => {
    console.log(`Decision ${i + 1}: ${decision.decision}`);
    console.log(`Reasoning: ${decision.reasoning}`);
    if (decision.executionPlan.length > 0) {
        console.log('Execution plan:', decision.executionPlan);
    }
});

import { GetAgentFactory, AgentRunner } from '@memberjunction/ai-agents';

// Context compression is automatically handled by BaseAgent
// Configure compression through the agent entity properties

const factory = GetAgentFactory();
const longConversationAgent = AIEngine.Instance.Agents.find(a => {
    return a.EnableContextCompression && 
           a.ContextCompressionMessageThreshold === 50 &&
           a.ContextCompressionMessageRetentionCount === 10;
});

const baseAgent = factory.CreateAgentFromEntity(longConversationAgent, null, contextUser);
const conductorAgent = await factory.CreateAgent('Conductor', null, contextUser);
const runner = new AgentRunner(conductorAgent, contextUser);

// Execute with long conversation - compression happens automatically in BaseAgent
const longConversation = Array(60).fill(null).map((_, i) => ({
    role: i % 2 === 0 ? 'user' : 'assistant',
    content: `Message ${i + 1} in a very long conversation`
}));

const result = await runner.Run({
    agent: baseAgent,
    goal: 'Handle long conversation with compression',
    conversationMessages: longConversation,
    onProgress: (progress) => {
        if (progress.step === 'prompt_execution') {
            console.log('Processing context (may include compression):', progress.message);
        }
    }
});

// Compression is applied automatically by BaseAgent based on agent configuration
// The agent run record tracks the compression activity

import { AgentRunner } from '@memberjunction/ai-agents';

const runner = new AgentRunner();

// Execute with streaming and progress callbacks
const result = await runner.RunAgent({
    agent: myAgent,
    conversationMessages: messages,
    contextUser: user,
    
    // Progress callback for execution status updates
    onProgress: (progress) => {
        console.log(`[${progress.percentage}%] ${progress.step}: ${progress.message}`);
        
        // Progress steps include:
        // - initialization: Setting up the agent
        // - validation: Validating agent configuration
        // - prompt_execution: Executing AI prompts
        // - action_execution: Running actions
        // - subagent_execution: Running sub-agents
        // - decision_processing: Processing next steps
        // - finalization: Completing execution
    },
    
    // Streaming callback for real-time AI responses
    onStreaming: (chunk) => {
        process.stdout.write(chunk.content);
        
        if (chunk.isComplete) {
            console.log('\n--- Stream complete ---');
        }
        
        // Additional metadata available:
        // - chunk.stepType: 'prompt', 'action', 'subagent', or 'chat'
        // - chunk.stepEntityId: ID of the step being executed
        // - chunk.modelName: AI model producing the content (for prompts)
    }
});

import { AgentRunner } from '@memberjunction/ai-agents';

const runner = new AgentRunner();
const controller = new AbortController();

// Set up cancellation after 30 seconds
setTimeout(() => {
    console.log('Cancelling agent execution...');
    controller.abort();
}, 30000);

try {
    const result = await runner.RunAgent({
        agent: myAgent,
        conversationMessages: messages,
        contextUser: user,
        cancellationToken: controller.signal,
        onProgress: (progress) => {
            console.log(`Progress: ${progress.message}`);
        }
    });
    
    if (result.cancelled) {
        console.log('Execution was cancelled:', result.cancellationReason);
    }
} catch (error) {
    if (controller.signal.aborted) {
        console.log('Operation cancelled by user');
    } else {
        console.error('Execution error:', error);
    }
}

// Cancellation is checked at multiple points:
// - Before starting execution
// - After initialization
// - Before each execution step
// - After prompt/action/sub-agent completion
// The agent run is properly marked as 'Cancelled' in the database

import { BaseAgent, ExecuteAgentParams } from '@memberjunction/ai-agents';

// Define your context type
interface MyAgentContext {
    apiEndpoint: string;
    apiKey: string;
    environment: 'dev' | 'staging' | 'prod';
    userPreferences: {
        language: string;
        timezone: string;
    };
}

// Execute agent with typed context
const agent = new BaseAgent();
const params: ExecuteAgentParams<MyAgentContext> = {
    agent: myAgentEntity,
    conversationMessages: messages,
    contextUser: currentUser,
    context: {
        apiEndpoint: 'https://api.example.com',
        apiKey: process.env.API_KEY,
        environment: 'prod',
        userPreferences: {
            language: 'en',
            timezone: 'UTC'
        }
    }
};
const result = await agent.Execute(params);

// Parent agent execution
const parentParams: ExecuteAgentParams<MyContext> = {
    agent: parentAgentEntity,
    conversationMessages: messages,
    context: myContext  // Context passed here
};
const parentResult = await parentAgent.Execute(parentParams);

// When parent executes sub-agents, context flows automatically
// Sub-agents receive the same context without manual passing

// When agents execute actions, context flows to them as well
// Actions can access context via params.Context

export class CustomAgent extends BaseAgent {
    protected async preparePromptParams(
        agentType: AIAgentTypeEntity,
        systemPrompt: any,
        childPrompt: any,
        params: ExecuteAgentParams<MyAgentContext>
    ): Promise<AIPromptParams> {
        const promptParams = await super.preparePromptParams(agentType, systemPrompt, childPrompt, params);
        
        // Access typed context
        if (params.context) {
            promptParams.data.apiEndpoint = params.context.apiEndpoint;
            promptParams.data.environment = params.context.environment;
            
            // Use context to modify behavior
            if (params.context.environment === 'dev') {
                promptParams.data.debugMode = true;
            }
        }
        
        return promptParams;
    }
}

import { BaseAction, RunActionParams } from '@memberjunction/actions';

export class APICallAction extends BaseAction {
    protected async InternalRunAction(params: RunActionParams<MyAgentContext>): Promise<ActionResultSimple> {
        // Access typed context
        const endpoint = params.Context?.apiEndpoint;
        const apiKey = params.Context?.apiKey;
        
        if (!endpoint || !apiKey) {
            return {
                Success: false,
                ResultCode: 'MISSING_CONTEXT',
                Message: 'Required API configuration not found in context'
            };
        }
        
        // Use context for action execution
        const response = await fetch(endpoint, {
            headers: {
                'Authorization': `Bearer ${apiKey}`,
                'Accept-Language': params.Context.userPreferences.language
            }
        });
        
        return {
            Success: true,
            ResultCode: 'SUCCESS',
            Message: 'API call completed'
        };
    }
}

import { BaseAgent, ExecuteAgentParams, ExecuteAgentResult } from '@memberjunction/ai-agents';
import { AIPromptParams } from '@memberjunction/ai-prompts';

export class CustomAnalysisAgent extends BaseAgent {
    // Override initialization to add custom setup
    protected async initializeEngines(contextUser?: UserInfo): Promise<void> {
        await super.initializeEngines(contextUser);
        
        // Add custom initialization
        await this.initializeAnalysisTools();
    }
    
    // Override validation to add custom checks
    protected async validateAgent(agent: AIAgentEntity): Promise<ExecuteAgentResult | null> {
        const baseValidation = await super.validateAgent(agent);
        if (baseValidation) return baseValidation;
        
        // Add custom validation
        if (!this.hasRequiredPermissions(agent)) {
            return {
                nextStep: 'failed',
                errorMessage: 'Agent lacks required analysis permissions'
            };
        }
        
        return null;
    }
    
    // Override prompt preparation to inject custom data
    protected async preparePromptParams(
        agentType: AIAgentTypeEntity,
        systemPrompt: any,
        childPrompt: any,
        params: ExecuteAgentParams
    ): Promise<AIPromptParams> {
        const promptParams = await super.preparePromptParams(agentType, systemPrompt, childPrompt, params);
        
        // Add custom context data
        promptParams.data = {
            ...promptParams.data,
            analysisContext: await this.gatherAnalysisContext(),
            historicalData: await this.loadHistoricalData()
        };
        
        return promptParams;
    }
    
    // Override action result formatting
    protected createActionResultMessage(actions: AgentAction[], results: any[]): ChatMessage {
        // Custom formatting for analysis results
        const analysisResults = results.map((result, index) => {
            return {
                action: actions[index].name,
                success: result.Success,
                analysisScore: result.Params?.find(p => p.Name === 'score')?.Value,
                insights: result.Params?.find(p => p.Name === 'insights')?.Value
            };
        });
        
        return {
            role: 'user',
            content: `Analysis completed:\n${JSON.stringify(analysisResults, null, 2)}`
        };
    }
}

export class StreamingAgent extends BaseAgent {
    // Only override prompt execution to add streaming
    protected async executePrompt(promptParams: AIPromptParams): Promise<any> {
        // Add streaming configuration
        promptParams.streaming = true;
        promptParams.streamingCallback = (chunk) => {
            this.handleStreamingChunk(chunk);
        };
        
        return await super.executePrompt(promptParams);
    }
    
    private handleStreamingChunk(chunk: string): void {
        // Process streaming response chunks
        console.log('Streaming:', chunk);
    }
}

export class BatchProcessingAgent extends BaseAgent {
    protected async handleActionResults(
        params: ExecuteAgentParams,
        nextStep: any,
        promptResult: any
    ): Promise<ExecuteAgentResult> {
        // Execute actions
        const actionResults = await this.ExecuteActions(nextStep.actions, params.contextUser);
        
        // Batch results instead of immediate recursion
        if (this.shouldBatchResults(actionResults)) {
            this.batchedResults.push(...actionResults);
            
            // Continue without recursion if batching
            return {
                nextStep: 'retry',
                returnValue: { batching: true, count: this.batchedResults.length }
            };
        }
        
        // Otherwise use default recursion behavior
        return await super.handleActionResults(params, nextStep, promptResult);
    }
}

export class MultiStageAgent extends BaseAgent {
    public async Execute(params: ExecuteAgentParams): Promise<ExecuteAgentResult> {
        // Stage 1: Initial analysis
        const stage1Result = await this.executeStage1(params);
        if (stage1Result.nextStep === 'failed') return stage1Result;
        
        // Stage 2: Deep processing based on stage 1
        const stage2Params = this.prepareStage2Params(params, stage1Result);
        const stage2Result = await this.executeStage2(stage2Params);
        if (stage2Result.nextStep === 'failed') return stage2Result;
        
        // Stage 3: Synthesis and final execution
        return await this.executeFinalStage(params, stage1Result, stage2Result);
    }
    
    private async executeStage1(params: ExecuteAgentParams): Promise<ExecuteAgentResult> {
        // Use base methods for configuration loading
        const config = await this.loadAgentConfiguration(params.agent);
        if (!config.success) {
            return { nextStep: 'failed', errorMessage: config.errorMessage };
        }
        
        // Custom stage 1 logic...
    }
}

protected async executePrompt(promptParams: AIPromptParams): Promise<any> {
    // Pre-processing
    await this.beforePromptExecution(promptParams);
    
    // Execute
    const result = await super.executePrompt(promptParams);
    
    // Post-processing
    await this.afterPromptExecution(result);
    
    return result;
}

protected async preparePromptParams(...args): Promise<AIPromptParams> {
    const params = await super.preparePromptParams(...args);
    
    // Inject custom context
    params.data.customContext = await this.loadCustomContext();
    params.conversationMessages = this.preprocessMessages(params.conversationMessages);
    
    return params;
}

protected async processNextStep(
    params: ExecuteAgentParams,
    agentType: AIAgentTypeEntity,
    promptResult: any
): Promise<ExecuteAgentResult> {
    // Check for special conditions
    if (this.shouldUseAlternativeFlow(promptResult)) {
        return await this.executeAlternativeFlow(params, promptResult);
    }
    
    // Otherwise use default flow
    return await super.processNextStep(params, agentType, promptResult);
}

interface ExecuteAgentResult {
    // Core execution outcome
    success: boolean;                    // Whether the overall execution was successful
    finalStep: BaseAgentNextStep['step']; // The final step type that terminated execution
    returnValue?: any;                   // Optional return value from the agent
    errorMessage?: string;               // Error message if execution failed
    
    // Tracking and history
    agentRun: AIAgentRunEntity;          // Database entity tracking this execution
    executionChain: ExecutionChainStep[]; // Complete chain of execution steps
}

interface ExecutionChainStep {
    stepEntity: AIAgentRunStepEntity;    // Database entity for this step
    executionType: 'prompt' | 'action' | 'sub-agent' | 'decision' | 'chat' | 'validation';
    executionResult: StepExecutionResult; // The actual result (varies by type)
    nextStepDecision: NextStepDecision;   // What was decided after this step
    startTime: Date;                      // When the step started
    endTime?: Date;                       // When the step completed
    durationMs?: number;                  // Execution duration in milliseconds
}

{
    type: 'prompt';
    promptId: string;
    promptName: string;
    result: AIPromptRunResult;  // Native result from @memberjunction/ai-prompts
}

{
    type: 'action';
    actionId: string;
    actionName: string;
    result: ActionResult | ActionResultSimple;  // Native result from @memberjunction/actions
}

{
    type: 'sub-agent';
    subAgentId: string;
    subAgentName: string;
    result: ExecuteAgentResult;  // Recursive - full execution result of sub-agent
}

const runner = new AgentRunner();
const result = await runner.RunAgent({
    agent: myAgent,
    conversationMessages: messages,
    contextUser: user
});

// Access execution outcome
console.log(`Success: ${result.success}`);
console.log(`Final step: ${result.finalStep}`);
console.log(`Return value:`, result.returnValue);

// Access the agent run record
console.log(`Agent run ID: ${result.agentRun.ID}`);
console.log(`Started at: ${result.agentRun.StartedAt}`);
console.log(`Duration: ${result.agentRun.CompletedAt - result.agentRun.StartedAt}ms`);

// Analyze the execution chain
result.executionChain.forEach((step, index) => {
    console.log(`\nStep ${index + 1}: ${step.executionType}`);
    console.log(`  Name: ${step.stepEntity.StepName}`);
    console.log(`  Duration: ${step.durationMs}ms`);
    console.log(`  Success: ${step.stepEntity.Success}`);
    
    // Access type-specific results
    switch (step.executionResult.type) {
        case 'prompt':
            console.log(`  Prompt: ${step.executionResult.promptName}`);
            console.log(`  Tokens used: ${step.executionResult.result.tokensUsed}`);
            break;
        case 'action':
            console.log(`  Action: ${step.executionResult.actionName}`);
            console.log(`  Result: ${step.executionResult.result.Success}`);
            break;
        case 'sub-agent':
            console.log(`  Sub-agent: ${step.executionResult.subAgentName}`);
            console.log(`  Sub-steps: ${step.executionResult.result.executionChain.length}`);
            break;
    }
    
    // Show what was decided next
    console.log(`  Next decision: ${step.nextStepDecision.decision}`);
    console.log(`  Reasoning: ${step.nextStepDecision.reasoning}`);
});

// Visualize the execution flow
const executionFlow = result.executionChain
    .map(step => `${step.executionType} → ${step.nextStepDecision.decision}`)
    .join(' → ');
console.log(`\nExecution flow: ${executionFlow}`);

function analyzeExecutionDepth(result: ExecuteAgentResult, depth = 0): void {
    const indent = '  '.repeat(depth);
    console.log(`${indent}Agent: ${result.agentRun.AgentID}`);
    console.log(`${indent}Steps: ${result.executionChain.length}`);
    
    // Find sub-agent executions
    const subAgentSteps = result.executionChain.filter(
        step => step.executionType === 'sub-agent'
    ) as Array<{ executionResult: SubAgentExecutionResult }>;
    
    // Recursively analyze sub-agents
    for (const step of subAgentSteps) {
        analyzeExecutionDepth(step.executionResult.result, depth + 1);
    }
}

// Analyze the entire execution tree
analyzeExecutionDepth(result);

// Calculate time spent in each type of operation
const timingAnalysis = result.executionChain.reduce((acc, step) => {
    const type = step.executionType;
    acc[type] = (acc[type] || 0) + (step.durationMs || 0);
    return acc;
}, {} as Record<string, number>);

console.log('Time spent by operation type:', timingAnalysis);

// Find slowest steps
const slowestSteps = result.executionChain
    .filter(step => step.durationMs)
    .sort((a, b) => b.durationMs! - a.durationMs!)
    .slice(0, 5);

console.log('Top 5 slowest steps:', slowestSteps.map(s => ({
    name: s.stepEntity.StepName,
    duration: s.durationMs,
    type: s.executionType
})));

// Import main classes
import { BaseAgent, ConductorAgent, AgentRunner } from '@memberjunction/ai-agents';
import { GetAgentFactory } from '@memberjunction/ai-agents';

// Import types
import { 
  AgentExecutionParams, 
  AgentExecutionResult,
  AgentRunnerParams,
  AgentRunnerResult,
  ConductorDecisionResponse 
} from '@memberjunction/ai-agents';

// Import base AI types from Core
import { ChatMessage, ChatResult } from '@memberjunction/ai';

// Import prompt types when needed
import { AIPromptParams, AIPromptRunResult } from '@memberjunction/ai-prompts';

// Import entity types
import { AIAgentEntity, AIAgentTypeEntity } from '@memberjunction/core-entities';

constructor(conductor: ConductorAgent, contextUser: UserInfo)

constructor(agent: AIAgentEntityExtended, factory: IAgentFactory, contextUser: UserInfo, promptRunner?: AIPromptRunner)

constructor(agent: AIAgentEntityExtended, factory: IAgentFactory, contextUser: UserInfo)

interface AgentRunnerParams extends AgentExecutionParams {
    agent: BaseAgent;
    maxIterations?: number;
    goal?: string;
    enableDetailedLogging?: boolean;
}

interface AgentRunnerResult extends AgentExecutionResult {
    decisionHistory?: ConductorDecisionResponse[];
    actionResults?: ActionResult[];
    finalDecision?: ConductorDecisionResponse;
    iterationCount?: number;
    executionSteps?: ExecutionHistoryItem[];
}

interface ConductorDecisionResponse {
    decision: ConductorDecisionType;
    reasoning: string;
    executionPlan: ExecutionStep[];
    isTaskComplete: boolean;
    finalResponse?: string;
    confidence: number;
    metadata?: {
        estimatedDuration?: number;
        riskLevel?: 'low' | 'medium' | 'high';
        failureStrategy?: string;
    };
}

interface ExecutionStep {
    type: 'action' | 'subagent';
    targetId: string;
    parameters?: Record<string, unknown>;
    executionOrder: number;
    allowParallel?: boolean;
    description?: string;
}

interface AgentProgressUpdate {
    step: 'initialization' | 'prompt_execution' | 'completion';
    percentage: number;
    message: string;
    metadata?: Record<string, unknown>;
}

// Example: Associate a prompt with an agent
const agentPrompt = await md.GetEntityObject<AIAgentPromptEntity>('AI Agent Prompts');
agentPrompt.NewRecord();
agentPrompt.AgentID = agent.ID;
agentPrompt.PromptID = prompt.ID;
agentPrompt.Purpose = 'Main conversation handler';
agentPrompt.ExecutionOrder = 1;
agentPrompt.ContextBehavior = 'Recent'; // or 'Full', 'None'
agentPrompt.ContextMessageCount = 20;
await agentPrompt.Save();

class ParallelAnalysisAgent extends BaseAgent {
    async execute(context: AgentContext): Promise<AgentResult> {
        // Execute multiple sub-agents in parallel
        const [sentiment, intent, entities] = await Promise.all([
            this.sentimentAgent.execute(context),
            this.intentAgent.execute(context),
            this.entityExtractorAgent.execute(context)
        ]);
        
        // Combine results
        return {
            response: this.synthesizeResults(sentiment, intent, entities),
            success: true,
            metadata: {
                childAgentResults: [sentiment, intent, entities]
            }
        };
    }
}

class LearningAgent extends BaseAgent {
    async execute(context: AgentContext): Promise<AgentResult> {
        try {
            const result = await super.execute(context);
            
            // Learn from successful execution
            if (result.success) {
                await this.addNote(
                    `Successfully handled query type: ${this.classifyQuery(context)}`,
                    'learning'
                );
            }
            
            return result;
        } catch (error) {
            // Learn from errors
            await this.addNote(
                `Error handling query: ${error.message}`,
                'error'
            );
            throw error;
        }
    }
}

class DataAnalysisAgent extends BaseAgent {
    async initialize(): Promise<void> {
        await super.initialize();
        
        // Register custom actions
        this.registerAction('analyzeData', this.analyzeData.bind(this));
        this.registerAction('generateReport', this.generateReport.bind(this));
        this.registerAction('exportResults', this.exportResults.bind(this));
    }
    
    private async analyzeData(params: { datasetId: string }): Promise<any> {
        // Implementation for data analysis
        const dataset = await this.loadDataset(params.datasetId);
        return this.performAnalysis(dataset);
    }
}

try {
    const result = await agent.execute(context);
    console.log('Success:', result);
} catch (error) {
    if (error instanceof AgentExecutionError) {
        console.error('Execution failed:', error.message);
        console.error('Agent:', error.agentName);
        console.error('Context:', error.context);
    } else if (error instanceof AgentInitializationError) {
        console.error('Failed to initialize agent:', error.message);
    } else {
        console.error('Unexpected error:', error);
    }
}

// Get factory and create specialized agents
const factory = GetAgentFactory();
const baseAgent = await factory.CreateAgent("CustomerSupport", null, contextUser);
const conductorAgent = await factory.CreateAgent("Conductor", null, contextUser);

// Execute with clean separation of concerns
const runner = new AgentRunner(conductorAgent, contextUser);
const result = await runner.Run({
  agent: baseAgent,
  goal: "Help customer with their issue",
  data: { customerName: "John" },
  conversationMessages: [...],
  onProgress: (progress) => console.log(progress),
  cancellationToken: controller.signal
});

// BaseAgent handles domain execution, ConductorAgent makes decisions
// AgentRunner coordinates the interaction between them

// Agent types define system prompts for behavioral characteristics
AIAgentType.SystemPromptID -> AIPrompt (system template)

// Agent-specific prompts provide domain logic
AIAgent -> AIAgentPrompt -> AIPrompt (agent-specific instructions)

// Runtime: Hierarchical execution with parent-child relationships
// Parent prompts specify children via childPrompts array
// Depth-first traversal with parallel execution at each level

import { BaseAgent } from '@memberjunction/ai-agents';
import { MockAgentEntity } from './test-utils';

describe('CustomerSupportAgent', () => {
    let agent: CustomerSupportAgent;
    
    beforeEach(async () => {
        const mockEntity = new MockAgentEntity({
            Name: 'Test Agent',
            EnableContextCompression: true,
            ContextCompressionMessageThreshold: 10
        });
        
        agent = new CustomerSupportAgent(mockEntity);
        await agent.initialize();
    });
    
    test('should handle customer query', async () => {
        const result = await agent.execute({
            conversationId: 'test-123',
            messages: [
                { role: 'user', content: 'What is my order status?' }
            ]
        });
        
        expect(result.success).toBe(true);
        expect(result.response).toContain('order');
    });
    
    test('should compress long conversations', async () => {
        const longContext = {
            conversationId: 'test-456',
            messages: Array(15).fill(null).map((_, i) => ({
                role: i % 2 === 0 ? 'user' : 'assistant',
                content: `Message ${i}`
            }))
        };
        
        const result = await agent.execute(longContext);
        expect(result.metadata.contextCompressed).toBe(true);
    });
});

// Enable debug logging
process.env.MJ_AI_AGENT_DEBUG = 'true';

const agent = new MyAgent(entity);
agent.on('debug', (message) => {
    console.log('[Agent Debug]:', message);
});