1
+import { afterEach, describe, expect, it } from '@effect/vitest';
2
+import { vi } from 'vitest';
3
+import * as BunFileSystem from '@effect/platform-bun/BunFileSystem';
4
+import * as BunPath from '@effect/platform-bun/BunPath';
5
+import { ConfigProvider, Effect, Fiber, Layer } from 'effect';
6
+import * as tempy from 'tempy';
7
+import { createToolRouterSessionContext } from 'src/effects/create-tool-router-session';
8
+import { ComposioCliUserConfigLive } from 'src/services/cli-user-config';
9
+import { ComposioClientSingleton, ComposioToolkitsRepository } from 'src/services/composio-clients';
10
+import { defaultNodeOs, NodeOs } from 'src/services/node-os';
11
+import { NodeProcess } from 'src/services/node-process';
12
+import { cliDebugFlagsLayer } from 'src/services/runtime-flags';
13
+import { ToolkitSlugCatalog } from 'src/services/toolkit-slug-catalog';
14
+import { ToolsExecutor, ToolsExecutorLive } from 'src/services/tools-executor';
15
+import { ComposioUserContextLive } from 'src/services/user-context';
16
+import { clearInProcessMemos } from 'src/utils/memoize-in-process';
17
+import { TerminalUITest } from 'test/__utils__/services/terminal-ui-test';
18
+
19
+// Exercise real user-context/config resolution without opening the OS credential store.
20
+vi.mock('@composio/cli-keyring/effect', async importOriginal => {
21
+ const actual = await importOriginal<typeof import('@composio/cli-keyring/effect')>();
22
+ const { Effect, Layer } = await import('effect');
23
+ const { KeyringError } = await import('@composio/cli-keyring');
24
+ return {
25
+ ...actual,
26
+ KeyringLiveWithBackend: () =>
27
+ Layer.succeed(actual.KeyringService, {
28
+ getPassword: () => Effect.fail(new KeyringError({ kind: 'NoEntry' })),
29
+ getSecret: () => Effect.fail(new KeyringError({ kind: 'NoEntry' })),
30
+ setPassword: () => Effect.die(new Error('Unexpected credential write')),
31
+ setSecret: () => Effect.die(new Error('Unexpected credential write')),
32
+ deleteCredential: () => Effect.die(new Error('Unexpected credential deletion')),
33
+ isAvailable: Effect.succeed(true),
34
+ }),
35
+ };
36
+});
37
+
38
+const BASE_URL = 'https://backend.composio.dev';
39
+
40
+const platformLayer = () =>
41
+ Layer.mergeAll(
42
+ BunFileSystem.layer,
43
+ BunPath.layer,
44
+ Layer.succeed(NodeOs, defaultNodeOs({ homedir: tempy.temporaryDirectory() })),
45
+ Layer.succeed(
46
+ ConfigProvider.ConfigProvider,
47
+ ConfigProvider.fromEnv({
48
+ env: { COMPOSIO_USER_API_KEY: 'uak_config', COMPOSIO_BASE_URL: BASE_URL },
49
+ })
50
+ )
51
+ );
52
+
53
+const withRepository = () => Layer.provide(ComposioToolkitsRepository.Default, platformLayer());
54
+
55
+// The real executor over the real client singleton, plus every service that
56
+// `execute` and session creation require, with the credential store mocked above.
57
+const withExecutor = () => {
58
+ const platform = platformLayer();
59
+ const singleton = Layer.provide(ComposioClientSingleton.Default, platform);
60
+ const repository = Layer.provide(ComposioToolkitsRepository.Default, platform);
61
+ const catalog = Layer.provide(ToolkitSlugCatalog.Default, Layer.mergeAll(repository, platform));
62
+ return Layer.mergeAll(
63
+ Layer.provide(ToolsExecutorLive, Layer.mergeAll(singleton, catalog)),
64
+ singleton,
65
+ repository,
66
+ platform,
67
+ NodeProcess.Default,
68
+ Layer.provide(ComposioUserContextLive, platform),
69
+ Layer.provide(ComposioCliUserConfigLive, Layer.mergeAll(platform, NodeProcess.Default)),
70
+ TerminalUITest,
71
+ cliDebugFlagsLayer()
72
+ );
73
+};
74
+
75
+const jsonResponse = (body: unknown) =>
76
+ new Response(JSON.stringify(body), {
77
+ status: 200,
78
+ headers: { 'Content-Type': 'application/json' },
79
+ });
80
+
81
+/**
82
+ * A `fetch` answer that never settles on its own: it hands out the request's
83
+ * `AbortSignal` and rejects only once that signal fires. Pair it with
84
+ * `mockImplementationOnce` so one chosen request hangs.
85
+ */
86
+const pendingRequest = () => {
87
+ const started = Promise.withResolvers<AbortSignal>();
88
+ const respond = (_input: string | URL | Request, init?: RequestInit) => {
89
+ const signal = init!.signal!;
90
+ started.resolve(signal);
91
+ return new Promise<Response>((_resolve, reject) => {
92
+ signal.addEventListener('abort', () => reject(signal.reason), { once: true });
93
+ });
94
+ };
95
+ return { respond, signal: Effect.promise(() => started.promise) };
96
+};
97
+
98
+const requestUrl = (call: readonly unknown[] | undefined) => new URL(String(call?.[0]));
99
+
100
+describe('interrupting a single-shot client request', () => {
101
+ afterEach(() => {
102
+ vi.restoreAllMocks();
103
+ clearInProcessMemos();
104
+ });
105
+
106
+ it.effect('connectedAccounts.list aborts the in-flight request', () =>
107
+ Effect.gen(function* () {
108
+ const pending = pendingRequest();
109
+ const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementationOnce(pending.respond);
110
+ const repository = yield* ComposioToolkitsRepository;
111
+
112
+ const fiber = yield* Effect.forkChild(
113
+ repository.listConnectedAccounts({ user_ids: ['default'], statuses: ['ACTIVE'] })
114
+ );
115
+ const requestSignal = yield* pending.signal;
116
+ expect(requestSignal.aborted).toBe(false);
117
+
118
+ yield* Fiber.interrupt(fiber);
119
+
120
+ expect(requestSignal.aborted).toBe(true);
121
+ expect(fetchSpy).toHaveBeenCalledTimes(1);
122
+ expect(requestUrl(fetchSpy.mock.calls[0]).pathname).toBe('/api/v3.1/connected_accounts');
123
+ }).pipe(Effect.provide(withRepository()))
124
+ );
125
+
126
+ it.effect('tool router session creation aborts the in-flight create request', () =>
127
+ Effect.gen(function* () {
128
+ const pending = pendingRequest();
129
+ const fetchSpy = vi
130
+ .spyOn(globalThis, 'fetch')
131
+ // The connection context the session is built from.
132
+ .mockResolvedValueOnce(jsonResponse({ items: [] }))
133
+ .mockImplementationOnce(pending.respond);
134
+ const client = yield* Effect.flatMap(ComposioClientSingleton, singleton => singleton.get());
135
+
136
+ const fiber = yield* Effect.forkChild(createToolRouterSessionContext(client, 'default'));
137
+ const requestSignal = yield* pending.signal;
138
+ expect(requestSignal.aborted).toBe(false);
139
+
140
+ yield* Fiber.interrupt(fiber);
141
+
142
+ expect(requestSignal.aborted).toBe(true);
143
+ expect(fetchSpy).toHaveBeenCalledTimes(2);
144
+ expect(requestUrl(fetchSpy.mock.calls[1]).pathname).toBe('/api/v3.1/tool_router/session');
145
+ }).pipe(Effect.provide(withExecutor()))
146
+ );
147
+
148
+ it.effect('a tool execution aborts the in-flight execute request', () =>
149
+ Effect.gen(function* () {
150
+ const pending = pendingRequest();
151
+ const fetchSpy = vi
152
+ .spyOn(globalThis, 'fetch')
153
+ // The connection context, then the session the execution runs in.
154
+ .mockResolvedValueOnce(jsonResponse({ items: [] }))
155
+ .mockResolvedValueOnce(jsonResponse({ session_id: 'trs_interrupted' }))
156
+ .mockImplementationOnce(pending.respond);
157
+ const executor = yield* ToolsExecutor;
158
+
159
+ // A meta tool: its execution needs no toolkit lookup and no input
160
+ // schema, so the hanging request is the execution itself.
161
+ const fiber = yield* Effect.forkChild(
162
+ executor.execute('COMPOSIO_SEARCH_TOOLS', {
163
+ userId: 'default',
164
+ arguments: { queries: [{ use_case: 'send an email' }] },
165
+ })
166
+ );
167
+ const requestSignal = yield* pending.signal;
168
+ expect(requestSignal.aborted).toBe(false);
169
+
170
+ yield* Fiber.interrupt(fiber);
171
+
172
+ expect(requestSignal.aborted).toBe(true);
173
+ expect(fetchSpy).toHaveBeenCalledTimes(3);
174
+ expect(requestUrl(fetchSpy.mock.calls[2]).pathname).toBe(
175
+ '/api/v3.1/tool_router/session/trs_interrupted/execute_meta'
176
+ );
177
+ }).pipe(Effect.provide(withExecutor()))
178
+ );
179
+});