@gotza02/seq-thinking 1.1.2 → 1.1.4

package/src/__tests__/sequential-thinking.test.ts

@@ -292,9 +292,9 @@ describe('MetaReasoningEngine', () => {
     graph = new ThoughtGraph();
   });
 
-  test('should reflect on session', () => {
+  test('should reflect on session', async () => {
     const session = createMockSession();
-    const reflection = engine.reflect(session);
+    const reflection = await engine.reflect(session);
     
     assert.ok(reflection.reflectionType);
     assert.ok(reflection.content);
@@ -318,18 +318,18 @@ describe('MetaReasoningEngine', () => {
     }
   });
 
-  test('should handle empty session reflection', () => {
+  test('should handle empty session reflection', async () => {
     const emptySession = createMockSession({ totalThoughts: 0, totalBranches: 0 });
-    const reflection = engine.reflect(emptySession);
+    const reflection = await engine.reflect(emptySession);
     
     assert.ok(reflection);
     assert.ok(Array.isArray(reflection.insights));
     assert.ok(Array.isArray(reflection.recommendations));
   });
 
-  test('should handle session with multiple branches', () => {
+  test('should handle session with multiple branches', async () => {
     const session = createMockSession({ totalThoughts: 10, totalBranches: 3 });
-    const reflection = engine.reflect(session);
+    const reflection = await engine.reflect(session);
     
     assert.ok(reflection.insights.length > 0 || reflection.recommendations.length > 0);
   });
@@ -344,11 +344,11 @@ describe('SelfCorrectionEngine', () => {
     graph = new ThoughtGraph();
   });
 
-  test('should detect issues in thought', () => {
+  test('should detect issues in thought', async () => {
     const sessionId = 'test-session';
     const thought = graph.createThought(sessionId, 'Test thought with potential issues');
     
-    const issues = engine.detectIssues(thought, graph);
+    const issues = await engine.detectIssues(thought, graph);
     
     assert.ok(Array.isArray(issues));
     issues.forEach(issue => {
@@ -359,14 +359,14 @@ describe('SelfCorrectionEngine', () => {
     });
   });
 
-  test('should detect no issues in well-formed thought', () => {
+  test('should detect no issues in well-formed thought', async () => {
     const sessionId = 'test-session';
     const thought = graph.createThought(sessionId, 'Well-formed thought with clear reasoning', {
       confidence: 0.95,
       assumptions: ['valid-assumption'],
     });
     
-    const issues = engine.detectIssues(thought, graph);
+    const issues = await engine.detectIssues(thought, graph);
     
     // Should either return empty array or only low severity issues
     issues.forEach(issue => {
@@ -418,30 +418,30 @@ describe('AdaptiveGranularityEngine', () => {
     engine = new AdaptiveGranularityEngine();
   });
 
-  test('should calculate granularity for simple topic', () => {
+  test('should calculate granularity for simple topic', async () => {
     const context = createMockContext();
-    const result = engine.calculateGranularity('Simple topic', context, 1);
+    const result = await engine.calculateGranularity('Simple topic', context, 1);
     
     assert.ok(typeof result.detail === 'number');
     assert.ok(result.detail > 0 && result.detail <= 1);
     assert.ok(result.reasoning);
   });
 
-  test('should calculate granularity for complex topic', () => {
+  test('should calculate granularity for complex topic', async () => {
     const context = createMockContext();
     const complexTopic = 'Analyze the implications of quantum computing on cryptographic systems';
-    const result = engine.calculateGranularity(complexTopic, context, 1);
+    const result = await engine.calculateGranularity(complexTopic, context, 1);
     
     assert.ok(result.detail > 0);
     assert.ok(result.reasoning.length > 0);
   });
 
-  test('should adjust granularity based on depth', () => {
+  test('should adjust granularity based on depth', async () => {
     const context = createMockContext();
     const topic = 'Test topic';
     
-    const shallow = engine.calculateGranularity(topic, context, 1);
-    const deep = engine.calculateGranularity(topic, context, 10);
+    const shallow = await engine.calculateGranularity(topic, context, 1);
+    const deep = await engine.calculateGranularity(topic, context, 10);
     
     // Deeper depth might suggest different granularity
     assert.ok(typeof shallow.detail === 'number');
@@ -458,7 +458,7 @@ describe('AdaptiveGranularityEngine', () => {
     assert.ok(recommendation.reasoning);
   });
 
-  test('should handle empty context', () => {
+  test('should handle empty context', async () => {
     const emptyContext: SessionContext = {
       originalProblem: '',
       constraints: [],
@@ -467,13 +467,13 @@ describe('AdaptiveGranularityEngine', () => {
       longTermReferences: [],
     };
     
-    const result = engine.calculateGranularity('Topic', emptyContext, 1);
+    const result = await engine.calculateGranularity('Topic', emptyContext, 1);
     
     assert.ok(typeof result.detail === 'number');
     assert.ok(result.reasoning);
   });
 
-  test('should handle very complex context', () => {
+  test('should handle very complex context', async () => {
     const complexContext: SessionContext = {
       originalProblem: 'Complex multi-faceted problem',
       constraints: Array(20).fill('constraint'),
@@ -482,7 +482,7 @@ describe('AdaptiveGranularityEngine', () => {
       longTermReferences: Array(10).fill('ref'),
     };
     
-    const result = engine.calculateGranularity('Complex topic', complexContext, 5);
+    const result = await engine.calculateGranularity('Complex topic', complexContext, 5);
     
     assert.ok(typeof result.detail === 'number');
     assert.ok(result.detail > 0 && result.detail <= 1);

package/src/agents/base-agent.ts

@@ -13,6 +13,7 @@ import {
   type TaskResult,
   type SwarmMessage
 } from '../types/index.js';
+import { Logger } from '../utils/logger.js';
 
 /**
  * Abstract base class for all agents
@@ -142,11 +143,11 @@ export abstract class BaseAgent {
         const result = handler(message);
         if (result instanceof Promise) {
           result.catch(error => {
-            console.error(`Error in message handler for agent ${this.id}:`, error);
+            Logger.error(`Error in message handler for agent ${this.id}`, { error });
           });
         }
       } catch (error) {
-        console.error(`Error in message handler for agent ${this.id}:`, error);
+        Logger.error(`Error in message handler for agent ${this.id}`, { error });
       }
     }
   }
@@ -254,6 +255,7 @@ export abstract class BaseAgent {
       tokensUsed?: number;
       reasoningSteps?: number;
       intermediateResults?: unknown[];
+      error?: string;
     } = {}
   ): TaskResult {
     return {
@@ -266,7 +268,8 @@ export abstract class BaseAgent {
       metadata: {
         tokensUsed: metadata.tokensUsed || 0,
         reasoningSteps: metadata.reasoningSteps || 1,
-        intermediateResults: metadata.intermediateResults || []
+        intermediateResults: metadata.intermediateResults || [],
+        error: metadata.error
       }
     };
   }