dialectical-framework 2.0.7__tar.gz → 2.0.8__tar.gz

{dialectical_framework-2.0.7 → dialectical_framework-2.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 2.0.7
+Version: 2.0.8
 Summary: A dialectical framework for augmented intelligence. AI reasoning powered with dialectics supports humans in: system optimization (psychology, engineering, business, politics, etc.); dispute resolution (mediation, conflicts, negotiations, etc.); decision-making (dilemmas, challenging situations, win-win, etc.).
 License: MIT
 Keywords: dialectics,dialectical-reasoning,synthesis,thesis-antithesis,ai,artificial-intelligence,llm,reasoning-framework,philosophy,logic,argumentation,conflict-resolution,decision-making,critical-thinking,semantic-graph,mirascope,pydantic,perspectives,polarity-reasoning

{dialectical_framework-2.0.7 → dialectical_framework-2.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "2.0.7"
+version = "2.0.8"
 description = "A dialectical framework for augmented intelligence. AI reasoning powered with dialectics supports humans in: system optimization (psychology, engineering, business, politics, etc.); dispute resolution (mediation, conflicts, negotiations, etc.); decision-making (dilemmas, challenging situations, win-win, etc.)."
 authors = ["Evaldas Taroza <evaldas@dialexity.com>"]
 readme = "README.md"

{dialectical_framework-2.0.7 → dialectical_framework-2.0.8}/src/dialectical_framework/agents/consultant/consultant.py

@@ -36,6 +36,7 @@ dropped from BOTH the product and the baseline.
 
 from __future__ import annotations
 
+import logging
 import re
 from contextlib import aclosing
 from typing import Any, AsyncGenerator, Optional
@@ -51,7 +52,14 @@ from dialectical_framework.agents.conversation_facilitator import (
     FROM_SETTINGS, ConversationFacilitator)
 from dialectical_framework.agents.stream_events import StreamEvent
 from dialectical_framework.agents.turn_timing import TurnTiming
-from dialectical_framework.graph.views import ExplorationView, PerspectiveView
+from dialectical_framework.exceptions.provider_errors import ModelRefusal
+from dialectical_framework.graph.views import (
+    ExplorationView,
+    FailedDrawView,
+    PerspectiveView,
+)
+
+logger = logging.getLogger(__name__)
 
 #: Tool verbs → mental acts. These are REWRITES, not drops: dropping every
 #: paragraph that mentions a tool name would also delete the discrimination test
@@ -135,6 +143,16 @@ _TOOL_TOKENS = (
 )
 
 
+def _failed_draw(error: BaseException) -> FailedDrawView:
+    """A failed draw's record: the exception's type, the provider's refusal
+    category when it is a `ModelRefusal` that carries one, and its text."""
+    return FailedDrawView(
+        kind=type(error).__name__,
+        category=getattr(error, "category", None) if isinstance(error, ModelRefusal) else None,
+        message=str(error) or None,
+    )
+
+
 def _apply_rewrites(section: str) -> tuple[str, list[str]]:
     """Apply the rewrite table whitespace-insensitively.
 
@@ -425,8 +443,22 @@ class Consultant:
         # measured cold-start rate.
         drawn = await asyncio.gather(*(draw() for _ in range(n)), return_exceptions=True)
         sketches = [d for d in drawn if not isinstance(d, BaseException)]
+        failures = [d for d in drawn if isinstance(d, BaseException)]
+        # A failed draw is a finding, not noise: it costs the card a candidate
+        # (or its whole comparison, when two fail) and it costs time before it
+        # fails. Said once per failure, by type — the host that counted 8 lost
+        # draws in 240 on Opus 5.5 had no cause on record because this branch
+        # was silent — and carried on the view as `failed_draws`.
+        failed_draws = [_failed_draw(e) for e in failures]
+        for failed in failed_draws:
+            logger.warning(
+                "A view-turn draw failed (%d of %d drawn): %s%s: %s",
+                len(sketches), n, failed.kind,
+                f" ({failed.category})" if failed.category else "",
+                failed.message,
+            )
         if not sketches:
-            raise next(d for d in drawn if isinstance(d, BaseException))
+            raise failures[0]
         # With several draws the framework's own coherence check picks the one
         # whose FIRST tension holds best (`concerns/tetrad_candidates.py`); a
         # draw with no complete first tension sorts last. The card a blindspot
@@ -447,7 +479,11 @@ class Consultant:
                 sketch = sketches[judgeable[0]] if judgeable else sketches[0]
         else:
             sketch = sketches[0]
-        view = dataclasses.replace(exploration_view_from_sketch(sketch), runners_up=runners_up)
+        view = dataclasses.replace(
+            exploration_view_from_sketch(sketch),
+            runners_up=runners_up,
+            failed_draws=failed_draws,
+        )
         # What the turn leaves behind is NOT what it sent: the long request and
         # the DTO come off, and the person's ask plus the drawing in words go
         # on. Kept as a request→prose pair, the long request taught the next

{dialectical_framework-2.0.7 → dialectical_framework-2.0.8}/src/dialectical_framework/graph/views.py

@@ -326,6 +326,32 @@ class WheelView:
         return dataclasses.asdict(self)
 
 
+@dataclass(frozen=True)
+class FailedDrawView:
+    """One best-of-N draw that produced nothing — what failed, by type.
+
+    A drawn view is best-of-N (`Consultant.exploration_view(attempts=)`), and a
+    draw that raises used to vanish: the gather dropped it, nothing logged it,
+    and the census never saw a call it could not record. A host measured the
+    gap as 8 of 240 draws on Opus 5.5 with no cause on record. `kind` is the
+    exception's class name (`ModelRefusal`, `ParseError`, a provider error);
+    `category` is the provider's refusal category when the kind is a refusal
+    and it sent one; `message` is the exception's text, for a log, never for
+    a screen — `without_terminology()` drops it, since a parse error names DTO
+    fields.
+    """
+
+    kind: str
+    category: Optional[str] = None
+    message: Optional[str] = None
+
+    def without_terminology(self) -> FailedDrawView:
+        return dataclasses.replace(self, message=None)
+
+    def to_dict(self) -> dict[str, Any]:
+        return dataclasses.asdict(self)
+
+
 @dataclass(frozen=True)
 class ExplorationView:
     """The perspectives seen together — an exploration's (a Nexus's) members,
@@ -344,6 +370,11 @@ class ExplorationView:
     #: host's "again"/"another" can show one without a new reasoning call.
     #: Empty for a view read off the graph, or drawn once.
     runners_up: list[PerspectiveView] = field(default_factory=list)
+    #: The best-of-N draws that FAILED, in no particular order — so a host can
+    #: count them and tell a card chosen among three from one that was the only
+    #: draw left. Empty for a view read off the graph. A view with every draw
+    #: failed is never returned: the method raises the first failure instead.
+    failed_draws: list[FailedDrawView] = field(default_factory=list)
 
     def without_terminology(self) -> ExplorationView:
         return dataclasses.replace(
@@ -351,6 +382,7 @@ class ExplorationView:
             perspectives=[p.without_terminology() for p in self.perspectives],
             nexus_hash=None,
             runners_up=[p.without_terminology() for p in self.runners_up],
+            failed_draws=[f.without_terminology() for f in self.failed_draws],
         )
 
     def to_dict(self) -> dict[str, Any]:

{dialectical_framework-2.0.7 → dialectical_framework-2.0.8}/src/dialectical_framework/utils/bedrock_provider.py

@@ -20,6 +20,7 @@ from dialectical_framework.exceptions.provider_errors import ModelRefusal
 from dialectical_framework.settings import Settings
 from dialectical_framework.utils.format_compat import (
     learn_format_mode_from_error,
+    structured_output_format,
     with_format_compat,
 )
 from dialectical_framework.utils.thinking_compat import (
@@ -381,7 +382,9 @@ class BedrockAnthropicProvider(AnthropicProvider):
         5.5); see format_compat. Encoding happens here, BEFORE the request is
         built, because the mode decides the request's shape — tools and
         tool_choice for one, system instructions for the other — and the
-        decoded response's parser follows the resolved format. Earlier turns'
+        decoded response's parser follows the resolved format. A JSON-mode
+        call to such a model also carries its schema as a structured output
+        (`output_config.format`, see `structured_output_format`). Earlier turns'
         thinking blocks are dropped here too, for a model that binds them to
         their prefix (see `without_earlier_turn_thinking`).
 
@@ -411,6 +414,16 @@ class BedrockAnthropicProvider(AnthropicProvider):
         )
         if compatible is not format and "thinking" not in kwargs:
             kwargs["thinking"] = {"type": "disabled"}
+        # A JSON-mode call to a model whose structured calls go in JSON mode
+        # is constrained to its schema (`output_config.format`): JSON asked for
+        # in prose came back with trailing commas often enough to cost a whole
+        # re-ask per 2.5 cards on Sonnet 5.5 (see format_compat). The thinking
+        # layer merges its `effort` into the same `output_config` later.
+        constraint = structured_output_format(model_name, compatible)
+        if constraint is not None:
+            output_config = dict(kwargs.get("output_config") or {})
+            output_config["format"] = constraint
+            kwargs["output_config"] = output_config
         _fix_cache_breakpoints(kwargs)
         return input_messages, resolved_format, kwargs
 

{dialectical_framework-2.0.7 → dialectical_framework-2.0.8}/src/dialectical_framework/utils/format_compat.py

@@ -23,6 +23,21 @@ that accept both. It parses as reliably on a DTO-shaped call and costs less
 prefill (`probe_format_mode_thinking.py`), but the framework's measured figures
 were taken on forced tool use, so switching every model is a measurement, not
 a compatibility fix.
+
+**A JSON-mode call to such a model is also sent as a structured output**
+(`output_config.format`, a JSON-schema constraint on the reply; since
+2026-10-09). JSON mode alone asks for JSON and gets prose-shaped JSON back
+often enough to cost whole calls: a host measured 32 parse re-asks in 80 cards
+on Sonnet 5.5 (25 on `TransformationSketchDto`, 7 on `ViewSketchDto` —
+trailing commas, invalid JSON), each a full extra generation on the
+framework's parse ladder. The constraint removes the class; Bedrock takes it
+through the client the framework uses on Sonnet 5, Sonnet 5.5 and Opus 5.5,
+with every thinking shape the framework sends and with the real DTO schemas
+(`tests/e2e/probe_structured_outputs.py`). Applied to the SAME models that
+refuse forced tool use — the ones whose structured calls go in JSON mode in
+the first place, explicitly (`format_mode="json"`) or by substitution — and
+to no other: Sonnet 5 / Opus 5 took it too in the probe, but every judged
+figure there was taken without it, so widening it is a measurement.
 """
 
 from __future__ import annotations
@@ -31,8 +46,10 @@ import logging
 import re
 from typing import Any, Optional, get_origin
 
+from anthropic.lib._parse._transform import transform_schema
 from mirascope import llm
 from mirascope.llm.formatting.format import Format
+from pydantic import BaseModel
 
 logger = logging.getLogger(__name__)
 
@@ -131,6 +148,29 @@ def learn_format_mode_from_error(
     return True
 
 
+def structured_output_format(model_name: str, format: Any) -> Optional[dict[str, Any]]:
+    """The ``output_config.format`` for this request, or None when it gets none.
+
+    Given the format AS RESOLVED for the model (after `with_format_compat`):
+    a `Format` in JSON mode on a model whose structured calls go in JSON mode
+    (`refuses_forced_tool_use`) gets a ``json_schema`` constraint on the reply;
+    everything else — forced tool use, parser mode, a primitive or an output
+    parser, a model that keeps forced tool use — gets None and goes as it
+    always did. The schema is the SDK's own strict transform of the DTO
+    (``additionalProperties: false`` on every object, the constraints the
+    grammar cannot hold moved into descriptions), the same one
+    ``messages.parse`` would send.
+    """
+    if format is None or not refuses_forced_tool_use(model_name):
+        return None
+    if not isinstance(format, Format) or format.mode != JSON:
+        return None
+    formattable = format.formattable
+    if not (isinstance(formattable, type) and issubclass(formattable, BaseModel)):
+        return None
+    return {"type": "json_schema", "schema": transform_schema(formattable)}
+
+
 def reset_learned_format_modes() -> None:
     """Test seam — the learned map is process-global by design."""
     _LEARNED.clear()