switchboard-llm 0.1.0__py3-none-any.whl

switchboard/__init__.py

@@ -0,0 +1,57 @@
+"""switchboard — an OpenAI-compatible LLM router that saves cost without losing quality.
+
+Point any OpenAI client at the switchboard server and it routes each request to
+the cheapest model that can handle it — easy prompts to a small model, hard ones
+to a parallel Mixture-of-Agents — trading a little latency for large savings while
+holding (or beating) frontier-model quality on a representative workload.
+
+Quickstart (library)::
+
+    import asyncio
+    from switchboard import Engine
+
+    async def main():
+        eng = Engine()
+        result = await eng.answer(
+            [{"role": "user", "content": "What is 17 * 23?"}],
+            mode="cost",
+        )
+        print(result.content, result.cost, result.savings_pct)
+        await eng.aclose()
+
+    asyncio.run(main())
+
+Quickstart (OpenAI-compatible server)::
+
+    $ switchboard serve            # http://localhost:8000/v1
+
+    from openai import OpenAI
+    client = OpenAI(base_url="http://localhost:8000/v1", api_key="anything")
+    client.chat.completions.create(model="router-cost", messages=[...])
+
+The gateway is configured via the ``OPENAI_BASE_URL`` and ``OPENAI_API_KEY``
+environment variables (any OpenAI-compatible endpoint that fronts multiple
+providers — e.g. a LiteLLM proxy — works).
+"""
+
+from switchboard.cache import ResponseCache
+from switchboard.classify import Triage, triage
+from switchboard.config import GatewayConfig, cost_usd, price_of
+from switchboard.engine import Engine, RouteResult
+from switchboard.gateway import Completion, Gateway
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Completion",
+    "Engine",
+    "Gateway",
+    "GatewayConfig",
+    "ResponseCache",
+    "RouteResult",
+    "Triage",
+    "__version__",
+    "cost_usd",
+    "price_of",
+    "triage",
+]

switchboard/cache.py

@@ -0,0 +1,56 @@
+"""Exact-match response cache.
+
+The cheapest API call is the one you never make. Repeated/identical prompts
+(very common in agent loops and eval harnesses) return instantly at zero cost.
+A semantic cache (embed the prompt, nearest-neighbour over past prompts) is the
+natural next step — the gateway exposes `gemini-embedding-*` and
+`text-embedding-3-*` for exactly this — but exact-match already captures the
+biggest, safest wins without false hits.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import threading
+import time
+from typing import Any
+
+
+def _key(messages: list[dict], mode: str) -> str:
+    blob = json.dumps({"m": messages, "mode": mode}, sort_keys=True, ensure_ascii=False)
+    return hashlib.sha256(blob.encode("utf-8")).hexdigest()
+
+
+class ResponseCache:
+    def __init__(self, max_items: int = 4096, ttl_seconds: float | None = None):
+        self._store: dict[str, tuple[float, Any]] = {}
+        self._lock = threading.Lock()
+        self._max = max_items
+        self._ttl = ttl_seconds
+        self.hits = 0
+        self.misses = 0
+
+    def get(self, messages: list[dict], mode: str) -> Any | None:
+        k = _key(messages, mode)
+        with self._lock:
+            item = self._store.get(k)
+            if item is None:
+                self.misses += 1
+                return None
+            ts, val = item
+            if self._ttl is not None and (time.time() - ts) > self._ttl:
+                del self._store[k]
+                self.misses += 1
+                return None
+            self.hits += 1
+            return val
+
+    def put(self, messages: list[dict], mode: str, value: Any) -> None:
+        k = _key(messages, mode)
+        with self._lock:
+            if len(self._store) >= self._max and k not in self._store:
+                # drop oldest
+                oldest = min(self._store, key=lambda x: self._store[x][0])
+                del self._store[oldest]
+            self._store[k] = (time.time(), value)

switchboard/classify.py

@@ -0,0 +1,142 @@
+"""Triage: decide how hard a request is, as cheaply as possible.
+
+Two signals, combined:
+  1. Heuristics (free, instant): length, code/math markers, multi-step verbs.
+  2. A tiny LLM classifier (gemini flash-lite, ~$0.0001/call) that reads a
+     truncated prefix of the prompt and returns difficulty 1-5 + domain.
+
+The LLM call is skipped when heuristics are confident (very short trivial
+prompts, or obvious giant code/math prompts), so most requests pay nothing for
+triage. The classifier only earns its keep on the ambiguous middle.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+
+from . import config
+from .gateway import Gateway
+
+_CODE_RE = re.compile(r"```|def |class |import |function |SELECT |#include|=>|console\.|public static")
+_MATH_RE = re.compile(r"\b(prove|integral|derivative|theorem|equation|matrix|probability|\d+\s*[+\-*/^]\s*\d+)\b", re.I)
+_HARD_VERBS = re.compile(
+    r"\b(design|architect|optimi[sz]e|prove|derive|refactor|debug|analy[sz]e|"
+    r"compare|trade-?off|explain why|step by step|plan|strategy|edge cases?)\b",
+    re.I,
+)
+
+DOMAINS = ("code", "math", "reasoning", "factual", "creative", "chat", "other")
+
+
+@dataclass
+class Triage:
+    difficulty: float  # 1.0 (trivial) .. 5.0 (very hard)
+    domain: str
+    tier: str  # "cheap" | "mid" | "hard"
+    source: str  # "heuristic" | "llm"
+    classifier_cost: float = 0.0
+    classifier_ms: float = 0.0
+    note: str = ""
+
+
+def _last_user_text(messages: list[dict]) -> str:
+    for m in reversed(messages):
+        if m.get("role") == "user":
+            c = m.get("content")
+            if isinstance(c, str):
+                return c
+            if isinstance(c, list):  # OpenAI content-parts form
+                return " ".join(p.get("text", "") for p in c if isinstance(p, dict))
+    return ""
+
+
+def _tier_for(difficulty: float) -> str:
+    if difficulty <= 2.0:
+        return "cheap"
+    if difficulty <= 3.4:
+        return "mid"
+    return "hard"
+
+
+def _heuristic(text: str) -> tuple[float, str, bool]:
+    """Return (difficulty_prior, domain_guess, confident)."""
+    n = len(text)
+    code = bool(_CODE_RE.search(text))
+    math = bool(_MATH_RE.search(text))
+    hard = len(_HARD_VERBS.findall(text))
+
+    domain = "chat"
+    if code:
+        domain = "code"
+    elif math:
+        domain = "math"
+    elif hard:
+        domain = "reasoning"
+
+    # Very short and no complexity markers -> confidently trivial.
+    if n < 80 and not (code or math or hard):
+        return 1.5, domain, True
+    # Huge prompt with code/math and multiple hard verbs -> confidently hard.
+    if (n > 2500 or hard >= 3) and (code or math or hard >= 2):
+        return 4.5, domain, True
+
+    # Otherwise produce a prior but defer to the LLM.
+    prior = 2.0
+    prior += min(n / 1500.0, 1.5)
+    prior += 0.6 * min(hard, 3)
+    prior += 0.5 if code else 0.0
+    prior += 0.5 if math else 0.0
+    return max(1.0, min(prior, 5.0)), domain, False
+
+
+_CLASSIFIER_SYS = (
+    "You are a fast request-difficulty classifier for an LLM router. "
+    "Read the user request and rate how powerful a model it needs. "
+    "Respond with ONLY a compact JSON object, no prose:\n"
+    '{"difficulty": <1-5 int>, "domain": "code|math|reasoning|factual|creative|chat|other"}\n'
+    "Scale: 1=trivial (greeting, lookup), 2=easy (short factual, simple rewrite), "
+    "3=moderate (normal coding/explanation), 4=hard (multi-step reasoning, non-trivial "
+    "code, careful analysis), 5=very hard (research-grade proof, complex system design)."
+)
+
+
+async def triage(gw: Gateway, messages: list[dict], *, use_llm: bool = True) -> Triage:
+    text = _last_user_text(messages)
+    prior, domain, confident = _heuristic(text)
+
+    if confident or not use_llm:
+        return Triage(
+            prior, domain, _tier_for(prior), "heuristic", note="heuristic-confident" if confident else "llm-disabled"
+        )
+
+    prefix = text[:1800]
+    comp = await gw.complete(
+        config.CLASSIFIER_MODEL,
+        [
+            {"role": "system", "content": _CLASSIFIER_SYS},
+            {"role": "user", "content": f"Request prefix (len={len(text)} chars):\n{prefix}"},
+        ],
+        max_tokens=40,
+    )
+
+    difficulty, dom = prior, domain
+    if comp.ok:
+        try:
+            m = re.search(r"\{.*\}", comp.content, re.S)
+            obj = json.loads(m.group(0)) if m else {}
+            d = float(obj.get("difficulty", prior))
+            difficulty = 0.5 * d + 0.5 * prior  # blend model judgement with prior
+            dom = obj.get("domain", domain) if obj.get("domain") in DOMAINS else domain
+        except Exception:  # noqa: BLE001
+            difficulty = prior
+
+    return Triage(
+        difficulty=difficulty,
+        domain=dom,
+        tier=_tier_for(difficulty),
+        source="llm",
+        classifier_cost=comp.cost,
+        classifier_ms=comp.latency_ms,
+    )

switchboard/cli.py

@@ -0,0 +1,106 @@
+"""Command-line interface for switchboard.
+
+switchboard serve [--host H] [--port P]   run the OpenAI-compatible server
+switchboard ask "<prompt>" [--mode cost]  route one prompt and print telemetry
+switchboard models                        probe which gateway models are live
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+
+
+def _cmd_serve(args: argparse.Namespace) -> int:
+    from switchboard.server import run
+
+    run(host=args.host, port=args.port)
+    return 0
+
+
+def _cmd_ask(args: argparse.Namespace) -> int:
+    from switchboard.engine import Engine
+
+    async def go() -> int:
+        eng = Engine()
+        try:
+            rr = await eng.answer(
+                [{"role": "user", "content": args.prompt}],
+                mode=args.mode,
+                max_tokens=args.max_tokens,
+            )
+        finally:
+            await eng.aclose()
+        print(rr.content)
+        print(
+            f"\n[route={rr.route} | cost=${rr.cost:.6f} "
+            f"| baseline(opus)≈${rr.baseline_cost_est:.6f} "
+            f"| savings={rr.savings_pct:.1f}% | {rr.latency_ms:.0f}ms]",
+            file=sys.stderr,
+        )
+        return 0
+
+    return asyncio.run(go())
+
+
+def _cmd_models(args: argparse.Namespace) -> int:
+    from switchboard import config
+    from switchboard.gateway import Gateway
+
+    async def go() -> int:
+        pool = sorted(
+            set(
+                config.CHEAP
+                + config.MID
+                + config.STRONG
+                + [config.CLASSIFIER_MODEL, config.JUDGE_MODEL, config.DEFAULT_CHEAP, config.DEFAULT_MID]
+                + config.MOA_PROPOSERS
+                + [config.MOA_SYNTHESIZER]
+                + config.BASELINE_MODELS
+            )
+        )
+        gw = Gateway()
+
+        async def probe(m: str):
+            c = await gw.complete(m, [{"role": "user", "content": "Reply with one word: ok"}], max_tokens=300)
+            return m, c.ok, "" if c.ok else (c.error or "")[:90]
+
+        results = await asyncio.gather(*(probe(m) for m in pool))
+        await gw.aclose()
+        bad = [r for r in results if not r[1]]
+        for m, ok, err in results:
+            print(f"  {'OK  ' if ok else 'FAIL'} {m:<26}{'' if ok else '  <- ' + err}")
+        print(
+            f"\n{len(results) - len(bad)}/{len(results)} live."
+            + (f"  BROKEN: {[b[0] for b in bad]}" if bad else "  all good.")
+        )
+        return 1 if bad else 0
+
+    return asyncio.run(go())
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="switchboard", description="OpenAI-compatible LLM router.")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_serve = sub.add_parser("serve", help="run the OpenAI-compatible server")
+    p_serve.add_argument("--host", default="0.0.0.0")
+    p_serve.add_argument("--port", type=int, default=8000)
+    p_serve.set_defaults(func=_cmd_serve)
+
+    p_ask = sub.add_parser("ask", help="route one prompt and print the answer + telemetry")
+    p_ask.add_argument("prompt")
+    p_ask.add_argument("--mode", default="balanced", choices=["balanced", "cost", "quality"])
+    p_ask.add_argument("--max-tokens", type=int, default=1024, dest="max_tokens")
+    p_ask.set_defaults(func=_cmd_ask)
+
+    p_models = sub.add_parser("models", help="probe which gateway models are actually live")
+    p_models.set_defaults(func=_cmd_models)
+
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

switchboard/config.py

@@ -0,0 +1,112 @@
+"""Model pool, pricing and routing tiers.
+
+IMPORTANT: the prices below are *public list-price proxies* in USD per 1M
+tokens. They are roughly correct relative to each other (which is what makes
+the routing decisions sensible), but they are almost certainly NOT what your
+gateway actually bills you. Drop your real rate card into `pricing.json`
+in the repo root and it will override these at load time.
+
+The whole point of the router is the *ratios* between tiers: a cheap model is
+~10-50x cheaper than Opus, a mid model ~3-10x cheaper. As long as those ratios
+hold, the cost story holds.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+
+# --------------------------------------------------------------------------- #
+# Pricing: USD per 1,000,000 tokens (input, output).
+# --------------------------------------------------------------------------- #
+_DEFAULT_PRICING: dict[str, tuple[float, float]] = {
+    # cheap tier
+    "gemini-3.1-flash-lite": (0.10, 0.40),
+    "gpt-5-nano": (0.05, 0.40),
+    "claude-haiku-4-5": (1.00, 5.00),
+    # mid tier
+    "gemini-3.5-flash": (0.30, 2.50),
+    "gpt-5.4-mini": (0.25, 2.00),
+    "claude-sonnet-4-6": (3.00, 15.00),
+    # strong tier (escalation targets + baselines)
+    "claude-opus-4-8": (15.00, 75.00),
+    "claude-fable-5": (15.00, 75.00),  # placeholder — real price unknown
+    "gpt-5.5": (1.25, 10.00),
+    "gemini-3.1-pro-preview": (1.25, 10.00),
+}
+
+
+def _load_pricing() -> dict[str, tuple[float, float]]:
+    pricing = dict(_DEFAULT_PRICING)
+    path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "pricing.json")
+    if os.path.exists(path):
+        try:
+            with open(path) as f:
+                override = json.load(f)
+            for k, v in override.items():
+                pricing[k] = (float(v[0]), float(v[1]))
+        except Exception as e:  # noqa: BLE001 - best effort, never crash on bad file
+            print(f"[config] warning: could not load pricing.json: {e}")
+    return pricing
+
+
+PRICING = _load_pricing()
+
+
+def price_of(model: str) -> tuple[float, float]:
+    """(input, output) USD per 1M tokens. Falls back to a mid-tier guess."""
+    return PRICING.get(model, (1.0, 5.0))
+
+
+def cost_usd(model: str, prompt_tokens: int, completion_tokens: int) -> float:
+    pin, pout = price_of(model)
+    return (prompt_tokens / 1e6) * pin + (completion_tokens / 1e6) * pout
+
+
+# --------------------------------------------------------------------------- #
+# Tiers and pools. Edit these to change routing behaviour.
+# --------------------------------------------------------------------------- #
+# NOTE: the gateway's /v1/models list is stale — it advertises some ids that
+# 404 at call time (e.g. gemini-3-pro-preview, claude-fable-5 -> "use Opus 4.8").
+# Every model below has been verified to actually answer. Run
+# `switchboard models` to re-check after any edit.
+CHEAP = ["gemini-3.1-flash-lite", "gpt-5-nano", "claude-haiku-4-5"]
+MID = ["gemini-3.5-flash", "gpt-5.4-mini", "claude-sonnet-4-6"]
+STRONG = ["claude-opus-4-8", "gpt-5.5", "gemini-3.1-pro-preview"]
+
+# Reliable, cheap, low-latency model used for triage + judging. Gemini
+# flash-lite was the most reliable for short structured outputs in testing
+# (gpt-5-nano spent its whole budget on hidden reasoning and returned empty).
+CLASSIFIER_MODEL = "gemini-3.1-flash-lite"
+JUDGE_MODEL = "gemini-3.1-flash-lite"
+
+# Default single-model picks per tier.
+DEFAULT_CHEAP = "gemini-3.1-flash-lite"
+DEFAULT_MID = "gemini-3.5-flash"
+
+# Mixture-of-Agents (used for the hard tier). Diverse *providers* give
+# diversity without needing temperature (gpt-5 reasoning models reject
+# non-default temperature anyway).
+MOA_PROPOSERS = ["gemini-3.5-flash", "gpt-5.4-mini", "claude-haiku-4-5"]
+MOA_SYNTHESIZER = "claude-sonnet-4-6"
+
+# Baselines we benchmark the router against ("always use the big model").
+# claude-fable-5 is advertised by the gateway but 404s ("use Opus 4.8"), so the
+# practical frontier baseline here is Opus 4.8.
+BASELINE_MODELS = ["claude-opus-4-8"]
+PRIMARY_BASELINE = "claude-opus-4-8"
+
+
+@dataclass
+class GatewayConfig:
+    base_url: str
+    api_key: str
+
+    @classmethod
+    def from_env(cls) -> GatewayConfig:
+        base = os.environ.get("OPENAI_BASE_URL", "").rstrip("/")
+        key = os.environ.get("OPENAI_API_KEY", "")
+        if not base or not key:
+            raise RuntimeError("OPENAI_BASE_URL and OPENAI_API_KEY must be set in the environment.")
+        return cls(base_url=base, api_key=key)

switchboard/engine.py

@@ -0,0 +1,283 @@
+"""The router engine: triage -> policy -> execute -> telemetry.
+
+Three strategies are composed by the policy:
+
+  single      one model answers (trivial / moderate traffic — the common case).
+  moa         Mixture-of-Agents: N diverse models propose in parallel, a
+              synthesizer fuses them. This is the lever that can *beat* a single
+              frontier model on hard queries, at well below frontier cost.
+  cascade     FrugalGPT-style: answer cheap, a cheap judge scores it, escalate
+              only if the score is low. Minimises spend on the easy majority.
+
+Every result reports its internal cost and an estimate of what always-Opus
+would have cost, so savings are measured, not asserted.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+from dataclasses import dataclass, field
+
+from . import config
+from .cache import ResponseCache
+from .classify import Triage, triage
+from .gateway import Completion, Gateway
+
+
+@dataclass
+class RouteResult:
+    content: str
+    route: str
+    tier: str
+    models_used: list[str]
+    prompt_tokens: int
+    completion_tokens: int
+    cost: float
+    baseline_cost_est: float
+    savings_pct: float
+    latency_ms: float
+    cached: bool
+    triage: Triage
+    steps: list[dict] = field(default_factory=list)
+
+
+_JUDGE_SYS = (
+    "You are a strict answer-quality judge. Given a user request and a candidate "
+    "answer, rate how fully and correctly the answer satisfies the request. "
+    'Respond ONLY with JSON: {"score": <0.0-1.0>, "reason": "<short>"}. '
+    "0.0 = wrong/empty/evasive, 1.0 = complete and correct."
+)
+
+_SYNTH_SYS = (
+    "You are an expert synthesizer in a Mixture-of-Agents system. You are given a "
+    "user request and several candidate answers from different models. The "
+    "candidates may be uneven or partly wrong. Critically compare them, discard "
+    "errors, and produce a single best answer that is more accurate and complete "
+    "than any individual candidate. Do not mention the candidates or the process; "
+    "just give the final answer to the user."
+)
+
+
+def _user_request_text(messages: list[dict]) -> str:
+    parts = []
+    for m in messages:
+        role = m.get("role")
+        c = m.get("content")
+        if isinstance(c, list):
+            c = " ".join(p.get("text", "") for p in c if isinstance(p, dict))
+        if role in ("user", "system") and c:
+            parts.append(f"{role}: {c}")
+    return "\n".join(parts)[:6000]
+
+
+class Engine:
+    def __init__(self, gateway: Gateway | None = None, cache: ResponseCache | None = None):
+        self.gw = gateway or Gateway()
+        self.cache = cache if cache is not None else ResponseCache()
+
+    async def aclose(self) -> None:
+        await self.gw.aclose()
+
+    # ---- primitives ------------------------------------------------------- #
+    async def _single(self, model: str, messages: list[dict], max_tokens: int) -> Completion:
+        return await self.gw.complete(model, messages, max_tokens=max_tokens)
+
+    async def _judge(self, messages: list[dict], answer: str) -> tuple[float, Completion]:
+        req = _user_request_text(messages)
+        comp = await self.gw.complete(
+            config.JUDGE_MODEL,
+            [
+                {"role": "system", "content": _JUDGE_SYS},
+                {"role": "user", "content": f"REQUEST:\n{req}\n\nANSWER:\n{answer[:4000]}"},
+            ],
+            max_tokens=60,
+        )
+        score = 0.5
+        if comp.ok:
+            try:
+                m = re.search(r"\{.*\}", comp.content, re.S)
+                score = float(json.loads(m.group(0)).get("score", 0.5)) if m else 0.5
+            except Exception:  # noqa: BLE001
+                score = 0.5
+        return max(0.0, min(score, 1.0)), comp
+
+    async def _moa(
+        self, messages: list[dict], proposers: list[str], synthesizer: str, max_tokens: int
+    ) -> tuple[Completion, list[Completion]]:
+        # Fan out proposers concurrently — this is the parallelism that keeps MoA
+        # from being N times slower; wall-clock ≈ slowest proposer + synthesizer.
+        proposals = await asyncio.gather(*(self.gw.complete(m, messages, max_tokens=max_tokens) for m in proposers))
+        good = [p for p in proposals if p.ok]
+        if not good:
+            # everything failed; fall back to a single mid model
+            fb = await self._single(config.DEFAULT_MID, messages, max_tokens)
+            return fb, list(proposals)
+
+        req = _user_request_text(messages)
+        bundle = "\n\n".join(f"--- Candidate {i + 1} (model {p.model}) ---\n{p.content}" for i, p in enumerate(good))
+        synth = await self.gw.complete(
+            synthesizer,
+            [
+                {"role": "system", "content": _SYNTH_SYS},
+                {"role": "user", "content": f"USER REQUEST:\n{req}\n\nCANDIDATE ANSWERS:\n{bundle}"},
+            ],
+            max_tokens=max_tokens,
+        )
+        return synth, list(proposals)
+
+    # ---- top-level -------------------------------------------------------- #
+    async def answer(
+        self,
+        messages: list[dict],
+        *,
+        mode: str = "balanced",
+        max_tokens: int = 1024,
+        use_llm_triage: bool = True,
+        use_cache: bool = True,
+    ) -> RouteResult:
+        loop = asyncio.get_event_loop()
+        t_start = loop.time()
+
+        if use_cache:
+            cached = self.cache.get(messages, mode)
+            if cached is not None:
+                c: RouteResult = cached
+                return RouteResult(**{**c.__dict__, "cached": True, "latency_ms": 0.0})
+
+        tri = await triage(self.gw, messages, use_llm=use_llm_triage)
+        steps: list[dict] = [{"stage": "triage", **_triage_dict(tri)}]
+
+        spent = tri.classifier_cost
+        models_used: list[str] = []
+
+        # ------------------------------------------------------------------ #
+        # Policy
+        # ------------------------------------------------------------------ #
+        if mode == "cost":
+            final, extra_cost, used, route = await self._cascade(messages, tri, max_tokens, steps)
+            spent += extra_cost
+            models_used += used
+        else:
+            tier = tri.tier
+            if mode == "quality":  # bias one tier up
+                tier = {"cheap": "mid", "mid": "hard", "hard": "hard"}[tier]
+
+            if tier == "cheap":
+                comp = await self._single(config.DEFAULT_CHEAP, messages, max_tokens)
+                final, route, used = comp, f"single:{config.DEFAULT_CHEAP}", [config.DEFAULT_CHEAP]
+                spent += comp.cost
+                steps.append(_step("single", comp))
+            elif tier == "mid":
+                comp = await self._single(config.DEFAULT_MID, messages, max_tokens)
+                final, route, used = comp, f"single:{config.DEFAULT_MID}", [config.DEFAULT_MID]
+                spent += comp.cost
+                steps.append(_step("single", comp))
+            else:  # hard -> Mixture-of-Agents
+                synth, props = await self._moa(messages, config.MOA_PROPOSERS, config.MOA_SYNTHESIZER, max_tokens)
+                used = [p.model for p in props] + [config.MOA_SYNTHESIZER]
+                route = f"moa[{'+'.join(config.MOA_PROPOSERS)}]->{config.MOA_SYNTHESIZER}"
+                spent += sum(p.cost for p in props) + synth.cost
+                for p in props:
+                    steps.append(_step("moa-proposer", p))
+                steps.append(_step("moa-synth", synth))
+                final = synth
+            models_used += used
+
+        # ------------------------------------------------------------------ #
+        # Telemetry + baseline comparison
+        # ------------------------------------------------------------------ #
+        rep_pt = final.prompt_tokens or _est_tokens(messages)
+        rep_ct = final.completion_tokens or _est_tokens_text(final.content)
+        baseline = config.cost_usd(config.PRIMARY_BASELINE, rep_pt, rep_ct)
+        savings = (1 - spent / baseline) * 100 if baseline > 0 else 0.0
+
+        result = RouteResult(
+            content=final.content,
+            route=route,
+            tier=tri.tier,
+            models_used=models_used,
+            prompt_tokens=rep_pt,
+            completion_tokens=rep_ct,
+            cost=spent,
+            baseline_cost_est=baseline,
+            savings_pct=savings,
+            latency_ms=(loop.time() - t_start) * 1000,
+            cached=False,
+            triage=tri,
+            steps=steps,
+        )
+        if use_cache and final.ok:
+            self.cache.put(messages, mode, result)
+        return result
+
+    async def _cascade(
+        self, messages: list[dict], tri: Triage, max_tokens: int, steps: list[dict]
+    ) -> tuple[Completion, float, list[str], str]:
+        """FrugalGPT cascade: cheap -> judge -> mid -> judge -> MoA."""
+        spent = 0.0
+        used: list[str] = []
+
+        c1 = await self._single(config.DEFAULT_CHEAP, messages, max_tokens)
+        spent += c1.cost
+        used.append(config.DEFAULT_CHEAP)
+        steps.append(_step("cascade-cheap", c1))
+        s1, j1 = await self._judge(messages, c1.content)
+        spent += j1.cost
+        steps.append({"stage": "cascade-judge", "score": round(s1, 3), "cost": j1.cost})
+        if c1.ok and s1 >= 0.70:
+            return c1, spent, used, f"cascade:single:{config.DEFAULT_CHEAP}(score={s1:.2f})"
+
+        c2 = await self._single(config.DEFAULT_MID, messages, max_tokens)
+        spent += c2.cost
+        used.append(config.DEFAULT_MID)
+        steps.append(_step("cascade-mid", c2))
+        s2, j2 = await self._judge(messages, c2.content)
+        spent += j2.cost
+        steps.append({"stage": "cascade-judge", "score": round(s2, 3), "cost": j2.cost})
+        if c2.ok and s2 >= 0.65:
+            return c2, spent, used, f"cascade:single:{config.DEFAULT_MID}(score={s2:.2f})"
+
+        synth, props = await self._moa(messages, config.MOA_PROPOSERS, config.MOA_SYNTHESIZER, max_tokens)
+        spent += sum(p.cost for p in props) + synth.cost
+        used += [p.model for p in props] + [config.MOA_SYNTHESIZER]
+        for p in props:
+            steps.append(_step("cascade-moa-proposer", p))
+        steps.append(_step("cascade-moa-synth", synth))
+        return synth, spent, used, f"cascade:moa->{config.MOA_SYNTHESIZER}"
+
+
+# --------------------------------------------------------------------------- #
+# helpers
+# --------------------------------------------------------------------------- #
+def _est_tokens(messages: list[dict]) -> int:
+    txt = _user_request_text(messages)
+    return max(1, len(txt) // 4)
+
+
+def _est_tokens_text(text: str) -> int:
+    return max(1, len(text) // 4)
+
+
+def _triage_dict(t: Triage) -> dict:
+    return {
+        "difficulty": round(t.difficulty, 2),
+        "domain": t.domain,
+        "tier": t.tier,
+        "source": t.source,
+        "cost": round(t.classifier_cost, 8),
+    }
+
+
+def _step(stage: str, c: Completion) -> dict:
+    return {
+        "stage": stage,
+        "model": c.model,
+        "ok": c.ok,
+        "prompt_tokens": c.prompt_tokens,
+        "completion_tokens": c.completion_tokens,
+        "cost": c.cost,
+        "latency_ms": round(c.latency_ms, 1),
+        "error": c.error,
+    }

switchboard/gateway.py

@@ -0,0 +1,124 @@
+"""Async client for the OpenAI-compatible gateway.
+
+One client addresses every model — OpenAI, Anthropic and Google — by just
+swapping the `model` field. This is what makes the router simple: it is just a
+policy on top of a single `complete()` call.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+
+import httpx
+
+from . import config
+
+
+@dataclass
+class Completion:
+    model: str
+    content: str
+    prompt_tokens: int
+    completion_tokens: int
+    cost: float
+    latency_ms: float
+    finish_reason: str = ""
+    error: str | None = None
+    raw: dict = field(default_factory=dict, repr=False)
+
+    @property
+    def ok(self) -> bool:
+        return self.error is None and bool(self.content.strip())
+
+
+# gpt-5* reasoning models bill hidden reasoning tokens against the completion
+# budget and return empty content if the budget is too small. We give them
+# headroom and retry once with a bigger budget if they come back empty.
+def _is_reasoning_model(model: str) -> bool:
+    return model.startswith("gpt-5") or model.startswith("o3") or model.startswith("o4")
+
+
+class Gateway:
+    def __init__(self, cfg: config.GatewayConfig | None = None, *, concurrency: int = 24):
+        self.cfg = cfg or config.GatewayConfig.from_env()
+        self._client = httpx.AsyncClient(
+            base_url=self.cfg.base_url,
+            headers={
+                "Authorization": f"Bearer {self.cfg.api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=httpx.Timeout(120.0, connect=10.0),
+            limits=httpx.Limits(max_connections=concurrency),
+        )
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    async def complete(
+        self,
+        model: str,
+        messages: list[dict],
+        *,
+        max_tokens: int = 1024,
+        temperature: float | None = None,
+        retries: int = 2,
+    ) -> Completion:
+        # gpt-5 reasoning models need extra headroom; everyone gets at least the ask.
+        budget = max_tokens
+        if _is_reasoning_model(model):
+            budget = max(max_tokens, 1024) + 1024  # room for hidden reasoning
+
+        last_err = "unknown error"
+        for attempt in range(retries + 1):
+            payload: dict = {
+                "model": model,
+                "messages": messages,
+                "max_completion_tokens": budget,
+            }
+            # gpt-5 reasoning models reject non-default temperature.
+            if temperature is not None and not _is_reasoning_model(model):
+                payload["temperature"] = temperature
+
+            t0 = time.perf_counter()
+            try:
+                r = await self._client.post("/chat/completions", json=payload)
+                dt = (time.perf_counter() - t0) * 1000
+                if r.status_code != 200:
+                    last_err = f"HTTP {r.status_code}: {r.text[:200]}"
+                    # 4xx other than rate limit won't fix on retry
+                    if r.status_code not in (408, 409, 425, 429, 500, 502, 503, 504):
+                        return Completion(model, "", 0, 0, 0.0, dt, error=last_err)
+                    continue
+                data = r.json()
+            except Exception as e:  # noqa: BLE001
+                dt = (time.perf_counter() - t0) * 1000
+                last_err = f"{type(e).__name__}: {e}"
+                continue
+
+            choice = (data.get("choices") or [{}])[0]
+            content = (choice.get("message") or {}).get("content") or ""
+            finish = choice.get("finish_reason") or ""
+            usage = data.get("usage") or {}
+            pt = int(usage.get("prompt_tokens", 0))
+            ct = int(usage.get("completion_tokens", 0))
+            cost = config.cost_usd(model, pt, ct)
+
+            # Empty content because the reasoning model ran out of budget — retry bigger.
+            if not content.strip() and finish == "length" and attempt < retries:
+                budget *= 2
+                last_err = "empty content (finish_reason=length)"
+                continue
+
+            return Completion(
+                model=model,
+                content=content,
+                prompt_tokens=pt,
+                completion_tokens=ct,
+                cost=cost,
+                latency_ms=dt,
+                finish_reason=finish,
+                raw=data,
+            )
+
+        return Completion(model, "", 0, 0, 0.0, 0.0, error=last_err)

switchboard/server.py

@@ -0,0 +1,190 @@
+"""OpenAI-compatible HTTP server in front of the router.
+
+Point any OpenAI client at it and it Just Works::
+
+    client = OpenAI(base_url="http://localhost:8000/v1", api_key="anything")
+    client.chat.completions.create(model="router", messages=[...])
+
+Virtual models:
+    router / router-balanced   triage -> single (easy) or Mixture-of-Agents (hard)
+    router-cost                FrugalGPT cascade (cheapest; escalate on low score)
+    router-quality             bias one tier up (best quality under Opus cost)
+
+Any *real* model id (e.g. "claude-opus-4-8", "gemini-3-pro-preview") is passed
+straight through to the gateway, so this also works as a plain proxy.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from switchboard.engine import Engine
+
+MODE_BY_MODEL = {
+    "router": "balanced",
+    "router-balanced": "balanced",
+    "router-cost": "cost",
+    "router-quality": "quality",
+}
+
+# Key under which router telemetry is attached to each response (ignored by
+# standard OpenAI clients).
+META_KEY = "switchboard"
+
+
+@asynccontextmanager
+async def _lifespan(app: FastAPI):
+    app.state.engine = Engine()
+    try:
+        yield
+    finally:
+        await app.state.engine.aclose()
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(title="switchboard", version="0.1.0", lifespan=_lifespan)
+
+    @app.get("/healthz")
+    async def healthz() -> dict:
+        return {"ok": True}
+
+    @app.get("/v1/models")
+    async def models() -> JSONResponse:
+        virtual = [{"id": m, "object": "model", "owned_by": "switchboard"} for m in MODE_BY_MODEL]
+        return JSONResponse({"object": "list", "data": virtual})
+
+    @app.post("/v1/chat/completions")
+    async def chat_completions(request: Request):
+        engine: Engine = request.app.state.engine
+        body = await request.json()
+        model = body.get("model", "router")
+        messages = body.get("messages", [])
+        stream = bool(body.get("stream", False))
+        max_tokens = int(body.get("max_completion_tokens") or body.get("max_tokens") or 1024)
+
+        # Real model id -> transparent proxy.
+        if model not in MODE_BY_MODEL:
+            comp = await engine.gw.complete(model, messages, max_tokens=max_tokens, temperature=body.get("temperature"))
+            if not comp.ok and comp.error:
+                return JSONResponse({"error": {"message": comp.error}}, status_code=502)
+            shim = _ProxyResult(comp, model)
+            if stream:
+                return StreamingResponse(_sse_chunks(shim, model), media_type="text/event-stream")
+            return JSONResponse(_openai_response(shim, model))
+
+        rr = await engine.answer(messages, mode=MODE_BY_MODEL[model], max_tokens=max_tokens)
+        if stream:
+            return StreamingResponse(_sse_chunks(rr, model), media_type="text/event-stream")
+        return JSONResponse(_openai_response(rr, model))
+
+    return app
+
+
+class _ProxyResult:
+    """Adapts a raw Completion to the RouteResult-ish shape the formatter expects."""
+
+    def __init__(self, comp, model: str):
+        self.content = comp.content
+        self.route = f"proxy:{model}"
+        self.tier = "n/a"
+        self.models_used = [model]
+        self.prompt_tokens = comp.prompt_tokens
+        self.completion_tokens = comp.completion_tokens
+        self.cost = comp.cost
+        self.baseline_cost_est = comp.cost
+        self.savings_pct = 0.0
+        self.latency_ms = comp.latency_ms
+        self.cached = False
+        self.steps: list = []
+
+
+def _openai_response(rr, model_label: str) -> dict:
+    return {
+        "id": f"chatcmpl-{uuid.uuid4().hex[:24]}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model_label,
+        "choices": [
+            {
+                "index": 0,
+                "message": {"role": "assistant", "content": rr.content},
+                "finish_reason": "stop",
+            }
+        ],
+        "usage": {
+            "prompt_tokens": rr.prompt_tokens,
+            "completion_tokens": rr.completion_tokens,
+            "total_tokens": rr.prompt_tokens + rr.completion_tokens,
+        },
+        META_KEY: {
+            "route": rr.route,
+            "tier": rr.tier,
+            "models_used": rr.models_used,
+            "cost_usd": round(rr.cost, 8),
+            "baseline_opus_cost_usd": round(rr.baseline_cost_est, 8),
+            "savings_pct": round(rr.savings_pct, 1),
+            "latency_ms": round(rr.latency_ms, 1),
+            "cached": rr.cached,
+            "steps": rr.steps,
+        },
+    }
+
+
+def _sse_chunks(rr, model_label: str):
+    cid = f"chatcmpl-{uuid.uuid4().hex[:24]}"
+    created = int(time.time())
+
+    def frame(delta: dict, finish=None) -> str:
+        return (
+            "data: "
+            + json.dumps(
+                {
+                    "id": cid,
+                    "object": "chat.completion.chunk",
+                    "created": created,
+                    "model": model_label,
+                    "choices": [{"index": 0, "delta": delta, "finish_reason": finish}],
+                }
+            )
+            + "\n\n"
+        )
+
+    yield frame({"role": "assistant"})
+    # We compute the full answer first (MoA can't truly stream), then chunk it
+    # so streaming clients still work.
+    text = rr.content
+    step = max(1, len(text) // 40)
+    for i in range(0, len(text), step):
+        yield frame({"content": text[i : i + step]})
+    yield frame({}, finish="stop")
+    yield (
+        "data: "
+        + json.dumps(
+            {
+                META_KEY: {
+                    "route": rr.route,
+                    "cost_usd": round(rr.cost, 8),
+                    "baseline_opus_cost_usd": round(rr.baseline_cost_est, 8),
+                    "savings_pct": round(rr.savings_pct, 1),
+                }
+            }
+        )
+        + "\n\n"
+    )
+    yield "data: [DONE]\n\n"
+
+
+# Module-level app for `uvicorn switchboard.server:app`.
+app = create_app()
+
+
+def run(host: str = "0.0.0.0", port: int = 8000) -> None:
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)

switchboard_llm-0.1.0.dist-info/METADATA

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: switchboard-llm
+Version: 0.1.0
+Summary: An OpenAI-compatible LLM router that saves cost without losing quality.
+Project-URL: Homepage, https://github.com/archit0/switchboard
+Project-URL: Repository, https://github.com/archit0/switchboard
+Project-URL: Issues, https://github.com/archit0/switchboard/issues
+Author: Archit Dwivedi
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anthropic,cost,frugalgpt,gateway,gemini,llm,mixture-of-agents,openai,router
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Requires-Dist: uvicorn[standard]>=0.29
+Description-Content-Type: text/markdown
+
+# switchboard
+
+[![CI](https://github.com/archit0/switchboard/actions/workflows/ci.yml/badge.svg)](https://github.com/archit0/switchboard/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/switchboard-llm.svg)](https://pypi.org/project/switchboard-llm/)
+
+An **OpenAI-compatible LLM router** that saves cost without losing quality. Point
+any OpenAI client at it and it routes each request to the cheapest model that can
+handle it — easy prompts to a small model, hard ones to a parallel
+**Mixture-of-Agents** — trading a little latency for large savings while holding
+(or beating) frontier-model quality on a representative workload.
+
+```python
+from openai import OpenAI
+client = OpenAI(base_url="http://localhost:8000/v1", api_key="anything")
+client.chat.completions.create(model="router-cost", messages=[{"role": "user", "content": "..."}])
+```
+
+It works on top of **any OpenAI-compatible gateway that fronts multiple providers**
+behind one key (e.g. a LiteLLM proxy) — so one client can reach OpenAI, Anthropic,
+and Google models just by changing the `model` field. The router is a thin policy
+on top of that.
+
+---
+
+## Install
+
+```bash
+pip install switchboard-llm        # or: uv add switchboard-llm
+```
+
+Configure your gateway (any OpenAI-compatible endpoint):
+
+```bash
+export OPENAI_API_KEY=...                  # your gateway key
+export OPENAI_BASE_URL=https://.../v1      # your endpoint
+```
+
+## Use it
+
+**As a server** (drop-in for any OpenAI client):
+
+```bash
+switchboard serve                          # http://localhost:8000/v1  (use --port to change)
+```
+```python
+from openai import OpenAI
+client = OpenAI(base_url="http://localhost:8000/v1", api_key="anything")
+r = client.chat.completions.create(model="router", messages=[{"role": "user", "content": "Hi"}])
+print(r.model_extra["switchboard"])        # route, cost, savings telemetry
+```
+
+**As a library:**
+
+```python
+import asyncio
+from switchboard import Engine
+
+async def main():
+    eng = Engine()
+    rr = await eng.answer([{"role": "user", "content": "What is 17 * 23?"}], mode="cost")
+    print(rr.content, f"${rr.cost:.6f}", f"{rr.savings_pct:.0f}% cheaper than Opus")
+    await eng.aclose()
+
+asyncio.run(main())
+```
+
+**From the CLI:**
+
+```bash
+switchboard ask "Prove sqrt(2) is irrational" --mode quality
+switchboard models                         # probe which gateway models are actually live
+```
+
+---
+
+## The honest thesis (read this first)
+
+The goal is a router that is **cheaper than a frontier model (e.g. Opus) and
+matches-or-beats it on benchmarks**. That is achievable — but only as a
+**portfolio result over a realistic workload**, not a per-query miracle. The iron
+law:
+
+> On a *single hard query*, you cannot both beat the frontier model **and** be
+> cheaper than it on that same query.
+
+What you *can* do, and what this does:
+
+| Traffic | What the router does | Outcome |
+|---|---|---|
+| **Easy queries** (most real traffic) | route to a cheap model | quality ties Opus, **5–50× cheaper** |
+| **Hard queries** (the minority) | **Mixture-of-Agents**: several cheap/mid models answer in parallel, a synthesizer fuses them | quality can **match or exceed** a single Opus call, still **< Opus cost** |
+| **Repeats** | exact-match cache | **free** |
+
+Averaged over the workload, total spend is well below always-Opus and mean
+accuracy is **equal-or-better**. Grounded in **RouteLLM**, **FrugalGPT** (cascade
+with a judge), and **Mixture-of-Agents**.
+
+---
+
+## Modes
+
+Pick the strategy via the `model` field:
+
+| `model` | strategy |
+|---|---|
+| `router` / `router-balanced` | triage → single cheap (easy) / single mid (moderate) / Mixture-of-Agents (hard) |
+| `router-cost` | **FrugalGPT cascade** — answer cheap, a judge scores it, escalate only if low |
+| `router-quality` | bias one tier up — best quality while staying under Opus cost |
+
+Any **real** model id (`claude-opus-4-8`, `gpt-5.5`, …) passes straight through, so
+this also works as a plain multi-provider proxy.
+
+## How it works
+
+```
+request ─► [cache] ─► [triage: how hard?] ─► [policy] ──► single cheap model      (easy)
+                                                      └─► single mid model        (moderate)
+                                                      └─► Mixture-of-Agents        (hard)
+                                                            proposers ∥ ─► synthesizer
+```
+
+- **Triage** (`src/switchboard/classify.py`) — free heuristics (length, code/math
+  markers, multi-step verbs) decide obvious cases; a tiny LLM classifier scores the
+  ambiguous middle. Output: difficulty 1–5 → tier.
+- **Policy / execution** (`src/switchboard/engine.py`) — `single`, `moa` (parallel
+  proposers + synthesizer), or `cascade` (cheap → judge → escalate).
+- **Cost accounting** — every response carries its internal cost, an estimate of
+  what always-Opus would have cost, and the savings %, under a `switchboard` key.
+
+---
+
+## Results
+
+On **GSM8K (50 items, exact numeric grading)**, baseline = always `claude-opus-4-8`:
+
+| config | accuracy | total cost | vs Opus |
+|---|---|---|---|
+| always-Opus | 100.0% | $0.3674 | baseline |
+| `router-cost` | **100.0%** | $0.0064 | **57× cheaper — Pareto win** |
+| `router-quality` | 100.0% | $0.2781 | 1.3× cheaper |
+| `router-balanced` | 92.0% | $0.0611 | 6× cheaper but lost accuracy |
+
+Reproduce: `python -m bench.run_gsm8k --n 50 --seed 0`. Full write-up and honest
+caveats in [`RESULTS.md`](RESULTS.md). (The verifier is what makes routing safe —
+`router-balanced` has none and lost 8 points; `router-cost`'s judge is the fix.)
+
+---
+
+## Limitations & next steps
+
+- **Pricing is a list-price proxy** (`src/switchboard/config.py`). Drop your real
+  rate card into `pricing.json` (`{"model": [in_per_1M, out_per_1M]}`) to override.
+- **Triage under-detects "deceptively simple" trap questions** — `router-cost`/
+  `router-quality` compensate via the judge/MoA.
+- **Streaming is simulated** (full answer computed, then chunked) — MoA can't
+  token-stream; only the single-model path could truly stream.
+- **Semantic cache** (embed prompt → nearest neighbour) is not yet wired.
+- **The gateway's `/v1/models` list may be stale** — trust `switchboard models`.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

switchboard_llm-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+switchboard/__init__.py,sha256=fMa5XVm2tqaCzHbI2_R4Xyuj_OFOoD-qi-BgvVcTvk8,1761
+switchboard/cache.py,sha256=5AOK4Vv_qsAwCJ8DSzsrO3kNW-W55DYnH8Q2NyEsVq8,1976
+switchboard/classify.py,sha256=5iMqEFEXaOmmqtZXwh8OZcPkqFzz6sOXSGx58SGY3ac,4883
+switchboard/cli.py,sha256=p7owaGcmueY9yJdnheeiFh93yxVK8gjy8g-zBGt9UFs,3526
+switchboard/config.py,sha256=kqZ-odX7lMWldcp1nc9NAmulREfmqBInMrUB0COtPrY,4509
+switchboard/engine.py,sha256=tmyyrhyMSOQKVcyVqk1XusI_suDEXutS5OTnRQpTo58,11208
+switchboard/gateway.py,sha256=7EmH5drldQ0DSG_SInZdULUg1GF1NeBtuNPHL3WycHg,4442
+switchboard/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/server.py,sha256=C9PPSwomrphRpL5AXxgQNtr_CWbZ2I_Fhfq3YSk4Gwk,6210
+switchboard_llm-0.1.0.dist-info/METADATA,sha256=nm2oqTFM27pFwf0MckcbuzDVvtxuHs4zUFkqrZ8qxpI,7307
+switchboard_llm-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+switchboard_llm-0.1.0.dist-info/entry_points.txt,sha256=r2X0ZfWK4hPbr1jjFGW-ODJN8-unQVhix3OTC0O3XUA,53
+switchboard_llm-0.1.0.dist-info/licenses/LICENSE,sha256=tys42fCgdQASPWxptC0DasjfZgUdVxXko8tGZ6K4ZOE,1071
+switchboard_llm-0.1.0.dist-info/RECORD,,

switchboard_llm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

switchboard_llm-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+switchboard = switchboard.cli:main

switchboard_llm-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Archit Dwivedi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.