@devries-cameron20 / composio Mirror · read-only / commits / 36d5dd7f5
Fork 0

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 });