Skip to content

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

Feat: Add session management (#25)

Musthaq Ahamad040b5a49f5c9
diff --git a/.changeset/lemon-regions-brush.md b/.changeset/lemon-regions-brush.md
new file mode 100644
index 000000000..4d1c5b99c
--- /dev/null
+++ b/.changeset/lemon-regions-brush.md
@@ -0,0 +1,12 @@
+---
+'@composio/core': patch
+'@composio/anthropic': patch
+'@composio/cloudflare': patch
+'@composio/google': patch
+'@composio/langchain': patch
+'@composio/mastra': patch
+'@composio/openai': patch
+'@composio/vercel': patch
+---
+
+Ability to create sessions for transferring request ids
diff --git a/docs/README.md b/docs/README.md
index a6ec02ad9..f2eaaab03 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -123,6 +123,7 @@ Check out our [examples directory](../examples) for complete code samples:
- [Telemetry](./advanced/telemetry.md)
- [Custom Providers](./advanced/custom-providers.md)
- [Modifiers](./advanced/modifiers.md)
+- [Session Management](./advanced/session-management.md)
## Internal Documentation
diff --git a/docs/advanced/session-management.md b/docs/advanced/session-management.md
new file mode 100644
index 000000000..93030e9ca
--- /dev/null
+++ b/docs/advanced/session-management.md
@@ -0,0 +1,163 @@
+# Session Management
+
+The Composio SDK provides powerful session management capabilities through the `createSession` method. This feature allows you to create new instances of the SDK with custom request options while preserving your existing configuration. This is particularly useful when you need to add request-specific headers, track request contexts, or customize request behavior for specific operations.
+
+## Composio Constructor Options
+
+When initializing the SDK, you can provide the following options:
+
+```typescript
+const composio = new Composio({
+ apiKey: 'your-api-key', // required
+ baseURL: 'https://api.composio.dev', // optional
+ allowTracking: true, // optional, default: true
+ allowTracing: true, // optional, default: true
+ provider: new OpenAIProvider(), // optional
+ telemetryTransport: customTransport, // optional
+ defaultHeaders: { 'x-request-id': 'global-id' }, // optional, applies to all requests
+});
+```
+
+- `apiKey` (**required**): Your Composio API key
+- `baseURL` (optional): Custom API endpoint
+- `allowTracking` (optional, default: true): Enable/disable telemetry
+- `allowTracing` (optional, default: true): Enable/disable tracing
+- `provider` (optional): Custom provider (defaults to OpenAIProvider)
+- `telemetryTransport` (optional): Custom telemetry transport
+- `defaultHeaders` (optional): Default headers for all requests (applies globally)
+
+## Overview
+
+When you create a new session using `createSession`, you get a new Composio instance that:
+
+- Inherits all configuration from the parent instance (apiKey, baseURL, provider, etc.)
+- Allows you to specify custom request headers that will be applied to all API calls made through that session
+- Maintains isolation between different sessions, enabling parallel operations with different contexts
+
+## Use Cases
+
+Sessions are particularly useful for:
+
+1. **Request Tracking**
+
+ - Adding correlation IDs
+ - Including request IDs for tracing
+ - Setting custom headers for monitoring
+
+2. **Context Management**
+
+ - Managing user-specific contexts
+ - Handling different authentication contexts
+ - Implementing tenant-specific headers
+
+3. **Request Customization**
+ - Modifying request behavior for specific operations
+ - Adding custom metadata
+ - Implementing custom retry logic
+
+## Usage
+
+Here's how to use session management in your application:
+
+```typescript
+// Create your base Composio instance
+const composio = new Composio({
+ apiKey: 'your-api-key',
+});
+
+// Create a session with custom headers
+const sessionWithHeaders = composio.createSession({
+ headers: {
+ 'x-request-id': '1234567890',
+ 'x-correlation-id': 'session-abc-123',
+ 'x-custom-header': 'custom-value',
+ },
+});
+
+// Use the session for making API calls
+await sessionWithHeaders.tools.list();
+```
+
+## Advanced Usage
+
+You can create multiple sessions with different configurations:
+
+```typescript
+// Session for user A
+const userASession = composio.createSession({
+ headers: {
+ 'x-user-id': 'user-a',
+ 'x-tenant-id': 'tenant-1',
+ },
+});
+
+// Session for user B
+const userBSession = composio.createSession({
+ headers: {
+ 'x-user-id': 'user-b',
+ 'x-tenant-id': 'tenant-2',
+ },
+});
+
+// Each session maintains its own context
+await Promise.all([
+ userASession.tools.get('a'), // Will include user A's headers
+ userBSession.tools.list('b'), // Will include user B's headers
+]);
+```
+
+## Best Practices
+
+1. **Session Lifecycle**
+
+ - Create sessions for specific contexts or operations
+ - Don't share sessions across different contexts
+ - Create new sessions when context changes
+
+2. **Header Management**
+
+ - Use consistent header naming conventions
+ - Include relevant tracking IDs
+ - Document custom headers used in your application
+
+3. **Error Handling**
+ - Sessions inherit error handling from the parent instance
+ - Add context-specific error handling when needed
+
+## Request Options
+
+The session accepts custom headers via the `headers` property. These headers will be used for all API calls made through that session:
+
+```typescript
+const session = composio.createSession({
+ headers: {
+ // Custom headers
+ 'x-request-id': 'unique-id',
+ 'x-correlation-id': 'correlation-id',
+ 'content-type': 'application/json',
+ },
+});
+```
+
+If you want to set default headers for all requests (even outside sessions), use the `defaultHeaders` property in the main constructor:
+
+```typescript
+const composio = new Composio({
+ apiKey: 'your-api-key',
+ defaultHeaders: {
+ 'x-global-header': 'global-value',
+ },
+});
+```
+
+## Limitations and Considerations
+
+1. Sessions are immutable – once created, their configuration (including headers) cannot be changed.
+2. Each session is a new Composio instance with its own context and headers.
+3. Headers set in a session apply to all API calls made through that session.
+
+## Related Topics
+
+- [Error Handling](./error-handling.md)
+- [Custom Providers](./custom-providers.md)
+- [Telemetry](./telemetry.md)
diff --git a/docs/getting-started.md b/docs/getting-started.md
index bbaba39d5..2cf49511d 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -263,6 +263,8 @@ const result = await composio.tools.execute('WEATHER_FORECAST', {
console.log(result.data.forecast);
```
+For more advanced session management features, check out the [Session Management Guide](./advanced/session-management.md).
+
## Next Steps
Now that you understand the basics, you can:
diff --git a/examples/connected-accounts/src/index.ts b/examples/connected-accounts/src/index.ts
index 8264408fc..3faea5eb6 100644
--- a/examples/connected-accounts/src/index.ts
+++ b/examples/connected-accounts/src/index.ts
@@ -9,19 +9,30 @@ const composio = new Composio({
/**
* Create a new auth config
*/
-const authConfig = await composio.authConfigs.create('my-toolkit', {
- type: AuthConfigTypes.CUSTOM,
- authScheme: AuthSchemeTypes.BASIC,
- credentials: {
- // this should error not like the credentials should come from the auth scheme type
- apiKey: '1234567890',
- },
+const authConfig = await composio.authConfigs.create('github', {
+ type: AuthConfigTypes.COMPOSIO_MANAGED,
+ name: 'My GitHub Auth Config',
});
+console.log(`✅ Auth config created: ${authConfig.id}`);
+console.log(`🔄 Createting a connection request`);
+
/**
* Create a new connected account
*/
const ConnectionRequest = await composio.connectedAccounts.initiate('default', authConfig.id);
+
+console.log(
+ `🔗 Please visit the following URL to authorize the user: ${ConnectionRequest.redirectUrl}`
+);
const connectedAccount = await ConnectionRequest.waitForConnection();
+console.log(`✅ Connected account created: ${connectedAccount.id}`);
console.log(connectedAccount);
+console.log(`🔄 Getting the GitHub tools`);
+
+const tools = await composio.tools.get('default', {
+ toolkits: ['github'],
+});
+
+console.log(tools);
diff --git a/examples/custom-tools/src/index.ts b/examples/custom-tools/src/index.ts
index 836419505..07a816458 100644
--- a/examples/custom-tools/src/index.ts
+++ b/examples/custom-tools/src/index.ts
@@ -39,7 +39,6 @@ const tool = await composio.tools.createCustomTool({
const result = await executeToolRequest({
endpoint: `/user/starred/composiohq/${input.repository}`,
method: 'PUT',
- body: {},
});
return result;
},
diff --git a/examples/session-management/.env.example b/examples/session-management/.env.example
new file mode 100644
index 000000000..0e728257c
--- /dev/null
+++ b/examples/session-management/.env.example
@@ -0,0 +1,6 @@
+# Composio API Key - Get it from https://app.composio.dev
+COMPOSIO_API_KEY=your_composio_api_key_here
+
+# Add other environment variables as needed for your example
+# OPENAI_API_KEY=your_openai_api_key_here
+# ANTHROPIC_API_KEY=your_anthropic_api_key_here
diff --git a/examples/session-management/README.md b/examples/session-management/README.md
new file mode 100644
index 000000000..726376018
--- /dev/null
+++ b/examples/session-management/README.md
@@ -0,0 +1,53 @@
+# Session-management Example
+
+This example demonstrates how to use Composio SDK for session-management.
+
+## Setup
+
+1. **Install dependencies:**
+ ```bash
+ pnpm install
+ ```
+
+2. **Configure environment:**
+ ```bash
+ cp .env.example .env
+ ```
+
+ Then edit `.env` and add your API keys:
+ - `COMPOSIO_API_KEY`: Get it from [Composio Dashboard](https://app.composio.dev)
+
+## Running the Example
+
+```bash
+# Run the example
+pnpm start
+
+# Run in development mode (with file watching)
+pnpm dev
+```
+
+## What This Example Does
+
+- Initializes Composio SDK
+- Fetches available tools
+- Demonstrates basic usage patterns
+
+## Customization
+
+Edit `src/index.ts` to:
+- Add specific apps you want to integrate with
+- Implement your business logic
+- Add error handling and logging
+
+## Related Examples
+
+- [OpenAI Example](../openai) - Shows integration with OpenAI
+- [LangChain Example](../langchain) - Shows integration with LangChain
+- [More Examples](../) - Browse all available examples
+
+## Support
+
+- [Documentation](https://docs.composio.dev)
+- [Discord Community](https://discord.gg/composio)
+- [GitHub Issues](https://github.com/composio/composio/issues)
diff --git a/examples/session-management/package.json b/examples/session-management/package.json
new file mode 100644
index 000000000..dfe547e75
--- /dev/null
+++ b/examples/session-management/package.json
@@ -0,0 +1,24 @@
+{
+ "name": "session-management-example",
+ "private": true,
+ "version": "0.1.0",
+ "description": "Example project for Session-management",
+ "main": "src/index.ts",
+ "scripts": {
+ "start": "bun src/index.ts",
+ "dev": "bun --watch src/index.ts",
+ "test": "echo \"Error: no test specified\" && exit 1"
+ },
+ "keywords": ["composio", "example", "session-management"],
+ "author": "",
+ "license": "ISC",
+ "packageManager": "[email protected]",
+ "dependencies": {
+ "@composio/core": "workspace:*",
+ "dotenv": "^16.4.1"
+ },
+ "devDependencies": {
+ "@types/bun": "^1.2.9",
+ "typescript": "^5.8.3"
+ }
+}
diff --git a/examples/session-management/src/index.ts b/examples/session-management/src/index.ts
new file mode 100644
index 000000000..270131e72
--- /dev/null
+++ b/examples/session-management/src/index.ts
@@ -0,0 +1,44 @@
+/**
+ * Session-management Example
+ *
+ * This example demonstrates how to use Composio SDK for session-management.
+ *
+ * Prerequisites:
+ * 1. Set up your COMPOSIO_API_KEY in the .env file
+ * 3. Run the example: pnpm start
+ */
+
+import { Composio } from '@composio/core';
+import 'dotenv/config';
+
+/**
+ * Initialize Composio
+ */
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+});
+
+/**
+ * Main function to run the example
+ */
+async function main() {
+ try {
+ console.log('🚀 Starting Session-management Example...');
+
+ // create a session with custom request options
+ const session = composio.createSession({
+ headers: {
+ 'x-request-id': 'custom-value',
+ },
+ });
+
+ // use the session to make API calls
+ const tools = await session.tools.get('default', 'HACKERNEWS_GET_USER');
+ console.log(`✅ Found ${tools.length} tools`);
+ } catch (error) {
+ console.error('❌ Error running example:', error);
+ }
+}
+
+// Run the example
+main().catch(console.error);
diff --git a/examples/session-management/tsconfig.json b/examples/session-management/tsconfig.json
new file mode 100644
index 000000000..158c157c8
--- /dev/null
+++ b/examples/session-management/tsconfig.json
@@ -0,0 +1,16 @@
+{
+ "compilerOptions": {
+ "target": "ESNext",
+ "module": "ESNext",
+ "declaration": true,
+ "declarationDir": "./dist",
+ "outDir": "./dist",
+ "rootDir": "./src",
+ "strict": true,
+ "esModuleInterop": true,
+ "moduleResolution": "node",
+ "skipLibCheck": true,
+ "resolveJsonModule": true
+ },
+ "include": ["src"]
+}
diff --git a/packages/core/package.json b/packages/core/package.json
index 4944f1049..1209f4133 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -36,7 +36,7 @@
"vitest": "^3.1.4"
},
"dependencies": {
- "@composio/client": "0.1.0-alpha.15",
+ "@composio/client": "0.1.0-alpha.16",
"chalk": "^5.4.1",
"openai": "^4.94.0",
"pusher-js": "^8.4.0",
diff --git a/packages/core/src/composio.ts b/packages/core/src/composio.ts
index 60c36256f..47ed9a183 100644
--- a/packages/core/src/composio.ts
+++ b/packages/core/src/composio.ts
@@ -14,7 +14,8 @@ import { checkForLatestVersionFromNPM } from './utils/version';
import { OpenAIProvider } from './provider/OpenAIProvider';
import { version } from '../package.json';
import { getRandomUUID } from './utils/uuid';
-import { MergedRequestInit } from '@composio/client/internal/types';
+import type { ComposioRequestHeaders } from './types/composio.types';
+import { LogLevel } from '@composio/client/client';
export type ComposioConfig<
TProvider extends BaseComposioProvider<unknown, unknown> = OpenAIProvider,
@@ -25,7 +26,19 @@ export type ComposioConfig<
allowTracing?: boolean;
provider?: TProvider;
telemetryTransport?: BaseTelemetryTransport;
- fetchOptions?: MergedRequestInit;
+ /**
+ * Request options to be passed to the Composio API client.
+ * This is useful for passing in a custom fetch implementation.
+ * @example
+ * ```typescript
+ * const composio = new Composio({
+ * defaultHeaders: {
+ * 'x-request-id': '1234567890',
+ * },
+ * });
+ * ```
+ */
+ defaultHeaders?: ComposioRequestHeaders;
};
/**
@@ -59,10 +72,10 @@ export class Composio<TProvider extends BaseComposioProvider<unknown, unknown> =
/**
* Creates a new instance of the Composio SDK.
- *
+ *
* The constructor initializes the SDK with the provided configuration options,
* sets up the API client, and initializes all core models (tools, toolkits, etc.).
- *
+ *
* @param {ComposioConfig<TProvider>} config - Configuration options for the Composio SDK
* @param {string} [config.apiKey] - The API key for authenticating with the Composio API
* @param {string} [config.baseURL] - The base URL for the Composio API (defaults to production URL)
@@ -70,18 +83,18 @@ export class Composio<TProvider extends BaseComposioProvider<unknown, unknown> =
* @param {boolean} [config.allowTracing=true] - Whether to allow request tracing for debugging
* @param {TProvider} [config.provider] - The provider to use for this Composio instance (defaults to OpenAIProvider)
* @param {BaseTelemetryTransport} [config.telemetryTransport] - Custom telemetry transport implementation
- *
+ *
* @example
* ```typescript
* // Initialize with default configuration
* const composio = new Composio();
- *
+ *
* // Initialize with custom API key and base URL
* const composio = new Composio({
* apiKey: 'your-api-key',
* baseURL: 'https://api.composio.dev'
* });
- *
+ *
* // Initialize with custom provider
* const composio = new Composio({
* apiKey: 'your-api-key',
@@ -106,7 +119,8 @@ export class Composio<TProvider extends BaseComposioProvider<unknown, unknown> =
this.client = new ComposioClient({
apiKey: apiKeyParsed,
baseURL: baseURLParsed,
- fetchOptions: config?.fetchOptions,
+ defaultHeaders: config?.defaultHeaders,
+ logLevel: (process.env.COMPOSIO_LOG_LEVEL as LogLevel) ?? undefined,
});
/**
@@ -171,4 +185,45 @@ export class Composio<TProvider extends BaseComposioProvider<unknown, unknown> =
}
return this.client;
}
+
+ /**
+ * Creates a new instance of the Composio SDK with custom request options while preserving the existing configuration.
+ * This method is particularly useful when you need to:
+ * - Add custom headers for specific requests
+ * - Track request contexts with unique identifiers
+ * - Override default request behavior for a subset of operations
+ *
+ * The new instance inherits all configuration from the parent instance (apiKey, baseURL, provider, etc.)
+ * but allows you to specify custom request options that will be used for all API calls made through this session.
+ *
+ * @param {MergedRequestInit} fetchOptions - Custom request options to be used for all API calls in this session.
+ * This follows the Fetch API RequestInit interface with additional options.
+ * @returns {Composio<TProvider>} A new Composio instance with the custom request options applied.
+ *
+ * @example
+ * ```typescript
+ * // Create a base Composio instance
+ * const composio = new Composio({
+ * apiKey: 'your-api-key'
+ * });
+ *
+ * // Create a session with request tracking headers
+ * const composioWithCustomHeaders = composio.createSession({
+ * headers: {
+ * 'x-request-id': '1234567890',
+ * 'x-correlation-id': 'session-abc-123',
+ * 'x-custom-header': 'custom-value'
+ * }
+ * });
+ *
+ * // Use the session for making API calls with the custom headers
+ * await composioWithCustomHeaders.tools.list();
+ * ```
+ */
+ createSession(options?: { headers?: ComposioRequestHeaders }): Composio<TProvider> {
+ return new Composio({
+ ...this.config,
+ defaultHeaders: options?.headers,
+ });
+ }
}
diff --git a/packages/core/src/models/AuthConfigs.ts b/packages/core/src/models/AuthConfigs.ts
index 294b4cfbf..0a785ddda 100644
--- a/packages/core/src/models/AuthConfigs.ts
+++ b/packages/core/src/models/AuthConfigs.ts
@@ -171,7 +171,21 @@ export class AuthConfigs {
toolkit: {
slug: toolkit,
},
- auth_config: parsedOptions.data,
+ auth_config:
+ parsedOptions.data.type === 'use_custom_auth'
+ ? {
+ type: parsedOptions.data.type,
+ name: parsedOptions.data.name,
+ authScheme: parsedOptions.data.authScheme,
+ credentials: parsedOptions.data.credentials,
+ restrict_to_following_tools: parsedOptions.data.restrictToFollowingTools,
+ }
+ : {
+ type: parsedOptions.data.type,
+ credentials: parsedOptions.data.credentials,
+ name: parsedOptions.data.name,
+ restrict_to_following_tools: parsedOptions.data.restrictToFollowingTools,
+ },
});
const parsedResult = CreateAuthConfigResponseSchema.safeParse({
id: result.auth_config.id,
diff --git a/packages/core/src/models/ConnectedAccounts.ts b/packages/core/src/models/ConnectedAccounts.ts
index 4498b6636..6b2f61d27 100644
--- a/packages/core/src/models/ConnectedAccounts.ts
+++ b/packages/core/src/models/ConnectedAccounts.ts
@@ -12,13 +12,10 @@ import {
ConnectedAccountUpdateStatusParams,
ConnectedAccountUpdateStatusResponse,
ConnectedAccountListParams as ConnectedAccountListParamsRaw,
- ConnectedAccountRetrieveResponse as ConnectedAccountRetrieveResponseRaw,
- ConnectedAccountListResponse as ConnectedAccountListResponseRaw,
} from '@composio/client/resources/connected-accounts';
import {
CreateConnectedAccountOptions,
ConnectedAccountRetrieveResponse,
- ConnectedAccountRetrieveResponseSchema,
ConnectedAccountListParams,
ConnectedAccountListParamsSchema,
ConnectedAccountListResponse,
@@ -27,6 +24,7 @@ import {
import { ConnectionRequest } from './ConnectionRequest';
import { ValidationError } from '../errors/ValidationErrors';
import { telemetry } from '../telemetry/Telemetry';
+import { transformConnectedAccountResponse } from '../utils/transformers/connectedAccounts';
/**
* ConnectedAccounts class
*
@@ -41,32 +39,6 @@ export class ConnectedAccounts {
telemetry.instrument(this);
}
- transformConnectedAccountRetrieveResponse(
- response: ConnectedAccountRetrieveResponseRaw | ConnectedAccountListResponseRaw['items'][0]
- ): ConnectedAccountRetrieveResponse {
- const result = ConnectedAccountRetrieveResponseSchema.safeParse({
- ...response,
- userId: response.user_id, // Add the missing userId property
- authConfig: {
- ...response.auth_config,
- authScheme: response.auth_config.auth_scheme,
- isComposioManaged: response.auth_config.is_composio_managed,
- isDisabled: response.auth_config.is_disabled,
- },
- statusReason: response.status_reason,
- isDisabled: response.is_disabled,
- createdAt: response.created_at,
- updatedAt: response.updated_at,
- testRequestEndpoint: response.test_request_endpoint,
- });
- if (!result.success) {
- throw new ValidationError('Failed to parse connected account retrieve response', {
- cause: result.error,
- });
- }
- return result.data;
- }
-
/**
* Lists all connected accounts based on provided filter criteria.
*
@@ -116,7 +88,7 @@ export class ConnectedAccounts {
const result = await this.client.connectedAccounts.list(rawQuery);
const parsedResponse = ConnectedAccountListResponseSchema.safeParse({
- items: result.items.map(this.transformConnectedAccountRetrieveResponse),
+ items: result.items.map(transformConnectedAccountResponse),
nextCursor: result.next_cursor,
totalPages: result.total_pages,
});
@@ -128,24 +100,6 @@ export class ConnectedAccounts {
return parsedResponse.data;
}
- /**
- * Transforms connected account data from API format to SDK format.
- *
- * This method converts property names from snake_case to camelCase and reorganizes
- * the data structure to match the SDK's standardized format for connected accounts.
- *
- * @param {ConnectedAccountRetrieveResponseRaw} response - The raw API response to transform
- * @returns {ConnectedAccountRetrieveResponse} The transformed connected account data
- * @throws {ValidationError} If the response fails validation against the expected schema
- *
- * @private
- */
- transformConnectedAccountResponse(
- response: ConnectedAccountRetrieveResponseRaw
- ): ConnectedAccountRetrieveResponse {
- return this.transformConnectedAccountRetrieveResponse(response);
- }
-
/**
* Compound function to create a new connected account.
* This function creates a new connected account and returns a connection request.
@@ -174,12 +128,22 @@ export class ConnectedAccounts {
id: authConfigId,
},
connection: {
- data: options?.data,
+ state: options?.state,
callback_url: options?.callbackUrl,
user_id: userId,
},
});
- return new ConnectionRequest(this.client, response.id, response.status, response.redirect_url);
+ const redirectUrl =
+ typeof response.connectionData?.val?.redirectUrl === 'string'
+ ? response.connectionData.val.redirectUrl
+ : null;
+
+ return new ConnectionRequest(
+ this.client,
+ response.id,
+ response.connectionData.val.status,
+ redirectUrl
+ );
}
/**
@@ -232,7 +196,7 @@ export class ConnectedAccounts {
*/
async get(nanoid: string): Promise<ConnectedAccountRetrieveResponse> {
const response = await this.client.connectedAccounts.retrieve(nanoid);
- return this.transformConnectedAccountResponse(response);
+ return transformConnectedAccountResponse(response);
}
/**
@@ -280,14 +244,14 @@ export class ConnectedAccounts {
* @param {string} nanoid - Unique identifier of the connected account
* @param {ConnectedAccountUpdateStatusParams} params - Parameters for updating the status
* @returns {Promise<ConnectedAccountUpdateStatusResponse>} Updated connected account details
- *
+ *
* @example
* ```typescript
* // Enable a connected account
* const updatedAccount = await composio.connectedAccounts.updateStatus('conn_abc123', {
* enabled: true
* });
- *
+ *
* // Disable a connected account with a reason
* const disabledAccount = await composio.connectedAccounts.updateStatus('conn_abc123', {
* enabled: false,
@@ -306,7 +270,7 @@ export class ConnectedAccounts {
* Enable a connected account
* @param {string} nanoid - Unique identifier of the connected account
* @returns {Promise<ConnectedAccountUpdateStatusResponse>} Updated connected account details
- *
+ *
* @example
* ```typescript
* // Enable a previously disabled connected account
@@ -322,13 +286,13 @@ export class ConnectedAccounts {
* Disable a connected account
* @param {string} nanoid - Unique identifier of the connected account
* @returns {Promise<ConnectedAccountUpdateStatusResponse>} Updated connected account details
- *
+ *
* @example
* ```typescript
* // Disable a connected account
* const disabledAccount = await composio.connectedAccounts.disable('conn_abc123');
* console.log(disabledAccount.isDisabled); // true
- *
+ *
* // You can also use updateStatus with a reason
* // const disabledAccount = await composio.connectedAccounts.updateStatus('conn_abc123', {
* // enabled: false,
diff --git a/packages/core/src/models/ConnectionRequest.ts b/packages/core/src/models/ConnectionRequest.ts
index c5d719dbc..bd6af95d1 100644
--- a/packages/core/src/models/ConnectionRequest.ts
+++ b/packages/core/src/models/ConnectionRequest.ts
@@ -10,17 +10,14 @@ import {
ConnectedAccountStatus,
ConnectedAccountStatuses,
ConnectedAccountRetrieveResponse,
- ConnectedAccountRetrieveResponseSchema,
} from '../types/connectedAccounts.types';
-import { ConnectedAccountRetrieveResponse as OriginalConnectedAccountResponse } from '@composio/client/resources/connected-accounts';
-import { ZodError } from 'zod';
-import logger from '../utils/logger';
import {
ConnectionRequestFailedError,
ConnectionRequestTimeoutError,
} from '../errors/ConnectionRequestErrors';
import { ComposioConnectedAccountNotFoundError } from '../errors/ConnectedAccountsErrors';
import { telemetry } from '../telemetry/Telemetry';
+import { transformConnectedAccountResponse } from '../utils/transformers/connectedAccounts';
export class ConnectionRequest {
private client: ComposioClient;
public id: string;
@@ -40,47 +37,6 @@ export class ConnectionRequest {
telemetry.instrument(this);
}
- /**
- * Transforms the raw connected account response from the Composio API to the SDK format.
- *
- * This method converts property names from snake_case to camelCase and reorganizes
- * the data structure to match the SDK's standardized format.
- *
- * @param {OriginalConnectedAccountResponse} response - The raw API response to transform
- * @returns {Promise<ConnectedAccountRetrieveResponse>} The transformed response
- * @throws {ZodError} If the response fails validation against the expected schema
- *
- * @private
- */
- private async transformResponse(
- response: OriginalConnectedAccountResponse
- ): Promise<ConnectedAccountRetrieveResponse> {
- try {
- const parsedResponse = ConnectedAccountRetrieveResponseSchema.parse({
- ...response,
- userId: response.user_id, // Add the missing userId property
- authConfig: {
- ...response.auth_config,
- authScheme: response.auth_config.auth_scheme,
- isComposioManaged: response.auth_config.is_composio_managed,
- isDisabled: response.auth_config.is_disabled,
- },
- statusReason: response.status_reason,
- isDisabled: response.is_disabled,
- createdAt: response.created_at,
- updatedAt: response.updated_at,
- testRequestEndpoint: response.test_request_endpoint,
- });
- return parsedResponse;
- } catch (error) {
- logger.error('Error transforming response', error);
- if (error instanceof ZodError) {
- logger.error(JSON.stringify(error.errors, null, 2));
- }
- throw error;
- }
- }
-
/**
* Waits for the connection request to complete and become active.
*
@@ -112,7 +68,7 @@ export class ConnectionRequest {
const response = await this.client.connectedAccounts.retrieve(this.id);
if (response.status === ConnectedAccountStatuses.ACTIVE) {
this.status = ConnectedAccountStatuses.ACTIVE;
- return this.transformResponse(response);
+ return transformConnectedAccountResponse(response);
}
} catch (error) {
if (error instanceof ComposioClient.NotFoundError) {
@@ -143,7 +99,7 @@ export class ConnectionRequest {
this.status = response.status;
if (response.status === ConnectedAccountStatuses.ACTIVE) {
- return this.transformResponse(response);
+ return transformConnectedAccountResponse(response);
}
if (terminalErrorStates.includes(response.status)) {
@@ -151,7 +107,6 @@ export class ConnectionRequest {
`Connection request failed with status: ${response.status}${response.status_reason ? `, reason: ${response.status_reason}` : ''}`,
{
meta: {
- userId: response.user_id,
connectedAccountId: this.id,
status: response.status,
statusReason: response.status_reason,
diff --git a/packages/core/src/models/Tools.ts b/packages/core/src/models/Tools.ts
index b881e7e93..82de4ceaa 100644
--- a/packages/core/src/models/Tools.ts
+++ b/packages/core/src/models/Tools.ts
@@ -549,7 +549,7 @@ export class Tools<
connected_account_id: body.connectedAccountId,
custom_auth_params: body.customAuthParams,
arguments: body.arguments,
- entity_id: body.userId,
+ user_id: body.userId,
version: body.version,
text: body.text,
});
diff --git a/packages/core/src/models/Triggers.ts b/packages/core/src/models/Triggers.ts
index 6c6267177..e2b4c313e 100644
--- a/packages/core/src/models/Triggers.ts
+++ b/packages/core/src/models/Triggers.ts
@@ -171,15 +171,15 @@ export class Triggers {
/**
* Update an existing trigger instance
*
- * @param {string} slug - The slug of the trigger instance
- * @param {TriggerInstanceManageUpdateParams} body - The parameters to create the trigger instance
- * @returns {Promise<TriggerInstanceUpsertResponse>} The updated trigger instance
+ * @param {string} triggerId - The Id of the trigger instance
+ * @param {TriggerInstanceManageUpdateParams} body - The parameters to update the trigger instance
+ * @returns {Promise<TriggerInstanceManageUpdateResponse>} The updated trigger instance response
*/
async update(
- slug: string,
+ triggerId: string,
body: TriggerInstanceManageUpdateParams
): Promise<TriggerInstanceManageUpdateResponse> {
- return this.client.triggerInstances.manage.update(slug, body);
+ return this.client.triggerInstances.manage.update(triggerId, body);
}
/**
diff --git a/packages/core/src/types/authConfigs.types.ts b/packages/core/src/types/authConfigs.types.ts
index 76c4a4085..3c4ea3df6 100644
--- a/packages/core/src/types/authConfigs.types.ts
+++ b/packages/core/src/types/authConfigs.types.ts
@@ -26,7 +26,6 @@ export type AuthSchemeType = (typeof AuthSchemeTypes)[keyof typeof AuthSchemeTyp
export const AuthSchemeEnum = z.enum([
'OAUTH2',
'OAUTH1',
- 'OAUTH1A',
'API_KEY',
'BASIC',
'BILLCOM_AUTH',
@@ -43,12 +42,14 @@ export const CreateCustomAuthConfigParamsSchema = z.object({
name: z.string().optional(),
credentials: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
authScheme: AuthSchemeEnum,
+ restrictToFollowingTools: z.array(z.string()).optional(),
});
export const CreateComposioManagedAuthConfigParamsSchema = z.object({
type: z.literal('use_composio_managed_auth'),
name: z.string().optional(),
credentials: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+ restrictToFollowingTools: z.array(z.string()).optional(),
});
/**
diff --git a/packages/core/src/types/composio.types.ts b/packages/core/src/types/composio.types.ts
new file mode 100644
index 000000000..29185d001
--- /dev/null
+++ b/packages/core/src/types/composio.types.ts
@@ -0,0 +1 @@
+export type ComposioRequestHeaders = Record<string, string>;
diff --git a/packages/core/src/types/connectedAccountAuthStates.types.ts b/packages/core/src/types/connectedAccountAuthStates.types.ts
new file mode 100644
index 000000000..72db5b8c6
--- /dev/null
+++ b/packages/core/src/types/connectedAccountAuthStates.types.ts
@@ -0,0 +1,474 @@
+import { z } from 'zod';
+
+export enum ConnectionStatusEnum {
+ INITIALIZING = 'INITIALIZING',
+ INITIATED = 'INITIATED',
+ ACTIVE = 'ACTIVE',
+ FAILED = 'FAILED',
+ EXPIRED = 'EXPIRED',
+}
+
+export const AUTH_MODES_ENUM = {
+ OAUTH2: 'OAUTH2',
+ OAUTH1: 'OAUTH1',
+ API_KEY: 'API_KEY',
+ BASIC: 'BASIC',
+ BILLCOM_AUTH: 'BILLCOM_AUTH',
+ BEARER_TOKEN: 'BEARER_TOKEN',
+ GOOGLE_SERVICE_ACCOUNT: 'GOOGLE_SERVICE_ACCOUNT',
+ NO_AUTH: 'NO_AUTH',
+ BASIC_WITH_JWT: 'BASIC_WITH_JWT',
+ COMPOSIO_LINK_AUTH: 'COMPOSIO_LINK',
+ CALCOM_AUTH: 'CALCOM_AUTH',
+ SNOWFLAKE: 'SNOWFLAKE',
+} as const;
+
+export type AUTH_MODES_ENUM = (typeof AUTH_MODES_ENUM)[keyof typeof AUTH_MODES_ENUM];
+
+export type RedirectableAuthScheme =
+ | (typeof AUTH_MODES_ENUM)['OAUTH1']
+ | (typeof AUTH_MODES_ENUM)['OAUTH2']
+ | (typeof AUTH_MODES_ENUM)['COMPOSIO_LINK_AUTH'];
+
+export const RedirectableAuthSchemeSchema = z.enum([
+ AUTH_MODES_ENUM.OAUTH1,
+ AUTH_MODES_ENUM.OAUTH2,
+ AUTH_MODES_ENUM.COMPOSIO_LINK_AUTH,
+]);
+
+// Define base fields as a Zod object (no baseUrl)
+const BaseSchemeRaw = z.object({
+ // for posthog, freshdesk, zendesk, clickup and others
+ subdomain: z.string().optional(),
+ // for atlassian
+ ['your-domain']: z.string().optional(),
+ // for mixpanel
+ region: z.string().optional(),
+ // for shopify
+ shop: z.string().optional(),
+ // for snowflake
+ account_url: z.string().optional(),
+ // likely pipedrive
+ COMPANYDOMAIN: z.string().optional(),
+ // likely zoho
+ extension: z.string().optional(),
+ // likely formsite
+ form_api_base_url: z.string().optional(),
+ // likely salesforce
+ instanceEndpoint: z.string().optional(),
+ // likely active campaign
+ api_url: z.string().optional(),
+ // for borneo
+ borneo_dashboard_url: z.string().optional(),
+ // for zenrows proxy
+ proxy_username: z.string().optional(),
+ proxy_password: z.string().optional(),
+ // for d2l
+ domain: z.string().optional(),
+ version: z.string().optional(),
+ // for mailchimp
+ dc: z.string().optional(),
+ // for sharepoint
+ site_name: z.string().optional(),
+ // for servicenow
+ instanceName: z.string().optional(),
+ // for netsuite
+ account_id: z.string().optional(),
+ // for custom servers
+ your_server: z.string().optional(),
+ // for ragic
+ server_location: z.string().optional(),
+ // base_url only
+ base_url: z.string().optional(),
+});
+
+// OAUTH2
+export const Oauth2InitiatingConnectionDataSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.INITIALIZING),
+}).catchall(z.unknown());
+
+export const Oauth2InitiatedConnectionDataSchema = Oauth2InitiatingConnectionDataSchema.extend({
+ status: z.literal(ConnectionStatusEnum.INITIATED),
+ code_verifier: z.string().optional(),
+ redirectUrl: z.string(),
+ callback_url: z.string().optional(),
+ finalRedirectUri: z.string().optional(),
+ // previously verification_token, will be sent as verification_token to slack
+ webhook_signature: z.string().optional(),
+}).catchall(z.unknown());
+
+export const Oauth2ActiveConnectionDataSchema = Oauth2InitiatingConnectionDataSchema.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+ access_token: z.string(),
+ id_token: z.string().optional(),
+ token_type: z.string(),
+ refresh_token: z.string().optional(),
+ expires_in: z.number().optional(),
+ scope: z.string().optional(),
+ // previously verification_token, will be sent as verification_token to slack
+ webhook_signature: z.string().optional(),
+ authed_user: z
+ .object({
+ access_token: z.string().optional(),
+ scope: z.string().optional(),
+ })
+ .optional()
+ .describe('for slack user scopes'),
+}).catchall(z.unknown());
+
+export const Oauth2FailedConnectionDataSchema = Oauth2InitiatingConnectionDataSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+}).catchall(z.unknown());
+
+export const Oauth2ExpiredConnectionDataSchema = Oauth2InitiatingConnectionDataSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+}).catchall(z.unknown());
+
+export const Oauth2ConnectionDataSchema = z.discriminatedUnion('status', [
+ Oauth2InitiatingConnectionDataSchema,
+ Oauth2InitiatedConnectionDataSchema,
+ Oauth2ActiveConnectionDataSchema,
+ Oauth2FailedConnectionDataSchema,
+ Oauth2ExpiredConnectionDataSchema,
+]);
+
+export type Oauth2InitiatingConnectionData = z.infer<typeof Oauth2InitiatingConnectionDataSchema>;
+export type Oauth2InitiatedConnectionData = z.infer<typeof Oauth2InitiatedConnectionDataSchema>;
+export type Oauth2ActiveConnectionData = z.infer<typeof Oauth2ActiveConnectionDataSchema>;
+export type Oauth2FailedConnectionData = z.infer<typeof Oauth2FailedConnectionDataSchema>;
+export type Oauth2ExpiredConnectionData = z.infer<typeof Oauth2ExpiredConnectionDataSchema>;
+export type Oauth2ConnectionData = z.infer<typeof Oauth2ConnectionDataSchema>;
+
+// OAUTH1
+export const Oauth1InitiatingConnectionDataSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.INITIALIZING),
+}).catchall(z.unknown());
+
+export const Oauth1InitiatedConnectionDataSchema = Oauth1InitiatingConnectionDataSchema.extend({
+ status: z.literal(ConnectionStatusEnum.INITIATED),
+ oauth_token: z.string(),
+ authUri: z.string(),
+ oauth_token_secret: z.string(),
+ redirectUrl: z.string(),
+ callbackUrl: z.string().optional(),
+}).catchall(z.unknown());
+
+export const Oauth1ActiveConnectionDataSchema = Oauth1InitiatingConnectionDataSchema.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+ oauth_token: z.string(),
+ consumer_key: z.string().optional(),
+ redirectUrl: z.string().optional(),
+ callback_url: z.string().optional(),
+}).catchall(z.unknown());
+
+export const Oauth1FailedConnectionDataSchema = Oauth1InitiatingConnectionDataSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+}).catchall(z.unknown());
+
+export const Oauth1ExpiredConnectionDataSchema = Oauth1InitiatingConnectionDataSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+}).catchall(z.unknown());
+
+export const Oauth1ConnectionDataSchema = z.discriminatedUnion('status', [
+ Oauth1InitiatingConnectionDataSchema,
+ Oauth1InitiatedConnectionDataSchema,
+ Oauth1ActiveConnectionDataSchema,
+ Oauth1FailedConnectionDataSchema,
+ Oauth1ExpiredConnectionDataSchema,
+]);
+
+export type Oauth1InitiatingConnectionData = z.infer<typeof Oauth1InitiatingConnectionDataSchema>;
+export type Oauth1InitiatedConnectionData = z.infer<typeof Oauth1InitiatedConnectionDataSchema>;
+export type Oauth1ActiveConnectionData = z.infer<typeof Oauth1ActiveConnectionDataSchema>;
+export type Oauth1FailedConnectionData = z.infer<typeof Oauth1FailedConnectionDataSchema>;
+export type Oauth1ExpiredConnectionData = z.infer<typeof Oauth1ExpiredConnectionDataSchema>;
+export type Oauth1ConnectionData = z.infer<typeof Oauth1ConnectionDataSchema>;
+
+// COMPOSIO_LINK_AUTH
+const ComposioLinkInitiatingSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.INITIALIZING),
+}).catchall(z.unknown());
+export const ComposioLinkConnectionDataSchema = z.discriminatedUnion('status', [
+ ComposioLinkInitiatingSchema,
+ ComposioLinkInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.INITIATED),
+ redirectUrl: z.string(),
+ }).catchall(z.unknown()),
+ ComposioLinkInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+ }).catchall(z.unknown()),
+ ComposioLinkInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ }).catchall(z.unknown()),
+ ComposioLinkInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+ }).catchall(z.unknown()),
+]);
+
+// BILLCOM_AUTH
+const BillcomAuthInitiatingSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.INITIALIZING),
+}).catchall(z.unknown());
+export const BillcomAuthConnectionDataSchema = z.discriminatedUnion('status', [
+ BillcomAuthInitiatingSchema,
+ BillcomAuthInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.INITIATED),
+ redirectUrl: z.string(),
+ }).catchall(z.unknown()),
+ BillcomAuthInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+ sessionId: z.string(),
+ devKey: z.string(),
+ }).catchall(z.unknown()),
+ BillcomAuthInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ }).catchall(z.unknown()),
+ BillcomAuthInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+ }).catchall(z.unknown()),
+]);
+
+// BASIC_WITH_JWT
+const BasicWithJwtInitiatingSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+ username: z.string(),
+ password: z.string(),
+}).catchall(z.unknown());
+
+export const BasicWithJwtConnectionDataSchema = z.discriminatedUnion('status', [
+ BasicWithJwtInitiatingSchema,
+ BasicWithJwtInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ }).catchall(z.unknown()),
+ BasicWithJwtInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+ }).catchall(z.unknown()),
+]);
+
+// API_KEY
+const ApiKeyInitiatingSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+ api_key: z.string(),
+}).catchall(z.unknown());
+const ApiKeyConnectionDataSchema = z.discriminatedUnion('status', [
+ ApiKeyInitiatingSchema,
+ ApiKeyInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ }).catchall(z.unknown()),
+ ApiKeyInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+ }).catchall(z.unknown()),
+]);
+
+// BASIC
+const BasicInitiatingSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+ username: z.string(),
+ password: z.string(),
+}).catchall(z.unknown());
+const BasicConnectionDataSchema = z.discriminatedUnion('status', [
+ BasicInitiatingSchema,
+ BasicInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ }).catchall(z.unknown()),
+ BasicInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+ }).catchall(z.unknown()),
+]);
+
+// BEARER_TOKEN
+const BearerTokenInitiatingSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+ token: z.string(),
+}).catchall(z.unknown());
+const BearerTokenConnectionDataSchema = z.discriminatedUnion('status', [
+ BearerTokenInitiatingSchema,
+ BearerTokenInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ }).catchall(z.unknown()),
+ BearerTokenInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+ }).catchall(z.unknown()),
+]);
+
+// GOOGLE_SERVICE_ACCOUNT
+const GoogleServiceAccountInitiatingSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+ credentials_json: z.string(),
+}).catchall(z.unknown());
+const GoogleServiceAccountConnectionDataSchema = z.discriminatedUnion('status', [
+ GoogleServiceAccountInitiatingSchema,
+ GoogleServiceAccountInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ }).catchall(z.unknown()),
+ GoogleServiceAccountInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+ }).catchall(z.unknown()),
+]);
+
+// NO_AUTH
+const NoAuthInitiatingSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+}).catchall(z.unknown());
+const NoAuthConnectionDataSchema = z.discriminatedUnion('status', [
+ NoAuthInitiatingSchema,
+ NoAuthInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ }).catchall(z.unknown()),
+ NoAuthInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+ }).catchall(z.unknown()),
+]);
+
+// CALCOM_AUTH
+const CalcomAuthInitiatingSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+}).catchall(z.unknown());
+const CalcomAuthConnectionDataSchema = z.discriminatedUnion('status', [
+ CalcomAuthInitiatingSchema,
+ CalcomAuthInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ }).catchall(z.unknown()),
+ CalcomAuthInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+ }).catchall(z.unknown()),
+]);
+
+// SNOWFLAKE
+const SnowflakeInitiatingSchema = BaseSchemeRaw.extend({
+ status: z.literal(ConnectionStatusEnum.ACTIVE),
+}).catchall(z.unknown());
+const SnowflakeConnectionDataSchema = z.discriminatedUnion('status', [
+ SnowflakeInitiatingSchema,
+ SnowflakeInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.FAILED),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ }).catchall(z.unknown()),
+ SnowflakeInitiatingSchema.extend({
+ status: z.literal(ConnectionStatusEnum.EXPIRED),
+ expired_at: z.string().optional(),
+ }).catchall(z.unknown()),
+]);
+
+export const ConnectionDataSchema = z.discriminatedUnion('authScheme', [
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.OAUTH1),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: Oauth1ConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.OAUTH2),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: Oauth2ConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.COMPOSIO_LINK_AUTH),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: ComposioLinkConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.API_KEY),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: ApiKeyConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.BASIC),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: BasicConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.BEARER_TOKEN),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: BearerTokenConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.GOOGLE_SERVICE_ACCOUNT),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: GoogleServiceAccountConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.NO_AUTH),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: NoAuthConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.CALCOM_AUTH),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: CalcomAuthConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.SNOWFLAKE),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: SnowflakeConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.BILLCOM_AUTH),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: BillcomAuthConnectionDataSchema,
+ }),
+ z.object({
+ authScheme: z.literal(AUTH_MODES_ENUM.BASIC_WITH_JWT),
+ /**
+ * the main connection data discriminated by auth scheme
+ */
+ val: BasicWithJwtConnectionDataSchema,
+ }),
+]);
+
+export type ConnectionData = z.infer<typeof ConnectionDataSchema>;
diff --git a/packages/core/src/types/connectedAccounts.types.ts b/packages/core/src/types/connectedAccounts.types.ts
index 5ffca6d8f..8834d3caf 100644
--- a/packages/core/src/types/connectedAccounts.types.ts
+++ b/packages/core/src/types/connectedAccounts.types.ts
@@ -1,4 +1,5 @@
import { z } from 'zod';
+import { ConnectionDataSchema } from './connectedAccountAuthStates.types';
/**
* Connected Account create parameters
@@ -36,14 +37,16 @@ export const DefaultCreateConnectedAccountParamsSchema = z.object({
id: z.string(),
}),
connection: z.object({
+ state: ConnectionDataSchema.optional(),
data: z.record(z.string(), z.unknown()).optional(),
callback_url: z.string().optional(),
user_id: z.string().optional(),
}),
});
+
export const CreateConnectedAccountOptionsSchema = z.object({
callbackUrl: z.string().optional(),
- data: z.record(z.string(), z.unknown()).optional(),
+ state: ConnectionDataSchema.optional(),
});
export type CreateConnectedAccountOptions = z.infer<typeof CreateConnectedAccountOptionsSchema>;
export type CreateConnectedAccountParams = z.infer<typeof CreateConnectedAccountParamsSchema>;
@@ -97,7 +100,6 @@ export type ConnectedAccountAuthSchemes =
export const ConnectedAccountAuthConfigSchema = z.object({
id: z.string(),
- authScheme: ConnectedAccountAuthSchemesSchema,
isComposioManaged: z.boolean(),
isDisabled: z.boolean(),
});
@@ -105,7 +107,6 @@ export const ConnectedAccountAuthConfigSchema = z.object({
export const ConnectedAccountRetrieveResponseSchema = z.object({
id: z.string(),
authConfig: ConnectedAccountAuthConfigSchema,
- userId: z.string(),
data: z.record(z.string(), z.unknown()),
params: z.record(z.string(), z.unknown()).optional(),
status: ConnectedAccountStatusSchema,
@@ -113,6 +114,7 @@ export const ConnectedAccountRetrieveResponseSchema = z.object({
toolkit: z.object({
slug: z.string(),
}),
+ state: ConnectionDataSchema.optional(),
testRequestEndpoint: z.string().optional(),
isDisabled: z.boolean(),
createdAt: z.string(),
diff --git a/packages/core/src/types/tool.types.ts b/packages/core/src/types/tool.types.ts
index 1fc5bbdb6..e305b6d29 100644
--- a/packages/core/src/types/tool.types.ts
+++ b/packages/core/src/types/tool.types.ts
@@ -184,13 +184,15 @@ export const ToolProxyParamsSchema = z.object({
endpoint: z.string(),
method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']),
body: z.unknown().optional(),
- parameters: z.array(
- z.object({
- in: z.enum(['query', 'header']),
- name: z.string(),
- value: z.union([z.string(), z.number()]),
- })
- ),
+ parameters: z
+ .array(
+ z.object({
+ in: z.enum(['query', 'header']),
+ name: z.string(),
+ value: z.union([z.string(), z.number()]),
+ })
+ )
+ .optional(),
connectedAccountId: z.string().optional(),
});
export type ToolProxyParams = z.infer<typeof ToolProxyParamsSchema>;
diff --git a/packages/core/src/utils/transformers/connectedAccounts.ts b/packages/core/src/utils/transformers/connectedAccounts.ts
new file mode 100644
index 000000000..611b4032e
--- /dev/null
+++ b/packages/core/src/utils/transformers/connectedAccounts.ts
@@ -0,0 +1,48 @@
+import {
+ ConnectedAccountListResponse as RawConnectedAccountListResponse,
+ ConnectedAccountRetrieveResponse as RawConnectedAccountRetrieveResponse,
+} from '@composio/client/resources/connected-accounts';
+import {
+ ConnectedAccountRetrieveResponse,
+ ConnectedAccountRetrieveResponseSchema,
+} from '../../types/connectedAccounts.types';
+import { ValidationError } from '../../errors';
+
+/**
+ * Transforms the raw connected account response from the Composio API to the SDK format.
+ *
+ * This method converts property names from snake_case to camelCase and reorganizes
+ * the data structure to match the SDK's standardized format.
+ *
+ * @param {RawConnectedAccountListResponse['items'][0]|RawConnectedAccountRetrieveResponse} response - The raw API response to transform
+ * @returns {Promise<ConnectedAccountRetrieveResponse>} The transformed response
+ * @throws {ZodError} If the response fails validation against the expected schema
+ *
+ * @private
+ */
+export function transformConnectedAccountResponse(
+ response: RawConnectedAccountRetrieveResponse | RawConnectedAccountListResponse['items'][0]
+): ConnectedAccountRetrieveResponse {
+ const result = ConnectedAccountRetrieveResponseSchema.safeParse({
+ ...response,
+ authConfig: {
+ ...response.auth_config,
+ id: response.auth_config.id,
+ isComposioManaged: response.auth_config.is_composio_managed,
+ isDisabled: response.auth_config.is_disabled,
+ },
+ state: response.state,
+ status: response.status,
+ statusReason: response.status_reason,
+ isDisabled: response.is_disabled,
+ createdAt: response.created_at,
+ updatedAt: response.updated_at,
+ testRequestEndpoint: response.test_request_endpoint,
+ });
+ if (!result.success) {
+ throw new ValidationError('Failed to parse connected account retrieve response', {
+ cause: result.error,
+ });
+ }
+ return result.data;
+}
diff --git a/packages/core/test/connectedAccounts/connectedAccounts.test.ts b/packages/core/test/connectedAccounts/connectedAccounts.test.ts
index ebbec016e..0c955d8b0 100644
--- a/packages/core/test/connectedAccounts/connectedAccounts.test.ts
+++ b/packages/core/test/connectedAccounts/connectedAccounts.test.ts
@@ -5,6 +5,11 @@ import ComposioClient from '@composio/client';
import { ConnectionRequest } from '../../src/models/ConnectionRequest';
import { ConnectedAccountRetrieveResponse } from '@composio/client/resources/connected-accounts.mjs';
import { ComposioConnectedAccountNotFoundError } from '../../src/errors';
+import { ConnectionStatusEnum } from '../../src/types/connectedAccountAuthStates.types';
+import {
+ ConnectedAccountAuthSchemes,
+ ConnectedAccountStatuses,
+} from '../../src/types/connectedAccounts.types';
// Extend the mock client object for ConnectedAccounts testing
const extendedMockClient = {
@@ -77,14 +82,18 @@ describe('ConnectedAccounts', () => {
const userId = 'user_123';
const authConfigId = 'auth_config_123';
const options = {
- data: { name: 'Test Account' },
callbackUrl: 'https://example.com/callback',
};
const mockResponse = {
id: 'conn_123',
- status: 'pending',
- redirect_url: 'https://auth.example.com/connect',
+ connectionData: {
+ val: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ status: 'INITIALIZING',
+ redirectUrl: 'https://auth.example.com/connect',
+ },
+ },
};
extendedMockClient.connectedAccounts.create.mockResolvedValueOnce(mockResponse);
@@ -96,7 +105,7 @@ describe('ConnectedAccounts', () => {
id: authConfigId,
},
connection: {
- data: options.data,
+ state: undefined,
callback_url: options.callbackUrl,
user_id: userId,
},
@@ -104,19 +113,29 @@ describe('ConnectedAccounts', () => {
expect(connectionRequest).toBeInstanceOf(ConnectionRequest);
expect(connectionRequest).toHaveProperty('id', mockResponse.id);
- expect(connectionRequest).toHaveProperty('status', mockResponse.status);
- expect(connectionRequest).toHaveProperty('redirectUrl', mockResponse.redirect_url);
+ expect(connectionRequest).toHaveProperty('status', mockResponse.connectionData.val.status);
+ expect(connectionRequest).toHaveProperty(
+ 'redirectUrl',
+ mockResponse.connectionData.val.redirectUrl
+ );
extendedMockClient.connectedAccounts.retrieve.mockResolvedValueOnce({
id: 'nanoid',
- status: 'ACTIVE',
+ status: ConnectedAccountStatuses.ACTIVE,
auth_scopes: ['read:user', 'write:user'],
auth_config: {
id: authConfigId,
- auth_scheme: 'OAUTH2',
is_composio_managed: true,
is_disabled: false,
},
+ state: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ val: {
+ status: ConnectedAccountStatuses.ACTIVE,
+ access_token: 'access_token_123',
+ token_type: 'Bearer',
+ },
+ },
user_id: userId,
data: {},
params: {},
@@ -134,6 +153,10 @@ describe('ConnectedAccounts', () => {
expect(extendedMockClient.connectedAccounts.retrieve).toHaveBeenCalledWith(mockResponse.id);
expect(connectedAccount).toHaveProperty('id', 'nanoid');
expect(connectedAccount).toHaveProperty('status', 'ACTIVE');
+ expect(connectedAccount).toHaveProperty(
+ 'state.authScheme',
+ ConnectedAccountAuthSchemes.OAUTH2
+ );
});
it('should work without optional parameters', async () => {
@@ -142,8 +165,12 @@ describe('ConnectedAccounts', () => {
const mockResponse = {
id: 'conn_123',
- status: 'pending',
- callback_url: 'https://auth.example.com/connect',
+ connectionData: {
+ val: {
+ status: 'INITIALIZING',
+ redirectUrl: null,
+ },
+ },
};
extendedMockClient.connectedAccounts.create.mockResolvedValueOnce(mockResponse);
@@ -155,7 +182,7 @@ describe('ConnectedAccounts', () => {
id: authConfigId,
},
connection: {
- data: undefined,
+ state: undefined,
callback_url: undefined,
user_id: userId,
},
@@ -174,10 +201,17 @@ describe('ConnectedAccounts', () => {
auth_scopes: ['read:user', 'write:user'],
auth_config: {
id: 'test-auth-config',
- auth_scheme: 'OAUTH2',
is_composio_managed: true,
is_disabled: false,
},
+ state: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ val: {
+ status: 'ACTIVE',
+ access_token: 'access_token_123',
+ token_type: 'Bearer',
+ },
+ },
user_id: 'user_123',
data: {},
params: {},
@@ -200,11 +234,17 @@ describe('ConnectedAccounts', () => {
status: 'ACTIVE',
authConfig: {
id: 'test-auth-config',
- authScheme: 'OAUTH2',
isComposioManaged: true,
isDisabled: false,
},
- userId: 'user_123',
+ state: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ val: {
+ status: 'ACTIVE',
+ access_token: 'access_token_123',
+ token_type: 'Bearer',
+ },
+ },
data: {},
params: {},
statusReason: null,
@@ -303,14 +343,22 @@ describe('ConnectedAccounts', () => {
const authConfigId = 'auth_config_123';
const mockGetResponse = {
id: nanoid,
- status: 'PENDING',
+ status: ConnectedAccountStatuses.INITIALIZING,
auth_scopes: ['read:user', 'write:user'],
auth_config: {
id: authConfigId,
- auth_scheme: 'OAUTH2',
+ auth_scheme: ConnectedAccountAuthSchemes.OAUTH2,
is_composio_managed: true,
is_disabled: false,
},
+ state: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ val: {
+ status: ConnectedAccountStatuses.INITIALIZING,
+ access_token: 'access_token_123',
+ token_type: 'Bearer',
+ },
+ },
user_id: 'user_123',
data: {},
params: {},
@@ -325,7 +373,15 @@ describe('ConnectedAccounts', () => {
const mockActiveResponse = {
...mockGetResponse,
- status: 'ACTIVE',
+ status: ConnectedAccountStatuses.ACTIVE,
+ state: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ val: {
+ status: ConnectedAccountStatuses.ACTIVE,
+ access_token: 'access_token_123',
+ token_type: 'Bearer',
+ },
+ },
} as unknown as ConnectedAccountRetrieveResponse;
// Mock the get method first call
@@ -336,9 +392,33 @@ describe('ConnectedAccounts', () => {
const result = await connectedAccounts.waitForConnection(nanoid);
expect(extendedMockClient.connectedAccounts.retrieve).toHaveBeenCalledWith(nanoid);
- expect(result).toEqual(
- connectedAccounts.transformConnectedAccountResponse(mockActiveResponse)
- );
+ expect(result).toEqual({
+ id: nanoid,
+ status: ConnectedAccountStatuses.ACTIVE,
+ authConfig: {
+ id: 'auth_config_123',
+ isComposioManaged: true,
+ isDisabled: false,
+ },
+ state: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ val: {
+ status: ConnectedAccountStatuses.ACTIVE,
+ access_token: 'access_token_123',
+ token_type: 'Bearer',
+ },
+ },
+ data: {},
+ params: {},
+ statusReason: null,
+ isDisabled: false,
+ createdAt: '2023-01-01T00:00:00Z',
+ updatedAt: '2023-01-01T00:00:00Z',
+ toolkit: {
+ slug: 'test-toolkit',
+ },
+ testRequestEndpoint: undefined,
+ });
});
it('should throw ComposioConnectedAccountNotFoundError if connected account does not exist', async () => {
@@ -360,13 +440,20 @@ describe('ConnectedAccounts', () => {
const timeout = 30000;
const mockGetResponse = {
id: nanoid,
- status: 'PENDING',
+ status: ConnectedAccountStatuses.INITIALIZING,
auth_config: {
id: 'auth_config_123',
- auth_scheme: 'OAUTH2',
is_composio_managed: true,
is_disabled: false,
},
+ state: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ val: {
+ status: ConnectedAccountStatuses.INITIALIZING,
+ access_token: 'access_token_123',
+ token_type: 'Bearer',
+ },
+ },
user_id: 'user_123',
data: {},
params: {},
@@ -383,6 +470,14 @@ describe('ConnectedAccounts', () => {
const mockActiveResponse = {
...mockGetResponse,
status: 'ACTIVE',
+ state: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ val: {
+ status: ConnectedAccountStatuses.ACTIVE,
+ access_token: 'access_token_123',
+ token_type: 'Bearer',
+ },
+ },
} as unknown as ConnectedAccountRetrieveResponse;
extendedMockClient.connectedAccounts.retrieve.mockResolvedValueOnce(mockGetResponse);
@@ -391,9 +486,33 @@ describe('ConnectedAccounts', () => {
const result = await connectedAccounts.waitForConnection(nanoid, timeout);
expect(extendedMockClient.connectedAccounts.retrieve).toHaveBeenCalledWith(nanoid);
- expect(result).toEqual(
- connectedAccounts.transformConnectedAccountResponse(mockActiveResponse)
- );
+ expect(result).toEqual({
+ id: nanoid,
+ status: ConnectedAccountStatuses.ACTIVE,
+ authConfig: {
+ id: 'auth_config_123',
+ isComposioManaged: true,
+ isDisabled: false,
+ },
+ state: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ val: {
+ status: ConnectedAccountStatuses.ACTIVE,
+ access_token: 'access_token_123',
+ token_type: 'Bearer',
+ },
+ },
+ data: {},
+ params: {},
+ statusReason: null,
+ isDisabled: false,
+ createdAt: '2023-01-01T00:00:00Z',
+ updatedAt: '2023-01-01T00:00:00Z',
+ toolkit: {
+ slug: 'test-toolkit',
+ },
+ testRequestEndpoint: undefined,
+ });
});
});
});
diff --git a/packages/core/test/connectedAccounts/connectionRequest.test.ts b/packages/core/test/connectedAccounts/connectionRequest.test.ts
index 583cd8e7a..d440edae6 100644
--- a/packages/core/test/connectedAccounts/connectionRequest.test.ts
+++ b/packages/core/test/connectedAccounts/connectionRequest.test.ts
@@ -2,7 +2,10 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
import { ConnectionRequest } from '../../src/models/ConnectionRequest';
import ComposioClient, { ComposioError } from '@composio/client';
import { ConnectionRequestTimeoutError } from '../../src/errors';
-import { ConnectedAccountStatuses } from '../../src/types/connectedAccounts.types';
+import {
+ ConnectedAccountAuthSchemes,
+ ConnectedAccountStatuses,
+} from '../../src/types/connectedAccounts.types';
// Mock ComposioClient
const mockClient = {
@@ -64,10 +67,17 @@ describe('ConnectionRequest', () => {
status: ConnectedAccountStatuses.ACTIVE,
auth_config: {
id: 'auth_config_123',
- auth_scheme: 'OAUTH2',
is_composio_managed: true,
is_disabled: false,
},
+ state: {
+ authScheme: ConnectedAccountAuthSchemes.OAUTH2,
+ val: {
+ status: 'ACTIVE',
+ access_token: 'access_token_123',
+ token_type: 'Bearer',
+ },
+ },
user_id: 'user_123',
data: {},
params: {},
@@ -88,7 +98,7 @@ describe('ConnectionRequest', () => {
expect(mockClient.connectedAccounts.retrieve).toHaveBeenCalledTimes(1);
expect(result).toHaveProperty('id', connectedAccountId);
expect(result).toHaveProperty('status', ConnectedAccountStatuses.ACTIVE);
- expect(result).toHaveProperty('authConfig.authScheme', 'OAUTH2');
+ expect(result).toHaveProperty('state.authScheme', 'OAUTH2');
});
it('should poll until status becomes ACTIVE', async () => {
@@ -229,11 +239,11 @@ describe('ConnectionRequest', () => {
);
const jsonObj = connectionRequest.toJSON();
-
+
expect(jsonObj).toHaveProperty('id', connectedAccountId);
expect(jsonObj).toHaveProperty('status', ConnectedAccountStatuses.INITIATED);
expect(jsonObj).toHaveProperty('redirectUrl', redirectUrl);
-
+
expect(jsonObj).not.toHaveProperty('client');
});
@@ -247,14 +257,14 @@ describe('ConnectionRequest', () => {
);
const jsonString = connectionRequest.toString();
-
+
expect(() => JSON.parse(jsonString)).not.toThrow();
-
+
const parsedObj = JSON.parse(jsonString);
expect(parsedObj).toHaveProperty('id', connectedAccountId);
expect(parsedObj).toHaveProperty('status', ConnectedAccountStatuses.INITIATED);
expect(parsedObj).toHaveProperty('redirectUrl', redirectUrl);
-
+
expect(jsonString).toContain('\n');
expect(jsonString).toContain(' ');
});
@@ -269,10 +279,10 @@ describe('ConnectionRequest', () => {
);
expect(() => JSON.stringify(connectionRequest)).not.toThrow();
-
+
const stringified = JSON.stringify(connectionRequest);
const parsed = JSON.parse(stringified);
-
+
expect(parsed).toHaveProperty('id', connectedAccountId);
expect(parsed).toHaveProperty('status', ConnectedAccountStatuses.INITIATED);
expect(parsed).toHaveProperty('redirectUrl', redirectUrl);
diff --git a/packages/core/test/core/session.test.ts b/packages/core/test/core/session.test.ts
new file mode 100644
index 000000000..82c93b5b2
--- /dev/null
+++ b/packages/core/test/core/session.test.ts
@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Composio } from '../../src/composio';
+import { MockProvider } from '../utils/mocks/provider.mock';
+
+describe('Composio Session Management', () => {
+ const baseConfig = {
+ apiKey: 'test-api-key',
+ baseURL: 'https://api.test.com',
+ provider: new MockProvider(),
+ allowTracking: false, // disable telemetry for tests
+ allowTracing: false,
+ };
+
+ it('should create a new session with custom headers', () => {
+ const composio = new Composio(baseConfig);
+ const customHeaders = {
+ headers: {
+ 'x-request-id': '1234567890',
+ 'x-correlation-id': 'session-abc-123',
+ 'x-custom-header': 'custom-value',
+ },
+ };
+ const session = composio.createSession(customHeaders);
+ // @ts-expect-error: access private config for test
+ expect(session.config.defaultHeaders).toEqual(customHeaders.headers);
+ // Should preserve other config
+ // @ts-expect-error: access private config for test
+ expect(session.config.apiKey).toBe(baseConfig.apiKey);
+ // Should be a new instance
+ expect(session).not.toBe(composio);
+ // Should have the same provider instance
+ expect(session.provider).toBe(composio.provider);
+ });
+
+ it('should inherit all configuration from the parent instance', () => {
+ const composio = new Composio(baseConfig);
+ const session = composio.createSession();
+ // @ts-expect-error: access private config for test
+ expect(session.config.apiKey).toBe(baseConfig.apiKey);
+ // @ts-expect-error: access private config for test
+ expect(session.config.baseURL).toBe(baseConfig.baseURL);
+ // Should have the same provider instance
+ expect(session.provider).toBe(composio.provider);
+ });
+
+ it('should allow multiple isolated sessions with different headers', () => {
+ const composio = new Composio(baseConfig);
+ const sessionA = composio.createSession({
+ headers: { 'x-user-id': 'user-a', 'x-tenant-id': 'tenant-1' },
+ });
+ const sessionB = composio.createSession({
+ headers: { 'x-user-id': 'user-b', 'x-tenant-id': 'tenant-2' },
+ });
+ // @ts-expect-error: access private config for test
+ expect(sessionA.config.defaultHeaders['x-user-id']).toBe('user-a');
+ // @ts-expect-error: access private config for test
+ expect(sessionB.config.defaultHeaders['x-user-id']).toBe('user-b');
+ // Sessions should be isolated
+ expect(sessionA).not.toBe(sessionB);
+ });
+
+ it('should default to parent config if no defaultHeaders are provided', () => {
+ const composio = new Composio(baseConfig);
+ const session = composio.createSession();
+ // @ts-expect-error: access private config for test
+ expect(session.config.defaultHeaders).toBeUndefined();
+ });
+});
diff --git a/packages/core/test/tools/tools.test.ts b/packages/core/test/tools/tools.test.ts
index c54793131..5f1bdbdc3 100644
--- a/packages/core/test/tools/tools.test.ts
+++ b/packages/core/test/tools/tools.test.ts
@@ -367,7 +367,7 @@ describe('Tools', () => {
connected_account_id: undefined,
custom_auth_params: undefined,
arguments: body.arguments,
- entity_id: body.userId,
+ user_id: body.userId,
version: undefined,
text: undefined,
});
@@ -391,7 +391,7 @@ describe('Tools', () => {
connected_account_id: 'test-connected-account-id',
custom_auth_params: undefined,
arguments: body.arguments,
- entity_id: body.userId,
+ user_id: body.userId,
version: undefined,
text: undefined,
});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 5241634d8..7a1227b15 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -243,6 +243,22 @@ importers:
specifier: ^5.8.3
version: 5.8.3
+ examples/session-management:
+ dependencies:
+ '@composio/core':
+ specifier: workspace:*
+ version: link:../../packages/core
+ dotenv:
+ specifier: ^16.4.1
+ version: 16.5.0
+ devDependencies:
+ '@types/bun':
+ specifier: ^1.2.9
+ version: 1.2.13
+ typescript:
+ specifier: ^5.8.3
+ version: 5.8.3
+
examples/telemetry:
dependencies:
'@ai-sdk/openai':
@@ -331,8 +347,8 @@ importers:
packages/core:
dependencies:
'@composio/client':
- specifier: 0.1.0-alpha.15
- version: 0.1.0-alpha.15
+ specifier: 0.1.0-alpha.16
+ version: 0.1.0-alpha.16
chalk:
specifier: ^5.4.1
version: 5.4.1
@@ -744,8 +760,8 @@ packages:
'@cloudflare/[email protected]':
resolution: {integrity: sha512-KoHFMH04gOXp3KEI+wrFIU+3ZfoSXnwqZTpybNQjalHoN3pWjtWBb/030cCRAZ639YX+DAHAxNF7AvEYGz1oaA==}
- '@composio/[email protected]':
- resolution: {integrity: sha512-fgUx9uo+wWKuS2+WnzqcQsUuID89hD1nqWs9VOCQw/UiRdwNpA0gZdfHAEQEcjPti7wy7mYLOzT9LCVrR+vs7g==}
+ '@composio/[email protected]':
+ resolution: {integrity: sha512-NWHGVzdbPNvrQhFrhUnpEBEuvw2WZDBT3uj3Lw8T3qYa6U4sB35khR/shxLYLq30mmh/G7LHhymSCe8SOas3uA==}
'@esbuild/[email protected]':
resolution: {integrity: sha512-1VCICWypeQKhVbE9oW/sJaAmjLxhVqacdkvPLEjwlttjfwENRSClS8EjBz0KzRyFSCPDIkuXW34Je/vk7zdB7Q==}
@@ -4994,7 +5010,7 @@ snapshots:
'@cloudflare/[email protected]': {}
- '@composio/[email protected]': {}
+ '@composio/[email protected]': {}
'@esbuild/[email protected]':
optional: true
@@ -6765,7 +6781,7 @@ snapshots:
flatted: 3.3.3
pathe: 2.0.3
sirv: 3.0.1
- tinyglobby: 0.2.13
+ tinyglobby: 0.2.14
tinyrainbow: 2.0.0