mycode-sdk 0.4.2__py3-none-any.whl

mycode/providers/gemini.py

@@ -0,0 +1,316 @@
+"""Google Gemini adapter built on the official google-genai Python SDK."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from typing import Any
+from urllib.parse import urlparse
+
+from google import genai
+from google.genai import types
+from google.genai.errors import APIError
+
+from mycode.messages import assistant_message, text_block, thinking_block, tool_use_block
+from mycode.providers.base import (
+    DEFAULT_REQUEST_TIMEOUT,
+    ProviderAdapter,
+    ProviderRequest,
+    ProviderStreamEvent,
+    get_native_meta,
+    load_document_block_payload,
+    load_image_block_payload,
+)
+
+_DUMMY_THOUGHT_SIGNATURE = "skip_thought_signature_validator"
+
+
+def _to_json(value: Any) -> Any:
+    """Convert SDK objects into JSON-safe plain data."""
+
+    if value is None:
+        return None
+    if hasattr(value, "model_dump"):
+        try:
+            return value.model_dump(mode="json", exclude_none=True)
+        except TypeError:
+            return _to_json(value.model_dump())
+    if isinstance(value, list):
+        return [_to_json(item) for item in value]
+    if isinstance(value, dict):
+        return {key: normalized for key, item in value.items() if (normalized := _to_json(item)) is not None}
+    return value
+
+
+class GoogleGeminiAdapter(ProviderAdapter):
+    """Adapter for the Gemini Developer API."""
+
+    provider_id = "google"
+    label = "Google Gemini"
+    default_base_url = "https://generativelanguage.googleapis.com"
+    env_api_key_names = ("GEMINI_API_KEY", "GOOGLE_API_KEY")
+    default_models = ("gemini-3.1-pro-preview", "gemini-3-flash-preview")
+    supports_reasoning_effort = True
+
+    async def stream_turn(self, request: ProviderRequest) -> AsyncIterator[ProviderStreamEvent]:
+        api_key = self.require_api_key(request.api_key)
+        client = genai.Client(api_key=api_key, http_options=self._http_options(request.api_base))
+
+        blocks: list[dict[str, Any]] = []
+        response_id: str | None = None
+        response_model: str | None = None
+        finish_reason: str | None = None
+        finish_message: str | None = None
+        usage: dict[str, Any] | None = None
+
+        try:
+            stream = await client.aio.models.generate_content_stream(
+                model=request.model,
+                contents=self._build_contents(request),
+                config=self._build_config(request),
+            )
+            async for chunk in stream:
+                response_id = response_id or getattr(chunk, "response_id", None)
+                response_model = response_model or getattr(chunk, "model_version", None)
+                usage = _to_json(getattr(chunk, "usage_metadata", None)) or usage
+
+                candidates = getattr(chunk, "candidates", None) or []
+                if not candidates:
+                    continue
+                candidate = candidates[0]
+
+                finish_reason = _to_json(getattr(candidate, "finish_reason", None)) or finish_reason
+                finish_message = getattr(candidate, "finish_message", None) or finish_message
+
+                for part in getattr(getattr(candidate, "content", None), "parts", None) or []:
+                    for event in self._consume_part(blocks, part):
+                        yield event
+        except APIError as exc:
+            raise ValueError(str(exc)) from exc
+        finally:
+            try:
+                await client.aio.aclose()
+            except Exception:
+                pass
+
+        yield ProviderStreamEvent(
+            "message_done",
+            {
+                "message": assistant_message(
+                    blocks,
+                    provider=self.provider_id,
+                    model=response_model or request.model,
+                    provider_message_id=response_id,
+                    stop_reason=str(finish_reason) if finish_reason else None,
+                    usage=usage,
+                    native_meta={"finish_message": str(finish_message)} if finish_message else None,
+                )
+            },
+        )
+
+    def _http_options(self, api_base: str | None) -> types.HttpOptions:
+        base_url = self.resolve_base_url(api_base)
+        api_version = "v1beta"
+        if base_url and urlparse(base_url).path.rstrip("/").lower().endswith(("/v1", "/v1beta")):
+            api_version = None
+        # google-genai expects milliseconds here; DEFAULT_REQUEST_TIMEOUT is seconds.
+        timeout_ms = int(DEFAULT_REQUEST_TIMEOUT * 1000)
+        return types.HttpOptions(base_url=base_url, api_version=api_version, timeout=timeout_ms)
+
+    def _build_contents(self, request: ProviderRequest) -> list[dict[str, Any]]:
+        """Convert canonical replay messages into Gemini contents."""
+
+        contents: list[dict[str, Any]] = []
+        tool_names: dict[str, str] = {}
+
+        for message in self.prepare_messages(request):
+            role = str(message.get("role") or "")
+            blocks = [block for block in message.get("content") or [] if isinstance(block, dict)]
+
+            if role == "assistant":
+                parts: list[dict[str, Any]] = []
+                needs_dummy_signature = True
+
+                for block in blocks:
+                    if block.get("type") == "tool_use":
+                        tool_id = str(block.get("id") or "")
+                        tool_name = str(block.get("name") or "")
+                        if tool_id and tool_name:
+                            tool_names[tool_id] = tool_name
+
+                    native_part = get_native_meta(block).get("part")
+                    if isinstance(native_part, dict):
+                        parts.append(dict(native_part))
+                        if native_part.get("function_call") and native_part.get("thought_signature"):
+                            needs_dummy_signature = False
+                        continue
+
+                    block_type = block.get("type")
+                    if block_type == "thinking":
+                        parts.append({"text": str(block.get("text") or ""), "thought": True})
+                        continue
+
+                    if block_type == "text":
+                        parts.append({"text": str(block.get("text") or "")})
+                        continue
+
+                    if block_type != "tool_use":
+                        continue
+
+                    part: dict[str, Any] = {
+                        "function_call": {
+                            "id": block.get("id") or "",
+                            "name": block.get("name") or "",
+                            "args": block.get("input") if isinstance(block.get("input"), dict) else {},
+                        }
+                    }
+                    # Gemini 3 validates the first function call in each step of
+                    # the current turn. Cross-provider replay has no real thought
+                    # signature, so we attach the documented dummy signature once.
+                    if needs_dummy_signature:
+                        part["thought_signature"] = _DUMMY_THOUGHT_SIGNATURE
+                        needs_dummy_signature = False
+                    parts.append(part)
+
+                if parts:
+                    contents.append({"role": "model", "parts": parts})
+                continue
+
+            if role != "user":
+                continue
+
+            parts = []
+            for block in blocks:
+                block_type = block.get("type")
+                if block_type == "text":
+                    parts.append({"text": str(block.get("text") or "")})
+                    continue
+
+                if block_type == "image":
+                    mime_type, data = load_image_block_payload(block)
+                    parts.append({"inline_data": {"mime_type": mime_type, "data": data}})
+                    continue
+                if block_type == "document":
+                    mime_type, data, _name = load_document_block_payload(block)
+                    parts.append({"inline_data": {"mime_type": mime_type, "data": data}})
+                    continue
+
+                if block_type != "tool_result":
+                    continue
+
+                tool_id = str(block.get("tool_use_id") or "")
+                response: dict[str, Any] = {"result": str(block.get("model_text") or "")}
+                if block.get("is_error"):
+                    response["is_error"] = True
+
+                # Gemini requires the exact id and name from the matching
+                # function_call in the previous model turn.
+                parts.append(
+                    {
+                        "function_response": {
+                            "id": tool_id,
+                            "name": tool_names.get(tool_id, ""),
+                            "response": response,
+                        }
+                    }
+                )
+
+            if parts:
+                contents.append({"role": "user", "parts": parts})
+
+        return contents
+
+    def _build_config(self, request: ProviderRequest) -> types.GenerateContentConfig:
+        tools: list[types.Tool | Any] | None = None
+        if request.tools:
+            tools = [
+                types.Tool(
+                    function_declarations=[
+                        types.FunctionDeclaration(
+                            name=str(tool.get("name") or ""),
+                            description=str(tool.get("description") or ""),
+                            parameters_json_schema=tool.get("input_schema") or {"type": "object", "properties": {}},
+                        )
+                        for tool in request.tools
+                    ]
+                )
+            ]
+
+        thinking_config = types.ThinkingConfig(include_thoughts=True)
+        if request.reasoning_effort and request.model.lower().startswith("gemini-3"):
+            # Official OpenAI-compat mapping:
+            # Gemini 3.1 Pro: minimal -> low
+            # Gemini 3 Flash:   minimal -> minimal
+            effort = request.reasoning_effort
+            if effort in {"none", "low"}:
+                thinking_config.thinking_level = (
+                    types.ThinkingLevel.LOW
+                    if request.model.lower().startswith("gemini-3.1-pro")
+                    else types.ThinkingLevel.MINIMAL
+                )
+            elif effort == "medium":
+                thinking_config.thinking_level = types.ThinkingLevel.MEDIUM
+            else:
+                thinking_config.thinking_level = types.ThinkingLevel.HIGH
+
+        return types.GenerateContentConfig(
+            system_instruction=request.system or None,
+            max_output_tokens=request.max_tokens,
+            tools=tools,
+            thinking_config=thinking_config,
+        )
+
+    def _consume_part(self, blocks: list[dict[str, Any]], part: Any) -> list[ProviderStreamEvent]:
+        native_part = _to_json(part) or {}
+        if native_part.get("thought") is False:
+            native_part.pop("thought", None)
+
+        function_call = getattr(part, "function_call", None)
+        if function_call is not None:
+            tool_input = getattr(function_call, "args", None)
+            blocks.append(
+                tool_use_block(
+                    tool_id=str(getattr(function_call, "id", None) or f"tool_call_{len(blocks)}"),
+                    name=str(getattr(function_call, "name", None) or ""),
+                    input=tool_input if isinstance(tool_input, dict) else {},
+                    meta={"native": {"part": native_part}},
+                )
+            )
+            return []
+
+        text = getattr(part, "text", None)
+        if text is None or text == "":
+            if not native_part.get("thought_signature"):
+                return []
+
+            # Gemini may put the final thought signature into an empty-text part.
+            # Keep it as a separate empty block so replay preserves the original
+            # part boundary instead of merging the signature into another block.
+            part_meta = {"native": {"part": native_part}}
+            is_thought = getattr(part, "thought", False)
+            blocks.append(thinking_block("", meta=part_meta) if is_thought else text_block("", meta=part_meta))
+            return []
+
+        is_thought = bool(getattr(part, "thought", False))
+        event = ProviderStreamEvent("thinking_delta" if is_thought else "text_delta", {"text": str(text)})
+        block_type = "thinking" if is_thought else "text"
+
+        # Gemini may stream one logical thought/text across many chunks.
+        # Merge only when the block kind matches and we are not combining
+        # distinct thought signatures.
+        if blocks and blocks[-1].get("type") == block_type:
+            last_part = get_native_meta(blocks[-1]).get("part")
+            if isinstance(last_part, dict):
+                last_signature = last_part.get("thought_signature")
+                current_signature = native_part.get("thought_signature")
+                if not (last_signature and current_signature and last_signature != current_signature):
+                    blocks[-1]["text"] = f"{blocks[-1].get('text') or ''}{text}"
+                    last_part["text"] = f"{last_part.get('text') or ''}{text}"
+                    if current_signature and not last_signature:
+                        last_part["thought_signature"] = current_signature
+                    return [event]
+
+        part_meta = {"native": {"part": native_part}}
+        blocks.append(
+            thinking_block(str(text), meta=part_meta) if is_thought else text_block(str(text), meta=part_meta)
+        )
+        return [event]

mycode/providers/openai_chat.py

@@ -0,0 +1,368 @@
+"""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.messages import assistant_message, text_block, thinking_block, tool_use_block
+from mycode.providers.base import (
+    DEFAULT_REQUEST_TIMEOUT,
+    ProviderAdapter,
+    ProviderRequest,
+    ProviderStreamEvent,
+    dump_model,
+    get_native_meta,
+    load_document_block_payload,
+    load_image_block_payload,
+)
+from mycode.utils import omit_none, 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 omit_none(payload)
+
+    def _build_provider_payload_overrides(self, request: ProviderRequest) -> dict[str, Any]:
+        del request
+        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_media = any(block.get("type") in {"image", "document"} for block in blocks)
+            if has_media:
+                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":
+                        mime_type, data = load_image_block_payload(block)
+                        user_content.append(
+                            {
+                                "type": "image_url",
+                                "image_url": {"url": f"data:{mime_type};base64,{data}"},
+                            }
+                        )
+                        continue
+                    if block_type == "document":
+                        mime_type, data, name = load_document_block_payload(block)
+                        user_content.append(
+                            {
+                                "type": "file",
+                                "file": {
+                                    "filename": name or "document.pdf",
+                                    "file_data": 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}}}