multiroute 0.1.0__tar.gz

multiroute-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 multiroute
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

multiroute-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: multiroute
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=0.84.0
+Requires-Dist: google-genai>=0.1.0
+Requires-Dist: openai>=2.26.0
+Dynamic: license-file

multiroute-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "multiroute"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "anthropic>=0.84.0",
+    "google-genai>=0.1.0",
+    "openai>=2.26.0",
+]
+
+[tool.uv]
+dev-dependencies = [
+    "multiroute",
+    "httpx>=0.28.1",
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
+    "respx>=0.22.0",
+]
+
+[tool.uv.workspace]
+members = [
+    ".",
+]
+
+[tool.uv.sources]
+multiroute = { workspace = true }
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "src"
+]
+asyncio_mode = "auto"

multiroute-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

multiroute-0.1.0/src/multiroute/__init__.py

@@ -0,0 +1,5 @@
+from .google import Client as GoogleClient
+from .openai import OpenAI
+from .anthropic import Anthropic
+
+__all__ = ["GoogleClient", "OpenAI", "Anthropic"]

multiroute-0.1.0/src/multiroute/anthropic/__init__.py

@@ -0,0 +1,3 @@
+from .client import Anthropic, AsyncAnthropic
+
+__all__ = ["Anthropic", "AsyncAnthropic"]

multiroute-0.1.0/src/multiroute/anthropic/client.py

@@ -0,0 +1,374 @@
+import json
+import os
+from typing import Any, Dict
+
+import anthropic
+import httpx
+import openai
+from anthropic.resources.messages import AsyncMessages, Messages
+from anthropic.types import Message
+
+MULTIROUTE_BASE_URL = "https://api.multiroute.ai/v1"
+
+
+def _is_multiroute_error(e: Exception) -> bool:
+    if isinstance(e, (anthropic.APIConnectionError, openai.APIConnectionError)):
+        return True
+    if isinstance(
+        e, (anthropic.InternalServerError, openai.InternalServerError)
+    ):  # 5xx errors
+        return True
+    if isinstance(e, (anthropic.APITimeoutError, openai.APITimeoutError)):
+        return True
+    if isinstance(e, (anthropic.NotFoundError, openai.NotFoundError)):  # 404
+        return True
+    # Catch httpx generic errors that might happen when we bypass the client
+    if isinstance(e, httpx.RequestError):
+        return True
+    if isinstance(e, httpx.HTTPStatusError):
+        if e.response.status_code >= 500 or e.response.status_code == 404:
+            return True
+    return False
+
+
+_shared_openai_client = None
+_shared_async_openai_client = None
+
+
+def _get_shared_openai_client() -> openai.OpenAI:
+    global _shared_openai_client
+    if _shared_openai_client is None:
+        _shared_openai_client = openai.OpenAI(
+            base_url=MULTIROUTE_BASE_URL,
+            api_key=os.environ.get("MULTIROUTE_API_KEY") or "dummy",
+            max_retries=0,
+        )
+    return _shared_openai_client
+
+
+def _get_shared_async_openai_client() -> openai.AsyncOpenAI:
+    global _shared_async_openai_client
+    if _shared_async_openai_client is None:
+        _shared_async_openai_client = openai.AsyncOpenAI(
+            base_url=MULTIROUTE_BASE_URL,
+            api_key=os.environ.get("MULTIROUTE_API_KEY") or "dummy",
+            max_retries=0,
+        )
+    return _shared_async_openai_client
+
+
+def _anthropic_to_openai_request(kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    """Convert Anthropic messages request parameters to OpenAI chat/completions format."""
+    openai_req = {}
+    model = kwargs["model"]
+
+    # Model
+    if "model" in kwargs:
+        openai_req["model"] = model
+
+    # System prompt -> role: system
+    messages = []
+    if "system" in kwargs and kwargs["system"]:
+        # system could be string or list of text blocks
+        sys_content = kwargs["system"]
+        if isinstance(sys_content, list):
+            # simplify list of text blocks to a single string for openai
+            sys_text = "".join(b["text"] for b in sys_content if b["type"] == "text")
+            messages.append({"role": "system", "content": sys_text})
+        else:
+            messages.append({"role": "system", "content": sys_content})
+
+    # Messages
+    if "messages" in kwargs:
+        for msg in kwargs["messages"]:
+            # Basic mapping, complex content blocks might need deeper extraction
+            # Anthropic allows content to be string or list of blocks
+            content = msg["content"]
+            if isinstance(content, list):
+                # Convert anthropic text blocks to openai text content
+                openai_content = []
+                tool_calls = []
+                for block in content:
+                    # Handle both dictionaries and Anthropic Pydantic models
+                    b_type = (
+                        block.get("type")
+                        if isinstance(block, dict)
+                        else getattr(block, "type", None)
+                    )
+
+                    if b_type == "text":
+                        b_text = (
+                            block.get("text")
+                            if isinstance(block, dict)
+                            else getattr(block, "text", "")
+                        )
+                        openai_content.append({"type": "text", "text": b_text})
+                    elif b_type == "image":
+                        # Convert image block
+                        b_source = (
+                            block.get("source")
+                            if isinstance(block, dict)
+                            else getattr(block, "source", {})
+                        )
+                        b_mime = (
+                            b_source.get("media_type")
+                            if isinstance(b_source, dict)
+                            else getattr(b_source, "media_type", "")
+                        )
+                        b_data = (
+                            b_source.get("data")
+                            if isinstance(b_source, dict)
+                            else getattr(b_source, "data", "")
+                        )
+                        openai_content.append(
+                            {
+                                "type": "image_url",
+                                "image_url": {"url": f"data:{b_mime};base64,{b_data}"},
+                            }
+                        )
+                    elif b_type == "tool_use":
+                        # Assistant turn with tool call
+                        b_id = (
+                            block.get("id")
+                            if isinstance(block, dict)
+                            else getattr(block, "id", "")
+                        )
+                        b_name = (
+                            block.get("name")
+                            if isinstance(block, dict)
+                            else getattr(block, "name", "")
+                        )
+                        b_input = (
+                            block.get("input")
+                            if isinstance(block, dict)
+                            else getattr(block, "input", {})
+                        )
+                        tool_calls.append(
+                            {
+                                "id": b_id,
+                                "type": "function",
+                                "function": {
+                                    "name": b_name,
+                                    "arguments": json.dumps(b_input),
+                                },
+                            }
+                        )
+                    elif b_type == "tool_result":
+                        # Tool result back to model
+                        b_id = (
+                            block.get("tool_use_id")
+                            if isinstance(block, dict)
+                            else getattr(block, "tool_use_id", "")
+                        )
+                        b_content = (
+                            block.get("content", "")
+                            if isinstance(block, dict)
+                            else getattr(block, "content", "")
+                        )
+                        messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": b_id,
+                                "content": str(b_content),
+                            }
+                        )
+                        continue  # Skip appending to current role's content
+
+                if tool_calls:
+                    # OpenAI assistant message with tool_calls
+                    msg_obj = {"role": "assistant", "tool_calls": tool_calls}
+                    # If there's text content, OpenAI allows it alongside tool_calls
+                    # but it must be a string or a list of content parts.
+                    if openai_content:
+                        # Anthropic text blocks were already converted to OpenAI parts format
+                        msg_obj["content"] = (
+                            openai_content[0]["text"]
+                            if len(openai_content) == 1
+                            else openai_content
+                        )
+                    else:
+                        # OpenAI requires 'content' to be present (can be null) even if tool_calls are present
+                        msg_obj["content"] = None
+                    messages.append(msg_obj)
+                elif openai_content:
+                    # If this message ONLY contained tool_result blocks (which were already handled above)
+                    # and no text/image blocks, we don't want to append an empty user message.
+                    # But if there are content parts, append them.
+                    messages.append({"role": msg["role"], "content": openai_content})
+                elif (
+                    not tool_calls
+                    and not openai_content
+                    and any(m["role"] == "tool" for m in messages)
+                ):
+                    # Special case: If this turn ONLY contained tool_result blocks,
+                    # those have already been appended to 'messages' as role: 'tool'.
+                    # We do NOT append anything else for this turn.
+                    pass
+                elif not tool_calls and not openai_content:
+                    # No content blocks at all (shouldn't happen in valid Anthropic requests)
+                    pass
+            else:
+                messages.append({"role": msg["role"], "content": content})
+
+    openai_req["messages"] = messages
+
+    if "tools" in kwargs:
+        openai_tools = []
+        for tool in kwargs["tools"]:
+            openai_tools.append(
+                {
+                    "type": "function",
+                    "function": {
+                        "name": tool["name"],
+                        "description": tool.get("description", ""),
+                        "parameters": tool.get("input_schema", {}),
+                    },
+                }
+            )
+        openai_req["tools"] = openai_tools
+
+    if "tool_choice" in kwargs:
+        tc = kwargs["tool_choice"]
+        if tc.get("type") == "auto":
+            openai_req["tool_choice"] = "auto"
+        elif tc.get("type") == "any":
+            openai_req["tool_choice"] = "required"
+        elif tc.get("type") == "tool":
+            openai_req["tool_choice"] = {
+                "type": "function",
+                "function": {"name": tc["name"]},
+            }
+
+    if "max_tokens" in kwargs:
+        openai_req["max_tokens"] = kwargs["max_tokens"]
+    if "temperature" in kwargs:
+        openai_req["temperature"] = kwargs["temperature"]
+    if "top_p" in kwargs:
+        openai_req["top_p"] = kwargs["top_p"]
+    if "stop_sequences" in kwargs:
+        openai_req["stop"] = kwargs["stop_sequences"]
+
+    return openai_req
+
+
+def _openai_to_anthropic_response(openai_resp: Dict[str, Any]) -> Message:
+    """Convert OpenAI chat/completions response to Anthropic Message type."""
+    choice = openai_resp.get("choices", [{}])[0]
+    message_data = choice.get("message", {})
+
+    # Map finish reason
+    finish_reason = choice.get("finish_reason")
+    stop_reason = "end_turn"
+    if finish_reason == "length":
+        stop_reason = "max_tokens"
+    elif finish_reason == "tool_calls":
+        stop_reason = "tool_use"
+    elif finish_reason == "stop":
+        stop_reason = "end_turn"
+
+    # Content
+    content = message_data.get("content", "")
+    content_blocks = [{"type": "text", "text": content}] if content else []
+
+    # Tool calls
+    tool_calls = message_data.get("tool_calls", [])
+    if tool_calls:
+        for tc in tool_calls:
+            # Safely parse arguments, they might be string or dict
+            try:
+                args = tc["function"]["arguments"]
+                if isinstance(args, str):
+                    args = json.loads(args)
+            except (json.JSONDecodeError, KeyError, TypeError):
+                args = {}
+
+            content_blocks.append(
+                {
+                    "type": "tool_use",
+                    "id": tc.get("id", ""),
+                    "name": tc["function"]["name"],
+                    "input": args,
+                }
+            )
+
+    # Usage
+    usage_data = openai_resp.get("usage", {})
+
+    # Create the dictionary structure expected by Anthropic models
+    msg_dict = {
+        "id": openai_resp.get("id", ""),
+        "type": "message",
+        "role": "assistant",
+        "content": content_blocks,
+        "model": openai_resp.get("model", ""),
+        "stop_reason": stop_reason,
+        "stop_sequence": None,
+        "usage": {
+            "input_tokens": usage_data.get("prompt_tokens", 0),
+            "output_tokens": usage_data.get("completion_tokens", 0),
+        },
+    }
+
+    return Message.construct(**msg_dict)
+
+
+class MultirouteMessages(Messages):
+    def create(self, **kwargs) -> Message:
+        if not os.environ.get("MULTIROUTE_API_KEY"):
+            return super().create(**kwargs)
+
+        # Save original API URL and client behavior
+        original_base_url = self._client.base_url
+
+        try:
+            openai_req = _anthropic_to_openai_request(kwargs)
+
+            client = _get_shared_openai_client().with_options(
+                api_key=os.environ.get("MULTIROUTE_API_KEY"),
+                timeout=self._client.timeout,
+            )
+            openai_resp_obj = client.chat.completions.create(**openai_req)
+
+            openai_resp = openai_resp_obj.model_dump()
+            return _openai_to_anthropic_response(openai_resp)
+        except Exception as e:
+            if _is_multiroute_error(e):
+                # Fallback to the real anthropic create using original parameters
+                return super().create(**kwargs)
+            raise
+
+
+class AsyncMultirouteMessages(AsyncMessages):
+    async def create(self, **kwargs) -> Message:
+        if not os.environ.get("MULTIROUTE_API_KEY"):
+            return await super().create(**kwargs)
+
+        original_base_url = self._client.base_url
+
+        try:
+            openai_req = _anthropic_to_openai_request(kwargs)
+
+            client = _get_shared_async_openai_client().with_options(
+                api_key=os.environ.get("MULTIROUTE_API_KEY"),
+                timeout=self._client.timeout,
+            )
+            openai_resp_obj = await client.chat.completions.create(**openai_req)
+
+            openai_resp = openai_resp_obj.model_dump()
+            return _openai_to_anthropic_response(openai_resp)
+        except Exception as e:
+            if _is_multiroute_error(e):
+                return await super().create(**kwargs)
+            raise
+
+
+class Anthropic(anthropic.Anthropic):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.messages = MultirouteMessages(self)
+
+
+class AsyncAnthropic(anthropic.AsyncAnthropic):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.messages = AsyncMultirouteMessages(self)

multiroute-0.1.0/src/multiroute/google/__init__.py

@@ -0,0 +1,3 @@
+from .client import Client
+
+__all__ = ["Client"]

multiroute-0.1.0/src/multiroute/google/client.py

@@ -0,0 +1,487 @@
+import json
+import os
+from typing import Any, Dict
+
+import google.genai as genai
+import httpx
+import openai
+from google.genai import types
+from google.genai._transformers import t_tools
+from google.genai.types import FinishReason, GenerateContentResponseUsageMetadata
+
+MULTIROUTE_BASE_URL = "https://api.multiroute.ai/v1"
+
+
+def _is_multiroute_error(e: Exception) -> bool:
+    if isinstance(
+        e,
+        (
+            openai.APIConnectionError,
+            openai.InternalServerError,
+            openai.APITimeoutError,
+            openai.NotFoundError,
+        ),
+    ):
+        return True
+    if isinstance(e, httpx.RequestError):
+        return True
+    if isinstance(e, httpx.HTTPStatusError):
+        if e.response.status_code >= 500 or e.response.status_code == 404:
+            return True
+    if "google.genai.errors.APIError" in str(type(e)):
+        return True
+    return False
+
+
+_shared_openai_client = None
+_shared_async_openai_client = None
+
+
+def _get_shared_openai_client() -> openai.OpenAI:
+    global _shared_openai_client
+    if _shared_openai_client is None:
+        _shared_openai_client = openai.OpenAI(
+            base_url=MULTIROUTE_BASE_URL,
+            api_key=os.environ.get("MULTIROUTE_API_KEY") or "dummy",
+            max_retries=0,
+        )
+    return _shared_openai_client
+
+
+def _get_shared_async_openai_client() -> openai.AsyncOpenAI:
+    global _shared_async_openai_client
+    if _shared_async_openai_client is None:
+        _shared_async_openai_client = openai.AsyncOpenAI(
+            base_url=MULTIROUTE_BASE_URL,
+            api_key=os.environ.get("MULTIROUTE_API_KEY") or "dummy",
+            max_retries=0,
+        )
+    return _shared_async_openai_client
+
+
+def _lower_dict_types(d: Any) -> Any:
+    """Helper to convert Google's UPPERCASE types to OpenAI's lowercase types."""
+    if not isinstance(d, dict):
+        return d
+    res = {}
+    for k, v in d.items():
+        if k == "type" and isinstance(v, str):
+            res[k] = v.lower()
+        elif isinstance(v, dict):
+            res[k] = _lower_dict_types(v)
+        elif isinstance(v, list):
+            res[k] = [
+                _lower_dict_types(item) if isinstance(item, dict) else item
+                for item in v
+            ]
+        else:
+            res[k] = v
+    return res
+
+
+def _schema_to_dict(schema: Any) -> Dict[str, Any]:
+    if not schema:
+        return {}
+    d = {}
+    if hasattr(schema, "type"):
+        d["type"] = schema.type.value if hasattr(schema.type, "value") else schema.type
+    if hasattr(schema, "description") and schema.description:
+        d["description"] = schema.description
+    if hasattr(schema, "properties") and schema.properties:
+        d["properties"] = {k: _schema_to_dict(v) for k, v in schema.properties.items()}
+    if hasattr(schema, "required") and schema.required:
+        d["required"] = schema.required
+    if hasattr(schema, "items") and schema.items:
+        d["items"] = _schema_to_dict(schema.items)
+    return d
+
+
+def _google_to_openai_request(
+    model: str, contents: Any, config: Any = None, client: Any = None
+) -> Dict[str, Any]:
+    messages = []
+
+    if isinstance(contents, str):
+        messages.append({"role": "user", "content": contents})
+    elif isinstance(contents, list):
+        for item in contents:
+            if isinstance(item, str):
+                messages.append({"role": "user", "content": item})
+            elif hasattr(item, "role") and hasattr(item, "parts"):
+                # types.Content object
+                role = "user" if item.role == "user" else "assistant"
+                content_text = ""
+                has_function_call = False
+                has_function_response = False
+                for part in item.parts:
+                    if hasattr(part, "function_call") and part.function_call:
+                        fc = part.function_call
+                        name = getattr(fc, "name", "")
+                        args = getattr(fc, "args", {})
+                        messages.append(
+                            {
+                                "role": "assistant",
+                                "tool_calls": [
+                                    {
+                                        "id": name,
+                                        "type": "function",
+                                        "function": {
+                                            "name": name,
+                                            "arguments": json.dumps(args),
+                                        },
+                                    }
+                                ],
+                            }
+                        )
+                        has_function_call = True
+                    elif hasattr(part, "function_response") and part.function_response:
+                        fr = part.function_response
+                        name = getattr(fr, "name", "")
+                        resp = getattr(fr, "response", {})
+                        messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": name,
+                                "content": json.dumps(resp),
+                            }
+                        )
+                        has_function_response = True
+                    elif hasattr(part, "text") and part.text:
+                        content_text += part.text
+                    elif isinstance(part, dict) and "text" in part:
+                        content_text += part["text"]
+
+                if not has_function_call and not has_function_response and content_text:
+                    messages.append({"role": role, "content": content_text})
+                elif content_text and has_function_call:
+                    messages[-1]["content"] = content_text
+            elif hasattr(item, "function_call") and item.function_call:
+                # Bare Part with function_call
+                fc = item.function_call
+                name = getattr(fc, "name", "")
+                args = getattr(fc, "args", {})
+                messages.append(
+                    {
+                        "role": "assistant",
+                        "tool_calls": [
+                            {
+                                "id": name,
+                                "type": "function",
+                                "function": {
+                                    "name": name,
+                                    "arguments": json.dumps(args),
+                                },
+                            }
+                        ],
+                    }
+                )
+            elif hasattr(item, "function_response") and item.function_response:
+                # Bare Part with function_response
+                fr = item.function_response
+                name = getattr(fr, "name", "")
+                resp = getattr(fr, "response", {})
+                messages.append(
+                    {"role": "tool", "tool_call_id": name, "content": json.dumps(resp)}
+                )
+            elif hasattr(item, "text") and item.text:
+                messages.append({"role": "user", "content": item.text})
+            elif isinstance(item, dict):
+                role = item.get("role", "user")
+                role = "user" if role == "user" else "assistant"
+                parts = item.get("parts", [])
+                content_text = ""
+                has_function_response = False
+                has_function_call = False
+                for p in parts:
+                    if isinstance(p, dict):
+                        if "functionCall" in p or "function_call" in p:
+                            fc = p.get("functionCall") or p.get("function_call")
+                            name = (
+                                fc.get("name")
+                                if isinstance(fc, dict)
+                                else getattr(fc, "name", "")
+                            )
+                            args = (
+                                fc.get("args")
+                                if isinstance(fc, dict)
+                                else getattr(fc, "args", {})
+                            )
+                            messages.append(
+                                {
+                                    "role": "assistant",
+                                    "tool_calls": [
+                                        {
+                                            "id": name,
+                                            "type": "function",
+                                            "function": {
+                                                "name": name,
+                                                "arguments": json.dumps(args),
+                                            },
+                                        }
+                                    ],
+                                }
+                            )
+                            has_function_call = True
+                        elif "functionResponse" in p or "function_response" in p:
+                            fr = p.get("functionResponse") or p.get("function_response")
+                            name = (
+                                fr.get("name")
+                                if isinstance(fr, dict)
+                                else getattr(fr, "name", "")
+                            )
+                            resp = (
+                                fr.get("response")
+                                if isinstance(fr, dict)
+                                else getattr(fr, "response", {})
+                            )
+                            messages.append(
+                                {
+                                    "role": "tool",
+                                    "tool_call_id": name,  # OpenAI requires an ID, Google usually uses name
+                                    "content": json.dumps(resp),
+                                }
+                            )
+                            has_function_response = True
+                        elif "text" in p:
+                            content_text += p["text"]
+                    elif hasattr(p, "function_call") and p.function_call:
+                        fc = p.function_call
+                        name = getattr(fc, "name", "")
+                        args = getattr(fc, "args", {})
+                        messages.append(
+                            {
+                                "role": "assistant",
+                                "tool_calls": [
+                                    {
+                                        "id": name,
+                                        "type": "function",
+                                        "function": {
+                                            "name": name,
+                                            "arguments": json.dumps(args),
+                                        },
+                                    }
+                                ],
+                            }
+                        )
+                        has_function_call = True
+                    elif hasattr(p, "function_response") and p.function_response:
+                        fr = p.function_response
+                        name = getattr(fr, "name", "")
+                        resp = getattr(fr, "response", {})
+                        messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": name,
+                                "content": json.dumps(resp),
+                            }
+                        )
+                        has_function_response = True
+                    elif hasattr(p, "text") and p.text:
+                        content_text += p.text
+
+                if not has_function_response and not has_function_call and content_text:
+                    messages.append({"role": role, "content": content_text})
+                elif content_text and has_function_call:
+                    # Assistant sent text AND tool call
+                    messages[-1]["content"] = content_text
+
+    openai_req = {"model": model, "messages": messages}
+
+    if config:
+        if isinstance(config, dict):
+            if "temperature" in config:
+                openai_req["temperature"] = config["temperature"]
+            if "top_p" in config:
+                openai_req["top_p"] = config["top_p"]
+            if "max_output_tokens" in config:
+                openai_req["max_tokens"] = config["max_output_tokens"]
+            if "stop_sequences" in config:
+                openai_req["stop"] = config["stop_sequences"]
+        else:
+            if hasattr(config, "temperature") and config.temperature is not None:
+                openai_req["temperature"] = config.temperature
+            if hasattr(config, "top_p") and config.top_p is not None:
+                openai_req["top_p"] = config.top_p
+            if (
+                hasattr(config, "max_output_tokens")
+                and config.max_output_tokens is not None
+            ):
+                openai_req["max_tokens"] = config.max_output_tokens
+            if hasattr(config, "stop_sequences") and config.stop_sequences is not None:
+                openai_req["stop"] = config.stop_sequences
+
+            if hasattr(config, "tools") and config.tools:
+                tools = config.tools
+                if client and hasattr(client, "_api_client"):
+                    # Use Google's internal transformer if we have a client instance
+                    try:
+                        g_tools = t_tools(client._api_client, tools)
+                        openai_tools = []
+                        for t in g_tools:
+                            if (
+                                hasattr(t, "function_declarations")
+                                and t.function_declarations
+                            ):
+                                for fd in t.function_declarations:
+                                    # Convert schema to dict and lowercase the types
+                                    params_dict = _schema_to_dict(fd.parameters)
+                                    params_dict = _lower_dict_types(params_dict)
+
+                                    openai_tools.append(
+                                        {
+                                            "type": "function",
+                                            "function": {
+                                                "name": fd.name,
+                                                "description": fd.description or "",
+                                                "parameters": params_dict,
+                                            },
+                                        }
+                                    )
+                        if openai_tools:
+                            openai_req["tools"] = openai_tools
+                    except Exception:
+                        pass  # Silently drop tools if conversion fails, let backend handle if possible
+
+    return openai_req
+
+
+def _openai_to_google_response(
+    openai_resp: Dict[str, Any], model: str
+) -> types.GenerateContentResponse:
+    choice = openai_resp.get("choices", [{}])[0]
+    message_data = choice.get("message", {})
+    content = message_data.get("content", "")
+
+    usage_data = openai_resp.get("usage", {})
+
+    parts = []
+    if content:
+        parts.append(types.Part(text=content))
+
+    tool_calls = message_data.get("tool_calls", [])
+    if tool_calls:
+        for tc in tool_calls:
+            try:
+                args = tc["function"]["arguments"]
+                if isinstance(args, str):
+                    args = json.loads(args)
+            except (json.JSONDecodeError, KeyError, TypeError):
+                args = {}
+
+            parts.append(
+                types.Part(
+                    function_call=types.FunctionCall(
+                        name=tc["function"]["name"], args=args
+                    )
+                )
+            )
+
+    finish_reason_str = choice.get("finish_reason")
+    if finish_reason_str == "stop":
+        finish_reason = FinishReason.STOP
+    elif finish_reason_str == "length":
+        finish_reason = FinishReason.MAX_TOKENS
+    elif finish_reason_str == "tool_calls":
+        finish_reason = FinishReason.STOP
+    else:
+        finish_reason = FinishReason.OTHER
+
+    candidate = types.Candidate(
+        content=types.Content(role="model", parts=parts),
+        finish_reason=finish_reason,
+    )
+
+    response = types.GenerateContentResponse(
+        candidates=[candidate],
+        usage_metadata=GenerateContentResponseUsageMetadata(
+            prompt_token_count=usage_data.get("prompt_tokens", 0),
+            candidates_token_count=usage_data.get("completion_tokens", 0),
+            total_token_count=usage_data.get("total_tokens", 0),
+        ),
+        model_version=model,
+    )
+    return response
+
+
+class MultirouteModels:
+    def __init__(self, client: genai.Client, original_method):
+        self._client = client
+        self._original_generate_content = original_method
+
+    def generate_content(
+        self, model: str, contents: Any, config: Any = None, **kwargs
+    ) -> types.GenerateContentResponse:
+        if not os.environ.get("MULTIROUTE_API_KEY"):
+            return self._original_generate_content(
+                model=model, contents=contents, config=config, **kwargs
+            )
+
+        try:
+            openai_req = _google_to_openai_request(
+                model, contents, config, self._client
+            )
+
+            client = _get_shared_openai_client().with_options(
+                api_key=os.environ.get("MULTIROUTE_API_KEY"),
+                timeout=kwargs.get("timeout", 60),
+            )
+            openai_resp_obj = client.chat.completions.create(**openai_req)
+
+            openai_resp = openai_resp_obj.model_dump()
+            return _openai_to_google_response(openai_resp, model)
+        except Exception as e:
+            if _is_multiroute_error(e):
+                return self._original_generate_content(
+                    model=model, contents=contents, config=config, **kwargs
+                )
+            raise
+
+
+class AsyncMultirouteModels:
+    def __init__(self, client: genai.Client, original_method):
+        self._client = client
+        self._original_generate_content = original_method
+
+    async def generate_content(
+        self, model: str, contents: Any, config: Any = None, **kwargs
+    ) -> types.GenerateContentResponse:
+        if not os.environ.get("MULTIROUTE_API_KEY"):
+            return await self._original_generate_content(
+                model=model, contents=contents, config=config, **kwargs
+            )
+
+        try:
+            openai_req = _google_to_openai_request(
+                model, contents, config, self._client
+            )
+
+            client = _get_shared_async_openai_client().with_options(
+                api_key=os.environ.get("MULTIROUTE_API_KEY"),
+                timeout=kwargs.get("timeout", 60),
+            )
+            openai_resp_obj = await client.chat.completions.create(**openai_req)
+
+            openai_resp = openai_resp_obj.model_dump()
+            return _openai_to_google_response(openai_resp, model)
+        except Exception as e:
+            if _is_multiroute_error(e):
+                return await self._original_generate_content(
+                    model=model, contents=contents, config=config, **kwargs
+                )
+            raise
+
+
+class Client(genai.Client):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Save original methods and override
+        self._multiroute_models = MultirouteModels(self, self.models.generate_content)
+        self.models.generate_content = self._multiroute_models.generate_content
+
+        if hasattr(self, "aio") and hasattr(self.aio, "models"):
+            self._async_multiroute_models = AsyncMultirouteModels(
+                self, self.aio.models.generate_content
+            )
+            self.aio.models.generate_content = (
+                self._async_multiroute_models.generate_content
+            )

multiroute-0.1.0/src/multiroute/openai/__init__.py

@@ -0,0 +1,3 @@
+from .client import OpenAI, AsyncOpenAI
+
+__all__ = ["OpenAI", "AsyncOpenAI"]

multiroute-0.1.0/src/multiroute/openai/client.py

@@ -0,0 +1,113 @@
+import os
+from typing import Any
+
+import openai
+from openai.resources.chat.completions import (
+    AsyncCompletions as AsyncChatCompletions,
+)
+from openai.resources.chat.completions import (
+    Completions as ChatCompletions,
+)
+from openai.resources.responses import AsyncResponses, Responses
+
+MULTIROUTE_BASE_URL = "https://api.multiroute.ai/v1"
+
+
+def _is_multiroute_error(e: Exception) -> bool:
+    if isinstance(e, openai.APIConnectionError):
+        return True
+    if isinstance(e, openai.InternalServerError):  # 5xx errors
+        return True
+    if isinstance(e, openai.APITimeoutError):
+        return True
+    if isinstance(
+        e, openai.NotFoundError
+    ):  # 404 - useful if endpoint or model is missing on proxy
+        return True
+    return False
+
+
+class MultirouteChatCompletions(ChatCompletions):
+    def create(self, **kwargs) -> Any:
+        if not os.environ.get("MULTIROUTE_API_KEY"):
+            return super().create(**kwargs)
+
+        # Safely create a temporary client sharing the connection pool
+        temp_client = self._client.with_options(
+            base_url=MULTIROUTE_BASE_URL, api_key=os.environ.get("MULTIROUTE_API_KEY")
+        )
+
+        try:
+            # Bypass the overridden create and call the original ChatCompletions directly
+            return ChatCompletions(temp_client).create(**kwargs)
+        except Exception as e:
+            if _is_multiroute_error(e):
+                # Fallback to original
+                return super().create(**kwargs)
+            raise
+
+
+class AsyncMultirouteChatCompletions(AsyncChatCompletions):
+    async def create(self, **kwargs) -> Any:
+        if not os.environ.get("MULTIROUTE_API_KEY"):
+            return await super().create(**kwargs)
+
+        temp_client = self._client.with_options(
+            base_url=MULTIROUTE_BASE_URL, api_key=os.environ.get("MULTIROUTE_API_KEY")
+        )
+
+        try:
+            return await AsyncChatCompletions(temp_client).create(**kwargs)
+        except Exception as e:
+            if _is_multiroute_error(e):
+                return await super().create(**kwargs)
+            raise
+
+
+class MultirouteResponses(Responses):
+    def create(self, **kwargs) -> Any:
+        if not os.environ.get("MULTIROUTE_API_KEY"):
+            return super().create(**kwargs)
+
+        temp_client = self._client.with_options(
+            base_url=MULTIROUTE_BASE_URL, api_key=os.environ.get("MULTIROUTE_API_KEY")
+        )
+
+        try:
+            return Responses(temp_client).create(**kwargs)
+        except Exception as e:
+            if _is_multiroute_error(e):
+                return super().create(**kwargs)
+            raise
+
+
+class AsyncMultirouteResponses(AsyncResponses):
+    async def create(self, **kwargs) -> Any:
+        if not os.environ.get("MULTIROUTE_API_KEY"):
+            return await super().create(**kwargs)
+
+        temp_client = self._client.with_options(
+            base_url=MULTIROUTE_BASE_URL, api_key=os.environ.get("MULTIROUTE_API_KEY")
+        )
+
+        try:
+            return await AsyncResponses(temp_client).create(**kwargs)
+        except Exception as e:
+            if _is_multiroute_error(e):
+                return await super().create(**kwargs)
+            raise
+
+
+class OpenAI(openai.OpenAI):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Override the chat completions and responses resources with our wrappers
+        self.chat.completions = MultirouteChatCompletions(self)
+        self.responses = MultirouteResponses(self)
+
+
+class AsyncOpenAI(openai.AsyncOpenAI):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.chat.completions = AsyncMultirouteChatCompletions(self)
+        self.responses = AsyncMultirouteResponses(self)

multiroute-0.1.0/src/multiroute.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: multiroute
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=0.84.0
+Requires-Dist: google-genai>=0.1.0
+Requires-Dist: openai>=2.26.0
+Dynamic: license-file

multiroute-0.1.0/src/multiroute.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/multiroute/__init__.py
+src/multiroute.egg-info/PKG-INFO
+src/multiroute.egg-info/SOURCES.txt
+src/multiroute.egg-info/dependency_links.txt
+src/multiroute.egg-info/requires.txt
+src/multiroute.egg-info/top_level.txt
+src/multiroute/anthropic/__init__.py
+src/multiroute/anthropic/client.py
+src/multiroute/google/__init__.py
+src/multiroute/google/client.py
+src/multiroute/openai/__init__.py
+src/multiroute/openai/client.py

multiroute-0.1.0/src/multiroute.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

multiroute-0.1.0/src/multiroute.egg-info/requires.txt

@@ -0,0 +1,3 @@
+anthropic>=0.84.0
+google-genai>=0.1.0
+openai>=2.26.0

multiroute-0.1.0/src/multiroute.egg-info/top_level.txt

@@ -0,0 +1 @@
+multiroute