@cogitator-ai/self-modifying 17.0.10 → 17.0.13

package/src/self-modifying-agent.ts

@@ -11,6 +11,9 @@ import type {
   ModificationCheckpoint,
   SelfModifyingEvent,
   CapabilityGap,
+  Message,
+  ToolSchema,
+  ToolContext,
 } from '@cogitator-ai/types';
 
 import { SelfModifyingEventEmitter } from './events';
@@ -67,18 +70,19 @@ export class SelfModifyingAgent {
     this.config = this.mergeConfig(options.config);
 
     const toolGenConfig = this.config.toolGeneration;
-    this.gapAnalyzer = new GapAnalyzer({ llm: this.llm, config: toolGenConfig });
-    this.toolGenerator = new ToolGenerator({ llm: this.llm, config: toolGenConfig });
+    const agentModel = this.agent.model;
+    this.gapAnalyzer = new GapAnalyzer({ llm: this.llm, config: toolGenConfig, model: agentModel });
+    this.toolGenerator = new ToolGenerator({ llm: this.llm, config: toolGenConfig, model: agentModel });
     this.toolStore = new InMemoryGeneratedToolStore();
 
     this.metaReasoner = new MetaReasoner({
       llm: this.llm,
-      model: 'default',
+      model: agentModel ?? 'default',
       config: this.config.metaReasoning,
     });
 
     const baseArchConfig: ArchitectureConfig = {
-      model: 'default',
+      model: agentModel ?? 'default',
       temperature: 0.7,
       maxTokens: 4096,
       toolStrategy: 'sequential',
@@ -89,11 +93,13 @@ export class SelfModifyingAgent {
       llm: this.llm,
       config: this.config.architectureEvolution,
       baseConfig: baseArchConfig,
+      model: agentModel,
     });
 
     this.capabilityAnalyzer = new CapabilityAnalyzer({
       llm: this.llm,
       enableLLMAnalysis: true,
+      model: agentModel,
     });
 
     this.modificationValidator = new ModificationValidator({
@@ -372,11 +378,8 @@ export class SelfModifyingAgent {
           reflective: { mode: 'reflective', temperature: 0.4, depth: 3 },
           exploratory: { mode: 'exploratory', temperature: 0.7, depth: 2 },
         },
-        maxAssessmentsPerRun: 5,
-        maxAdaptationsPerRun: 3,
         maxMetaAssessments: 5,
         maxAdaptations: 3,
-        assessmentCooldown: 10000,
         metaAssessmentCooldown: 10000,
         adaptationCooldown: 15000,
         triggers: ['on_failure', 'on_low_confidence', 'periodic'],
@@ -598,19 +601,90 @@ export class SelfModifyingAgent {
   }
 
   private async executeAgentStep(input: string): Promise<string> {
-    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 },
-      ],
+    const tools = this.currentContext?.tools ?? [];
+    const toolSchemas = this.buildToolSchemas(tools);
+    const toolMap = new Map<string, Tool>();
+    for (const t of tools) {
+      toolMap.set(t.name, t);
+    }
+
+    const model = this.currentContext?.currentConfig.model ?? this.agent.model ?? 'default';
+    const messages: Message[] = [
+      ...(this.agent.instructions
+        ? [{ role: 'system' as const, content: this.agent.instructions }]
+        : []),
+      { role: 'user' as const, content: input },
+    ];
+
+    const maxToolRounds = 10;
+    for (let round = 0; round < maxToolRounds; round++) {
+      const response = await this.llm.chat({
+        model,
+        messages,
+        tools: toolSchemas.length > 0 ? toolSchemas : undefined,
+        temperature: this.currentContext?.currentConfig.temperature,
+        maxTokens: this.currentContext?.currentConfig.maxTokens,
+      });
+
+      if (response.finishReason !== 'tool_calls' || !response.toolCalls?.length) {
+        return response.content;
+      }
+
+      messages.push({
+        role: 'assistant',
+        content: response.content,
+        toolCalls: response.toolCalls,
+      } as Message);
+
+      for (const toolCall of response.toolCalls) {
+        const t = toolMap.get(toolCall.name);
+        let result: unknown;
+
+        if (!t) {
+          result = { error: `Tool "${toolCall.name}" not found` };
+        } else {
+          try {
+            const ctx: ToolContext = {
+              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({
+          role: 'tool' as const,
+          content: typeof result === 'string' ? result : JSON.stringify(result),
+          toolCallId: toolCall.id,
+          name: toolCall.name,
+        });
+      }
+    }
+
+    const finalResponse = await this.llm.chat({
+      model,
+      messages,
       temperature: this.currentContext?.currentConfig.temperature,
       maxTokens: this.currentContext?.currentConfig.maxTokens,
     });
+    return finalResponse.content;
+  }
 
-    return response.content;
+  private buildToolSchemas(tools: Tool[]): ToolSchema[] {
+    return tools
+      .map((t) => {
+        if (typeof t.toJSON === 'function') {
+          return t.toJSON() as ToolSchema;
+        }
+        return {
+          name: t.name,
+          description: t.description,
+          parameters: { type: 'object' as const, properties: {} },
+        };
+      });
   }
 
   private estimateConfidence(output: string): number {

package/src/tool-generation/gap-analyzer.ts

@@ -10,16 +10,19 @@ import { buildGapAnalysisPrompt, parseGapAnalysisResponse } from './prompts';
 export interface GapAnalyzerOptions {
   llm: LLMBackend;
   config: ToolSelfGenerationConfig;
+  model?: string;
 }
 
 export class GapAnalyzer {
   private readonly llm: LLMBackend;
   private readonly config: ToolSelfGenerationConfig;
+  private readonly model: string;
   private readonly analysisCache = new Map<string, GapAnalysisResult>();
 
   constructor(options: GapAnalyzerOptions) {
     this.llm = options.llm;
     this.config = options.config;
+    this.model = options.model ?? 'default';
   }
 
   async analyze(
@@ -233,6 +236,6 @@ Consider tool composition before suggesting new tools.`,
     if (this.llm.complete) {
       return this.llm.complete({ messages, temperature });
     }
-    return this.llm.chat({ model: 'default', messages, temperature });
+    return this.llm.chat({ model: this.model, messages, temperature });
   }
 }

package/src/tool-generation/prompts.ts

@@ -1,23 +1,24 @@
 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.
+export const TOOL_GENERATION_SYSTEM_PROMPT = `You are an expert JavaScript developer specializing in creating tools for AI agents.
+Your task is to generate safe, efficient tool implementations.
 
 CRITICAL CONSTRAINTS:
-1. Generate ONLY pure TypeScript functions - no external dependencies beyond built-in modules
-2. All generated code must be self-contained and synchronous where possible
-3. Never generate code that accesses file system, network, or system resources unless explicitly requested
-4. Always include proper error handling
-5. Use Zod for parameter validation when schemas are provided
-6. Follow the exact Tool interface structure
+1. Generate ONLY plain JavaScript (ES2020+) - NO TypeScript syntax, NO type annotations, NO interfaces
+2. No external dependencies - only built-in globals (Math, JSON, Date, Array, Object, String, Number, Boolean, RegExp, Map, Set, Error)
+3. All generated code must be self-contained
+4. Never generate code that accesses file system, network, or system resources
+5. Always include proper error handling with try-catch
+6. The implementation MUST define an async function called "execute" that takes a params object and returns a result
+7. Do NOT use: eval, Function, import, require, process, global, fetch, setTimeout, setInterval, constructor
 
 OUTPUT FORMAT:
 Return a JSON object with:
 {
   "name": "tool_name",
   "description": "Clear description of what the tool does",
-  "implementation": "// TypeScript code as a string",
+  "implementation": "async function execute(params) { ... }",
   "parameters": { "type": "object", "properties": {...}, "required": [...] },
   "reasoning": "Why this implementation was chosen"
 }`;
@@ -92,7 +93,7 @@ export function buildToolGenerationPrompt(
   const security = constraints?.securityLevel || 'strict';
   const maxLines = constraints?.maxLines || 100;
 
-  return `Generate a TypeScript tool implementation for the following capability gap.
+  return `Generate a plain JavaScript tool implementation for the following capability gap.
 
 CAPABILITY GAP:
 - Description: ${gap.description}
@@ -106,6 +107,8 @@ ${existingTools.map((t) => `- ${t.name}: ${t.description}`).join('\n')}
 CONSTRAINTS:
 - Maximum ${maxLines} lines of code
 - Security level: ${security}
+- MUST use plain JavaScript (ES2020+), NO TypeScript syntax, NO type annotations, NO interfaces
+- The "implementation" field must define an async function called "execute" that takes a plain object "params"
 ${securityRules[security]}
 ${constraints?.allowedModules ? `- Allowed modules: ${constraints.allowedModules.join(', ')}` : ''}
 
@@ -113,7 +116,7 @@ Generate a complete, self-contained tool following this exact structure:
 {
   "name": "${gap.suggestedToolName}",
   "description": "Clear description",
-  "implementation": "async function execute(params: Params): Promise<Result> { ... }",
+  "implementation": "async function execute(params) { ... }",
   "parameters": {
     "type": "object",
     "properties": { ... },
@@ -190,11 +193,12 @@ SUGGESTIONS:
 ${validationResult.suggestions.map((s, idx) => `${idx + 1}. ${s}`).join('\n')}
 
 Generate an improved implementation that addresses ALL issues.
+IMPORTANT: Use plain JavaScript only (NO TypeScript, NO type annotations). The execute function signature must be: async function execute(params) { ... }
 Respond with the same JSON format as before:
 {
   "name": "${tool.name}",
   "description": "Updated description if needed",
-  "implementation": "// Improved TypeScript code",
+  "implementation": "async function execute(params) { ... }",
   "parameters": { ... },
   "reasoning": "What was changed and why"
 }`;

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

@@ -19,6 +19,7 @@ import {
 export interface ToolGeneratorOptions {
   llm: LLMBackend;
   config: ToolSelfGenerationConfig;
+  model?: string;
 }
 
 export interface GenerationResult {
@@ -32,15 +33,18 @@ export interface GenerationResult {
 export class ToolGenerator {
   private readonly llm: LLMBackend;
   private readonly config: ToolSelfGenerationConfig;
+  private readonly model: string;
   private readonly validator: ToolValidator;
   private readonly sandbox: ToolSandbox;
 
   constructor(options: ToolGeneratorOptions) {
     this.llm = options.llm;
     this.config = options.config;
+    this.model = options.model ?? 'default';
     this.validator = new ToolValidator({
       llm: options.llm,
       config: options.config,
+      model: options.model,
     });
     this.sandbox = new ToolSandbox(options.config.sandboxConfig);
   }
@@ -240,6 +244,6 @@ export class ToolGenerator {
     if (this.llm.complete) {
       return this.llm.complete({ messages, temperature });
     }
-    return this.llm.chat({ model: 'default', messages, temperature });
+    return this.llm.chat({ model: this.model, messages, temperature });
   }
 }

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

@@ -10,6 +10,7 @@ import { buildToolValidationPrompt, parseValidationResponse } from './prompts';
 export interface ToolValidatorOptions {
   llm?: LLMBackend;
   config: ToolSelfGenerationConfig;
+  model?: string;
 }
 
 interface ValidationRule {
@@ -141,12 +142,14 @@ const STATIC_VALIDATION_RULES: ValidationRule[] = [
 export class ToolValidator {
   private readonly llm?: LLMBackend;
   private readonly config: ToolSelfGenerationConfig;
+  private readonly model: string;
   private readonly sandbox: ToolSandbox;
   private readonly customRules: ValidationRule[] = [];
 
   constructor(options: ToolValidatorOptions) {
     this.llm = options.llm;
     this.config = options.config;
+    this.model = options.model ?? 'default';
     this.sandbox = new ToolSandbox(options.config.sandboxConfig);
   }
 
@@ -303,11 +306,6 @@ Be thorough but practical - focus on real issues.`,
         validInput[key] = this.generateSampleValue(schema.type, schema.default);
       }
       testCases.push({ input: validInput });
-
-      const required = params.required as string[] | undefined;
-      testCases.push({ input: {}, shouldThrow: (required?.length ?? 0) > 0 });
-
-      testCases.push({ input: null, shouldThrow: true });
     }
 
     return testCases;
@@ -364,6 +362,6 @@ Be thorough but practical - focus on real issues.`,
     if (this.llm.complete) {
       return this.llm.complete({ messages, temperature });
     }
-    return this.llm.chat({ model: 'default', messages, temperature });
+    return this.llm.chat({ model: this.model, messages, temperature });
   }
 }