Changelog

const const session: ToolRouterSession<unknown, unknown, OpenAIProvider>session = await const composio: Composio<OpenAIProvider>composio.Composio<OpenAIProvider>.toolRouter: ToolRouter<unknown, unknown, OpenAIProvider>
Experimental feature, use with caution
@experimentaltoolRouter.ToolRouter<unknown, unknown, OpenAIProvider>.create(userId: string, config?: ToolRouterCreateSessionConfig): Promise<ToolRouterSession<unknown, unknown, OpenAIProvider>>
Creates a new tool router session for a user.
@paramuserId The user id to create the session for@paramconfig The config for the tool router session@returnsThe tool router session@example```typescript
import { Composio } from '@composio/core';

const composio = new Composio();
const userId = 'user_123';

const session = await composio.experimental.create(userId, {
  toolkits: ['gmail'],
  manageConnections: true,
  tools: {
    gmail: {
      disabled: ['gmail_send_email']
    }
  },
  tags: ['readOnlyHint']
});

console.log(session.sessionId);
console.log(session.mcp.url);

// Get tools formatted for your framework (requires provider)
const tools = await session.tools();

// Check toolkit connection states
const toolkits = await session.toolkits();
```create(const userId: "user_123"userId, {
  
manageConnections?: boolean | {
    callbackUrl?: string | undefined;
    enable?: boolean | undefined;
    waitForConnections?: boolean | undefined;
} | undefinedmanageConnections: {
    enable?: boolean | undefinedenable: true,
    callbackUrl?: string | undefinedcallbackUrl: 'https://example.com/callback',
    waitForConnections?: boolean | undefinedwaitForConnections: true  // NEW
  }
});

const const tools: OpenAiToolCollectiontools = await const session: ToolRouterSession<unknown, unknown, OpenAIProvider>session.ToolRouterSession<unknown, unknown, OpenAIProvider>.tools: (modifiers?: SessionMetaToolOptions) => Promise<OpenAiToolCollection>
Get the tools available in the session, formatted for your AI framework.
Requires a provider to be configured in the Composio constructor.tools({
  modifySchema?: TransformToolSchemaModifier | undefined
Function to transform tool schemas before they're exposed to consumers.
This allows customizing input/output parameters, descriptions, and other metadata.modifySchema: ({ toolSlug: stringtoolSlug, toolkitSlug: stringtoolkitSlug, 
schema: {
    slug: string;
    name: string;
    description?: string | undefined;
    inputParameters?: {
        type: "object";
        properties: Record<string, any>;
        description?: string | undefined;
        anyOf?: any[] | undefined;
        oneOf?: any[] | undefined;
        allOf?: any[] | undefined;
        not?: any;
        required?: string[] | undefined;
        title?: string | undefined;
        default?: any;
        nullable?: boolean | undefined;
        additionalProperties?: boolean | undefined;
    } | undefined;
    outputParameters?: {
        type: "object";
        properties: Record<string, any>;
        description?: string | undefined;
        anyOf?: any[] | undefined;
        oneOf?: any[] | undefined;
        allOf?: any[] | undefined;
        not?: any;
        required?: string[] | undefined;
        title?: string | undefined;
        default?: any;
        nullable?: boolean | undefined;
        additionalProperties?: boolean | undefined;
    } | undefined;
    ... 6 more ...;
    isNoAuth?: boolean | undefined;
}schema }) => 
schema: {
    slug: string;
    name: string;
    description?: string | undefined;
    inputParameters?: {
        type: "object";
        properties: Record<string, any>;
        description?: string | undefined;
        anyOf?: any[] | undefined;
        oneOf?: any[] | undefined;
        allOf?: any[] | undefined;
        not?: any;
        required?: string[] | undefined;
        title?: string | undefined;
        default?: any;
        nullable?: boolean | undefined;
        additionalProperties?: boolean | undefined;
    } | undefined;
    outputParameters?: {
        type: "object";
        properties: Record<string, any>;
        description?: string | undefined;
        anyOf?: any[] | undefined;
        oneOf?: any[] | undefined;
        allOf?: any[] | undefined;
        not?: any;
        required?: string[] | undefined;
        title?: string | undefined;
        default?: any;
        nullable?: boolean | undefined;
        additionalProperties?: boolean | undefined;
    } | undefined;
    ... 6 more ...;
    isNoAuth?: boolean | undefined;
}schema,
  beforeExecute?: beforeExecuteMetaModifier | undefined
Function to intercept and modify meta tool execution parameters before the tool is executed.
This allows customizing the request based on session-specific needs.beforeExecute: ({ toolSlug: stringtoolSlug, toolkitSlug: stringtoolkitSlug, sessionId: stringsessionId, params: Record<string, unknown>params }) => params: Record<string, unknown>params,
  afterExecute?: afterExecuteMetaModifier | undefined
Function to intercept and modify meta tool execution responses after the tool has executed.
This allows transforming the response or implementing custom session-specific handling.afterExecute: ({ toolSlug: stringtoolSlug, toolkitSlug: stringtoolkitSlug, sessionId: stringsessionId, 
result: {
    error: string | null;
    data: Record<string, unknown>;
    successful: boolean;
    logId?: string | undefined;
    sessionInfo?: unknown;
}result }) => 
result: {
    error: string | null;
    data: Record<string, unknown>;
    successful: boolean;
    logId?: string | undefined;
    sessionInfo?: unknown;
}result
});

const const metaTools: ToolListmetaTools = await const composio: Composio<OpenAIProvider>composio.Composio<OpenAIProvider>.tools: Tools<unknown, unknown, OpenAIProvider>
List, retrieve, and execute toolstools.Tools<unknown, unknown, OpenAIProvider>.getRawToolRouterMetaTools(sessionId: string, options?: SchemaModifierOptions): Promise<ToolList>
Fetches the meta tools for a tool router session.
This method fetches the meta tools from the Composio API and transforms them to the expected format.
It provides access to the underlying meta tool data without provider-specific wrapping.
@paramsessionId The session id to get the meta tools for@paramoptions Optional configuration for tool retrieval@paramoptions.modifySchema - Function to transform the tool schema@returnsThe list of meta tools@example```typescript
const metaTools = await composio.tools.getRawToolRouterMetaTools('session_123');
console.log(metaTools);
```getRawToolRouterMetaTools('session_123', {
  modifySchema: TransformToolSchemaModifiermodifySchema: ({ toolSlug: stringtoolSlug, toolkitSlug: stringtoolkitSlug, 
schema: {
    slug: string;
    name: string;
    description?: string | undefined;
    inputParameters?: {
        type: "object";
        properties: Record<string, any>;
        description?: string | undefined;
        anyOf?: any[] | undefined;
        oneOf?: any[] | undefined;
        allOf?: any[] | undefined;
        not?: any;
        required?: string[] | undefined;
        title?: string | undefined;
        default?: any;
        nullable?: boolean | undefined;
        additionalProperties?: boolean | undefined;
    } | undefined;
    outputParameters?: {
        type: "object";
        properties: Record<string, any>;
        description?: string | undefined;
        anyOf?: any[] | undefined;
        oneOf?: any[] | undefined;
        allOf?: any[] | undefined;
        not?: any;
        required?: string[] | undefined;
        title?: string | undefined;
        default?: any;
        nullable?: boolean | undefined;
        additionalProperties?: boolean | undefined;
    } | undefined;
    ... 6 more ...;
    isNoAuth?: boolean | undefined;
}schema }) => {
    // Customize schema
    return 
schema: {
    slug: string;
    name: string;
    description?: string | undefined;
    inputParameters?: {
        type: "object";
        properties: Record<string, any>;
        description?: string | undefined;
        anyOf?: any[] | undefined;
        oneOf?: any[] | undefined;
        allOf?: any[] | undefined;
        not?: any;
        required?: string[] | undefined;
        title?: string | undefined;
        default?: any;
        nullable?: boolean | undefined;
        additionalProperties?: boolean | undefined;
    } | undefined;
    outputParameters?: {
        type: "object";
        properties: Record<string, any>;
        description?: string | undefined;
        anyOf?: any[] | undefined;
        oneOf?: any[] | undefined;
        allOf?: any[] | undefined;
        not?: any;
        required?: string[] | undefined;
        title?: string | undefined;
        default?: any;
        nullable?: boolean | undefined;
        additionalProperties?: boolean | undefined;
    } | undefined;
    ... 6 more ...;
    isNoAuth?: boolean | undefined;
}schema;
  }
});

const const response: Responseresponse = await function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)
[MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch)fetch(
  "https://backend.composio.dev/api/v3/org/project/config",
  {
    RequestInit.method?: string | undefined
A string to set request's method.method: "PATCH",
    RequestInit.headers?: HeadersInit | undefined
A Headers object, an object literal, or an array of two-item arrays to set request's headers.headers: {
      "Content-Type": "application/json",
      "x-api-key": "ak_your_api_key"
    },
    RequestInit.body?: BodyInit | null | undefined
A BodyInit object or null to set request's body.body: var JSON: JSON
An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.JSON.JSON.stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string (+1 overload)
Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
@paramvalue A JavaScript value, usually an object or array, to be converted.@paramreplacer A function that transforms the results.@paramspace Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.@throws{TypeError} If a circular reference or a BigInt value is found.stringify({ require_mcp_api_key: booleanrequire_mcp_api_key: true })
  }
);

var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log(await const response: Responseresponse.Body.json(): Promise<any>
[MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/json)json());

// Before (V2)
const const triggerSlug: anytriggerSlug = payload.type;  // "gmail_new_gmail_message"
const const connectionId: anyconnectionId = payload.data.connection_id;
const const triggerId: anytriggerId = payload.data.trigger_id;
const const messageText: anymessageText = payload.data.message_text;

// After (V3)
const const webhookType: anywebhookType = payload.type;  // "composio.trigger.message"
const const triggerSlug: anytriggerSlug = payload.metadata.trigger_slug;  // "GMAIL_NEW_GMAIL_MESSAGE"
const const connectionId: anyconnectionId = payload.metadata.connected_account_id;
const const triggerId: anytriggerId = payload.metadata.trigger_id;
const const messageText: anymessageText = payload.data.message_text;

// This will no longer work
const const toolkits: Responsetoolkits = await function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)
[MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch)fetch('/api/v3/toolkits?is_local=true');

// Simply remove the is_local parameter
const const toolkits: Responsetoolkits = await function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)
[MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch)fetch('/api/v3/toolkits');

const const toolkit: anytoolkit = await composio.toolkits.get('github');
if (const toolkit: anytoolkit.is_local_toolkit) {
  // This condition will never be true
  handleLocalToolkit(const toolkit: anytoolkit);
}

const const toolkit: anytoolkit = await composio.toolkits.get('github');
// Remove is_local_toolkit checks - they're no longer meaningful

// TypeScript - Configure versions at initialization
const const composio: anycomposio = new Composio({
  apiKey: stringapiKey: 'your-api-key',
  
toolkitVersions: {
    gmail: string;
    github: string;
}toolkitVersions: {
    gmail: stringgmail: '12082025_00',
    github: stringgithub: '10082025_01'
  }
});

// Create trigger - uses version '12082025_00' for Gmail
const const trigger: anytrigger = await const composio: anycomposio.triggers.create('user@example.com', 'GMAIL_NEW_MESSAGE', {
  connectedAccountId: stringconnectedAccountId: 'ca_abc123',
  
triggerConfig: {
    labelIds: string;
    userId: string;
    interval: number;
}triggerConfig: {
    labelIds: stringlabelIds: 'INBOX',
    userId: stringuserId: 'me',
    interval: numberinterval: 60,
  },
});

// TypeScript
const const composio: anycomposio = new Composio({
  apiKey: stringapiKey: 'your-api-key',
  
toolkitVersions: {
    github: string;
}toolkitVersions: { github: stringgithub: '10082025_01' }
});

// Get trigger type for specific version
const const triggerType: anytriggerType = await const composio: anycomposio.triggers.getType('GITHUB_COMMIT_EVENT');
// Returns trigger type for version '10082025_01'

// Uses 'latest' version by default
const const trigger: anytrigger = await composio.triggers.create('user', 'GITHUB_COMMIT_EVENT', {...});

// Explicitly configure versions for better control
const const composio: anycomposio = new Composio({
  apiKey: stringapiKey: 'your-api-key',
  
toolkitVersions: {
    github: string;
}toolkitVersions: { github: stringgithub: '10082025_01' }
});

const const trigger: anytrigger = await const composio: anycomposio.triggers.create('user', 'GITHUB_COMMIT_EVENT', {...});

import { class Composio<TProvider extends BaseComposioProvider<unknown, unknown, unknown> = OpenAIProvider>
This is the core class for Composio.
It is used to initialize the Composio SDK and provide a global configuration.Composio } from '@composio/core';

const const composio: Composio<OpenAIProvider>composio = new new Composio<OpenAIProvider>(config?: ComposioConfig<OpenAIProvider> | undefined): Composio<OpenAIProvider>
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.).
@paramconfig - Configuration options for the Composio SDK@paramconfig.apiKey - The API key for authenticating with the Composio API@paramconfig.baseURL - The base URL for the Composio API (defaults to production URL)@paramconfig.allowTracking - Whether to allow anonymous usage analytics@paramconfig.provider - The provider to use for this Composio instance (defaults to OpenAIProvider)@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',
  provider: new CustomProvider()
});
```Composio({
  apiKey?: string | null | undefined
The API key for the Composio API.
@example'sk-1234567890'apiKey: var process: NodeJS.Processprocess.NodeJS.Process.env: NodeJS.ProcessEnv
The `process.env` property returns an object containing the user environment.
See [`environ(7)`](http://man7.org/linux/man-pages/man7/environ.7.html).

An example of this object looks like:

```js
{
  TERM: 'xterm-256color',
  SHELL: '/usr/local/bin/bash',
  USER: 'maciej',
  PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
  PWD: '/Users/maciej',
  EDITOR: 'vim',
  SHLVL: '1',
  HOME: '/Users/maciej',
  LOGNAME: 'maciej',
  _: '/usr/local/bin/node'
}
```

It is possible to modify this object, but such modifications will not be
reflected outside the Node.js process, or (unless explicitly requested)
to other `Worker` threads.
In other words, the following example would not work:

```bash
node -e 'process.env.foo = "bar"' &#x26;&#x26; echo $foo
```

While the following will:

```js
import { env } from 'node:process';

env.foo = 'bar';
console.log(env.foo);
```

Assigning a property on `process.env` will implicitly convert the value
to a string. **This behavior is deprecated.** Future versions of Node.js may
throw an error when the value is not a string, number, or boolean.

```js
import { env } from 'node:process';

env.test = null;
console.log(env.test);
// => 'null'
env.test = undefined;
console.log(env.test);
// => 'undefined'
```

Use `delete` to delete a property from `process.env`.

```js
import { env } from 'node:process';

env.TEST = 1;
delete env.TEST;
console.log(env.TEST);
// => undefined
```

On Windows operating systems, environment variables are case-insensitive.

```js
import { env } from 'node:process';

env.TEST = 1;
console.log(env.test);
// => 1
```

Unless explicitly specified when creating a `Worker` instance,
each `Worker` thread has its own copy of `process.env`, based on its
parent thread's `process.env`, or whatever was specified as the `env` option
to the `Worker` constructor. Changes to `process.env` will not be visible
across `Worker` threads, and only the main thread can make changes that
are visible to the operating system or to native add-ons. On Windows, a copy of `process.env` on a `Worker` instance operates in a case-sensitive manner
unlike the main thread.
@sincev0.1.27env.string | undefinedCOMPOSIO_API_KEY,
});

// Create MCP configuration
const const mcpConfig: MCPConfigCreateResponsemcpConfig = await const composio: Composio<OpenAIProvider>composio.Composio<OpenAIProvider>.mcp: MCP
Model Context Protocol server managementmcp.
MCP.create(name: string, mcpConfig: {
    toolkits: (string | {
        toolkit?: string | undefined;
        authConfigId?: string | undefined;
    })[];
    allowedTools?: string[] | undefined;
    manuallyManageConnections?: boolean | undefined;
}): Promise<MCPConfigCreateResponse>
Create a new MCP configuration.
@paramparams - Parameters for creating the MCP configuration@paramparams.authConfig - Array of auth configurations with id and allowed tools@paramparams.options - Configuration options@paramparams.options.name - Unique name for the MCP configuration@paramparams.options.manuallyManageConnections - Whether to use chat-based authentication or manually connect accounts@returnsCreated server details with instance getter@example```typescript
const server = await composio.mcpConfig.create("personal-mcp-server", {
  toolkits: ["github", "slack"],
  allowedTools: ["GMAIL_FETCH_EMAILS", "SLACK_SEND_MESSAGE"],
  manuallyManageConnections: false
 }
});

const server = await composio.mcpConfig.create("personal-mcp-server", {
  toolkits: [{ toolkit: "gmail", authConfigId: "ac_243434343" }],
  allowedTools: ["GMAIL_FETCH_EMAILS"],
  manuallyManageConnections: false
 }
});
```create('my-server-name', {
  
toolkits: (string | {
    toolkit?: string | undefined;
    authConfigId?: string | undefined;
})[]toolkits: [
    { toolkit?: string | undefinedtoolkit: 'github', authConfigId?: string | undefinedauthConfigId: 'ac_233434343' },
    { toolkit?: string | undefinedtoolkit: 'gmail', authConfigId?: string | undefinedauthConfigId: 'ac_567890123' }
  ],
  allowedTools?: string[] | undefinedallowedTools: ['GITHUB_CREATE_ISSUE', 'GMAIL_SEND_EMAIL'],
  manuallyManageConnections?: boolean | undefinedmanuallyManageConnections: false,
});

// Generate server instance for a user
const 
const serverInstance: {
    name: string;
    type: "streamable_http";
    id: string;
    userId: string;
    allowedTools: string[];
    url: string;
    authConfigs: string[];
}serverInstance = await const composio: Composio<OpenAIProvider>composio.Composio<OpenAIProvider>.mcp: MCP
Model Context Protocol server managementmcp.
MCP.generate(userId: string, mcpConfigId: string, options?: {
    manuallyManageConnections?: boolean | undefined;
}): Promise<{
    name: string;
    type: "streamable_http";
    id: string;
    userId: string;
    allowedTools: string[];
    url: string;
    authConfigs: string[];
}>
Get server URLs for an existing MCP server.
The response is wrapped according to the provider's specifications.
@example```typescript
import { Composio } from "@composio/code";

const composio = new Composio();
const mcp = await composio.experimental.mcp.generate("default", "<mcp_config_id>");
```@paramuserId external user id from your database for whom you want the server for@parammcpConfigId config id of the MCPConfig for which you want to create a server for@paramoptions additional options@paramoptions.isChatAuth Authenticate the users via chat when they use the MCP Servergenerate('user123', const mcpConfig: MCPConfigCreateResponsemcpConfig.id: stringid);
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log('MCP URL:', 
const serverInstance: {
    name: string;
    type: "streamable_http";
    id: string;
    userId: string;
    allowedTools: string[];
    url: string;
    authConfigs: string[];
}serverInstance.url: stringurl);

// Vercel AI Integration
import { class SSEClientTransport
Client transport for SSE: this will connect to a server using Server-Sent Events for receiving
messages and make separate POST requests for sending messages.
@deprecatedSSEClientTransport is deprecated. Prefer to use StreamableHTTPClientTransport where possible instead. Note that because some servers are still using SSE, clients may need to support both transports during the migration period.SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
import { experimental_createMCPClient as import createMCPClientcreateMCPClient } from 'ai';

const const mcpClient: anymcpClient = await import createMCPClientcreateMCPClient({
  name: stringname: 'composio-mcp-client',
  transport: SSEClientTransporttransport: new new SSEClientTransport(url: URL, opts?: SSEClientTransportOptions): SSEClientTransport
Client transport for SSE: this will connect to a server using Server-Sent Events for receiving
messages and make separate POST requests for sending messages.
@deprecatedSSEClientTransport is deprecated. Prefer to use StreamableHTTPClientTransport where possible instead. Note that because some servers are still using SSE, clients may need to support both transports during the migration period.SSEClientTransport(new var URL: new (url: string | URL, base?: string | URL) => URL
The **`URL`** interface is used to parse, construct, normalize, and encode URL.

[MDN Reference](https://developer.mozilla.org/docs/Web/API/URL)URL(serverInstance.url)),
});

// Mastra Integration
import { class MCPClientMCPClient as class MastraMCPClientMastraMCPClient } from '@mastra/mcp';

const const mcpClient: MastraMCPClientmcpClient = new new MastraMCPClient(args: MCPClientOptions): MastraMCPClientMastraMCPClient({
  MCPClientOptions.servers: Record<string, MastraMCPServerDefinition>servers: {
    
composio: {
    url: URL;
}composio: { url: URLurl: new var URL: new (url: string | URL, base?: string | URL) => URL
The **`URL`** interface is used to parse, construct, normalize, and encode URL.

[MDN Reference](https://developer.mozilla.org/docs/Web/API/URL)URL(mcpSession.url) },
  },
});

// OpenAI Agents Integration
import { 
function hostedMcpTool<Context = unknown>(options: {
    allowedTools?: string[] | {
        toolNames?: string[];
    };
} & ({
    serverLabel: string;
    serverUrl?: string;
    authorization?: string;
    headers?: Record<string, string>;
} | {
    serverLabel: string;
    connectorId: string;
    authorization?: string;
    headers?: Record<string, string>;
}) & ({
    requireApproval?: never;
} | {
    requireApproval: "never";
} | {
    requireApproval: "always" | {
        never?: {
            toolNames: string[];
        };
        always?: {
            toolNames: string[];
        };
    };
    onApproval?: HostedMCPApprovalFunction<Context>;
})): HostedMCPTool<Context>
Creates a hosted MCP tool definition.
@paramoptions - Configuration for the hosted MCP tool, including server connection details
and approval requirements.hostedMcpTool } from '@openai/agents';

const const tools: HostedMCPTool<unknown>[]tools = [
  
hostedMcpTool<unknown>(options: {
    allowedTools?: string[] | {
        toolNames?: string[];
    };
} & (({
    serverLabel: string;
    serverUrl?: string;
    authorization?: string;
    headers?: Record<string, string>;
} | {
    serverLabel: string;
    connectorId: string;
    authorization?: string;
    headers?: Record<string, string>;
}) & ({
    requireApproval?: never;
} | {
    requireApproval: "never";
} | {
    requireApproval: "always" | {
        never?: {
            toolNames: string[];
        };
        always?: {
            toolNames: string[];
        };
    };
    onApproval?: HostedMCPApprovalFunction<unknown> | undefined;
}))): HostedMCPTool<...>
Creates a hosted MCP tool definition.
@paramoptions - Configuration for the hosted MCP tool, including server connection details
and approval requirements.hostedMcpTool({
    serverLabel: stringserverLabel: 'composio',
    serverUrl?: string | undefinedserverUrl: mcpSession.url,
  }),
];

// Create session with simple toolkit names
const const session: anysession = await composio.experimental.toolRouter.createSession('user_123', {
  toolkits: string[]toolkits: ['gmail', 'slack', 'github'],
});

// Create session with auth configs
const const session: anysession = await composio.experimental.toolRouter.createSession('user_456', {
  
toolkits: {
    toolkit: string;
    authConfigId: string;
}[]toolkits: [
    { toolkit: stringtoolkit: 'gmail', authConfigId: stringauthConfigId: 'ac_gmail_work' },
    { toolkit: stringtoolkit: 'slack', authConfigId: stringauthConfigId: 'ac_slack_team' },
    { toolkit: stringtoolkit: 'github', authConfigId: stringauthConfigId: 'ac_github_personal' },
  ],
  manuallyManageConnections: booleanmanuallyManageConnections: true,
});

var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log('Session ID:', const session: anysession.sessionId);
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log('MCP URL:', const session: anysession.url);

// Complex workflow session
const const integrationSession: anyintegrationSession = await composio.experimental.toolRouter.createSession('user_789', {
  
toolkits: {
    toolkit: string;
    authConfigId: string;
}[]toolkits: [
    { toolkit: stringtoolkit: 'gmail', authConfigId: stringauthConfigId: 'ac_gmail_work' },
    { toolkit: stringtoolkit: 'slack', authConfigId: stringauthConfigId: 'ac_slack_team' },
    { toolkit: stringtoolkit: 'github', authConfigId: stringauthConfigId: 'ac_github_personal' },
    { toolkit: stringtoolkit: 'notion', authConfigId: stringauthConfigId: 'ac_notion_workspace' },
    { toolkit: stringtoolkit: 'calendar', authConfigId: stringauthConfigId: 'ac_gcal_primary' },
  ],
});

// Use with any MCP client
const const mcpClient: anymcpClient = new MCPClient(const integrationSession: anyintegrationSession.url);

// Mastra Integration
const const mcpSession: anymcpSession = await composio.experimental.toolRouter.createSession(userId, {
  toolkits: string[]toolkits: ["gmail"],
  manuallyManageConnections: booleanmanuallyManageConnections: true,
});

const const agent: anyagent = new MastraAgent({
  name: stringname: 'Gmail Assistant',
  model: anymodel: openai('gpt-4o-mini'),
  tools: anytools: await mcpClient.getTools(),
});

// OpenAI Agents Integration
const const tools: any[]tools = [
  hostedMcpTool({
    serverLabel: stringserverLabel: 'composio tool router',
    serverUrl: anyserverUrl: const mcpSession: anymcpSession.url,
    
requireApproval: {
    never: {
        toolNames: string[];
    };
}requireApproval: {
      
never: {
    toolNames: string[];
}never: { toolNames: string[]toolNames: ['GMAIL_FETCH_EMAILS'] },
    },
  }),
];