fix: coerce stringified dict/list fields in analyze files tool input args (#686)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: cotovanu-cristian

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-langchain"
-version = "0.8.18"
+version = "0.8.19"
 description = "Python SDK that enables developers to build and deploy LangGraph agents to the UiPath Cloud Platform"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

src/uipath_langchain/agent/react/json_utils.py

@@ -1,3 +1,5 @@
+import ast
+import json
 import sys
 from typing import Any, ForwardRef, Union, get_args, get_origin
 
@@ -212,3 +214,59 @@ def _json_key(field_name: str, field_info: Any) -> str:
 
 def _is_pydantic_model(annotation: Any) -> bool:
     return isinstance(annotation, type) and issubclass(annotation, BaseModel)
+
+
+def _coerce_field(key: str, value: Any, schema: type[BaseModel] | None) -> Any:
+    """Coerce a single field value, skipping str-typed fields when schema is available."""
+    if schema is None:
+        return coerce_json_strings(value)
+
+    field_info = schema.model_fields.get(key)
+    if field_info is None:
+        return coerce_json_strings(value)
+
+    annotation = _unwrap_optional(field_info.annotation)
+
+    if annotation is str:
+        return value
+
+    if _is_pydantic_model(annotation):
+        return coerce_json_strings(value, annotation)
+
+    if get_origin(annotation) is list:
+        item_args = get_args(annotation)
+        item_schema = None
+        if item_args and _is_pydantic_model(item_args[0]):
+            item_schema = item_args[0]
+        if isinstance(value, list):
+            return [coerce_json_strings(item, item_schema) for item in value]
+
+    return coerce_json_strings(value)
+
+
+def coerce_json_strings(data: Any, schema: type[BaseModel] | None = None) -> Any:
+    """Parse stringified dicts/lists back into Python objects.
+
+    LLMs sometimes serialize nested objects as strings instead of dicts,
+    either as JSON (double quotes) or Python repr (single quotes).
+    When a schema is provided, str-typed fields are left untouched.
+    """
+    if isinstance(data, dict):
+        return {k: _coerce_field(k, v, schema) for k, v in data.items()}
+    if isinstance(data, list):
+        return [coerce_json_strings(item) for item in data]
+    if isinstance(data, str):
+        try:
+            parsed = json.loads(data)
+            if isinstance(parsed, (dict, list)):
+                return parsed
+        except (json.JSONDecodeError, TypeError):
+            pass
+        # LLMs sometimes emit Python repr (single quotes) instead of JSON
+        try:
+            parsed = ast.literal_eval(data)
+            if isinstance(parsed, (dict, list)):
+                return parsed
+        except (ValueError, SyntaxError):
+            pass
+    return data

src/uipath_langchain/agent/wrappers/job_attachment_wrapper.py

@@ -11,6 +11,7 @@
     get_job_attachments,
     replace_job_attachment_ids,
 )
+from uipath_langchain.agent.react.json_utils import coerce_json_strings
 from uipath_langchain.agent.react.types import AgentGraphState
 from uipath_langchain.agent.tools.tool_node import AsyncToolWrapperWithState
 
@@ -73,18 +74,21 @@ async def job_attachment_wrapper(
         input_args = call["args"]
         modified_input_args = input_args
 
+        schema = None
         if isinstance(tool.args_schema, type) and issubclass(
             tool.args_schema, BaseModel
         ):
+            schema = tool.args_schema
             errors: list[str] = []
-            paths = get_job_attachment_paths(tool.args_schema)
+            paths = get_job_attachment_paths(schema)
             modified_input_args = replace_job_attachment_ids(
                 paths, input_args, state.inner_state.job_attachments, errors
             )
 
             if errors:
                 return {"error": "\n".join(errors)}
-        call["args"] = modified_input_args
+
+        call["args"] = coerce_json_strings(modified_input_args, schema)
         tool_result = await tool.ainvoke(call)
         job_attachments_dict = {}
         if output_type is not None:

tests/agent/react/test_json_utils.py

@@ -3,6 +3,7 @@
 from pydantic import BaseModel, RootModel
 
 from uipath_langchain.agent.react.json_utils import (
+    coerce_json_strings,
     extract_values_by_paths,
     get_json_paths_by_type,
 )
@@ -323,3 +324,148 @@ def test_underscore_field_list_jsonpath(self) -> None:
         model = create_model(schema)
         paths = get_json_paths_by_type(model, "__Job_attachment")
         assert paths == ["$._files[*]"]
+
+
+# -- coerce_json_strings: no schema (blind coercion) --------------------------
+
+
+class TestCoerceJsonStringsNoSchema:
+    """Without a schema, all parseable strings are coerced."""
+
+    def test_no_coercion_needed(self) -> None:
+        data = {"name": "test", "count": 42}
+        assert coerce_json_strings(data) == data
+
+    def test_json_object_string(self) -> None:
+        data = {"metadata": '{"size": "99353"}'}
+        assert coerce_json_strings(data) == {"metadata": {"size": "99353"}}
+
+    def test_python_repr_string(self) -> None:
+        data = {"metadata": "{'size': '99353'}"}
+        assert coerce_json_strings(data) == {"metadata": {"size": "99353"}}
+
+    def test_nested_in_dict(self) -> None:
+        data = {"attachment": {"metadata": '{"size": 1024}', "name": "file.pdf"}}
+        assert coerce_json_strings(data) == {
+            "attachment": {"metadata": {"size": 1024}, "name": "file.pdf"}
+        }
+
+    def test_in_list_items(self) -> None:
+        data = {
+            "items": [
+                {"metadata": '{"size": 100}', "name": "a.pdf"},
+                {"metadata": {"size": 200}, "name": "b.pdf"},
+            ]
+        }
+        assert coerce_json_strings(data) == {
+            "items": [
+                {"metadata": {"size": 100}, "name": "a.pdf"},
+                {"metadata": {"size": 200}, "name": "b.pdf"},
+            ]
+        }
+
+    def test_invalid_string_unchanged(self) -> None:
+        data = {"metadata": "not valid json"}
+        assert coerce_json_strings(data) == data
+
+    def test_json_array_string(self) -> None:
+        data = {"tags": "[1, 2, 3]"}
+        assert coerce_json_strings(data) == {"tags": [1, 2, 3]}
+
+    def test_plain_string_unchanged(self) -> None:
+        data = {"name": "hello world"}
+        assert coerce_json_strings(data) == data
+
+    def test_empty_dict(self) -> None:
+        assert coerce_json_strings({}) == {}
+
+    def test_dict_value_unchanged(self) -> None:
+        data = {"metadata": {"already": "a dict"}}
+        assert coerce_json_strings(data) == data
+
+    def test_json_primitives_unchanged(self) -> None:
+        """JSON primitives (numbers, booleans) stay as strings."""
+        data = {"value": "42", "flag": "true"}
+        assert coerce_json_strings(data) == data
+
+    def test_non_dict_passthrough(self) -> None:
+        assert coerce_json_strings(42) == 42
+        assert coerce_json_strings(None) is None
+        assert coerce_json_strings(True) is True
+
+
+# -- coerce_json_strings: with schema -----------------------------------------
+
+
+class TestCoerceJsonStringsWithSchema:
+    """With a schema, str-typed fields are protected from coercion."""
+
+    def test_str_field_preserved_dict_field_coerced(self) -> None:
+        """The real-world Analyze_Files scenario."""
+
+        class AttachmentInput(BaseModel):
+            ID: str
+            FullName: str
+            MimeType: str
+            Metadata: dict[str, Any] | None = None
+
+        class AnalyzeFilesInput(BaseModel):
+            analysisTask: str
+            attachments: list[AttachmentInput]
+
+        data = {
+            "analysisTask": '{"instruction": "summarize the document"}',
+            "attachments": [
+                {
+                    "ID": "550e8400-e29b-41d4-a716-446655440000",
+                    "FullName": "report.pdf",
+                    "MimeType": "application/pdf",
+                    "Metadata": '{"size": "99353"}',
+                }
+            ],
+        }
+        result = coerce_json_strings(data, AnalyzeFilesInput)
+
+        assert result["attachments"][0]["Metadata"] == {"size": "99353"}
+        assert isinstance(result["analysisTask"], str)
+        assert result["analysisTask"] == '{"instruction": "summarize the document"}'
+
+    def test_python_repr_with_schema(self) -> None:
+        """Single-quoted Python repr is coerced for dict fields."""
+
+        class Inner(BaseModel):
+            Metadata: dict[str, Any] | None = None
+
+        class Outer(BaseModel):
+            item: Inner
+
+        data = {"item": {"Metadata": "{'size': '99353'}"}}
+        result = coerce_json_strings(data, Outer)
+        assert result["item"]["Metadata"] == {"size": "99353"}
+
+    def test_unknown_field_coerced(self) -> None:
+        """Fields not in the schema fall back to blind coercion."""
+
+        class Schema(BaseModel):
+            name: str
+
+        data = {"name": "test", "extra": '{"a": 1}'}
+        result = coerce_json_strings(data, Schema)
+        assert result["name"] == "test"
+        assert result["extra"] == {"a": 1}
+
+    def test_nested_model_field_recurses(self) -> None:
+        """BaseModel-typed fields recurse with child schema."""
+
+        class Child(BaseModel):
+            value: str
+            data: dict[str, Any] | None = None
+
+        class Parent(BaseModel):
+            child: Child
+
+        result = coerce_json_strings(
+            {"child": {"value": '{"x": 1}', "data": '{"y": 2}'}}, Parent
+        )
+        assert result["child"]["value"] == '{"x": 1}'
+        assert result["child"]["data"] == {"y": 2}