Oi fork

pyagentspec/src/pyagentspec/adapters/_tools_common.py

@@ -16,7 +16,11 @@
     maybe_warn_about_unrestricted_templated_url,
     validate_url_against_allow_list,
 )
-from pyagentspec.adapters._utils import render_nested_object_template, render_template
+from pyagentspec.adapters._utils import (
+    render_nested_json_template,
+    render_nested_object_template,
+    render_template,
+)
 from pyagentspec.retrypolicy import RetryPolicy
 from pyagentspec.tools.remotetool import RemoteTool as AgentSpecRemoteTool
 
@@ -38,7 +42,10 @@ def _create_remote_tool_func(remote_tool: AgentSpecRemoteTool) -> Callable[...,
     )
 
     def _remote_tool(**kwargs: Any) -> Any:
-        remote_tool_data = render_nested_object_template(remote_tool.data, kwargs)
+        # The body is JSON: preserve the type of whole-placeholder values so
+        # structured tool arguments (arrays/objects/numbers/None) survive instead
+        # of being stringified to a Python repr. URL/headers/query stay strings.
+        remote_tool_data = render_nested_json_template(remote_tool.data, kwargs)
         remote_tool_headers = {
             render_template(k, kwargs): render_nested_object_template(v, kwargs)
             for k, v in remote_tool.headers.items()
@@ -87,7 +94,20 @@ def _remote_tool(**kwargs: Any) -> Any:
         response = _request_with_retry(remote_tool.retry_policy, request_kwargs)
         if remote_tool.retry_policy is not None and not response.is_success:
             response.raise_for_status()
-        return response.json()
+        try:
+            return response.json()
+        except ValueError as exc:
+            # A body that isn't JSON is almost always an error page the status
+            # would have explained — but a tool with no retry policy doesn't
+            # check the status (a non-2xx JSON error body is handed to the agent
+            # to read), so the decode failure was the only thing surfaced:
+            # "Expecting value: line 1 column 1 (char 0)", with no clue that the
+            # backend answered 401 or served HTML.
+            raise ValueError(
+                f"{remote_tool.name} returned {response.status_code} "
+                f"{response.headers.get('content-type', 'no content-type')}, "
+                f"which is not JSON: {response.text[:200]!r}"
+            ) from exc
 
     return _remote_tool
 

pyagentspec/src/pyagentspec/adapters/_utils.py

@@ -74,6 +74,57 @@ def render_template(template: Any, inputs: Dict[str, Any]) -> str:
     return _render_template_placeholders(template, inputs)
 
 
+def _to_jsonable(value: Any) -> Any:
+    """Normalize a value into JSON-compatible primitives/containers.
+
+    Pydantic models (e.g. the per-input models built from a tool's input schema)
+    are dumped to plain dicts so they serialize correctly into a JSON request
+    body; nested structures are converted recursively.
+    """
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode="json")
+    if isinstance(value, dict):
+        return {k: _to_jsonable(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [_to_jsonable(item) for item in value]
+    return value
+
+
+def render_nested_json_template(object: Any, inputs: Dict[str, Any]) -> Any:
+    """Render a template destined for a JSON request body.
+
+    Behaves like :func:`render_nested_object_template`, except a string *value*
+    that is exactly one placeholder (e.g. ``"{{members}}"``) is replaced by the
+    raw input value with its type preserved (list/dict/number/bool/None) — so
+    structured tool arguments survive as JSON instead of being stringified into a
+    Python ``repr`` (``"[membersItem(...)]"``) or ``"None"``. Strings with
+    surrounding text keep ordinary interpolation, and dict keys are always
+    rendered as strings.
+    """
+    if isinstance(object, str):
+        return _render_json_leaf(object, inputs)
+    elif isinstance(object, bytes):
+        return render_nested_json_template(object.decode("utf-8", errors="replace"), inputs)
+    elif isinstance(object, dict):
+        return {
+            render_template(k, inputs): render_nested_json_template(v, inputs)
+            for k, v in object.items()
+        }
+    elif isinstance(object, list) or isinstance(object, set) or isinstance(object, tuple):
+        return object.__class__([render_nested_json_template(item, inputs) for item in object])
+    else:
+        return object
+
+
+def _render_json_leaf(template: str, inputs: Dict[str, Any]) -> Any:
+    """Whole-placeholder string -> raw (JSON-able) value; otherwise interpolate."""
+    stripped = template.strip()
+    matches = list(re.finditer(TEMPLATE_PLACEHOLDER_REGEXP, stripped))
+    if len(matches) == 1 and matches[0].group(0) == stripped and matches[0].group(1) in inputs:
+        return _to_jsonable(inputs[matches[0].group(1)])
+    return _render_template_placeholders(template, inputs)
+
+
 def _render_template_placeholders(template: str, inputs: Dict[str, Any]) -> str:
     """Render placeholders found in the original template using the list of inputs."""
     rendered_parts: List[str] = []
@@ -137,6 +188,14 @@ def _build_type_from_schema(
         return List[item_type]  # type: ignore
     # objects
     if t == "object" or ("properties" in schema or "required" in schema):
+        props = schema.get("properties", {}) or {}
+        # An object schema with no declared properties accepts any object
+        # (JSON Schema semantics). Building an empty create_model() here would
+        # silently strip every key on validation (pydantic defaults to
+        # extra="ignore"), so the tool receives {} instead of the LLM's
+        # arguments. Map it to a passthrough dict instead.
+        if not props and schema.get("additionalProperties") is not False:
+            return Dict[str, Any]
         # Create or reuse a Pydantic model for this object schema
         model_name = schema.get("title") or name
         unique_name = model_name
@@ -145,7 +204,6 @@ def _build_type_from_schema(
             suffix += 1
             unique_name = f"{model_name}_{suffix}"
 
-        props = schema.get("properties", {}) or {}
         required = set(schema.get("required", []))
 
         fields: Dict[str, Tuple[Any, Any]] = {}