scrapegraphai 2.2.0b3__tar.gz → 2.2.0b4__tar.gz

{scrapegraphai-2.2.0b3 → scrapegraphai-2.2.0b4}/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [2.2.0-beta.4](https://github.com/ScrapeGraphAI/Scrapegraph-ai/compare/v2.2.0-beta.3...v2.2.0-beta.4) (2026-06-11)
+
+
+### Bug Fixes
+
+* **nodes:** tolerate doubled-brace JSON output from models like DeepSeek ([#1085](https://github.com/ScrapeGraphAI/Scrapegraph-ai/issues/1085)) ([aaa5d2c](https://github.com/ScrapeGraphAI/Scrapegraph-ai/commit/aaa5d2cf6d2657f8e8a3b9020ab8b40cdb311c46))
+
 ## [2.2.0-beta.3](https://github.com/ScrapeGraphAI/Scrapegraph-ai/compare/v2.2.0-beta.2...v2.2.0-beta.3) (2026-06-01)
 
 

{scrapegraphai-2.2.0b3 → scrapegraphai-2.2.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scrapegraphai
-Version: 2.2.0b3
+Version: 2.2.0b4
 Summary: A web scraping library based on LangChain which uses LLM and direct graph logic to create scraping pipelines.
 Author-email: Marco Vinciguerra <mvincig11@gmail.com>, Lorenzo Padoan <lorenzo.padoan977@gmail.com>
 Keywords: ai,artificial intelligence,gpt,graph,langchain,llm,machine learning,natural language processing,nlp,openai,rag,scrapegraph,scrapegraphai,scraping,web scraping,web scraping library,web scraping tool,webscraping

{scrapegraphai-2.2.0b3 → scrapegraphai-2.2.0b4}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "scrapegraphai"
 
-version = "2.2.0b3"
+version = "2.2.0b4"
 
 description = "A web scraping library based on LangChain which uses LLM and direct graph logic to create scraping pipelines."
 authors = [

{scrapegraphai-2.2.0b3 → scrapegraphai-2.2.0b4}/scrapegraphai/nodes/generate_answer_node.py

@@ -9,7 +9,6 @@ from typing import List, Optional
 from langchain_core.prompts import PromptTemplate
 from langchain_aws import ChatBedrock
 from langchain_ollama import ChatOllama
-from langchain_core.output_parsers import JsonOutputParser
 from langchain_core.runnables import RunnableParallel
 from langchain_openai import ChatOpenAI
 from requests.exceptions import Timeout
@@ -23,7 +22,10 @@ from ..prompts import (
     TEMPLATE_NO_CHUNKS,
     TEMPLATE_NO_CHUNKS_MD,
 )
-from ..utils.output_parser import get_pydantic_output_parser
+from ..utils.output_parser import (
+    TolerantJsonOutputParser,
+    get_pydantic_output_parser,
+)
 from .base_node import BaseNode
 
 
@@ -148,7 +150,7 @@ class GenerateAnswerNode(BaseNode):
                     format_instructions = ""
         else:
             if not isinstance(self.llm_model, ChatBedrock):
-                output_parser = JsonOutputParser()
+                output_parser = TolerantJsonOutputParser()
                 format_instructions = (
                     "You must respond with a JSON object. Your response should be formatted as a valid JSON "
                     "with a 'content' field containing your analysis. For example:\n"

{scrapegraphai-2.2.0b3 → scrapegraphai-2.2.0b4}/scrapegraphai/utils/output_parser.py

@@ -2,13 +2,53 @@
 Functions to retrieve the correct output parser and format instructions for the LLM model.
 """
 
-from typing import Any, Callable, Dict, Type, Union
+from typing import Any, Callable, Dict, List, Type, Union
 
+from langchain_core.exceptions import OutputParserException
+from langchain_core.outputs import Generation
 from langchain_core.output_parsers import JsonOutputParser
 from pydantic import BaseModel as BaseModelV2
 from pydantic.v1 import BaseModel as BaseModelV1
 
 
+def _strip_doubled_braces(text: str) -> str:
+    """Strip one layer of the doubled braces some models echo from the prompt.
+
+    The default ``format_instructions`` show the expected shape using LangChain's
+    escaped braces, e.g. ``{{"content": "..."}}``. Strongly instruction-following
+    models (GPT-4o, etc.) emit single braces, but some models (notably DeepSeek)
+    copy the doubled braces verbatim, producing ``{{"content": "..."}}`` which is
+    not valid JSON. This normalizes that single case and is a no-op otherwise.
+    """
+    stripped = text.strip()
+    if stripped.startswith("{{") and stripped.endswith("}}"):
+        return stripped[1:-1]
+    return text
+
+
+class TolerantJsonOutputParser(JsonOutputParser):
+    """A :class:`JsonOutputParser` tolerant of doubled-brace output.
+
+    Behaviour is unchanged on the happy path: valid JSON is parsed by the parent
+    parser exactly as before. Only when parsing fails AND the output is wrapped in
+    doubled braces (``{{ ... }}``) does it retry once with a single layer of braces
+    removed. This keeps providers like DeepSeek working without altering output for
+    any model that already returns clean JSON.
+    """
+
+    def parse_result(self, result: List[Generation], *, partial: bool = False) -> Any:
+        try:
+            return super().parse_result(result, partial=partial)
+        except OutputParserException:
+            text = result[0].text
+            normalized = _strip_doubled_braces(text)
+            if normalized != text:
+                return super().parse_result(
+                    [Generation(text=normalized)], partial=partial
+                )
+            raise
+
+
 def get_structured_output_parser(
     schema: Union[Dict[str, Any], Type[BaseModelV1 | BaseModelV2], Type],
 ) -> Callable:

scrapegraphai-2.2.0b4/tests/utils/output_parser_test.py

@@ -0,0 +1,44 @@
+"""Tests for scrapegraphai.utils.output_parser.TolerantJsonOutputParser."""
+
+import pytest
+
+from scrapegraphai.utils.output_parser import (
+    TolerantJsonOutputParser,
+    _strip_doubled_braces,
+)
+
+
+def test_strip_doubled_braces_unwraps_single_layer():
+    assert _strip_doubled_braces('{{"content": "hi"}}') == '{"content": "hi"}'
+
+
+def test_strip_doubled_braces_is_noop_for_clean_json():
+    text = '{"content": "hi"}'
+    assert _strip_doubled_braces(text) == text
+
+
+def test_strip_doubled_braces_ignores_unbalanced():
+    text = '{{"content": "hi"}'
+    assert _strip_doubled_braces(text) == text
+
+
+def test_tolerant_parser_parses_clean_json_unchanged():
+    parser = TolerantJsonOutputParser()
+    assert parser.parse('{"content": "hi"}') == {"content": "hi"}
+
+
+def test_tolerant_parser_recovers_doubled_braces():
+    """Models such as DeepSeek echo the prompt's escaped braces verbatim."""
+    parser = TolerantJsonOutputParser()
+    assert parser.parse('{{"content": "hi"}}') == {"content": "hi"}
+
+
+def test_tolerant_parser_recovers_doubled_braces_with_whitespace():
+    parser = TolerantJsonOutputParser()
+    assert parser.parse('  {{"content": "hi"}}  ') == {"content": "hi"}
+
+
+def test_tolerant_parser_still_raises_on_irrecoverable_output():
+    parser = TolerantJsonOutputParser()
+    with pytest.raises(Exception):
+        parser.parse("this is not json at all")