mycode-cli 0.1.0__py3-none-any.whl

mycode/core/providers/openai_chat.py

@@ -0,0 +1,356 @@
+"""Chat Completions adapters for OpenAI-compatible providers."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from typing import Any
+
+from openai import APIError, AsyncOpenAI
+
+from mycode.core.messages import assistant_message, text_block, thinking_block, tool_use_block
+from mycode.core.providers.base import (
+    DEFAULT_REQUEST_TIMEOUT,
+    ProviderAdapter,
+    ProviderRequest,
+    ProviderStreamEvent,
+    dump_model,
+    get_native_meta,
+    load_image_block_payload,
+)
+from mycode.core.tools import parse_tool_arguments
+
+
+@dataclass
+class _ChatToolCallState:
+    """Accumulate one streamed tool call from chat-completions deltas."""
+
+    index: int
+    tool_id: str | None = None
+    name: str = ""
+    arguments_text: str = ""
+
+
+class OpenAIChatAdapter(ProviderAdapter):
+    """Base adapter for Chat Completions style providers."""
+
+    provider_id = "openai_chat"
+    label = "OpenAI Chat Completions"
+    default_base_url = "https://api.openai.com/v1"
+    env_api_key_names = ("OPENAI_API_KEY",)
+    auto_discoverable = False
+
+    async def stream_turn(self, request: ProviderRequest) -> AsyncIterator[ProviderStreamEvent]:
+        api_key = self.require_api_key(request.api_key)
+        client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=self.resolve_base_url(request.api_base),
+            timeout=DEFAULT_REQUEST_TIMEOUT,
+        )
+
+        # Keep the streamed turn state local to this adapter so the wire-format
+        # mapping stays readable in one file.
+        tool_calls: dict[int, _ChatToolCallState] = {}
+        text_parts: list[str] = []
+        thinking_parts: list[str] = []
+        thinking_native_meta: dict[str, Any] = {}
+        response_id: str | None = None
+        response_model: str | None = None
+        finish_reason: str | None = None
+        usage: Any = None
+
+        try:
+            stream = await client.chat.completions.create(**self._build_request_payload(request), stream=True)
+            async for chunk in stream:
+                response_id = response_id or getattr(chunk, "id", None)
+                response_model = response_model or getattr(chunk, "model", None)
+
+                if getattr(chunk, "usage", None) is not None:
+                    usage = chunk.usage
+
+                if not chunk.choices:
+                    continue
+
+                choice = chunk.choices[0]
+                if choice.finish_reason:
+                    finish_reason = choice.finish_reason
+
+                delta = choice.delta
+                reasoning_delta, reasoning_meta_update = self._extract_reasoning_delta(delta)
+                if reasoning_delta:
+                    thinking_parts.append(reasoning_delta)
+                    thinking_native_meta.update(reasoning_meta_update)
+                    yield ProviderStreamEvent("thinking_delta", {"text": reasoning_delta})
+
+                if delta.content:
+                    text_parts.append(delta.content)
+                    yield ProviderStreamEvent("text_delta", {"text": delta.content})
+
+                for tool_call in delta.tool_calls or []:
+                    index = tool_call.index or 0
+                    state = tool_calls.setdefault(index, _ChatToolCallState(index=index))
+                    if tool_call.id:
+                        state.tool_id = tool_call.id
+                    function = tool_call.function
+                    if function is None:
+                        continue
+                    if function.name:
+                        state.name = function.name
+                    if function.arguments:
+                        state.arguments_text += function.arguments
+        except APIError as exc:
+            raise ValueError(str(exc)) from exc
+
+        blocks = []
+        if thinking_parts:
+            blocks.append(
+                thinking_block(
+                    "".join(thinking_parts),
+                    meta={"native": thinking_native_meta} if thinking_native_meta else None,
+                )
+            )
+        if text_parts:
+            blocks.append(text_block("".join(text_parts)))
+
+        for index in sorted(tool_calls):
+            state = tool_calls[index]
+            raw_arguments = state.arguments_text
+            parsed_arguments = parse_tool_arguments(raw_arguments)
+            if isinstance(parsed_arguments, str):
+                tool_input = {}
+                meta = {"native": {"raw_arguments": raw_arguments}}
+            else:
+                tool_input = parsed_arguments
+                meta = None
+
+            blocks.append(
+                tool_use_block(
+                    tool_id=state.tool_id or f"tool_call_{index}",
+                    name=state.name,
+                    input=tool_input,
+                    meta=meta,
+                )
+            )
+
+        final_message = assistant_message(
+            blocks,
+            provider=self.provider_id,
+            model=response_model or request.model,
+            provider_message_id=response_id,
+            stop_reason=finish_reason,
+            usage=dump_model(usage),
+        )
+        yield ProviderStreamEvent("message_done", {"message": final_message})
+
+    def _build_request_payload(self, request: ProviderRequest) -> dict[str, Any]:
+        messages = []
+        if request.system:
+            messages.append({"role": "system", "content": request.system})
+        for message in self.prepare_messages(request):
+            messages.extend(self._serialize_message(message))
+
+        payload: dict[str, Any] = {
+            "model": request.model,
+            "messages": messages,
+            "tools": [self._serialize_tool(tool) for tool in request.tools] or None,
+            "tool_choice": "auto" if request.tools else None,
+            "max_tokens": request.max_tokens,
+            "stream_options": {"include_usage": True},
+        }
+        payload.update(self._build_provider_payload_overrides(request))
+        return {key: value for key, value in payload.items() if value is not None}
+
+    def _build_provider_payload_overrides(self, request: ProviderRequest) -> dict[str, Any]:
+        return {}
+
+    def _serialize_tool(self, tool: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "type": "function",
+            "function": {
+                "name": tool.get("name") or "",
+                "description": tool.get("description") or "",
+                "parameters": tool.get("input_schema") or {"type": "object", "properties": {}},
+            },
+        }
+
+    def _serialize_message(self, message: dict[str, Any]) -> list[dict[str, Any]]:
+        """Convert one canonical message into Chat Completions wire messages."""
+
+        role = str(message.get("role") or "user")
+        blocks = [block for block in message.get("content") or [] if isinstance(block, dict)]
+
+        if role == "user":
+            payload_messages: list[dict[str, Any]] = []
+            has_images = any(block.get("type") == "image" for block in blocks)
+            if has_images:
+                user_content: str | list[dict[str, Any]] | None = []
+                for block in blocks:
+                    block_type = block.get("type")
+                    if block_type == "text":
+                        text = str(block.get("text") or "")
+                        if text:
+                            user_content.append({"type": "text", "text": text})
+                        continue
+                    if block_type != "image":
+                        continue
+
+                    mime_type, data = load_image_block_payload(block)
+                    user_content.append(
+                        {
+                            "type": "image_url",
+                            "image_url": {"url": f"data:{mime_type};base64,{data}"},
+                        }
+                    )
+                if not user_content:
+                    user_content = None
+            else:
+                text_parts = [
+                    str(block.get("text") or "")
+                    for block in blocks
+                    if block.get("type") == "text" and block.get("text")
+                ]
+                text = "\n".join(text_parts)
+                user_content = text or None
+
+            if user_content:
+                payload_messages.append({"role": "user", "content": user_content})
+
+            for block in blocks:
+                if block.get("type") != "tool_result":
+                    continue
+                payload_messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": block.get("tool_use_id") or "",
+                        "content": str(block.get("model_text") or ""),
+                    }
+                )
+            return payload_messages
+
+        if role != "assistant":
+            return []
+
+        text_parts = [str(block.get("text") or "") for block in blocks if block.get("type") == "text"]
+        thinking_blocks = [block for block in blocks if block.get("type") == "thinking"]
+        tool_use_blocks = [block for block in blocks if block.get("type") == "tool_use"]
+
+        payload: dict[str, Any] = {
+            "role": "assistant",
+            "content": "\n".join(part for part in text_parts if part),
+        }
+
+        if tool_use_blocks:
+            payload["tool_calls"] = [
+                {
+                    "id": block.get("id") or "",
+                    "type": "function",
+                    "function": {
+                        "name": block.get("name") or "",
+                        "arguments": json.dumps(
+                            block.get("input") if isinstance(block.get("input"), dict) else {},
+                            ensure_ascii=False,
+                        ),
+                    },
+                }
+                for block in tool_use_blocks
+            ]
+
+        if thinking_blocks:
+            payload.update(self._serialize_reasoning(thinking_blocks))
+
+        return [payload]
+
+    def _serialize_reasoning(self, thinking_blocks: list[dict[str, Any]]) -> dict[str, Any]:
+        """Replay canonical thinking through the provider's reasoning field.
+
+        When the source provider did not record a native field name, default to
+        `reasoning_content`, which is the common reasoning slot used by the
+        OpenAI-compatible thinking providers we support.
+        """
+
+        thinking_text = "\n".join(str(block.get("text") or "") for block in thinking_blocks if block.get("text"))
+        native_meta = get_native_meta(thinking_blocks[0])
+        reasoning_field = str(native_meta.get("reasoning_field") or "")
+        if reasoning_field == "reasoning_details":
+            return {"reasoning_details": native_meta.get("reasoning_details") or []}
+        return {"reasoning_content": thinking_text} if thinking_text else {}
+
+    def _extract_reasoning_delta(self, delta: Any) -> tuple[str, dict[str, Any]]:
+        # Third-party providers surface reasoning through non-standard extras.
+        # We check both the delta root and model_extra to cover both patterns.
+        # Known fields: reasoning_content (Moonshot/MiniMax chat), reasoning_details (some others).
+        for source in (delta, getattr(delta, "model_extra", None) or {}):
+            if isinstance(source, dict):
+                reasoning_content = source.get("reasoning_content")
+                reasoning_details = source.get("reasoning_details")
+            else:
+                reasoning_content = getattr(source, "reasoning_content", None)
+                reasoning_details = getattr(source, "reasoning_details", None)
+
+            if isinstance(reasoning_content, str) and reasoning_content:
+                return reasoning_content, {"reasoning_field": "reasoning_content"}
+
+            if isinstance(reasoning_details, list) and reasoning_details:
+                reasoning_text = "".join(
+                    str(item.get("text") or "") for item in reasoning_details if isinstance(item, dict)
+                )
+                if reasoning_text:
+                    return reasoning_text, {
+                        "reasoning_field": "reasoning_details",
+                        "reasoning_details": reasoning_details,
+                    }
+
+        return "", {}
+
+
+class DeepSeekAdapter(OpenAIChatAdapter):
+    """DeepSeek's OpenAI-compatible chat endpoint.
+
+    deepseek-reasoner always thinks — no parameter needed to enable it.
+    deepseek-chat does not think by default; send thinking: {"type": "enabled"}
+    to activate it. We rely on the model's default behavior, so no overrides here.
+    """
+
+    provider_id = "deepseek"
+    label = "DeepSeek"
+    default_base_url = "https://api.deepseek.com"
+    env_api_key_names = ("DEEPSEEK_API_KEY",)
+    default_models = ("deepseek-chat", "deepseek-reasoner")
+    auto_discoverable = True
+
+
+class ZAIAdapter(OpenAIChatAdapter):
+    """Z.AI's OpenAI-compatible chat endpoint.
+
+    GLM models think by default. We still send the explicit thinking parameter
+    so that clear_thinking=False preserves reasoning across multi-turn tool loops
+    instead of resetting it on each turn.
+    """
+
+    provider_id = "zai"
+    label = "Z.AI"
+    default_base_url = "https://api.z.ai/api/paas/v4/"
+    env_api_key_names = ("ZAI_API_KEY",)
+    default_models = ("glm-5.1", "glm-5-turbo")
+    auto_discoverable = True
+
+    def _build_provider_payload_overrides(self, request: ProviderRequest) -> dict[str, Any]:
+        return {"extra_body": {"thinking": {"type": "enabled", "clear_thinking": False}}}
+
+
+class OpenRouterAdapter(OpenAIChatAdapter):
+    """OpenRouter's OpenAI-compatible chat endpoint."""
+
+    provider_id = "openrouter"
+    label = "OpenRouter"
+    default_base_url = "https://openrouter.ai/api/v1"
+    env_api_key_names = ("OPENROUTER_API_KEY",)
+    default_models = ("openrouter/auto",)
+    auto_discoverable = True
+    supports_reasoning_effort = True
+
+    def _build_provider_payload_overrides(self, request: ProviderRequest) -> dict[str, Any]:
+        if not request.reasoning_effort:
+            return {}
+        return {"extra_body": {"reasoning": {"effort": request.reasoning_effort}}}

mycode/core/providers/openai_responses.py

@@ -0,0 +1,326 @@
+"""OpenAI Responses API adapter."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator
+from copy import deepcopy
+from typing import Any, cast
+
+from openai import APIError, AsyncOpenAI
+
+from mycode.core.messages import ConversationMessage, assistant_message, text_block, thinking_block, tool_use_block
+from mycode.core.providers.base import (
+    DEFAULT_REQUEST_TIMEOUT,
+    ProviderAdapter,
+    ProviderRequest,
+    ProviderStreamEvent,
+    dump_model,
+    load_image_block_payload,
+    tool_result_content_blocks,
+)
+from mycode.core.tools import parse_tool_arguments
+
+
+class OpenAIResponsesAdapter(ProviderAdapter):
+    """Adapter for OpenAI's Responses API."""
+
+    provider_id = "openai"
+    label = "OpenAI Responses"
+    default_base_url = "https://api.openai.com/v1"
+    env_api_key_names = ("OPENAI_API_KEY",)
+    default_models = ("gpt-5.4", "gpt-5.4-mini")
+    supports_reasoning_effort = True
+
+    async def stream_turn(self, request: ProviderRequest) -> AsyncIterator[ProviderStreamEvent]:
+        api_key = self.require_api_key(request.api_key)
+        client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=self.resolve_base_url(request.api_base),
+            timeout=DEFAULT_REQUEST_TIMEOUT,
+        )
+
+        payload = self._build_request_payload(request)
+        try:
+            stream = await client.responses.create(**payload, stream=True)
+            final_response = None
+            async for event in stream:
+                if event.type == "response.reasoning_text.delta" and event.delta:
+                    yield ProviderStreamEvent("thinking_delta", {"text": event.delta})
+                    continue
+
+                if event.type == "response.output_text.delta" and event.delta:
+                    yield ProviderStreamEvent("text_delta", {"text": event.delta})
+                    continue
+
+                if event.type == "response.error":
+                    raise ValueError(str(getattr(event, "error", None) or event))
+
+                if event.type == "response.failed":
+                    raise ValueError(str(getattr(event, "response", None) or event))
+
+                if event.type == "response.completed":
+                    final_response = event.response
+        except APIError as exc:
+            raise ValueError(str(exc)) from exc
+
+        if final_response is None:
+            raise ValueError("OpenAI Responses stream ended before response.completed")
+
+        yield ProviderStreamEvent("message_done", {"message": self._convert_final_response(final_response)})
+
+    def _build_request_payload(self, request: ProviderRequest) -> dict[str, Any]:
+        prepared_messages = self.prepare_messages(request)
+        input_items: list[dict[str, Any]] = []
+        for message in prepared_messages:
+            role = message.get("role")
+            if role == "user":
+                input_items.extend(self._serialize_user_message(message))
+                continue
+
+            if role != "assistant":
+                continue
+
+            native_output_items = self._native_output_items(message)
+            if native_output_items is not None:
+                input_items.extend(native_output_items)
+                continue
+
+            input_items.extend(self._serialize_fallback_assistant_message(message))
+
+        payload: dict[str, Any] = {
+            "model": request.model,
+            "input": input_items,
+            "instructions": request.system or None,
+            "store": False,
+            "include": ["reasoning.encrypted_content"],
+            "prompt_cache_key": request.session_id or None,
+            "max_output_tokens": request.max_tokens,
+            "tools": [self._serialize_tool(tool) for tool in request.tools] or None,
+            "tool_choice": "auto" if request.tools else None,
+        }
+        if request.reasoning_effort:
+            payload["reasoning"] = {"effort": request.reasoning_effort}
+        return {key: value for key, value in payload.items() if value is not None}
+
+    def _serialize_user_message(self, message: ConversationMessage) -> list[dict[str, Any]]:
+        items: list[dict[str, Any]] = []
+        blocks = [block for block in message.get("content") or [] if isinstance(block, dict)]
+        message_content = self._serialize_input_content(
+            [block for block in blocks if block.get("type") in {"text", "image"}]
+        )
+        if message_content:
+            items.append(
+                {
+                    "type": "message",
+                    "role": "user",
+                    "content": message_content,
+                }
+            )
+
+        for block in blocks:
+            if block.get("type") != "tool_result":
+                continue
+            result_blocks = tool_result_content_blocks(block)
+            has_images = any(item.get("type") == "image" for item in result_blocks)
+            if has_images:
+                output: str | list[dict[str, Any]] = self._serialize_input_content(result_blocks)
+            else:
+                output = str(block.get("model_text") or "")
+            items.append(
+                {
+                    "type": "function_call_output",
+                    "call_id": block.get("tool_use_id") or "",
+                    "output": output,
+                }
+            )
+
+        return items
+
+    def _serialize_input_content(self, blocks: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        content: list[dict[str, Any]] = []
+        for block in blocks:
+            block_type = block.get("type")
+            if block_type == "text":
+                content.append({"type": "input_text", "text": str(block.get("text") or "")})
+                continue
+            if block_type == "image":
+                mime_type, data = load_image_block_payload(block)
+                content.append({"type": "input_image", "image_url": f"data:{mime_type};base64,{data}"})
+        return content
+
+    def _native_output_items(self, message: ConversationMessage) -> list[dict[str, Any]] | None:
+        """Replay stored OpenAI output items when history already came from Responses."""
+
+        raw_meta = message.get("meta")
+        if not isinstance(raw_meta, dict) or raw_meta.get("provider") != self.provider_id:
+            return None
+
+        native_meta = raw_meta.get("native")
+        output_items = native_meta.get("output_items") if isinstance(native_meta, dict) else None
+        if not isinstance(output_items, list) or not output_items:
+            return None
+
+        replay_items: list[dict[str, Any]] = []
+        for item in cast(list[dict[str, Any]], deepcopy(output_items)):
+            item_type = str(item.get("type") or "")
+            item.pop("status", None)
+            if item_type != "reasoning":
+                item.pop("id", None)
+            replay_items.append(item)
+
+        return replay_items
+
+    def _serialize_fallback_assistant_message(self, message: ConversationMessage) -> list[dict[str, Any]]:
+        blocks = [block for block in message.get("content") or [] if isinstance(block, dict)]
+        text_parts = [
+            str(block.get("text") or "") for block in blocks if block.get("type") == "text" and block.get("text")
+        ]
+
+        items: list[dict[str, Any]] = []
+        if text_parts:
+            message_item: dict[str, Any] = {
+                "type": "message",
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": "\n".join(text_parts)}],
+            }
+            items.append(message_item)
+
+        for block in blocks:
+            if block.get("type") != "tool_use":
+                continue
+            call_item: dict[str, Any] = {
+                "type": "function_call",
+                "call_id": block.get("id") or "",
+                "name": block.get("name") or "",
+                "arguments": json.dumps(block.get("input") if isinstance(block.get("input"), dict) else {}),
+            }
+            items.append(call_item)
+
+        return items
+
+    def _serialize_tool(self, tool: dict[str, Any]) -> dict[str, Any]:
+        parameters = cast(dict[str, Any], dict(tool.get("input_schema") or {"type": "object", "properties": {}}))
+        properties = parameters.get("properties")
+        required = parameters.get("required")
+
+        # OpenAI strict tools require every top-level property to appear in
+        # `required`. Our built-in tool schemas are flat, so optional fields only
+        # need a shallow nullable conversion here.
+        if isinstance(properties, dict):
+            copied_properties: dict[str, Any] = {
+                key: dict(value) if isinstance(value, dict) else value for key, value in properties.items()
+            }
+            required_names = {str(name) for name in required} if isinstance(required, list) else set()
+
+            for name, property_schema in copied_properties.items():
+                if name in required_names or not isinstance(property_schema, dict):
+                    continue
+
+                property_type = property_schema.get("type")
+                if isinstance(property_type, str):
+                    property_schema["type"] = [property_type, "null"]
+                elif isinstance(property_type, list):
+                    if "null" not in property_type:
+                        property_schema["type"] = [*property_type, "null"]
+                else:
+                    copied_properties[name] = {"anyOf": [property_schema, {"type": "null"}]}
+                    continue
+
+                enum_values = property_schema.get("enum")
+                if isinstance(enum_values, list) and None not in enum_values:
+                    property_schema["enum"] = [*enum_values, None]
+
+            parameters["properties"] = copied_properties
+            parameters["required"] = list(copied_properties.keys())
+
+        return {
+            "type": "function",
+            "name": tool.get("name") or "",
+            "description": tool.get("description") or "",
+            "parameters": parameters,
+            "strict": True,
+        }
+
+    def _convert_final_response(self, response: Any) -> dict[str, Any]:
+        output_items = dump_model(getattr(response, "output", None))
+        blocks: list[dict[str, Any]] = []
+        for item in getattr(response, "output", []) or []:
+            item_type = getattr(item, "type", None)
+
+            if item_type == "reasoning":
+                text_parts = []
+                for content in getattr(item, "content", None) or []:
+                    text = getattr(content, "text", None)
+                    if text:
+                        text_parts.append(text)
+
+                if not text_parts:
+                    for summary in getattr(item, "summary", None) or []:
+                        text = getattr(summary, "text", None)
+                        if text:
+                            text_parts.append(text)
+
+                native_meta = {
+                    "item_id": getattr(item, "id", None),
+                    "status": getattr(item, "status", None),
+                }
+                summary = dump_model(getattr(item, "summary", None))
+                if summary:
+                    native_meta["summary"] = summary
+                filtered_native_meta = {key: value for key, value in native_meta.items() if value is not None}
+                blocks.append(
+                    thinking_block(
+                        "".join(text_parts),
+                        meta={"native": filtered_native_meta} if filtered_native_meta else None,
+                    )
+                )
+                continue
+
+            if item_type == "message":
+                for part in getattr(item, "content", []) or []:
+                    if getattr(part, "type", None) != "output_text":
+                        continue
+                    native_meta = {}
+                    annotations = dump_model(getattr(part, "annotations", None))
+                    if annotations:
+                        native_meta["annotations"] = annotations
+                    blocks.append(
+                        text_block(
+                            getattr(part, "text", ""),
+                            meta={"native": native_meta} if native_meta else None,
+                        )
+                    )
+                continue
+
+            if item_type == "function_call":
+                raw_arguments = getattr(item, "arguments", "") or ""
+                parsed_arguments = parse_tool_arguments(raw_arguments)
+                native_meta = {
+                    "item_id": getattr(item, "id", None),
+                    "status": getattr(item, "status", None),
+                }
+                if isinstance(parsed_arguments, str):
+                    tool_input = {}
+                    native_meta["raw_arguments"] = raw_arguments
+                else:
+                    tool_input = parsed_arguments
+                filtered_native_meta = {key: value for key, value in native_meta.items() if value is not None}
+                blocks.append(
+                    tool_use_block(
+                        tool_id=getattr(item, "call_id", ""),
+                        name=getattr(item, "name", ""),
+                        input=tool_input,
+                        meta={"native": filtered_native_meta} if filtered_native_meta else None,
+                    )
+                )
+
+        return assistant_message(
+            blocks,
+            provider=self.provider_id,
+            model=getattr(response, "model", None),
+            provider_message_id=getattr(response, "id", None),
+            stop_reason=getattr(response, "status", None),
+            usage=dump_model(getattr(response, "usage", None)),
+            native_meta={"output_items": output_items} if output_items else None,
+        )