1
-import { VERSION as clientLibraryVersion } from '@composio/client';
1
+import {
2
+ ComposioError as ClientComposioError,
3
+ VERSION as clientLibraryVersion,
4
+} from '@composio/client';
5
import { afterEach, beforeEach, describe, it, expect, vi } from 'vitest';
6
import * as fs from 'node:fs';
7
import * as os from 'node:os';
10
import { SessionConfigs } from '../../src/models/SessionConfigs';
11
import { MockProvider } from '../utils/mocks/provider.mock';
12
import { OpenAIProvider } from '../../src/provider/OpenAIProvider';
10
-import { getDefaultHeaders, getSessionHeaders } from '../../src/utils/session';
13
+import { getClientIdentity } from '../../src/utils/session';
14
import { version } from '../../package.json';
15
import {
16
ComposioAPIKeyKindError,
20
import { ComposioMCPDestinationError } from '../../src/errors/ToolRouterErrors';
21
import logger from '../../src/utils/logger';
22
20
-const provenanceHeaders = {
23
+const identityHeaders = (framework: string) => ({
24
'x-client-provenance': '@composio/core',
25
'x-client-version': version,
26
+ 'x-sdk-version': version,
27
'x-client-language': 'typescript',
28
'x-client-library': '@composio/client',
29
'x-client-library-version': clientLibraryVersion,
30
+ 'x-client-runtime': 'nodejs',
31
'x-runtime-version': process.versions.node,
27
-};
32
+ 'x-runtime': 'NODEJS',
33
+ 'x-source': 'TYPESCRIPT_SDK',
34
+ 'x-framework': framework,
35
+});
36
37
describe('Composio Session Management', () => {
38
const baseConfig = {
61
'x-request-id': '1234567890',
62
'x-correlation-id': 'session-abc-123',
63
'x-custom-header': 'custom-value',
56
- 'x-framework': 'MockProvider', // from provider
57
- 'x-source': 'TYPESCRIPT_SDK',
58
- 'x-runtime': 'NODEJS',
59
- 'x-client-runtime': 'nodejs',
60
- ...provenanceHeaders,
61
- 'x-sdk-version': version,
64
});
65
66
// Should preserve other config
101
expect(headersA).toEqual({
102
'x-user-id': 'user-a',
103
'x-tenant-id': 'tenant-1',
102
- 'x-framework': 'MockProvider',
103
- 'x-source': 'TYPESCRIPT_SDK',
104
- 'x-runtime': 'NODEJS',
105
- 'x-client-runtime': 'nodejs',
106
- ...provenanceHeaders,
107
- 'x-sdk-version': version,
104
});
105
106
expect(headersB).toEqual({
107
'x-user-id': 'user-b',
108
'x-tenant-id': 'tenant-2',
113
- 'x-framework': 'MockProvider',
114
- 'x-source': 'TYPESCRIPT_SDK',
115
- 'x-runtime': 'NODEJS',
116
- 'x-client-runtime': 'nodejs',
117
- ...provenanceHeaders,
118
- 'x-sdk-version': version,
109
});
110
111
// Sessions should be isolated
112
expect(sessionA).not.toBe(sessionB);
113
});
114
125
- it('should include session headers even when no custom headers are provided', () => {
115
+ it('should carry no default headers when no custom headers are provided', () => {
116
const composio = new Composio(baseConfig);
117
const session = composio.createSession();
118
129
- // Should still have session headers from provider
119
+ // The identity headers come from the client's `identity`, not defaultHeaders
120
// @ts-expect-error: access private config for test
121
const defaultHeaders = session.config.defaultHeaders;
132
- expect(defaultHeaders).toEqual({
133
- 'x-framework': 'MockProvider', // from provider
134
- 'x-source': 'TYPESCRIPT_SDK',
135
- 'x-runtime': 'NODEJS',
136
- 'x-client-runtime': 'nodejs',
137
- ...provenanceHeaders,
138
- 'x-sdk-version': version,
139
- });
122
+ expect(defaultHeaders).toBeUndefined();
123
});
124
125
it('should expose sessions.create and keep composio.create as a bound alias', async () => {
163
});
164
});
165
183
-describe('Session Headers Generation', () => {
184
- describe('getSessionHeaders', () => {
185
- it('should generate correct session headers for OpenAI provider', () => {
186
- const openAIProvider = new OpenAIProvider();
187
- const headers = getSessionHeaders(openAIProvider);
188
-
189
- expect(headers).toEqual({
190
- 'x-framework': 'openai',
191
- 'x-source': 'TYPESCRIPT_SDK',
192
- 'x-runtime': 'NODEJS',
193
- 'x-client-runtime': 'nodejs',
194
- ...provenanceHeaders,
195
- 'x-sdk-version': version,
196
- });
197
- });
198
-
199
- it('should generate correct session headers for MockProvider', () => {
200
- const mockProvider = new MockProvider();
201
- const headers = getSessionHeaders(mockProvider);
202
-
203
- expect(headers).toEqual({
204
- 'x-framework': 'MockProvider',
205
- 'x-source': 'TYPESCRIPT_SDK',
206
- 'x-runtime': 'NODEJS',
207
- 'x-client-runtime': 'nodejs',
208
- ...provenanceHeaders,
209
- 'x-sdk-version': version,
210
- });
211
- });
166
+describe('getClientIdentity', () => {
167
+ const sdkIdentity = (framework: string) => ({
168
+ product: '@composio/core',
169
+ version,
170
+ source: 'TYPESCRIPT_SDK',
171
+ framework,
172
+ runtime: 'NODEJS',
173
+ });
174
213
- it('should use fallback source when provider is undefined', () => {
214
- const headers = getSessionHeaders(undefined);
175
+ it('reports the OpenAI provider as the framework', () => {
176
+ expect(getClientIdentity(new OpenAIProvider())).toEqual(sdkIdentity('openai'));
177
+ });
178
216
- expect(headers).toEqual({
217
- 'x-framework': 'unknown',
218
- 'x-source': 'TYPESCRIPT_SDK',
219
- 'x-runtime': 'NODEJS',
220
- 'x-client-runtime': 'nodejs',
221
- ...provenanceHeaders,
222
- 'x-sdk-version': version,
223
- });
224
- });
179
+ it('reports a custom provider by its name', () => {
180
+ expect(getClientIdentity(new MockProvider())).toEqual(sdkIdentity('MockProvider'));
181
+ });
182
226
- it('should use fallback source when provider name is undefined', () => {
227
- const mockProvider = {
228
- name: undefined,
229
- } as unknown;
230
- const headers = getSessionHeaders(mockProvider);
183
+ it('reports an unknown framework without a provider or a provider name', () => {
184
+ expect(getClientIdentity(undefined)).toEqual(sdkIdentity('unknown'));
185
+ expect(getClientIdentity({ name: undefined } as unknown as MockProvider)).toEqual(
186
+ sdkIdentity('unknown')
187
+ );
188
+ });
189
232
- expect(headers).toEqual({
233
- 'x-framework': 'unknown',
234
- 'x-source': 'TYPESCRIPT_SDK',
235
- 'x-runtime': 'NODEJS',
236
- 'x-client-runtime': 'nodejs',
237
- ...provenanceHeaders,
238
- 'x-sdk-version': version,
239
- });
240
- });
190
+ it('reports an unknown framework for a provider name the client cannot send', () => {
191
+ for (const name of ['café', ' padded ', '', 'openai\n', 'openai\r\n']) {
192
+ expect(getClientIdentity({ name } as unknown as MockProvider)).toEqual(
193
+ sdkIdentity('unknown')
194
+ );
195
+ }
196
});
197
+});
198
243
- describe('getDefaultHeaders', () => {
244
- it('should merge custom headers with session headers for OpenAI provider', () => {
245
- const openAIProvider = new OpenAIProvider();
246
- const customHeaders = {
247
- 'x-request-id': '1234567890',
248
- 'x-custom-header': 'custom-value',
249
- };
199
+describe('Identity headers at the transport boundary', () => {
200
+ const captureFetch = () => {
201
+ const fetchMock = vi.fn(async () => Response.json({ items: [], next_cursor: null }));
202
+ vi.stubGlobal('fetch', fetchMock);
203
+ return fetchMock;
204
+ };
205
251
- const headers = getDefaultHeaders(customHeaders, openAIProvider);
206
+ const sentHeaders = (fetchMock: ReturnType<typeof captureFetch>) => {
207
+ const call = fetchMock.mock.calls[0] as unknown as [string, { headers: HeadersInit }];
208
+ return Object.fromEntries(new Headers(call[1].headers));
209
+ };
210
253
- expect(headers).toEqual({
254
- 'x-request-id': '1234567890',
255
- 'x-custom-header': 'custom-value',
256
- 'x-framework': 'openai',
257
- 'x-source': 'TYPESCRIPT_SDK',
258
- 'x-runtime': 'NODEJS',
259
- 'x-client-runtime': 'nodejs',
260
- ...provenanceHeaders,
261
- 'x-sdk-version': version,
262
- });
211
+ const build = (config: ConstructorParameters<typeof Composio>[0] = {}) =>
212
+ new Composio({
213
+ apiKey: 'test-api-key',
214
+ baseURL: 'https://api.test.com',
215
+ provider: new MockProvider(),
216
+ allowTracking: false,
217
+ disableVersionCheck: true,
218
+ ...config,
219
});
220
265
- it('should merge custom headers with session headers for MockProvider', () => {
266
- const mockProvider = new MockProvider();
267
- const customHeaders = {
268
- 'x-user-id': 'user-123',
269
- 'x-tenant-id': 'tenant-456',
270
- };
271
-
272
- const headers = getDefaultHeaders(customHeaders, mockProvider);
273
-
274
- expect(headers).toEqual({
275
- 'x-user-id': 'user-123',
276
- 'x-tenant-id': 'tenant-456',
277
- 'x-framework': 'MockProvider',
278
- 'x-source': 'TYPESCRIPT_SDK',
279
- 'x-runtime': 'NODEJS',
280
- 'x-client-runtime': 'nodejs',
281
- ...provenanceHeaders,
282
- 'x-sdk-version': version,
283
- });
284
- });
221
+ afterEach(() => {
222
+ vi.unstubAllGlobals();
223
+ });
224
286
- it('should prioritize session headers over custom headers when keys conflict', () => {
287
- const openAIProvider = new OpenAIProvider();
288
- const customHeaders = {
289
- 'x-source': 'custom-source',
290
- 'x-runtime': 'custom-runtime',
291
- 'x-sdk-version': 'custom-version',
292
- 'x-custom-header': 'custom-value',
293
- };
294
-
295
- const headers = getDefaultHeaders(customHeaders, openAIProvider);
296
-
297
- expect(headers).toEqual({
298
- 'x-framework': 'openai', // session header takes precedence
299
- 'x-source': 'TYPESCRIPT_SDK', // session header takes precedence
300
- 'x-runtime': 'NODEJS',
301
- 'x-client-runtime': 'nodejs', // session header takes precedence
302
- ...provenanceHeaders,
303
- 'x-sdk-version': version, // session header takes precedence
304
- 'x-custom-header': 'custom-value', // custom header preserved
305
- });
306
- });
225
+ it('sends the SDK identity, the provider as the framework, and the caller headers', async () => {
226
+ const fetchMock = captureFetch();
227
308
- it('should handle undefined custom headers', () => {
309
- const openAIProvider = new OpenAIProvider();
310
- const headers = getDefaultHeaders(undefined, openAIProvider);
228
+ await build({ defaultHeaders: { 'x-request-id': 'req-1' } })
229
+ .getClient()
230
+ .toolkits.list({ limit: 1 });
231
312
- expect(headers).toEqual({
313
- 'x-framework': 'openai',
314
- 'x-source': 'TYPESCRIPT_SDK',
315
- 'x-runtime': 'NODEJS',
316
- 'x-client-runtime': 'nodejs',
317
- ...provenanceHeaders,
318
- 'x-sdk-version': version,
319
- });
232
+ expect(sentHeaders(fetchMock)).toMatchObject({
233
+ ...identityHeaders('MockProvider'),
234
+ 'x-request-id': 'req-1',
235
});
236
+ });
237
322
- it('should handle empty custom headers object', () => {
323
- const openAIProvider = new OpenAIProvider();
324
- const headers = getDefaultHeaders({}, openAIProvider);
238
+ it('sends the same identity from a createSession clone', async () => {
239
+ const fetchMock = captureFetch();
240
326
- expect(headers).toEqual({
327
- 'x-framework': 'openai',
328
- 'x-source': 'TYPESCRIPT_SDK',
329
- 'x-runtime': 'NODEJS',
330
- 'x-client-runtime': 'nodejs',
331
- ...provenanceHeaders,
332
- 'x-sdk-version': version,
333
- });
334
- });
241
+ await build({ provider: new OpenAIProvider() })
242
+ .createSession({ headers: { 'x-session': 's-1' } })
243
+ .getClient()
244
+ .toolkits.list({ limit: 1 });
245
336
- it('should handle undefined provider', () => {
337
- const customHeaders = {
338
- 'x-request-id': '1234567890',
339
- };
246
+ expect(sentHeaders(fetchMock)).toMatchObject({
247
+ ...identityHeaders('openai'),
248
+ 'x-session': 's-1',
249
+ });
250
+ });
251
341
- const headers = getDefaultHeaders(customHeaders, undefined);
252
+ it('rejects an identity header in defaultHeaders', () => {
253
+ expect(() => build({ defaultHeaders: { 'x-source': 'custom-source' } })).toThrow(
254
+ ClientComposioError
255
+ );
256
+ expect(() => build({ defaultHeaders: { 'X-Client-Library': 'other' } })).toThrow(
257
+ ClientComposioError
258
+ );
259
+ });
260
343
- expect(headers).toEqual({
344
- 'x-request-id': '1234567890',
345
- 'x-framework': 'unknown',
346
- 'x-source': 'TYPESCRIPT_SDK',
347
- 'x-runtime': 'NODEJS',
348
- 'x-client-runtime': 'nodejs',
349
- ...provenanceHeaders,
350
- 'x-sdk-version': version,
351
- });
352
- });
261
+ it('rejects an identity header passed to createSession', () => {
262
+ expect(() => build().createSession({ headers: { 'x-framework': 'other' } })).toThrow(
263
+ ClientComposioError
264
+ );
265
});
266
});
267
327
expect(sessionDefaultHeaders).toEqual({
328
'x-request-id': '1234567890',
329
'x-user-context': 'user-session',
418
- 'x-framework': 'openai',
419
- 'x-source': 'TYPESCRIPT_SDK',
420
- 'x-runtime': 'NODEJS',
421
- 'x-client-runtime': 'nodejs',
422
- ...provenanceHeaders,
423
- 'x-sdk-version': version,
330
});
331
});
332
358
expect(sessionOpenAI.provider).toBe(openAIProvider);
359
expect(sessionMock.provider).toBe(mockProvider);
360
455
- // Verify session configurations have provider-specific headers
361
+ // Each session carries its own headers; the provider reaches the wire through `identity`
362
// @ts-expect-error: access private config for test
457
- const openAIHeaders = sessionOpenAI.config.defaultHeaders!;
363
+ expect(sessionOpenAI.config.defaultHeaders).toEqual({ 'x-session': 'openai-session' });
364
// @ts-expect-error: access private config for test
459
- const mockHeaders = sessionMock.config.defaultHeaders!;
460
-
461
- expect(openAIHeaders['x-framework']).toBe('openai');
462
- expect(openAIHeaders['x-session']).toBe('openai-session');
463
-
464
- expect(mockHeaders['x-framework']).toBe('MockProvider');
465
- expect(mockHeaders['x-session']).toBe('mock-session');
365
+ expect(sessionMock.config.defaultHeaders).toEqual({ 'x-session': 'mock-session' });
366
});
367
468
- it('should create session with provider-specific headers even without custom headers', () => {
368
+ it('should create session with no default headers without custom headers', () => {
369
const openAIProvider = new OpenAIProvider();
370
const composio = new Composio({
371
apiKey: 'test-api-key',
380
// @ts-expect-error: access private config for test
381
const sessionHeaders = session.config.defaultHeaders;
382
483
- expect(sessionHeaders).toEqual({
484
- 'x-framework': 'openai',
485
- 'x-source': 'TYPESCRIPT_SDK',
486
- 'x-runtime': 'NODEJS',
487
- 'x-client-runtime': 'nodejs',
488
- ...provenanceHeaders,
489
- 'x-sdk-version': version,
490
- });
383
+ expect(sessionHeaders).toBeUndefined();
384
});
385
386
it('should properly merge headers when both parent and session have custom headers', () => {
411
expect(sessionHeaders).toEqual({
412
'x-session-header': 'session-value',
413
'x-shared-header': 'session-shared-value', // session value takes precedence
521
- 'x-framework': 'openai', // provider-specific header
522
- 'x-source': 'TYPESCRIPT_SDK',
523
- 'x-runtime': 'NODEJS',
524
- 'x-client-runtime': 'nodejs',
525
- ...provenanceHeaders,
526
- 'x-sdk-version': version,
414
});
415
});
416
});