rosetta-llm 0.1.0__py3-none-any.whl

rosetta/__init__.py

@@ -0,0 +1,3 @@
+"""LLM Proxy — Multi-format bidirectional translation service."""
+
+__version__ = "0.1.0"

rosetta/__main__.py

@@ -0,0 +1,78 @@
+"""Entrypoint for `python -m rosetta` and the `rosetta-llm` CLI."""
+
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+
+import uvicorn
+
+from rosetta.app import create_app
+from rosetta.config import load_config
+from rosetta.observability import setup_logging
+
+DEFAULT_CONFIG = str(Path.home() / ".rosetta-llm" / "config.json")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="rosetta-llm",
+        description="Multi-format bidirectional LLM proxy",
+    )
+    parser.add_argument(
+        "--config",
+        "-c",
+        default=os.environ.get("ROSETTA_CONFIG", DEFAULT_CONFIG),
+        help=f"Path to config.json (default: {DEFAULT_CONFIG})",
+    )
+    parser.add_argument(
+        "--host",
+        default=None,
+        help="Bind address (overrides config)",
+    )
+    parser.add_argument(
+        "--port",
+        "-p",
+        type=int,
+        default=None,
+        help="Bind port (overrides config)",
+    )
+    parser.add_argument(
+        "--proxy-headers",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Trust X-Forwarded-* headers from proxies (default: on)",
+    )
+    parser.add_argument(
+        "--forwarded-allow-ips",
+        default="*",
+        help="Allowed forwarded IPs (default: *)",
+    )
+
+    args = parser.parse_args()
+
+    config = load_config(args.config)
+    setup_logging(config.log_level)
+
+    if args.host is not None:
+        config.host = args.host
+    if args.port is not None:
+        config.port = args.port
+
+    app = create_app(config)
+
+    uvicorn.run(
+        app,
+        host=config.host,
+        port=config.port,
+        log_level=config.log_level,
+        access_log=False,
+        log_config=None,
+        proxy_headers=args.proxy_headers,
+        forwarded_allow_ips=args.forwarded_allow_ips,
+    )
+
+
+if __name__ == "__main__":
+    main()

rosetta/app.py

@@ -0,0 +1,74 @@
+"""FastAPI app factory with lifespan management."""
+
+import asyncio
+import contextlib
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from rosetta.auth import AuthMiddleware
+from rosetta.config import Config
+from rosetta.observability import RequestContextMiddleware
+from rosetta.routes.chat_completions import router as chat_router
+from rosetta.routes.health import router as health_router
+from rosetta.routes.messages import router as messages_router
+from rosetta.routes.models import refresh_models
+from rosetta.routes.models import router as models_router
+from rosetta.routes.responses import router as responses_router
+from rosetta.upstream import UpstreamClient
+
+_REFRESH_INTERVAL = 300  # seconds
+
+
+async def _models_refresh_loop(app: FastAPI, interval: float) -> None:
+    while True:
+        try:
+            await asyncio.sleep(interval)
+            await refresh_models(app.state.config, app.state.upstream, app.state.model_snapshot)
+        except asyncio.CancelledError:
+            break
+        except Exception:
+            from rosetta.observability import get_logger
+
+            get_logger().exception("models_refresh_loop_error")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+    app.state.upstream = UpstreamClient(app.state.config.providers)
+    await app.state.upstream.start()
+
+    refresh_task = asyncio.create_task(
+        refresh_models(app.state.config, app.state.upstream, app.state.model_snapshot)
+    )
+    loop_task = asyncio.create_task(_models_refresh_loop(app, _REFRESH_INTERVAL))
+
+    try:
+        yield
+    finally:
+        loop_task.cancel()
+        refresh_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await loop_task
+            await refresh_task
+        await app.state.upstream.close()
+
+
+def create_app(config: Config) -> FastAPI:
+    app = FastAPI(lifespan=lifespan)
+    app.state.config = config
+    app.state.provider_status = {}
+    app.state.model_snapshot = {}
+    app.state.model_refresh_lock = asyncio.Lock()
+
+    app.add_middleware(AuthMiddleware)
+    app.add_middleware(RequestContextMiddleware)
+
+    app.include_router(health_router)
+    app.include_router(messages_router)
+    app.include_router(chat_router)
+    app.include_router(responses_router)
+    app.include_router(models_router)
+
+    return app

rosetta/asgi.py

@@ -0,0 +1,18 @@
+"""ASGI entrypoint — creates the app at module level so uvicorn can import it.
+
+uvicorn rosetta.asgi:app --host 0.0.0.0 --port 7860
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from rosetta.app import create_app
+from rosetta.config import load_config
+from rosetta.observability import setup_logging
+
+config_path = os.environ.get("ROSETTA_CONFIG", str(Path.home() / ".rosetta-llm" / "config.json"))
+config = load_config(config_path)
+setup_logging(config.log_level)
+app = create_app(config)

rosetta/auth.py

@@ -0,0 +1,88 @@
+"""Bearer-token authentication as a pure ASGI middleware.
+
+BaseHTTPMiddleware buffers streaming responses, which would break SSE.
+Implementing as raw ASGI keeps streams flowing chunk-by-chunk.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+import orjson
+
+ASGIApp = Callable[
+    [
+        dict[str, Any],
+        Callable[[], Awaitable[dict[str, Any]]],
+        Callable[[dict[str, Any]], Awaitable[None]],
+    ],
+    Awaitable[None],
+]
+Receive = Callable[[], Awaitable[dict[str, Any]]]
+Send = Callable[[dict[str, Any]], Awaitable[None]]
+
+_PUBLIC_PATHS = frozenset({"/health", "/providers"})
+
+
+class AuthMiddleware:
+    """Strict ASGI middleware that rejects requests lacking a valid bearer token."""
+
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: dict[str, Any], receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        config = scope["app"].state.config
+        keys = set(config.proxy.api_keys)
+        if not keys or scope["path"] in _PUBLIC_PATHS:
+            await self.app(scope, receive, send)
+            return
+
+        headers = {k.decode().lower(): v.decode() for k, v in scope.get("headers", [])}
+        token = ""
+        auth_header = headers.get("authorization", "")
+        if auth_header[:7].lower() == "bearer ":
+            token = auth_header[7:].strip()
+        if not token:
+            token = headers.get("x-api-key", "").strip()
+
+        if token in keys:
+            await self.app(scope, receive, send)
+            return
+
+        body = _error_body(scope["path"])
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 401,
+                "headers": [
+                    (b"content-type", b"application/json"),
+                    (b"content-length", str(len(body)).encode()),
+                ],
+            }
+        )
+        await send({"type": "http.response.body", "body": body})
+
+
+def _error_body(path: str) -> bytes:
+    if path.startswith("/v1/messages"):
+        return orjson.dumps(
+            {
+                "type": "error",
+                "error": {"type": "authentication_error", "message": "Invalid or missing API key"},
+            }
+        )
+    return orjson.dumps(
+        {
+            "error": {
+                "message": "Invalid or missing API key",
+                "type": "authentication_error",
+                "code": None,
+                "param": None,
+            },
+        }
+    )

rosetta/codecs/__init__.py

@@ -0,0 +1 @@
+"""Non-streaming parse/render codecs for each API format."""