backend-switchboard 0.1.1__py3-none-any.whl

backend_switchboard/__init__.py

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

backend_switchboard/__main__.py

@@ -0,0 +1,3 @@
+from backend_switchboard._router import main
+
+main()

backend_switchboard/_asksage.py

@@ -0,0 +1,216 @@
+"""@asksage: translate Anthropic Messages requests to AskSage's /query API, in process (stdlib only).
+
+AskSage takes a message history of {"user": "me"|"gpt", "message": text} turns plus an OpenAI-style `tools` list, and
+returns the whole answer at once (`message`, `tool_calls`). It has no slot for tool results, so tool calls and their
+results travel through the history as text turns; the model still sees the real `tools` list.
+"""
+import http.client
+import json
+import os
+import ssl
+import time
+import uuid
+from urllib.parse import urlsplit
+
+
+def _text(content):
+    """Flatten a tool_result's content (string or blocks) to text."""
+    if isinstance(content, str):
+        return content
+    return "\n".join(b.get("text", "[%s omitted]" % b.get("type")) if isinstance(b, dict) else str(b)
+                     for b in content or [])
+
+
+def _render(blk):
+    if isinstance(blk, str):
+        return blk
+    t = blk.get("type")
+    if t == "text":
+        return blk.get("text", "")
+    if t == "tool_use":
+        return "(Earlier in this conversation I used the %s tool with input %s.)" % (blk.get("name"), json.dumps(blk.get("input", {})))
+    if t == "tool_result":
+        err = " (error)" if blk.get("is_error") else ""
+        return "(Result of that tool call%s:)\n%s" % (err, _text(blk.get("content")))
+    if t in ("thinking", "redacted_thinking"):
+        return ""
+    return "[%s omitted]" % t
+
+
+def to_query(obj):
+    """Anthropic request body -> AskSage /query payload."""
+    system = obj.get("system")
+    if isinstance(system, list):
+        system = "\n\n".join(b.get("text", "") for b in system if isinstance(b, dict))
+    turns = []
+    for m in obj.get("messages", []):
+        content = m.get("content")
+        text = "\n\n".join(x for x in (_render(b) for b in content) if x) if isinstance(content, list) else content or ""
+        who = "gpt" if m.get("role") == "assistant" else "me"
+        if turns and turns[-1]["user"] == who:
+            turns[-1]["message"] += "\n\n" + text
+        else:
+            turns.append({"user": who, "message": text})
+    q = {"message": turns or "", "model": obj["model"], "persona": "default", "dataset": "none", "live": 0,
+         "limit_references": 0}
+    if system:
+        q["system_prompt"] = system
+    if obj.get("temperature") is not None:
+        q["temperature"] = obj["temperature"]
+    tools = [{"type": "function", "function": {"name": t["name"], "description": t.get("description", ""),
+                                               "parameters": t.get("input_schema", {"type": "object"})}}
+             for t in obj.get("tools") or [] if isinstance(t, dict) and t.get("name")]
+    if tools:  # a JSON list; a JSON-encoded string is silently ignored by most models
+        q["tools"] = tools
+        choice = (obj.get("tool_choice") or {}).get("type")
+        if choice in ("any", "tool"):
+            q["tool_choice"] = "required"
+        elif choice == "none":
+            q["tool_choice"] = "none"
+    return q
+
+
+def _tokens(x):
+    return max(1, len(x if isinstance(x, str) else json.dumps(x)) // 4)
+
+
+def _mimicked_calls(text, names):
+    """Models sometimes copy the history's "[tool_use NAME id=..] {json}" notation instead of making a real call.
+    Recover those as tool_use blocks (known tool names only); return (remaining text, blocks)."""
+    dec, blocks, out, i = json.JSONDecoder(), [], [], 0
+    while True:
+        j = text.find("[tool_use ", i)
+        k = text.find("]", j) if j >= 0 else -1
+        if k < 0:
+            out.append(text[i:])
+            break
+        head = text[j + 10:k].split()
+        name = (head[0] if head else "").split("functions.")[-1]
+        if name not in names:
+            out.append(text[i:k + 1])
+            i = k + 1
+            continue
+        args, end = {}, k + 1
+        try:
+            rest = text[k + 1:]
+            val, n = dec.raw_decode(rest.lstrip())
+            if isinstance(val, dict):
+                args, end = val, k + 1 + (len(rest) - len(rest.lstrip())) + n
+        except ValueError:
+            pass
+        out.append(text[i:j])
+        blocks.append({"type": "tool_use", "id": "toolu_" + uuid.uuid4().hex[:24], "name": name, "input": args})
+        i = end
+    return "".join(out).strip(), blocks
+
+
+def to_message(d, req, q):
+    """AskSage /query response -> (Anthropic message dict, None) or (None, (status, type, message))."""
+    err = d.get("error")
+    if isinstance(err, dict):
+        code = err.get("code", "")
+        status = {"model_not_permitted": 403}.get(code, err.get("http_status") or 502)
+        return None, (status, "permission_error" if status == 403 else "api_error", d.get("message") or code)
+    content = []
+    text = (d.get("message") or "").strip()
+    if text:
+        content.append({"type": "text", "text": text})
+    for c in d.get("tool_calls_unified") or d.get("tool_calls") or []:
+        # OpenAI-shaped ({function: {name, arguments}}, arguments a JSON string or dict) or Anthropic-shaped ({name, input})
+        fn = c.get("function") or c
+        args = fn.get("arguments", fn.get("input")) or {}
+        if isinstance(args, str):
+            try:
+                args = json.loads(args)
+            except ValueError:
+                args = {}
+        if fn.get("name"):
+            content.append({"type": "tool_use", "id": str(c.get("id") or "toolu_" + uuid.uuid4().hex[:24]),
+                            "name": fn["name"], "input": args if isinstance(args, dict) else {}})
+    names = {t["name"] for t in req.get("tools") or [] if isinstance(t, dict) and t.get("name")}
+    if "[tool_use " in text and not any(b["type"] == "tool_use" for b in content):
+        text, found = _mimicked_calls(text, names)
+        content = ([{"type": "text", "text": text}] if text else []) + found
+    tool = any(b["type"] == "tool_use" for b in content)
+    return {"id": "msg_" + uuid.uuid4().hex[:24], "type": "message", "role": "assistant", "model": req["model"],
+            "content": content or [{"type": "text", "text": ""}], "stop_reason": "tool_use" if tool else "end_turn",
+            "stop_sequence": None,
+            "usage": {"input_tokens": _tokens(q["message"]) + _tokens(q.get("tools", [])) + _tokens(q.get("system_prompt", "")),
+                      "output_tokens": _tokens(content)}}, None
+
+
+def sse(msg):
+    """Whole message -> Anthropic SSE event stream."""
+    def ev(name, data):
+        return ("event: %s\ndata: %s\n\n" % (name, json.dumps(dict(data, type=name)))).encode()
+    out = [ev("message_start", {"message": dict(msg, content=[], stop_reason=None,
+                                                usage={"input_tokens": msg["usage"]["input_tokens"], "output_tokens": 1})})]
+    for i, b in enumerate(msg["content"]):
+        if b["type"] == "tool_use":
+            out.append(ev("content_block_start", {"index": i, "content_block": dict(b, input={})}))
+            out.append(ev("content_block_delta", {"index": i, "delta": {"type": "input_json_delta",
+                                                                         "partial_json": json.dumps(b["input"])}}))
+        else:
+            out.append(ev("content_block_start", {"index": i, "content_block": {"type": "text", "text": ""}}))
+            out.append(ev("content_block_delta", {"index": i, "delta": {"type": "text_delta", "text": b["text"]}}))
+        out.append(ev("content_block_stop", {"index": i}))
+    out.append(ev("message_delta", {"delta": {"stop_reason": msg["stop_reason"], "stop_sequence": None},
+                                    "usage": {"output_tokens": msg["usage"]["output_tokens"]}}))
+    out.append(ev("message_stop", {}))
+    return b"".join(out)
+
+
+def _query(cfg, q, key):
+    u = urlsplit(cfg["asksage_url"])
+    if u.scheme == "https":
+        ctx = ssl.create_default_context()
+        cert = cfg.get("asksage_cert")
+        if cert:
+            ctx.load_verify_locations(os.path.expanduser(cert))
+        conn = http.client.HTTPSConnection(u.hostname, u.port or 443, timeout=600, context=ctx)
+    else:
+        conn = http.client.HTTPConnection(u.hostname, u.port or 80, timeout=600)
+    try:
+        conn.request("POST", u.path.rstrip("/") + "/query", json.dumps(q),
+                     {"x-access-tokens": key, "content-type": "application/json"})
+        r = conn.getresponse()
+        raw = r.read()
+        return r.status, raw
+    finally:
+        conn.close()
+
+
+def handle(h, cfg, obj):
+    """Serve one /v1/messages (or count_tokens) request on handler `h`; return the HTTP status sent."""
+    def send(status, body, ctype="application/json"):
+        h.send_response(status)
+        h.send_header("content-type", ctype)
+        h.send_header("content-length", str(len(body)))
+        h.send_header("connection", "close")
+        h.end_headers()
+        h.wfile.write(body)
+        h.close_connection = True
+        return status
+
+    def fail(status, etype, message):
+        return send(status, json.dumps({"type": "error", "error": {"type": etype, "message": message}}).encode())
+
+    q = to_query(obj)
+    if h.path.split("?")[0].endswith("/count_tokens"):
+        return send(200, json.dumps({"input_tokens": _tokens(q["message"]) + _tokens(q.get("tools", []))}).encode())
+    key = os.environ.get("ASKSAGE_API_KEY")
+    if not key:
+        return fail(401, "authentication_error", "ASKSAGE_API_KEY is not set in the router's environment (restart it after exporting)")
+    try:
+        status, raw = _query(cfg, q, key)
+        d = json.loads(raw)
+    except (OSError, ValueError) as e:
+        return fail(502, "api_error", "AskSage request failed: %s" % e)
+    if status != 200:
+        return fail(status, "api_error", str(d.get("message") if isinstance(d, dict) else raw[:300]))
+    msg, err = to_message(d, obj, q)
+    if err:
+        return fail(*err)
+    if obj.get("stream"):
+        return send(200, sse(msg), "text/event-stream")
+    return send(200, json.dumps(msg).encode())

backend_switchboard/_copilot.py

@@ -0,0 +1,230 @@
+"""@copilot: GitHub Copilot's API (https://api.githubcopilot.com), authenticated with your `gh` login.
+
+Copilot lists the endpoints each model supports. Claude models serve the Anthropic Messages API natively and are
+forwarded by the router like any other native backend. Models that only offer OpenAI's /responses API (gpt-*, grok-*,
+mai-*) are translated here, in process (stdlib only). Answers are requested whole and streaming is emulated.
+Models that only offer /chat/completions (gemini-*) are not supported.
+"""
+import http.client
+import json
+import os
+import re
+import shutil
+import ssl
+import subprocess
+import threading
+import time
+from urllib.parse import urlsplit
+
+from ._asksage import _text, _tokens, sse
+
+HEADERS = {"user-agent": "GitHubCopilot/1.0.105", "copilot-integration-id": "copilot-developer-cli",
+           "x-initiator": "user"}
+_tok = {"lock": threading.Lock(), "token": None, "at": 0.0}
+_models = {"lock": threading.Lock(), "map": None, "at": 0.0}
+
+
+def token():
+    """COPILOT_GITHUB_TOKEN / GH_TOKEN / GITHUB_TOKEN if set, else `gh auth token` (cached 2 min)."""
+    for var in ("COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"):
+        if os.environ.get(var):
+            return os.environ[var]
+    with _tok["lock"]:
+        if _tok["token"] and time.time() - _tok["at"] < 120:
+            return _tok["token"]
+        exe = shutil.which("gh") or os.path.join(os.path.expanduser("~"), ".local/bin/gh")
+        try:
+            out = subprocess.run([exe, "auth", "token"], capture_output=True, text=True, timeout=30)
+        except (OSError, subprocess.TimeoutExpired):
+            return None
+        _tok["token"], _tok["at"] = out.stdout.strip() or None, time.time()
+        return _tok["token"]
+
+
+def upstream_name(model):
+    """Claude Code says claude-opus-5-5; Copilot says claude-opus-5.5."""
+    if model.startswith("claude-"):
+        return re.sub(r"-(\d{1,2})-(\d{1,2})(?=-|$)", r"-\1.\2", model)
+    return model
+
+
+def _conn(cfg, timeout):
+    u = urlsplit(cfg["copilot_url"])
+    if u.scheme == "https":
+        return u, http.client.HTTPSConnection(u.hostname, u.port or 443, timeout=timeout, context=ssl.create_default_context())
+    return u, http.client.HTTPConnection(u.hostname, u.port or 80, timeout=timeout)
+
+
+def _get(cfg, path, tok):
+    u, conn = _conn(cfg, 30)
+    try:
+        conn.request("GET", u.path.rstrip("/") + path, headers=dict(HEADERS, authorization="Bearer " + tok))
+        r = conn.getresponse()
+        return r.status, r.read()
+    finally:
+        conn.close()
+
+
+def _fetch_models(cfg, tok):
+    status, raw = _get(cfg, "/models", tok)
+    if status != 200:
+        raise ValueError("HTTP %s" % status)
+    m = {}
+    for d in json.loads(raw)["data"]:
+        eps = d.get("supported_endpoints") or []
+        m[d["id"]] = ("messages" if "/v1/messages" in eps else "responses" if "/responses" in eps
+                      else "chat" if "/chat/completions" in eps else None)
+    return m
+
+
+def endpoint(cfg, model, tok):
+    """'messages', 'responses' or 'chat' for this model, from Copilot's model list (cached 10 min; a failed fetch keeps
+    the old list and is retried after 1 min). The fetch runs outside the lock so a slow /models can't stall requests."""
+    with _models["lock"]:
+        stale = _models["map"] is None or time.time() > _models["at"]
+        if stale:
+            _models["at"] = time.time() + 60  # claim the refresh; other requests use the old map meanwhile
+    if stale:
+        try:
+            m = _fetch_models(cfg, tok)
+            with _models["lock"]:
+                _models["map"], _models["at"] = m, time.time() + 600
+        except (OSError, ValueError, KeyError, TypeError, http.client.HTTPException):
+            pass
+    hit = (_models["map"] or {}).get(model)
+    return hit or ("messages" if model.startswith("claude-") else "responses")
+
+
+def _image(b):
+    s = b.get("source") or {}
+    url = s.get("url") if s.get("type") == "url" else "data:%s;base64,%s" % (s.get("media_type"), s.get("data"))
+    return {"type": "input_image", "image_url": url}
+
+
+def to_responses(obj):
+    """Anthropic request body -> OpenAI Responses payload."""
+    system = obj.get("system")
+    if isinstance(system, list):
+        system = "\n\n".join(b.get("text", "") for b in system if isinstance(b, dict))
+    items = []
+    for m in obj.get("messages", []):
+        content = m.get("content")
+        asst = m.get("role") == "assistant"
+        tt = "output_text" if asst else "input_text"
+        if isinstance(content, str):
+            content = [{"type": "text", "text": content}]
+        parts = []
+
+        def flush():
+            if parts:
+                items.append({"role": "assistant" if asst else "user", "content": list(parts)})
+                del parts[:]
+        for b in content or []:
+            t = b.get("type")
+            if t == "text" and b.get("text"):
+                parts.append({"type": tt, "text": b["text"]})
+            elif t == "image" and not asst:
+                parts.append(_image(b))
+            elif t == "tool_use":
+                flush()
+                items.append({"type": "function_call", "call_id": b["id"], "name": b["name"],
+                              "arguments": json.dumps(b.get("input", {}))})
+            elif t == "tool_result":
+                flush()
+                out = _text(b.get("content"))
+                items.append({"type": "function_call_output", "call_id": b["tool_use_id"],
+                              "output": ("Error: " + out) if b.get("is_error") else out})
+        flush()
+    r = {"model": obj["model"], "input": items, "stream": False}
+    if system:
+        r["instructions"] = system
+    if obj.get("max_tokens"):
+        r["max_output_tokens"] = obj["max_tokens"]
+    tools = [{"type": "function", "name": t["name"], "description": t.get("description", ""),
+              "parameters": t.get("input_schema", {"type": "object"})}
+             for t in obj.get("tools") or [] if isinstance(t, dict) and t.get("name")]
+    if tools:
+        r["tools"] = tools
+        tc = obj.get("tool_choice") or {}
+        if tc.get("type") == "any":
+            r["tool_choice"] = "required"
+        elif tc.get("type") == "tool":
+            r["tool_choice"] = {"type": "function", "name": tc.get("name")}
+        elif tc.get("type") == "none":
+            r["tool_choice"] = "none"
+    return r
+
+
+def to_message(d, req):
+    """Responses result -> (Anthropic message dict, None) or (None, (status, type, message))."""
+    if isinstance(d.get("error"), dict):
+        e = d["error"]
+        return None, (502, "api_error", e.get("message") or e.get("code") or "upstream error")
+    content = []
+    for it in d.get("output") or []:
+        if it.get("type") == "message":
+            text = "".join(c.get("text", "") for c in it.get("content") or [] if c.get("type") == "output_text")
+            if text.strip():
+                content.append({"type": "text", "text": text})
+        elif it.get("type") == "function_call":
+            try:
+                args = json.loads(it.get("arguments") or "{}")
+            except ValueError:
+                args = {}
+            content.append({"type": "tool_use", "id": it.get("call_id") or it.get("id"), "name": it.get("name"),
+                            "input": args if isinstance(args, dict) else {}})
+    tool = any(b["type"] == "tool_use" for b in content)
+    cut = d.get("status") == "incomplete"
+    refused = cut and (d.get("incomplete_details") or {}).get("reason") == "content_filter"
+    u = d.get("usage") or {}
+    return {"id": "msg_" + (d.get("id") or "x").replace("resp_", "")[:24], "type": "message", "role": "assistant",
+            "model": req["model"], "content": content or [{"type": "text", "text": ""}],
+            "stop_reason": "tool_use" if tool else "refusal" if refused else "max_tokens" if cut else "end_turn", "stop_sequence": None,
+            "usage": {"input_tokens": u.get("input_tokens") or _tokens(req.get("messages", [])),
+                      "output_tokens": u.get("output_tokens") or _tokens(content)}}, None
+
+
+def handle(h, cfg, obj, tok, model, kind):
+    """Serve one /v1/messages (or count_tokens) request on handler `h` via /responses; return the status sent.
+    `kind` is endpoint()'s answer for the model; only non-native ('responses'/'chat') models reach here."""
+    def send(status, body, ctype="application/json"):
+        h.send_response(status)
+        h.send_header("content-type", ctype)
+        h.send_header("content-length", str(len(body)))
+        h.send_header("connection", "close")
+        h.end_headers()
+        h.wfile.write(body)
+        h.close_connection = True
+        return status
+
+    def fail(status, etype, message):
+        return send(status, json.dumps({"type": "error", "error": {"type": etype, "message": message}}).encode())
+
+    req = to_responses(obj)
+    if h.path.split("?")[0].endswith("/count_tokens"):
+        return send(200, json.dumps({"input_tokens": _tokens(req["input"]) + _tokens(req.get("tools", []))}).encode())
+    if kind == "chat":
+        return fail(400, "invalid_request_error", "%s only offers /chat/completions on Copilot, which @copilot does not support" % model)
+    u, conn = _conn(cfg, 900)
+    try:
+        conn.request("POST", u.path.rstrip("/") + "/responses", json.dumps(req),
+                     dict(HEADERS, authorization="Bearer " + tok, **{"content-type": "application/json"}))
+        r = conn.getresponse()
+        raw = r.read()
+        d = json.loads(raw)
+    except (OSError, ValueError, http.client.HTTPException) as e:
+        return fail(502, "api_error", "Copilot request failed: %s" % e)
+    finally:
+        conn.close()
+    if r.status != 200:
+        e = d.get("error") if isinstance(d, dict) else None
+        msg = e.get("message") if isinstance(e, dict) else raw[:300].decode("utf8", "replace")
+        etype = {400: "invalid_request_error", 401: "authentication_error", 403: "permission_error", 404: "not_found_error",
+                 413: "request_too_large", 429: "rate_limit_error", 503: "overloaded_error"}.get(r.status, "api_error")
+        return fail(r.status, etype, str(msg))
+    msg, err = to_message(d, obj)
+    if err:
+        return fail(*err)
+    if obj.get("stream"):
+        return send(200, sse(msg), "text/event-stream")
+    return send(200, json.dumps(msg).encode())

backend_switchboard/_router.py

@@ -0,0 +1,450 @@
+#!/usr/bin/env python3
+"""backend-switchboard: one local Anthropic-API endpoint for Claude Code, routed by /model suffix.
+
+  claude-opus-5-5              -> Anthropic (your subscription; client headers pass through untouched)
+  claude-opus-5-5@google@mag   -> AMSC MAG   (router tag @mag is stripped; "@google" is MAG's own suffix)
+  claude-opus-5-5@argo         -> Argo via argo-shim
+  beam@alcf / muse@alcf        -> ALCF Minerva (serves the Anthropic Messages API natively; Bearer token)
+  gpt-5.4@asksage              -> AskSage /query (translated in-process; needs ASKSAGE_API_KEY)
+  claude-opus-5-5@copilot      -> GitHub Copilot (Claude: native; gpt-*/grok-*: /responses, translated; uses `gh auth token`)
+
+Standard library only (3.8+). Upstream credentials are read per request and never logged.
+"""
+import argparse
+import hmac
+import http.client
+import json
+import os
+import secrets
+import shlex
+import shutil
+import signal
+import ssl
+import subprocess
+import sys
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import urlsplit
+
+from . import _asksage as asksage
+from . import _copilot as copilot
+
+HOME = os.path.expanduser("~")
+DIR = os.environ.get("BACKEND_SWITCHBOARD_HOME", os.path.join(HOME, ".backend-switchboard"))
+BACKENDS = ("anthropic", "argo", "mag", "alcf", "asksage", "copilot")
+HOP = {"connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailers",
+       "transfer-encoding", "upgrade", "host", "content-length"}
+SOFT_ERRORS = (b"ACCESS REVOKED", b"IMPORTANT USAGE NOTICE")
+
+DEFAULTS = {
+    "port": 8790,
+    "tool_search": "true",
+    "anthropic_url": "https://api.anthropic.com",
+    "mag_url": "https://mag.genesis.americansciencecloud.org",
+    "argo_settings": os.path.join(HOME, ".claude", "settings.json"),
+    "argo_url": None,
+    "alcf_url": "https://inference-api.alcf.anl.gov/resource_server/minerva/api",
+    "asksage_url": "https://api.asksage.anl.gov/server",
+    "asksage_cert": None,  # extra CA bundle (ANL's AskSage cert), e.g. ~/.config/asksage_proxy/asksage_anl_gov.pem
+    "copilot_url": "https://api.githubcopilot.com",
+    "aliases": {"alcf": {"beam": "beam-1.0-bf16", "muse": "muse-spark-bf16"}},
+}
+
+
+def load_config():
+    cfg = dict(DEFAULTS)
+    try:
+        with open(os.path.join(DIR, "config.json")) as f:
+            cfg.update(json.load(f))
+    except FileNotFoundError:
+        pass
+    return cfg
+
+
+def read_key():
+    with open(os.path.join(DIR, "key")) as f:
+        return f.read().strip()
+
+
+def split_model(model):
+    """'name@mag' -> ('name', 'mag'); only the LAST @tag, and only if it is a router backend."""
+    base, sep, tag = model.rpartition("@")
+    if sep and tag in BACKENDS:
+        return base, tag
+    return model, None
+
+
+class RouteError(Exception):
+    def __init__(self, status, message):
+        Exception.__init__(self, message)
+        self.status, self.message = status, message
+
+
+_cache = {}
+
+
+def cached_file(path, parse):
+    """Re-parse a file only when its mtime changes (tokens rotate; settings files get rewritten)."""
+    try:
+        m = os.stat(path).st_mtime
+    except OSError:
+        return None
+    key = (path, parse.__name__)
+    hit = _cache.get(key)
+    if hit and hit[0] == m:
+        return hit[1]
+    try:
+        val = parse(path)
+    except Exception:
+        val = None
+    _cache[key] = (m, val)
+    return val
+
+
+def _argo_token(path):
+    helper = json.load(open(path)).get("apiKeyHelper", "")
+    words = shlex.split(helper)
+    return words[-1] if words else None
+
+
+def _argo_base(path):
+    url = json.load(open(path)).get("env", {}).get("ANTHROPIC_BASE_URL", "")
+    return url if urlsplit(url).hostname in ("127.0.0.1", "localhost") else None
+
+
+def mag_token():
+    return os.environ.get("AMSC_TOKEN")
+
+
+_alcf = {"lock": threading.Lock(), "token": None, "at": 0.0}
+
+
+def alcf_token():
+    """ALCF inference token: ALCF_INFERENCE_TOKEN if set, else `alcf-tokens get-token inference` (cached 2 min)."""
+    tok = os.environ.get("ALCF_INFERENCE_TOKEN")
+    if tok:
+        return tok
+    with _alcf["lock"]:
+        if _alcf["token"] and time.time() - _alcf["at"] < 120:
+            return _alcf["token"]
+        exe = shutil.which("alcf-tokens") or os.path.join(HOME, ".local/bin/alcf-tokens")
+        try:
+            out = subprocess.run([exe, "get-token", "inference"], capture_output=True, text=True, timeout=30)
+        except (OSError, subprocess.TimeoutExpired):
+            return None
+        _alcf["token"], _alcf["at"] = out.stdout.strip() or None, time.time()
+        return _alcf["token"]
+
+
+def resolve(cfg, model):
+    """Return (base_url, extra_headers, drop_client_auth, upstream_model, backend)."""
+    base, tag = split_model(model)
+    if tag is None:
+        if "@" in model:
+            raise RouteError(400, "ambiguous model %r: add a router tag, e.g. %s@mag or %s@argo (tags: %s)"
+                             % (model, model, model, ", ".join(BACKENDS)))
+        return cfg["anthropic_url"], {}, False, model, "anthropic"
+    if tag == "anthropic":
+        return cfg["anthropic_url"], {}, False, base, tag
+    if tag == "mag":
+        tok = mag_token()
+        if not tok:
+            raise RouteError(401, "AMSC_TOKEN is not set in the router's environment (restart it after exporting)")
+        return cfg["mag_url"], {"authorization": "Bearer " + tok}, True, base, tag
+    if tag == "argo":
+        tok = cached_file(cfg["argo_settings"], _argo_token)
+        url = cfg["argo_url"] or cached_file(cfg["argo_settings"], _argo_base)
+        if not tok or not url:
+            raise RouteError(502, "cannot read argo-shim token/base URL from %s" % cfg["argo_settings"])
+        return url, {"x-api-key": tok}, True, base, tag
+    if tag == "asksage":
+        return cfg["asksage_url"], {}, True, base, tag
+    if tag == "copilot":
+        tok = copilot.token()
+        if not tok:
+            raise RouteError(401, "no GitHub token; run in your own terminal: gh auth login (or set COPILOT_GITHUB_TOKEN)")
+        return (cfg["copilot_url"], dict(copilot.HEADERS, authorization="Bearer " + tok), True,
+                cfg["aliases"].get("copilot", {}).get(base, copilot.upstream_name(base)), tag)
+    tok = alcf_token()
+    if not tok:
+        raise RouteError(401, "no ALCF token; run in your own terminal: alcf-tokens login inference")
+    return cfg["alcf_url"], {"authorization": "Bearer " + tok}, True, cfg["aliases"]["alcf"].get(base, base), tag
+
+
+BLOCK_TYPES = {"text", "image", "document", "tool_use", "tool_result", "thinking", "redacted_thinking",
+               "server_tool_use", "web_search_tool_result", "search_result", "container_upload"}
+
+
+def strip_client_extensions(obj):
+    """Drop Claude Code's Anthropic-only extras that Vertex-backed Argo rejects with a 400: message-level keys other
+    than role/content (e.g. output_config) and content blocks of unknown type (e.g. tool_addition).
+    Returns True if anything changed."""
+    changed = False
+    for msg in obj.get("messages", []):
+        if not isinstance(msg, dict):
+            continue
+        for k in [k for k in msg if k not in ("role", "content")]:
+            del msg[k]
+            changed = True
+        content = msg.get("content")
+        if isinstance(content, list):
+            kept = [b for b in content if not isinstance(b, dict) or b.get("type") in BLOCK_TYPES]
+            if len(kept) != len(content):
+                msg["content"] = kept
+                changed = True
+    return changed
+
+
+def flatten_tool_search(obj):
+    """Make Claude Code's deferred-tool search safe for backends that lack Anthropic's tool_reference blocks.
+
+    The client already adds a loaded tool's full schema to `tools` on the next request, so it is enough to drop
+    the defer_loading placeholder and turn each tool_reference into a text result. Returns True if anything changed.
+    """
+    changed = False
+    tools = obj.get("tools")
+    if isinstance(tools, list):
+        kept = [t for t in tools if not (isinstance(t, dict) and t.get("defer_loading"))]
+        changed = len(kept) != len(tools)
+        obj["tools"] = kept
+    for msg in obj.get("messages", []):
+        content = msg.get("content")
+        if not isinstance(content, list):
+            continue
+        for blk in content:
+            inner = blk.get("content") if isinstance(blk, dict) and blk.get("type") == "tool_result" else None
+            if not isinstance(inner, list):
+                continue
+            for i, b in enumerate(inner):
+                if isinstance(b, dict) and b.get("type") == "tool_reference":
+                    inner[i] = {"type": "text", "text": "Tool loaded: %s. Its schema is now in your tool list; "
+                                                        "call it directly." % b.get("tool_name")}
+                    changed = True
+    return changed
+
+
+class Handler(BaseHTTPRequestHandler):
+    cfg = key = None
+    server_version = "backend-switchboard"
+
+    def log_message(self, *a):
+        pass
+
+    def _err(self, status, message):
+        body = json.dumps({"type": "error", "error": {"type": "invalid_request_error" if status < 500 else "api_error",
+                                                       "message": message}}).encode()
+        self.send_response(status)
+        self.send_header("content-type", "application/json")
+        self.send_header("content-length", str(len(body)))
+        self.send_header("connection", "close")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_HEAD(self):
+        self.send_response(200)
+        self.send_header("content-length", "0")
+        self.end_headers()
+
+    def do_GET(self):
+        if self.path == "/health":
+            return self._plain(b'{"ok":true}')
+        self._proxy()
+
+    def do_POST(self):
+        self._proxy()
+
+    def _plain(self, body):
+        self.send_response(200)
+        self.send_header("content-type", "application/json")
+        self.send_header("content-length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _proxy(self):
+        t0 = time.time()
+        if not hmac.compare_digest(self.headers.get("x-router-key", ""), self.key):
+            return self._err(401, "missing or wrong x-router-key")
+        n = int(self.headers.get("content-length") or 0)
+        raw = self.rfile.read(n) if n else b""
+        model, backend = "-", "?"
+        try:
+            body = raw
+            if raw and self.path.split("?")[0].startswith("/v1/messages"):
+                try:
+                    obj = json.loads(raw)
+                except ValueError:
+                    obj = None
+                if isinstance(obj, dict) and isinstance(obj.get("model"), str):
+                    model = obj["model"]
+            url, extra, drop_auth, up_model, backend = resolve(self.cfg, model) \
+                if model != "-" else (self.cfg["anthropic_url"], {}, False, None, "anthropic")
+            if model != "-":
+                dirty = up_model != model
+                obj["model"] = up_model
+                if backend != "anthropic":
+                    dirty = flatten_tool_search(obj) or dirty
+                    dirty = strip_client_extensions(obj) or dirty
+                if dirty:
+                    body = json.dumps(obj).encode()
+            if backend == "asksage":
+                status = asksage.handle(self, self.cfg, obj)
+            else:
+                kind = copilot.endpoint(self.cfg, up_model, extra["authorization"][7:]) if backend == "copilot" else None
+                if kind and kind != "messages":
+                    status = copilot.handle(self, self.cfg, obj, extra["authorization"][7:], up_model, kind)
+                else:
+                    status = self._forward(url, extra, drop_auth, body, backend)
+        except RouteError as e:
+            status = e.status
+            self._err(e.status, e.message)
+        except Exception as e:
+            status = 502 if isinstance(e, (OSError, http.client.HTTPException)) else 500
+            sys.stderr.write("router error: %r\n" % (e,))
+            try:
+                self._err(status, "router/upstream error: %s" % e)
+            except OSError:
+                pass
+        sys.stderr.write("%s %-40s -> %s %s %.2fs\n" % (time.strftime("%H:%M:%S"), model[:40],
+                         backend, status, time.time() - t0))
+        sys.stderr.flush()
+
+    def _forward(self, url, extra, drop_auth, body, backend):
+        u = urlsplit(url)
+        headers = {}
+        for k, v in self.headers.items():
+            lk = k.lower()
+            if lk in HOP or lk == "x-router-key":
+                continue
+            if drop_auth and lk in ("authorization", "x-api-key"):
+                continue
+            if backend == "argo" and lk == "accept-encoding":
+                continue
+            headers[lk] = v
+        headers.update(extra)
+        if u.scheme == "https":
+            conn = http.client.HTTPSConnection(u.hostname, u.port or 443, timeout=900, context=ssl.create_default_context())
+        else:
+            conn = http.client.HTTPConnection(u.hostname, u.port or 80, timeout=900)
+        conn.request(self.command, u.path.rstrip("/") + self.path, body or None, headers)
+        resp = conn.getresponse()
+        first = b""
+        if backend == "argo" and resp.status == 200:
+            first = resp.read1(8192)
+            if any(s in first[:4000] for s in SOFT_ERRORS):
+                self._err(429, "Argo returned a usage/quota notice (HTTP 200 soft error): " + first[:300].decode("utf8", "replace"))
+                conn.close()
+                return 429
+        self.send_response(resp.status, resp.reason)
+        for k, v in resp.getheaders():
+            if k.lower() not in HOP:
+                self.send_header(k, v)
+        self.send_header("connection", "close")
+        self.end_headers()
+        self.close_connection = True
+        if first:
+            self.wfile.write(first)
+            self.wfile.flush()
+        while True:
+            chunk = resp.read1(8192)
+            if not chunk:
+                break
+            self.wfile.write(chunk)
+            self.wfile.flush()
+        conn.close()
+        return resp.status
+
+
+def build_server(cfg):
+    Handler.cfg, Handler.key = cfg, read_key()
+    ThreadingHTTPServer.daemon_threads = True
+    return ThreadingHTTPServer(("127.0.0.1", cfg["port"]), Handler)
+
+
+def healthy(port):
+    try:
+        c = http.client.HTTPConnection("127.0.0.1", port, timeout=2)
+        c.request("GET", "/health")
+        return c.getresponse().status == 200
+    except OSError:
+        return False
+
+
+def cmd_init(cfg, quiet=False):
+    os.makedirs(DIR, mode=0o700, exist_ok=True)
+    kp = os.path.join(DIR, "key")
+    if not os.path.exists(kp):
+        fd = os.open(kp, os.O_WRONLY | os.O_CREAT, 0o600)
+        with os.fdopen(fd, "w") as f:
+            f.write(secrets.token_urlsafe(32) + "\n")
+    settings = {"env": {
+        "ANTHROPIC_BASE_URL": "http://127.0.0.1:%d" % cfg["port"],
+        "ANTHROPIC_CUSTOM_HEADERS": "x-router-key: " + read_key(),
+        "ENABLE_TOOL_SEARCH": str(cfg["tool_search"]),
+    }}
+    sp = os.path.join(DIR, "settings.json")
+    fd = os.open(sp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as f:
+        json.dump(settings, f, indent=2)
+    if not quiet:
+        print("wrote", kp, "and", sp)
+        print("launch Claude Code with:  backend-switchboard run   (then /model <name>[@argo|@mag|@alcf|@asksage|@copilot])")
+
+
+def cmd_ensure(cfg):
+    if healthy(cfg["port"]):
+        return
+    log = open(os.path.join(DIR, "router.log"), "ab")
+    p = subprocess.Popen([sys.executable, "-m", "backend_switchboard", "serve"], stdout=log, stderr=log,
+                         stdin=subprocess.DEVNULL, start_new_session=True)
+    with open(os.path.join(DIR, "router.pid"), "w") as f:
+        f.write(str(p.pid))
+    for _ in range(20):
+        if healthy(cfg["port"]):
+            return
+        time.sleep(0.25)
+    sys.exit("backend-switchboard failed to start; see %s/router.log" % DIR)
+
+
+def cmd_run(cfg, args):
+    cmd_init(cfg, quiet=True)  # keeps settings.json in sync with config.json (port)
+    cmd_ensure(cfg)
+    if shutil.which("claude") is None:
+        sys.exit("claude not found on PATH; install Claude Code first")
+    os.execvp("claude", ["claude", "--settings", os.path.join(DIR, "settings.json")] + args)
+
+
+def cmd_stop():
+    try:
+        pid = int(open(os.path.join(DIR, "router.pid")).read())
+        os.kill(pid, 15)
+        print("stopped", pid)
+    except (OSError, ValueError):
+        print("not running")
+
+
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] == "run":  # everything after "run" belongs to claude
+        return cmd_run(load_config(), sys.argv[2:])
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("command", choices=["init", "serve", "ensure", "stop"],
+                    help="run [claude args...] is also accepted: starts the router if needed, then launches claude")
+    cmd = ap.parse_args().command
+    cfg = load_config()
+    if cmd == "init":
+        cmd_init(cfg)
+    elif cmd == "serve":
+        srv = build_server(cfg)
+        signal.signal(signal.SIGTERM, lambda *a: sys.exit(0))
+        try:
+            srv.serve_forever()
+        except KeyboardInterrupt:
+            pass
+    elif cmd == "ensure":
+        cmd_ensure(cfg)
+    else:
+        cmd_stop()
+
+
+if __name__ == "__main__":
+    main()

backend_switchboard-0.1.1.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.5
+Name: backend-switchboard
+Version: 0.1.1
+Summary: Switch Claude Code between your Anthropic subscription, Argo, MAG and ALCF models with /model
+Project-URL: Homepage, https://github.com/n-getty/backend-switchboard
+Project-URL: Repository, https://github.com/n-getty/backend-switchboard
+Project-URL: Issues, https://github.com/n-getty/backend-switchboard/issues
+Author: Neil Getty
+License-Expression: MIT
+License-File: LICENSE
+Keywords: alcf,anthropic,argo,claude-code,llm-gateway,proxy,router
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: Proxy Servers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# backend-switchboard
+
+One local endpoint that lets Claude Code switch between several model backends with `/model`, in a single session:
+
+| `/model` value | Goes to |
+|---|---|
+| `claude-sonnet-5-5` (no tag) | Anthropic, using your own Claude Code login. Requests are forwarded untouched. |
+| `claude-sonnet-5-5@argo` | [Argo](https://github.com/n-getty/argo-shim) through a running `argo-shim` |
+| `claude-opus-5-5@google@mag` | A LiteLLM-style gateway with Bearer auth (AMSC "MAG"); the tag `@mag` is stripped and `@google` is MAG's own suffix |
+| `beam@alcf`, `muse@alcf` | ALCF inference endpoints, which serve the Anthropic Messages API natively |
+| `google-claude-opus-5@asksage` | AskSage models, translated in-process to AskSage's `/query` API |
+| `claude-opus-5-5@copilot`, `gpt-6.1-sol@copilot` | GitHub Copilot, using your `gh` login: Claude models natively, GPT/Grok models translated to `/responses` |
+
+Claude Code only accepts one `ANTHROPIC_BASE_URL` per session, so the switch has to happen behind that URL.
+backend-switchboard is that URL. It reads the model name, picks a backend, swaps in that backend's credentials, and
+streams the response back. Standard library only, Python 3.8+. No other services to run.
+
+> Not affiliated with Anthropic. The Anthropic route forwards your Claude Code login (OAuth or API key) unchanged and
+> never reads, stores or logs it. Check your plan's terms before sending subscription traffic through a local proxy.
+
+```
+Claude Code --> 127.0.0.1:8790 (backend-switchboard) --+--> api.anthropic.com        (no tag)
+   /model name[@tag]                                   +--> argo-shim                (@argo)
+                                                       +--> MAG                      (@mag)
+                                                       +--> ALCF Minerva             (@alcf)
+                                                       +--> AskSage                  (@asksage)
+                                                       +--> GitHub Copilot           (@copilot)
+```
+
+## Install
+
+```bash
+pip install backend-switchboard
+# or without installing:
+uvx backend-switchboard run
+```
+
+## Use
+
+```bash
+backend-switchboard run              # starts the router if needed, then launches claude
+backend-switchboard run -c           # anything after "run" is passed to claude
+```
+
+Then inside Claude Code: `/model beam@alcf`, `/model claude-sonnet-5-5@argo`, `/model claude-sonnet-5-5` (back to your
+subscription). You can switch mid-conversation; the history is carried across backends.
+
+Other commands: `init` (create the key and settings), `ensure` (start the router in the background), `stop`, `serve`
+(foreground). State lives in `~/.backend-switchboard/` (override with `BACKEND_SWITCHBOARD_HOME`).
+
+If you launch Claude Code with a separate config directory, e.g. a personal subscription, export `CLAUDE_CONFIG_DIR`
+first; `run` leaves it alone.
+
+## Backends
+
+**Anthropic (no tag).** Nothing to configure. Whatever login your Claude Code already has is used.
+
+**Argo (`@argo`).** Run [argo-shim](https://github.com/n-getty/argo-shim) as usual. The router re-reads its token and
+local URL from `~/.claude/settings.json` on every request (change the path with `argo_settings`). If Argo answers an
+exhausted quota with HTTP 200 and an "ACCESS REVOKED" notice, the router turns that into a 429 so it is not shown as a
+model answer.
+
+**MAG (`@mag`).** Export `AMSC_TOKEN` in the environment the router starts from. Set `mag_url` in `config.json` to
+point at another Bearer-auth gateway. MAG's own provider suffixes stay in the name: `claude-opus-5-5@google@mag`.
+
+**ALCF (`@alcf`).** Install the ALCF token tools and log in once, in your own terminal:
+
+```bash
+uv tool install alcf-ai alcf-tokens
+alcf-tokens login inference
+```
+
+The router runs `alcf-tokens get-token inference` (cached for two minutes), or uses `ALCF_INFERENCE_TOKEN` if you set it.
+ALCF's Minerva endpoint accepts the Anthropic Messages API directly with a Bearer token, so requests are forwarded as they
+are, including streaming, tool calls and the models' thinking blocks. Aliases `beam` and `muse` map to `beam-1.0-bf16`
+and `muse-spark-bf16`; any other name is passed through. Add or change aliases under `aliases.alcf` in `config.json`.
+
+**AskSage (`@asksage`).** Setup:
+
+1. Get an AskSage API key from your AskSage account settings (for ANL: https://api.asksage.anl.gov) and export it in the
+   shell that starts the router, e.g. in `~/.bashrc`: `export ASKSAGE_API_KEY=...`. The router reads it per request and
+   never logs it. It reads only the environment, so restart the router after changing it: `backend-switchboard stop`,
+   then launch again.
+2. If your AskSage host uses a private CA, save its certificate and point at it in `~/.backend-switchboard/config.json`:
+   `{"asksage_cert": "~/path/to/asksage.pem"}`. `asksage_url` defaults to `https://api.asksage.anl.gov/server`; change it
+   for another AskSage server.
+3. Use AskSage's own model ids: `/model google-claude-opus-5@asksage`, `/model gpt-4.1@asksage`. To list the ids your
+   account can use, POST to `<asksage_url>/get-models` with an `x-access-tokens: $ASKSAGE_API_KEY` header.
+
+How it works: the router translates Anthropic requests to AskSage's `/query` itself, with no asksage-proxy or llm-rosetta.
+The history goes over as `me`/`gpt` turns and `tools` as a JSON list. AskSage has no field for tool results, so earlier
+tool calls and their results are written into the history as prose, and answers arrive whole, so streaming is emulated.
+Claude models on AskSage handle the full tool loop (Read, ToolSearch, Bash); weaker ones (`gpt-4.1`) often stall on
+deferred tools. Token counts are estimates, and some AskSage models return `model_error` while their upstream is down.
+
+**GitHub Copilot (`@copilot`).** Log in once with `gh auth login` (the account needs a Copilot seat). The router runs
+`gh auth token` (cached two minutes), or uses `COPILOT_GITHUB_TOKEN`, `GH_TOKEN` or `GITHUB_TOKEN` if set, and sends
+the Copilot client headers. It asks `/models` which endpoint each model supports (cached ten minutes):
+
+- Claude models serve the Anthropic Messages API, so requests are forwarded as they are, with streaming. Claude Code's
+  dashed names are mapped to Copilot's dotted ones: `claude-opus-5-5@copilot` becomes `claude-opus-5.5`.
+- `gpt-*`, `grok-*` and `mai-*` models only offer OpenAI's `/responses`. The router translates to it in process, including
+  tool calls and tool results. Answers are requested whole and streaming is emulated, and token counts for
+  `count_tokens` are estimates. Reasoning content is not carried across turns.
+- `gemini-*` models only offer `/chat/completions` and are rejected with a 400.
+
+To list your models, GET `https://api.githubcopilot.com/models` with `Authorization: Bearer $(gh auth token)`,
+`User-Agent: GitHubCopilot/1.0.105` and `Copilot-Integration-Id: copilot-developer-cli` headers.
+Add short names under `aliases.copilot` in `config.json`.
+
+A bare `name@google` is rejected as ambiguous, because more than one backend uses that suffix. Always add a router tag.
+
+## Tool search
+
+`init` sets `ENABLE_TOOL_SEARCH=true`, which defers most tool definitions and cuts the request size (about 37% fewer
+tokens in one measurement with roughly 26 tools; your mix will differ). Claude Code decides this once per session, not per model, and the
+Anthropic-only `tool_reference` blocks it uses are not understood by other backends. For every route except the plain
+Anthropic one, the router therefore drops the `defer_loading` placeholder and rewrites each `tool_reference` into a short
+text result; Claude Code already sends the loaded tool's full schema on the next request. To send every
+tool definition on every request instead, set `"tool_search": "false"` in `config.json` (Claude Code also accepts
+`auto:N`).
+
+## Configuration
+
+Optional `~/.backend-switchboard/config.json`; every key has a default:
+
+| key | default | meaning |
+|---|---|---|
+| `port` | `8790` | local listen port (loopback only) |
+| `tool_search` | `true` | value written to `ENABLE_TOOL_SEARCH` in the generated Claude Code settings |
+| `anthropic_url` | `https://api.anthropic.com` | no-tag route |
+| `mag_url` | the AMSC MAG host | `@mag` route |
+| `argo_settings` / `argo_url` | `~/.claude/settings.json` / read from it | where to find argo-shim |
+| `asksage_url` / `asksage_cert` | `https://api.asksage.anl.gov/server` / none | AskSage server and optional extra CA bundle |
+| `copilot_url` | `https://api.githubcopilot.com` | `@copilot` route |
+| `alcf_url` | ALCF Minerva `/api` | endpoint behind `@alcf` (Anthropic Messages API) |
+| `aliases` | `beam`, `muse` | short names per backend (`alcf`, `copilot`) |
+
+## Security
+
+- The router listens on `127.0.0.1` only and requires a random key on every request, sent by Claude Code through
+  `ANTHROPIC_CUSTOM_HEADERS`. This matters on shared login nodes: without it, any other user on the machine could spend
+  your Argo, MAG and ALCF credentials. The key and `settings.json` are created with mode 600.
+- Upstream credentials are read per request and are never logged. The log records the model name, backend, status and
+  duration only.
+
+## Status and limits
+
+- Tested live: your Anthropic login, ALCF Beam and Muse, and a single conversation switched across backends between turns.
+  The Argo and MAG routes are covered by mock-upstream tests only.
+- Beam handled loading a deferred tool with `ToolSearch` and then calling it reliably in every run. Muse was inconsistent: in two
+  runs, one succeeded and one looped on tool calls until the client timed out. All requests returned 200, so this is model
+  behavior, not routing.
+- When a backend is down or returns a 5xx, Claude Code retries for a few minutes, so a stopped Argo tunnel looks like a
+  hang. Check `~/.backend-switchboard/router.log`.
+- ALCF does not implement the token-count endpoint (404). Claude Code falls back and the turn completes.
+- Switching between an Anthropic model and ALCF models worked in testing (history includes the ALCF thinking blocks), but not
+  with extended thinking enabled on the Anthropic side.
+- Not covered: the interactive `/model` picker UI (typing the name works), and prompt-cache behavior across backends.
+
+## Tests
+
+```bash
+python3 tests/selftest.py
+```
+
+See [tests/README.md](tests/README.md). Releases are cut by merging to `main`; the workflow bumps the version, updates
+the changelog and publishes to PyPI.
+
+## License
+
+MIT

backend_switchboard-0.1.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+backend_switchboard/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+backend_switchboard/__main__.py,sha256=SKaP_RReP-RQ3x5u2gNaZqeRMjTJtiYh2_Gfj1d1O20,53
+backend_switchboard/_asksage.py,sha256=kj78cLv1yt2zp0P2lff6FeVB9h0F6LGqnaKcwAnxKpU,9926
+backend_switchboard/_copilot.py,sha256=6Jj4IInRvE4x_xwc7FCVy0siZYWz6GjBUyQNP8cpxK0,10354
+backend_switchboard/_router.py,sha256=N5i29QmDICqmQxODPa9xwsd_YEHMTR92pDI_At0qbA0,17522
+backend_switchboard-0.1.1.dist-info/METADATA,sha256=oWL-3-NBBy-vvKQWIFoR3-pjZQlNRda5VX79lD3Z0zg,11393
+backend_switchboard-0.1.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+backend_switchboard-0.1.1.dist-info/entry_points.txt,sha256=F2aZFZB9wj-odrAdN_USA3eyeyJdjBuAQtl6zMKAkBQ,73
+backend_switchboard-0.1.1.dist-info/licenses/LICENSE,sha256=dyrk9yhDJCreFPXfRA4-ZaJqobDr-MfswN1gG9c8M90,1067
+backend_switchboard-0.1.1.dist-info/RECORD,,

backend_switchboard-0.1.1.dist-info/WHEEL

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

backend_switchboard-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+backend-switchboard = backend_switchboard._router:main

backend_switchboard-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neil Getty
+
+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.