@framers/agentos 0.1.0

package/dist/core/planning/PlanningEngine.js

@@ -0,0 +1,783 @@
+/**
+ * @file PlanningEngine.ts
+ * @description Implementation of the AgentOS Planning Engine.
+ * Provides autonomous goal pursuit, task decomposition, and self-correcting plans
+ * using ReAct (Reasoning + Acting) and other cognitive patterns.
+ *
+ * @module AgentOS/Planning
+ * @version 1.0.0
+ *
+ * @example
+ * ```typescript
+ * import { PlanningEngine } from '../../core/planning/index.js';
+ *
+ * const engine = new PlanningEngine({
+ *   llmProvider: aiModelProviderManager,
+ *   defaultModelId: 'gpt-4-turbo',
+ * });
+ *
+ * const plan = await engine.generatePlan('Build a web scraper', {
+ *   strategy: 'react',
+ *   maxSteps: 10,
+ * });
+ * ```
+ */
+import { uuidv4 } from '../../utils/uuid.js';
+/**
+ * Prompt templates for planning operations.
+ */
+const PLANNING_PROMPTS = {
+    generatePlan: `You are an expert planning agent. Generate a detailed step-by-step plan to achieve the following goal.
+
+GOAL: {goal}
+
+CONTEXT:
+{context}
+
+AVAILABLE TOOLS:
+{tools}
+
+CONSTRAINTS:
+- Maximum {maxSteps} steps
+- Strategy: {strategy}
+- {additionalConstraints}
+
+Generate a plan in the following JSON format:
+{
+  "reasoning": "Your chain-of-thought reasoning for the plan",
+  "steps": [
+    {
+      "action": {
+        "type": "tool_call|reasoning|information_gathering|synthesis|validation",
+        "toolId": "tool_name (if tool_call)",
+        "toolArgs": { "arg": "value" },
+        "content": "description of the action"
+      },
+      "reasoning": "Why this step is needed",
+      "expectedOutcome": "What this step should produce",
+      "dependsOn": ["step_ids"],
+      "estimatedTokens": 100,
+      "confidence": 0.85
+    }
+  ],
+  "overallConfidence": 0.8
+}`,
+    decomposeTask: `Decompose the following complex task into simpler subtasks that can be executed independently or in sequence.
+
+TASK: {task}
+
+Provide a decomposition in JSON format:
+{
+  "reasoning": "How you broke down the task",
+  "subtasks": [
+    {
+      "description": "Subtask description",
+      "complexity": 1-10,
+      "dependsOn": ["subtask_ids"],
+      "estimatedTokens": 100,
+      "parallelizable": true|false
+    }
+  ],
+  "executionOrder": ["subtask_ids in order"]
+}`,
+    reflect: `Reflect on the current execution state and provide insights.
+
+GOAL: {goal}
+PLAN: {plan}
+COMPLETED STEPS: {completedSteps}
+CURRENT RESULTS: {results}
+ISSUES ENCOUNTERED: {issues}
+
+Analyze the execution and provide:
+{
+  "insights": ["Key observations"],
+  "issues": ["Problems identified"],
+  "adjustments": [
+    {
+      "type": "add_step|remove_step|modify_step|reorder",
+      "targetStepId": "id",
+      "reason": "Why this change"
+    }
+  ],
+  "confidenceAdjustment": 0.1 (positive or negative),
+  "recommendation": "continue|adjust|replan|abort"
+}`,
+    reactStep: `You are executing a plan step using the ReAct pattern.
+
+GOAL: {goal}
+CURRENT STEP: {step}
+PREVIOUS RESULTS: {previousResults}
+CONTEXT: {context}
+
+Think through this step:
+1. THOUGHT: What needs to be done and why
+2. ACTION: The specific action to take
+3. OBSERVATION: (Will be filled after execution)
+
+Respond with your thought and action plan in JSON:
+{
+  "thought": "Your reasoning",
+  "action": {
+    "type": "tool_call|reasoning|synthesis",
+    "details": { ... }
+  },
+  "expectedObservation": "What you expect to see"
+}`,
+};
+// ============================================================================
+// PlanningEngine Implementation
+// ============================================================================
+/**
+ * Implementation of the AgentOS Planning Engine.
+ *
+ * Features:
+ * - ReAct (Reasoning + Acting) pattern for interleaved planning and execution
+ * - Plan-and-Execute for upfront planning
+ * - Tree-of-Thought for exploring multiple reasoning paths
+ * - Self-reflection and plan refinement
+ * - Checkpoint and rollback support
+ * - Human-in-the-loop integration points
+ *
+ * @implements {IPlanningEngine}
+ */
+export class PlanningEngine {
+    /**
+     * Creates a new PlanningEngine instance.
+     *
+     * @param config - Engine configuration
+     */
+    constructor(config) {
+        /** Active execution states keyed by planId */
+        this.executionStates = new Map();
+        /** Saved checkpoints keyed by checkpointId */
+        this.checkpoints = new Map();
+        this.llmProvider = config.llmProvider;
+        this.defaultModelId = config.defaultModelId ?? 'gpt-4-turbo';
+        this.defaultProviderId = config.defaultProviderId;
+        this.logger = config.logger;
+        this.defaultOptions = {
+            maxSteps: 15,
+            maxIterations: 5,
+            minConfidence: 0.6,
+            allowToolUse: true,
+            strategy: 'react',
+            enableCheckpoints: true,
+            checkpointFrequency: 5,
+            maxTotalTokens: 100000,
+            planningTimeoutMs: 60000,
+            ...config.defaultOptions,
+        };
+    }
+    // ==========================================================================
+    // Plan Generation
+    // ==========================================================================
+    /**
+     * Generates a multi-step execution plan from a high-level goal.
+     *
+     * @param goal - The high-level goal to achieve
+     * @param context - Additional context for planning
+     * @param options - Planning configuration options
+     * @returns Generated execution plan
+     */
+    async generatePlan(goal, context, options) {
+        const opts = { ...this.defaultOptions, ...options };
+        const startTime = Date.now();
+        this.logger?.info?.('Generating execution plan', { goal, strategy: opts.strategy });
+        try {
+            // Build the planning prompt
+            const prompt = this.buildPlanningPrompt(goal, context, opts);
+            // Generate plan using LLM
+            const response = await this.callLLM(prompt, { jsonMode: true });
+            const planData = JSON.parse(response);
+            // Build the execution plan
+            const plan = this.buildExecutionPlan(goal, planData, opts, startTime);
+            // Validate the generated plan
+            const validation = await this.validatePlan(plan);
+            if (!validation.isValid) {
+                this.logger?.warn?.('Generated plan has validation issues', {
+                    planId: plan.planId,
+                    issues: validation.issues,
+                });
+            }
+            this.logger?.info?.('Plan generated successfully', {
+                planId: plan.planId,
+                steps: plan.steps.length,
+                confidence: plan.confidenceScore,
+            });
+            return plan;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.error?.('Failed to generate plan', { goal, error: errorMessage });
+            throw new Error(`Planning failed: ${errorMessage}`);
+        }
+    }
+    /**
+     * Decomposes a complex task into simpler subtasks.
+     *
+     * @param task - The task description to decompose
+     * @param depth - Maximum decomposition depth
+     * @returns Task decomposition result
+     */
+    async decomposeTask(task, depth = 3) {
+        this.logger?.debug?.('Decomposing task', { task, depth });
+        const prompt = PLANNING_PROMPTS.decomposeTask.replace('{task}', task);
+        const response = await this.callLLM(prompt, { jsonMode: true });
+        const data = JSON.parse(response);
+        const subtasks = data.subtasks.map((st, idx) => ({
+            subtaskId: `subtask-${idx}-${uuidv4().slice(0, 8)}`,
+            description: st.description,
+            complexity: st.complexity,
+            dependsOn: st.dependsOn ?? [],
+            estimatedTokens: st.estimatedTokens ?? 500,
+            parallelizable: st.parallelizable ?? false,
+        }));
+        return {
+            originalTask: task,
+            subtasks,
+            reasoning: data.reasoning,
+            isComplete: true,
+            executionOrder: data.executionOrder ?? subtasks.map((st) => st.subtaskId),
+        };
+    }
+    /**
+     * Validates a plan for feasibility and completeness.
+     *
+     * @param plan - Plan to validate
+     * @returns Validation result with any issues found
+     */
+    async validatePlan(plan) {
+        const issues = [];
+        const suggestions = [];
+        // Check for empty plan
+        if (plan.steps.length === 0) {
+            issues.push({
+                severity: 'error',
+                message: 'Plan has no steps',
+                suggestedFix: 'Regenerate plan with clearer goal',
+            });
+        }
+        // Check for circular dependencies
+        const visited = new Set();
+        const recursionStack = new Set();
+        const hasCycle = (stepId) => {
+            if (recursionStack.has(stepId))
+                return true;
+            if (visited.has(stepId))
+                return false;
+            visited.add(stepId);
+            recursionStack.add(stepId);
+            const deps = plan.dependencies.get(stepId) ?? [];
+            for (const dep of deps) {
+                if (hasCycle(dep))
+                    return true;
+            }
+            recursionStack.delete(stepId);
+            return false;
+        };
+        for (const step of plan.steps) {
+            if (hasCycle(step.stepId)) {
+                issues.push({
+                    severity: 'error',
+                    stepId: step.stepId,
+                    message: 'Circular dependency detected',
+                    suggestedFix: 'Remove or restructure dependent steps',
+                });
+                break;
+            }
+        }
+        // Check confidence scores
+        const lowConfidenceSteps = plan.steps.filter((s) => s.confidence < 0.5);
+        if (lowConfidenceSteps.length > 0) {
+            issues.push({
+                severity: 'warning',
+                message: `${lowConfidenceSteps.length} steps have low confidence (<0.5)`,
+                suggestedFix: 'Consider adding validation steps or gathering more context',
+            });
+        }
+        // Check for missing tool references
+        for (const step of plan.steps) {
+            if (step.action.type === 'tool_call' && !step.action.toolId) {
+                issues.push({
+                    severity: 'error',
+                    stepId: step.stepId,
+                    message: 'Tool call step missing toolId',
+                    suggestedFix: 'Specify the tool to be called',
+                });
+            }
+        }
+        // Suggestions
+        if (plan.steps.length > 10) {
+            suggestions.push('Consider breaking this plan into phases for better manageability');
+        }
+        if (plan.confidenceScore < 0.7) {
+            suggestions.push('Overall confidence is moderate - consider adding validation checkpoints');
+        }
+        return {
+            isValid: issues.filter((i) => i.severity === 'error').length === 0,
+            issues,
+            suggestions,
+        };
+    }
+    // ==========================================================================
+    // Plan Refinement
+    // ==========================================================================
+    /**
+     * Refines an existing plan based on execution feedback.
+     *
+     * @param plan - Original plan to refine
+     * @param feedback - Feedback from execution
+     * @returns Refined execution plan
+     */
+    async refinePlan(plan, feedback) {
+        this.logger?.info?.('Refining plan based on feedback', {
+            planId: plan.planId,
+            feedbackType: feedback.feedbackType,
+        });
+        // Get current execution state
+        const state = this.executionStates.get(plan.planId);
+        // Perform reflection
+        const reflection = await this.reflect(plan, state ?? this.createInitialState(plan));
+        // Apply adjustments based on reflection
+        let refinedPlan = { ...plan };
+        for (const adjustment of reflection.adjustments) {
+            refinedPlan = this.applyAdjustment(refinedPlan, adjustment);
+        }
+        // Update confidence
+        refinedPlan.confidenceScore = Math.max(0.1, Math.min(1.0, refinedPlan.confidenceScore + reflection.confidenceAdjustment));
+        // Update metadata
+        refinedPlan.metadata.iterations++;
+        this.logger?.info?.('Plan refined', {
+            planId: refinedPlan.planId,
+            adjustments: reflection.adjustments.length,
+            newConfidence: refinedPlan.confidenceScore,
+        });
+        return refinedPlan;
+    }
+    /**
+     * Performs self-reflection on plan execution state.
+     *
+     * @param plan - Current plan
+     * @param executionState - Current execution state
+     * @returns Reflection insights and suggested adjustments
+     */
+    async reflect(plan, executionState) {
+        const completedSteps = plan.steps.filter((s) => executionState.completedSteps.includes(s.stepId));
+        const failedSteps = plan.steps.filter((s) => executionState.failedSteps.includes(s.stepId));
+        const resultsStr = Array.from(executionState.results.entries())
+            .map(([id, result]) => `${id}: ${result.success ? 'Success' : 'Failed'} - ${JSON.stringify(result.output)}`)
+            .join('\n');
+        const prompt = PLANNING_PROMPTS.reflect
+            .replace('{goal}', plan.goal)
+            .replace('{plan}', JSON.stringify(plan.steps.map((s) => s.action)))
+            .replace('{completedSteps}', completedSteps.map((s) => s.stepId).join(', '))
+            .replace('{results}', resultsStr)
+            .replace('{issues}', failedSteps.map((s) => `Step ${s.stepId} failed`).join(', '));
+        const response = await this.callLLM(prompt, { jsonMode: true });
+        const data = JSON.parse(response);
+        return {
+            insights: data.insights ?? [],
+            issues: data.issues ?? [],
+            adjustments: (data.adjustments ?? []).map((adj) => ({
+                type: adj.type,
+                targetStepId: adj.targetStepId,
+                reason: adj.reason,
+            })),
+            confidenceAdjustment: data.confidenceAdjustment ?? 0,
+            recommendation: data.recommendation ?? 'continue',
+        };
+    }
+    // ==========================================================================
+    // Execution
+    // ==========================================================================
+    /**
+     * Executes a single plan step.
+     *
+     * @param step - Step to execute
+     * @param context - Execution context
+     * @returns Step execution result
+     */
+    async executeStep(step, context) {
+        const startTime = Date.now();
+        this.logger?.debug?.('Executing step', { stepId: step.stepId, action: step.action.type });
+        try {
+            let output;
+            const tokensUsed = 0;
+            const observations = [];
+            switch (step.action.type) {
+                case 'tool_call':
+                    if (step.action.toolId && context?.tools) {
+                        const tool = context.tools.find((t) => t.id === step.action.toolId);
+                        if (tool) {
+                            const toolResult = await tool.execute(step.action.toolArgs ?? {}, {
+                                gmiId: 'planning-engine',
+                                personaId: 'planner',
+                                userContext: { userId: 'system' },
+                            });
+                            output = toolResult.output;
+                            observations.push(`Tool ${tool.name} executed: ${toolResult.success ? 'success' : 'failed'}`);
+                        }
+                        else {
+                            throw new Error(`Tool ${step.action.toolId} not found`);
+                        }
+                    }
+                    break;
+                case 'reasoning': {
+                    const reasoningPrompt = `Reason through: ${step.action.content}\n\nPrevious context: ${JSON.stringify(context?.previousResults)}`;
+                    output = await this.callLLM(reasoningPrompt);
+                    observations.push('Reasoning step completed');
+                    break;
+                }
+                case 'information_gathering':
+                    if (context?.retrieve && step.action.query) {
+                        const retrieved = await context.retrieve(step.action.query);
+                        output = retrieved;
+                        observations.push(`Retrieved ${retrieved.length} relevant items`);
+                    }
+                    break;
+                case 'synthesis': {
+                    const synthesisPrompt = `Synthesize the following results into a coherent output:\n${JSON.stringify(context?.previousResults)}\n\nContext: ${step.action.content}`;
+                    output = await this.callLLM(synthesisPrompt);
+                    observations.push('Synthesis completed');
+                    break;
+                }
+                case 'validation': {
+                    const validationPrompt = `Validate the following output against expected criteria:\nOutput: ${JSON.stringify(context?.previousResults)}\nCriteria: ${step.action.content}`;
+                    output = await this.callLLM(validationPrompt, { jsonMode: true });
+                    observations.push('Validation completed');
+                    break;
+                }
+                default:
+                    output = { message: 'Step type not implemented', type: step.action.type };
+            }
+            return {
+                success: true,
+                output,
+                tokensUsed,
+                durationMs: Date.now() - startTime,
+                observations,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.error?.('Step execution failed', { stepId: step.stepId, error: errorMessage });
+            return {
+                success: false,
+                output: null,
+                error: errorMessage,
+                tokensUsed: 0,
+                durationMs: Date.now() - startTime,
+                observations: [`Error: ${errorMessage}`],
+            };
+        }
+    }
+    /**
+     * Runs an autonomous goal pursuit loop.
+     *
+     * @param goal - Goal to pursue
+     * @param options - Loop configuration
+     * @yields Progress updates
+     * @returns Final execution summary
+     */
+    async *runAutonomousLoop(goal, options) {
+        const opts = {
+            maxIterations: options?.maxIterations ?? 20,
+            goalConfidenceThreshold: options?.goalConfidenceThreshold ?? 0.9,
+            enableReflection: options?.enableReflection ?? true,
+            reflectionFrequency: options?.reflectionFrequency ?? 3,
+            requireApprovalFor: options?.requireApprovalFor ?? ['human_input'],
+            onProgress: options?.onProgress ?? (() => { }),
+            onApprovalRequired: options?.onApprovalRequired ?? (async () => true),
+        };
+        const startTime = Date.now();
+        let tokensUsed = 0;
+        const allObservations = [];
+        let iteration = 0;
+        let goalConfidence = 0;
+        let currentPlan = null;
+        this.logger?.info?.('Starting autonomous loop', { goal, maxIterations: opts.maxIterations });
+        try {
+            // Generate initial plan
+            currentPlan = await this.generatePlan(goal, {}, { strategy: 'react' });
+            const state = this.createInitialState(currentPlan);
+            this.executionStates.set(currentPlan.planId, state);
+            while (iteration < opts.maxIterations && goalConfidence < opts.goalConfidenceThreshold) {
+                iteration++;
+                // Get next ready step
+                const nextStep = this.getNextReadyStep(currentPlan, state);
+                if (!nextStep) {
+                    // All steps complete or blocked
+                    goalConfidence = currentPlan.confidenceScore;
+                    break;
+                }
+                // Check if approval required
+                if (opts.requireApprovalFor.includes(nextStep.action.type)) {
+                    const approved = await opts.onApprovalRequired({
+                        requestId: uuidv4(),
+                        step: nextStep,
+                        reason: `Action type ${nextStep.action.type} requires approval`,
+                        suggestedAction: 'approve',
+                        timeoutMs: 30000,
+                    });
+                    if (!approved) {
+                        state.failedSteps.push(nextStep.stepId);
+                        continue;
+                    }
+                }
+                // Execute step
+                const result = await this.executeStep(nextStep, {
+                    previousResults: state.results,
+                    tools: [],
+                });
+                // Update state
+                state.results.set(nextStep.stepId, result);
+                if (result.success) {
+                    state.completedSteps.push(nextStep.stepId);
+                }
+                else {
+                    state.failedSteps.push(nextStep.stepId);
+                }
+                state.tokensUsed += result.tokensUsed;
+                tokensUsed += result.tokensUsed;
+                allObservations.push(...result.observations);
+                state.lastUpdatedAt = new Date();
+                // Calculate progress
+                const progress = state.completedSteps.length / currentPlan.steps.length;
+                goalConfidence = progress * currentPlan.confidenceScore;
+                // Yield progress
+                const loopProgress = {
+                    iteration,
+                    currentStep: nextStep,
+                    progress,
+                    observations: allObservations,
+                    goalConfidence,
+                    tokensUsed,
+                };
+                opts.onProgress(loopProgress);
+                yield loopProgress;
+                // Reflection at intervals
+                if (opts.enableReflection && iteration % opts.reflectionFrequency === 0) {
+                    const reflection = await this.reflect(currentPlan, state);
+                    if (reflection.recommendation === 'replan') {
+                        currentPlan = await this.generatePlan(goal, {
+                            failedApproaches: state.failedSteps.map((id) => `Step ${id} failed`),
+                        });
+                        state.currentStepIndex = 0;
+                    }
+                    else if (reflection.recommendation === 'abort') {
+                        break;
+                    }
+                }
+            }
+            // Generate final summary
+            const summary = {
+                goalAchieved: goalConfidence >= opts.goalConfidenceThreshold,
+                finalConfidence: goalConfidence,
+                iterations: iteration,
+                totalTokensUsed: tokensUsed,
+                totalDurationMs: Date.now() - startTime,
+                outcomes: allObservations.slice(-10),
+                unresolvedIssues: state.failedSteps.map((id) => `Step ${id} failed`),
+            };
+            this.logger?.info?.('Autonomous loop completed', summary);
+            return summary;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.error?.('Autonomous loop failed', { goal, error: errorMessage });
+            return {
+                goalAchieved: false,
+                finalConfidence: 0,
+                iterations: iteration,
+                totalTokensUsed: tokensUsed,
+                totalDurationMs: Date.now() - startTime,
+                outcomes: [],
+                unresolvedIssues: [errorMessage],
+            };
+        }
+    }
+    // ==========================================================================
+    // State Management
+    // ==========================================================================
+    /**
+     * Saves current execution state for checkpointing.
+     *
+     * @param plan - Plan being executed
+     * @param state - Current execution state
+     * @returns Checkpoint identifier
+     */
+    async saveCheckpoint(plan, state) {
+        const checkpointId = `checkpoint-${plan.planId}-${Date.now()}`;
+        this.checkpoints.set(checkpointId, {
+            plan: JSON.parse(JSON.stringify(plan)),
+            state: {
+                ...state,
+                results: new Map(state.results),
+            },
+        });
+        this.logger?.debug?.('Checkpoint saved', { checkpointId, planId: plan.planId });
+        return checkpointId;
+    }
+    /**
+     * Restores execution state from a checkpoint.
+     *
+     * @param checkpointId - Checkpoint to restore
+     * @returns Restored plan and state
+     */
+    async restoreCheckpoint(checkpointId) {
+        const checkpoint = this.checkpoints.get(checkpointId);
+        if (!checkpoint) {
+            throw new Error(`Checkpoint ${checkpointId} not found`);
+        }
+        this.logger?.debug?.('Checkpoint restored', { checkpointId });
+        return {
+            plan: JSON.parse(JSON.stringify(checkpoint.plan)),
+            state: {
+                ...checkpoint.state,
+                results: new Map(checkpoint.state.results),
+            },
+        };
+    }
+    /**
+     * Gets the current execution state for a plan.
+     *
+     * @param planId - Plan identifier
+     * @returns Current execution state or null
+     */
+    getExecutionState(planId) {
+        return this.executionStates.get(planId) ?? null;
+    }
+    // ==========================================================================
+    // Private Helpers
+    // ==========================================================================
+    buildPlanningPrompt(goal, context, options) {
+        const toolsStr = options.availableTools
+            ? options.availableTools.map((t) => `- ${t.name}: ${t.description}`).join('\n')
+            : 'No tools available';
+        const contextStr = [
+            context?.conversationHistory && `Conversation: ${context.conversationHistory}`,
+            context?.retrievedContext && `Retrieved Context: ${context.retrievedContext}`,
+            context?.domainContext && `Domain: ${context.domainContext}`,
+            context?.userConstraints?.length && `Constraints: ${context.userConstraints.join(', ')}`,
+        ]
+            .filter(Boolean)
+            .join('\n');
+        return PLANNING_PROMPTS.generatePlan
+            .replace('{goal}', goal)
+            .replace('{context}', contextStr || 'No additional context')
+            .replace('{tools}', toolsStr)
+            .replace('{maxSteps}', String(options.maxSteps))
+            .replace('{strategy}', options.strategy ?? 'react')
+            .replace('{additionalConstraints}', options.allowToolUse ? 'Tool use is allowed' : 'No tool use');
+    }
+    buildExecutionPlan(goal, planData, options, startTime) {
+        const planId = `plan-${uuidv4()}`;
+        const steps = [];
+        const dependencies = new Map();
+        const rawSteps = planData.steps;
+        let totalEstimatedTokens = 0;
+        for (let i = 0; i < rawSteps.length; i++) {
+            const rawStep = rawSteps[i];
+            const stepId = `step-${i}-${uuidv4().slice(0, 8)}`;
+            const action = rawStep.action;
+            const step = {
+                stepId,
+                index: i,
+                action: {
+                    type: action.type ?? 'reasoning',
+                    toolId: action.toolId,
+                    toolArgs: action.toolArgs,
+                    content: action.content ?? '',
+                },
+                reasoning: rawStep.reasoning ?? '',
+                expectedOutcome: rawStep.expectedOutcome ?? '',
+                dependsOn: rawStep.dependsOn ?? [],
+                estimatedTokens: rawStep.estimatedTokens ?? 500,
+                confidence: rawStep.confidence ?? 0.7,
+                requiresHumanApproval: action.type === 'human_input',
+                status: 'pending',
+            };
+            steps.push(step);
+            dependencies.set(stepId, step.dependsOn);
+            totalEstimatedTokens += step.estimatedTokens;
+        }
+        return {
+            planId,
+            goal,
+            steps,
+            dependencies,
+            estimatedTokens: totalEstimatedTokens,
+            confidenceScore: planData.overallConfidence ?? 0.7,
+            createdAt: new Date(),
+            strategy: options.strategy ?? 'react',
+            metadata: {
+                modelId: this.defaultModelId,
+                iterations: 1,
+                planningDurationMs: Date.now() - startTime,
+                alternativesConsidered: 1,
+            },
+        };
+    }
+    createInitialState(plan) {
+        return {
+            planId: plan.planId,
+            currentStepIndex: 0,
+            completedSteps: [],
+            failedSteps: [],
+            results: new Map(),
+            tokensUsed: 0,
+            startedAt: new Date(),
+            lastUpdatedAt: new Date(),
+        };
+    }
+    getNextReadyStep(plan, state) {
+        for (const step of plan.steps) {
+            if (state.completedSteps.includes(step.stepId))
+                continue;
+            if (state.failedSteps.includes(step.stepId))
+                continue;
+            // Check if dependencies are met
+            const depsmet = step.dependsOn.every((depId) => state.completedSteps.includes(depId));
+            if (depsmet) {
+                return step;
+            }
+        }
+        return null;
+    }
+    applyAdjustment(plan, adjustment) {
+        const newPlan = { ...plan, steps: [...plan.steps] };
+        switch (adjustment.type) {
+            case 'remove_step':
+                if (adjustment.targetStepId) {
+                    newPlan.steps = newPlan.steps.filter((s) => s.stepId !== adjustment.targetStepId);
+                }
+                break;
+            case 'modify_step':
+                if (adjustment.targetStepId && adjustment.newStepData) {
+                    const idx = newPlan.steps.findIndex((s) => s.stepId === adjustment.targetStepId);
+                    if (idx >= 0) {
+                        newPlan.steps[idx] = { ...newPlan.steps[idx], ...adjustment.newStepData };
+                    }
+                }
+                break;
+            // Add other adjustment types as needed
+        }
+        return newPlan;
+    }
+    async callLLM(prompt, options) {
+        const messages = [{ role: 'user', content: prompt }];
+        const providerId = this.defaultProviderId ?? 'openai';
+        const provider = this.llmProvider.getProvider(providerId);
+        if (!provider) {
+            throw new Error(`Provider "${providerId}" not found`);
+        }
+        const response = await provider.generateCompletion(this.defaultModelId, messages, {
+            temperature: 0.7,
+            maxTokens: 4000,
+            responseFormat: options?.jsonMode ? { type: 'json_object' } : undefined,
+        });
+        const content = response.choices?.[0]?.message?.content;
+        return typeof content === 'string' ? content : '';
+    }
+}
+//# sourceMappingURL=PlanningEngine.js.map