sycommon-python-lib 0.2.10a18__tar.gz → 0.2.10a19__tar.gz

{sycommon_python_lib-0.2.10a18 → sycommon_python_lib-0.2.10a19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.10a18
+Version: 0.2.10a19
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.10a18 → sycommon_python_lib-0.2.10a19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.10a18"
+version = "0.2.10a19"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.10a18 → sycommon_python_lib-0.2.10a19}/src/sycommon/pi/coding/mcpserver.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import json
 import os
+import tempfile
 from dataclasses import dataclass, field
 from typing import Any, Callable, Optional
 
@@ -98,6 +99,60 @@ def _to_pi_content(block: Any) -> ContentPart:
     return block
 
 
+MCP_OUTPUT_MAX_BYTES = 20 * 1024
+
+
+def _truncate_middle(s: str, max_bytes: int) -> str:
+    """Keep the start and end of s (half the cap each) with a
+    "…N chars truncated…" marker between, cutting only at character
+    boundaries (truncateMiddle, truncate.ts / the Go twin)."""
+    if len(s) <= max_bytes:
+        return s
+    head_end = max_bytes // 2
+    tail_start = len(s) - (max_bytes - max_bytes // 2)
+    head, tail = s[:head_end], s[tail_start:]
+    removed = len(s[head_end:tail_start])
+    return f"{head}…{removed} chars truncated…{tail}"
+
+
+def _save_full_output(text: str) -> tuple[str, str]:
+    """Write the untruncated text to a temp file (saveToTempFile) and
+    return (path, footer); on failure the footer says so instead."""
+    try:
+        with tempfile.NamedTemporaryFile(
+            prefix="mcp-output-", suffix=".txt", delete=False, mode="w", encoding="utf-8"
+        ) as f:
+            f.write(text)
+            path = f.name
+        return path, f"[Full output: {path} (read it with offset/limit)]"
+    except OSError as exc:
+        return "", f"[Could not save the full output: {exc}]"
+
+
+def limit_mcp_content(content: list[ContentPart]) -> tuple[list[ContentPart], str]:
+    """Keep model-facing text within MCP_OUTPUT_MAX_BYTES (limitMcpContent,
+    tools.ts / the Go twin): when the combined text overruns the cap, ALL
+    text blocks collapse into ONE middle-truncated block and images
+    follow untouched."""
+    combined = "\n".join(
+        b.text for b in content if isinstance(b, TextContent)
+    )
+    if len(combined) <= MCP_OUTPUT_MAX_BYTES:
+        return content, ""
+    images = [b for b in content if isinstance(b, ImageContent)]
+    truncated = _truncate_middle(combined, MCP_OUTPUT_MAX_BYTES)
+    full_output_path, where = _save_full_output(combined)
+    tokens = (len(combined) + 3) // 4
+    lines = combined.count("\n")
+    if not combined.endswith("\n"):
+        lines += 1  # splitLinesForCounting pops one trailing newline
+    text = (
+        f"Warning: truncated output (original token count: {tokens})\n"
+        f"Total output lines: {lines}\n\n{truncated}\n\n{where}"
+    )
+    return [TextContent(text=text), *images], full_output_path
+
+
 def _normalize_schema(schema) -> dict[str, Any]:
     """Schemas missing type/properties (but with other keys, e.g. a
     lone description) get them added — providers reject object schemas
@@ -213,6 +268,12 @@ class Registry:
             parts: list[ContentPart] = [
                 _to_pi_content(block) for block in to_llm_content(result)
             ]
+            # limitMcpContent caps the model-facing text (20KiB) with a
+            # middle truncation + temp-file pointer; images survive.
+            parts, full_output_path = limit_mcp_content(parts)
+            details: dict[str, Any] = {"mcpServer": server, "isError": result.is_error}
+            if full_output_path:
+                details["fullOutputPath"] = full_output_path
             if result.is_error and not content_text(parts):
                 # The model must see WHY the tool failed
                 # (convertMcpResult appends the fallback when isError
@@ -225,7 +286,7 @@ class Registry:
             return (
                 AgentToolResult(
                     content=parts,
-                    details={"mcpServer": server, "isError": result.is_error},
+                    details=details,
                     structured_content=result.structured_content,
                     is_error=result.is_error,
                 ),

sycommon_python_lib-0.2.10a19/src/sycommon/pi/core/usage.py

@@ -0,0 +1,264 @@
+"""Usage and cost accounting: ports pi-ai usage.ts / models.ts
+calculateCost, mirroring the Go port (piai/usage.go)."""
+
+from __future__ import annotations
+
+import json
+import math
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:  # runtime imports stay lazy: message.py imports usage.py
+    from sycommon.pi.core.message import (
+        AssistantMessage,
+        ImageContent,
+        SystemMessage,
+        TextContent,
+        ThinkingContent,
+        ToolCall,
+        ToolResultMessage,
+        UserMessage,
+        get_system_message_text,
+    )
+
+
+@dataclass
+class Cost:
+    """The USD cost breakdown of a Usage."""
+
+    input: float = 0.0
+    output: float = 0.0
+    cache_read: float = 0.0
+    cache_write: float = 0.0
+    total: float = 0.0
+
+
+@dataclass
+class Usage:
+    """Token accounting for one assistant response, with the cache split
+    pi tracks (types.ts Usage)."""
+
+    input: int = 0
+    output: int = 0
+    cache_read: int = 0
+    cache_write: int = 0
+    cache_write_1h: Optional[int] = None  # subset of cache_write; Anthropic only
+    reasoning: Optional[int] = None  # subset of output; None = not reported
+    total_tokens: int = 0
+    cost: Cost = field(default_factory=Cost)
+
+
+@dataclass
+class ModelCostRates:
+    """Per-million-token rates for one pricing tier."""
+
+    input: float = 0.0
+    output: float = 0.0
+    cache_read: float = 0.0
+    cache_write: float = 0.0
+
+
+@dataclass
+class ModelCostTier:
+    """A request-wide pricing tier: rates apply above a token threshold."""
+
+    input_tokens_above: float = 0.0
+    rates: ModelCostRates = field(default_factory=ModelCostRates)
+
+
+@dataclass
+class ModelCost:
+    """Cost schedule for one model (base rates plus tiers)."""
+
+    input: float = 0.0
+    output: float = 0.0
+    cache_read: float = 0.0
+    cache_write: float = 0.0
+    tiers: list[ModelCostTier] = field(default_factory=list)
+
+    @property
+    def model_cost_rates(self) -> ModelCostRates:
+        return ModelCostRates(self.input, self.output, self.cache_read, self.cache_write)
+
+
+def calculate_cost(model, usage: Usage) -> Cost:
+    """Fill usage.cost from the model's catalog rates (models.ts
+    calculateCost). Request-wide pricing tiers pick the highest matching
+    input threshold; 1h cache writes bill at 2x base input."""
+    input_tokens = usage.input + usage.cache_read + usage.cache_write
+    rates = model.cost.model_cost_rates
+    matched_threshold = -1.0
+    for tier in model.cost.tiers:
+        if input_tokens > tier.input_tokens_above and tier.input_tokens_above > matched_threshold:
+            rates = tier.rates
+            matched_threshold = tier.input_tokens_above
+
+    long_write = usage.cache_write_1h or 0
+    short_write = usage.cache_write - long_write
+
+    usage.cost.input = rates.input / 1_000_000 * usage.input
+    usage.cost.output = rates.output / 1_000_000 * usage.output
+    usage.cost.cache_read = rates.cache_read / 1_000_000 * usage.cache_read
+    usage.cost.cache_write = (
+        rates.cache_write * short_write + rates.input * 2 * long_write
+    ) / 1_000_000
+    usage.cost.total = (
+        usage.cost.input + usage.cost.output + usage.cost.cache_read + usage.cost.cache_write
+    )
+    return usage.cost
+
+
+def empty_usage() -> Usage:
+    """The zero-cost usage faux and error paths start from."""
+    return Usage()
+
+
+def calculate_context_tokens(u: Usage) -> int:
+    """The context size a usage block describes (utils/estimate.ts)."""
+    if u.total_tokens != 0:
+        return u.total_tokens
+    return u.input + u.output + u.cache_read + u.cache_write
+
+
+# --- context token estimation (utils/estimate.ts, twins piai/estimate.go) ---
+
+_CHARS_PER_TOKEN = 3.5
+_ESTIMATED_IMAGE_CHARS = 4800
+
+
+def _utf16_len(text: str) -> int:
+    """JS .length counts UTF-16 code units; astral chars count 2."""
+    return sum(2 if ord(ch) > 0xFFFF else 1 for ch in text)
+
+
+def estimate_text_tokens(text: str) -> int:
+    """Estimate tokens for a plain string (chars ÷ 3.5, rounded up)."""
+    return math.ceil(_utf16_len(text) / _CHARS_PER_TOKEN)
+
+
+def _estimate_text_image_tokens(parts: list) -> int:
+    from sycommon.pi.core.message import ImageContent, TextContent
+
+    chars = 0
+    for p in parts:
+        if isinstance(p, ImageContent):
+            chars += _ESTIMATED_IMAGE_CHARS
+        elif isinstance(p, TextContent):
+            chars += _utf16_len(p.text)
+    return math.ceil(chars / _CHARS_PER_TOKEN)
+
+
+def estimate_message_tokens(message) -> int:
+    """Estimate tokens for one message (estimate.ts by role)."""
+    from sycommon.pi.core.message import (
+        AssistantMessage,
+        SystemMessage,
+        TextContent,
+        ThinkingContent,
+        ToolCall,
+        ToolResultMessage,
+        UserMessage,
+        get_system_message_text,
+    )
+
+    if isinstance(message, SystemMessage):
+        return estimate_text_tokens(get_system_message_text(message)) + _estimate_tools_tokens(
+            message.tools_added
+        ) + _estimate_tools_tokens(message.tools_removed)
+    if isinstance(message, (UserMessage, ToolResultMessage)):
+        return _estimate_text_image_tokens(message.content)
+    if isinstance(message, AssistantMessage):
+        chars = 0
+        for block in message.content:
+            if isinstance(block, TextContent):
+                chars += _utf16_len(block.text)
+            elif isinstance(block, ThinkingContent):
+                chars += _utf16_len(block.thinking)
+            elif isinstance(block, ToolCall):
+                chars += _utf16_len(block.name) + _utf16_len(_safe_json(block.arguments))
+        return math.ceil(chars / _CHARS_PER_TOKEN)
+    # Custom roles: serialize as JSON and estimate.
+    return estimate_text_tokens(_safe_json(message))
+
+
+def _estimate_tools_tokens(tools: list) -> int:
+    if not tools:
+        return 0
+    s = _safe_json(tools)
+    if not s:
+        return 0
+    return estimate_text_tokens(s)
+
+
+def _jsonable(value):
+    """Tool/ToolReference render like TS JSON.stringify (name/
+    description/parameters[/constrainedSampling] — never the dataclass
+    repr); lists walk element-wise."""
+    name = getattr(value, "name", None)
+    if isinstance(name, str) and hasattr(value, "parameters"):
+        out = {"name": value.name, "description": getattr(value, "description", ""), "parameters": getattr(value, "parameters", {})}
+        cs = getattr(value, "constrained_sampling", None)
+        if cs is not None:
+            # ConstrainedSamplingConfig wire form (types.ts:744-752):
+            # type + strict / variants — never the dataclass repr.
+            cs_out: dict = {"type": getattr(cs, "type", "")}
+            strict = getattr(cs, "strict", "")
+            if strict:
+                cs_out["strict"] = strict
+            variants = getattr(cs, "variants", None)
+            if variants:
+                cs_out["variants"] = variants
+            out["constrainedSampling"] = cs_out
+        return out
+    if isinstance(name, str) and not hasattr(value, "parameters") and value.__class__.__name__ == "ToolReference":
+        return {"name": value.name}
+    if isinstance(value, list):
+        return [_jsonable(v) for v in value]
+    if isinstance(value, dict):
+        return {k: _jsonable(v) for k, v in value.items()}
+    return value
+
+
+def _safe_json(value) -> str:
+    try:
+        return json.dumps(_jsonable(value), separators=(",", ":"), default=str)
+    except (TypeError, ValueError):
+        return "[unserializable]"
+
+
+def estimate_context_tokens(messages: list) -> int:
+    """Estimate total context tokens: the most recent applicable
+    assistant usage block plus an estimate of everything after it, or a
+    full estimate when no usage applies (estimate.ts)."""
+    from sycommon.pi.core.message import AssistantMessage, StopReason
+
+    latest_prefix_ts = -(2**63)
+    usage: Optional[Usage] = None
+    idx = -1
+    for i, m in enumerate(messages):
+        if isinstance(m, AssistantMessage):
+            applies = m.timestamp_ms >= latest_prefix_ts
+            if (
+                applies
+                and m.stop_reason not in (StopReason.ABORTED, StopReason.ERROR)
+                and calculate_context_tokens(m.usage) > 0
+            ):
+                usage, idx = m.usage, i
+        ts = m.timestamp()
+        if ts > latest_prefix_ts:
+            latest_prefix_ts = ts
+    if idx >= 0 and usage is not None:
+        usage_tokens = calculate_context_tokens(usage)
+        trailing = sum(estimate_message_tokens(messages[i]) for i in range(idx + 1, len(messages)))
+        return usage_tokens + trailing
+    return sum(estimate_message_tokens(m) for m in messages)
+
+
+def clamp_max_tokens_to_context(model, messages: list, max_tokens: int) -> int:
+    """simple-options.ts clampMaxTokensToContext: keep the output cap
+    inside the context window minus the estimated context and a 4096
+    safety margin (floor 1). A non-positive window disables the clamp."""
+    if getattr(model, "context_window", 0) <= 0:
+        return max(max_tokens, 1)
+    available = model.context_window - estimate_context_tokens(messages) - 4096
+    return min(max_tokens, max(available, 1))

{sycommon_python_lib-0.2.10a18 → sycommon_python_lib-0.2.10a19}/src/sycommon/pi/mcp/transport.py

@@ -425,7 +425,10 @@ class HTTPTransport:
         # so trailing server messages after the answer are delivered.
         answered = False
         try:
-            for chunk in resp.iter_content(chunk_size=512):
+            # chunk_size=1: http.client read(n) blocks until n bytes
+            # arrive, so any larger quantum would hold a complete short
+            # SSE event hostage until the next one starts arriving.
+            for chunk in resp.iter_content(chunk_size=1):
                 if not chunk:
                     continue
                 if self._drain_event(parser.feed(chunk), related_to):
@@ -493,7 +496,9 @@ class HTTPTransport:
             self._live.add(resp)
         parser = _SseParser()
         try:
-            for chunk in resp.iter_content(chunk_size=512):
+            # chunk_size=1 (see the POST scan above): a byte at a time
+            # keeps held-open server streams deliverable.
+            for chunk in resp.iter_content(chunk_size=1):
                 if not chunk or self._closed.is_set():
                     return
                 for event in parser.feed(chunk):

{sycommon_python_lib-0.2.10a18 → sycommon_python_lib-0.2.10a19}/src/sycommon/pi/providers/anthropic_client.py

@@ -204,6 +204,15 @@ class AnthropicClient:
             cache = {"type": "ephemeral", **({"ttl": "1h"} if retention == "long" else {})}
 
         max_tokens = (options.max_tokens if options and options.max_tokens else model.max_tokens) or 4096
+        # clampMaxTokensToContext (simple-options.ts, via buildBaseOptions):
+        # keep max_tokens inside the context window minus the estimated
+        # context and a 4096 safety margin, so long sessions clamp
+        # instead of 400ing. The estimate uses the FULL context (system
+        # head included — upstream reads context.messages before the
+        # head is split off).
+        from sycommon.pi.core.usage import clamp_max_tokens_to_context
+
+        max_tokens = clamp_max_tokens_to_context(model, messages, max_tokens)
         converted = _convert_messages(model, transformed)
         # Cache the conversation history: cache_control lands on the LAST
         # user message's last block (anthropic-messages.ts).
@@ -242,7 +251,7 @@ class AnthropicClient:
         # streamSimple's first branch: adaptive models never take the
         # budget ladder — XOR, never both (forceAdaptiveThinking pick).
         if model.reasoning and model.force_adaptive_thinking and wants_thinking:
-            effort = _effort_of(options.reasoning) if options else ""
+            effort = _effort_of(model, options.reasoning) if options else ""
             params["thinking"] = {"type": "adaptive", "display": "summarized"}
             if effort:
                 params["output_config"] = {"effort": effort}
@@ -260,10 +269,17 @@ class AnthropicClient:
             elif self.opts.thinking_budget_tokens:
                 budget = self.opts.thinking_budget_tokens
             # adjustMaxTokensForThinking: an explicit caller cap widens
-            # to fit the budget under the model ceiling; the budget
-            # always leaves MIN_ANSWER_TOKENS (1024) of room.
+            # to fit the budget under the model ceiling; the widened
+            # value then goes through a SECOND context clamp
+            # (anthropic-messages.ts:1003-1012: maxTokens =
+            # clampMaxTokensToContext(adjusted.maxTokens)) — a cap that
+            # widens past the context-derived ceiling must come back
+            # down, and the budget rides the clamped room.
             if options and options.max_tokens:
                 max_tokens = min(max_tokens + budget, model.max_tokens or max_tokens)
+            from sycommon.pi.core.usage import clamp_max_tokens_to_context
+
+            max_tokens = clamp_max_tokens_to_context(model, messages, max_tokens)
             budget = min(budget, max(0, max_tokens - 1024))
             params["max_tokens"] = max_tokens
             params["thinking"] = {"type": "enabled", "budget_tokens": budget, "display": "summarized"}
@@ -280,10 +296,14 @@ class AnthropicClient:
             # its default thinking level.
             params["thinking"] = {"type": "disabled"}
 
-        # getBetaFeatures' configured-header path: an anthropic-beta
-        # header on the model or options force-sets the request's betas
-        # (comma-split, deduped). This port has no OAuth/claude-code
-        # betas and no adaptive-thinking metadata, so no computed betas.
+        # getBetaFeatures: the configured anthropic-beta header is
+        # authoritative when present (configuredFeatures short-circuits
+        # before any computed feature); with NO header, budget thinking
+        # on a reasoning model rides the interleaved-thinking beta
+        # (interleavedThinking defaults true; adaptive-thinking models
+        # are excluded — they never take the budget ladder). This port
+        # has no OAuth/fine-grained-tool-streaming/server-fallback
+        # betas, so the computed path is exactly this one feature.
         configured = None
         for hdrs in (model.headers, options.headers if options else {}):
             for name, value in (hdrs or {}).items():
@@ -297,10 +317,18 @@ class AnthropicClient:
                     features.append(feature)
             if features:
                 params["betas"] = features
+        elif "thinking" in params and params["thinking"].get("type") == "enabled":
+            params["betas"] = ["interleaved-thinking-2025-05-14"]
 
         if options:
-            # temperature is incompatible with thinking; send only when off
-            if options.temperature is not None and "thinking" not in params:
+            # Temperature is incompatible with thinking and keyed on the
+            # thinking OPTION (anthropic-messages.ts:1256:
+            # !options?.thinkingEnabled): streamSimple sets it true for
+            # any truthy reasoning on ANY model — a non-reasoning model
+            # with reasoning requested suppresses temperature even
+            # though no thinking block is emitted. The client flag
+            # (explicit construction) suppresses too.
+            if options.temperature is not None and not wants_thinking:
                 params["temperature"] = options.temperature
             # tool_choice is sent UNCONDITIONALLY when set
             # (anthropic-messages.ts:1318-1324 has no tools gate).
@@ -336,8 +364,15 @@ def _retry_delay(
     return _openai_retry_delay(resp, retry_index, max_delay_ms=max_delay_ms)
 
 
-def _effort_of(level: str) -> str:
-    return {"low": "low", "minimal": "low", "medium": "medium", "high": "high", "xhigh": "high", "max": "max"}.get(level, "")
+def _effort_of(model: Model, level: str) -> str:
+    """mapThinkingLevelToEffort: the model's thinkingLevelMap entry wins
+    when mapped to a string; otherwise the ladder — and the switch
+    DEFAULT is high (max/xhigh both map to high, never ride raw)."""
+    if level:
+        mapped = (model.thinking_level_map or {}).get(level)
+        if isinstance(mapped, str) and mapped:
+            return mapped
+    return {"low": "low", "minimal": "low", "medium": "medium", "high": "high", "xhigh": "high", "max": "high"}.get(level, "high")
 
 
 def _render_system_update(m: SystemMessage) -> str:
@@ -585,7 +620,10 @@ def _consume_anthropic_sse(stream: AssistantMessageEventStream, model: Model, re
 
     parser = _SseParser()
     try:
-        for chunk in resp.iter_content(chunk_size=512):
+        # chunk_size=1: http.client read(n) blocks until n bytes arrive,
+        # so any larger quantum would hold a complete short SSE event
+        # hostage until the next one starts arriving.
+        for chunk in resp.iter_content(chunk_size=1):
             if not chunk:
                 continue
             for parsed in parser.feed(chunk):

{sycommon_python_lib-0.2.10a18 → sycommon_python_lib-0.2.10a19}/src/sycommon/pi/providers/bedrock_client.py

@@ -243,19 +243,27 @@ class BedrockClient:
             else:
                 tool_config["toolChoice"] = {"auto": {}}
             params["toolConfig"] = tool_config
-        # inferenceConfig: maxTokens only when an explicit cap exists
-        # (option or — for Claude — the model catalog); temperature when set.
+        # inferenceConfig: buildBaseOptions ALWAYS sets a clamped
+        # maxTokens (simple-options.ts:46), and upstream bedrock emits
+        # it for every model on the streamSimple path
+        # (inferenceMaxTokens = options.maxTokens ?? (isClaude ?
+        # model.maxTokens : undefined) — never undefined here because
+        # the base options already carry options?.maxTokens ??
+        # model.maxTokens); temperature when set.
         inference: dict[str, Any] = {}
-        max_tokens = options.max_tokens if options and options.max_tokens else 0
-        if not max_tokens and _is_claude(model) and model.max_tokens:
-            max_tokens = model.max_tokens
+        from sycommon.pi.core.usage import clamp_max_tokens_to_context
+
+        base_cap = options.max_tokens if options and options.max_tokens else 0
+        if not base_cap:
+            base_cap = model.max_tokens
+        max_tokens = clamp_max_tokens_to_context(model, messages, base_cap) if base_cap else 0
         if max_tokens:
             inference["maxTokens"] = max_tokens
         if options and options.temperature is not None:
             inference["temperature"] = options.temperature
         if inference:
             params["inferenceConfig"] = inference
-        extra = _additional_model_request_fields(model, options, max_tokens)
+        extra = _additional_model_request_fields(model, options, max_tokens, messages)
         if extra:
             params["additionalModelRequestFields"] = extra
             widened = extra.get("_widened_max_tokens")
@@ -331,7 +339,7 @@ _OPENAI_GPT_OSS_EFFORT = {
 
 
 def _additional_model_request_fields(
-    model: Model, options: Optional[StreamOptions], max_tokens: int
+    model: Model, options: Optional[StreamOptions], max_tokens: int, context_messages: list
 ) -> Optional[dict[str, Any]]:
     """Claude thinking rides additionalModelRequestFields (upstream
     buildAdditionalModelRequestFields): adaptive families get
@@ -350,29 +358,44 @@ def _additional_model_request_fields(
                 "output_config": {"effort": _map_thinking_level_to_effort(model, options.reasoning)},
             }
         level = options.reasoning
-        budget = 0
+        budget = None
         if options.thinking_budgets:
             # custom budgets only cover token-based levels through high
             if level in ("xhigh", "max"):
                 level = "high"
-            budget = int(options.thinking_budgets.get(level, 0))
-        if not budget:
+            if level in options.thinking_budgets:
+                # a configured 0 stays 0 (upstream ?? — 0 is not nullish)
+                budget = int(options.thinking_budgets[level])
+        if budget is None:
             budget = _DEFAULT_THINKING_BUDGETS.get(options.reasoning, 0)
-        # adjustMaxTokensForThinking: an EXPLICIT caller cap widens to
-        # fit the budget under the model ceiling (upstream
-        # maxTokens+budget capped at model.max_tokens); the budget always
-        # leaves MIN_ANSWER_TOKENS (1024) of room under the ceiling.
+        # adjustMaxTokensForThinking (simple-options.ts) over the
+        # clamp#1 value, then clamp#2 (bedrock-converse-stream.ts:554-
+        # 566): maxTokens = clampMaxTokensToContext(adjusted.maxTokens)
+        # and the budget rides the POST-clamp#2 room — the widened
+        # number never escapes the context clamp.
+        from sycommon.pi.core.usage import clamp_max_tokens_to_context
+
         widened = 0
         if max_tokens:
             ceiling = model.max_tokens or max_tokens
             widened = min(max_tokens + budget, ceiling)
-            budget = min(budget, max(0, widened - 1024))
+        else:
+            # No explicit cap: maxTokens defaults to model.max_tokens
+            # (a 0-cap model has no ceiling — upstream Case E collapses
+            # the budget to 0).
+            widened = model.max_tokens
+        final = clamp_max_tokens_to_context(model, context_messages, widened) if widened else 0
+        if final <= budget:
+            budget = min(budget, max(0, final - 1024))
         out = {
             "thinking": {"type": "enabled", "budget_tokens": budget, "display": "summarized"},
             "anthropic_beta": ["interleaved-thinking-2025-05-14"],
         }
-        if widened and widened != max_tokens:
-            out["_widened_max_tokens"] = widened
+        # The widened value that actually rewrites inferenceConfig is
+        # the POST-clamp#2 one, whenever it differs from the clamped
+        # cap the caller path already emitted (or a cap was absent).
+        if final and final != max_tokens:
+            out["_widened_max_tokens"] = final
         return out
     cands = _match_candidates(model)
     if any("gpt-oss" in c for c in cands):
@@ -657,7 +680,10 @@ def _consume_bedrock_sse(stream: AssistantMessageEventStream, model: Model, resp
         return [e["data"] for e in parser.feed(chunk)]
 
     try:
-        for chunk in resp.iter_content(chunk_size=512):
+        # chunk_size=1: http.client read(n) blocks until n bytes arrive,
+        # so any larger quantum would hold a complete short SSE event
+        # hostage until the next one starts arriving.
+        for chunk in resp.iter_content(chunk_size=1):
             if not chunk:
                 continue
             for data in _events_of(chunk):