Skip to content

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

fix(sdk): resolve toolkit versions case-insensitively in both SDKs (#3762)

Alberto Schiabel820abb907243
diff --git a/.changeset/toolkit-version-case-insensitive.md b/.changeset/toolkit-version-case-insensitive.md
new file mode 100644
index 000000000..d6c82704d
--- /dev/null
+++ b/.changeset/toolkit-version-case-insensitive.md
@@ -0,0 +1,5 @@
+---
+'@composio/core': patch
+---
+
+Resolve toolkit version pins case-insensitively. Version maps are keyed by normalized (lowercase) slugs, but `getToolkitVersion` previously looked them up with the raw slug, so a pin configured under a different casing (e.g. `{ GitHub: '20250101_00' }` or `COMPOSIO_TOOLKIT_VERSION_GITHUB`) could silently fall back to `'latest'`. Normalization is now centralized in a single `normalizeToolkitSlug` helper used symmetrically on both the write (map-building) and read (lookup) paths, so the two sides can no longer drift. This mirrors the equivalent fix in the Python SDK.
diff --git a/python/composio/utils/toolkit_version.py b/python/composio/utils/toolkit_version.py
index 1c96bdb5f..ebf9c2d93 100644
--- a/python/composio/utils/toolkit_version.py
+++ b/python/composio/utils/toolkit_version.py
@@ -8,6 +8,24 @@ import typing as t
from composio.core.types import ToolkitVersion, ToolkitVersionParam, ToolkitVersions
+def normalize_toolkit_slug(toolkit_slug: str) -> str:
+ """
+ Canonicalizes a toolkit slug into the form used as a version-map key.
+
+ Toolkit slugs are matched case-insensitively. This is the single source of
+ truth for that rule: every write into a version map (env vars, user-supplied
+ dicts) and every read out of one MUST go through this helper so the two sides
+ can never drift apart and silently miss a configured pin.
+
+ Kept intentionally equivalent to the TypeScript SDK's ``normalizeToolkitSlug``
+ (see ts/packages/core/src/utils/toolkitVersion.ts).
+
+ :param toolkit_slug: The slug/name of the toolkit, in any casing
+ :return: The normalized (lowercase) slug used as a version-map key
+ """
+ return toolkit_slug.lower()
+
+
def get_toolkit_version(
toolkit_slug: str, toolkit_versions: t.Optional[ToolkitVersionParam] = None
) -> ToolkitVersion:
@@ -23,9 +41,11 @@ def get_toolkit_version(
if isinstance(toolkit_versions, str):
return toolkit_versions
- # If toolkit_versions is a dict mapping, look up the specific toolkit version
+ # If toolkit_versions is a dict mapping, look up the specific toolkit version.
+ # The map is keyed by normalized slugs, so normalize the lookup too
+ # (see normalize_toolkit_slug for why).
if isinstance(toolkit_versions, dict) and len(toolkit_versions) > 0:
- return toolkit_versions.get(toolkit_slug, "latest")
+ return toolkit_versions.get(normalize_toolkit_slug(toolkit_slug), "latest")
# Else use 'latest'
return "latest"
@@ -55,14 +75,15 @@ def get_toolkit_versions(
for key, value in os.environ.items():
if key.startswith("COMPOSIO_TOOLKIT_VERSION_"):
toolkit_name = key.replace("COMPOSIO_TOOLKIT_VERSION_", "")
- toolkit_versions_from_env[toolkit_name.lower()] = value
+ toolkit_versions_from_env[normalize_toolkit_slug(toolkit_name)] = value
- # If the provided default versions is a dict, normalize the keys to be lower case
- # Use user provided values as overrides
+ # Normalize keys via normalize_toolkit_slug (the same helper the lookup uses);
+ # user-provided values override env.
user_provided_toolkit_versions: ToolkitVersions = {}
if default_versions and isinstance(default_versions, dict):
user_provided_toolkit_versions = {
- key.lower(): value for key, value in default_versions.items()
+ normalize_toolkit_slug(key): value
+ for key, value in default_versions.items()
}
# Final toolkit versions
diff --git a/python/tests/test_toolkit_version.py b/python/tests/test_toolkit_version.py
index 30b76e1eb..65112a009 100644
--- a/python/tests/test_toolkit_version.py
+++ b/python/tests/test_toolkit_version.py
@@ -124,6 +124,19 @@ class TestToolkitVersion:
expected = {"github": "v1.0.0", "slack": "v2.0.0", "openai": "v3.0.0"}
assert result == expected
+ def test_get_toolkit_version_lookup_is_case_insensitive(self):
+ """The lookup slug is matched case-insensitively.
+
+ Version maps are keyed by normalized (lowercase) slugs (write side
+ covered by test_user_dict_case_normalization), so the read side must
+ resolve any-cased slugs instead of silently returning 'latest'.
+ """
+ versions = {"github": "v1.0.0"}
+
+ assert get_toolkit_version("GITHUB", versions) == "v1.0.0"
+ assert get_toolkit_version("GitHub", versions) == "v1.0.0"
+ assert get_toolkit_version("github", versions) == "v1.0.0"
+
def test_priority_order_matches_typescript(self):
"""Test that priority order matches TypeScript implementation.
diff --git a/ts/packages/core/src/utils/sdk.ts b/ts/packages/core/src/utils/sdk.ts
index fdd76d553..89c22ea62 100644
--- a/ts/packages/core/src/utils/sdk.ts
+++ b/ts/packages/core/src/utils/sdk.ts
@@ -4,6 +4,7 @@ import { getEnvsWithPrefix, getEnvVariable } from './env';
import logger from './logger';
import { ComposioError } from '../errors/ComposioError';
import { ToolkitVersion, ToolkitVersionParam, ToolkitVersions } from '../types/tool.types';
+import { normalizeToolkitSlug } from './toolkitVersion';
import { platform } from '#platform';
// File path helpers
@@ -82,16 +83,16 @@ export function getToolkitVersionsFromEnv(
const envPrefixedVersions = getEnvsWithPrefix(`COMPOSIO_TOOLKIT_VERSION_`);
const toolkitVersionsFromEnv = Object.entries(envPrefixedVersions).reduce((acc, [key, value]) => {
const toolkitName = key.replace('COMPOSIO_TOOLKIT_VERSION_', '');
- acc[toolkitName.toLowerCase()] = value as ToolkitVersion;
+ acc[normalizeToolkitSlug(toolkitName)] = value as ToolkitVersion;
return acc;
}, {} as ToolkitVersions);
- // if the provided default versions is an object, normalize the keys to be lower case
- // use user provided values as overrides
+ // normalize keys via normalizeToolkitSlug (the same helper the lookup uses);
+ // user provided values act as overrides
let userProvidedToolkitVersions = {};
if (defaultVersions && typeof defaultVersions === 'object') {
userProvidedToolkitVersions = Object.fromEntries(
- Object.entries(defaultVersions).map(([key, value]) => [key.toLowerCase(), value])
+ Object.entries(defaultVersions).map(([key, value]) => [normalizeToolkitSlug(key), value])
);
}
diff --git a/ts/packages/core/src/utils/toolkitVersion.ts b/ts/packages/core/src/utils/toolkitVersion.ts
index 87488dbb8..ea21d26af 100644
--- a/ts/packages/core/src/utils/toolkitVersion.ts
+++ b/ts/packages/core/src/utils/toolkitVersion.ts
@@ -1,5 +1,22 @@
import { ToolkitVersion, ToolkitVersionParam } from '../types/tool.types';
+/**
+ * Canonicalizes a toolkit slug into the form used as a version-map key.
+ *
+ * Toolkit slugs are matched case-insensitively. This is the single source of
+ * truth for that rule: every write into a version map (env vars, user-supplied
+ * objects — see `getToolkitVersionsFromEnv`) and every read out of one MUST go
+ * through this helper so the two sides can never drift apart and silently miss a
+ * configured pin.
+ *
+ * Kept intentionally equivalent to the Python SDK's `normalize_toolkit_slug`
+ * (see python/composio/utils/toolkit_version.py).
+ *
+ * @param toolkitSlug - The slug/name of the toolkit, in any casing
+ * @returns The normalized (lowercase) slug used as a version-map key
+ */
+export const normalizeToolkitSlug = (toolkitSlug: string): string => toolkitSlug.toLowerCase();
+
/**
* Gets the version for a specific toolkit based on the provided toolkit versions configuration.
*
@@ -15,10 +32,12 @@ export const getToolkitVersion = (
if (typeof toolkitVersions === 'string') {
return toolkitVersions;
}
- // If toolkitVersions is an object mapping, look up the specific toolkit version
+ // If toolkitVersions is an object mapping, look up the specific toolkit version.
+ // The map is keyed by normalized slugs, so normalize the lookup too
+ // (see normalizeToolkitSlug for why).
const hasToolkitVersion = toolkitVersions && Object.keys(toolkitVersions).length > 0;
if (hasToolkitVersion) {
- return toolkitVersions[toolkitSlug] ?? 'latest';
+ return toolkitVersions[normalizeToolkitSlug(toolkitSlug)] ?? 'latest';
}
// Else use 'latest'
diff --git a/ts/packages/core/test/core/versions.test.ts b/ts/packages/core/test/core/versions.test.ts
index f2d53c899..75c53e11b 100644
--- a/ts/packages/core/test/core/versions.test.ts
+++ b/ts/packages/core/test/core/versions.test.ts
@@ -283,15 +283,17 @@ describe('Version Management', () => {
expect(result).toBe('latest');
});
- it('should be case-sensitive for toolkit slugs', () => {
+ it('should resolve the lookup slug case-insensitively', () => {
+ // Version maps are keyed by normalized (lowercase) slugs (write side
+ // covered by 'should normalize toolkit names to lowercase'), so the read
+ // side must resolve any casing instead of falling back to 'latest'.
const toolkitVersions = {
github: '20250902_00',
- GITHUB: 'latest',
};
expect(getToolkitVersion('github', toolkitVersions)).toBe('20250902_00');
- expect(getToolkitVersion('GITHUB', toolkitVersions)).toBe('latest');
- expect(getToolkitVersion('GitHub', toolkitVersions)).toBe('latest'); // not found
+ expect(getToolkitVersion('GITHUB', toolkitVersions)).toBe('20250902_00');
+ expect(getToolkitVersion('GitHub', toolkitVersions)).toBe('20250902_00');
});
});