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

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

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

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

@@ -42,6 +42,7 @@ from dialectical_framework.agents.stream_events import (ResponseComplete,
                                                         StreamEvent, TextDelta,
                                                         ToolResult, ToolStart)
 from dialectical_framework.agents.toolsets import merge_app_tools
+from dialectical_framework.exceptions.provider_errors import ModelRefusal
 from dialectical_framework.agents.turn_timing import (ClosingOutcome,
                                                        DeferralOutcome,
                                                        TurnTiming)
@@ -850,7 +851,13 @@ class Advisor(SettingsAware):
             # Around the provider round ONLY — the closing seam and the
             # off-turn scheduling below run outside it on purpose.
             with speaking(user_message):
-                result = await self._conversation.submit(ChatResponse, user_message)
+                try:
+                    result = await self._conversation.submit(
+                        ChatResponse, user_message
+                    )
+                except ModelRefusal:
+                    await self._settle_refused_turn(user_message)
+                    raise
             reply_path_s = (
                 deferred_wait_s
                 + context_render_s
@@ -966,33 +973,37 @@ class Advisor(SettingsAware):
             # Entered here, before the stream is opened, because the tool runs
             # inside the generator while it is being iterated.
             with speaking(user_message):
-                async with aclosing(
-                    self._conversation.submit_stream(ChatResponse, user_message)
-                ) as rounds:
-                    async for event in rounds:
-                        if isinstance(event, ResponseComplete):
-                            final_event = event
-                            reply = event.message
-                            # `continue`, so `submit_stream` is asked for one more
-                            # event and runs to its own end instead of being closed
-                            # while suspended at its yield. The seconds read below are
-                            # safe either way — it stamps them as this event passes
-                            # through it, not on exit — but running out is still the
-                            # cleaner exit: the provider's connection is let go of by
-                            # exhaustion rather than by a close unwinding a live frame.
-                            continue
-                        if hygiene is not None:
-                            if isinstance(event, TextDelta):
-                                clean = hygiene.feed(event.text)
-                                if clean:
-                                    yield TextDelta(text=clean)
+                try:
+                    async with aclosing(
+                        self._conversation.submit_stream(ChatResponse, user_message)
+                    ) as rounds:
+                        async for event in rounds:
+                            if isinstance(event, ResponseComplete):
+                                final_event = event
+                                reply = event.message
+                                # `continue`, so `submit_stream` is asked for one more
+                                # event and runs to its own end instead of being closed
+                                # while suspended at its yield. The seconds read below are
+                                # safe either way — it stamps them as this event passes
+                                # through it, not on exit — but running out is still the
+                                # cleaner exit: the provider's connection is let go of by
+                                # exhaustion rather than by a close unwinding a live frame.
                                 continue
-                            if isinstance(event, (ToolStart, ToolResult)):
-                                tail = hygiene.flush()
-                                if tail:
-                                    yield TextDelta(text=tail)
-                                hygiene = HashCitationFilter()
-                        yield event
+                            if hygiene is not None:
+                                if isinstance(event, TextDelta):
+                                    clean = hygiene.feed(event.text)
+                                    if clean:
+                                        yield TextDelta(text=clean)
+                                    continue
+                                if isinstance(event, (ToolStart, ToolResult)):
+                                    tail = hygiene.flush()
+                                    if tail:
+                                        yield TextDelta(text=tail)
+                                    hygiene = HashCitationFilter()
+                            yield event
+                except ModelRefusal:
+                    await self._settle_refused_turn(user_message)
+                    raise
             if hygiene is not None:
                 tail = hygiene.flush()
                 if tail:
@@ -2829,6 +2840,27 @@ class Advisor(SettingsAware):
             logger.exception("Accepted-cost ground resolution failed (fail-soft)")
         return None
 
+    async def _settle_refused_turn(self, user_message: str) -> None:
+        """The closing work a refused turn still owes, before the refusal goes on.
+
+        A refusal can arrive AFTER tool rounds: the resume round is the one
+        declined, so `record_decision` may already have written a Decision and
+        `note` may already have kept a Note. The facilitator drops the turn
+        from history, but the graph keeps what the tools wrote — and without
+        this the recorded decision never gets its pathway weave (the seam's
+        MODEL_RECORDED branch is what schedules it) and the noted tensions wait
+        for the next turn to be offered. Only the work the tools already did is
+        followed up: the classifier is not asked about a turn that was refused,
+        so no decision is written here that the model did not write.
+        Fail-soft: the refusal is what the host must see.
+        """
+        try:
+            if self._recorded_decision_this_turn():
+                await self._repair_unrecorded_decision(user_message, "")
+            self._schedule_noted_tensions()
+        except Exception:
+            logger.exception("Closing work after a refused turn failed (fail-soft)")
+
     def _recorded_decision_this_turn(self) -> bool:
         """Did `record_decision` already run, successfully, on this turn?
 

{dialectical_framework-2.0.6 → 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.6 → dialectical_framework-2.0.8}/src/dialectical_framework/agents/conversation_facilitator.py

@@ -29,6 +29,7 @@ from dialectical_framework.agents.stream_events import (
     ToolStart,
 )
 from dialectical_framework.agents.turn_timing import ToolRound
+from dialectical_framework.exceptions.provider_errors import ModelRefusal
 from dialectical_framework.protocols.has_config import SettingsAware
 from dialectical_framework.utils.call_census import record_call
 from dialectical_framework.utils.thinking_compat import conversational_round
@@ -37,7 +38,7 @@ from dialectical_framework.utils.retry_accounting import (RetryAccount,
 from dialectical_framework.utils.use_brain import (prefill_token_kwargs,
                                                   retry_transient, use_brain)
 
-from mirascope.llm import TextChunk, ThoughtChunk, ToolOutput
+from mirascope.llm import FinishReason, TextChunk, ThoughtChunk, ToolOutput
 
 if TYPE_CHECKING:
     from mirascope.llm import UserContent
@@ -513,6 +514,7 @@ class ConversationFacilitator(SettingsAware):
         Returns:
             Structured response matching response_model
         """
+        history_before = len(self._messages)
         self._messages.append(llm.messages.user(user_content))
         self.last_tool_calls = []
         self.last_tool_results = []
@@ -567,6 +569,10 @@ class ConversationFacilitator(SettingsAware):
                     # Mirascope's own request, so nothing in `use_brain` marks it).
                     with conversational_round():
                         response = await response.resume(tool_outputs)
+                    # 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:
+                        raise ModelRefusal(getattr(response, "model_id", "unknown"))
 
                 # Sync full conversation history from the response chain
                 self._messages = list(response.messages)
@@ -580,6 +586,9 @@ class ConversationFacilitator(SettingsAware):
 
                 # Extract structured response
                 return await self._call_with_response_model(response_model)
+        except ModelRefusal:
+            self._forget_refused_turn(history_before)
+            raise
         finally:
             if epoch == self._turn_epoch:
                 self.last_submit_seconds = time.monotonic() - started
@@ -631,6 +640,7 @@ class ConversationFacilitator(SettingsAware):
         #: with a later reading, or every ordinary turn would silently absorb
         #: however long the consumer took to come back for the last event.
         recorded = False
+        history_before = len(self._messages)
         # Held in a name so it can be closed; see the docstring.
         rounds = self._stream_turn(
             response_model,
@@ -644,6 +654,9 @@ class ConversationFacilitator(SettingsAware):
                     self.last_submit_seconds = time.monotonic() - started
                     recorded = True
                 yield event
+        except ModelRefusal:
+            self._forget_refused_turn(history_before)
+            raise
         finally:
             # Before the close, which can raise: the figure is the point.
             if not recorded and epoch == self._turn_epoch:
@@ -802,6 +815,13 @@ class ConversationFacilitator(SettingsAware):
                 first_chunk_at=first_chunk_at,
                 yielded_s=yielded_s,
             )
+            if getattr(stream, "finish_reason", None) == FinishReason.REFUSAL:
+                # The awaited path raises at the provider; a stream only says so
+                # in its last chunk, after any text has been yielded. The host
+                # has shown a partial reply and should replace it — the
+                # exception is the signal. No `stop_details` on this path.
+                raise ModelRefusal(getattr(stream, "model_id", "unknown"))
+
             if self.last_submit_first_delta_s is None and first_delta_at is not None:
                 # From the TURN's start, not this round's: the person has been
                 # waiting since they hit send, through the context re-render's
@@ -900,6 +920,17 @@ class ConversationFacilitator(SettingsAware):
 
     # --- Internal helpers ---
 
+    def _forget_refused_turn(self, history_before: int) -> None:
+        """Drop the refused turn from history, user message included.
+
+        A refused exchange left in history is the context the next request is
+        refused in again; the provider's guidance on a refusal is to change or
+        drop the turn that triggered it. The turn did not happen, so history
+        returns to where it stood before it — the host still has the person's
+        words and can offer them back for rephrasing.
+        """
+        del self._messages[history_before:]
+
     #: Answer written into the synthetic tool_result when the tool loop is cut
     #: short. Addressed to the model, because the model reads it: it must
     #: understand that the tool did not run and that it should wrap up with

dialectical_framework-2.0.8/src/dialectical_framework/exceptions/provider_errors.py

@@ -0,0 +1,42 @@
+"""
+Provider verdicts that are not transport faults.
+
+`ModelRefusal` is raised when the model stops with ``stop_reason: "refusal"``
+(the provider's policy classifiers intervened). It is deliberately its own
+type: before it existed a refusal reached the framework as an empty or cut-off
+reply, so a structured call re-asked it as a ParseError (ten times) and a
+conversational turn fell through to a second, structured call that was refused
+again. A refusal is the provider's answer to THIS request, so nothing retries
+it; the caller decides — a concern fails soft as on any error, a host shows the
+person something and lets them rephrase.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+class ModelRefusal(RuntimeError):
+    """The model declined the request (``stop_reason: "refusal"``).
+
+    ``category`` and ``explanation`` are the provider's ``stop_details`` when it
+    sends them (``"cyber"``, ``"bio"``, or None for an unnamed category); a
+    streamed round does not carry them and leaves both None. The explanation
+    text is not guaranteed stable by the provider — show it, never branch on it.
+    """
+
+    def __init__(
+        self,
+        model: str,
+        *,
+        category: Optional[str] = None,
+        explanation: Optional[str] = None,
+    ) -> None:
+        self.model = model
+        self.category = category
+        self.explanation = explanation
+        detail = f" ({category})" if category else ""
+        super().__init__(
+            f"Model {model} refused the request{detail}"
+            + (f": {explanation}" if explanation else "")
+        )

{dialectical_framework-2.0.6 → 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.6 → dialectical_framework-2.0.8}/src/dialectical_framework/utils/bedrock_provider.py

@@ -16,10 +16,17 @@ from mirascope.llm.responses import AsyncResponse, AsyncStreamResponse, Response
 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.utils.format_compat import (
+    learn_format_mode_from_error,
+    structured_output_format,
+    with_format_compat,
+)
 from dialectical_framework.utils.thinking_compat import (
     learn_thinking_shape_from_error,
     with_thinking_compat,
+    without_earlier_turn_thinking,
 )
 
 if TYPE_CHECKING:
@@ -288,6 +295,62 @@ def _bedrock_model_name(model_id: str) -> str:
     return model_id.removeprefix("bedrock/").removeprefix("anthropic/")
 
 
+class _LearningStreamManager:
+    """`messages.stream(...)` that learns the thinking shape from a 400, once.
+
+    The request is made when the manager is ENTERED (Mirascope's decoder does
+    `async with` on the first chunk), before anything has been yielded, so a
+    rejected shape can be re-sent without replaying a token — and the streamed
+    conversational round is exactly where an unset level goes out as "off",
+    so without this a wrong name heuristic would fail every streamed turn until
+    some awaited call taught the process. Thinking only: a learned FORMAT mode
+    would change the response's parser, which the caller already holds.
+    """
+
+    def __init__(
+        self, client: Any, kwargs: dict[str, Any], params: Mapping[str, Any]
+    ) -> None:
+        self._client = client
+        self._kwargs = kwargs
+        self._params = params
+        self._manager: Any = None
+
+    def _open(self) -> Any:
+        return self._client.messages.stream(
+            **with_thinking_compat(self._kwargs["model"], self._kwargs, self._params)
+        )
+
+    async def __aenter__(self) -> Any:
+        self._manager = self._open()
+        try:
+            return await self._manager.__aenter__()
+        except Exception as e:
+            if not learn_thinking_shape_from_error(self._kwargs["model"], e):
+                raise
+            self._manager = self._open()
+            return await self._manager.__aenter__()
+
+    async def __aexit__(self, *exc: Any) -> Any:
+        return await self._manager.__aexit__(*exc)
+
+
+def raise_on_refusal(response: Any, model_name: str) -> None:
+    """Raise `ModelRefusal` when the provider stopped on a refusal.
+
+    Raised at the provider, below `use_brain`, so no retry ladder ever re-asks
+    it (an unknown exception re-raises there) and the tool loop's resumes —
+    Mirascope's own requests, which reach this provider too — are covered.
+    """
+    if getattr(response, "stop_reason", None) != "refusal":
+        return
+    details = getattr(response, "stop_details", None)
+    raise ModelRefusal(
+        model_name,
+        category=getattr(details, "category", None),
+        explanation=getattr(details, "explanation", None),
+    )
+
+
 class BedrockAnthropicProvider(AnthropicProvider):
     """Mirascope v2 provider that routes through AnthropicBedrock client (async-native).
 
@@ -305,6 +368,65 @@ class BedrockAnthropicProvider(AnthropicProvider):
         self.async_client = AsyncAnthropicBedrock(timeout=timeout)
         self._beta_provider = None
 
+    @staticmethod
+    def _encode(
+        model_id: str,
+        messages: Sequence[Message],
+        toolkit: AsyncToolkit | Toolkit,
+        format: FormatSpec[FormattableT] | None,
+        params: Mapping[str, Any],
+    ) -> tuple[Any, Any, dict[str, Any]]:
+        """Encode a request in the formatting mode this model can take.
+
+        Forced tool use is re-asked as JSON for a model that refuses it (Claude
+        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. 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`).
+
+        A call moved OFF forced tool use is also sent with thinking off unless
+        it asked for thinking: forced tool choice is what kept every structured
+        call from thinking by default (0 thinking tokens with no parameter,
+        2026-09-24), and JSON mode with nothing sent is the provider's default,
+        thinking on. Without this every concern on a 5.5 model would think —
+        a cost, latency and behaviour change no figure was taken under.
+        `with_thinking_compat` turns "disabled" into the model's own off.
+        """
+        model_name = _bedrock_model_name(model_id)
+        compatible = with_format_compat(model_name, format)
+        input_messages, resolved_format, kwargs = _utils.encode_request(
+            model_id=model_id,
+            messages=messages,
+            tools=toolkit,
+            format=compatible,
+            params=params,
+        )
+        kwargs["model"] = model_name
+        # A structured call is never a round of the tool loop: no tools, and in
+        # JSON mode extra system text, so even THIS turn's blocks are bound to a
+        # prefix the request no longer has. Drop them all there.
+        kwargs["messages"] = without_earlier_turn_thinking(
+            model_name, kwargs["messages"], every_turn=format is not None
+        )
+        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
+
     async def _create_async(
         self, kwargs: dict[str, Any], params: Mapping[str, Any]
     ) -> AnthropicMessage:
@@ -353,18 +475,23 @@ class BedrockAnthropicProvider(AnthropicProvider):
         **params: Unpack[Params],
     ) -> AsyncResponse | AsyncResponse[FormattableT]:
         """Always use standard path — bedrock doesn't support beta structured outputs."""
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=toolkit,
-            format=format,
-            params=params,
-        )
-        kwargs["model"] = _bedrock_model_name(model_id)
-        _fix_cache_breakpoints(kwargs)
-        anthropic_response = cast(
-            AnthropicMessage, await self._create_async(kwargs, params)
+        input_messages, resolved_format, kwargs = self._encode(
+            model_id, messages, toolkit, format, params
         )
+        try:
+            anthropic_response = cast(
+                AnthropicMessage, await self._create_async(kwargs, params)
+            )
+        except Exception as e:
+            if not learn_format_mode_from_error(kwargs["model"], format, e):
+                raise
+            input_messages, resolved_format, kwargs = self._encode(
+                model_id, messages, toolkit, format, params
+            )
+            anthropic_response = cast(
+                AnthropicMessage, await self._create_async(kwargs, params)
+            )
+        raise_on_refusal(anthropic_response, kwargs["model"])
         include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
             anthropic_response, model_id, include_thoughts=include_thoughts
@@ -393,21 +520,10 @@ class BedrockAnthropicProvider(AnthropicProvider):
         **params: Unpack[Params],
     ) -> AsyncStreamResponse | AsyncStreamResponse[FormattableT]:
         """Stream responses from Bedrock Anthropic."""
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=toolkit,
-            format=format,
-            params=params,
+        input_messages, resolved_format, kwargs = self._encode(
+            model_id, messages, toolkit, format, params
         )
-        kwargs["model"] = _bedrock_model_name(model_id)
-        _fix_cache_breakpoints(kwargs)
-        # Streaming cannot learn from a 400: the error surfaces when the caller
-        # consumes the iterator, by which point retrying would replay tokens
-        # already yielded. The name heuristic is applied, and a genuine mismatch
-        # raises to the caller.
-        kwargs = with_thinking_compat(kwargs["model"], kwargs, params)
-        anthropic_stream = self.async_client.messages.stream(**kwargs)
+        anthropic_stream = _LearningStreamManager(self.async_client, kwargs, params)
         include_thoughts = _utils.get_include_thoughts(params)
         chunk_iterator = _utils.decode_async_stream(
             anthropic_stream, include_thoughts=include_thoughts
@@ -433,16 +549,23 @@ class BedrockAnthropicProvider(AnthropicProvider):
         **params: Unpack[Params],
     ) -> Response | Response[FormattableT]:
         """Always use standard path — bedrock doesn't support beta structured outputs."""
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=toolkit,
-            format=format,
-            params=params,
+        input_messages, resolved_format, kwargs = self._encode(
+            model_id, messages, toolkit, format, params
         )
-        kwargs["model"] = _bedrock_model_name(model_id)
-        _fix_cache_breakpoints(kwargs)
-        anthropic_response = cast(AnthropicMessage, self._create_sync(kwargs, params))
+        try:
+            anthropic_response = cast(
+                AnthropicMessage, self._create_sync(kwargs, params)
+            )
+        except Exception as e:
+            if not learn_format_mode_from_error(kwargs["model"], format, e):
+                raise
+            input_messages, resolved_format, kwargs = self._encode(
+                model_id, messages, toolkit, format, params
+            )
+            anthropic_response = cast(
+                AnthropicMessage, self._create_sync(kwargs, params)
+            )
+        raise_on_refusal(anthropic_response, kwargs["model"])
         include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
             anthropic_response, model_id, include_thoughts=include_thoughts