Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.
Python agent-orchestrationaiai-agentschatopsdiscordlangchainmcpmicrosoft-teamsmulti-agentopen-sourceopenaiself-hostedslack
Ship the decision service in the repo
agent-runner3536104332caa80
diff --git a/decision/.dockerignore b/decision/.dockerignorenew file mode 100644index 000000000..eb2778e46--- /dev/null+++ b/decision/.dockerignore@@ -0,0 +1,7 @@+.venv+.pytest_cache+**/__pycache__+tests+eval+Dockerfile+README.mddiff --git a/decision/Dockerfile b/decision/Dockerfilenew file mode 100644index 000000000..60376fa3e--- /dev/null+++ b/decision/Dockerfile@@ -0,0 +1,26 @@+# switch-decision: the decision service (POST /decide, GET /health).+# CPU-only. The self-hosted model runs in its own container (for example the+# llama.cpp server image on a GPU node); point LLAMACPP_URL at it. No model+# weights are baked into this image.+FROM python:3.12.11-slim-bookworm++COPY --from=ghcr.io/astral-sh/uv:0.13.1 /uv /usr/local/bin/uv+WORKDIR /app+ENV UV_COMPILE_BYTECODE=1 \+ UV_LINK_MODE=copy \+ UV_PYTHON_DOWNLOADS=never+COPY pyproject.toml uv.lock ./+RUN uv sync --frozen --no-dev --no-install-project+COPY switch_decision ./switch_decision+RUN uv sync --frozen --no-dev --no-editable \+ && groupadd --gid 10001 decision \+ && useradd --uid 10001 --gid 10001 --no-create-home decision++ENV PATH="/app/.venv/bin:$PATH" \+ PYTHONDONTWRITEBYTECODE=1 \+ PYTHONUNBUFFERED=1 \+ PORT=8230 \+ DECISION_BACKEND=llamacpp+USER 10001:10001+EXPOSE 8230+CMD ["sh", "-c", "exec uvicorn switch_decision.app:app --host 0.0.0.0 --port ${PORT}"]diff --git a/decision/README.md b/decision/README.mdnew file mode 100644index 000000000..828482d73--- /dev/null+++ b/decision/README.md@@ -0,0 +1,143 @@+# switch-decision++The decision service behind auto-route. When a room has auto-route on and a+message tags no agent, switch-core asks this service which agent in the room,+if any, should answer. The service puts the room's context to a decision model+as one choice (each candidate agent, plus "none") and only names an agent when+the model's confidence clears a threshold.++It is a small FastAPI app (`switch_decision`). It holds no state and keeps no+message content after answering.++## Contract++switch-core talks only to this contract; the backend behind it is configuration.++- **`GET /health`** returns `200 {"ok": true, "backend", "model", "model_server",+ "model_server_status", "confidence_threshold", "backends_available"}`, or+ `503 {"detail"}` when the default backend's model server is down.+ `backends_available` is `["default", "anthropic"]`, plus `"bedrock"` when+ `DECISION_BEDROCK_ENABLED=1`. It never needs a token.+- **`POST /decide`** takes `room` (`name`, `instructions`), `message` (`sender`,+ `text`, `thread_id`), `agents` (`name`, `description`, `role`), `thread`,+ `recent` and an optional `confidence_threshold`. It returns+ `{"agent", "model_choice", "confidence", "threshold", "reason", "model", "backend", "latency_ms"}`.+ `agent` is null for "none", for a pick below the threshold, and for an answer+ that names an agent who is not a candidate (logged as an error).+- **Status codes:** `422` for a bad body, `502` when the backend failed (the+ detail says why), `401` when a service token is set and the request lacks+ it, and `400 {"detail", "code": "backend_unavailable"}` for an unknown or+ unavailable backend override.+- **Auth:** with `DECISION_SERVICE_TOKEN` set, every request except+ `GET /health` needs `Authorization: Bearer <token>`. Unset means no auth,+ for use inside a cluster behind a NetworkPolicy.+- **Per-request backend override**, so a workspace can choose Haiku without a+ restart. The headers are never logged.+ - `X-Decision-Backend`: `default` (or absent) for the configured backend;+ `anthropic`, which needs `X-Decision-Anthropic-Key`; or `bedrock`, refused+ unless `DECISION_BEDROCK_ENABLED=1` (it spends the service's own AWS+ credentials).+ - `X-Decision-Anthropic-Key`: the Anthropic key for this request. Clients+ are cached by a SHA-256 of the key.+ - `X-Decision-Model`: the model for `anthropic` (default `claude-haiku-5-5`)+ or `bedrock` (default `DECISION_BEDROCK_MODEL`).+- **Logs:** one line per decision: backend, model, number of candidates,+ choice, confidence, threshold, pick and latency. No message text, room name,+ room instructions or keys.++## Backends++| `DECISION_BACKEND` | What it calls | Default `DECISION_MODEL` |+|---|---|---|+| `llamacpp` (default) | a llama.cpp server; reads the probabilities of the option letters from the first token | `qwen3.5-4b-q4_k_m` |+| `systemone` | a SystemOne-API server (Clef-flash, Strands Decider) | `clef-flash` |+| `anthropic` | Claude Haiku on the Anthropic API, forced to call a pick tool; thinking off | `claude-haiku-5-5` |+| `bedrock` | a model on Amazon Bedrock through Converse, forced to call the same tool | `us.anthropic.claude-haiku-5-5-v1:0` |+| `ollama` | an Ollama model forced into JSON, kept for comparison | `qwen3.5:9b` |++## Settings++| Variable | Default | |+|---|---|---|+| `DECISION_BACKEND` | `llamacpp` | see above |+| `DECISION_MODEL` | per backend | reported by `/health` and `/decide` |+| `LLAMACPP_URL` | `http://127.0.0.1:8300` | llama.cpp server |+| `SYSTEMONE_URL` | `http://127.0.0.1:8100/v1/systemone` | SystemOne server |+| `OLLAMA_URL` | `http://localhost:11434` | Ollama |+| `DECISION_CONFIDENCE_THRESHOLD` | `0.6` | 0 to 1; a request can override it |+| `DECISION_TIMEOUT_S` | `30` | per backend call |+| `DECISION_HISTORY_LIMIT` | `30` | recent and thread messages kept |+| `DECISION_WITH_REASON` | `1` | `0` drops the reason from Haiku's tool call |+| `DECISION_SERVICE_TOKEN` | unset | bearer token for everything but `/health` |+| `DECISION_BEDROCK_ENABLED` | unset | `1` lets a request choose `bedrock` |+| `DECISION_BEDROCK_MODEL` | `us.anthropic.claude-haiku-5-5-v1:0` | Bedrock model or inference profile |+| `AWS_REGION`, `AWS_PROFILE` | `us-east-1`, unset | standard AWS credential chain |+| `ANTHROPIC_API_KEY` | unset | service-wide key when `DECISION_BACKEND=anthropic` |+| `PORT` | `8230` | the image's listen port |++## Run locally++Start a llama.cpp server with a Qwen3.5-4B GGUF (4-bit), then the service:++```+llama-server -m qwen3.5-4b-q4_k_m.gguf --port 8300+cd decision+uv sync+uv run uvicorn switch_decision.app:app --port 8230+curl localhost:8230/health+uv run pytest+```++## Run with Docker++The `switch-decision` image is CPU-only and holds no model weights. The model+runs in its own container: on a GPU host, the llama.cpp server image with the+weights in a volume.++```+docker build -t switch-decision decision/++# the model server (NVIDIA GPU)+docker run -d --gpus all -v decision-models:/models -p 8300:8080 \+ ghcr.io/ggml-org/llama.cpp:server-cuda \+ -m /models/qwen3.5-4b-q4_k_m.gguf --host 0.0.0.0 --port 8080 -ngl 99++# the service+docker run -d -p 8230:8230 \+ --add-host=host.docker.internal:host-gateway \+ -e LLAMACPP_URL=http://host.docker.internal:8300 \+ switch-decision+```++Without a GPU, use the `ghcr.io/ggml-org/llama.cpp:server` image and drop+`--gpus` and `-ngl`. Expect several seconds per decision.++To use Haiku only, no model server is needed: set+`DECISION_BACKEND=anthropic` and `ANTHROPIC_API_KEY`, or leave the default+backend and send the override headers per request.++## Evaluate++`eval/` holds two scenario sets: `scenarios.json` (15 easy cases, three agents)+and `scenarios_hard.json` (40 cases, five agents with overlapping jobs;+regenerate it with `eval/make_hard_scenarios.py`).++```+uv run python eval/eval.py --url http://localhost:8230+uv run python eval/eval.py --url http://localhost:8230 --file eval/scenarios_hard.json+# through the Haiku override (reads ANTHROPIC_API_KEY)+uv run python eval/eval.py --url http://localhost:8230 --file eval/scenarios_hard.json --backend anthropic+```++`DECISION_SERVICE_TOKEN` is sent when set. It prints each pick, then the+accuracy and the median and maximum latency.++## Latency so far++On the 40-scenario hard set:++- **Qwen3.5-4B (4-bit) via llama.cpp:** 34/40, 0.61 s median on an Apple M4 Pro.+- **Haiku 5.5 via the Anthropic API:** 39/40, 1.4–1.6 s median, about 2.7 s+ p95. About 0.65 s of each call is fixed API and network overhead.+- **On one NVIDIA L4:** an estimated 0.1–0.4 s for the small models. Not yet+ measured.diff --git a/decision/eval/eval.py b/decision/eval/eval.pynew file mode 100644index 000000000..7e52996e7--- /dev/null+++ b/decision/eval/eval.py@@ -0,0 +1,86 @@+"""Run every scenario against a decision service and print how it did.++ uv run python eval/eval.py [--url http://localhost:8230] [--file eval/scenarios_hard.json]+ [--threshold 0.6] [--backend anthropic]++DECISION_SERVICE_TOKEN and ANTHROPIC_API_KEY are read from the environment when set.+"""++import argparse+import json+import os+import statistics+import sys+from pathlib import Path++import httpx+++def main() -> int:+ ap = argparse.ArgumentParser()+ ap.add_argument("--url", default="http://localhost:8230")+ ap.add_argument("--threshold", type=float, default=None)+ ap.add_argument("--file", default=str(Path(__file__).with_name("scenarios.json")))+ ap.add_argument(+ "--backend",+ default=None,+ help="sent as X-Decision-Backend (default, anthropic, bedrock)",+ )+ ap.add_argument("--model", default=None, help="sent as X-Decision-Model")+ args = ap.parse_args()+ data = json.load(open(args.file))+ headers = {}+ if token := os.environ.get("DECISION_SERVICE_TOKEN"):+ headers["Authorization"] = f"Bearer {token}"+ if args.backend:+ headers["X-Decision-Backend"] = args.backend+ if args.backend == "anthropic" and os.environ.get("ANTHROPIC_API_KEY"):+ headers["X-Decision-Anthropic-Key"] = os.environ["ANTHROPIC_API_KEY"]+ if args.model:+ headers["X-Decision-Model"] = args.model+ rows, latencies = [], []+ correct = routed = routed_right = 0+ for s in data["scenarios"]:+ body = {+ "room": data["room"],+ "agents": data["agents"],+ "message": s["message"],+ "recent": s.get("recent", []),+ "thread": s.get("thread", []),+ }+ if args.threshold is not None:+ body["confidence_threshold"] = args.threshold+ r = httpx.post(f"{args.url}/decide", json=body, headers=headers, timeout=120)+ r.raise_for_status()+ out = r.json()+ ok = out["agent"] in s["expect"]+ correct += ok+ if out["agent"] is not None:+ routed += 1+ routed_right += ok+ latencies.append(out["latency_ms"])+ rows.append(+ (+ s["id"],+ "/".join(str(e) for e in s["expect"]),+ str(out["agent"]),+ out["model_choice"],+ f"{out['confidence']:.2f}",+ out["latency_ms"],+ "PASS" if ok else "FAIL",+ out["reason"][:90],+ )+ )+ w = [max(len(str(r[i])) for r in rows) for i in range(7)]+ for r in rows:+ print(" ".join(str(c).ljust(w[i]) for i, c in enumerate(r[:7])) + " " + r[7])+ n = len(rows)+ print(+ f"\ncorrect {correct}/{n} routed {routed} precision of routed {routed_right}/{routed if routed else 1}"+ f" median latency {statistics.median(latencies)} ms max {max(latencies)} ms"+ )+ return 0 if correct == n else 1+++if __name__ == "__main__":+ sys.exit(main())diff --git a/decision/eval/make_hard_scenarios.py b/decision/eval/make_hard_scenarios.pynew file mode 100644index 000000000..e927b5f88--- /dev/null+++ b/decision/eval/make_hard_scenarios.py@@ -0,0 +1,392 @@+"""Write scenarios_hard.json: 40 harder cases with five overlapping agents."""++import json+from pathlib import Path+++def P(s, t, to=()):+ return {"sender": s, "sender_kind": "person", "text": t, "addressed": list(to)}+++def A(s, t, to=()):+ return {"sender": s, "sender_kind": "agent", "text": t, "addressed": list(to)}+++def M(s, t, thread=None):+ return {"sender": s, "text": t, "thread_id": thread}+++room = {+ "name": "eng-platform",+ "instructions": (+ "Platform team room. Deploys and CI go to deploy-bot; cloud infrastructure, databases and cloud costs go to infra-bot; "+ "customer invoices and plans go to billing-bot; customer tickets and escalations go to support-bot, who is on call; "+ "docs and release notes go to docs-bot. People here also talk among themselves; agents should not jump into those."+ ),+}+agents = [+ {+ "name": "deploy-bot",+ "description": "Runs and watches CI pipelines and deployments; investigates failed builds and deploys, reruns and rolls back.",+ "role": "release",+ },+ {+ "name": "infra-bot",+ "description": "Cloud infrastructure: databases, queues, Kubernetes clusters, networking, capacity and the cloud bill.",+ },+ {+ "name": "billing-bot",+ "description": "Customer billing: pricing, plans, invoices, refunds, payment failures.",+ },+ {+ "name": "support-bot",+ "description": "Customer support tickets, escalations and account questions from customers.",+ "role": "on-call",+ },+ {+ "name": "docs-bot",+ "description": "Product documentation, guides, API reference and release notes.",+ },+]+deploy_thread = [+ P("sara", "prod deploy for 4.2 failed again"),+ A(+ "deploy-bot",+ "It failed at the database migration: the new index timed out. I can rerun it with a longer timeout or roll back.",+ ["sara"],+ ),+]+infra_thread = [+ P("lee", "the orders database is at 92% CPU"),+ A(+ "infra-bot",+ "It's the nightly report query doing a full table scan. I can add the index or move the report to the replica.",+ ["lee"],+ ),+]+recent_chatter = [+ P("tom", "morning!"),+ P("priya", "morning, coffee first"),+ P("tom", "standup moved to 10:30 today"),+ P("sara", "ok thanks"),+]++S = [+ # clear but with overlapping vocabulary+ (+ "deploy-vs-infra-pipeline",+ ["deploy-bot"],+ [],+ [],+ M("sara", "the CI pipeline has been queued for 40 minutes, can someone look?"),+ ),+ (+ "infra-db-disk",+ ["infra-bot"],+ [],+ [],+ M(+ "lee",+ "we're running out of disk on the analytics database, what are our options?",+ ),+ ),+ (+ "infra-cloud-cost",+ ["infra-bot"],+ [],+ [],+ M("priya", "why did our cloud bill jump 30% last month?"),+ ),+ (+ "billing-customer-invoice",+ ["billing-bot"],+ [],+ [],+ M(+ "priya",+ "acme says their October invoice charged them for 50 seats instead of 40",+ ),+ ),+ (+ "support-escalation",+ ["support-bot"],+ [],+ [],+ M(+ "tom",+ "a customer is threatening to churn because login has been broken for them since yesterday, who can pick this up?",+ ),+ ),+ (+ "docs-release-notes",+ ["docs-bot"],+ [],+ [],+ M("sara", "we need release notes for 4.2 before the deploy goes out"),+ ),+ (+ "cloud-bill-not-customer-bill",+ ["infra-bot"],+ [],+ [],+ M("lee", "can we get a breakdown of what we spend on Kubernetes versus RDS?"),+ ),+ (+ "customer-refund-not-cloud",+ ["billing-bot"],+ [],+ [],+ M("priya", "can we refund the duplicate payment from globex?"),+ ),+ (+ "rollback-request",+ ["deploy-bot"],+ [],+ [],+ M("tom", "4.2 is throwing 500s on checkout, should we roll back?"),+ ),+ (+ "queue-backlog",+ ["infra-bot"],+ [],+ [],+ M("lee", "the email queue has 200k messages backed up"),+ ),+ # thread continuations, including topic shifts+ (+ "thread-continue-rerun",+ ["deploy-bot"],+ deploy_thread,+ [],+ M("sara", "rerun it with the longer timeout please", "t1"),+ ),+ (+ "thread-shift-to-docs",+ ["docs-bot"],+ deploy_thread,+ [],+ M("sara", "while that runs, can the changelog mention the new index?", "t1"),+ ),+ (+ "thread-continue-index",+ ["infra-bot"],+ infra_thread,+ [],+ M("lee", "add the index, and do it tonight", "t2"),+ ),+ (+ "thread-shift-to-billing",+ ["billing-bot"],+ infra_thread,+ [],+ M("lee", "unrelated, but did the refund for globex go through?", "t2"),+ ),+ ("thread-ack", [None], deploy_thread, [], M("sara", "ok cool, thanks", "t1")),+ (+ "thread-person-to-person",+ [None],+ deploy_thread,+ [],+ M("tom", "sara are you around to watch it after lunch?", "t1"),+ ),+ (+ "thread-pronoun-it",+ ["deploy-bot"],+ deploy_thread + [P("sara", "roll back for now")],+ [],+ M("sara", "and let me know when it's done", "t1"),+ ),+ # people talking among themselves about agent topics+ (+ "people-debating-rollback",+ [None],+ [],+ [+ P("tom", "I think we should roll back 4.2"),+ P("sara", "I'd rather fix forward, the bug is small"),+ ],+ M("tom", "fair, let's give it an hour"),+ ),+ (+ "people-planning-db",+ [None],+ [],+ [+ P("lee", "we should move reporting to a replica this quarter"),+ P("priya", "agreed, I'll put it on the roadmap"),+ ],+ M("lee", "I'll write the design doc next week"),+ ),+ (+ "named-person-deploy",+ [None],+ [],+ [],+ M("tom", "sara can you check why the deploy failed when you get a minute?"),+ ),+ (+ "named-person-invoice",+ [None],+ [],+ [],+ M("sara", "priya, did you ever hear back from acme about the invoice?"),+ ),+ (+ "opinion-not-question",+ [None],+ [],+ [],+ M("lee", "honestly our CI has been flaky all week"),+ ),+ (+ "rhetorical",+ [None],+ [],+ [],+ M("tom", "who decided friday deploys were a good idea lol"),+ ),+ (+ "social",+ [None],+ [],+ recent_chatter,+ M("priya", "anyone want to grab lunch at 12?"),+ ),+ (+ "praise",+ [None],+ deploy_thread,+ [],+ M("sara", "nice work everyone on the release", "t1"),+ ),+ (+ "announcement",+ [None],+ [],+ [],+ M("tom", "reminder: the office is closed on monday"),+ ),+ # ambiguous, either answer acceptable+ (+ "ambiguous-db-migration-deploy",+ ["deploy-bot", "infra-bot"],+ [],+ [],+ M("sara", "the migration is locking the users table, what do we do?"),+ ),+ (+ "ambiguous-customer-billing-support",+ ["billing-bot", "support-bot"],+ [],+ [],+ M(+ "tom",+ "a customer says they were charged after cancelling and they're angry",+ ),+ ),+ (+ "ambiguous-docs-support",+ ["docs-bot", "support-bot"],+ [],+ [],+ M("priya", "customers keep asking how to rotate their API keys"),+ ),+ (+ "ambiguous-cost-or-billing",+ ["infra-bot", "billing-bot"],+ [],+ [],+ M("lee", "why is the bill so high this month?"),+ ),+ # instructions / roles+ (+ "on-call-escalation",+ ["support-bot"],+ [],+ [],+ M("tom", "we have a sev2 from a customer, who's on call?"),+ ),+ (+ "release-role",+ ["deploy-bot"],+ [],+ [],+ M("sara", "who's handling the release today?"),+ ),+ # nothing any agent covers+ (+ "out-of-scope-hiring",+ [None],+ [],+ [],+ M("priya", "how many interviews do we have this week?"),+ ),+ (+ "out-of-scope-design",+ [None],+ [],+ [],+ M("sara", "does anyone have the figma file for the new onboarding?"),+ ),+ ("vague", [None], [], [], M("tom", "hmm")),+ # longer context: the channel moved on to another topic+ (+ "context-moved-on",+ ["billing-bot"],+ [],+ [+ P("sara", "deploy failed again"),+ A("deploy-bot", "Rerunning with the cache cleared.", ["sara"]),+ P("sara", "thanks, it's green now"),+ P("priya", "switching topics: globex disputed their card payment"),+ ],+ M("priya", "what do we need from them to resolve it?"),+ ),+ (+ "context-agent-already-helping",+ ["infra-bot"],+ [],+ [+ P("lee", "orders db CPU is high again"),+ A("infra-bot", "Same report query. Moving it to the replica now.", ["lee"]),+ ],+ M("lee", "how long will that take?"),+ ),+ (+ "context-two-agents-recent",+ ["docs-bot"],+ [],+ [+ A("deploy-bot", "4.2 is deployed to production."),+ A("docs-bot", "Release notes for 4.2 are drafted and waiting for review."),+ ],+ M("sara", "can you add the migration change to them?"),+ ),+ (+ "context-person-reply-to-person",+ [None],+ [],+ [+ P("tom", "can someone review my PR for the retry logic?"),+ P("sara", "I'll take it after lunch"),+ ],+ M("tom", "thanks sara!"),+ ),+ (+ "question-to-room-after-chatter",+ ["infra-bot"],+ [],+ recent_chatter,+ M("lee", "is anyone else seeing timeouts from the redis cluster?"),+ ),+]+out = {+ "room": room,+ "agents": agents,+ "scenarios": [+ {"id": i, "expect": e, "thread": t, "recent": r, "message": m}+ for i, e, t, r, m in S+ ],+}+json.dump(out, open(Path(__file__).with_name("scenarios_hard.json"), "w"), indent=1)+print(len(S), "scenarios")diff --git a/decision/eval/scenarios.json b/decision/eval/scenarios.jsonnew file mode 100644index 000000000..49881361d--- /dev/null+++ b/decision/eval/scenarios.json@@ -0,0 +1,45 @@+{+ "room": {"name": "eng-team", "instructions": "Team channel for the web product. billing-bot handles customer escalations about money."},+ "agents": [+ {"name": "deploy-bot", "description": "Runs and watches CI and deployments; investigates failed builds and deploys, reruns pipelines.", "role": "release"},+ {"name": "billing-bot", "description": "Handles pricing, plans, invoices, refunds and payment problems."},+ {"name": "docs-bot", "description": "Writes and updates product documentation pages and guides."}+ ],+ "scenarios": [+ {"id": "deploy-failed", "expect": ["deploy-bot"], "message": {"sender": "alice", "text": "Can someone check why last night's deploy failed?"}},+ {"id": "double-charge", "expect": ["billing-bot"], "message": {"sender": "carol", "text": "We got charged twice on the March invoice, who can look into it?"}},+ {"id": "docs-outdated", "expect": ["docs-bot"], "message": {"sender": "bob", "text": "The API page in the docs still shows the old auth flow"}},+ {"id": "thanks", "expect": [null],+ "recent": [+ {"sender": "alice", "text": "Can someone check why last night's deploy failed?"},+ {"sender": "deploy-bot", "sender_kind": "agent", "text": "The migration step timed out; I reran it and the deploy is green now.", "addressed": ["alice"]}+ ],+ "message": {"sender": "alice", "text": "thanks!"}},+ {"id": "person-to-person", "expect": [null], "message": {"sender": "alice", "text": "Bob, are you joining standup in 5?"}},+ {"id": "lunch", "expect": [null], "message": {"sender": "carol", "text": "lunch anyone? thinking tacos"}},+ {"id": "weather", "expect": [null], "message": {"sender": "bob", "text": "what's the weather going to be like in London tomorrow?"}},+ {"id": "thread-continue-deploy", "expect": ["deploy-bot"],+ "thread": [+ {"sender": "alice", "text": "Staging deploy is stuck on the build step"},+ {"sender": "deploy-bot", "sender_kind": "agent", "text": "The build cache looks corrupted; the step keeps restoring a stale layer.", "addressed": ["alice"]}+ ],+ "message": {"sender": "alice", "text": "ok can you rerun it with the cache cleared?", "thread_id": "t1"}},+ {"id": "escalation-room-rule", "expect": ["billing-bot"], "message": {"sender": "dave", "text": "A customer is really upset about how their cancellation was handled"}},+ {"id": "follow-on-docs", "expect": ["docs-bot"],+ "recent": [+ {"sender": "alice", "text": "docs-bot please draft a getting-started guide for the CLI", "addressed": ["docs-bot"]},+ {"sender": "docs-bot", "sender_kind": "agent", "text": "Drafted it: covers install, login and the first command.", "addressed": ["alice"]}+ ],+ "message": {"sender": "alice", "text": "one more thing, add a section on rate limits"}},+ {"id": "build-green", "expect": ["deploy-bot"], "message": {"sender": "bob", "text": "is the main build green yet?"}},+ {"id": "named-person-no-at", "expect": [null], "message": {"sender": "carol", "text": "bob can you approve my PR when you get a sec"}},+ {"id": "plans-question", "expect": ["billing-bot"], "message": {"sender": "erin", "text": "what's the difference between the Team and Business plans?"}},+ {"id": "ambiguous-pricing-docs", "expect": ["billing-bot", "docs-bot"], "message": {"sender": "alice", "text": "the pricing page needs updating for the new Business plan"}},+ {"id": "people-discussing-deploy", "expect": [null],+ "recent": [+ {"sender": "alice", "text": "bob, did you see the deploy failed earlier?", "addressed": ["bob"]},+ {"sender": "bob", "text": "yeah I'm on it, it's the flaky migration again"}+ ],+ "message": {"sender": "alice", "text": "cool, ping me if you need a hand"}}+ ]+}diff --git a/decision/eval/scenarios_hard.json b/decision/eval/scenarios_hard.jsonnew file mode 100644index 000000000..7f2802190--- /dev/null+++ b/decision/eval/scenarios_hard.json@@ -0,0 +1,826 @@+{+ "room": {+ "name": "eng-platform",+ "instructions": "Platform team room. Deploys and CI go to deploy-bot; cloud infrastructure, databases and cloud costs go to infra-bot; customer invoices and plans go to billing-bot; customer tickets and escalations go to support-bot, who is on call; docs and release notes go to docs-bot. People here also talk among themselves; agents should not jump into those."+ },+ "agents": [+ {+ "name": "deploy-bot",+ "description": "Runs and watches CI pipelines and deployments; investigates failed builds and deploys, reruns and rolls back.",+ "role": "release"+ },+ {+ "name": "infra-bot",+ "description": "Cloud infrastructure: databases, queues, Kubernetes clusters, networking, capacity and the cloud bill."+ },+ {+ "name": "billing-bot",+ "description": "Customer billing: pricing, plans, invoices, refunds, payment failures."+ },+ {+ "name": "support-bot",+ "description": "Customer support tickets, escalations and account questions from customers.",+ "role": "on-call"+ },+ {+ "name": "docs-bot",+ "description": "Product documentation, guides, API reference and release notes."+ }+ ],+ "scenarios": [+ {+ "id": "deploy-vs-infra-pipeline",+ "expect": [+ "deploy-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "the CI pipeline has been queued for 40 minutes, can someone look?",+ "thread_id": null+ }+ },+ {+ "id": "infra-db-disk",+ "expect": [+ "infra-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "lee",+ "text": "we're running out of disk on the analytics database, what are our options?",+ "thread_id": null+ }+ },+ {+ "id": "infra-cloud-cost",+ "expect": [+ "infra-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "priya",+ "text": "why did our cloud bill jump 30% last month?",+ "thread_id": null+ }+ },+ {+ "id": "billing-customer-invoice",+ "expect": [+ "billing-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "priya",+ "text": "acme says their October invoice charged them for 50 seats instead of 40",+ "thread_id": null+ }+ },+ {+ "id": "support-escalation",+ "expect": [+ "support-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "tom",+ "text": "a customer is threatening to churn because login has been broken for them since yesterday, who can pick this up?",+ "thread_id": null+ }+ },+ {+ "id": "docs-release-notes",+ "expect": [+ "docs-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "we need release notes for 4.2 before the deploy goes out",+ "thread_id": null+ }+ },+ {+ "id": "cloud-bill-not-customer-bill",+ "expect": [+ "infra-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "lee",+ "text": "can we get a breakdown of what we spend on Kubernetes versus RDS?",+ "thread_id": null+ }+ },+ {+ "id": "customer-refund-not-cloud",+ "expect": [+ "billing-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "priya",+ "text": "can we refund the duplicate payment from globex?",+ "thread_id": null+ }+ },+ {+ "id": "rollback-request",+ "expect": [+ "deploy-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "tom",+ "text": "4.2 is throwing 500s on checkout, should we roll back?",+ "thread_id": null+ }+ },+ {+ "id": "queue-backlog",+ "expect": [+ "infra-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "lee",+ "text": "the email queue has 200k messages backed up",+ "thread_id": null+ }+ },+ {+ "id": "thread-continue-rerun",+ "expect": [+ "deploy-bot"+ ],+ "thread": [+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "prod deploy for 4.2 failed again",+ "addressed": []+ },+ {+ "sender": "deploy-bot",+ "sender_kind": "agent",+ "text": "It failed at the database migration: the new index timed out. I can rerun it with a longer timeout or roll back.",+ "addressed": [+ "sara"+ ]+ }+ ],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "rerun it with the longer timeout please",+ "thread_id": "t1"+ }+ },+ {+ "id": "thread-shift-to-docs",+ "expect": [+ "docs-bot"+ ],+ "thread": [+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "prod deploy for 4.2 failed again",+ "addressed": []+ },+ {+ "sender": "deploy-bot",+ "sender_kind": "agent",+ "text": "It failed at the database migration: the new index timed out. I can rerun it with a longer timeout or roll back.",+ "addressed": [+ "sara"+ ]+ }+ ],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "while that runs, can the changelog mention the new index?",+ "thread_id": "t1"+ }+ },+ {+ "id": "thread-continue-index",+ "expect": [+ "infra-bot"+ ],+ "thread": [+ {+ "sender": "lee",+ "sender_kind": "person",+ "text": "the orders database is at 92% CPU",+ "addressed": []+ },+ {+ "sender": "infra-bot",+ "sender_kind": "agent",+ "text": "It's the nightly report query doing a full table scan. I can add the index or move the report to the replica.",+ "addressed": [+ "lee"+ ]+ }+ ],+ "recent": [],+ "message": {+ "sender": "lee",+ "text": "add the index, and do it tonight",+ "thread_id": "t2"+ }+ },+ {+ "id": "thread-shift-to-billing",+ "expect": [+ "billing-bot"+ ],+ "thread": [+ {+ "sender": "lee",+ "sender_kind": "person",+ "text": "the orders database is at 92% CPU",+ "addressed": []+ },+ {+ "sender": "infra-bot",+ "sender_kind": "agent",+ "text": "It's the nightly report query doing a full table scan. I can add the index or move the report to the replica.",+ "addressed": [+ "lee"+ ]+ }+ ],+ "recent": [],+ "message": {+ "sender": "lee",+ "text": "unrelated, but did the refund for globex go through?",+ "thread_id": "t2"+ }+ },+ {+ "id": "thread-ack",+ "expect": [+ null+ ],+ "thread": [+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "prod deploy for 4.2 failed again",+ "addressed": []+ },+ {+ "sender": "deploy-bot",+ "sender_kind": "agent",+ "text": "It failed at the database migration: the new index timed out. I can rerun it with a longer timeout or roll back.",+ "addressed": [+ "sara"+ ]+ }+ ],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "ok cool, thanks",+ "thread_id": "t1"+ }+ },+ {+ "id": "thread-person-to-person",+ "expect": [+ null+ ],+ "thread": [+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "prod deploy for 4.2 failed again",+ "addressed": []+ },+ {+ "sender": "deploy-bot",+ "sender_kind": "agent",+ "text": "It failed at the database migration: the new index timed out. I can rerun it with a longer timeout or roll back.",+ "addressed": [+ "sara"+ ]+ }+ ],+ "recent": [],+ "message": {+ "sender": "tom",+ "text": "sara are you around to watch it after lunch?",+ "thread_id": "t1"+ }+ },+ {+ "id": "thread-pronoun-it",+ "expect": [+ "deploy-bot"+ ],+ "thread": [+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "prod deploy for 4.2 failed again",+ "addressed": []+ },+ {+ "sender": "deploy-bot",+ "sender_kind": "agent",+ "text": "It failed at the database migration: the new index timed out. I can rerun it with a longer timeout or roll back.",+ "addressed": [+ "sara"+ ]+ },+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "roll back for now",+ "addressed": []+ }+ ],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "and let me know when it's done",+ "thread_id": "t1"+ }+ },+ {+ "id": "people-debating-rollback",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [+ {+ "sender": "tom",+ "sender_kind": "person",+ "text": "I think we should roll back 4.2",+ "addressed": []+ },+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "I'd rather fix forward, the bug is small",+ "addressed": []+ }+ ],+ "message": {+ "sender": "tom",+ "text": "fair, let's give it an hour",+ "thread_id": null+ }+ },+ {+ "id": "people-planning-db",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [+ {+ "sender": "lee",+ "sender_kind": "person",+ "text": "we should move reporting to a replica this quarter",+ "addressed": []+ },+ {+ "sender": "priya",+ "sender_kind": "person",+ "text": "agreed, I'll put it on the roadmap",+ "addressed": []+ }+ ],+ "message": {+ "sender": "lee",+ "text": "I'll write the design doc next week",+ "thread_id": null+ }+ },+ {+ "id": "named-person-deploy",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "tom",+ "text": "sara can you check why the deploy failed when you get a minute?",+ "thread_id": null+ }+ },+ {+ "id": "named-person-invoice",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "priya, did you ever hear back from acme about the invoice?",+ "thread_id": null+ }+ },+ {+ "id": "opinion-not-question",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "lee",+ "text": "honestly our CI has been flaky all week",+ "thread_id": null+ }+ },+ {+ "id": "rhetorical",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "tom",+ "text": "who decided friday deploys were a good idea lol",+ "thread_id": null+ }+ },+ {+ "id": "social",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [+ {+ "sender": "tom",+ "sender_kind": "person",+ "text": "morning!",+ "addressed": []+ },+ {+ "sender": "priya",+ "sender_kind": "person",+ "text": "morning, coffee first",+ "addressed": []+ },+ {+ "sender": "tom",+ "sender_kind": "person",+ "text": "standup moved to 10:30 today",+ "addressed": []+ },+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "ok thanks",+ "addressed": []+ }+ ],+ "message": {+ "sender": "priya",+ "text": "anyone want to grab lunch at 12?",+ "thread_id": null+ }+ },+ {+ "id": "praise",+ "expect": [+ null+ ],+ "thread": [+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "prod deploy for 4.2 failed again",+ "addressed": []+ },+ {+ "sender": "deploy-bot",+ "sender_kind": "agent",+ "text": "It failed at the database migration: the new index timed out. I can rerun it with a longer timeout or roll back.",+ "addressed": [+ "sara"+ ]+ }+ ],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "nice work everyone on the release",+ "thread_id": "t1"+ }+ },+ {+ "id": "announcement",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "tom",+ "text": "reminder: the office is closed on monday",+ "thread_id": null+ }+ },+ {+ "id": "ambiguous-db-migration-deploy",+ "expect": [+ "deploy-bot",+ "infra-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "the migration is locking the users table, what do we do?",+ "thread_id": null+ }+ },+ {+ "id": "ambiguous-customer-billing-support",+ "expect": [+ "billing-bot",+ "support-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "tom",+ "text": "a customer says they were charged after cancelling and they're angry",+ "thread_id": null+ }+ },+ {+ "id": "ambiguous-docs-support",+ "expect": [+ "docs-bot",+ "support-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "priya",+ "text": "customers keep asking how to rotate their API keys",+ "thread_id": null+ }+ },+ {+ "id": "ambiguous-cost-or-billing",+ "expect": [+ "infra-bot",+ "billing-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "lee",+ "text": "why is the bill so high this month?",+ "thread_id": null+ }+ },+ {+ "id": "on-call-escalation",+ "expect": [+ "support-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "tom",+ "text": "we have a sev2 from a customer, who's on call?",+ "thread_id": null+ }+ },+ {+ "id": "release-role",+ "expect": [+ "deploy-bot"+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "who's handling the release today?",+ "thread_id": null+ }+ },+ {+ "id": "out-of-scope-hiring",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "priya",+ "text": "how many interviews do we have this week?",+ "thread_id": null+ }+ },+ {+ "id": "out-of-scope-design",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "sara",+ "text": "does anyone have the figma file for the new onboarding?",+ "thread_id": null+ }+ },+ {+ "id": "vague",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [],+ "message": {+ "sender": "tom",+ "text": "hmm",+ "thread_id": null+ }+ },+ {+ "id": "context-moved-on",+ "expect": [+ "billing-bot"+ ],+ "thread": [],+ "recent": [+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "deploy failed again",+ "addressed": []+ },+ {+ "sender": "deploy-bot",+ "sender_kind": "agent",+ "text": "Rerunning with the cache cleared.",+ "addressed": [+ "sara"+ ]+ },+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "thanks, it's green now",+ "addressed": []+ },+ {+ "sender": "priya",+ "sender_kind": "person",+ "text": "switching topics: globex disputed their card payment",+ "addressed": []+ }+ ],+ "message": {+ "sender": "priya",+ "text": "what do we need from them to resolve it?",+ "thread_id": null+ }+ },+ {+ "id": "context-agent-already-helping",+ "expect": [+ "infra-bot"+ ],+ "thread": [],+ "recent": [+ {+ "sender": "lee",+ "sender_kind": "person",+ "text": "orders db CPU is high again",+ "addressed": []+ },+ {+ "sender": "infra-bot",+ "sender_kind": "agent",+ "text": "Same report query. Moving it to the replica now.",+ "addressed": [+ "lee"+ ]+ }+ ],+ "message": {+ "sender": "lee",+ "text": "how long will that take?",+ "thread_id": null+ }+ },+ {+ "id": "context-two-agents-recent",+ "expect": [+ "docs-bot"+ ],+ "thread": [],+ "recent": [+ {+ "sender": "deploy-bot",+ "sender_kind": "agent",+ "text": "4.2 is deployed to production.",+ "addressed": []+ },+ {+ "sender": "docs-bot",+ "sender_kind": "agent",+ "text": "Release notes for 4.2 are drafted and waiting for review.",+ "addressed": []+ }+ ],+ "message": {+ "sender": "sara",+ "text": "can you add the migration change to them?",+ "thread_id": null+ }+ },+ {+ "id": "context-person-reply-to-person",+ "expect": [+ null+ ],+ "thread": [],+ "recent": [+ {+ "sender": "tom",+ "sender_kind": "person",+ "text": "can someone review my PR for the retry logic?",+ "addressed": []+ },+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "I'll take it after lunch",+ "addressed": []+ }+ ],+ "message": {+ "sender": "tom",+ "text": "thanks sara!",+ "thread_id": null+ }+ },+ {+ "id": "question-to-room-after-chatter",+ "expect": [+ "infra-bot"+ ],+ "thread": [],+ "recent": [+ {+ "sender": "tom",+ "sender_kind": "person",+ "text": "morning!",+ "addressed": []+ },+ {+ "sender": "priya",+ "sender_kind": "person",+ "text": "morning, coffee first",+ "addressed": []+ },+ {+ "sender": "tom",+ "sender_kind": "person",+ "text": "standup moved to 10:30 today",+ "addressed": []+ },+ {+ "sender": "sara",+ "sender_kind": "person",+ "text": "ok thanks",+ "addressed": []+ }+ ],+ "message": {+ "sender": "lee",+ "text": "is anyone else seeing timeouts from the redis cluster?",+ "thread_id": null+ }+ }+ ]+}\ No newline at end of filediff --git a/decision/pyproject.toml b/decision/pyproject.tomlnew file mode 100644index 000000000..1aafadfb3--- /dev/null+++ b/decision/pyproject.toml@@ -0,0 +1,40 @@+[project]+name = "switch-decision"+version = "0.1.0"+description = "Switch decision service: picks which agent in a room, if any, should answer a message nobody tagged."+requires-python = ">=3.12"+license = "LicenseRef-Apache-2.0-with-Commons-Clause"+dependencies = [+ "fastapi>=0.115",+ "uvicorn>=0.30",+ "httpx>=0.27",+ "pydantic>=2.7",+ "boto3>=1.43.117",+ "anthropic>=2.3.0",+]++[build-system]+requires = ["hatchling"]+build-backend = "hatchling.build"++[tool.hatch.build.targets.wheel]+packages = ["switch_decision"]++[dependency-groups]+dev = [+ "pytest>=9.1.1",+]++[tool.pytest.ini_options]+testpaths = ["tests"]++[tool.ruff]+target-version = "py312"+src = ["."]++[tool.ruff.lint]+select = ["E", "F", "I", "UP"]+ignore = ["E501"]++[tool.ruff.lint.isort]+known-first-party = ["switch_decision"]diff --git a/decision/switch_decision/__init__.py b/decision/switch_decision/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/decision/switch_decision/app.py b/decision/switch_decision/app.pynew file mode 100644index 000000000..feeee7550--- /dev/null+++ b/decision/switch_decision/app.py@@ -0,0 +1,214 @@+"""The decision service: POST /decide picks which agent in a room should answer+an untagged message, GET /health reports the backend and its model server.++The HTTP contract is fixed in the decision-routing-setup change (contracts.md,+section 1); see decision/README.md."""++import hmac+import logging+import time+from contextlib import asynccontextmanager+from dataclasses import replace++import httpx+from fastapi import FastAPI, HTTPException, Request+from fastapi.responses import JSONResponse++from switch_decision.backends import (+ InvalidChoiceError,+ ModelServerError,+ ask,+ check,+ model_server,+)+from switch_decision.config import DEFAULT_ANTHROPIC_MODEL, Settings, load_settings+from switch_decision.models import DecideRequest, DecideResponse+from switch_decision.prompt import NONE++logger = logging.getLogger("switch_decision")+logging.basicConfig(+ level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s"+)++BACKEND_HEADER = "X-Decision-Backend"+ANTHROPIC_KEY_HEADER = "X-Decision-Anthropic-Key"+MODEL_HEADER = "X-Decision-Model"++settings = load_settings()+client: httpx.AsyncClient | None = None+++@asynccontextmanager+async def lifespan(_: FastAPI):+ global client+ client = httpx.AsyncClient()+ yield+ await client.aclose()+++app = FastAPI(title="Switch decision service", lifespan=lifespan)+++def _client() -> httpx.AsyncClient:+ assert client is not None+ return client+++class BackendUnavailable(Exception):+ def __init__(self, detail: str):+ super().__init__(detail)+ self.detail = detail++[email protected]_handler(BackendUnavailable)+async def _backend_unavailable(_: Request, exc: BackendUnavailable) -> JSONResponse:+ return JSONResponse(+ status_code=400, content={"detail": exc.detail, "code": "backend_unavailable"}+ )++[email protected]("http")+async def require_token(request: Request, call_next):+ """With DECISION_SERVICE_TOKEN set, everything but GET /health needs the bearer token."""+ token = settings.service_token+ if token and not (request.method == "GET" and request.url.path == "/health"):+ scheme, _, given = request.headers.get("authorization", "").partition(" ")+ if scheme.lower() != "bearer" or not hmac.compare_digest(+ given.strip().encode(), token.encode()+ ):+ return JSONResponse(+ status_code=401,+ content={"detail": "missing or wrong bearer token"},+ headers={"WWW-Authenticate": "Bearer"},+ )+ return await call_next(request)+++def backends_available(s: Settings) -> list[str]:+ return ["default", "anthropic"] + (["bedrock"] if s.bedrock_enabled else [])+++def resolve_backend(request: Request) -> tuple[Settings, str | None]:+ """The settings for this request (after any X-Decision-Backend override) and+ the per-request Anthropic key, if any. Header values are never logged."""+ name = (request.headers.get(BACKEND_HEADER) or "default").strip().lower()+ model = (request.headers.get(MODEL_HEADER) or "").strip() or None+ if name == "default":+ return settings, None+ if name == "anthropic":+ key = (request.headers.get(ANTHROPIC_KEY_HEADER) or "").strip()+ if not key:+ raise BackendUnavailable(+ f"the anthropic backend needs an {ANTHROPIC_KEY_HEADER} header"+ )+ return replace(+ settings, backend="anthropic", model=model or DEFAULT_ANTHROPIC_MODEL+ ), key+ if name == "bedrock":+ if not settings.bedrock_enabled:+ raise BackendUnavailable(+ "the bedrock backend is not enabled on this service (DECISION_BEDROCK_ENABLED)"+ )+ return replace(+ settings, backend="bedrock", model=model or settings.bedrock_model+ ), None+ raise BackendUnavailable(+ f"unknown backend {name[:40]!r}; use one of {backends_available(settings)}"+ )++[email protected]("/health")+async def health() -> dict:+ try:+ server = await check(_client(), settings)+ except ModelServerError as exc:+ raise HTTPException(status_code=503, detail=str(exc)) from exc+ return {+ "ok": True,+ "backend": settings.backend,+ "model": settings.model,+ "model_server": model_server(settings),+ "model_server_status": server,+ "confidence_threshold": settings.confidence_threshold,+ "backends_available": backends_available(settings),+ }++[email protected]("/decide")+async def decide(req: DecideRequest, request: Request) -> DecideResponse:+ if not req.agents:+ raise HTTPException(+ status_code=422, detail="agents must list at least one agent"+ )+ used, anthropic_key = resolve_backend(request)+ threshold = (+ req.confidence_threshold+ if req.confidence_threshold is not None+ else used.confidence_threshold+ )+ candidates = len(req.agents)+ started = time.monotonic()+ try:+ answer = await ask(_client(), used, req, anthropic_key)+ except InvalidChoiceError as exc:+ # The backend answered but named no candidate: route to nobody.+ latency_ms = int((time.monotonic() - started) * 1000)+ logger.error(+ "decide invalid_choice backend=%s model=%s candidates=%d choice=%.60r confidence=%.2f "+ "threshold=%.2f picked=None latency_ms=%d",+ used.backend,+ used.model,+ candidates,+ exc.choice,+ exc.confidence,+ threshold,+ latency_ms,+ )+ return DecideResponse(+ agent=None,+ model_choice=exc.choice,+ confidence=exc.confidence,+ threshold=threshold,+ reason="the model named an agent that is not a candidate",+ model=used.model,+ backend=used.backend,+ latency_ms=latency_ms,+ )+ except ModelServerError as exc:+ latency_ms = int((time.monotonic() - started) * 1000)+ logger.warning(+ "decide failed backend=%s model=%s candidates=%d latency_ms=%d error=%s",+ used.backend,+ used.model,+ candidates,+ latency_ms,+ exc.log_text,+ )+ raise HTTPException(status_code=502, detail=str(exc)) from exc+ latency_ms = int((time.monotonic() - started) * 1000)+ picked = (+ None+ if answer.choice == NONE or answer.confidence < threshold+ else answer.choice+ )+ logger.info(+ "decide backend=%s model=%s candidates=%d choice=%s confidence=%.2f threshold=%.2f picked=%s latency_ms=%d",+ used.backend,+ used.model,+ candidates,+ answer.choice,+ answer.confidence,+ threshold,+ picked,+ latency_ms,+ )+ return DecideResponse(+ agent=picked,+ model_choice=answer.choice,+ confidence=answer.confidence,+ threshold=threshold,+ reason=answer.reason,+ model=used.model,+ backend=used.backend,+ latency_ms=latency_ms,+ )diff --git a/decision/switch_decision/backends.py b/decision/switch_decision/backends.pynew file mode 100644index 000000000..1b7a0b053--- /dev/null+++ b/decision/switch_decision/backends.py@@ -0,0 +1,459 @@+"""Model backends: turn a /decide request into one model call and read the answer back."""++import asyncio+import hashlib+import json+import math+import os+from dataclasses import dataclass+from typing import Any++import anthropic+import boto3+import httpx+from botocore.config import Config+from botocore.exceptions import BotoCoreError, ClientError++from switch_decision.config import Settings+from switch_decision.models import DecideRequest+from switch_decision.prompt import (+ NONE,+ PICK_TOOL,+ SPEAKER_QUESTION,+ SYSTEM,+ build_messages,+ build_state,+ letter_messages,+ output_schema,+ pick_tool,+ systemone_request,+)+++class ModelServerError(Exception):+ """The model server could not be reached or gave an answer we cannot use.++ `log_text` is what the service logs: the same as the message, minus anything+ the backend sent back (an error body could echo room content)."""++ def __init__(self, message: str, log_text: str | None = None):+ super().__init__(message)+ self.log_text = log_text if log_text is not None else message+++class InvalidChoiceError(ModelServerError):+ """The model answered, but named something that is not one of the options.++ The API turns this into "no agent" rather than a failure: the backend worked,+ its answer just can't be routed."""++ def __init__(self, choice: object, confidence: float = 0.0):+ super().__init__(f"model chose {choice!r}, which is not one of the options")+ self.choice = str(choice)+ self.confidence = confidence+++def _confidence_of(value: object) -> float:+ try:+ c = float(value) # type: ignore[arg-type]+ except (TypeError, ValueError):+ return 0.0+ return c if 0.0 <= c <= 1.0 else 0.0+++@dataclass(frozen=True)+class ModelAnswer:+ choice: str+ confidence: float+ reason: str+++def read_systemone(body: object, options: list[str]) -> ModelAnswer:+ """Map a SystemOne response to a choice and the chosen option's probability."""+ try:+ answer = body["answers"][SPEAKER_QUESTION] # type: ignore[index]+ choice = answer["choice"]+ probabilities = answer.get("probabilities") or {}+ except (KeyError, TypeError) as exc:+ raise ModelServerError(+ f"SystemOne response has no '{SPEAKER_QUESTION}' answer"+ ) from exc+ if choice not in options:+ raise InvalidChoiceError(+ choice, _confidence_of(probabilities.get(choice, answer.get("confidence")))+ )+ confidence = probabilities.get(choice, answer.get("confidence"))+ if not isinstance(confidence, (int, float)):+ raise ModelServerError(f"SystemOne response has no probability for {choice!r}")+ top = sorted(probabilities.items(), key=lambda kv: kv[1], reverse=True)[:3]+ reason = (+ "probabilities: " + ", ".join(f"{k}={v:.2f}" for k, v in top) if top else ""+ )+ return ModelAnswer(choice=choice, confidence=float(confidence), reason=reason)+++def read_ollama(body: object, options: list[str]) -> ModelAnswer:+ try:+ content = body["message"]["content"] # type: ignore[index]+ out = json.loads(content)+ choice, confidence, reason = (+ out["agent"],+ float(out["confidence"]),+ out.get("reason", ""),+ )+ except (KeyError, TypeError, ValueError) as exc:+ raise ModelServerError("Ollama output was not the expected JSON") from exc+ if choice not in options:+ raise InvalidChoiceError(choice, _confidence_of(confidence))+ return ModelAnswer(choice=choice, confidence=confidence, reason=reason)+++def read_bedrock(body: dict, options: list[str]) -> ModelAnswer:+ """Map a Converse response whose message calls the pick tool."""+ try:+ blocks = body["output"]["message"]["content"]+ call = next(+ b["toolUse"]+ for b in blocks+ if "toolUse" in b and b["toolUse"]["name"] == PICK_TOOL+ )+ out = call["input"]+ choice, confidence, reason = (+ out["agent"],+ float(out["confidence"]),+ out.get("reason", ""),+ )+ except (KeyError, TypeError, ValueError, StopIteration) as exc:+ raise ModelServerError(+ "Bedrock response did not call the pick tool with a decision"+ ) from exc+ if choice not in options:+ raise InvalidChoiceError(choice, _confidence_of(confidence))+ if not 0.0 <= confidence <= 1.0:+ raise ModelServerError(f"model gave confidence {confidence}, outside 0 to 1")+ return ModelAnswer(choice=choice, confidence=confidence, reason=reason)+++def _is_claude(model_id: str) -> bool:+ return "anthropic." in model_id or model_id.startswith("claude")+++def bedrock_request(req: DecideRequest, settings: Settings) -> dict:+ names = [a.name for a in req.agents]+ body: dict[str, Any] = {+ "modelId": settings.model,+ "system": [{"text": SYSTEM}],+ "messages": [+ {+ "role": "user",+ "content": [{"text": build_state(req, settings.history_limit)}],+ }+ ],+ "inferenceConfig": {"temperature": 0, "maxTokens": 200},+ "toolConfig": {+ "tools": [pick_tool(names)],+ "toolChoice": {"tool": {"name": PICK_TOOL}},+ },+ }+ if _is_claude(settings.model):+ # Haiku 5.5 refuses a non-default temperature, and thinks by default:+ # turn thinking off so the forced tool call is the whole answer.+ body["inferenceConfig"] = {"maxTokens": 256}+ body["additionalModelRequestFields"] = {"thinking": {"type": "disabled"}}+ return body+++_bedrock_clients: dict[tuple[str, str | None], Any] = {}+++def bedrock_client(settings: Settings) -> Any:+ key = (settings.aws_region, settings.aws_profile)+ if key not in _bedrock_clients:+ session = boto3.Session(+ profile_name=settings.aws_profile, region_name=settings.aws_region+ )+ _bedrock_clients[key] = session.client(+ "bedrock-runtime",+ config=Config(+ read_timeout=settings.timeout_s,+ connect_timeout=5,+ retries={"max_attempts": 2},+ ),+ )+ return _bedrock_clients[key]+++async def ask_bedrock(settings: Settings, req: DecideRequest) -> ModelAnswer:+ options = [a.name for a in req.agents] + [NONE]+ where = f"Bedrock {settings.model} in {settings.aws_region}"+ try:+ body = await asyncio.to_thread(+ bedrock_client(settings).converse, **bedrock_request(req, settings)+ )+ except (BotoCoreError, ClientError) as exc:+ code = (+ exc.response.get("Error", {}).get("Code", "")+ if isinstance(exc, ClientError)+ else ""+ )+ raise ModelServerError(+ f"{where} failed: {type(exc).__name__}: {exc}",+ f"{where} failed: {type(exc).__name__} {code}".rstrip(),+ ) from exc+ return read_bedrock(body, options)+++def read_letter_logprobs(body: dict, options: dict[str, str]) -> ModelAnswer:+ """Probabilities over the option letters from the first token's top logprobs,+ renormalised over the letters that are options."""+ try:+ top = body["choices"][0]["logprobs"]["content"][0]["top_logprobs"]+ except (KeyError, IndexError, TypeError) as exc:+ raise ModelServerError(+ "llama.cpp response has no top logprobs for the first token"+ ) from exc+ mass: dict[str, float] = {}+ for t in top:+ letter = t["token"].strip()+ if letter in options:+ mass[letter] = mass.get(letter, 0.0) + math.exp(t["logprob"])+ total = sum(mass.values())+ if total <= 0:+ raise ModelServerError("the model put no probability on any option letter")+ probs = {options[k]: v / total for k, v in mass.items()}+ choice = max(probs, key=probs.get)+ ranked = sorted(probs.items(), key=lambda kv: kv[1], reverse=True)[:3]+ return ModelAnswer(+ choice=choice,+ confidence=probs[choice],+ reason="probabilities: " + ", ".join(f"{k}={v:.2f}" for k, v in ranked),+ )+++def anthropic_request(req: DecideRequest, settings: Settings) -> dict:+ """One Messages API call whose forced tool call is the decision. Haiku 5.5+ takes no temperature; thinking is off and effort low, for a fast pick."""+ names = [a.name for a in req.agents]+ schema = {**output_schema(names), "additionalProperties": False}+ # Strict tools don't take numeric bounds; the range is stated instead and+ # read_bedrock refuses a value outside it.+ schema["properties"] = {+ **schema["properties"],+ "confidence": {"type": "number", "description": "0 to 1"},+ }+ if not settings.with_reason:+ schema["properties"] = {+ k: v for k, v in schema["properties"].items() if k != "reason"+ }+ schema["required"] = [k for k in schema["required"] if k != "reason"]+ return {+ "model": settings.model,+ "max_tokens": 256,+ "system": SYSTEM,+ "messages": [+ {"role": "user", "content": build_state(req, settings.history_limit)}+ ],+ "tools": [+ {+ "name": PICK_TOOL,+ "description": "Record which agent, if any, should answer the latest message.",+ "input_schema": schema,+ "strict": True,+ }+ ],+ "tool_choice": {"type": "tool", "name": PICK_TOOL},+ "thinking": {"type": "disabled"},+ "output_config": {"effort": "low"},+ }+++def read_anthropic(message: Any, options: list[str]) -> ModelAnswer:+ block = next(+ (b for b in message.content if b.type == "tool_use" and b.name == PICK_TOOL),+ None,+ )+ if block is None:+ raise ModelServerError(+ f"Claude did not call the pick tool (stop_reason={message.stop_reason})"+ )+ return read_bedrock(+ {+ "output": {+ "message": {+ "content": [{"toolUse": {"name": PICK_TOOL, "input": block.input}}]+ }+ }+ },+ options,+ )+++# One client per API key, cached by a hash of the key so the raw key is never+# a dict key that could end up in a log or a traceback.+_anthropic_clients: dict[str, anthropic.AsyncAnthropic] = {}+_SERVICE_KEY = "service"+++def key_fingerprint(api_key: str) -> str:+ return hashlib.sha256(api_key.encode()).hexdigest()+++def anthropic_client(+ settings: Settings, api_key: str | None = None+) -> anthropic.AsyncAnthropic:+ """The client for a per-request key, or the service-wide one (ANTHROPIC_API_KEY)."""+ cache_key = key_fingerprint(api_key) if api_key else _SERVICE_KEY+ client = _anthropic_clients.get(cache_key)+ if client is None:+ kwargs: dict[str, Any] = {"timeout": settings.timeout_s, "max_retries": 1}+ if api_key:+ kwargs["api_key"] = api_key+ client = anthropic.AsyncAnthropic(**kwargs)+ _anthropic_clients[cache_key] = client+ return client+++async def ask_anthropic(+ settings: Settings, req: DecideRequest, api_key: str | None = None+) -> ModelAnswer:+ options = [a.name for a in req.agents] + [NONE]+ try:+ message = await anthropic_client(settings, api_key).messages.create(+ **anthropic_request(req, settings)+ )+ except anthropic.APIConnectionError as exc:+ raise ModelServerError(f"Anthropic API unreachable: {exc}") from exc+ except anthropic.APIStatusError as exc:+ raise ModelServerError(+ f"Anthropic API returned {exc.status_code} for {settings.model}: {exc.message}",+ f"Anthropic API returned {exc.status_code} for {settings.model}",+ ) from exc+ return read_anthropic(message, options)+++def model_server(settings: Settings) -> str:+ if settings.backend == "bedrock":+ return f"bedrock:{settings.aws_region}"+ if settings.backend == "llamacpp":+ return settings.llamacpp_url+ if settings.backend == "anthropic":+ return "api.anthropic.com"+ return (+ settings.systemone_url+ if settings.backend == "systemone"+ else settings.ollama_url+ )+++async def ask(+ client: httpx.AsyncClient,+ settings: Settings,+ req: DecideRequest,+ anthropic_key: str | None = None,+) -> ModelAnswer:+ if settings.backend == "bedrock":+ return await ask_bedrock(settings, req)+ if settings.backend == "anthropic":+ return await ask_anthropic(settings, req, anthropic_key)+ if settings.backend == "llamacpp":+ messages, letters = letter_messages(req, settings.history_limit)+ url = f"{settings.llamacpp_url}/v1/chat/completions"+ payload = {+ "messages": messages,+ "max_tokens": 1,+ "temperature": 0,+ "logprobs": True,+ "top_logprobs": 20,+ "chat_template_kwargs": {"enable_thinking": False},+ }+ try:+ r = await client.post(url, json=payload, timeout=settings.timeout_s)+ except httpx.HTTPError as exc:+ raise ModelServerError(+ f"model server {url} unreachable: {type(exc).__name__}: {exc}"+ ) from exc+ if r.status_code != 200:+ raise ModelServerError(+ f"model server {url} returned {r.status_code}: {r.text[:300]}",+ f"model server {url} returned {r.status_code}",+ )+ return read_letter_logprobs(r.json(), letters)+ options = [a.name for a in req.agents] + [NONE]+ if settings.backend == "systemone":+ url = settings.systemone_url+ payload = systemone_request(req, settings.model, settings.history_limit)+ else:+ url = f"{settings.ollama_url}/api/chat"+ payload = {+ "model": settings.model,+ "messages": build_messages(req, settings.history_limit),+ "format": output_schema([a.name for a in req.agents]),+ "think": False,+ "stream": False,+ "options": {"temperature": 0},+ }+ try:+ r = await client.post(url, json=payload, timeout=settings.timeout_s)+ except httpx.HTTPError as exc:+ raise ModelServerError(+ f"model server {url} unreachable: {type(exc).__name__}: {exc}"+ ) from exc+ if r.status_code != 200:+ raise ModelServerError(+ f"model server {url} returned {r.status_code}: {r.text[:300]}",+ f"model server {url} returned {r.status_code}",+ )+ try:+ body = r.json()+ except ValueError as exc:+ raise ModelServerError(f"model server {url} returned non-JSON") from exc+ return (+ read_systemone(body, options)+ if settings.backend == "systemone"+ else read_ollama(body, options)+ )+++async def check(client: httpx.AsyncClient, settings: Settings) -> dict:+ """Probe the model server; raise ModelServerError when it is down."""+ if settings.backend == "anthropic":+ if not os.environ.get("ANTHROPIC_API_KEY"):+ raise ModelServerError("ANTHROPIC_API_KEY is not set")+ return {"status": "api key set"}+ if settings.backend == "bedrock":+ try:+ creds = await asyncio.to_thread(+ lambda: boto3.Session(+ profile_name=settings.aws_profile+ ).get_credentials()+ )+ except BotoCoreError as exc:+ raise ModelServerError(f"AWS credentials unavailable: {exc}") from exc+ if creds is None:+ raise ModelServerError(+ "AWS credentials unavailable: no profile or environment credentials found"+ )+ return {"status": "credentials found", "region": settings.aws_region}+ if settings.backend == "llamacpp":+ url = f"{settings.llamacpp_url}/health"+ try:+ r = await client.get(url, timeout=5)+ r.raise_for_status()+ return r.json()+ except (httpx.HTTPError, ValueError) as exc:+ raise ModelServerError(+ f"model server {url} unavailable: {type(exc).__name__}: {exc}"+ ) from exc+ if settings.backend == "systemone":+ base = settings.systemone_url.rsplit("/v1/", 1)[0]+ url = f"{base}/health"+ else:+ url = f"{settings.ollama_url}/api/version"+ try:+ r = await client.get(url, timeout=5)+ r.raise_for_status()+ return r.json()+ except (httpx.HTTPError, ValueError) as exc:+ raise ModelServerError(+ f"model server {url} unavailable: {type(exc).__name__}: {exc}"+ ) from excdiff --git a/decision/switch_decision/config.py b/decision/switch_decision/config.pynew file mode 100644index 000000000..2653d3edd--- /dev/null+++ b/decision/switch_decision/config.py@@ -0,0 +1,74 @@+import os+from dataclasses import dataclass+from typing import Literal++Backend = Literal["systemone", "ollama", "bedrock", "llamacpp", "anthropic"]++DEFAULT_BEDROCK_MODEL = "us.anthropic.claude-haiku-5-5-v1:0"+DEFAULT_ANTHROPIC_MODEL = "claude-haiku-5-5"++DEFAULT_MODELS: dict[str, str] = {+ "systemone": "clef-flash",+ "ollama": "qwen3.5:9b",+ "bedrock": DEFAULT_BEDROCK_MODEL,+ "llamacpp": "qwen3.5-4b-q4_k_m",+ "anthropic": DEFAULT_ANTHROPIC_MODEL,+}+++def _flag(name: str) -> bool:+ return os.environ.get(name, "").strip().lower() in ("1", "true", "yes", "on")+++@dataclass(frozen=True)+class Settings:+ backend: Backend+ model: str+ systemone_url: str+ ollama_url: str+ llamacpp_url: str+ aws_region: str+ aws_profile: str | None+ confidence_threshold: float+ timeout_s: float+ history_limit: int+ with_reason: bool = True+ # Bearer token every request but GET /health must carry; None means no auth.+ service_token: str | None = None+ # Whether a request may choose Bedrock with X-Decision-Backend (it spends+ # the service's own AWS credentials).+ bedrock_enabled: bool = False+ bedrock_model: str = DEFAULT_BEDROCK_MODEL+++def load_settings() -> Settings:+ backend = os.environ.get("DECISION_BACKEND", "llamacpp")+ if backend not in DEFAULT_MODELS:+ raise ValueError(+ f"DECISION_BACKEND must be one of {sorted(DEFAULT_MODELS)}, got {backend!r}"+ )+ threshold = float(os.environ.get("DECISION_CONFIDENCE_THRESHOLD", "0.6"))+ if not 0.0 <= threshold <= 1.0:+ raise ValueError(+ f"DECISION_CONFIDENCE_THRESHOLD must be between 0 and 1, got {threshold}"+ )+ bedrock_model = os.environ.get("DECISION_BEDROCK_MODEL") or DEFAULT_BEDROCK_MODEL+ default_model = bedrock_model if backend == "bedrock" else DEFAULT_MODELS[backend]+ return Settings(+ backend=backend, # type: ignore[arg-type]+ model=os.environ.get("DECISION_MODEL") or default_model,+ systemone_url=os.environ.get(+ "SYSTEMONE_URL", "http://127.0.0.1:8100/v1/systemone"+ ),+ ollama_url=os.environ.get("OLLAMA_URL", "http://localhost:11434"),+ llamacpp_url=os.environ.get("LLAMACPP_URL", "http://127.0.0.1:8300"),+ aws_region=os.environ.get("AWS_REGION", "us-east-1"),+ aws_profile=os.environ.get("AWS_PROFILE") or None,+ confidence_threshold=threshold,+ timeout_s=float(os.environ.get("DECISION_TIMEOUT_S", "30")),+ history_limit=int(os.environ.get("DECISION_HISTORY_LIMIT", "30")),+ with_reason=os.environ.get("DECISION_WITH_REASON", "1") != "0",+ service_token=os.environ.get("DECISION_SERVICE_TOKEN") or None,+ bedrock_enabled=_flag("DECISION_BEDROCK_ENABLED"),+ bedrock_model=bedrock_model,+ )diff --git a/decision/switch_decision/models.py b/decision/switch_decision/models.pynew file mode 100644index 000000000..f07f1e4c0--- /dev/null+++ b/decision/switch_decision/models.py@@ -0,0 +1,52 @@+from typing import Literal++from pydantic import BaseModel, Field+++class Agent(BaseModel):+ name: str+ description: str+ role: str | None = None+++class Message(BaseModel):+ sender: str+ sender_kind: Literal["person", "agent"] = "person"+ text: str+ # Who this message addressed by name (@mentions or targeted messages).+ addressed: list[str] = Field(default_factory=list)+++class Room(BaseModel):+ name: str+ instructions: str | None = None+++class Incoming(BaseModel):+ sender: str+ text: str+ thread_id: str | None = None+++class DecideRequest(BaseModel):+ room: Room+ message: Incoming+ agents: list[Agent]+ # The thread the message is in (oldest first), empty for a top-level message.+ thread: list[Message] = Field(default_factory=list)+ # Recent top-level messages in the room (oldest first).+ recent: list[Message] = Field(default_factory=list)+ # Per-request override of the configured threshold.+ confidence_threshold: float | None = Field(default=None, ge=0.0, le=1.0)+++class DecideResponse(BaseModel):+ agent: str | None+ model_choice: str+ confidence: float+ threshold: float+ reason: str+ model: str+ # The backend that answered: the configured one, or the per-request override.+ backend: str+ latency_ms: intdiff --git a/decision/switch_decision/prompt.py b/decision/switch_decision/prompt.pynew file mode 100644index 000000000..5f4e8a880--- /dev/null+++ b/decision/switch_decision/prompt.py@@ -0,0 +1,187 @@+from collections import Counter++from switch_decision.models import DecideRequest, Message++NONE = "none"++SYSTEM = """You decide which single agent in a team chat room, if any, should answer the latest message.++People and AI agents share the room. Nobody tagged an agent in the latest message, so you decide.++Choose exactly one agent whose job clearly covers the message, or "none".+Choose "none" when:+- people are talking to each other, or the message is meant for a named person+- it is small talk, thanks, an acknowledgement or social chatter+- no agent's description covers it+Prefer an agent already helping in this conversation when the message continues that topic.++Give a short reason first, then your choice, then your confidence from 0 to 1 that the+choice is right (for "none", your confidence that no agent should answer)."""+++def _line(m: Message) -> str:+ kind = "agent" if m.sender_kind == "agent" else "person"+ to = f" (to {', '.join(m.addressed)})" if m.addressed else ""+ return f"- {m.sender} [{kind}]{to}: {m.text}"+++def _interactions(messages: list[Message]) -> list[str]:+ pairs: Counter[tuple[str, str]] = Counter()+ for m in messages:+ for target in m.addressed:+ pairs[(m.sender, target)] += 1+ # A reply right after someone spoke is also an interaction.+ for prev, cur in zip(messages, messages[1:]):+ if prev.sender != cur.sender and not cur.addressed:+ pairs[(cur.sender, prev.sender)] += 1+ return [f"- {a} -> {b}: {n}" for (a, b), n in pairs.most_common(10)]+++def build_state(req: DecideRequest, history_limit: int) -> str:+ """The room's context as one text block: what a decision model reads."""+ agents = "\n".join(+ f"- {a.name}: {a.description}" + (f" (role: {a.role})" if a.role else "")+ for a in req.agents+ )+ recent = req.recent[-history_limit:]+ thread = req.thread[-history_limit:]+ parts = [f"Room: {req.room.name}"]+ if req.room.instructions:+ parts.append(f"Room instructions:\n{req.room.instructions}")+ parts.append(f"Agents in the room:\n{agents}")+ if recent:+ parts.append(+ "Recent messages in the room (oldest first):\n"+ + "\n".join(map(_line, recent))+ )+ if thread:+ parts.append(+ "The thread this message is in (oldest first):\n"+ + "\n".join(map(_line, thread))+ )+ talked = _interactions(recent + thread)+ if talked:+ parts.append("Who talked to whom recently:\n" + "\n".join(talked))+ where = (+ "in the thread above"+ if req.message.thread_id+ else "at the top level of the room"+ )+ parts.append(+ f"Latest message, {where}:\n- {req.message.sender} [person]: {req.message.text}"+ )+ return "\n\n".join(parts)+++def build_messages(req: DecideRequest, history_limit: int) -> list[dict[str, str]]:+ return [+ {"role": "system", "content": SYSTEM},+ {"role": "user", "content": build_state(req, history_limit)},+ ]+++SPEAKER_QUESTION = "speaker"++SPEAKER_INSTRUCTIONS = (+ "Which single agent in this room should answer the latest message? Nobody tagged "+ "an agent. Pick the agent whose job clearly covers the message; prefer an agent "+ "already helping in this conversation when the message continues that topic. "+ "Pick none when people are talking to each other, the message is for a named "+ "person, it is small talk or thanks, or no agent's job covers it."+)++NONE_CRITERION = (+ "No agent should answer: people talking to each other, a message meant for a "+ "named person, small talk, thanks or acknowledgement, or nothing any agent covers."+)+++def systemone_request(req: DecideRequest, model: str, history_limit: int) -> dict:+ criteria = {+ a.name: f"{a.name}: {a.description}" + (f" (role: {a.role})" if a.role else "")+ for a in req.agents+ }+ criteria[NONE] = NONE_CRITERION+ return {+ "model": model,+ "state": build_state(req, history_limit),+ "questions": {+ SPEAKER_QUESTION: {+ "type": "choice",+ "instructions": SPEAKER_INSTRUCTIONS,+ "criteria": criteria,+ }+ },+ }+++def output_schema(agent_names: list[str]) -> dict:+ return {+ "type": "object",+ "properties": {+ "reason": {"type": "string"},+ "agent": {"type": "string", "enum": [*agent_names, NONE]},+ "confidence": {"type": "number", "minimum": 0, "maximum": 1},+ },+ "required": ["reason", "agent", "confidence"],+ }+++PICK_TOOL = "pick_speaker"+++def pick_tool(agent_names: list[str]) -> dict:+ """A Bedrock Converse tool the model is forced to call: its input is the decision."""+ return {+ "toolSpec": {+ "name": PICK_TOOL,+ "description": "Record which agent, if any, should answer the latest message.",+ "inputSchema": {"json": output_schema(agent_names)},+ }+ }+++NONE_LETTER = "N"+AGENT_LETTERS = "ABCDEFGHIJKLM" # N is none+++def lettered_options(agent_names: list[str]) -> dict[str, str]:+ """Letter -> option name: one single-token letter per agent, and N for none."""+ if len(agent_names) > len(AGENT_LETTERS):+ raise ValueError(+ f"at most {len(AGENT_LETTERS)} agents can be lettered, got {len(agent_names)}"+ )+ return {**dict(zip(AGENT_LETTERS, agent_names)), NONE_LETTER: NONE}+++LETTER_SYSTEM = (+ SYSTEM.split("Give a short reason first")[0].rstrip()+ + "\n\nAnswer with the letter of your choice only."+)+++def letter_messages(+ req: DecideRequest, history_limit: int+) -> tuple[list[dict[str, str]], dict[str, str]]:+ options = lettered_options([a.name for a in req.agents])+ by_name = {a.name: a for a in req.agents}+ lines = []+ for letter, name in options.items():+ if name == NONE:+ lines.append(f"{letter}) none: {NONE_CRITERION}")+ else:+ a = by_name[name]+ lines.append(+ f"{letter}) {a.name}: {a.description}"+ + (f" (role: {a.role})" if a.role else "")+ )+ user = (+ build_state(req, history_limit)+ + "\n\nWho should answer the latest message?\n"+ + "\n".join(lines)+ + "\n\nAnswer:"+ )+ return [+ {"role": "system", "content": LETTER_SYSTEM},+ {"role": "user", "content": user},+ ], optionsdiff --git a/decision/tests/__init__.py b/decision/tests/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/decision/tests/test_api.py b/decision/tests/test_api.pynew file mode 100644index 000000000..f200d7c57--- /dev/null+++ b/decision/tests/test_api.py@@ -0,0 +1,401 @@+"""The HTTP surface: per-request backend override, service token, and what the logs keep."""++import logging+from dataclasses import replace+from types import SimpleNamespace++import httpx+import pytest+from fastapi.testclient import TestClient++from switch_decision import app as app_module+from switch_decision import backends+from switch_decision.config import Settings+from switch_decision.prompt import NONE++SECRET_TEXT = "zebra-quartz-7731 rollback the purple cluster"+ROOM_RULES = "never-log-these-room-rules-4412"+ANTHROPIC_KEY = "fake-key-0001"++BODY = {+ "room": {"name": "eng-secret-room", "instructions": ROOM_RULES},+ "message": {"sender": "sara", "text": SECRET_TEXT},+ "agents": [+ {"name": "deploy-bot", "description": "CI and deploys"},+ {"name": "billing-bot", "description": "invoices"},+ ],+ "recent": [{"sender": "tom", "text": f"earlier: {SECRET_TEXT}"}],+}+++def _settings(**kw) -> Settings:+ base = dict(+ backend="llamacpp",+ model="qwen3.5-4b-q4_k_m",+ systemone_url="http://s",+ ollama_url="http://o",+ llamacpp_url="http://llama.test",+ aws_region="us-east-1",+ aws_profile=None,+ confidence_threshold=0.6,+ timeout_s=5,+ history_limit=30,+ )+ base.update(kw)+ return Settings(**base)+++def _logprobs(letter: str):+ top = [{"token": letter, "logprob": -0.05}, {"token": "N", "logprob": -3.0}]+ return {"choices": [{"logprobs": {"content": [{"top_logprobs": top}]}}]}+++class FakeAnthropic:+ """Stands in for anthropic.AsyncAnthropic: records each call, answers with a pick."""++ def __init__(self, agent: str, confidence: float = 0.9):+ self.agent, self.confidence = agent, confidence+ self.calls: list[dict] = []+ self.messages = self++ async def create(self, **kw):+ self.calls.append(kw)+ block = SimpleNamespace(+ type="tool_use",+ name="pick_speaker",+ input={"reason": "r", "agent": self.agent, "confidence": self.confidence},+ )+ return SimpleNamespace(stop_reason="tool_use", content=[block])+++def make_client(monkeypatch):+ def make(settings: Settings | None = None, handler=None) -> TestClient:+ monkeypatch.setattr(app_module, "settings", settings or _settings())+ tc = TestClient(app_module.app)+ tc.__enter__()+ transport = httpx.MockTransport(+ handler or (lambda r: httpx.Response(200, json=_logprobs("A")))+ )+ monkeypatch.setattr(+ app_module, "client", httpx.AsyncClient(transport=transport)+ )+ return tc++ return make+++def fake_anthropic(monkeypatch):+ holder: dict = {}++ def install(agent: str, confidence: float = 0.9) -> FakeAnthropic:+ fake = FakeAnthropic(agent, confidence)++ def factory(settings, api_key=None):+ holder.setdefault("keys", []).append(api_key)+ return fake++ monkeypatch.setattr(backends, "anthropic_client", factory)+ holder["fake"] = fake+ return fake++ install.holder = holder # type: ignore[attr-defined]+ return install+++# ── default backend ─────────────────────────────────────────────────────────+++def test_default_backend_answers_and_names_itself(make_client):+ r = make_client().post("/decide", json=BODY)+ assert r.status_code == 200+ body = r.json()+ assert (+ body["agent"] == "deploy-bot"+ and body["backend"] == "llamacpp"+ and body["model"] == "qwen3.5-4b-q4_k_m"+ )+++def test_explicit_default_header_uses_configured_backend(make_client):+ r = make_client().post(+ "/decide",+ json=BODY,+ headers={"X-Decision-Backend": "default", "X-Decision-Model": "x"},+ )+ assert (+ r.status_code == 200+ and r.json()["backend"] == "llamacpp"+ and r.json()["model"] == "qwen3.5-4b-q4_k_m"+ )+++# ── per-request override ────────────────────────────────────────────────────+++def test_override_to_anthropic_uses_the_request_key(make_client, fake_anthropic):+ fake = fake_anthropic("billing-bot", 0.8)+ tc = make_client(+ handler=lambda r: pytest.fail("the default backend must not be called")+ )+ r = tc.post(+ "/decide",+ json=BODY,+ headers={+ "X-Decision-Backend": "anthropic",+ "X-Decision-Anthropic-Key": ANTHROPIC_KEY,+ },+ )+ assert r.status_code == 200+ body = r.json()+ assert (+ body["agent"] == "billing-bot"+ and body["backend"] == "anthropic"+ and body["model"] == "claude-haiku-5-5"+ )+ assert fake_anthropic.holder["keys"] == [ANTHROPIC_KEY]+ assert fake.calls[0]["model"] == "claude-haiku-5-5"+++def test_override_model_header(make_client, fake_anthropic):+ fake = fake_anthropic("deploy-bot")+ r = make_client().post(+ "/decide",+ json=BODY,+ headers={+ "X-Decision-Backend": "anthropic",+ "X-Decision-Anthropic-Key": ANTHROPIC_KEY,+ "X-Decision-Model": "claude-sonnet-5-5",+ },+ )+ assert r.status_code == 200 and r.json()["model"] == "claude-sonnet-5-5"+ assert fake.calls[0]["model"] == "claude-sonnet-5-5"+++def test_anthropic_without_key_is_backend_unavailable(make_client, fake_anthropic):+ fake = fake_anthropic("deploy-bot")+ r = make_client().post(+ "/decide", json=BODY, headers={"X-Decision-Backend": "anthropic"}+ )+ assert r.status_code == 400+ assert (+ r.json()["code"] == "backend_unavailable"+ and "X-Decision-Anthropic-Key" in r.json()["detail"]+ )+ assert fake.calls == []+++def test_bedrock_disabled_is_backend_unavailable(make_client, monkeypatch):+ monkeypatch.setattr(+ backends, "bedrock_client", lambda s: pytest.fail("bedrock must not be called")+ )+ r = make_client().post(+ "/decide", json=BODY, headers={"X-Decision-Backend": "bedrock"}+ )+ assert r.status_code == 400 and r.json()["code"] == "backend_unavailable"+++def test_bedrock_enabled_override_uses_bedrock_model(make_client, monkeypatch):+ calls = []++ class FakeBedrock:+ def converse(self, **kw):+ calls.append(kw)+ return {+ "output": {+ "message": {+ "content": [+ {+ "toolUse": {+ "name": "pick_speaker",+ "input": {+ "reason": "r",+ "agent": "deploy-bot",+ "confidence": 0.9,+ },+ }+ }+ ]+ }+ }+ }++ monkeypatch.setattr(backends, "bedrock_client", lambda s: FakeBedrock())+ tc = make_client(_settings(bedrock_enabled=True))+ r = tc.post("/decide", json=BODY, headers={"X-Decision-Backend": "bedrock"})+ assert r.status_code == 200+ assert (+ r.json()["backend"] == "bedrock"+ and r.json()["model"] == "us.anthropic.claude-haiku-5-5-v1:0"+ )+ assert calls[0]["modelId"] == "us.anthropic.claude-haiku-5-5-v1:0"+ assert "temperature" not in calls[0]["inferenceConfig"]+ assert make_client(_settings(bedrock_enabled=True)).get("/health").json()[+ "backends_available"+ ] == ["default", "anthropic", "bedrock"]+++def test_unknown_backend_is_backend_unavailable(make_client):+ r = make_client().post(+ "/decide", json=BODY, headers={"X-Decision-Backend": "vertex"}+ )+ assert r.status_code == 400 and r.json()["code"] == "backend_unavailable"+++def test_haiku_naming_a_non_candidate_is_no_agent(make_client, fake_anthropic, caplog):+ fake_anthropic("ghost-bot", 0.95)+ with caplog.at_level(logging.INFO, logger="switch_decision"):+ r = make_client().post(+ "/decide",+ json=BODY,+ headers={+ "X-Decision-Backend": "anthropic",+ "X-Decision-Anthropic-Key": ANTHROPIC_KEY,+ },+ )+ assert r.status_code == 200+ body = r.json()+ assert (+ body["agent"] is None+ and body["model_choice"] == "ghost-bot"+ and body["backend"] == "anthropic"+ )+ errors = [rec for rec in caplog.records if rec.levelno == logging.ERROR]+ assert errors and "invalid_choice" in errors[0].getMessage()+++def test_anthropic_api_failure_is_502(make_client, monkeypatch):+ class Failing:+ def __init__(self):+ self.messages = self++ async def create(self, **kw):+ raise backends.anthropic.APIConnectionError(+ request=httpx.Request("POST", "https://api.anthropic.test")+ )++ monkeypatch.setattr(backends, "anthropic_client", lambda s, k=None: Failing())+ r = make_client().post(+ "/decide",+ json=BODY,+ headers={+ "X-Decision-Backend": "anthropic",+ "X-Decision-Anthropic-Key": ANTHROPIC_KEY,+ },+ )+ assert r.status_code == 502 and "unreachable" in r.json()["detail"]+++def test_anthropic_clients_are_cached_by_key_hash(monkeypatch):+ monkeypatch.setattr(backends, "_anthropic_clients", {})+ s = replace(_settings(), backend="anthropic", model="claude-haiku-5-5")+ a = backends.anthropic_client(s, ANTHROPIC_KEY)+ assert backends.anthropic_client(s, ANTHROPIC_KEY) is a+ assert backends.anthropic_client(s, "fake-key-0002") is not a+ assert ANTHROPIC_KEY not in backends._anthropic_clients+ assert backends.key_fingerprint(ANTHROPIC_KEY) in backends._anthropic_clients+++# ── service token ───────────────────────────────────────────────────────────+++def test_token_required_when_configured(make_client):+ tc = make_client(_settings(service_token="placeholder-service-token"))+ assert tc.post("/decide", json=BODY).status_code == 401+ assert (+ tc.post(+ "/decide", json=BODY, headers={"Authorization": "Bearer wrong"}+ ).status_code+ == 401+ )+ assert (+ tc.post(+ "/decide",+ json=BODY,+ headers={"Authorization": "Basic placeholder-service-token"},+ ).status_code+ == 401+ )+ ok = tc.post(+ "/decide",+ json=BODY,+ headers={"Authorization": "Bearer placeholder-service-token"},+ )+ assert ok.status_code == 200 and ok.json()["agent"] == "deploy-bot"+++def test_health_needs_no_token(make_client):+ tc = make_client(+ _settings(service_token="placeholder-service-token"),+ handler=lambda r: httpx.Response(200, json={"status": "ok"}),+ )+ r = tc.get("/health")+ assert r.status_code == 200 and r.json()["ok"] is True+++def test_no_token_configured_means_no_auth(make_client):+ assert make_client().post("/decide", json=BODY).status_code == 200+++# ── logs ────────────────────────────────────────────────────────────────────+++def _assert_clean(caplog):+ text = "\n".join(rec.getMessage() for rec in caplog.records)+ for secret in (+ SECRET_TEXT,+ "zebra-quartz",+ ROOM_RULES,+ ANTHROPIC_KEY,+ "eng-secret-room",+ ):+ assert secret not in text, f"{secret!r} leaked into the logs"+ return text+++def test_logs_keep_no_message_text_room_rules_or_key(+ make_client, fake_anthropic, caplog+):+ fake_anthropic("deploy-bot")+ tc = make_client()+ with caplog.at_level(logging.DEBUG):+ assert tc.post("/decide", json=BODY).status_code == 200+ assert (+ tc.post(+ "/decide",+ json=BODY,+ headers={+ "X-Decision-Backend": "anthropic",+ "X-Decision-Anthropic-Key": ANTHROPIC_KEY,+ },+ ).status_code+ == 200+ )+ text = _assert_clean(caplog)+ assert "backend=llamacpp" in text and "backend=anthropic" in text+ assert (+ "candidates=2" in text and "choice=deploy-bot" in text and "latency_ms=" in text+ )+++def test_failure_logs_keep_no_backend_error_body(make_client, caplog):+ tc = make_client(+ handler=lambda r: httpx.Response(500, text=f"context too long: {SECRET_TEXT}")+ )+ with caplog.at_level(logging.DEBUG):+ r = tc.post("/decide", json=BODY)+ assert r.status_code == 502+ text = _assert_clean(caplog)+ assert "decide failed" in text and "returned 500" in text+++def test_none_answer_is_nobody(make_client):+ r = make_client(handler=lambda r: httpx.Response(200, json=_logprobs("N"))).post(+ "/decide", json=BODY+ )+ assert (+ r.status_code == 200+ and r.json()["agent"] is None+ and r.json()["model_choice"] == NONE+ )diff --git a/decision/tests/test_backends.py b/decision/tests/test_backends.pynew file mode 100644index 000000000..739ef22ff--- /dev/null+++ b/decision/tests/test_backends.py@@ -0,0 +1,456 @@+import json+import math+from types import SimpleNamespace++import httpx+import pytest+from botocore.exceptions import ClientError+from fastapi.testclient import TestClient++from switch_decision import app as app_module+from switch_decision import backends+from switch_decision.backends import (+ InvalidChoiceError,+ ModelServerError,+ anthropic_request,+ bedrock_request,+ read_anthropic,+ read_bedrock,+ read_letter_logprobs,+ read_systemone,+)+from switch_decision.config import Settings+from switch_decision.models import Agent, DecideRequest, Incoming, Message, Room+from switch_decision.prompt import (+ NONE,+ SPEAKER_QUESTION,+ letter_messages,+ lettered_options,+ systemone_request,+)++AGENTS = [+ Agent(name="deploy-bot", description="CI and deploys"),+ Agent(name="billing-bot", description="invoices", role="finance"),+]+OPTIONS = ["deploy-bot", "billing-bot", NONE]+++def _req(**kw) -> DecideRequest:+ base = dict(+ room=Room(name="eng", instructions="be brief"),+ message=Incoming(+ sender="sara", text="why did the deploy fail?", thread_id="t1"+ ),+ agents=AGENTS,+ thread=[+ Message(+ sender="deploy-bot",+ sender_kind="agent",+ text="deploy started",+ addressed=[],+ )+ ],+ recent=[+ Message(+ sender="sara", sender_kind="person", text="morning", addressed=["bob"]+ )+ ],+ )+ base.update(kw)+ return DecideRequest(**base)+++def _answer(choice, probs):+ return {+ "answers": {+ SPEAKER_QUESTION: {+ "type": "choice",+ "choice": choice,+ "confidence": probs.get(choice),+ "probabilities": probs,+ }+ }+ }+++def test_request_builder_has_one_choice_question_with_none():+ body = systemone_request(_req(), "clef-flash", 30)+ assert body["model"] == "clef-flash"+ q = body["questions"][SPEAKER_QUESTION]+ assert q["type"] == "choice"+ assert list(q["criteria"]) == ["deploy-bot", "billing-bot", NONE]+ assert q["criteria"]["billing-bot"] == "billing-bot: invoices (role: finance)"+ state = body["state"]+ for part in (+ "Room: eng",+ "be brief",+ "deploy started",+ "sara [person] (to bob)",+ "in the thread above",+ "Who talked to whom",+ ):+ assert part in state+++def test_history_limit_caps_rows():+ recent = [+ Message(sender="p", sender_kind="person", text=f"msg{i}", addressed=[])+ for i in range(10)+ ]+ state = systemone_request(_req(recent=recent), "m", 3)["state"]+ assert "msg9" in state and "msg7" in state and "msg6" not in state+++def test_read_systemone_choice_uses_probability():+ a = read_systemone(+ _answer("deploy-bot", {"deploy-bot": 0.9, "billing-bot": 0.05, NONE: 0.05}),+ OPTIONS,+ )+ assert (a.choice, a.confidence) == ("deploy-bot", 0.9)+ assert a.reason.startswith("probabilities: deploy-bot=0.90")+++def test_read_systemone_none():+ a = read_systemone(+ _answer(NONE, {"deploy-bot": 0.1, "billing-bot": 0.1, NONE: 0.8}), OPTIONS+ )+ assert a.choice == NONE+++def test_read_systemone_refuses_unknown_name():+ with pytest.raises(InvalidChoiceError, match="not one of the options") as exc:+ read_systemone(_answer("ghost-bot", {"ghost-bot": 0.99}), OPTIONS)+ assert (exc.value.choice, exc.value.confidence) == ("ghost-bot", 0.99)+++def test_read_systemone_refuses_malformed():+ with pytest.raises(ModelServerError):+ read_systemone({"answers": {}}, OPTIONS)+++def _settings(url="http://model.test/v1/systemone", threshold=0.6):+ return Settings(+ backend="systemone",+ model="clef-flash",+ systemone_url=url,+ ollama_url="http://o",+ llamacpp_url="http://l",+ aws_region="us-east-1",+ aws_profile=None,+ confidence_threshold=threshold,+ timeout_s=5,+ history_limit=30,+ )+++def _client(monkeypatch, handler, **kw):+ monkeypatch.setattr(app_module, "settings", _settings(**kw))+ transport = httpx.MockTransport(handler)++ def fake_client():+ return httpx.AsyncClient(transport=transport)++ tc = TestClient(app_module.app)+ tc.__enter__()+ monkeypatch.setattr(app_module, "client", fake_client())+ return tc+++def _payload(**kw):+ return json.loads(_req(**kw).model_dump_json())+++def test_decide_picks_agent(monkeypatch):+ tc = _client(+ monkeypatch,+ lambda r: httpx.Response(+ 200,+ json=_answer(+ "deploy-bot", {"deploy-bot": 0.9, "billing-bot": 0.05, NONE: 0.05}+ ),+ ),+ )+ r = tc.post("/decide", json=_payload())+ assert r.status_code == 200+ assert r.json()["agent"] == "deploy-bot" and r.json()["confidence"] == 0.9+ assert r.json()["backend"] == "systemone"+++def test_decide_below_threshold_is_nobody(monkeypatch):+ tc = _client(+ monkeypatch,+ lambda r: httpx.Response(+ 200,+ json=_answer(+ "deploy-bot", {"deploy-bot": 0.5, "billing-bot": 0.3, NONE: 0.2}+ ),+ ),+ )+ body = tc.post("/decide", json=_payload()).json()+ assert body["agent"] is None and body["model_choice"] == "deploy-bot"+++def test_decide_request_threshold_overrides(monkeypatch):+ tc = _client(+ monkeypatch,+ lambda r: httpx.Response(+ 200,+ json=_answer(+ "deploy-bot", {"deploy-bot": 0.5, "billing-bot": 0.3, NONE: 0.2}+ ),+ ),+ )+ body = tc.post("/decide", json=_payload(confidence_threshold=0.4)).json()+ assert body["agent"] == "deploy-bot" and body["threshold"] == 0.4+++def test_decide_none_is_nobody(monkeypatch):+ tc = _client(+ monkeypatch,+ lambda r: httpx.Response(+ 200, json=_answer(NONE, {"deploy-bot": 0.1, "billing-bot": 0.1, NONE: 0.8})+ ),+ )+ assert tc.post("/decide", json=_payload()).json()["agent"] is None+++def test_decide_unknown_name_is_nobody(monkeypatch):+ tc = _client(+ monkeypatch,+ lambda r: httpx.Response(200, json=_answer("ghost-bot", {"ghost-bot": 1.0})),+ )+ r = tc.post("/decide", json=_payload())+ assert r.status_code == 200+ assert r.json()["agent"] is None and r.json()["model_choice"] == "ghost-bot"+++def test_decide_model_server_error_status_is_502(monkeypatch):+ tc = _client(monkeypatch, lambda r: httpx.Response(500, text="boom"))+ r = tc.post("/decide", json=_payload())+ assert r.status_code == 502 and "returned 500" in r.json()["detail"]+++def test_decide_unreachable_model_server_is_502_naming_it(monkeypatch):+ def boom(request):+ raise httpx.ConnectError("refused", request=request)++ tc = _client(monkeypatch, boom)+ r = tc.post("/decide", json=_payload())+ assert r.status_code == 502+ assert "http://model.test/v1/systemone" in r.json()["detail"]+++def test_health_reports_backend_model_threshold(monkeypatch):+ tc = _client(+ monkeypatch,+ lambda r: httpx.Response(200, json={"status": "ok", "model": "clef-flash"}),+ )+ body = tc.get("/health").json()+ assert (+ body["backend"] == "systemone"+ and body["model"] == "clef-flash"+ and body["confidence_threshold"] == 0.6+ )+ assert body["backends_available"] == ["default", "anthropic"]+++def test_health_fails_when_model_server_down(monkeypatch):+ def boom(request):+ raise httpx.ConnectError("refused", request=request)++ tc = _client(monkeypatch, boom)+ r = tc.get("/health")+ assert r.status_code == 503 and "http://model.test/health" in r.json()["detail"]+++# ── Bedrock backend ─────────────────────────────────────────────────────────+++def _bedrock_settings(**kw):+ base = dict(+ backend="bedrock",+ model="us.amazon.nova-micro-v1:0",+ systemone_url="",+ ollama_url="",+ llamacpp_url="",+ aws_region="us-east-1",+ aws_profile=None,+ confidence_threshold=0.6,+ timeout_s=5,+ history_limit=30,+ )+ base.update(kw)+ return Settings(**base)+++def _converse(agent, confidence, reason="r"):+ return {+ "output": {+ "message": {+ "role": "assistant",+ "content": [+ {+ "toolUse": {+ "toolUseId": "t",+ "name": "pick_speaker",+ "input": {+ "reason": reason,+ "agent": agent,+ "confidence": confidence,+ },+ }+ }+ ],+ }+ },+ "usage": {"inputTokens": 900, "outputTokens": 20},+ "metrics": {"latencyMs": 400},+ }+++def test_bedrock_request_forces_the_pick_tool_with_the_options():+ body = bedrock_request(_req(), _bedrock_settings())+ assert body["modelId"] == "us.amazon.nova-micro-v1:0"+ assert body["toolConfig"]["toolChoice"] == {"tool": {"name": "pick_speaker"}}+ schema = body["toolConfig"]["tools"][0]["toolSpec"]["inputSchema"]["json"]+ assert schema["properties"]["agent"]["enum"] == ["deploy-bot", "billing-bot", NONE]+ assert "why did the deploy fail?" in body["messages"][0]["content"][0]["text"]+ assert body["inferenceConfig"]["temperature"] == 0+++def test_read_bedrock_choice_and_refusals():+ a = read_bedrock(_converse("deploy-bot", 0.9), OPTIONS)+ assert (a.choice, a.confidence) == ("deploy-bot", 0.9)+ with pytest.raises(InvalidChoiceError, match="not one of the options"):+ read_bedrock(_converse("ghost-bot", 0.9), OPTIONS)+ with pytest.raises(ModelServerError, match="pick tool"):+ read_bedrock(+ {"output": {"message": {"content": [{"text": "deploy-bot"}]}}}, OPTIONS+ )+++class _FakeBedrock:+ def __init__(self, response=None, error=None):+ self.response, self.error, self.calls = response, error, []++ def converse(self, **kw):+ self.calls.append(kw)+ if self.error:+ raise self.error+ return self.response+++def test_decide_via_bedrock(monkeypatch):+ fake = _FakeBedrock(_converse("billing-bot", 0.8))+ monkeypatch.setattr(backends, "bedrock_client", lambda s: fake)+ monkeypatch.setattr(app_module, "settings", _bedrock_settings())+ with TestClient(app_module.app) as tc:+ body = tc.post("/decide", json=_payload()).json()+ assert (+ body["agent"] == "billing-bot" and body["model"] == "us.amazon.nova-micro-v1:0"+ )+ assert body["backend"] == "bedrock"+ assert len(fake.calls) == 1+++def test_bedrock_error_is_502_naming_model(monkeypatch):+ err = ClientError(+ {"Error": {"Code": "AccessDeniedException", "Message": "no access"}}, "Converse"+ )+ monkeypatch.setattr(backends, "bedrock_client", lambda s: _FakeBedrock(error=err))+ monkeypatch.setattr(app_module, "settings", _bedrock_settings())+ with TestClient(app_module.app) as tc:+ r = tc.post("/decide", json=_payload())+ assert r.status_code == 502+ assert (+ "us.amazon.nova-micro-v1:0" in r.json()["detail"]+ and "AccessDenied" in r.json()["detail"]+ )+++# ── llama.cpp letter readout ────────────────────────────────────────────────+++def _top(pairs):+ return {+ "choices": [+ {+ "logprobs": {+ "content": [+ {+ "top_logprobs": [+ {"token": t, "logprob": lp} for t, lp in pairs+ ]+ }+ ]+ }+ }+ ]+ }+++def test_letter_messages_list_agents_and_none():+ messages, options = letter_messages(_req(), 30)+ assert options == {"A": "deploy-bot", "B": "billing-bot", "N": NONE}+ user = messages[1]["content"]+ assert (+ "A) deploy-bot: CI and deploys" in user+ and "B) billing-bot: invoices (role: finance)" in user+ and "N) none:" in user+ )+++def test_letter_readout_renormalises_over_options():+ a = read_letter_logprobs(+ _top(+ [+ ("A", math.log(0.6)),+ ("N", math.log(0.2)),+ ("<think>", math.log(0.1)),+ ("B", math.log(0.1)),+ ]+ ),+ lettered_options(["deploy-bot", "billing-bot"]),+ )+ assert a.choice == "deploy-bot" and abs(a.confidence - 0.6 / 0.9) < 1e-9+++def test_letter_readout_with_no_option_letter_fails():+ with pytest.raises(ModelServerError, match="no probability"):+ read_letter_logprobs(_top([("hello", -0.1)]), lettered_options(["deploy-bot"]))+++# ── Anthropic API backend ───────────────────────────────────────────────────+++def test_anthropic_request_forces_the_pick_tool_without_sampling_params():+ s = _bedrock_settings(backend="anthropic", model="claude-haiku-5-5")+ body = anthropic_request(_req(), s)+ assert body["model"] == "claude-haiku-5-5"+ assert body["tool_choice"] == {"type": "tool", "name": "pick_speaker"}+ assert body["tools"][0]["strict"] is True+ assert body["tools"][0]["input_schema"]["additionalProperties"] is False+ assert body["tools"][0]["input_schema"]["properties"]["agent"]["enum"] == [+ "deploy-bot",+ "billing-bot",+ NONE,+ ]+ assert "temperature" not in body and body["thinking"] == {"type": "disabled"}+++def test_read_anthropic_tool_call():+ msg = SimpleNamespace(+ stop_reason="tool_use",+ content=[+ SimpleNamespace(+ type="tool_use",+ name="pick_speaker",+ input={"reason": "r", "agent": "deploy-bot", "confidence": 0.8},+ )+ ],+ )+ a = read_anthropic(msg, OPTIONS)+ assert (a.choice, a.confidence) == ("deploy-bot", 0.8)+ with pytest.raises(ModelServerError, match="did not call"):+ read_anthropic(SimpleNamespace(stop_reason="refusal", content=[]), OPTIONS)diff --git a/decision/tests/test_config.py b/decision/tests/test_config.pynew file mode 100644index 000000000..9207902f5--- /dev/null+++ b/decision/tests/test_config.py@@ -0,0 +1,69 @@+import pytest++from switch_decision.config import load_settings+++def test_defaults(monkeypatch):+ for k in (+ "DECISION_BACKEND",+ "DECISION_MODEL",+ "DECISION_CONFIDENCE_THRESHOLD",+ "LLAMACPP_URL",+ "DECISION_SERVICE_TOKEN",+ "DECISION_BEDROCK_ENABLED",+ ):+ monkeypatch.delenv(k, raising=False)+ s = load_settings()+ assert (s.backend, s.model, s.confidence_threshold) == (+ "llamacpp",+ "qwen3.5-4b-q4_k_m",+ 0.6,+ )+ assert s.llamacpp_url == "http://127.0.0.1:8300"+ assert (s.service_token, s.bedrock_enabled) == (None, False)+++def test_ollama_backend_default_model(monkeypatch):+ monkeypatch.setenv("DECISION_BACKEND", "ollama")+ monkeypatch.delenv("DECISION_MODEL", raising=False)+ assert load_settings().model == "qwen3.5:9b"++[email protected]("value", ["-0.1", "1.5"])+def test_threshold_out_of_range_refused(monkeypatch, value):+ monkeypatch.setenv("DECISION_CONFIDENCE_THRESHOLD", value)+ with pytest.raises(ValueError, match="between 0 and 1"):+ load_settings()+++def test_unknown_backend_refused(monkeypatch):+ monkeypatch.setenv("DECISION_BACKEND", "vertex")+ with pytest.raises(ValueError, match="DECISION_BACKEND"):+ load_settings()+++def test_bedrock_backend_defaults(monkeypatch):+ monkeypatch.setenv("DECISION_BACKEND", "bedrock")+ for k in ("DECISION_MODEL", "DECISION_BEDROCK_MODEL", "AWS_REGION", "AWS_PROFILE"):+ monkeypatch.delenv(k, raising=False)+ s = load_settings()+ assert (s.model, s.aws_region, s.aws_profile) == (+ "us.anthropic.claude-haiku-5-5-v1:0",+ "us-east-1",+ None,+ )+++def test_bedrock_model_setting_is_the_bedrock_default(monkeypatch):+ monkeypatch.setenv("DECISION_BACKEND", "bedrock")+ monkeypatch.setenv("DECISION_BEDROCK_MODEL", "us.anthropic.some-other-v1:0")+ monkeypatch.delenv("DECISION_MODEL", raising=False)+ assert load_settings().model == "us.anthropic.some-other-v1:0"+++ ("value", "enabled"), [("1", True), ("true", True), ("0", False), ("", False)]+)+def test_bedrock_enabled_flag(monkeypatch, value, enabled):+ monkeypatch.setenv("DECISION_BEDROCK_ENABLED", value)+ assert load_settings().bedrock_enabled is enableddiff --git a/decision/uv.lock b/decision/uv.locknew file mode 100644index 000000000..bbf66cb72--- /dev/null+++ b/decision/uv.lock@@ -0,0 +1,646 @@+version = 1+revision = 5+requires-python = ">=3.12"++[[package]]+name = "annotated-doc"+version = "0.0.5"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" },+]++[[package]]+name = "annotated-types"+version = "0.8.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" },+]++[[package]]+name = "anthropic"+version = "2.3.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "anyio" },+ { name = "docstring-parser" },+ { name = "httpx2" },+ { name = "jiter" },+ { name = "opentelemetry-api" },+ { name = "pydantic" },+ { name = "sniffio" },+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/3e/ba/4c91947e0d0062d66d371db371597287153f7685fbed512d3294d0cde3c7/anthropic-2.3.0.tar.gz", hash = "sha256:edfdea1e3fa7b3ce25df1511953408b2f03bfa61eb6f6268f766101a9e18ad53", size = 1869656, upload-time = "2026-10-23T23:18:47.649Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/3f/29/eb3558ab6bf252a07ac41c76ac5b0ea24a0aa0c23f87a40aaf31a5f8dba4/anthropic-2.3.0-py3-none-any.whl", hash = "sha256:aa6a3984f9276f307933d42dc6f58b6efc821a5ecafbc8d1bb5993a066767622", size = 2216980, upload-time = "2026-10-23T23:18:45.779Z" },+]++[[package]]+name = "anyio"+version = "4.15.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "idna" },+ { name = "typing-extensions", marker = "python_full_version < '3.15'" },+]+sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" },+]++[[package]]+name = "boto3"+version = "1.43.119"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "botocore" },+ { name = "jmespath" },+ { name = "s3transfer" },+]+sdist = { url = "https://files.pythonhosted.org/packages/02/1b/97f8ec6ce00ae49455797b8af9fde522624ecf80bc73c937596b558b1853/boto3-1.43.119.tar.gz", hash = "sha256:e12c3b1d81713e14bd6947b7412d9d0ea49b320642d795ded1d64d6483ca6f49", size = 112659, upload-time = "2026-10-26T19:25:58.76Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/3a/d7/6c82dff652082a4bab907b7a5833933a362f12400f14bd7a9935a330145e/boto3-1.43.119-py3-none-any.whl", hash = "sha256:d1718edae48c3241d289c0ece8a515399a7242c406e35328b9685c4d24039186", size = 140045, upload-time = "2026-10-26T19:25:57.128Z" },+]++[[package]]+name = "botocore"+version = "1.43.119"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "jmespath" },+ { name = "python-dateutil" },+ { name = "urllib3" },+]+sdist = { url = "https://files.pythonhosted.org/packages/a8/ab/8e6d1d97c086c127f725cdeffae3b44d92ca3ca40741fb90f245f11887d5/botocore-1.43.119.tar.gz", hash = "sha256:ed11934be6e6d398ac21b7fe03778c9584368eeff8ba5371581f19bb47db0b6a", size = 16457548, upload-time = "2026-10-26T19:25:52.703Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/3f/54/04e5950c7f2d22d78f22db00ca119b257b7cd2024328b6116ebaeb9c14eb/botocore-1.43.119-py3-none-any.whl", hash = "sha256:6026aec97914a4fa116915fd3b05af899912eff51b93fb8dff95aa228a3e761b", size = 16154402, upload-time = "2026-10-26T19:25:48.301Z" },+]++[[package]]+name = "certifi"+version = "2026.10.23"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },+]++[[package]]+name = "click"+version = "8.5.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" },+]++[[package]]+name = "colorama"+version = "0.4.6"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },+]++[[package]]+name = "docstring-parser"+version = "0.18.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", hash = "sha256:292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015", size = 29341, upload-time = "2026-04-14T04:09:19.867Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", hash = "sha256:b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b", size = 22484, upload-time = "2026-04-14T04:09:18.638Z" },+]++[[package]]+name = "fastapi"+version = "0.162.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "annotated-doc" },+ { name = "opentelemetry-api" },+ { name = "pydantic" },+ { name = "starlette" },+ { name = "typing-extensions" },+ { name = "typing-inspection" },+]+sdist = { url = "https://files.pythonhosted.org/packages/e9/eb/2cf8c80abf09b2800aef0a83b41066fbfda8ee5495b7a08b9d1af40f7046/fastapi-0.162.0.tar.gz", hash = "sha256:6a22c1e2e6e32e0633ee7e170f00009a29b8228b16feb219ee42f32fd8d88a8f", size = 527867, upload-time = "2026-10-23T18:47:33.264Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/b4/4f/3f2c25c9b43970b5e9a08beb5e04776247edea684ddc0930f4f02f0bb6cb/fastapi-0.162.0-py3-none-any.whl", hash = "sha256:3785963de305dd09912426cb81f2d230fce98ab3521cdfe97265c8d14983128c", size = 148912, upload-time = "2026-10-23T18:47:31.734Z" },+]++[[package]]+name = "h11"+version = "0.16.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },+]++[[package]]+name = "httpcore"+version = "1.0.9"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "certifi" },+ { name = "h11" },+]+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },+]++[[package]]+name = "httpcore2"+version = "2.16.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "h11" },+ { name = "truststore" },+]+sdist = { url = "https://files.pythonhosted.org/packages/c0/61/afa9d6b7452f9eca73f73d45324eb0bb52f098fd5e6049bf6b8263be9b4e/httpcore2-2.16.0.tar.gz", hash = "sha256:c72cd0413563b17e1cd8354677dff887466f8ec2551679759e93126534428643", size = 69886, upload-time = "2026-10-21T07:09:45.31Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/af/c2/ce417c397afa5181f0e3c6ff01a4d01639414e1adef08730d97571297151/httpcore2-2.16.0-py3-none-any.whl", hash = "sha256:5c4358319f2602d984ad93182c9fee5160f22e9da7babdda870a5e7c4e2dc34f", size = 85070, upload-time = "2026-10-21T07:09:42.802Z" },+]++[[package]]+name = "httpx"+version = "0.28.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "anyio" },+ { name = "certifi" },+ { name = "httpcore" },+ { name = "idna" },+]+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },+]++[[package]]+name = "httpx2"+version = "2.16.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "anyio", marker = "sys_platform != 'emscripten'" },+ { name = "httpcore2", marker = "sys_platform != 'emscripten'" },+ { name = "httpx2-jsfetch", marker = "sys_platform == 'emscripten'" },+ { name = "idna" },+ { name = "truststore", marker = "sys_platform != 'emscripten'" },+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },+]+sdist = { url = "https://files.pythonhosted.org/packages/43/73/5ca2cedf5e4e50423d1c258877865a6b62793633b561c58499f8aeb33b7e/httpx2-2.16.0.tar.gz", hash = "sha256:0d54c98128e8f2ff7fbbde0fca8c359e5f032edeaaaac443cdb7f31f685bcd7f", size = 103116, upload-time = "2026-10-21T07:09:46.348Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/7b/3d/2e4bc4fd1ef9770871669adb348d612a6e4786b303a23f9935b81c48dd60/httpx2-2.16.0-py3-none-any.whl", hash = "sha256:fd2c5d7909e8d86fe92d53020c310ca0e4e431b838c207c5754b9bbf0308d49a", size = 97880, upload-time = "2026-10-21T07:09:44.01Z" },+]++[[package]]+name = "httpx2-jsfetch"+version = "1.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/0e5636363151a2a1795e0a77617168b9ca438e1748ec05fc9b5687f93d64/httpx2_jsfetch-1.0.tar.gz", hash = "sha256:70a0e3eabfef7cce5ad9c629f7d01ca05e418f586646f4ddf14782e4c1454c60", size = 6872, upload-time = "2026-08-07T00:13:07.492Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/9b/43/832f631d32e4f1211caa2ba368317739fe71f0b8530e4c9d15dc454bac2a/httpx2_jsfetch-1.0-py3-none-any.whl", hash = "sha256:cb916b707601e69a07721aabc8f3f6659be3a6893bc1ff5c6f9e02241df2da32", size = 6382, upload-time = "2026-08-07T00:13:06.567Z" },+]++[[package]]+name = "idna"+version = "3.20"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" },+]++[[package]]+name = "iniconfig"+version = "2.3.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" },+]++[[package]]+name = "jiter"+version = "0.18.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/63/5b/f68319f4fe624311a744a33d10fdbcac4c971991e348223cba60d31780b2/jiter-0.18.0.tar.gz", hash = "sha256:a0ca63fd9450a212e4e658d4cfe0ab4977c4f9b0003c68828b843c65e27662ff", size = 234470, upload-time = "2026-10-23T13:51:13.103Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/45/0e/075bfa4fa46820da9ac8cf8a67c435b0586012279fba15deccde0e73b9ce/jiter-0.18.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:77a01cdf4381a1becbe5b827f682006f47b712581667451c5b1eb259b9ae7041", size = 290095, upload-time = "2026-10-23T13:49:14.118Z" },+ { url = "https://files.pythonhosted.org/packages/2e/e2/f4000a4d9c519ca019bf0e2922cc0c6b6db347be6303161382eda7635be7/jiter-0.18.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7b41cd64ee6b54db94bea6274e6e37002ed526aa06c114a8be6f36ffe21c184e", size = 316319, upload-time = "2026-10-23T13:49:15.263Z" },+ { url = "https://files.pythonhosted.org/packages/51/93/9aaef4d18d19446fd044b9cff0323b1b45b5526f077f1a80418567a6eef8/jiter-0.18.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7424194e68ef44e94290961f59319850d7ce11a329a3957f91709c15ded6618", size = 335631, upload-time = "2026-10-23T13:49:16.551Z" },+ { url = "https://files.pythonhosted.org/packages/fd/9e/d2dc5e8179e248df7ef1c7c8822554f4c7f694a33be30790bb523f1e657a/jiter-0.18.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:04a484fce032a8b2c21dec0410a805d7b16573eb34297156a3b4d242c507d2b4", size = 322596, upload-time = "2026-10-23T13:49:17.875Z" },+ { url = "https://files.pythonhosted.org/packages/22/ca/28bfd20743be0b2b37c1ddfe069a637d5180e535f1c8faad555cf7ac0b98/jiter-0.18.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:860ac97858116bda0ac02ef5f50c541fc1a84ad7b9368cac68d4de5697a9012d", size = 333858, upload-time = "2026-10-23T13:49:19.343Z" },+ { url = "https://files.pythonhosted.org/packages/69/89/e42f7dba54dcf7787aa4be3e22cdcb1f14d9635b6527949652ab490d6f8e/jiter-0.18.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39ef656cf371971486ec545ca0ae2da8d037d5479bc906121e3e46de86ee73c4", size = 348656, upload-time = "2026-10-23T13:49:20.796Z" },+ { url = "https://files.pythonhosted.org/packages/74/6a/b13407f609ddaf9a1f0cdf1336326dc5c8c7fc56943e8450a04a542f5edf/jiter-0.18.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3c741e6b778c951a6861964ee475118812a33208426c54fb92bf4e318bda834", size = 336286, upload-time = "2026-10-23T13:49:22.152Z" },+ { url = "https://files.pythonhosted.org/packages/b2/7e/b560f97495a485a569e7fa338a13587328854f6a40cd2e93602c327ca4a6/jiter-0.18.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:1277ac083a58d2f49a24ff9a28fd9876a6443a1992d4467a1db80fb45e354b18", size = 314415, upload-time = "2026-10-23T13:49:23.645Z" },+ { url = "https://files.pythonhosted.org/packages/8b/97/457b6ec16f1f3f25ec760f23728f43a2b20ddf934fcd8f02c81a2183597e/jiter-0.18.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ccf224d2e706be81d464b59c2bc3f98ba65d12c092c1789e625127e64488944e", size = 332078, upload-time = "2026-10-23T13:49:24.917Z" },+ { url = "https://files.pythonhosted.org/packages/0e/d9/6f616071650f7bb8fcbce674d4dde7e59cfbd8a4d30f5c71c03630425d6e/jiter-0.18.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:5c7fc8e5357d1ad082bb177be71e398fcd3d458726439255ca5cb0d706060269", size = 480354, upload-time = "2026-10-23T13:49:26.221Z" },+ { url = "https://files.pythonhosted.org/packages/42/72/52a3630c8213cdc8093cc86dc6ad50f2bc89ccfa97ef272205d38a24e16d/jiter-0.18.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a6bba0404b46157a651d1fe512cf2c59c8e42836a9284c35cdff35310758ba4f", size = 515322, upload-time = "2026-10-23T13:49:27.652Z" },+ { url = "https://files.pythonhosted.org/packages/31/54/987cfee52bdf8a286e9c1c58192a9bb64f8773a6be36e4ec46959f67fb7e/jiter-0.18.0-cp312-cp312-win32.whl", hash = "sha256:07ae058bc052ead609b49bbae78c01bf4dee8f5f9d21705cbae9bfe59b33efc9", size = 185341, upload-time = "2026-10-23T13:49:29.147Z" },+ { url = "https://files.pythonhosted.org/packages/c5/c9/b1279eecf68e5f62c918af3f7f856a071ae7db0c90b8fd2235b1b6020c8c/jiter-0.18.0-cp312-cp312-win_amd64.whl", hash = "sha256:79d1fe529bd7065c6f3f50279a08c2ab82eaa0631a6f5dfafa9c65105eeaaafa", size = 225889, upload-time = "2026-10-23T13:49:30.306Z" },+ { url = "https://files.pythonhosted.org/packages/e0/14/715f84be58a7fc97779aa40c37164acfa25ccb2cee89bfb69358e7071ff3/jiter-0.18.0-cp312-cp312-win_arm64.whl", hash = "sha256:1f8b3b3d8761dee3cddcb5d3e99eaccc0155bbefc345affcdedcc758a4933a1f", size = 181852, upload-time = "2026-10-23T13:49:31.811Z" },+ { url = "https://files.pythonhosted.org/packages/50/94/aa275cdb099fd84e402977f8fc8628e2cee2f7c8eafe1d1d5c5e722f5ee5/jiter-0.18.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1517648b5f6268513dea206241a99d9991d6ffcbdbc406848e77a7f02ed3ccf1", size = 289648, upload-time = "2026-10-23T13:49:33.059Z" },+ { url = "https://files.pythonhosted.org/packages/8d/30/3eaf67279c6183393d3608b6713c93668ae82ea59f0589ea59d8176d8741/jiter-0.18.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7161217e2190b9b2c8c79b81699be29d67010f6f77e09a53a3b62261792d5489", size = 315919, upload-time = "2026-10-23T13:49:34.457Z" },+ { url = "https://files.pythonhosted.org/packages/f8/2b/d18adcfec3516b97b24c0d5cd1b0ced22cada8ea9806f21bece75af49ffe/jiter-0.18.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9623fc90f1a4754452a525383ce70476476c16556098944709b8cdbd9ad905f0", size = 335231, upload-time = "2026-10-23T13:49:35.776Z" },+ { url = "https://files.pythonhosted.org/packages/41/e8/42cff1077883ea5311621dc9384a1ede4799bc3c01411798ac75f7a71f15/jiter-0.18.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f9083a7c2a4ee6358bc0401c46b4d5090f208f6fadfb6275c7b5fe3217e13506", size = 321590, upload-time = "2026-10-23T13:49:36.997Z" },+ { url = "https://files.pythonhosted.org/packages/1d/4d/2fbedfce563223d4783a872cead5f5bb74d2d1e418f963410ca28e4b7394/jiter-0.18.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4632f5172800da4cd42fd53f4553c772acd08f1c33dd7ac135e29d735080fa0d", size = 332960, upload-time = "2026-10-23T13:49:38.615Z" },+ { url = "https://files.pythonhosted.org/packages/04/a0/b082b2d8bd3bef9a888cc0a0f060a24644f24b5195f2e8227a40507e6b71/jiter-0.18.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c00b1f8fc1dd06c610305be36778b38148ed1e9a532bdd81189c3c0d9905c888", size = 348149, upload-time = "2026-10-23T13:49:39.826Z" },+ { url = "https://files.pythonhosted.org/packages/64/11/babc8d3c004bb2f11b7e3adfe27a5bc7c1e13cdfc6360d424c57355c55ff/jiter-0.18.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e3350b7431f7b8315b925d9ca0f29a44e8fb6ed45c1fe552392cb6297966bb9", size = 335978, upload-time = "2026-10-23T13:49:41.165Z" },+ { url = "https://files.pythonhosted.org/packages/3b/21/c50bf83c39d60f0df896ebcb025b316b670a703397d08bea2c69b9615101/jiter-0.18.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:3b49071fb7917cdbc6d80c81a491c6ad146c1a8fd6cb3076cd3c1bfeb6e266f6", size = 313767, upload-time = "2026-10-23T13:49:42.538Z" },+ { url = "https://files.pythonhosted.org/packages/af/19/3f66480d5bfd3f49571a073eefac4d890dd590a8eb3c78b15e0293909cc6/jiter-0.18.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04e210f5ddcccdbde484821040216a112381e6484abc549c20c38e9698ab07ca", size = 331070, upload-time = "2026-10-23T13:49:43.782Z" },+ { url = "https://files.pythonhosted.org/packages/5a/3d/b5662c84b14475c8b018ed1ca2ea44069194b7d97a03bac81ae6b46f6b9f/jiter-0.18.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:5b339f6ae14fe7be92f391cc65cc5c80ff76e8da76d63b18fc14664f09b7cece", size = 479939, upload-time = "2026-10-23T13:49:45.033Z" },+ { url = "https://files.pythonhosted.org/packages/80/b8/081c0414379ee2564aa7808f78e963538a2c4aed2f8d31775e2423e1cdbf/jiter-0.18.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:5cb43336244e063f9cc11e44730e4b92dea70c6eb9b649d268c5ebebc4bc7685", size = 514734, upload-time = "2026-10-23T13:49:46.236Z" },+ { url = "https://files.pythonhosted.org/packages/0f/1c/6f7bf98786851ae424a1d88562586302536cc137848fd12d2add3960fab3/jiter-0.18.0-cp313-cp313-win32.whl", hash = "sha256:9656d0e9001f69c4af6523874ff445ab4e5db7b835f59733cc5ff51e73a9aa57", size = 184699, upload-time = "2026-10-23T13:49:47.398Z" },+ { url = "https://files.pythonhosted.org/packages/38/53/5803216c024a241a0bf41ed2668713d7228f92c5593e40d5e873e3b20e0b/jiter-0.18.0-cp313-cp313-win_amd64.whl", hash = "sha256:8f26198220165eb9627847401fff4d0ca8bebf3ef840a88c6312918d2291c33a", size = 222493, upload-time = "2026-10-23T13:49:48.533Z" },+ { url = "https://files.pythonhosted.org/packages/fe/8e/484919ccb041c9a1e84059be02bd37ff086b8b084e21630e0958d3ae41a3/jiter-0.18.0-cp313-cp313-win_arm64.whl", hash = "sha256:bef1fe687dc6af17bef9f644a95d465f15f0efa20b743c858e0b6a14e2c0c73e", size = 181250, upload-time = "2026-10-23T13:49:49.777Z" },+ { url = "https://files.pythonhosted.org/packages/74/0e/45a502771d73d4a939132d8bf85d7b049c7ca06a07f84b414b525c3dc084/jiter-0.18.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:248e939f67a9f8030e2624260a9f417decfe275af37aa96728d256468a9c4086", size = 291757, upload-time = "2026-10-23T13:49:50.95Z" },+ { url = "https://files.pythonhosted.org/packages/21/f6/d9cfa2bf2a969fb8e002fb8d8a6cd98d49a6248cb7e4ffe2247766af13fb/jiter-0.18.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0390fa550fcafbf69fb97ccb287bd71192f90410a1c7dd600ca4000aa9aabcf2", size = 318585, upload-time = "2026-10-23T13:49:52.407Z" },+ { url = "https://files.pythonhosted.org/packages/46/38/ea1dae56f123e3a864188cbbc577314293c0dcc019a880fa9c0a8097934a/jiter-0.18.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8013186f2b9a8c27ededa601050392527aa9d27ffd35d49aae424fbd2062f38", size = 338099, upload-time = "2026-10-23T13:49:53.658Z" },+ { url = "https://files.pythonhosted.org/packages/1f/d9/fcc5c53a32f98d52f4fd46fda62b69f5c7c2c975a582c0e18501250a4f78/jiter-0.18.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd4316df8e2074fcf5173f6001f1fc9596e7c1e8c4bf499b02f9ebe92babdfb1", size = 324016, upload-time = "2026-10-23T13:49:54.999Z" },+ { url = "https://files.pythonhosted.org/packages/d4/63/c24cd08907f08e6a3ba3173616ad268a3d32dd81c63ba34b991d08577d28/jiter-0.18.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a9e474da7a9f65d3b460cca93cc8a0f4ec0220d1fa41f1f7a3709195ead60056", size = 335904, upload-time = "2026-10-23T13:49:56.214Z" },+ { url = "https://files.pythonhosted.org/packages/0b/78/19ca1c8fe87bd3c8540b91504ff2dd52c9c538233044c4cf787fc1fab39b/jiter-0.18.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d55acd326db8ecfc94f21951abd20902c7939d35925444e48d94527e287bead7", size = 350523, upload-time = "2026-10-23T13:49:57.552Z" },+ { url = "https://files.pythonhosted.org/packages/c3/27/84be9cc1c2b781d2da7c694fd7608311af3aaab91f20eb00d4999285b351/jiter-0.18.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a01642d403b8925f2b1e1bb51b4ba49ece8a2bdc9b9560fc8ed0b1f2b35b567a", size = 338324, upload-time = "2026-10-23T13:49:58.842Z" },+ { url = "https://files.pythonhosted.org/packages/9a/ac/7b3bfb49b19e42ebc2ae56ec307c372602dd1e17892f7e051c9bf97cd7e6/jiter-0.18.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:89ba6b674d4bd7290f9943bbeba0e1bf35955bbb1e07e41ba94691648cf133d5", size = 316484, upload-time = "2026-10-23T13:50:00.257Z" },+ { url = "https://files.pythonhosted.org/packages/f9/6a/e37f50885aa4daa1dfe413784692ead6b48a1d9e857cd394a61bf345189c/jiter-0.18.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:feadebdfee32c61e91066433f4aa74c891752e26e43032c1feef08dda6d9b6ed", size = 334225, upload-time = "2026-10-23T13:50:01.542Z" },+ { url = "https://files.pythonhosted.org/packages/8b/f8/1026bc92f0fd443a1137993d1448a7d7c4b7a34bec2722a1533302ebc4b4/jiter-0.18.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:dd7e57efd54a3580620f635c48a3226f910e23649b7eb83ffbc6f0f3386293b8", size = 482157, upload-time = "2026-10-23T13:50:02.849Z" },+ { url = "https://files.pythonhosted.org/packages/1b/2d/61f3c35736873c34eeee3d0008067febd88ded8e8cf6f9a0ab090348a787/jiter-0.18.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:ea69e23481497c2143775a98d273ccc43de5c92a6387df18c903d2d37bc2b181", size = 516956, upload-time = "2026-10-23T13:50:04.19Z" },+ { url = "https://files.pythonhosted.org/packages/6b/bf/9d14be58e76324f4927c7f8e5dbe2f9fd04faaec884a6465173f8142eac1/jiter-0.18.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:d9b61af76a3cd90ad9656a331737d97dab8c05facb2d04cb41fb16c9adadc966", size = 112087, upload-time = "2026-10-23T13:50:05.423Z" },+ { url = "https://files.pythonhosted.org/packages/c6/7d/cff751c560d514da283bae595fe154714f285ec5ac15e2b16e9e0c0c8948/jiter-0.18.0-cp314-cp314-win32.whl", hash = "sha256:fe42726d7fe171cd8fc1966d4457a6aae03bd408d519d2cc5e7726805460b51e", size = 186562, upload-time = "2026-10-23T13:50:06.81Z" },+ { url = "https://files.pythonhosted.org/packages/04/70/4e7f51e517be4146400fd1ce642d535380a38c7db5ab475d38bbcd16a82d/jiter-0.18.0-cp314-cp314-win_amd64.whl", hash = "sha256:f1e738b851019d6bb6ff4a42c6319bdede967dec958ef3ec6feb7ab9d12408f7", size = 225448, upload-time = "2026-10-23T13:50:08.302Z" },+ { url = "https://files.pythonhosted.org/packages/78/43/02bfb85f63e04c87c406731197e41f2e6b415035e41497428e0422fb326e/jiter-0.18.0-cp314-cp314-win_arm64.whl", hash = "sha256:80a961b1c5c7786bc03b332deb7f7ebe818b7baa6e26685e2bf480548ca128b4", size = 182907, upload-time = "2026-10-23T13:50:09.795Z" },+ { url = "https://files.pythonhosted.org/packages/9c/66/5cbde35cbb14c8339af39c9bc61cbda08b212116f96603d23b7c9cc84a4d/jiter-0.18.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b066f37dd9ec19fc7931d79dee38f56b6f849217bbe824a7dad4518ef96ee515", size = 318962, upload-time = "2026-10-23T13:50:10.91Z" },+ { url = "https://files.pythonhosted.org/packages/eb/d1/dccc47ed6070d3b25622823048a80a49fe87ccd737e5d66b802ca20e4fde/jiter-0.18.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ccdc09887b04f50f1761eedcfd19da882d9d834096bc1215049af637023f7db7", size = 336718, upload-time = "2026-10-23T13:50:12.149Z" },+ { url = "https://files.pythonhosted.org/packages/de/a5/8d4ec06d7a0f2bccbde8508ed847ccd323a9dd1fbab5900cda3fc5bd71f8/jiter-0.18.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6133abcd0f332964fbb8145adb1ce775cd0312c9eaf6e4bf26b7a5c9b6f7cca7", size = 322945, upload-time = "2026-10-23T13:50:13.591Z" },+ { url = "https://files.pythonhosted.org/packages/7f/50/49d06214b30c685d64ffdd40fdb50a98b6ccff4b012fc9ed491d44de9ef1/jiter-0.18.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ca381b4a466023d1fdd04c889c759b46f7d9654f622b28bb01e65abf31d07bba", size = 335325, upload-time = "2026-10-23T13:50:14.807Z" },+ { url = "https://files.pythonhosted.org/packages/f4/9a/4ecb866a7a01a4e76d9ffbde3fac2cd66ad978c8c797953d44f91fbf2040/jiter-0.18.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b961fedf589ffa182fe302fc4371acf4606d3ed4a6a48a151fbfd724d811f5a", size = 350578, upload-time = "2026-10-23T13:50:16.125Z" },+ { url = "https://files.pythonhosted.org/packages/16/7e/c8b5ecb6af4c9454376263f167f3f8bb5dec41b10fac4f48ea4557b9f115/jiter-0.18.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b77eabfbae1ac47872be0076899e66340bbef39b862971c3d6c9a4b7c91fd10", size = 338791, upload-time = "2026-10-23T13:50:17.703Z" },+ { url = "https://files.pythonhosted.org/packages/8a/04/45ba31ce79022706323fd2291f87d956fd51fdfcba2ba8924b3de62f0ce2/jiter-0.18.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:92a16933d0fa852133500837d33cd6a4f75e4414d77389c58269e12bafc2ee02", size = 316169, upload-time = "2026-10-23T13:50:18.915Z" },+ { url = "https://files.pythonhosted.org/packages/62/c1/fd36126144f4c32d1b76939278e9d3b7b798075c0478b641d6066621bafd/jiter-0.18.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2f7ba518893a4ccef5afb38e41bc3e126bf652354417ec4e75e5a5b000fb1ef6", size = 334754, upload-time = "2026-10-23T13:50:20.169Z" },+ { url = "https://files.pythonhosted.org/packages/cc/e2/30a5ac1a3ee9e01bda75a4fcb55bbeddcf8875f8ce7e680b787c177f14b5/jiter-0.18.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:04d67a44b040a6662a35edc9869030f7aa566bf5baaf3549c99d847aa44213e2", size = 481094, upload-time = "2026-10-23T13:50:21.481Z" },+ { url = "https://files.pythonhosted.org/packages/33/de/5e736a36eff6933da012dc440540f79e3ccfc06e27f557638280657df023/jiter-0.18.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:e4d4819398d5330636bc0b91ccc0048dba782076fb99257038257ba6f121c840", size = 515524, upload-time = "2026-10-23T13:50:22.872Z" },+ { url = "https://files.pythonhosted.org/packages/0a/ea/1e8bc5b0c920a13e5b698106dbb2d2da5c5e3474668746246f649abb6d5f/jiter-0.18.0-cp314-cp314t-win32.whl", hash = "sha256:c435e795a7ea4b372166a058a5b49a25caeb9c94e469a1414868b14c83ee5c41", size = 185058, upload-time = "2026-10-23T13:50:24.098Z" },+ { url = "https://files.pythonhosted.org/packages/1e/0f/a742b397699c3af52dd95443332164884fe6204e5faa5321b7c073beab0f/jiter-0.18.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5a3d5397da7ae46c7a9601ef02d2c9ec47a6c3abe15e1ea940eaf93e675ee20e", size = 225598, upload-time = "2026-10-23T13:50:25.44Z" },+ { url = "https://files.pythonhosted.org/packages/b3/b7/08ae26347dca48d5cadca33be2f2f5b6b1ae790b322109083d6f95959feb/jiter-0.18.0-cp314-cp314t-win_arm64.whl", hash = "sha256:4b81b474e4a8ec745ab20a6762275a360e1147cb70cf08872ec14e1aa5debc37", size = 183052, upload-time = "2026-10-23T13:50:26.675Z" },+ { url = "https://files.pythonhosted.org/packages/c2/d6/0d2a8a9747ad918141827fabdc05abc3bf73986f7f36647fb8c19708e21e/jiter-0.18.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:30f8ae18425e0247ffff4e4a5753ec1952e1b81ed4e7949b84e5ecfaf8315833", size = 291908, upload-time = "2026-10-23T13:50:27.94Z" },+ { url = "https://files.pythonhosted.org/packages/54/b4/19c582727e22681c6069db037c3b3e354c6fbdce7fbc5290a7bc7bc5884f/jiter-0.18.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:93150a3bb0317d8f5a94d4c3ea68db1cb434b94ac819e08c443cea97b7645f2f", size = 316544, upload-time = "2026-10-23T13:50:29.167Z" },+ { url = "https://files.pythonhosted.org/packages/c3/62/5d34e93dc5d1e707788a378335efc876cdc731ceb2111b0a9d7c6f9fdada/jiter-0.18.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9c8a61d6227cdcb0a67c678f30a020837c9f3dd7e0b3f916781defa157e4eb9", size = 338101, upload-time = "2026-10-23T13:50:30.457Z" },+ { url = "https://files.pythonhosted.org/packages/75/e2/0b16a6ca5479cd9efa3c59497cd42f1979a539b6c664a5b9c87e3632f176/jiter-0.18.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:285cc15ff9ffcd4ce7f0b9ce02fcbc65e22fcf7dfbda1a3d71ccac8d7b73f8a1", size = 324213, upload-time = "2026-10-23T13:50:31.695Z" },+ { url = "https://files.pythonhosted.org/packages/85/9d/620a97457a0210092bf9faa1eb30f5da094fab2de07a9478af7c254e22fd/jiter-0.18.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c8f69ef2e28f8c1759bc1522385ab3e4ade0b1056053cecf67449a947c4525a8", size = 335777, upload-time = "2026-10-23T13:50:32.984Z" },+ { url = "https://files.pythonhosted.org/packages/76/08/a3514df093824f10a61dc1d0bbc22285ed779ba42f15d727499a8c877e16/jiter-0.18.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eec2da60423287bd60377b0fad1723560dcc51cfb2b99615be8431ad425c4438", size = 350490, upload-time = "2026-10-23T13:50:34.421Z" },+ { url = "https://files.pythonhosted.org/packages/cd/60/8f8b51bae62259b429e83d0adff69d93e39e4fadbc4bd1856dc2a0950639/jiter-0.18.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5db2cdae6a2f01e8f52ab2154886dcf5bb1844b4f31245440bf623ec91b65b08", size = 338591, upload-time = "2026-10-23T13:50:35.759Z" },+ { url = "https://files.pythonhosted.org/packages/2e/ed/5307f0eb051d987510fdd1020c904927c0b364a4937d372817bdefaced31/jiter-0.18.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:029da1f29852beac2f9001f20209b73b29b4d7bdc748c7f8028895769e2cc0d8", size = 316623, upload-time = "2026-10-23T13:50:37.316Z" },+ { url = "https://files.pythonhosted.org/packages/f9/0e/4bdc945ffbf77c60f07c726fbeb45508018322df9d9942d262256397062e/jiter-0.18.0-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:67c6662b1b7e5728a507db06ad1b8a7ff8ade04c2a74f092d467209ef744d3a4", size = 334720, upload-time = "2026-10-23T13:50:38.507Z" },+ { url = "https://files.pythonhosted.org/packages/4b/33/fb3e8f9354e7edab05f3752383eac58ce6e785f2f1626b697dd5dd0a86e4/jiter-0.18.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:4db12daef4a231df528a16f70d5ff7f5e3be21f70e8ad904e4c61442366e8a10", size = 482130, upload-time = "2026-10-23T13:50:40.023Z" },+ { url = "https://files.pythonhosted.org/packages/2e/3d/3aef2be95155bbacadd8691208b6f0f7371cc0cefe80241a1245e38e308d/jiter-0.18.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:4654ea93f525ea96adf289afcf1ead32d773b8325ec326862b4f81f5f4570835", size = 516986, upload-time = "2026-10-23T13:50:41.279Z" },+ { url = "https://files.pythonhosted.org/packages/3c/f6/2aa54fd5da3d0a93de2655e2525426263168454259ba3f2fb70d1b36fbc9/jiter-0.18.0-cp315-cp315-win32.whl", hash = "sha256:f035d01b450ac4e141502f1ce142462cee638198ff5a0237c80e6683798b3b87", size = 186645, upload-time = "2026-10-23T13:50:42.526Z" },+ { url = "https://files.pythonhosted.org/packages/b5/77/5b54ca8c292b83991cafbac6b022f515e46f1ae77dd5f4a97cc33644b235/jiter-0.18.0-cp315-cp315-win_amd64.whl", hash = "sha256:4a18ef4fe95685b000d95eca797cc683e0c178a4b364f2e39f6c79ab107a26e6", size = 225087, upload-time = "2026-10-23T13:50:43.779Z" },+ { url = "https://files.pythonhosted.org/packages/9f/f3/53b7f39b83c757380ab57d9bc3f934431d6b6751f007e8122f7f63c10c2c/jiter-0.18.0-cp315-cp315-win_arm64.whl", hash = "sha256:c73922e4ff4b1ad2929cd795c98223c6688a43c5fd42e9deb8955e4d43b00abb", size = 183120, upload-time = "2026-10-23T13:50:44.985Z" },+ { url = "https://files.pythonhosted.org/packages/77/f8/3a3ef55c528722f3b4be0e7b9686a37ddbe86ed96510bc1c2a63dab7f14b/jiter-0.18.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:0ccf55f6fcdcee82fe40ae617e9d64b8e5f433fa6cb5bf7d2969e584e6df0e5d", size = 317996, upload-time = "2026-10-23T13:50:46.266Z" },+ { url = "https://files.pythonhosted.org/packages/e1/15/b06c1c17bed30b5c5dabb40f80a56a3b71b89c16ae86552307f7ccedc93a/jiter-0.18.0-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:163a55e77f8e92d739b1f4ef212f1d445ddc58ecdf0da1feca44ef424b5331f8", size = 336638, upload-time = "2026-10-23T13:50:47.444Z" },+ { url = "https://files.pythonhosted.org/packages/87/79/b7bcd3e8c850326a323d18a5607334ea40659e22a4fc321e315d1d230007/jiter-0.18.0-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9de6c9133be12a51ea2d8c270f39a04ed45ee369802bb6270649b952e6cec256", size = 323116, upload-time = "2026-10-23T13:50:48.715Z" },+ { url = "https://files.pythonhosted.org/packages/5e/99/4c53c9d46462cd0691c3c188f89612e63a424d19f5befd1b0631f8f90638/jiter-0.18.0-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2ea4f2ed18eba7454182d4ff727444788ae51ad11bf5a25ad892f5f0ad3e754b", size = 335162, upload-time = "2026-10-23T13:50:49.987Z" },+ { url = "https://files.pythonhosted.org/packages/6f/ab/ef873065a3a1c442a4e62558b77bfa338066317dbafdfdc991121201f5ad/jiter-0.18.0-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:626d5c9fb8b57babc6ce9d03224846ecb094e1d22ff5bff6080398e7f8aee162", size = 350560, upload-time = "2026-10-23T13:50:51.478Z" },+ { url = "https://files.pythonhosted.org/packages/19/7e/48e78558d7cb3d289211da0397b7ed31cfe3efc98dd85f2324abd574c07c/jiter-0.18.0-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3c3318cc6ef857b6554b43479c30e8249fc143189d500d4137cde9c58412e6d", size = 337848, upload-time = "2026-10-23T13:50:52.961Z" },+ { url = "https://files.pythonhosted.org/packages/2c/35/b0a093e72def7caec970dd8536c3d42af3add3aedfb3c06ac0588effde26/jiter-0.18.0-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:9a70f25f6de76a01e309e109c9bcf2143c5c126b3488dd17a25c7aa404b28f16", size = 315870, upload-time = "2026-10-23T13:50:54.152Z" },+ { url = "https://files.pythonhosted.org/packages/48/a4/fd7ca4d1ce8b876be7a260f5e31615854aed5b041553a63e85c4a265cb63/jiter-0.18.0-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:22d8dd757e603224e46786d63cb7d7bfbddc8f579a02e7b082840468d18c06f3", size = 335253, upload-time = "2026-10-23T13:50:55.427Z" },+ { url = "https://files.pythonhosted.org/packages/f5/71/ccd7154afecd4687b22a8195d5dc6460f89f6e17537ec78edb58a2faac34/jiter-0.18.0-cp315-cp315t-musllinux_1_1_aarch64.whl", hash = "sha256:552a8714f26ddcb43115c82da6d045b3b9f2fa5997d8b21b2f8ec3721503bebb", size = 480775, upload-time = "2026-10-23T13:50:56.91Z" },+ { url = "https://files.pythonhosted.org/packages/c8/b9/bad5391d7fb734cd6ebc383c8603bc324518bf4ce865f5d813908ae42596/jiter-0.18.0-cp315-cp315t-musllinux_1_1_x86_64.whl", hash = "sha256:8060a206e290410d3bfc3bd91715f3ec90a499246f8335d48927e0b3b6a6ccc5", size = 515619, upload-time = "2026-10-23T13:50:58.231Z" },+ { url = "https://files.pythonhosted.org/packages/c8/5c/9596452ad56340e6ed395c5fe27ab102bb2aa0c4b59de2e6a8b3dc3b03a7/jiter-0.18.0-cp315-cp315t-win32.whl", hash = "sha256:91d463858f11ee76ce8e39f391bbcbf1d4c3cc4703a1496fed3a5666dcd5e01d", size = 185204, upload-time = "2026-10-23T13:50:59.456Z" },+ { url = "https://files.pythonhosted.org/packages/08/c8/62c798e2a1a6f827eac1d45232c93b1b0e387a22d559c8483dc7302d5fd5/jiter-0.18.0-cp315-cp315t-win_amd64.whl", hash = "sha256:6ee49daab0b826279c152ad8d61171ea17f4197f91a5e14251d0d5d4adf51059", size = 224948, upload-time = "2026-10-23T13:51:00.624Z" },+ { url = "https://files.pythonhosted.org/packages/64/42/cdfa494914b6d512431e795d8d6226b84b77b733bb8b5eccafd5a1a86dad/jiter-0.18.0-cp315-cp315t-win_arm64.whl", hash = "sha256:bec676a0dc24d4dabd4bdfb3d1f1bf80d4d3dd892fc5c5b3f8f953e2459dbfce", size = 183182, upload-time = "2026-10-23T13:51:01.797Z" },+ { url = "https://files.pythonhosted.org/packages/a0/c2/49ee8f4743c27e61c52b4746ba636b43bedda97131a14043dc6f5ce5bb9d/jiter-0.18.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:118c1fd995f349f1cad0557f31d6860f336b4aeef7f002dedbc068027f68e2c3", size = 287302, upload-time = "2026-10-23T13:51:08.073Z" },+ { url = "https://files.pythonhosted.org/packages/60/72/394036294ac3226216f73bfa4b14df920eb5baf7fb80fa7e0a0d7ef442a6/jiter-0.18.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:44d0d719cd7845e66b01a0cf346ec9882073e710a05e89a5b6d87be47a9dc69c", size = 277797, upload-time = "2026-10-23T13:51:09.324Z" },+ { url = "https://files.pythonhosted.org/packages/ce/80/f0dadedaa9a109f31e8978c7db355593916968d5956f382188a3f8c0888c/jiter-0.18.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d1d2dc4d930ebc225f488b6b3790acebb2e51b3a165a4a42cc1d05bb927f83e", size = 300192, upload-time = "2026-10-23T13:51:10.551Z" },+ { url = "https://files.pythonhosted.org/packages/93/51/e57dbc6c264ec6557a677189755fe4525d83439237418e3ae59771ac1cde/jiter-0.18.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ebb0c346b6c5d9c033fe9e9b6ed6a1ff6dac0288fe681c3434dde6eb9c264fa1", size = 301141, upload-time = "2026-10-23T13:51:11.882Z" },+]++[[package]]+name = "jmespath"+version = "1.1.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },+]++[[package]]+name = "opentelemetry-api"+version = "1.45.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },+]++[[package]]+name = "packaging"+version = "26.3"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },+]++[[package]]+name = "pluggy"+version = "1.7.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" },+]++[[package]]+name = "pydantic"+version = "2.14.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "annotated-types" },+ { name = "pydantic-core" },+ { name = "typing-extensions" },+ { name = "typing-inspection" },+]+sdist = { url = "https://files.pythonhosted.org/packages/7c/0b/8e10b2e693af8ec54346a14caf36221334775975a747c9ceaa3f8371d96d/pydantic-2.14.1.tar.gz", hash = "sha256:94f478203dd03404682a1ada216965651dd74b1d2d5ffd62e00e0837caab5c26", size = 900362, upload-time = "2026-10-11T18:37:55.396Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/35/ea/a56b9fe5066f3537b7882f77e9c5dfb26d8c2eefdaed9b5fc73d57b4dc22/pydantic-2.14.1-py3-none-any.whl", hash = "sha256:9195d967ec791692a04438115466764fb8b9a27b31f14a760437694f40d6b454", size = 488106, upload-time = "2026-10-11T18:37:53.437Z" },+]++[[package]]+name = "pydantic-core"+version = "2.50.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/a6/24/af4ec4be49fbc810f35b0bdcacc3d433b56bbfa469fd3bfd4ae116cd9bf1/pydantic_core-2.50.1.tar.gz", hash = "sha256:e50d7b94baac6c7d09927fa5ca5800a0c7ee5015c7fcff65beb3a1931b5a6e09", size = 513515, upload-time = "2026-10-11T18:35:44.82Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/ee/94/101b49a6c63f99586755690696eae14532772587d9e39e93f7b8d28a49da/pydantic_core-2.50.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:704075d10b74f2f3c6e15407c696d88701df35fc8953f434a431add0d0074db0", size = 2222428, upload-time = "2026-10-11T18:32:20.228Z" },+ { url = "https://files.pythonhosted.org/packages/db/a3/f8b1b39349c33037c73d7a1b794c9c29d8f07d5bd2b74399c1375a529cc6/pydantic_core-2.50.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e8e1d6ce820aa23317e8209a86bd65a540973c12dc7552b48a4f6c8e9926815e", size = 2025779, upload-time = "2026-10-11T18:32:21.723Z" },+ { url = "https://files.pythonhosted.org/packages/d2/2d/862a7d115305cc621358e51ba13f296e0ffdf4fbd984be9f63bc7862730b/pydantic_core-2.50.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c18db21573bd2c6489f9a544b7499f0df2853958c568e5e783536ee1f690af41", size = 2048429, upload-time = "2026-10-11T18:32:23.3Z" },+ { url = "https://files.pythonhosted.org/packages/c0/7d/fed95d18bf2b5abe2d5ab2bbec4184bfc22b6805994a33ccdae8edffd25a/pydantic_core-2.50.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb57f304525a5e3c13333b772bf9a473f36326e9c821b2e8e1b2fd36f80ae2c3", size = 2173274, upload-time = "2026-10-11T18:32:24.697Z" },+ { url = "https://files.pythonhosted.org/packages/93/1e/c6f22ceac65dc3d291ff79bea0eb74cbd1de8b128f01fee48af03bcea1e1/pydantic_core-2.50.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a27c09d86600f1bf2fe3f37e1ae697faf3143931c09322cd799da94deee923b5", size = 2360403, upload-time = "2026-10-11T18:32:26.281Z" },+ { url = "https://files.pythonhosted.org/packages/2c/97/190b5b6bfe4c72f265feb657913eb30749193927a5ad7b83cfa7866a25a2/pydantic_core-2.50.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:46b3301d3b5c886f77de7546e47274a5842c622ea2020b8c6524c6b66913b4a6", size = 2439799, upload-time = "2026-10-11T18:32:27.844Z" },+ { url = "https://files.pythonhosted.org/packages/90/24/48cd98388e4ac2c08d0800af36d15413db15e20387f1038123a2c86cb2f6/pydantic_core-2.50.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93ba4e9d8210d941c200431a56b2c0400b131865947903937ed3ec5404307d2e", size = 2160157, upload-time = "2026-10-11T18:32:29.553Z" },+ { url = "https://files.pythonhosted.org/packages/00/86/d909133d0b9979ed14c20f110f21124a0e346caf071bd66ac5af3009062b/pydantic_core-2.50.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:e5faeaee74a57d32b3ab3aebad2e348f06d3ba946fc5d28c1728455f00a3d13a", size = 2229523, upload-time = "2026-10-11T18:32:31.027Z" },+ { url = "https://files.pythonhosted.org/packages/90/31/4b43f08131b2098e73a852fd932063385f3103b33839fd9d1abdb89e673d/pydantic_core-2.50.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a3cda0e538208e5d722bbf3698b24f19c0a7d05bc8d5f8a7f9b121ea7fa243d9", size = 2242700, upload-time = "2026-10-11T18:32:32.622Z" },+ { url = "https://files.pythonhosted.org/packages/88/77/de39658569dc7a4c293d110a89629f61145e7538f00d1e4280c28debefd3/pydantic_core-2.50.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:57f51b31ff826e2859120cf4737c5a758a48d96f3e97da40ccee1796d58078ff", size = 2278452, upload-time = "2026-10-11T18:32:34.165Z" },+ { url = "https://files.pythonhosted.org/packages/46/bd/1eeb9e4e791e81210ef9096f58080b32ba15b5b13c108d50aaa3f8ce9f73/pydantic_core-2.50.1-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8daa7ee75245d43ad7d747e5c9ecc1b1d06552f72b14887e9276f787d57375f4", size = 2450098, upload-time = "2026-10-11T18:32:35.547Z" },+ { url = "https://files.pythonhosted.org/packages/1c/e6/b2accfdff17e5a88d6358536702146de00f9339adaa4d5bbe1ee93cb4832/pydantic_core-2.50.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:acbf31f37c53a5ac0c34706c80b4f5107ba20b05fdd3816124bf236ef0c57dd2", size = 2476839, upload-time = "2026-10-11T18:32:37.119Z" },+ { url = "https://files.pythonhosted.org/packages/3b/7e/c8a83eb5d2cd42c2e13507150fb777b1edea5a018adc9cbf2858a1d08285/pydantic_core-2.50.1-cp312-cp312-win32.whl", hash = "sha256:45b11cac094aa25725581d9304eee93c9028516b9ea80dd9e175e13a5a2c840e", size = 2101425, upload-time = "2026-10-11T18:32:38.593Z" },+ { url = "https://files.pythonhosted.org/packages/c5/17/8bbd530b8659e9d963f5b16f6cb8e159f4cd174b4d6304e48969ab12dba8/pydantic_core-2.50.1-cp312-cp312-win_amd64.whl", hash = "sha256:132529c83901437ff642f585216831bf5fd7a91df66829907e155192ead62498", size = 2172522, upload-time = "2026-10-11T18:32:40.112Z" },+ { url = "https://files.pythonhosted.org/packages/af/9f/a79d690b127e4e3cff143d031538ab9aa715f6b2fbeecbd07cd6f2bf9fb7/pydantic_core-2.50.1-cp312-cp312-win_arm64.whl", hash = "sha256:4e834f6a8e4ff772dcc34f58ef5504147a3ea5b0f4eeb13b0f8eb2ca75ac57f1", size = 2161366, upload-time = "2026-10-11T18:32:41.606Z" },+ { url = "https://files.pythonhosted.org/packages/ae/57/0e237d7091d2cd44a35d243b7344227f90440166860469cd036afc23a04d/pydantic_core-2.50.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:d5e062c01286d861fd6a1c4ff6e063547b3e713067f2df033c0ff97ac2ca006b", size = 2222774, upload-time = "2026-10-11T18:32:43.103Z" },+ { url = "https://files.pythonhosted.org/packages/f7/b9/c720e56858d4e1539503297ed37063e0c08e0f3541c41b777f6a800f75fa/pydantic_core-2.50.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0c003c3b7f49debb893d2d85ae099ac5959c9839e2f330fadb1fcdf7a6594482", size = 2024738, upload-time = "2026-10-11T18:32:44.587Z" },+ { url = "https://files.pythonhosted.org/packages/4d/b8/fbfc25875219cc060e613170ff10e850c6d8924beb4910da57c2ee3ba1d2/pydantic_core-2.50.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:409e0ea40ec30d9158f33574fd758e689f6045a0f2596701828c27816ca9687d", size = 2047049, upload-time = "2026-10-11T18:32:46.164Z" },+ { url = "https://files.pythonhosted.org/packages/d7/43/34210124d504c553688f2f04b48500b131237528ac545b445e0d6d30e0d5/pydantic_core-2.50.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:131059670f1d2444269b8585cb888963994871932447c08b39ac6a51fcfef658", size = 2173415, upload-time = "2026-10-11T18:32:47.722Z" },+ { url = "https://files.pythonhosted.org/packages/65/cf/6e178e8fdc11da5965bef980983bf46326a42f436871dd51ba0a57f39df1/pydantic_core-2.50.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6dbcbee53bf17196a7f745aa9bf5a9603953a1e365b1f020be3207c676a3e7c4", size = 2361719, upload-time = "2026-10-11T18:32:49.217Z" },+ { url = "https://files.pythonhosted.org/packages/11/14/bd5169d356aa91bf777e28ba0b281c192d286d03c2812c9c9db023a2f00e/pydantic_core-2.50.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:325c23f3e35cfbf0fe3486fa5f7260d1e45885173002d30a28ca019994124255", size = 2439803, upload-time = "2026-10-11T18:32:51.025Z" },+ { url = "https://files.pythonhosted.org/packages/1c/bc/d79d000e5203ebef39af839f2ce77a777fcad6e08ad26af9a2fcd114ffc8/pydantic_core-2.50.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17e722e156d0444ecaefbe640bdb60928752bf2013e2b7a11cdb099aaae19bec", size = 2158402, upload-time = "2026-10-11T18:32:52.714Z" },+ { url = "https://files.pythonhosted.org/packages/1b/a5/4902cb5fd599422c130bd3124ab31ee8b771199bd56662702eed07d3fec7/pydantic_core-2.50.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:aa8224f10880d9bf1b5993988ba153d42a8b4f3f4f511f93b1f09c93ff613c72", size = 2229755, upload-time = "2026-10-11T18:32:54.126Z" },+ { url = "https://files.pythonhosted.org/packages/1a/f5/c1481f8669f6060d89110c9b1374173fc8767ca276b84f4870bd8acd5e3f/pydantic_core-2.50.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:41bc8237121bd8dc8d888dfd6279fc166ffc88c1f1bf3a8bf00869680533ca4c", size = 2242303, upload-time = "2026-10-11T18:32:55.641Z" },+ { url = "https://files.pythonhosted.org/packages/04/f9/77fc3c7653ba9b6e42049e17e96b25388187d4a7c274ab1cb07f58ac8419/pydantic_core-2.50.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:45c6266d071c241f2a168d45bf8c54344f0effce35e7e6b73afdec11f3687568", size = 2278345, upload-time = "2026-10-11T18:32:57.38Z" },+ { url = "https://files.pythonhosted.org/packages/95/9b/0579c5d12e7f2b16b27e6782427987341fcce07b0725e02ddb0b74add0c4/pydantic_core-2.50.1-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:1deeacb112d14d3f4fcb16b165f7dbaf76c70ba6e82f37ba042bdab51970a0b8", size = 2449947, upload-time = "2026-10-11T18:32:58.896Z" },+ { url = "https://files.pythonhosted.org/packages/a8/ac/1b677db91eba54cc5922f4de6edc46ba45c2bd712dfdc0130382d158e214/pydantic_core-2.50.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:1c96fd793b73d1b92e65570132505498fe7b21eaef73cdf74e67e5dfba7ac9e4", size = 2476889, upload-time = "2026-10-11T18:33:00.665Z" },+ { url = "https://files.pythonhosted.org/packages/4d/2a/3a9f6624ee3ea9ccba5249dde11418bb4c35780a7a92608f8768bd3fea39/pydantic_core-2.50.1-cp313-cp313-win32.whl", hash = "sha256:06ead20d39ffd6f2f6f2a8f8a6de67ff8bb1b4f14a8a30e058502514ee2ac685", size = 2101118, upload-time = "2026-10-11T18:33:02.329Z" },+ { url = "https://files.pythonhosted.org/packages/2d/1f/323f78ddd9d9938aac420c1abb4e8ba799fc8bdab0acc67c0593b837c979/pydantic_core-2.50.1-cp313-cp313-win_amd64.whl", hash = "sha256:7816e98acc08119dc0f340ab167048ecc54126316330c1f0caf7c6756c88e28f", size = 2170840, upload-time = "2026-10-11T18:33:03.919Z" },+ { url = "https://files.pythonhosted.org/packages/cb/09/8497c52a739ae425c3ac2f7f56414cbc711c67d374346174f40fe2062644/pydantic_core-2.50.1-cp313-cp313-win_arm64.whl", hash = "sha256:c17799a62c142d61b8a3c51752a7cbc87fe2ad4ccfab10e628a77b405075c662", size = 2161633, upload-time = "2026-10-11T18:33:05.518Z" },+ { url = "https://files.pythonhosted.org/packages/49/33/28b96e81677153715e3eafb9f26663a80841e859fde282a380359b0d3fa1/pydantic_core-2.50.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:1cf41f1ae3fa155cf167a72689ad044bcc1e3c97e064123677149bdfb5dafc4a", size = 2224428, upload-time = "2026-10-11T18:33:07.153Z" },+ { url = "https://files.pythonhosted.org/packages/94/40/15c06410c9b7b8da5805d27b64e09bd3f900e986728106db2689dbc51513/pydantic_core-2.50.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4df197990c15b5a37c5a277d131d9f2c67de6133f2e5dafd80d9bba4b99f46f9", size = 2023740, upload-time = "2026-10-11T18:33:08.763Z" },+ { url = "https://files.pythonhosted.org/packages/a1/4e/5eb629f6efc2a27e421d789dd4bfacbb5f6d09c80c28b13d1e87d73163d5/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0036473f5583e6a60e50b8b21651511564277a3f05cc5dab8cf579f552cd5f6c", size = 2049435, upload-time = "2026-10-11T18:33:10.366Z" },+ { url = "https://files.pythonhosted.org/packages/ba/8e/f195aebec49ad12318876ac2368c197a7939f5d52f8e156d2238ef8a4588/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:992c3514ec891fa7858099183e4d64e6bd5a5d4ff452fae29df22faa77a006bb", size = 2172975, upload-time = "2026-10-11T18:33:12.368Z" },+ { url = "https://files.pythonhosted.org/packages/e0/f5/7ad9fb83010cd5ea0948409db105676ed779c4e709e2d3d89b9fe2558794/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:739dc730e6be3bd5ec2f4ab5cfc7eb047cc45fc1497b3bafec74ff2ed07df597", size = 2364197, upload-time = "2026-10-11T18:33:14.244Z" },+ { url = "https://files.pythonhosted.org/packages/ca/fb/bf0aab3e78301d202b82a0322ec968cd703b11fc0623fde9a28708936f62/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:32fad3a91e51b6d2039c572db04a5a873260b399f6bd62c3552671fa7a4a2899", size = 2444259, upload-time = "2026-10-11T18:33:15.79Z" },+ { url = "https://files.pythonhosted.org/packages/45/35/38f6d6564fae57d9b12e5676dfa947e0e7d5c46dbeaa7eb3352261d6d299/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42b54c2c90ad348b5e3a85e03e715d572c1fde357ef104cdfe3b03b697a404ea", size = 2159857, upload-time = "2026-10-11T18:33:17.51Z" },+ { url = "https://files.pythonhosted.org/packages/65/a0/fb0a3ca10f139dcf765b2d312d10cf0f65c57c59993229d00ad12b14ceff/pydantic_core-2.50.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:2df1ff41884de2bc4b307bafd7c40a691094fad2ff8e767e5b45a319257bcf4e", size = 2233954, upload-time = "2026-10-11T18:33:19.591Z" },+ { url = "https://files.pythonhosted.org/packages/8c/6a/e63842252702aa4ec6e6b7178ca85e541a77459076592c23ebe2d9840b33/pydantic_core-2.50.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe90228920fd8ff2be62622b6bb8a2b11acd65046d50c6b130614b5879605a20", size = 2243876, upload-time = "2026-10-11T18:33:21.393Z" },+ { url = "https://files.pythonhosted.org/packages/39/25/5991cf8318b37e0dfab47b87541619a1df8501a793cba0d978846cba37a7/pydantic_core-2.50.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:844b869f118e22a41a091bdcedda8a71bc1b0f62c38d1a0c3211cece47e1d8fc", size = 2277908, upload-time = "2026-10-11T18:33:23.324Z" },+ { url = "https://files.pythonhosted.org/packages/a7/3e/3ee8baaa6cc25a6961c69168cf9ff0f002d56f4e0d541ad6724c18fb61f3/pydantic_core-2.50.1-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:2eb75304506894a281d346220a4f7481a1b8729577c5ed2a05395991966a8396", size = 2449285, upload-time = "2026-10-11T18:33:24.942Z" },+ { url = "https://files.pythonhosted.org/packages/c0/c7/acbec6deac13fe697a80c275a9b6661db62c4d323bac8a47347b1f39c7cd/pydantic_core-2.50.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:6b20a4bffabdad0db2927ac034ae3b8a681b1f7a0182f3e60b479ad2fde21ebb", size = 2479013, upload-time = "2026-10-11T18:33:26.925Z" },+ { url = "https://files.pythonhosted.org/packages/10/08/21a3f237b264389f6219d053ee78fc1b5c2fd402c1b1cb2b6cb8b85f9834/pydantic_core-2.50.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:99ba9bc2b8062ea0c326a990f7f00e6530c23579de66dd246e72c4cafef950a5", size = 1484400, upload-time = "2026-10-11T18:33:28.693Z" },+ { url = "https://files.pythonhosted.org/packages/09/ce/077a6d262d12ef09108377ac0717f029f420d773ace63cafd6143af75568/pydantic_core-2.50.1-cp314-cp314-win32.whl", hash = "sha256:cf356f70551d40374eaffb1aa63f1eb6d2006681cbd7a9faea173ce0f4dd7cd2", size = 2103222, upload-time = "2026-10-11T18:33:30.326Z" },+ { url = "https://files.pythonhosted.org/packages/14/4c/350a2415209c43d670eb71d3c040f332c04a30583d39e311b05c7ac15762/pydantic_core-2.50.1-cp314-cp314-win_amd64.whl", hash = "sha256:d32f3acc081cc3923386d88f422cde8892335e95f034e0104bb4cf9310d9915f", size = 2171586, upload-time = "2026-10-11T18:33:32.139Z" },+ { url = "https://files.pythonhosted.org/packages/bf/92/9bea6ca96580a0902fed366f064f0829e404f41889b34543279a1162b888/pydantic_core-2.50.1-cp314-cp314-win_arm64.whl", hash = "sha256:bed5163e03b98bc1fa2eb05d74c63d9c5c95d8ed6254985481640fbf5e237dea", size = 2155773, upload-time = "2026-10-11T18:33:33.896Z" },+ { url = "https://files.pythonhosted.org/packages/86/8c/f121f073cf32bdd5cba7e6230b1ce0ac845b0cf43e44dd597d95af272db2/pydantic_core-2.50.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:9572c1369e9c9da2d64a7b7992c786d90ff295abc93964cfe3125e4290768070", size = 2234017, upload-time = "2026-10-11T18:33:35.588Z" },+ { url = "https://files.pythonhosted.org/packages/a4/69/2bb2bcd6146cffe98d760a46c42ae71efd5151d9b2f9c9bf6619a3b32083/pydantic_core-2.50.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2005207aafe1231315718bf6ed5d064a7300fb4772754af35ee72fc68159492e", size = 2001016, upload-time = "2026-10-11T18:33:37.57Z" },+ { url = "https://files.pythonhosted.org/packages/20/b3/fbf854c7d07ec114260c26e9e2071a4381740f9ae09641dbfcbdf2a18c45/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64f6047f62a6c5ae08d0a6afb035667aa2d97c3d20d69762e034c5ea144d92a5", size = 2023015, upload-time = "2026-10-11T18:33:39.433Z" },+ { url = "https://files.pythonhosted.org/packages/65/20/6de55b2f92cdb614b745c6e9ced639fc4fd7e1e77604825a88bdece6fcbd/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ef800dd7d85bcdadf4c3076e4c94e43939493558a3b69a1ea830c706d4617bb", size = 2192543, upload-time = "2026-10-11T18:33:41.381Z" },+ { url = "https://files.pythonhosted.org/packages/0c/d9/19e91c94bd5c405945ce2f15526808aea37e162c253160de8ed7bf70b406/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b0135bcdcaa0f23573f286e4cb5e0fd2962700964ed13df085b85f2b97aeab9e", size = 2388704, upload-time = "2026-10-11T18:33:43.167Z" },+ { url = "https://files.pythonhosted.org/packages/b6/bc/2e24c8415eae1a25ee5a5484946a917123bad2e9d01689a759236928175a/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0b3a6f334c6a2345ca15318ff894502a90012536404b37c844a976c76c846e0b", size = 2464118, upload-time = "2026-10-11T18:33:44.856Z" },+ { url = "https://files.pythonhosted.org/packages/bd/1f/945b8053cb061c64e102bcaf7bfb9ed740c0bd4349f9bb978a7d4ddff4ab/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06e01fbbfdb9be777b316a71b6c49efaf4a08b615d0a98d678cda3023f79d019", size = 2150142, upload-time = "2026-10-11T18:33:46.661Z" },+ { url = "https://files.pythonhosted.org/packages/2b/78/96a3e50bf0d64aaae781107eb9335b7529d05a85793ed6e7241c4cd1d931/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:a29a061fec0b4e2d714f277e70a3a18125ecff803f2fea6eade2f2e53711d112", size = 2245577, upload-time = "2026-10-11T18:33:48.574Z" },+ { url = "https://files.pythonhosted.org/packages/7a/5d/a6038a0322232758a6ebfa709f4ca14a60bf5b93940cd0b345056a557da4/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f5187624823423e1d1b82b1072ac41dc837389e18d3d0572cc19bbee46cd550a", size = 2263728, upload-time = "2026-10-11T18:33:50.527Z" },+ { url = "https://files.pythonhosted.org/packages/0d/4b/76ded3333a457a9344c4f2d63f2d82d0101654b05178fa4ddfe7d3627674/pydantic_core-2.50.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3e46a9eb0a0901dd6275e6b06ac3a464885ef350ec4121fe486869de8053e4bb", size = 2293630, upload-time = "2026-10-11T18:33:52.362Z" },+ { url = "https://files.pythonhosted.org/packages/a9/00/9eca378335c9c1b72bc779bf6e4c2a82ce784f14ec48a0e87102c9870e05/pydantic_core-2.50.1-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:756d669f04e62ec4148ecfe22be6a4484d9b1181a6ef32e205ebfd200540858b", size = 2468048, upload-time = "2026-10-11T18:33:54.118Z" },+ { url = "https://files.pythonhosted.org/packages/35/ca/e3832e9cf93651251de43c8c5c029ed680a3c1a0a1b17ee26c81bed08cbd/pydantic_core-2.50.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:c516cc5367ca3448995d42cb994bf3f4c9002d2a7c22eac9622551269ad1b807", size = 2512159, upload-time = "2026-10-11T18:33:55.99Z" },+ { url = "https://files.pythonhosted.org/packages/4b/f2/773469b5a10a39116a2cb17edaf6d722f017dd8da07161b371465311c542/pydantic_core-2.50.1-cp314-cp314t-win32.whl", hash = "sha256:9d1bed94af6a63835461f3cf7502058eb166c58c4778e11d0f433cfb1bd69e19", size = 2098406, upload-time = "2026-10-11T18:33:58.043Z" },+ { url = "https://files.pythonhosted.org/packages/ee/42/0bb74f8f25204b259b11ab7c12dc7f180893b6bd706118b385147fb6efd5/pydantic_core-2.50.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c8dce1f1e0e5358b682a6ad3fa5e31b31d4560997b8e61417e9217c8d60f8a0c", size = 2148481, upload-time = "2026-10-11T18:33:59.913Z" },+ { url = "https://files.pythonhosted.org/packages/47/0d/d801646c9679a4e630e15cf521d4108b93854b42a6e6e02391bd4c6b1095/pydantic_core-2.50.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ceff0acc940be2715bd6ad17b24c0e5304abf44f6efd0f81ee8499e640f9dc86", size = 2174972, upload-time = "2026-10-11T18:34:01.875Z" },+ { url = "https://files.pythonhosted.org/packages/b2/84/23984b763d8862a02a13d27a44b6e8169428fd85ecfed88f54c29108604d/pydantic_core-2.50.1-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:8a6791afa2245e6c6b180122d105941644f5bd410bb18623b408808cc41a3102", size = 2224599, upload-time = "2026-10-11T18:34:04.016Z" },+ { url = "https://files.pythonhosted.org/packages/4d/90/a63cf8586abc1d1a3f6d9b18f0224789ebf003851f092ebda3c7c863fd32/pydantic_core-2.50.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:84f34323a61a365b4e9295de6028474754829aaddd59c7bf1a040e7487ef8f3c", size = 2024191, upload-time = "2026-10-11T18:34:05.901Z" },+ { url = "https://files.pythonhosted.org/packages/a6/6a/f34bff9808ffb4907fbf5f5040457d253cacf2da7fce9efbc99ca1b1a44d/pydantic_core-2.50.1-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23edad659e8dbd8ca7e4e877fe6c81573abbdf215bd25a68b53e1272f58b80c7", size = 2048252, upload-time = "2026-10-11T18:34:07.757Z" },+ { url = "https://files.pythonhosted.org/packages/b2/54/13f419bf1eb59852003818e25935aaf175687d978f4c4bca70e08fe40a3b/pydantic_core-2.50.1-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a5fce22f1e87d181e924e12da7d81cfe031fb3881a5ddf26ad28f141756ca43", size = 2173376, upload-time = "2026-10-11T18:34:09.592Z" },+ { url = "https://files.pythonhosted.org/packages/6d/6c/b5a34d24cd0c81669d8f8339d74e6815abcf2f8fb48ab4b49b84c09be1d5/pydantic_core-2.50.1-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c73622ef819328873b53109ee4f77ceb598bffedd02daf916102be3228866b78", size = 2364559, upload-time = "2026-10-11T18:34:11.534Z" },+ { url = "https://files.pythonhosted.org/packages/eb/8d/d64d6216a8df365082665927ff923f183056f9049fee08e9777c9ac05296/pydantic_core-2.50.1-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce8c25ca38cc0e3d7753ba180808de2c0c8cb24eae0df64491e40921454e9831", size = 2444697, upload-time = "2026-10-11T18:34:13.535Z" },+ { url = "https://files.pythonhosted.org/packages/b8/0d/1b1149f60a00ea21ba5f70e28acbd40feb4598af414f80f53c921fac07c9/pydantic_core-2.50.1-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7689580e72a642ab5ec64d5f55b2e33636fa43b4ebe63c0c2c965ef307c7d1aa", size = 2159961, upload-time = "2026-10-11T18:34:15.56Z" },+ { url = "https://files.pythonhosted.org/packages/1e/35/f236549299dcc78e71e945495d7ec67e78d20844d0999c60601685003031/pydantic_core-2.50.1-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:d5c0e32fdbce7f1e8ef4d11f655694bf5f4175c757a9f1dc2be09b8864e5bcf5", size = 2234581, upload-time = "2026-10-11T18:34:17.502Z" },+ { url = "https://files.pythonhosted.org/packages/6a/85/26901a490522b7f75ef9bb9a7afb73e5bb550f0e1cb5b99a0069183e2eb9/pydantic_core-2.50.1-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:40f523349960fa30f3ea51404308ff50f9997a90df639590f47a057c1f32b415", size = 2244090, upload-time = "2026-10-11T18:34:19.402Z" },+ { url = "https://files.pythonhosted.org/packages/ca/2c/481bcfc70ceeb77a778ca6e5b705fe592cb64735c108157f81b7dd9c280e/pydantic_core-2.50.1-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:d4193206b6587047437f6f11d7e776df23e1c1e23af2a54d9347275614791e10", size = 2277948, upload-time = "2026-10-11T18:34:21.317Z" },+ { url = "https://files.pythonhosted.org/packages/24/eb/f1e09333faa7ba447cde967310f758430cc7c5e987bdab5228816c70030d/pydantic_core-2.50.1-cp315-cp315-musllinux_1_1_armv7l.whl", hash = "sha256:84bc765b282a9d5b7fe0348b8648904f25a6a04b2139da52b1dd30c8ac3a2c8f", size = 2449688, upload-time = "2026-10-11T18:34:23.321Z" },+ { url = "https://files.pythonhosted.org/packages/d1/b3/036bde636db8f76d92996e81aefc75678ab5cec4a07eea1ad0c72a893fc3/pydantic_core-2.50.1-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:ed1e728b39a383c81035b2459cfcb35d99dfb01f7d6ebe3a913bc1cc5b81e459", size = 2479286, upload-time = "2026-10-11T18:34:25.214Z" },+ { url = "https://files.pythonhosted.org/packages/d0/a3/07f018294ee18d144afeb6df1a47d9e92960f014be45c5ed13519fa5af95/pydantic_core-2.50.1-cp315-cp315-win32.whl", hash = "sha256:bc94f474417604bd383d2cd445d071b07dd55fedceed3ce33407bf1fcc107290", size = 2103683, upload-time = "2026-10-11T18:34:27.42Z" },+ { url = "https://files.pythonhosted.org/packages/5f/98/f9bd7e1f9b6709f155acb9ef826d9c3884fe925f811fd8e55b9b52280bad/pydantic_core-2.50.1-cp315-cp315-win_amd64.whl", hash = "sha256:983a662de2571cb2502fc8ff47b6770b03d025d2eb314c92f77b3f07c74720ed", size = 2171681, upload-time = "2026-10-11T18:34:29.508Z" },+ { url = "https://files.pythonhosted.org/packages/10/87/4bb3e1e7f385c076ab5af4d6dd0571b22042cd8207eb810d5b9fef15ae31/pydantic_core-2.50.1-cp315-cp315-win_arm64.whl", hash = "sha256:94845ff54dc5193f228cab81b2662a04bfbb892e95bdc15edf7399000ce57d54", size = 2156251, upload-time = "2026-10-11T18:34:31.455Z" },+ { url = "https://files.pythonhosted.org/packages/47/47/83643225b08f2aef6c8cc4bbe6e3f79c5e139c4364a6e450d0f399d87774/pydantic_core-2.50.1-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:4a53d13cdfbedbfa87f08b83c1a0a5efcc767d785a4b41934fa9cb672670493a", size = 2234363, upload-time = "2026-10-11T18:34:33.65Z" },+ { url = "https://files.pythonhosted.org/packages/5e/66/127ca649ba2f2462039dc1e694c6c01e00a3689f023a617364d3507e6d97/pydantic_core-2.50.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:efbecf43d321f7b9281441f1f213f7c21c66988b0e06c2730ba13ed47a46bb08", size = 2000972, upload-time = "2026-10-11T18:34:36.037Z" },+ { url = "https://files.pythonhosted.org/packages/5e/4f/e421e0a5d653b1203b090b2e48745976988d7338a647940704b5b9c2b399/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc1f08f68dac9f9e83845a8039880aba2ab553eb9b2259c3243a313182c253fe", size = 2022925, upload-time = "2026-10-11T18:34:37.972Z" },+ { url = "https://files.pythonhosted.org/packages/d5/4e/ea5568e2491e1a71100f15ae8c2d01ef52db42a184a2d4e716bc79e5eb8f/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5dfe41f232befddb9c4377f6cfc702b51595e2d78ed082672adf8758d2c4619f", size = 2192867, upload-time = "2026-10-11T18:34:39.921Z" },+ { url = "https://files.pythonhosted.org/packages/ae/5e/3b8c3a35acbe219909ada5defad5d7d9fed845fb2b37bd5ec518f453c119/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:adc06d218a1cadfd2ec4628424d7d79ce4eba69c2965e7e7b55106f0da5208c8", size = 2388687, upload-time = "2026-10-11T18:34:42.184Z" },+ { url = "https://files.pythonhosted.org/packages/b6/aa/7889b4e515f91a2e8c0ae6b5081fec0feb30c4398d1434e14793c60f173a/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2cf91809d0721ab81592ba67bea7694821679c10b1a2e3c3460082b286c1918a", size = 2464415, upload-time = "2026-10-11T18:34:44.384Z" },+ { url = "https://files.pythonhosted.org/packages/08/78/93449e628eb8a6fdcce3eff9043081179d1bc7ce6f1bff32dc5006f41e00/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23923ab9292c40da026330b1ecf4dc2618c8e86e0422e5d1fbf50d94d64ca4f8", size = 2150823, upload-time = "2026-10-11T18:34:46.392Z" },+ { url = "https://files.pythonhosted.org/packages/f4/f1/72c5bc129fceb0d00f05dc1e67f518c1728de1928c55f81fc13d7690de39/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:f3377c8c2b3ce898423c5e5dd94c7982e30aa7717a7e6ab2470b9de364963709", size = 2245806, upload-time = "2026-10-11T18:34:48.805Z" },+ { url = "https://files.pythonhosted.org/packages/28/2a/922a0e78f3aa6ab837b59f88190233fb8dad546c17995fde9bb3ed3b9b49/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:455a773617b5913bf5c20d0692e5787b119e52c4d40ea644ca31f5758fd31be2", size = 2264160, upload-time = "2026-10-11T18:34:50.876Z" },+ { url = "https://files.pythonhosted.org/packages/52/a8/0f1449e3e1b20941c9372faa18e7b6a092e30cdfa841902473f7989532ac/pydantic_core-2.50.1-cp315-cp315t-musllinux_1_1_aarch64.whl", hash = "sha256:1a9006395dece0e32e704c315eff8a00bede494f6108546cfc5539c89fef4f9a", size = 2294031, upload-time = "2026-10-11T18:34:52.876Z" },+ { url = "https://files.pythonhosted.org/packages/d1/d0/1031f492857de70355fb16524bbb03efce5fd34c93ed4a1ec60be07e0d4b/pydantic_core-2.50.1-cp315-cp315t-musllinux_1_1_armv7l.whl", hash = "sha256:d2d82aa62521c55ddfb000ae70f88cdd8de974078f6024e821dfe5addd0c818f", size = 2468423, upload-time = "2026-10-11T18:34:54.995Z" },+ { url = "https://files.pythonhosted.org/packages/46/52/269ffffa645b8e47906395a39cf9db1151ae9fa4bcd7f47b960bc31baf37/pydantic_core-2.50.1-cp315-cp315t-musllinux_1_1_x86_64.whl", hash = "sha256:009634b83993777ddcd69cad0ffcace43dabde692109528e35f0fde91e386a8b", size = 2512598, upload-time = "2026-10-11T18:34:57.149Z" },+ { url = "https://files.pythonhosted.org/packages/31/5c/e47e28281f20326ff6f3c31d626f0a83e615d2d94ba41bb0ad6ec237184a/pydantic_core-2.50.1-cp315-cp315t-win32.whl", hash = "sha256:3fde4fdc6487a58d944ca87cf5adc95d5f266e872c19599f5f4c0a8a1b1f9f9f", size = 2098535, upload-time = "2026-10-11T18:34:59.313Z" },+ { url = "https://files.pythonhosted.org/packages/03/ad/759e181e69c1b472c60b2049e5f61d5da1deefdd5ce1df4bb2ebcf771f25/pydantic_core-2.50.1-cp315-cp315t-win_amd64.whl", hash = "sha256:1c8632d4ac04e6f91128fca584b3a8a507d81604c24eeaaad00d4be42765c32b", size = 2148645, upload-time = "2026-10-11T18:35:01.571Z" },+ { url = "https://files.pythonhosted.org/packages/6d/56/8a702c27e5be9f47e5f19d8669227424290e4c024e7c370279cbaf244b4e/pydantic_core-2.50.1-cp315-cp315t-win_arm64.whl", hash = "sha256:c3ede305158e75510be50869b319550ab072008c13d64d4ab1e094fb286b6f44", size = 2175297, upload-time = "2026-10-11T18:35:04.079Z" },+ { url = "https://files.pythonhosted.org/packages/a5/09/1bcf160f3cd6333e2a76982fae5963e5032de0bcaaba38464223dc266bfe/pydantic_core-2.50.1-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:76e2e83fa6ec8cdc972d438dafc2522b3a47bee4ec0ae668b29cfb1977ab5242", size = 2217070, upload-time = "2026-10-11T18:35:15.688Z" },+ { url = "https://files.pythonhosted.org/packages/3d/81/f02de95eec7794dfc7a5bc69a834f0e834b31b3009014ce6de903855f775/pydantic_core-2.50.1-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:a51eee75939cf811ac09b278745a6cee7dc873ccfbc8b9af3cc88fe4b7ce25b5", size = 2039027, upload-time = "2026-10-11T18:35:18.07Z" },+ { url = "https://files.pythonhosted.org/packages/4d/16/227746ed3771d9bf2304568b55134849ece34e13b38b1d76de763015c77f/pydantic_core-2.50.1-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ae28183297fb0d2b8dc46a1f01d51f5e45825fc5afe76a835a6cb7fb34821295", size = 2109009, upload-time = "2026-10-11T18:35:20.218Z" },+ { url = "https://files.pythonhosted.org/packages/e5/b9/7664d1592a0e5a74903f357cd5b28ceb7336f3473256c5a4e8c8432f1881/pydantic_core-2.50.1-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88e492e8b9d0312e7dc13667c30222abf284dc3b79b5302b3607b41a5784ce61", size = 2269883, upload-time = "2026-10-11T18:35:22.48Z" },+]++[[package]]+name = "pygments"+version = "2.21.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },+]++[[package]]+name = "pytest"+version = "9.1.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "colorama", marker = "sys_platform == 'win32'" },+ { name = "iniconfig" },+ { name = "packaging" },+ { name = "pluggy" },+ { name = "pygments" },+]+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },+]++[[package]]+name = "python-dateutil"+version = "2.9.0.post0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "six" },+]+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },+]++[[package]]+name = "s3transfer"+version = "0.19.3"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "botocore" },+]+sdist = { url = "https://files.pythonhosted.org/packages/49/c5/0a5ce655109cb96b8dfad36908a4e108d15f5dc2eff8fbc3146c4312e704/s3transfer-0.19.3.tar.gz", hash = "sha256:8326acc3d056d7f7b8a37110c7d2aea41f67e83f6ae79cd3b5fbcca34c726406", size = 166087, upload-time = "2026-10-19T19:19:49.751Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/e2/a4/88f9e10498759121060b8050a1554753dfc04df39bbbcc7aad9ecc8d9440/s3transfer-0.19.3-py3-none-any.whl", hash = "sha256:24eb7535804306355e31c952a90022bf5b2f9d760f9a11062c7493a217c08553", size = 90252, upload-time = "2026-10-19T19:19:48.309Z" },+]++[[package]]+name = "six"+version = "1.17.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },+]++[[package]]+name = "sniffio"+version = "1.3.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },+]++[[package]]+name = "starlette"+version = "1.10.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "anyio" },+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },+]+sdist = { url = "https://files.pythonhosted.org/packages/48/bb/3d8757f21e9a53d9035c9eb039a777047139a16bfdbedfc7a58241c3d914/starlette-1.10.0.tar.gz", hash = "sha256:b8399098d4c1e3522734f7235dc79b1fc967f96cf139c81e0fa30479e0685f9b", size = 2734356, upload-time = "2026-10-24T15:04:12.342Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/88/2e/947cfe02def9371c07cd5bf5b6b61c829e9aecb9904db02a66cfafbc1eec/starlette-1.10.0-py3-none-any.whl", hash = "sha256:478c0ab3b4ced6e82719849c118fa406f0278a3499c1a898cd15cd31bdc38ce4", size = 80571, upload-time = "2026-10-24T15:04:10.371Z" },+]++[[package]]+name = "switch-decision"+version = "0.1.0"+source = { editable = "." }+dependencies = [+ { name = "anthropic" },+ { name = "boto3" },+ { name = "fastapi" },+ { name = "httpx" },+ { name = "pydantic" },+ { name = "uvicorn" },+]++[package.dev-dependencies]+dev = [+ { name = "pytest" },+]++[package.metadata]+requires-dist = [+ { name = "anthropic", specifier = ">=2.3.0" },+ { name = "boto3", specifier = ">=1.43.117" },+ { name = "fastapi", specifier = ">=0.115" },+ { name = "httpx", specifier = ">=0.27" },+ { name = "pydantic", specifier = ">=2.7" },+ { name = "uvicorn", specifier = ">=0.30" },+]++[package.metadata.requires-dev]+dev = [{ name = "pytest", specifier = ">=9.1.1" }]++[[package]]+name = "truststore"+version = "0.10.5"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/ee/9f/c5201d42a484c061e528825fc8e2d565f5abd50a4ced6fb7d29c4ec99b2b/truststore-0.10.5.tar.gz", hash = "sha256:30d36967ccaded5cbb38d602c433f53600036c79d502f4533a49b60a03bbefcd", size = 28091, upload-time = "2026-10-12T22:27:31.808Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/51/e9/3a7820be2bb0fe53b6bc9c3be26d3d1158004e4c3ab953aa6840b955b1e9/truststore-0.10.5-py3-none-any.whl", hash = "sha256:9aaaedaefaf06d8b206278cf8b5012bc897f485a874503501e12d776df78951c", size = 19017, upload-time = "2026-10-12T22:27:30.377Z" },+]++[[package]]+name = "typing-extensions"+version = "4.16.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },+]++[[package]]+name = "typing-inspection"+version = "0.4.4"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147", size = 14750, upload-time = "2026-08-12T12:37:24.648Z" },+]++[[package]]+name = "urllib3"+version = "2.8.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" },+]++[[package]]+name = "uvicorn"+version = "0.54.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "click" },+ { name = "h11" },+]+sdist = { url = "https://files.pythonhosted.org/packages/da/34/30e9280707135d2cfc589dfff3cb796bd07a3aeb1a3e415ba09dd89d7bb4/uvicorn-0.54.0.tar.gz", hash = "sha256:a2e33cbfaa0306f8e6b0c13e0cb89d7d7a2da3e62b90c66e18c33d9807b28620", size = 112283, upload-time = "2026-09-25T06:52:37.601Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/38/0c/b54a4fdd7f90a3af8b02ebc9ce6712c2c208b7926a2f7bad95c33ebbe943/uvicorn-0.54.0-py3-none-any.whl", hash = "sha256:505bdb0f318731d45f1f712071fc781a8981f6847a31c902c9f5e652d4f67faf", size = 87427, upload-time = "2026-09-25T06:52:35.829Z" },+]