Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
Mirrored from https://github.com/Camo67/composio.git
Synced Nov 22, 22:00 UTC
feat: add support for sending source and runtime headers (#1800)
Utkarsh Dixit committed
Jul 29, 2025 at 09:39 UTC
36d5dd7f54b3323a3849b1dcc9373c57b90bfd38
3 files changed
+397
-18
ts/packages/core/src/composio.ts
+17
-12
@@ -16,6 +16,7 @@ import { version } from '../package.json';
16
import type { ComposioRequestHeaders } from './types/composio.types';
17
import { McpServerGetResponse } from './types/mcp.types';
18
import { Files } from './models/Files';
19
+import { getDefaultHeaders, getSessionHeaders } from './utils/session';
20
21
export type ComposioConfig<
22
TProvider extends BaseComposioProvider<unknown, unknown, unknown> = OpenAIProvider,
@@ -148,17 +149,6 @@ export class Composio<
149
logger.debug(`Initializing Composio w API Key: [REDACTED] and baseURL: ${baseURLParsed}`);
150
}
151
151
- /**
152
- * Initialize the Composio SDK client.
153
- * The client is used to make API calls to the Composio API.
154
- */
155
- this.client = new ComposioClient({
156
- apiKey: apiKeyParsed,
157
- baseURL: baseURLParsed,
158
- defaultHeaders: config?.defaultHeaders,
159
- logLevel: COMPOSIO_LOG_LEVEL,
160
- });
161
-
152
/**
153
* Keep a reference to the config object.
154
* This is useful for creating a builder pattern, debugging and logging.
@@ -172,6 +162,20 @@ export class Composio<
162
* Set the default provider, if not provided by the user.
163
*/
164
this.provider = (config?.provider ?? new OpenAIProvider()) as TProvider;
165
+
166
+ const defaultHeaders = getDefaultHeaders(this.config.defaultHeaders, this.provider);
167
+
168
+ /**
169
+ * Initialize the Composio SDK client.
170
+ * The client is used to make API calls to the Composio API.
171
+ */
172
+ this.client = new ComposioClient({
173
+ apiKey: apiKeyParsed,
174
+ baseURL: baseURLParsed,
175
+ defaultHeaders: defaultHeaders,
176
+ logLevel: COMPOSIO_LOG_LEVEL,
177
+ });
178
+
179
this.tools = new Tools(this.client, this.provider, {
180
autoUploadDownloadFiles: config?.autoUploadDownloadFiles ?? true,
181
});
@@ -253,9 +257,10 @@ export class Composio<
257
* ```
258
*/
259
createSession(options?: { headers?: ComposioRequestHeaders }): Composio<TProvider> {
260
+ const sessionHeaders = getDefaultHeaders(options?.headers, this.provider);
261
return new Composio({
262
...this.config,
258
- defaultHeaders: options?.headers,
263
+ defaultHeaders: sessionHeaders,
264
});
265
}
266
}
ts/packages/core/src/utils/session.ts
new
+25
@@ -0,0 +1,25 @@
1
+import { BaseComposioProvider } from '../provider/BaseProvider';
2
+import { version } from '../../package.json';
3
+import { ComposioConfig } from '../composio';
4
+import { ComposioRequestHeaders } from '../types/composio.types';
5
+
6
+export function getSessionHeaders(
7
+ provider: BaseComposioProvider<unknown, unknown, unknown> | undefined
8
+) {
9
+ return {
10
+ 'x-source': provider?.name || '@composio/core',
11
+ 'x-runtime': 'composio-v3-ts-sdk',
12
+ 'x-sdk-version': version,
13
+ };
14
+}
15
+
16
+export const getDefaultHeaders = (
17
+ headers: ComposioRequestHeaders | undefined,
18
+ provider: BaseComposioProvider<unknown, unknown, unknown> | undefined
19
+) => {
20
+ const sessionHeaders = getSessionHeaders(provider);
21
+ return {
22
+ ...(headers || {}),
23
+ ...sessionHeaders,
24
+ };
25
+};
ts/packages/core/test/core/session.test.ts
+355
-6
@@ -1,6 +1,9 @@
1
import { describe, it, expect, vi } from 'vitest';
2
import { Composio } from '../../src/composio';
3
import { MockProvider } from '../utils/mocks/provider.mock';
4
+import { OpenAIProvider } from '../../src/provider/OpenAIProvider';
5
+import { getDefaultHeaders, getSessionHeaders } from '../../src/utils/session';
6
+import { version } from '../../package.json';
7
8
describe('Composio Session Management', () => {
9
const baseConfig = {
@@ -11,7 +14,7 @@ describe('Composio Session Management', () => {
14
allowTracing: false,
15
};
16
14
- it('should create a new session with custom headers', () => {
17
+ it('should create a new session with custom headers merged with session headers', () => {
18
const composio = new Composio(baseConfig);
19
const customHeaders = {
20
headers: {
@@ -21,8 +24,19 @@ describe('Composio Session Management', () => {
24
},
25
};
26
const session = composio.createSession(customHeaders);
27
+
28
+ // Should merge custom headers with session headers
29
// @ts-expect-error: access private config for test
25
- expect(session.config.defaultHeaders).toEqual(customHeaders.headers);
30
+ const defaultHeaders = session.config.defaultHeaders;
31
+ expect(defaultHeaders).toEqual({
32
+ 'x-request-id': '1234567890',
33
+ 'x-correlation-id': 'session-abc-123',
34
+ 'x-custom-header': 'custom-value',
35
+ 'x-source': 'MockProvider', // from provider
36
+ 'x-runtime': 'composio-v3-ts-sdk',
37
+ 'x-sdk-version': version,
38
+ });
39
+
40
// Should preserve other config
41
// @ts-expect-error: access private config for test
42
expect(session.config.apiKey).toBe(baseConfig.apiKey);
@@ -51,18 +65,353 @@ describe('Composio Session Management', () => {
65
const sessionB = composio.createSession({
66
headers: { 'x-user-id': 'user-b', 'x-tenant-id': 'tenant-2' },
67
});
68
+
69
// @ts-expect-error: access private config for test
55
- expect(sessionA.config.defaultHeaders['x-user-id']).toBe('user-a');
70
+ const headersA = sessionA.config.defaultHeaders;
71
// @ts-expect-error: access private config for test
57
- expect(sessionB.config.defaultHeaders['x-user-id']).toBe('user-b');
72
+ const headersB = sessionB.config.defaultHeaders;
73
+
74
+ // Each session should have its own custom headers merged with session headers
75
+ expect(headersA).toEqual({
76
+ 'x-user-id': 'user-a',
77
+ 'x-tenant-id': 'tenant-1',
78
+ 'x-source': 'MockProvider',
79
+ 'x-runtime': 'composio-v3-ts-sdk',
80
+ 'x-sdk-version': version,
81
+ });
82
+
83
+ expect(headersB).toEqual({
84
+ 'x-user-id': 'user-b',
85
+ 'x-tenant-id': 'tenant-2',
86
+ 'x-source': 'MockProvider',
87
+ 'x-runtime': 'composio-v3-ts-sdk',
88
+ 'x-sdk-version': version,
89
+ });
90
+
91
// Sessions should be isolated
92
expect(sessionA).not.toBe(sessionB);
93
});
94
62
- it('should default to parent config if no defaultHeaders are provided', () => {
95
+ it('should include session headers even when no custom headers are provided', () => {
96
const composio = new Composio(baseConfig);
97
const session = composio.createSession();
98
+
99
+ // Should still have session headers from provider
100
// @ts-expect-error: access private config for test
66
- expect(session.config.defaultHeaders).toBeUndefined();
101
+ const defaultHeaders = session.config.defaultHeaders;
102
+ expect(defaultHeaders).toEqual({
103
+ 'x-source': 'MockProvider', // from provider
104
+ 'x-runtime': 'composio-v3-ts-sdk',
105
+ 'x-sdk-version': version,
106
+ });
107
+ });
108
+});
109
+
110
+describe('Session Headers Generation', () => {
111
+ describe('getSessionHeaders', () => {
112
+ it('should generate correct session headers for OpenAI provider', () => {
113
+ const openAIProvider = new OpenAIProvider();
114
+ const headers = getSessionHeaders(openAIProvider);
115
+
116
+ expect(headers).toEqual({
117
+ 'x-source': 'openai',
118
+ 'x-runtime': 'composio-v3-ts-sdk',
119
+ 'x-sdk-version': version,
120
+ });
121
+ });
122
+
123
+ it('should generate correct session headers for MockProvider', () => {
124
+ const mockProvider = new MockProvider();
125
+ const headers = getSessionHeaders(mockProvider);
126
+
127
+ expect(headers).toEqual({
128
+ 'x-source': 'MockProvider',
129
+ 'x-runtime': 'composio-v3-ts-sdk',
130
+ 'x-sdk-version': version,
131
+ });
132
+ });
133
+
134
+ it('should use fallback source when provider is undefined', () => {
135
+ const headers = getSessionHeaders(undefined);
136
+
137
+ expect(headers).toEqual({
138
+ 'x-source': '@composio/core',
139
+ 'x-runtime': 'composio-v3-ts-sdk',
140
+ 'x-sdk-version': version,
141
+ });
142
+ });
143
+
144
+ it('should use fallback source when provider name is undefined', () => {
145
+ const mockProvider = {
146
+ name: undefined,
147
+ } as any;
148
+ const headers = getSessionHeaders(mockProvider);
149
+
150
+ expect(headers).toEqual({
151
+ 'x-source': '@composio/core',
152
+ 'x-runtime': 'composio-v3-ts-sdk',
153
+ 'x-sdk-version': version,
154
+ });
155
+ });
156
+ });
157
+
158
+ describe('getDefaultHeaders', () => {
159
+ it('should merge custom headers with session headers for OpenAI provider', () => {
160
+ const openAIProvider = new OpenAIProvider();
161
+ const customHeaders = {
162
+ 'x-request-id': '1234567890',
163
+ 'x-custom-header': 'custom-value',
164
+ };
165
+
166
+ const headers = getDefaultHeaders(customHeaders, openAIProvider);
167
+
168
+ expect(headers).toEqual({
169
+ 'x-request-id': '1234567890',
170
+ 'x-custom-header': 'custom-value',
171
+ 'x-source': 'openai',
172
+ 'x-runtime': 'composio-v3-ts-sdk',
173
+ 'x-sdk-version': version,
174
+ });
175
+ });
176
+
177
+ it('should merge custom headers with session headers for MockProvider', () => {
178
+ const mockProvider = new MockProvider();
179
+ const customHeaders = {
180
+ 'x-user-id': 'user-123',
181
+ 'x-tenant-id': 'tenant-456',
182
+ };
183
+
184
+ const headers = getDefaultHeaders(customHeaders, mockProvider);
185
+
186
+ expect(headers).toEqual({
187
+ 'x-user-id': 'user-123',
188
+ 'x-tenant-id': 'tenant-456',
189
+ 'x-source': 'MockProvider',
190
+ 'x-runtime': 'composio-v3-ts-sdk',
191
+ 'x-sdk-version': version,
192
+ });
193
+ });
194
+
195
+ it('should prioritize session headers over custom headers when keys conflict', () => {
196
+ const openAIProvider = new OpenAIProvider();
197
+ const customHeaders = {
198
+ 'x-source': 'custom-source',
199
+ 'x-runtime': 'custom-runtime',
200
+ 'x-sdk-version': 'custom-version',
201
+ 'x-custom-header': 'custom-value',
202
+ };
203
+
204
+ const headers = getDefaultHeaders(customHeaders, openAIProvider);
205
+
206
+ expect(headers).toEqual({
207
+ 'x-source': 'openai', // session header takes precedence
208
+ 'x-runtime': 'composio-v3-ts-sdk', // session header takes precedence
209
+ 'x-sdk-version': version, // session header takes precedence
210
+ 'x-custom-header': 'custom-value', // custom header preserved
211
+ });
212
+ });
213
+
214
+ it('should handle undefined custom headers', () => {
215
+ const openAIProvider = new OpenAIProvider();
216
+ const headers = getDefaultHeaders(undefined, openAIProvider);
217
+
218
+ expect(headers).toEqual({
219
+ 'x-source': 'openai',
220
+ 'x-runtime': 'composio-v3-ts-sdk',
221
+ 'x-sdk-version': version,
222
+ });
223
+ });
224
+
225
+ it('should handle empty custom headers object', () => {
226
+ const openAIProvider = new OpenAIProvider();
227
+ const headers = getDefaultHeaders({}, openAIProvider);
228
+
229
+ expect(headers).toEqual({
230
+ 'x-source': 'openai',
231
+ 'x-runtime': 'composio-v3-ts-sdk',
232
+ 'x-sdk-version': version,
233
+ });
234
+ });
235
+
236
+ it('should handle undefined provider', () => {
237
+ const customHeaders = {
238
+ 'x-request-id': '1234567890',
239
+ };
240
+
241
+ const headers = getDefaultHeaders(customHeaders, undefined);
242
+
243
+ expect(headers).toEqual({
244
+ 'x-request-id': '1234567890',
245
+ 'x-source': '@composio/core',
246
+ 'x-runtime': 'composio-v3-ts-sdk',
247
+ 'x-sdk-version': version,
248
+ });
249
+ });
250
+ });
251
+});
252
+
253
+describe('Session Headers Configuration Integration', () => {
254
+ it('should create Composio instance with correct session headers config for OpenAI provider', () => {
255
+ const openAIProvider = new OpenAIProvider();
256
+ const composio = new Composio({
257
+ apiKey: 'test-api-key',
258
+ baseURL: 'https://api.test.com',
259
+ provider: openAIProvider,
260
+ allowTracking: false,
261
+ });
262
+
263
+ // Verify the provider and configuration are set correctly
264
+ expect(composio.provider).toBe(openAIProvider);
265
+ // @ts-expect-error: access private config for test
266
+ expect(composio.config.provider).toBe(openAIProvider);
267
+ });
268
+
269
+ it('should create Composio instance with custom default headers merged with session headers', () => {
270
+ const openAIProvider = new OpenAIProvider();
271
+ const customHeaders = {
272
+ 'x-request-id': '1234567890',
273
+ 'x-correlation-id': 'correlation-123',
274
+ };
275
+
276
+ const composio = new Composio({
277
+ apiKey: 'test-api-key',
278
+ baseURL: 'https://api.test.com',
279
+ provider: openAIProvider,
280
+ defaultHeaders: customHeaders,
281
+ allowTracking: false,
282
+ });
283
+
284
+ // Verify the configuration includes custom headers
285
+ // @ts-expect-error: access private config for test
286
+ expect(composio.config.defaultHeaders).toEqual(customHeaders);
287
+ expect(composio.provider).toBe(openAIProvider);
288
+ });
289
+
290
+ it('should create session instance with provider-specific configuration', () => {
291
+ const openAIProvider = new OpenAIProvider();
292
+ const composio = new Composio({
293
+ apiKey: 'test-api-key',
294
+ baseURL: 'https://api.test.com',
295
+ provider: openAIProvider,
296
+ allowTracking: false,
297
+ });
298
+
299
+ const sessionHeaders = {
300
+ 'x-request-id': '1234567890',
301
+ 'x-user-context': 'user-session',
302
+ };
303
+
304
+ const session = composio.createSession({ headers: sessionHeaders });
305
+
306
+ // Verify session inherits provider and has merged headers configuration
307
+ expect(session.provider).toBe(openAIProvider);
308
+ // @ts-expect-error: access private config for test
309
+ const sessionDefaultHeaders = session.config.defaultHeaders;
310
+
311
+ // Verify that session headers include both custom and provider-specific headers
312
+ expect(sessionDefaultHeaders).toEqual({
313
+ 'x-request-id': '1234567890',
314
+ 'x-user-context': 'user-session',
315
+ 'x-source': 'openai',
316
+ 'x-runtime': 'composio-v3-ts-sdk',
317
+ 'x-sdk-version': version,
318
+ });
319
+ });
320
+
321
+ it('should maintain distinct provider configurations across sessions', () => {
322
+ const openAIProvider = new OpenAIProvider();
323
+ const mockProvider = new MockProvider();
324
+
325
+ const composioOpenAI = new Composio({
326
+ apiKey: 'test-api-key',
327
+ provider: openAIProvider,
328
+ allowTracking: false,
329
+ });
330
+
331
+ const composioMock = new Composio({
332
+ apiKey: 'test-api-key',
333
+ provider: mockProvider,
334
+ allowTracking: false,
335
+ });
336
+
337
+ const sessionOpenAI = composioOpenAI.createSession({
338
+ headers: { 'x-session': 'openai-session' },
339
+ });
340
+
341
+ const sessionMock = composioMock.createSession({
342
+ headers: { 'x-session': 'mock-session' },
343
+ });
344
+
345
+ // Verify providers are maintained correctly
346
+ expect(sessionOpenAI.provider).toBe(openAIProvider);
347
+ expect(sessionMock.provider).toBe(mockProvider);
348
+
349
+ // Verify session configurations have provider-specific headers
350
+ // @ts-expect-error: access private config for test
351
+ const openAIHeaders = sessionOpenAI.config.defaultHeaders!;
352
+ // @ts-expect-error: access private config for test
353
+ const mockHeaders = sessionMock.config.defaultHeaders!;
354
+
355
+ expect(openAIHeaders['x-source']).toBe('openai');
356
+ expect(openAIHeaders['x-session']).toBe('openai-session');
357
+
358
+ expect(mockHeaders['x-source']).toBe('MockProvider');
359
+ expect(mockHeaders['x-session']).toBe('mock-session');
360
+ });
361
+
362
+ it('should create session with provider-specific headers even without custom headers', () => {
363
+ const openAIProvider = new OpenAIProvider();
364
+ const composio = new Composio({
365
+ apiKey: 'test-api-key',
366
+ provider: openAIProvider,
367
+ allowTracking: false,
368
+ });
369
+
370
+ const session = composio.createSession();
371
+
372
+ // Verify session has provider-specific configuration
373
+ expect(session.provider).toBe(openAIProvider);
374
+ // @ts-expect-error: access private config for test
375
+ const sessionHeaders = session.config.defaultHeaders;
376
+
377
+ expect(sessionHeaders).toEqual({
378
+ 'x-source': 'openai',
379
+ 'x-runtime': 'composio-v3-ts-sdk',
380
+ 'x-sdk-version': version,
381
+ });
382
+ });
383
+
384
+ it('should properly merge headers when both parent and session have custom headers', () => {
385
+ const openAIProvider = new OpenAIProvider();
386
+
387
+ // Create parent with default headers
388
+ const composio = new Composio({
389
+ apiKey: 'test-api-key',
390
+ provider: openAIProvider,
391
+ defaultHeaders: {
392
+ 'x-parent-header': 'parent-value',
393
+ 'x-shared-header': 'parent-shared-value',
394
+ },
395
+ allowTracking: false,
396
+ });
397
+
398
+ // Create session with additional headers
399
+ const session = composio.createSession({
400
+ headers: {
401
+ 'x-session-header': 'session-value',
402
+ 'x-shared-header': 'session-shared-value', // should override parent
403
+ },
404
+ });
405
+
406
+ // @ts-expect-error: access private config for test
407
+ const sessionHeaders = session.config.defaultHeaders;
408
+
409
+ expect(sessionHeaders).toEqual({
410
+ 'x-session-header': 'session-value',
411
+ 'x-shared-header': 'session-shared-value', // session value takes precedence
412
+ 'x-source': 'openai', // provider-specific header
413
+ 'x-runtime': 'composio-v3-ts-sdk',
414
+ 'x-sdk-version': version,
415
+ });
416
});
417
});