mycode-cli 0.1.0__py3-none-any.whl

mycode/core/providers/base.py

@@ -0,0 +1,351 @@
+"""Shared provider adapter interfaces.
+
+The agent loop talks to providers through a small normalized contract:
+
+- input: `ProviderRequest`
+- output: streamed `ProviderStreamEvent` objects
+
+Concrete adapters are free to use the official SDK or protocol that best matches
+their upstream provider. Each adapter is also responsible for projecting the
+canonical session transcript into a provider-safe replay history before a new
+request is sent upstream.
+"""
+
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+from typing import Any
+
+from mycode.core.messages import ConversationMessage, build_message, text_block, tool_result_block
+
+DEFAULT_REQUEST_TIMEOUT = 300.0
+
+
+@dataclass(frozen=True)
+class ProviderRequest:
+    provider: str
+    model: str
+    session_id: str | None
+    messages: list[ConversationMessage]
+    system: str
+    tools: list[dict[str, Any]]
+    max_tokens: int
+    api_key: str | None
+    api_base: str | None
+    reasoning_effort: str | None = None
+    supports_image_input: bool = True
+
+
+@dataclass
+class ProviderStreamEvent:
+    type: str
+    data: dict[str, Any] = field(default_factory=dict)
+
+
+def dump_model(value: Any) -> Any:
+    """Convert SDK model objects into plain Python data."""
+
+    if value is None:
+        return None
+    if hasattr(value, "model_dump"):
+        return value.model_dump()
+    if isinstance(value, list):
+        return [dump_model(item) for item in value]
+    return value
+
+
+def get_native_meta(block: dict[str, Any]) -> dict[str, Any]:
+    """Return block.meta.native as a dict, or {} if absent."""
+
+    raw_meta = block.get("meta")
+    if isinstance(raw_meta, dict):
+        candidate = raw_meta.get("native")
+        if isinstance(candidate, dict):
+            return candidate
+    return {}
+
+
+class ProviderAdapter(ABC):
+    """Base class for provider adapters.
+
+    New adapters usually only need to implement `stream_turn()` and optionally
+    override tool-call ID projection.
+    """
+
+    provider_id: str
+    label: str
+    default_base_url: str | None = None
+    env_api_key_names: tuple[str, ...] = ()
+    # Used only as lightweight defaults during config resolution.
+    default_models: tuple[str, ...] = ()
+    # Auto-discovery is intentionally limited to first-party built-ins that can
+    # run from environment variables alone.
+    auto_discoverable: bool = True
+    # Whether this adapter accepts the shared `reasoning_effort` knob. Providers
+    # that do not support it keep their upstream default behavior unchanged.
+    supports_reasoning_effort: bool = False
+
+    @abstractmethod
+    def stream_turn(self, request: ProviderRequest) -> AsyncIterator[ProviderStreamEvent]:
+        """Stream exactly one assistant turn."""
+
+    def prepare_messages(self, request: ProviderRequest) -> list[ConversationMessage]:
+        """Repair canonical history, then project tool IDs for provider replay."""
+
+        supports_image_input = getattr(request, "supports_image_input", True)
+        repaired_messages = repair_messages_for_replay(request.messages, supports_image_input=supports_image_input)
+        prepared_messages: list[ConversationMessage] = []
+        tool_id_map: dict[str, str] = {}
+        used_tool_call_ids: set[str] = set()
+
+        for message in repaired_messages:
+            projected_blocks: list[dict[str, Any]] = []
+            for raw_block in message.get("content") or []:
+                if not isinstance(raw_block, dict):
+                    continue
+
+                block = dict(raw_block)
+                if block.get("type") == "tool_use":
+                    tool_use_id = str(block.get("id") or "")
+                    if tool_use_id and tool_use_id not in tool_id_map:
+                        tool_id_map[tool_use_id] = self.project_tool_call_id(tool_use_id, used_tool_call_ids)
+                        used_tool_call_ids.add(tool_id_map[tool_use_id])
+                    if tool_use_id:
+                        block["id"] = tool_id_map[tool_use_id]
+                elif block.get("type") == "tool_result":
+                    tool_use_id = str(block.get("tool_use_id") or "")
+                    if tool_use_id in tool_id_map:
+                        block["tool_use_id"] = tool_id_map[tool_use_id]
+
+                projected_blocks.append(block)
+
+            projected_message = dict(message)
+            projected_message["content"] = projected_blocks
+            prepared_messages.append(projected_message)
+
+        return prepared_messages
+
+    def project_tool_call_id(self, tool_call_id: str, used_tool_call_ids: set[str]) -> str:
+        """Project one canonical tool call ID into a provider-safe ID.
+
+        Most providers accept canonical tool IDs as-is. Adapters can override
+        this when the upstream protocol restricts character sets or length, as
+        long as the returned ID stays unique within the projected request.
+        """
+
+        return tool_call_id
+
+    def api_key_from_env(self) -> str | None:
+        for env_name in self.env_api_key_names:
+            value = os.environ.get(env_name)
+            if value:
+                return value
+        return None
+
+    def require_api_key(self, api_key: str | None) -> str:
+        resolved = (api_key or "").strip() or self.api_key_from_env() or ""
+        if resolved:
+            return resolved
+
+        checked = ", ".join(self.env_api_key_names) or "<api key env>"
+        raise ValueError(f"missing API key for provider {self.provider_id}; checked: {checked}")
+
+    def resolve_base_url(self, api_base: str | None) -> str | None:
+        base = (api_base or self.default_base_url or "").strip()
+        return base.rstrip("/") or None
+
+
+def repair_messages_for_replay(
+    source_messages: list[ConversationMessage],
+    *,
+    supports_image_input: bool,
+) -> list[ConversationMessage]:
+    """Return a minimal replay-safe transcript from canonical session history.
+
+    This keeps only replayable blocks, removes duplicate or orphaned tool
+    records, and inserts synthetic error tool results when a tool call was left
+    open by an interrupted turn.
+    """
+
+    replay_messages: list[ConversationMessage] = []
+    emitted_tool_use_ids: set[str] = set()
+    emitted_tool_result_ids: set[str] = set()
+    open_tool_use_ids: list[str] = []
+
+    for message in source_messages:
+        role = str(message.get("role") or "")
+
+        if role == "assistant":
+            if open_tool_use_ids:
+                replay_messages.append(_interrupted_tool_result_message(open_tool_use_ids))
+                emitted_tool_result_ids.update(open_tool_use_ids)
+                open_tool_use_ids = []
+
+            raw_meta = message.get("meta")
+            stop_reason = str((raw_meta or {}).get("stop_reason") or "") if isinstance(raw_meta, dict) else ""
+            if stop_reason in {"error", "aborted", "cancelled"}:
+                continue
+
+            content: list[dict[str, Any]] = []
+            current_tool_use_ids: list[str] = []
+            for raw_block in message.get("content") or []:
+                if not isinstance(raw_block, dict):
+                    continue
+                block_type = raw_block.get("type")
+                if block_type in {"text", "thinking"}:
+                    text = str(raw_block.get("text") or "")
+                    if text:
+                        content.append(dict(raw_block))
+                    continue
+
+                if block_type != "tool_use":
+                    continue
+
+                tool_use_id = str(raw_block.get("id") or "")
+                if not tool_use_id or tool_use_id in emitted_tool_use_ids:
+                    continue
+
+                emitted_tool_use_ids.add(tool_use_id)
+                current_tool_use_ids.append(tool_use_id)
+                content.append(dict(raw_block))
+
+            if not content:
+                continue
+
+            replay_message = dict(message)
+            replay_message["content"] = content
+            if isinstance(raw_meta, dict):
+                replay_message["meta"] = dict(raw_meta)
+            replay_messages.append(replay_message)
+            open_tool_use_ids = current_tool_use_ids
+            continue
+
+        if role != "user":
+            continue
+
+        content = []
+        resolved_tool_use_ids: set[str] = set()
+        has_user_input = False
+
+        for raw_block in message.get("content") or []:
+            if not isinstance(raw_block, dict):
+                continue
+
+            block_type = raw_block.get("type")
+            if block_type == "text":
+                text = str(raw_block.get("text") or "")
+                if text:
+                    has_user_input = True
+                    content.append(dict(raw_block))
+                continue
+
+            if block_type == "image":
+                if supports_image_input:
+                    has_user_input = True
+                    content.append(dict(raw_block))
+                continue
+
+            if block_type != "tool_result":
+                continue
+
+            tool_use_id = str(raw_block.get("tool_use_id") or "")
+            if not tool_use_id or tool_use_id not in emitted_tool_use_ids or tool_use_id in emitted_tool_result_ids:
+                continue
+
+            block = dict(raw_block)
+            raw_content = block.get("content")
+            if not supports_image_input and isinstance(raw_content, list):
+                filtered_content = [
+                    dict(item) for item in raw_content if isinstance(item, dict) and item.get("type") != "image"
+                ]
+                if filtered_content:
+                    block["content"] = filtered_content
+                else:
+                    block.pop("content", None)
+
+            content.append(block)
+            resolved_tool_use_ids.add(tool_use_id)
+            emitted_tool_result_ids.add(tool_use_id)
+
+        if has_user_input and open_tool_use_ids:
+            missing_tool_use_ids = [
+                tool_use_id for tool_use_id in open_tool_use_ids if tool_use_id not in resolved_tool_use_ids
+            ]
+            if missing_tool_use_ids:
+                replay_messages.append(_interrupted_tool_result_message(missing_tool_use_ids))
+                emitted_tool_result_ids.update(missing_tool_use_ids)
+            open_tool_use_ids = []
+
+        elif open_tool_use_ids:
+            open_tool_use_ids = [
+                tool_use_id for tool_use_id in open_tool_use_ids if tool_use_id not in resolved_tool_use_ids
+            ]
+
+        if not content:
+            if replay_messages and replay_messages[-1].get("role") == "assistant":
+                # Keep a valid replay transcript when a corrupted user turn is
+                # reduced to nothing after cleanup.
+                replay_messages.append(
+                    build_message(
+                        "user",
+                        [text_block("[User turn omitted during replay]")],
+                        meta={"synthetic": True},
+                    )
+                )
+            continue
+
+        replay_message = dict(message)
+        replay_message["content"] = content
+        if isinstance(message.get("meta"), dict):
+            replay_message["meta"] = dict(message["meta"])
+        replay_messages.append(replay_message)
+
+    if open_tool_use_ids:
+        replay_messages.append(_interrupted_tool_result_message(open_tool_use_ids))
+
+    return replay_messages
+
+
+def _interrupted_tool_result_message(tool_use_ids: list[str]) -> ConversationMessage:
+    """Return one synthetic user message that closes interrupted tool calls."""
+
+    return build_message(
+        "user",
+        [
+            tool_result_block(
+                tool_use_id=tool_use_id,
+                model_text="error: tool call was interrupted",
+                display_text="Tool call was interrupted",
+                is_error=True,
+            )
+            for tool_use_id in tool_use_ids
+        ],
+    )
+
+
+def load_image_block_payload(block: dict[str, Any]) -> tuple[str, str]:
+    """Return (mime_type, base64_data) for one canonical image block."""
+
+    mime_type = block.get("mime_type")
+    if not isinstance(mime_type, str) or not mime_type:
+        raise ValueError("image block is missing mime_type")
+
+    data = block.get("data")
+    if not isinstance(data, str) or not data:
+        raise ValueError("image block is missing data")
+
+    return mime_type, data
+
+
+def tool_result_content_blocks(block: dict[str, Any]) -> list[dict[str, Any]]:
+    """Return structured tool-result content, falling back to one text block."""
+
+    raw_content = block.get("content")
+    if isinstance(raw_content, list):
+        structured = [dict(item) for item in raw_content if isinstance(item, dict)]
+        if structured:
+            return structured
+    return [text_block(str(block.get("model_text") or ""))]

mycode/core/providers/gemini.py

@@ -0,0 +1,321 @@
+"""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.core.messages import assistant_message, text_block, thinking_block, tool_use_block
+from mycode.core.providers.base import (
+    DEFAULT_REQUEST_TIMEOUT,
+    ProviderAdapter,
+    ProviderRequest,
+    ProviderStreamEvent,
+    get_native_meta,
+    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
+        return types.HttpOptions(base_url=base_url, api_version=api_version, timeout=int(DEFAULT_REQUEST_TIMEOUT))
+
+    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: list[dict[str, Any]] = []
+            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 != "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 = None
+        tool_config = None
+        automatic_function_calling = 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
+                    ]
+                )
+            ]
+            automatic_function_calling = types.AutomaticFunctionCallingConfig(disable=True)
+            tool_config = types.ToolConfig(
+                function_calling_config=types.FunctionCallingConfig(stream_function_call_arguments=False)
+            )
+
+        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,
+            tool_config=tool_config,
+            automatic_function_calling=automatic_function_calling,
+            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.
+            blocks.append(
+                thinking_block("", meta={"native": {"part": native_part}})
+                if bool(getattr(part, "thought", False))
+                else text_block("", meta={"native": {"part": native_part}})
+            )
+            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]
+
+        block = (
+            thinking_block(str(text), meta={"native": {"part": native_part}})
+            if is_thought
+            else text_block(str(text), meta={"native": {"part": native_part}})
+        )
+        blocks.append(block)
+        return [event]