Fix _strip_code_fences truncating JSON when content contains inner backticks (#2563)

* Fix _strip_code_fences truncating JSON when content contains inner backticks

The old implementation used content.split('')[0] to strip
markdown code fences from LLM responses. This finds the FIRST occurrence of '''
after the opening fence — so when the extracted JSON itself contains literal
triple-backtick characters (e.g. facts about code fence formatting), the split
matches those inner backticks and truncates the JSON mid-string.

Replace with line-based fence detection that only matches fences at line
boundaries per the markdown spec. Inner backticks inside JSON string values
are preserved since they aren't at line boundaries.

* test(llm): cover inner-backtick fence stripping regression

---------

Co-authored-by: Ben <ben.bartholomew@vectorize.io>

Author: poog26

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

@@ -78,12 +78,24 @@ def _strip_code_fences(content: str) -> str:
     """
     if "```" not in content:
         return content
-    try:
-        if "```json" in content:
-            return content.split("```json")[1].split("```")[0].strip()
-        return content.split("```")[1].split("```")[0].strip()
-    except (IndexError, ValueError):
+    lines = content.split("\n")
+    # Find first line that starts a code fence (``` optionally followed by language)
+    fence_start = None
+    for i, line in enumerate(lines):
+        if line.startswith("```"):
+            fence_start = i
+            break
+    if fence_start is None:
+        return content
+    # Find matching closing fence (``` alone or with trailing whitespace)
+    fence_end = None
+    for j in range(fence_start + 1, len(lines)):
+        if lines[j].strip() == "```":
+            fence_end = j
+            break
+    if fence_end is None:
         return content
+    return "\n".join(lines[fence_start + 1 : fence_end]).strip()
 
 
 # Reasoning/thinking tags emitted by extended-thinking models. Some providers

hindsight-api-slim/tests/test_strip_code_fences.py

@@ -36,6 +36,22 @@ def test_fence_with_leading_whitespace(self):
         result = _strip_code_fences(content)
         assert '{"facts": []}' in result
 
+    def test_inner_backticks_preserved(self):
+        """Inner triple-backticks inside a JSON string value must not truncate the JSON.
+
+        Regression for the fact-extraction case where an extracted fact describes
+        code-fence behavior, so the JSON payload itself contains a literal
+        ```` ```json ```` — the old split-based stripper matched that inner
+        occurrence and cut the JSON mid-string.
+        """
+        import json
+
+        content = '```json\n{"facts": [{"what": "the model wraps output in ```json fences"}]}\n```'
+        result = _strip_code_fences(content)
+        assert result == '{"facts": [{"what": "the model wraps output in ```json fences"}]}'
+        parsed = json.loads(result)
+        assert parsed["facts"][0]["what"] == "the model wraps output in ```json fences"
+
     def test_no_fences_no_change(self):
         """Content without any backticks passes through."""
         content = "Just some text without fences"