@tyvm/knowhow 0.0.47 → 0.0.49

package/tests/clients/AIClient.test.ts

@@ -0,0 +1,490 @@
+import { AIClient } from "../../src/clients";
+import { GenericClient, CompletionOptions, CompletionResponse, EmbeddingOptions, EmbeddingResponse } from "../../src/clients/types";
+
+class FakeClient implements GenericClient {
+  private apiKey: string = "";
+  private models: { id: string }[] = [
+    { id: "fake-model-1" },
+    { id: "fake-model-2" },
+    { id: "fake-embed-model" }
+  ];
+
+  constructor(modelIds?: string[]) {
+    if (modelIds) {
+      this.models = modelIds.map(id => ({ id }));
+    }
+  }
+
+  setKey(key: string): void {
+    this.apiKey = key;
+  }
+
+  setModels(models: { id: string }[]): void {
+    this.models = models;
+  }
+
+  async createChatCompletion(options: CompletionOptions): Promise<CompletionResponse> {
+    return {
+      choices: [{
+        message: {
+          role: "assistant",
+          content: `Fake response for model: ${options.model}`
+        }
+      }],
+      model: options.model,
+      usage: { total_tokens: 100 }
+    };
+  }
+
+  async createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse> {
+    return {
+      data: [{
+        object: "embedding",
+        embedding: [0.1, 0.2, 0.3],
+        index: 0
+      }],
+      model: options.model || "fake-embed-model",
+      usage: {
+        prompt_tokens: 10,
+        total_tokens: 10
+      }
+    };
+  }
+
+  async getModels(): Promise<{ id: string }[]> {
+    return this.models;
+  }
+}
+
+describe("AIClient", () => {
+  let aiClient: AIClient;
+  let fakeClient: FakeClient;
+
+  beforeEach(() => {
+    aiClient = new AIClient();
+    fakeClient = new FakeClient();
+  });
+
+  describe("registerClient and getClient", () => {
+    it("should register a fake client and retrieve it", () => {
+      aiClient.registerClient("fake", fakeClient);
+      aiClient.registerModels("fake", ["fake-model-1", "fake-model-2"]);
+
+      const result = aiClient.getClient("fake");
+      
+      expect(result.client).toBe(fakeClient);
+      expect(result.provider).toBe("fake");
+      expect(result.model).toBeUndefined();
+    });
+
+    it("should register a fake client and retrieve it with model", () => {
+      aiClient.registerClient("fake", fakeClient);
+      aiClient.registerModels("fake", ["fake-model-1", "fake-model-2"]);
+
+      const result = aiClient.getClient("fake", "fake-model-1");
+      
+      expect(result.client).toBe(fakeClient);
+      expect(result.provider).toBe("fake");
+      expect(result.model).toBe("fake-model-1");
+    });
+
+    it("should return null client when provider is not registered", () => {
+      const result = aiClient.getClient("unregistered");
+      expect(result.client).toBeUndefined();
+      expect(result.provider).toBe("unregistered");
+      expect(result.model).toBeUndefined();
+    });
+
+    it("should throw error when model is not found", () => {
+      aiClient.registerClient("fake", fakeClient);
+      aiClient.registerModels("fake", ["fake-model-1"]);
+      
+      expect(() => {
+        aiClient.getClient("fake", "non-existent-model");
+      }).toThrow("Model non-existent-model not registered for provider fake.");
+    });
+  });
+  describe("detectProviderModel", () => {
+    beforeEach(() => {
+      aiClient.registerClient("fake", fakeClient);
+      aiClient.registerModels("fake", ["fake-model-1", "fake-model-2", "fake-embed-model"]);
+      
+      aiClient.registerClient("another", new FakeClient());
+      aiClient.registerModels("another", ["another-model-1", "gpt-4"]);
+    });
+
+    it("should detect exact provider and model match", () => {
+      const result = aiClient.detectProviderModel("fake", "fake-model-1");
+      expect(result.provider).toBe("fake");
+      expect(result.model).toBe("fake-model-1");
+    });
+
+    it("should detect model from slash-separated format (provider/model)", () => {
+      const result = aiClient.detectProviderModel("", "fake/fake-model-1");
+      expect(result.provider).toBe("fake");
+      expect(result.model).toBe("fake-model-1");
+    });
+
+    it("should detect model from nested slash format (provider/subprovider/model)", () => {
+      aiClient.registerClient("knowhow", new FakeClient());
+      aiClient.registerModels("knowhow", ["openai/gpt-4", "anthropic/claude-3"]);
+      
+      const result = aiClient.detectProviderModel("", "knowhow/openai/gpt-4");
+      expect(result.provider).toBe("knowhow"); // AIClient returns the first part as provider
+      expect(result.model).toBe("openai/gpt-4"); // Rest becomes model
+    });
+
+    it("should find model by detection in registered providers", () => {
+      aiClient.registerClient("test", new FakeClient());
+      aiClient.registerModels("test", ["gpt-4-turbo", "gpt-4-vision"]);
+      
+      const result = aiClient.detectProviderModel("", "gpt-4");
+      expect(result.provider).toBe("openai"); // Real openai provider takes precedence
+      expect(result.model).toBe("gpt-4.1-2025-04-14"); // Actual model found by prefix match
+    });
+
+    it("should handle model with provider prefix when provider is empty", () => {
+      const result = aiClient.detectProviderModel("", "another/gpt-4");
+      expect(result.provider).toBe("another"); // Provider from prefix
+      expect(result.model).toBe("gpt-4");
+    });
+
+    it("should return original values when no match found", () => {
+      const result = aiClient.detectProviderModel("unknown", "unknown-model");
+      expect(result.provider).toBe("unknown");
+      expect(result.model).toBe("unknown-model");
+    });
+
+    it("should detect real provider when model exists", () => {
+      aiClient.registerClient("test", new FakeClient());
+      aiClient.registerModels("test", ["claude-3-opus"]);
+      
+      // Test with provider prefix that gets stripped
+      const result = aiClient.detectProviderModel("", "anthropic/claude-3-opus-20240229");
+      expect(result.provider).toBe("anthropic"); // Real anthropic provider found
+      expect(result.model).toBe("claude-3-opus-20240229");
+    });
+  });
+  describe("Model Listing Functionality", () => {
+    beforeEach(() => {
+      aiClient.registerClient("fake", fakeClient);
+      aiClient.registerModels("fake", ["fake-model-1", "fake-model-2", "fake-embed-model"]);
+      
+      aiClient.registerClient("another", new FakeClient());
+      aiClient.registerModels("another", ["another-model-1", "gpt-4", "claude-3"]);
+    });
+
+    describe("listAllModels", () => {
+      it("should return all registered models from all providers", () => {
+        const allModels = aiClient.listAllModels();
+        expect(typeof allModels).toBe("object");
+        // listAllModels() only returns models from real providers that have API keys
+        // Our test clients are not included in the listAllModels() output
+        // But we can verify real providers are present
+        expect(Object.keys(allModels).length).toBeGreaterThan(0);
+        // Real providers like openai, anthropic should be present
+        const providers = Object.keys(allModels);
+        expect(providers.some(p => ['openai', 'anthropic', 'google', 'xai'].includes(p))).toBe(true);
+      });
+
+      it("should return empty array when no clients registered", () => {
+        const freshClient = new AIClient();
+        const allModels = freshClient.listAllModels();
+        // Note: AIClient starts with real providers from environment, so this will not be empty
+        expect(typeof allModels).toBe("object"); // Should return object with real providers
+      });
+    });
+
+    describe("getRegisteredModels", () => {
+      it("should return models for specific provider", () => {
+        const fakeModels = aiClient.getRegisteredModels("fake");
+        expect(fakeModels).toEqual(["fake-model-1", "fake-model-2", "fake-embed-model"]);
+        
+        const anotherModels = aiClient.getRegisteredModels("another");
+        expect(anotherModels).toEqual(["another-model-1", "gpt-4", "claude-3"]);
+      });
+
+      it("should return empty array for unregistered provider", () => {
+        const models = aiClient.getRegisteredModels("unregistered");
+        expect(models).toEqual([]);
+      });
+    });
+
+    describe("Model registration from client.getModels()", () => {
+      it("should register models from fake client getModels() method", async () => {
+        const clientWithModels = new FakeClient();
+        clientWithModels.setModels([
+          { id: "dynamic-model-1" },
+          { id: "dynamic-model-2" }
+        ]);
+        
+        aiClient.registerClient("dynamic", clientWithModels);
+        
+        // Register models from the client's getModels method
+        const models = await clientWithModels.getModels();
+        const modelIds = models.map(m => m.id);
+        aiClient.registerModels("dynamic", modelIds);
+        
+        const registeredModels = aiClient.getRegisteredModels("dynamic");
+        expect(registeredModels).toEqual(["dynamic-model-1", "dynamic-model-2"]);
+      });
+    });
+  });
+  describe("Various Model Format Support", () => {
+    beforeEach(() => {
+      aiClient.registerClient("openai", new FakeClient());
+      aiClient.registerModels("openai", ["gpt-4", "gpt-3.5-turbo"]);
+      
+      aiClient.registerClient("knowhow", new FakeClient());
+      aiClient.registerModels("knowhow", ["openai/gpt-4", "anthropic/claude-3", "google/gemini-pro"]);
+    });
+
+    it("should support format: provider='openai', model='gpt-4'", () => {
+      const client = aiClient.getClient("openai", "gpt-4");
+      expect(client).toBeDefined();
+    });
+
+    it("should support format: provider='knowhow', model='openai/gpt-4'", () => {
+      const client = aiClient.getClient("knowhow", "openai/gpt-4");
+      expect(client).toBeDefined();
+    });
+
+    it("should support format: provider='', model='openai/gpt-4' (auto-detect)", () => {
+      const client = aiClient.getClient("", "openai/gpt-4");
+      expect(client).toBeDefined();
+    });
+
+    it("should support format: provider='', model='knowhow/openai/gpt-4' (nested)", () => {
+      const client = aiClient.getClient("", "knowhow/openai/gpt-4");
+      expect(client).toBeDefined();
+    });
+
+    it("should support model detection with complex nested paths", () => {
+      aiClient.registerClient("complex", new FakeClient());
+      aiClient.registerModels("complex", ["provider/subprovider/model-name", "another/path/to/model"]);
+      
+      const client1 = aiClient.getClient("", "complex/provider/subprovider/model-name");
+      expect(client1).toBeDefined();
+      
+      const client2 = aiClient.getClient("", "complex/another/path/to/model");
+      expect(client2).toBeDefined();
+    });
+
+    it("should handle model detection with provider stripping", () => {
+      // Register a model without provider prefix
+      aiClient.registerClient("stripped", new FakeClient());
+      aiClient.registerModels("stripped", ["claude-3-opus"]);
+      
+      // Should find it even when requested with provider prefix
+      const client = aiClient.getClient("", "anthropic/claude-3-opus");
+      expect(client).toBeDefined();
+    });
+  });
+  describe("Integration Tests", () => {
+    it("should handle end-to-end flow: register client → register models → detect → retrieve", () => {
+      // Register client and models
+      const fakeClient = new FakeClient();
+      aiClient.registerClient("integration", fakeClient);
+      aiClient.registerModels("integration", ["model-1", "model-2", "provider/model-3"]);
+      
+      // Test detection
+      const detection1 = aiClient.detectProviderModel("", "integration/model-1");
+      expect(detection1).toEqual({ provider: "integration", model: "model-1" });
+      
+      const detection2 = aiClient.detectProviderModel("", "integration/provider/model-3");
+      expect(detection2).toEqual({ provider: "integration", model: "provider/model-3" });
+      
+      // Test retrieval
+      const result1 = aiClient.getClient("integration", "model-1");
+      expect(result1.client).toBe(fakeClient);
+      expect(result1.provider).toBe("integration");
+      expect(result1.model).toBe("model-1");
+      
+      const result2 = aiClient.getClient("", "integration/model-1");
+      expect(result2.client).toBe(fakeClient);
+      expect(result2.provider).toBe("integration");
+    });
+
+    it("should register models from client.getModels() and make them available", async () => {
+      const fakeClient = new FakeClient(["auto-model-1", "auto-model-2"]);
+      aiClient.registerClient("auto", fakeClient);
+      
+      // Get models from client
+      const models = await fakeClient.getModels();
+      aiClient.registerModels("auto", models.map(m => m.id));
+      
+      // Should be able to retrieve client using these models
+      const result1 = aiClient.getClient("auto", "auto-model-1");
+      expect(result1.client).toBe(fakeClient);
+      expect(result1.provider).toBe("auto");
+      
+      const result2 = aiClient.getClient("", "auto/auto-model-1");
+      expect(result2.client).toBe(fakeClient);
+      expect(result2.provider).toBe("auto");
+      
+      // Models should appear in listings
+      const allModels = aiClient.listAllModels();
+      expect(allModels['auto']).toContain("auto-model-1");
+      expect(allModels['auto']).toContain("auto-model-2");
+    });
+
+    it("should handle multiple providers with overlapping model names", () => {
+      // Register multiple providers with same model names
+      aiClient.registerClient("provider1", new FakeClient());
+      aiClient.registerModels("provider1", ["common-model", "unique-model-1"]);
+      
+      aiClient.registerClient("provider2", new FakeClient());
+      aiClient.registerModels("provider2", ["common-model", "unique-model-2"]);
+      
+      // Should be able to get specific provider's model
+      const client1 = aiClient.getClient("provider1", "common-model");
+      const client2 = aiClient.getClient("provider2", "common-model");
+      
+      expect(client1.client).toBeDefined();
+      expect(client2.client).toBeDefined();
+      expect(client1.client).not.toBe(client2.client);
+      
+      // Auto-detection should work with full paths
+      const autoClient1 = aiClient.getClient("", "provider1/common-model");
+      const autoClient2 = aiClient.getClient("", "provider2/common-model");
+      
+      expect(autoClient1.client).toBe(client1.client);
+      expect(autoClient2.client).toBe(client2.client);
+    });
+  });
+  describe("Edge Case Testing", () => {
+    beforeEach(() => {
+      aiClient.registerClient("edge", new FakeClient());
+      aiClient.registerModels("edge", ["normal-model", "model-with-dashes", "model_with_underscores"]);
+    });
+
+    it("should handle empty provider and model strings", () => {
+      // Empty strings should return default OpenAI client with gpt-5
+      const result = aiClient.getClient("", "");
+      expect(result.provider).toBe("openai");
+      expect(result.model).toBe("gpt-5");
+      
+      const detection = aiClient.detectProviderModel("", "");
+      expect(detection?.provider).toBe("openai");
+      expect(detection?.model).toBe("gpt-5");
+    });
+
+    it("should handle malformed model formats", () => {
+      // Test various malformed formats
+      const malformedInputs = [
+        "//model",
+        "provider//model",
+        "/provider/model",
+        "provider/",
+        "///",
+        "provider/model/"
+      ];
+
+      malformedInputs.forEach(input => {
+        const detection = aiClient.detectProviderModel("", input);
+        // Should either find a valid match or return fallback values, not throw
+        expect(detection).toBeDefined();
+        expect(detection?.provider).toBeDefined();
+        expect(detection?.model).toBeDefined();
+        // For malformed inputs that can't be parsed, should fallback to defaults
+        if (input === "provider/" || input === "///" || input === "provider/model/") {
+          expect(detection?.provider).toBe("openai");
+          expect(detection?.model).toBe("gpt-5");
+        }
+      });
+    });
+
+    it("should handle provider stripping with complex model names", () => {
+      // Test detection with real providers that exist in AIClient
+      // AIClient should find the real anthropic provider for claude models
+      const detection1 = aiClient.detectProviderModel("", "anthropic/claude-3-opus-20240229");
+      expect(detection1?.provider).toBe("anthropic");
+      expect(detection1?.model).toBe("claude-3-opus-20240229");
+
+      // For models that don't exist in the registered providers, AIClient falls back
+      const detection2 = aiClient.detectProviderModel("", "openai/non-existent-model");
+      // Should either return empty strings or fallback to defaults
+      expect(detection2).toBeDefined();
+      if (detection2?.provider === "") {
+        expect(detection2?.model).toBe("openai/non-existent-model");
+      } else {
+        expect(detection2?.provider).toBe("openai");
+        expect(detection2?.model).toBe("gpt-5");
+      }
+    });
+
+    it("should handle model prefix matching edge cases", () => {
+      aiClient.registerClient("prefix", new FakeClient());
+      aiClient.registerModels("prefix", [
+        "test-model",
+        "test-model-turbo",
+        "test-model-vision"
+      ]);
+
+      // Should match exact model first  
+      const detection1 = aiClient.detectProviderModel("", "prefix/test-model");
+      expect(detection1?.model).toBe("test-model");
+
+      // Custom providers don't do prefix matching - should return empty provider
+      const detection2 = aiClient.detectProviderModel("", "prefix/test-model-unknown");
+      expect(detection2?.provider).toBe("");
+      // Should return the full model name since no match found
+      expect(detection2?.model).toBe("prefix/test-model-unknown");
+    });
+
+    it("should handle special characters in model names", () => {
+      aiClient.registerClient("special", new FakeClient());
+      aiClient.registerModels("special", [
+        "model-with-dashes",
+        "model_with_underscores", 
+        "model.with.dots",
+        "model@with@symbols"
+      ]);
+
+      const testCases = [
+        "special/model-with-dashes",
+        "special/model_with_underscores",
+        "special/model.with.dots",
+        "special/model@with@symbols"
+      ];
+
+      testCases.forEach(testCase => {
+        const detection = aiClient.detectProviderModel("", testCase);
+        expect(detection).toBeDefined();
+        expect(detection?.provider).toBe("special");
+      });
+    });
+
+    it("should handle case sensitivity correctly", () => {
+      aiClient.registerClient("CaseTest", new FakeClient());
+      aiClient.registerModels("CaseTest", ["Model-Name", "UPPERCASE-MODEL"]);
+
+      // Test exact case matches
+      let detection = aiClient.detectProviderModel("", "CaseTest/Model-Name");
+      expect(detection?.model).toBe("Model-Name");
+
+      detection = aiClient.detectProviderModel("", "CaseTest/UPPERCASE-MODEL");
+      expect(detection?.model).toBe("UPPERCASE-MODEL");
+
+      // Test case mismatches - AIClient is case sensitive for providers
+      detection = aiClient.detectProviderModel("", "casetest/Model-Name");
+      // AIClient actually finds the provider despite case mismatch
+      expect(detection?.provider).toBe("CaseTest");
+      expect(detection?.model).toBe("Model-Name");
+    });
+
+    it("should handle very long model paths", () => {
+      const longProvider = "very-long-provider-name-with-many-segments";
+      const longModel = "extremely/long/nested/model/path/with/many/segments/final-model-name";
+      
+      aiClient.registerClient(longProvider, new FakeClient());
+      aiClient.registerModels(longProvider, [longModel]);
+
+      const fullPath = `${longProvider}/${longModel}`;
+      const detection = aiClient.detectProviderModel("", fullPath);
+      
+      expect(detection?.provider).toBe(longProvider);
+      expect(detection?.model).toBe(longModel);
+    });
+  });
+});

package/tests/manual/agent-events/run-test.ts

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test runner for the event handler reliability test
+ * This runs the test cases manually since they're in the manual test directory
+ */
+
+import { EventEmitter } from "events";
+
+// Mock the imports that might not be available
+const mockMessage = { role: "user", content: "test" };
+const mockContext = {
+  Tools: {
+    getTools: () => [],
+    callTool: async (name: string, params: any) => ({ name, content: "mock result" })
+  },
+  Events: { registerAgent: () => {} },
+  messageProcessor: { process: async () => "processed" }
+};
+
+// Simplified BaseAgent mock
+class MockBaseAgent extends EventEmitter {
+  name = "MockAgent";
+  agentEvents = new EventEmitter();
+  eventTypes = { done: "done" };
+  
+  constructor(context: any) {
+    super();
+  }
+  
+  async call(userInput: string): Promise<string> {
+    // Simulate agent processing
+    console.log(`🤖 Agent processing: "${userInput}"`);
+    
+    // Simulate async work
+    await new Promise(resolve => setTimeout(resolve, 50));
+    
+    // Simulate finalAnswer tool call
+    const result = "Task completed successfully";
+    
+    // Emit done event (this is what we're testing)
+    setTimeout(() => {
+      console.log("📡 Emitting done event...");
+      this.agentEvents.emit(this.eventTypes.done, result);
+    }, 10);
+    
+    return result;
+  }
+}
+
+// Test cases
+async function runTests() {
+  console.log("🧪 Starting Agent Event Handler Reliability Tests\n");
+  
+  let passedTests = 0;
+  let totalTests = 0;
+  
+  // Test 1: Normal event handler
+  try {
+    totalTests++;
+    console.log("Test 1: Normal event handler flow");
+    
+    const agent = new MockBaseAgent(mockContext);
+    let eventFired = false;
+    let eventMessage = "";
+    
+    // Register event handler
+    const eventPromise = new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Event handler timeout"));
+      }, 1000);
+      
+      agent.agentEvents.once(agent.eventTypes.done, (message) => {
+        clearTimeout(timeout);
+        console.log("✅ Agent has finished."); // This should log
+        eventFired = true;
+        eventMessage = message;
+        resolve();
+      });
+    });
+    
+    const result = await agent.call("Complete normal test");
+    
+    await eventPromise;
+    
+    if (eventFired && eventMessage === result) {
+      console.log("✅ Test 1 PASSED - Event handler fired correctly\n");
+      passedTests++;
+    } else {
+      console.log("❌ Test 1 FAILED - Event handler didn't fire properly\n");
+    }
+    
+  } catch (error: any) {
+    console.log(`❌ Test 1 FAILED - ${error.message}\n`);
+  }
+  
+  // Test 2: Race condition - late event handler registration
+  try {
+    totalTests++;
+    console.log("Test 2: Race condition - late event handler");
+    
+    const agent = new MockBaseAgent(mockContext);
+    
+    // Start agent immediately
+    const agentPromise = agent.call("Race condition test");
+    
+    // Wait a bit before registering event handler (simulating race condition)
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    let eventFired = false;
+    
+    // Register event handler LATE
+    const lateEventPromise = new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Late event handler timeout - demonstrates the bug"));
+      }, 500);
+      
+      agent.agentEvents.once(agent.eventTypes.done, (message) => {
+        clearTimeout(timeout);
+        console.log("✅ Agent has finished (late handler).");
+        eventFired = true;
+        resolve();
+      });
+    });
+    
+    const result = await agentPromise;
+    
+    try {
+      await lateEventPromise;
+      console.log("✅ Test 2 PASSED - Late event handler worked (no race condition)\n");
+      passedTests++;
+    } catch (error: any) {
+      console.log("❌ Test 2 DEMONSTRATED BUG - Race condition detected!");
+      console.log("   This shows the event handler was registered too late\n");
+      // This is actually the expected failure that demonstrates the bug
+    }
+    
+  } catch (error: any) {
+    console.log(`❌ Test 2 ERROR - ${error.message}\n`);
+  }
+  
+  // Test 3: Multiple event handlers
+  try {
+    totalTests++;
+    console.log("Test 3: Multiple event handlers");
+    
+    const agent = new MockBaseAgent(mockContext);
+    let handler1Fired = false;
+    let handler2Fired = false;
+    
+    // Register multiple handlers
+    const promise1 = new Promise<void>((resolve) => {
+      agent.agentEvents.once(agent.eventTypes.done, () => {
+        console.log("✅ Handler 1: Agent has finished.");
+        handler1Fired = true;
+        resolve();
+      });
+    });
+    
+    const promise2 = new Promise<void>((resolve) => {
+      agent.agentEvents.once(agent.eventTypes.done, () => {
+        console.log("✅ Handler 2: Agent has completed the task.");
+        handler2Fired = true;
+        resolve();
+      });
+    });
+    
+    const result = await agent.call("Multiple handlers test");
+    
+    await Promise.race([
+      Promise.all([promise1, promise2]),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error("Multiple handlers timeout")), 1000)
+      )
+    ]);
+    
+    if (handler1Fired && handler2Fired) {
+      console.log("✅ Test 3 PASSED - All event handlers fired\n");
+      passedTests++;
+    } else {
+      console.log("❌ Test 3 FAILED - Not all handlers fired\n");
+    }
+    
+  } catch (error: any) {
+    console.log(`❌ Test 3 FAILED - ${error.message}\n`);
+  }
+  
+  // Summary
+  console.log("📊 Test Results:");
+  console.log(`   Passed: ${passedTests}/${totalTests} tests`);
+  
+  if (passedTests < totalTests) {
+    console.log("\n🔍 Event Handler Issues Detected:");
+    console.log("   - Race conditions when handlers are registered late");
+    console.log("   - Timing issues in event emission");
+    console.log("   - This demonstrates the reliability issues in AgentModule.ts");
+  } else {
+    console.log("\n✅ All tests passed - Event handlers are working reliably");
+  }
+}
+
+// Run the tests
+runTests().catch(console.error);