devcopilot 0.2.0__py3-none-any.whl

core/anthropic/emitted_sse_tracker.py

@@ -0,0 +1,346 @@
+"""Track content-block state for native Anthropic SSE strings we emit to clients."""
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import Iterator
+from contextlib import suppress
+from dataclasses import dataclass, field
+from typing import Any
+
+from core.anthropic.sse import SSEBuilder, format_sse_event
+from core.anthropic.stream_contracts import SSEEvent, parse_sse_lines
+from core.anthropic.stream_recovery import (
+    ToolSchema,
+    accept_tool_json_repair,
+    continuation_suffix,
+    parse_complete_tool_input,
+)
+
+
+@dataclass
+class EmittedBlockState:
+    """Tracked downstream block payload emitted to the client."""
+
+    index: int
+    block_type: str
+    open: bool = True
+    tool_id: str = ""
+    name: str = ""
+    parts: list[str] = field(default_factory=list)
+
+    @property
+    def content(self) -> str:
+        return "".join(self.parts)
+
+
+class EmittedNativeSseTracker:
+    """Parse emitted SSE frames so mid-stream errors can close blocks and pick a fresh index."""
+
+    def __init__(self) -> None:
+        self._buf = ""
+        self._open_stack: list[int] = []
+        self._max_index = -1
+        self._blocks: dict[int, EmittedBlockState] = {}
+        self.message_id: str | None = None
+        self.model: str = ""
+        self.stop_reason: str | None = None
+        self.message_stopped = False
+
+    def feed(self, chunk: str) -> None:
+        """Record SSE frames completed by ``chunk`` (handles splitting across reads)."""
+        self._buf += chunk
+        while True:
+            sep = self._buf.find("\n\n")
+            if sep < 0:
+                break
+            frame = self._buf[:sep]
+            self._buf = self._buf[sep + 2 :]
+            if not frame.strip():
+                continue
+            for event in parse_sse_lines(frame.splitlines()):
+                self._observe(event)
+
+    def _observe(self, event: SSEEvent) -> None:
+        if event.event == "message_start":
+            message = event.data.get("message")
+            if isinstance(message, dict):
+                mid = message.get("id")
+                if isinstance(mid, str) and mid:
+                    self.message_id = mid
+                model = message.get("model")
+                if isinstance(model, str) and model:
+                    self.model = model
+            return
+
+        if event.event == "content_block_start":
+            raw_index = event.data.get("index")
+            if not isinstance(raw_index, int):
+                return
+            idx = raw_index
+            self._max_index = max(self._max_index, idx)
+            self._open_stack.append(idx)
+            block = event.data.get("content_block")
+            if isinstance(block, dict):
+                block_type = str(block.get("type", ""))
+                state = EmittedBlockState(index=idx, block_type=block_type)
+                if block_type == "tool_use":
+                    tool_id = block.get("id")
+                    name = block.get("name")
+                    state.tool_id = tool_id if isinstance(tool_id, str) else ""
+                    state.name = name if isinstance(name, str) else ""
+                elif block_type == "text":
+                    text = block.get("text")
+                    if isinstance(text, str) and text:
+                        state.parts.append(text)
+                elif block_type == "thinking":
+                    thinking = block.get("thinking")
+                    if isinstance(thinking, str) and thinking:
+                        state.parts.append(thinking)
+                self._blocks[idx] = state
+            return
+
+        if event.event == "content_block_delta":
+            raw_index = event.data.get("index")
+            if not isinstance(raw_index, int):
+                return
+            idx = raw_index
+            state = self._blocks.get(idx)
+            delta = event.data.get("delta")
+            if state is not None and isinstance(delta, dict):
+                if state.block_type == "text":
+                    text = delta.get("text")
+                    if isinstance(text, str):
+                        state.parts.append(text)
+                elif state.block_type == "thinking":
+                    thinking = delta.get("thinking")
+                    if isinstance(thinking, str):
+                        state.parts.append(thinking)
+                elif state.block_type == "tool_use":
+                    partial = delta.get("partial_json")
+                    if isinstance(partial, str):
+                        state.parts.append(partial)
+            return
+
+        if event.event == "content_block_stop":
+            raw_index = event.data.get("index")
+            if not isinstance(raw_index, int):
+                return
+            idx = raw_index
+            if self._open_stack and self._open_stack[-1] == idx:
+                self._open_stack.pop()
+            else:
+                with suppress(ValueError):
+                    self._open_stack.remove(idx)
+            state = self._blocks.get(idx)
+            if state is not None:
+                state.open = False
+            return
+
+        if event.event == "message_delta":
+            delta = event.data.get("delta")
+            if isinstance(delta, dict):
+                stop_reason = delta.get("stop_reason")
+                if isinstance(stop_reason, str):
+                    self.stop_reason = stop_reason
+            return
+
+        if event.event == "message_stop":
+            self.message_stopped = True
+
+    def next_content_index(self) -> int:
+        """Next unused content block index based on emitted starts."""
+        return self._max_index + 1
+
+    def iter_close_unclosed_blocks(self) -> Iterator[str]:
+        """Yield ``content_block_stop`` events for blocks that were started but not stopped."""
+        while self._open_stack:
+            idx = self._open_stack.pop()
+            state = self._blocks.get(idx)
+            if state is not None:
+                state.open = False
+            yield format_sse_event(
+                "content_block_stop",
+                {"type": "content_block_stop", "index": idx},
+            )
+
+    def emitted_text(self) -> str:
+        return "".join(
+            block.content
+            for block in self._blocks.values()
+            if block.block_type == "text"
+        )
+
+    def emitted_thinking(self) -> str:
+        return "".join(
+            block.content
+            for block in self._blocks.values()
+            if block.block_type == "thinking"
+        )
+
+    def has_tool_block(self) -> bool:
+        return any(block.block_type == "tool_use" for block in self._blocks.values())
+
+    def has_content_block(self) -> bool:
+        return bool(self._blocks)
+
+    def has_terminal_message(self) -> bool:
+        return self.message_stopped
+
+    def tool_blocks(self) -> list[EmittedBlockState]:
+        return [
+            block for block in self._blocks.values() if block.block_type == "tool_use"
+        ]
+
+    def can_salvage_tool_use(self, schemas: dict[str, ToolSchema]) -> bool:
+        tool_blocks = self.tool_blocks()
+        if not tool_blocks:
+            return False
+        for block in tool_blocks:
+            if not block.tool_id or not block.name:
+                return False
+            if parse_complete_tool_input(block.content, block.name, schemas) is None:
+                return False
+        return True
+
+    def append_text_suffix(self, suffix: str) -> Iterator[str]:
+        if not suffix:
+            return
+        active = self._last_open_block("text")
+        if active is None:
+            index = self.next_content_index()
+            self._max_index = max(self._max_index, index)
+            active = EmittedBlockState(index=index, block_type="text")
+            self._blocks[index] = active
+            self._open_stack.append(index)
+            yield format_sse_event(
+                "content_block_start",
+                {
+                    "type": "content_block_start",
+                    "index": index,
+                    "content_block": {"type": "text", "text": ""},
+                },
+            )
+        active.parts.append(suffix)
+        yield format_sse_event(
+            "content_block_delta",
+            {
+                "type": "content_block_delta",
+                "index": active.index,
+                "delta": {"type": "text_delta", "text": suffix},
+            },
+        )
+
+    def append_thinking_suffix(self, suffix: str) -> Iterator[str]:
+        if not suffix:
+            return
+        active = self._last_open_block("thinking")
+        if active is None:
+            index = self.next_content_index()
+            self._max_index = max(self._max_index, index)
+            active = EmittedBlockState(index=index, block_type="thinking")
+            self._blocks[index] = active
+            self._open_stack.append(index)
+            yield format_sse_event(
+                "content_block_start",
+                {
+                    "type": "content_block_start",
+                    "index": index,
+                    "content_block": {"type": "thinking", "thinking": ""},
+                },
+            )
+        active.parts.append(suffix)
+        yield format_sse_event(
+            "content_block_delta",
+            {
+                "type": "content_block_delta",
+                "index": active.index,
+                "delta": {"type": "thinking_delta", "thinking": suffix},
+            },
+        )
+
+    def append_tool_repair_suffix(
+        self,
+        tool_index: int,
+        suffix: str,
+    ) -> Iterator[str]:
+        tool_blocks = self.tool_blocks()
+        if tool_index >= len(tool_blocks) or not suffix:
+            return
+        block = tool_blocks[tool_index]
+        block.parts.append(suffix)
+        yield format_sse_event(
+            "content_block_delta",
+            {
+                "type": "content_block_delta",
+                "index": block.index,
+                "delta": {"type": "input_json_delta", "partial_json": suffix},
+            },
+        )
+
+    def iter_success_tail(self, stop_reason: str) -> Iterator[str]:
+        yield from self.iter_close_unclosed_blocks()
+        if self.stop_reason is None:
+            yield format_sse_event(
+                "message_delta",
+                {
+                    "type": "message_delta",
+                    "delta": {"stop_reason": stop_reason, "stop_sequence": None},
+                    "usage": {"input_tokens": 0, "output_tokens": 1},
+                },
+            )
+        if not self.message_stopped:
+            yield format_sse_event("message_stop", {"type": "message_stop"})
+
+    def accept_tool_repair(
+        self,
+        tool_index: int,
+        candidate: str,
+        schemas: dict[str, ToolSchema],
+    ) -> str | None:
+        tool_blocks = self.tool_blocks()
+        if tool_index >= len(tool_blocks):
+            return None
+        block = tool_blocks[tool_index]
+        repair = accept_tool_json_repair(
+            block.content,
+            candidate,
+            tool_name=block.name,
+            schemas=schemas,
+        )
+        return repair.suffix if repair is not None else None
+
+    def continuation_text_suffix(self, candidate: str) -> str | None:
+        return continuation_suffix(self.emitted_text(), candidate)
+
+    def continuation_thinking_suffix(self, candidate: str) -> str | None:
+        return continuation_suffix(self.emitted_thinking(), candidate)
+
+    def iter_midstream_error_tail(
+        self,
+        error_message: str,
+        *,
+        request: Any,
+        input_tokens: int,
+        log_raw_sse_events: bool,
+    ) -> Iterator[str]:
+        """Close dangling blocks, emit a text error block at a fresh index, then message tail."""
+        mid = self.message_id or f"msg_{uuid.uuid4()}"
+        model = self.model or (getattr(request, "model", "") or "")
+        sse = SSEBuilder(
+            mid,
+            model,
+            input_tokens,
+            log_raw_events=log_raw_sse_events,
+        )
+        sse.blocks.next_index = self.next_content_index()
+        yield from sse.emit_error(error_message)
+        yield sse.message_delta("end_turn", 1)
+        yield sse.message_stop()
+
+    def _last_open_block(self, block_type: str) -> EmittedBlockState | None:
+        for index in reversed(self._open_stack):
+            block = self._blocks.get(index)
+            if block is not None and block.block_type == block_type and block.open:
+                return block
+        return None

core/anthropic/errors.py

@@ -0,0 +1,70 @@
+"""User-facing error formatting shared by API, providers, and integrations."""
+
+import httpx
+import openai
+
+
+def get_user_facing_error_message(
+    e: Exception,
+    *,
+    read_timeout_s: float | None = None,
+) -> str:
+    """Return a readable, non-empty error message for users.
+
+    Known transport and OpenAI SDK exception types are mapped to stable wording
+    before falling back to ``str(e)``, so empty or noisy SDK messages do not skip
+    the mapped path.
+    """
+    if isinstance(e, httpx.ReadTimeout):
+        if read_timeout_s is not None:
+            return f"Provider request timed out after {read_timeout_s:g}s."
+        return "Provider request timed out."
+    if isinstance(e, httpx.ConnectTimeout):
+        return "Could not connect to provider."
+    if isinstance(e, TimeoutError):
+        if read_timeout_s is not None:
+            return f"Provider request timed out after {read_timeout_s:g}s."
+        return "Request timed out."
+
+    if isinstance(e, openai.RateLimitError):
+        return "Provider rate limit reached. Please retry shortly."
+    if isinstance(e, openai.AuthenticationError):
+        return "Provider authentication failed. Check API key."
+    if isinstance(e, openai.BadRequestError):
+        return "Invalid request sent to provider."
+
+    name = type(e).__name__
+    status_code = getattr(e, "status_code", None)
+    if name == "RateLimitError":
+        return "Provider rate limit reached. Please retry shortly."
+    if name == "AuthenticationError":
+        return "Provider authentication failed. Check API key."
+    if name == "InvalidRequestError":
+        return "Invalid request sent to provider."
+    if name == "OverloadedError":
+        return "Provider is currently overloaded. Please retry."
+    if name == "APIError":
+        if status_code in (502, 503, 504):
+            return "Provider is temporarily unavailable. Please retry."
+        return "Provider API request failed."
+    if name.endswith("ProviderError") or name == "ProviderError":
+        return "Provider request failed."
+
+    message = str(e).strip()
+    if message:
+        return message
+
+    return "Provider request failed unexpectedly."
+
+
+def format_user_error_preview(exc: Exception, *, max_len: int = 200) -> str:
+    """Truncate a user-facing error string for short chat replies."""
+    return get_user_facing_error_message(exc)[:max_len]
+
+
+def append_request_id(message: str, request_id: str | None) -> str:
+    """Append request_id suffix when available."""
+    base = message.strip() or "Provider request failed unexpectedly."
+    if request_id:
+        return f"{base} (request_id={request_id})"
+    return base

core/anthropic/native_messages_request.py

@@ -0,0 +1,280 @@
+"""Native Anthropic Messages request body construction (JSON-ready dicts).
+
+Provider adapters supply policy via parameters (defaults, OpenRouter post-steps).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from pydantic import BaseModel
+
+_REQUEST_FIELDS = (
+    "model",
+    "messages",
+    "system",
+    "max_tokens",
+    "stop_sequences",
+    "stream",
+    "temperature",
+    "top_p",
+    "top_k",
+    "metadata",
+    "tools",
+    "tool_choice",
+    "thinking",
+    "context_management",
+    "output_config",
+    "mcp_servers",
+    "extra_body",
+)
+
+# Keys that would override routed canonical request fields if merged from ``extra_body``.
+_OPENROUTER_EXTRA_BODY_FORBIDDEN_KEYS = frozenset(
+    {
+        "model",
+        "messages",
+        "system",
+        "tools",
+        "tool_choice",
+        "stream",
+        "max_tokens",
+        "temperature",
+        "top_p",
+        "top_k",
+        "metadata",
+        "stop_sequences",
+        "context_management",
+        "output_config",
+        "mcp_servers",
+    }
+)
+
+
+class OpenRouterExtraBodyError(ValueError):
+    """``extra_body`` contained reserved keys that would override canonical fields."""
+
+
+def validate_openrouter_extra_body(extra: Any) -> None:
+    """Reject ``extra_body`` keys that must not override routed request fields."""
+    if not isinstance(extra, dict) or not extra:
+        return
+    bad = _OPENROUTER_EXTRA_BODY_FORBIDDEN_KEYS & extra.keys()
+    if bad:
+        raise OpenRouterExtraBodyError(
+            f"extra_body must not override canonical request fields: {sorted(bad)}"
+        )
+
+
+_INTERNAL_FIELDS = {
+    "thinking",
+    "extra_body",
+}
+
+
+def _serialize_value(value: Any) -> Any:
+    """Convert Pydantic models and lightweight objects into JSON-ready values."""
+    if isinstance(value, BaseModel):
+        return value.model_dump(exclude_none=True)
+    if isinstance(value, dict):
+        return {
+            key: _serialize_value(item)
+            for key, item in value.items()
+            if item is not None
+        }
+    if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):
+        return [_serialize_value(item) for item in value]
+    if value is None or isinstance(value, str | int | float | bool):
+        return value
+    if hasattr(value, "__dict__"):
+        return {
+            key: _serialize_value(item)
+            for key, item in vars(value).items()
+            if not key.startswith("_") and item is not None
+        }
+    return value
+
+
+def _dump_request_fields(request_data: Any) -> dict[str, Any]:
+    """Extract the public request fields (OpenRouter-style explicit field list)."""
+    if isinstance(request_data, BaseModel):
+        raw = request_data.model_dump(exclude_none=True)
+        return {
+            field: raw[field]
+            for field in _REQUEST_FIELDS
+            if field in raw and raw[field] is not None
+        }
+
+    dump = getattr(request_data, "model_dump", None)
+    if callable(dump):
+        raw = dump(exclude_none=True)
+        if isinstance(raw, dict):
+            return {
+                field: raw[field]
+                for field in _REQUEST_FIELDS
+                if field in raw and raw[field] is not None
+            }
+
+    dumped: dict[str, Any] = {}
+    for field in _REQUEST_FIELDS:
+        value = getattr(request_data, field, None)
+        if value is not None:
+            dumped[field] = _serialize_value(value)
+    return dumped
+
+
+def dump_raw_messages_request(request_data: Any) -> dict[str, Any]:
+    """Public JSON-ready dict of Anthropic public request fields (for native adapters)."""
+    return _dump_request_fields(request_data)
+
+
+def sanitize_native_messages_thinking_policy(
+    messages: Any, *, thinking_enabled: bool
+) -> Any:
+    """Filter assistant message thinking blocks for upstream native Anthropic JSON.
+
+    When ``thinking_enabled`` is false, remove ``thinking`` and ``redacted_thinking``
+    history so disabled policy is not undermined by prior turns.
+
+    When true, keep ``redacted_thinking`` and signed ``thinking``; remove only
+    unsigned plain ``thinking`` blocks (not replayable).
+    """
+    if not isinstance(messages, list):
+        return messages
+
+    sanitized_messages: list[Any] = []
+    for message in messages:
+        if not isinstance(message, dict):
+            sanitized_messages.append(message)
+            continue
+
+        if message.get("role") != "assistant":
+            sanitized_messages.append(message)
+            continue
+
+        content = message.get("content")
+        if not isinstance(content, list):
+            sanitized_messages.append(message)
+            continue
+
+        if not thinking_enabled:
+            sanitized_content = [
+                block
+                for block in content
+                if not (
+                    isinstance(block, dict)
+                    and block.get("type") in ("thinking", "redacted_thinking")
+                )
+            ]
+        else:
+            sanitized_content = [
+                block
+                for block in content
+                if not (
+                    isinstance(block, dict)
+                    and block.get("type") == "thinking"
+                    and not isinstance(block.get("signature"), str)
+                )
+            ]
+
+        sanitized_message = dict(message)
+        sanitized_message["content"] = sanitized_content or ""
+        sanitized_messages.append(sanitized_message)
+
+    return sanitized_messages
+
+
+def _normalize_system_prompt_for_openrouter(system: Any) -> Any:
+    """Flatten Claude SDK system blocks for OpenRouter's native endpoint."""
+    if not isinstance(system, list):
+        return system
+
+    text_parts: list[str] = []
+    for block in system:
+        if not isinstance(block, dict):
+            continue
+        if block.get("type") == "text" and isinstance(block.get("text"), str):
+            text_parts.append(block["text"])
+    return "\n\n".join(text_parts).strip() if text_parts else system
+
+
+def _apply_openrouter_reasoning_policy(body: dict[str, Any], thinking_cfg: Any) -> None:
+    """Map Anthropic thinking controls onto OpenRouter reasoning controls."""
+    reasoning = body.setdefault("reasoning", {"enabled": True})
+    if not isinstance(reasoning, dict):
+        return
+    reasoning.setdefault("enabled", True)
+    if not isinstance(thinking_cfg, dict):
+        return
+    budget_tokens = thinking_cfg.get("budget_tokens")
+    if isinstance(budget_tokens, int):
+        reasoning.setdefault("max_tokens", budget_tokens)
+
+
+def build_base_native_anthropic_request_body(
+    request: Any,
+    *,
+    default_max_tokens: int,
+    thinking_enabled: bool,
+) -> dict[str, Any]:
+    """Serialize a Pydantic messages request to a generic native Anthropic body."""
+    body = dump_raw_messages_request(request)
+
+    body.pop("extra_body", None)
+
+    if "thinking" in body:
+        thinking_cfg = body.pop("thinking")
+        if thinking_enabled and isinstance(thinking_cfg, dict):
+            thinking_payload: dict[str, Any] = {"type": "enabled"}
+            budget_tokens = thinking_cfg.get("budget_tokens")
+            if isinstance(budget_tokens, int):
+                thinking_payload["budget_tokens"] = budget_tokens
+            body["thinking"] = thinking_payload
+
+    if "max_tokens" not in body:
+        body["max_tokens"] = default_max_tokens
+
+    if "messages" in body:
+        body["messages"] = sanitize_native_messages_thinking_policy(
+            body["messages"],
+            thinking_enabled=thinking_enabled,
+        )
+
+    return body
+
+
+def build_openrouter_native_request_body(
+    request_data: Any,
+    *,
+    thinking_enabled: bool,
+    default_max_tokens: int,
+) -> dict[str, Any]:
+    """Build an Anthropic-format request body for OpenRouter (policy hooks built-in)."""
+    dumped_request = _dump_request_fields(request_data)
+    request_extra = dumped_request.pop("extra_body", None)
+    thinking_cfg = dumped_request.get("thinking")
+    body: dict[str, Any] = {
+        key: value
+        for key, value in dumped_request.items()
+        if key not in _INTERNAL_FIELDS
+    }
+
+    if isinstance(request_extra, dict):
+        validate_openrouter_extra_body(request_extra)
+        body.update(request_extra)
+
+    body["messages"] = sanitize_native_messages_thinking_policy(
+        body.get("messages"),
+        thinking_enabled=thinking_enabled,
+    )
+    if "system" in body:
+        body["system"] = _normalize_system_prompt_for_openrouter(body["system"])
+    body["stream"] = True
+    if body.get("max_tokens") is None:
+        body["max_tokens"] = default_max_tokens
+
+    if thinking_enabled:
+        _apply_openrouter_reasoning_policy(body, thinking_cfg)
+
+    return body