@cogitator-ai/self-modifying 17.0.13 → 17.0.16

package/src/tool-generation/prompts.ts

@@ -1,27 +1,15 @@
 import type { CapabilityGap, GeneratedTool, ToolValidationResult } from '@cogitator-ai/types';
 import { extractJson } from '../utils';
 
-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 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": "async function execute(params) { ... }",
-  "parameters": { "type": "object", "properties": {...}, "required": [...] },
-  "reasoning": "Why this implementation was chosen"
-}`;
+export const TOOL_GENERATION_SYSTEM_PROMPT = `You generate JavaScript tools. Respond with ONLY a JSON object, no other text.
+
+Rules:
+- Plain JavaScript only, no TypeScript
+- No require/import/eval/process/fetch
+- Must have an async function called "execute"
+
+Example response:
+{"name":"add","description":"Add two numbers","implementation":"async function execute(params) { try { return params.a + params.b; } catch(e) { return 0; } }","parameters":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}},"required":["a","b"]},"reasoning":"Simple addition"}`;
 
 export function buildGapAnalysisPrompt(
   userIntent: string,
@@ -64,66 +52,19 @@ Respond with a JSON object:
 
 export function buildToolGenerationPrompt(
   gap: CapabilityGap,
-  existingTools: Array<{ name: string; description: string }>,
-  constraints?: {
+  _existingTools: Array<{ name: string; description: string }>,
+  _constraints?: {
     maxLines?: number;
     allowedModules?: string[];
     securityLevel?: 'strict' | 'moderate' | 'permissive';
   }
 ): string {
-  const securityRules = {
-    strict: `
-- NO file system access
-- NO network requests
-- NO eval() or Function constructor
-- NO dynamic imports
-- NO process or child_process access
-- ONLY pure computation`,
-    moderate: `
-- File system access ONLY if explicitly requested
-- Network requests ONLY to whitelisted domains
-- NO eval() or Function constructor
-- NO dynamic imports`,
-    permissive: `
-- File system access allowed with path validation
-- Network requests allowed
-- NO eval() or Function constructor`,
-  };
-
-  const security = constraints?.securityLevel || 'strict';
-  const maxLines = constraints?.maxLines || 100;
+  return `Create a tool named "${gap.suggestedToolName}".
+Task: ${gap.description}
+Formula/Logic: ${gap.requiredCapability}
 
-  return `Generate a plain JavaScript tool implementation for the following capability gap.
-
-CAPABILITY GAP:
-- Description: ${gap.description}
-- Required: ${gap.requiredCapability}
-- Suggested name: ${gap.suggestedToolName}
-- Complexity: ${gap.complexity}
-
-EXISTING TOOLS (avoid duplication):
-${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(', ')}` : ''}
-
-Generate a complete, self-contained tool following this exact structure:
-{
-  "name": "${gap.suggestedToolName}",
-  "description": "Clear description",
-  "implementation": "async function execute(params) { ... }",
-  "parameters": {
-    "type": "object",
-    "properties": { ... },
-    "required": [ ... ]
-  },
-  "reasoning": "Implementation rationale"
-}`;
+Respond with ONLY this JSON (no other text):
+{"name":"${gap.suggestedToolName}","description":"${gap.description}","implementation":"async function execute(params) { try { /* YOUR CODE HERE */ } catch(e) { throw e; } }","parameters":{"type":"object","properties":{/* DEFINE PARAMS */},"required":[/* REQUIRED PARAMS */]},"reasoning":"explanation"}`;
 }
 
 export function buildToolValidationPrompt(
@@ -244,32 +185,48 @@ export function parseGapAnalysisResponse(response: string): {
 
 export function parseToolGenerationResponse(response: string): GeneratedTool | null {
   const json = extractJson(response);
-  if (!json) {
-    return null;
+  if (json) {
+    try {
+      const parsed = JSON.parse(json);
+      if (parsed.name && parsed.implementation) {
+        return buildToolFromParsed(parsed);
+      }
+    } catch {}
   }
 
-  try {
-    const parsed = JSON.parse(json);
-    if (!parsed.name || !parsed.implementation) {
-      return null;
-    }
-
-    return {
-      id: `gen_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      name: String(parsed.name),
-      description: String(parsed.description || ''),
-      implementation: String(parsed.implementation),
-      parameters: parsed.parameters || { type: 'object', properties: {} },
-      createdAt: new Date(),
-      version: 1,
-      status: 'pending_validation',
-      metadata: {
-        reasoning: parsed.reasoning ? String(parsed.reasoning) : undefined,
-      },
-    };
-  } catch {
-    return null;
+  const fnRegex = /(?:async\s+)?function\s+execute\s*\([^)]*\)\s*\{[\s\S]*?\n\}/;
+  const fnMatch = fnRegex.exec(response);
+  if (fnMatch) {
+    const nameRegex = /["']?name["']?\s*[:=]\s*["']([^"']+)["']/;
+    const nameMatch = nameRegex.exec(response);
+    return buildToolFromParsed({
+      name: nameMatch?.[1] ?? 'generated_tool',
+      description: '',
+      implementation: fnMatch[0],
+      parameters: { type: 'object', properties: {} },
+    });
   }
+
+  return null;
+}
+
+function buildToolFromParsed(parsed: Record<string, unknown>): GeneratedTool {
+  return {
+    id: `gen_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    name: String(parsed.name),
+    description: String(parsed.description || ''),
+    implementation: String(parsed.implementation),
+    parameters: (parsed.parameters as GeneratedTool['parameters']) || {
+      type: 'object',
+      properties: {},
+    },
+    createdAt: new Date(),
+    version: 1,
+    status: 'pending_validation',
+    metadata: {
+      reasoning: parsed.reasoning ? String(parsed.reasoning) : undefined,
+    },
+  };
 }
 
 export function parseValidationResponse(response: string): ToolValidationResult | null {

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

@@ -71,13 +71,7 @@ export class ToolGenerator {
         }
 
         if (!currentTool) {
-          return {
-            tool: null,
-            validationResult: null,
-            iterations,
-            success: false,
-            error: 'Failed to generate tool implementation',
-          };
+          continue;
         }
 
         validationResult = await this.validator.validate(currentTool, testCases);

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

@@ -273,7 +273,8 @@ export class ToolSandbox {
         execute(params),
         new Promise((_, reject) =>
           setTimeout(
-            () => reject(new Error(`Execution timeout: exceeded ${this.config.maxExecutionTime}ms`)),
+            () =>
+              reject(new Error(`Execution timeout: exceeded ${this.config.maxExecutionTime}ms`)),
             this.config.maxExecutionTime
           )
         ),

package/src/utils/index.ts

@@ -1,15 +1,23 @@
 export { llmChat } from './llm-helper';
 
 export function extractJson(text: string): string | null {
-  const start = text.indexOf('{');
+  let cleaned = text;
+
+  const codeBlockRegex = /```(?:json)?\s*\n?([\s\S]*?)```/;
+  const codeBlockMatch = codeBlockRegex.exec(cleaned);
+  if (codeBlockMatch) {
+    cleaned = codeBlockMatch[1].trim();
+  }
+
+  const start = cleaned.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];
+  for (let i = start; i < cleaned.length; i++) {
+    const ch = cleaned[i];
 
     if (escape) {
       escape = false;
@@ -32,10 +40,22 @@ export function extractJson(text: string): string | null {
     else if (ch === '}') {
       depth--;
       if (depth === 0) {
-        return text.slice(start, i + 1);
+        return cleaned.slice(start, i + 1);
       }
     }
   }
 
+  if (depth > 0) {
+    let repaired = cleaned.slice(start);
+    repaired = repaired.replace(/,\s*$/, '');
+    repaired += '}'.repeat(depth);
+    try {
+      JSON.parse(repaired);
+      return repaired;
+    } catch {
+      return null;
+    }
+  }
+
   return null;
 }