@cogitator-ai/self-modifying 17.0.5 → 17.0.10

package/src/architecture-evolution/parameter-optimizer.ts

@@ -7,7 +7,7 @@ import type {
   EvolutionMetrics,
 } from '@cogitator-ai/types';
 import { CapabilityAnalyzer } from './capability-analyzer';
-import { EvolutionStrategy, type SelectionResult as _SelectionResult } from './evolution-strategy';
+import { EvolutionStrategy } from './evolution-strategy';
 import {
   buildCandidateGenerationPrompt,
   buildPerformanceAnalysisPrompt,
@@ -48,6 +48,7 @@ export class ParameterOptimizer {
   private candidates: EvolutionCandidate[] = [];
   private history: HistoricalRecord[] = [];
   private currentGeneration = 0;
+  private lastEvolutionTimestamp = 0;
   private readonly maxHistorySize = 100;
 
   constructor(options: ParameterOptimizerOptions) {
@@ -173,6 +174,7 @@ export class ParameterOptimizer {
 
   private async evolve(currentProfile: TaskProfile): Promise<void> {
     this.currentGeneration++;
+    this.lastEvolutionTimestamp = Date.now();
 
     const topCandidates = [...this.candidates]
       .filter((c) => c.evaluationCount > 0)
@@ -325,10 +327,7 @@ export class ParameterOptimizer {
   }
 
   private getLastEvolutionTime(): number {
-    const latestGenCandidate = this.candidates.find(
-      (c) => c.generation === this.currentGeneration && c.evaluationCount === 0
-    );
-    return latestGenCandidate ? Date.now() - 300000 : 0;
+    return this.lastEvolutionTimestamp;
   }
 
   private getRelevantHistory(profile: TaskProfile): HistoricalRecord[] {
@@ -410,7 +409,7 @@ export class ParameterOptimizer {
       fields++;
     }
 
-    if (a.model !== b.model) {
+    if (a.model !== undefined && b.model !== undefined && a.model !== b.model) {
       distance += 1;
       fields++;
     }
@@ -447,8 +446,9 @@ export class ParameterOptimizer {
     if (evaluatedCandidates.length === 0) return null;
 
     const results = evaluatedCandidates.map((c) => {
+      const configKey = JSON.stringify(c.config, Object.keys(c.config).sort());
       const records = this.history.filter(
-        (h) => JSON.stringify(h.config) === JSON.stringify(c.config)
+        (h) => JSON.stringify(h.config, Object.keys(h.config).sort()) === configKey
       );
       const avgMetrics =
         records.length > 0
@@ -503,6 +503,7 @@ export class ParameterOptimizer {
     this.candidates = [];
     this.history = [];
     this.currentGeneration = 0;
+    this.lastEvolutionTimestamp = 0;
     this.evolutionStrategy.reset();
   }
 }

package/src/architecture-evolution/prompts.ts

@@ -1,4 +1,5 @@
 import type { TaskProfile, ArchitectureConfig, EvolutionCandidate } from '@cogitator-ai/types';
+import { extractJson } from '../utils';
 
 export const ARCHITECTURE_ANALYSIS_SYSTEM_PROMPT = `You are an expert in AI agent architecture optimization.
 Your task is to analyze tasks and recommend optimal configurations.
@@ -140,11 +141,11 @@ Respond with:
 }
 
 export function parseTaskProfileResponse(response: string): TaskProfile | null {
-  const jsonMatch = /\{[\s\S]*\}/.exec(response);
-  if (!jsonMatch) return null;
+  const json = extractJson(response);
+  if (!json) return null;
 
   try {
-    const parsed = JSON.parse(jsonMatch[0]);
+    const parsed = JSON.parse(json);
 
     return {
       complexity: parsed.complexity || 'moderate',
@@ -197,11 +198,11 @@ export function parsePerformanceAnalysisResponse(response: string): {
   shouldAdopt: boolean;
   analysis: string;
 } | null {
-  const jsonMatch = /\{[\s\S]*\}/.exec(response);
-  if (!jsonMatch) return null;
+  const json = extractJson(response);
+  if (!json) return null;
 
   try {
-    const parsed = JSON.parse(jsonMatch[0]);
+    const parsed = JSON.parse(json);
 
     return {
       recommendation: String(parsed.recommendation || ''),

package/src/constraints/index.ts

@@ -6,6 +6,7 @@ export {
   mergeSafetyConstraints,
   mergeCapabilityConstraints,
   mergeResourceConstraints,
+  mergeCustomConstraints,
   mergeConstraints,
 } from './safety-constraints';
 

package/src/constraints/modification-validator.ts

@@ -92,23 +92,7 @@ export class ModificationValidator {
       return this.evaluateExpression(rule, request.payload as Record<string, unknown>);
     }
 
-    const payload = request.payload as Record<string, unknown>;
-
-    switch (rule.type) {
-      case 'invariant':
-        return this.evaluateExpression(rule.expression ?? '', payload);
-      case 'precondition':
-        return this.evaluateExpression(rule.expression ?? '', payload);
-      case 'postcondition':
-        return true;
-      case 'temporal':
-        if (rule.pattern?.source === 'never') {
-          return !this.evaluateExpression(rule.expression ?? '', payload);
-        }
-        return true;
-      default:
-        return true;
-    }
+    return this.evaluateExpression(rule.expression ?? '', request.payload as Record<string, unknown>);
   }
 
   private evaluateExpression(expression: string, context: Record<string, unknown>): boolean {
@@ -127,16 +111,18 @@ export class ModificationValidator {
 
     if (conditions.length === 0) return true;
 
-    let result = conditions[0];
+    const orGroups: boolean[][] = [[]];
+    orGroups[0].push(conditions[0]);
+
     for (let i = 0; i < operators.length; i++) {
       if (operators[i] === 'AND') {
-        result = result && conditions[i + 1];
+        orGroups[orGroups.length - 1].push(conditions[i + 1]);
       } else {
-        result = result || conditions[i + 1];
+        orGroups.push([conditions[i + 1]]);
       }
     }
 
-    return result;
+    return orGroups.some((group) => group.every(Boolean));
   }
 
   private evaluateSimpleCondition(condition: string, context: Record<string, unknown>): boolean {
@@ -238,7 +224,7 @@ export class ModificationValidator {
     request: ModificationRequest
   ): Promise<ConstraintCheckResult[]> {
     const results: ConstraintCheckResult[] = [];
-    const payload = request.payload as {
+    const payload = (request.payload ?? {}) as {
       tokensUsed?: number;
       cost?: number;
       activeTools?: number;
@@ -384,6 +370,11 @@ export class ModificationValidator {
   }
 
   getConstraints(): ModificationConstraints {
-    return { ...this.constraints };
+    return {
+      safety: [...this.constraints.safety],
+      capability: [...this.constraints.capability],
+      resource: [...this.constraints.resource],
+      custom: this.constraints.custom ? [...this.constraints.custom] : [],
+    };
   }
 }

package/src/constraints/safety-constraints.ts

@@ -2,6 +2,7 @@ import type {
   SafetyConstraint,
   CapabilityConstraint,
   ResourceConstraint,
+  CustomConstraint,
   ModificationConstraints,
 } from '@cogitator-ai/types';
 import { DEFAULT_SAFETY_CONSTRAINTS } from '@cogitator-ai/types';
@@ -84,6 +85,20 @@ export function mergeResourceConstraints(
   return [...result.values()];
 }
 
+export function mergeCustomConstraints(
+  base: CustomConstraint[],
+  additions: CustomConstraint[]
+): CustomConstraint[] {
+  const result = new Map<string, CustomConstraint>();
+  for (const c of base) {
+    result.set(c.id, c);
+  }
+  for (const c of additions) {
+    result.set(c.id, c);
+  }
+  return [...result.values()];
+}
+
 export function mergeConstraints(
   base: ModificationConstraints,
   additions: Partial<ModificationConstraints>
@@ -96,6 +111,6 @@ export function mergeConstraints(
     resource: additions.resource
       ? mergeResourceConstraints(base.resource, additions.resource)
       : base.resource,
-    custom: [...(base.custom ?? []), ...(additions.custom ?? [])],
+    custom: mergeCustomConstraints(base.custom ?? [], additions.custom ?? []),
   };
 }

package/src/events/event-emitter.ts

@@ -30,7 +30,15 @@ export class SelfModifyingEventEmitter {
       ...(wildcardHandlers ? [...wildcardHandlers] : []),
     ];
 
-    await Promise.all(allHandlers.map((h) => Promise.resolve(h(event))));
+    await Promise.allSettled(
+      allHandlers.map((h) => {
+        try {
+          return Promise.resolve(h(event));
+        } catch (e) {
+          return Promise.reject(e instanceof Error ? e : new Error(String(e)));
+        }
+      })
+    );
   }
 
   createEvent(

package/src/index.ts

@@ -67,6 +67,7 @@ export {
   mergeSafetyConstraints,
   mergeCapabilityConstraints,
   mergeResourceConstraints,
+  mergeCustomConstraints,
   type ModificationValidatorOptions,
   type RollbackManagerOptions,
   type CheckpointStore,
@@ -75,6 +76,8 @@ export {
 
 export { SelfModifyingEventEmitter, type SelfModifyingEventHandler } from './events';
 
+export { llmChat, extractJson } from './utils';
+
 export type {
   SelfModifyingConfig,
   ToolSelfGenerationConfig,

package/src/meta-reasoning/meta-reasoner.ts

@@ -111,6 +111,9 @@ export class MetaReasoner {
       case 'progress_stall':
         return context.stagnationCount >= this.config.triggerOnProgressStall;
 
+      case 'periodic':
+        return context.iteration > 0 && context.iteration % this.config.triggerAfterIterations === 0;
+
       case 'tool_call_failed':
         return true;
 
@@ -165,12 +168,17 @@ export class MetaReasoner {
 
       recommendation: this.buildRecommendation(parsed, observation),
 
+      requiresAdaptation:
+        parsed?.recommendation?.action !== undefined &&
+        parsed?.recommendation?.action !== 'continue',
+
       assessmentDuration: Date.now() - startTime,
       assessmentCost: (response.usage?.outputTokens ?? 0) * 0.00001,
     };
 
     const runAssessments = this.assessments.get(observation.runId) ?? [];
     runAssessments.push(assessment);
+    this.assessments.set(observation.runId, runAssessments);
     this.lastAssessmentTime.set(observation.runId, Date.now());
 
     return assessment;
@@ -277,6 +285,7 @@ export class MetaReasoner {
 
     const runAdaptations = this.adaptations.get(runId) ?? [];
     runAdaptations.push(adaptation);
+    this.adaptations.set(runId, runAdaptations);
     this.lastAdaptationTime.set(runId, Date.now());
 
     return adaptation;

package/src/meta-reasoning/prompts.ts

@@ -111,14 +111,54 @@ export interface ParsedAssessment {
 
 export function parseMetaAssessmentResponse(content: string): ParsedAssessment | null {
   try {
-    const jsonMatch = /\{[\s\S]*\}/.exec(content);
-    if (!jsonMatch) return null;
-    return JSON.parse(jsonMatch[0]) as ParsedAssessment;
+    const json = extractJson(content);
+    if (!json) return null;
+    return JSON.parse(json) as ParsedAssessment;
   } catch {
     return null;
   }
 }
 
+function extractJson(text: string): string | null {
+  const start = text.indexOf('{');
+  if (start === -1) return null;
+
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+
+    if (escape) {
+      escape = false;
+      continue;
+    }
+
+    if (ch === '\\' && inString) {
+      escape = true;
+      continue;
+    }
+
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (inString) continue;
+
+    if (ch === '{') depth++;
+    else if (ch === '}') {
+      depth--;
+      if (depth === 0) {
+        return text.slice(start, i + 1);
+      }
+    }
+  }
+
+  return null;
+}
+
 export const META_REASONING_SYSTEM_PROMPT = `You are a meta-reasoning system analyzing an AI agent's reasoning process.
 Your job is to assess whether the agent is on track and recommend strategic adjustments.
 

package/src/self-modifying-agent.ts

@@ -54,7 +54,7 @@ export class SelfModifyingAgent {
   private readonly toolStore: InMemoryGeneratedToolStore;
   private readonly metaReasoner: MetaReasoner;
   private readonly parameterOptimizer: ParameterOptimizer;
-  private readonly _capabilityAnalyzer: CapabilityAnalyzer;
+  private readonly capabilityAnalyzer: CapabilityAnalyzer;
   private readonly modificationValidator: ModificationValidator;
   private readonly rollbackManager: RollbackManager;
 
@@ -91,7 +91,7 @@ export class SelfModifyingAgent {
       baseConfig: baseArchConfig,
     });
 
-    this._capabilityAnalyzer = new CapabilityAnalyzer({
+    this.capabilityAnalyzer = new CapabilityAnalyzer({
       llm: this.llm,
       enableLLMAnalysis: true,
     });
@@ -217,6 +217,7 @@ export class SelfModifyingAgent {
 
       throw error;
     } finally {
+      this.metaReasoner.cleanupRun(runId);
       this.currentContext = null;
     }
   }
@@ -409,18 +410,34 @@ export class SelfModifyingAgent {
 
     return {
       enabled: partial.enabled ?? defaults.enabled,
-      toolGeneration: { ...defaults.toolGeneration, ...partial.toolGeneration },
-      metaReasoning: { ...defaults.metaReasoning, ...partial.metaReasoning },
+      toolGeneration: {
+        ...defaults.toolGeneration,
+        ...partial.toolGeneration,
+        sandboxConfig: partial.toolGeneration?.sandboxConfig
+          ? { ...defaults.toolGeneration.sandboxConfig, ...partial.toolGeneration.sandboxConfig }
+          : defaults.toolGeneration.sandboxConfig,
+      },
+      metaReasoning: {
+        ...defaults.metaReasoning,
+        ...partial.metaReasoning,
+        modeProfiles: {
+          ...defaults.metaReasoning.modeProfiles,
+          ...partial.metaReasoning?.modeProfiles,
+        },
+      },
       architectureEvolution: {
         ...defaults.architectureEvolution,
         ...partial.architectureEvolution,
+        strategy: partial.architectureEvolution?.strategy
+          ? { ...defaults.architectureEvolution.strategy, ...partial.architectureEvolution.strategy }
+          : defaults.architectureEvolution.strategy,
       },
       constraints: { ...defaults.constraints, ...partial.constraints },
     };
   }
 
   private getAvailableTools(): Tool[] {
-    return [];
+    return this.agent.tools ?? [];
   }
 
   private async optimizeArchitecture(input: string): Promise<void> {
@@ -452,7 +469,14 @@ export class SelfModifyingAgent {
           });
         }
       }
-    } catch {}
+    } 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) },
+      });
+    }
   }
 
   private async analyzeAndGenerateTools(input: string): Promise<void> {
@@ -479,7 +503,19 @@ export class SelfModifyingAgent {
           }
         }
       }
-    } catch {}
+    } 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),
+        },
+      });
+    }
   }
 
   private async executeWithMetaReasoning(input: string, runId: string): Promise<string> {
@@ -562,7 +598,19 @@ export class SelfModifyingAgent {
   }
 
   private async executeAgentStep(input: string): Promise<string> {
-    return `Processed: ${input}`;
+    const response = await this.llm.chat({
+      model: this.currentContext?.currentConfig.model ?? this.agent.model ?? 'default',
+      messages: [
+        ...(this.agent.instructions
+          ? [{ role: 'system' as const, content: this.agent.instructions }]
+          : []),
+        { role: 'user' as const, content: input },
+      ],
+      temperature: this.currentContext?.currentConfig.temperature,
+      maxTokens: this.currentContext?.currentConfig.maxTokens,
+    });
+
+    return response.content;
   }
 
   private estimateConfidence(output: string): number {
@@ -572,7 +620,7 @@ export class SelfModifyingAgent {
     return 0.8;
   }
 
-  private isTaskComplete(output: string): boolean {
-    return output.length > 0;
+  private isTaskComplete(_output: string): boolean {
+    return true;
   }
 }

package/src/tool-generation/generated-tool-store.ts

@@ -25,10 +25,8 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
 
   async save(tool: GeneratedTool): Promise<void> {
     const existing = this.tools.get(tool.id);
-    if (existing) {
-      tool.version = existing.version + 1;
-    }
-    this.tools.set(tool.id, { ...tool, updatedAt: new Date() });
+    const version = existing ? existing.version + 1 : tool.version;
+    this.tools.set(tool.id, { ...tool, version, updatedAt: new Date() });
   }
 
   async get(id: string): Promise<GeneratedTool | null> {

package/src/tool-generation/prompts.ts

@@ -1,4 +1,5 @@
 import type { CapabilityGap, GeneratedTool, ToolValidationResult } from '@cogitator-ai/types';
+import { extractJson } from '../utils';
 
 export const TOOL_GENERATION_SYSTEM_PROMPT = `You are an expert TypeScript developer specializing in creating tools for AI agents.
 Your task is to generate safe, efficient, and well-typed tool implementations.
@@ -205,13 +206,13 @@ export function parseGapAnalysisResponse(response: string): {
   canProceed: boolean;
   alternativeApproach?: string;
 } {
-  const jsonMatch = /\{[\s\S]*\}/.exec(response);
-  if (!jsonMatch) {
+  const json = extractJson(response);
+  if (!json) {
     return { hasGap: false, gaps: [], canProceed: true };
   }
 
   try {
-    const parsed = JSON.parse(jsonMatch[0]);
+    const parsed = JSON.parse(json);
     return {
       hasGap: Boolean(parsed.hasGap),
       gaps: Array.isArray(parsed.gaps)
@@ -238,13 +239,13 @@ export function parseGapAnalysisResponse(response: string): {
 }
 
 export function parseToolGenerationResponse(response: string): GeneratedTool | null {
-  const jsonMatch = /\{[\s\S]*\}/.exec(response);
-  if (!jsonMatch) {
+  const json = extractJson(response);
+  if (!json) {
     return null;
   }
 
   try {
-    const parsed = JSON.parse(jsonMatch[0]);
+    const parsed = JSON.parse(json);
     if (!parsed.name || !parsed.implementation) {
       return null;
     }
@@ -268,13 +269,13 @@ export function parseToolGenerationResponse(response: string): GeneratedTool | n
 }
 
 export function parseValidationResponse(response: string): ToolValidationResult | null {
-  const jsonMatch = /\{[\s\S]*\}/.exec(response);
-  if (!jsonMatch) {
+  const json = extractJson(response);
+  if (!json) {
     return null;
   }
 
   try {
-    const parsed = JSON.parse(jsonMatch[0]);
+    const parsed = JSON.parse(json);
 
     return {
       isValid: Boolean(parsed.isValid),

package/src/tool-generation/tool-generator.ts

@@ -8,6 +8,7 @@ import type {
 } from '@cogitator-ai/types';
 import { z, type ZodType } from 'zod';
 import { ToolValidator } from './tool-validator';
+import { ToolSandbox } from './tool-sandbox';
 import {
   TOOL_GENERATION_SYSTEM_PROMPT,
   buildToolGenerationPrompt,
@@ -32,6 +33,7 @@ export class ToolGenerator {
   private readonly llm: LLMBackend;
   private readonly config: ToolSelfGenerationConfig;
   private readonly validator: ToolValidator;
+  private readonly sandbox: ToolSandbox;
 
   constructor(options: ToolGeneratorOptions) {
     this.llm = options.llm;
@@ -40,6 +42,7 @@ export class ToolGenerator {
       llm: options.llm,
       config: options.config,
     });
+    this.sandbox = new ToolSandbox(options.config.sandboxConfig);
   }
 
   async generate(
@@ -203,7 +206,16 @@ export class ToolGenerator {
   }
 
   createExecutableTool(generated: GeneratedTool): Tool {
-    const execute = this.compileImplementation(generated.implementation);
+    const sandbox = this.sandbox;
+    const tool = generated;
+
+    const execute = async (params: unknown): Promise<unknown> => {
+      const result = await sandbox.execute(tool, params);
+      if (!result.success) {
+        throw new Error(result.error ?? 'Tool execution failed');
+      }
+      return result.result;
+    };
 
     return {
       name: generated.name,
@@ -221,20 +233,6 @@ export class ToolGenerator {
     };
   }
 
-  private compileImplementation(implementation: string): (params: unknown) => Promise<unknown> {
-    return async (params: unknown): Promise<unknown> => {
-      // eslint-disable-next-line @typescript-eslint/no-implied-eval
-      const factory = new Function(`
-        "use strict";
-        ${implementation}
-        return execute;
-      `);
-
-      const execute = factory();
-      return execute(params);
-    };
-  }
-
   private async callLLM(
     messages: Array<{ role: 'system' | 'user' | 'assistant'; content: string }>,
     temperature: number

package/src/tool-generation/tool-sandbox.ts

@@ -150,7 +150,8 @@ export class ToolSandbox {
       /\bexec\s*\(/,
       /\bspawn\s*\(/,
       /__proto__/,
-      /\bconstructor\s*\[/,
+      /\bconstructor\b/,
+      /\bgetPrototypeOf\b/,
     ];
 
     if (this.config.isolationLevel === 'strict') {
@@ -267,7 +268,16 @@ export class ToolSandbox {
         return execute;
       `);
       const execute = factory();
-      const result = await execute(params);
+
+      const result = await Promise.race([
+        execute(params),
+        new Promise((_, reject) =>
+          setTimeout(
+            () => reject(new Error(`Execution timeout: exceeded ${this.config.maxExecutionTime}ms`)),
+            this.config.maxExecutionTime
+          )
+        ),
+      ]);
 
       return {
         success: true,

package/src/utils/index.ts

@@ -1 +1,41 @@
 export { llmChat } from './llm-helper';
+
+export function extractJson(text: string): string | null {
+  const start = text.indexOf('{');
+  if (start === -1) return null;
+
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+
+    if (escape) {
+      escape = false;
+      continue;
+    }
+
+    if (ch === '\\' && inString) {
+      escape = true;
+      continue;
+    }
+
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (inString) continue;
+
+    if (ch === '{') depth++;
+    else if (ch === '}') {
+      depth--;
+      if (depth === 0) {
+        return text.slice(start, i + 1);
+      }
+    }
+  }
+
+  return null;
+}