@elizaos/core 1.5.1 → 1.5.2

package/dist/browser/index.d.ts

@@ -1 +1,3 @@
-export * from '../../src/index.browser';
+// Type definitions for @elizaos/core (Browser)
+// Re-exports all types from the Browser source entry point
+export * from '../../src/index.browser';

package/dist/index.d.ts

@@ -1,4 +1,3 @@
 // Type definitions for @elizaos/core
-// Re-export all types from the built Node entry by default
-
-export * from './node/index';
+// Re-exports all types from the Node.js entry point
+export * from '../src/index.node';

package/dist/index.js

@@ -1,8 +1,4 @@
-/**
- * Main entry point for @elizaos/core
- * Automatically selects the correct build based on the environment
- */
-
+// Main entry point for @elizaos/core
 // This file is not used directly - package.json conditional exports handle the routing
 // See package.json "exports" field for the actual entry points
 export * from './node/index.node.js';

package/dist/node/index.d.ts

@@ -1 +1,3 @@
-export * from '../../src/index.node';
+// Type definitions for @elizaos/core (Node.js)
+// Re-exports all types from the Node.js source entry point
+export * from '../../src/index.node';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/core",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -12,14 +12,19 @@
     ".": {
       "types": "./dist/index.d.ts",
       "browser": {
+        "types": "./dist/browser/index.d.ts",
         "import": "./dist/browser/index.browser.js",
         "default": "./dist/browser/index.browser.js"
       },
       "node": {
+        "types": "./dist/node/index.d.ts",
         "import": "./dist/node/index.node.js",
         "default": "./dist/node/index.node.js"
       },
-      "bun": "./dist/node/index.node.js",
+      "bun": {
+        "types": "./dist/node/index.d.ts",
+        "default": "./dist/node/index.node.js"
+      },
       "default": "./dist/node/index.node.js"
     },
     "./node": {
@@ -34,7 +39,8 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "bun run build.ts",
@@ -75,5 +81,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e2da2b5640a11e8b8dd7b4aef51d8d5cddf29895"
+  "gitHead": "78ec4978065a95e4102d270417ac2b3f4dd96e9f"
 }

package/src/__tests__/action-chaining-simple.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, it, beforeEach, mock } from 'bun:test';
+import { AgentRuntime } from '../runtime';
+import { createActionResult } from '../types/components';
+import type { ActionResult } from '../types';
+
+describe('Action Chaining Fixes', () => {
+  describe('createActionResult helper', () => {
+    it('should create ActionResult with default success=true', () => {
+      const result = createActionResult();
+      expect(result.success).toBe(true);
+      expect(result.text).toBeUndefined();
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should allow overriding success field', () => {
+      const result = createActionResult({ success: false, error: 'Test error' });
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Test error');
+    });
+
+    it('should preserve all provided fields', () => {
+      const result = createActionResult({
+        text: 'Test text',
+        values: { key: 'value' },
+        data: { foo: 'bar' },
+      });
+      expect(result.success).toBe(true);
+      expect(result.text).toBe('Test text');
+      expect(result.values).toEqual({ key: 'value' });
+      expect(result.data).toEqual({ foo: 'bar' });
+    });
+  });
+
+  describe('Runtime immutable helpers', () => {
+    let runtime: any;
+
+    beforeEach(() => {
+      // Access private methods through prototype
+      runtime = AgentRuntime.prototype;
+    });
+
+    it('should update action plan immutably', () => {
+      const originalPlan = {
+        currentStep: 1,
+        totalSteps: 3,
+        steps: [{ action: 'step1' }, { action: 'step2' }, { action: 'step3' }],
+      };
+
+      const updatedPlan = runtime.updateActionPlan(originalPlan, { currentStep: 2 });
+
+      // Original should be unchanged
+      expect(originalPlan.currentStep).toBe(1);
+
+      // Updated should have new value
+      expect(updatedPlan.currentStep).toBe(2);
+      expect(updatedPlan.totalSteps).toBe(3);
+      expect(updatedPlan.steps).toEqual(originalPlan.steps);
+
+      // Should be different objects
+      expect(updatedPlan).not.toBe(originalPlan);
+    });
+
+    it('should update action step immutably', () => {
+      const originalPlan = {
+        currentStep: 1,
+        steps: [
+          { action: 'step1', status: 'pending' },
+          { action: 'step2', status: 'pending' },
+          { action: 'step3', status: 'pending' },
+        ],
+      };
+
+      const updatedPlan = runtime.updateActionStep(originalPlan, 1, {
+        status: 'completed',
+        result: { success: true },
+      });
+
+      // Original should be unchanged
+      expect(originalPlan.steps[1].status).toBe('pending');
+      expect(originalPlan.steps[1].result).toBeUndefined();
+
+      // Updated should have new values
+      expect(updatedPlan.steps[1].status).toBe('completed');
+      expect(updatedPlan.steps[1].result).toEqual({ success: true });
+
+      // Other steps should be unchanged
+      expect(updatedPlan.steps[0]).toEqual(originalPlan.steps[0]);
+      expect(updatedPlan.steps[2]).toEqual(originalPlan.steps[2]);
+
+      // Should be different objects
+      expect(updatedPlan).not.toBe(originalPlan);
+      expect(updatedPlan.steps).not.toBe(originalPlan.steps);
+      expect(updatedPlan.steps[1]).not.toBe(originalPlan.steps[1]);
+    });
+  });
+
+  describe('Working Memory Cleanup', () => {
+    it('should enforce MAX_WORKING_MEMORY_ENTRIES limit', () => {
+      // This is more of a documentation test showing the expected behavior
+      const MAX_WORKING_MEMORY_ENTRIES = 50;
+      const workingMemory: Record<string, any> = {};
+
+      // Add 60 entries
+      for (let i = 0; i < 60; i++) {
+        workingMemory[`action_${i}`] = {
+          actionName: `Action${i}`,
+          timestamp: Date.now() + i, // Incrementing timestamps
+          result: { success: true },
+        };
+      }
+
+      // Simulate cleanup
+      const entries = Object.entries(workingMemory);
+      expect(entries.length).toBe(60);
+
+      // Sort by timestamp (newest first) with proper type safety
+      const sorted = entries.sort((a, b) => {
+        const entryA = a[1] as { timestamp?: number } | null;
+        const entryB = b[1] as { timestamp?: number } | null;
+        const timestampA = entryA?.timestamp ?? 0;
+        const timestampB = entryB?.timestamp ?? 0;
+        return timestampB - timestampA;
+      });
+
+      // Keep only the most recent MAX_WORKING_MEMORY_ENTRIES
+      const cleaned = Object.fromEntries(sorted.slice(0, MAX_WORKING_MEMORY_ENTRIES));
+
+      expect(Object.keys(cleaned).length).toBe(MAX_WORKING_MEMORY_ENTRIES);
+
+      // Verify we kept the newest entries
+      const cleanedKeys = Object.keys(cleaned);
+      expect(cleanedKeys).toContain('action_59');
+      expect(cleanedKeys).toContain('action_50');
+      expect(cleanedKeys).not.toContain('action_9'); // Old entry should be removed
+    });
+  });
+
+  describe('Bounds Checking', () => {
+    it('should handle updateActionStep with invalid indices', () => {
+      // Mock logger
+      const warnCalls: string[] = [];
+      const mockLogger = {
+        warn: (msg: string) => {
+          warnCalls.push(msg);
+        },
+      };
+
+      // Helper function that mimics the runtime's updateActionStep
+      const updateActionStep = <T, S>(
+        plan: T & { steps: S[] },
+        index: number,
+        stepUpdates: Partial<S>,
+        logger: typeof mockLogger
+      ): T & { steps: S[] } => {
+        if (!plan.steps || index < 0 || index >= plan.steps.length) {
+          logger.warn(
+            `Invalid step index: ${index} for plan with ${plan.steps?.length || 0} steps`
+          );
+          return plan;
+        }
+        return {
+          ...plan,
+          steps: plan.steps.map((step: S, i: number) =>
+            i === index ? { ...step, ...stepUpdates } : step
+          ),
+        };
+      };
+
+      // Test data
+      const plan = {
+        name: 'test-plan',
+        steps: [
+          { status: 'pending', action: 'step1' },
+          { status: 'pending', action: 'step2' },
+          { status: 'pending', action: 'step3' },
+        ],
+      };
+
+      // Test valid index
+      const updated1 = updateActionStep(plan, 1, { status: 'completed' }, mockLogger);
+      expect(updated1.steps[1].status).toBe('completed');
+      expect(warnCalls.length).toBe(0);
+
+      // Test negative index
+      const updated2 = updateActionStep(plan, -1, { status: 'failed' }, mockLogger);
+      expect(updated2).toBe(plan); // Should return original plan
+      expect(warnCalls[0]).toBe('Invalid step index: -1 for plan with 3 steps');
+
+      // Test index out of bounds
+      warnCalls.length = 0; // Clear warnings
+      const updated3 = updateActionStep(plan, 5, { status: 'failed' }, mockLogger);
+      expect(updated3).toBe(plan); // Should return original plan
+      expect(warnCalls[0]).toBe('Invalid step index: 5 for plan with 3 steps');
+
+      // Test with null steps
+      warnCalls.length = 0; // Clear warnings
+      const planWithNullSteps = { name: 'test', steps: null as any };
+      const updated4 = updateActionStep(planWithNullSteps, 0, { status: 'completed' }, mockLogger);
+      expect(updated4).toBe(planWithNullSteps);
+      expect(warnCalls[0]).toBe('Invalid step index: 0 for plan with 0 steps');
+    });
+  });
+});

package/src/__tests__/actions.test.ts

@@ -0,0 +1,218 @@
+import { describe, expect, it } from 'bun:test';
+import { composeActionExamples, formatActionNames, formatActions } from '../actions';
+import type { Action } from '../types';
+
+describe('Actions', () => {
+  const mockActions: Action[] = [
+    {
+      name: 'greet',
+      description: 'Greet someone',
+      examples: [
+        [
+          { name: 'name1', content: { text: 'Hello {{name2}}!' } },
+          {
+            name: 'name2',
+            content: { text: 'Hi {{name1}}!', action: 'wave' },
+          },
+        ],
+        [
+          {
+            name: 'name1',
+            content: { text: 'Hey {{name2}}, how are you?' },
+          },
+          {
+            name: 'name2',
+            content: { text: "I'm good {{name1}}, thanks!" },
+          },
+        ],
+      ],
+      similes: ['say hi', 'welcome'],
+      handler: async () => {
+        throw new Error('Not implemented');
+      },
+      validate: async () => {
+        throw new Error('Not implemented');
+      },
+    },
+    {
+      name: 'farewell',
+      description: 'Say goodbye',
+      examples: [
+        [
+          { name: 'name1', content: { text: 'Goodbye {{name2}}!' } },
+          { name: 'name2', content: { text: 'Bye {{name1}}!' } },
+        ],
+      ],
+      similes: ['say bye', 'leave'],
+      handler: async () => {
+        throw new Error('Not implemented');
+      },
+      validate: async () => {
+        throw new Error('Not implemented');
+      },
+    },
+    {
+      name: 'help',
+      description: 'Get assistance',
+      examples: [
+        [
+          {
+            name: 'name1',
+            content: { text: 'Can you help me {{name2}}?' },
+          },
+          {
+            name: 'name2',
+            content: {
+              text: 'Of course {{name1}}, what do you need?',
+              action: 'assist',
+            },
+          },
+        ],
+      ],
+      similes: ['assist', 'support'],
+      handler: async () => {
+        throw new Error('Not implemented');
+      },
+      validate: async () => {
+        throw new Error('Not implemented');
+      },
+    },
+  ];
+
+  describe('composeActionExamples', () => {
+    it('should generate examples with correct format', () => {
+      const examples = composeActionExamples(mockActions, 1);
+      const lines = examples.trim().split('\n');
+      expect(lines.length).toBeGreaterThan(0);
+      expect(lines[0]).toMatch(/^name\d: .+/);
+    });
+
+    it('should replace name placeholders with generated names', () => {
+      const examples = composeActionExamples(mockActions, 1);
+      expect(examples).not.toContain('{{name1}}');
+      expect(examples).not.toContain('{{name2}}');
+    });
+
+    it('should handle empty actions array', () => {
+      const examples = composeActionExamples([], 5);
+      expect(examples).toBe('');
+    });
+
+    it('should handle count larger than available examples', () => {
+      const examples = composeActionExamples(mockActions, 10);
+      expect(examples.length).toBeGreaterThan(0);
+    });
+
+    it('should handle actions without examples', () => {
+      const actionsWithoutExamples: Action[] = [
+        {
+          name: 'test',
+          description: 'Test action without examples',
+          examples: [], // Empty examples array
+          similes: [],
+          handler: async () => {
+            throw new Error('Not implemented');
+          },
+          validate: async () => {
+            throw new Error('Not implemented');
+          },
+        },
+        {
+          name: 'test2',
+          description: 'Test action with no examples property',
+          // examples property not defined
+          similes: [],
+          handler: async () => {
+            throw new Error('Not implemented');
+          },
+          validate: async () => {
+            throw new Error('Not implemented');
+          },
+        } as Action,
+      ];
+
+      const examples = composeActionExamples(actionsWithoutExamples, 5);
+      expect(examples).toBe('');
+    });
+
+    it('should handle count of zero', () => {
+      const examples = composeActionExamples(mockActions, 0);
+      expect(examples).toBe('');
+    });
+
+    it('should handle negative count', () => {
+      const examples = composeActionExamples(mockActions, -5);
+      expect(examples).toBe('');
+    });
+  });
+
+  describe('formatActionNames', () => {
+    it('should format action names correctly', () => {
+      const formatted = formatActionNames([mockActions[0], mockActions[1]]);
+      expect(formatted).toMatch(/^(greet|farewell)(, (greet|farewell))?$/);
+    });
+
+    it('should handle single action', () => {
+      const formatted = formatActionNames([mockActions[0]]);
+      expect(formatted).toBe('greet');
+    });
+
+    it('should handle empty actions array', () => {
+      const formatted = formatActionNames([]);
+      expect(formatted).toBe('');
+    });
+  });
+
+  describe('formatActions', () => {
+    it('should format actions with descriptions', () => {
+      const formatted = formatActions([mockActions[0]]);
+      expect(formatted).toBe('- **greet**: Greet someone');
+    });
+
+    it('should include commas and newlines between multiple actions', () => {
+      const formatted = formatActions([mockActions[0], mockActions[1]]);
+      const parts = formatted.split('\n');
+      expect(parts.length).toBe(2);
+      expect(parts[0]).toMatch(/^- \*\*(greet|farewell)\*\*: /);
+      expect(parts[1]).toMatch(/^- \*\*(greet|farewell)\*\*: /);
+    });
+
+    it('should handle empty actions array', () => {
+      const formatted = formatActions([]);
+      expect(formatted).toBe('');
+    });
+  });
+
+  describe('Action Structure', () => {
+    it('should validate action structure', () => {
+      for (const action of mockActions) {
+        expect(action).toHaveProperty('name');
+        expect(action).toHaveProperty('description');
+        expect(action).toHaveProperty('examples');
+        expect(action).toHaveProperty('similes');
+        expect(action).toHaveProperty('handler');
+        expect(action).toHaveProperty('validate');
+        expect(Array.isArray(action.examples)).toBe(true);
+        expect(Array.isArray(action.similes)).toBe(true);
+      }
+    });
+
+    it('should validate example structure', () => {
+      for (const action of mockActions) {
+        for (const example of action.examples ?? []) {
+          for (const message of example) {
+            expect(message).toHaveProperty('name');
+            expect(message).toHaveProperty('content');
+            expect(message.content).toHaveProperty('text');
+          }
+        }
+      }
+    });
+
+    it('should have unique action names', () => {
+      const names = mockActions.map((action) => action.name);
+      const uniqueNames = new Set(names);
+      expect(names.length).toBe(uniqueNames.size);
+    });
+  });
+});