onbuzz 4.8.3 → 4.9.0

package/src/tools/__tests__/composioTool.test.js

@@ -0,0 +1,268 @@
+/**
+ * Composio tool unit tests.
+ *
+ * SDK is mocked at the tool level via `_loadSdk` override (no need to
+ * mock the @composio/core ESM at the resolver layer — the tool isolates
+ * SDK access behind that single method).
+ *
+ * Covers:
+ *   - SDK-not-installed path (no @composio/core, no env var)
+ *   - API-key-missing path
+ *   - Both envelope shapes (plural canonical + singular legacy)
+ *   - Each of the 5 actions: list-toolkits, list-tools, connect,
+ *     connection-status, execute
+ *   - Per-action validation (missing toolkitSlug / actionSlug)
+ *   - Batched execution
+ *   - userId mapped from context.agentId
+ *   - Error surfacing on upstream failures
+ */
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import ComposioTool from '../composioTool.js';
+
+const SILENT_LOGGER = { info() {}, warn() {}, error() {}, debug() {} };
+
+function makeMockClient() {
+  return {
+    toolkits: { list: jest.fn().mockResolvedValue([{ slug: 'github', name: 'GitHub' }]) },
+    tools: {
+      list: jest.fn().mockResolvedValue([{ slug: 'GITHUB_CREATE_AN_ISSUE', description: 'Create issue' }]),
+      execute: jest.fn().mockResolvedValue({ successful: true, data: { issueNumber: 42 } }),
+    },
+    connectedAccounts: {
+      initiate: jest.fn().mockResolvedValue({ id: 'conn-1', redirectUrl: 'https://connect.composio.dev/link/abc' }),
+      get: jest.fn().mockResolvedValue({ id: 'conn-1', status: 'ACTIVE' }),
+    },
+  };
+}
+
+function makeTool({ client } = {}) {
+  const tool = new ComposioTool({}, SILENT_LOGGER);
+  if (client) {
+    tool._loadSdk = jest.fn().mockResolvedValue({ client });
+  }
+  return tool;
+}
+
+let savedApiKey;
+beforeEach(() => {
+  savedApiKey = process.env.COMPOSIO_API_KEY;
+  process.env.COMPOSIO_API_KEY = 'test-key';
+});
+afterEach(() => {
+  if (savedApiKey === undefined) delete process.env.COMPOSIO_API_KEY;
+  else process.env.COMPOSIO_API_KEY = savedApiKey;
+});
+
+describe('ComposioTool — startup guards', () => {
+  test('returns structured error when COMPOSIO_API_KEY is missing', async () => {
+    delete process.env.COMPOSIO_API_KEY;
+    const tool = new ComposioTool({}, SILENT_LOGGER);
+    const r = await tool.execute({ actions: [{ type: 'list-toolkits' }] }, { agentId: 'a' });
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/COMPOSIO_API_KEY/);
+  });
+
+  test('returns structured error when @composio/core SDK is not installed', async () => {
+    const tool = new ComposioTool({}, SILENT_LOGGER);
+    // Force the dynamic import to fail.
+    tool._loadSdk = async () => ({ error: '@composio/core SDK is not installed.' });
+    const r = await tool.execute({ actions: [{ type: 'list-toolkits' }] }, { agentId: 'a' });
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/SDK is not installed/);
+  });
+});
+
+describe('ComposioTool — validation', () => {
+  test('rejects empty params with helpful error', async () => {
+    const tool = makeTool({ client: makeMockClient() });
+    const r = await tool.execute({}, { agentId: 'a' });
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/action/);
+  });
+
+  test('customValidateParameters rejects unknown action type', () => {
+    const tool = new ComposioTool({}, SILENT_LOGGER);
+    const v = tool.customValidateParameters({ actions: [{ type: 'invade-poland' }] });
+    expect(v.valid).toBe(false);
+    expect(v.errors.join(' ')).toMatch(/invalid type/);
+  });
+
+  test('customValidateParameters requires toolkitSlug for list-tools/connect/connection-status', () => {
+    const tool = new ComposioTool({}, SILENT_LOGGER);
+    for (const t of ['list-tools', 'connect', 'connection-status']) {
+      const v = tool.customValidateParameters({ actions: [{ type: t }] });
+      expect(v.valid).toBe(false);
+      expect(v.errors.join(' ')).toMatch(/toolkitSlug/);
+    }
+  });
+
+  test('customValidateParameters requires both toolkitSlug AND actionSlug for execute', () => {
+    const tool = new ComposioTool({}, SILENT_LOGGER);
+    const v1 = tool.customValidateParameters({ actions: [{ type: 'execute', toolkitSlug: 'gh' }] });
+    expect(v1.errors.join(' ')).toMatch(/actionSlug/);
+    const v2 = tool.customValidateParameters({ actions: [{ type: 'execute', actionSlug: 'X' }] });
+    expect(v2.errors.join(' ')).toMatch(/toolkitSlug/);
+    const vOk = tool.customValidateParameters({ actions: [{ type: 'execute', toolkitSlug: 'gh', actionSlug: 'X' }] });
+    expect(vOk.valid).toBe(true);
+  });
+});
+
+describe('ComposioTool — envelope acceptance', () => {
+  test('accepts canonical {actions: [{type}]}', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    const r = await tool.execute({ actions: [{ type: 'list-toolkits' }] }, { agentId: 'a' });
+    expect(r.success).toBe(true);
+    expect(client.toolkits.list).toHaveBeenCalled();
+  });
+
+  test('accepts legacy singular {action}', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    const r = await tool.execute({ action: 'list-toolkits' }, { agentId: 'a' });
+    expect(r.success).toBe(true);
+    expect(client.toolkits.list).toHaveBeenCalled();
+  });
+
+  test('accepts {action} inside items (action-named discriminator)', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    const r = await tool.execute({ actions: [{ action: 'list-toolkits' }] }, { agentId: 'a' });
+    expect(r.success).toBe(true);
+  });
+});
+
+describe('ComposioTool — actions', () => {
+  test('list-toolkits returns the toolkits array', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    const r = await tool.execute({ actions: [{ type: 'list-toolkits' }] }, { agentId: 'a' });
+    expect(r.success).toBe(true);
+    expect(r.action).toBe('list-toolkits');
+    expect(r.toolkits[0].slug).toBe('github');
+  });
+
+  test('list-tools forwards toolkitSlug and userId', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    const r = await tool.execute({ actions: [{ type: 'list-tools', toolkitSlug: 'github' }] }, { agentId: 'agent-42' });
+    expect(r.success).toBe(true);
+    expect(client.tools.list).toHaveBeenCalledWith({ toolkit: 'github', userId: 'agent-42' });
+  });
+
+  test('connect returns a Connect Link URL and connectionId', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    const r = await tool.execute({ actions: [{ type: 'connect', toolkitSlug: 'github' }] }, { agentId: 'agent-99' });
+    expect(r.success).toBe(true);
+    expect(r.connectLink).toMatch(/^https:\/\/connect\.composio\.dev/);
+    expect(r.connectionId).toBe('conn-1');
+    expect(client.connectedAccounts.initiate).toHaveBeenCalledWith({ userId: 'agent-99', toolkit: 'github' });
+  });
+
+  test('connection-status maps ACTIVE → connected: true', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    const r = await tool.execute({ actions: [{ type: 'connection-status', toolkitSlug: 'github' }] }, { agentId: 'a' });
+    expect(r.connected).toBe(true);
+    expect(r.status).toBe('ACTIVE');
+  });
+
+  test('connection-status maps missing connection → connected: false', async () => {
+    const client = makeMockClient();
+    client.connectedAccounts.get.mockResolvedValueOnce(null);
+    const tool = makeTool({ client });
+    const r = await tool.execute({ actions: [{ type: 'connection-status', toolkitSlug: 'slack' }] }, { agentId: 'a' });
+    expect(r.connected).toBe(false);
+    expect(r.status).toBe('NOT_CONNECTED');
+  });
+
+  test('execute forwards arguments and returns upstream output', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    const r = await tool.execute({
+      actions: [{
+        type: 'execute',
+        toolkitSlug: 'github',
+        actionSlug: 'GITHUB_CREATE_AN_ISSUE',
+        arguments: { owner: 'acme', repo: 'api', title: 'Bug' },
+      }],
+    }, { agentId: 'agent-1' });
+    expect(r.success).toBe(true);
+    expect(r.output).toMatchObject({ issueNumber: 42 });
+    expect(client.tools.execute).toHaveBeenCalledWith(
+      'GITHUB_CREATE_AN_ISSUE',
+      { userId: 'agent-1', arguments: { owner: 'acme', repo: 'api', title: 'Bug' } }
+    );
+  });
+
+  test('execute surfaces upstream errors structurally', async () => {
+    const client = makeMockClient();
+    client.tools.execute.mockResolvedValueOnce({ successful: false, error: 'rate limited' });
+    const tool = makeTool({ client });
+    const r = await tool.execute({
+      actions: [{ type: 'execute', toolkitSlug: 'gh', actionSlug: 'X', arguments: {} }],
+    }, { agentId: 'a' });
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/rate limited/);
+  });
+});
+
+describe('ComposioTool — batched execution', () => {
+  test('two actions in one call returns results[] with both', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    const r = await tool.execute({
+      actions: [
+        { type: 'list-toolkits' },
+        { type: 'list-tools', toolkitSlug: 'github' },
+      ],
+    }, { agentId: 'a' });
+    expect(r.batched).toBe(true);
+    expect(r.actionCount).toBe(2);
+    expect(r.results).toHaveLength(2);
+    expect(r.results[0].action).toBe('list-toolkits');
+    expect(r.results[1].action).toBe('list-tools');
+  });
+
+  test('one action failure does not abort the batch', async () => {
+    const client = makeMockClient();
+    client.tools.list.mockRejectedValueOnce(new Error('upstream down'));
+    const tool = makeTool({ client });
+    const r = await tool.execute({
+      actions: [
+        { type: 'list-toolkits' },
+        { type: 'list-tools', toolkitSlug: 'github' },
+      ],
+    }, { agentId: 'a' });
+    expect(r.results[0].success).toBe(true);
+    expect(r.results[1].success).toBe(false);
+    expect(r.results[1].error).toMatch(/upstream down/);
+  });
+});
+
+describe('ComposioTool — userId scoping', () => {
+  test('agentId is used as Composio userId', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    await tool.execute({ actions: [{ type: 'execute', toolkitSlug: 'gh', actionSlug: 'X', arguments: {} }] }, { agentId: 'agent-zeta' });
+    expect(client.tools.execute).toHaveBeenCalledWith(
+      'X',
+      expect.objectContaining({ userId: 'agent-zeta' })
+    );
+  });
+
+  test('falls back to default-user when agentId is missing (no crash)', async () => {
+    const client = makeMockClient();
+    const tool = makeTool({ client });
+    await tool.execute({ actions: [{ type: 'list-toolkits' }] }, {});
+    // The fallback userId is used internally; list-toolkits doesn't pass
+    // it explicitly to the SDK in this implementation, but we verified
+    // no crash. Spot-check with execute too:
+    await tool.execute({ actions: [{ type: 'execute', toolkitSlug: 'gh', actionSlug: 'X', arguments: {} }] }, {});
+    expect(client.tools.execute).toHaveBeenCalledWith(
+      'X',
+      expect.objectContaining({ userId: 'default-user' })
+    );
+  });
+});

package/src/tools/__tests__/memoryTool.pluralCanonical.test.js

@@ -0,0 +1,189 @@
+/**
+ * Tests for the plural-canonical envelope on the memory tool.
+ *
+ * Memory and code-map were previously singular-only ({action: "X", ...}).
+ * All other tools (filesystem, terminal, taskmanager, file-content-replace)
+ * used plural ({actions: [{type: "X", ...}]}). Production agents
+ * (Kimi-K2.6, gpt-5.4) drifted between shapes mid-session and emitted
+ * the wrong shape for whichever tool they reached for. Unifying on
+ * plural-canonical removes the inconsistency.
+ *
+ * Contract:
+ *   - {actions: [...]} is the canonical input
+ *   - {action, ...} singular is accepted (backward-compat)
+ *   - Both `type` and `action` inside an action item are accepted
+ *   - Batched (multi-action) calls execute every action and return
+ *     a results[] array
+ *   - Single-action calls (canonical OR singular) return the unwrapped
+ *     legacy shape — no regression for existing callers
+ */
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+
+const mockMemoryService = {
+  initialize:        jest.fn().mockResolvedValue(undefined),
+  loadMemories:      jest.fn().mockResolvedValue([]),
+  saveMemories:      jest.fn().mockResolvedValue(undefined),
+  readMemory:        jest.fn(),
+  listMemories:      jest.fn().mockResolvedValue({ count: 0, memories: [], grouped: {} }),
+  addMemory:         jest.fn(),
+  updateMemory:      jest.fn(),
+  appendToMemory:    jest.fn(),
+  deleteMemory:      jest.fn(),
+  searchMemories:    jest.fn(),
+  getStats:          jest.fn(),
+  getCatalog:        jest.fn(),
+};
+jest.unstable_mockModule('../../services/memoryService.js', () => ({
+  getMemoryService: jest.fn(() => mockMemoryService),
+  PLAN_TITLE_PREFIX: 'plan/',
+}));
+
+const { default: MemoryTool } = await import('../memoryTool.js');
+
+const SILENT_LOGGER = { info() {}, warn() {}, error() {}, debug() {} };
+
+function makeTool() {
+  const tool = new MemoryTool({}, SILENT_LOGGER);
+  return tool;
+}
+const ctx = { agentId: 'agent-1', agent: { id: 'agent-1' } };
+
+beforeEach(() => {
+  for (const fn of Object.values(mockMemoryService)) {
+    if (typeof fn.mockReset === 'function') fn.mockReset();
+  }
+  mockMemoryService.initialize.mockResolvedValue(undefined);
+  mockMemoryService.loadMemories.mockResolvedValue([]);
+  mockMemoryService.saveMemories.mockResolvedValue(undefined);
+});
+
+describe('_normalizeToActions — canonical-plural promotion', () => {
+  const tool = makeTool();
+  test('promotes singular {action: "list"} to [{type: "list"}]', () => {
+    const r = tool._normalizeToActions({ action: 'list' });
+    expect(r).toEqual([{ type: 'list' }]);
+  });
+
+  test('flattens singular {action: "X", parameters: {id}} to [{type, id}]', () => {
+    const r = tool._normalizeToActions({ action: 'read', parameters: { id: 'mem-1' } });
+    expect(r).toEqual([{ type: 'read', id: 'mem-1' }]);
+  });
+
+  test('accepts canonical {actions: [{type, ...}]} unchanged', () => {
+    const r = tool._normalizeToActions({ actions: [{ type: 'read', id: 'mem-1' }] });
+    expect(r).toEqual([{ type: 'read', id: 'mem-1' }]);
+  });
+
+  test('renames {actions: [{action: "X", ...}]} to [{type: "X", ...}]', () => {
+    const r = tool._normalizeToActions({ actions: [{ action: 'read', id: 'mem-1' }] });
+    expect(r).toEqual([{ type: 'read', id: 'mem-1' }]);
+  });
+
+  test('returns empty array on missing input', () => {
+    expect(tool._normalizeToActions({})).toEqual([]);
+    expect(tool._normalizeToActions(null)).toEqual([]);
+  });
+});
+
+describe('execute — single-action backward compatibility', () => {
+  test('singular {action: "list"} returns the legacy unwrapped shape', async () => {
+    mockMemoryService.listMemories.mockResolvedValueOnce({ count: 1, memories: [], grouped: {} });
+    const r = await makeTool().execute({ action: 'list', level: 'titles' }, ctx);
+    // Old contract: a single-action call returns the inner result
+    // directly, NOT wrapped in {results: [...]}.
+    expect(r.success).toBe(true);
+    expect(r.action).toBe('list');
+    expect(r).not.toHaveProperty('batched');
+  });
+
+  test('canonical plural with 1 action returns the same unwrapped shape', async () => {
+    mockMemoryService.listMemories.mockResolvedValueOnce({ count: 0, memories: [], grouped: {} });
+    const r = await makeTool().execute({ actions: [{ type: 'list', level: 'titles' }] }, ctx);
+    expect(r.success).toBe(true);
+    expect(r.action).toBe('list');
+    expect(r).not.toHaveProperty('batched');
+  });
+});
+
+describe('execute — multi-action batching (new capability)', () => {
+  test('two reads in one call returns results[] with both', async () => {
+    const m1 = { id: 'mem-1', title: 'A', description: 'a', content: 'CONTENT-A', createdAt: new Date().toISOString() };
+    const m2 = { id: 'mem-2', title: 'B', description: 'b', content: 'CONTENT-B', createdAt: new Date().toISOString() };
+    mockMemoryService.readMemory.mockImplementation(async (_a, id) => {
+      if (id === 'mem-1') return m1;
+      if (id === 'mem-2') return m2;
+      return null;
+    });
+    const r = await makeTool().execute({
+      actions: [
+        { type: 'read', id: 'mem-1' },
+        { type: 'read', id: 'mem-2' },
+      ],
+    }, ctx);
+    expect(r.batched).toBe(true);
+    expect(r.actionCount).toBe(2);
+    expect(r.results).toHaveLength(2);
+    expect(r.success).toBe(true);
+    expect(r.results[0].memory?.id).toBe('mem-1');
+    expect(r.results[1].memory?.id).toBe('mem-2');
+  });
+
+  test('one action failure does not abort the batch (each result carries success)', async () => {
+    const m1 = { id: 'mem-1', title: 'A', description: 'a', content: 'CA', createdAt: new Date().toISOString() };
+    mockMemoryService.readMemory.mockImplementation(async (_a, id) => (id === 'mem-1' ? m1 : null));
+    const r = await makeTool().execute({
+      actions: [
+        { type: 'read', id: 'mem-1' },        // succeeds
+        { type: 'read', id: 'mem-not-here' }, // not-found
+      ],
+    }, ctx);
+    expect(r.batched).toBe(true);
+    expect(r.results).toHaveLength(2);
+    expect(r.results[0].success).toBe(true);
+    // Not-found is communicated via success:false in the per-action result.
+    expect(r.results[1].success).toBe(false);
+    expect(r.results[1].message || r.results[1].error).toMatch(/not found|Memory not found/i);
+  });
+});
+
+describe('customValidateParameters — accepts both shapes', () => {
+  test('singular {action} validates', () => {
+    const v = makeTool().customValidateParameters({ action: 'read', id: 'mem-1' });
+    expect(v.valid).toBe(true);
+  });
+
+  test('canonical plural validates per-action', () => {
+    const v = makeTool().customValidateParameters({
+      actions: [
+        { type: 'read', id: 'mem-1' },
+        { type: 'add',  title: 'T', content: 'C' },
+      ],
+    });
+    expect(v.valid).toBe(true);
+  });
+
+  test('plural with one bad action reports that action by index', () => {
+    const v = makeTool().customValidateParameters({
+      actions: [
+        { type: 'read', id: 'mem-1' },
+        { type: 'add' /* missing title+content */ },
+      ],
+    });
+    expect(v.valid).toBe(false);
+    expect(v.errors.join(' ')).toMatch(/actions\[1\]/);
+  });
+
+  test('plural rejects unknown type', () => {
+    const v = makeTool().customValidateParameters({
+      actions: [{ type: 'frobnicate' }],
+    });
+    expect(v.valid).toBe(false);
+    expect(v.errors.join(' ')).toMatch(/type must be one of/);
+  });
+
+  test('empty params rejected with helpful message', () => {
+    const v = makeTool().customValidateParameters({});
+    expect(v.valid).toBe(false);
+    expect(v.errors.join(' ')).toMatch(/action is required|actions/);
+  });
+});

package/src/tools/__tests__/memoryTool.test.js

@@ -283,7 +283,7 @@ describe('MemoryTool', () => {
 
   test('execute throws on unknown action', async () => {
     await expect(tool.execute({ action: 'unknown' }, context))
-      .rejects.toThrow('Unknown action');
+      .rejects.toThrow(/Unknown memory action/);
   });
 
   test('execute logs and re-throws service errors', async () => {