@cogitator-ai/self-modifying 17.0.18 → 19.0.0

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

@@ -7,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;
@@ -34,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;
@@ -47,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',
@@ -58,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,
@@ -217,26 +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(',');
-    const raw = `${userIntent}|${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/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, deepEqual } 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

@@ -78,6 +78,7 @@ export function buildToolGenerationPrompt(
     maxLines?: number;
     allowedModules?: string[];
     securityLevel?: 'strict' | 'moderate' | 'permissive';
+    parameters?: Record<string, unknown>;
   }
 ): string {
   const toolName = sanitizeToolName(gap.suggestedToolName);
@@ -112,12 +113,19 @@ export function buildToolGenerationPrompt(
   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}
+${existingToolsSection}${constraintsText}${parametersText}
 Respond with ONLY this JSON (no other text):
-{"name":"${toolName}","description":"${description}","implementation":"async function execute(params) { /* YOUR CODE HERE — throw on invalid input */ }","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(
@@ -224,7 +232,10 @@ export function parseGapAnalysisResponse(response: string): {
             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 || ''),
           }))
         : [],
@@ -279,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',

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

@@ -1,5 +1,6 @@
 import type {
   Tool,
+  ToolSchema,
   LLMBackend,
   CapabilityGap,
   GeneratedTool,
@@ -8,7 +9,8 @@ import type {
 } from '@cogitator-ai/types';
 import { z, type ZodType } from 'zod';
 import { ToolValidator } from './tool-validator';
-import { ToolSandbox } from './tool-sandbox';
+import { ToolSandbox, type SandboxTestCase } from './tool-sandbox';
+import { llmChat } from '../utils/llm-helper';
 import {
   TOOL_GENERATION_SYSTEM_PROMPT,
   buildToolGenerationPrompt,
@@ -22,6 +24,10 @@ export interface ToolGeneratorOptions {
   model?: string;
 }
 
+export interface GenerateOptions {
+  parameters?: Record<string, unknown>;
+}
+
 export interface GenerationResult {
   tool: GeneratedTool | null;
   validationResult: ToolValidationResult | null;
@@ -52,7 +58,8 @@ export class ToolGenerator {
   async generate(
     gap: CapabilityGap,
     existingTools: Tool[],
-    testCases?: Array<{ input: unknown; expectedOutput?: unknown }>
+    testCases?: SandboxTestCase[],
+    options: GenerateOptions = {}
   ): Promise<GenerationResult> {
     let currentTool: GeneratedTool | null = null;
     let validationResult: ToolValidationResult | null = null;
@@ -65,15 +72,23 @@ export class ToolGenerator {
 
       try {
         if (currentTool === null) {
-          currentTool = await this.generateInitial(gap, existingTools);
+          currentTool = await this.generateInitial(gap, existingTools, options.parameters);
         } else if (validationResult) {
-          currentTool = await this.improve(currentTool, validationResult, iterations);
+          const improved = await this.improve(currentTool, validationResult, iterations);
+          if (!improved) {
+            continue;
+          }
+          currentTool = improved;
         }
 
         if (!currentTool) {
           continue;
         }
 
+        if (options.parameters) {
+          currentTool.parameters = options.parameters;
+        }
+
         validationResult = await this.validator.validate(currentTool, testCases);
 
         if (validationResult.isValid) {
@@ -132,21 +147,22 @@ export class ToolGenerator {
       reasoning: 'User-requested quick generation',
     };
 
-    const result = await this.generate(gap, []);
-
-    if (result.tool && Object.keys(parameters).length > 0) {
-      result.tool.parameters = {
-        type: 'object',
-        properties: parameters,
-      };
-    }
+    const result = await this.generate(
+      gap,
+      [],
+      undefined,
+      Object.keys(parameters).length > 0
+        ? { parameters: { type: 'object', properties: parameters } }
+        : {}
+    );
 
-    return result.tool;
+    return result.success ? result.tool : null;
   }
 
   private async generateInitial(
     gap: CapabilityGap,
-    existingTools: Tool[]
+    existingTools: Tool[],
+    parameters?: Record<string, unknown>
   ): Promise<GeneratedTool | null> {
     const toolSummaries = existingTools.map((t) => ({
       name: t.name,
@@ -157,17 +173,19 @@ export class ToolGenerator {
       maxLines: 100,
       securityLevel: 'strict',
       allowedModules: this.config.sandboxConfig?.allowedModules,
+      parameters,
     });
 
-    const response = await this.callLLM(
+    const content = await llmChat(
+      this.llm,
       [
         { role: 'system', content: TOOL_GENERATION_SYSTEM_PROMPT },
         { role: 'user', content: prompt },
       ],
-      0.4
+      { model: this.model, temperature: 0.4 }
     );
 
-    const tool = parseToolGenerationResponse(response.content);
+    const tool = parseToolGenerationResponse(content);
 
     if (tool) {
       tool.metadata = {
@@ -187,18 +205,21 @@ export class ToolGenerator {
   ): Promise<GeneratedTool | null> {
     const prompt = buildToolImprovementPrompt(tool, validationResult, iteration);
 
-    const response = await this.callLLM(
+    const content = await llmChat(
+      this.llm,
       [
         { role: 'system', content: TOOL_GENERATION_SYSTEM_PROMPT },
         { role: 'user', content: prompt },
       ],
-      0.3
+      { model: this.model, temperature: 0.3 }
     );
 
-    const improved = parseToolGenerationResponse(response.content);
+    const improved = parseToolGenerationResponse(content);
 
     if (improved) {
       improved.id = tool.id;
+      improved.name = tool.name;
+      improved.createdAt = tool.createdAt;
       improved.version = tool.version + 1;
       improved.metadata = {
         ...tool.metadata,
@@ -215,6 +236,7 @@ export class ToolGenerator {
     const sandbox = this.sandbox;
     const tool = generated;
     const paramSchema = buildZodSchema(generated.parameters);
+    const jsonSchema = toToolJsonSchema(generated.parameters);
 
     const execute = async (params: unknown): Promise<unknown> => {
       const parsed = paramSchema.safeParse(params);
@@ -239,23 +261,27 @@ export class ToolGenerator {
       toJSON: () => ({
         name: generated.name,
         description: generated.description,
-        parameters: {
-          type: 'object' as const,
-          properties: generated.parameters as Record<string, unknown>,
-        },
+        parameters: jsonSchema,
       }),
     };
   }
+}
 
-  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 });
-  }
+function toToolJsonSchema(parameters: Record<string, unknown>): ToolSchema['parameters'] {
+  const properties =
+    parameters.type === 'object' &&
+    parameters.properties &&
+    typeof parameters.properties === 'object' &&
+    !Array.isArray(parameters.properties)
+      ? (parameters.properties as Record<string, unknown>)
+      : {};
+  const required = Array.isArray(parameters.required)
+    ? parameters.required.filter((key): key is string => typeof key === 'string')
+    : [];
+
+  return required.length > 0
+    ? { type: 'object', properties, required }
+    : { type: 'object', properties };
 }
 
 function buildZodSchema(parameters: Record<string, unknown>): ZodType<unknown> {