onbuzz 4.8.2 → 4.9.0

package/src/services/__tests__/compactionRetry.test.js

@@ -19,11 +19,11 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
   };
 
   const mockModelsService = {
-    getAvailableModelNames: jest.fn().mockReturnValue(['gpt-5.1-codex-mini', 'gpt-5-mini']),
+    getAvailableModelNames: jest.fn().mockReturnValue(['gpt-4.1-nano', 'gpt-4.1-mini']),
     getModels: jest.fn().mockReturnValue([
-      { name: 'gpt-5.1-codex-mini', type: 'chat', contextWindow: 400000 },
-      { name: 'gpt-5-mini', type: 'chat', contextWindow: 400000 },
-      { name: 'gpt-5-nano', type: 'chat', contextWindow: 400000 },
+      { name: 'gpt-4.1-nano', type: 'chat', contextWindow: 400000 },
+      { name: 'gpt-4.1-mini', type: 'chat', contextWindow: 400000 },
+      { name: 'gpt-4.1-nano', type: 'chat', contextWindow: 400000 },
       { name: 'random-model-xyz', type: 'chat', contextWindow: 200000 }
     ])
   };
@@ -53,12 +53,12 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
       const onRetryAttempt = jest.fn();
 
       // Only 2 validated models available; first fails, second succeeds
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini', 'gpt-5-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano', 'gpt-4.1-mini']);
       mockAiService.sendMessage
         .mockRejectedValueOnce(new Error('Service unavailable'))
         .mockResolvedValueOnce({ content: 'Summary of conversation' });
 
-      await service._generateSummary(testMessages, 'gpt-5.1-codex-mini', { onRetryAttempt });
+      await service._generateSummary(testMessages, 'gpt-4.1-nano', { onRetryAttempt });
 
       expect(onRetryAttempt).toHaveBeenCalledTimes(1);
     });
@@ -66,18 +66,18 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
     test('onRetryAttempt receives correct message, failedModel, nextModel, attempt', async () => {
       const onRetryAttempt = jest.fn();
 
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini', 'gpt-5-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano', 'gpt-4.1-mini']);
       mockAiService.sendMessage
         .mockRejectedValueOnce(new Error('Service unavailable'))
         .mockResolvedValueOnce({ content: 'Summary of conversation' });
 
-      await service._generateSummary(testMessages, 'gpt-5.1-codex-mini', { onRetryAttempt });
+      await service._generateSummary(testMessages, 'gpt-4.1-nano', { onRetryAttempt });
 
       expect(onRetryAttempt).toHaveBeenCalledWith(
         expect.objectContaining({
           type: 'compaction_retry',
-          failedModel: 'gpt-5.1-codex-mini',
-          nextModel: 'gpt-5-mini',
+          failedModel: 'gpt-4.1-nano',
+          nextModel: 'gpt-4.1-mini',
           attempt: 1
         })
       );
@@ -87,14 +87,14 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
       const onRetryAttempt = jest.fn();
 
       // Only 1 validated model, and no suitable random models
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano']);
       mockModelsService.getModels.mockReturnValue([
-        { name: 'gpt-5.1-codex-mini', type: 'chat', contextWindow: 400000 }
+        { name: 'gpt-4.1-nano', type: 'chat', contextWindow: 400000 }
       ]);
       mockAiService.sendMessage.mockRejectedValue(new Error('Service unavailable'));
 
       await expect(
-        service._generateSummary(testMessages, 'gpt-5.1-codex-mini', { onRetryAttempt })
+        service._generateSummary(testMessages, 'gpt-4.1-nano', { onRetryAttempt })
       ).rejects.toThrow();
 
       // The only call to onRetryAttempt would be from the last-resort block, but
@@ -108,16 +108,16 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
 
   describe('Random model fallback', () => {
     test('after all recommended models fail, tries a random model from modelsService', async () => {
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano']);
       mockModelsService.getModels.mockReturnValue([
-        { name: 'gpt-5.1-codex-mini', type: 'chat', contextWindow: 400000 },
+        { name: 'gpt-4.1-nano', type: 'chat', contextWindow: 400000 },
         { name: 'random-model-xyz', type: 'chat', contextWindow: 200000 }
       ]);
       mockAiService.sendMessage
         .mockRejectedValueOnce(new Error('Service unavailable'))  // recommended model fails
         .mockResolvedValueOnce({ content: 'Last-resort summary' }); // random model succeeds
 
-      const result = await service._generateSummary(testMessages, 'gpt-5.1-codex-mini', {});
+      const result = await service._generateSummary(testMessages, 'gpt-4.1-nano', {});
 
       // Should have been called twice: once for recommended, once for random
       expect(mockAiService.sendMessage).toHaveBeenCalledTimes(2);
@@ -125,16 +125,16 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
     });
 
     test('random model success returns valid summary and does not throw', async () => {
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano']);
       mockModelsService.getModels.mockReturnValue([
-        { name: 'gpt-5.1-codex-mini', type: 'chat', contextWindow: 400000 },
+        { name: 'gpt-4.1-nano', type: 'chat', contextWindow: 400000 },
         { name: 'fallback-model', type: 'chat', contextWindow: 200000 }
       ]);
       mockAiService.sendMessage
         .mockRejectedValueOnce(new Error('Service unavailable'))
         .mockResolvedValueOnce({ content: 'Fallback summary content' });
 
-      const result = await service._generateSummary(testMessages, 'gpt-5.1-codex-mini', {});
+      const result = await service._generateSummary(testMessages, 'gpt-4.1-nano', {});
 
       expect(result.role).toBe('system');
       expect(result.type).toBe('summary');
@@ -142,44 +142,44 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
     });
 
     test('random model failure still throws ALL_MODELS_EXHAUSTED', async () => {
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano']);
       mockAiService.sendMessage.mockRejectedValue(new Error('Everything is broken'));
 
       await expect(
-        service._generateSummary(testMessages, 'gpt-5.1-codex-mini', {})
+        service._generateSummary(testMessages, 'gpt-4.1-nano', {})
       ).rejects.toThrow('ALL_MODELS_EXHAUSTED');
     });
 
     test('random model is NOT one already attempted (filtered out)', async () => {
-      // Only gpt-5.1-codex-mini is validated; random pool has others
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini']);
+      // Only gpt-4.1-nano is validated; random pool has others
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano']);
       mockModelsService.getModels.mockReturnValue([
-        { name: 'gpt-5.1-codex-mini', type: 'chat', contextWindow: 400000 },
+        { name: 'gpt-4.1-nano', type: 'chat', contextWindow: 400000 },
         { name: 'random-model-xyz', type: 'chat', contextWindow: 200000 }
       ]);
       mockAiService.sendMessage
-        .mockRejectedValueOnce(new Error('fail'))  // gpt-5.1-codex-mini fails
+        .mockRejectedValueOnce(new Error('fail'))  // gpt-4.1-nano fails
         .mockResolvedValueOnce({ content: 'Random success' }); // random-model-xyz succeeds
 
-      const result = await service._generateSummary(testMessages, 'gpt-5.1-codex-mini', {});
+      const result = await service._generateSummary(testMessages, 'gpt-4.1-nano', {});
 
       // Second call should be the random model, not the already-attempted one
       const secondCallModel = mockAiService.sendMessage.mock.calls[1][0];
-      expect(secondCallModel).not.toBe('gpt-5.1-codex-mini');
-      expect(result.metadata.compactionModel).not.toBe('gpt-5.1-codex-mini');
+      expect(secondCallModel).not.toBe('gpt-4.1-nano');
+      expect(result.metadata.compactionModel).not.toBe('gpt-4.1-nano');
     });
 
     test('random model must have sufficient context window', async () => {
       // All models except the recommended one have tiny context windows
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano']);
       mockModelsService.getModels.mockReturnValue([
-        { name: 'gpt-5.1-codex-mini', type: 'chat', contextWindow: 400000 },
+        { name: 'gpt-4.1-nano', type: 'chat', contextWindow: 400000 },
         { name: 'tiny-model', type: 'chat', contextWindow: 100 } // too small
       ]);
       mockAiService.sendMessage.mockRejectedValue(new Error('fail'));
 
       await expect(
-        service._generateSummary(testMessages, 'gpt-5.1-codex-mini', {})
+        service._generateSummary(testMessages, 'gpt-4.1-nano', {})
       ).rejects.toThrow('ALL_MODELS_EXHAUSTED');
 
       // Should only have tried the recommended model, not the tiny one
@@ -193,11 +193,11 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
     test('onAllModelsExhausted is called only after ALL models (including random) fail', async () => {
       const onAllModelsExhausted = jest.fn();
 
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano']);
       mockAiService.sendMessage.mockRejectedValue(new Error('fail'));
 
       await expect(
-        service._generateSummary(testMessages, 'gpt-5.1-codex-mini', { onAllModelsExhausted })
+        service._generateSummary(testMessages, 'gpt-4.1-nano', { onAllModelsExhausted })
       ).rejects.toThrow('ALL_MODELS_EXHAUSTED');
 
       expect(onAllModelsExhausted).toHaveBeenCalledTimes(1);
@@ -211,16 +211,16 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
     test('onAllModelsExhausted includes all attempted model names', async () => {
       const onAllModelsExhausted = jest.fn();
 
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini', 'gpt-5-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano', 'gpt-4.1-mini']);
       mockAiService.sendMessage.mockRejectedValue(new Error('fail'));
 
       await expect(
-        service._generateSummary(testMessages, 'gpt-5.1-codex-mini', { onAllModelsExhausted })
+        service._generateSummary(testMessages, 'gpt-4.1-nano', { onAllModelsExhausted })
       ).rejects.toThrow('ALL_MODELS_EXHAUSTED');
 
       const callArg = onAllModelsExhausted.mock.calls[0][0];
-      expect(callArg.models).toContain('gpt-5.1-codex-mini');
-      expect(callArg.models).toContain('gpt-5-mini');
+      expect(callArg.models).toContain('gpt-4.1-nano');
+      expect(callArg.models).toContain('gpt-4.1-mini');
       // Should also include at least one random model that was attempted
       expect(callArg.models.length).toBeGreaterThanOrEqual(2);
     });
@@ -233,10 +233,10 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
       const onRetryAttempt = jest.fn();
       const onAllModelsExhausted = jest.fn();
 
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini', 'gpt-5-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano', 'gpt-4.1-mini']);
       mockAiService.sendMessage.mockResolvedValueOnce({ content: 'Great summary here' });
 
-      const result = await service._generateSummary(testMessages, 'gpt-5.1-codex-mini', {
+      const result = await service._generateSummary(testMessages, 'gpt-4.1-nano', {
         onRetryAttempt,
         onAllModelsExhausted
       });
@@ -253,12 +253,12 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
       const onRetryAttempt = jest.fn();
       const onAllModelsExhausted = jest.fn();
 
-      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-5.1-codex-mini', 'gpt-5-mini']);
+      mockModelsService.getAvailableModelNames.mockReturnValue(['gpt-4.1-nano', 'gpt-4.1-mini']);
       mockAiService.sendMessage
         .mockRejectedValueOnce(new Error('429 rate limit'))
         .mockResolvedValueOnce({ content: 'Second model summary' });
 
-      const result = await service._generateSummary(testMessages, 'gpt-5.1-codex-mini', {
+      const result = await service._generateSummary(testMessages, 'gpt-4.1-nano', {
         onRetryAttempt,
         onAllModelsExhausted
       });
@@ -266,7 +266,7 @@ describe('ConversationCompactionService - _generateSummary retry behavior', () =
       expect(onRetryAttempt).toHaveBeenCalledTimes(1);
       expect(onAllModelsExhausted).not.toHaveBeenCalled();
       expect(result.content).toContain('Second model summary');
-      expect(result.metadata.compactionModel).toBe('gpt-5-mini');
+      expect(result.metadata.compactionModel).toBe('gpt-4.1-mini');
     });
   });
 });

package/src/services/__tests__/composioService.test.js

@@ -0,0 +1,332 @@
+/**
+ * composioService — shared SDK wrapper used by composioTool, REST
+ * endpoints, and the CLI.
+ *
+ * Tests inject a stub client via `_injectClientForTests` so we cover
+ * every method without depending on a real Composio account.
+ */
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import * as composioService from '../composioService.js';
+import {
+  registerApiKeyManager,
+  _resetApiKeyManagerRegistrationForTests,
+} from '../apiKeyManager.js';
+
+/** A minimal ApiKeyManager stand-in for tests. */
+function makeStubApiKeyManager(initial = {}) {
+  return {
+    keys: { loxiaApiKey: null, vendorKeys: { ...initial } },
+    setSessionKeys: jest.fn(async function (_sid, { vendorKeys = {} }) {
+      this.keys.vendorKeys = { ...this.keys.vendorKeys, ...vendorKeys };
+    }),
+    persist: jest.fn().mockResolvedValue(undefined),
+  };
+}
+
+function makeStubClient() {
+  return {
+    toolkits: {
+      list: jest.fn().mockResolvedValue([
+        { slug: 'github', name: 'GitHub' },
+        { slug: 'slack',  name: 'Slack' },
+      ]),
+    },
+    tools: {
+      list: jest.fn().mockResolvedValue([
+        { slug: 'GITHUB_CREATE_AN_ISSUE', description: 'Create issue' },
+      ]),
+      execute: jest.fn().mockResolvedValue({ successful: true, data: { issueNumber: 42 } }),
+    },
+    connectedAccounts: {
+      list:       jest.fn().mockResolvedValue([
+        { id: 'conn-1', toolkitSlug: 'github', status: 'ACTIVE' },
+        { id: 'conn-2', toolkitSlug: 'slack',  status: 'INITIATED' },
+      ]),
+      get:        jest.fn().mockResolvedValue({ id: 'conn-1', status: 'ACTIVE' }),
+      initiate:   jest.fn().mockResolvedValue({ id: 'conn-1', redirectUrl: 'https://connect.composio.dev/link/abc' }),
+      delete:     jest.fn().mockResolvedValue({ success: true }),
+    },
+  };
+}
+
+let savedApiKey;
+beforeEach(() => {
+  savedApiKey = process.env.COMPOSIO_API_KEY;
+  process.env.COMPOSIO_API_KEY = 'test-key';
+  _resetApiKeyManagerRegistrationForTests();
+  composioService._resetForTests();
+});
+afterEach(() => {
+  if (savedApiKey === undefined) delete process.env.COMPOSIO_API_KEY;
+  else process.env.COMPOSIO_API_KEY = savedApiKey;
+  _resetApiKeyManagerRegistrationForTests();
+  composioService._resetForTests();
+});
+
+describe('composioService — availability', () => {
+  test('reports unavailable when no key is set anywhere', async () => {
+    delete process.env.COMPOSIO_API_KEY;
+    composioService._resetForTests();
+    const r = await composioService.isAvailable();
+    expect(r.available).toBe(false);
+    expect(r.reason).toMatch(/No Composio API key/i);
+    expect(r.keySource).toBeNull();
+  });
+
+  test('isAvailable returns true when client is injected', async () => {
+    composioService._injectClientForTests(makeStubClient());
+    const r = await composioService.isAvailable();
+    expect(r.available).toBe(true);
+  });
+
+  test('keySource = "env" when only the env var is set', async () => {
+    process.env.COMPOSIO_API_KEY = 'env-key-12345';
+    composioService._resetForTests();
+    composioService._injectClientForTests(makeStubClient());
+    const r = await composioService.isAvailable();
+    expect(r.keySource).toBe('env');
+  });
+
+  test('keySource = "vault" when ApiKeyManager has the key (vault > env precedence)', async () => {
+    process.env.COMPOSIO_API_KEY = 'env-key';
+    registerApiKeyManager(makeStubApiKeyManager({ composio: 'vault-key-XYZ' }));
+    composioService._resetForTests();
+    composioService._injectClientForTests(makeStubClient());
+    const r = await composioService.isAvailable();
+    expect(r.keySource).toBe('vault');
+  });
+});
+
+describe('composioService — setApiKey + forgetApiKey', () => {
+  test('setApiKey persists via apiKeyManager and invalidates the client', async () => {
+    const mgr = makeStubApiKeyManager();
+    registerApiKeyManager(mgr);
+    // Seed a cached client with the old (env) key.
+    composioService._injectClientForTests(makeStubClient());
+
+    const r = await composioService.setApiKey('comp_abcdef123456');
+    expect(r.success).toBe(true);
+    expect(mgr.setSessionKeys).toHaveBeenCalledWith(null, { vendorKeys: { composio: 'comp_abcdef123456' } });
+    // The cached client was wiped — next op will re-derive from the new vault key.
+    composioService._injectClientForTests(makeStubClient()); // re-seed for the next assertion
+    const r2 = await composioService.isAvailable();
+    expect(r2.keySource).toBe('vault');
+  });
+
+  test('setApiKey rejects too-short keys', async () => {
+    registerApiKeyManager(makeStubApiKeyManager());
+    const r = await composioService.setApiKey('hi');
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/too short/i);
+  });
+
+  test('setApiKey with empty string clears the stored key', async () => {
+    const mgr = makeStubApiKeyManager({ composio: 'existing-key-XYZ' });
+    registerApiKeyManager(mgr);
+    const r = await composioService.setApiKey('');
+    expect(r.success).toBe(true);
+    expect(r.cleared).toBe(true);
+    expect(mgr.keys.vendorKeys.composio).toBeUndefined();
+    expect(mgr.persist).toHaveBeenCalled();
+  });
+
+  test('forgetApiKey is an alias for setApiKey("")', async () => {
+    const mgr = makeStubApiKeyManager({ composio: 'k' });
+    registerApiKeyManager(mgr);
+    const r = await composioService.forgetApiKey();
+    expect(r.success).toBe(true);
+    expect(r.cleared).toBe(true);
+    expect(mgr.keys.vendorKeys.composio).toBeUndefined();
+  });
+
+  test('setApiKey returns a friendly error if no ApiKeyManager is registered', async () => {
+    _resetApiKeyManagerRegistrationForTests();
+    const r = await composioService.setApiKey('comp_abcdef123456');
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/ApiKeyManager is not initialized/i);
+  });
+});
+
+describe('composioService — listToolkits', () => {
+  test('returns the SDK list', async () => {
+    const client = makeStubClient();
+    composioService._injectClientForTests(client);
+    const r = await composioService.listToolkits();
+    expect(r.success).toBe(true);
+    expect(r.toolkits).toHaveLength(2);
+    expect(r.toolkits[0].slug).toBe('github');
+    expect(client.toolkits.list).toHaveBeenCalled();
+  });
+
+  test('surfaces SDK errors as success:false', async () => {
+    const client = makeStubClient();
+    client.toolkits.list = jest.fn().mockRejectedValue(new Error('rate limited'));
+    composioService._injectClientForTests(client);
+    const r = await composioService.listToolkits();
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/rate limited/);
+  });
+});
+
+describe('composioService — listConnections', () => {
+  test('forwards userId and returns array', async () => {
+    const client = makeStubClient();
+    composioService._injectClientForTests(client);
+    const r = await composioService.listConnections('operator');
+    expect(r.success).toBe(true);
+    expect(r.connections).toHaveLength(2);
+    expect(client.connectedAccounts.list).toHaveBeenCalledWith({ userId: 'operator' });
+  });
+
+  test('accepts SDK list responses wrapped in {items: ...}', async () => {
+    const client = makeStubClient();
+    client.connectedAccounts.list = jest.fn().mockResolvedValue({
+      items: [{ id: 'x', toolkitSlug: 'gh', status: 'ACTIVE' }],
+    });
+    composioService._injectClientForTests(client);
+    const r = await composioService.listConnections('operator');
+    expect(r.connections).toHaveLength(1);
+    expect(r.connections[0].id).toBe('x');
+  });
+});
+
+describe('composioService — connectionStatus', () => {
+  test('maps ACTIVE → connected:true', async () => {
+    composioService._injectClientForTests(makeStubClient());
+    const r = await composioService.connectionStatus('operator', 'github');
+    expect(r.connected).toBe(true);
+    expect(r.status).toBe('ACTIVE');
+    expect(r.connectionId).toBe('conn-1');
+  });
+
+  test('maps missing connection → connected:false', async () => {
+    const client = makeStubClient();
+    client.connectedAccounts.get = jest.fn().mockResolvedValue(null);
+    composioService._injectClientForTests(client);
+    const r = await composioService.connectionStatus('operator', 'github');
+    expect(r.connected).toBe(false);
+    expect(r.status).toBe('NOT_CONNECTED');
+  });
+});
+
+describe('composioService — connect', () => {
+  test('forwards userId + toolkit and returns the connect link', async () => {
+    const client = makeStubClient();
+    composioService._injectClientForTests(client);
+    const r = await composioService.connect('operator', 'github');
+    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: 'operator', toolkit: 'github',
+    });
+  });
+
+  test('passes through authConfigId when provided', async () => {
+    const client = makeStubClient();
+    composioService._injectClientForTests(client);
+    await composioService.connect('operator', 'github', { authConfigId: 'auth-cfg-xyz' });
+    expect(client.connectedAccounts.initiate).toHaveBeenCalledWith({
+      userId: 'operator', toolkit: 'github', authConfigId: 'auth-cfg-xyz',
+    });
+  });
+});
+
+describe('composioService — disconnect', () => {
+  test('disconnect by connectionId', async () => {
+    const client = makeStubClient();
+    composioService._injectClientForTests(client);
+    const r = await composioService.disconnect({ connectionId: 'conn-1' });
+    expect(r.success).toBe(true);
+    expect(client.connectedAccounts.delete).toHaveBeenCalledWith('conn-1');
+  });
+
+  test('disconnect by {userId, toolkitSlug} looks up the id first', async () => {
+    const client = makeStubClient();
+    composioService._injectClientForTests(client);
+    const r = await composioService.disconnect({ userId: 'operator', toolkitSlug: 'github' });
+    expect(r.success).toBe(true);
+    expect(client.connectedAccounts.get).toHaveBeenCalledWith({ userId: 'operator', toolkit: 'github' });
+    expect(client.connectedAccounts.delete).toHaveBeenCalledWith('conn-1');
+  });
+
+  test('rejects with helpful error when no target shape is provided', async () => {
+    composioService._injectClientForTests(makeStubClient());
+    const r = await composioService.disconnect({});
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/connectionId/);
+  });
+
+  test('handles missing connection cleanly when looking up by toolkit', async () => {
+    const client = makeStubClient();
+    client.connectedAccounts.get = jest.fn().mockResolvedValue(null);
+    composioService._injectClientForTests(client);
+    const r = await composioService.disconnect({ userId: 'operator', toolkitSlug: 'github' });
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/No active connection found/);
+  });
+});
+
+describe('composioService — listTools', () => {
+  test('forwards toolkit + userId', async () => {
+    const client = makeStubClient();
+    composioService._injectClientForTests(client);
+    const r = await composioService.listTools('github', 'operator');
+    expect(r.success).toBe(true);
+    expect(r.tools[0].slug).toBe('GITHUB_CREATE_AN_ISSUE');
+    expect(client.tools.list).toHaveBeenCalledWith({ toolkit: 'github', userId: 'operator' });
+  });
+
+  test('omits userId from the SDK call when not provided', async () => {
+    const client = makeStubClient();
+    composioService._injectClientForTests(client);
+    await composioService.listTools('github');
+    expect(client.tools.list).toHaveBeenCalledWith({ toolkit: 'github' });
+  });
+});
+
+describe('composioService — execute', () => {
+  test('forwards userId + actionSlug + arguments', async () => {
+    const client = makeStubClient();
+    composioService._injectClientForTests(client);
+    const r = await composioService.execute('operator', 'github', 'GITHUB_CREATE_AN_ISSUE', {
+      owner: 'acme', repo: 'api', title: 'Bug', body: '…',
+    });
+    expect(r.success).toBe(true);
+    expect(r.output).toEqual({ issueNumber: 42 });
+    expect(client.tools.execute).toHaveBeenCalledWith('GITHUB_CREATE_AN_ISSUE', {
+      userId: 'operator',
+      arguments: { owner: 'acme', repo: 'api', title: 'Bug', body: '…' },
+    });
+  });
+
+  test('upstream success=false is surfaced unchanged', async () => {
+    const client = makeStubClient();
+    client.tools.execute = jest.fn().mockResolvedValue({ successful: false, error: 'repo not found' });
+    composioService._injectClientForTests(client);
+    const r = await composioService.execute('op', 'gh', 'X', {});
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/repo not found/);
+  });
+});
+
+describe('composioService — every op fails gracefully when SDK is unavailable', () => {
+  beforeEach(() => {
+    delete process.env.COMPOSIO_API_KEY;
+    composioService._resetForTests();
+  });
+
+  test.each([
+    ['listToolkits',     () => composioService.listToolkits()],
+    ['listConnections',  () => composioService.listConnections('op')],
+    ['connectionStatus', () => composioService.connectionStatus('op', 'gh')],
+    ['connect',          () => composioService.connect('op', 'gh')],
+    ['disconnect',       () => composioService.disconnect({ connectionId: 'x' })],
+    ['listTools',        () => composioService.listTools('gh')],
+    ['execute',          () => composioService.execute('op', 'gh', 'X', {})],
+  ])('%s returns success:false with "no key" error', async (_label, op) => {
+    const r = await op();
+    expect(r.success).toBe(false);
+    expect((r.error || r.reason || '')).toMatch(/No Composio API key/i);
+  });
+});