Composio — The AI Toolchain

Composio 3.1.0

Fri, 28 Aug 2026 18:29:32 GMT

API surface changed: +2 endpoints, 6 modified • New endpoint GET /api/v3.1/toolkits/{toolkit_slug}/scopes/grant_context • New endpoint POST /api/v3.1/toolkits/{toolkit_slug}/scopes/recommended • GET /api/v3.1/auth_configs: response schema changed • GET /api/v3.1/auth_configs/{nanoid}: response schema changed • GET /api/v3.1/connected_accounts: response schema changed • GET /api/v3.1/connected_accounts/{nanoid}: response schema changed • PATCH /api/v3.1/connected_accounts/{nanoId}/status: response schema changed • POST /api/v3.1/connected_accounts: request body changed; response schema changed

Composio @composio/openai-agents@0.10.2

Thu, 27 Aug 2026 18:24:53 GMT

OpenAI Agents provider gains working `strict: true` mode for structured-output tool registration • Enables OpenAIAgentsProvider({ strict: true }): tools are now registered with `strict: true` and schemas normalized for OpenAI structured outputs (every property required, optional ones accept `null`); `null` arguments rejected by a tool's own schema are dropped before execution; tools whose schemas cannot express strict mode are registered without it and emit a warning. Breaking changes: • Node.js 22.22.3 is now the minimum supported runtime for every published TypeScript package; older Node.js versions will be rejected by package managers before install.

Composio @composio/core@0.18.0

Thu, 27 Aug 2026 18:24:20 GMT

Composio core 0.18.0 exports toStrictJsonSchema() and omitNullToolArguments() for OpenAI strict-mode tool schemas. • Exports new toStrictJsonSchema() utility from `@composio/core` to normalize any tool schema to full OpenAI strict-mode compliance at every depth (nested objects, `anyOf` branches, array items, inlined `$ref`/`$defs`), adding `required` lists and `additionalProperties: false` automatically. • Exports new omitNullToolArguments() utility from `@composio/core` to strip `null` arguments before tool execution when the tool's own schema does not accept them. • Adds a `strict=True` constructor flag to the Python `OpenAIResponsesProvider` that emits `strict: true` on wrapped tools, enabling OpenAI structured-output compliance from the Python SDK. • Tools whose schemas strict mode cannot express (objects with arbitrary keys, `allOf`, `prefixItems`, unresolved `$ref`s) are now forwarded without strict mode and emit a warning naming the tool and path, instead of being silently narrowed or rejected. Breaking changes: • Node.js 22.22.3 is now declared as the minimum supported runtime for every published TypeScript package; package managers will surface incompatible runtimes before installation.

Composio 3.1.0

Thu, 20 Aug 2026 10:00:16 GMT

Composio now publishes an API — 97 endpoints across 17 areas: Tool Router, Mcp, Connected Accounts, … • Tool Router (17 endpoints) — (Labs) Tool router endpoints • Mcp (11 endpoints) — MCP server management • Connected Accounts (10 endpoints) — Connected account management • Projects (8 endpoints) — create, read, delete • Toolkits (8 endpoints) — Toolkit and tool management • Tools (7 endpoints) — Tool execution endpoints • Triggers (7 endpoints) — Trigger management and execution • Webhook Subscriptions (7 endpoints) — Webhook delivery subscriptions. • 9 more areas: Auth Configs, Webhook Endpoints, Authentication, Files, Logs, Organization, Api Keys, Invite Codes, Organization Management

Composio @composio/openai@0.12.0

Tue, 18 Aug 2026 22:39:29 GMT

Composio OpenAI/Anthropic tool-call helpers now route execution through a Tool Router session, with error text preserved in `{ error }` results. • OpenAI and Anthropic provider tool-call helpers can now execute through a supplied Tool Router session, with session meta-tools retaining their session context alongside existing user-ID direct execution. • Anthropic helper failures now preserve error text in `{ error }` results without altering successful payloads. Breaking changes: • Custom provider subclasses overriding `executeToolCall` or `handleToolCalls` may require updates because these methods now accept session targets.

Composio @composio/openai@0.12.0

Tue, 18 Aug 2026 22:39:29 GMT

Composio OpenAI/Anthropic helpers can now execute tool calls through a Tool Router session, with error text preserved in `{ error }` results. • OpenAI and Anthropic provider tool-call helpers (`executeToolCall`, `handleToolCalls`) now accept a Tool Router session target, so session meta-tools retain their session context during execution. • Anthropic helper failures now preserve error text in `{ error }` result payloads instead of discarding it. Breaking changes: • Custom provider subclasses overriding `executeToolCall` or `handleToolCalls` may require updates because these methods now accept session targets.

Composio @composio/core@0.17.0

Tue, 18 Aug 2026 22:39:26 GMT

Composio @composio/core@0.17.0 adds Tool Router session support for OpenAI/Anthropic helpers and extends SSRF guards to API-response URLs. • OpenAI and Anthropic provider tool-call helpers (`executeToolCall` / `handleToolCalls`) can now execute through a supplied Tool Router session, with session meta-tools retaining their session context across calls. • Anthropic helper failures now preserve error text in `{ error }` results instead of swallowing them. Breaking changes: • Custom provider subclasses overriding `executeToolCall` or `handleToolCalls` may break on upgrade because these methods now accept session targets as an additional parameter.

Composio @composio/core@0.17.0

Tue, 18 Aug 2026 22:39:26 GMT

Tool Router sessions now flow through OpenAI/Anthropic helpers, and API-response URLs are SSRF-guarded before fetch. • Enables OpenAI and Anthropic provider tool-call helpers (`executeToolCall`, `handleToolCalls`) to execute through a supplied Tool Router session, so session meta-tools retain their session context during provider calls. • Anthropic helper failures now return error text in `{ error }` results instead of swallowing it, preserving failure detail without altering successful payloads. Breaking changes: • Custom provider subclasses overriding `executeToolCall` or `handleToolCalls` may require updates because these methods now accept session targets.

Composio @composio/anthropic@0.11.0

Tue, 18 Aug 2026 22:39:23 GMT

Composio Anthropic helper routes tool calls through a Tool Router session and preserves error text in `{ error }` results. • Enables the Anthropic provider tool-call helper to execute through a supplied Tool Router session, with session meta-tools retaining their session context alongside existing user-ID direct execution. • Anthropic helper failures now preserve their error text in `{ error }` results without altering successful payloads. • Custom provider subclasses overriding `executeToolCall` or `handleToolCalls` now accept session targets, enabling session-aware routing in subclassed providers. Breaking changes: • Custom provider subclasses overriding `executeToolCall` or `handleToolCalls` may require updates because these methods now accept session targets.

Composio @composio/anthropic@0.11.0

Tue, 18 Aug 2026 22:39:23 GMT

Composio @composio/anthropic 0.11.0 routes Anthropic tool-call helpers through a Tool Router session and preserves error text in results. • Anthropic provider tool-call helpers can now execute through a supplied Tool Router session, with session meta-tools retaining their session context alongside existing user-ID direct execution. • Anthropic helper failures now preserve their error text in `{ error }` results without altering successful payloads. • Custom provider subclasses overriding `executeToolCall` or `handleToolCalls` now accept session targets as part of their method signatures. Breaking changes: • Custom provider subclasses overriding `executeToolCall` or `handleToolCalls` may require updates because these methods now accept session targets.

Composio @composio/cli@0.3.4-beta.350

Wed, 12 Aug 2026 21:41:56 GMT

Composio CLI 0.3.4-beta.350 publishes the agent skill and fixes auth-config credential nesting. • Nests custom credentials under `auth_config.credentials` in the `auth-configs create` CLI command, correcting how credentials are submitted. • Publishes the Composio agent skill, making it available for use in skill-based agent workflows.

Composio @composio/cli@0.3.3

Tue, 11 Aug 2026 13:33:26 GMT

Composio CLI 0.3.3 bakes the toolkit slug catalog locally for faster, offline toolkit resolution. • Bakes the toolkit slug catalog directly into the CLI binary, enabling toolkit resolution from local knowledge without a catalog network call — unlocking offline and low-latency workflows.

Composio @composio/cli@0.3.3

Tue, 11 Aug 2026 13:33:26 GMT

Composio CLI 0.3.3 resolves toolkits locally for faster offline-capable lookups and bakes in the full toolkit slug catalog. • Bakes the complete toolkit slug catalog into the CLI binary, enabling toolkit resolution without a network call to the catalog service.

Composio @composio/cli@0.3.3-beta.347

Tue, 11 Aug 2026 09:00:21 GMT

Composio CLI now resolves toolkits locally from a baked-in catalog, eliminating network round-trips. • Bakes the toolkit slug catalog directly into the CLI binary so toolkit resolution works from local knowledge rather than requiring a catalog API call.

Composio @composio/core@0.16.0

Tue, 11 Aug 2026 08:56:23 GMT

Composio @composio/core@0.16.0 extends ToolSchema to support free-form object roots, patternProperties, and schema-valued additionalProperties. • Adds support for free-form object roots, `patternProperties`, and schema-valued `additionalProperties` in `ToolSchema.parse`, so tools that declare dynamic keys now pass those constraints through to every provider's `inputParameters` instead of having them silently stripped. • Makes the `properties` field optional on the public `ToolSchema` type to reflect valid property-less object schemas. • Automatically injects `type: 'object'` into nested JSON Schema nodes that carry `properties` without an explicit type, ensuring compatibility with strict OpenAPI 3.0 consumers such as Google Gemini. • Reuses fetched tool schemas when provider-wrapped tools execute, avoiding a redundant retrieval request per tool call. Breaking changes: • Code that assumed `additionalProperties` in `inputParameters` is always a boolean must be widened — `ToolSchema.parse` now accepts and preserves `additionalProperties` as a schema object (e.g. `{ type: 'number' }`), and `patternProperties` can also appear on a parsed schema.

Composio @composio/core@0.16.0

Tue, 11 Aug 2026 08:56:23 GMT

Composio @composio/core@0.16.0 extends ToolSchema to support free-form object roots, patternProperties, and schema-valued additionalProperties. • Adds support in `ToolSchema.parse` for free-form `{ "type": "object" }` root schemas, root `patternProperties`, and root `additionalProperties` expressed as a schema object rather than a boolean, so dynamic-key tools no longer have those rules silently stripped before reaching the model. • Makes `properties` optional in the public `ToolSchema` type to reflect valid property-less object schemas. • Automatically injects `type: 'object'` into nested JSON Schema nodes that declare `properties` without an explicit type, enabling compatibility with strict OpenAPI 3.0 consumers such as Google Gemini. • Reuses fetched tool schemas during provider-wrapped tool execution to eliminate a redundant retrieval request per invocation. Breaking changes: • Code that relied on `ToolSchema.parse` rejecting a schema-valued root `additionalProperties` (only a boolean was previously accepted) will no longer see that parse failure — parsing now succeeds and `inputParameters.additionalProperties` carries the schema object. • Code that assumed `inputParameters` never carries `patternProperties`, or that `additionalProperties` is always a boolean, must be widened: both keywords can now appear, and `additionalProperties` can be a boolean or a schema object.

Composio @composio/claude-agent-sdk@0.11.0

Tue, 11 Aug 2026 08:56:17 GMT

Claude Agent SDK provider now registers complete object schemas, enforcing `additionalProperties` and rejecting undeclared arguments. • The Claude Agent SDK provider now registers each tool with its full object schema, so root-level rules like `additionalProperties` and `patternProperties` are respected instead of being silently dropped. Breaking changes: • Undeclared tool arguments no longer pass silently — a tool that previously ran after stripping unknown keys (e.g. `hallucinated: 'value'`) now returns an error result and does not execute. Any tool schema that relies on silent argument removal must be updated: either declare the extra keys in `properties` or set `additionalProperties: true` in the tool's JSON schema.

Composio @composio/json-schema-to-zod@0.3.0

Tue, 11 Aug 2026 08:56:14 GMT

json-schema-to-zod now accepts arbitrary content in property-less objects and correctly scopes patternProperties and additionalProperties validation. • Property-less object schemas (`{ "type": "object" }` or `{ "properties": {} }`) are now open by default, accepting and preserving arbitrary content at the root, nested inside objects, and inside array items — instead of rejecting everything as z.object({}).strict(). • Dynamic key routing now correctly applies each `patternProperties` pattern only to keys it actually claims, and `additionalProperties` (schema-valued) applies only to keys unmatched by any declared property or pattern. Breaking changes: • Converting a property-less object schema (`{ "type": "object" }` or `{ "properties": {} }`) no longer produces a schema that rejects all non-empty payloads; callers that relied on that closed behavior must now explicitly set `additionalProperties: false` in their JSON Schema to restore it.

Composio @composio/json-schema-to-zod@0.3.0

Tue, 11 Aug 2026 08:56:14 GMT

json-schema-to-zod now converts property-less objects to open schemas and correctly routes patternProperties and additionalProperties. • Objects with no named properties (`{ "type": "object" }` or `{ "properties": {} }`) now convert to open Zod schemas that accept arbitrary content instead of strict empty objects that rejected all payloads. Breaking changes: • Property-less object schemas such as `{ "type": "object" }` no longer produce a schema that rejects all input: jsonSchemaToZod({ type: 'object' }).parse({ anything: 1 }) now returns `{ anything: 1 }` instead of throwing. To preserve the old closed behavior, explicitly set `additionalProperties: false` in the JSON Schema.

Composio @composio/openai@0.11.0

Fri, 07 Aug 2026 16:49:02 GMT

Composio OpenAI integration now supports OpenAI SDK versions 6 and 7. • Adds support for OpenAI SDK versions 6 and 7 in the `@composio/openai` package.

Composio @composio/cli@0.3.2

Wed, 05 Aug 2026 16:12:14 GMT

Composio CLI 0.3.2 makes automatic shell setup the default during installation. • Automatic shell setup is now the installer default, removing the need for manual shell configuration after install.

Composio @composio/cli@0.3.2

Wed, 05 Aug 2026 16:12:14 GMT

Composio CLI installer now sets up shell integration automatically by default. • Automatic shell setup is now the default behavior of the installer, removing the need for manual shell configuration after install.

Composio @composio/cli@0.3.2-beta.337

Wed, 05 Aug 2026 14:36:28 GMT

Composio CLI installer now performs automatic shell setup by default. • Automatic shell environment setup is now the default behavior of the installer, removing the need for manual post-install shell configuration.

Composio @composio/cli@0.3.2-beta.334

Wed, 05 Aug 2026 11:55:57 GMT

Composio CLI gains `--shell` flag for explicit PATH setup during `composio install`. • Adds `--shell` flag to `composio install` for explicit shell-targeted PATH configuration, reworking how the CLI sets up PATH after installation.

Composio @composio/experimental@0.2.0

Thu, 16 Jul 2026 16:09:31 GMT

Composio experimental adds EveProvider with native defineTool support, step resolvers, and middleware hooks for Tool Router calls. • Adds `EveProvider`, which makes session.tools() return eve-native `defineTool`s for direct integration with the Eve runtime. • Adds `defineComposioTools` as a replay-safe `step.started` resolver for use with EveProvider. • Supports (ctx, next) middleware hooks on Tool Router meta-tool calls, enabling callers to rewrite, deny, or transform requests before they execute. • Preserves successful local-tool results when the remote half of a mixed `COMPOSIO_MULTI_EXECUTE_TOOL` batch fails at the transport layer, so callers can inspect which side effects completed before retrying.

Composio @composio/core@0.14.0

Thu, 16 Jul 2026 12:56:54 GMT

Composio @composio/core@0.14.0 adds an Eve provider, SSRF/secret guardrails, and server-side trigger connection resolution. • Adds `EveProvider` with session.tools() returning eve-native `defineTool`s, `defineComposioTools` as a replay-safe `step.started` resolver, and (ctx, next) hooks to rewrite, deny, or transform Tool Router meta-tool calls. • Exports `assertSafeFileUploadPath`, `isBlockedSensitiveFileUploadPath`, and `BUILTIN_FILE_UPLOAD_PATH_DENY_SEGMENTS` from the package root so downstream packages share one sensitive-file-upload denylist implementation. • Adds SSRF guard to composio.files.upload(url) and automatic file uploads: resolves hosts, blocks private/loopback/link-local (including `169.254.169.254`)/CGNAT/reserved addresses, rejects non-`http(s)` schemes, and re-validates each redirect hop; blocked requests throw `ComposioBlockedInternalUrlError`. • Adds telemetry redaction that strips URL query strings, `Authorization` bearer/basic credentials, and secret-like `key=value` pairs (API keys, tokens, client secrets, passwords) from `error.message` and `error.stack` before transport. • Adds a `realpathSync` method to the internal `#platform` abstraction, making the file-upload denylist guard edge/workerd-safe with no static `node:*` imports. • Preserves successful local-tool results when the remote half of a mixed `COMPOSIO_MULTI_EXECUTE_TOOL` batch fails at the transport layer, so callers can identify which side effects completed before retrying. • `OpenAIProvider.handleToolCalls` now executes every parallel tool call in an assistant message (sequentially, in model-returned order), answering each `tool_call_id` exactly once. • Treats local file paths beginning with `http` as paths rather than URLs so upload allowlist and sensitive-file denylist checks still run. Breaking changes: • `triggers.create` no longer throws `ComposioConnectedAccountNotFoundError` for a missing or invalid connection when `connectedAccountId` is omitted; that error now surfaces as the backend error from the upsert call. Self-hosted deployments must be on a backend version that includes platform#10932 (resolves trigger connection from `user_id` on upsert) or `triggers.create` will fail.

Composio @composio/vercel@0.11.0

Fri, 26 Jun 2026 20:51:14 GMT

@composio/vercel 0.11.0 adds AI SDK 7 support, with peer dependency range now covering both v6 and v7. • Adds AI SDK 7 support to `@composio/vercel`; the `ai` peer dependency range is now `^6.0.0 || ^7.0.0`, covering both v6 and v7 with e2e compatibility tests. Breaking changes: • AI SDK 5 is no longer supported by `@composio/vercel`; the `ai` peer dependency range drops v5 and now requires `^6.0.0 || ^7.0.0`.

Composio @composio/core@0.13.0

Fri, 26 Jun 2026 01:56:29 GMT

Composio @composio/core@0.13.0 adds first-class session and trigger APIs, MCP opt-in, and workbench config surfacing. • Adds composio.sessions.create() as the new first-class session creation API, with composio.create() retained as an alias. • Adds connectedAccounts.updateAcl() as a stable alias for the experimental shared-connection ACL patch helper, previously only reachable via experimental.updateAcl(). • Makes MCP opt-in: sessions now return `SessionWithoutMcp` by default; pass `{ mcp: true }` to sessions.create() to surface the hosted MCP endpoint on the type. • Exposes `Session.workbench` populated from the API response on `create`, `retrieve`, `attach`, and `update`, including `session.workbench?.enable`, enabling callers to pass `{ workbench: { enable: false } }` and detect sandbox state. • Adds triggers.parse() to parse and optionally verify incoming webhook requests. • Adds triggers.setWebhookSubscription() to create or update a project webhook subscription from the TypeScript SDK. • Accepts `sandbox` as the preferred key for session code-execution configuration, with `workbench` continuing to work as an alias. Breaking changes: • The default sessions.create() / use() now returns `SessionWithoutMcp` — `session.mcp` is no longer present on the type unless the session is created with `{ mcp: true }`. Code that reads `session.mcp` without passing `{ mcp: true }` will encounter a type error.

Composio @composio/core@0.12.0

Thu, 25 Jun 2026 00:40:21 GMT

Composio @composio/core@0.12.0 adds per-request AbortSignal cancellation across all SDK methods and cooperative cancellation for custom tools. • Adds a `ComposioRequestOptions` trailing argument (`{ signal?: AbortSignal }`) to all public SDK methods — `tools.get`, `tools.execute`, `toolkits.get`, `authConfigs.list/create/get/update/delete`, `connectedAccounts.*`, `triggers.*`, `mcp.*`, `toolRouter.*`, and `toolRouterSession.*` — so callers can cancel long-running requests without blocking an agent indefinitely. • Adds `ComposioRequestCancelledError` as a typed, `instanceof`-detectable error class; any `APIUserAbortError`, `AbortError`, or DOMException(name='AbortError') from the underlying fetch is normalized to it, and catch paths in `tools.execute`, `tools.getRawComposioToolBySlug`, and `toolkits.get` re-throw it rather than remapping to `ComposioToolExecutionError` / `ComposioToolNotFoundError` / `ComposioToolkitFetchError`. • Exposes `SessionContext.signal` (the caller's `AbortSignal`) inside Tool Router custom tools via `experimental_createTool`, enabling cooperative mid-execution cancellation by wiring `ctx.signal` into any abortable I/O. • Adds a pre-execute signal check for custom tools: if `signal.aborted` is true before user `execute` runs, the SDK throws `ComposioRequestCancelledError` and never invokes user code. • Adds `search` and `showDisabled` filter parameters to authConfigs.list(). • Adds provider-agnostic JSON-schema property-key sanitizer utilities: sanitizeSchemaPropertyKeys(schema, policy), restoreOriginalKeys(value, mapping), mappingHasRenames(mapping), and the `KeyMapping` / `KeySanitizationPolicy` types, consumed by the `@composio/anthropic` provider to handle per-provider key character/length constraints. • Exposes `jsonSchemaToZodShape` via the `@composio/core/utils/json-schema` subpath export, and adds correct conversion of both `zod/v3` and Zod v4 schemas to JSON Schema for custom tools. • Preserves root `$defs` / `definitions` blocks on tool parameter schemas and dereferences them in the Node file modifier, enabling auto file upload/download detection when `file_uploadable` or `file_downloadable` is hidden behind an internal `$ref`. Breaking changes: • The packages are now ESM-only; CommonJS entrypoints and `.cjs` artifacts are removed. Node.js 22.22.3 or newer is required; CommonJS callers can only rely on Node's native require(esm) interop. • The `uuid` field is removed from `AuthConfigRetrieveResponse` and `AuthConfigListResponse`; consumers must use `id` instead.

Composio @composio/core@0.11.0

Fri, 19 Jun 2026 14:36:16 GMT

Composio core 0.11.0 forwards userId in trigger flows and exposes new schema-resolution and argument-normalization APIs. • Forwards `userId` when creating trigger instances so trigger 2FA flows can verify connected account ownership. • Adds `dereferenceJsonSchema` optional second argument `{ onUnresolved?: 'throw' | 'sentinel'; onReplace?: (ref, reason) => void }` to control handling of unresolvable `$ref` pointers, with new type exports `UnresolvedRefStrategy`, `UnresolvedRefReason`, and `DereferenceJsonSchemaOptions`. • Adds `normalizeToolArguments` helper (exported from `@composio/core`) that routes model-supplied tool-call arguments through a single normalization path — object payloads pass through, JSON strings are parsed, empty/`null` payloads become `{}`, and unresolvable values throw a typed `ComposioInvalidToolArgumentsError`. • Re-exports the `telemetry` instance from `@composio/core` as a public export alongside `logger`, allowing providers to emit aggregate signals without reaching into package internals. • `MastraProvider.wrapTool` now opts `inputParameters` and `outputParameters` into `'sentinel'` mode for dangling `$ref` resolution, emitting one `logger.warn` per (toolSlug, ref) pair and a one-shot telemetry event `composio.mastra.wrapTool.danglingRef` (respects `COMPOSIO_DISABLE_TELEMETRY=true`). • Telemetry batch and error sends are now deferred so the SDK returns results and rethrows errors without waiting on telemetry network requests. Breaking changes: • The legacy composio.tools.createCustomTool(...) in-memory registry API is removed. Use Tool Router custom tools via `experimental_createTool`, `experimental_createToolkit`, and composio.create(..., { experimental: { customTools, customToolkits } }) instead.

Composio @composio/core@0.10.0

Wed, 13 May 2026 17:26:15 GMT

Composio @composio/core@0.10.0 surfaces `accountType` filter on connectedAccounts.list() and namespaces Shared Connection mutation APIs under `experimental`. • Adds `accountType: 'SHARED'` filter to connectedAccounts.list() so SHARED connections can be listed directly without dropping to the raw client. • Moves `accountType` and `aclConfigForShared` options on connectedAccounts.link() and session.authorize() under a single `experimental` block, signalling that the shape may change in future releases. • Promotes connectedAccounts.updateAcl() off the class to a top-level named export experimental_updateAcl(composio, id, opts), consistent with the existing `experimental_createTool` / `experimental_createToolkit` pattern. Breaking changes: • The flat `accountType` and `aclConfigForShared` options on connectedAccounts.link() and session.authorize() must now be nested inside an `experimental: { ... }` block — callers passing these at the top level will no longer compile or behave correctly. • connectedAccounts.updateAcl() has been removed from the class; callers must switch to the top-level experimental_updateAcl(composio, id, opts) export.

Composio @composio/core@0.9.1

Mon, 11 May 2026 23:13:34 GMT

Composio adds SHARED connected accounts with per-user ACL controls and a new updateAcl() method • Adds `accountType: 'SHARED'` option to composio.connectedAccounts.link() — creates a shared connection usable by multiple `userId`s when explicitly pinned in a tool-router session; default remains `'PRIVATE'`. • Adds `aclConfigForShared` block (`{ allowAllUsers, allowedUserIds, notAllowedUserIds }`) on both create and retrieve for SHARED connections, with deny-win resolution: `notAllowedUserIds` checked first, then `allowAllUsers`, then `allowedUserIds`, otherwise deny-by-default. • New composio.connectedAccounts.updateAcl(nanoid, { allowAllUsers, allowedUserIds, notAllowedUserIds }) method writes ACL via PATCH semantics — omit a field to leave it unchanged, pass an empty array to clear a list; at least one field required; each list accepts up to 1 000 entries, each `userId` up to 256 characters. • Adds `accountType` and `aclConfigForShared` options to ToolRouterSession.authorize() so a SHARED connection with an ACL can be created in a single call from inside a tool-router session. • The `accountType` field (`'PRIVATE' | 'SHARED'`) is now returned in get() and list() responses for connected accounts. • New error classes: `ComposioSharedAccessDeniedError` (403) when a user fails the ACL on a shared connection, `ComposioAclOnlyForSharedError` (400) when ACL fields are sent on a PRIVATE connection, and `ComposioSharedConnectionNotAccessibleError` (400) when a tool-router session is created or PATCHed with a pinned SHARED connection the session user cannot access.

Composio py@0.13.0

Thu, 07 May 2026 15:53:39 GMT

Composio py@0.13.0 adds Tool Router v3.1 with preload and session.update(), plus REVOKED connected account status and sandbox compute tiers. • Adds Tool Router v3.1 support including preload, SDK-local custom tool preload, attach/use flow refinements, and session.update(). • Adds `REVOKED` status for connected accounts, along with connected account string/list coercion and the `allow_multiple` guard. • Adds workbench sandbox compute tier support.

Composio @composio/cli-local-tools@0.0.2

Thu, 07 May 2026 15:33:07 GMT

Composio CLI local-tools debuts with iMessage, Chrome DevTools, and Peekaboo macOS integrations plus four new subcommands. • Adds `composio local-tools list`, `composio local-tools doctor`, `composio local-tools configure`, and `composio local-tools meta` subcommands for discovery, readiness checks, setup hints, and local metadata state. • Adds Beeper iMessage local toolkit with compact thread discovery, contact-aware thread search, send verification, and reaction preparation, backed by rebuildable sidecar binaries from the ComposioHQ `platform-imessage` submodule. • Adds Chrome DevTools local tools backed by the official `chrome-devtools-mcp` package and its stateful `chrome-devtools` CLI daemon. • Adds Peekaboo macOS local tools backed by a bundled darwin-arm64 Peekaboo CLI binary. • Wires the local-tools foundation package into Tool Router search and execute sessions.

Composio @composio/core@0.9.0

Thu, 07 May 2026 15:32:53 GMT

Composio @composio/core@0.9.0 adds session.update(), expanded ToolRouter session controls, custom tools in composio.use(), and typed OAuth migration errors. • Adds session.update() method to partially update session configuration after creation; accepts the same config shape as create() and mutates the session in-place, available in TypeScript and Python SDKs. • Adds composio.use(id, { customTools, customToolkits }) to reuse an existing session and bind SDK-local custom tools for search and execution, with `inlineCustomToolsPayload` and `preloadedCustomToolSlugs` passed through on rehydrated sessions. • Exposes `SessionPreset.DIRECT_TOOLS` constant (Python: `SESSION_PRESET_DIRECT_TOOLS`) for the Tool Router direct-tools preset, enabling agents that know their tool set upfront to bypass search. • Adds `ComposioLegacyConnectedAccountsEndpointRetiredError`, exported from `@composio/core`, thrown by initiate() when `POST /api/v3/connected_accounts` returns a 400 on the retiring Composio-managed OAuth path; carries a `possibleFixes` block pointing at link() ahead of the 2026-07-03 cutover. • Expands composio.create() to create a fresh session on each call for better isolation, while composio.use() resumes an existing session for multi-turn conversations; sessions can preload tools and expose custom tools via session.tools(). • `connectedAccounts` now accepts both `string` and `string[]` per toolkit, with a single string automatically coerced to an array to match the v3.1 API wire format. • Adds `dereferenceJsonSchema` helper exported from `@composio/core` that resolves internal JSON Schema `$ref` pointers (`#/$defs/...` and `#/definitions/...`) before handing tool parameters to downstream schema libraries.

Composio @composio/cli@0.2.28

Fri, 01 May 2026 22:20:47 GMT

Composio CLI 0.2.28 adds agent signup and claim support. • Adds agent signup and claim support to the Composio CLI.

Composio @composio/core@0.8.1

Thu, 30 Apr 2026 12:32:55 GMT

Composio core 0.8.1 adds `allowMultiple` guard to connectedAccounts.link() and a `workbench.sandboxSize` compute-tier selector for Tool Router sessions. • Adds `allowMultiple` option to connectedAccounts.link(userId, authConfigId, { allowMultiple }): when `false` (default) and the user already has an `ACTIVE` connection on the auth config, throws `ComposioMultipleConnectedAccountsError` — matching the existing initiate() guard. Pass `allowMultiple: true` to intentionally create multiple connections per auth config. • Adds `workbench.sandboxSize` field (type `'standard' | 'medium' | 'large' | 'xlarge'`) to `ToolRouterCreateSessionConfig`, letting callers select the workbench sandbox compute tier. Tiers: `standard` (1 vCPU / 1 GB), `medium` (2 vCPU / 2 GB), `large` (4 vCPU / 4 GB), `xlarge` (8 vCPU / 8 GB). Forwarded to the API as snake_case `workbench.sandbox_size`; defaults to `'standard'` when omitted. • Exports `SandboxSize` literal union and `SandboxSizeSchema` zod enum from `@composio/core` so callers can reference tier values without stringly-typing them. • Python SDK gains parity: `allow_multiple: bool = False` option and the same `ACTIVE`-connection guard added to composio.connected_accounts.link(). Breaking changes: • connectedAccounts.link() now performs a pre-flight connectedAccounts.list({ userIds, authConfigIds, statuses: ['ACTIVE'] }) before calling `client.link.create`. Callers that intentionally create multiple connections per auth config must now pass `allowMultiple: true` or the call will throw `ComposioMultipleConnectedAccountsError`.

Composio py@0.12.0

Tue, 28 Apr 2026 06:28:43 GMT

Composio py@0.12.0 makes file upload/download opt-in, adding new constructor flags and a per-upload source hint for hooks. • Adds `dangerously_allow_auto_upload_download_files: bool = False` to Composio(...) to opt back in to automatic file staging — when `True`, collapses `file_uploadable` schemas to `{"type": "string", "format": "path"}` for the model and stages local paths/URLs at execute time. • Adds `file_upload_dirs: Sequence[str] | Literal[False] | None = None` to Composio(...) as a fail-closed allowlist for local upload paths — `None` defaults to `[/.composio/temp]`, `False` rejects all local paths, and an explicit list replaces the default. • Adds `file_download_dir: str | None` to Composio(...) to set the directory used to stage downloads on `file_downloadable` results. • The `before_file_upload` modifier hook now receives `source: Literal['path', 'url', 'file']` so hooks can branch on the original input type. • When auto-upload is off and a tool with `file_uploadable` inputs is executed, the SDK emits a one-shot warning per tool slug pointing at composio.files.upload() for manual staging. Breaking changes: • Automatic file upload/download is now off by default — existing code that relied on auto-staging local paths/URLs or auto-downloading `file_downloadable` results will stop working unless `dangerously_allow_auto_upload_download_files=True` is set on Composio(...). • The `auto_upload_download_files` constructor option is removed; code that sets it must migrate to `dangerously_allow_auto_upload_download_files`.

Composio @composio/cli@0.2.26

Sat, 25 Apr 2026 06:28:04 GMT

Composio CLI gains a connection removal command in v0.2.26. • Adds a connection removal command to the Composio CLI, enabling practitioners to delete existing connections directly from the command line.

Composio @composio/core@0.6.11

Thu, 23 Apr 2026 13:20:19 GMT

Composio core 0.6.11 adds file-upload path hardening with denylist controls and a pre-upload hook. • Adds automatic blocking of local file uploads from credential-sensitive paths (e.g. `.ssh`, `.aws`) and credential-like filenames (e.g. `.env`, default SSH private-key names) by default; URLs and `File` objects are unaffected. • Adds `sensitiveFileUploadProtection: false` option to opt out of the default credential-path blocking when required. • Adds `fileUploadPathDenySegments` option to extend the built-in denylist with custom path segments. • Adds an optional `beforeFileUpload` hook (e.g. on `composio.tools.get`) to rewrite paths, return `false` to abort, or throw to cancel an upload programmatically. • Introduces two new error types: `ComposioSensitiveFilePathBlockedError` (path matched the denylist) and `ComposioFileUploadAbortedError` (hook returned `false` or threw). Breaking changes: • File uploads from paths matching common credential locations (e.g. `.ssh`, `.aws`) or credential-like filenames (e.g. `.env`, default SSH private-key names) are now blocked by default; any working setup that uploads such files will break unless `sensitiveFileUploadProtection: false` is set.

Composio py@0.11.6

Thu, 23 Apr 2026 13:13:50 GMT

Composio 0.11.6 adds sensitive file-path blocking and `@before_file_upload` modifier hooks before auto-upload. • Adds sensitive file-path blocking via a built-in denylist (segments such as `.ssh`, `.aws`, and risky filenames) checked before any local file is auto-uploaded; configurable with `sensitive_file_upload_protection` and `file_upload_path_deny_segments` on the Composio(...) constructor. • Adds `@before_file_upload` modifier hooks — decorate a function and pass it via `modifiers=[...]` on `tools.get`, `tools.execute`, or the tool router session.tools(...) — running before `before_execute` modifiers when substituting `file_uploadable` paths. • Adds `merge_before_file_upload` to compose multiple `@before_file_upload` hooks in a single call. • Raises `SensitiveFilePathBlockedError` or `FileUploadAbortedError` when a path matches the denylist or a hook returns `False`, giving callers explicit error handling surfaces. Breaking changes: • The `before_file_upload=` keyword argument has been removed from `Composio`, `get`, `execute`, and the tool router; file upload hooks must now be passed exclusively via `modifiers=[...]`. • `FileHelper` no longer stores a default hook on the client; only the merged modifier hook (or `None`) is available per call.

Composio @composio/cli@0.2.18

Wed, 01 Apr 2026 07:56:44 GMT

Composio CLI 0.2.18 preloads custom auth connections into tool router sessions and adds a beta-channel release promotion flow. • Preloads custom auth connections into CLI tool router sessions, enabling authenticated tools to be available immediately when a session starts. • Adds a beta-channel CLI release promotion flow, allowing users to receive and test pre-release CLI builds.

Composio @composio/cli@0.2.10

Fri, 27 Mar 2026 06:38:02 GMT

Composio CLI 0.2.10 adds parallel execute, batched tool search, `--get-schema` without auth, and a `composio files` subcommand. • Adds `--get-schema` flag to `execute` that now works without user context, enabling schema inspection in unauthenticated or CI environments. • Adds `--no-skill-install` opt-out flag to `composio login` to skip the new automatic skill installer that runs during login. • Adds `composio files` subcommand with built-in help and richer examples surfaced in root help output. • Adds parallel execute support to the CLI, allowing multiple tool executions to run concurrently. • Adds batched multi-query tool search, enabling multiple search queries to be resolved in a single call. • Reports execute failure origin and tool log IDs on failed executions, giving practitioners a direct handle for post-mortem investigation. • Caches no-auth toolkits as connected, removing redundant authentication checks for toolkits that require no credentials. • Adds contextual help output on CLI errors and unknown arguments to surface relevant guidance at the point of failure. • Respects `COMPOSIO_SESSION_DIR` and `COMPOSIO_CACHE_DIR` environment variables for session artifacts and analytics directory placement in sandboxed environments.

Composio @composio/cli@0.2.9

Thu, 26 Mar 2026 08:29:44 GMT

Composio CLI 0.2.9 adds parallel tool execution, ACP-backed subagent runs, and a new `dev` namespace for manage commands. • Adds ACP-backed subagent execution to `composio run`, enabling agent-driven tool invocation via the CLI. • Moves CLI manage commands under the `dev` namespace (e.g., `composio dev ...`). • Adds parallel tool execution support in the CLI. Breaking changes: • CLI manage commands have been moved under the `dev` namespace; any scripts or workflows invoking those commands directly will need to be updated to use `composio dev `.

Composio @composio/core@0.6.7

Tue, 24 Mar 2026 18:57:47 GMT

Adds `workbench.enable` session config option to exclude code execution tools from a session entirely. • Adds `workbench.enable` to session config (default `true`); setting it to `false` excludes `COMPOSIO_REMOTE_WORKBENCH` and `COMPOSIO_REMOTE_BASH_TOOL` from the session, disabling the workbench entirely.

Composio @composio/cli@0.2.8

Tue, 24 Mar 2026 18:57:32 GMT

Composio CLI 0.2.8 scopes commands by role, adds proxy execute, and introduces a workbench disable option. • Adds `composio manage ...` as the developer-scoped namespace, moving developer-only operations under it and removing those flags from the root help. • Moves `composio search`, `composio link`, and `composio execute` to consumer-only top-level commands, with short related-command hints added to root help. • Adds proxy execute capability via `composio execute`, defaulting to an empty object `{}` when no `-d`/`--data` flag or piped stdin is provided. • Adds `workbench.enable` config option to disable the workbench in sessions. • Search CTA now uses `-d '{}'` (shell-safe) for tools with no schema properties. Breaking changes: • Developer-only flags previously available at the root CLI level are removed from root help; developer workflows must now use `composio manage ...`.

Composio @composio/cli@0.2.7

Sat, 21 Mar 2026 01:56:51 GMT

Composio CLI 0.2.7 reorganizes commands: top-level `search`, `link`, and `execute` are now consumer-only; developer flows move under `composio manage`. • Moves developer-scoped usage of `composio search`, `composio link`, and `composio execute` under `composio manage ...`, keeping the top-level commands consumer-only. • Removes developer-only flags from root help output and adds short related-command hints pointing to the `composio manage` surface. • `composio execute` now defaults to an empty object `{}` when neither `-d`/`--data` nor piped stdin is provided, so invocations without data no longer require an explicit argument. • Search call-to-action now uses `-d "{}"` for tools with no schema properties, producing shell-safe output. Breaking changes: • Developer-scoped `composio search`, `composio link`, and `composio execute` are removed from the root level; existing scripts or workflows using those commands in a developer context must be updated to use `composio manage ...` equivalents.

Composio @composio/cli@0.2.6

Fri, 20 Mar 2026 23:54:36 GMT

Composio CLI 0.2.6 reorganizes commands into consumer vs. developer scopes and adds smarter `execute` defaults. • Moves `composio search`, `composio link`, and `composio execute` to consumer-only top-level commands, with developer-scoped operations now under `composio manage ...`. • Defaults `composio execute` to an empty object `{}` when no `-d`/`--data` flag or piped stdin is provided, eliminating the need to pass an explicit empty payload. • Uses `-d "{}"` in the search call-to-action for tools with no schema properties, ensuring shell-safe invocation. • Removes developer-only flags from root help output and adds short related-command hints pointing to `composio manage ...`. Breaking changes: • Developer-scoped commands previously available at `composio search`, `composio link`, and `composio execute` are now consumer-only at the root level; developer usage must move to `composio manage ...`.

Composio @composio/cli@0.2.5

Thu, 19 Mar 2026 06:01:31 GMT

Composio CLI 0.2.5 adds a `manage` namespace for advanced commands and moves code-gen under a unified `generate` command. • Adds `manage` namespace to the CLI for grouping advanced commands. • Moves Python and TypeScript SDK code-generation subcommands under a unified `generate` command. Breaking changes: • The Python and TypeScript SDK generation subcommands (`py` and `ts`) have been moved under the `generate` command; any scripts or workflows invoking the old command paths will break.

Composio @composio/cli@0.2.4

Fri, 13 Mar 2026 12:55:06 GMT

Composio CLI gains `--no-wait` and `--key` flags on the login command to support headless agent and auth flows. • Adds `--no-wait` flag to the `login` command to print the URL and session info then exit immediately, enabling non-interactive agent flows. • Adds `--key` flag to the `login` command to complete login with a session key, polling until the session is linked unless `--no-wait` is also passed.

Composio @composio/cli@0.2.2

Fri, 13 Mar 2026 06:39:08 GMT

Composio CLI v0.2.2 adds interactive org/project picker, `--no-wait` for `composio link`, and redacts API keys from `whoami` • Adds `--no-wait` flag to `composio link` — prints URL/JSON output and exits immediately without blocking on completion. • Adds `-y` flag to `composio login` to skip the new interactive org/project picker and proceed non-interactively via browser flow. • Adds `composio install` command for shell integration. • Adds interactive org/project picker after `composio login` to guide users through org and project selection. • Adds background upgrade-available hint to the CLI to surface when a newer version is available. • `composio whoami` no longer exposes API keys in its output. Breaking changes: • The `--api-key`, `--org-id`, and `--project-id` flags have been removed from `composio login` and `composio init`; non-interactive login via these flags is no longer supported — use the browser flow with `-y` instead.

Composio @composio/cli@0.2.0

Fri, 06 Mar 2026 04:09:14 GMT

Composio CLI 0.2.0 adds top-level command aliases and restructures root help into BASIC/ADVANCED sections. • Adds top-level command aliases to the CLI, letting practitioners invoke common commands with shorter names. • Restructures the CLI root help output into BASIC and ADVANCED sections with full usage and options shown for basic commands.

Composio @composio/cli@0.1.35

Wed, 04 Mar 2026 18:31:15 GMT

Composio CLI 0.1.35 adds checksums, cross-compilation, and a simplified install process. • Adds checksums, cross-compilation support, and a simplified install flow to the CLI distribution.

Composio @composio/cli@0.1.33

Sat, 28 Feb 2026 20:51:47 GMT

Composio CLI gains org/project switch and list commands for managing multi-tenant contexts from the terminal. • Adds global org switching and listing commands to the CLI, enabling practitioners to change the active organization context without leaving the terminal. • Adds global project switching and listing commands to the CLI, enabling quick context changes across projects in a multi-project environment. • Adds a `toolkit version` subcommand to the CLI for inspecting toolkit versions.

Composio @composio/cli@0.1.28

Thu, 26 Feb 2026 04:44:32 GMT

Composio CLI 0.1.28 enhances init and tool-router based tool discovery with improved tool search and API key inference. • Enhances `init` and tool-router based tool discovery in the CLI for improved tool search and API key inference.

Composio v0.11.1

Tue, 10 Feb 2026 05:31:24 GMT

Composio v0.11.1 adds public URL support, type-safe get_tools(), typed webhook schemas, and a CLI env-var toolkit version override. • Adds env-var toolkit version override in the TypeScript CLI, letting operators pin or swap toolkit versions without code changes. • Adds typed schema for connection-expired webhook events in the core, so handlers can pattern-match on `composio.*` event types with full type safety. • Adds type-safe generic get_tools() in the Python SDK that infers return types based on the given provider. • Enables public URLs in the Python SDK (`feat(py): enable public URLs`). • Loosens the V3 webhook schema to accept any `composio.*` event type, broadening the range of subscribable webhook events.

Composio v0.11.0

Thu, 29 Jan 2026 10:34:49 GMT

Composio v0.11.0 adds Mastra v1 support, async webhook verification, redirect_url in connected accounts, and platform-specific file tool modifiers. • Adds `redirect_url` support in `connectedAccounts` for the TypeScript core SDK, enabling post-auth redirects in OAuth flows. • Introduces `composio.triggers.verifyWebhook` as an async method in the TypeScript SDK, removing the `node:crypto` dependency from triggers for broader runtime compatibility. • Adds a platform-specific file tool modifier in the TypeScript core SDK, allowing file tools to be adapted per deployment target. • Adds support for Mastra v1 in the TypeScript SDK, including e2e tests with Tool Router. • Optimizes `@composio/client` bandwidth usage in the CLI and introduces debug metrics. • Defaults tool selection to 'important tools' in the TypeScript core SDK when no explicit tool list is provided. • Adds secrets detection workflow for pull requests to the CI pipeline. • Adds an experimental assistive prompt to the client. Breaking changes: • `composio.triggers.verifyWebhook` is now async in the TypeScript SDK — callers must `await` it or their webhook verification will silently break. • Mastra v1 support is introduced as a breaking change in the TypeScript SDK — existing Mastra integrations targeting earlier versions may require updates.

Composio v0.10.6

Tue, 13 Jan 2026 08:42:49 GMT

Composio v0.10.6 adds Cloudflare Workers support, `auto_upload_download_files` flag, and Vercel AI v6 provider upgrade. • Adds `auto_upload_download_files` boolean flag to the Composio() Python constructor to control automatic file upload/download behavior. • Adds Cloudflare Workers runtime support in the TypeScript SDK. • Upgrades the Vercel provider in the TypeScript SDK to support AI v6. • Extends `composio.triggers.verifyWebhooks` to support webhook versions v1, v2, and v3.

Composio v0.10.5

Mon, 12 Jan 2026 15:25:35 GMT

Composio v0.10.5 adds wait-for-connections control, session-scoped execution modifiers, and auto file upload/download to the tool router. • Adds `waitForConnections` (TypeScript) / `wait_for_connections` (Python) property to `manageConnections` / `manage_connections` in toolRouter.create() / tool_router.create() to block session progression until users complete authentication. • Adds getRawToolRouterMetaTools(sessionId, { modifySchema }) (TypeScript) / get_raw_tool_router_meta_tools(session_id, modifiers) (Python) method on the Tools class for fetching meta tools directly from a tool router session. • Introduces `SessionExecuteMetaModifiers` and `SessionMetaToolOptions` modifier types, plus `@before_execute_meta` and `@after_execute_meta` decorators (Python), exposing `sessionId` / `session_id` to `beforeExecute` / `afterExecute` hooks for session-scoped tool execution control. • Adds `auto_upload_download_files` boolean flag to the Composio() constructor (Python) to control automatic file upload and download behaviour. • Upgrades the Vercel provider (TypeScript) to support Vercel AI SDK v6.

Composio @composio/vercel@0.4.0

Mon, 12 Jan 2026 15:24:53 GMT

Composio Vercel SDK 0.4.0 adds dedicated tools support for the tool router. • Adds support for dedicated tools for the tool router in `@composio/vercel`.

Composio v0.10.4

Mon, 12 Jan 2026 10:50:13 GMT

Composio v0.10.4 adds Anthropic Claude Code Agents provider, LangChain v1 port for TypeScript, and openWorldHint tag filters for the tool router. • Adds `openWorldHint` as a tag filter option in the tool router, enabling agents to distinguish open-world from closed-world tool scopes. • Adds Anthropic Claude Code Agents as a new provider in the core SDK. • Ports the LangChain integration to LangChain v1 in the TypeScript SDK. • Adds support for enable/disable tags and search within toolkits.

Composio v0.10.2

Tue, 23 Dec 2025 06:20:07 GMT

Composio v0.10.2 adds Anthropic Claude Code Agents provider, LangChain v1 support, and openWorldHint tool router filtering. • Adds `openWorldHint` as a tag filter for the tool router, enabling finer-grained control over which tools are surfaced by the router. • Adds Anthropic Claude Code Agents as a new provider in the core integration layer. • Ports the TypeScript LangChain integration to LangChain v1.

Composio v0.10.1

Tue, 16 Dec 2025 10:17:36 GMT

Composio v0.10.1 adds `composio generate --toolkits` flag for scoped code generation in TypeScript and Python. • Adds `--toolkits [toolkits]` argument to `composio generate`, letting practitioners scope code generation to specific toolkits for both TypeScript and Python.

Composio v0.10.0

Mon, 15 Dec 2025 08:29:40 GMT

Tool Router goes GA in Python and TypeScript SDKs, with webhook verification and LangChain v1 support added. • Adds composio.triggers.verifyWebhook() (TypeScript) and verify_webhook() on the `Triggers` class (Python) for signature-based webhook verification of incoming trigger payloads. • Promotes Tool Router from experimental to stable in both the Python (`composio==0.10.0`) and TypeScript (`@composio/core@0.3.0`) SDKs, enabling isolated MCP sessions with scoped toolkit access via composio.create(). • Adds native tool execution through `ToolRouterSession` in the Python SDK and an enhanced session.tools() method in the TypeScript SDK, allowing direct tool invocation without additional setup. • Ports the Python LangChain provider (`python/providers/langchain/`) to LangChain v1, updating APIs, dependencies, and examples. • Adds CommonJS support for `@composio/core` by switching the TypeScript bundler from `tsup` to `tsdown`, with a new CommonJS example at `ts/examples/cjs/`. • Adds `pnpm audit --prod` automated security vulnerability scanning to CI for the TypeScript SDK. • Updates `zod-to-json-schema` dependency to 3.25.0, adding support for zod v3 in the TypeScript SDK. • Integrates Tool Router sessions with AI frameworks including OpenAI, Anthropic, LangChain, LlamaIndex, CrewAI, and Vercel AI SDK. Breaking changes: • Deprecated MCP methods and classes have been removed; code using the old experimental composio.experimental.tool_router.create(...) API must migrate to composio.create(...).

Composio v0.9.3

Sat, 22 Nov 2025 15:53:18 GMT

Composio v0.9.3 adds LlamaIndex provider for the TS SDK, toolkit versioning support, and query-param/x-api-key auth in MCP URLs. • Adds LlamaIndex provider for the TypeScript SDK, enabling LlamaIndex-based agents to call Composio tools natively. • Adds toolkit versions support and deprecation flags to the TypeScript SDK, allowing pinning of specific toolkit versions for reproducible agent workflows. • Adds `x-api-key` header support in MCP URLs for authenticating MCP connections. • Adds query parameter support in MCP URLs for passing configuration inline. • Adds trigger signature verification, enabling consumers to validate the authenticity of incoming trigger payloads. • Adds support for both Zod 3 and Zod 4 in the JSON-Schema-to-Zod conversion layer of the TS SDK.

Composio v0.9.2

Mon, 10 Nov 2025 12:39:29 GMT

Composio v0.9.2 adds LlamaIndex provider for the TypeScript SDK and toolkit versioning with deprecation flags. • Adds toolkit versions support and deprecation flags to the TypeScript SDK, letting callers pin a specific toolkit version when executing tools. • Adds LlamaIndex as a provider for the TypeScript SDK, enabling LlamaIndex-based agents to use Composio tools natively. • Supports query parameters in MCP URLs, expanding MCP connection configurability. • Adds support for both Zod 3 and Zod 4 in the `json-schema-to-zod` package, removing the hard dependency on a single Zod major version.

Composio v0.9.1

Mon, 03 Nov 2025 06:33:49 GMT

Composio v0.9.1 adds LlamaIndex provider for the TypeScript SDK and toolkit versioning with deprecation flags. • Adds toolkit versions support and deprecation flags to the TypeScript SDK, enabling pinned, versioned toolkit consumption. • Adds LlamaIndex provider for the TypeScript SDK, expanding AI framework integrations. • Supports both Zod 3 and Zod 4 in the `json-schema-to-zod` conversion layer of the TypeScript SDK.

Composio @composio/core@0.2.1

Mon, 27 Oct 2025 13:26:26 GMT

Composio TypeScript SDK gains toolkit version pinning, deprecation flags, and no-auth identification for tools and triggers. • Adds `toolkit_versions` parameter to the `Triggers` class (defaults to `'latest'`) so callers can pin or select specific toolkit versions when listing trigger types. • Adds `isDeprecated` field to tool types returned by Tools.get() to surface whether a tool is deprecated. • Adds `isNoAuth` field to tool types returned by Tools.get() to identify tools that support no-auth mode. • Adds `version` field to trigger types to track individual trigger versions. • Adds `availableVersions` array to toolkit metadata to enumerate all available versions of a toolkit. • Makes the `Triggers` class generic to accept provider configuration, enabling typed provider config pass-through.

Composio v0.9.0

Wed, 22 Oct 2025 06:04:30 GMT

Composio v0.9.0 adds a LlamaIndex provider for the TypeScript SDK. • Adds LlamaIndex provider for the TypeScript SDK, enabling LlamaIndex-based agents to use Composio tools natively.

Composio @composio/google@0.2.0

Wed, 22 Oct 2025 05:58:34 GMT

Composio @composio/google@0.2.0 adds mandatory toolkit version validation for manual tool execution with new bypass flag and error types. • Adds `dangerously_skip_version_check` (Python) / `dangerouslySkipVersionCheck` (TypeScript) parameter to tools.execute() to optionally bypass version validation. • Adds `version` parameter to tools.execute() for passing an explicit toolkit version string (e.g. `'20251201_01'`) at call time. • Adds `toolkit_versions` configuration key to the `Tools` constructor for instance-level toolkit version pinning (e.g. `toolkit_versions={'github': '20251201_01'}`). • Supports `COMPOSIO_TOOLKIT_VERSION_` environment variables (e.g. `COMPOSIO_TOOLKIT_VERSION_GITHUB`) as a third option for version pinning without code changes. • Introduces `ToolVersionRequiredError` (Python) and `ComposioToolVersionRequiredError` (TypeScript) exceptions raised when tools.execute() is called with `latest` version and no skip flag, including error messages listing all four resolution options. • Manual tool execution via tools.execute() now validates toolkit versions before making API calls, preventing unexpected behavior from `latest` version drift. Breaking changes: • Manual tool execution via tools.execute() now raises `ToolVersionRequiredError` (Python) or `ComposioToolVersionRequiredError` (TypeScript) when no explicit version is specified and `dangerously_skip_version_check` is not set — any existing code calling tools.execute() without a version will break on upgrade.

Composio @composio/openai-agents@0.2.0

Wed, 22 Oct 2025 05:58:31 GMT

Composio OpenAI Agents 0.2.0 adds mandatory toolkit version validation for manual tool execution with four opt-out paths. • Adds version validation to tools.execute(): manual tool execution now requires an explicit toolkit version, preventing silent breakage from `latest` version drift. • New `dangerously_skip_version_check` parameter (Python) / `dangerouslySkipVersionCheck` (TypeScript) flag on tools.execute() to bypass version validation when needed. • New `ToolVersionRequiredError` exception (Python) and `ComposioToolVersionRequiredError` error (TypeScript) raised when a tool is executed against `latest` without the skip flag, each including resolution hints. • Supports toolkit version pinning via `toolkit_versions` dict at Tools() initialization — e.g. `toolkit_versions={'github': '20251201_01'}` — resolved consistently across both execute() and _execute_tool(). • Supports toolkit version pinning via environment variables in the format `COMPOSIO_TOOLKIT_VERSION_` (e.g. `COMPOSIO_TOOLKIT_VERSION_GITHUB=20251201_01`) as an alternative to code-level configuration. • Agentic framework integrations (LangChain, CrewAI, etc.) automatically set `dangerously_skip_version_check=True` internally, requiring no migration for those flows. Breaking changes: • Manual calls to tools.execute() using `latest` (the implicit default) now raise `ToolVersionRequiredError` (Python) or `ComposioToolVersionRequiredError` (TypeScript) unless a version is specified via the `version` argument, `toolkit_versions` at init, an environment variable like `COMPOSIO_TOOLKIT_VERSION_GITHUB`, or `dangerously_skip_version_check=True`.

Composio @composio/core@0.2.0

Wed, 22 Oct 2025 05:58:28 GMT

Composio @composio/core@0.2.0 adds mandatory toolkit version pinning for manual tool execution with multiple opt-out paths. • Adds `dangerously_skip_version_check` parameter (Python) / `dangerouslySkipVersionCheck` (TypeScript) to tools.execute() to bypass version validation when using `latest` toolkit versions. • Adds `ToolVersionRequiredError` exception (Python) and `ComposioToolVersionRequiredError` error (TypeScript) raised when tools.execute() is called with `latest` version and no skip flag, with error messages listing all four resolution paths. • Supports toolkit version pinning via `COMPOSIO_TOOLKIT_VERSION_` environment variables (e.g., `COMPOSIO_TOOLKIT_VERSION_GITHUB=20251201_01`) as an alternative to inline version arguments. • Supports per-call version pinning via `version` argument to tools.execute(), e.g., tools.execute('GITHUB_CREATE_ISSUE', arguments={...}, version='20251201_01'). • Supports instance-level version pinning via `toolkit_versions` dict at `Tools` initialization, e.g., Tools(client, provider, toolkit_versions={'github': '20251201_01'}). • Manual tool execution via tools.execute() now validates toolkit versions before API calls; agentic framework integrations (LangChain, CrewAI, etc.) are unaffected as they automatically set `dangerously_skip_version_check=True` internally. Breaking changes: • Calling tools.execute() manually with the `latest` toolkit version (the previous default) now raises `ToolVersionRequiredError` (Python) or `ComposioToolVersionRequiredError` (TypeScript) unless `dangerously_skip_version_check=True` / `dangerouslySkipVersionCheck: true` is passed or a specific version is supplied.

Composio @composio/llamaindex@0.2.0

Wed, 22 Oct 2025 05:58:25 GMT

Composio @composio/llamaindex@0.2.0 enforces toolkit version validation for manual tool execution, with new bypass flags and errors. • Adds `dangerously_skip_version_check` (Python) / `dangerouslySkipVersionCheck` (TypeScript) optional parameter to tools.execute() to bypass version validation when needed. • Adds `ToolVersionRequiredError` exception (Python) and `ComposioToolVersionRequiredError` error (TypeScript) raised when attempting to execute tools with `latest` version without the skip flag, including resolution suggestions. • Manual tool execution via tools.execute() now requires explicit toolkit version specification, configurable via `version` argument, `toolkit_versions` at Tools() initialization, or `COMPOSIO_TOOLKIT_VERSION_` environment variable. • Supports instance-level version configuration via `toolkit_versions` dict at Tools() construction, applying consistently across execute() and _execute_tool() calls. Breaking changes: • Manual calls to tools.execute() with `latest` toolkit version now raise `ToolVersionRequiredError` (Python) or `ComposioToolVersionRequiredError` (TypeScript) unless a specific version is supplied via the `version` argument, `toolkit_versions` config, the `COMPOSIO_TOOLKIT_VERSION_` environment variable, or `dangerously_skip_version_check=True`.

Composio @composio/cloudflare@0.2.0

Wed, 22 Oct 2025 05:58:22 GMT

Composio Cloudflare 0.2.0 adds mandatory toolkit version validation for manual tool execution with new skip flags and error types. • Adds `dangerously_skip_version_check` parameter (Python) / `dangerouslySkipVersionCheck` (TypeScript) to bypass toolkit version validation when executing tools manually. • Adds `version` parameter to tools.execute() for passing an explicit toolkit version (e.g. `'20251201_01'`) at call time. • Adds `toolkit_versions` configuration key to Tools() initializer for instance-level version pinning (e.g. `toolkit_versions={'github': '20251201_01'}`). • Supports `COMPOSIO_TOOLKIT_VERSION_` environment variables (e.g. `COMPOSIO_TOOLKIT_VERSION_GITHUB`) as a third path for pinning toolkit versions. • Introduces `ToolVersionRequiredError` (Python) and `ComposioToolVersionRequiredError` (TypeScript) exceptions raised when tools.execute() is called with the `latest` version without the skip flag, including resolution suggestions. • Manual tool execution via tools.execute() now validates toolkit versions before making API calls; agentic framework integrations (LangChain, CrewAI, etc.) are unaffected via automatic internal skip. Breaking changes: • Manual calls to tools.execute() that previously relied on the implicit `latest` version will now raise `ToolVersionRequiredError` (Python) or `ComposioToolVersionRequiredError` (TypeScript) unless an explicit `version` is provided, `toolkit_versions` is set at initialization, a `COMPOSIO_TOOLKIT_VERSION_` environment variable is present, or `dangerously_skip_version_check=True` is passed.

Composio @composio/mastra@0.2.0

Wed, 22 Oct 2025 05:58:19 GMT

Composio Mastra 0.2.0 adds mandatory toolkit version validation for manual tool execution with opt-out flags and new error types. • Adds `dangerouslySkipVersionCheck` (TypeScript) / `dangerously_skip_version_check` (Python) parameter to tools.execute() to bypass version validation when needed. • Adds `toolkit_versions` config at SDK initialization (e.g., Tools(client, provider, toolkit_versions={"github": "20251201_01"})) for instance-level version pinning. • Supports `COMPOSIO_TOOLKIT_VERSION_` environment variables (e.g., `COMPOSIO_TOOLKIT_VERSION_GITHUB=20251201_01`) to pin toolkit versions without code changes. • Introduces `ToolVersionRequiredError` (Python) and `ComposioToolVersionRequiredError` (TypeScript) errors with detailed resolution suggestions when `latest` version is used without the skip flag. • Manual tool execution via tools.execute() now validates toolkit versions before API calls, with four documented resolution paths included in error messages. Breaking changes: • Manual execution via tools.execute() now raises `ToolVersionRequiredError` (Python) or `ComposioToolVersionRequiredError` (TypeScript) when called with the `latest` toolkit version and no explicit version or `dangerously_skip_version_check` flag is provided.

Composio @composio/openai@0.2.0

Wed, 22 Oct 2025 05:58:16 GMT

Composio OpenAI SDK v0.2.0 adds mandatory toolkit version validation for manual tool execution with four opt-out paths. • Adds explicit toolkit version requirement for manual tools.execute() calls to prevent unexpected behavior from `latest` version drift. • New `dangerously_skip_version_check` parameter (Python) / `dangerouslySkipVersionCheck` (TypeScript) flag lets callers bypass version validation when needed. • Supports `toolkit_versions` dict at Tools() initialization (e.g. `toolkit_versions={"github": "20251201_01"}`) for instance-level version pinning applied to all subsequent calls. • Supports per-call `version` parameter on tools.execute() (e.g. `version="20251201_01"`) for one-off version overrides. • Supports `COMPOSIO_TOOLKIT_VERSION_` environment variables (e.g. `COMPOSIO_TOOLKIT_VERSION_GITHUB=20251201_01`) as a third version-pinning path. • Agentic framework integrations (LangChain, CrewAI, etc.) automatically set `dangerously_skip_version_check=True` internally, preserving backward compatibility. Breaking changes: • Manual tools.execute() calls that rely on the `latest` toolkit version will now raise `ToolVersionRequiredError` (Python) or `ComposioToolVersionRequiredError` (TypeScript) on upgrade unless a `version` parameter, `toolkit_versions` config, `COMPOSIO_TOOLKIT_VERSION_` env var, or `dangerously_skip_version_check=True` is supplied.

Composio @composio/langchain@0.2.0

Wed, 22 Oct 2025 05:58:13 GMT

Composio @composio/langchain@0.2.0 adds mandatory toolkit version validation for manual tool execution with four opt-out paths. • Adds `version` parameter to tools.execute() to require explicit toolkit version when executing tools manually, preventing unexpected behavior from `latest` version drift. • Adds `toolkit_versions` config dict at Tools() initialization (e.g., `toolkit_versions={"github": "20251201_01"}`) for instance-level version pinning across all executions. • Supports `COMPOSIO_TOOLKIT_VERSION_` environment variables (e.g., `COMPOSIO_TOOLKIT_VERSION_GITHUB`) as a third path to pin toolkit versions without code changes. • Adds `dangerously_skip_version_check` (Python) / `dangerouslySkipVersionCheck` (TypeScript) flag to tools.execute() to bypass version validation when needed. • Introduces `ToolVersionRequiredError` (Python) and `ComposioToolVersionRequiredError` (TypeScript) exceptions with four concrete resolution suggestions when `latest` is used without the skip flag. Breaking changes: • Manual tools.execute() calls that rely on the implicit `latest` toolkit version will now raise `ToolVersionRequiredError` (Python) or `ComposioToolVersionRequiredError` (TypeScript) unless a `version` is specified, `toolkit_versions` is configured at init, a `COMPOSIO_TOOLKIT_VERSION_` env var is set, or `dangerously_skip_version_check=True` is passed.

Composio @composio/anthropic@0.2.0

Wed, 22 Oct 2025 05:58:07 GMT

Composio @composio/anthropic 0.2.0 adds mandatory toolkit version validation for manual tool execution with escape hatches via flag, config, or env var. • Adds `dangerously_skip_version_check` parameter (Python) / `dangerouslySkipVersionCheck` (TypeScript) to tools.execute() to bypass version validation when needed. • Adds `version` parameter to tools.execute() for explicit per-call toolkit version pinning (e.g. `version='20251201_01'`). • Adds `toolkit_versions` config key to Tools() constructor for instance-level version pinning across all executions. • Supports `COMPOSIO_TOOLKIT_VERSION_` environment variables (e.g. `COMPOSIO_TOOLKIT_VERSION_GITHUB`) to set toolkit versions without code changes. • Introduces `ToolVersionRequiredError` (Python) and `ComposioToolVersionRequiredError` (TypeScript) exceptions raised when tools.execute() is called with `latest` version and no skip flag, including resolution suggestions. Breaking changes: • Manual tool execution via tools.execute() now raises `ToolVersionRequiredError` (Python) / `ComposioToolVersionRequiredError` (TypeScript) when the toolkit version resolves to `latest` and `dangerously_skip_version_check` is not set — existing call sites that relied on implicit `latest` resolution will break and must add an explicit `version`, a `toolkit_versions` config, a `COMPOSIO_TOOLKIT_VERSION_` env var, or `dangerously_skip_version_check=True`.

Composio @composio/vercel@0.2.12

Wed, 22 Oct 2025 05:58:04 GMT

Composio @composio/vercel@0.2.12 adds mandatory toolkit version validation for manual tool execution with new skip flags and error types. • Adds `dangerously_skip_version_check` parameter (Python) / `dangerouslySkipVersionCheck` (TypeScript) to tools.execute() to bypass version validation when needed. • Adds `toolkit_versions` config key at SDK initialization (e.g. Tools(client, provider, toolkit_versions={...})) for instance-level toolkit version pinning. • Supports `COMPOSIO_TOOLKIT_VERSION_` environment variables (e.g. `COMPOSIO_TOOLKIT_VERSION_GITHUB`) to specify toolkit versions without code changes. • Introduces `ToolVersionRequiredError` (Python) and `ComposioToolVersionRequiredError` (TypeScript) — raised when tools.execute() is called with `latest` version without the skip flag, with error messages covering 4 resolution options. • Agentic framework integrations (LangChain, CrewAI, etc.) automatically apply `dangerously_skip_version_check=True` internally to maintain backward compatibility. Breaking changes: • Manual tools.execute() calls using the `latest` toolkit version now raise `ToolVersionRequiredError` (Python) or `ComposioToolVersionRequiredError` (TypeScript) unless `dangerously_skip_version_check=True` is passed or a version is explicitly specified via the `version` parameter, `toolkit_versions` config, or a `COMPOSIO_TOOLKIT_VERSION_` environment variable.

Composio v0.8.20

Fri, 03 Oct 2025 05:02:11 GMT

Composio v0.8.20 adds `allow_multiple` for connected accounts and OpenAI Responses API support in the Python SDK. • Adds `allow_multiple` option to the Python SDK when creating connected accounts, enabling multiple connections to the same integration. • Adds support for the OpenAI Python Responses API in the Composio Python SDK.

Composio v0.8.16

Sat, 27 Sep 2025 07:53:35 GMT

Composio v0.8.16 adds an MCP API and ToolRouter capability. • Adds MCP API support to Composio core. • Adds ToolRouter alongside MCP integration for routing tool calls.

Composio @composio/anthropic@0.1.53

Fri, 26 Sep 2025 14:39:00 GMT

Composio @composio/anthropic 0.1.53 adds experimental ToolRouter and new MCP components. • Adds experimental `ToolRouter` for routing tool calls across integrations. • Introduces new MCP components, replacing the previous MCP experience; old components remain accessible via `deprecated.mcp` until the next release. Breaking changes: • The existing MCP components are deprecated and accessible only via `deprecated.mcp`; they will be removed in the next release.

Composio @composio/google@0.1.53

Fri, 26 Sep 2025 14:38:57 GMT

Composio @composio/google 0.1.53 adds an experimental ToolRouter and new MCP components. • Adds the new experimental `ToolRouter` for routing tool calls. • Introduces new MCP components, replacing the existing MCP experience; old MCP components remain accessible via `deprecated.mcp` until the next release.

Composio @composio/vercel@0.2.9

Fri, 26 Sep 2025 14:38:54 GMT

Composio Vercel SDK adds experimental ToolRouter and new MCP components, retiring the old MCP experience. • Adds experimental `ToolRouter` as a new capability for routing tools. • Introduces new MCP components, replacing the deprecated MCP experience; old components remain accessible via `deprecated.mcp` until the next release.

Composio @composio/openai@0.1.53

Fri, 26 Sep 2025 14:38:51 GMT

Composio OpenAI adds experimental ToolRouter and new MCP components, deprecating the old MCP experience. • Adds the new experimental `ToolRouter` for routing tool calls. • Introduces new MCP components, replacing the old MCP experience; old components remain accessible via `deprecated.mcp` until the next release.

Composio @composio/mastra@0.1.54

Fri, 26 Sep 2025 14:38:48 GMT

Composio Mastra 0.1.54 adds experimental ToolRouter and new MCP components, replacing the previous MCP experience. • Adds the new experimental `ToolRouter` for routing tool calls across integrations. • Introduces new MCP components to replace the deprecated MCP experience; old components remain accessible via `deprecated.mcp` until the next release. Breaking changes: • The existing MCP components are deprecated and moved to `deprecated.mcp`; they will be removed in the next release.

Composio @composio/openai-agents@0.1.54

Fri, 26 Sep 2025 14:38:45 GMT

Composio OpenAI Agents SDK gains experimental ToolRouter and new MCP components, replacing the previous MCP experience. • Adds the experimental `ToolRouter` for routing tool calls across integrations. • Introduces new MCP components, accessible via the updated MCP API; the old components remain available under `deprecated.mcp` until the next release. Breaking changes: • The existing MCP components are deprecated and will be removed in the next release; migrate away from the old MCP API now — the old components are temporarily accessible via `deprecated.mcp` only.

Composio @composio/core@0.1.53

Fri, 26 Sep 2025 14:38:42 GMT

Composio @composio/core@0.1.53 adds an experimental ToolRouter and new MCP components. • Adds the new experimental `ToolRouter` for routing tool calls. • Introduces new MCP components, accessible as the primary MCP experience going forward. • Old MCP components remain accessible via `deprecated.mcp` until the next release.

Composio @composio/langchain@0.1.53

Fri, 26 Sep 2025 14:38:39 GMT

Composio LangChain 0.1.53 adds experimental ToolRouter and new MCP components, replacing the prior MCP experience. • Introduces the experimental `ToolRouter` as a new routing layer for tool dispatch. • Adds new MCP components, replacing the existing MCP integration (old components accessible via `deprecated.mcp` until the next release). • Adds `description` to connection fields returned by `toolkits.list` and `toolkits.get` methods. Breaking changes: • The existing MCP components are deprecated and moved to `deprecated.mcp`; they will be removed in the next release.

Composio @composio/cloudflare@0.1.53

Fri, 26 Sep 2025 14:38:36 GMT

Composio Cloudflare 0.1.53 adds experimental ToolRouter and new MCP components, with old MCP accessible via `deprecated.mcp`. • Adds experimental `ToolRouter` for routing tool calls across integrations. • Introduces new MCP components to replace the existing MCP experience; old components remain accessible via `deprecated.mcp` until the next release. • Adds `description` to connection fields returned by `toolkits.list` and `toolkits.get` methods.

Composio v0.8.15

Fri, 19 Sep 2025 07:06:45 GMT

Adds `--type-tools` flag to the `ts generate` CLI command for typed tool generation. • Adds `--type-tools` support to the `ts generate` command, enabling typed tool generation from the CLI.

Composio 0.8.14

Tue, 16 Sep 2025 19:22:34 GMT

Composio 0.8.14 adds versioning support for tools. • Adds versioning support for tools, enabling management of multiple tool versions.

Composio v0.8.13

Tue, 16 Sep 2025 07:04:35 GMT

Composio v0.8.13 adds versioning support for tools. • Adds versioning support for tools, enabling practitioners to pin or target specific tool versions.

Composio v0.8.12

Mon, 15 Sep 2025 10:21:15 GMT

Composio v0.8.12 adds connected account lookup by user ID • Adds the ability to retrieve a connected account for a specific user via `user_id`.

Composio v0.8.11

Sun, 14 Sep 2025 05:07:58 GMT

Composio v0.8.11 adds Composio Connect Link support directly in the SDK • Adds Composio Connect Link support to the SDK, enabling programmatic generation of connection links for users.

Composio v0.8.9

Tue, 26 Aug 2025 05:51:18 GMT

Composio v0.8.9 adds Vercel AI SDK v5 support, a complete CLI `login` command, and a disable-version-check flag. • Adds `--disable-version-check` flag to the CLI to skip version validation on startup. • Completes the `login` command in the CLI, enabling full authentication workflows from the terminal. • Adds support for Vercel AI SDK v5 integration.

Composio v0.8.8

Fri, 15 Aug 2025 04:59:18 GMT

Composio v0.8.8 adds strict mode for Vercel AI SDK and CLI-based TypeScript type generation for trigger payloads and events. • Adds `strict mode` support in the Vercel AI SDK integration. • New CLI command generates TypeScript types for trigger payloads and events.

Composio v0.8.6

Mon, 04 Aug 2025 09:53:41 GMT

Composio v0.8.6 adds trigger event types, HTTP response caching via `FORCE_USE_CACHE=1`, and triggerTypes payload to code-generation commands. • Adds `FORCE_USE_CACHE=1` environment variable to the CLI to cache HTTP responses, reducing redundant network calls during development. • Adds `triggerTypes` payload support to `ts generate` and `py generate` CLI subcommands for richer type-safe code generation. • Adds trigger event types to the API surface. • Adds support for sending source and runtime headers in SDK requests.

Composio v0.8.2

Thu, 24 Jul 2025 04:53:21 GMT

Composio v0.8.2 adds CLI `upgrade` and `logout` commands plus configurable file download paths. • Adds `upgrade` subcommand to the CLI for in-place version upgrades. • Adds `logout` support to the CLI for user-context management. • Makes the file downloadable path configurable instead of hardcoded.

Composio v0.8.0

Mon, 21 Jul 2025 15:06:14 GMT

Composio v0.8.0 adds configurable file download paths and custom connection data support in proxy/tool execution. • Adds configurable file downloadable path support, letting users control where downloaded files are stored. • Supports custom connection data argument in `execute proxy` and tool execution calls.

Composio v0.7.20

Thu, 03 Jul 2025 08:48:04 GMT

Composio v0.7.20 increases the open file window size to 500 and adds a new MCP transport method. • Adds a new transport method for MCP connections. • Increases the open file window size to 500 lines.

Composio v0.7.19

Thu, 19 Jun 2025 14:45:11 GMT

Composio v0.7.19 adds a name argument and StreamableHTTP support to the MCP CLI setup command. • Adds `name` as a positional argument to the MCP CLI, allowing servers to be identified by name directly from the command line. • Adds `streamableHttp` transport support and the `name` argument to the MCP CLI `setup` command.

Composio v0.7.18

Fri, 13 Jun 2025 12:34:20 GMT

Composio v0.7.18 adds a `scopes` parameter to the action model for fine-grained permission control. • Adds `scopes` parameter to the action model, enabling explicit permission scope declarations on actions.

Composio v0.7.16

Tue, 27 May 2025 08:27:52 GMT

Composio v0.7.16 adds LiveKit and Qwen agent integrations plus MCP API references in docs • Adds Composio LiveKit integration for the Python SDK, enabling LiveKit-based agent workflows. • Adds Qwen agent integration via the agents SDK. • Adds MCP API references to documentation, covering the Model Context Protocol surface. • Uses `fern` to pull and filter OpenAPI specs for SDK generation.

Composio v0.7.15

Mon, 07 Apr 2025 21:48:21 GMT

Composio v0.7.15 adds Llama 4 agent support, v3 API migration, and updated MCP API references. • Adds Llama 4 agent integration for running agentic workflows with Meta's Llama 4 model. • Introduces v3 API migration with updated changelogs and v3 API references alongside updated MCP API refs. • Updates file utilities to support Windows file processing.

Composio v0.7.13

Tue, 01 Apr 2025 10:40:20 GMT

Composio v0.7.13 adds Mastra framework integration and MCP support with agents SDK example. • Adds Mastra framework integration instructions, enabling Composio tools to be used within the Mastra agent framework. • Adds Model Context Protocol (MCP) support with documentation and an agents SDK MCP example. • Adds tool-level documentation surfaced directly alongside individual tools.

Composio v0.7.12

Thu, 27 Mar 2025 06:33:28 GMT

Composio v0.7.12 adds a game builder integration powered by Gemini. • Adds a game builder capability using Gemini as the underlying agent.

Composio v0.7.11

Tue, 25 Mar 2025 05:47:14 GMT

Composio v0.7.11 adds Cursor MCP setup, S3 URL support, Slack computer-use, and a new current-user API endpoint. • Adds `cursor` setup command to the MCP CLI for configuring Cursor editor integration. • Adds `get_current_user_endpoint` to the apps API endpoint for retrieving the authenticated user. • Adds S3 URL support for file/asset handling. • Adds computer-use capability with Slack integration. • Bumps MCP CLI to version 0.4.0.

Composio v0.7.8

Fri, 14 Mar 2025 04:33:03 GMT

Composio v0.7.8 adds OpenAI Agents integration, MCP CLI package, auth scheme filtering, and Node 10 support. • Adds auth scheme support to the app list, enabling filtering of apps by authentication scheme. • Adds Composio OpenAI Agents integration as a new plugin. • Creates a separate package for the MCP CLI with CommonJS support for Node 10 compatibility. • Enhances schema optimization by removing unnecessary keys from tool schemas.

Composio v0.7.7

Mon, 10 Mar 2025 06:58:16 GMT

Composio v0.7.7 adds a Together AI plugin for the Python SDK and launches MCP Server support. • Adds Together AI plugin to the Python SDK, enabling Together AI as an integrated provider. • Launches Composio MCP Servers support with accompanying documentation. • Creates a new Axios instance per Composio instance in the JavaScript SDK, improving isolation between concurrent clients.

Composio v0.7.5

Wed, 05 Mar 2025 06:07:22 GMT

Composio v0.7.5 adds MCP command support for Claude/Windsurf, session-aware tracing, and a silent logging level. • Adds `mcp` command for Claude and Windsurf integrations. • Adds `allow_tracing` parameter to toolset-level configuration to control tracing per toolset. • Adds global-level tracing support, allowing tracing to retrieve log and session IDs. • Adds session information to tracing output. • Adds props for controlling tracing behavior. • Adds `silent` logging level for suppressing log output.

Composio v0.7.3

Thu, 20 Feb 2025 06:02:27 GMT

Composio v0.7.3 adds a response formatter to the TypeScript SDK and expands file processor and upload encoding support. • Adds a response formatter in the TypeScript SDK for structured action output handling. • Expands file processor support with updated file upload encoding capabilities. • Adds versioned actions usage documentation. • Adds new example agents: sales agent, HackerNews/Perplexity agent, game builder agent, loan underwriting agent, and Python Gemini examples.

Composio v0.7.2

Tue, 11 Feb 2025 10:42:38 GMT

Composio v0.7.2 adds Google Gemini, Agno, and smol agent plugins plus granular exception classes for external APIs. • Adds more granular exception classes for external APIs, enabling finer-grained error handling in integrations. • Adds a Google Gemini plugin, extending Composio's AI framework integrations to include Gemini. • Adds an Agno plugin, bringing Agno agent framework support to Composio. • Adds a smol agent plugin, enabling smol-agent workflows within Composio. • Adds a deep researcher example using the AI SDK.

Composio v0.7.1-0

Wed, 05 Feb 2025 17:27:58 GMT

Composio v0.7.1-0 adds no_auth scheme support, limitedActions filtering, checkRequest overrides, and trigger methods on toolsets. • Adds `no_auth` auth scheme type in Python, including proper error handling during `initiate_connection` for tools that require no authentication. • Adds `limitedActions` parameter to `getTools` to filter the returned action set to only the specified actions. • Adds support for `checkRequest` actions override in the OpenAI integration, enabling per-request action validation customization. • Adds trigger methods directly on the toolset object, allowing trigger management without a separate client call.

Composio v0.7.0

Tue, 04 Feb 2025 08:03:50 GMT

Composio v0.7.0 adds `connectedAccountIds` support at toolset init and updates file upload/download on toolsets. • Adds `connectedAccountIds` parameter to toolset initialization, enabling scoped tool execution against specific connected accounts. • Updates file upload and download mechanism on toolsets, improving how files are transferred through tool actions.

Composio v0.6.17

Fri, 24 Jan 2025 06:38:29 GMT

Composio v0.6.17 adds Pydantic AI integration and action versioning support. • Adds Pydantic AI integration with Composio, enabling Pydantic AI agents to use Composio-managed tools and connected accounts. • Implements action versioning, allowing callers to target specific versions of actions.

Composio js-v-0.5.5

Wed, 22 Jan 2025 09:38:13 GMT

Composio JS SDK v0.5.5 adds account enable/disable controls, reInitiateConnection(), and `appUniqueKeys` support. • Adds reInitiateConnection() method for managing and re-initiating existing connections. • Adds `appUniqueKeys` as a replacement identifier for `appName` when referencing apps. • Enables enabling and disabling connected accounts via the SDK. Breaking changes: • The .create() method on Connections is removed entirely — use .initiate() instead to create new connections. • Integration deletion now requires an object parameter instead of a string ID. • .getRequiredParams() on integrations now requires an object parameter instead of a string. • `.getTriggerInfo` is deprecated — use .get() on Triggers instead.

Composio v0.6.16

Mon, 20 Jan 2025 19:48:10 GMT

Composio v0.6.16 adds new integration/connection APIs, Helicone caching, crypto kit agents, and renames trigger identifiers. • Renames `triggerId` to `triggerName` and `triggerInstanceId`, and adds new methods for managing trigger connections via updated API schema. • Adds Helicone integration for caching OpenAI responses, reducing latency and cost for AI-backed workflows. • Introduces new API schema for creating integrations, initiating connections, re-initiating, and updating connections. • Adds crypto kit agents for cryptocurrency-related automation use cases. Breaking changes: • The `triggerId` field is renamed to `triggerName`; existing code or API calls referencing `triggerId` will break on upgrade.

Composio v0.6.15

Wed, 15 Jan 2025 06:08:43 GMT

Composio v0.6.15 adds `refresh_token` to AuthConnectionParamsModel • Adds `refresh_token` field to `AuthConnectionParamsModel`, exposing refresh tokens in authenticated connection parameters.

Composio v0.6.14

Tue, 14 Jan 2025 19:20:07 GMT

Composio v0.6.14 adds custom action support in the Vercel toolkit and updates the AutoGen tools integration. • Supports custom actions in the Vercel toolkit, with type safety improvements. • Updates AutoGen tools to a new version, refreshing the AutoGen integration.

Composio v0.6.10

Thu, 02 Jan 2025 08:26:26 GMT

Composio v0.6.10 adds JS agent support and custom auth delegation for runtime actions. • Adds support for delegating custom authentication to runtime actions, enabling dynamic auth injection at execution time. • Introduces JavaScript agent support (JS agents).

Composio js-v-0.5.0

Thu, 02 Jan 2025 07:20:56 GMT

Composio JS v0.5.0 adds frontend framework support, new trigger APIs, and slashes bundle size from 10 MB to 400 KB. • Adds `getTriggerInfo` and `getTriggerConfig` methods to the trigger interface for querying trigger metadata. • Exposes `.apps`, `.actions`, `.triggers`, and `.connectedAccounts` directly on toolset classes. • Exposes `ComposioToolset` from `index.ts` for top-level imports. • Adds a new typed API client with full type definitions. • All errors are now instances of `ComposioError`, each carrying an `error.error_code` property for programmatic debugging. • Adds support for frontend frameworks including React server components. • Reduces bundle size from 10 MB to 400 KB, enabling use in browser and edge environments. • Adds improved format for `PreProcessor`, `PostProcessor`, and `SchemaProcessor` types. • Adds Zod-based early validation and improved type safety across the SDK. Breaking changes: • Support for local and Docker workspaces has been removed; any code referencing workspace configurations will break. • In `toolset.createAction`, the `params` argument is renamed to `inputParams`, and the `callback` signature now receives `params` as its argument and must return `{ successful: boolean, data: object }` instead of a plain string. Callers using the old `params` key or returning plain strings must migrate.

Composio v0.6.9

Tue, 31 Dec 2024 09:21:51 GMT

Composio v0.6.9 adds custom auth injection for local tools and updated type definitions. • Allows injection of custom authentication for local tools, enabling practitioners to supply their own auth credentials when working with locally defined tools. • Updates types to align with backend definitions for improved API contract accuracy.

Composio v0.6.8

Tue, 31 Dec 2024 09:18:24 GMT

Composio v0.6.8 adds retry support in Action postprocessor and connected_account access in custom actions. • Supports requesting `connected_account` inside custom actions, enabling action authors to access the connected account context at runtime. • Adds retry support in the Action postprocessor, allowing failed action post-processing steps to be retried automatically.

Composio v0.6.7

Tue, 24 Dec 2024 13:57:59 GMT

Composio v0.6.7 adds trigger list support and expands SQL tooling with SQLite and remote database connections. • Adds trigger list support, enabling enumeration of available triggers via the Composio client. • Enhances the SQL Query Tool with SQLite and remote database support, broadening the range of data sources accessible through Composio actions.

Composio v0.6.4

Fri, 20 Dec 2024 09:51:36 GMT

Composio v0.6.4 adds SDR kit agents, initiate connection support, and TypeScript exports. • Adds SDR (Sales Development Representative) kit agents for automated outreach workflows. • Adds `initiate connection` support and new TypeScript exports to the SDK. • Updates the Phidata plugin to support the `use toolkit` interface. • Reduces TypeScript bundle size and brings ESLint and TypeScript issues to zero.

Composio v0.6.0

Thu, 12 Dec 2024 12:05:09 GMT

Composio v0.6.0 adds processor support, bundler support, object params for methods, and remove-integration capability. • Adds processor support alongside a move to object params for methods, enabling pre/post-processing of tool calls. • Adds bundler support for the JavaScript SDK. • Adds remove integration support via the CLI/SDK. • Revamps the `composio apps update` CLI command. • Improves 400-error handling with richer error messages.

Composio v0.5.51

Thu, 05 Dec 2024 12:01:07 GMT

Composio v0.5.51 adds advanced use-case search in the JS SDK, workflow dispatch, LangGraph integration, and `x-request-id` propagation. • Passes `x-request-id` header in all Composio API queries, enabling request tracing across distributed calls. • Adds advanced use-case search functionality in the JS SDK. • Adds workflow dispatch support with improved logging level controls. • Adds LangGraph integration for both Python and TypeScript. • Makes beta enum generation the default behavior.

Composio v0.5.50

Thu, 28 Nov 2024 12:15:34 GMT

Composio v0.5.50 adds a trigger list CLI command and app connector listing in the API reference. • Adds `trigger list` command to the CLI for listing available triggers. • Adds app connector listing in the API reference documentation. • Adds more detailed error message information for missing or invalid enum values.

Composio v0.5.49

Tue, 26 Nov 2024 17:43:27 GMT

Composio v0.5.49 adds advanced use case search capability. • Adds advanced use case search for discovering integrations and actions by use case.

Composio v0.5.47

Mon, 25 Nov 2024 06:30:19 GMT

Composio v0.5.47 adds request executor injection for runtime tools and case-insensitive trigger filtering. • Supports injecting a custom request executor into the runtime tool, enabling custom HTTP handling at execution time. • Makes trigger filter matching case-insensitive, so trigger names no longer need to match exact casing.

Composio v0.5.46

Sat, 23 Nov 2024 08:29:52 GMT

Composio v0.5.46 adds proxy support for custom actions and auto-creates integrations when no ID is provided. • Adds proxy support for executing custom actions, enabling custom actions to route through a configured proxy. • Auto-creates a new integration when no `integrationId` is provided, removing the requirement to pre-provision an integration before connecting.

Composio v0.5.45

Fri, 22 Nov 2024 18:38:56 GMT

Composio v0.5.45 auto-creates integrations on `initiate_connection` when none exists • Adds auto-initiation of a new integration when none exists on `initiate_connection`, removing the need to manually pre-create integrations before starting a connection flow.

Composio v0.5.44

Thu, 21 Nov 2024 11:46:26 GMT

Composio v0.5.44 adds `execute_request` method and friendlier trigger-not-enabled errors. • Adds `execute_request` method for direct HTTP request execution. • Shows a friendly error message when a trigger is not enabled on your account, replacing opaque failures.

Composio v0.5.43

Wed, 20 Nov 2024 08:04:17 GMT

Composio v0.5.43 defaults action execution to the 'primary' account label and adds improved callback filter error messages. • Automatically executes actions against the account labelled `primary` when no account is explicitly specified. • Adds improved error messages for wrong callback filters, helping developers diagnose misconfigured trigger callbacks faster. • Improves developer experience for the code analysis tool. • Adds `exclude` functionality to the file tool.

Composio v0.5.42

Thu, 14 Nov 2024 07:19:58 GMT

Composio v0.5.42 adds support for disconnecting and reconnecting trigger subscriptions. • Adds support for disconnecting and reconnecting trigger subscriptions, enabling more dynamic lifecycle management of event listeners.

Composio v0.5.39

Wed, 06 Nov 2024 02:24:22 GMT

Composio v0.5.39 adds Anthropic computer use tools and refactored SWE-agent support for LangGraph and CrewAI. • Adds Anthropic computer use tools integration. • Adds working SWE-agent in LangGraph and CrewAI, plus a PR-review agent in LangGraph, via SWEKit refactoring.

Composio v0.5.38

Mon, 04 Nov 2024 12:13:28 GMT

Composio v0.5.38 adds toolset.get_connected_accounts(), `streamWait` for OpenAI, and auto-update for failed remote apps. • Adds toolset.get_connected_accounts() method to retrieve all connected accounts from a toolset. • Adds `streamWait` method to the OpenAI integration and moves `getExpectedParamsForUser` in the JS SDK. • Renames `getAction` to `getTools` in the JS SDK. • Adds suggestion text and a documentation link to connection-not-found errors to help users self-serve. • Auto-updates apps when a remote app or action fails to load, reducing manual intervention on stale definitions. • Adds a SWE agent scaffold for software-engineering agent workflows. • Adds a Git custom tool integration. • Bumps the JS SDK to version 0.2.5 and updates the Cloudflare JS version. Breaking changes: • Deprecated methods removed in this release — any code calling the previously deprecated methods will break on upgrade.

Composio v0.5.37

Mon, 28 Oct 2024 11:35:42 GMT

Composio v0.5.37 adds a to-do list generator agent and boosts SWE-bench score to 48.6% with Claude v2. • Adds a to-do list generator agent to the agent library. • Upgrades the SWE-bench agent LLM to Claude v2, achieving a 48.6% SWE-bench score.

Composio v0.5.36

Fri, 25 Oct 2024 15:29:16 GMT

Composio v0.5.36 adds `check_connected_accounts` flag to `get_tools` and `auth_scheme` support on `get_expected_params_for_user`. • Adds `check_connected_accounts` flag to `get_tools` to filter tools based on whether the entity has connected accounts. • Adds `auth_scheme` parameter support on `get_expected_params_for_user` to specify the authentication scheme when retrieving expected auth params for a user. • Adds API key and `entityId` support for auth handling, enabling per-entity authentication flows.

Composio v0.5.35

Wed, 23 Oct 2024 07:20:18 GMT

Composio v0.5.35 adds user-defined auth for action execution and custom auth data support in the JS SDK. • Adds support for user-defined auth parameters during action execution in the Python SDK, enabling callers to supply custom credentials at runtime rather than relying solely on stored connections. • Adds custom auth data support in the JS SDK (released as JS SDK v0.2.3), bringing parity with the Python SDK for runtime auth overrides. • Makes `is_secret` a default argument in auth parameter definitions, simplifying how sensitive fields are declared. • Adds a Cloudflare + OpenAI integration example.

Composio v0.5.34

Thu, 17 Oct 2024 15:39:50 GMT

Composio v0.5.34 adds `getExpectedParamsForUser` method across all framework integrations. • Adds `getExpectedParamsForUser` method (and Python equivalent `get_expected_params_for_user`) to all framework integrations, enabling callers to retrieve the expected connection parameters for a given user.

Composio v0.5.32

Thu, 17 Oct 2024 10:37:37 GMT

Composio v0.5.32 adds user-defined auth params for connectors, integration ID lookup by app, and ExpectedFieldInput support • Adds `ExpectedFieldInput` attribute and a separate method for customer expected fields, enabling more precise definition of required auth inputs when configuring connectors. • Adds support for user-defined auth params when initialising connectors, giving practitioners control over custom authentication parameters at connector setup time. • Adds support for specifying connected account params when initialising a connected account. • Adds support for fetching integration ID using app name, simplifying programmatic lookup of integrations. • Logs session ID when ingesting logs and executing an action, improving traceability across action executions. • Adds top-level utils module for broader access to shared utilities. • Workspace dependencies are now definable as extras, allowing optional installation of workspace-specific dependencies.

Composio v0.5.31

Fri, 11 Oct 2024 09:45:26 GMT

Composio v0.5.31 adds log ingestion for local tool execution, an auth params API, and connection info in the JS SDK. • Adds log ingestion for local tool execution, enabling visibility into locally run tool actions. • Adds an auth params API for retrieving authentication parameters programmatically. • Adds connection info support and fixes the `initConnection` flow in the JavaScript SDK.

Composio v0.5.27

Mon, 23 Sep 2024 17:43:42 GMT

Composio v0.5.27 adds delete connected account and trigger APIs to the JS SDK, plus code indexing for non-Python repos. • Adds delete connected account and delete trigger APIs to the JavaScript SDK. • Extends code indexing support to non-Python repositories.

Composio v0.5.26

Mon, 23 Sep 2024 04:25:53 GMT

Composio v0.5.26 adds a Google plugin, Sheets DB sync, and skip-default-connector support. • Adds support for skipping the default connector via `skip default connector` (#ENG-1386). • Adds a new Google plugin integration. • Adds Sheets DB sync capability. • Adds integration YAML documentation support.

Composio v0.5.24

Wed, 18 Sep 2024 13:32:24 GMT

Composio v0.5.24 adds connection ID specifiers, remote enum opt-out, schema control, and a new Testing tool. • Adds support for connection ID specifiers, letting callers target a specific authenticated connection when invoking actions. • Adds support for disabling remote enum fetching, giving offline or air-gapped deployments control over schema resolution behaviour. • Adds support for changing the schema in Code Analysis tools, enabling custom schema configurations. • Adds a new Testing tool to the local toolset.

Composio v0.5.22

Fri, 13 Sep 2024 18:34:13 GMT

Composio v0.5.22 adds a SWE Autogen template and re-enables Pusher on listen. • Adds a SWE (Software Engineering) Autogen template for automating software engineering agent workflows. • Re-enables Pusher on `listen` to restore real-time event connectivity.

Composio v0.5.20

Fri, 13 Sep 2024 11:31:37 GMT

Composio v0.5.20 adds a JavaScript CLI and file upload/download support. • Adds Composio CLI for JavaScript, enabling JS-based workflows to manage Composio directly from the command line. • Adds file upload and download support.

Composio v0.5.17

Wed, 11 Sep 2024 08:32:47 GMT

Composio v0.5.17 adds a client Pusher key environment variable for real-time connection configuration. • Adds a client Pusher key environment variable for configuring real-time push connections.

Composio v0.5.11

Sat, 31 Aug 2024 11:36:23 GMT

Composio v0.5.11 adds `composio triggers show` command for inspecting trigger details from the CLI. • Adds `composio triggers show` subcommand to inspect trigger details directly from the CLI.

Composio v0.5.7

Tue, 27 Aug 2024 16:21:19 GMT

Composio v0.5.7 adds AgentOps integration and a new website roaster tool. • Adds AgentOps integration for agent observability and monitoring. • Adds `website_roaster` tool for website analysis. • Adds logging support to the core client.

Composio v0.5.0

Wed, 21 Aug 2024 18:06:52 GMT

Composio v0.5.0 adds human-in-the-loop support and removes legacy auth endpoints. • Adds human-in-the-loop workflow capability, enabling agent actions to pause and await human approval or input before proceeding. • Removes auth endpoints, consolidating authentication surface. Breaking changes: • Auth endpoints have been removed; integrations relying on those endpoints will break on upgrade.

Composio v0.4.5

Mon, 19 Aug 2024 10:54:56 GMT

Composio v0.4.5 adds OpenAPI-spec-based JavaScript SDK generation. • Generates a JavaScript SDK directly from the OpenAPI spec, enabling JS-native integration with Composio's action and trigger surfaces.

Composio v0.4.3

Fri, 16 Aug 2024 13:10:14 GMT

Composio v0.4.3 adds processors and metadata as plugin toolset arguments and a new frontend agent. • Adds `processors` and `metadata` as plugin toolset arguments, enabling per-plugin configuration of request/response processing and contextual metadata. • Adds a frontend agent capability to the platform.

Composio v0.4.2

Tue, 13 Aug 2024 14:04:40 GMT

Composio v0.4.2 adds Vercel AI SDK and Phidata integrations plus pre/post action processors • Adds `pre`/`post` action processors and top-level metadata config support, enabling hooks to run before and after any action execution. • New Vercel AI SDK integration, allowing Composio tools to be used directly within Vercel AI workflows. • New Phidata plugin, adding Composio support for the Phidata agent framework. • Updates e2b sandbox support in the JS SDK (bumped to v0.1.12).

Composio v0.4.1

Mon, 05 Aug 2024 13:49:06 GMT

Composio v0.4.1 adds browser tool support, LangGraph scaffolding, system tools, and a LlamaIndex agent integration. • Adds a browser tool integration for agent-driven web interaction. • Adds LangGraph scaffolding to support LangGraph-based agent workflows. • Adds system tools and a Rewind integration example. • Adds a LlamaIndex agent integration. • Enables API key retrieval from login credentials, streamlining authentication setup.

Composio v0.3.29

Fri, 26 Jul 2024 09:27:01 GMT

Composio v0.3.29 adds SWE Docker images and auto-login when adding tools. • Adds SWE Docker images for sandboxed software-engineering agent workflows. • Adds auto-login flow when adding a tool via `composio add`, reducing manual authentication steps.

Composio v0.3.28

Wed, 24 Jul 2024 19:54:03 GMT

Composio v0.3.28 adds a JavaScript SWE (Software Engineering) agent example and accompanying JS SWE documentation. • Adds a JavaScript SWE (Software Engineering) agent example, expanding Composio's agentic workflow support to JS environments.

Composio v0.3.26

Tue, 23 Jul 2024 16:07:00 GMT

Composio v0.3.26 adds COMPOSIO_BASE_URL config, JS SDK workspace support, and an in-memory file manager. • Adds `COMPOSIO_BASE_URL` environment variable to configure the base URL for the Composio service. • Adds workspace support to the JavaScript SDK. • Adds an in-memory file manager. • Passes OAuth scope through the authorization flow. • Adds a CLI release flow. • Adds a Docker release flow.

Composio v0.3.24

Fri, 19 Jul 2024 13:26:46 GMT

Composio v0.3.24 adds OAuth scope selection when adding connections and automatic GitHub token retrieval for agent workspaces. • Adds support for specifying OAuth scopes when adding a connection via `composio add`. • Reads GitHub access token automatically from the Composio account for agent workspaces, removing the need to supply it manually. • Switches Docker-based agent workspaces to use the tooling server.

Composio v0.3.21

Fri, 12 Jul 2024 07:18:16 GMT

Composio v0.3.21 adds LangGraph plugin, FlyIO workspace, paramiko shell sessions, code indexing, and new toolset methods. • Adds `get_agent_instruction` method to the toolset for retrieving agent instructions directly from tool configurations. • Adds `file_uploadable` option to support file upload capabilities in tool definitions. • Adds 'Add integration by id' function for retrieving integrations by their identifier. • Introduces a LangGraph plugin, enabling Composio tool use within LangGraph agent workflows. • Integrates paramiko for interactive shell sessions, enabling SSH-based interactive execution environments. • Adds FlyIO workspace support for running agent workloads on FlyIO infrastructure. • Adds code indexing capability for semantic search and navigation over codebases. • Adds a scheduler agent example built with CrewAI.

Composio v0.3.19

Wed, 10 Jul 2024 09:05:15 GMT

Composio v0.3.19 adds an `@action` decorator for custom actions and a new Spider scraper & crawler tool integration. • Adds `@action` decorator (importable at top level) to define custom actions directly in Python code. • Adds Spider scraper and crawler tool integration for web scraping and crawling workflows. • Ports Docker utilities to `swekit` for software-engineering kit workflows.

Composio v0.3.17

Tue, 09 Jul 2024 14:38:24 GMT

Composio v0.3.17 adds Camel-AI plugin, Cloudflare AI integration, Zep tool, multi-workspace support, and shell exit code reading. • Adds `$COMPOSIO_DEV_MODE` environment variable for development mode configuration. • Adds `composio-camel` plugin, integrating Composio with the Camel-AI framework. • Adds Cloudflare AI as a supported integration. • Adds `zep` as a supported tool within Composio. • Adds a `composio-core` package for core library functionality. • Adds support for reading exit codes on shells, enabling more reliable shell-based workflows. • Adds support for multiple workspaces, allowing concurrent isolated execution environments. • Adds support for user inputs within agent workflows. • Adds a Slack assistant integration. • Enables end-to-end evaluation on Composio-hosted Docker images. • Sets up host shell using Docker scripts for SWE agent environments.

Composio v0.3.14

Tue, 25 Jun 2024 03:30:58 GMT

Composio v0.3.14 adds runtime headers, score retrieval, and per-app action iteration. • Adds `x-source` and `x-runtime` headers to API requests, enabling runtime context to be passed with each call. • Supports iterating over actions for a specific app, allowing targeted enumeration of available actions per integration. • Adds score retrieval capability to the API.

Composio v0.3.13

Fri, 21 Jun 2024 09:49:37 GMT

Composio v0.3.13 adds use-case action search, text-driven argument generation, and API key validation on login. • Adds support for searching actions by use case, letting practitioners find relevant actions without knowing exact action names. • Adds support for using user-provided text to generate function arguments automatically. • Adds API key validation at login time, surfacing invalid credentials immediately. • Restructures Composio SWE (software engineering agent) layout to make it simpler to edit and extend. • Migrates to a monorepo structure unifying the Python SDK, JavaScript SDK, and docs.

Composio v0.3.11

Tue, 18 Jun 2024 13:55:02 GMT

Composio v0.3.11 adds a CLI for SWE workflows. • Adds a CLI for SWE (Software Engineering agent) workflows.

Composio v0.3.10

Tue, 18 Jun 2024 09:09:07 GMT

Composio v0.3.10 adds a LlamaIndex extension, a submit-patch command, and local tool support without an API key. • Adds `submit patch` command for submitting patches directly from the CLI. • Adds LlamaIndex extension, enabling Composio integration with LlamaIndex workflows. • Enables use of local tools without requiring an API key.

Composio v0.3.9

Sat, 08 Jun 2024 11:06:21 GMT

Composio v0.3.9 adds trigger error handling, entity trigger functions, file upload/download support, and SWE benchmark evaluation. • Adds trigger error tracking and trigger functions for entity objects, expanding event-driven automation capabilities. • Adds local file upload handling, enabling agents to upload files from the local workspace. • Adds download response handling for file-type action results, enabling agents to receive and process file downloads. • Includes `local_workspace` config directory in the distribution package, making local workspace tooling available out of the box. • Adds SWE benchmark evaluation support for measuring agent performance on software-engineering tasks. • Adds 'did you mean' suggestions to the CLI for mistyped commands, reducing friction during tool configuration. • Adds unexpected error tracking via Sentry for improved observability of runtime failures. • CLI `composio apps` command now displays app keys instead of display names for more reliable programmatic reference.

Composio v0.3.9rc4

Sat, 08 Jun 2024 08:35:02 GMT

Composio v0.3.9rc4 adds local file upload handling and file-based download response support. • Adds handling for local file uploads, enabling files to be submitted directly through the integration layer. • Adds handling for download responses written to file, supporting file-based output from API responses.

Composio v0.3.9-rc.3

Sat, 08 Jun 2024 07:11:31 GMT

Composio v0.3.9-rc.3 adds trigger functions for entity support. • Adds trigger functions for entity, enabling entities to subscribe to and handle triggers programmatically.

Composio v0.3.9-rc.2

Fri, 07 Jun 2024 12:48:27 GMT

Composio v0.3.9-rc.2 adds Sentry error tracking, bundles local_workspace config, and surfaces app keys in the CLI. • Includes `local_workspace` config directory in the distributed package, enabling local workspace configurations to ship with the tool. • Shows app keys instead of app names in `composio apps` CLI output, making programmatic references more actionable. • Adds unexpected error tracking via Sentry for improved observability of runtime failures. • Adds SWE benchmark evaluation support for assessing agent performance.

Composio v0.3.9-rc.1

Thu, 06 Jun 2024 05:37:39 GMT

Composio v0.3.9-rc.1 adds 'did you mean' suggestions and improved CLI help text. • Adds 'did you mean' suggestions to the CLI when a user miskeys a command or app name. • Improves CLI help text for clearer guidance on available commands and options. • Makes app name matching in `composio add` case-insensitive.

Composio v0.3.5

Sat, 01 Jun 2024 01:15:05 GMT

Composio v0.3.5 adds RAG and web tools alongside restructured local-tool types. • Adds RAG and web tool integrations as new local tools. • Updates enums for local tools with improved type structure.

Composio v0.3.0

Thu, 30 May 2024 03:49:55 GMT

Composio v0.3.0 adds Claude & Griptape plugins, no-auth entity support, local tools, and connection filtering by ID. • Adds support for filtering connections using a connection ID. • Adds no-auth entity support, enabling action execution without authentication. • Adds Claude and Griptape plugins for agent integrations. • Adds local tools support. • Adds a scheduler enum and scheduler usage examples. • Adds user image support for direct and isolated script execution.