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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 2.0.7
+Version: 2.0.9
 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.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "2.0.7"
+version = "2.0.9"
 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.9}/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.9}/src/dialectical_framework/concerns/transformation_sketch.py

@@ -53,8 +53,30 @@ one-shot can replace it there is a separate, gated measurement
 (`one-shot-transformation.md`, "Open"). Texts only, nothing persisted, no
 scores — a number here would be an unchecked guess.
 
-Unthinking, like every concern: nothing measured thinking on this call, and
-the measured arm ran without it.
+Unthinking, like every concern. Measured once, on Sonnet 5.5 under the
+structured-output constraint (2026-10-09, `probe_structured_s_minus.py`, 100
+pairs): the same call thinking at `low` (`format_mode="json", thinking="low"`)
+kept Ac- (+4, within noise) where the in-turn wording alone cost it a little
+(−8 / −4 over two runs), at no latency on that model (4.7 s against 4.4 s a
+write); on S- it added nothing beyond the wording (+15 either way). Not wired:
+on a model that keeps forced tool use it would also move this call to JSON
+mode, where no figure for it was taken. The next lever, if Ac- under the
+constraint needs one.
+
+THE CONSTRAINT AND S- (2026-10-09)
+=================================
+On a model whose structured calls carry `output_config.format`
+(`format_compat.structured_output_format`; Sonnet 5.5 first), the reply comes
+back as one compact line with terser texts — no prose, no thinking, the same
+request otherwise (`probe_structured_wire.py`) — and S- came back as the two
+traps IN TURN: a distinct third failure in 42% of 100 (four runs: 42/44/41/42)
+against 57% for the same call without the constraint (+15, CI +2..+28), which
+is what the first app measured on its cards (63% → 41% / 33%). Ac-/Re- were
+not hurt; the constraint helps them (96-98% valid against 91-93%). The rule
+now names the in-turn forms (`SYNTHESIS_SHAPE`), which restores S- to the
+unconstrained level under the constraint and is neutral without it. The
+constraint stays: it ended the parse re-asks, and the loss was a shape the
+rule did not name.
 
 SELECTION: AVAILABLE, OFF BY DEFAULT
 ====================================
@@ -99,8 +121,19 @@ TRANSFORMATION_POSITIONS = """1. The action (Ac): the concrete move that carries
 
 #: What the developments produce together. The S- sentences are the measured
 #: fix (`one-shot-transformation.md`: third-trap 4/17 → 12/17 on graph-built
-#: wheels once the synthesis prompt carried them) and are kept word for word.
-SYNTHESIS_SHAPE = """S+ is what emerges only when Ac+ and Re+ run together — a gain in dimension, not a middle: not "both", not the two strengths listed side by side. S- is the ONE named state Ac- and Re- produce together: a single way of failing that is neither trap on its own and not a choice between them. "Either X or Y", "X versus Y" and "X while Y" with X and Y the two traps are the inputs listed, not the collapse named."""
+#: wheels once the synthesis prompt carried them) and are kept word for word,
+#: with the two IN-TURN forms added on 2026-10-09: a writer under a structured-
+#: output constraint (Sonnet 5.5, `format_compat.structured_output_format`)
+#: wrote S- as the two traps in sequence ("X, then Y", "X alternating with Y")
+#: in 13-14 of ~58 failures per 100 against 4 of 43 without the constraint,
+#: and the rule named only the side-by-side forms. With them named: S- as a
+#: distinct third failure 42% → 57% on 100 pairs, twice (+15 / +16, both clear
+#: of noise), back to the unconstrained writer's 57%; neutral on Sonnet 5
+#: (−1, 100 pairs). Price: a pairwise "which S- is more specific" judge
+#: prefers the trap-restating headline (30-48 against this wording; an arm
+#: that asked for particulars won that read 60-19 and lost the whole shape
+#: gain), so that read is not a shape read. `tests/e2e/probe_structured_s_minus.py`.
+SYNTHESIS_SHAPE = """S+ is what emerges only when Ac+ and Re+ run together — a gain in dimension, not a middle: not "both", not the two strengths listed side by side. S- is the ONE named state Ac- and Re- produce together: a single way of failing that is neither trap on its own and not a choice between them. "Either X or Y", "X versus Y", "X while Y", "X, then Y" and "X alternating with Y" with X and Y the two traps are the inputs listed, side by side or in turn, not the collapse named."""
 
 #: How a one-shot call builds it: the poles FIRST, because a degraded action
 #: needs an action to degrade (the measured order), then the developments,
@@ -236,7 +269,8 @@ class TransformationSketchDto(BaseModel):
     s_minus: str = Field(
         description=(
             "S- — what Ac- and Re- running together collapse into: ONE named way of "
-            "failing that is neither T- nor A- on its own. Never 'either X or Y'."
+            "failing that is neither T- nor A- on its own. Never 'either X or Y', "
+            "'X then Y' or 'X alternating with Y'."
         )
     )
 

{dialectical_framework-2.0.7 → dialectical_framework-2.0.9}/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.9}/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.9}/src/dialectical_framework/utils/format_compat.py

@@ -23,6 +23,32 @@ 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.
+
+**The constraint changes what is written, not only how it parses.** Under it
+the reply is one compact line with terser texts (`tests/e2e/
+probe_structured_wire.py`), and `TransformationSketch`'s S- came back as the
+two traps in turn: a distinct third failure 42% against 57% unconstrained on
+Sonnet 5.5 (100 pairs, +15 clear of noise; the first app saw 63% → 33-41%),
+while Ac-/Re- validity rose. The repair was the prompt, not the constraint:
+`SYNTHESIS_SHAPE` names the in-turn forms since 2026-10-09 and S- is back at
+57% with the constraint on (`tests/e2e/probe_structured_s_minus.py`, the gate
+for this seam on the transformation layer). A judged figure taken on a
+forced-tool model does not transfer to the constrained call by itself.
 """
 
 from __future__ import annotations
@@ -31,8 +57,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 +159,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()