@cogitator-ai/self-modifying 17.0.17 → 18.0.0

package/dist/self-modifying-agent.js

@@ -1,29 +1,41 @@
+import { nanoid } from 'nanoid';
+import { DEFAULT_META_REASONING_CONFIG } from '@cogitator-ai/types';
 import { SelfModifyingEventEmitter } from './events/index.js';
 import { GapAnalyzer, ToolGenerator, InMemoryGeneratedToolStore } from './tool-generation/index.js';
 import { MetaReasoner } from './meta-reasoning/index.js';
-import { ParameterOptimizer, CapabilityAnalyzer } from './architecture-evolution/index.js';
+import { ParameterOptimizer } from './architecture-evolution/index.js';
 import { ModificationValidator, RollbackManager, DEFAULT_SAFETY_CONSTRAINTS, DEFAULT_CAPABILITY_CONSTRAINTS, DEFAULT_RESOURCE_CONSTRAINTS, } from './constraints/index.js';
+const DEFAULT_TOOL_TIMEOUT_MS = 30_000;
+function resolveModelName(model, provider) {
+    if (!model)
+        return 'default';
+    const prefix = `${provider}/`;
+    return model.startsWith(prefix) ? model.slice(prefix.length) : model;
+}
+const DEFAULT_MAX_TOOL_ROUNDS = 10;
 export class SelfModifyingAgent {
     agent;
     llm;
+    modelName;
     config;
     emitter = new SelfModifyingEventEmitter();
+    listenerWrappers = new Map();
     gapAnalyzer;
     toolGenerator;
     toolStore;
     metaReasoner;
     parameterOptimizer;
-    capabilityAnalyzer;
     modificationValidator;
     rollbackManager;
     currentContext = null;
-    isInitialized = false;
+    runQueue = Promise.resolve();
     constructor(options) {
         this.agent = options.agent;
         this.llm = options.llm;
+        this.modelName = resolveModelName(options.agent.model, options.llm.provider);
         this.config = this.mergeConfig(options.config);
         const toolGenConfig = this.config.toolGeneration;
-        const agentModel = this.agent.model;
+        const agentModel = this.modelName;
         this.gapAnalyzer = new GapAnalyzer({ llm: this.llm, config: toolGenConfig, model: agentModel });
         this.toolGenerator = new ToolGenerator({
             llm: this.llm,
@@ -33,32 +45,28 @@ export class SelfModifyingAgent {
         this.toolStore = new InMemoryGeneratedToolStore();
         this.metaReasoner = new MetaReasoner({
             llm: this.llm,
-            model: agentModel ?? 'default',
+            model: agentModel,
             config: this.config.metaReasoning,
         });
-        const baseArchConfig = {
-            model: agentModel ?? 'default',
-            temperature: 0.7,
-            maxTokens: 4096,
-            toolStrategy: 'sequential',
-            reflectionDepth: 1,
-        };
         this.parameterOptimizer = new ParameterOptimizer({
             llm: this.llm,
             config: this.config.architectureEvolution,
-            baseConfig: baseArchConfig,
-            model: agentModel,
-        });
-        this.capabilityAnalyzer = new CapabilityAnalyzer({
-            llm: this.llm,
-            enableLLMAnalysis: true,
+            baseConfig: this.createBaseArchitectureConfig(),
             model: agentModel,
+            availableModels: options.availableModels,
         });
         this.modificationValidator = new ModificationValidator({
             constraints: {
-                safety: DEFAULT_SAFETY_CONSTRAINTS,
-                capability: DEFAULT_CAPABILITY_CONSTRAINTS,
-                resource: DEFAULT_RESOURCE_CONSTRAINTS,
+                safety: [...DEFAULT_SAFETY_CONSTRAINTS, ...(options.modificationConstraints?.safety ?? [])],
+                capability: [
+                    ...DEFAULT_CAPABILITY_CONSTRAINTS,
+                    ...(options.modificationConstraints?.capability ?? []),
+                ],
+                resource: [
+                    ...DEFAULT_RESOURCE_CONSTRAINTS,
+                    ...(options.modificationConstraints?.resource ?? []),
+                ],
+                custom: options.modificationConstraints?.custom,
             },
         });
         this.rollbackManager = new RollbackManager({
@@ -66,126 +74,37 @@ export class SelfModifyingAgent {
         });
     }
     on(event, handler) {
-        this.emitter.on(event, handler);
+        let wrappers = this.listenerWrappers.get(event);
+        if (!wrappers) {
+            wrappers = new Map();
+            this.listenerWrappers.set(event, wrappers);
+        }
+        const existing = wrappers.get(handler);
+        if (existing)
+            this.emitter.off(event, existing);
+        const wrapped = (e) => handler(e);
+        wrappers.set(handler, wrapped);
+        this.emitter.on(event, wrapped);
+        return () => this.off(event, handler);
     }
     off(event, handler) {
-        this.emitter.off(event, handler);
+        const wrappers = this.listenerWrappers.get(event);
+        const wrapped = wrappers?.get(handler);
+        if (!wrappers || !wrapped)
+            return;
+        this.emitter.off(event, wrapped);
+        wrappers.delete(handler);
     }
-    async run(input) {
-        await this.ensureInitialized();
-        const runId = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        const tools = this.getAvailableTools();
-        const baseConfig = {
-            model: 'default',
-            temperature: 0.7,
-            maxTokens: 4096,
-            toolStrategy: 'sequential',
-            reflectionDepth: 1,
-        };
-        this.currentContext = {
-            runId,
-            input,
-            startTime: Date.now(),
-            tools: [...tools],
-            currentConfig: baseConfig,
-            generatedTools: [],
-            observations: [],
-            adaptations: [],
-            checkpoints: [],
-        };
-        void this.emitter.emit({
-            type: 'run_started',
-            runId,
-            timestamp: new Date(),
-            data: { input },
-        });
-        try {
-            if (this.config.architectureEvolution.enabled) {
-                await this.optimizeArchitecture(input);
-            }
-            if (this.config.toolGeneration.enabled && this.config.toolGeneration.autoGenerate) {
-                await this.analyzeAndGenerateTools(input);
-            }
-            const modeConfig = this.metaReasoner.initializeRun(runId);
-            void this.emitter.emit({
-                type: 'strategy_changed',
-                runId,
-                timestamp: new Date(),
-                data: {
-                    previousMode: 'analytical',
-                    newMode: modeConfig.mode,
-                    reason: 'Initial mode selection',
-                },
-            });
-            const output = await this.executeWithMetaReasoning(input, runId);
-            const result = {
-                output,
-                toolsGenerated: [...this.currentContext.generatedTools],
-                adaptationsMade: [...this.currentContext.adaptations],
-                finalConfig: { ...this.currentContext.currentConfig },
-            };
-            void this.emitter.emit({
-                type: 'run_completed',
-                runId,
-                timestamp: new Date(),
-                data: {
-                    success: true,
-                    toolsGenerated: result.toolsGenerated.length,
-                    adaptationsMade: result.adaptationsMade.length,
-                },
-            });
-            return result;
-        }
-        catch (error) {
-            void this.emitter.emit({
-                type: 'run_completed',
-                runId,
-                timestamp: new Date(),
-                data: {
-                    success: false,
-                    error: error instanceof Error ? error.message : String(error),
-                },
-            });
-            throw error;
-        }
-        finally {
-            this.metaReasoner.cleanupRun(runId);
-            this.currentContext = null;
-        }
+    run(input) {
+        const result = this.runQueue.then(() => this.executeRun(input));
+        this.runQueue = result.catch(() => undefined);
+        return result;
     }
     async generateTool(gap) {
         if (!this.config.toolGeneration.enabled) {
             return null;
         }
-        const tools = this.getAvailableTools();
-        const result = await this.toolGenerator.generate(gap, tools);
-        if (result.success && result.tool) {
-            await this.toolStore.save(result.tool);
-            void this.emitter.emit({
-                type: 'tool_generation_completed',
-                runId: this.currentContext?.runId || 'manual',
-                timestamp: new Date(),
-                data: {
-                    toolId: result.tool.id,
-                    name: result.tool.name,
-                    success: true,
-                    iterations: result.iterations,
-                },
-            });
-            return result.tool;
-        }
-        void this.emitter.emit({
-            type: 'tool_generation_completed',
-            runId: this.currentContext?.runId || 'manual',
-            timestamp: new Date(),
-            data: {
-                toolId: '',
-                name: gap.suggestedToolName,
-                success: false,
-                error: result.error,
-            },
-        });
-        return null;
+        return this.generateAndRegisterTool(gap, this.currentContext?.tools ?? this.getAgentTools());
     }
     async recordToolUsage(toolId, success, executionTime) {
         await this.toolStore.recordUsage({
@@ -199,48 +118,131 @@ export class SelfModifyingAgent {
         return this.toolStore.list({ status: 'active' });
     }
     async createCheckpoint() {
-        if (!this.currentContext)
+        const ctx = this.currentContext;
+        if (!ctx)
             return null;
         const agentConfig = {
             name: this.agent.name || 'agent',
-            model: this.currentContext.currentConfig.model,
+            model: ctx.currentConfig.model,
             instructions: this.agent.instructions || '',
-            temperature: this.currentContext.currentConfig.temperature,
-            maxTokens: this.currentContext.currentConfig.maxTokens,
+            temperature: ctx.currentConfig.temperature,
+            maxTokens: ctx.currentConfig.maxTokens,
         };
-        const checkpoint = await this.rollbackManager.createCheckpoint(this.agent.name || 'agent', agentConfig, this.currentContext.tools, []);
-        this.currentContext.checkpoints.push(checkpoint);
-        void this.emitter.emit({
-            type: 'checkpoint_created',
-            runId: this.currentContext.runId,
-            timestamp: new Date(),
-            data: { checkpointId: checkpoint.id },
-        });
+        const checkpoint = await this.rollbackManager.createCheckpoint(this.agent.name || 'agent', agentConfig, ctx.tools, [...ctx.appliedModifications]);
+        ctx.checkpoints.push(checkpoint);
+        this.emit('checkpoint_created', ctx.runId, { checkpointId: checkpoint.id });
         return checkpoint;
     }
-    async rollbackToCheckpoint(checkpointId) {
+    async rollbackToCheckpoint(checkpointId, reason = 'Manual rollback') {
+        const checkpoint = await this.rollbackManager.getCheckpoint(checkpointId);
         const restored = await this.rollbackManager.rollbackTo(checkpointId);
-        if (!restored)
+        if (!checkpoint || !restored)
             return false;
-        if (this.currentContext) {
-            this.currentContext.tools = restored.tools;
+        const ctx = this.currentContext;
+        if (ctx) {
+            ctx.tools = restored.tools;
+            ctx.currentConfig = {
+                ...ctx.currentConfig,
+                model: restored.agentConfig.model ?? ctx.currentConfig.model,
+                temperature: restored.agentConfig.temperature ?? ctx.currentConfig.temperature,
+                maxTokens: restored.agentConfig.maxTokens ?? ctx.currentConfig.maxTokens,
+            };
+            ctx.appliedModifications = [...checkpoint.modifications];
+            const restoredNames = new Set(restored.tools.map((t) => t.name));
+            const discarded = ctx.generatedTools.filter((t) => !restoredNames.has(t.name));
+            for (const tool of discarded) {
+                await this.toolStore.deprecate(tool.id, `Rolled back to checkpoint ${checkpointId}`);
+            }
+            ctx.generatedTools = ctx.generatedTools.filter((t) => restoredNames.has(t.name));
         }
+        this.emit('rollback_performed', ctx?.runId ?? 'manual', { checkpointId, reason });
+        return true;
+    }
+    async executeRun(input) {
+        const runId = `run_${nanoid(12)}`;
+        const selfModification = this.config.enabled;
+        const tools = selfModification ? await this.loadAvailableTools() : this.getAgentTools();
+        const ctx = {
+            runId,
+            input,
+            startTime: Date.now(),
+            tools,
+            currentConfig: this.createBaseArchitectureConfig(),
+            generatedTools: [],
+            observations: [],
+            adaptations: [],
+            checkpoints: [],
+            modificationsCount: 0,
+            appliedModifications: [],
+            tokensUsed: 0,
+        };
+        this.currentContext = ctx;
+        this.emit('run_started', runId, { input });
+        let optimization = null;
+        try {
+            if (selfModification &&
+                this.config.constraints.enabled &&
+                this.config.constraints.autoRollback) {
+                await this.createCheckpoint();
+            }
+            if (selfModification && this.config.architectureEvolution.enabled) {
+                optimization = await this.optimizeArchitecture(ctx);
+            }
+            if (selfModification &&
+                this.config.toolGeneration.enabled &&
+                this.config.toolGeneration.autoGenerate) {
+                await this.analyzeAndGenerateTools(ctx);
+            }
+            const execution = await this.executeWithMetaReasoning(ctx, selfModification);
+            await this.recordArchitectureOutcome(ctx, optimization, true, execution.confidence);
+            const result = {
+                output: execution.output,
+                toolsGenerated: [...ctx.generatedTools],
+                adaptationsMade: [...ctx.adaptations],
+                finalConfig: { ...ctx.currentConfig },
+            };
+            this.emit('run_completed', runId, {
+                success: true,
+                toolsGenerated: result.toolsGenerated.length,
+                adaptationsMade: result.adaptationsMade.length,
+            });
+            return result;
+        }
+        catch (error) {
+            await this.recordArchitectureOutcome(ctx, optimization, false, 0).catch(() => undefined);
+            if (selfModification &&
+                this.config.constraints.enabled &&
+                this.config.constraints.autoRollback) {
+                await this.autoRollback(ctx, 'Run failed');
+            }
+            this.emit('run_completed', runId, {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+        finally {
+            this.metaReasoner.cleanupRun(runId);
+            this.currentContext = null;
+        }
+    }
+    emit(type, runId, data) {
         void this.emitter.emit({
-            type: 'rollback_performed',
-            runId: this.currentContext?.runId || 'manual',
+            type,
+            runId,
+            agentId: this.agent.id,
             timestamp: new Date(),
-            data: {
-                checkpointId,
-                reason: 'Manual rollback',
-            },
+            data,
         });
-        return true;
     }
-    async ensureInitialized() {
-        if (this.isInitialized)
-            return;
-        await this.toolStore.list({ status: 'active' });
-        this.isInitialized = true;
+    createBaseArchitectureConfig() {
+        return {
+            model: this.modelName,
+            temperature: this.agent.config?.temperature ?? 0.7,
+            maxTokens: this.agent.config?.maxTokens ?? 4096,
+            toolStrategy: 'sequential',
+            reflectionDepth: 0,
+        };
     }
     mergeConfig(partial) {
         const defaults = {
@@ -260,40 +262,7 @@ export class SelfModifyingAgent {
                     isolationLevel: 'strict',
                 },
             },
-            metaReasoning: {
-                enabled: true,
-                defaultMode: 'analytical',
-                allowedModes: [
-                    'analytical',
-                    'creative',
-                    'systematic',
-                    'intuitive',
-                    'reflective',
-                    'exploratory',
-                ],
-                modeProfiles: {
-                    analytical: { mode: 'analytical', temperature: 0.3, depth: 3 },
-                    creative: { mode: 'creative', temperature: 0.9, depth: 2 },
-                    systematic: { mode: 'systematic', temperature: 0.2, depth: 4 },
-                    intuitive: { mode: 'intuitive', temperature: 0.6, depth: 1 },
-                    reflective: { mode: 'reflective', temperature: 0.4, depth: 3 },
-                    exploratory: { mode: 'exploratory', temperature: 0.7, depth: 2 },
-                },
-                maxMetaAssessments: 5,
-                maxAdaptations: 3,
-                metaAssessmentCooldown: 10000,
-                adaptationCooldown: 15000,
-                triggers: ['on_failure', 'on_low_confidence', 'periodic'],
-                triggerAfterIterations: 3,
-                triggerOnConfidenceDrop: 0.3,
-                triggerOnProgressStall: 2,
-                tokenBudget: 2000,
-                maxMetaTokens: 1000,
-                minConfidenceToAdapt: 0.6,
-                enableRollback: true,
-                rollbackWindow: 30000,
-                rollbackOnDecline: true,
-            },
+            metaReasoning: { ...DEFAULT_META_REASONING_CONFIG },
             architectureEvolution: {
                 enabled: true,
                 strategy: { type: 'ucb', explorationConstant: 2 },
@@ -311,14 +280,19 @@ export class SelfModifyingAgent {
         };
         if (!partial)
             return defaults;
+        const defaultSandbox = defaults.toolGeneration.sandboxConfig ?? {
+            enabled: true,
+            maxExecutionTime: 5000,
+            maxMemory: 50 * 1024 * 1024,
+            allowedModules: [],
+            isolationLevel: 'strict',
+        };
         return {
             enabled: partial.enabled ?? defaults.enabled,
             toolGeneration: {
                 ...defaults.toolGeneration,
                 ...partial.toolGeneration,
-                sandboxConfig: partial.toolGeneration?.sandboxConfig
-                    ? { ...defaults.toolGeneration.sandboxConfig, ...partial.toolGeneration.sandboxConfig }
-                    : defaults.toolGeneration.sandboxConfig,
+                sandboxConfig: { ...defaultSandbox, ...partial.toolGeneration?.sandboxConfig },
             },
             metaReasoning: {
                 ...defaults.metaReasoning,
@@ -331,241 +305,474 @@ export class SelfModifyingAgent {
             architectureEvolution: {
                 ...defaults.architectureEvolution,
                 ...partial.architectureEvolution,
-                strategy: partial.architectureEvolution?.strategy
-                    ? {
-                        ...defaults.architectureEvolution.strategy,
-                        ...partial.architectureEvolution.strategy,
-                    }
-                    : defaults.architectureEvolution.strategy,
+                strategy: {
+                    ...defaults.architectureEvolution.strategy,
+                    ...partial.architectureEvolution?.strategy,
+                },
             },
             constraints: { ...defaults.constraints, ...partial.constraints },
         };
     }
-    getAvailableTools() {
-        return this.agent.tools ?? [];
+    getAgentTools() {
+        return [...(this.agent.tools ?? [])];
     }
-    async optimizeArchitecture(input) {
-        if (!this.currentContext)
-            return;
+    async loadAvailableTools() {
+        const tools = this.getAgentTools();
+        const names = new Set(tools.map((t) => t.name));
+        const stored = await this.toolStore.list({ status: 'active' });
+        for (const generated of stored) {
+            if (names.has(generated.name))
+                continue;
+            names.add(generated.name);
+            tools.push(this.toolGenerator.createExecutableTool(generated));
+        }
+        return tools;
+    }
+    async optimizeArchitecture(ctx) {
         try {
-            const result = await this.parameterOptimizer.optimize(input);
-            if (result.shouldAdopt && result.confidence > 0.6) {
-                const validation = await this.modificationValidator.validate({
-                    type: 'config_change',
-                    target: 'architecture',
-                    changes: result.recommendedConfig,
-                    reason: result.reasoning,
-                });
-                if (validation.valid) {
-                    this.currentContext.currentConfig = result.recommendedConfig;
-                    void this.emitter.emit({
-                        type: 'architecture_evolved',
-                        runId: this.currentContext.runId,
-                        timestamp: new Date(),
-                        data: {
-                            candidateId: result.candidate?.id,
-                            changes: result.recommendedConfig,
-                            metrics: result.metrics,
-                        },
-                    });
-                }
+            const result = await this.parameterOptimizer.optimize(ctx.input);
+            const candidate = result.candidate;
+            if (!candidate)
+                return null;
+            const isNoop = Object.keys(candidate.config).length === 0;
+            if (isNoop) {
+                return { result, candidateId: candidate.id };
+            }
+            if (!result.shouldAdopt || !this.canApplyModification(ctx)) {
+                return { result, candidateId: 'baseline' };
             }
+            const valid = await this.validateModification(ctx, {
+                type: 'config_change',
+                target: 'architecture',
+                changes: result.recommendedConfig,
+                reason: result.reasoning,
+                payload: { candidateId: candidate.id, changedKeys: Object.keys(candidate.config) },
+            });
+            if (!valid) {
+                return { result, candidateId: 'baseline' };
+            }
+            ctx.currentConfig = { ...result.recommendedConfig };
+            this.recordModification(ctx, 'config_change', {
+                candidateId: candidate.id,
+                config: result.recommendedConfig,
+            });
+            this.emit('architecture_evolved', ctx.runId, {
+                success: true,
+                candidateId: candidate.id,
+                changes: result.recommendedConfig,
+                metrics: result.metrics,
+            });
+            return { result, candidateId: candidate.id };
         }
         catch (error) {
-            void this.emitter.emit({
-                type: 'architecture_evolved',
-                runId: this.currentContext.runId,
-                timestamp: new Date(),
-                data: { error: error instanceof Error ? error.message : String(error) },
+            this.emit('architecture_evolved', ctx.runId, {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
             });
+            return null;
         }
     }
-    async analyzeAndGenerateTools(input) {
-        if (!this.currentContext)
+    async recordArchitectureOutcome(ctx, optimization, success, quality) {
+        if (!optimization)
             return;
+        await this.parameterOptimizer.recordOutcome(optimization.candidateId, optimization.result.taskProfile, {
+            successRate: success ? 1 : 0,
+            latency: Date.now() - ctx.startTime,
+            tokenUsage: ctx.tokensUsed,
+            qualityScore: quality,
+        });
+    }
+    async analyzeAndGenerateTools(ctx) {
         try {
-            const analysis = await this.gapAnalyzer.analyze(input, this.currentContext.tools);
+            const analysis = await this.gapAnalyzer.analyze(ctx.input, ctx.tools);
             for (const gap of analysis.gaps) {
-                if (gap.confidence >= this.config.toolGeneration.minConfidenceForGeneration) {
-                    void this.emitter.emit({
-                        type: 'tool_generation_started',
-                        runId: this.currentContext.runId,
-                        timestamp: new Date(),
-                        data: { gap },
-                    });
-                    const tool = await this.generateTool(gap);
-                    if (tool) {
-                        this.currentContext.generatedTools.push(tool);
-                        const executableTool = this.toolGenerator.createExecutableTool(tool);
-                        this.currentContext.tools.push(executableTool);
-                    }
-                }
+                if (ctx.generatedTools.length >= this.config.toolGeneration.maxToolsPerSession)
+                    break;
+                if (!this.canApplyModification(ctx))
+                    break;
+                if (gap.confidence < this.config.toolGeneration.minConfidenceForGeneration)
+                    continue;
+                const tool = await this.generateAndRegisterTool(gap, ctx.tools);
+                if (!tool)
+                    continue;
+                ctx.generatedTools.push(tool);
+                ctx.tools.push(this.toolGenerator.createExecutableTool(tool));
+                this.recordModification(ctx, 'tool_generation', { toolId: tool.id, name: tool.name });
             }
         }
         catch (error) {
-            void this.emitter.emit({
-                type: 'tool_generation_completed',
-                runId: this.currentContext.runId,
-                timestamp: new Date(),
-                data: {
-                    toolId: '',
-                    name: '',
-                    success: false,
-                    error: error instanceof Error ? error.message : String(error),
-                },
+            this.emit('tool_generation_completed', ctx.runId, {
+                toolId: '',
+                name: '',
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
             });
         }
     }
-    async executeWithMetaReasoning(input, runId) {
-        if (!this.currentContext) {
-            throw new Error('No active run context');
+    async generateAndRegisterTool(gap, existingTools) {
+        const ctx = this.currentContext;
+        const runId = ctx?.runId ?? 'manual';
+        this.emit('tool_generation_started', runId, { gap });
+        const result = await this.toolGenerator.generate(gap, existingTools);
+        const generated = result.tool;
+        if (!result.success || !generated) {
+            this.emit('tool_generation_completed', runId, {
+                toolId: generated?.id ?? '',
+                name: generated?.name ?? gap.suggestedToolName,
+                success: false,
+                iterations: result.iterations,
+                error: result.error,
+            });
+            return null;
+        }
+        const rejection = await this.checkGeneratedTool(generated, existingTools);
+        if (rejection) {
+            this.emit('tool_generation_completed', runId, {
+                toolId: generated.id,
+                name: generated.name,
+                success: false,
+                iterations: result.iterations,
+                error: rejection,
+            });
+            return null;
+        }
+        const activeTool = { ...generated, status: 'active' };
+        await this.toolStore.save(activeTool);
+        const saved = (await this.toolStore.get(activeTool.id)) ?? activeTool;
+        this.emit('tool_generation_completed', runId, {
+            toolId: saved.id,
+            name: saved.name,
+            success: true,
+            iterations: result.iterations,
+        });
+        return saved;
+    }
+    async checkGeneratedTool(tool, existingTools) {
+        if (existingTools.some((t) => t.name === tool.name)) {
+            return `A tool named "${tool.name}" already exists`;
+        }
+        const linesOfCode = tool.implementation.split('\n').length;
+        const valid = await this.validateModification(this.currentContext, {
+            type: 'tool_generation',
+            target: tool.name,
+            changes: { name: tool.name, implementation: tool.implementation },
+            reason: `Generated tool for capability gap: ${tool.name}`,
+            payload: {
+                sandboxExecution: this.config.toolGeneration.sandboxConfig?.enabled ?? false,
+                linesOfCode,
+                complexity: linesOfCode,
+                modificationDepth: 1,
+            },
+        });
+        return valid ? null : 'Rejected by modification constraints';
+    }
+    async executeWithMetaReasoning(ctx, selfModification) {
+        const runId = ctx.runId;
+        const metaEnabled = selfModification && this.config.metaReasoning.enabled;
+        const maxAttempts = metaEnabled ? Math.max(1, this.config.metaReasoning.maxAdaptations + 1) : 1;
+        const contextAdditions = [];
+        let modeAdapted = false;
+        let pendingAdaptation = null;
+        if (metaEnabled) {
+            const modeConfig = this.metaReasoner.initializeRun(runId);
+            this.emit('strategy_changed', runId, {
+                previousMode: this.config.metaReasoning.defaultMode,
+                newMode: modeConfig.mode,
+                reason: 'Initial mode selection',
+            });
         }
-        let output = '';
-        let iteration = 0;
-        const maxIterations = 10;
-        while (iteration < maxIterations) {
-            iteration++;
-            const currentMode = this.metaReasoner.getCurrentMode(runId);
+        let step = null;
+        let confidence = 0;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const temperature = modeAdapted
+                ? this.metaReasoner.getCurrentConfig(runId).temperature
+                : ctx.currentConfig.temperature;
+            step = await this.executeAgentStep(ctx, { temperature, contextAdditions });
+            ctx.tokensUsed += step.tokensUsed;
+            confidence = this.stepConfidence(step);
+            if (!metaEnabled)
+                break;
+            this.metaReasoner.recordConfidence(runId, confidence);
+            if (pendingAdaptation) {
+                this.metaReasoner.recordOutcome(runId, pendingAdaptation.adaptation.id, {
+                    improved: step.complete || confidence > pendingAdaptation.confidence,
+                    progressDelta: step.complete ? 1 : 0,
+                    confidenceDelta: confidence - pendingAdaptation.confidence,
+                });
+                pendingAdaptation = null;
+            }
+            if (step.complete || attempt === maxAttempts)
+                break;
             const observation = this.metaReasoner.observe({
                 runId,
-                iteration,
-                goal: input,
-                currentMode,
-                tokensUsed: Math.round(output.length * 1.3),
-                timeElapsed: Date.now() - this.currentContext.startTime,
-                iterationsRemaining: maxIterations - iteration,
-                budgetRemaining: 10000 - Math.round(output.length * 1.3),
+                iteration: attempt,
+                goal: ctx.input,
+                currentMode: this.metaReasoner.getCurrentMode(runId),
+                tokensUsed: ctx.tokensUsed,
+                timeElapsed: Date.now() - ctx.startTime,
+                iterationsRemaining: maxAttempts - attempt,
+                budgetRemaining: (maxAttempts - attempt) / maxAttempts,
             }, []);
-            this.currentContext.observations.push(observation);
-            if (this.metaReasoner.shouldTrigger(runId, 'periodic', {
-                iteration,
-                confidence: this.estimateConfidence(output),
-                progressDelta: output.length > 0 ? 0.1 : 0,
-                stagnationCount: 0,
-            })) {
-                const assessment = await this.metaReasoner.assess(observation);
-                void this.emitter.emit({
-                    type: 'meta_assessment',
-                    runId,
-                    timestamp: new Date(),
-                    data: {
-                        observation,
-                        assessment,
-                    },
-                });
-                if (assessment.requiresAdaptation) {
-                    const adaptation = await this.metaReasoner.adapt(runId, assessment);
-                    if (adaptation) {
-                        this.currentContext.adaptations.push(adaptation);
-                        void this.emitter.emit({
-                            type: 'strategy_changed',
-                            runId,
-                            timestamp: new Date(),
-                            data: {
-                                previousMode: adaptation.before?.mode || 'analytical',
-                                newMode: adaptation.after?.mode || 'analytical',
-                                reason: adaptation.type,
-                            },
-                        });
-                    }
-                }
-            }
-            output = await this.executeAgentStep(input);
-            if (this.isTaskComplete(output)) {
+            ctx.observations.push(observation);
+            if (!this.selectTrigger(runId, attempt, confidence, observation))
+                continue;
+            const assessment = await this.metaReasoner.assess(observation);
+            this.emit('meta_assessment', runId, { observation, assessment });
+            if (!assessment.requiresAdaptation)
+                continue;
+            if (assessment.recommendation.action === 'abort')
                 break;
+            const adaptation = await this.metaReasoner.adapt(runId, assessment);
+            if (!adaptation)
+                continue;
+            ctx.adaptations.push(adaptation);
+            pendingAdaptation = { adaptation, confidence };
+            if (adaptation.type === 'context_injection' && assessment.recommendation.contextAddition) {
+                contextAdditions.push(assessment.recommendation.contextAddition);
             }
+            else {
+                modeAdapted = true;
+            }
+            this.emit('strategy_changed', runId, {
+                previousMode: adaptation.previousMode ?? this.metaReasoner.getCurrentMode(runId),
+                newMode: adaptation.newMode ?? this.metaReasoner.getCurrentMode(runId),
+                reason: adaptation.reason ?? adaptation.type,
+            });
         }
-        return output;
+        return { output: step?.content ?? '', confidence };
     }
-    async executeAgentStep(input) {
-        const tools = this.currentContext?.tools ?? [];
-        const toolSchemas = this.buildToolSchemas(tools);
-        const toolMap = new Map();
-        for (const t of tools) {
-            toolMap.set(t.name, t);
+    selectTrigger(runId, iteration, confidence, observation) {
+        const context = {
+            iteration,
+            confidence,
+            progressDelta: observation.progressDelta,
+            stagnationCount: observation.stagnationCount,
+        };
+        const candidates = [
+            'on_failure',
+            'on_low_confidence',
+            'on_stagnation',
+            'iteration_complete',
+            'periodic',
+        ];
+        return candidates.find((t) => this.metaReasoner.shouldTrigger(runId, t, context)) ?? null;
+    }
+    async executeAgentStep(ctx, options) {
+        const toolMap = new Map(ctx.tools.map((t) => [t.name, t]));
+        const toolSchemas = this.buildToolSchemas(ctx.tools);
+        const generatedIds = new Map(ctx.generatedTools.map((t) => [t.name, t.id]));
+        for (const stored of await this.toolStore.list({ status: 'active' })) {
+            if (!generatedIds.has(stored.name))
+                generatedIds.set(stored.name, stored.id);
         }
-        const model = this.currentContext?.currentConfig.model ?? this.agent.model ?? 'default';
+        const model = ctx.currentConfig.model;
+        const maxTokens = ctx.currentConfig.maxTokens;
         const messages = [
             ...(this.agent.instructions
                 ? [{ role: 'system', content: this.agent.instructions }]
                 : []),
-            { role: 'user', content: input },
+            ...options.contextAdditions.map((content) => ({ role: 'system', content })),
+            { role: 'user', content: ctx.input },
         ];
-        const maxToolRounds = 10;
+        let tokensUsed = 0;
+        let toolCalls = 0;
+        let toolErrors = 0;
+        let response = null;
+        const maxToolRounds = this.agent.config?.maxIterations ?? DEFAULT_MAX_TOOL_ROUNDS;
         for (let round = 0; round < maxToolRounds; round++) {
-            const response = await this.llm.chat({
+            response = await this.llm.chat({
                 model,
                 messages,
                 tools: toolSchemas.length > 0 ? toolSchemas : undefined,
-                temperature: this.currentContext?.currentConfig.temperature,
-                maxTokens: this.currentContext?.currentConfig.maxTokens,
+                temperature: options.temperature,
+                maxTokens,
             });
+            tokensUsed += response.usage?.totalTokens ?? 0;
             if (response.finishReason !== 'tool_calls' || !response.toolCalls?.length) {
-                return response.content;
+                break;
             }
-            messages.push({
+            const assistantMessage = {
                 role: 'assistant',
                 content: response.content,
                 toolCalls: response.toolCalls,
-            });
-            for (const toolCall of response.toolCalls) {
-                const t = toolMap.get(toolCall.name);
-                let result;
-                if (!t) {
-                    result = { error: `Tool "${toolCall.name}" not found` };
-                }
-                else {
-                    try {
-                        const ctx = {
-                            agentId: this.agent.name || 'self-modifying',
-                            runId: this.currentContext?.runId || 'unknown',
-                            signal: AbortSignal.timeout(30_000),
-                        };
-                        result = await t.execute(toolCall.arguments, ctx);
-                    }
-                    catch (err) {
-                        result = { error: err instanceof Error ? err.message : String(err) };
-                    }
-                }
+            };
+            messages.push(assistantMessage);
+            const outcomes = await this.executeToolCalls(ctx, response.toolCalls, toolMap, generatedIds);
+            for (const outcome of outcomes) {
+                toolCalls++;
+                if (outcome.failed)
+                    toolErrors++;
                 messages.push({
                     role: 'tool',
-                    content: typeof result === 'string' ? result : JSON.stringify(result),
-                    toolCallId: toolCall.id,
-                    name: toolCall.name,
+                    content: outcome.content,
+                    toolCallId: outcome.call.id,
+                    name: outcome.call.name,
                 });
             }
+            response = null;
         }
-        const finalResponse = await this.llm.chat({
-            model,
-            messages,
-            temperature: this.currentContext?.currentConfig.temperature,
-            maxTokens: this.currentContext?.currentConfig.maxTokens,
-        });
-        return finalResponse.content;
+        if (!response) {
+            response = await this.llm.chat({
+                model,
+                messages,
+                temperature: options.temperature,
+                maxTokens,
+            });
+            tokensUsed += response.usage?.totalTokens ?? 0;
+        }
+        let content = response.content;
+        let finishReason = response.finishReason;
+        for (let depth = 0; depth < ctx.currentConfig.reflectionDepth && content.trim(); depth++) {
+            const reflection = await this.llm.chat({
+                model,
+                messages: [
+                    ...messages,
+                    { role: 'assistant', content },
+                    {
+                        role: 'user',
+                        content: 'Review your previous answer for mistakes or omissions. Reply with the final, corrected answer only. If it is already correct, repeat it unchanged.',
+                    },
+                ],
+                temperature: options.temperature,
+                maxTokens,
+            });
+            tokensUsed += reflection.usage?.totalTokens ?? 0;
+            if (!reflection.content.trim() || reflection.finishReason === 'error')
+                break;
+            content = reflection.content;
+            finishReason = reflection.finishReason;
+        }
+        return {
+            content,
+            finishReason,
+            tokensUsed,
+            toolCalls,
+            toolErrors,
+            complete: content.trim().length > 0 && finishReason !== 'length' && finishReason !== 'error',
+        };
     }
-    buildToolSchemas(tools) {
-        return tools.map((t) => {
-            if (typeof t.toJSON === 'function') {
-                return t.toJSON();
+    async executeToolCalls(ctx, calls, toolMap, generatedIds) {
+        const strategy = ctx.currentConfig.toolStrategy;
+        const parallel = strategy === 'parallel' ||
+            (strategy === 'adaptive' && new Set(calls.map((c) => c.name)).size === calls.length);
+        if (parallel) {
+            return Promise.all(calls.map((call) => this.executeToolCall(ctx, call, toolMap, generatedIds)));
+        }
+        const outcomes = [];
+        for (const call of calls) {
+            outcomes.push(await this.executeToolCall(ctx, call, toolMap, generatedIds));
+        }
+        return outcomes;
+    }
+    async executeToolCall(ctx, call, toolMap, generatedIds) {
+        const t = toolMap.get(call.name);
+        const startedAt = Date.now();
+        let result;
+        let error;
+        if (!t) {
+            error = `Tool "${call.name}" not found`;
+        }
+        else {
+            const parsed = t.parameters.safeParse(call.arguments);
+            if (!parsed.success) {
+                error = `Invalid arguments for "${call.name}": ${parsed.error.issues
+                    .map((i) => `${i.path.join('.') || '(root)'}: ${i.message}`)
+                    .join('; ')}`;
+            }
+            else {
+                try {
+                    const toolContext = {
+                        agentId: this.agent.id ?? this.agent.name ?? 'self-modifying',
+                        runId: ctx.runId,
+                        signal: AbortSignal.timeout(t.timeout ?? DEFAULT_TOOL_TIMEOUT_MS),
+                    };
+                    result = await t.execute(parsed.data, toolContext);
+                }
+                catch (err) {
+                    error = err instanceof Error ? err.message : String(err);
+                }
             }
-            return {
+        }
+        const duration = Date.now() - startedAt;
+        const generatedId = generatedIds.get(call.name);
+        if (generatedId) {
+            await this.toolStore.recordUsage({
+                toolId: generatedId,
+                timestamp: new Date(),
+                success: error === undefined,
+                executionTime: duration,
+                error,
+            });
+        }
+        if (this.config.enabled && this.config.metaReasoning.enabled) {
+            this.metaReasoner.recordAction(ctx.runId, {
+                type: 'tool_call',
+                toolName: call.name,
+                input: call.arguments,
+                output: error === undefined ? result : undefined,
+                error,
+                duration,
+                timestamp: startedAt,
+            });
+        }
+        if (error !== undefined) {
+            return { call, content: JSON.stringify({ error }), failed: true };
+        }
+        return {
+            call,
+            content: typeof result === 'string' ? result : (JSON.stringify(result) ?? 'null'),
+            failed: false,
+        };
+    }
+    buildToolSchemas(tools) {
+        return tools.map((t) => typeof t.toJSON === 'function'
+            ? t.toJSON()
+            : {
                 name: t.name,
                 description: t.description,
                 parameters: { type: 'object', properties: {} },
-            };
-        });
+            });
     }
-    estimateConfidence(output) {
-        if (!output)
-            return 0.3;
-        if (output.length < 50)
-            return 0.4;
-        if (output.length < 200)
-            return 0.6;
-        return 0.8;
+    stepConfidence(step) {
+        if (!step.complete)
+            return 0.2;
+        if (step.toolCalls > 0 && step.toolErrors > 0) {
+            return step.toolErrors >= step.toolCalls ? 0.4 : 0.6;
+        }
+        return 0.9;
     }
-    isTaskComplete(_output) {
-        return true;
+    async validateModification(ctx, request) {
+        if (!this.config.constraints.enabled)
+            return true;
+        const validation = await this.modificationValidator.validate(request);
+        if (validation.rollbackRequired && this.config.constraints.autoRollback && ctx) {
+            await this.autoRollback(ctx, `Critical constraint violation: ${request.type}`);
+        }
+        return validation.valid;
+    }
+    canApplyModification(ctx) {
+        if (!this.config.constraints.enabled)
+            return true;
+        return ctx.modificationsCount < this.config.constraints.maxModificationsPerRun;
+    }
+    recordModification(ctx, type, data) {
+        ctx.modificationsCount++;
+        ctx.appliedModifications.push({
+            id: `mod_${nanoid(8)}`,
+            type,
+            appliedAt: new Date(),
+            data,
+        });
+    }
+    async autoRollback(ctx, reason) {
+        const now = Date.now();
+        const window = this.config.constraints.rollbackWindow;
+        const target = ctx.checkpoints
+            .filter((c) => now - c.timestamp.getTime() <= window)
+            .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())[0];
+        if (target) {
+            await this.rollbackToCheckpoint(target.id, reason);
+        }
     }
 }
 //# sourceMappingURL=self-modifying-agent.js.map