router-maestro 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

router_maestro/routing/router.py

@@ -19,6 +19,9 @@ from router_maestro.providers import (
     ModelInfo,
     OpenAICompatibleProvider,
     ProviderError,
+    ResponsesRequest,
+    ResponsesResponse,
+    ResponsesStreamChunk,
 )
 from router_maestro.utils import get_logger
 
@@ -382,7 +385,7 @@ class Router:
         try:
             await provider.ensure_token()
             if is_stream:
-                stream = await provider.chat_completion_stream(actual_request)
+                stream = provider.chat_completion_stream(actual_request)
                 logger.info("Stream request routed to %s", provider_name)
                 return stream, provider_name
             else:
@@ -417,7 +420,7 @@ class Router:
                 try:
                     await other_provider.ensure_token()
                     if is_stream:
-                        stream = await other_provider.chat_completion_stream(fallback_request)
+                        stream = other_provider.chat_completion_stream(fallback_request)
                         logger.info("Stream fallback succeeded via %s", other_name)
                         return stream, other_name
                     else:
@@ -479,6 +482,159 @@ class Router:
         )
         return result, used_provider  # type: ignore
 
+    def _create_responses_request_with_model(
+        self, original_request: ResponsesRequest, model_id: str
+    ) -> ResponsesRequest:
+        """Create a new ResponsesRequest with a different model ID.
+
+        Args:
+            original_request: The original request
+            model_id: The new model ID to use
+
+        Returns:
+            New ResponsesRequest with updated model
+        """
+        return ResponsesRequest(
+            model=model_id,
+            input=original_request.input,
+            stream=original_request.stream,
+            instructions=original_request.instructions,
+            temperature=original_request.temperature,
+            max_output_tokens=original_request.max_output_tokens,
+            tools=original_request.tools,
+            tool_choice=original_request.tool_choice,
+            parallel_tool_calls=original_request.parallel_tool_calls,
+        )
+
+    async def _execute_responses_with_fallback(
+        self,
+        request: ResponsesRequest,
+        provider_name: str,
+        actual_model_id: str,
+        provider: BaseProvider,
+        fallback: bool,
+        is_stream: bool,
+    ) -> tuple[ResponsesResponse | AsyncIterator[ResponsesStreamChunk], str]:
+        """Execute Responses API request with fallback support.
+
+        Args:
+            request: Original responses request
+            provider_name: Name of the primary provider
+            actual_model_id: The actual model ID to use
+            provider: The primary provider instance
+            fallback: Whether to try fallback providers on error
+            is_stream: Whether this is a streaming request
+
+        Returns:
+            Tuple of (response or stream, provider_name)
+
+        Raises:
+            ProviderError: If all providers fail
+        """
+        actual_request = self._create_responses_request_with_model(request, actual_model_id)
+
+        try:
+            await provider.ensure_token()
+            if is_stream:
+                stream = provider.responses_completion_stream(actual_request)
+                logger.info("Responses stream request routed to %s", provider_name)
+                return stream, provider_name
+            else:
+                response = await provider.responses_completion(actual_request)
+                logger.info("Responses request completed via %s", provider_name)
+                return response, provider_name
+        except ProviderError as e:
+            logger.warning("Provider %s failed for responses: %s", provider_name, e)
+            if not fallback or not e.retryable:
+                raise
+
+            # Load fallback config
+            priorities_config = self._get_priorities_config()
+            fallback_config = priorities_config.fallback
+
+            if fallback_config.strategy == FallbackStrategy.NONE:
+                raise
+
+            # Get fallback candidates
+            candidates = self._get_fallback_candidates(
+                provider_name, actual_model_id, fallback_config.strategy
+            )
+
+            # Try fallback candidates up to maxRetries
+            for i, (other_name, other_model_id, other_provider) in enumerate(candidates):
+                if i >= fallback_config.maxRetries:
+                    break
+
+                logger.info("Trying responses fallback: %s/%s", other_name, other_model_id)
+                fallback_request = self._create_responses_request_with_model(
+                    request, other_model_id
+                )
+
+                try:
+                    await other_provider.ensure_token()
+                    if is_stream:
+                        stream = other_provider.responses_completion_stream(fallback_request)
+                        logger.info("Responses stream fallback succeeded via %s", other_name)
+                        return stream, other_name
+                    else:
+                        response = await other_provider.responses_completion(fallback_request)
+                        logger.info("Responses fallback succeeded via %s", other_name)
+                        return response, other_name
+                except ProviderError as fallback_error:
+                    logger.warning("Responses fallback %s failed: %s", other_name, fallback_error)
+                    continue
+            raise
+
+    async def responses_completion(
+        self,
+        request: ResponsesRequest,
+        fallback: bool = True,
+    ) -> tuple[ResponsesResponse, str]:
+        """Route a Responses API completion request.
+
+        Args:
+            request: Responses completion request
+            fallback: Whether to try fallback providers on error
+
+        Returns:
+            Tuple of (response, provider_name)
+
+        Raises:
+            ProviderError: If model not found or all providers fail
+        """
+        provider_name, actual_model_id, provider = await self._resolve_provider(request.model)
+        logger.info("Routing responses request to %s/%s", provider_name, actual_model_id)
+
+        result, used_provider = await self._execute_responses_with_fallback(
+            request, provider_name, actual_model_id, provider, fallback, is_stream=False
+        )
+        return result, used_provider  # type: ignore
+
+    async def responses_completion_stream(
+        self,
+        request: ResponsesRequest,
+        fallback: bool = True,
+    ) -> tuple[AsyncIterator[ResponsesStreamChunk], str]:
+        """Route a streaming Responses API completion request.
+
+        Args:
+            request: Responses completion request
+            fallback: Whether to try fallback providers on error
+
+        Returns:
+            Tuple of (stream iterator, provider_name)
+
+        Raises:
+            ProviderError: If model not found or all providers fail
+        """
+        provider_name, actual_model_id, provider = await self._resolve_provider(request.model)
+        logger.info("Routing responses stream request to %s/%s", provider_name, actual_model_id)
+
+        result, used_provider = await self._execute_responses_with_fallback(
+            request, provider_name, actual_model_id, provider, fallback, is_stream=True
+        )
+        return result, used_provider  # type: ignore
+
     async def list_models(self) -> list[ModelInfo]:
         """List all available models from all authenticated providers.
 

router_maestro/server/app.py

@@ -9,7 +9,13 @@ from fastapi.middleware.cors import CORSMiddleware
 from router_maestro import __version__
 from router_maestro.routing import get_router
 from router_maestro.server.middleware import verify_api_key
-from router_maestro.server.routes import admin_router, anthropic_router, chat_router, models_router
+from router_maestro.server.routes import (
+    admin_router,
+    anthropic_router,
+    chat_router,
+    models_router,
+    responses_router,
+)
 from router_maestro.utils import get_logger, setup_logging
 
 logger = get_logger("server")
@@ -64,6 +70,7 @@ def create_app() -> FastAPI:
     # Include routers with API key verification
     app.include_router(chat_router, dependencies=[Depends(verify_api_key)])
     app.include_router(models_router, dependencies=[Depends(verify_api_key)])
+    app.include_router(responses_router, dependencies=[Depends(verify_api_key)])
     app.include_router(anthropic_router, dependencies=[Depends(verify_api_key)])
     app.include_router(admin_router, dependencies=[Depends(verify_api_key)])
 

router_maestro/server/routes/__init__.py

@@ -4,5 +4,12 @@ from router_maestro.server.routes.admin import router as admin_router
 from router_maestro.server.routes.anthropic import router as anthropic_router
 from router_maestro.server.routes.chat import router as chat_router
 from router_maestro.server.routes.models import router as models_router
+from router_maestro.server.routes.responses import router as responses_router
 
-__all__ = ["admin_router", "anthropic_router", "chat_router", "models_router"]
+__all__ = [
+    "admin_router",
+    "anthropic_router",
+    "chat_router",
+    "models_router",
+    "responses_router",
+]

router_maestro/server/routes/anthropic.py

@@ -3,6 +3,7 @@
 import json
 import uuid
 from collections.abc import AsyncGenerator
+from datetime import UTC, datetime
 
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
@@ -13,6 +14,8 @@ from router_maestro.server.schemas.anthropic import (
     AnthropicCountTokensRequest,
     AnthropicMessagesRequest,
     AnthropicMessagesResponse,
+    AnthropicModelInfo,
+    AnthropicModelList,
     AnthropicStreamState,
     AnthropicTextBlock,
     AnthropicUsage,
@@ -33,6 +36,75 @@ logger = get_logger("server.routes.anthropic")
 router = APIRouter()
 
 
+TEST_RESPONSE_TEXT = "This is a test response from Router-Maestro."
+
+
+def _create_test_response() -> AnthropicMessagesResponse:
+    """Create a mock response for test model."""
+    return AnthropicMessagesResponse(
+        id=f"msg_{uuid.uuid4().hex[:24]}",
+        type="message",
+        role="assistant",
+        content=[AnthropicTextBlock(type="text", text=TEST_RESPONSE_TEXT)],
+        model="test",
+        stop_reason="end_turn",
+        stop_sequence=None,
+        usage=AnthropicUsage(input_tokens=10, output_tokens=10),
+    )
+
+
+async def _stream_test_response() -> AsyncGenerator[str, None]:
+    """Stream a mock test response."""
+    response_id = f"msg_{uuid.uuid4().hex[:24]}"
+
+    # message_start event
+    message_start = {
+        "type": "message_start",
+        "message": {
+            "id": response_id,
+            "type": "message",
+            "role": "assistant",
+            "content": [],
+            "model": "test",
+            "stop_reason": None,
+            "stop_sequence": None,
+            "usage": {"input_tokens": 10, "output_tokens": 0},
+        },
+    }
+    yield f"event: message_start\ndata: {json.dumps(message_start)}\n\n"
+
+    # content_block_start event
+    block_start = {
+        "type": "content_block_start",
+        "index": 0,
+        "content_block": {"type": "text", "text": ""},
+    }
+    yield f"event: content_block_start\ndata: {json.dumps(block_start)}\n\n"
+
+    # content_block_delta event
+    block_delta = {
+        "type": "content_block_delta",
+        "index": 0,
+        "delta": {"type": "text_delta", "text": TEST_RESPONSE_TEXT},
+    }
+    yield f"event: content_block_delta\ndata: {json.dumps(block_delta)}\n\n"
+
+    # content_block_stop event
+    block_stop = {"type": "content_block_stop", "index": 0}
+    yield f"event: content_block_stop\ndata: {json.dumps(block_stop)}\n\n"
+
+    # message_delta event
+    message_delta = {
+        "type": "message_delta",
+        "delta": {"stop_reason": "end_turn", "stop_sequence": None},
+        "usage": {"output_tokens": 10},
+    }
+    yield f"event: message_delta\ndata: {json.dumps(message_delta)}\n\n"
+
+    # message_stop event
+    yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
+
+
 @router.post("/v1/messages")
 @router.post("/api/anthropic/v1/messages")
 async def messages(request: AnthropicMessagesRequest):
@@ -42,6 +114,16 @@ async def messages(request: AnthropicMessagesRequest):
         request.model,
         request.stream,
     )
+
+    # Handle test model
+    if request.model == "test":
+        if request.stream:
+            return StreamingResponse(
+                _stream_test_response(),
+                media_type="text/event-stream",
+            )
+        return _create_test_response()
+
     model_router = get_router()
 
     # Translate Anthropic request to OpenAI format
@@ -227,3 +309,93 @@ async def stream_response(
             },
         }
         yield f"event: error\ndata: {json.dumps(error_event)}\n\n"
+
+
+def _generate_display_name(model_id: str) -> str:
+    """Generate a human-readable display name from model ID.
+
+    Transforms model IDs like 'github-copilot/claude-sonnet-4' into
+    'Claude Sonnet 4 (github-copilot)'.
+    """
+    if "/" in model_id:
+        provider, model_name = model_id.split("/", 1)
+    else:
+        provider = ""
+        model_name = model_id
+
+    # Capitalize words and handle common patterns
+    words = model_name.replace("-", " ").replace("_", " ").split()
+    display_words = []
+    for word in words:
+        # Keep version numbers as-is
+        if word.replace(".", "").isdigit():
+            display_words.append(word)
+        else:
+            display_words.append(word.capitalize())
+
+    display_name = " ".join(display_words)
+    if provider:
+        display_name = f"{display_name} ({provider})"
+
+    return display_name
+
+
+@router.get("/api/anthropic/v1/models")
+async def list_models(
+    limit: int = 20,
+    after_id: str | None = None,
+    before_id: str | None = None,
+) -> AnthropicModelList:
+    """List available models in Anthropic format.
+
+    Args:
+        limit: Maximum number of models to return (default 20)
+        after_id: Return models after this ID (for forward pagination)
+        before_id: Return models before this ID (for backward pagination)
+    """
+    model_router = get_router()
+    models = await model_router.list_models()
+
+    # Generate ISO 8601 timestamp for created_at
+    # Using current time since actual creation dates aren't tracked
+    created_at = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    # Convert to Anthropic format
+    anthropic_models = [
+        AnthropicModelInfo(
+            id=model.id,
+            created_at=created_at,
+            display_name=_generate_display_name(model.id),
+            type="model",
+        )
+        for model in models
+    ]
+
+    # Handle pagination
+    start_idx = 0
+    if after_id:
+        for i, model in enumerate(anthropic_models):
+            if model.id == after_id:
+                start_idx = i + 1
+                break
+
+    end_idx = len(anthropic_models)
+    if before_id:
+        for i, model in enumerate(anthropic_models):
+            if model.id == before_id:
+                end_idx = i
+                break
+
+    # Apply limit
+    paginated = anthropic_models[start_idx : min(start_idx + limit, end_idx)]
+
+    first_id = paginated[0].id if paginated else None
+    last_id = paginated[-1].id if paginated else None
+    has_more = (start_idx + limit) < end_idx
+
+    return AnthropicModelList(
+        data=paginated,
+        first_id=first_id,
+        last_id=last_id,
+        has_more=has_more,
+    )

router_maestro/server/routes/chat.py

@@ -27,8 +27,7 @@ logger = get_logger("server.routes.chat")
 router = APIRouter()
 
 
-@router.post("/chat/completions")
-@router.post("/v1/chat/completions")
+@router.post("/api/openai/v1/chat/completions")
 async def chat_completions(request: ChatCompletionRequest):
     """Handle chat completion requests."""
     logger.info(

router_maestro/server/routes/models.py

@@ -15,8 +15,7 @@ def get_router() -> Router:
     return Router()
 
 
-@router.get("/models")
-@router.get("/v1/models")
+@router.get("/api/openai/v1/models")
 async def list_models() -> ModelList:
     """List available models."""
     model_router = get_router()