Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
TypeScript agentic-aiagentsaiai-agentsaiagentsdeveloper-toolsfunction-callinggpt-4javascriptjsllmllmopsmcppythonremote-mcp-serverssetypescript
Feat: Add session management (#25)
Musthaq Ahamad040b5a49f5c9
diff --git a/.changeset/lemon-regions-brush.md b/.changeset/lemon-regions-brush.mdnew file mode 100644index 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 idsdiff --git a/docs/README.md b/docs/README.mdindex 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 Documentationdiff --git a/docs/advanced/session-management.md b/docs/advanced/session-management.mdnew file mode 100644index 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.mdindex 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 StepsNow that you understand the basics, you can:diff --git a/examples/connected-accounts/src/index.ts b/examples/connected-accounts/src/index.tsindex 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.tsindex 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.examplenew file mode 100644index 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_herediff --git a/examples/session-management/README.md b/examples/session-management/README.mdnew file mode 100644index 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.jsonnew file mode 100644index 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.tsnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 AuthSchemeTypexport 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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 testingconst 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.tsindex 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 ComposioClientconst 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.tsnew file mode 100644index 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.tsindex 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.yamlindex 5241634d8..7a1227b15 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -243,6 +243,22 @@ importers:specifier: ^5.8.3version: 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.16chalk:specifier: ^5.4.1version: 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.3pathe: 2.0.3sirv: 3.0.1- tinyglobby: 0.2.13+ tinyglobby: 0.2.14tinyrainbow: 2.0.0vitest: 3.1.4(@types/[email protected])(@vitest/[email protected])([email protected])([email protected])