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

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

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

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

@@ -425,11 +425,13 @@ class Consultant:
         """
         from dialectical_framework.concerns.view_sketch import (
             ViewSketchDto, exploration_view_from_sketch, history_ask,
-            history_text, perspective_from_sketch, view_sketch_prompt)
+            history_text, judge_context, perspective_from_sketch,
+            view_sketch_prompt)
 
         import asyncio
         import dataclasses
 
+        from dialectical_framework.agents.advisor.migration import person_turns
         from dialectical_framework.concerns.tetrad_candidates import (
             clamp_attempts, ranking, select_sketch)
 
@@ -459,7 +461,6 @@ class Consultant:
             sketch_turn._messages = list(history)
             return await sketch_turn.submit(ViewSketchDto, request)
 
-        n = clamp_attempts(attempts)
         # Fully parallel, deliberately. On a COLD cache all N draws write the
         # ~12k system head instead of one writing and the rest reading (~$0.06
         # a card at list prices, 2026-10-06), and the fix would be to await the
@@ -470,6 +471,13 @@ class Consultant:
         # (`utils/bedrock_provider.py::_CACHE_TTL`) attacks the same cost
         # without the latency, which is the trade taken. Revisit only with a
         # measured cold-start rate.
+        n = clamp_attempts(attempts)
+        # The SAME request N times, by measurement: N identical requests draw
+        # the same opposition N times, reworded (the first app, 52/52 cards),
+        # and asking draw 2..N for a different one made the spares differ and
+        # the winner worse (CC 19/40 against 27/40, 2026-10-13,
+        # `tests/e2e/probe_view_turn_ask.py`) — so this is a coherence re-roll,
+        # and a host's "another" served from `runners_up` is a rewording.
         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)]
@@ -503,13 +511,20 @@ class Consultant:
         # screen shows is that first tension. The judged draws that lost come
         # back too, best first, as `runners_up` — a host's "again"/"another"
         # can serve one without a new call (the module's stated intent).
+        # The judge reads the PERSON's turns as its context (`judge_context`):
+        # it never sees T or A, and called blind — as it was here until
+        # 2026-10-13, while the build and the persisted path passed their
+        # material — it scored the four aspects against nothing.
         runners_up: list[PerspectiveView] = []
         if len(sketches) > 1:
             firsts = [s.tensions[0] if s.tensions else None for s in sketches]
             judgeable = [i for i, t in enumerate(firsts) if t is not None and all(
                 (getattr(t, k) or "").strip() for k in ("thesis", "antithesis", "t_plus", "t_minus", "a_plus", "a_minus"))]
             if len(judgeable) > 1:
-                _best, verdicts = await select_sketch([firsts[i] for i in judgeable])
+                _best, verdicts = await select_sketch(
+                    [firsts[i] for i in judgeable],
+                    context=judge_context(person_turns(history)),
+                )
                 order = ranking(verdicts)
                 sketch = sketches[judgeable[order[0]]]
                 runners_up = [perspective_from_sketch(firsts[judgeable[i]]) for i in order[1:]]

{dialectical_framework-2.0.12 → dialectical_framework-2.1.1}/src/dialectical_framework/concerns/tetrad_candidates.py

@@ -12,6 +12,22 @@ parallel, the two control statements judged for each, the best kept. The
 runners-up are returned, not thrown away — a person's "another" can be one of
 them without a new call.
 
+The N draws are N identical requests, and they draw the SAME opposition N
+times, reworded (the first app's handoff, 2026-10-13: 52/52 cards, the chosen
+A at 0.79 similarity to its spares, a served runner-up "the same tension
+re-worded" in 8/8 retries) — a coherence re-roll, which is what the figures
+above measure, not a choice between tensions. Asking draw 2..N for a
+DIFFERENT opposition was tried and rejected the same day on a pre-registered
+A/B (`tests/e2e/probe_view_turn_ask.py`, pinned, 40 utterances): the spares
+became different positions (75/80) and the winner lost — CC 19/40 against
+27/40, positions 34 against 37, 1.26x the seconds. Temperature is not a
+lever either: both one-shot writers think, and a thinking call takes the
+provider's default. The rejected ask and the record:
+`docs/dev-notes/antithesis-selection.md`, "Best-of-3 drew the same tetrad
+three times". What the handoff found beside it is kept: the ranking reads
+dialectical validity after the pass floor (`ranking`), and the view turn's
+judge reads the person's words (`view_sketch.judge_context`).
+
 What this must NOT become: a loop that optimises against the judge. The judge
 never sees the thesis or antithesis — it scores the four aspects' coherence
 and passes a MIRROR antithesis more readily than a genuine position — so a
@@ -75,17 +91,41 @@ def clamp_attempts(attempts: Optional[int], default: Optional[int] = None) -> in
 
 @dataclass(frozen=True)
 class SketchVerdict:
-    """The two control statements' coherence scores for one sketch."""
+    """The two control statements' scores for one sketch: coherence (CC) on
+    both, and dialectical validity (DV) on both where the judge gave it.
+
+    DV is scored in the SAME call as CC (`CoherenceEvaluationDto`), so carrying
+    it costs nothing; until 2026-10-13 it was computed on every draft and
+    dropped here, and the ranking read coherence alone (the first app's
+    handoff). `None` on the DV fields means the judge did not say — a verdict
+    built from CC alone — and such a verdict ranks BELOW any with a DV, never
+    as a zero (a zero is a claim).
+    """
 
     t_plus_without_a_plus: float
     a_plus_without_t_plus: float
     reasoning: str = ""
+    t_plus_without_a_plus_dv: Optional[float] = None
+    a_plus_without_t_plus_dv: Optional[float] = None
 
     @property
     def floor(self) -> float:
         """The weaker statement — what the pass/fail rule reads."""
         return min(self.t_plus_without_a_plus, self.a_plus_without_t_plus)
 
+    @property
+    def mean(self) -> float:
+        return (self.t_plus_without_a_plus + self.a_plus_without_t_plus) / 2
+
+    @property
+    def dialectical_validity(self) -> Optional[float]:
+        """The mean DV of the two statements — whether the relationship is a
+        natural, generative one rather than a forced pairing. `None` when the
+        judge gave none."""
+        if self.t_plus_without_a_plus_dv is None or self.a_plus_without_t_plus_dv is None:
+            return None
+        return (self.t_plus_without_a_plus_dv + self.a_plus_without_t_plus_dv) / 2
+
     @property
     def passes(self) -> bool:
         return self.floor >= CONCEPTUAL_COHERENCE_THRESHOLD
@@ -153,6 +193,8 @@ async def judge_sketches(
                 t_plus_without_a_plus=first.coherence_score,
                 a_plus_without_t_plus=second.coherence_score,
                 reasoning=f"{first.reasoning} / {second.reasoning}".strip(" /"),
+                t_plus_without_a_plus_dv=first.dialectical_validity,
+                a_plus_without_t_plus_dv=second.dialectical_validity,
             )
         except Exception as exc:  # noqa: BLE001 — degrade to "unjudged"
             logger.warning("Judging a sketch failed; it sorts last: %s", exc)
@@ -167,10 +209,11 @@ async def select_sketch(
     """Judge every candidate (gathered) and return the index of the best plus
     all verdicts (None where judging failed).
 
-    Ranking: the weaker control statement first (the pass rule), then the
-    mean, then the earlier draw — a deterministic tie-break, not a preference.
-    A candidate whose judging failed sorts last; if every judging failed the
-    first draw is kept, which is exactly what `attempts=1` would have done.
+    Ranking (`ranking`): the weaker control statement first (the pass rule),
+    then dialectical validity, then the mean coherence, then the earlier draw
+    — a deterministic tie-break, not a preference. A candidate whose judging
+    failed sorts last; if every judging failed the first draw is kept, which
+    is exactly what `attempts=1` would have done.
 
     ONE candidate is never judged: there is nothing to select among, so
     `attempts=1` costs no extra call.
@@ -183,15 +226,30 @@ async def select_sketch(
 
 
 def ranking(verdicts: Sequence[Optional[SketchVerdict]]) -> list[int]:
-    """Candidate indices best first, by `select_sketch`'s rule: the weaker
-    control statement, then the mean, then the earlier draw; unjudged last.
-    `[0]` is the winner; the rest are the runners-up in order."""
+    """Candidate indices best first: the weaker control statement, then
+    dialectical validity, then the mean coherence, then the earlier draw;
+    unjudged last. `[0]` is the winner; the rest are the runners-up in order.
+
+    Why the floor stays FIRST: it is the pass rule, and every best-of-N figure
+    on record (CC 36/40 on the view turn, 30/40 on the build, 26/46 on
+    documents) is a keep-any-passing-draw figure — a term ahead of it would
+    trade those for an unmeasured one. Why DV comes next, ahead of the mean:
+    DV is the paper's acceptance term beside SP (the Advisor's quality floor
+    already reads it), and it answers the question the choice is about — of
+    two draws that both hold, which is the LIVE tension rather than the
+    forced pairing — where the mean is only the other statement's score,
+    already above the floor. On the archive DV tracks CC at 0.96, so this
+    moves few selections — the draws of one request are rewordings of one
+    tension. A verdict with no DV sorts
+    below any with one (`-1.0` exists only to lose this term, like
+    `explorer._causality_probability`), never as a zero.
+    """
 
-    def key(index: int) -> tuple[int, float, float, int]:
+    def key(index: int) -> tuple[int, float, float, float, int]:
         verdict = verdicts[index]
         if verdict is None:
-            return (0, 0.0, 0.0, -index)
-        mean = (verdict.t_plus_without_a_plus + verdict.a_plus_without_t_plus) / 2
-        return (1, verdict.floor, mean, -index)
+            return (0, 0.0, 0.0, 0.0, -index)
+        dv = verdict.dialectical_validity
+        return (1, verdict.floor, -1.0 if dv is None else dv, verdict.mean, -index)
 
     return sorted(range(len(verdicts)), key=key, reverse=True)

{dialectical_framework-2.0.12 → dialectical_framework-2.1.1}/src/dialectical_framework/concerns/tetrad_sketch.py

@@ -128,8 +128,10 @@ class TetradSketch(ReasonableConcern[ViewSketchPerspectiveDto], SettingsAware):
         attempts: Optional[int] = None,
     ) -> ViewSketchPerspectiveDto:
         """One tension, whole. With `attempts` > 1 (`clamp_attempts`, max 3) the
-        call is drawn that many times IN PARALLEL and the framework's own
-        coherence check picks the best (`concerns/tetrad_candidates.py`); the
+        call is drawn that many times IN PARALLEL — the SAME request each
+        time: asking later draws for a different opposition was measured and
+        rejected on the view turn (`view_sketch_prompt`'s docstring) — and
+        the framework's own coherence check picks the best (`concerns/tetrad_candidates.py`); the
         runners-up stay on `self.alternatives` with their verdicts, the
         winner's verdict on `self.verdict`. Measured reason and the guard
         against turning this into a loop: that module's docstring.
@@ -171,6 +173,12 @@ class TetradSketch(ReasonableConcern[ViewSketchPerspectiveDto], SettingsAware):
                 "drawn": len(candidates),
                 "selected": best,
                 "floors": [None if v is None else round(v.floor, 2) for v in verdicts],
+                "validity": [
+                    None if v is None or v.dialectical_validity is None
+                    else round(v.dialectical_validity, 2)
+                    for v in verdicts
+                ],
+                "oppositions": [c.antithesis for c in candidates],
                 "alternatives": [c.model_dump() for c, _v in self.alternatives],
             }
         return tension

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

@@ -45,7 +45,7 @@ The view BEFORE the upgrade, not a lighter version of the checked one.
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import Optional, Sequence
 
 from pydantic import BaseModel, Field
 
@@ -215,6 +215,33 @@ For each pair:
 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."""
 
 
+
+#: How much of the person's own words the view turn's JUDGE reads (characters,
+#: newest turns kept whole). The judge never sees T or A, so without context
+#: it scores the four aspects' coherence against nothing: the persisted path
+#: and the one-shot build pass their material, and the view turn passed ""
+#: until 2026-10-13 (the first app's handoff, §3). The person's turns are what
+#: the migration mines as material too (`migration.person_turns`); a card's
+#: history is one utterance, a long consultation is bounded here so six judge
+#: calls do not each re-read it whole (no cache breakpoint sits on a judge
+#: call). Policy, not config.
+JUDGE_CONTEXT_CHARS = 4_000
+
+
+def judge_context(person_texts: Sequence[str], budget: int = JUDGE_CONTEXT_CHARS) -> str:
+    """The person's turns as the judge's `<context>`, in order, the NEWEST
+    kept whole within `budget` and older ones dropped first — a tetrad drawn
+    now answers what was said last. Empty when nothing was said."""
+    kept: list[str] = []
+    used = 0
+    for text in reversed([t.strip() for t in person_texts if t and t.strip()]):
+        if kept and used + len(text) > budget:
+            break
+        kept.append(text)
+        used += len(text)
+    return "\n\n".join(reversed(kept))
+
+
 def view_sketch_prompt(
     focus: Optional[str], max_words: int, thesis: Optional[str] = None
 ) -> str:
@@ -239,6 +266,16 @@ def view_sketch_prompt(
     (`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.
+
+    ONE request for every draw of a best-of-N, by measurement (2026-10-13,
+    `tests/e2e/probe_view_turn_ask.py`, pinned, 40 utterances, two arms the
+    same day): asking draw 2..N for a different opposition made every card's
+    spares a different position (75/80 positions) and cost the WINNER —
+    coherence 19/40 against 27/40 with identical draws, positions 34 against
+    37, 1.26x the seconds — so the draws stay a re-roll of one request and
+    the spares stay the same tension reworded. The rejected ask and its
+    figures: `docs/dev-notes/antithesis-selection.md`, "Best-of-3 drew the
+    same tetrad three times".
     """
     pinned = (thesis or "").strip()
     focus_line = (

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

@@ -288,8 +288,10 @@ class Settings(BaseModel):
     # 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
+    # non-streamed case only. Since `llm_stream_awaited_calls` (below) every
+    # awaited call is streamed too, so this bounds the wait for the first
+    # content; a hang is caught earlier, when the response fails to open.
+    # 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
@@ -299,6 +301,21 @@ class Settings(BaseModel):
     # 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.")
 
+    # Every awaited Bedrock call (`BedrockAnthropicProvider._create_async`) is
+    # sent as a stream and assembled into the same `Message` before Mirascope
+    # decodes it, so a stall is caught where it happens instead of at the whole
+    # read timeout: the response must OPEN within 5s (`_STREAM_HEADERS_TIMEOUT_S`),
+    # content must start within `llm_read_timeout_s`, and a gap past 5s once it
+    # flows is a stall. Measured on the first app's promise run (2026-10-12,
+    # Sonnet 5.5, 59 cases, read timeout 20s): ~5.5% of calls hang, ALL before
+    # the response opens, while healthy calls open in a median 1.2s whatever
+    # their size; against a same-day baseline, cards drawn 43 -> 51, cards past
+    # the app's deadline 9 -> 0, p90 53s -> 33s, cost unchanged. The switch
+    # exists as an off switch for a model or provider the measurement did not
+    # cover (`docs/dev-notes/streaming-latency-and-retry.md`, "Hangs are caught
+    # at the opening"). Per request.
+    llm_stream_awaited_calls: bool = Field(default=True, description="Send awaited provider calls as streams and assemble the message, so a hung call is caught when the response fails to open (5s) rather than at the whole read timeout. On by default; off only for a model or provider where streaming misbehaves.")
+
     @classmethod
     def from_partial(cls, partial_settings: Optional[Settings] = None) -> Self:
         """
@@ -377,5 +394,6 @@ class Settings(BaseModel):
             **_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)),
+            llm_stream_awaited_calls=os.getenv("DIALEXITY_LLM_STREAM_AWAITED_CALLS", "true").lower() == "true",
             effect_log_dir=os.getenv("DIALEXITY_GRAPH_LOG_DIR"),
         )

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

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import asyncio
+import logging
+import time
 from collections.abc import Mapping, Sequence
 from typing import TYPE_CHECKING, Any, cast
 
@@ -18,6 +21,7 @@ from typing_extensions import Unpack
 from dialectical_framework.enums.di import DI
 from dialectical_framework.exceptions.provider_errors import ModelRefusal
 from dialectical_framework.settings import Settings
+from dialectical_framework.settings_context import get_current_settings
 from dialectical_framework.utils.format_compat import (
     learn_format_mode_from_error,
     structured_output_format,
@@ -375,6 +379,135 @@ def raise_on_refusal(response: Any, model_name: str) -> None:
     )
 
 
+logger = logging.getLogger(__name__)
+
+#: Once a streamed awaited call has started writing content, the longest it may
+#: go without another event before it counts as a stall. Generation is a steady
+#: flow of deltas, so a silence this long mid-content is a hang rather than a
+#: slow token. Before the first content delta the wait is the read timeout:
+#: that window holds queueing, prefill and (where a call thinks) the thinking
+#: block. Fired once in 2,700 streamed calls on the first app's promise runs,
+#: so it is a backstop; the measured hangs are all caught at the opening.
+_STREAM_GAP_TIMEOUT_S = 5.0
+
+#: How long a streamed awaited call may wait for the response to OPEN (headers,
+#: `message_start`) before it counts as a stall. Measured on the first app's
+#: promise run (2026-10-12, Sonnet 5.5, 890 streamed calls): every stall (48,
+#: 5.4%) hung before the headers, while healthy calls opened at a median 1.2s,
+#: p99 3.6s, whatever their size (6 of 842 past 5s). Streamed, the opening is
+#: the one wait that does not grow with the output, so it is where a hang is
+#: caught: here at 5s rather than at the whole read timeout.
+_STREAM_HEADERS_TIMEOUT_S = 5.0
+
+#: Deltas that are the answer being written, as opposed to thinking or
+#: bookkeeping. The SDK's stream yields both the raw `content_block_delta` and
+#: a synthesized event per delta kind.
+_CONTENT_DELTAS = frozenset({"text_delta", "input_json_delta"})
+_CONTENT_EVENTS = frozenset({"text", "input_json"})
+
+
+class StreamReadTimeout(httpx.ReadTimeout):
+    """A streamed awaited call went quiet past its budget.
+
+    Subclasses `httpx.ReadTimeout` so `use_brain._is_stall_error` reads it as a
+    stall (the name ends in `ReadTimeout`) and re-asks it once, exactly like a
+    socket read timeout on the non-streamed path.
+    """
+
+
+def _is_content_event(event: Any) -> bool:
+    kind = getattr(event, "type", None)
+    if kind in _CONTENT_EVENTS:
+        return True
+    if kind == "content_block_delta":
+        return getattr(getattr(event, "delta", None), "type", None) in _CONTENT_DELTAS
+    return False
+
+
+async def _stream_to_message(
+    manager: _LearningStreamManager, model_name: str, read_timeout_s: float
+) -> AnthropicMessage:
+    """Consume one stream and return the assembled `Message`, policing silence.
+
+    Three budgets: the response must OPEN within `_STREAM_HEADERS_TIMEOUT_S`
+    (where the measured hangs are), the first content must follow within the
+    read timeout (queueing, prefill, thinking), and once content flows a gap
+    longer than `_STREAM_GAP_TIMEOUT_S` is a stall.
+
+    The provider's `ping`s do not count as progress: a stream that only pings
+    is a hang the socket's read timeout would never see. Every stall is logged
+    with the phase it happened in: the phase is what chose the opening as the
+    place to police (all 137 measured hangs were there), and a shift in it is
+    the first sign that choice needs revisiting.
+    """
+    loop = asyncio.get_running_loop()
+    started = time.monotonic()
+    headers_budget = min(_STREAM_HEADERS_TIMEOUT_S, read_timeout_s)
+    try:
+        stream = await asyncio.wait_for(manager.__aenter__(), timeout=headers_budget)
+    except asyncio.TimeoutError as e:
+        logger.warning(
+            "Stream stalled on %s before headers (%.1fs)",
+            model_name, time.monotonic() - started,
+        )
+        raise StreamReadTimeout(
+            f"stream did not open within {headers_budget:.0f}s"
+        ) from e
+    except Exception as e:
+        if type(e).__name__.endswith(("TimeoutError", "ReadTimeout")):
+            logger.warning(
+                "Stream stalled on %s before headers (%.1fs)",
+                model_name, time.monotonic() - started,
+            )
+        raise
+    events = 0
+    first_content_s: float | None = None
+    try:
+        iterator = stream.__aiter__()
+        deadline = loop.time() + read_timeout_s
+        while True:
+            try:
+                event = await asyncio.wait_for(
+                    iterator.__anext__(), timeout=max(deadline - loop.time(), 0.0)
+                )
+            except StopAsyncIteration:
+                break
+            except Exception as e:
+                timed_out_here = isinstance(e, asyncio.TimeoutError)
+                if not timed_out_here and not type(e).__name__.endswith(
+                    ("Timeout", "TimeoutError")
+                ):
+                    raise
+                elapsed = time.monotonic() - started
+                phase = (
+                    "before first content"
+                    if first_content_s is None
+                    else f"mid-content (first content at {first_content_s:.1f}s)"
+                )
+                logger.warning(
+                    "Stream stalled on %s %s: %.1fs, %d events",
+                    model_name, phase, elapsed, events,
+                )
+                if not timed_out_here:
+                    raise
+                raise StreamReadTimeout(
+                    f"stream went quiet {phase} after {elapsed:.1f}s and {events} events"
+                ) from e
+            if getattr(event, "type", None) == "ping":
+                continue
+            events += 1
+            if first_content_s is None and _is_content_event(event):
+                first_content_s = time.monotonic() - started
+            budget = read_timeout_s if first_content_s is None else _STREAM_GAP_TIMEOUT_S
+            deadline = loop.time() + budget
+        message = await stream.get_final_message()
+    except BaseException as e:
+        await manager.__aexit__(type(e), e, e.__traceback__)
+        raise
+    await manager.__aexit__(None, None, None)
+    return message
+
+
 class BedrockAnthropicProvider(AnthropicProvider):
     """Mirascope v2 provider that routes through AnthropicBedrock client (async-native).
 
@@ -394,6 +527,7 @@ class BedrockAnthropicProvider(AnthropicProvider):
     ) -> None:
         # Skip super().__init__() — parent creates Anthropic/AsyncAnthropic clients we don't need
         timeout = _client_timeout(connect_timeout_s, read_timeout_s)
+        self._read_timeout_s = timeout.read or 120.0
         self.client = AnthropicBedrock(timeout=timeout, max_retries=_SDK_MAX_RETRIES)
         self.async_client = AsyncAnthropicBedrock(
             timeout=timeout, max_retries=_SDK_MAX_RETRIES
@@ -468,8 +602,20 @@ class BedrockAnthropicProvider(AnthropicProvider):
         models reject. `with_thinking_compat` translates by model name; if the
         name heuristic is wrong the 400 itself says which shape is wanted, so
         one retry is both sufficient and self-correcting. See thinking_compat.
+
+        With `Settings.llm_stream_awaited_calls` the same request goes out as a
+        stream and comes back as the same assembled `Message`, so a stall is
+        caught by the gap between chunks (`_stream_to_message`) instead of by a
+        ceiling on the whole generation. The stream manager learns the thinking
+        shape the same way.
         """
         model_name = kwargs["model"]
+        if get_current_settings().llm_stream_awaited_calls:
+            return await _stream_to_message(
+                _LearningStreamManager(self.async_client, kwargs, params),
+                model_name,
+                self._read_timeout_s,
+            )
         try:
             return await self.async_client.messages.create(
                 **with_thinking_compat(model_name, kwargs, params)