add completion_image_pricing to Pricing Model + hardcoded values for Gemini Image models

example.py

@@ -0,0 +1,37 @@
+import os
+
+import openai
+
+client = openai.OpenAI(
+    api_key=os.environ["CASHU_TOKEN"],
+    base_url=os.environ.get("ROUTSTR_API_URL", "https://api.routstr.com/v1"),
+    # base_url="http://roustrjfsdgfiueghsklchg.onion/v1",
+    # client=httpx.AsyncClient(
+    #     proxies={"http": "socks5://localhost:9050"},
+    # ),  # to use onion proxy (tor)
+)
+history: list = []
+
+
+def chat() -> None:
+    while True:
+        user_msg = {"role": "user", "content": input("\nYou: ")}
+        history.append(user_msg)
+        ai_msg = {"role": "assistant", "content": ""}
+
+        for chunk in client.chat.completions.create(
+            model=os.environ.get("MODEL", "openai/gpt-4o-mini"),
+            messages=history,
+            stream=True,
+        ):
+            if len(chunk.choices) > 0:
+                content = chunk.choices[0].delta.content
+                if content is not None:
+                    ai_msg["content"] += content
+                    print(content, end="", flush=True)
+        print()
+        history.append(ai_msg)
+
+
+if __name__ == "__main__":
+    chat()

examples/balance/check_balance.py

@@ -1,11 +0,0 @@
-import os
-
-import httpx
-
-# Use your Cashu token or API key as the Bearer token,
-# cashu token is hashed on the server and acts as an Temporary API key
-headers = {"Authorization": f"Bearer {os.environ.get('TOKEN')}"}
-base_url = os.environ.get("API_URL", "https://api.routstr.com/v1")
-
-resp = httpx.get(f"{base_url}/balance/info", headers=headers)
-print(resp.json())

examples/balance/create_balance.py

@@ -1,15 +0,0 @@
-import os
-
-import httpx
-
-# Send a Cashu token to the /create endpoint to get a persistent API key
-token = os.environ.get("TOKEN")
-if not token:
-    print("Please set TOKEN environment variable with a Cashu token")
-    exit(1)
-
-base_url = os.environ.get("API_URL", "https://api.routstr.com/v1")
-
-resp = httpx.get(f"{base_url}/balance/create", params={"initial_balance_token": token})
-
-print(resp.json())

examples/balance/refund_balance.py

@@ -1,12 +0,0 @@
-import os
-
-import httpx
-
-# Use your Cashu token or API key as the Bearer token
-headers = {"Authorization": f"Bearer {os.environ.get('TOKEN')}"}
-base_url = os.environ.get("API_URL", "https://api.routstr.com/v1")
-
-resp = httpx.post(f"{base_url}/balance/refund", headers=headers)
-
-print("Refund successful!")
-print(resp.json())

examples/balance/topup_balance.py

@@ -1,16 +0,0 @@
-import os
-
-import httpx
-
-# Use your Cashu token or API key as the Bearer token
-headers = {"Authorization": f"Bearer {os.environ.get('TOKEN')}"}
-base_url = os.environ.get("API_URL", "https://api.routstr.com/v1")
-
-# The Cashu token to top up with
-cashu_token = input("Enter Cashu token to top up: ")
-
-resp = httpx.post(
-    f"{base_url}/balance/topup", headers=headers, json={"cashu_token": cashu_token}
-)
-
-print(resp.json())

examples/chat_completions.py

@@ -1,15 +0,0 @@
-import os
-
-from openai import OpenAI
-
-client = OpenAI(
-    api_key=os.environ.get("TOKEN"),
-    base_url=os.environ.get("API_URL", "https://api.routstr.com/v1"),
-)
-
-response = client.chat.completions.create(
-    model=os.environ.get("MODEL", "gpt-5-nano"),
-    messages=[{"role": "user", "content": "Hello!"}],
-)
-
-print(response.choices[0].message.content)

examples/list_models.py

@@ -1,19 +0,0 @@
-import os
-
-import httpx
-from openai import OpenAI
-
-client = OpenAI(
-    api_key=os.environ.get("TOKEN", ""),
-    base_url=os.environ.get("API_URL", "https://api.routstr.com/v1"),
-)
-
-for model in client.models.list():
-    print(model.id)
-
-# OR
-
-models = httpx.get(
-    f"{client.base_url}/v1/models",
-    headers={"Authorization": f"Bearer {client.api_key}"},
-).json()

examples/responses/conversation.py

@@ -1,31 +0,0 @@
-import os
-
-from openai import OpenAI
-
-client = OpenAI(
-    api_key=os.environ.get("TOKEN"),
-    base_url=os.environ.get("API_URL", "https://api.routstr.com/v1"),
-)
-
-conversation = []  # type: ignore
-
-# First turn
-response1 = client.responses.create(  # type: ignore
-    model="o4-mini",
-    input="Hi, my name is Alice.",
-    conversation=conversation,
-)
-print("Response 1:", response1.output)
-
-# Note: The 'conversation' parameter might need to be constructed differently
-# depending on exact SDK/API spec. Typically, you pass back the previous turn's data.
-# Assuming the SDK manages or returns a conversation object/ID:
-# conversation.append(response1)
-
-# Second turn - demonstrating intent, actual implementation depends on strict API spec
-# response2 = client.responses.create(
-#     model="openai/gpt-4o-mini",
-#     input="What is my name?",
-#     conversation=conversation,
-# )
-# print("Response 2:", response2.output)

examples/responses/create.py

@@ -1,17 +0,0 @@
-import os
-
-from openai import OpenAI
-
-# The OpenAI SDK handles the 'responses' endpoint if it's updated to the latest version
-# and the base_url points to a compatible proxy like Routstr.
-client = OpenAI(
-    api_key=os.environ.get("TOKEN"),
-    base_url=os.environ.get("API_URL", "https://api.routstr.com/v1"),
-)
-
-response = client.responses.create(
-    model="gpt-5-mini",
-    input="Tell me a three sentence bedtime story about a unicorn.",
-)
-
-print(response.output)

examples/responses/streaming_response.py

@@ -1,20 +0,0 @@
-import os
-
-from openai import OpenAI
-
-client = OpenAI(
-    api_key=os.environ.get("TOKEN"),
-    base_url=os.environ.get("API_URL", "https://api.routstr.com/v1"),
-)
-
-stream = client.responses.create(
-    model="claude-4.5-sonnet",
-    input="Write a short poem about rust.",
-    stream=True,
-)
-
-for event in stream:
-    # Note: Depending on the SDK version and response structure,
-    # you might access event.output_delta or similar fields
-    print(event, end="", flush=True)
-print()

examples/responses/web_search.py

@@ -1,16 +0,0 @@
-import os
-
-from openai import OpenAI
-
-client = OpenAI(
-    api_key=os.environ.get("TOKEN"),
-    base_url=os.environ.get("API_URL", "https://api.routstr.com/v1"),
-)
-
-response = client.responses.create(
-    model="gpt-5-mini",
-    input="What is the latest news about AI?",
-    tools=[{"type": "web_search"}],  # type: ignore
-)
-
-print(response.output)

examples/streaming.py

@@ -1,28 +0,0 @@
-import os
-
-from openai import OpenAI
-
-client = OpenAI(
-    api_key=os.environ.get("TOKEN"),
-    base_url=os.environ.get("API_URL", "https://api.routstr.com/v1"),
-)
-
-messages = []
-while True:
-    messages.append({"role": "user", "content": input("\nYou: ")})
-
-    stream = client.chat.completions.create(
-        model=os.environ.get("MODEL", "gpt-5.1-mini"),
-        messages=messages,  # type: ignore
-        stream=True,
-    )
-
-    print("AI: ", end="")
-    response_content = ""
-    for chunk in stream:
-        if content := chunk.choices[0].delta.content:  # type: ignore
-            print(content, end="", flush=True)
-            response_content += content
-    print()
-
-    messages.append({"role": "assistant", "content": response_content})

examples/tor.py

@@ -1,20 +0,0 @@
-import os
-
-import httpx
-from openai import OpenAI
-
-# Requires `pip install "httpx[socks]"` and a running Tor proxy on port 9050
-client = OpenAI(
-    api_key=os.environ.get("TOKEN"),
-    base_url=os.environ.get("ONION_URL", "http://roustrjfsdgfiueghsklchg.onion/v1"),
-    http_client=httpx.Client(proxies="socks5://localhost:9050"),
-)
-
-print(
-    client.chat.completions.create(
-        model="openai/gpt-4o-mini",
-        messages=[{"role": "user", "content": "Hello from Tor!"}],
-    )
-    .choices[0]
-    .message.content
-)

pyproject.toml

@@ -73,7 +73,6 @@ packages = ["routstr"]
 [tool.ruff.lint]
 select = ["E", "F", "I"]
 ignore = ["E501"]
-exclude = ["examples"]
 
 [tool.mypy]
 python_version = "3.11"

routstr/payment/cost_calculation.py

@@ -5,7 +5,6 @@ from pydantic.v1 import BaseModel
 from ..core import get_logger
 from ..core.db import AsyncSession
 from ..core.settings import settings
-from .price import sats_usd_price
 
 logger = get_logger(__name__)
 
@@ -65,62 +64,13 @@ async def calculate_cost(  # todo: can be sync
         )
         return cost_data
 
-    usage_data = response_data["usage"]
-
-    usd_cost = 0.0
-
-    # Prioritize cost_details.upstream_inference_cost
-    if "cost_details" in usage_data:
-        usd_cost = float(
-            usage_data["cost_details"].get("upstream_inference_cost", 0) or 0
-        )
-
-    # Fallback to cost field if upstream_inference_cost is 0
-    if usd_cost == 0 and "cost" in usage_data:
-        try:
-            usd_cost = float(usage_data.get("cost", 0) or 0)
-        except Exception:
-            pass
-
-    if usd_cost > 0:
-        try:
-            sats_per_usd = 1.0 / sats_usd_price()
-            cost_in_sats = usd_cost * sats_per_usd
-            cost_in_msats = math.ceil(cost_in_sats * 1000)
-
-            logger.info(
-                "Using cost from usage data/details",
-                extra={
-                    "usd_cost": usd_cost,
-                    "cost_in_sats": cost_in_sats,
-                    "cost_in_msats": cost_in_msats,
-                    "model": response_data.get("model", "unknown"),
-                },
-            )
-
-            return CostData(
-                base_msats=-1,
-                input_msats=-1,  # Cost field doesn't break down by token type
-                output_msats=-1,
-                total_msats=cost_in_msats,
-            )
-        except Exception as e:
-            logger.warning(
-                "Error calculating cost from usage data",
-                extra={
-                    "error": str(e),
-                    "usd_cost": usd_cost,
-                    "model": response_data.get("model", "unknown"),
-                },
-            )
-            # Fall through to token-based calculation
-
     MSATS_PER_1K_INPUT_TOKENS: float = (
         float(settings.fixed_per_1k_input_tokens) * 1000.0
     )
     MSATS_PER_1K_OUTPUT_TOKENS: float = (
         float(settings.fixed_per_1k_output_tokens) * 1000.0
     )
+    MSATS_PER_1K_IMAGE_COMPLETION_TOKENS: float = 0.0
 
     if not settings.fixed_pricing:
         response_model = response_data.get("model", "")
@@ -155,11 +105,13 @@ async def calculate_cost(  # todo: can be sync
         try:
             mspp = float(model_obj.sats_pricing.prompt)
             mspc = float(model_obj.sats_pricing.completion)
+            mspci = float(getattr(model_obj.sats_pricing, "completion_image", 0.0))
         except Exception:
             return CostDataError(message="Invalid pricing data", code="pricing_invalid")
 
         MSATS_PER_1K_INPUT_TOKENS = mspp * 1_000_000.0
         MSATS_PER_1K_OUTPUT_TOKENS = mspc * 1_000_000.0
+        MSATS_PER_1K_IMAGE_COMPLETION_TOKENS = mspci * 1_000_000.0
 
         logger.info(
             "Applied model-specific pricing",
@@ -167,6 +119,7 @@ async def calculate_cost(  # todo: can be sync
                 "model": response_model,
                 "input_price_msats_per_1k": MSATS_PER_1K_INPUT_TOKENS,
                 "output_price_msats_per_1k": MSATS_PER_1K_OUTPUT_TOKENS,
+                "image_completion_price_msats_per_1k": MSATS_PER_1K_IMAGE_COMPLETION_TOKENS,
             },
         )
 
@@ -179,7 +132,7 @@ async def calculate_cost(  # todo: can be sync
             },
         )
         return cost_data
-
+    usage_data = response_data["usage"]
     input_tokens = usage_data.get("prompt_tokens", 0)
     output_tokens = usage_data.get("completion_tokens", 0)
 
@@ -191,10 +144,32 @@ async def calculate_cost(  # todo: can be sync
         output_tokens if output_tokens != 0 else usage_data.get("output_tokens", 0)
     )
 
+    # Calculate image completion cost
+    image_completion_msats = 0.0
+    if MSATS_PER_1K_IMAGE_COMPLETION_TOKENS > 0:
+        completion_details = usage_data.get("completion_tokens_details", {})
+        image_tokens = completion_details.get("image_tokens", 0)
+
+        if image_tokens > 0:
+            if output_tokens >= image_tokens:
+                output_tokens -= image_tokens
+
+            image_completion_msats = round(
+                image_tokens / 1000 * MSATS_PER_1K_IMAGE_COMPLETION_TOKENS, 3
+            )
+
+            logger.info(
+                "Calculated image completion cost",
+                extra={
+                    "image_tokens": image_tokens,
+                    "image_completion_msats": image_completion_msats,
+                },
+            )
+
     input_msats = round(input_tokens / 1000 * MSATS_PER_1K_INPUT_TOKENS, 3)
 
     output_msats = round(output_tokens / 1000 * MSATS_PER_1K_OUTPUT_TOKENS, 3)
-    token_based_cost = math.ceil(input_msats + output_msats)
+    token_based_cost = math.ceil(input_msats + output_msats + image_completion_msats)
 
     logger.info(
         "Calculated token-based cost",
@@ -203,6 +178,7 @@ async def calculate_cost(  # todo: can be sync
             "output_tokens": output_tokens,
             "input_cost_msats": input_msats,
             "output_cost_msats": output_msats,
+            "image_completion_msats": image_completion_msats,
             "total_cost_msats": token_based_cost,
             "model": response_data.get("model", "unknown"),
         },

routstr/payment/models.py

@@ -31,6 +31,7 @@ class Pricing(BaseModel):
     completion: float
     request: float = 0.0
     image: float = 0.0
+    completion_image: float = 0.0
     web_search: float = 0.0
     internal_reasoning: float = 0.0
     input_cache_read: float = 0.0
@@ -40,6 +41,13 @@ class Pricing(BaseModel):
     max_cost: float = 0.0  # in sats not msats
 
 
+PRICING_OVERRIDES = {
+    "gemini-3-pro-image-preview": {"completion_image": 0.00012},
+    "gemini-2.5-flash-image": {"completion_image": 0.00003},
+    "gemini-2.0-flash": {"completion_image": 0.00003},
+}
+
+
 class TopProvider(BaseModel):
     context_length: int | None = None
     max_completion_tokens: int | None = None
@@ -93,32 +101,12 @@ async def async_fetch_openrouter_models(source_filter: str | None = None) -> lis
 
     try:
         async with httpx.AsyncClient() as client:
-            models_response, embeddings_response = await asyncio.gather(
-                client.get(f"{base_url}/models", timeout=30),
-                client.get(f"{base_url}/embeddings/models", timeout=30),
-                return_exceptions=True,
-            )
-
-            def process_models_response(
-                response: httpx.Response | BaseException,
-            ) -> list[dict]:
-                if not isinstance(response, BaseException):
-                    response.raise_for_status()
-                    data = response.json()
-                    return [
-                        model
-                        for model in data.get("data", [])
-                        if ":free" not in model.get("id", "").lower()
-                    ]
-                return []
+            response = await client.get(f"{base_url}/models", timeout=30)
+            response.raise_for_status()
+            data = response.json()
 
             models_data: list[dict] = []
-            models_data.extend(process_models_response(models_response))
-            models_data.extend(process_models_response(embeddings_response))
-
-            # Apply source filter and exclusions
-            filtered_models = []
-            for model in models_data:
+            for model in data.get("data", []):
                 model_id = model.get("id", "")
 
                 if source_filter:
@@ -136,9 +124,19 @@ async def async_fetch_openrouter_models(source_filter: str | None = None) -> lis
                 if not _has_valid_pricing(model):
                     continue
 
-                filtered_models.append(model)
+                # Apply manual pricing overrides
+                if model_id in PRICING_OVERRIDES:
+                    pricing = model.get("pricing", {})
+                    if pricing:
+                        for k, v in PRICING_OVERRIDES[model_id].items():
+                            pricing[k] = str(
+                                v
+                            )  # OpenRouter API returns strings for pricing
+                        model["pricing"] = pricing
 
-            return filtered_models
+                models_data.append(model)
+
+            return models_data
     except Exception as e:
         logger.error(f"Error (async) fetching models from OpenRouter API: {e}")
         return []
@@ -168,6 +166,12 @@ def _row_to_model(
     if isinstance(pricing, dict) and float(pricing.get("request", 0.0)) <= 0.0:
         pricing["request"] = max(pricing.get("request", 0.0), 0.0)
 
+    # Apply defaults for missing fields from manual overrides
+    if row.id in PRICING_OVERRIDES and isinstance(pricing, dict):
+        for k, v in PRICING_OVERRIDES[row.id].items():
+            if k not in pricing:
+                pricing[k] = v
+
     parsed_pricing = Pricing.parse_obj(pricing)
     model = Model(
         id=row.id,
@@ -527,6 +531,7 @@ def _pricing_matches(
         "completion",
         "request",
         "image",
+        "completion_image",
         "web_search",
         "internal_reasoning",
     ]

routstr/proxy.py

@@ -65,7 +65,7 @@ def get_upstreams() -> list[BaseUpstreamProvider]:
 
 def get_model_instance(model_id: str) -> Model | None:
     """Get Model instance by ID from global cache."""
-    return _model_instances.get(model_id.lower())
+    return _model_instances.get(model_id)
 
 
 def get_provider_for_model(model_id: str) -> BaseUpstreamProvider | None:

routstr/upstream/base.py

@@ -734,53 +734,51 @@ class BaseUpstreamProvider:
                     await client.aclose()
                 return mapped_error
 
-            if path.endswith("chat/completions") or path.endswith("embeddings"):
-                if path.endswith("chat/completions"):
-                    client_wants_streaming = False
-                    if request_body:
-                        try:
-                            request_data = json.loads(request_body)
-                            client_wants_streaming = request_data.get("stream", False)
-                            logger.debug(
-                                "Chat completion request analysis",
-                                extra={
-                                    "client_wants_streaming": client_wants_streaming,
-                                    "model": request_data.get("model", "unknown"),
-                                    "key_hash": key.hashed_key[:8] + "...",
-                                },
-                            )
-                        except json.JSONDecodeError:
-                            logger.warning(
-                                "Failed to parse request body JSON for streaming detection"
-                            )
-
-                    content_type = response.headers.get("content-type", "")
-                    upstream_is_streaming = "text/event-stream" in content_type
-                    is_streaming = client_wants_streaming and upstream_is_streaming
-
-                    logger.debug(
-                        "Response type analysis",
-                        extra={
-                            "is_streaming": is_streaming,
-                            "client_wants_streaming": client_wants_streaming,
-                            "upstream_is_streaming": upstream_is_streaming,
-                            "content_type": content_type,
-                            "key_hash": key.hashed_key[:8] + "...",
-                        },
-                    )
-
-                    if is_streaming and response.status_code == 200:
-                        result = await self.handle_streaming_chat_completion(
-                            response, key, max_cost_for_model
+            if path.endswith("chat/completions"):
+                client_wants_streaming = False
+                if request_body:
+                    try:
+                        request_data = json.loads(request_body)
+                        client_wants_streaming = request_data.get("stream", False)
+                        logger.debug(
+                            "Chat completion request analysis",
+                            extra={
+                                "client_wants_streaming": client_wants_streaming,
+                                "model": request_data.get("model", "unknown"),
+                                "key_hash": key.hashed_key[:8] + "...",
+                            },
+                        )
+                    except json.JSONDecodeError:
+                        logger.warning(
+                            "Failed to parse request body JSON for streaming detection"
                         )
-                        background_tasks = BackgroundTasks()
-                        background_tasks.add_task(response.aclose)
-                        background_tasks.add_task(client.aclose)
-                        result.background = background_tasks
-                        return result
 
-                # Handle both non-streaming chat completions and embeddings
-                if response.status_code == 200:
+                content_type = response.headers.get("content-type", "")
+                upstream_is_streaming = "text/event-stream" in content_type
+                is_streaming = client_wants_streaming and upstream_is_streaming
+
+                logger.debug(
+                    "Response type analysis",
+                    extra={
+                        "is_streaming": is_streaming,
+                        "client_wants_streaming": client_wants_streaming,
+                        "upstream_is_streaming": upstream_is_streaming,
+                        "content_type": content_type,
+                        "key_hash": key.hashed_key[:8] + "...",
+                    },
+                )
+
+                if is_streaming and response.status_code == 200:
+                    result = await self.handle_streaming_chat_completion(
+                        response, key, max_cost_for_model
+                    )
+                    background_tasks = BackgroundTasks()
+                    background_tasks.add_task(response.aclose)
+                    background_tasks.add_task(client.aclose)
+                    result.background = background_tasks
+                    return result
+
+                elif response.status_code == 200:
                     try:
                         return await self.handle_non_streaming_chat_completion(
                             response, key, session, max_cost_for_model
@@ -1521,9 +1519,9 @@ class BaseUpstreamProvider:
                     error_response.headers["X-Cashu"] = refund_token
                     return error_response
 
-                if path.endswith("chat/completions") or path.endswith("embeddings"):
+                if path.endswith("chat/completions"):
                     logger.debug(
-                        "Processing completion/embeddings response",
+                        "Processing chat completion response",
                         extra={"path": path, "amount": amount, "unit": unit},
                     )
 
@@ -1772,32 +1770,15 @@ class BaseUpstreamProvider:
     async def _fetch_openrouter_models(self) -> list[dict]:
         """Fetch models from OpenRouter API."""
         url = "https://openrouter.ai/api/v1/models"
-        embeddings_url = "https://openrouter.ai/api/v1/embeddings/models"
-
         async with httpx.AsyncClient(timeout=30.0) as client:
-            models_response, embeddings_response = await asyncio.gather(
-                client.get(url), client.get(embeddings_url), return_exceptions=True
-            )
-
-            all_models = []
-
-            def process_models_response(
-                response: httpx.Response | BaseException,
-            ) -> list[dict]:
-                if not isinstance(response, BaseException):
-                    response.raise_for_status()
-                    data = response.json()
-                    return [
-                        model
-                        for model in data.get("data", [])
-                        if ":free" not in model.get("id", "").lower()
-                    ]
-                return []
-
-            all_models.extend(process_models_response(models_response))
-            all_models.extend(process_models_response(embeddings_response))
-
-            return all_models
+            response = await client.get(url)
+            response.raise_for_status()
+            models = response.json()
+            return [
+                model
+                for model in models.get("data", [])
+                if ":free" not in model.get("id", "").lower()
+            ]
 
     async def _fetch_provider_models(self) -> dict:
         """Fetch models from provider's API."""

routstr/upstream/openrouter.py

@@ -50,13 +50,7 @@ class OpenRouterUpstreamProvider(BaseUpstreamProvider):
     async def fetch_models(self) -> list[Model]:
         """Fetch all OpenRouter models."""
         models_data = await async_fetch_openrouter_models()
-        models = [Model(**model) for model in models_data]  # type: ignore
-        # manual alias for openai/text-embedding-ada-002 due to openrouter api bug
-        for model in models:
-            if model.id == "openai/text-embedding-ada-002":
-                model.alias_ids = ["text-embedding-ada-002-v2"]
-                break
-        return models
+        return [Model(**model) for model in models_data]  # type: ignore
 
     async def get_balance(self) -> float | None:
         """Get the current account balance from OpenRouter.

tests/integration/test_embeddings.py

@@ -1,97 +0,0 @@
-import json
-from typing import Any
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-from httpx import AsyncClient
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_proxy_embeddings_endpoint(authenticated_client: AsyncClient) -> None:
-    """Test the embeddings endpoint proxy functionality"""
-
-    test_payload = {
-        "model": "text-embedding-ada-002",
-        "input": "The quick brown fox",
-    }
-
-    mock_response_data = {
-        "object": "list",
-        "data": [
-            {"object": "embedding", "embedding": [0.0023, -0.0012, 0.0045], "index": 0}
-        ],
-        "model": "text-embedding-ada-002",
-        "usage": {"prompt_tokens": 5, "total_tokens": 5},
-    }
-
-    with patch("httpx.AsyncClient.send") as mock_send:
-        # Create a proper async generator for iter_bytes
-        async def mock_iter_bytes(*args: Any, **kwargs: Any) -> Any:
-            yield json.dumps(mock_response_data).encode()
-
-        mock_response = AsyncMock()
-        mock_response.status_code = 200
-        mock_response.headers = {"content-type": "application/json"}
-        mock_response.text = json.dumps(mock_response_data)
-        # Use MagicMock for synchronous .json() method
-        mock_response.json = MagicMock(return_value=mock_response_data)
-        mock_response.iter_bytes = mock_iter_bytes
-        mock_response.aiter_bytes = mock_iter_bytes
-        mock_send.return_value = mock_response
-
-        # Make POST request to embeddings endpoint
-        response = await authenticated_client.post("/v1/embeddings", json=test_payload)
-
-        assert response.status_code == 200
-        response_data = response.json()
-        assert response_data["object"] == "list"
-        assert len(response_data["data"]) == 1
-        assert response_data["data"][0]["object"] == "embedding"
-
-        # Verify request was forwarded
-        mock_send.assert_called_once()
-        forwarded_request = mock_send.call_args[0][0]
-        # Verify the path ends with embeddings
-        # Note: forwarded path might be full URL
-        assert str(forwarded_request.url).endswith("embeddings")
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_model_case_insensitivity(authenticated_client: AsyncClient) -> None:
-    """Test that model lookups are case insensitive"""
-
-    # We'll use a mixed-case model ID that should match the lowercase one in the system
-    # We assume 'gpt-3.5-turbo' is available in the mock env/database
-
-    test_payload = {
-        "model": "GPT-3.5-TURBO",
-        "messages": [{"role": "user", "content": "Hello"}],
-    }
-
-    with patch("httpx.AsyncClient.send") as mock_send:
-        mock_response_data = {
-            "id": "chatcmpl-123",
-            "object": "chat.completion",
-            "choices": [{"message": {"content": "Hi"}}],
-            "usage": {"total_tokens": 10},
-        }
-
-        async def mock_iter_bytes(*args: Any, **kwargs: Any) -> Any:
-            yield json.dumps(mock_response_data).encode()
-
-        mock_response = AsyncMock()
-        mock_response.status_code = 200
-        mock_response.headers = {"content-type": "application/json"}
-        mock_response.text = json.dumps(mock_response_data)
-        mock_response.json = MagicMock(return_value=mock_response_data)
-        mock_response.iter_bytes = mock_iter_bytes
-        mock_response.aiter_bytes = mock_iter_bytes
-        mock_send.return_value = mock_response
-
-        response = await authenticated_client.post(
-            "/v1/chat/completions", json=test_payload
-        )
-
-        assert response.status_code == 200