awerouter 0.2.0__py3-none-any.whl

awerouter/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

awerouter/cli.py

@@ -0,0 +1,224 @@
+"""CLI commands: serve / add / list / show / log / stats / calibrate.
+
+Imports the click group from config.py and extends it.
+"""
+
+import asyncio
+
+import click
+
+from awerouter.config import (
+    cli as config_cli,
+    config_dir,
+    die,
+    format_providers_display,
+    format_routing_display,
+    init_config,
+    load_default_profile,
+    load_for_profile,
+    load_providers,
+    load_routing,
+    providers_path,
+    routing_path,
+    save_profile_entry,
+    save_provider,
+    validate_profiles,
+)
+from awerouter.server import _serve
+
+# Attach config sub-group to the main cli group
+cli = config_cli
+
+
+def _run_serve(profile, port: int, host: str) -> None:
+    if profile:
+        providers, routing, settings = load_for_profile(profile)
+    else:
+        providers, routing, settings = load_default_profile()
+    try:
+        asyncio.run(_serve(host, port, providers, routing, settings))
+    except KeyboardInterrupt:
+        raise SystemExit(0)
+
+
+@cli.command()
+@click.argument("profile", required=False)
+@click.option("--port", default=20128, show_default=True, help="Listen port.")
+@click.option("--host", default="127.0.0.1", show_default=True, help="Bind address.")
+def serve(profile, port: int, host: str):
+    """Start the awerouter daemon for PROFILE.
+
+    PROFILE is a profile id from routing.json. If omitted, auto-selects when only
+    one profile exists.
+    """
+    _run_serve(profile, port, host)
+
+
+@click.command("__serve_profile__", hidden=True)
+@click.option("--port", default=20128, show_default=True, help="Listen port.")
+@click.option("--host", default="127.0.0.1", show_default=True, help="Bind address.")
+@click.pass_context
+def _serve_profile(ctx, port: int, host: str):
+    """Bare profile launch: `awerouter <profile>` == `awerouter serve <profile>`."""
+    _run_serve(ctx.meta["profile_name"], port, host)
+
+
+cli.add_command(_serve_profile)
+
+
+@cli.command("add")
+def add():
+    """Interactively add a routing profile (creates any new providers)."""
+    if not providers_path().exists() or not routing_path().exists():
+        init_config()
+        click.echo(f"initialized config in {config_dir()}")
+    providers_all = load_providers()
+    _, profiles = load_routing()
+
+    name = click.prompt("Profile name")
+    if name in profiles:
+        die(f"profile already exists: {name}")
+    agent = click.prompt("Agent group", type=click.Choice(["claude", "codex", "opencode"]), default="claude")
+    known = set(providers_all.get(agent, {}))
+
+    def ask_tier(tier: str) -> str:
+        hint = ", ".join(sorted(known)) or "none yet"
+        pname = click.prompt(f"{tier} provider ({hint})")
+        if pname not in known:
+            base_url = click.prompt(f"  {pname} base_url")
+            auth_var = click.prompt(f"  {pname} auth env var name (stored as ${{VAR}})")
+            save_provider(agent, pname, base_url, f"${{{auth_var}}}")
+            known.add(pname)
+        model = click.prompt(f"{tier} model id")
+        return f"{pname},{model}"
+
+    flash = ask_tier("flash")
+    pro = ask_tier("pro")
+    threshold = click.prompt("longContextThreshold", default=8000, type=int)
+    save_profile_entry(name, agent, threshold, flash, pro)
+
+    # Fail loudly if the wizard wrote something inconsistent.
+    validate_profiles(load_providers(), load_routing()[1])
+    click.echo(f"Profile '{name}' added: flash={flash}  pro={pro}  L3>{threshold}")
+    click.echo(f"Start it with: awerouter {name}")
+
+
+@cli.command("list")
+def list_profiles():
+    """List routing profiles (name, agent, flash, pro, threshold)."""
+    providers_all = load_providers()
+    _, profiles = load_routing()
+    validate_profiles(providers_all, profiles)
+    for name, p in profiles.items():
+        flash = p.destinations["flash"]
+        pro = p.destinations["pro"]
+        click.echo(
+            f"{name}\t{p.agent}\t{flash.provider_name}/{flash.model}"
+            f"\t{pro.provider_name}/{pro.model}\tL3>{p.long_context_threshold}"
+        )
+
+
+@cli.command()
+@click.argument("profile", required=False)
+def show(profile):
+    """Show PROFILE (or the whole config) with secrets redacted."""
+    providers_all = load_providers()
+    settings, profiles = load_routing()
+    validate_profiles(providers_all, profiles)
+    if not profile:
+        click.echo("providers.json:")
+        click.echo(format_providers_display(providers_all))
+        click.echo()
+        click.echo("routing.json:")
+        click.echo(format_routing_display(settings, profiles))
+        return
+    if profile not in profiles:
+        avail = ", ".join(profiles) or "(none)"
+        die(f"profile '{profile}' not found in routing.json; available: {avail}")
+    p = profiles[profile]
+    used = {d.provider_name: providers_all[p.agent][d.provider_name]
+            for d in p.destinations.values()}
+    click.echo("providers:")
+    click.echo(format_providers_display({p.agent: used}))
+    click.echo()
+    click.echo("profile:")
+    click.echo(format_routing_display(settings, {profile: p}))
+
+
+@cli.command()
+@click.option("--lines", default=20, show_default=True, help="Tail N entries.")
+def log(lines: int):
+    """Show recent request logs."""
+    from awerouter.logging import tail
+    entries = tail(lines)
+    if not entries:
+        click.echo("(no logs yet)")
+        return
+    for e in entries:
+        status_s = str(e.status) if e.status is not None else "-"
+        click.echo(
+            f"{e.ts}  {e.request_id[:12]:12s}  {e.destination:7s}  "
+            f"{e.provider:12s}  {e.model_out:24s}  {e.label:14s}  "
+            f"status={status_s:>3}  {e.ms}ms  {e.bytes}B  "
+            f"tokens={e.token_count}  in={e.model_in}"
+        )
+
+
+@cli.command()
+def stats():
+    """Show aggregated routing stats, grouped by profile."""
+    from awerouter.logging import stats as _stats
+    s = _stats()
+    if not s:
+        click.echo("(no logs yet)")
+        return
+    click.echo(f"total_requests : {s['total_requests']}")
+    click.echo(f"total_bytes    : {s['total_bytes']}")
+    if s["flash_requests"]:
+        click.echo(
+            f"pro input offloaded to flash: ~{s['flash_tokens']} tokens "
+            f"across {s['flash_requests']} requests"
+        )
+        click.echo("  (message tokens only — system prompt & tools excluded; conservative)")
+    for name, p in sorted(s["by_profile"].items()):
+        click.echo()
+        click.echo(f"profile {name}  ({p['requests']} requests, ~{p['flash_tokens']} flash tokens):")
+        click.echo("  by_label:")
+        for k, v in sorted(p["by_label"].items()):
+            click.echo(f"    {k:16s} {v}")
+        click.echo("  by_destination:")
+        for k, v in sorted(p["by_destination"].items()):
+            click.echo(f"    {k:10s} {v}")
+        click.echo("  by_provider:")
+        for k, v in sorted(p["by_provider"].items()):
+            click.echo(f"    {k:16s} {v}")
+
+
+@cli.command()
+def calibrate():
+    """Show L3 token distribution to tune longContextThreshold.
+
+    Only L3 traffic (default/longContext/image labels) is threshold-sensitive;
+    L1 (webSearch) and L2 (background/think) route identically regardless.
+    """
+    from awerouter.logging import token_distribution
+    d = token_distribution()
+    if not d:
+        click.echo("(no L3 traffic yet — run some non-background/think requests first)")
+        return
+    click.echo(f"L3 message-token distribution ({d['n']} requests):")
+    click.echo("  (messages only — system prompt and tools definitions are excluded)")
+    click.echo(f"  min: {d['min']:>7}   p50: {d['p50']:>7}   p75: {d['p75']:>7}")
+    click.echo(f"  p90: {d['p90']:>7}   p95: {d['p95']:>7}   p99: {d['p99']:>7}   max: {d['max']:>7}")
+    click.echo()
+    click.echo("if you set longContextThreshold to:")
+    for c in d["candidates"]:
+        click.echo(f"  {c['threshold']:>7}   → {c['flash_pct']}% flash, {100 - c['flash_pct']}% pro")
+
+
+def main(argv=None):
+    return cli.main(args=argv, prog_name="awerouter")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

awerouter/config.py

@@ -0,0 +1,416 @@
+import json
+import os
+import re
+import shutil
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from urllib.parse import urlparse
+
+from awerouter import __version__
+from awerouter.types import Destination, Provider, RoutingProfile, Settings
+
+# ---------------------------------------------------------------------------
+# Constants (mirror aweswitch cli.py conventions exactly)
+# ---------------------------------------------------------------------------
+
+ENV_REF_RE = re.compile(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}")
+SECRET_RE = re.compile(r"(TOKEN|KEY|SECRET|PASSWORD|AUTH)", re.IGNORECASE)
+
+TEMPLATE_PROVIDERS = Path(__file__).parent / "default-providers.json"
+TEMPLATE_ROUTING = Path(__file__).parent / "default-routing.json"
+
+
+def die(message: str) -> "SystemExit":
+    raise SystemExit(f"awerouter: {message}")
+
+
+def detect_auth_header(base_url: str) -> str:
+    """Auto-detect auth header from base_url.
+
+    anthropic.com endpoints use x-api-key (bare token); everyone else uses
+    Authorization (Bearer prefix added at request time). Matched on netloc,
+    not substring — "https://evil.com/anthropic.com" must not match.
+    """
+    netloc = urlparse(base_url).netloc.lower()
+    is_anthropic = netloc == "api.anthropic.com" or netloc.endswith(".anthropic.com")
+    return "x-api-key" if is_anthropic else "authorization"
+
+
+# ---------------------------------------------------------------------------
+# Path helpers
+# ---------------------------------------------------------------------------
+
+def config_dir() -> Path:
+    return Path(os.environ.get("AWEROUTER_CONFIG_DIR", "~/.config/awerouter")).expanduser()
+
+
+def providers_path() -> Path:
+    return config_dir() / "providers.json"
+
+
+def routing_path() -> Path:
+    return config_dir() / "routing.json"
+
+
+# ---------------------------------------------------------------------------
+# Value helpers (mirror aweswitch exactly)
+# ---------------------------------------------------------------------------
+
+def expand_value(value, env: dict) -> "str | int | float | bool | None":
+    if not isinstance(value, str):
+        return value
+
+    def replace(match):
+        name = match.group(1)
+        if name not in env:
+            die(
+                f"required environment variable not set: {name}\n"
+                f"  Add it to your shell config (e.g. ~/.zshrc or ~/.bashrc), then reload your shell."
+            )
+        return env[name]
+
+    return ENV_REF_RE.sub(replace, value)
+
+
+def redact(data):
+    redacted = json.loads(json.dumps(data))  # deep copy via JSON
+
+    def walk(value, key=""):
+        if isinstance(value, dict):
+            for child_key, child_value in value.items():
+                if SECRET_RE.search(child_key) and isinstance(child_value, str):
+                    value[child_key] = "<redacted>"
+                else:
+                    walk(child_value, child_key)
+        elif isinstance(value, list):
+            for item in value:
+                walk(item, key)
+
+    walk(redacted)
+    return redacted
+
+
+# ---------------------------------------------------------------------------
+# Load / validate
+# ---------------------------------------------------------------------------
+
+def _load_json(path: Path, label: str) -> dict:
+    if not path.exists():
+        die(f"{label} not found: {path}\nrun: awerouter config init")
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        die(f"invalid JSON in {path}: {exc}")
+    if not isinstance(data, dict):
+        die(f"{label} must be a JSON object: {path}")
+    return data
+
+
+def _parse_destination(raw: str) -> Destination:
+    parts = raw.split(",", 1)
+    if len(parts) != 2:
+        die(f"destination must be 'provider,model': {raw}")
+    provider_name, model = parts[0].strip(), parts[1].strip()
+    if not provider_name or not model:
+        die(f"destination must be 'provider,model': {raw}")
+    return Destination(provider_name=provider_name, model=model)
+
+
+def load_providers(path: Optional[Path] = None) -> dict[str, dict[str, Provider]]:
+    """Load providers grouped by agent. Returns {agent: {provider_name: Provider}}."""
+    path = path or providers_path()
+    data = _load_json(path, "providers.json")
+    result: dict[str, dict[str, Provider]] = {}
+    for agent, group in data.items():
+        if not isinstance(group, dict):
+            die(f"agent group '{agent}' must be an object")
+        agent_providers: dict[str, Provider] = {}
+        for name, entry in group.items():
+            if not isinstance(entry, dict):
+                die(f"provider '{agent}.{name}' must be an object")
+            base_url = entry.get("base_url")
+            auth = entry.get("auth")
+            if not base_url or not auth:
+                die(f"provider '{agent}.{name}' missing base_url or auth")
+            auth_header = entry.get("auth_header") or detect_auth_header(base_url)
+            agent_providers[name] = Provider(
+                name=name, base_url=base_url, auth=auth, auth_header=auth_header,
+            )
+        result[agent] = agent_providers
+    return result
+
+
+def load_routing(path: Optional[Path] = None) -> tuple[Settings, dict[str, RoutingProfile]]:
+    """Load global settings + all routing profiles keyed by profile id."""
+    path = path or routing_path()
+    data = _load_json(path, "routing.json")
+
+    # Parse optional global settings (defaults: flash/pro)
+    raw_settings = data.pop("settings", {})
+    if not isinstance(raw_settings, dict):
+        die("routing.json 'settings' must be an object")
+    settings = Settings(
+        background_model=str(raw_settings.get("backgroundModel", "flash")),
+        think_model=str(raw_settings.get("thinkModel", "pro")),
+        web_search_model=str(raw_settings.get("webSearchModel", "pro")),
+    )
+
+    profiles: dict[str, RoutingProfile] = {}
+    for name, body in data.items():
+        if not isinstance(body, dict):
+            die(f"profile '{name}' must be an object")
+        agent = body.get("agent")
+        if not agent:
+            die(f"profile '{name}' missing required 'agent' field")
+        for key in ("longContextThreshold", "destinations"):
+            if key not in body:
+                die(f"profile '{name}' missing required key: {key}")
+        dests_raw = body["destinations"]
+        if not isinstance(dests_raw, dict):
+            die(f"profile '{name}' destinations must be an object")
+        parsed: dict[str, Destination] = {}
+        for tier, raw in dests_raw.items():
+            if tier not in ("flash", "pro"):
+                die(f"profile '{name}' destination key must be flash or pro, got: {tier}")
+            parsed[tier] = _parse_destination(str(raw))
+        profiles[name] = RoutingProfile(
+            name=name,
+            agent=str(agent),
+            long_context_threshold=int(body["longContextThreshold"]),
+            destinations=parsed,
+        )
+    return settings, profiles
+
+
+def resolve_provider(name: str, providers: dict[str, Provider]) -> Provider:
+    if name not in providers:
+        avail = ", ".join(providers) or "(none)"
+        die(f"provider '{name}' not found in this profile's agent group; available: {avail}")
+    return providers[name]
+
+
+def validate_profiles(providers_all: dict, profiles: dict) -> None:
+    """Cross-check every profile's agent and destinations against providers.json.
+
+    Called by both serve and config show, so bad references fail at load time
+    instead of on the first request.
+    """
+    for profile in profiles.values():
+        group = providers_all.get(profile.agent)
+        if group is None:
+            avail = ", ".join(providers_all) or "(none)"
+            die(
+                f"agent '{profile.agent}' (for profile '{profile.name}') not found in "
+                f"providers.json; available: {avail}"
+            )
+        for tier, dest in profile.destinations.items():
+            resolve_provider(dest.provider_name, group)
+
+
+def load_for_profile(name: str) -> tuple[dict[str, Provider], RoutingProfile, Settings]:
+    """Resolve one profile: returns (agent providers, profile, settings)."""
+    providers_all = load_providers()
+    settings, profiles = load_routing()
+    if name not in profiles:
+        avail = ", ".join(profiles) or "(none)"
+        die(f"profile '{name}' not found in routing.json; available: {avail}")
+    profile = profiles[name]
+    validate_profiles(providers_all, {name: profile})
+    return providers_all[profile.agent], profile, settings
+
+
+def load_default_profile() -> tuple[dict[str, Provider], RoutingProfile, Settings]:
+    """Auto-select when only one profile exists; prompt otherwise."""
+    settings, profiles = load_routing()
+    if not profiles:
+        die("no profiles in routing.json")
+    if len(profiles) == 1:
+        return load_for_profile(next(iter(profiles)))
+    die(
+        "multiple profiles available, specify one:\n"
+        f"  awerouter serve <name>\navailable: {', '.join(profiles)}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Init / template
+# ---------------------------------------------------------------------------
+
+def init_config() -> None:
+    d = config_dir()
+    if providers_path().exists() or routing_path().exists():
+        die(f"config already exists in {d}")
+    d.mkdir(parents=True, exist_ok=True)
+    if not TEMPLATE_PROVIDERS.exists() or not TEMPLATE_ROUTING.exists():
+        die("default templates not found next to config.py")
+    shutil.copy2(TEMPLATE_PROVIDERS, providers_path())
+    shutil.copy2(TEMPLATE_ROUTING, routing_path())
+
+
+def save_provider(agent: str, name: str, base_url: str, auth: str) -> None:
+    """Append one provider entry to providers.json."""
+    path = providers_path()
+    data = _load_json(path, "providers.json")
+    group = data.setdefault(agent, {})
+    if name in group:
+        die(f"provider already exists: {agent}.{name}")
+    group[name] = {"base_url": base_url, "auth": auth}
+    path.write_text(json.dumps(data, indent=2) + "\n")
+
+
+def save_profile_entry(
+    name: str, agent: str, long_context_threshold: int, flash: str, pro: str
+) -> None:
+    """Append one profile entry to routing.json. flash/pro are 'provider,model'."""
+    path = routing_path()
+    data = _load_json(path, "routing.json")
+    if name in data:
+        die(f"profile already exists: {name}")
+    data[name] = {
+        "agent": agent,
+        "longContextThreshold": long_context_threshold,
+        "destinations": {"flash": flash, "pro": pro},
+    }
+    path.write_text(json.dumps(data, indent=2) + "\n")
+
+
+# ---------------------------------------------------------------------------
+# Config display
+# ---------------------------------------------------------------------------
+
+def format_providers_display(all_providers: dict[str, dict[str, Provider]]) -> str:
+    display = {}
+    for agent, group in all_providers.items():
+        agent_display = {}
+        for name, p in group.items():
+            entry = {"base_url": p.base_url, "auth_header": p.auth_header}
+            if ENV_REF_RE.fullmatch(str(p.auth)):
+                entry["auth"] = str(p.auth)
+            else:
+                entry["auth"] = "<set>"
+            agent_display[name] = entry
+        display[agent] = agent_display
+    return json.dumps(display, indent=2)
+
+
+def format_routing_display(settings: Settings, profiles: dict[str, RoutingProfile]) -> str:
+    display = {
+        "settings": {
+            "backgroundModel": settings.background_model,
+            "thinkModel": settings.think_model,
+            "webSearchModel": settings.web_search_model,
+        },
+    }
+    for name, p in profiles.items():
+        display[name] = {
+            "agent": p.agent,
+            "longContextThreshold": p.long_context_threshold,
+            "destinations": {
+                k: f"{v.provider_name},{v.model}" for k, v in p.destinations.items()
+            },
+        }
+    return json.dumps(display, indent=2)
+
+
+# ---------------------------------------------------------------------------
+# Click CLI
+# ---------------------------------------------------------------------------
+
+class ProfileGroup(click.Group):
+    """Group where an unknown subcommand is treated as a profile name:
+    `awerouter cc-router-1` == `awerouter serve cc-router-1`.
+
+    Defined commands always win, so profiles named after commands are
+    unreachable via the shorthand (use `serve <name>` for those).
+    """
+
+    def resolve_command(self, ctx, args):
+        try:
+            return super().resolve_command(ctx, args)
+        except click.UsageError:
+            if not args:
+                raise
+            ctx.meta["profile_name"] = args[0]
+            command = self.get_command(ctx, "__serve_profile__")
+            return args[0], command, args[1:]
+
+
+@click.group(
+    cls=ProfileGroup,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.version_option(__version__, "-v", "--version", message="awerouter %(version)s")
+def cli():
+    """Smart LLM router: fast cheap tasks to flash, hard decisions to pro."""
+
+
+@cli.group(context_settings={"help_option_names": ["-h", "--help"]})
+def config():
+    """Manage awerouter config."""
+
+
+@config.command("path")
+def config_path_cmd():
+    """Print config directory path."""
+    click.echo(config_dir())
+
+
+@config.command("show")
+def config_show_cmd():
+    """Show config (secrets redacted)."""
+    providers_all = load_providers()
+    settings, profiles = load_routing()
+    validate_profiles(providers_all, profiles)
+    click.echo("providers.json:" )
+    click.echo(format_providers_display(providers_all))
+    click.echo()
+    click.echo("routing.json:")
+    click.echo(format_routing_display(settings, profiles))
+
+
+@config.command("edit")
+def config_edit_cmd():
+    """Open config dir in $EDITOR (creates default config if missing)."""
+    d = config_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    if not providers_path().exists() or not routing_path().exists():
+        init_config()
+    editor = os.environ.get("VISUAL") or os.environ.get("EDITOR") or shutil.which("nano")
+    if not editor:
+        die("no EDITOR set; edit config manually")
+    import subprocess
+    import sys
+    if os.name == "nt":
+        argv = [editor, str(d)]
+        result = subprocess.run(argv)
+        sys.exit(result.returncode)
+    else:
+        os.execvp(editor, [editor, str(d)])
+
+
+@config.command("init")
+def config_init_cmd():
+    """Create default config from templates."""
+    init_config()
+    click.echo(config_dir())
+
+
+@cli.command("init")
+def init_cmd():
+    """Create default config from templates (same as config init)."""
+    init_config()
+    click.echo(config_dir())
+
+
+def main(argv=None):
+    try:
+        return cli.main(args=argv, prog_name="awerouter")
+    except SystemExit as exc:
+        return int(exc.code) if exc.code is not None else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

awerouter/default-providers.json

@@ -0,0 +1,9 @@
+{
+  "claude": {
+    "stepfun":   { "base_url": "https://api.stepfun.com/step_plan", "auth": "${STEPFUN_AUTH_TOKEN}" },
+    "anthropic": { "base_url": "https://api.anthropic.com",          "auth": "${ANTHROPIC_KEY}" }
+  },
+  "codex": {
+    "stepfun": { "base_url": "https://api.stepfun.com/v1", "auth": "${STEPFUN_AUTH_TOKEN}" }
+  }
+}

awerouter/default-routing.json

@@ -0,0 +1,15 @@
+{
+  "settings": {
+    "backgroundModel": "flash",
+    "thinkModel": "pro",
+    "webSearchModel": "pro"
+  },
+  "cc-router-1": {
+    "agent": "claude",
+    "longContextThreshold": 8000,
+    "destinations": {
+      "flash": "stepfun,step-3.7-flash",
+      "pro":   "anthropic,claude-opus-5"
+    }
+  }
+}