@cogitator-ai/self-modifying 17.0.17 → 18.0.0

package/src/architecture-evolution/prompts.ts

@@ -37,10 +37,12 @@ ${contextSection}
 
 Respond with a JSON object:
 {
-  "complexity": "trivial" | "simple" | "moderate" | "complex" | "extreme",
+  "complexity": "trivial" | "simple" | "moderate" | "complex" | "expert" | "extreme",
   "domain": "general" | "coding" | "reasoning" | "creative" | "factual" | "conversational",
   "estimatedTokens": number,
   "requiresTools": boolean,
+  "requiresReasoning": boolean,
+  "requiresCreativity": boolean,
   "toolIntensity": "none" | "light" | "moderate" | "heavy",
   "reasoningDepth": "shallow" | "moderate" | "deep" | "exhaustive",
   "creativityLevel": "low" | "moderate" | "high",
@@ -58,8 +60,18 @@ export function buildCandidateGenerationPrompt(
     config: Partial<ArchitectureConfig>;
     score: number;
     metrics: Record<string, number>;
-  }>
+  }>,
+  options: { availableModels?: string[] } = {}
 ): string {
+  const availableModels = options.availableModels ?? [];
+  const modelLine =
+    availableModels.length > 0
+      ? `\n      "model": ${availableModels.map((m) => JSON.stringify(m)).join(' | ')} | null,`
+      : '';
+  const modelRule =
+    availableModels.length > 0
+      ? `Only use models from this list: ${availableModels.join(', ')}.`
+      : 'Do not change the model.';
   const historySection = historicalPerformance?.length
     ? `
 HISTORICAL PERFORMANCE:
@@ -83,18 +95,17 @@ ${historySection}
 
 Generate 3-5 candidate configurations that might improve performance.
 Each candidate should modify 1-3 parameters from current config.
+${modelRule}
 
 Respond with a JSON array:
 [
   {
     "id": "candidate_1",
-    "config": {
-      "model": "model name or null to keep current",
-      "temperature": number or null,
+    "config": {${modelLine}
+      "temperature": number between 0 and 2 or null,
       "maxTokens": number or null,
-      "systemPromptAdditions": "additional instructions or null",
       "toolStrategy": "sequential" | "parallel" | "adaptive" | null,
-      "reflectionDepth": number or null
+      "reflectionDepth": integer between 0 and 5 or null
     },
     "reasoning": "Why this configuration might help",
     "expectedImprovement": 0.0-1.0,
@@ -140,56 +151,187 @@ Respond with:
 }`;
 }
 
+const COMPLEXITIES: readonly TaskProfile['complexity'][] = [
+  'trivial',
+  'simple',
+  'moderate',
+  'complex',
+  'expert',
+  'extreme',
+];
+const DOMAINS: readonly TaskProfile['domain'][] = [
+  'general',
+  'coding',
+  'reasoning',
+  'creative',
+  'factual',
+  'conversational',
+];
+const TOOL_INTENSITIES: readonly TaskProfile['toolIntensity'][] = [
+  'none',
+  'light',
+  'moderate',
+  'heavy',
+];
+const REASONING_DEPTHS: readonly TaskProfile['reasoningDepth'][] = [
+  'shallow',
+  'moderate',
+  'deep',
+  'exhaustive',
+];
+const CREATIVITY_LEVELS: readonly TaskProfile['creativityLevel'][] = ['low', 'moderate', 'high'];
+const ACCURACY_LEVELS: readonly TaskProfile['accuracyRequirement'][] = [
+  'approximate',
+  'moderate',
+  'high',
+  'critical',
+];
+const TIME_CONSTRAINTS: readonly TaskProfile['timeConstraint'][] = [
+  'none',
+  'relaxed',
+  'moderate',
+  'strict',
+];
+const TOOL_STRATEGIES: readonly ArchitectureConfig['toolStrategy'][] = [
+  'sequential',
+  'parallel',
+  'adaptive',
+];
+const RISKS: readonly EvolutionCandidate['risk'][] = ['low', 'medium', 'high'];
+
+export const MAX_TOKENS_RANGE = { min: 100, max: 32000 } as const;
+export const REFLECTION_DEPTH_RANGE = { min: 0, max: 5 } as const;
+export const TEMPERATURE_RANGE = { min: 0, max: 2 } as const;
+
+function pickEnum<T extends string>(value: unknown, allowed: readonly T[], fallback: T): T {
+  return typeof value === 'string' && (allowed as readonly string[]).includes(value)
+    ? (value as T)
+    : fallback;
+}
+
+function finiteNumber(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function clamp(value: number, range: { min: number; max: number }): number {
+  return Math.min(range.max, Math.max(range.min, value));
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
 export function parseTaskProfileResponse(response: string): TaskProfile | null {
   const json = extractJson(response);
   if (!json) return null;
 
+  let parsed: unknown;
   try {
-    const parsed = JSON.parse(json);
-
-    return {
-      complexity: parsed.complexity || 'moderate',
-      domain: parsed.domain || 'general',
-      estimatedTokens: parsed.estimatedTokens || 1000,
-      requiresTools: Boolean(parsed.requiresTools),
-      toolIntensity: parsed.toolIntensity || 'none',
-      reasoningDepth: parsed.reasoningDepth || 'moderate',
-      creativityLevel: parsed.creativityLevel || 'moderate',
-      accuracyRequirement: parsed.accuracyRequirement || 'moderate',
-      timeConstraint: parsed.timeConstraint || 'none',
-    };
+    parsed = JSON.parse(json);
   } catch {
     return null;
   }
+  if (!isRecord(parsed)) return null;
+
+  const estimatedTokens = finiteNumber(parsed.estimatedTokens);
+
+  return {
+    complexity: pickEnum(parsed.complexity, COMPLEXITIES, 'moderate'),
+    domain: pickEnum(parsed.domain, DOMAINS, 'general'),
+    estimatedTokens:
+      estimatedTokens !== undefined && estimatedTokens > 0 ? Math.round(estimatedTokens) : 1000,
+    requiresTools: Boolean(parsed.requiresTools),
+    requiresReasoning: Boolean(parsed.requiresReasoning),
+    requiresCreativity: Boolean(parsed.requiresCreativity),
+    toolIntensity: pickEnum(parsed.toolIntensity, TOOL_INTENSITIES, 'none'),
+    reasoningDepth: pickEnum(parsed.reasoningDepth, REASONING_DEPTHS, 'moderate'),
+    creativityLevel: pickEnum(parsed.creativityLevel, CREATIVITY_LEVELS, 'moderate'),
+    accuracyRequirement: pickEnum(parsed.accuracyRequirement, ACCURACY_LEVELS, 'moderate'),
+    timeConstraint: pickEnum(parsed.timeConstraint, TIME_CONSTRAINTS, 'none'),
+  };
 }
 
-export function parseCandidateGenerationResponse(response: string): EvolutionCandidate[] {
-  const jsonMatch = /\[[\s\S]*\]/.exec(response);
-  if (!jsonMatch) return [];
+export function sanitizeCandidateConfig(
+  raw: unknown,
+  options: { availableModels?: string[] } = {}
+): Partial<ArchitectureConfig> {
+  if (!isRecord(raw)) return {};
+  const config: Partial<ArchitectureConfig> = {};
+
+  if (typeof raw.model === 'string' && options.availableModels?.includes(raw.model)) {
+    config.model = raw.model;
+  }
+
+  const temperature = finiteNumber(raw.temperature);
+  if (temperature !== undefined) {
+    config.temperature = clamp(temperature, TEMPERATURE_RANGE);
+  }
 
+  const maxTokens = finiteNumber(raw.maxTokens);
+  if (maxTokens !== undefined) {
+    config.maxTokens = clamp(Math.round(maxTokens), MAX_TOKENS_RANGE);
+  }
+
+  if (
+    typeof raw.toolStrategy === 'string' &&
+    (TOOL_STRATEGIES as readonly string[]).includes(raw.toolStrategy)
+  ) {
+    config.toolStrategy = raw.toolStrategy as ArchitectureConfig['toolStrategy'];
+  }
+
+  const reflectionDepth = finiteNumber(raw.reflectionDepth);
+  if (reflectionDepth !== undefined) {
+    config.reflectionDepth = clamp(Math.round(reflectionDepth), REFLECTION_DEPTH_RANGE);
+  }
+
+  return config;
+}
+
+export function parseCandidateGenerationResponse(
+  response: string,
+  options: { availableModels?: string[] } = {}
+): EvolutionCandidate[] {
+  const json = extractJsonArray(response);
+  if (!json) return [];
+
+  let parsed: unknown;
   try {
-    const parsed = JSON.parse(jsonMatch[0]);
-    if (!Array.isArray(parsed)) return [];
-
-    return parsed
-      .filter((c: Record<string, unknown>) => c && typeof c === 'object' && c.config)
-      .map((c: Record<string, unknown>, idx: number) => ({
-        id: String(c.id || `candidate_${idx}`),
-        config: c.config as Partial<ArchitectureConfig>,
-        reasoning: String(c.reasoning || ''),
-        expectedImprovement:
-          typeof c.expectedImprovement === 'number' ? c.expectedImprovement : 0.5,
-        risk: (['low', 'medium', 'high'].includes(String(c.risk)) ? c.risk : 'medium') as
-          | 'low'
-          | 'medium'
-          | 'high',
-        generation: 0,
-        score: 0,
-        evaluationCount: 0,
-      }));
+    parsed = JSON.parse(json);
   } catch {
     return [];
   }
+  if (!Array.isArray(parsed)) return [];
+
+  const usedIds = new Set<string>(['baseline']);
+  const candidates: EvolutionCandidate[] = [];
+
+  parsed.forEach((raw: unknown, idx: number) => {
+    if (!isRecord(raw)) return;
+    const config = sanitizeCandidateConfig(raw.config, options);
+    if (Object.keys(config).length === 0) return;
+
+    let id = typeof raw.id === 'string' && raw.id.trim() ? raw.id.trim() : `candidate_${idx}`;
+    while (usedIds.has(id)) {
+      id = `${id}_${idx}`;
+    }
+    usedIds.add(id);
+
+    const expectedImprovement = finiteNumber(raw.expectedImprovement);
+
+    candidates.push({
+      id,
+      config,
+      reasoning: typeof raw.reasoning === 'string' ? raw.reasoning : '',
+      expectedImprovement:
+        expectedImprovement !== undefined ? clamp(expectedImprovement, { min: 0, max: 1 }) : 0.5,
+      risk: pickEnum(raw.risk, RISKS, 'medium'),
+      generation: 0,
+      score: 0,
+      evaluationCount: 0,
+    });
+  });
+
+  return candidates;
 }
 
 export function parsePerformanceAnalysisResponse(response: string): {
@@ -214,3 +356,43 @@ export function parsePerformanceAnalysisResponse(response: string): {
     return null;
   }
 }
+
+function extractJsonArray(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 === '[' || ch === '{') depth++;
+    else if (ch === ']' || ch === '}') {
+      depth--;
+      if (depth === 0) {
+        return text.slice(start, i + 1);
+      }
+    }
+  }
+
+  return null;
+}

package/src/constraints/modification-validator.ts

@@ -74,6 +74,9 @@ export class ModificationValidator {
     const results: ConstraintCheckResult[] = [];
 
     for (const constraint of this.constraints.safety) {
+      if (constraint.appliesTo && !constraint.appliesTo.includes(request.type)) {
+        continue;
+      }
       const satisfied = this.evaluateSafetyRule(constraint.rule, request);
       results.push({
         constraintId: constraint.id,
@@ -88,14 +91,26 @@ export class ModificationValidator {
   }
 
   private evaluateSafetyRule(rule: ConstraintRule, request: ModificationRequest): boolean {
+    const context = this.payloadOf(request);
+
     if (typeof rule === 'string') {
-      return this.evaluateExpression(rule, request.payload as Record<string, unknown>);
+      return this.evaluateExpression(rule, context);
+    }
+
+    const checks: boolean[] = [];
+
+    if (rule.expression) {
+      checks.push(this.evaluateExpression(rule.expression, context));
     }
 
-    return this.evaluateExpression(
-      rule.expression ?? '',
-      request.payload as Record<string, unknown>
-    );
+    if (rule.pattern) {
+      const subject = JSON.stringify(request.changes ?? request.payload ?? '');
+      checks.push(rule.pattern.test(subject));
+    }
+
+    if (checks.length === 0) return false;
+
+    return checks.every(Boolean);
   }
 
   private evaluateExpression(expression: string, context: Record<string, unknown>): boolean {
@@ -159,10 +174,20 @@ export class ModificationValidator {
     return Boolean(value);
   }
 
+  private payloadOf(request: ModificationRequest): Record<string, unknown> {
+    const payload = request.payload;
+    return payload && typeof payload === 'object' && !Array.isArray(payload)
+      ? (payload as Record<string, unknown>)
+      : {};
+  }
+
   private resolveValue(expr: string, context: Record<string, unknown>): unknown {
     if (expr === 'true') return true;
     if (expr === 'false') return false;
-    if (/^\d+(\.\d+)?$/.test(expr)) return parseFloat(expr);
+    if (expr === 'null') return null;
+    if (/^-?\d+(\.\d+)?$/.test(expr)) return parseFloat(expr);
+    const quoted = /^(['"])(.*)\1$/.exec(expr);
+    if (quoted) return quoted[2];
 
     const keys = expr.split('.');
     let current: unknown = context;
@@ -181,34 +206,36 @@ export class ModificationValidator {
   ): Promise<ConstraintCheckResult[]> {
     const results: ConstraintCheckResult[] = [];
 
-    if (request.type !== 'tool_generation') {
+    if (request.type !== 'tool_generation' && request.type !== 'tool_creation') {
       return results;
     }
 
-    const payload = request.payload as { category?: string; complexity?: number };
+    const payload = this.payloadOf(request) as { category?: unknown; complexity?: unknown };
+    const category = typeof payload.category === 'string' ? payload.category : undefined;
+    const complexity = typeof payload.complexity === 'number' ? payload.complexity : undefined;
 
     for (const constraint of this.constraints.capability) {
       let satisfied = true;
       let message: string | undefined;
 
-      if (payload.category) {
-        if (constraint.forbidden?.includes(payload.category)) {
+      if (category) {
+        if (constraint.forbidden?.includes(category)) {
           satisfied = false;
-          message = `Category '${payload.category}' is forbidden`;
-        } else if (constraint.allowed?.length && !constraint.allowed.includes(payload.category)) {
+          message = `Category '${category}' is forbidden`;
+        } else if (constraint.allowed?.length && !constraint.allowed.includes(category)) {
           satisfied = false;
-          message = `Category '${payload.category}' is not in allowed list`;
+          message = `Category '${category}' is not in allowed list`;
         }
       }
 
       if (
         satisfied &&
-        constraint.maxComplexity &&
-        payload.complexity &&
-        payload.complexity > constraint.maxComplexity
+        constraint.maxComplexity !== undefined &&
+        complexity !== undefined &&
+        complexity > constraint.maxComplexity
       ) {
         satisfied = false;
-        message = `Complexity ${payload.complexity} exceeds max ${constraint.maxComplexity}`;
+        message = `Complexity ${complexity} exceeds max ${constraint.maxComplexity}`;
       }
 
       results.push({
@@ -227,7 +254,7 @@ export class ModificationValidator {
     request: ModificationRequest
   ): Promise<ConstraintCheckResult[]> {
     const results: ConstraintCheckResult[] = [];
-    const payload = (request.payload ?? {}) as {
+    const payload = this.payloadOf(request) as {
       tokensUsed?: number;
       cost?: number;
       activeTools?: number;
@@ -239,7 +266,7 @@ export class ModificationValidator {
 
       if (
         constraint.maxTokensPerRun &&
-        payload.tokensUsed &&
+        payload.tokensUsed != null &&
         payload.tokensUsed > constraint.maxTokensPerRun
       ) {
         satisfied = false;
@@ -249,7 +276,7 @@ export class ModificationValidator {
       if (
         satisfied &&
         constraint.maxCostPerRun &&
-        payload.cost &&
+        payload.cost != null &&
         payload.cost > constraint.maxCostPerRun
       ) {
         satisfied = false;
@@ -259,7 +286,7 @@ export class ModificationValidator {
       if (
         satisfied &&
         constraint.maxToolsActive &&
-        payload.activeTools &&
+        payload.activeTools != null &&
         payload.activeTools > constraint.maxToolsActive
       ) {
         satisfied = false;

package/src/constraints/rollback-manager.ts

@@ -119,11 +119,30 @@ export class RollbackManager {
     if (!checkpoint) return null;
 
     return {
-      agentConfig: checkpoint.agentConfig as unknown as AgentConfig,
+      agentConfig: this.toAgentConfig(checkpoint.agentConfig),
       tools: checkpoint.tools.map((t) => ({ ...t })),
     };
   }
 
+  private toAgentConfig(record: Record<string, unknown>): AgentConfig {
+    const config: AgentConfig = {
+      name: typeof record.name === 'string' ? record.name : 'agent',
+      model: typeof record.model === 'string' ? record.model : 'default',
+      instructions: typeof record.instructions === 'string' ? record.instructions : '',
+    };
+
+    if (typeof record.id === 'string') config.id = record.id;
+    if (typeof record.description === 'string') config.description = record.description;
+    if (typeof record.provider === 'string') config.provider = record.provider;
+    if (typeof record.temperature === 'number') config.temperature = record.temperature;
+    if (typeof record.topP === 'number') config.topP = record.topP;
+    if (typeof record.maxTokens === 'number') config.maxTokens = record.maxTokens;
+    if (typeof record.maxIterations === 'number') config.maxIterations = record.maxIterations;
+    if (typeof record.timeout === 'number') config.timeout = record.timeout;
+
+    return config;
+  }
+
   async rollbackToLatest(
     agentId: string
   ): Promise<{ agentConfig: AgentConfig; tools: Tool[] } | null> {

package/src/events/event-emitter.ts

@@ -30,7 +30,7 @@ export class SelfModifyingEventEmitter {
       ...(wildcardHandlers ? [...wildcardHandlers] : []),
     ];
 
-    await Promise.allSettled(
+    const results = await Promise.allSettled(
       allHandlers.map((h) => {
         try {
           return Promise.resolve(h(event));
@@ -39,21 +39,12 @@ export class SelfModifyingEventEmitter {
         }
       })
     );
-  }
 
-  createEvent(
-    type: SelfModifyingEventType,
-    runId: string,
-    agentId: string,
-    data: unknown
-  ): SelfModifyingEvent {
-    return {
-      type,
-      runId,
-      agentId,
-      timestamp: new Date(),
-      data,
-    };
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        console.error(`[self-modifying] event handler for "${event.type}" failed:`, result.reason);
+      }
+    }
   }
 
   removeAllListeners(event?: SelfModifyingEventType | '*'): void {

package/src/index.ts

@@ -1,6 +1,9 @@
 export {
   SelfModifyingAgent,
   type SelfModifyingAgentOptions,
+  type SelfModifyingAgentConfig,
+  type SelfModifyingEventDataMap,
+  type TypedSelfModifyingEvent,
   type RunContext,
 } from './self-modifying-agent';
 
@@ -15,11 +18,16 @@ export {
   buildGapAnalysisPrompt,
   buildToolGenerationPrompt,
   buildToolValidationPrompt,
+  buildToolImprovementPrompt,
   parseGapAnalysisResponse,
   parseToolGenerationResponse,
+  parseValidationResponse,
   type GapAnalyzerOptions,
   type ToolGeneratorOptions,
   type ToolValidatorOptions,
+  type ValidationRule,
+  type SandboxTestCase,
+  type GenerateOptions,
   type GenerationResult,
   type ToolUsageRecord,
   type ToolMetrics,
@@ -48,13 +56,17 @@ export {
   ARCHITECTURE_ANALYSIS_SYSTEM_PROMPT,
   buildTaskProfilePrompt,
   buildCandidateGenerationPrompt,
+  buildPerformanceAnalysisPrompt,
   parseTaskProfileResponse,
   parseCandidateGenerationResponse,
+  parsePerformanceAnalysisResponse,
+  sanitizeCandidateConfig,
   type CapabilityAnalyzerOptions,
   type EvolutionStrategyOptions,
   type ParameterOptimizerOptions,
   type SelectionResult,
   type OptimizationResult,
+  type HistoricalRecord,
 } from './architecture-evolution';
 
 export {
@@ -64,6 +76,8 @@ export {
   DEFAULT_SAFETY_CONSTRAINTS,
   DEFAULT_CAPABILITY_CONSTRAINTS,
   DEFAULT_RESOURCE_CONSTRAINTS,
+  createDefaultConstraints,
+  mergeConstraints,
   mergeSafetyConstraints,
   mergeCapabilityConstraints,
   mergeResourceConstraints,