@riotprompt/riotprompt 0.0.8 → 0.0.10

package/dist/iteration-strategy.js

@@ -0,0 +1,520 @@
+import { wrapLogger, DEFAULT_LOGGER } from './logger.js';
+import { MetricsCollector, ReflectionReportGenerator } from './reflection.js';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+// ===== STRATEGY EXECUTOR =====
+/**
+ * StrategyExecutor executes iteration strategies.
+ *
+ * Features:
+ * - Execute multi-phase strategies
+ * - Manage tool calls and results
+ * - Track state and metrics
+ * - Handle timeouts and errors
+ * - Provide lifecycle hooks
+ *
+ * @example
+ * ```typescript
+ * const executor = new StrategyExecutor(llmClient);
+ *
+ * const result = await executor.execute(
+ *   conversation,
+ *   toolRegistry,
+ *   strategy
+ * );
+ *
+ * console.log('Completed in', result.totalIterations, 'iterations');
+ * console.log('Used', result.toolCallsExecuted, 'tools');
+ * ```
+ */ class StrategyExecutor {
+    /**
+     * Enable reflection generation
+     */ withReflection(config) {
+        this.reflectionConfig = config;
+        return this;
+    }
+    /**
+     * Execute a strategy
+     */ async execute(conversation, tools, strategy) {
+        var _this_reflectionConfig;
+        const startTime = Date.now();
+        // Initialize metrics collector if reflection enabled
+        if ((_this_reflectionConfig = this.reflectionConfig) === null || _this_reflectionConfig === void 0 ? void 0 : _this_reflectionConfig.enabled) {
+            this.metricsCollector = new MetricsCollector(this.logger);
+        }
+        const state = {
+            phase: 0,
+            iteration: 0,
+            toolCallsExecuted: 0,
+            startTime,
+            insights: [],
+            findings: [],
+            errors: [],
+            toolFailures: new Map()
+        };
+        this.logger.info('Starting strategy execution', {
+            strategy: strategy.name
+        });
+        const context = {
+            conversation,
+            tools,
+            llm: this.llm,
+            state
+        };
+        try {
+            var _strategy_onStart, _this_reflectionConfig1, _strategy_onComplete;
+            // Initialize
+            await ((_strategy_onStart = strategy.onStart) === null || _strategy_onStart === void 0 ? void 0 : _strategy_onStart.call(strategy, context));
+            // Execute phases or single loop
+            const phases = strategy.phases || [
+                {
+                    name: 'default',
+                    maxIterations: strategy.maxIterations,
+                    toolUsage: 'encouraged'
+                }
+            ];
+            const phaseResults = [];
+            for (const phase of phases){
+                var _phase_skipIf, _strategy_onPhaseComplete;
+                // Check if should skip phase
+                if ((_phase_skipIf = phase.skipIf) === null || _phase_skipIf === void 0 ? void 0 : _phase_skipIf.call(phase, state)) {
+                    this.logger.debug('Skipping phase', {
+                        phase: phase.name
+                    });
+                    continue;
+                }
+                state.phase = phase.name;
+                state.iteration = 0;
+                this.logger.debug('Starting phase', {
+                    phase: phase.name
+                });
+                const phaseResult = await this.executePhase(conversation, tools, phase, state, strategy);
+                phaseResults.push(phaseResult);
+                await ((_strategy_onPhaseComplete = strategy.onPhaseComplete) === null || _strategy_onPhaseComplete === void 0 ? void 0 : _strategy_onPhaseComplete.call(strategy, phaseResult, state));
+                // Check if should continue
+                if (strategy.shouldContinue && !strategy.shouldContinue(state)) {
+                    this.logger.debug('Strategy decided to stop');
+                    break;
+                }
+            }
+            const duration = Date.now() - startTime;
+            const result = {
+                finalMessage: conversation.getLastMessage(),
+                phases: phaseResults,
+                totalIterations: state.iteration,
+                toolCallsExecuted: state.toolCallsExecuted,
+                duration,
+                success: true,
+                conversation
+            };
+            // Generate reflection if enabled
+            if (this.metricsCollector && ((_this_reflectionConfig1 = this.reflectionConfig) === null || _this_reflectionConfig1 === void 0 ? void 0 : _this_reflectionConfig1.enabled)) {
+                const metrics = this.metricsCollector.getMetrics(conversation.getMessages(), conversation.getMetadata().model);
+                const generator = new ReflectionReportGenerator(this.logger);
+                result.reflection = generator.generate(metrics, result);
+                // Save reflection if output path specified
+                if (this.reflectionConfig.outputPath && result.reflection) {
+                    await this.saveReflection(result.reflection, this.reflectionConfig);
+                }
+            }
+            await ((_strategy_onComplete = strategy.onComplete) === null || _strategy_onComplete === void 0 ? void 0 : _strategy_onComplete.call(strategy, result));
+            this.logger.info('Strategy execution complete', {
+                iterations: result.totalIterations,
+                toolCalls: result.toolCallsExecuted,
+                duration
+            });
+            return result;
+        } catch (error) {
+            this.logger.error('Strategy execution failed', {
+                error
+            });
+            return {
+                finalMessage: conversation.getLastMessage(),
+                phases: [],
+                totalIterations: state.iteration,
+                toolCallsExecuted: state.toolCallsExecuted,
+                duration: Date.now() - startTime,
+                success: false,
+                conversation
+            };
+        }
+    }
+    /**
+     * Save reflection report
+     */ async saveReflection(reflection, config) {
+        if (!config.outputPath) {
+            return;
+        }
+        try {
+            const fs = await import('fs/promises');
+            const path = await import('path');
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const filename = `reflection-${timestamp}.${config.format === 'json' ? 'json' : 'md'}`;
+            const fullPath = path.join(config.outputPath, filename);
+            // Ensure directory exists
+            await fs.mkdir(config.outputPath, {
+                recursive: true
+            });
+            // Save based on format
+            if (config.format === 'json') {
+                await fs.writeFile(fullPath, JSON.stringify(reflection, null, 2), 'utf-8');
+            } else {
+                const generator = new ReflectionReportGenerator(this.logger);
+                const markdown = generator.formatMarkdown(reflection);
+                await fs.writeFile(fullPath, markdown, 'utf-8');
+            }
+            this.logger.info('Reflection saved', {
+                path: fullPath
+            });
+        } catch (error) {
+            this.logger.error('Failed to save reflection', {
+                error
+            });
+        }
+    }
+    /**
+     * Execute a single phase
+     */ async executePhase(conversation, tools, phase, state, strategy) {
+        const phaseStartTools = state.toolCallsExecuted;
+        // Add phase instructions if provided
+        if (phase.instructions) {
+            conversation.asUser(phase.instructions);
+        }
+        // Iteration loop for this phase
+        for(let i = 0; i < phase.maxIterations; i++){
+            var _strategy_onIteration;
+            state.iteration++;
+            // Track iteration for metrics
+            if (this.metricsCollector) {
+                this.metricsCollector.incrementIteration();
+            }
+            this.logger.debug('Iteration', {
+                phase: phase.name,
+                iteration: i + 1
+            });
+            // Check iteration hook
+            const action = await ((_strategy_onIteration = strategy.onIteration) === null || _strategy_onIteration === void 0 ? void 0 : _strategy_onIteration.call(strategy, i, state));
+            if (action === 'stop') {
+                break;
+            }
+            if (action === 'next-phase') {
+                break;
+            }
+            // Get LLM response
+            const toolsToProvide = phase.toolUsage !== 'forbidden' ? tools.toOpenAIFormat() : undefined;
+            const response = await this.llm.complete(conversation.toMessages(), toolsToProvide);
+            // Handle tool calls
+            if (response.tool_calls && response.tool_calls.length > 0) {
+                if (phase.toolUsage === 'forbidden') {
+                    this.logger.warn('Tool calls requested but forbidden in this phase');
+                    conversation.asAssistant(response.content);
+                    continue;
+                }
+                conversation.asAssistant(response.content, response.tool_calls);
+                // Execute tools
+                for (const toolCall of response.tool_calls){
+                    var _phase_maxConsecutiveToolFailures;
+                    var _strategy_onToolCall;
+                    // Check if tool is allowed in this phase
+                    if (phase.allowedTools && !phase.allowedTools.includes(toolCall.function.name)) {
+                        this.logger.debug('Tool not allowed in phase', {
+                            tool: toolCall.function.name
+                        });
+                        continue;
+                    }
+                    // Circuit breaker: Check if tool has exceeded failure threshold
+                    const maxFailures = (_phase_maxConsecutiveToolFailures = phase.maxConsecutiveToolFailures) !== null && _phase_maxConsecutiveToolFailures !== void 0 ? _phase_maxConsecutiveToolFailures : 3;
+                    const consecutiveFailures = state.toolFailures.get(toolCall.function.name) || 0;
+                    if (consecutiveFailures >= maxFailures) {
+                        this.logger.warn('Tool circuit breaker triggered', {
+                            tool: toolCall.function.name,
+                            failures: consecutiveFailures
+                        });
+                        conversation.asTool(toolCall.id, {
+                            error: `Tool temporarily disabled due to ${consecutiveFailures} consecutive failures`
+                        }, {
+                            success: false,
+                            circuitBreakerTriggered: true
+                        });
+                        continue;
+                    }
+                    // Check tool call hook
+                    const toolAction = await ((_strategy_onToolCall = strategy.onToolCall) === null || _strategy_onToolCall === void 0 ? void 0 : _strategy_onToolCall.call(strategy, toolCall, state));
+                    if (toolAction === 'skip') {
+                        continue;
+                    }
+                    // Execute tool
+                    const toolStart = Date.now();
+                    try {
+                        var _strategy_onToolResult;
+                        // Parse tool arguments with error handling
+                        let toolArgs;
+                        try {
+                            toolArgs = JSON.parse(toolCall.function.arguments);
+                        } catch (parseError) {
+                            const error = new Error(`Invalid JSON in tool arguments for ${toolCall.function.name}: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                            if (parseError instanceof Error) {
+                                error.cause = parseError; // Preserve original error
+                            }
+                            throw error;
+                        }
+                        const result = await tools.execute(toolCall.function.name, toolArgs);
+                        const toolDuration = Date.now() - toolStart;
+                        const toolResult = {
+                            callId: toolCall.id,
+                            toolName: toolCall.function.name,
+                            result,
+                            duration: toolDuration
+                        };
+                        conversation.asTool(toolCall.id, result, {
+                            duration: toolDuration,
+                            success: true
+                        });
+                        state.toolCallsExecuted++;
+                        // Reset failure counter on success
+                        state.toolFailures.set(toolCall.function.name, 0);
+                        // Record metrics
+                        if (this.metricsCollector) {
+                            this.metricsCollector.recordToolCall(toolCall.function.name, state.iteration, toolDuration, true);
+                        }
+                        await ((_strategy_onToolResult = strategy.onToolResult) === null || _strategy_onToolResult === void 0 ? void 0 : _strategy_onToolResult.call(strategy, toolResult, state));
+                    } catch (error) {
+                        var _strategy_onToolResult1;
+                        this.logger.error('Tool execution failed', {
+                            tool: toolCall.function.name,
+                            error
+                        });
+                        const toolDuration = Date.now() - toolStart;
+                        const toolResult = {
+                            callId: toolCall.id,
+                            toolName: toolCall.function.name,
+                            result: null,
+                            error: error,
+                            duration: toolDuration
+                        };
+                        conversation.asTool(toolCall.id, {
+                            error: error.message
+                        }, {
+                            success: false,
+                            errorName: error.name
+                        });
+                        state.errors.push(error);
+                        // Increment failure counter for circuit breaker
+                        const failures = (state.toolFailures.get(toolCall.function.name) || 0) + 1;
+                        state.toolFailures.set(toolCall.function.name, failures);
+                        // Record metrics
+                        if (this.metricsCollector) {
+                            this.metricsCollector.recordToolCall(toolCall.function.name, state.iteration, toolDuration, false, error.message);
+                        }
+                        await ((_strategy_onToolResult1 = strategy.onToolResult) === null || _strategy_onToolResult1 === void 0 ? void 0 : _strategy_onToolResult1.call(strategy, toolResult, state));
+                    }
+                }
+            } else {
+                // No tool calls - add response and potentially end phase
+                conversation.asAssistant(response.content);
+                // Check if this phase requires tool calls
+                if (phase.toolUsage === 'required' && state.toolCallsExecuted === phaseStartTools) {
+                    this.logger.warn('No tools used but required in phase');
+                // Continue to try again
+                } else if (phase.earlyExit !== false) {
+                    break;
+                }
+            }
+            // Check phase completion conditions
+            const toolCallsInPhase = state.toolCallsExecuted - phaseStartTools;
+            if (phase.minToolCalls && toolCallsInPhase < phase.minToolCalls) {
+                continue; // Need more tool calls
+            }
+            if (phase.maxToolCalls && toolCallsInPhase >= phase.maxToolCalls) {
+                break; // Hit max tool calls for phase
+            }
+            if (phase.continueIf && !phase.continueIf(state)) {
+                break; // Condition not met
+            }
+        }
+        return {
+            name: phase.name,
+            iterations: state.iteration,
+            toolCalls: state.toolCallsExecuted - phaseStartTools,
+            success: true,
+            insights: state.insights
+        };
+    }
+    constructor(llm, logger){
+        _define_property(this, "llm", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "metricsCollector", void 0);
+        _define_property(this, "reflectionConfig", void 0);
+        this.llm = llm;
+        this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'StrategyExecutor');
+    }
+}
+// ===== PRE-BUILT STRATEGIES =====
+/**
+ * Factory for creating iteration strategies
+ */ class IterationStrategyFactory {
+    /**
+     * Investigate then respond strategy
+     * Phase 1: Use tools to gather information
+     * Phase 2: Synthesize into final answer
+     */ static investigateThenRespond(config = {}) {
+        const { maxInvestigationSteps = 5, requireMinimumTools = 1, finalSynthesis = true } = config;
+        return {
+            name: 'investigate-then-respond',
+            description: 'Investigate using tools, then synthesize findings',
+            maxIterations: maxInvestigationSteps + (finalSynthesis ? 1 : 0),
+            phases: [
+                {
+                    name: 'investigate',
+                    maxIterations: maxInvestigationSteps,
+                    toolUsage: 'encouraged',
+                    minToolCalls: requireMinimumTools,
+                    earlyExit: false
+                },
+                ...finalSynthesis ? [
+                    {
+                        name: 'respond',
+                        maxIterations: 1,
+                        toolUsage: 'forbidden',
+                        instructions: 'Based on your investigation, provide a comprehensive answer.',
+                        requireFinalAnswer: true
+                    }
+                ] : []
+            ]
+        };
+    }
+    /**
+     * Multi-pass refinement strategy
+     * Generate, critique, refine repeatedly
+     */ static multiPassRefinement(config = {}) {
+        const { passes = 3, critiqueBetweenPasses = true } = config;
+        const phases = [];
+        for(let i = 0; i < passes; i++){
+            phases.push({
+                name: `pass-${i + 1}`,
+                maxIterations: 1,
+                toolUsage: 'optional',
+                instructions: i === 0 ? 'Generate your best response' : 'Refine your previous response based on the critique'
+            });
+            if (critiqueBetweenPasses && i < passes - 1) {
+                phases.push({
+                    name: `critique-${i + 1}`,
+                    maxIterations: 1,
+                    toolUsage: 'forbidden',
+                    instructions: 'Critique the previous response. What can be improved?'
+                });
+            }
+        }
+        return {
+            name: 'multi-pass-refinement',
+            description: 'Iteratively refine response through multiple passes',
+            maxIterations: passes * 2,
+            phases
+        };
+    }
+    /**
+     * Breadth-first investigation
+     * Explore broadly before going deep
+     */ static breadthFirst(config = {}) {
+        const { levelsDeep = 3, toolsPerLevel = 4 } = config;
+        const phases = [];
+        for(let level = 0; level < levelsDeep; level++){
+            phases.push({
+                name: `level-${level + 1}`,
+                maxIterations: toolsPerLevel,
+                toolUsage: 'encouraged',
+                minToolCalls: 1,
+                maxToolCalls: toolsPerLevel,
+                instructions: level === 0 ? 'Get a broad overview' : `Dive deeper into areas discovered in level ${level}`
+            });
+        }
+        return {
+            name: 'breadth-first',
+            description: 'Explore broadly at each level before going deeper',
+            maxIterations: levelsDeep * toolsPerLevel,
+            phases
+        };
+    }
+    /**
+     * Depth-first investigation
+     * Deep dive immediately
+     */ static depthFirst(config = {}) {
+        const { maxDepth = 5, backtrackOnFailure = true } = config;
+        return {
+            name: 'depth-first',
+            description: 'Deep dive investigation path',
+            maxIterations: maxDepth,
+            phases: [
+                {
+                    name: 'deep-dive',
+                    maxIterations: maxDepth,
+                    toolUsage: 'encouraged',
+                    adaptiveDepth: true
+                }
+            ],
+            shouldContinue: (state)=>{
+                // Continue if making progress
+                if (backtrackOnFailure && state.errors.length > 2) {
+                    return false;
+                }
+                return true;
+            }
+        };
+    }
+    /**
+     * Adaptive strategy
+     * Changes behavior based on progress
+     */ static adaptive(_config = {}) {
+        return {
+            name: 'adaptive',
+            description: 'Adapts strategy based on progress',
+            maxIterations: 20,
+            onIteration: async (iteration, state)=>{
+                // Change behavior based on iteration count
+                if (iteration < 5) {
+                    // Early: broad exploration
+                    return 'continue';
+                } else if (iteration < 15) {
+                    // Mid: focused investigation
+                    return 'continue';
+                } else {
+                    // Late: wrap up
+                    return state.toolCallsExecuted > 0 ? 'continue' : 'stop';
+                }
+            }
+        };
+    }
+    /**
+     * Simple iteration (basic tool-use loop)
+     */ static simple(config = {}) {
+        const { maxIterations = 10, allowTools = true } = config;
+        return {
+            name: 'simple',
+            description: 'Simple iteration loop',
+            maxIterations,
+            phases: [
+                {
+                    name: 'main',
+                    maxIterations,
+                    toolUsage: allowTools ? 'encouraged' : 'forbidden',
+                    earlyExit: true
+                }
+            ]
+        };
+    }
+}
+
+export { IterationStrategyFactory, StrategyExecutor, IterationStrategyFactory as default };
+//# sourceMappingURL=iteration-strategy.js.map

package/dist/iteration-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-strategy.js","sources":["../src/iteration-strategy.ts"],"sourcesContent":["import { ConversationBuilder, type ConversationMessage, type ToolCall } from \"./conversation\";\nimport { ToolRegistry, type Tool } from \"./tools\";\nimport { DEFAULT_LOGGER, wrapLogger } from \"./logger\";\nimport { MetricsCollector, ReflectionReportGenerator, type ReflectionReport, type ReflectionConfig } from \"./reflection\";\n\n// ===== TYPE DEFINITIONS =====\n\n/**\n * Tool usage policy for a phase\n */\nexport type ToolUsagePolicy = 'required' | 'encouraged' | 'optional' | 'forbidden';\n\n/**\n * LLM client interface (generic, provider-agnostic)\n */\nexport interface LLMClient {\n    complete(messages: ConversationMessage[], tools?: any[]): Promise<{\n        content: string | null;\n        tool_calls?: ToolCall[];\n    }>;\n}\n\n/**\n * Context provided to strategy execution\n */\nexport interface StrategyContext {\n    conversation: ConversationBuilder;\n    tools: ToolRegistry;\n    llm: LLMClient;\n    state: StrategyState;\n}\n\n/**\n * Current state of strategy execution\n */\nexport interface StrategyState {\n    phase: string | number;\n    iteration: number;\n    toolCallsExecuted: number;\n    startTime: number;\n    insights: Insight[];\n    findings: any[];\n    errors: Error[];\n    toolFailures: Map<string, number>;  // Track consecutive failures per tool\n    [key: string]: any;\n}\n\n/**\n * Insight discovered during execution\n */\nexport interface Insight {\n    source: string;\n    content: string;\n    confidence: number;\n    relatedTo?: string[];\n}\n\n/**\n * Result of tool execution\n */\nexport interface ToolResult {\n    callId: string;\n    toolName: string;\n    result: any;\n    error?: Error;\n    duration: number;\n}\n\n/**\n * Action to take after iteration\n */\nexport type IterationAction = 'continue' | 'stop' | 'next-phase';\n\n/**\n * Action to take for tool call\n */\nexport type ToolCallAction = 'execute' | 'skip' | 'defer';\n\n/**\n * Result of a phase\n */\nexport interface PhaseResult {\n    name: string;\n    iterations: number;\n    toolCalls: number;\n    success: boolean;\n    insights?: Insight[];\n}\n\n/**\n * Final strategy result\n */\nexport interface StrategyResult {\n    finalMessage: ConversationMessage | undefined;\n    phases: PhaseResult[];\n    totalIterations: number;\n    toolCallsExecuted: number;\n    duration: number;\n    success: boolean;\n    conversation: ConversationBuilder;\n    reflection?: ReflectionReport;\n}\n\n/**\n * Configuration for a strategy phase\n */\nexport interface StrategyPhase {\n    name: string;\n    maxIterations: number;\n    toolUsage: ToolUsagePolicy;\n    allowedTools?: string[];\n    minToolCalls?: number;\n    maxToolCalls?: number;\n    instructions?: string;\n    earlyExit?: boolean;\n    requireFinalAnswer?: boolean;\n    adaptiveDepth?: boolean;\n    maxConsecutiveToolFailures?: number;  // Circuit breaker threshold (default: 3)\n    continueIf?: (state: StrategyState) => boolean;\n    skipIf?: (state: StrategyState) => boolean;\n}\n\n/**\n * Iteration strategy interface\n */\nexport interface IterationStrategy {\n    name: string;\n    description: string;\n    maxIterations: number;\n    maxToolCalls?: number;\n    timeoutMs?: number;\n    phases?: StrategyPhase[];\n\n    // Lifecycle hooks\n    onStart?: (context: StrategyContext) => Promise<void>;\n    onIteration?: (iteration: number, state: StrategyState) => Promise<IterationAction>;\n    onToolCall?: (toolCall: ToolCall, state: StrategyState) => Promise<ToolCallAction>;\n    onToolResult?: (result: ToolResult, state: StrategyState) => Promise<void>;\n    onPhaseComplete?: (phase: PhaseResult, state: StrategyState) => Promise<void>;\n    onComplete?: (result: StrategyResult) => Promise<void>;\n\n    // Decision logic\n    shouldContinue?: (state: StrategyState) => boolean;\n    shouldCallTool?: (tool: Tool, state: StrategyState) => boolean;\n    selectTools?: (available: Tool[], state: StrategyState) => Tool[];\n}\n\n// ===== STRATEGY EXECUTOR =====\n\n/**\n * StrategyExecutor executes iteration strategies.\n *\n * Features:\n * - Execute multi-phase strategies\n * - Manage tool calls and results\n * - Track state and metrics\n * - Handle timeouts and errors\n * - Provide lifecycle hooks\n *\n * @example\n * ```typescript\n * const executor = new StrategyExecutor(llmClient);\n *\n * const result = await executor.execute(\n *   conversation,\n *   toolRegistry,\n *   strategy\n * );\n *\n * console.log('Completed in', result.totalIterations, 'iterations');\n * console.log('Used', result.toolCallsExecuted, 'tools');\n * ```\n */\nexport class StrategyExecutor {\n    private llm: LLMClient;\n    private logger: any;\n    private metricsCollector?: MetricsCollector;\n    private reflectionConfig?: ReflectionConfig;\n\n    constructor(llm: LLMClient, logger?: any) {\n        this.llm = llm;\n        this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'StrategyExecutor');\n    }\n\n    /**\n     * Enable reflection generation\n     */\n    withReflection(config: ReflectionConfig): this {\n        this.reflectionConfig = config;\n        return this;\n    }\n\n    /**\n     * Execute a strategy\n     */\n    async execute(\n        conversation: ConversationBuilder,\n        tools: ToolRegistry,\n        strategy: IterationStrategy\n    ): Promise<StrategyResult> {\n        const startTime = Date.now();\n\n        // Initialize metrics collector if reflection enabled\n        if (this.reflectionConfig?.enabled) {\n            this.metricsCollector = new MetricsCollector(this.logger);\n        }\n\n        const state: StrategyState = {\n            phase: 0,\n            iteration: 0,\n            toolCallsExecuted: 0,\n            startTime,\n            insights: [],\n            findings: [],\n            errors: [],\n            toolFailures: new Map<string, number>(),\n        };\n\n        this.logger.info('Starting strategy execution', { strategy: strategy.name });\n\n        const context: StrategyContext = { conversation, tools, llm: this.llm, state };\n\n        try {\n            // Initialize\n            await strategy.onStart?.(context);\n\n            // Execute phases or single loop\n            const phases = strategy.phases || [\n                {\n                    name: 'default',\n                    maxIterations: strategy.maxIterations,\n                    toolUsage: 'encouraged' as ToolUsagePolicy,\n                }\n            ];\n\n            const phaseResults: PhaseResult[] = [];\n\n            for (const phase of phases) {\n                // Check if should skip phase\n                if (phase.skipIf?.(state)) {\n                    this.logger.debug('Skipping phase', { phase: phase.name });\n                    continue;\n                }\n\n                state.phase = phase.name;\n                state.iteration = 0;\n\n                this.logger.debug('Starting phase', { phase: phase.name });\n\n                const phaseResult = await this.executePhase(\n                    conversation,\n                    tools,\n                    phase,\n                    state,\n                    strategy\n                );\n\n                phaseResults.push(phaseResult);\n\n                await strategy.onPhaseComplete?.(phaseResult, state);\n\n                // Check if should continue\n                if (strategy.shouldContinue && !strategy.shouldContinue(state)) {\n                    this.logger.debug('Strategy decided to stop');\n                    break;\n                }\n            }\n\n            const duration = Date.now() - startTime;\n\n            const result: StrategyResult = {\n                finalMessage: conversation.getLastMessage(),\n                phases: phaseResults,\n                totalIterations: state.iteration,\n                toolCallsExecuted: state.toolCallsExecuted,\n                duration,\n                success: true,\n                conversation,\n            };\n\n            // Generate reflection if enabled\n            if (this.metricsCollector && this.reflectionConfig?.enabled) {\n                const metrics = this.metricsCollector.getMetrics(\n                    conversation.getMessages(),\n                    conversation.getMetadata().model\n                );\n\n                const generator = new ReflectionReportGenerator(this.logger);\n                result.reflection = generator.generate(metrics, result);\n\n                // Save reflection if output path specified\n                if (this.reflectionConfig.outputPath && result.reflection) {\n                    await this.saveReflection(result.reflection, this.reflectionConfig);\n                }\n            }\n\n            await strategy.onComplete?.(result);\n\n            this.logger.info('Strategy execution complete', {\n                iterations: result.totalIterations,\n                toolCalls: result.toolCallsExecuted,\n                duration\n            });\n\n            return result;\n\n        } catch (error) {\n            this.logger.error('Strategy execution failed', { error });\n\n            return {\n                finalMessage: conversation.getLastMessage(),\n                phases: [],\n                totalIterations: state.iteration,\n                toolCallsExecuted: state.toolCallsExecuted,\n                duration: Date.now() - startTime,\n                success: false,\n                conversation,\n            };\n        }\n    }\n\n    /**\n     * Save reflection report\n     */\n    private async saveReflection(\n        reflection: ReflectionReport,\n        config: ReflectionConfig\n    ): Promise<void> {\n        if (!config.outputPath) {\n            return;\n        }\n\n        try {\n            const fs = await import('fs/promises');\n            const path = await import('path');\n\n            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');\n            const filename = `reflection-${timestamp}.${config.format === 'json' ? 'json' : 'md'}`;\n            const fullPath = path.join(config.outputPath, filename);\n\n            // Ensure directory exists\n            await fs.mkdir(config.outputPath, { recursive: true });\n\n            // Save based on format\n            if (config.format === 'json') {\n                await fs.writeFile(fullPath, JSON.stringify(reflection, null, 2), 'utf-8');\n            } else {\n                const generator = new ReflectionReportGenerator(this.logger);\n                const markdown = generator.formatMarkdown(reflection);\n                await fs.writeFile(fullPath, markdown, 'utf-8');\n            }\n\n            this.logger.info('Reflection saved', { path: fullPath });\n        } catch (error) {\n            this.logger.error('Failed to save reflection', { error });\n        }\n    }\n\n    /**\n     * Execute a single phase\n     */\n    private async executePhase(\n        conversation: ConversationBuilder,\n        tools: ToolRegistry,\n        phase: StrategyPhase,\n        state: StrategyState,\n        strategy: IterationStrategy\n    ): Promise<PhaseResult> {\n        const phaseStartTools = state.toolCallsExecuted;\n\n        // Add phase instructions if provided\n        if (phase.instructions) {\n            conversation.asUser(phase.instructions);\n        }\n\n        // Iteration loop for this phase\n        for (let i = 0; i < phase.maxIterations; i++) {\n            state.iteration++;\n\n            // Track iteration for metrics\n            if (this.metricsCollector) {\n                this.metricsCollector.incrementIteration();\n            }\n\n            this.logger.debug('Iteration', { phase: phase.name, iteration: i + 1 });\n\n            // Check iteration hook\n            const action = await strategy.onIteration?.(i, state);\n            if (action === 'stop') {\n                break;\n            }\n            if (action === 'next-phase') {\n                break;\n            }\n\n            // Get LLM response\n            const toolsToProvide = phase.toolUsage !== 'forbidden' ? tools.toOpenAIFormat() : undefined;\n            const response = await this.llm.complete(\n                conversation.toMessages(),\n                toolsToProvide\n            );\n\n            // Handle tool calls\n            if (response.tool_calls && response.tool_calls.length > 0) {\n                if (phase.toolUsage === 'forbidden') {\n                    this.logger.warn('Tool calls requested but forbidden in this phase');\n                    conversation.asAssistant(response.content);\n                    continue;\n                }\n\n                conversation.asAssistant(response.content, response.tool_calls);\n\n                // Execute tools\n                for (const toolCall of response.tool_calls) {\n                    // Check if tool is allowed in this phase\n                    if (phase.allowedTools && !phase.allowedTools.includes(toolCall.function.name)) {\n                        this.logger.debug('Tool not allowed in phase', { tool: toolCall.function.name });\n                        continue;\n                    }\n\n                    // Circuit breaker: Check if tool has exceeded failure threshold\n                    const maxFailures = phase.maxConsecutiveToolFailures ?? 3;\n                    const consecutiveFailures = state.toolFailures.get(toolCall.function.name) || 0;\n                    if (consecutiveFailures >= maxFailures) {\n                        this.logger.warn('Tool circuit breaker triggered', {\n                            tool: toolCall.function.name,\n                            failures: consecutiveFailures\n                        });\n                        conversation.asTool(toolCall.id, {\n                            error: `Tool temporarily disabled due to ${consecutiveFailures} consecutive failures`\n                        }, {\n                            success: false,\n                            circuitBreakerTriggered: true\n                        });\n                        continue;\n                    }\n\n                    // Check tool call hook\n                    const toolAction = await strategy.onToolCall?.(toolCall, state);\n                    if (toolAction === 'skip') {\n                        continue;\n                    }\n\n                    // Execute tool\n                    const toolStart = Date.now();\n                    try {\n                        // Parse tool arguments with error handling\n                        let toolArgs: any;\n                        try {\n                            toolArgs = JSON.parse(toolCall.function.arguments);\n                        } catch (parseError) {\n                            const error = new Error(\n                                `Invalid JSON in tool arguments for ${toolCall.function.name}: ${\n                                    parseError instanceof Error ? parseError.message : String(parseError)\n                                }`\n                            );\n                            if (parseError instanceof Error) {\n                                (error as any).cause = parseError; // Preserve original error\n                            }\n                            throw error;\n                        }\n\n                        const result = await tools.execute(\n                            toolCall.function.name,\n                            toolArgs\n                        );\n\n                        const toolDuration = Date.now() - toolStart;\n\n                        const toolResult: ToolResult = {\n                            callId: toolCall.id,\n                            toolName: toolCall.function.name,\n                            result,\n                            duration: toolDuration,\n                        };\n\n                        conversation.asTool(toolCall.id, result, {\n                            duration: toolDuration,\n                            success: true\n                        });\n\n                        state.toolCallsExecuted++;\n\n                        // Reset failure counter on success\n                        state.toolFailures.set(toolCall.function.name, 0);\n\n                        // Record metrics\n                        if (this.metricsCollector) {\n                            this.metricsCollector.recordToolCall(\n                                toolCall.function.name,\n                                state.iteration,\n                                toolDuration,\n                                true\n                            );\n                        }\n\n                        await strategy.onToolResult?.(toolResult, state);\n\n                    } catch (error) {\n                        this.logger.error('Tool execution failed', { tool: toolCall.function.name, error });\n\n                        const toolDuration = Date.now() - toolStart;\n\n                        const toolResult: ToolResult = {\n                            callId: toolCall.id,\n                            toolName: toolCall.function.name,\n                            result: null,\n                            error: error as Error,\n                            duration: toolDuration,\n                        };\n\n                        conversation.asTool(toolCall.id, {\n                            error: (error as Error).message\n                        }, {\n                            success: false,\n                            errorName: (error as Error).name\n                        });\n\n                        state.errors.push(error as Error);\n\n                        // Increment failure counter for circuit breaker\n                        const failures = (state.toolFailures.get(toolCall.function.name) || 0) + 1;\n                        state.toolFailures.set(toolCall.function.name, failures);\n\n                        // Record metrics\n                        if (this.metricsCollector) {\n                            this.metricsCollector.recordToolCall(\n                                toolCall.function.name,\n                                state.iteration,\n                                toolDuration,\n                                false,\n                                (error as Error).message\n                            );\n                        }\n\n                        await strategy.onToolResult?.(toolResult, state);\n                    }\n                }\n\n            } else {\n                // No tool calls - add response and potentially end phase\n                conversation.asAssistant(response.content);\n\n                // Check if this phase requires tool calls\n                if (phase.toolUsage === 'required' && state.toolCallsExecuted === phaseStartTools) {\n                    this.logger.warn('No tools used but required in phase');\n                    // Continue to try again\n                } else if (phase.earlyExit !== false) {\n                    // Exit phase early if we got a response without tools\n                    break;\n                }\n            }\n\n            // Check phase completion conditions\n            const toolCallsInPhase = state.toolCallsExecuted - phaseStartTools;\n\n            if (phase.minToolCalls && toolCallsInPhase < phase.minToolCalls) {\n                continue;  // Need more tool calls\n            }\n\n            if (phase.maxToolCalls && toolCallsInPhase >= phase.maxToolCalls) {\n                break;  // Hit max tool calls for phase\n            }\n\n            if (phase.continueIf && !phase.continueIf(state)) {\n                break;  // Condition not met\n            }\n        }\n\n        return {\n            name: phase.name,\n            iterations: state.iteration,\n            toolCalls: state.toolCallsExecuted - phaseStartTools,\n            success: true,\n            insights: state.insights,\n        };\n    }\n}\n\n// ===== PRE-BUILT STRATEGIES =====\n\n/**\n * Factory for creating iteration strategies\n */\nexport class IterationStrategyFactory {\n    /**\n     * Investigate then respond strategy\n     * Phase 1: Use tools to gather information\n     * Phase 2: Synthesize into final answer\n     */\n    static investigateThenRespond(config: {\n        maxInvestigationSteps?: number;\n        requireMinimumTools?: number;\n        finalSynthesis?: boolean;\n    } = {}): IterationStrategy {\n        const {\n            maxInvestigationSteps = 5,\n            requireMinimumTools = 1,\n            finalSynthesis = true,\n        } = config;\n\n        return {\n            name: 'investigate-then-respond',\n            description: 'Investigate using tools, then synthesize findings',\n            maxIterations: maxInvestigationSteps + (finalSynthesis ? 1 : 0),\n            phases: [\n                {\n                    name: 'investigate',\n                    maxIterations: maxInvestigationSteps,\n                    toolUsage: 'encouraged',\n                    minToolCalls: requireMinimumTools,\n                    earlyExit: false,\n                },\n                ...(finalSynthesis ? [{\n                    name: 'respond',\n                    maxIterations: 1,\n                    toolUsage: 'forbidden' as ToolUsagePolicy,\n                    instructions: 'Based on your investigation, provide a comprehensive answer.',\n                    requireFinalAnswer: true,\n                }] : []),\n            ],\n        };\n    }\n\n    /**\n     * Multi-pass refinement strategy\n     * Generate, critique, refine repeatedly\n     */\n    static multiPassRefinement(config: {\n        passes?: number;\n        critiqueBetweenPasses?: boolean;\n        improvementThreshold?: number;\n    } = {}): IterationStrategy {\n        const {\n            passes = 3,\n            critiqueBetweenPasses = true,\n        } = config;\n\n        const phases: StrategyPhase[] = [];\n\n        for (let i = 0; i < passes; i++) {\n            phases.push({\n                name: `pass-${i + 1}`,\n                maxIterations: 1,\n                toolUsage: 'optional',\n                instructions: i === 0\n                    ? 'Generate your best response'\n                    : 'Refine your previous response based on the critique',\n            });\n\n            if (critiqueBetweenPasses && i < passes - 1) {\n                phases.push({\n                    name: `critique-${i + 1}`,\n                    maxIterations: 1,\n                    toolUsage: 'forbidden',\n                    instructions: 'Critique the previous response. What can be improved?',\n                });\n            }\n        }\n\n        return {\n            name: 'multi-pass-refinement',\n            description: 'Iteratively refine response through multiple passes',\n            maxIterations: passes * 2,\n            phases,\n        };\n    }\n\n    /**\n     * Breadth-first investigation\n     * Explore broadly before going deep\n     */\n    static breadthFirst(config: {\n        levelsDeep?: number;\n        toolsPerLevel?: number;\n    } = {}): IterationStrategy {\n        const {\n            levelsDeep = 3,\n            toolsPerLevel = 4,\n        } = config;\n\n        const phases: StrategyPhase[] = [];\n\n        for (let level = 0; level < levelsDeep; level++) {\n            phases.push({\n                name: `level-${level + 1}`,\n                maxIterations: toolsPerLevel,\n                toolUsage: 'encouraged',\n                minToolCalls: 1,\n                maxToolCalls: toolsPerLevel,\n                instructions: level === 0\n                    ? 'Get a broad overview'\n                    : `Dive deeper into areas discovered in level ${level}`,\n            });\n        }\n\n        return {\n            name: 'breadth-first',\n            description: 'Explore broadly at each level before going deeper',\n            maxIterations: levelsDeep * toolsPerLevel,\n            phases,\n        };\n    }\n\n    /**\n     * Depth-first investigation\n     * Deep dive immediately\n     */\n    static depthFirst(config: {\n        maxDepth?: number;\n        backtrackOnFailure?: boolean;\n    } = {}): IterationStrategy {\n        const {\n            maxDepth = 5,\n            backtrackOnFailure = true,\n        } = config;\n\n        return {\n            name: 'depth-first',\n            description: 'Deep dive investigation path',\n            maxIterations: maxDepth,\n            phases: [{\n                name: 'deep-dive',\n                maxIterations: maxDepth,\n                toolUsage: 'encouraged',\n                adaptiveDepth: true,\n            }],\n            shouldContinue: (state) => {\n                // Continue if making progress\n                if (backtrackOnFailure && state.errors.length > 2) {\n                    return false;\n                }\n                return true;\n            },\n        };\n    }\n\n    /**\n     * Adaptive strategy\n     * Changes behavior based on progress\n     */\n    static adaptive(_config: {\n        strategies?: IterationStrategy[];\n        switchConditions?: Array<{\n            when: (state: StrategyState) => boolean;\n            switchTo: number;\n        }>;\n    } = {}): IterationStrategy {\n        return {\n            name: 'adaptive',\n            description: 'Adapts strategy based on progress',\n            maxIterations: 20,\n            onIteration: async (iteration, state) => {\n                // Change behavior based on iteration count\n                if (iteration < 5) {\n                    // Early: broad exploration\n                    return 'continue';\n                } else if (iteration < 15) {\n                    // Mid: focused investigation\n                    return 'continue';\n                } else {\n                    // Late: wrap up\n                    return state.toolCallsExecuted > 0 ? 'continue' : 'stop';\n                }\n            },\n        };\n    }\n\n    /**\n     * Simple iteration (basic tool-use loop)\n     */\n    static simple(config: {\n        maxIterations?: number;\n        allowTools?: boolean;\n    } = {}): IterationStrategy {\n        const {\n            maxIterations = 10,\n            allowTools = true,\n        } = config;\n\n        return {\n            name: 'simple',\n            description: 'Simple iteration loop',\n            maxIterations,\n            phases: [{\n                name: 'main',\n                maxIterations,\n                toolUsage: allowTools ? 'encouraged' : 'forbidden',\n                earlyExit: true,\n            }],\n        };\n    }\n}\n\nexport default IterationStrategyFactory;\n\n"],"names":["StrategyExecutor","withReflection","config","reflectionConfig","execute","conversation","tools","strategy","startTime","Date","now","enabled","metricsCollector","MetricsCollector","logger","state","phase","iteration","toolCallsExecuted","insights","findings","errors","toolFailures","Map","info","name","context","llm","onStart","phases","maxIterations","toolUsage","phaseResults","skipIf","debug","phaseResult","executePhase","push","onPhaseComplete","shouldContinue","duration","result","finalMessage","getLastMessage","totalIterations","success","metrics","getMetrics","getMessages","getMetadata","model","generator","ReflectionReportGenerator","reflection","generate","outputPath","saveReflection","onComplete","iterations","toolCalls","error","fs","path","timestamp","toISOString","replace","filename","format","fullPath","join","mkdir","recursive","writeFile","JSON","stringify","markdown","formatMarkdown","phaseStartTools","instructions","asUser","i","incrementIteration","action","onIteration","toolsToProvide","toOpenAIFormat","undefined","response","complete","toMessages","tool_calls","length","warn","asAssistant","content","toolCall","allowedTools","includes","function","tool","maxFailures","maxConsecutiveToolFailures","consecutiveFailures","get","failures","asTool","id","circuitBreakerTriggered","toolAction","onToolCall","toolStart","toolArgs","parse","arguments","parseError","Error","message","String","cause","toolDuration","toolResult","callId","toolName","set","recordToolCall","onToolResult","errorName","earlyExit","toolCallsInPhase","minToolCalls","maxToolCalls","continueIf","wrapLogger","DEFAULT_LOGGER","IterationStrategyFactory","investigateThenRespond","maxInvestigationSteps","requireMinimumTools","finalSynthesis","description","requireFinalAnswer","multiPassRefinement","passes","critiqueBetweenPasses","breadthFirst","levelsDeep","toolsPerLevel","level","depthFirst","maxDepth","backtrackOnFailure","adaptiveDepth","adaptive","_config","simple","allowTools"],"mappings":"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"}