@cogitator-ai/self-modifying 17.0.18 → 18.0.0

package/src/__tests__/sandbox-security.test.ts

@@ -0,0 +1,186 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import type { GeneratedTool } from '@cogitator-ai/types';
+import { ToolSandbox, deepEqual } from '../tool-generation';
+
+function makeTool(implementation: string): GeneratedTool {
+  return {
+    id: 'sandbox_test',
+    name: 'sandbox_test',
+    description: 'sandbox test tool',
+    implementation,
+    parameters: { type: 'object', properties: {} },
+    createdAt: new Date(),
+    version: 1,
+    status: 'validated',
+  };
+}
+
+describe('ToolSandbox isolation', () => {
+  const sandbox = new ToolSandbox({ enabled: true, maxExecutionTime: 3000 });
+
+  it('blocks constructor-chain escapes to the host realm', async () => {
+    const result = await sandbox.execute(
+      makeTool(`async function execute() {
+        const F = Array["constr" + "uctor"];
+        return F("return pro" + "cess")();
+      }`),
+      {}
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/code generation/i);
+  });
+
+  it('does not expose host globals inside the sandbox', async () => {
+    const result = await sandbox.execute(
+      makeTool(`async function execute() {
+        return [typeof process, typeof require, typeof setTimeout, typeof Buffer];
+      }`),
+      {}
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toEqual(['undefined', 'undefined', 'undefined', 'undefined']);
+  });
+
+  it('passes params as sandbox-realm data that cannot reach host constructors', async () => {
+    const result = await sandbox.execute(
+      makeTool(`async function execute(params) {
+        const ctor = params["constr" + "uctor"]["constr" + "uctor"];
+        return ctor("return 1")();
+      }`),
+      { a: 1 }
+    );
+
+    expect(result.success).toBe(false);
+  });
+
+  it('captures console output with JSON-formatted objects', async () => {
+    const result = await sandbox.execute(
+      makeTool(`async function execute(params) {
+        console.log("value", { a: params.a });
+        console.warn("careful");
+        return params.a;
+      }`),
+      { a: 5 }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.logs).toEqual(['[LOG] value {"a":5}', '[WARN] careful']);
+  });
+
+  it('reports promises that can never settle without waiting for the timeout', async () => {
+    const started = Date.now();
+    const result = await sandbox.execute(
+      makeTool('async function execute() { return new Promise(() => {}); }'),
+      {}
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/never settled/);
+    expect(Date.now() - started).toBeLessThan(2500);
+  });
+
+  it('rejects non-serializable parameters', async () => {
+    const circular: Record<string, unknown> = {};
+    circular.self = circular;
+
+    const result = await sandbox.execute(
+      makeTool('async function execute(p) { return 1; }'),
+      circular
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/JSON-serializable/);
+  });
+
+  it('reports non-serializable results instead of crashing the worker', async () => {
+    const result = await sandbox.execute(
+      makeTool('async function execute() { const a = {}; a.self = a; return a; }'),
+      {}
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/non-serializable/);
+  });
+
+  it('allows RegExp.prototype.exec in generated code', async () => {
+    const result = await sandbox.execute(
+      makeTool('async function execute(p) { return /(\\d+)/.exec(p.text)[1]; }'),
+      { text: 'order 42' }
+    );
+
+    expect(result).toMatchObject({ success: true, result: '42' });
+  });
+});
+
+describe('ToolSandbox.testWithCases', () => {
+  const sandbox = new ToolSandbox({ enabled: true, maxExecutionTime: 500 });
+
+  it('distinguishes thrown errors from timeouts for shouldThrow and allowThrow cases', async () => {
+    const tool = makeTool(`async function execute(params) {
+      if (params.mode === 'throw') throw new Error('invalid input');
+      if (params.mode === 'hang') { while (true) {} }
+      return 'ok';
+    }`);
+
+    const { results } = await sandbox.testWithCases(tool, [
+      { input: { mode: 'throw' }, shouldThrow: true },
+      { input: { mode: 'throw' }, allowThrow: true },
+      { input: { mode: 'ok' }, allowThrow: true },
+      { input: { mode: 'hang' }, shouldThrow: true },
+      { input: { mode: 'hang' }, allowThrow: true },
+    ]);
+
+    expect(results.map((r) => r.passed)).toEqual([true, true, true, false, false]);
+  });
+});
+
+describe('ToolSandbox without isolation', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('clears its timeout timer after execution completes', async () => {
+    vi.useFakeTimers();
+    const sandbox = new ToolSandbox({ enabled: false, maxExecutionTime: 60_000 });
+
+    const result = await sandbox.execute(
+      makeTool('async function execute(p) { return p.a * 2; }'),
+      { a: 21 }
+    );
+
+    expect(result).toMatchObject({ success: true, result: 42 });
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});
+
+describe('deepEqual', () => {
+  it('treats shared references and distinct copies as equal', () => {
+    const shared = { v: 1 };
+    expect(deepEqual({ a: shared, b: shared }, { a: { v: 1 }, b: { v: 1 } })).toBe(true);
+  });
+
+  it('handles circular arrays and objects without overflowing the stack', () => {
+    const a: unknown[] = [1];
+    a.push(a);
+    const b: unknown[] = [1];
+    b.push(b);
+    expect(deepEqual(a, b)).toBe(true);
+
+    const x: Record<string, unknown> = { n: 1 };
+    x.self = x;
+    const y: Record<string, unknown> = { n: 2 };
+    y.self = y;
+    expect(deepEqual(x, y)).toBe(false);
+  });
+
+  it('compares sets of objects structurally', () => {
+    expect(deepEqual(new Set([{ a: 1 }]), new Set([{ a: 1 }]))).toBe(true);
+    expect(deepEqual(new Set([{ a: 1 }]), new Set([{ a: 2 }]))).toBe(false);
+  });
+
+  it('distinguishes arrays from plain objects', () => {
+    expect(deepEqual([1], { 0: 1 })).toBe(false);
+  });
+});

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

@@ -1,6 +1,13 @@
 import { describe, it, expect, vi } from 'vitest';
 import { SelfModifyingAgent } from '../self-modifying-agent';
-import type { Agent, LLMBackend, Tool, ChatResponse, ToolCall } from '@cogitator-ai/types';
+import type {
+  Agent,
+  LLMBackend,
+  Tool,
+  ChatRequest,
+  ChatResponse,
+  ToolCall,
+} from '@cogitator-ai/types';
 import { z } from 'zod';
 
 function createMockAgent(tools: Tool[] = []): Agent {
@@ -231,3 +238,358 @@ describe('SelfModifyingAgent tool execution', () => {
     expect(chatCall.tools).toBeUndefined();
   });
 });
+
+const ADD_TOOL_JSON = JSON.stringify({
+  name: 'add_numbers',
+  description: 'Add two numbers',
+  implementation:
+    "async function execute(params) { if (typeof params.a !== 'number' || typeof params.b !== 'number') { throw new Error('a and b must be numbers'); } return params.a + params.b; }",
+  parameters: {
+    type: 'object',
+    properties: { a: { type: 'number' }, b: { type: 'number' } },
+    required: ['a', 'b'],
+  },
+});
+
+const ADD_GAP_JSON = JSON.stringify({
+  hasGap: true,
+  gaps: [
+    {
+      id: 'gap_add',
+      description: 'Add two numbers',
+      requiredCapability: 'a + b',
+      suggestedToolName: 'add_numbers',
+      complexity: 'simple',
+      confidence: 0.95,
+    },
+  ],
+  canProceed: false,
+});
+
+interface RouterReplies {
+  gap?: string;
+  tool?: string;
+  profile?: string;
+  candidates?: string;
+  meta?: string;
+  agent: (request: ChatRequest) => ChatResponse;
+}
+
+function routedLLM(replies: RouterReplies): LLMBackend & { chat: ReturnType<typeof vi.fn> } {
+  const chat = vi.fn(async (request: ChatRequest): Promise<ChatResponse> => {
+    const system = String(request.messages[0]?.content ?? '');
+    if (system.includes('capability analyzer')) return chatResponse(replies.gap ?? '{"gaps":[]}');
+    if (system.includes('You generate JavaScript tools')) return chatResponse(replies.tool ?? '');
+    if (system.includes('task analysis expert')) return chatResponse(replies.profile ?? '{}');
+    if (system.includes('architecture optimizer')) return chatResponse(replies.candidates ?? '[]');
+    if (system.includes('meta-reasoning system')) return chatResponse(replies.meta ?? '{}');
+    return replies.agent(request);
+  });
+  return {
+    provider: 'ollama',
+    chat,
+    chatStream: async function* () {
+      yield { id: 'x', delta: {} };
+    },
+  };
+}
+
+function agentCalls(llm: { chat: ReturnType<typeof vi.fn> }): ChatRequest[] {
+  return llm.chat.mock.calls
+    .map((call) => call[0] as ChatRequest)
+    .filter((req) => String(req.messages[0]?.content) === 'You are a test assistant.');
+}
+
+const quietConfig = {
+  toolGeneration: { enabled: false },
+  metaReasoning: { enabled: false },
+  architectureEvolution: { enabled: false },
+  constraints: { enabled: false },
+};
+
+describe('SelfModifyingAgent run semantics', () => {
+  it('completes a short answer with a single LLM call even with meta-reasoning enabled', async () => {
+    const llm = routedLLM({ agent: () => chatResponse('4') });
+    const selfMod = new SelfModifyingAgent({
+      agent: createMockAgent(),
+      llm,
+      config: {
+        toolGeneration: { enabled: false },
+        architectureEvolution: { enabled: false },
+      },
+    });
+
+    const result = await selfMod.run('What is 2 + 2?');
+
+    expect(result.output).toBe('4');
+    expect(llm.chat).toHaveBeenCalledTimes(1);
+  });
+
+  it('skips every self-modification step when disabled globally', async () => {
+    const llm = routedLLM({
+      gap: ADD_GAP_JSON,
+      tool: ADD_TOOL_JSON,
+      agent: () => chatResponse('ok'),
+    });
+    const selfMod = new SelfModifyingAgent({
+      agent: createMockAgent(),
+      llm,
+      config: { enabled: false },
+    });
+
+    const result = await selfMod.run('add 1 and 2');
+
+    expect(result.output).toBe('ok');
+    expect(result.toolsGenerated).toEqual([]);
+    expect(llm.chat).toHaveBeenCalledTimes(1);
+  });
+
+  it('uses the agent temperature and max tokens as the baseline config', async () => {
+    const llm = routedLLM({ agent: () => chatResponse('done') });
+    const agent = { ...createMockAgent(), config: { temperature: 0.15, maxTokens: 321 } } as Agent;
+    const selfMod = new SelfModifyingAgent({ agent, llm, config: quietConfig });
+
+    const result = await selfMod.run('hi');
+
+    expect(llm.chat.mock.calls[0][0]).toMatchObject({ temperature: 0.15, maxTokens: 321 });
+    expect(result.finalConfig).toMatchObject({ temperature: 0.15, maxTokens: 321 });
+  });
+
+  it('validates tool arguments against the tool schema before executing', async () => {
+    const calculator = createMockTool('calculator', 42);
+    const llm = routedLLM({
+      agent: vi
+        .fn()
+        .mockReturnValueOnce(
+          chatResponse('', [{ id: 'c1', name: 'calculator', arguments: { input: 7 } }])
+        )
+        .mockReturnValueOnce(chatResponse('could not compute')),
+    });
+    const selfMod = new SelfModifyingAgent({
+      agent: createMockAgent([calculator]),
+      llm,
+      config: quietConfig,
+    });
+
+    await selfMod.run('compute');
+
+    expect(calculator.execute).not.toHaveBeenCalled();
+    const toolMessage = llm.chat.mock.calls[1][0].messages.find(
+      (m: { role: string }) => m.role === 'tool'
+    );
+    expect(toolMessage.content).toContain('Invalid arguments');
+  });
+
+  it('serializes concurrent runs so contexts never mix', async () => {
+    let resolveFirst: ((value: ChatResponse) => void) | undefined;
+    const llm = routedLLM({
+      agent: (request) => {
+        const input = String(request.messages[request.messages.length - 1].content);
+        if (input === 'first') {
+          return new Promise<ChatResponse>((resolve) => {
+            resolveFirst = resolve;
+          }) as unknown as ChatResponse;
+        }
+        return chatResponse(`answer:${input}`);
+      },
+    });
+    const selfMod = new SelfModifyingAgent({ agent: createMockAgent(), llm, config: quietConfig });
+
+    const first = selfMod.run('first');
+    const second = selfMod.run('second');
+    await vi.waitFor(() => expect(resolveFirst).toBeDefined());
+    expect(llm.chat).toHaveBeenCalledTimes(1);
+
+    resolveFirst!(chatResponse('answer:first'));
+
+    await expect(first).resolves.toMatchObject({ output: 'answer:first' });
+    await expect(second).resolves.toMatchObject({ output: 'answer:second' });
+  });
+
+  it('provides typed events and an unsubscribe function', async () => {
+    const llm = routedLLM({ agent: () => chatResponse('done') });
+    const selfMod = new SelfModifyingAgent({ agent: createMockAgent(), llm, config: quietConfig });
+    const inputs: string[] = [];
+
+    const unsubscribe = selfMod.on('run_started', (event) => {
+      inputs.push(event.data.input);
+    });
+    await selfMod.run('one');
+    unsubscribe();
+    await selfMod.run('two');
+
+    expect(inputs).toEqual(['one']);
+  });
+});
+
+describe('SelfModifyingAgent tool generation', () => {
+  it('activates accepted tools, exposes them to the LLM and keeps them for later runs', async () => {
+    const llm = routedLLM({
+      gap: ADD_GAP_JSON,
+      tool: ADD_TOOL_JSON,
+      agent: (request) => {
+        const hasToolResult = request.messages.some((m) => m.role === 'tool');
+        if (!hasToolResult && request.tools?.some((t) => t.name === 'add_numbers')) {
+          return chatResponse('', [{ id: 'c1', name: 'add_numbers', arguments: { a: 2, b: 3 } }]);
+        }
+        return chatResponse('The sum is 5');
+      },
+    });
+    const selfMod = new SelfModifyingAgent({
+      agent: createMockAgent(),
+      llm,
+      config: {
+        toolGeneration: { requireLLMValidation: false },
+        metaReasoning: { enabled: false },
+        architectureEvolution: { enabled: false },
+      },
+    });
+
+    const first = await selfMod.run('Add 2 and 3');
+
+    expect(first.output).toBe('The sum is 5');
+    expect(first.toolsGenerated.map((t) => t.name)).toEqual(['add_numbers']);
+    const active = await selfMod.getGeneratedTools();
+    expect(active.map((t) => t.status)).toEqual(['active']);
+
+    const toolMessage = agentCalls(llm)
+      .flatMap((r) => r.messages)
+      .find((m) => m.role === 'tool');
+    expect(toolMessage?.content).toBe('5');
+
+    const firstSchema = agentCalls(llm)[0].tools?.find((t) => t.name === 'add_numbers');
+    expect(firstSchema?.parameters).toEqual({
+      type: 'object',
+      properties: { a: { type: 'number' }, b: { type: 'number' } },
+      required: ['a', 'b'],
+    });
+
+    llm.chat.mockClear();
+    await selfMod.run('Add 2 and 3 again');
+    expect(agentCalls(llm)[0].tools?.map((t) => t.name)).toContain('add_numbers');
+  });
+
+  it('does not store tools rejected by modification constraints', async () => {
+    const llm = routedLLM({
+      gap: ADD_GAP_JSON,
+      tool: ADD_TOOL_JSON,
+      agent: () => chatResponse('ok'),
+    });
+    const selfMod = new SelfModifyingAgent({
+      agent: createMockAgent(),
+      llm,
+      config: {
+        toolGeneration: { requireLLMValidation: false, sandboxConfig: { enabled: false } },
+        metaReasoning: { enabled: false },
+        architectureEvolution: { enabled: false },
+      },
+    });
+    const completed: Array<{ success: boolean; error?: string }> = [];
+    selfMod.on('tool_generation_completed', (e) => completed.push(e.data));
+
+    const result = await selfMod.run('Add 2 and 3');
+
+    expect(result.toolsGenerated).toEqual([]);
+    expect(await selfMod.getGeneratedTools()).toEqual([]);
+    expect(completed).toEqual([
+      expect.objectContaining({ success: false, error: 'Rejected by modification constraints' }),
+    ]);
+  });
+});
+
+describe('SelfModifyingAgent meta-reasoning', () => {
+  it('retries failed steps with the adapted reasoning mode', async () => {
+    const llm = routedLLM({
+      meta: JSON.stringify({
+        onTrack: false,
+        confidence: 0.3,
+        recommendation: {
+          action: 'switch_mode',
+          newMode: 'creative',
+          confidence: 0.9,
+          reasoning: 'try a different approach',
+        },
+      }),
+      agent: vi.fn().mockReturnValueOnce(chatResponse('')).mockReturnValueOnce(chatResponse('42')),
+    });
+    const selfMod = new SelfModifyingAgent({
+      agent: createMockAgent(),
+      llm,
+      config: {
+        toolGeneration: { enabled: false },
+        architectureEvolution: { enabled: false },
+        metaReasoning: { metaAssessmentCooldown: 0, adaptationCooldown: 0 },
+      },
+    });
+    const modes: string[] = [];
+    selfMod.on('strategy_changed', (e) => modes.push(`${e.data.previousMode}->${e.data.newMode}`));
+
+    const result = await selfMod.run('answer');
+    const calls = agentCalls(llm);
+
+    expect(result.output).toBe('42');
+    expect(calls.map((c) => c.temperature)).toEqual([0.5, 0.9]);
+    expect(result.adaptationsMade).toHaveLength(1);
+    expect(modes).toEqual(['analytical->analytical', 'analytical->creative']);
+  });
+});
+
+describe('SelfModifyingAgent architecture evolution', () => {
+  it('applies config changes and records outcomes so candidates get evaluated', async () => {
+    const llm = routedLLM({
+      profile: JSON.stringify({ complexity: 'simple', domain: 'general' }),
+      candidates: JSON.stringify([
+        { id: 'cool', config: { temperature: 0.2, reflectionDepth: 1 }, risk: 'low' },
+      ]),
+      agent: () => chatResponse('answer'),
+    });
+    const selfMod = new SelfModifyingAgent({
+      agent: createMockAgent(),
+      llm,
+      config: {
+        toolGeneration: { enabled: false },
+        metaReasoning: { enabled: false },
+        architectureEvolution: { strategy: { type: 'ucb' } },
+      },
+    });
+    const evolved: Array<string | undefined> = [];
+    selfMod.on('architecture_evolved', (e) => evolved.push(e.data.candidateId));
+
+    const first = await selfMod.run('task');
+    expect(first.finalConfig.temperature).toBe(0.5);
+
+    llm.chat.mockClear();
+    const second = await selfMod.run('task');
+
+    expect(second.finalConfig).toMatchObject({ temperature: 0.2, reflectionDepth: 1 });
+    expect(evolved).toEqual(['cool']);
+    const calls = agentCalls(llm);
+    expect(calls).toHaveLength(2);
+    expect(String(calls[1].messages[calls[1].messages.length - 1].content)).toContain(
+      'Review your previous answer'
+    );
+  });
+});
+
+describe('SelfModifyingAgent model resolution', () => {
+  it('strips the backend provider prefix from the agent model', async () => {
+    const llm = routedLLM({ agent: () => chatResponse('done') });
+    const agent = { ...createMockAgent(), model: 'ollama/llama3.2' } as Agent;
+    const selfMod = new SelfModifyingAgent({ agent, llm, config: quietConfig });
+
+    const result = await selfMod.run('hi');
+
+    expect(llm.chat.mock.calls[0][0].model).toBe('llama3.2');
+    expect(result.finalConfig.model).toBe('llama3.2');
+  });
+
+  it('keeps model names whose prefix belongs to another provider', async () => {
+    const llm = routedLLM({ agent: () => chatResponse('done') });
+    const agent = { ...createMockAgent(), model: 'openai/gpt-4o' } as Agent;
+    const selfMod = new SelfModifyingAgent({ agent, llm, config: quietConfig });
+
+    await selfMod.run('hi');
+
+    expect(llm.chat.mock.calls[0][0].model).toBe('openai/gpt-4o');
+  });
+});