evidor 1.10.5.dev1__tar.gz → 1.10.6.dev1__tar.gz

{evidor-1.10.5.dev1 → evidor-1.10.6.dev1}/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 <!-- version list -->
 
+## v1.10.6-dev.1 (2026-10-30)
+
+### Bug Fixes
+
+- **gemini**: Fixing tool schema sanitization issues
+  ([`4fb1034`](https://github.com/vedangiitb/evidor-core/commit/4fb103470787d203cc7542c68283f28a724c5041))
+
+- **gemini**: Fixing tool schema sanitization issues
+  ([`186bdd3`](https://github.com/vedangiitb/evidor-core/commit/186bdd394b08f003953dc362bd020a99004346f9))
+
+
+## v1.10.5 (2026-10-29)
+
+
 ## v1.10.5-dev.1 (2026-10-29)
 
 ### Bug Fixes

{evidor-1.10.5.dev1 → evidor-1.10.6.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: evidor
-Version: 1.10.5-dev.1
+Version: 1.10.6-dev.1
 Summary: A small, provider-agnostic harness for LLM input and output.
 Project-URL: Homepage, https://github.com/evidor/evidor-core
 Project-URL: Repository, https://github.com/evidor/evidor-core

{evidor-1.10.5.dev1 → evidor-1.10.6.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "evidor"
-version = "1.10.5-dev.1"
+version = "1.10.6-dev.1"
 description = "A small, provider-agnostic harness for LLM input and output."
 readme = "README.md"
 requires-python = ">=3.10"

{evidor-1.10.5.dev1 → evidor-1.10.6.dev1}/src/evidor/agent/providers/gemini/__init__.py

@@ -1,6 +1,6 @@
 """Google Gemini provider package."""
 
-from .builder import GeminiPayloadBuilder, sanitize_gemini_schema
+from .builder import GeminiPayloadBuilder
 from .parser import GeminiResponseParser
 from .provider import GeminiProvider
 from .stream import GeminiStreamHandler
@@ -10,6 +10,5 @@ __all__ = [
     "GeminiProvider",
     "GeminiResponseParser",
     "GeminiStreamHandler",
-    "sanitize_gemini_schema",
 ]
 

{evidor-1.10.5.dev1 → evidor-1.10.6.dev1}/src/evidor/agent/providers/gemini/builder.py

@@ -6,6 +6,17 @@ from typing import Any
 from evidor.models import GenerationRequest, Message
 from ..base import extract_system_prompt, sort_tools
 
+_SNAKE_TO_CAMEL: dict[str, str] = {
+    "any_of": "anyOf",
+    "max_length": "maxLength",
+    "min_length": "minLength",
+    "max_items": "maxItems",
+    "min_items": "minItems",
+    "max_properties": "maxProperties",
+    "min_properties": "minProperties",
+    "property_ordering": "propertyOrdering",
+}
+
 _ALLOWED_GEMINI_SCHEMA_KEYS = {
     "type",
     "format",
@@ -17,94 +28,29 @@ _ALLOWED_GEMINI_SCHEMA_KEYS = {
     "properties",
     "required",
     "items",
-    "any_of",
     "anyOf",
+    "any_of",
     "maximum",
     "minimum",
-    "max_length",
     "maxLength",
-    "min_length",
+    "max_length",
     "minLength",
+    "min_length",
     "pattern",
-    "max_items",
     "maxItems",
-    "min_items",
+    "max_items",
     "minItems",
-    "max_properties",
+    "min_items",
     "maxProperties",
-    "min_properties",
+    "max_properties",
     "minProperties",
+    "min_properties",
     "example",
-    "property_ordering",
     "propertyOrdering",
+    "property_ordering",
 }
 
 
-def sanitize_gemini_schema(schema: Any, types_mod: Any = None) -> Any:
-    """Sanitize a JSON schema dictionary for Google GenAI types.Schema."""
-    if not isinstance(schema, dict):
-        if isinstance(schema, list):
-            return [sanitize_gemini_schema(item, types_mod) for item in schema]
-        return schema
-
-    cleaned: dict[str, Any] = {}
-
-    # Handle 'type' if given as a list (union types, e.g. ['string', 'number', 'boolean'])
-    raw_type = schema.get("type")
-    if isinstance(raw_type, list):
-        types_list = [t for t in raw_type if t != "null"]
-        has_null = "null" in raw_type
-        if len(types_list) == 1:
-            cleaned["type"] = types_list[0]
-            if has_null:
-                cleaned["nullable"] = True
-        elif len(types_list) > 1:
-            subschemas = [{"type": t} for t in types_list]
-            if has_null:
-                cleaned["nullable"] = True
-            cleaned["anyOf"] = subschemas
-        elif has_null:
-            cleaned["type"] = "NULL"
-    elif raw_type is not None:
-        cleaned["type"] = raw_type
-
-    # Handle const -> enum
-    if "const" in schema and "enum" not in schema:
-        cleaned["enum"] = [schema["const"]]
-
-    for k, v in schema.items():
-        if k == "type":
-            continue
-        if k in ("oneOf", "one_of") and "anyOf" not in cleaned and "any_of" not in cleaned:
-            cleaned["anyOf"] = (
-                [sanitize_gemini_schema(it, types_mod) for it in v]
-                if isinstance(v, list)
-                else sanitize_gemini_schema(v, types_mod)
-            )
-            continue
-        if k == "examples" and "example" not in schema and isinstance(v, list) and v:
-            cleaned["example"] = v[0]
-            continue
-
-        if k == "properties" and isinstance(v, dict):
-            cleaned["properties"] = {
-                prop_name: sanitize_gemini_schema(prop_s, types_mod)
-                for prop_name, prop_s in v.items()
-            }
-        elif k == "items":
-            if isinstance(v, list):
-                if len(v) == 1:
-                    cleaned["items"] = sanitize_gemini_schema(v[0], types_mod)
-                elif len(v) > 1:
-                    cleaned["items"] = {"anyOf": [sanitize_gemini_schema(it, types_mod) for it in v]}
-            else:
-                cleaned["items"] = sanitize_gemini_schema(v, types_mod)
-        elif k in _ALLOWED_GEMINI_SCHEMA_KEYS:
-            cleaned[k] = sanitize_gemini_schema(v, types_mod)
-
-    return cleaned
-
-
 class GeminiPayloadBuilder:
     """Builds and formats API request payloads for Google Gemini Interactions API."""
 
@@ -118,6 +64,80 @@ class GeminiPayloadBuilder:
         self.cached_content = cached_content
         self.thinking = thinking
 
+    def _sanitize_schema(self, schema: Any) -> Any:
+        """Sanitize a JSON schema dictionary for Google GenAI types.Schema."""
+        if not isinstance(schema, dict):
+            if isinstance(schema, list):
+                return [self._sanitize_schema(item) for item in schema]
+            return schema
+
+        cleaned: dict[str, Any] = {}
+
+        # Handle 'type' if given as a list (union types, e.g. ['string', 'number', 'boolean'])
+        raw_type = schema.get("type")
+        if isinstance(raw_type, list):
+            types_list = [t for t in raw_type if t != "null"]
+            has_null = "null" in raw_type
+            if len(types_list) == 1:
+                cleaned["type"] = types_list[0]
+                if has_null:
+                    cleaned["nullable"] = True
+            elif len(types_list) > 1:
+                subschemas = [{"type": t} for t in types_list]
+                if has_null:
+                    cleaned["nullable"] = True
+                cleaned["anyOf"] = subschemas
+            elif has_null:
+                cleaned["type"] = "NULL"
+        elif raw_type is not None:
+            cleaned["type"] = raw_type
+
+        # Handle const -> enum
+        if "const" in schema and "enum" not in schema:
+            cleaned["enum"] = [schema["const"]]
+
+        for k, v in schema.items():
+            if k == "type":
+                continue
+            if k in ("oneOf", "one_of") and "anyOf" not in cleaned:
+                cleaned["anyOf"] = (
+                    [self._sanitize_schema(it) for it in v]
+                    if isinstance(v, list)
+                    else self._sanitize_schema(v)
+                )
+                continue
+            if k == "examples" and "example" not in schema and isinstance(v, list) and v:
+                cleaned["example"] = v[0]
+                continue
+
+            target_k = _SNAKE_TO_CAMEL.get(k, k)
+
+            if k == "properties" and isinstance(v, dict):
+                cleaned["properties"] = {
+                    prop_name: self._sanitize_schema(prop_s)
+                    for prop_name, prop_s in v.items()
+                }
+            elif k == "items":
+                if isinstance(v, list):
+                    if len(v) == 1:
+                        cleaned["items"] = self._sanitize_schema(v[0])
+                    elif len(v) > 1:
+                        cleaned["items"] = {"anyOf": [self._sanitize_schema(it) for it in v]}
+                else:
+                    cleaned["items"] = self._sanitize_schema(v)
+            elif k in _ALLOWED_GEMINI_SCHEMA_KEYS:
+                cleaned[target_k] = self._sanitize_schema(v)
+
+        # Ensure ARRAY types have an items schema (required by Gemini API)
+        if cleaned.get("type") in ("array", "ARRAY") and "items" not in cleaned:
+            cleaned["items"] = {"type": "string"}
+
+        # Omit empty required lists (Gemini schema validation rejects empty required arrays)
+        if "required" in cleaned and not cleaned["required"]:
+            del cleaned["required"]
+
+        return cleaned
+
     def build(self, request: GenerationRequest, types: Any = None) -> dict[str, Any]:
         """Construct the full request dictionary for Gemini Interactions API."""
         system_prompt = extract_system_prompt(request)
@@ -142,7 +162,7 @@ class GeminiPayloadBuilder:
                     "type": "function",
                     "name": t.name,
                     "description": t.description,
-                    "parameters": sanitize_gemini_schema(t.parameters, types) if t.parameters else None,
+                    "parameters": self._sanitize_schema(t.parameters) if t.parameters else None,
                 }
                 for t in sorted_tools
             ]
@@ -241,3 +261,4 @@ class GeminiPayloadBuilder:
                 })
         return input_steps
 
+

{evidor-1.10.5.dev1 → evidor-1.10.6.dev1}/src/evidor/utils/schema.py

@@ -70,6 +70,19 @@ def python_type_to_json_type(annotation: Any) -> str:
     return TYPE_MAPPING.get(annotation, "string")
 
 
+def _unwrap_optional(annotation: Any) -> tuple[Any, bool]:
+    """Unwrap Optional / Union[..., None] and return (inner_type, is_nullable)."""
+    origin = get_origin(annotation)
+    if origin in (Union, types.UnionType):
+        args = get_args(annotation)
+        is_nullable = type(None) in args
+        non_none_args = [arg for arg in args if arg is not type(None)]
+        if len(non_none_args) == 1:
+            return non_none_args[0], is_nullable
+        return annotation, is_nullable
+    return annotation, False
+
+
 def generate_parameters_schema(func: Callable[..., Any], param_docs: dict[str, str]) -> dict[str, Any]:
     """Generate a JSON Schema object describing the function parameters."""
     sig = inspect.signature(func)
@@ -86,7 +99,22 @@ def generate_parameters_schema(func: Callable[..., Any], param_docs: dict[str, s
             inspect.Parameter.VAR_KEYWORD,
         ):
             continue
-        prop_schema: dict[str, Any] = {"type": python_type_to_json_type(type_hints.get(name, param.annotation))}
+        annotation = type_hints.get(name, param.annotation)
+        unwrapped, is_nullable = _unwrap_optional(annotation)
+        json_type = python_type_to_json_type(unwrapped)
+        prop_schema: dict[str, Any] = {"type": json_type}
+        if is_nullable:
+            prop_schema["nullable"] = True
+
+        if json_type == "array":
+            item_type = "string"
+            item_origin = get_origin(unwrapped)
+            if item_origin is not None:
+                args = get_args(unwrapped)
+                if args and args[0] is not Ellipsis:
+                    item_type = python_type_to_json_type(args[0])
+            prop_schema["items"] = {"type": item_type}
+
         if name in param_docs:
             prop_schema["description"] = param_docs[name]
         properties[name] = prop_schema

{evidor-1.10.5.dev1 → evidor-1.10.6.dev1}/tests/test_providers.py

@@ -1449,30 +1449,88 @@ def test_gemini_payload_builder_thinking_config() -> None:
 
 
 def test_gemini_payload_builder_types_optional() -> None:
-    from evidor.agent.providers.gemini.builder import GeminiPayloadBuilder, sanitize_gemini_schema
+    from evidor.agent.providers.gemini.builder import GeminiPayloadBuilder
     from evidor.models import GenerationRequest
     from evidor.tools import Tool
 
-    # sanitize_gemini_schema works without types_mod
+    builder = GeminiPayloadBuilder(model="gemini-3.8-flash")
+
+    # _sanitize_schema works as an internal instance method
     schema = {
         "type": "object",
         "properties": {"name": {"type": "string"}},
         "required": ["name"],
     }
-    sanitized = sanitize_gemini_schema(schema)
+    sanitized = builder._sanitize_schema(schema)
     assert sanitized["type"] == "object"
     assert "name" in sanitized["properties"]
 
     # builder.build works without types argument
     tool = Tool(name="test_tool", description="A test tool", parameters=schema, func=lambda: None)
     req = GenerationRequest(prompt="Use tool", tools=[tool])
-    builder = GeminiPayloadBuilder(model="gemini-3.8-flash")
     payload = builder.build(req)
     assert "cached_content" not in payload
     assert len(payload["tools"]) == 1
     assert payload["tools"][0]["name"] == "test_tool"
 
 
+def test_gemini_schema_sanitizer_enhancements() -> None:
+    from evidor.agent.providers.gemini.builder import GeminiPayloadBuilder
+
+    builder = GeminiPayloadBuilder(model="gemini-3.8-flash")
+
+    # 1. Bare array missing items gets default string items
+    schema_array = {
+        "type": "object",
+        "properties": {
+            "tags": {"type": "array"},
+        },
+    }
+    sanitized_array = builder._sanitize_schema(schema_array)
+    assert sanitized_array["properties"]["tags"]["items"] == {"type": "string"}
+
+    # 2. Empty required list is omitted
+    schema_empty_req = {
+        "type": "object",
+        "properties": {"opt": {"type": "string"}},
+        "required": [],
+    }
+    sanitized_empty_req = builder._sanitize_schema(schema_empty_req)
+    assert "required" not in sanitized_empty_req
+
+    # 3. Non-empty required list is preserved
+    schema_with_req = {
+        "type": "object",
+        "properties": {"req_field": {"type": "string"}},
+        "required": ["req_field"],
+    }
+    sanitized_with_req = builder._sanitize_schema(schema_with_req)
+    assert sanitized_with_req["required"] == ["req_field"]
+
+    # 4. Normalization of snake_case to camelCase
+    schema_snake = {
+        "type": "object",
+        "properties": {
+            "val": {
+                "max_length": 50,
+                "min_length": 5,
+                "any_of": [{"type": "string"}, {"type": "number"}],
+            }
+        },
+        "property_ordering": ["val"],
+    }
+    sanitized_snake = builder._sanitize_schema(schema_snake)
+    val_prop = sanitized_snake["properties"]["val"]
+    assert "maxLength" in val_prop
+    assert "max_length" not in val_prop
+    assert "minLength" in val_prop
+    assert "min_length" not in val_prop
+    assert "anyOf" in val_prop
+    assert "any_of" not in val_prop
+    assert "propertyOrdering" in sanitized_snake
+    assert "property_ordering" not in sanitized_snake
+
+
 def test_gemini_parser_no_thought_leakage() -> None:
     from evidor.agent.providers.gemini.parser import GeminiResponseParser
 

{evidor-1.10.5.dev1 → evidor-1.10.6.dev1}/tests/test_tools.py

@@ -257,3 +257,27 @@ def test_async_tool_preserves_contextvars() -> None:
     asyncio.run(_run())
     # When executed synchronously outside any active loop, it runs in a new loop and preserves contextvars
     assert get_token.execute() == "custom_token_123"
+
+
+def test_tool_nullable_and_array_items() -> None:
+    @tool
+    def search_records(
+        scores: list[int],
+        filter_name: Optional[str] = None,
+        tags: list = [],  # type: ignore[assignment]
+    ) -> str:
+        """Search records."""
+        return "ok"
+
+    props = search_records.parameters["properties"]
+    # Generic list[int] has items: integer
+    assert props["scores"]["type"] == "array"
+    assert props["scores"]["items"] == {"type": "integer"}
+
+    # Optional[str] has nullable: True
+    assert props["filter_name"]["type"] == "string"
+    assert props["filter_name"]["nullable"] is True
+
+    # Bare list defaults items to string
+    assert props["tags"]["type"] == "array"
+    assert props["tags"]["items"] == {"type": "string"}