Allow bare dict / Dict[Any, ...] fields in json schema generation

GenerateJsonSchemaSafe rejected any dict whose key type wasn't exactly
'str', which also caught bare dict / Dict[Any, ...] fields (keys_schema
type 'any'). Those map to an unconstrained JSON object, which is valid
(JSON object keys are always strings) and is accepted by the backend, so
rejecting them with 'JSON does not support non-string keys' is a false
positive with a misleading message.

Allow the 'any' key type alongside 'str'; int/float/etc. keys stay
rejected. Also read keys_schema/type defensively via .get(). Adds tests
for bare dict, Dict[str, Any], Dict[Any, Any], and a bare-dict model
field being accepted, and keeps the existing int-key rejection test.

Closes #1493

Author: ErenAta16

guidance/library/_pydantic.py

@@ -17,8 +17,14 @@ class GenerateJsonSchemaSafe(pydantic.json_schema.GenerateJsonSchema):
 
     def generate_inner(self, schema):
         if schema["type"] == "dict":
-            key_type = schema["keys_schema"]["type"]
-            if key_type != "str":
+            # A dict with no key type (bare ``dict``, ``Dict[Any, ...]``) has an
+            # ``"any"`` keys_schema. In JSON that maps to an unconstrained object
+            # (JSON object keys are always strings), which is a valid, supported
+            # schema, so it must not be rejected as "non-string keys". Only key
+            # types that genuinely can't be represented as JSON strings (``int``,
+            # ``float``, ...) are rejected.
+            key_type = schema.get("keys_schema", {}).get("type", "any")
+            if key_type not in ("str", "any"):
                 raise TypeError(f"JSON does not support non-string keys, got type {key_type}")
         return super().generate_inner(schema)
 

tests/unit/library/test_pydantic.py

@@ -170,6 +170,28 @@ def test_prevent_non_string_keys(self):
             generate_and_check({1: 2}, model)
         assert exc_info.value.args[0] == "JSON does not support non-string keys, got type int"
 
+    def test_any_keys_allowed(self):
+        """
+        A dict with no key type (bare ``dict``, ``Dict[Any, ...]``) maps to an
+        unconstrained JSON object and must not be rejected as "non-string keys":
+        JSON object keys are always strings, and the resulting ``{"type":
+        "object"}`` schema is supported by the backend.
+        """
+        for model in (
+            pydantic.TypeAdapter(dict),
+            pydantic.TypeAdapter(dict[str, Any]),
+            pydantic.TypeAdapter(dict[Any, Any]),
+        ):
+            generate_and_check({"a": 1, "b": 2}, model)
+
+    def test_any_keys_allowed_as_model_field(self):
+        # The common "arbitrary JSON metadata" pattern: a bare dict field.
+        class Config(pydantic.BaseModel):
+            name: str
+            metadata: dict
+
+        generate_and_check({"name": "x", "metadata": {"k": 1}}, Config)
+
 
 class TestComposite:
     class Simple(pydantic.BaseModel):