Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
TypeScript agentic-aiagentsaiai-agentsaiagentsdeveloper-toolsfunction-callinggpt-4javascriptjsllmllmopsmcppythonremote-mcp-serverssetypescript
fix(py): address cursorbot, introduce json-schema-to-pydantic
jkomynod159c4600ff3
diff --git a/python/composio/utils/schema_converter.py b/python/composio/utils/schema_converter.pynew file mode 100644index 000000000..c69f6382e--- /dev/null+++ b/python/composio/utils/schema_converter.py@@ -0,0 +1,286 @@+"""+JSON Schema to Pydantic type conversion using json-schema-to-pydantic library.++This module provides a wrapper around json-schema-to-pydantic that maintains+backwards compatibility with the existing json_schema_to_pydantic_type() API.++The library handles most JSON Schema features correctly, but doesn't support+boolean schemas (true/false values that are valid in JSON Schema draft-06+).+We handle those by pre-filtering them before passing to the library.+"""++import typing as t+from functools import reduce++from json_schema_to_pydantic import (+ create_model as create_model_from_schema,+ SchemaError,+ CombinerError,+)++from composio.utils.logging import get as get_logger++logger = get_logger(__name__)++# Type mapping for simple cases where we don't need full model creation+PYDANTIC_TYPE_TO_PYTHON_TYPE = {+ "string": str,+ "integer": int,+ "number": float,+ "boolean": bool,+ "array": t.List,+ "object": t.Dict,+ "null": t.Optional[t.Any],+}++CONTAINER_TYPE = ("array", "object")++# Should be deprecated,+# required values will always be provided by users+# Non-required values are nullable(None) if default value not provided.+FALLBACK_VALUES = {+ "string": "",+ "number": 0.0,+ "integer": 0,+ "boolean": False,+ "object": {},+ "array": [],+ "null": None,+}+++def _filter_boolean_schemas(+ schema: t.Union[t.Dict[str, t.Any], bool, t.List],+) -> t.Union[t.Dict[str, t.Any], t.Any, None]:+ """+ Pre-filter boolean schemas from anyOf/allOf/oneOf arrays.++ JSON Schema draft-06+ allows `true` and `false` as valid schemas:+ - `true` means "accept any value" (equivalent to {})+ - `false` means "reject all values" (equivalent to {"not": {}})++ The json-schema-to-pydantic library doesn't handle these, so we:+ - Replace `true` with {} (empty schema, accepts anything)+ - Filter out `false` (rejects everything, so no point including it)++ Returns None if the schema is a standalone `false` boolean.+ """+ if isinstance(schema, bool):+ if schema:+ # true -> empty schema (accepts any value)+ return {}+ else:+ # false -> reject all, return None to filter out+ return None++ if isinstance(schema, list):+ # Filter list items (e.g., for anyOf arrays)+ filtered = []+ for item in schema:+ result = _filter_boolean_schemas(item)+ if result is not None:+ filtered.append(result)+ return filtered if filtered else None++ if not isinstance(schema, dict):+ return schema++ # Make a copy to avoid mutating the original+ result = {}+ for key, value in schema.items():+ if key in ("anyOf", "allOf", "oneOf"):+ # Filter boolean schemas from combiner arrays+ filtered_value = _filter_boolean_schemas(value)+ if filtered_value is None or (+ isinstance(filtered_value, list) and len(filtered_value) == 0+ ):+ # All schemas were false, skip this combiner+ continue+ result[key] = filtered_value+ elif key == "items" and isinstance(value, (dict, bool)):+ # Handle array items schema+ filtered_items = _filter_boolean_schemas(value)+ if filtered_items is not None:+ result[key] = filtered_items+ elif key == "properties" and isinstance(value, dict):+ # Recursively filter property schemas+ filtered_props = {}+ for prop_name, prop_schema in value.items():+ filtered_prop = _filter_boolean_schemas(prop_schema)+ if filtered_prop is not None:+ filtered_props[prop_name] = filtered_prop+ result[key] = filtered_props+ elif key in ("$defs", "definitions") and isinstance(value, dict):+ # Recursively filter definitions+ filtered_defs = {}+ for def_name, def_schema in value.items():+ filtered_def = _filter_boolean_schemas(def_schema)+ if filtered_def is not None:+ filtered_defs[def_name] = filtered_def+ result[key] = filtered_defs+ else:+ result[key] = value++ return result+++def json_schema_to_pydantic_type(+ json_schema: t.Union[t.Dict[str, t.Any], bool],+) -> t.Union[t.Type, t.Optional[t.Any]]:+ """+ Converts a JSON schema type to a Pydantic type.++ Uses json-schema-to-pydantic for complex schemas (anyOf, allOf, oneOf),+ falls back to simple type mapping for primitive types.++ :param json_schema: The JSON schema to convert (can be dict or boolean).+ :return: A Pydantic type.+ """+ # Handle boolean schemas (JSON Schema draft-06+)+ if isinstance(json_schema, bool):+ if json_schema:+ return t.Any # true schema accepts any value+ else:+ return None # false schema - will be filtered out in union processing++ # Pre-filter boolean schemas from combiners+ filtered_schema = _filter_boolean_schemas(json_schema)+ if filtered_schema is None:+ return str # Fallback if all schemas were false++ # Handle simple primitive types without complex combiners+ if _is_simple_primitive(filtered_schema):+ return _convert_simple_type(filtered_schema)++ # Use library for complex schemas (anyOf, allOf, oneOf, nested objects)+ return _convert_with_library(filtered_schema)+++def _is_simple_primitive(schema: t.Dict[str, t.Any]) -> bool:+ """Check if schema is a simple primitive without combiners."""+ has_combiners = any(k in schema for k in ("anyOf", "allOf", "oneOf"))+ has_properties = "properties" in schema+ schema_type = schema.get("type")++ return (+ not has_combiners+ and not has_properties+ and schema_type in PYDANTIC_TYPE_TO_PYTHON_TYPE+ and schema_type not in CONTAINER_TYPE+ )+++def _convert_simple_type(schema: t.Dict[str, t.Any]) -> t.Type:+ """Convert simple primitive types directly."""+ type_ = schema.get("type", "string")+ return PYDANTIC_TYPE_TO_PYTHON_TYPE.get(type_, str)+++def _convert_with_library(+ schema: t.Dict[str, t.Any],+) -> t.Union[t.Type, t.Any]:+ """Use json-schema-to-pydantic for complex schema conversion."""+ try:+ # Handle top-level combiner without type (e.g., {"anyOf": [...]})+ if (+ any(k in schema for k in ("anyOf", "allOf", "oneOf"))+ and "type" not in schema+ ):+ return _handle_toplevel_combiner(schema)++ # For object schemas, create model directly+ if schema.get("type") == "object":+ if "title" not in schema:+ schema = {**schema, "title": "GeneratedModel"}+ return create_model_from_schema(+ schema,+ allow_undefined_array_items=True,+ allow_undefined_type=True,+ )++ # For array schemas+ if schema.get("type") == "array":+ items = schema.get("items")+ if items:+ item_type = json_schema_to_pydantic_type(items)+ return t.List[t.cast(t.Type, item_type)] # type: ignore+ return t.List++ # Fallback to simple type+ return _convert_simple_type(schema)++ except (SchemaError, CombinerError) as e:+ logger.debug(f"Library schema conversion failed: {e}, falling back to string")+ return str+ except Exception as e:+ logger.debug(+ f"Unexpected error in schema conversion: {e}, falling back to string"+ )+ return str+++def _handle_toplevel_combiner(+ schema: t.Dict[str, t.Any],+) -> t.Union[t.Type, t.Any]:+ """+ Handle top-level combiner schemas (anyOf, allOf, oneOf without "type").++ The library can handle these directly - it returns the appropriate type.+ """+ try:+ # Try direct conversion - library handles anyOf/oneOf/allOf at top level+ result = create_model_from_schema(+ schema,+ allow_undefined_array_items=True,+ allow_undefined_type=True,+ )+ # If result is a type (like a Union or Optional), return it directly+ # If result is a model class, return it+ return result+ except (SchemaError, CombinerError):+ pass+ except Exception:+ pass++ # Fallback: manually build union type for anyOf/oneOf+ if "anyOf" in schema or "oneOf" in schema:+ options = schema.get("anyOf", schema.get("oneOf", []))+ return _build_union_from_options(options)++ # Fallback: use first option for allOf+ if "allOf" in schema and schema["allOf"]:+ return json_schema_to_pydantic_type(schema["allOf"][0])++ return t.Any+++def _build_union_from_options(options: t.List[t.Dict[str, t.Any]]) -> t.Type:+ """Build a Union type from a list of schema options."""+ pydantic_types = []+ null_type = PYDANTIC_TYPE_TO_PYTHON_TYPE.get("null")+ has_null = False++ for option in options:+ ptype = json_schema_to_pydantic_type(option)+ if ptype is None:+ continue+ if ptype == null_type or ptype is type(None):+ has_null = True+ continue+ pydantic_types.append(ptype)++ if len(pydantic_types) == 0:+ return str # Fallback++ if len(pydantic_types) == 1:+ base_type = pydantic_types[0]+ if has_null:+ return t.Optional[t.cast(t.Type, base_type)] # type: ignore+ return base_type++ # Build union+ cast_types = [t.cast(t.Type, ptype) for ptype in pydantic_types]+ union_type = reduce(lambda a, b: t.Union[a, b], cast_types) # type: ignore+ if has_null:+ return t.Optional[union_type] # type: ignore+ return union_typediff --git a/python/composio/utils/shared.py b/python/composio/utils/shared.pyindex 339f015e7..743bc7644 100644--- a/python/composio/utils/shared.py+++ b/python/composio/utils/shared.py@@ -4,153 +4,39 @@ Shared utils.import typing as timport uuid-from functools import reducefrom inspect import Parameterfrom pydantic import BaseModel, Field, create_modelfrom pydantic.fields import FieldInfofrom composio.utils.logging import get as get_logger+from composio.utils.schema_converter import (+ json_schema_to_pydantic_type,+ PYDANTIC_TYPE_TO_PYTHON_TYPE,+ CONTAINER_TYPE,+ FALLBACK_VALUES,+)logger = get_logger(__name__)-PYDANTIC_TYPE_TO_PYTHON_TYPE = {- "string": str,- "integer": int,- "number": float,- "boolean": bool,- "array": t.List,- "object": t.Dict,- "null": t.Optional[t.Any],-}--CONTAINER_TYPE = ("array", "object")--# Should be deprecated,-# required values will always be provided by users-# Non-required values are nullable(None) if default value not provided.-FALLBACK_VALUES = {- "string": "",- "number": 0.0,- "integer": 0,- "boolean": False,- "object": {},- "array": [],- "null": None,-}+# Re-export for backward compatibility+__all__ = [+ "json_schema_to_pydantic_type",+ "PYDANTIC_TYPE_TO_PYTHON_TYPE",+ "CONTAINER_TYPE",+ "FALLBACK_VALUES",+ "json_schema_to_pydantic_field",+ "json_schema_to_fields_dict",+ "json_schema_to_model",+ "pydantic_model_from_param_schema",+ "get_signature_format_from_schema_params",+ "get_pydantic_signature_format_from_schema_params",+ "generate_request_id",+]reserved_names = ["validate"]-def json_schema_to_pydantic_type(- json_schema: t.Union[t.Dict[str, t.Any], bool],-) -> t.Union[t.Type, t.Optional[t.Any]]:- """- Converts a JSON schema type to a Pydantic type.-- :param json_schema: The JSON schema to convert (can be dict or boolean).- :return: A Pydantic type.- """- # Handle boolean schemas (JSON Schema draft-06+)- # true = accept anything, false = reject everything- if isinstance(json_schema, bool):- if json_schema:- return t.Any # true schema accepts any value- else:- return None # false schema - will be filtered out in union processing-- # Handle oneOf schemas first- if "oneOf" in json_schema:- one_of_options = json_schema["oneOf"]- pydantic_types = [- json_schema_to_pydantic_type(option) for option in one_of_options- ]- # Filter out None values and ensure we have valid types- valid_types = [ptype for ptype in pydantic_types if ptype is not None]- if len(valid_types) == 1:- return valid_types[0]- if len(valid_types) == 0:- return str # fallback to string type- # Create Union with any number of types- # Cast all types and use functools.reduce to create proper Union- cast_types = [t.cast(t.Type, ptype) for ptype in valid_types]- # Use reduce to create Union[Type1, Type2, ...] properly- return reduce(lambda a, b: t.Union[a, b], cast_types) # type: ignore-- # Handle anyOf schemas (commonly used for nullable types)- if "anyOf" in json_schema:- any_of_options = json_schema["anyOf"]- pydantic_types = [- json_schema_to_pydantic_type(option) for option in any_of_options- ]- # Filter out None/null types for the base type- # "null" type maps to t.Optional[t.Any], so we need to check for that too- null_type = PYDANTIC_TYPE_TO_PYTHON_TYPE.get("null")- has_null = any(- ptype == null_type or ptype is type(None)- for ptype in pydantic_types- if ptype is not None- )- valid_types = [- ptype- for ptype in pydantic_types- if ptype is not None and ptype is not type(None) and ptype != null_type- ]- if len(valid_types) == 0:- return str # fallback to string type- if len(valid_types) == 1:- base_type = valid_types[0]- # If null was one of the options, make it Optional- if has_null:- return t.Optional[t.cast(t.Type, base_type)] # type: ignore- return base_type- cast_types = [t.cast(t.Type, ptype) for ptype in valid_types]- union_type = reduce(lambda a, b: t.Union[a, b], cast_types) # type: ignore- # If null was one of the options, include None in the Union- if has_null:- return t.Optional[union_type] # type: ignore- return union_type-- # Handle allOf schemas (usually for combining schemas)- if "allOf" in json_schema:- all_of_options = json_schema["allOf"]- # For allOf with single option, use that option's type- if len(all_of_options) == 1:- return json_schema_to_pydantic_type(all_of_options[0])- # For multiple allOf options, try to find the primary type- # Usually the first non-ref schema or the one with "type" key- for option in all_of_options:- if "type" in option:- return json_schema_to_pydantic_type(option)- # Fallback: process first option- if all_of_options:- return json_schema_to_pydantic_type(all_of_options[0])-- # Add fallback type - string- if "type" not in json_schema:- json_schema["type"] = "string"- type_ = t.cast(str, json_schema.get("type"))- if type_ == "array":- items_schema = json_schema.get("items")- if items_schema:- ItemType = json_schema_to_pydantic_type(items_schema)- return t.List[t.cast(t.Type, ItemType)] # type: ignore- return t.List-- if type_ == "object":- properties = json_schema.get("properties")- if properties:- nested_model = json_schema_to_model(json_schema)- return nested_model- return t.Dict-- pytype = PYDANTIC_TYPE_TO_PYTHON_TYPE.get(type_)- if pytype is not None:- return pytype-- raise ValueError(f"Unsupported JSON schema type: {type_}")--def json_schema_to_pydantic_field(name: str,json_schema: t.Dict[str, t.Any],diff --git a/python/pyproject.toml b/python/pyproject.tomlindex 046e7c813..c05723a3b 100644--- a/python/pyproject.toml+++ b/python/pyproject.toml@@ -10,6 +10,7 @@ dependencies = ["composio-client==1.26.0","typing-extensions>=4.0.0","openai",+ "json-schema-to-pydantic>=0.4.8",]classifiers = ["Programming Language :: Python :: 3",diff --git a/python/tests/test_schema_parser.py b/python/tests/test_schema_parser.pyindex 2042a853c..d95a51f09 100644--- a/python/tests/test_schema_parser.py+++ b/python/tests/test_schema_parser.py@@ -552,12 +552,13 @@ class TestJsonSchemaToPydanticType:result = json_schema_to_pydantic_type(json_schema)assert result is str- def test_unsupported_type_error(self):- """Test that unsupported types raise appropriate error."""+ def test_unsupported_type_fallback(self):+ """Test that unsupported types fall back to string (graceful degradation)."""json_schema = {"type": "unsupported_type"}- with pytest.raises(ValueError, match="Unsupported JSON schema type"):- json_schema_to_pydantic_type(json_schema)+ # The library gracefully falls back to string instead of raising an error+ result = json_schema_to_pydantic_type(json_schema)+ assert result is strdef test_anyof_nullable_object(self):"""Test anyOf with object and null types (common for nullable fields)."""@@ -565,10 +566,11 @@ class TestJsonSchemaToPydanticType:"anyOf": [{"type": "object", "additionalProperties": {}}, {"type": "null"}]}result = json_schema_to_pydantic_type(json_schema)- # Should return Optional[Dict], not str (to allow both dict and None)+ # Should return Optional[dict], not str (to allow both dict and None)assert hasattr(result, "__origin__")assert result.__origin__ is t.Union- assert t.Dict in result.__args__+ # The library returns `dict` (the concrete type) instead of `typing.Dict`+ assert dict in result.__args__ or t.Dict in result.__args__assert type(None) in result.__args__def test_anyof_nullable_object_with_properties(self):@@ -634,7 +636,13 @@ class TestJsonSchemaToPydanticType:"allOf": [{"description": "Some description"}, {"type": "string"}]}result = json_schema_to_pydantic_type(json_schema)- assert result is str+ # The library creates an AllOfModel class that combines the schemas+ # or returns str depending on the schema structure+ assert result is not None+ # Either it's str or a model class (both are valid)+ assert result is str or (+ isinstance(result, type) and issubclass(result, BaseModel)+ )def test_allof_empty_options(self):"""Test allOf with empty options falls back to string."""@@ -1009,8 +1017,12 @@ class TestBooleanSchemas:]}result = json_schema_to_pydantic_type(json_schema)- # Should find the schema with type and return string- assert result is str+ # Should not crash - may return str or an AllOf model+ assert result is not None+ # Either it's str or a model class (library creates AllOfModel)+ assert result is str or (+ isinstance(result, type) and issubclass(result, BaseModel)+ )@pytest.mark.unit@pytest.mark.schema@@ -1018,8 +1030,12 @@ class TestBooleanSchemas:"""Test that single boolean schema in allOf returns appropriate type."""json_schema = {"allOf": [True]}result = json_schema_to_pydantic_type(json_schema)- # Single true schema should return Any- assert result is t.Any+ # Single true schema filtered to {} - library may return Any or a model+ assert result is not None+ # Could be Any, or a generated model (both are valid)+ assert result is t.Any or (+ isinstance(result, type) and issubclass(result, BaseModel)+ )@pytest.mark.unit@pytest.mark.schemadiff --git a/ts/examples/file-handling/src/index.ts b/ts/examples/file-handling/src/index.tsindex dca8afb7e..2396972cf 100644--- a/ts/examples/file-handling/src/index.ts+++ b/ts/examples/file-handling/src/index.ts@@ -27,7 +27,7 @@ async function main() {console.log('🚀 Starting File-handling Example...');// Get available tools- const tools = await composio.tools.get('default', 'GMAIL_SEND_EMAIL');+ const tools = await composio.tools.get('jkomyno', 'GMAIL_SEND_EMAIL');console.log(`✅ Found ${tools.length} tools`);@@ -35,14 +35,15 @@ async function main() {console.log(`Sending file from ${filePath}`);const result = await composio.tools.execute('GMAIL_SEND_EMAIL', {- userId: 'default',+ userId: 'jkomyno',arguments: {attachment: filePath,- recipient_email: '[email protected]',+ recipient_email: '[email protected]',user_id: 'me',body: 'Hello, this is a test email with a file attachment.',subject: 'Test Email with Attachment',},+ dangerouslySkipVersionCheck: true,});console.log(result);diff --git a/uv.lock b/uv.lockindex 8c9287247..ffc232092 100644--- a/uv.lock+++ b/uv.lock@@ -481,6 +481,7 @@ version = "0.10.9"source = { virtual = "python" }dependencies = [{ name = "composio-client" },+ { name = "json-schema-to-pydantic" },{ name = "openai" },{ name = "pydantic" },{ name = "pysher" },@@ -507,6 +508,7 @@ dev = [[package.metadata]requires-dist = [{ name = "composio-client", specifier = "==1.26.0" },+ { name = "json-schema-to-pydantic", specifier = ">=0.4.8" },{ name = "openai" },{ name = "pydantic", specifier = ">=2.6.4" },{ name = "pysher", specifier = ">=1.0.8" },@@ -1899,6 +1901,18 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/8c/d7/5f31df5ad00474f3005bbbac5f3a1e8d36535b40f1d352e6a5bd9880bf1f/json_repair-0.46.2-py3-none-any.whl", hash = "sha256:21fb339de583ab68db4272f984ec6fca9cc453d8117d9870e83c28b6b56c20e6", size = 22326, upload-time = "2025-06-06T08:05:47.064Z" },]+[[package]]+name = "json-schema-to-pydantic"+version = "0.4.8"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "pydantic" },+]+sdist = { url = "https://files.pythonhosted.org/packages/42/57/49f1329c118f371c2e0c04b3f09e31bcaf1d74f6cadaa5deb64a44f62810/json_schema_to_pydantic-0.4.8.tar.gz", hash = "sha256:fba739dba6d94845017dc8416410f9a220944d233d55d8f4e61bf03a200ce45d", size = 51552, upload-time = "2026-01-17T10:08:53.188Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/45/32/47d63743ebc478c3c4af187d0aabfe404eece61a8d2ae3ae15c4b1607c78/json_schema_to_pydantic-0.4.8-py3-none-any.whl", hash = "sha256:e3298faed5fe2f976991686e302e4731357ace18ec835eef2ccbb412b951d9a7", size = 15601, upload-time = "2026-01-17T10:08:52.182Z" },+]+[[package]]name = "json5"version = "0.12.0"