devcopilot 0.2.0__py3-none-any.whl

core/anthropic/tokens.py

@@ -0,0 +1,117 @@
+"""Token estimation for Anthropic-compatible requests."""
+
+import json
+
+import tiktoken
+from loguru import logger
+
+from .content import get_block_attr
+
+ENCODER = tiktoken.get_encoding("cl100k_base")
+
+_DISALLOWED_SPECIAL: tuple[str, ...] = ()
+
+
+def _count_text_tokens(text: str) -> int:
+    return len(ENCODER.encode(text, disallowed_special=_DISALLOWED_SPECIAL))
+
+
+def get_token_count(
+    messages: list,
+    system: str | list | None = None,
+    tools: list | None = None,
+) -> int:
+    """Estimate token count for a request."""
+    total_tokens = 0
+
+    if system:
+        if isinstance(system, str):
+            total_tokens += _count_text_tokens(system)
+        elif isinstance(system, list):
+            for block in system:
+                text = get_block_attr(block, "text", "")
+                if text:
+                    total_tokens += _count_text_tokens(str(text))
+        total_tokens += 4
+
+    for msg in messages:
+        if isinstance(msg.content, str):
+            total_tokens += _count_text_tokens(msg.content)
+        elif isinstance(msg.content, list):
+            for block in msg.content:
+                b_type = get_block_attr(block, "type") or None
+
+                if b_type == "text":
+                    text = get_block_attr(block, "text", "")
+                    total_tokens += _count_text_tokens(str(text))
+                elif b_type == "thinking":
+                    thinking = get_block_attr(block, "thinking", "")
+                    total_tokens += _count_text_tokens(str(thinking))
+                elif b_type == "tool_use":
+                    name = get_block_attr(block, "name", "")
+                    inp = get_block_attr(block, "input", {})
+                    block_id = get_block_attr(block, "id", "")
+                    total_tokens += _count_text_tokens(str(name))
+                    total_tokens += _count_text_tokens(json.dumps(inp))
+                    total_tokens += _count_text_tokens(str(block_id))
+                    total_tokens += 15
+                elif b_type == "image":
+                    source = get_block_attr(block, "source")
+                    if isinstance(source, dict):
+                        data = source.get("data") or source.get("base64") or ""
+                        if data:
+                            total_tokens += max(85, len(data) // 3000)
+                        else:
+                            total_tokens += 765
+                    else:
+                        total_tokens += 765
+                elif b_type == "tool_result":
+                    content = get_block_attr(block, "content", "")
+                    tool_use_id = get_block_attr(block, "tool_use_id", "")
+                    if isinstance(content, str):
+                        total_tokens += _count_text_tokens(content)
+                    else:
+                        total_tokens += _count_text_tokens(json.dumps(content))
+                    total_tokens += _count_text_tokens(str(tool_use_id))
+                    total_tokens += 8
+                elif b_type in (
+                    "server_tool_use",
+                    "web_search_tool_result",
+                    "web_fetch_tool_result",
+                ):
+                    if hasattr(block, "model_dump"):
+                        blob: object = block.model_dump()
+                    else:
+                        blob = block
+                    try:
+                        total_tokens += _count_text_tokens(
+                            json.dumps(blob, default=str, ensure_ascii=False)
+                        )
+                    except (TypeError, ValueError, OverflowError) as e:
+                        logger.debug(
+                            "Block encode fallback b_type={} err={}", b_type, e
+                        )
+                        total_tokens += _count_text_tokens(str(blob))
+                    total_tokens += 12
+                else:
+                    logger.debug(
+                        "Unexpected block type %r, falling back to json/str encoding",
+                        b_type,
+                    )
+                    try:
+                        total_tokens += _count_text_tokens(json.dumps(block))
+                    except TypeError, ValueError:
+                        total_tokens += _count_text_tokens(str(block))
+
+    if tools:
+        for tool in tools:
+            tool_str = (
+                tool.name + (tool.description or "") + json.dumps(tool.input_schema)
+            )
+            total_tokens += _count_text_tokens(tool_str)
+
+    total_tokens += len(messages) * 4
+    if tools:
+        total_tokens += len(tools) * 5
+
+    return max(1, total_tokens)

core/anthropic/tools.py

@@ -0,0 +1,212 @@
+"""Heuristic parser for text-emitted tool calls."""
+
+import json
+import re
+import uuid
+from enum import Enum
+from typing import Any
+
+from loguru import logger
+
+_CONTROL_TOKEN_RE = re.compile(r"<\|[^|>]{1,80}\|>")
+_CONTROL_TOKEN_START = "<|"
+_CONTROL_TOKEN_END = "|>"
+
+
+class ParserState(Enum):
+    TEXT = 1
+    MATCHING_FUNCTION = 2
+    PARSING_PARAMETERS = 3
+
+
+class HeuristicToolParser:
+    """
+    Stateful parser for raw text tool calls.
+
+    Some OpenAI-compatible models emit tool calls as text rather than structured
+    chunks. This parser converts the common ``● <function=...>`` form into
+    Anthropic-style ``tool_use`` blocks.
+    """
+
+    _FUNC_START_PATTERN = re.compile(r"●\s*<function=([^>]+)>")
+    _PARAM_PATTERN = re.compile(
+        r"<parameter=([^>]+)>(.*?)(?:</parameter>|$)", re.DOTALL
+    )
+    _WEB_TOOL_JSON_PATTERN = re.compile(
+        r"(?is)\b(?:use\s+)?(?P<tool>WebFetch|WebSearch)\b.*?(?P<json>\{.*?\})"
+    )
+
+    def __init__(self):
+        self._state = ParserState.TEXT
+        self._buffer = ""
+        self._current_tool_id = None
+        self._current_function_name = None
+        self._current_parameters = {}
+
+    def _extract_web_tool_json_calls(self) -> tuple[str, list[dict[str, Any]]]:
+        detected_tools: list[dict[str, Any]] = []
+
+        for match in self._WEB_TOOL_JSON_PATTERN.finditer(self._buffer):
+            try:
+                tool_input = json.loads(match.group("json"))
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(tool_input, dict):
+                continue
+
+            tool_name = match.group("tool")
+            if tool_name == "WebFetch" and "url" not in tool_input:
+                continue
+            if tool_name == "WebSearch" and "query" not in tool_input:
+                continue
+
+            detected_tools.append(
+                {
+                    "type": "tool_use",
+                    "id": f"toolu_heuristic_{uuid.uuid4().hex[:8]}",
+                    "name": tool_name,
+                    "input": tool_input,
+                }
+            )
+            logger.debug(
+                "Heuristic bypass: Detected JSON-style tool call '{}'",
+                tool_name,
+            )
+
+        if not detected_tools:
+            return self._buffer, []
+
+        return "", detected_tools
+
+    def _strip_control_tokens(self, text: str) -> str:
+        return _CONTROL_TOKEN_RE.sub("", text)
+
+    def _split_incomplete_control_token_tail(self) -> str:
+        start = self._buffer.rfind(_CONTROL_TOKEN_START)
+        if start == -1:
+            return ""
+        end = self._buffer.find(_CONTROL_TOKEN_END, start)
+        if end != -1:
+            return ""
+
+        prefix = self._buffer[:start]
+        self._buffer = self._buffer[start:]
+        return prefix
+
+    def feed(self, text: str) -> tuple[str, list[dict[str, Any]]]:
+        """Feed text and return safe text plus detected tool calls."""
+        self._buffer += text
+        self._buffer = self._strip_control_tokens(self._buffer)
+        self._buffer, detected_tools = self._extract_web_tool_json_calls()
+        filtered_output_parts: list[str] = []
+
+        while True:
+            if self._state == ParserState.TEXT:
+                if "●" in self._buffer:
+                    idx = self._buffer.find("●")
+                    filtered_output_parts.append(self._buffer[:idx])
+                    self._buffer = self._buffer[idx:]
+                    self._state = ParserState.MATCHING_FUNCTION
+                else:
+                    safe_prefix = self._split_incomplete_control_token_tail()
+                    if safe_prefix:
+                        filtered_output_parts.append(safe_prefix)
+                        break
+
+                    filtered_output_parts.append(self._buffer)
+                    self._buffer = ""
+                    break
+
+            if self._state == ParserState.MATCHING_FUNCTION:
+                match = self._FUNC_START_PATTERN.search(self._buffer)
+                if match:
+                    self._current_function_name = match.group(1).strip()
+                    self._current_tool_id = f"toolu_heuristic_{uuid.uuid4().hex[:8]}"
+                    self._current_parameters = {}
+                    self._buffer = self._buffer[match.end() :]
+                    self._state = ParserState.PARSING_PARAMETERS
+                    logger.debug(
+                        "Heuristic bypass: Detected start of tool call '{}'",
+                        self._current_function_name,
+                    )
+                elif len(self._buffer) > 100:
+                    filtered_output_parts.append(self._buffer[0])
+                    self._buffer = self._buffer[1:]
+                    self._state = ParserState.TEXT
+                else:
+                    break
+
+            if self._state == ParserState.PARSING_PARAMETERS:
+                finished_tool_call = False
+
+                while True:
+                    param_match = self._PARAM_PATTERN.search(self._buffer)
+                    if param_match and "</parameter>" in param_match.group(0):
+                        pre_match_text = self._buffer[: param_match.start()]
+                        if pre_match_text:
+                            filtered_output_parts.append(pre_match_text)
+
+                        key = param_match.group(1).strip()
+                        val = param_match.group(2).strip()
+                        self._current_parameters[key] = val
+                        self._buffer = self._buffer[param_match.end() :]
+                    else:
+                        break
+
+                if "●" in self._buffer:
+                    idx = self._buffer.find("●")
+                    if idx > 0:
+                        filtered_output_parts.append(self._buffer[:idx])
+                        self._buffer = self._buffer[idx:]
+                    finished_tool_call = True
+                elif len(self._buffer) > 0 and not self._buffer.strip().startswith("<"):
+                    if "<parameter=" not in self._buffer:
+                        filtered_output_parts.append(self._buffer)
+                        self._buffer = ""
+                        finished_tool_call = True
+
+                if finished_tool_call:
+                    detected_tools.append(
+                        {
+                            "type": "tool_use",
+                            "id": self._current_tool_id,
+                            "name": self._current_function_name,
+                            "input": self._current_parameters,
+                        }
+                    )
+                    logger.debug(
+                        "Heuristic bypass: Emitting tool call '{}' with {} params",
+                        self._current_function_name,
+                        len(self._current_parameters),
+                    )
+                    self._state = ParserState.TEXT
+                else:
+                    break
+
+        return "".join(filtered_output_parts), detected_tools
+
+    def flush(self) -> list[dict[str, Any]]:
+        """Flush any remaining tool call in the buffer."""
+        self._buffer = self._strip_control_tokens(self._buffer)
+        detected_tools = []
+        if self._state == ParserState.PARSING_PARAMETERS:
+            partial_matches = re.finditer(
+                r"<parameter=([^>]+)>(.*)$", self._buffer, re.DOTALL
+            )
+            for match in partial_matches:
+                key = match.group(1).strip()
+                val = match.group(2).strip()
+                self._current_parameters[key] = val
+
+            detected_tools.append(
+                {
+                    "type": "tool_use",
+                    "id": self._current_tool_id,
+                    "name": self._current_function_name,
+                    "input": self._current_parameters,
+                }
+            )
+            self._state = ParserState.TEXT
+            self._buffer = ""
+
+        return detected_tools

core/anthropic/utils.py

@@ -0,0 +1,9 @@
+"""Small shared protocol utility helpers."""
+
+from typing import Any
+
+
+def set_if_not_none(body: dict[str, Any], key: str, value: Any) -> None:
+    """Set ``body[key]`` only when value is not None."""
+    if value is not None:
+        body[key] = value

core/openai_responses/__init__.py

@@ -0,0 +1,5 @@
+"""OpenAI Responses protocol adapter."""
+
+from .adapter import OpenAIResponsesAdapter
+
+__all__ = ["OpenAIResponsesAdapter"]

core/openai_responses/adapter.py

@@ -0,0 +1,31 @@
+"""Facade for OpenAI Responses protocol adaptation."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterable, AsyncIterator, Mapping
+from typing import Any, ClassVar
+
+from .errors import ResponsesConversionError, openai_error_payload
+from .events import OPENAI_RESPONSES_SSE_HEADERS
+from .input import convert_request_to_anthropic_payload
+from .stream import iter_responses_sse_from_anthropic
+
+
+class OpenAIResponsesAdapter:
+    """Convert between OpenAI Responses and the proxy's Anthropic core path."""
+
+    ConversionError: ClassVar[type[ResponsesConversionError]] = ResponsesConversionError
+    sse_headers: ClassVar[dict[str, str]] = OPENAI_RESPONSES_SSE_HEADERS
+
+    def to_anthropic_payload(self, request: Mapping[str, Any]) -> dict[str, Any]:
+        return convert_request_to_anthropic_payload(request)
+
+    def iter_sse_from_anthropic(
+        self,
+        chunks: AsyncIterable[Any],
+        request: Mapping[str, Any],
+    ) -> AsyncIterator[str]:
+        return iter_responses_sse_from_anthropic(chunks, request)
+
+    def error_payload(self, *, message: str, error_type: str) -> dict[str, Any]:
+        return openai_error_payload(message=message, error_type=error_type)

core/openai_responses/anthropic_sse.py

@@ -0,0 +1,59 @@
+"""Anthropic SSE parsing used by the Responses stream adapter."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterable, AsyncIterator
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(slots=True)
+class AnthropicSseEvent:
+    event: str
+    data: dict[str, Any]
+
+
+async def iter_sse_events(
+    chunks: AsyncIterable[Any],
+) -> AsyncIterator[AnthropicSseEvent]:
+    buffer = ""
+    async for chunk in chunks:
+        if isinstance(chunk, bytes):
+            buffer += chunk.decode("utf-8", errors="replace")
+        else:
+            buffer += str(chunk)
+
+        while "\n\n" in buffer:
+            raw, buffer = buffer.split("\n\n", 1)
+            event = parse_sse_event(raw)
+            if event is not None:
+                yield event
+
+    if buffer.strip():
+        event = parse_sse_event(buffer)
+        if event is not None:
+            yield event
+
+
+def parse_sse_event(raw: str) -> AnthropicSseEvent | None:
+    event_type = ""
+    data_parts: list[str] = []
+    for line in raw.splitlines():
+        stripped = line.rstrip("\r")
+        if stripped.startswith("event:"):
+            event_type = stripped.split(":", 1)[1].strip()
+        elif stripped.startswith("data:"):
+            data_parts.append(stripped.split(":", 1)[1].strip())
+    if not event_type and not data_parts:
+        return None
+    data_text = "\n".join(data_parts)
+    if data_text == "[DONE]":
+        return None
+    try:
+        parsed = json.loads(data_text) if data_text else {}
+    except json.JSONDecodeError:
+        parsed = {"raw": data_text}
+    if not isinstance(parsed, dict):
+        parsed = {"value": parsed}
+    return AnthropicSseEvent(event=event_type, data=parsed)

core/openai_responses/errors.py

@@ -0,0 +1,22 @@
+"""Errors and error envelopes for OpenAI Responses compatibility."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class ResponsesConversionError(ValueError):
+    """Raised when a Responses request cannot be converted deterministically."""
+
+
+def openai_error_payload(*, message: str, error_type: str) -> dict[str, Any]:
+    """Return an OpenAI-compatible error envelope."""
+
+    return {
+        "error": {
+            "message": message,
+            "type": error_type,
+            "param": None,
+            "code": None,
+        }
+    }

core/openai_responses/events.py

@@ -0,0 +1,19 @@
+"""OpenAI Responses SSE event formatting."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import Any
+
+OPENAI_RESPONSES_SSE_HEADERS: dict[str, str] = {
+    "X-Accel-Buffering": "no",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+}
+
+
+def format_response_sse_event(event_type: str, data: Mapping[str, Any]) -> str:
+    """Format one OpenAI Responses SSE event."""
+
+    return f"event: {event_type}\ndata: {json.dumps(data)}\n\n"

core/openai_responses/ids.py

@@ -0,0 +1,21 @@
+"""Identifier helpers for OpenAI Responses payloads."""
+
+from __future__ import annotations
+
+import uuid
+
+
+def new_response_id() -> str:
+    return f"resp_{uuid.uuid4().hex}"
+
+
+def new_message_item_id() -> str:
+    return f"msg_{uuid.uuid4().hex}"
+
+
+def new_reasoning_item_id() -> str:
+    return f"rs_{uuid.uuid4().hex}"
+
+
+def new_call_id() -> str:
+    return f"call_{uuid.uuid4().hex[:24]}"