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(py): support list-valued schema types in tool signatures (#3815)

Alberto Schiabel3a5e62feb4e3
diff --git a/python/composio/utils/shared.py b/python/composio/utils/shared.py
index 15b1e2237..9ac99b841 100644
--- a/python/composio/utils/shared.py
+++ b/python/composio/utils/shared.py
@@ -587,13 +587,22 @@ def get_signature_format_from_schema_params(
# that are missing a "type" key or use an unrecognized type, then build
# a Union for any count of members (no 1/2/3-member cap).
mapped_types: t.List[t.Any] = [
- PYDANTIC_TYPE_TO_PYTHON_TYPE.get(ptype, t.Any) for ptype in param_types
+ _annotation_from_json_schema_type(ptype) for ptype in param_types
]
if len(mapped_types) == 1:
annotation = mapped_types[0]
else:
annotation = reduce(lambda a, b: t.Union[a, b], mapped_types)
param_default = param_schema.get("default", "")
+ elif isinstance(param_type, list):
+ annotation = _annotation_from_json_schema_type(param_type)
+ scalar_type = param_type[0] if len(param_type) == 1 else None
+ if isinstance(scalar_type, str) and scalar_type in FALLBACK_VALUES:
+ param_default = param_schema.get(
+ "default", FALLBACK_VALUES[scalar_type]
+ )
+ else:
+ param_default = param_schema.get("default", "")
elif param_type in PYDANTIC_TYPE_TO_PYTHON_TYPE:
annotation = PYDANTIC_TYPE_TO_PYTHON_TYPE[param_type]
param_default = param_schema.get("default", FALLBACK_VALUES[param_type])
@@ -625,6 +634,27 @@ def get_signature_format_from_schema_params(
return default_parameters + none_default_parameters
+def _annotation_from_json_schema_type(schema_type: t.Any) -> t.Any:
+ """Convert a JSON Schema ``type`` value to a Python annotation.
+
+ JSON Schema Draft 2020-12 and OpenAPI 3.1 allow ``type`` to be an array,
+ including inside ``anyOf`` and ``oneOf`` branches. Keep that form from
+ reaching the scalar dictionary lookup, where a list would be unhashable.
+ """
+ if isinstance(schema_type, list):
+ mapped_types = [_annotation_from_json_schema_type(item) for item in schema_type]
+ if not mapped_types:
+ return t.Any
+ if len(mapped_types) == 1:
+ return mapped_types[0]
+ return reduce(lambda left, right: t.Union[left, right], mapped_types)
+
+ if isinstance(schema_type, str):
+ return PYDANTIC_TYPE_TO_PYTHON_TYPE.get(schema_type, t.Any)
+
+ return t.Any
+
+
def get_pydantic_signature_format_from_schema_params(
schema_params: t.Dict,
skip_default: bool = False,
diff --git a/python/tests/test_schema_parser.py b/python/tests/test_schema_parser.py
index 2046b674b..c3eeb6ec2 100644
--- a/python/tests/test_schema_parser.py
+++ b/python/tests/test_schema_parser.py
@@ -1496,10 +1496,14 @@ class TestGetSignatureFormatFromSchemaParams:
"""Test cases for get_signature_format_from_schema_params union handling."""
@staticmethod
- def _annotation(schema):
+ def _parameter(schema):
params = get_signature_format_from_schema_params(schema)
assert len(params) == 1
- return params[0].annotation
+ return params[0]
+
+ @classmethod
+ def _annotation(cls, schema):
+ return cls._parameter(schema).annotation
@pytest.mark.unit
@pytest.mark.schema
@@ -1631,6 +1635,81 @@ class TestGetSignatureFormatFromSchemaParams:
assert str in args
assert type(None) in args
+ @pytest.mark.unit
+ @pytest.mark.schema
+ @pytest.mark.parametrize(
+ ("schema_type", "expected_members"),
+ [
+ (["string", "null"], {str, type(None)}),
+ (["integer"], {int}),
+ (["string", "integer"], {str, int}),
+ (["file", "null"], {t.Any, type(None)}),
+ ],
+ )
+ def test_type_list_resolves(self, schema_type, expected_members):
+ """List-valued JSON Schema types produce an annotation without raising."""
+ annotation = self._annotation({"properties": {"value": {"type": schema_type}}})
+ actual = set(t.get_args(annotation)) if t.get_args(annotation) else {annotation}
+ assert expected_members <= actual
+
+ @pytest.mark.unit
+ @pytest.mark.schema
+ @pytest.mark.parametrize(
+ ("schema_type", "expected_annotation", "expected_default"),
+ [
+ (["integer"], int, 0),
+ (["boolean"], bool, False),
+ (["array"], t.List, []),
+ ],
+ )
+ def test_single_type_list_uses_scalar_fallback(
+ self, schema_type, expected_annotation, expected_default
+ ):
+ """A one-item type list keeps its scalar type's implicit default."""
+ parameter = self._parameter({"properties": {"value": {"type": schema_type}}})
+
+ assert parameter.annotation is expected_annotation
+ assert parameter.default == expected_default
+
+ @pytest.mark.unit
+ @pytest.mark.schema
+ def test_single_type_list_preserves_explicit_default(self):
+ """An explicit default overrides the fallback for a one-item type list."""
+ parameter = self._parameter(
+ {"properties": {"value": {"type": ["integer"], "default": 42}}}
+ )
+
+ assert parameter.default == 42
+
+ @pytest.mark.unit
+ @pytest.mark.schema
+ def test_multi_type_list_keeps_union_fallback(self):
+ """A multi-type list remains a union with the existing empty-string fallback."""
+ parameter = self._parameter(
+ {"properties": {"value": {"type": ["integer", "null"]}}}
+ )
+
+ assert {int, type(None)} <= set(t.get_args(parameter.annotation))
+ assert parameter.default == ""
+
+ @pytest.mark.unit
+ @pytest.mark.schema
+ def test_combiner_option_with_type_list_resolves(self):
+ """List-valued types inside combiners do not reach a scalar dict lookup."""
+ schema = {
+ "properties": {
+ "value": {
+ "anyOf": [
+ {"type": ["string", "null"]},
+ {"type": "integer"},
+ ]
+ }
+ }
+ }
+
+ annotation = self._annotation(schema)
+ assert {str, int, type(None)} <= set(t.get_args(annotation))
+
if __name__ == "__main__":
pytest.main([__file__, "-v"])