@cogitator-ai/self-modifying 17.0.8 → 17.0.11

package/src/__tests__/events.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SelfModifyingEventEmitter } from '../events';
+import type { SelfModifyingEvent } from '@cogitator-ai/types';
+
+function makeEvent(type: string): SelfModifyingEvent {
+  return { type, runId: 'test', timestamp: new Date(), data: {} } as SelfModifyingEvent;
+}
+
+describe('SelfModifyingEventEmitter', () => {
+  it('emits to specific type handlers', async () => {
+    const emitter = new SelfModifyingEventEmitter();
+    const handler = vi.fn();
+
+    emitter.on('run_started', handler);
+    await emitter.emit(makeEvent('run_started'));
+
+    expect(handler).toHaveBeenCalledOnce();
+  });
+
+  it('emits to wildcard handlers', async () => {
+    const emitter = new SelfModifyingEventEmitter();
+    const handler = vi.fn();
+
+    emitter.on('*', handler);
+    await emitter.emit(makeEvent('run_started'));
+    await emitter.emit(makeEvent('run_completed'));
+
+    expect(handler).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not call handlers for different event types', async () => {
+    const emitter = new SelfModifyingEventEmitter();
+    const handler = vi.fn();
+
+    emitter.on('run_started', handler);
+    await emitter.emit(makeEvent('run_completed'));
+
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('removes handler with off()', async () => {
+    const emitter = new SelfModifyingEventEmitter();
+    const handler = vi.fn();
+
+    emitter.on('run_started', handler);
+    emitter.off('run_started', handler);
+    await emitter.emit(makeEvent('run_started'));
+
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('returns unsubscribe function from on()', async () => {
+    const emitter = new SelfModifyingEventEmitter();
+    const handler = vi.fn();
+
+    const unsub = emitter.on('run_started', handler);
+    unsub();
+    await emitter.emit(makeEvent('run_started'));
+
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('survives handler errors with Promise.allSettled', async () => {
+    const emitter = new SelfModifyingEventEmitter();
+    const goodHandler = vi.fn();
+    const badHandler = vi.fn(() => {
+      throw new Error('boom');
+    });
+
+    emitter.on('run_started', badHandler);
+    emitter.on('run_started', goodHandler);
+
+    await emitter.emit(makeEvent('run_started'));
+
+    expect(badHandler).toHaveBeenCalled();
+    expect(goodHandler).toHaveBeenCalled();
+  });
+
+  it('removeAllListeners clears specific event', () => {
+    const emitter = new SelfModifyingEventEmitter();
+    emitter.on('run_started', vi.fn());
+    emitter.on('run_completed', vi.fn());
+
+    emitter.removeAllListeners('run_started');
+
+    expect(emitter.listenerCount('run_started')).toBe(0);
+    expect(emitter.listenerCount('run_completed')).toBe(1);
+  });
+
+  it('removeAllListeners clears all events', () => {
+    const emitter = new SelfModifyingEventEmitter();
+    emitter.on('run_started', vi.fn());
+    emitter.on('run_completed', vi.fn());
+    emitter.on('*', vi.fn());
+
+    emitter.removeAllListeners();
+
+    expect(emitter.listenerCount('run_started')).toBe(0);
+    expect(emitter.listenerCount('run_completed')).toBe(0);
+    expect(emitter.listenerCount('*')).toBe(0);
+  });
+
+  it('listenerCount returns correct count', () => {
+    const emitter = new SelfModifyingEventEmitter();
+    expect(emitter.listenerCount('run_started')).toBe(0);
+
+    emitter.on('run_started', vi.fn());
+    emitter.on('run_started', vi.fn());
+
+    expect(emitter.listenerCount('run_started')).toBe(2);
+  });
+});

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

@@ -0,0 +1,197 @@
+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 { z } from 'zod';
+
+function createMockAgent(tools: Tool[] = []): Agent {
+  return {
+    name: 'test-agent',
+    model: 'test-model',
+    instructions: 'You are a test assistant.',
+    tools,
+    config: { temperature: 0.5 },
+  } as Agent;
+}
+
+function createMockTool(name: string, result: unknown): Tool {
+  return {
+    name,
+    description: `Mock tool: ${name}`,
+    parameters: z.object({ input: z.string() }),
+    execute: vi.fn().mockResolvedValue(result),
+    toJSON: () => ({
+      name,
+      description: `Mock tool: ${name}`,
+      parameters: { type: 'object' as const, properties: { input: { type: 'string' } } },
+    }),
+  };
+}
+
+function chatResponse(content: string, toolCalls?: ToolCall[]): ChatResponse {
+  return {
+    content,
+    toolCalls,
+    finishReason: toolCalls?.length ? 'tool_calls' : 'stop',
+    usage: { inputTokens: 10, outputTokens: 10, totalTokens: 20 },
+  };
+}
+
+describe('SelfModifyingAgent tool execution', () => {
+  it('passes tools to LLM and returns response', async () => {
+    const calculator = createMockTool('calculator', { result: 42 });
+
+    const mockLLM: Partial<LLMBackend> = {
+      chat: vi.fn()
+        .mockResolvedValueOnce(chatResponse('', [
+          { id: 'call_1', name: 'calculator', arguments: { input: '6*7' } },
+        ]))
+        .mockResolvedValueOnce(chatResponse('The answer is 42.')),
+    };
+
+    const agent = createMockAgent([calculator]);
+    const selfMod = new SelfModifyingAgent({
+      agent,
+      llm: mockLLM as LLMBackend,
+      config: {
+        toolGeneration: { enabled: false },
+        metaReasoning: { enabled: false },
+        architectureEvolution: { enabled: false },
+        constraints: { enabled: false },
+      },
+    });
+
+    const result = await selfMod.run('What is 6 times 7?');
+
+    expect(result.output).toBe('The answer is 42.');
+    expect(calculator.execute).toHaveBeenCalledOnce();
+    expect(calculator.execute).toHaveBeenCalledWith(
+      { input: '6*7' },
+      expect.objectContaining({ agentId: 'test-agent' }),
+    );
+
+    const chatCalls = vi.mocked(mockLLM.chat!).mock.calls;
+    expect(chatCalls[0][0].tools).toBeDefined();
+    expect(chatCalls[0][0].tools).toHaveLength(1);
+    expect(chatCalls[0][0].tools![0].name).toBe('calculator');
+  });
+
+  it('handles multiple sequential tool calls', async () => {
+    const search = createMockTool('search', { results: ['found it'] });
+    const format = createMockTool('format', { text: 'formatted result' });
+
+    const mockLLM: Partial<LLMBackend> = {
+      chat: vi.fn()
+        .mockResolvedValueOnce(chatResponse('', [
+          { id: 'call_1', name: 'search', arguments: { input: 'test' } },
+        ]))
+        .mockResolvedValueOnce(chatResponse('', [
+          { id: 'call_2', name: 'format', arguments: { input: 'found it' } },
+        ]))
+        .mockResolvedValueOnce(chatResponse('Here is your formatted result.')),
+    };
+
+    const agent = createMockAgent([search, format]);
+    const selfMod = new SelfModifyingAgent({
+      agent,
+      llm: mockLLM as LLMBackend,
+      config: {
+        toolGeneration: { enabled: false },
+        metaReasoning: { enabled: false },
+        architectureEvolution: { enabled: false },
+        constraints: { enabled: false },
+      },
+    });
+
+    const result = await selfMod.run('Search and format');
+
+    expect(result.output).toBe('Here is your formatted result.');
+    expect(search.execute).toHaveBeenCalledOnce();
+    expect(format.execute).toHaveBeenCalledOnce();
+    expect(vi.mocked(mockLLM.chat!)).toHaveBeenCalledTimes(3);
+  });
+
+  it('handles tool execution errors gracefully', async () => {
+    const failTool = createMockTool('broken', null);
+    (failTool.execute as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('tool crashed'));
+
+    const mockLLM: Partial<LLMBackend> = {
+      chat: vi.fn()
+        .mockResolvedValueOnce(chatResponse('', [
+          { id: 'call_1', name: 'broken', arguments: { input: 'test' } },
+        ]))
+        .mockResolvedValueOnce(chatResponse('The tool failed but I can help anyway.')),
+    };
+
+    const agent = createMockAgent([failTool]);
+    const selfMod = new SelfModifyingAgent({
+      agent,
+      llm: mockLLM as LLMBackend,
+      config: {
+        toolGeneration: { enabled: false },
+        metaReasoning: { enabled: false },
+        architectureEvolution: { enabled: false },
+        constraints: { enabled: false },
+      },
+    });
+
+    const result = await selfMod.run('Use the broken tool');
+
+    expect(result.output).toBe('The tool failed but I can help anyway.');
+    const secondCall = vi.mocked(mockLLM.chat!).mock.calls[1][0];
+    const toolMsg = secondCall.messages.find((m: { role: string }) => m.role === 'tool');
+    expect(toolMsg?.content).toContain('tool crashed');
+  });
+
+  it('handles unknown tool calls', async () => {
+    const mockLLM: Partial<LLMBackend> = {
+      chat: vi.fn()
+        .mockResolvedValueOnce(chatResponse('', [
+          { id: 'call_1', name: 'nonexistent', arguments: { input: 'x' } },
+        ]))
+        .mockResolvedValueOnce(chatResponse('I could not find that tool.')),
+    };
+
+    const agent = createMockAgent([]);
+    const selfMod = new SelfModifyingAgent({
+      agent,
+      llm: mockLLM as LLMBackend,
+      config: {
+        toolGeneration: { enabled: false },
+        metaReasoning: { enabled: false },
+        architectureEvolution: { enabled: false },
+        constraints: { enabled: false },
+      },
+    });
+
+    const result = await selfMod.run('Call a tool');
+
+    expect(result.output).toBe('I could not find that tool.');
+    const secondCall = vi.mocked(mockLLM.chat!).mock.calls[1][0];
+    const toolMsg = secondCall.messages.find((m: { role: string }) => m.role === 'tool');
+    expect(toolMsg?.content).toContain('not found');
+  });
+
+  it('works without any tools (no tools passed to LLM)', async () => {
+    const mockLLM: Partial<LLMBackend> = {
+      chat: vi.fn().mockResolvedValueOnce(chatResponse('Hello world')),
+    };
+
+    const agent = createMockAgent([]);
+    const selfMod = new SelfModifyingAgent({
+      agent,
+      llm: mockLLM as LLMBackend,
+      config: {
+        toolGeneration: { enabled: false },
+        metaReasoning: { enabled: false },
+        architectureEvolution: { enabled: false },
+        constraints: { enabled: false },
+      },
+    });
+
+    const result = await selfMod.run('Just say hi');
+
+    expect(result.output).toBe('Hello world');
+    const chatCall = vi.mocked(mockLLM.chat!).mock.calls[0][0];
+    expect(chatCall.tools).toBeUndefined();
+  });
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { extractJson, llmChat } from '../utils';
+
+describe('extractJson', () => {
+  it('extracts simple JSON object', () => {
+    const result = extractJson('{"key": "value"}');
+    expect(result).toBe('{"key": "value"}');
+  });
+
+  it('extracts JSON from surrounding text', () => {
+    const result = extractJson('Here is the result: {"onTrack": true, "confidence": 0.8} and that is it.');
+    expect(result).toBe('{"onTrack": true, "confidence": 0.8}');
+  });
+
+  it('handles nested braces', () => {
+    const result = extractJson('{"a": {"b": {"c": 1}}}');
+    expect(JSON.parse(result!)).toEqual({ a: { b: { c: 1 } } });
+  });
+
+  it('ignores braces inside strings', () => {
+    const result = extractJson('{"text": "hello {world}"}');
+    expect(JSON.parse(result!)).toEqual({ text: 'hello {world}' });
+  });
+
+  it('handles escaped quotes in strings', () => {
+    const result = extractJson('{"text": "she said \\"hi\\""}');
+    expect(result).toBe('{"text": "she said \\"hi\\""}');
+    expect(JSON.parse(result!)).toEqual({ text: 'she said "hi"' });
+  });
+
+  it('returns null for no JSON', () => {
+    expect(extractJson('no json here')).toBeNull();
+  });
+
+  it('returns null for empty input', () => {
+    expect(extractJson('')).toBeNull();
+  });
+
+  it('does not greedily match across multiple JSON objects', () => {
+    const input = 'Note: {not valid} But here is: {"valid": true}';
+    const result = extractJson(input);
+    expect(result).toBe('{not valid}');
+  });
+
+  it('handles first valid JSON from LLM response with preamble containing braces', () => {
+    const input = `Here's my analysis:
+{"hasGap": true, "gaps": []}`;
+    const result = extractJson(input);
+    expect(JSON.parse(result!)).toEqual({ hasGap: true, gaps: [] });
+  });
+
+  it('handles arrays inside objects', () => {
+    const result = extractJson('{"items": [1, 2, {"nested": true}]}');
+    expect(JSON.parse(result!)).toEqual({ items: [1, 2, { nested: true }] });
+  });
+});
+
+describe('llmChat', () => {
+  it('uses complete when available', async () => {
+    const llm = {
+      complete: async (_opts: { messages: unknown[] }) => ({
+        content: `response from complete`,
+        usage: { inputTokens: 10, outputTokens: 20 },
+      }),
+      chat: async () => ({
+        content: 'should not be called',
+        usage: { inputTokens: 10, outputTokens: 20 },
+      }),
+    };
+
+    const result = await llmChat(llm as never, [{ role: 'user', content: 'hi' }]);
+    expect(result).toBe('response from complete');
+  });
+
+  it('falls back to chat when complete is unavailable', async () => {
+    const llm = {
+      chat: async (opts: { model: string }) => ({
+        content: `response from chat with model ${opts.model}`,
+        usage: { inputTokens: 10, outputTokens: 20 },
+      }),
+    };
+
+    const result = await llmChat(llm as never, [{ role: 'user', content: 'hi' }], {
+      model: 'gpt-4',
+    });
+    expect(result).toBe('response from chat with model gpt-4');
+  });
+
+  it('uses default model when none specified', async () => {
+    const llm = {
+      chat: async (opts: { model: string }) => ({
+        content: opts.model,
+        usage: { inputTokens: 10, outputTokens: 20 },
+      }),
+    };
+
+    const result = await llmChat(llm as never, [{ role: 'user', content: 'hi' }]);
+    expect(result).toBe('default');
+  });
+});

package/src/architecture-evolution/capability-analyzer.ts

@@ -151,7 +151,7 @@ export class CapabilityAnalyzer {
     let profile: TaskProfile;
 
     if (this.llm && this.enableLLMAnalysis) {
-      profile = await this.analyzWithLLM(taskDescription, context);
+      profile = await this.analyzeWithLLM(taskDescription, context);
     } else {
       profile = this.analyzeHeuristically(taskDescription, context?.availableTools);
     }
@@ -167,7 +167,7 @@ export class CapabilityAnalyzer {
     return profile;
   }
 
-  private async analyzWithLLM(
+  private async analyzeWithLLM(
     taskDescription: string,
     context?: {
       availableTools?: Tool[];
@@ -266,9 +266,11 @@ export class CapabilityAnalyzer {
   }
 
   private detectComplexity(task: string, wordCount: number): TaskProfile['complexity'] {
+    const taskWords = new Set(task.split(/\s+/));
+
     for (const [level, indicators] of Object.entries(COMPLEXITY_INDICATORS).reverse()) {
       for (const indicator of indicators) {
-        if (task.includes(indicator)) {
+        if (taskWords.has(indicator)) {
           return level as TaskProfile['complexity'];
         }
       }

package/src/architecture-evolution/evolution-strategy.ts

@@ -176,17 +176,18 @@ export class EvolutionStrategy {
   }
 
   private sampleNormal(): number {
-    const u1 = Math.random();
+    const u1 = Math.random() || Number.MIN_VALUE;
     const u2 = Math.random();
     return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
   }
 
   updateCandidate(candidate: EvolutionCandidate, reward: number): void {
+    const clampedReward = Math.max(0, Math.min(1, reward));
     const oldScore = candidate.score;
     const oldCount = candidate.evaluationCount;
 
     candidate.evaluationCount++;
-    candidate.score = (oldScore * oldCount + reward) / candidate.evaluationCount;
+    candidate.score = (oldScore * oldCount + clampedReward) / candidate.evaluationCount;
   }
 
   getExplorationRate(): number {

package/src/architecture-evolution/parameter-optimizer.ts

@@ -7,7 +7,7 @@ import type {
   EvolutionMetrics,
 } from '@cogitator-ai/types';
 import { CapabilityAnalyzer } from './capability-analyzer';
-import { EvolutionStrategy, type SelectionResult as _SelectionResult } from './evolution-strategy';
+import { EvolutionStrategy } from './evolution-strategy';
 import {
   buildCandidateGenerationPrompt,
   buildPerformanceAnalysisPrompt,
@@ -48,6 +48,7 @@ export class ParameterOptimizer {
   private candidates: EvolutionCandidate[] = [];
   private history: HistoricalRecord[] = [];
   private currentGeneration = 0;
+  private lastEvolutionTimestamp = 0;
   private readonly maxHistorySize = 100;
 
   constructor(options: ParameterOptimizerOptions) {
@@ -173,6 +174,7 @@ export class ParameterOptimizer {
 
   private async evolve(currentProfile: TaskProfile): Promise<void> {
     this.currentGeneration++;
+    this.lastEvolutionTimestamp = Date.now();
 
     const topCandidates = [...this.candidates]
       .filter((c) => c.evaluationCount > 0)
@@ -325,10 +327,7 @@ export class ParameterOptimizer {
   }
 
   private getLastEvolutionTime(): number {
-    const latestGenCandidate = this.candidates.find(
-      (c) => c.generation === this.currentGeneration && c.evaluationCount === 0
-    );
-    return latestGenCandidate ? Date.now() - 300000 : 0;
+    return this.lastEvolutionTimestamp;
   }
 
   private getRelevantHistory(profile: TaskProfile): HistoricalRecord[] {
@@ -410,7 +409,7 @@ export class ParameterOptimizer {
       fields++;
     }
 
-    if (a.model !== b.model) {
+    if (a.model !== undefined && b.model !== undefined && a.model !== b.model) {
       distance += 1;
       fields++;
     }
@@ -447,8 +446,9 @@ export class ParameterOptimizer {
     if (evaluatedCandidates.length === 0) return null;
 
     const results = evaluatedCandidates.map((c) => {
+      const configKey = JSON.stringify(c.config, Object.keys(c.config).sort());
       const records = this.history.filter(
-        (h) => JSON.stringify(h.config) === JSON.stringify(c.config)
+        (h) => JSON.stringify(h.config, Object.keys(h.config).sort()) === configKey
       );
       const avgMetrics =
         records.length > 0
@@ -503,6 +503,7 @@ export class ParameterOptimizer {
     this.candidates = [];
     this.history = [];
     this.currentGeneration = 0;
+    this.lastEvolutionTimestamp = 0;
     this.evolutionStrategy.reset();
   }
 }

package/src/architecture-evolution/prompts.ts

@@ -1,4 +1,5 @@
 import type { TaskProfile, ArchitectureConfig, EvolutionCandidate } from '@cogitator-ai/types';
+import { extractJson } from '../utils';
 
 export const ARCHITECTURE_ANALYSIS_SYSTEM_PROMPT = `You are an expert in AI agent architecture optimization.
 Your task is to analyze tasks and recommend optimal configurations.
@@ -140,11 +141,11 @@ Respond with:
 }
 
 export function parseTaskProfileResponse(response: string): TaskProfile | null {
-  const jsonMatch = /\{[\s\S]*\}/.exec(response);
-  if (!jsonMatch) return null;
+  const json = extractJson(response);
+  if (!json) return null;
 
   try {
-    const parsed = JSON.parse(jsonMatch[0]);
+    const parsed = JSON.parse(json);
 
     return {
       complexity: parsed.complexity || 'moderate',
@@ -197,11 +198,11 @@ export function parsePerformanceAnalysisResponse(response: string): {
   shouldAdopt: boolean;
   analysis: string;
 } | null {
-  const jsonMatch = /\{[\s\S]*\}/.exec(response);
-  if (!jsonMatch) return null;
+  const json = extractJson(response);
+  if (!json) return null;
 
   try {
-    const parsed = JSON.parse(jsonMatch[0]);
+    const parsed = JSON.parse(json);
 
     return {
       recommendation: String(parsed.recommendation || ''),

package/src/constraints/index.ts

@@ -6,6 +6,7 @@ export {
   mergeSafetyConstraints,
   mergeCapabilityConstraints,
   mergeResourceConstraints,
+  mergeCustomConstraints,
   mergeConstraints,
 } from './safety-constraints';
 

package/src/constraints/modification-validator.ts

@@ -92,23 +92,7 @@ export class ModificationValidator {
       return this.evaluateExpression(rule, request.payload as Record<string, unknown>);
     }
 
-    const payload = request.payload as Record<string, unknown>;
-
-    switch (rule.type) {
-      case 'invariant':
-        return this.evaluateExpression(rule.expression ?? '', payload);
-      case 'precondition':
-        return this.evaluateExpression(rule.expression ?? '', payload);
-      case 'postcondition':
-        return true;
-      case 'temporal':
-        if (rule.pattern?.source === 'never') {
-          return !this.evaluateExpression(rule.expression ?? '', payload);
-        }
-        return true;
-      default:
-        return true;
-    }
+    return this.evaluateExpression(rule.expression ?? '', request.payload as Record<string, unknown>);
   }
 
   private evaluateExpression(expression: string, context: Record<string, unknown>): boolean {
@@ -127,16 +111,18 @@ export class ModificationValidator {
 
     if (conditions.length === 0) return true;
 
-    let result = conditions[0];
+    const orGroups: boolean[][] = [[]];
+    orGroups[0].push(conditions[0]);
+
     for (let i = 0; i < operators.length; i++) {
       if (operators[i] === 'AND') {
-        result = result && conditions[i + 1];
+        orGroups[orGroups.length - 1].push(conditions[i + 1]);
       } else {
-        result = result || conditions[i + 1];
+        orGroups.push([conditions[i + 1]]);
       }
     }
 
-    return result;
+    return orGroups.some((group) => group.every(Boolean));
   }
 
   private evaluateSimpleCondition(condition: string, context: Record<string, unknown>): boolean {
@@ -384,6 +370,11 @@ export class ModificationValidator {
   }
 
   getConstraints(): ModificationConstraints {
-    return { ...this.constraints };
+    return {
+      safety: [...this.constraints.safety],
+      capability: [...this.constraints.capability],
+      resource: [...this.constraints.resource],
+      custom: this.constraints.custom ? [...this.constraints.custom] : [],
+    };
   }
 }

package/src/constraints/safety-constraints.ts

@@ -2,6 +2,7 @@ import type {
   SafetyConstraint,
   CapabilityConstraint,
   ResourceConstraint,
+  CustomConstraint,
   ModificationConstraints,
 } from '@cogitator-ai/types';
 import { DEFAULT_SAFETY_CONSTRAINTS } from '@cogitator-ai/types';
@@ -84,6 +85,20 @@ export function mergeResourceConstraints(
   return [...result.values()];
 }
 
+export function mergeCustomConstraints(
+  base: CustomConstraint[],
+  additions: CustomConstraint[]
+): CustomConstraint[] {
+  const result = new Map<string, CustomConstraint>();
+  for (const c of base) {
+    result.set(c.id, c);
+  }
+  for (const c of additions) {
+    result.set(c.id, c);
+  }
+  return [...result.values()];
+}
+
 export function mergeConstraints(
   base: ModificationConstraints,
   additions: Partial<ModificationConstraints>
@@ -96,6 +111,6 @@ export function mergeConstraints(
     resource: additions.resource
       ? mergeResourceConstraints(base.resource, additions.resource)
       : base.resource,
-    custom: [...(base.custom ?? []), ...(additions.custom ?? [])],
+    custom: mergeCustomConstraints(base.custom ?? [], additions.custom ?? []),
   };
 }

package/src/events/event-emitter.ts

@@ -30,7 +30,15 @@ export class SelfModifyingEventEmitter {
       ...(wildcardHandlers ? [...wildcardHandlers] : []),
     ];
 
-    await Promise.all(allHandlers.map((h) => Promise.resolve(h(event))));
+    await Promise.allSettled(
+      allHandlers.map((h) => {
+        try {
+          return Promise.resolve(h(event));
+        } catch (e) {
+          return Promise.reject(e instanceof Error ? e : new Error(String(e)));
+        }
+      })
+    );
   }
 
   createEvent(