Revert "fix(llm): simplify JSON schemas for better Ollama and LLM compliance (#1292)"

This reverts commit 5b1c348.

Author: nicoloboschi

hindsight-api-slim/hindsight_api/config.py

@@ -132,13 +132,11 @@ def normalize_config_dict(config: dict[str, Any]) -> dict[str, Any]:
 ENV_LLM_GROQ_SERVICE_TIER = "HINDSIGHT_API_LLM_GROQ_SERVICE_TIER"
 ENV_LLM_OPENAI_SERVICE_TIER = "HINDSIGHT_API_LLM_OPENAI_SERVICE_TIER"
 ENV_LLM_EXTRA_BODY = "HINDSIGHT_API_LLM_EXTRA_BODY"
-ENV_LLM_SIMPLIFY_JSON_SCHEMA = "HINDSIGHT_API_LLM_SIMPLIFY_JSON_SCHEMA"
 
 # Defaults for service tiers
 DEFAULT_LLM_GROQ_SERVICE_TIER = "auto"  # "on_demand", "flex", or "auto"
 DEFAULT_LLM_OPENAI_SERVICE_TIER = None  # None (default) or "flex" (50% cheaper)
 DEFAULT_LLM_EXTRA_BODY = None  # None = no extra body params; JSON dict merged into OpenAI extra_body
-DEFAULT_LLM_SIMPLIFY_JSON_SCHEMA = True  # Flatten $ref/$defs/anyOf in JSON schemas for better LLM compliance
 
 # Per-operation LLM configuration (optional, falls back to global LLM config)
 ENV_RETAIN_LLM_PROVIDER = "HINDSIGHT_API_RETAIN_LLM_PROVIDER"
@@ -844,7 +842,6 @@ class HindsightConfig:
     llm_extra_body: (
         dict | None
     )  # Extra body params merged into OpenAI-compatible API calls (e.g. {"chat_template_kwargs": {"enable_thinking": true}})
-    llm_simplify_json_schema: bool  # Flatten $ref/$defs/anyOf in JSON schemas for better LLM compliance (default: true)
 
     # Vertex AI configuration
     llm_vertexai_project_id: str | None
@@ -1342,10 +1339,6 @@ def from_env(cls) -> "HindsightConfig":
             llm_groq_service_tier=os.getenv(ENV_LLM_GROQ_SERVICE_TIER, DEFAULT_LLM_GROQ_SERVICE_TIER),
             llm_openai_service_tier=os.getenv(ENV_LLM_OPENAI_SERVICE_TIER, DEFAULT_LLM_OPENAI_SERVICE_TIER),
             llm_extra_body=json.loads(os.getenv(ENV_LLM_EXTRA_BODY, "null")),
-            llm_simplify_json_schema=os.getenv(
-                ENV_LLM_SIMPLIFY_JSON_SCHEMA, str(DEFAULT_LLM_SIMPLIFY_JSON_SCHEMA)
-            ).lower()
-            in ("true", "1"),
             # Vertex AI
             llm_vertexai_project_id=os.getenv(ENV_LLM_VERTEXAI_PROJECT_ID) or DEFAULT_LLM_VERTEXAI_PROJECT_ID,
             llm_vertexai_region=os.getenv(ENV_LLM_VERTEXAI_REGION, DEFAULT_LLM_VERTEXAI_REGION),

hindsight-api-slim/hindsight_api/engine/providers/openai_compatible_llm.py

@@ -61,77 +61,6 @@ def _strip_code_fences(content: str) -> str:
         return content
 
 
-def _simplify_json_schema(schema: dict[str, Any]) -> dict[str, Any]:
-    """Simplify a Pydantic JSON schema for maximum LLM compatibility.
-
-    Pydantic v2's model_json_schema() produces schemas with $ref/$defs, anyOf
-    (for Optional fields), and const — features that Ollama's grammar-based
-    constrained decoding silently fails on, and that confuse weaker models when
-    the schema appears as a text hint in the prompt.
-
-    This function:
-    1. Resolves all $ref/$defs by inlining referenced definitions
-    2. Simplifies anyOf nullable unions (e.g. anyOf: [{type: "string"}, {type: "null"}])
-       to just the non-null type, keeping default/description
-    3. Replaces const with single-element enum
-    """
-    defs = schema.get("$defs", {})
-
-    def _resolve(node: Any) -> Any:
-        if not isinstance(node, dict):
-            if isinstance(node, list):
-                return [_resolve(item) for item in node]
-            return node
-
-        # Resolve $ref first
-        if "$ref" in node:
-            ref_path = node["$ref"]  # e.g. "#/$defs/Entity"
-            ref_name = ref_path.rsplit("/", 1)[-1]
-            if ref_name in defs:
-                # Inline the definition, merging any sibling keys (e.g. description)
-                resolved = _resolve(dict(defs[ref_name]))
-                # Preserve sibling keys from the referencing node
-                for k, v in node.items():
-                    if k != "$ref":
-                        resolved[k] = _resolve(v)
-                return resolved
-            return node  # unresolvable ref, leave as-is
-
-        result: dict[str, Any] = {}
-        for key, value in node.items():
-            if key == "$defs":
-                continue  # drop $defs — everything is inlined now
-
-            if key == "anyOf" and isinstance(value, list):
-                # Simplify nullable anyOf: [{type: "string"}, {type: "null"}] → {type: "string"}
-                non_null = [_resolve(v) for v in value if not (isinstance(v, dict) and v.get("type") == "null")]
-                if len(non_null) == 1:
-                    # Single non-null type — inline it, preserving sibling keys
-                    simplified = dict(non_null[0])
-                    for k, v in node.items():
-                        if k not in ("anyOf",) and k not in simplified:
-                            simplified[k] = _resolve(v)
-                    return simplified
-                elif len(non_null) > 1:
-                    # Multiple non-null types — keep anyOf but resolved
-                    result["anyOf"] = non_null
-                else:
-                    # All null — just use null
-                    result["type"] = "null"
-                continue
-
-            if key == "const":
-                # Replace const with single-element enum for broader compatibility
-                result["enum"] = [value]
-                continue
-
-            result[key] = _resolve(value)
-
-        return result
-
-    return _resolve(schema)
-
-
 def _summarize_status_error(e: APIStatusError, body_max: int = 400) -> str:
     """Render an APIStatusError with status code + truncated response body.
 
@@ -441,12 +370,6 @@ async def call(
             schema = None
             if hasattr(response_format, "model_json_schema"):
                 schema = response_format.model_json_schema()
-                # Simplify schema for better LLM compliance — resolves $ref/$defs,
-                # simplifies anyOf nullables, replaces const with enum.
-                from hindsight_api.config import get_config
-
-                if get_config().llm_simplify_json_schema:
-                    schema = _simplify_json_schema(schema)
 
             if strict_schema and schema is not None:
                 # Use OpenAI's strict JSON schema enforcement
@@ -931,14 +854,8 @@ async def _call_ollama_native(
         """
         start_time = time.time()
 
-        # Get the JSON schema from the Pydantic model and simplify it for Ollama's
-        # grammar engine, which doesn't support $ref, anyOf, or const.
+        # Get the JSON schema from the Pydantic model
         schema = response_format.model_json_schema() if hasattr(response_format, "model_json_schema") else None
-        if schema:
-            from hindsight_api.config import get_config
-
-            if get_config().llm_simplify_json_schema:
-                schema = _simplify_json_schema(schema)
 
         # Build the base URL for Ollama's native API
         # Default OpenAI-compatible URL is http://localhost:11434/v1

hindsight-docs/docs/developer/configuration.md

@@ -174,7 +174,6 @@ To switch between backends:
 | `HINDSIGHT_API_LLM_GROQ_SERVICE_TIER` | Groq service tier: `on_demand`, `flex`, `auto` | `auto` |
 | `HINDSIGHT_API_LLM_OPENAI_SERVICE_TIER` | OpenAI service tier: `flex` for 50% cost savings (OpenAI Flex Processing) | None (default) |
 | `HINDSIGHT_API_LLM_EXTRA_BODY` | JSON dict merged into `extra_body` for all OpenAI-compatible API calls. Useful for custom model servers (e.g., vLLM `chat_template_kwargs`). | `null` |
-| `HINDSIGHT_API_LLM_SIMPLIFY_JSON_SCHEMA` | Flatten `$ref`/`$defs`/`anyOf` in JSON schemas before sending to LLMs. Required for Ollama structured output; improves compliance for all providers. Set to `false` to send raw Pydantic schemas. | `true` |
 | `HINDSIGHT_API_LLM_GEMINI_SAFETY_SETTINGS` | JSON-encoded list of `{category, threshold}` dicts for Gemini/VertexAI content safety filtering | `null` |
 
 **Provider Examples**