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

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

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

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

@@ -42,6 +42,7 @@ from contextlib import aclosing
 from typing import Any, AsyncGenerator, Optional
 
 from mirascope import llm
+from mirascope.llm.exceptions import ProviderError
 
 from dialectical_framework.agents.advisor.advisor import ChatResponse
 from dialectical_framework.agents.advisor.system_prompts import (
@@ -145,9 +146,21 @@ _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."""
+    category when it is a `ModelRefusal` that carries one, and its text.
+
+    The type is the PROVIDER's where Mirascope wrapped one: its `ProviderError`
+    subclasses carry the SDK exception as `original_exception`, and that is
+    the name a host counts by (`APITimeoutError` for a stalled draw, where the
+    wrapper says only `TimeoutError` — the builtin's name too). `ParseError`
+    is not a `ProviderError` and keeps its own name.
+    """
+    original = (
+        getattr(error, "original_exception", None)
+        if isinstance(error, ProviderError)
+        else None
+    )
     return FailedDrawView(
-        kind=type(error).__name__,
+        kind=type(original if isinstance(original, BaseException) else error).__name__,
         category=getattr(error, "category", None) if isinstance(error, ModelRefusal) else None,
         message=str(error) or None,
     )
@@ -368,7 +381,10 @@ class Consultant:
         return self._conversation._messages
 
     async def exploration_view(
-        self, focus: Optional[str] = None, attempts: Optional[int] = None
+        self,
+        focus: Optional[str] = None,
+        attempts: Optional[int] = None,
+        thesis: Optional[str] = None,
     ) -> ExplorationView:
         """The structure of this conversation as a view — drawn by this head.
 
@@ -389,6 +405,17 @@ class Consultant:
         think and building a tetrad in one shot is the heaviest reasoning a
         structured call is asked to do here.
 
+        `thesis` pins T to the host's own text, VERBATIM: the request says so
+        (`view_sketch.THESIS_IS_FIXED`) and the given words are then written
+        back over whatever each draw wrote, so the guarantee is code and not
+        compliance. For a host that shows the person their own sentence as
+        their position, a seven-word recomposition of it is a different
+        sentence. The rest of the tetrad is still built — and still built
+        around the pinned position, which is why the request carries the text
+        too rather than relying on the overwrite alone. Not the same contract
+        as `SketchTetrad(thesis=)`, which asks for the position condensed to
+        `component_length` because the graph stores a headline.
+
         Terminology-free by construction (no hash, alias or score exists),
         unchecked by construction (no HS gate, no validation, nothing
         persisted). Not a tool: the model cannot call this, and the prompt's
@@ -420,7 +447,9 @@ class Consultant:
         # utterances; the first app had measured the same 4.6 calls and +17 s).
         # The request->prose pair `history_ask` keeps OUT of the history is the
         # same trap; the long request as the last turn is what holds the format.
-        request = view_sketch_prompt(focus, self._conversation.settings.component_length)
+        request = view_sketch_prompt(
+            focus, self._conversation.settings.component_length, thesis=thesis
+        )
 
         async def draw() -> ViewSketchDto:
             # Each draw works on a COPY of the history: the turns run in
@@ -459,6 +488,15 @@ class Consultant:
             )
         if not sketches:
             raise failures[0]
+        # The pin, enforced: every draw's first tension carries the host's own
+        # words as T, so the winner and any runner-up a host serves later all
+        # show the sentence the person typed. Done before selection, so the
+        # coherence check judges the tetrad the host will actually get.
+        pinned = (thesis or "").strip()
+        if pinned:
+            for drawn_sketch in sketches:
+                if drawn_sketch.tensions:
+                    drawn_sketch.tensions[0].thesis = pinned
         # 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

{dialectical_framework-2.0.9 → dialectical_framework-2.0.12}/src/dialectical_framework/agents/conversation_facilitator.py

@@ -567,8 +567,19 @@ class ConversationFacilitator(SettingsAware):
                     self._strip_caller_from_messages(response.messages)
                     # The continuation is a conversational round too (and it is
                     # Mirascope's own request, so nothing in `use_brain` marks it).
+                    # Retried like the streamed resume (`_start_stream_round`):
+                    # since the Bedrock client's own retry went to 0
+                    # (`bedrock_provider._SDK_MAX_RETRIES`) this is the one
+                    # provider request with no other retry layer. Safe to re-ask
+                    # — `resume_async` is `response.messages + [user(outputs)]`
+                    # with no mutation of the response — and the tools have
+                    # already run, so a retry re-sends their outputs, never
+                    # re-executes them.
                     with conversational_round():
-                        response = await response.resume(tool_outputs)
+                        resuming = response
+                        response = await retry_transient(
+                            lambda: resuming.resume(tool_outputs), what="Resume"
+                        )
                     # Mirascope's own request, below `use_brain`: a provider that
                     # does not raise on a refusal itself only says so here.
                     if getattr(response, "finish_reason", None) == FinishReason.REFUSAL:

{dialectical_framework-2.0.9 → dialectical_framework-2.0.12}/src/dialectical_framework/concerns/aspect_generation.py

@@ -165,10 +165,35 @@ Generate aspect statements that fit the semantic structure."""
 # — small, and not re-measured at the archive's sample size. Do not re-add a
 # worked plus example without measuring BOTH coherence and restatement
 # (`tests/e2e/probe_aspect_variants.py`).
+#
+# Re-aimed on 2026-10-12, by measurement, from "supplies what the other pole is
+# for" to "leaves it possible". The old wording was the take-up half stated a
+# third time, and with a DECIDED thesis ("I'm not inviting my sister — done")
+# "A developed so that it supplies what T is for" IS the middle path: A+ came
+# back as the compromise ("Leave a path back that she must earn"), and the
+# transformation's Ac+, which turns T- into A+, then faithfully handed the
+# person back the thing they had refused (reported by the first app, promise
+# eval v12, 3 of 7 decided cases failing in every rep). On 16 decided stances
+# x 2 reps x 3 arms, Sonnet 5.5 (`tests/e2e/probe_decided_stance.py`,
+# `decided_stance-20261012-090438.json`): A+ a good A ITSELF is for, 39% ->
+# 94% (paired +55, 95% CI +33..+77), compromise pluses gone (plus_relation
+# `distinct` 69% -> 100%), and coherence ROSE, 59% -> 91% (+31, +9..+54) —
+# which is the theory's own reading, since a plus that carries the other pole
+# cannot satisfy "T+ without A+ yields T-". The arm that only reversed the
+# relation reached 75% / +12 CC; what took it to 94% was adding "a position,
+# not a move" (`view_sketch.TETRAD_BUILD_PROCEDURE` step 1), so the two
+# sentences ship together. Not the same lever as the two spent ones: pushing
+# take-up HARDER (the `*_takes_up` fields, 2026-10-02) cost coherence 25/40 ->
+# 15/40, and a hedged-parent CHECK (2026-09-30) moved nothing.
+# `ASPECT_DEFINITIONS` still states the relation the old way and was in both
+# arms' context — unchanged on purpose; editing it is a new measurement.
 PLUS_RESTATEMENT_CHECK = (
-    "Restated parent: if a plus only names what its own parent already "
-    "delivers, rewrite it so the parent stays the generative act while its "
-    "result also supplies what the other pole is for."
+    "Blended parent: a plus is its own parent developed, never the two sides "
+    "combined into one arrangement — not the parent made conditional on the "
+    "other pole, not a partial, scheduled or trial version of it, not the "
+    "middle between them. If a plus only names what its own parent already "
+    "delivers, rewrite it so the parent stays the generative act and what the "
+    "other pole is for is left possible by it."
 )
 
 def is_axis_name(axis: Optional[str]) -> bool:

{dialectical_framework-2.0.9 → dialectical_framework-2.0.12}/src/dialectical_framework/concerns/transformation_sketch.py

@@ -116,9 +116,40 @@ from dialectical_framework.protocols.has_config import SettingsAware
 #: that writes the way through a tension in its own voice (the first app's
 #: card) — so none of them can restate the theory differently.
 TRANSFORMATION_POSITIONS = """1. The action (Ac): the concrete move that carries T toward A. The reflection (Re): the re-reading that carries A back toward T. These are the two poles of the transformation.
-2. Each developed well — Ac+ turns T's trap (T-) into A's strength (A+); Re+ turns A's trap (A-) into T's strength (T+).
+2. Each developed well — Ac+ turns T's trap (T-) into A's strength (A+); Re+ turns A's trap (A-) into T's strength (T+). Where T is something the person has DECIDED or refused, Ac and Ac+ are that decision carried out: what A is for shapes HOW they carry it out, never whether or how much. This governs the action and the action developed well only — Ac- still ends in A's trap, as point 3 says.
 3. Each overdeveloped one-sidedly — Ac- is the good action without the good reflection (Ac+ without Re+), which carries T's strength (T+) into A's trap (A-); Re- is the good reflection without the good action (Re+ without Ac+), which carries A's strength (A+) into T's trap (T-). They are the ACTION and the REFLECTION gone wrong: they END in the traps but are not the traps restated — a path is not its destination. Ac+ contradicts Re-, and Re+ contradicts Ac-."""
 
+#: THE DECIDED POSITION (2026-10-12). Point 2's second sentence, and the only
+#: part of this text that knows anything about the person's state. The first app
+#: reported the framework handing people back exactly what they had refused:
+#: given "Im not inviting my sister to the wedding … done.", Ac+ came back as
+#: "Give her a clear route back: apologise to Marco and she's welcome." Repairing
+#: A+ upstream (the compromise plus, `antithesis-selection.md`, same day) fixed
+#: the CORNER and not the move — `decision_stands` 62% before and after — so this
+#: layer has its own site, and it is not point 1's "carries T toward A":
+#: rewording that moved nothing (-3 paired, `tests/e2e/probe_decided_move.py`).
+#: What moved it is naming the state: 53% -> 88% of actions keeping the decision
+#: (+34, +18..+51, 32 frozen decided tetrads).
+#:
+#: **The scope clause is load-bearing, measured twice.** Whichever minus the rule
+#: is allowed to reach is the one that breaks. Stated unscoped here it kept 32 of
+#: 32 decisions and broke Ac- (-25, resolved): told the action must not dilute
+#: toward A, the writer wrote Ac- as the decision carried out COLDLY, which lands
+#: in T-, not A-. Moved onto the `action` / `ac_plus` field descriptions it scored
+#: the best endpoint of the three (+47) and broke Re- instead (-32, resolved).
+#: Naming what it does not govern is what left both landings alone.
+#:
+#: Price, on this text's own gate (`probe_transformation_sketch.py`, 25 tetrads
+#: x 2 reps, arm `no_decided_rule`): landings intact (Ac- +2, Re- -4, noise),
+#: validity composites within noise (-8, -10), S- third failure +8, and
+#: **`ac_own` 100% -> 90% (-10, -18..-2, resolved)** — the second accepted trade
+#: on that read, after the scaffold fields' 100% -> 93%. Named rather than
+#: swallowed: a third one needs an argument.
+#:
+#: What the sentence deliberately does NOT say is that a diluted action IS Ac-.
+#: That is a theory claim nothing here has checked, and the archive's record is
+#: that a gloss hardened into a rule gets argued with rather than obeyed.
+#:
 #: 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,

{dialectical_framework-2.0.9 → dialectical_framework-2.0.12}/src/dialectical_framework/concerns/view_sketch.py

@@ -111,9 +111,11 @@ class ViewSketchPerspectiveDto(BaseModel):
     )
     t_plus: str = Field(
         description=(
-            "T+ — the THESIS developed constructively, so that it also strengthens "
-            "what A offers. Derived from T; the positive end of the axis above. "
-            "Empty when not drawn."
+            "T+ — the THESIS developed constructively, so that what A is for stays "
+            "possible alongside it. T's own side developed — never T blended with A, "
+            "made conditional on it, or the middle between the two. Derived from T; "
+            "the positive end of the axis above. A position held, not a move to "
+            "make. Empty when not drawn."
         )
     )
     a_minus: str = Field(
@@ -131,9 +133,11 @@ class ViewSketchPerspectiveDto(BaseModel):
     )
     a_plus: str = Field(
         description=(
-            "A+ — the ANTITHESIS developed constructively, so that it also strengthens "
-            "what T offers. Derived from A; the positive end of the axis above. "
-            "Empty when not drawn."
+            "A+ — the ANTITHESIS developed constructively, so that what T is for "
+            "stays possible alongside it. A's own side developed — never A blended "
+            "with T, made conditional on it, or the middle between the two. Derived "
+            "from A; the positive end of the axis above. A position held, not a move "
+            "to make. Empty when not drawn."
         )
     )
     t_minus: str = Field(
@@ -162,6 +166,16 @@ class ViewSketchDto(BaseModel):
 #: the graph path gives `AspectGeneration._tetrad_prompt`, stated once here and
 #: shared by the view turn and `concerns/tetrad_sketch.py`, so the two
 #: one-shot builders cannot drift apart.
+#:
+#: Step 1's two measured sentences (2026-10-12, `probe_decided_stance.py`; the
+#: story is on `PLUS_RESTATEMENT_CHECK`, which carries the same rule as the
+#: step-3 check): a plus LEAVES the other pole's good possible rather than
+#: delivering it, and an aspect is a POSITION rather than a move. The second
+#: is what took A+ from 75% to 94% own-strength and coherence from 72% to 91%
+#: on decided stances — the failures it removes are imperatives ("Leave a path
+#: back that she must earn"), and a move that answers both sides at once is a
+#: compromise by construction. It is also where the layering is stated to the
+#: writer: positions live in the tetrad, moves in the Transformation.
 #: What the thesis IS, for a writer that finds it in free words. Measured
 #: without it (`tests/e2e/probe_question_entry.py`, 2026-10-04, 20 questions
 #: through the view turn): the tetrad was statement-grade (CC 17/20, a genuine
@@ -181,12 +195,29 @@ THESIS_IS_A_STANCE = """The thesis (T) is a STANCE: something the person holds,
 TETRAD_BUILD_PROCEDURE = f"""Building a tetrad, when you build one — as its two diagonal contradiction pairs (T+ vs A-, A+ vs T-).
 Each aspect has one fixed parent: T+ and T- develop T; A+ and A- develop A.
 For each pair:
-1. Derive each aspect from ITS OWN parent — a plus develops that parent so it also takes up what the other pole offers; a minus overdevelops that parent one-sidedly, with the other pole absent.
+1. Derive each aspect from ITS OWN parent — a plus develops that parent so that what the other pole is for stays POSSIBLE alongside it, not so that it delivers it; a minus overdevelops that parent one-sidedly, with the other pole absent. Each aspect is a POSITION held or a good someone values, never a move to make: the moves come later, from the way through the tension.
 2. Then name the **axis** — the single dimension on which the two aspects are opposite ends, so they cannot both hold at once.
 3. Re-read both aspects against step 1 for two distinct failures. (a) Wrong parent: if one is really the OTHER parent developed, rewrite it from its own parent. (b) {PLUS_RESTATEMENT_CHECK}"""
 
 
-def view_sketch_prompt(focus: Optional[str], max_words: int) -> str:
+#: What the thesis is when the HOST already has it and wants it kept word for
+#: word. Distinct from `tetrad_sketch_prompt`'s given-thesis line, which asks
+#: for the position "worded in the person's own terms, {max_words} words or
+#: fewer" — a condensation, which is right for `anchor` (the model named the
+#: position, the graph stores a headline) and wrong for a host that shows the
+#: person their OWN sentence as their position (the first app, 2026-10-12: the
+#: card displays the typed words while T was a seven-word recomposition of
+#: them). So this one forbids the rewording the other one invites, and the
+#: framework does not rely on it being obeyed: `Consultant.exploration_view`
+#: writes the given text back over the drawn one (the pin is in code; this
+#: text only stops the writer building the rest of the tetrad around a position
+#: it has quietly reworded).
+THESIS_IS_FIXED = """The thesis (T) is GIVEN, in the person's own words, and it is FIXED: carry it into the view exactly as it stands — do not reword, shorten, sharpen or generalise it, and do not put a different position in its place. Everything else in the tetrad is built around it as given."""
+
+
+def view_sketch_prompt(
+    focus: Optional[str], max_words: int, thesis: Optional[str] = None
+) -> str:
     """The structured turn's request, over the consultant's own conversation.
 
     Two instructions in one, because the ask is one or the other and the model
@@ -203,12 +234,42 @@ def view_sketch_prompt(focus: Optional[str], max_words: int) -> str:
     (docs/dev-notes/antithesis-selection.md, 2026-10-02). The thesis is asked
     for as a STANCE (`THESIS_IS_A_STANCE`): on 20 questions the turn echoed the
     question as T in 6 before the ask was here (the alsotrue app repo, docs/lab-notes-entry.md).
+
+    With `thesis` the host has the position already and wants it kept verbatim
+    (`THESIS_IS_FIXED`): the stance ask comes OFF — there is nothing to find —
+    and the view is asked for the ONE tension that position stands in, because
+    a pinned T says nothing about any other tension and a card shows one.
     """
+    pinned = (thesis or "").strip()
     focus_line = (
         f"What to show: {focus}\n\n"
         if focus and focus.strip()
         else "What to show: the tensions this conversation has worked out so far.\n\n"
     )
+    scope_line = (
+        "- ONE tension: the one the given position below stands in. How much of "
+        "it is drawn is still the ask's to say, by the rule above."
+        if pinned
+        else f"- At most {VIEW_SKETCH_MAX_PERSPECTIVES} tensions, most central "
+        "first. Nothing at all rather than a tension the conversation does not "
+        "support — a turn that carries no stance (a request for information) "
+        "supports none."
+    )
+    thesis_section = (
+        f'{THESIS_IS_FIXED}\n\nThe position: "{pinned}"'
+        if pinned
+        else THESIS_IS_A_STANCE
+    )
+    # The exception rides on the line that states the limit, not as a
+    # cross-reference from the section above it: a rule and its exception in
+    # two places is the competing-signal shape, and the limit is the last line
+    # the model reads.
+    length_exception = (
+        " The given position is the one exception: it stays exactly as it is, "
+        "whatever its length."
+        if pinned
+        else ""
+    )
     return f"""Draw the structure of this conversation as dialectical tetrads. Answer with ONE JSON object in the requested schema and nothing else — no prose. Earlier drawings in this conversation are recorded in prose; that is their record, not the format of this answer.
 
 {focus_line}{ASPECT_DEFINITIONS}
@@ -217,15 +278,15 @@ Rules for what goes in the view:
 - Show what this conversation has ESTABLISHED: a tension you named and the person took up is drawn as you both have it, in their terms. Do not re-derive what is already on the table.
 - Where the ask needs structure not yet worked out — a perspective for a thesis so far only stated, the antithesis of a position, the corners of a tension you only named — build it now, by the method below, and then draw it.
 - Where the ask stops short of a full tetrad (only the two poles, only the antitheses), leave the positions not asked for EMPTY. An empty corner is honest; an invented one is not.
-- At most {VIEW_SKETCH_MAX_PERSPECTIVES} tensions, most central first. Nothing at all rather than a tension the conversation does not support — a turn that carries no stance (a request for information) supports none.
+{scope_line}
 
-{THESIS_IS_A_STANCE}
+{thesis_section}
 
 {_OPPOSING_POSITION_ASK}
 
 {TETRAD_BUILD_PROCEDURE}
 
-Write every position in the person's own terms, {max_words} words or fewer each."""
+Write every position in the person's own terms, {max_words} words or fewer each.{length_exception}"""
 
 
 # --- The view shaping (pure) ----------------------------------------------

{dialectical_framework-2.0.9 → dialectical_framework-2.0.12}/src/dialectical_framework/settings.py

@@ -40,8 +40,8 @@ class Settings(BaseModel):
 
     Per process (read once, from the base `DialecticalReasoning.setup()` installs;
     a value inside `using_settings` has no effect): `graph_db_*` (the connection is
-    a Singleton), `llm_connect_timeout_s` (the provider is registered once),
-    `effect_log_dir` (installed in `setup`). `DIALEXITY_MAX_CONCURRENT_LLM_CALLS`
+    a Singleton), `llm_connect_timeout_s` and `llm_read_timeout_s` (the provider
+    is registered once), `effect_log_dir` (installed in `setup`). `DIALEXITY_MAX_CONCURRENT_LLM_CALLS`
     is not a field at all: an env var behind one process-wide semaphore.
     """
 
@@ -276,6 +276,29 @@ class Settings(BaseModel):
     # slow generation is not the problem being solved here.
     llm_connect_timeout_s: float = Field(default=30.0, description="TCP/TLS connect timeout for LLM calls, in seconds. Raise on slow or high-latency links.")
 
+    # Read timeout for the Bedrock client, in seconds: how long one provider
+    # call may go without a byte arriving before it raises (`APITimeoutError`,
+    # which the ladder retries ONCE — `use_brain._STALL_RETRY_MAX`).
+    #
+    # The SDK's default is 600s, and the client used to keep it, so a stalled
+    # call held whatever was waiting on it for ten minutes with no error and no
+    # retry on record (a 610s turn, `prompt-vs-machinery`; the handoff that set
+    # this field: one of three gathered draws hung a 20-31s card for 300s,
+    # 2026-10-09, Sonnet 5.5). On a NON-streamed call the body arrives whole,
+    # so this is a ceiling on one generation; on a streamed round it is the gap
+    # between two chunks, and a thinking turn streams its deltas (the
+    # facilitator asks for `include_thoughts`), so the long silence is the
+    # non-streamed case only. 120s clears every unstalled generation in the
+    # archive (the longest measured conversational rounds sit under a minute on
+    # Sonnet 5 with thinking) while cutting a stall from 600s to two minutes. A
+    # host whose calls are short sets it lower: the first app's draws run ~15s,
+    # texts ~8s, structured calls ~3s on Sonnet 5.5, and it runs at 30s. Too
+    # low, and a legitimately long generation (a digest of a 40k-character
+    # part, an Opus round with a large dump) is cut and re-asked — the retry
+    # does not help a call that needed the time. Read once, with the connect
+    # timeout, when the provider registers.
+    llm_read_timeout_s: float = Field(default=120.0, description="Read timeout for LLM calls, in seconds: the longest one call may wait for the provider's next byte. Lower where every call is short; a stall then surfaces as a timeout instead of holding the caller.")
+
     @classmethod
     def from_partial(cls, partial_settings: Optional[Settings] = None) -> Self:
         """
@@ -353,5 +376,6 @@ class Settings(BaseModel):
             # something. `**` on an empty dict sends nothing.
             **_env_thinking_level(),
             llm_connect_timeout_s=float(os.getenv("DIALEXITY_LLM_CONNECT_TIMEOUT_S", 30.0)),
+            llm_read_timeout_s=float(os.getenv("DIALEXITY_LLM_READ_TIMEOUT_S", 120.0)),
             effect_log_dir=os.getenv("DIALEXITY_GRAPH_LOG_DIR"),
         )

{dialectical_framework-2.0.9 → dialectical_framework-2.0.12}/src/dialectical_framework/settings_context.py

@@ -31,8 +31,8 @@ TWO TIERS, as the code already treats them (see `Settings`):
   through `SettingsAware.settings` (word limits, thinking level, the Advisor's
   floors and caps, the audit switches);
 - read ONCE per process, from the base only: `graph_db_*` (the connection is a
-  Singleton), `llm_connect_timeout_s` (the provider is registered once),
-  `effect_log_dir` (installed in `setup`). A value for these inside
+  Singleton), `llm_connect_timeout_s` and `llm_read_timeout_s` (the provider is
+  registered once), `effect_log_dir` (installed in `setup`). A value for these inside
   `using_settings` has no effect, by construction, not by accident.
 
 `container.settings.override(...)` RAISES: it would replace this provider with one

{dialectical_framework-2.0.9 → dialectical_framework-2.0.12}/src/dialectical_framework/utils/bedrock_provider.py

@@ -36,27 +36,51 @@ if TYPE_CHECKING:
     from mirascope.llm.tools import AsyncToolkit, Toolkit
 
 
-def _connect_timeout(connect_timeout_s: float | None) -> httpx.Timeout:
-    """SDK default timeouts with a widened CONNECT phase only.
-
-    The SDK's 5s connect timeout assumes a warm datacenter link. A cold TLS
-    handshake over a tethered/VPN/mobile connection measured 7.7s, so the first
-    call on every fresh connection failed — and the parallel stages failed
-    hardest, since each concurrent call opens its own cold connection while a
-    sequential one reuses a handshaked socket. Read/write keep the SDK defaults:
-    a slow-to-connect link is a different problem from a slow generation, and
-    conflating them would mask real hangs.
+def _client_timeout(
+    connect_timeout_s: float | None, read_timeout_s: float | None = None
+) -> httpx.Timeout:
+    """SDK default timeouts with the CONNECT and READ phases set by the framework.
+
+    Connect: the SDK's 5s assumes a warm datacenter link. A cold TLS handshake
+    over a tethered/VPN/mobile connection measured 7.7s, so the first call on
+    every fresh connection failed — and the parallel stages failed hardest,
+    since each concurrent call opens its own cold connection while a sequential
+    one reuses a handshaked socket.
+
+    Read: the SDK's 600s is the length of a stall nobody asked for. A provider
+    call that stops sending holds its caller for ten minutes with no error, and
+    where callers are gathered (the view turn's best-of-3) one stalled draw
+    holds the two that finished (a 300s card where the same case took 20-31s,
+    2026-10-09). `Settings.llm_read_timeout_s` sets it; a timeout raises
+    `APITimeoutError`, which the ladder classifies as a stall and re-asks once.
+    Write and pool keep the SDK defaults: nothing has stalled on either.
     """
-    seconds = connect_timeout_s if connect_timeout_s is not None else 30.0
+    connect = connect_timeout_s if connect_timeout_s is not None else 30.0
+    read = read_timeout_s if read_timeout_s is not None else 120.0
     default = DEFAULT_TIMEOUT
     return httpx.Timeout(
-        connect=seconds,
-        read=default.read,
+        connect=connect,
+        read=read,
         write=default.write,
         pool=default.pool,
     )
 
 
+#: The Anthropic SDK's own retry is OFF: every retry the framework makes is one
+#: it can see. The SDK defaults to two retries of a timeout, a connection error
+#: or a 408/409/429/5xx with its own backoff, BELOW `use_brain`'s ladder and
+#: `retry_transient` — so a stalled call cost three read timeouts before the
+#: ladder saw one failure, and `retry_accounting`/`call_census` recorded none of
+#: it (a 610s turn with `retry_count` 0, `prompt-vs-machinery`). With this at 0
+#: the bound on one call is the ladder's: a stall is (`_STALL_RETRY_MAX`) × the
+#: read timeout plus its flat delay, and the retry is on the account. Every
+#: provider request the framework makes passes a retry layer of its own — the
+#: ladder (`use_brain`), the streamed open and resume (`retry_transient` in
+#: `_start_stream_round`) and, since this went to 0, the awaited resume too
+#: (`ConversationFacilitator.submit`), which until then had only the SDK's.
+_SDK_MAX_RETRIES = 0
+
+
 #: Start of the Advisor's mutable graph dump inside its system prompt.
 #:
 #: `_CONTEXT_SLOT` (`agents/advisor/system_prompts.py`) is the LAST section and the
@@ -361,11 +385,19 @@ class BedrockAnthropicProvider(AnthropicProvider):
     id = "bedrock"
     default_scope = "bedrock/"
 
-    def __init__(self, *, connect_timeout_s: float | None = None, **kwargs) -> None:  # noqa: ARG002
+    def __init__(
+        self,
+        *,
+        connect_timeout_s: float | None = None,
+        read_timeout_s: float | None = None,
+        **kwargs,  # noqa: ARG002
+    ) -> None:
         # Skip super().__init__() — parent creates Anthropic/AsyncAnthropic clients we don't need
-        timeout = _connect_timeout(connect_timeout_s)
-        self.client = AnthropicBedrock(timeout=timeout)
-        self.async_client = AsyncAnthropicBedrock(timeout=timeout)
+        timeout = _client_timeout(connect_timeout_s, read_timeout_s)
+        self.client = AnthropicBedrock(timeout=timeout, max_retries=_SDK_MAX_RETRIES)
+        self.async_client = AsyncAnthropicBedrock(
+            timeout=timeout, max_retries=_SDK_MAX_RETRIES
+        )
         self._beta_provider = None
 
     @staticmethod
@@ -594,17 +626,19 @@ def ensure_bedrock_provider(
 ) -> None:
     """Register the bedrock provider if not already registered. Idempotent.
 
-    Registration happens on the first call, so `llm_connect_timeout_s` is read
-    from DI here rather than in `__init__` (Mirascope constructs providers with
-    no arguments). Consequence of the idempotence: changing the setting after
-    the first LLM call of the process has no effect.
+    Registration happens on the first call, so `llm_connect_timeout_s` and
+    `llm_read_timeout_s` are read from DI here rather than in `__init__`
+    (Mirascope constructs providers with no arguments). Consequence of the
+    idempotence: changing either setting after the first LLM call of the
+    process has no effect.
     """
     global _registered
     if _registered:
         return
     llm.register_provider(
         BedrockAnthropicProvider(
-            connect_timeout_s=getattr(settings, "llm_connect_timeout_s", None)
+            connect_timeout_s=getattr(settings, "llm_connect_timeout_s", None),
+            read_timeout_s=getattr(settings, "llm_read_timeout_s", None),
         ),
         scope="bedrock/",
     )