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

router_maestro/__init__.py

@@ -1,3 +1,3 @@
 """Router-Maestro: Multi-model routing and load balancing system."""
 
-__version__ = "0.1.5"
+__version__ = "0.1.7"

router_maestro/cli/config.py

@@ -3,9 +3,11 @@
 import asyncio
 import json
 import shutil
+import tomllib
 from datetime import datetime
 from pathlib import Path
 
+import tomlkit
 import typer
 from rich.console import Console
 from rich.panel import Panel
@@ -24,6 +26,10 @@ CLI_TOOLS = {
         "name": "Claude Code",
         "description": "Generate settings.json for Claude Code CLI",
     },
+    "codex": {
+        "name": "OpenAI Codex",
+        "description": "Generate config.toml for OpenAI Codex CLI",
+    },
 }
 
 
@@ -35,6 +41,14 @@ def get_claude_code_paths() -> dict[str, Path]:
     }
 
 
+def get_codex_paths() -> dict[str, Path]:
+    """Get Codex config paths."""
+    return {
+        "user": Path.home() / ".codex" / "config.toml",
+        "project": Path.cwd() / ".codex" / "config.toml",
+    }
+
+
 @app.callback(invoke_without_command=True)
 def config_callback(ctx: typer.Context) -> None:
     """Generate configuration for CLI tools (interactive selection if not specified)."""
@@ -60,6 +74,8 @@ def config_callback(ctx: typer.Context) -> None:
     # Dispatch to the appropriate command
     if tool_key == "claude-code":
         claude_code_config()
+    elif tool_key == "codex":
+        codex_config()
 
 
 @app.command(name="claude-code")
@@ -175,3 +191,113 @@ def claude_code_config() -> None:
             border_style="green",
         )
     )
+
+
+@app.command(name="codex")
+def codex_config() -> None:
+    """Generate OpenAI Codex CLI config.toml for router-maestro."""
+    # Step 1: Select level
+    console.print("\n[bold]Step 1: Select configuration level[/bold]")
+    console.print("  1. User-level (~/.codex/config.toml)")
+    console.print("  2. Project-level (./.codex/config.toml)")
+    choice = Prompt.ask("Select", choices=["1", "2"], default="1")
+
+    paths = get_codex_paths()
+    level = "user" if choice == "1" else "project"
+    config_path = paths[level]
+
+    # Step 2: Backup if exists
+    if config_path.exists():
+        console.print(f"\n[yellow]config.toml already exists at {config_path}[/yellow]")
+        if Confirm.ask("Backup existing file?", default=True):
+            backup_path = config_path.with_suffix(
+                f".toml.backup.{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            )
+            shutil.copy(config_path, backup_path)
+            console.print(f"[green]Backed up to {backup_path}[/green]")
+
+    # Step 3: Get models from server
+    try:
+        client = get_admin_client()
+        models = asyncio.run(client.list_models())
+    except ServerNotRunningError as e:
+        console.print(f"[red]{e}[/red]")
+        console.print("[dim]Tip: Start router-maestro server first.[/dim]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+    if not models:
+        console.print("[red]No models available. Please authenticate first.[/red]")
+        raise typer.Exit(1)
+
+    # Display models
+    console.print("\n[bold]Available models:[/bold]")
+    table = Table()
+    table.add_column("#", style="dim")
+    table.add_column("Model Key", style="green")
+    table.add_column("Name", style="white")
+    for i, model in enumerate(models, 1):
+        table.add_row(str(i), f"{model['provider']}/{model['id']}", model["name"])
+    console.print(table)
+
+    # Select model
+    console.print("\n[bold]Step 2: Select model[/bold]")
+    model_choice = Prompt.ask("Enter number (or 0 for auto-routing)", default="0")
+    selected_model = "router-maestro"
+    if model_choice != "0" and model_choice.isdigit():
+        idx = int(model_choice) - 1
+        if 0 <= idx < len(models):
+            m = models[idx]
+            selected_model = f"{m['provider']}/{m['id']}"
+
+    # Step 4: Generate config
+    client = get_admin_client()
+    base_url = (
+        client.endpoint.rstrip("/") if hasattr(client, "endpoint") else "http://localhost:8080"
+    )
+    openai_url = f"{base_url}/api/openai/v1"
+
+    # Load existing config to preserve other sections
+    existing_config: tomlkit.TOMLDocument = tomlkit.document()
+    if config_path.exists():
+        try:
+            with open(config_path, "rb") as f:
+                existing_config = tomlkit.load(f)
+        except (tomllib.TOMLDecodeError, OSError):
+            pass  # If file is corrupted, start fresh
+
+    # Update configuration
+    existing_config["model"] = selected_model
+    existing_config["model_provider"] = "router-maestro"
+
+    # Create or update model_providers section
+    if "model_providers" not in existing_config:
+        existing_config["model_providers"] = tomlkit.table()
+
+    provider_config = tomlkit.table()
+    provider_config["name"] = "Router Maestro"
+    provider_config["base_url"] = openai_url
+    provider_config["env_key"] = "ROUTER_MAESTRO_API_KEY"
+    provider_config["wire_api"] = "responses"
+    existing_config["model_providers"]["router-maestro"] = provider_config
+
+    # Write config
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(config_path, "w", encoding="utf-8") as f:
+        f.write(tomlkit.dumps(existing_config))
+
+    console.print(
+        Panel(
+            f"[green]Created {config_path}[/green]\n\n"
+            f"Model: {selected_model}\n\n"
+            f"Endpoint: {openai_url}\n\n"
+            "[dim]Start router-maestro server before using Codex:[/dim]\n"
+            "  router-maestro server start\n\n"
+            "[dim]Set API key environment variable (optional):[/dim]\n"
+            "  export ROUTER_MAESTRO_API_KEY=your-key",
+            title="Success",
+            border_style="green",
+        )
+    )

router_maestro/providers/__init__.py

@@ -9,6 +9,10 @@ from router_maestro.providers.base import (
     Message,
     ModelInfo,
     ProviderError,
+    ResponsesRequest,
+    ResponsesResponse,
+    ResponsesStreamChunk,
+    ResponsesToolCall,
 )
 from router_maestro.providers.copilot import CopilotProvider
 from router_maestro.providers.openai import OpenAIProvider
@@ -23,6 +27,10 @@ __all__ = [
     "ChatResponse",
     "ChatStreamChunk",
     "ModelInfo",
+    "ResponsesRequest",
+    "ResponsesResponse",
+    "ResponsesStreamChunk",
+    "ResponsesToolCall",
     # Providers
     "CopilotProvider",
     "OpenAIProvider",

router_maestro/providers/base.py

@@ -59,6 +59,53 @@ class ModelInfo:
     provider: str
 
 
+@dataclass
+class ResponsesToolCall:
+    """A tool/function call from the Responses API."""
+
+    call_id: str
+    name: str
+    arguments: str
+
+
+@dataclass
+class ResponsesRequest:
+    """Request for the Responses API (used by Codex models)."""
+
+    model: str
+    input: str | list  # Can be string or list of message dicts
+    stream: bool = False
+    instructions: str | None = None
+    temperature: float = 1.0
+    max_output_tokens: int | None = None
+    # Tool support
+    tools: list[dict] | None = None
+    tool_choice: str | dict | None = None
+    parallel_tool_calls: bool | None = None
+
+
+@dataclass
+class ResponsesResponse:
+    """Response from the Responses API."""
+
+    content: str
+    model: str
+    usage: dict | None = None
+    tool_calls: list[ResponsesToolCall] | None = None
+
+
+@dataclass
+class ResponsesStreamChunk:
+    """A chunk from streaming Responses API completion."""
+
+    content: str
+    finish_reason: str | None = None
+    usage: dict | None = None
+    # Tool call support
+    tool_call: ResponsesToolCall | None = None  # A complete tool call
+    tool_call_delta: dict | None = None  # Partial tool call for streaming
+
+
 class ProviderError(Exception):
     """Error from a provider."""
 
@@ -121,3 +168,36 @@ class BaseProvider(ABC):
         Override this for providers that need token refresh.
         """
         pass
+
+    async def responses_completion(self, request: ResponsesRequest) -> ResponsesResponse:
+        """Generate a Responses API completion (for Codex models).
+
+        Args:
+            request: Responses completion request
+
+        Returns:
+            Responses completion response
+
+        Raises:
+            NotImplementedError: If provider does not support Responses API
+        """
+        raise NotImplementedError("Provider does not support Responses API")
+
+    async def responses_completion_stream(
+        self, request: ResponsesRequest
+    ) -> AsyncIterator[ResponsesStreamChunk]:
+        """Generate a streaming Responses API completion (for Codex models).
+
+        Args:
+            request: Responses completion request
+
+        Yields:
+            Responses completion chunks
+
+        Raises:
+            NotImplementedError: If provider does not support Responses API
+        """
+        raise NotImplementedError("Provider does not support Responses API")
+        # Make this a generator (required for type checking)
+        if False:
+            yield ResponsesStreamChunk(content="")

router_maestro/providers/copilot.py

@@ -7,6 +7,7 @@ import httpx
 
 from router_maestro.auth import AuthManager, AuthType
 from router_maestro.auth.github_oauth import get_copilot_token
+from router_maestro.auth.storage import OAuthCredential
 from router_maestro.providers.base import (
     BaseProvider,
     ChatRequest,
@@ -14,6 +15,10 @@ from router_maestro.providers.base import (
     ChatStreamChunk,
     ModelInfo,
     ProviderError,
+    ResponsesRequest,
+    ResponsesResponse,
+    ResponsesStreamChunk,
+    ResponsesToolCall,
 )
 from router_maestro.utils import get_logger
 
@@ -22,6 +27,7 @@ logger = get_logger("providers.copilot")
 COPILOT_BASE_URL = "https://api.githubcopilot.com"
 COPILOT_CHAT_URL = f"{COPILOT_BASE_URL}/chat/completions"
 COPILOT_MODELS_URL = f"{COPILOT_BASE_URL}/models"
+COPILOT_RESPONSES_URL = f"{COPILOT_BASE_URL}/responses"
 
 # Model cache TTL in seconds (5 minutes)
 MODELS_CACHE_TTL = 300
@@ -50,7 +56,7 @@ class CopilotProvider(BaseProvider):
     async def ensure_token(self) -> None:
         """Ensure we have a valid Copilot token, refreshing if needed."""
         cred = self.auth_manager.get_credential("github-copilot")
-        if not cred or cred.type != AuthType.OAUTH:
+        if not cred or not isinstance(cred, OAuthCredential):
             logger.error("Not authenticated with GitHub Copilot")
             raise ProviderError("Not authenticated with GitHub Copilot", status_code=401)
 
@@ -344,3 +350,318 @@ class CopilotProvider(BaseProvider):
                 return self._models_cache
             logger.error("Failed to list Copilot models: %s", e)
             raise ProviderError(f"Failed to list models: {e}", retryable=True)
+
+    # Tools that are not supported by Copilot Responses API
+    UNSUPPORTED_TOOL_TYPES = {"web_search", "web_search_preview", "code_interpreter"}
+
+    def _filter_unsupported_tools(self, tools: list[dict] | None) -> list[dict] | None:
+        """Filter out tools that are not supported by Copilot API.
+
+        Args:
+            tools: List of tool definitions
+
+        Returns:
+            Filtered list of tools, or None if empty
+        """
+        if not tools:
+            return None
+
+        filtered = []
+        for tool in tools:
+            tool_type = tool.get("type", "function")
+            # Only include function tools, filter out unsupported built-in tools
+            if tool_type == "function":
+                filtered.append(tool)
+            elif tool_type not in self.UNSUPPORTED_TOOL_TYPES:
+                filtered.append(tool)
+            else:
+                logger.debug("Filtering out unsupported tool type: %s", tool_type)
+
+        return filtered if filtered else None
+
+    def _build_responses_payload(self, request: ResponsesRequest) -> dict:
+        """Build payload for Responses API request.
+
+        Args:
+            request: The responses request
+
+        Returns:
+            Payload dictionary for the API
+        """
+        payload: dict = {
+            "model": request.model,
+            "input": request.input,
+            "stream": request.stream,
+        }
+        if request.instructions:
+            payload["instructions"] = request.instructions
+        if request.temperature != 1.0:
+            payload["temperature"] = request.temperature
+        if request.max_output_tokens:
+            payload["max_output_tokens"] = request.max_output_tokens
+        # Tool support - filter out unsupported tools
+        filtered_tools = self._filter_unsupported_tools(request.tools)
+        if filtered_tools:
+            payload["tools"] = filtered_tools
+        if request.tool_choice:
+            payload["tool_choice"] = request.tool_choice
+        if request.parallel_tool_calls is not None:
+            payload["parallel_tool_calls"] = request.parallel_tool_calls
+        return payload
+
+    def _extract_response_content(self, data: dict) -> str:
+        """Extract text content from Responses API response.
+
+        Args:
+            data: The response JSON data
+
+        Returns:
+            The extracted text content
+        """
+        content = ""
+        for output in data.get("output", []):
+            if output.get("type") == "message":
+                for content_item in output.get("content", []):
+                    if content_item.get("type") == "output_text":
+                        content += content_item.get("text", "")
+        return content
+
+    def _extract_tool_calls(self, data: dict) -> list[ResponsesToolCall]:
+        """Extract tool calls from Responses API response.
+
+        Args:
+            data: The response JSON data
+
+        Returns:
+            List of tool calls
+        """
+        tool_calls = []
+        for output in data.get("output", []):
+            if output.get("type") == "function_call":
+                tool_calls.append(
+                    ResponsesToolCall(
+                        call_id=output.get("call_id", ""),
+                        name=output.get("name", ""),
+                        arguments=output.get("arguments", "{}"),
+                    )
+                )
+        return tool_calls
+
+    async def responses_completion(self, request: ResponsesRequest) -> ResponsesResponse:
+        """Generate a Responses API completion via Copilot (for Codex models)."""
+        await self.ensure_token()
+
+        payload = self._build_responses_payload(request)
+
+        logger.debug("Copilot responses completion: model=%s", request.model)
+        client = self._get_client()
+        try:
+            response = await client.post(
+                COPILOT_RESPONSES_URL,
+                json=payload,
+                headers=self._get_headers(),
+            )
+            response.raise_for_status()
+            data = response.json()
+
+            content = self._extract_response_content(data)
+            tool_calls = self._extract_tool_calls(data)
+
+            usage = None
+            if "usage" in data:
+                usage = data["usage"]
+
+            logger.debug("Copilot responses completion successful")
+            return ResponsesResponse(
+                content=content,
+                model=data.get("model", request.model),
+                usage=usage,
+                tool_calls=tool_calls if tool_calls else None,
+            )
+        except httpx.HTTPStatusError as e:
+            retryable = e.response.status_code in (429, 500, 502, 503, 504)
+            try:
+                error_body = e.response.text
+            except Exception:
+                error_body = ""
+            logger.error(
+                "Copilot responses API error: %d - %s",
+                e.response.status_code,
+                error_body[:200],
+            )
+            raise ProviderError(
+                f"Copilot API error: {e.response.status_code} - {error_body}",
+                status_code=e.response.status_code,
+                retryable=retryable,
+            )
+        except httpx.HTTPError as e:
+            logger.error("Copilot responses HTTP error: %s", e)
+            raise ProviderError(f"HTTP error: {e}", retryable=True)
+
+    async def responses_completion_stream(
+        self, request: ResponsesRequest
+    ) -> AsyncIterator[ResponsesStreamChunk]:
+        """Generate a streaming Responses API completion via Copilot (for Codex models)."""
+        await self.ensure_token()
+
+        payload = self._build_responses_payload(request)
+        payload["stream"] = True
+
+        logger.debug("Copilot streaming responses: model=%s", request.model)
+        logger.debug("Copilot responses payload: %s", payload)
+        client = self._get_client()
+        try:
+            async with client.stream(
+                "POST",
+                COPILOT_RESPONSES_URL,
+                json=payload,
+                headers=self._get_headers(),
+            ) as response:
+                # Check for errors before processing stream
+                if response.status_code >= 400:
+                    # Read the error body before the context closes
+                    error_body = await response.aread()
+                    error_text = error_body.decode("utf-8", errors="replace")
+                    logger.error(
+                        "Copilot responses stream API error: %d - %s",
+                        response.status_code,
+                        error_text,
+                    )
+                    retryable = response.status_code in (429, 500, 502, 503, 504)
+                    raise ProviderError(
+                        f"Copilot API error: {response.status_code} - {error_text}",
+                        status_code=response.status_code,
+                        retryable=retryable,
+                    )
+
+                stream_finished = False
+                final_usage = None
+                # Track current function call being streamed
+                current_fc: dict | None = None
+
+                async for line in response.aiter_lines():
+                    if stream_finished:
+                        break
+
+                    if not line or not line.startswith("data: "):
+                        continue
+
+                    data_str = line[6:]  # Remove "data: " prefix
+                    if data_str == "[DONE]":
+                        # Stream ended, emit final chunk if we haven't already
+                        if not stream_finished:
+                            yield ResponsesStreamChunk(
+                                content="",
+                                finish_reason="stop",
+                                usage=final_usage,
+                            )
+                            stream_finished = True
+                        break
+
+                    import json
+
+                    data = json.loads(data_str)
+                    event_type = data.get("type", "")
+
+                    # Handle text delta events
+                    if event_type == "response.output_text.delta":
+                        delta_text = data.get("delta", "")
+                        if delta_text:
+                            yield ResponsesStreamChunk(content=delta_text)
+
+                    # Handle function call output_item.added - start of a new function call
+                    elif event_type == "response.output_item.added":
+                        item = data.get("item", {})
+                        if item.get("type") == "function_call":
+                            current_fc = {
+                                "id": item.get("id", ""),
+                                "call_id": item.get("call_id", ""),
+                                "name": item.get("name", ""),
+                                "arguments": "",
+                                "output_index": data.get("output_index", 0),
+                            }
+
+                    # Handle function call arguments delta
+                    elif event_type == "response.function_call_arguments.delta":
+                        delta = data.get("delta", "")
+                        if current_fc and delta:
+                            current_fc["arguments"] += delta
+                            # Emit delta event for streaming
+                            yield ResponsesStreamChunk(
+                                content="",
+                                tool_call_delta={
+                                    "type": "function_call_arguments_delta",
+                                    "item_id": current_fc["id"],
+                                    "call_id": current_fc["call_id"],
+                                    "name": current_fc["name"],
+                                    "output_index": current_fc["output_index"],
+                                    "delta": delta,
+                                },
+                            )
+
+                    # Handle function call arguments done
+                    elif event_type == "response.function_call_arguments.done":
+                        if current_fc:
+                            current_fc["arguments"] = data.get("arguments", current_fc["arguments"])
+                            # Emit complete tool call
+                            yield ResponsesStreamChunk(
+                                content="",
+                                tool_call=ResponsesToolCall(
+                                    call_id=current_fc["call_id"],
+                                    name=current_fc["name"],
+                                    arguments=current_fc["arguments"],
+                                ),
+                            )
+                            current_fc = None
+
+                    # Handle output_item.done for function calls
+                    elif event_type == "response.output_item.done":
+                        item = data.get("item", {})
+                        if item.get("type") == "function_call":
+                            # Emit complete tool call if not already done
+                            yield ResponsesStreamChunk(
+                                content="",
+                                tool_call=ResponsesToolCall(
+                                    call_id=item.get("call_id", ""),
+                                    name=item.get("name", ""),
+                                    arguments=item.get("arguments", "{}"),
+                                ),
+                            )
+                            current_fc = None
+
+                    # Handle done event to get final usage
+                    elif event_type == "response.done":
+                        resp = data.get("response", {})
+                        final_usage = resp.get("usage")
+                        yield ResponsesStreamChunk(
+                            content="",
+                            finish_reason="stop",
+                            usage=final_usage,
+                        )
+                        stream_finished = True
+
+                    # Handle completed events
+                    elif event_type == "response.completed":
+                        # Final response received - emit finish chunk
+                        resp = data.get("response", {})
+                        if not final_usage:
+                            final_usage = resp.get("usage")
+                        yield ResponsesStreamChunk(
+                            content="",
+                            finish_reason="stop",
+                            usage=final_usage,
+                        )
+                        stream_finished = True
+
+                # If stream ended without explicit completion event, emit final chunk
+                if not stream_finished:
+                    logger.debug("Stream ended without completion event, emitting final chunk")
+                    yield ResponsesStreamChunk(
+                        content="",
+                        finish_reason="stop",
+                        usage=final_usage,
+                    )
+
+        except httpx.HTTPError as e:
+            logger.error("Copilot responses stream HTTP error: %s", e)
+            raise ProviderError(f"HTTP error: {e}", retryable=True)