86
execute: sessionExecute,
87
});
88
89
+// ── Shared helpers for provider-aware session tests ────────────
90
+
91
+const createSessionWithProvider = (
92
+ client: ReturnType<typeof createMockClient>,
93
+ provider: MockProvider,
94
+ customTools: CustomToolHandle[]
95
+) => {
96
+ return new ToolRouterSession(
97
+ client as unknown as ComposioClient,
98
+ { apiKey: 'key', provider },
99
+ 'sess_123',
100
+ { type: 'http' as const, url: 'https://mcp.example.com/sess_123' },
101
+ undefined,
102
+ buildLocalToolsMap(customTools),
103
+ 'user_1'
104
+ );
105
+};
106
+
107
+const captureExecuteFn = (provider: MockProvider) => {
108
+ provider.wrapTools.mockImplementation((tools: any, executeFn: any) => {
109
+ (provider as any)._capturedExecuteFn = executeFn;
110
+ (provider as any)._capturedTools = tools;
111
+ return 'wrapped-tools-with-routing';
112
+ });
113
+};
114
+
115
// ────────────────────────────────────────────────────────────────
116
// ToolRouter.create() with customTools
117
// ────────────────────────────────────────────────────────────────
220
expect(result.logId).toBe('local');
221
expect(localExecute).toHaveBeenCalledWith(
222
{ category: 'prefs' },
197
- expect.objectContaining({ userId: 'user_1', sessionId: 'sess_123' })
223
+ expect.objectContaining({ userId: 'user_1' })
224
);
225
// Should NOT call remote
226
expect(mockClient.toolRouter.session.execute).not.toHaveBeenCalled();
267
});
268
269
describe('session.execute() — SessionContext injection', () => {
244
- it('should inject SessionContext with correct userId and sessionId', async () => {
270
+ it('should inject SessionContext with correct userId', async () => {
271
const session = createSession(mockClient, [sessionToolHandle]);
272
273
await session.execute('GET_AD_ACCOUNTS', { fields: 'id' });
276
{ fields: 'id' },
277
expect.objectContaining({
278
userId: 'user_1',
253
- sessionId: 'sess_123',
279
})
280
);
281
});
384
});
385
386
describe('session.tools() — COMPOSIO_MULTI_EXECUTE_TOOL routing with tools[] array', () => {
362
- const createSessionWithProvider = (
363
- client: ReturnType<typeof createMockClient>,
364
- provider: MockProvider,
365
- customTools: CustomToolHandle[]
366
- ) => {
367
- return new ToolRouterSession(
368
- client as unknown as ComposioClient,
369
- { apiKey: 'key', provider },
370
- 'sess_123',
371
- { type: 'http' as const, url: 'https://mcp.example.com/sess_123' },
372
- undefined,
373
- buildLocalToolsMap(customTools),
374
- 'user_1'
375
- );
376
- };
377
-
378
- const captureExecuteFn = (provider: MockProvider) => {
379
- provider.wrapTools.mockImplementation((tools: any, executeFn: any) => {
380
- (provider as any)._capturedExecuteFn = executeFn;
381
- return 'wrapped-tools-with-routing';
382
- });
383
- };
384
-
387
it('should route all-local tools[] to in-process execution', async () => {
388
const provider = new MockProvider();
389
captureExecuteFn(provider);
402
expect(result.data).toEqual({ local_result: true });
403
expect(localExecute).toHaveBeenCalledWith(
404
{ category: 'test' },
403
- expect.objectContaining({ userId: 'user_1', sessionId: 'sess_123' })
405
+ expect.objectContaining({ userId: 'user_1' })
406
+ );
407
+ });
408
+
409
+ it('should route local tool by non-prefixed slug in multi-execute', async () => {
410
+ const provider = new MockProvider();
411
+ captureExecuteFn(provider);
412
+ const session = createSessionWithProvider(mockClient, provider, [customToolHandle]);
413
+
414
+ await session.tools();
415
+ const executeFn = (provider as any)._capturedExecuteFn;
416
+
417
+ const result = await executeFn('COMPOSIO_MULTI_EXECUTE_TOOL', {
418
+ tools: [
419
+ { tool_slug: 'GET_USER_CONTEXT', arguments: { category: 'no-prefix' } },
420
+ ],
421
+ sync_response_to_workbench: false,
422
+ });
423
+
424
+ expect(result.data).toEqual({ local_result: true });
425
+ expect(localExecute).toHaveBeenCalledWith(
426
+ { category: 'no-prefix' },
427
+ expect.objectContaining({ userId: 'user_1' })
428
);
429
});
430
454
const session = createSessionWithProvider(mockClient, provider, [customToolHandle]);
455
456
await session.tools();
457
+
458
+ // Re-mock executeMetaTool after session.tools() created the Tools instance
459
+ const latestToolsInstance = (Tools as any).mock.results[
460
+ (Tools as any).mock.results.length - 1
461
+ ].value;
462
+ latestToolsInstance.executeMetaTool.mockResolvedValueOnce({
463
+ data: { GMAIL_SEND_EMAIL: { messageId: 'msg_1' } },
464
+ error: null,
465
+ successful: true,
466
+ });
467
+
468
const executeFn = (provider as any)._capturedExecuteFn;
469
470
const result = await executeFn('COMPOSIO_MULTI_EXECUTE_TOOL', {
480
// Remote goes to backend — merged results keyed by slug
481
expect(result.data).toHaveProperty('LOCAL_GET_USER_CONTEXT');
482
expect(result.data).toHaveProperty('GMAIL_SEND_EMAIL');
483
+ expect(result.data.GMAIL_SEND_EMAIL).toEqual({ messageId: 'msg_1' });
484
});
485
486
it('should route non-MULTI_EXECUTE meta tools to backend', async () => {
532
expect(localExecute).not.toHaveBeenCalled();
533
});
534
});
535
+
536
+ describe('remote batch duplication fix — each remote tool gets its own result', () => {
537
+ it('should return per-tool keyed results when multiple remote tools are in a mixed batch', async () => {
538
+ const provider = new MockProvider();
539
+ captureExecuteFn(provider);
540
+ const session = createSessionWithProvider(mockClient, provider, [customToolHandle]);
541
+
542
+ // Mock executeMetaTool to return data keyed by slug (like real backend)
543
+ const toolsInstance = (Tools as any).mock.results[
544
+ (Tools as any).mock.results.length - 1
545
+ ]?.value;
546
+
547
+ await session.tools();
548
+
549
+ // Re-mock executeMetaTool after session.tools() created the Tools instance
550
+ const latestToolsInstance = (Tools as any).mock.results[
551
+ (Tools as any).mock.results.length - 1
552
+ ].value;
553
+ latestToolsInstance.executeMetaTool.mockResolvedValueOnce({
554
+ data: {
555
+ GMAIL_SEND_EMAIL: { message_id: 'msg_1' },
556
+ SLACK_POST_MESSAGE: { ts: '123456' },
557
+ },
558
+ error: null,
559
+ successful: true,
560
+ });
561
+
562
+ const executeFn = (provider as any)._capturedExecuteFn;
563
+
564
+ const result = await executeFn('COMPOSIO_MULTI_EXECUTE_TOOL', {
565
+ tools: [
566
+ { tool_slug: 'LOCAL_GET_USER_CONTEXT', arguments: { category: 'prefs' } },
567
+ { tool_slug: 'GMAIL_SEND_EMAIL', arguments: { to: 'a@b.com' } },
568
+ { tool_slug: 'SLACK_POST_MESSAGE', arguments: { channel: '#general' } },
569
+ ],
570
+ sync_response_to_workbench: false,
571
+ });
572
+
573
+ // Local tool result keyed by its slug
574
+ expect(result.data).toHaveProperty('LOCAL_GET_USER_CONTEXT');
575
+ expect(result.data.LOCAL_GET_USER_CONTEXT).toEqual({ local_result: true });
576
+
577
+ // Each remote tool gets its own keyed result, not the entire batch blob
578
+ expect(result.data).toHaveProperty('GMAIL_SEND_EMAIL');
579
+ expect(result.data.GMAIL_SEND_EMAIL).toEqual({ message_id: 'msg_1' });
580
+
581
+ expect(result.data).toHaveProperty('SLACK_POST_MESSAGE');
582
+ expect(result.data.SLACK_POST_MESSAGE).toEqual({ ts: '123456' });
583
+ });
584
+ });
585
+
586
+ describe('provider guard — session.tools() throws without provider', () => {
587
+ it('should throw when provider is not configured but local tools exist', async () => {
588
+ const localToolsMap = buildLocalToolsMap([customToolHandle]);
589
+
590
+ const session = new ToolRouterSession(
591
+ mockClient as unknown as ComposioClient,
592
+ { apiKey: 'key' } as any, // no provider
593
+ 'sess_123',
594
+ { type: 'http' as const, url: 'https://mcp.example.com/sess_123' },
595
+ undefined,
596
+ localToolsMap,
597
+ 'user_1'
598
+ );
599
+
600
+ await expect(session.tools()).rejects.toThrow(
601
+ 'A provider is required when using custom tools with session.tools()'
602
+ );
603
+ });
604
+ });
605
+
606
+ describe('localTools() method', () => {
607
+ it('should return wrapped tools with COMPOSIO_EXECUTE_LOCAL_TOOL slug', async () => {
608
+ const provider = new MockProvider();
609
+ captureExecuteFn(provider);
610
+ const session = createSessionWithProvider(mockClient, provider, [customToolHandle]);
611
+
612
+ const result = await session.localTools();
613
+
614
+ expect(result).toBe('wrapped-tools-with-routing');
615
+ expect(provider.wrapTools).toHaveBeenCalled();
616
+
617
+ const tools = (provider as any)._capturedTools;
618
+ expect(tools).toHaveLength(1);
619
+ expect(tools[0].slug).toBe('COMPOSIO_EXECUTE_LOCAL_TOOL');
620
+ });
621
+
622
+ it('should route to local tool correctly when executing via localTools()', async () => {
623
+ const provider = new MockProvider();
624
+ captureExecuteFn(provider);
625
+ const session = createSessionWithProvider(mockClient, provider, [customToolHandle]);
626
+
627
+ await session.localTools();
628
+ const executeFn = (provider as any)._capturedExecuteFn;
629
+
630
+ const result = await executeFn('COMPOSIO_EXECUTE_LOCAL_TOOL', {
631
+ tool_slug: 'LOCAL_GET_USER_CONTEXT',
632
+ arguments: { category: 'test' },
633
+ });
634
+
635
+ expect(result.data).toEqual({ local_result: true });
636
+ expect(result.successful).toBe(true);
637
+ expect(localExecute).toHaveBeenCalledWith(
638
+ { category: 'test' },
639
+ expect.objectContaining({ userId: 'user_1' })
640
+ );
641
+ });
642
+
643
+ it('should return error when executing with invalid slug via localTools()', async () => {
644
+ const provider = new MockProvider();
645
+ captureExecuteFn(provider);
646
+ const session = createSessionWithProvider(mockClient, provider, [customToolHandle]);
647
+
648
+ await session.localTools();
649
+ const executeFn = (provider as any)._capturedExecuteFn;
650
+
651
+ const result = await executeFn('COMPOSIO_EXECUTE_LOCAL_TOOL', {
652
+ tool_slug: 'NON_EXISTENT_TOOL',
653
+ arguments: {},
654
+ });
655
+
656
+ expect(result.successful).toBe(false);
657
+ expect(result.error).toContain('Local tool "NON_EXISTENT_TOOL" not found');
658
+ expect(result.data).toEqual({});
659
+ });
660
+
661
+ it('should throw when calling localTools() without custom tools', async () => {
662
+ const session = new ToolRouterSession(
663
+ mockClient as unknown as ComposioClient,
664
+ { apiKey: 'key', provider: new MockProvider() },
665
+ 'sess_123',
666
+ { type: 'http' as const, url: 'https://mcp.example.com/sess_123' }
667
+ // No localToolsMap, no userId
668
+ );
669
+
670
+ await expect(session.localTools()).rejects.toThrow(
671
+ 'No custom tools are bound to this session.'
672
+ );
673
+ });
674
+ });
675
+
676
+ describe('COMPOSIO_EXECUTE_LOCAL_TOOL interception in routing', () => {
677
+ it('should route COMPOSIO_EXECUTE_LOCAL_TOOL to the correct local tool via session.tools() routing', async () => {
678
+ const provider = new MockProvider();
679
+ captureExecuteFn(provider);
680
+ const session = createSessionWithProvider(mockClient, provider, [customToolHandle]);
681
+
682
+ await session.tools();
683
+ const executeFn = (provider as any)._capturedExecuteFn;
684
+
685
+ const result = await executeFn('COMPOSIO_EXECUTE_LOCAL_TOOL', {
686
+ tool_slug: 'LOCAL_GET_USER_CONTEXT',
687
+ arguments: { category: 'routing-test' },
688
+ });
689
+
690
+ expect(result.data).toEqual({ local_result: true });
691
+ expect(result.successful).toBe(true);
692
+ expect(localExecute).toHaveBeenCalledWith(
693
+ { category: 'routing-test' },
694
+ expect.objectContaining({ userId: 'user_1' })
695
+ );
696
+ // Should NOT call remote
697
+ expect(mockClient.toolRouter.session.execute).not.toHaveBeenCalled();
698
+ });
699
+
700
+ it('should return error for COMPOSIO_EXECUTE_LOCAL_TOOL with unknown slug', async () => {
701
+ const provider = new MockProvider();
702
+ captureExecuteFn(provider);
703
+ const session = createSessionWithProvider(mockClient, provider, [customToolHandle]);
704
+
705
+ await session.tools();
706
+ const executeFn = (provider as any)._capturedExecuteFn;
707
+
708
+ const result = await executeFn('COMPOSIO_EXECUTE_LOCAL_TOOL', {
709
+ tool_slug: 'DOES_NOT_EXIST',
710
+ arguments: {},
711
+ });
712
+
713
+ expect(result.successful).toBe(false);
714
+ expect(result.error).toContain('Local tool "DOES_NOT_EXIST" not found');
715
+ expect(result.data).toEqual({});
716
+ });
717
+ });
718
});