devcopilot 0.2.0__py3-none-any.whl

core/anthropic/conversion.py

@@ -0,0 +1,587 @@
+"""Message and tool format converters."""
+
+import json
+from copy import deepcopy
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+from pydantic import BaseModel
+
+from .content import get_block_attr, get_block_type
+from .utils import set_if_not_none
+
+
+class OpenAIConversionError(Exception):
+    """Raised when Anthropic content cannot be converted to OpenAI chat without data loss."""
+
+
+class ReasoningReplayMode(StrEnum):
+    """How assistant reasoning history is replayed to OpenAI-compatible providers."""
+
+    DISABLED = "disabled"
+    THINK_TAGS = "think_tags"
+    REASONING_CONTENT = "reasoning_content"
+
+
+def _openai_reject_native_only_top_level_fields(request_data: Any) -> None:
+    """OpenAI chat providers may only convert known top-level request fields.
+
+    First-class model fields (e.g. ``context_management``) are not forwarded to
+    the OpenAI API but are allowed so clients do not hit spurious 400s.
+    Unknown extra keys (``__pydantic_extra__``) are still rejected.
+    """
+    if not isinstance(request_data, BaseModel):
+        return
+    extra = getattr(request_data, "__pydantic_extra__", None)
+    if not extra:
+        return
+    raise OpenAIConversionError(
+        "OpenAI chat conversion does not support these top-level request fields: "
+        f"{sorted(str(k) for k in extra)}. Use a native Anthropic transport provider."
+    )
+
+
+def _tool_name(tool: Any) -> str:
+    return str(getattr(tool, "name", "") or "")
+
+
+def _tool_input_schema(tool: Any) -> dict[str, Any]:
+    schema = getattr(tool, "input_schema", None)
+    if isinstance(schema, dict):
+        return schema
+    return {"type": "object", "properties": {}}
+
+
+def _serialize_tool_result_content(tool_content: Any) -> str:
+    """Serialize tool_result content for OpenAI ``role: tool`` messages (stable JSON for structured values)."""
+    if tool_content is None:
+        return ""
+    if isinstance(tool_content, str):
+        return tool_content
+    if isinstance(tool_content, dict):
+        return json.dumps(tool_content, ensure_ascii=False)
+    if isinstance(tool_content, list):
+        parts: list[str] = []
+        for item in tool_content:
+            if isinstance(item, dict) and item.get("type") == "text":
+                parts.append(str(item.get("text", "")))
+            elif isinstance(item, dict):
+                parts.append(json.dumps(item, ensure_ascii=False))
+            else:
+                parts.append(str(item))
+        return "\n".join(parts)
+    return str(tool_content)
+
+
+def _clean_reasoning_content(value: Any) -> str | None:
+    if not isinstance(value, str):
+        return None
+    return value if value else None
+
+
+def _think_tag_content(reasoning: str) -> str:
+    return f"<think>\n{reasoning}\n</think>"
+
+
+def _tool_call_from_tool_use(block: Any) -> dict[str, Any]:
+    tool_input = get_block_attr(block, "input", {})
+    tool_call: dict[str, Any] = {
+        "id": get_block_attr(block, "id"),
+        "type": "function",
+        "function": {
+            "name": get_block_attr(block, "name"),
+            "arguments": json.dumps(tool_input)
+            if isinstance(tool_input, dict)
+            else str(tool_input),
+        },
+    }
+    extra_content = get_block_attr(block, "extra_content", None)
+    if isinstance(extra_content, dict) and extra_content:
+        tool_call["extra_content"] = deepcopy(extra_content)
+    return tool_call
+
+
+@dataclass
+class _PendingAfterTools:
+    """Assistant content that appears after ``tool_use`` in an Anthropic message.
+
+    OpenAI ``chat.completions`` cannot place assistant text after ``tool_calls`` in the
+    same message, so it is deferred until the corresponding ``role: tool`` results have
+    been replayed in order.
+    """
+
+    # Tool use IDs still missing a ``role: tool`` result before post-tool text may be replayed.
+    remaining_tool_ids: set[str] = field(default_factory=set)
+    deferred_blocks: list[Any] = field(default_factory=list)
+    top_level_reasoning: str | None = None
+    reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS
+    # True after deferred assistant text has been added to the OpenAI transcript.
+    deferred_emitted: bool = False
+
+    def needs_deferred(self) -> bool:
+        return bool(self.deferred_blocks) and not self.deferred_emitted
+
+
+def _index_first_tool_use(blocks: list[Any]) -> int | None:
+    for i, block in enumerate(blocks):
+        if get_block_type(block) == "tool_use":
+            return i
+    return None
+
+
+def _iter_tool_uses_in_order(blocks: list[Any]) -> list[dict[str, Any]]:
+    return [
+        _tool_call_from_tool_use(block)
+        for block in blocks
+        if get_block_type(block) == "tool_use"
+    ]
+
+
+def _deferred_post_tool_blocks(
+    content: list[Any], *, first_tool_index: int
+) -> list[Any]:
+    return [
+        b
+        for i, b in enumerate(content)
+        if i > first_tool_index and get_block_type(b) != "tool_use"
+    ]
+
+
+def _assert_no_forbidden_assistant_block(block: Any) -> None:
+    block_type = get_block_type(block)
+    if block_type == "image":
+        raise OpenAIConversionError(
+            "Assistant image blocks are not supported for OpenAI chat conversion."
+        )
+    if block_type in (
+        "server_tool_use",
+        "web_search_tool_result",
+        "web_fetch_tool_result",
+    ):
+        raise OpenAIConversionError(
+            "OpenAI chat conversion does not support Anthropic server tool blocks "
+            f"({block_type!r} in an assistant message). Use a native Anthropic transport provider."
+        )
+
+
+class AnthropicToOpenAIConverter:
+    """Convert Anthropic message format to OpenAI-compatible format."""
+
+    @staticmethod
+    def convert_messages(
+        messages: list[Any],
+        *,
+        reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,
+    ) -> list[dict[str, Any]]:
+        result: list[dict[str, Any]] = []
+        pending: _PendingAfterTools | None = None
+
+        for msg in messages:
+            role = msg.role
+            content = msg.content
+            reasoning_content = _clean_reasoning_content(
+                getattr(msg, "reasoning_content", None)
+            )
+
+            if role == "assistant" and isinstance(content, list):
+                if pending is not None and pending.needs_deferred():
+                    # Orphan: expected tool result; emit deferred to avoid a stuck session.
+                    result.extend(
+                        AnthropicToOpenAIConverter._deferred_post_tool_to_messages(
+                            pending,
+                        )
+                    )
+                    pending.deferred_emitted = True
+                    pending = None
+
+                if (first_i := _index_first_tool_use(content)) is not None:
+                    for block in content:
+                        if get_block_type(block) == "tool_use":
+                            continue
+                        _assert_no_forbidden_assistant_block(block)
+                    out, new_pending = (
+                        AnthropicToOpenAIConverter._convert_assistant_message_with_split(
+                            content,
+                            first_tool_index=first_i,
+                            reasoning_content=reasoning_content,
+                            reasoning_replay=reasoning_replay,
+                        )
+                    )
+                    result.extend(out)
+                    if new_pending is not None:
+                        pending = new_pending
+                else:
+                    for block in content:
+                        _assert_no_forbidden_assistant_block(block)
+                    result.extend(
+                        AnthropicToOpenAIConverter._convert_assistant_message(
+                            content,
+                            reasoning_content=reasoning_content,
+                            reasoning_replay=reasoning_replay,
+                        )
+                    )
+            elif isinstance(content, str):
+                if role == "user" and pending is not None and pending.needs_deferred():
+                    result.extend(
+                        AnthropicToOpenAIConverter._deferred_post_tool_to_messages(
+                            pending
+                        )
+                    )
+                    pending.deferred_emitted = True
+                    pending = None
+                converted = {"role": role, "content": content}
+                if role == "assistant" and reasoning_content:
+                    if reasoning_replay == ReasoningReplayMode.REASONING_CONTENT:
+                        converted["reasoning_content"] = reasoning_content
+                    elif reasoning_replay == ReasoningReplayMode.THINK_TAGS:
+                        content_parts = [_think_tag_content(reasoning_content)]
+                        if content:
+                            content_parts.append(content)
+                        converted["content"] = "\n\n".join(content_parts)
+                result.append(converted)
+            elif isinstance(content, list):
+                if role == "user":
+                    if pending is not None and pending.needs_deferred():
+                        if not pending.remaining_tool_ids:
+                            result.extend(
+                                AnthropicToOpenAIConverter._deferred_post_tool_to_messages(
+                                    pending
+                                )
+                            )
+                            pending.deferred_emitted = True
+                            pending = None
+                            result.extend(
+                                AnthropicToOpenAIConverter._convert_user_message(
+                                    content
+                                )
+                            )
+                        else:
+                            pieces = AnthropicToOpenAIConverter._convert_user_message_with_injection(
+                                content, pending
+                            )
+                            result.extend(pieces["messages"])
+                            if pieces["cleared_pending"]:
+                                pending = None
+                    else:
+                        result.extend(
+                            AnthropicToOpenAIConverter._convert_user_message(content)
+                        )
+            else:
+                if role == "user" and pending is not None and pending.needs_deferred():
+                    result.extend(
+                        AnthropicToOpenAIConverter._deferred_post_tool_to_messages(
+                            pending
+                        )
+                    )
+                    pending.deferred_emitted = True
+                    pending = None
+                result.append({"role": role, "content": str(content)})
+
+        if pending is not None and pending.needs_deferred():
+            result.extend(
+                AnthropicToOpenAIConverter._deferred_post_tool_to_messages(pending)
+            )
+
+        return result
+
+    @staticmethod
+    def _convert_assistant_message_with_split(
+        content: list[Any],
+        *,
+        first_tool_index: int,
+        reasoning_content: str | None,
+        reasoning_replay: ReasoningReplayMode,
+    ) -> tuple[list[dict[str, Any]], _PendingAfterTools | None]:
+        pre = content[:first_tool_index]
+        tool_calls = _iter_tool_uses_in_order(content)
+        if not tool_calls:
+            return (
+                AnthropicToOpenAIConverter._convert_assistant_message(
+                    content,
+                    reasoning_content=reasoning_content,
+                    reasoning_replay=reasoning_replay,
+                ),
+                None,
+            )
+        deferred_blocks = _deferred_post_tool_blocks(
+            content, first_tool_index=first_tool_index
+        )
+
+        pre_msg: dict[str, Any]
+        if not pre:
+            pre_msg = {
+                "role": "assistant",
+                "content": "",
+            }
+            if reasoning_replay == ReasoningReplayMode.REASONING_CONTENT:
+                replay = reasoning_content
+                if replay:
+                    pre_msg["reasoning_content"] = replay
+        else:
+            pre_msg = AnthropicToOpenAIConverter._convert_assistant_message(
+                pre,
+                reasoning_content=reasoning_content,
+                reasoning_replay=reasoning_replay,
+            )[0]
+        pre_msg["tool_calls"] = tool_calls
+        if tool_calls and pre_msg.get("content") == " ":
+            pre_msg["content"] = ""
+        pnd: _PendingAfterTools | None = None
+        if deferred_blocks:
+            res_ids: set[str] = set()
+            for tc in tool_calls:
+                tid = tc.get("id")
+                if tid is not None and str(tid).strip() != "":
+                    res_ids.add(str(tid))
+            pnd = _PendingAfterTools(
+                remaining_tool_ids=res_ids,
+                deferred_blocks=deferred_blocks,
+                top_level_reasoning=reasoning_content,
+                reasoning_replay=reasoning_replay,
+            )
+        return [pre_msg], pnd
+
+    @staticmethod
+    def _convert_assistant_message(
+        content: list[Any],
+        *,
+        reasoning_content: str | None = None,
+        reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,
+    ) -> list[dict[str, Any]]:
+        content_parts: list[str] = []
+        thinking_parts: list[str] = []
+        tool_calls: list[dict[str, Any]] = []
+        for block in content:
+            block_type = get_block_type(block)
+            if block_type == "text":
+                content_parts.append(get_block_attr(block, "text", ""))
+            elif block_type == "thinking":
+                if reasoning_replay == ReasoningReplayMode.DISABLED:
+                    continue
+                thinking = get_block_attr(block, "thinking", "")
+                if reasoning_replay == ReasoningReplayMode.THINK_TAGS:
+                    content_parts.append(_think_tag_content(thinking))
+                elif reasoning_content is None:
+                    thinking_parts.append(thinking)
+            elif block_type == "redacted_thinking":
+                # Opaque provider continuation data; do not materialize as model-visible text
+                # or reasoning_content for OpenAI chat upstreams.
+                continue
+            elif block_type == "tool_use":
+                tool_calls.append(_tool_call_from_tool_use(block))
+            else:
+                _assert_no_forbidden_assistant_block(block)
+
+        content_str = "\n\n".join(content_parts)
+        if not content_str and not tool_calls:
+            content_str = " "
+
+        msg: dict[str, Any] = {
+            "role": "assistant",
+            "content": content_str,
+        }
+        if tool_calls:
+            msg["tool_calls"] = tool_calls
+        if reasoning_replay == ReasoningReplayMode.REASONING_CONTENT:
+            replay_reasoning = reasoning_content or "\n".join(thinking_parts)
+            if replay_reasoning:
+                msg["reasoning_content"] = replay_reasoning
+
+        return [msg]
+
+    @staticmethod
+    def _deferred_post_tool_to_messages(
+        pending: _PendingAfterTools,
+    ) -> list[dict[str, Any]]:
+        if not pending.deferred_blocks:
+            return []
+        return AnthropicToOpenAIConverter._convert_assistant_message(
+            pending.deferred_blocks,
+            reasoning_content=pending.top_level_reasoning,
+            reasoning_replay=pending.reasoning_replay,
+        )
+
+    @staticmethod
+    def _convert_user_message_with_injection(
+        content: list[Any], pending: _PendingAfterTools
+    ) -> dict[str, Any]:
+        """Convert user list blocks, emitting deferred assistant after all tool results."""
+        if not pending.needs_deferred() or not pending.remaining_tool_ids:
+            return {
+                "messages": AnthropicToOpenAIConverter._convert_user_message(content),
+                "cleared_pending": False,
+            }
+
+        result: list[dict[str, Any]] = []
+        text_parts: list[str] = []
+        cleared = False
+
+        def flush_text() -> None:
+            if text_parts:
+                result.append({"role": "user", "content": "\n".join(text_parts)})
+                text_parts.clear()
+
+        for block in content:
+            block_type = get_block_type(block)
+            if block_type == "text":
+                text_parts.append(get_block_attr(block, "text", ""))
+            elif block_type == "image":
+                raise OpenAIConversionError(
+                    "User message image blocks are not supported for OpenAI chat "
+                    "conversion; use a vision-capable native Anthropic provider or "
+                    "extend the converter."
+                )
+            elif block_type == "tool_result":
+                flush_text()
+                tool_content = get_block_attr(block, "content", "")
+                serialized = _serialize_tool_result_content(tool_content)
+                tuid = get_block_attr(block, "tool_use_id")
+                tuid_s = str(tuid) if tuid is not None else ""
+                result.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tuid,
+                        "content": serialized if serialized else "",
+                    }
+                )
+                if tuid_s in pending.remaining_tool_ids:
+                    pending.remaining_tool_ids.discard(tuid_s)
+                if not pending.remaining_tool_ids:
+                    result.extend(
+                        AnthropicToOpenAIConverter._deferred_post_tool_to_messages(
+                            pending
+                        )
+                    )
+                    pending.deferred_emitted = True
+                    cleared = True
+            else:
+                pass
+
+        flush_text()
+        return {"messages": result, "cleared_pending": cleared}
+
+    @staticmethod
+    def _convert_user_message(content: list[Any]) -> list[dict[str, Any]]:
+        result: list[dict[str, Any]] = []
+        text_parts: list[str] = []
+
+        def flush_text() -> None:
+            if text_parts:
+                result.append({"role": "user", "content": "\n".join(text_parts)})
+                text_parts.clear()
+
+        for block in content:
+            block_type = get_block_type(block)
+
+            if block_type == "text":
+                text_parts.append(get_block_attr(block, "text", ""))
+            elif block_type == "image":
+                raise OpenAIConversionError(
+                    "User message image blocks are not supported for OpenAI chat "
+                    "conversion; use a vision-capable native Anthropic provider or "
+                    "extend the converter."
+                )
+            elif block_type == "tool_result":
+                flush_text()
+                tool_content = get_block_attr(block, "content", "")
+                serialized = _serialize_tool_result_content(tool_content)
+                result.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": get_block_attr(block, "tool_use_id"),
+                        "content": serialized if serialized else "",
+                    }
+                )
+
+        flush_text()
+        return result
+
+    @staticmethod
+    def convert_tools(tools: list[Any]) -> list[dict[str, Any]]:
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description or "",
+                    "parameters": _tool_input_schema(tool),
+                },
+            }
+            for tool in tools
+        ]
+
+    @staticmethod
+    def convert_tool_choice(tool_choice: Any) -> Any:
+        if not isinstance(tool_choice, dict):
+            return tool_choice
+
+        choice_type = tool_choice.get("type")
+        if choice_type == "tool":
+            name = tool_choice.get("name")
+            if name:
+                return {"type": "function", "function": {"name": name}}
+        if choice_type == "any":
+            return "required"
+        if choice_type in {"auto", "none", "required"}:
+            return choice_type
+        if choice_type == "function" and isinstance(tool_choice.get("function"), dict):
+            return tool_choice
+
+        return tool_choice
+
+    @staticmethod
+    def convert_system_prompt(system: Any) -> dict[str, str] | None:
+        if isinstance(system, str):
+            return {"role": "system", "content": system}
+        if isinstance(system, list):
+            text_parts = [
+                get_block_attr(block, "text", "")
+                for block in system
+                if get_block_type(block) == "text"
+            ]
+            if text_parts:
+                return {"role": "system", "content": "\n\n".join(text_parts).strip()}
+        return None
+
+
+def build_base_request_body(
+    request_data: Any,
+    *,
+    default_max_tokens: int | None = None,
+    reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,
+) -> dict[str, Any]:
+    """Build the common parts of an OpenAI-format request body."""
+    _openai_reject_native_only_top_level_fields(request_data)
+    messages = AnthropicToOpenAIConverter.convert_messages(
+        request_data.messages,
+        reasoning_replay=reasoning_replay,
+    )
+
+    system = getattr(request_data, "system", None)
+    if system:
+        system_msg = AnthropicToOpenAIConverter.convert_system_prompt(system)
+        if system_msg:
+            messages.insert(0, system_msg)
+
+    body: dict[str, Any] = {"model": request_data.model, "messages": messages}
+
+    max_tokens = getattr(request_data, "max_tokens", None)
+    set_if_not_none(body, "max_tokens", max_tokens or default_max_tokens)
+    set_if_not_none(body, "temperature", getattr(request_data, "temperature", None))
+    set_if_not_none(body, "top_p", getattr(request_data, "top_p", None))
+
+    stop_sequences = getattr(request_data, "stop_sequences", None)
+    if stop_sequences:
+        body["stop"] = stop_sequences
+
+    tools = getattr(request_data, "tools", None)
+    if tools:
+        body["tools"] = AnthropicToOpenAIConverter.convert_tools(tools)
+    tool_choice = getattr(request_data, "tool_choice", None)
+    if tool_choice:
+        body["tool_choice"] = AnthropicToOpenAIConverter.convert_tool_choice(
+            tool_choice
+        )
+
+    return body