@cogitator-ai/self-modifying 17.0.17 → 18.0.0

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

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import type {
   Tool,
   LLMBackend,
@@ -6,6 +7,7 @@ import type {
   ToolSelfGenerationConfig,
 } from '@cogitator-ai/types';
 import { buildGapAnalysisPrompt, parseGapAnalysisResponse } from './prompts';
+import { llmChat } from '../utils/llm-helper';
 
 export interface GapAnalyzerOptions {
   llm: LLMBackend;
@@ -33,7 +35,7 @@ export class GapAnalyzer {
       previousGaps?: CapabilityGap[];
     }
   ): Promise<GapAnalysisResult> {
-    const cacheKey = this.buildCacheKey(userIntent, availableTools);
+    const cacheKey = this.buildCacheKey(userIntent, availableTools, context);
     const cached = this.analysisCache.get(cacheKey);
     if (cached && Date.now() - cached.timestamp.getTime() < 60000) {
       return cached;
@@ -46,7 +48,8 @@ export class GapAnalyzer {
 
     const prompt = buildGapAnalysisPrompt(userIntent, toolSummaries, context?.failedAttempts);
 
-    const response = await this.callLLM(
+    const content = await llmChat(
+      this.llm,
       [
         {
           role: 'system',
@@ -57,10 +60,10 @@ Consider tool composition before suggesting new tools.`,
         },
         { role: 'user', content: prompt },
       ],
-      0.3
+      { model: this.model, temperature: 0.3 }
     );
 
-    const parsed = parseGapAnalysisResponse(response.content);
+    const parsed = parseGapAnalysisResponse(content);
     const filteredGaps = this.filterAndPrioritizeGaps(
       parsed.gaps,
       availableTools,
@@ -151,7 +154,6 @@ Consider tool composition before suggesting new tools.`,
       return 1.0;
     }
 
-    const _intentWords = userIntent.toLowerCase().split(/\s+/).length;
     const toolDescriptionWords = availableTools
       .map((t) => t.description.toLowerCase().split(/\s+/))
       .flat();
@@ -217,25 +219,25 @@ Consider tool composition before suggesting new tools.`,
     return `Identified ${gaps.length} capability gap(s):\n${gapDescriptions}`;
   }
 
-  private buildCacheKey(userIntent: string, tools: Tool[]): string {
+  private buildCacheKey(
+    userIntent: string,
+    tools: Tool[],
+    context?: { failedAttempts?: string[]; previousGaps?: CapabilityGap[] }
+  ): string {
     const toolSignature = tools
-      .map((t) => t.name)
+      .map((t) => `${t.name}:${t.description}`)
       .sort()
-      .join(',');
-    return `${userIntent.slice(0, 100)}|${toolSignature}`;
+      .join('\n');
+    const raw = JSON.stringify([
+      userIntent,
+      toolSignature,
+      context?.failedAttempts ?? [],
+      (context?.previousGaps ?? []).map((g) => g.id).sort(),
+    ]);
+    return createHash('sha256').update(raw).digest('hex');
   }
 
   clearCache(): void {
     this.analysisCache.clear();
   }
-
-  private async callLLM(
-    messages: Array<{ role: 'system' | 'user' | 'assistant'; content: string }>,
-    temperature: number
-  ) {
-    if (this.llm.complete) {
-      return this.llm.complete({ messages, temperature });
-    }
-    return this.llm.chat({ model: this.model, messages, temperature });
-  }
 }

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

@@ -1,5 +1,78 @@
 import type { GeneratedTool, GeneratedToolStore as IGeneratedToolStore } from '@cogitator-ai/types';
 
+const STOP_WORDS = new Set([
+  'the',
+  'and',
+  'for',
+  'not',
+  'are',
+  'was',
+  'were',
+  'been',
+  'being',
+  'have',
+  'has',
+  'had',
+  'does',
+  'did',
+  'will',
+  'would',
+  'could',
+  'should',
+  'may',
+  'might',
+  'shall',
+  'can',
+  'this',
+  'that',
+  'these',
+  'those',
+  'with',
+  'from',
+  'into',
+  'through',
+  'during',
+  'before',
+  'after',
+  'above',
+  'below',
+  'between',
+  'under',
+  'over',
+  'again',
+  'further',
+  'then',
+  'once',
+  'here',
+  'there',
+  'when',
+  'where',
+  'why',
+  'how',
+  'all',
+  'each',
+  'every',
+  'both',
+  'few',
+  'more',
+  'most',
+  'other',
+  'some',
+  'such',
+  'only',
+  'own',
+  'same',
+  'than',
+  'too',
+  'very',
+  'just',
+  'because',
+  'but',
+  'nor',
+  'yet',
+  'about',
+]);
+
 export interface ToolUsageRecord {
   toolId: string;
   timestamp: Date;
@@ -25,7 +98,7 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
 
   async save(tool: GeneratedTool): Promise<void> {
     const existing = this.tools.get(tool.id);
-    const version = existing ? existing.version + 1 : tool.version;
+    const version = existing ? existing.version + 1 : 1;
     this.tools.set(tool.id, { ...tool, version, updatedAt: new Date() });
   }
 
@@ -140,17 +213,27 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
   }
 
   async findSimilar(description: string, limit: number = 5): Promise<GeneratedTool[]> {
-    const descWords = new Set(description.toLowerCase().split(/\s+/));
+    const descWords = new Set(
+      description
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length >= 3 && !STOP_WORDS.has(w))
+    );
     const scored: Array<{ tool: GeneratedTool; score: number }> = [];
 
     for (const tool of this.tools.values()) {
       if (tool.status === 'deprecated') continue;
 
-      const toolWords = new Set(`${tool.name} ${tool.description}`.toLowerCase().split(/\s+/));
+      const toolWords = new Set(
+        `${tool.name} ${tool.description}`
+          .toLowerCase()
+          .split(/\s+/)
+          .filter((w) => w.length >= 3 && !STOP_WORDS.has(w))
+      );
 
       let matchCount = 0;
       for (const word of descWords) {
-        if (word.length >= 3 && toolWords.has(word)) {
+        if (toolWords.has(word)) {
           matchCount++;
         }
       }
@@ -204,13 +287,13 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
     let removed = 0;
     const now = Date.now();
 
+    const keysToRemove: string[] = [];
+
     for (const [id, tool] of this.tools) {
       if (options.maxAge && tool.createdAt) {
         const age = now - tool.createdAt.getTime();
         if (age > options.maxAge && tool.status !== 'active') {
-          this.tools.delete(id);
-          this.usageRecords.delete(id);
-          removed++;
+          keysToRemove.push(id);
           continue;
         }
       }
@@ -218,13 +301,17 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
       if (options.minUsage !== undefined) {
         const usage = tool.usageCount || 0;
         if (usage < options.minUsage && tool.status === 'deprecated') {
-          this.tools.delete(id);
-          this.usageRecords.delete(id);
-          removed++;
+          keysToRemove.push(id);
         }
       }
     }
 
+    for (const id of keysToRemove) {
+      this.tools.delete(id);
+      this.usageRecords.delete(id);
+      removed++;
+    }
+
     if (options.maxDeprecated !== undefined) {
       const deprecated = Array.from(this.tools.values())
         .filter((t) => t.status === 'deprecated')

package/src/tool-generation/index.ts

@@ -1,7 +1,17 @@
 export { GapAnalyzer, type GapAnalyzerOptions } from './gap-analyzer';
-export { ToolGenerator, type ToolGeneratorOptions, type GenerationResult } from './tool-generator';
-export { ToolValidator, type ToolValidatorOptions } from './tool-validator';
-export { ToolSandbox, DEFAULT_SANDBOX_CONFIG } from './tool-sandbox';
+export {
+  ToolGenerator,
+  type ToolGeneratorOptions,
+  type GenerateOptions,
+  type GenerationResult,
+} from './tool-generator';
+export { ToolValidator, type ToolValidatorOptions, type ValidationRule } from './tool-validator';
+export {
+  ToolSandbox,
+  DEFAULT_SANDBOX_CONFIG,
+  deepEqual,
+  type SandboxTestCase,
+} from './tool-sandbox';
 export {
   InMemoryGeneratedToolStore,
   type ToolUsageRecord,

package/src/tool-generation/prompts.ts

@@ -7,9 +7,30 @@ Rules:
 - Plain JavaScript only, no TypeScript
 - No require/import/eval/process/fetch
 - Must have an async function called "execute"
+- Always propagate errors with throw, never silently swallow them
 
 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"}`;
+{"name":"add","description":"Add two numbers","implementation":"async function execute(params) { if (typeof params.a !== 'number' || typeof params.b !== 'number') { throw new Error('Parameters a and b must be numbers'); } return params.a + params.b; }","parameters":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}},"required":["a","b"]},"reasoning":"Simple addition"}`;
+
+const TOOL_NAME_REGEX = /^[a-z_][a-z0-9_]*$/;
+
+function sanitizeForPrompt(value: string): string {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
+}
+
+function sanitizeToolName(name: string): string {
+  const cleaned = name
+    .toLowerCase()
+    .replace(/[^a-z0-9_]/g, '_')
+    .replace(/^[0-9]/, '_$&')
+    .slice(0, 64);
+  return TOOL_NAME_REGEX.test(cleaned) ? cleaned : `generated_tool_${Date.now()}`;
+}
 
 export function buildGapAnalysisPrompt(
   userIntent: string,
@@ -52,19 +73,59 @@ 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';
+    parameters?: Record<string, unknown>;
   }
 ): string {
-  return `Create a tool named "${gap.suggestedToolName}".
-Task: ${gap.description}
-Formula/Logic: ${gap.requiredCapability}
+  const toolName = sanitizeToolName(gap.suggestedToolName);
+  const description = sanitizeForPrompt(gap.description);
+  const capability = sanitizeForPrompt(gap.requiredCapability);
+
+  const existingToolsSection =
+    existingTools.length > 0
+      ? `\nEXISTING TOOLS (avoid duplication, consider composing with these):\n${existingTools.map((t) => `- ${t.name}: ${t.description}`).join('\n')}\n`
+      : '';
+
+  const constraintsSection: string[] = [];
+  if (constraints?.maxLines) {
+    constraintsSection.push(`- Maximum ${constraints.maxLines} lines of code`);
+  }
+  if (constraints?.securityLevel) {
+    constraintsSection.push(`- Security level: ${constraints.securityLevel}`);
+  }
+  if (constraints?.allowedModules && constraints.allowedModules.length > 0) {
+    constraintsSection.push(
+      `- Only these modules may be referenced: ${constraints.allowedModules.join(', ')}`
+    );
+  }
+  if (constraints?.securityLevel === 'strict') {
+    constraintsSection.push(
+      '- No eval, Function constructor, process, global, globalThis, fetch, setTimeout, setInterval',
+      '- No bracket notation access to global objects',
+      '- No prototype chain manipulation'
+    );
+  }
 
+  const constraintsText =
+    constraintsSection.length > 0 ? `\nCONSTRAINTS:\n${constraintsSection.join('\n')}\n` : '';
+
+  const parametersJson = constraints?.parameters
+    ? JSON.stringify(constraints.parameters)
+    : '{"type":"object","properties":{/* DEFINE PARAMS */},"required":[/* REQUIRED PARAMS */]}';
+  const parametersText = constraints?.parameters
+    ? `\nThe tool MUST accept exactly this parameters JSON Schema: ${parametersJson}\n`
+    : '';
+
+  return `Create a tool named "${toolName}".
+Task: ${description}
+Formula/Logic: ${capability}
+${existingToolsSection}${constraintsText}${parametersText}
 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"}`;
+{"name":"${toolName}","description":"${description}","implementation":"async function execute(params) { /* YOUR CODE HERE — throw on invalid input */ }","parameters":${parametersJson},"reasoning":"explanation"}`;
 }
 
 export function buildToolValidationPrompt(
@@ -78,7 +139,7 @@ Name: ${tool.name}
 Description: ${tool.description}
 
 IMPLEMENTATION:
-\`\`\`typescript
+\`\`\`javascript
 ${tool.implementation}
 \`\`\`
 
@@ -123,7 +184,7 @@ Name: ${tool.name}
 Description: ${tool.description}
 
 CURRENT IMPLEMENTATION:
-\`\`\`typescript
+\`\`\`javascript
 ${tool.implementation}
 \`\`\`
 
@@ -165,11 +226,16 @@ export function parseGapAnalysisResponse(response: string): {
             id: String(g.id || `gap_${idx}`),
             description: String(g.description || ''),
             requiredCapability: String(g.requiredCapability || ''),
-            suggestedToolName: String(g.suggestedToolName || `generated_tool_${idx}`),
+            suggestedToolName: sanitizeToolName(
+              String(g.suggestedToolName || `generated_tool_${idx}`)
+            ),
             complexity: (['simple', 'moderate', 'complex'].includes(String(g.complexity))
               ? g.complexity
               : 'moderate') as 'simple' | 'moderate' | 'complex',
-            confidence: typeof g.confidence === 'number' ? g.confidence : 0.5,
+            confidence:
+              typeof g.confidence === 'number' && Number.isFinite(g.confidence)
+                ? Math.min(1, Math.max(0, g.confidence))
+                : 0.5,
             reasoning: String(g.reasoning || ''),
           }))
         : [],
@@ -194,15 +260,29 @@ export function parseToolGenerationResponse(response: string): GeneratedTool | n
     } catch {}
   }
 
-  const fnRegex = /(?:async\s+)?function\s+execute\s*\([^)]*\)\s*\{[\s\S]*?\n\}/;
+  const fnRegex = /(?:async\s+)?function\s+execute\s*\([^)]*\)\s*\{[\s\S]*\}/;
   const fnMatch = fnRegex.exec(response);
   if (fnMatch) {
+    let impl = fnMatch[0];
+    let braceDepth = 0;
+    let endIdx = impl.length;
+    const firstBrace = impl.indexOf('{');
+    for (let i = firstBrace; i < impl.length; i++) {
+      if (impl[i] === '{') braceDepth++;
+      if (impl[i] === '}') braceDepth--;
+      if (braceDepth === 0) {
+        endIdx = i + 1;
+        break;
+      }
+    }
+    impl = impl.slice(0, endIdx);
+
     const nameRegex = /["']?name["']?\s*[:=]\s*["']([^"']+)["']/;
     const nameMatch = nameRegex.exec(response);
     return buildToolFromParsed({
       name: nameMatch?.[1] ?? 'generated_tool',
       description: '',
-      implementation: fnMatch[0],
+      implementation: impl,
       parameters: { type: 'object', properties: {} },
     });
   }
@@ -210,16 +290,38 @@ export function parseToolGenerationResponse(response: string): GeneratedTool | n
   return null;
 }
 
+function normalizeParameters(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return { type: 'object', properties: {} };
+  }
+
+  const schema = value as Record<string, unknown>;
+  const properties =
+    schema.properties && typeof schema.properties === 'object' && !Array.isArray(schema.properties)
+      ? (schema.properties as Record<string, unknown>)
+      : {};
+  const required = Array.isArray(schema.required)
+    ? schema.required.filter(
+        (key): key is string => typeof key === 'string' && Object.hasOwn(properties, key)
+      )
+    : [];
+
+  const normalized: Record<string, unknown> = { ...schema, type: 'object', properties };
+  if (required.length > 0) {
+    normalized.required = required;
+  } else {
+    delete normalized.required;
+  }
+  return normalized;
+}
+
 function buildToolFromParsed(parsed: Record<string, unknown>): GeneratedTool {
   return {
     id: `gen_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-    name: String(parsed.name),
+    name: sanitizeToolName(String(parsed.name)),
     description: String(parsed.description || ''),
     implementation: String(parsed.implementation),
-    parameters: (parsed.parameters as GeneratedTool['parameters']) || {
-      type: 'object',
-      properties: {},
-    },
+    parameters: normalizeParameters(parsed.parameters),
     createdAt: new Date(),
     version: 1,
     status: 'pending_validation',