@cogitator-ai/self-modifying 19.1.1 → 19.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogitator-ai/self-modifying",
-  "version": "19.1.1",
+  "version": "19.1.3",
   "description": "Self-modifying agent capabilities for Cogitator - tool generation, meta-reasoning, architecture evolution",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,7 +20,7 @@
     "node": ">=22.12.0"
   },
   "dependencies": {
-    "@cogitator-ai/types": "0.26.0",
+    "@cogitator-ai/types": "0.28.0",
     "nanoid": "^6.0.1",
     "zod": "^4.6.5"
   },
@@ -53,6 +53,6 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "eslint src --ext .ts",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit -p tsconfig.test.json"
   }
 }

package/src/__tests__/architecture-evolution.test.ts

@@ -6,15 +6,23 @@ import {
   parseTaskProfileResponse,
   parseCandidateGenerationResponse,
 } from '../architecture-evolution';
-import type { LLMBackend, EvolutionCandidate } from '@cogitator-ai/types';
-
-const mockLLM: LLMBackend = {
-  complete: vi.fn(),
-  name: 'mock',
-  supportsTool: () => true,
-  supportsStreaming: () => false,
-  validateConfig: () => true,
-};
+import type { ChatResponse, LLMBackend, EvolutionCandidate } from '@cogitator-ai/types';
+
+function chatResponse(content: string): ChatResponse {
+  return {
+    id: 'resp',
+    content,
+    finishReason: 'stop',
+    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+  };
+}
+
+const mockLLM = {
+  provider: 'ollama',
+  chat: vi.fn<LLMBackend['chat']>(),
+  chatStream: async function* () {},
+  complete: vi.fn<NonNullable<LLMBackend['complete']>>(),
+} satisfies LLMBackend;
 
 describe('CapabilityAnalyzer', () => {
   it('analyzes task with heuristics', async () => {
@@ -290,24 +298,26 @@ describe('EvolutionStrategy', () => {
 describe('ParameterOptimizer', () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    (mockLLM.complete as ReturnType<typeof vi.fn>).mockResolvedValue({
-      content: JSON.stringify([
-        {
-          id: 'candidate_1',
-          config: { temperature: 0.5 },
-          reasoning: 'Lower temperature for precision',
-          expectedImprovement: 0.7,
-          risk: 'low',
-        },
-        {
-          id: 'candidate_2',
-          config: { temperature: 0.9, maxTokens: 8000 },
-          reasoning: 'Higher temperature for creativity',
-          expectedImprovement: 0.6,
-          risk: 'medium',
-        },
-      ]),
-    });
+    mockLLM.complete.mockResolvedValue(
+      chatResponse(
+        JSON.stringify([
+          {
+            id: 'candidate_1',
+            config: { temperature: 0.5 },
+            reasoning: 'Lower temperature for precision',
+            expectedImprovement: 0.7,
+            risk: 'low',
+          },
+          {
+            id: 'candidate_2',
+            config: { temperature: 0.9, maxTokens: 8000 },
+            reasoning: 'Higher temperature for creativity',
+            expectedImprovement: 0.6,
+            risk: 'medium',
+          },
+        ])
+      )
+    );
   });
 
   it('optimizes architecture for task', async () => {

package/src/__tests__/constraints.test.ts

@@ -1,4 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
+import { z } from 'zod';
+import type { AgentConfig, Tool } from '@cogitator-ai/types';
 import {
   ModificationValidator,
   RollbackManager,
@@ -7,6 +9,20 @@ import {
   mergeSafetyConstraints,
 } from '../constraints';
 
+function agentConfig(overrides: Partial<AgentConfig>): AgentConfig {
+  return { name: 'agent', instructions: 'Test agent', ...overrides };
+}
+
+function makeTool(name: string, description: string): Tool {
+  return {
+    name,
+    description,
+    parameters: z.object({}),
+    execute: async () => null,
+    toJSON: () => ({ name, description, parameters: { type: 'object', properties: {} } }),
+  };
+}
+
 describe('ModificationValidator', () => {
   let validator: ModificationValidator;
 
@@ -132,8 +148,8 @@ describe('RollbackManager', () => {
   it('creates checkpoints', async () => {
     const checkpoint = await manager.createCheckpoint(
       'agent-1',
-      { model: 'gpt-4', temperature: 0.7 },
-      [{ name: 'tool1', description: 'Test', parameters: {}, execute: async () => null }],
+      agentConfig({ model: 'gpt-4', temperature: 0.7 }),
+      [makeTool('tool1', 'Test')],
       []
     );
 
@@ -145,15 +161,8 @@ describe('RollbackManager', () => {
   it('rolls back to checkpoint', async () => {
     const checkpoint = await manager.createCheckpoint(
       'agent-1',
-      { model: 'gpt-4', temperature: 0.7 },
-      [
-        {
-          name: 'original_tool',
-          description: 'Original',
-          parameters: {},
-          execute: async () => null,
-        },
-      ],
+      agentConfig({ model: 'gpt-4', temperature: 0.7 }),
+      [makeTool('original_tool', 'Original')],
       []
     );
 
@@ -168,18 +177,15 @@ describe('RollbackManager', () => {
   it('compares checkpoints', async () => {
     const cp1 = await manager.createCheckpoint(
       'agent-1',
-      { model: 'gpt-4', temperature: 0.7 },
-      [{ name: 'tool1', description: 'Test', parameters: {}, execute: async () => null }],
+      agentConfig({ model: 'gpt-4', temperature: 0.7 }),
+      [makeTool('tool1', 'Test')],
       []
     );
 
     const cp2 = await manager.createCheckpoint(
       'agent-1',
-      { model: 'gpt-4o', temperature: 0.9 },
-      [
-        { name: 'tool1', description: 'Test', parameters: {}, execute: async () => null },
-        { name: 'tool2', description: 'New', parameters: {}, execute: async () => null },
-      ],
+      agentConfig({ model: 'gpt-4o', temperature: 0.9 }),
+      [makeTool('tool1', 'Test'), makeTool('tool2', 'New')],
       []
     );
 
@@ -195,7 +201,7 @@ describe('RollbackManager', () => {
     const customManager = new RollbackManager({ maxCheckpoints: 3 });
 
     for (let i = 0; i < 5; i++) {
-      await customManager.createCheckpoint('agent-1', { iteration: i }, [], []);
+      await customManager.createCheckpoint('agent-1', agentConfig({ name: `agent-${i}` }), [], []);
     }
 
     const checkpoints = await customManager.listCheckpoints('agent-1');

package/src/__tests__/meta-reasoning.test.ts

@@ -9,8 +9,11 @@ import {
 } from '../meta-reasoning';
 import type { LLMBackend, MetaObservation } from '@cogitator-ai/types';
 
-const mockLLM: LLMBackend = {
-  chat: vi.fn().mockResolvedValue({
+const mockLLM = {
+  provider: 'ollama',
+  chat: vi.fn<LLMBackend['chat']>().mockResolvedValue({
+    id: 'resp',
+    finishReason: 'stop',
     content: JSON.stringify({
       onTrack: true,
       confidence: 0.8,
@@ -23,13 +26,10 @@ const mockLLM: LLMBackend = {
         reasoning: 'Making good progress',
       },
     }),
-    usage: { outputTokens: 100 },
+    usage: { inputTokens: 0, outputTokens: 100, totalTokens: 100 },
   }),
-  name: 'mock',
-  supportsTool: () => true,
-  supportsStreaming: () => false,
-  validateConfig: () => true,
-};
+  chatStream: async function* () {},
+} satisfies LLMBackend;
 
 describe('ObservationCollector', () => {
   let collector: ObservationCollector;
@@ -224,9 +224,8 @@ describe('MetaReasoner', () => {
       model: 'gpt-4o',
       config: {
         enabled: true,
-        maxAssessmentsPerRun: 5,
-        maxAdaptationsPerRun: 3,
-        assessmentCooldown: 0,
+        maxMetaAssessments: 5,
+        maxAdaptations: 3,
         metaAssessmentCooldown: 0,
         adaptationCooldown: 0,
         triggers: ['iteration_complete', 'confidence_drop', 'progress_stall'],
@@ -270,7 +269,20 @@ describe('MetaReasoner', () => {
         iterationsRemaining: 5,
         budgetRemaining: 0.8,
       },
-      [{ type: 'observation', content: 'Test insight', confidence: 0.8 }]
+      [
+        {
+          id: 'insight-1',
+          type: 'pattern',
+          content: 'Test insight',
+          context: 'Test goal',
+          confidence: 0.8,
+          usageCount: 0,
+          createdAt: new Date(0),
+          lastUsedAt: new Date(0),
+          agentId: 'agent-1',
+          source: { runId, reflectionId: 'reflection-1' },
+        },
+      ]
     );
 
     expect(observation.tokensUsed).toBe(1000);

package/src/__tests__/self-modifying-agent.test.ts

@@ -36,6 +36,7 @@ function createMockTool(name: string, result: unknown): Tool {
 
 function chatResponse(content: string, toolCalls?: ToolCall[]): ChatResponse {
   return {
+    id: 'resp',
     content,
     toolCalls,
     finishReason: toolCalls?.length ? 'tool_calls' : 'stop',

package/src/__tests__/tool-generation.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { z } from 'zod';
 import {
   GapAnalyzer,
   ToolGenerator,
@@ -8,7 +9,12 @@ import {
   parseGapAnalysisResponse,
   parseToolGenerationResponse,
 } from '../tool-generation';
-import type { LLMBackend, GeneratedTool, ToolSelfGenerationConfig } from '@cogitator-ai/types';
+import type {
+  ChatResponse,
+  LLMBackend,
+  GeneratedTool,
+  ToolSelfGenerationConfig,
+} from '@cogitator-ai/types';
 
 const mockToolConfig: ToolSelfGenerationConfig = {
   enabled: true,
@@ -26,13 +32,21 @@ const mockToolConfig: ToolSelfGenerationConfig = {
   },
 };
 
-const mockLLM: LLMBackend = {
-  complete: vi.fn(),
-  name: 'mock',
-  supportsTool: () => true,
-  supportsStreaming: () => false,
-  validateConfig: () => true,
-};
+function chatResponse(content: string): ChatResponse {
+  return {
+    id: 'resp',
+    content,
+    finishReason: 'stop',
+    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+  };
+}
+
+const mockLLM = {
+  provider: 'ollama',
+  chat: vi.fn<LLMBackend['chat']>(),
+  chatStream: async function* () {},
+  complete: vi.fn<NonNullable<LLMBackend['complete']>>(),
+} satisfies LLMBackend;
 
 describe('ToolSandbox', () => {
   let sandbox: ToolSandbox;
@@ -218,23 +232,25 @@ describe('GapAnalyzer', () => {
   });
 
   it('analyzes capability gaps', async () => {
-    (mockLLM.complete as ReturnType<typeof vi.fn>).mockResolvedValue({
-      content: JSON.stringify({
-        hasGap: true,
-        gaps: [
-          {
-            id: 'gap-1',
-            description: 'Missing CSV parsing capability',
-            requiredCapability: 'Parse CSV files',
-            suggestedToolName: 'csv_parser',
-            complexity: 'simple',
-            confidence: 0.9,
-            reasoning: 'User needs to analyze CSV data',
-          },
-        ],
-        canProceed: false,
-      }),
-    });
+    mockLLM.complete.mockResolvedValue(
+      chatResponse(
+        JSON.stringify({
+          hasGap: true,
+          gaps: [
+            {
+              id: 'gap-1',
+              description: 'Missing CSV parsing capability',
+              requiredCapability: 'Parse CSV files',
+              suggestedToolName: 'csv_parser',
+              complexity: 'simple',
+              confidence: 0.9,
+              reasoning: 'User needs to analyze CSV data',
+            },
+          ],
+          canProceed: false,
+        })
+      )
+    );
 
     const analyzer = new GapAnalyzer({ llm: mockLLM, config: mockToolConfig, model: 'test-model' });
 
@@ -242,8 +258,13 @@ describe('GapAnalyzer', () => {
       {
         name: 'calculator',
         description: 'Perform calculations',
-        parameters: {},
+        parameters: z.object({}),
         execute: async () => null,
+        toJSON: () => ({
+          name: 'calculator',
+          description: 'Perform calculations',
+          parameters: { type: 'object', properties: {} },
+        }),
       },
     ]);
 
@@ -258,11 +279,12 @@ describe('ToolGenerator', () => {
   });
 
   it('generates tools from gaps', async () => {
-    (mockLLM.complete as ReturnType<typeof vi.fn>).mockResolvedValue({
-      content: JSON.stringify({
-        name: 'csv_parser',
-        description: 'Parse CSV data into JSON',
-        implementation: `
+    mockLLM.complete.mockResolvedValue(
+      chatResponse(
+        JSON.stringify({
+          name: 'csv_parser',
+          description: 'Parse CSV data into JSON',
+          implementation: `
           async function execute(params) {
             const lines = params.data.split('\\n');
             const headers = lines[0].split(',');
@@ -274,14 +296,15 @@ describe('ToolGenerator', () => {
             });
           }
         `,
-        parameters: {
-          type: 'object',
-          properties: { data: { type: 'string' } },
-          required: ['data'],
-        },
-        reasoning: 'Simple CSV parsing without external dependencies',
-      }),
-    });
+          parameters: {
+            type: 'object',
+            properties: { data: { type: 'string' } },
+            required: ['data'],
+          },
+          reasoning: 'Simple CSV parsing without external dependencies',
+        })
+      )
+    );
 
     const generator = new ToolGenerator({
       llm: mockLLM,