SAP · NicoleMGomes · Jun 29, 2026 · Jun 29, 2026 · Jun 29, 2026 · Jun 29, 2026
@@ -1,6 +1,6 @@
 [project]
 name = "sap-cloud-sdk"
-version = "0.31.0"
+version = "0.31.1"
 description = "SAP Cloud SDK for Python"
 readme = "README.md"
 license = "Apache-2.0"

@@ -16,6 +16,15 @@
 if TYPE_CHECKING:
     from langchain_core.tools import StructuredTool
 
+_JSON_TYPE_MAP: dict[str, type] = {
+    "string": str,
+    "integer": int,
+    "number": float,
+    "boolean": bool,
+    "array": list,
+    "object": dict,
+}
+
 
 def mcp_tool_to_langchain(
     mcp_tool: MCPTool,
@@ -83,8 +92,15 @@ async def run(**kwargs) -> str:
     properties = mcp_tool.input_schema.get("properties", {})
     required = set(mcp_tool.input_schema.get("required", []))
     fields: dict[str, Any] = {
-        k: (str, ...) if k in required else (str | None, Field(default=None))
-        for k in properties
+        k: (
+            (_JSON_TYPE_MAP.get(v.get("type", ""), Any), ...)
+            if k in required
+            else (
+                _JSON_TYPE_MAP.get(v.get("type", ""), Any) | None,
+                Field(default=None),
+            )
+        )
+        for k, v in properties.items()
     }
     args_schema = create_model(f"{mcp_tool.name}_args", **fields) if fields else None
 

@@ -122,6 +122,20 @@ mcp_tool_to_langchain(
 )
 ```
 
+The converter maps each property's JSON Schema `"type"` to the corresponding Python type so Pydantic validates and forwards the correct native type to the MCP server:
+
+| JSON Schema type | Python type |
+|------------------|-------------|
+| `"string"`       | `str`       |
+| `"integer"`      | `int`       |
+| `"number"`       | `float`     |
+| `"boolean"`      | `bool`      |
+| `"array"`        | `list`      |
+| `"object"`       | `dict`      |
+| missing / other  | `Any`       |
+
+Optional fields (not listed in `"required"`) are typed as `T | None` with a `None` default.
+
 ## Concepts
 
 ### Agent Types

@@ -89,6 +89,103 @@ def test_input_schema_without_properties_key(self):
         assert lc_tool.args_schema is not None
 
 
+class TestMcpToolToLangchainTypeMapping:
+    """Tests that JSON Schema types are mapped to the correct Python types."""
+
+    def _tool_with_types(self, properties: dict, required: list[str] | None = None) -> MCPTool:
+        return MCPTool(
+            name="typed_tool",
+            server_name="server",
+            description="desc",
+            input_schema={
+                "type": "object",
+                "required": required or [],
+                "properties": properties,
+            },
+            url="https://example.com/mcp",
+        )
+
+    def test_string_type_maps_to_str(self):
+        lc_tool = mcp_tool_to_langchain(
+            self._tool_with_types({"name": {"type": "string"}}, required=["name"]),
+            AsyncMock(),
+            lambda: "token",
+        )
+        assert _schema_fields(lc_tool)["name"].annotation is str
+
+    def test_integer_type_maps_to_int(self):
+        lc_tool = mcp_tool_to_langchain(
+            self._tool_with_types({"limit": {"type": "integer"}}, required=["limit"]),
+            AsyncMock(),
+            lambda: "token",
+        )
+        assert _schema_fields(lc_tool)["limit"].annotation is int
+
+    def test_number_type_maps_to_float(self):
+        lc_tool = mcp_tool_to_langchain(
+            self._tool_with_types({"ratio": {"type": "number"}}, required=["ratio"]),
+            AsyncMock(),
+            lambda: "token",
+        )
+        assert _schema_fields(lc_tool)["ratio"].annotation is float
+
+    def test_boolean_type_maps_to_bool(self):
+        lc_tool = mcp_tool_to_langchain(
+            self._tool_with_types({"active": {"type": "boolean"}}, required=["active"]),
+            AsyncMock(),
+            lambda: "token",
+        )
+        assert _schema_fields(lc_tool)["active"].annotation is bool
+
+    def test_array_type_maps_to_list(self):
+        lc_tool = mcp_tool_to_langchain(
+            self._tool_with_types({"tags": {"type": "array"}}, required=["tags"]),
+            AsyncMock(),
+            lambda: "token",
+        )
+        assert _schema_fields(lc_tool)["tags"].annotation is list
+
+    def test_object_type_maps_to_dict(self):
+        lc_tool = mcp_tool_to_langchain(
+            self._tool_with_types({"meta": {"type": "object"}}, required=["meta"]),
+            AsyncMock(),
+            lambda: "token",
+        )
+        assert _schema_fields(lc_tool)["meta"].annotation is dict
+
+    def test_unknown_type_maps_to_any(self):
+        from typing import Any
+        lc_tool = mcp_tool_to_langchain(
+            self._tool_with_types({"data": {"type": "unknown"}}, required=["data"]),
+            AsyncMock(),
+            lambda: "token",
+        )
+        assert _schema_fields(lc_tool)["data"].annotation is Any
+
+    def test_missing_type_maps_to_any(self):
+        from typing import Any
+        lc_tool = mcp_tool_to_langchain(
+            self._tool_with_types({"data": {}}, required=["data"]),
+            AsyncMock(),
+            lambda: "token",
+        )
+        assert _schema_fields(lc_tool)["data"].annotation is Any
+
+    def test_optional_non_string_field_is_nullable(self):
+        lc_tool = mcp_tool_to_langchain(
+            self._tool_with_types({"limit": {"type": "integer"}}),
+            AsyncMock(),
+            lambda: "token",
+        )
+        field = _schema_fields(lc_tool)["limit"]
+        assert not field.is_required()
+        # annotation should be int | None
+        import types as _types
+        assert isinstance(field.annotation, _types.UnionType)
+        assert int in field.annotation.__args__
+        assert type(None) in field.annotation.__args__
+
+
 class TestMcpToolToLangchainInvocation:
     """End-to-end invocation tests: verify what actually reaches call_tool."""