slice-gateway 0.2.2__tar.gz → 0.2.3__tar.gz

{slice_gateway-0.2.2 → slice_gateway-0.2.3}/MANIFEST.in

@@ -1,5 +1,6 @@
-# The slice-gateway distribution is the CLI only. Keep the sdist to the CLI module,
-# its PyPI readme, the license, and build metadata. Nothing from the server repo.
+# The slice-gateway distribution is the CLI plus the standalone MCP server. Keep the sdist
+# to those two, the PyPI readme, the license, and build metadata. Nothing else from the
+# server repo (mcp_server is kept, so it is not pruned here).
 prune tests
 prune app
 prune infra
@@ -12,7 +13,6 @@ prune demo
 prune scripts
 prune guardrails
 prune docs
-prune mcp_server
 prune gateway
 prune pipeline
 prune rag_store

{slice_gateway-0.2.2/slice_gateway.egg-info → slice_gateway-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slice-gateway
-Version: 0.2.2
+Version: 0.2.3
 Summary: Command-line client for slice, the self-hosted LLM gateway.
 Author: Jishnu Janardanan
 License-Expression: MIT
@@ -15,6 +15,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: typer
 Requires-Dist: httpx
+Requires-Dist: mcp<2,>=1.9
 Dynamic: license-file
 
 # slice-gateway
@@ -43,12 +44,24 @@ This package installs the `slice` command. It logs you in through GitHub, then p
 
 Run `slice use anthropic`, `slice use openai`, `slice use curl`, or `slice use claude-code` to print the exact lines for your tool.
 
+## Claude Code MCP
+
+This package also installs `slice-mcp`, a stdio MCP server. Add it to Claude Code with one command:
+
+    claude mcp add slice -s user -e SLICE_API_KEY=slk_live_... -- slice-mcp
+
+It exposes six read and write tools over your slice account: check spend against budget, list recent requests, show the eval pass rate, and list, add, or delete model-routing rules. It talks to the hosted gateway by default; set `SLICE_BASE_URL` for a self-hosted one.
+
 ## The gateway
 
 This is only the client. The slice gateway itself, the server that does the routing, caching, budgets, and dashboards, lives on GitHub at https://github.com/jjk30/slice.
 
 Homepage: https://sliceapp.dev
 
+## What's new in 0.2.3
+
+The package now installs `slice-mcp`, the slice MCP server, so `pipx install slice-gateway` gives you both the CLI and the Claude Code integration. See the Claude Code MCP section above.
+
 ## What's new in 0.2.2
 
 `slice login` now ends by printing your dashboard link and opening it in the browser.

{slice_gateway-0.2.2 → slice_gateway-0.2.3}/PYPI.md

@@ -24,12 +24,24 @@ This package installs the `slice` command. It logs you in through GitHub, then p
 
 Run `slice use anthropic`, `slice use openai`, `slice use curl`, or `slice use claude-code` to print the exact lines for your tool.
 
+## Claude Code MCP
+
+This package also installs `slice-mcp`, a stdio MCP server. Add it to Claude Code with one command:
+
+    claude mcp add slice -s user -e SLICE_API_KEY=slk_live_... -- slice-mcp
+
+It exposes six read and write tools over your slice account: check spend against budget, list recent requests, show the eval pass rate, and list, add, or delete model-routing rules. It talks to the hosted gateway by default; set `SLICE_BASE_URL` for a self-hosted one.
+
 ## The gateway
 
 This is only the client. The slice gateway itself, the server that does the routing, caching, budgets, and dashboards, lives on GitHub at https://github.com/jjk30/slice.
 
 Homepage: https://sliceapp.dev
 
+## What's new in 0.2.3
+
+The package now installs `slice-mcp`, the slice MCP server, so `pipx install slice-gateway` gives you both the CLI and the Claude Code integration. See the Claude Code MCP section above.
+
 ## What's new in 0.2.2
 
 `slice login` now ends by printing your dashboard link and opening it in the browser.

slice_gateway-0.2.3/mcp_server/__init__.py

@@ -0,0 +1,23 @@
+"""slice MCP server (phase 14).
+
+A standalone stdio MCP server that exposes slice's data as tools inside Claude Code.
+It is a *thin adapter* over slice's existing HTTP gateway: it makes short async httpx
+calls to the running gateway and shapes the JSON into compact, human-readable text. It
+holds no gateway logic, no database access, and no business rules of its own: every
+number it reports comes from an endpoint the gateway already serves.
+
+Run it as ``python -m mcp_server`` (stdio). Configuration is two env vars, read by
+``mcp_server.config``: ``SLICE_BASE_URL`` (default ``http://localhost:8080``) and
+``SLICE_API_KEY`` (the slice key, sent as ``Authorization: Bearer <key>``, the same way
+the phase-12 gateway auth reads it). With no key set the server still works against a
+gateway running in local/unlocked mode; a call that comes back 401 tells the user to set
+the key.
+
+Layout:
+
+- ``config``: env-driven settings.
+- ``client``: the httpx wrapper and its typed errors (unreachable / unauthorized / other).
+- ``tools``: the tool functions. Pure ``(SliceClient, args) -> str``; this is the layer
+  the tests drive with a mocked gateway. No dependency on the ``mcp`` SDK.
+- ``server``: wires the tool functions into an ``mcp`` ``FastMCP`` server as stdio tools.
+"""

slice_gateway-0.2.3/mcp_server/__main__.py

@@ -0,0 +1,21 @@
+"""Entry point: ``python -m mcp_server`` or the ``slice-mcp`` console script runs the
+slice MCP server over stdio.
+
+Reads ``SLICE_BASE_URL`` / ``SLICE_API_KEY`` from the environment (see
+``mcp_server.config``), builds the FastMCP server, and hands control to the ``mcp`` SDK's
+stdio transport. Claude Code (or any MCP client) speaks to it over stdin/stdout. Exits
+with a one-line message when ``SLICE_API_KEY`` is unset (see ``load_settings``).
+"""
+
+from __future__ import annotations
+
+from mcp_server.config import load_settings
+from mcp_server.server import build_server
+
+
+def main() -> None:
+    build_server(load_settings()).run("stdio")
+
+
+if __name__ == "__main__":
+    main()

slice_gateway-0.2.3/mcp_server/client.py

@@ -0,0 +1,136 @@
+"""The httpx wrapper around slice's gateway, with typed errors the tools turn into text.
+
+This is the only place that talks to the network. It builds one short-timeout
+``httpx.AsyncClient`` against ``SLICE_BASE_URL``, attaches the slice key on every call,
+and classifies the outcome into three failure kinds the tools can render cleanly:
+
+- ``GatewayUnreachable``: the gateway isn't answering (connection refused, DNS, a
+  timeout). The tools turn this into "slice gateway not running at <url>", never a stack
+  trace. This is by far the most common failure while developing locally.
+- ``GatewayUnauthorized``: the gateway answered 401. The slice key is missing, wrong, or
+  revoked; the tools tell the user to set ``SLICE_API_KEY``.
+- ``GatewayError``: any other non-2xx (4xx/5xx). Carries the status and the gateway's own
+  error message when it sent one, so a 404/503 surfaces the gateway's words.
+
+Nothing here raises a bare httpx exception up to the tools: ``request`` maps them all.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+
+from mcp_server.config import Settings
+
+# Short timeouts: this is a local adapter, not a long-running proxy. A gateway that is up
+# answers a read in milliseconds; one that is down should fail fast, not hang Claude Code.
+TIMEOUT = httpx.Timeout(5.0, connect=2.0)
+
+
+class GatewayUnreachable(Exception):
+    """The gateway could not be reached at all (connection error or timeout)."""
+
+    def __init__(self, base_url: str, detail: str = "") -> None:
+        self.base_url = base_url
+        self.detail = detail
+        super().__init__(f"slice gateway not reachable at {base_url}")
+
+
+class GatewayUnauthorized(Exception):
+    """The gateway answered 401: the slice key is missing, invalid, or revoked."""
+
+    def __init__(self, message: str = "") -> None:
+        self.message = message
+        super().__init__("unauthorized")
+
+
+class GatewayError(Exception):
+    """Any other non-2xx response from the gateway."""
+
+    def __init__(self, status_code: int, message: str = "") -> None:
+        self.status_code = status_code
+        self.message = message
+        super().__init__(f"gateway returned {status_code}")
+
+
+def _error_message(response: httpx.Response) -> str:
+    """Pull the gateway's own error text out of a non-2xx body, in any of its shapes.
+
+    The gateway speaks three error shapes (see ``app.auth.middleware.error_body``):
+    ``{"error": {"message": ...}}`` (admin/dashboard), the OpenAI ``{"error": {...}}``,
+    and the Anthropic ``{"error": {"type", "message"}}``. All nest the message under
+    ``error.message``, so one lookup covers them; a non-JSON body falls back to the text.
+    """
+    try:
+        body = response.json()
+    except (json.JSONDecodeError, ValueError):
+        return response.text.strip()[:200]
+    if isinstance(body, dict):
+        err = body.get("error")
+        if isinstance(err, dict) and isinstance(err.get("message"), str):
+            return err["message"]
+        if isinstance(err, str):
+            return err
+        if isinstance(body.get("detail"), str):
+            return body["detail"]
+    return ""
+
+
+class SliceClient:
+    """A thin async client for the slice gateway. Owns one httpx client for its lifetime."""
+
+    def __init__(self, settings: Settings, http: httpx.AsyncClient) -> None:
+        self._settings = settings
+        self._http = http
+
+    @property
+    def base_url(self) -> str:
+        return self._settings.base_url
+
+    @property
+    def has_key(self) -> bool:
+        return self._settings.api_key is not None
+
+    @classmethod
+    def build(cls, settings: Settings) -> "SliceClient":
+        """A client with its own httpx.AsyncClient. Close it with ``aclose``."""
+        http = httpx.AsyncClient(
+            base_url=settings.base_url,
+            headers=settings.auth_headers(),
+            timeout=TIMEOUT,
+        )
+        return cls(settings, http)
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def request(
+        self, method: str, path: str, *, params: dict | None = None, json_body: Any = None
+    ) -> Any:
+        """Make one gateway call and return parsed JSON, or raise a typed gateway error.
+
+        Every transport failure becomes ``GatewayUnreachable``; a 401 becomes
+        ``GatewayUnauthorized``; any other non-2xx becomes ``GatewayError``. A 2xx with an
+        empty or non-JSON body returns ``None`` rather than raising: a few write
+        responses carry only a short JSON object, and this stays lenient about the rest.
+        """
+        try:
+            response = await self._http.request(method, path, params=params, json=json_body)
+        except (httpx.ConnectError, httpx.ConnectTimeout, httpx.ReadTimeout) as exc:
+            raise GatewayUnreachable(self._settings.base_url, str(exc)) from exc
+        except httpx.RequestError as exc:  # DNS, protocol, pool: still "can't reach it".
+            raise GatewayUnreachable(self._settings.base_url, str(exc)) from exc
+
+        if response.status_code == 401:
+            raise GatewayUnauthorized(_error_message(response))
+        if response.status_code >= 400:
+            raise GatewayError(response.status_code, _error_message(response))
+
+        if not response.content:
+            return None
+        try:
+            return response.json()
+        except (json.JSONDecodeError, ValueError):
+            return None

slice_gateway-0.2.3/mcp_server/config.py

@@ -0,0 +1,53 @@
+"""Environment-driven configuration for the slice MCP server.
+
+Two knobs, both read from the environment at construction time so a test can set them
+with ``monkeypatch.setenv`` and build a fresh ``Settings``:
+
+- ``SLICE_BASE_URL``: where the gateway is (default ``https://api.sliceapp.dev``, the
+  hosted gateway). Point it at ``http://localhost:8080`` for a self-hosted gateway. A
+  trailing slash is trimmed so paths join cleanly.
+- ``SLICE_API_KEY``: the slice key. It rides on every gateway call as
+  ``Authorization: Bearer <key>``, the header the phase-12 auth middleware reads (see
+  ``app.auth.keys.bearer_token``). ``Settings.from_env`` leaves it unset when absent (a
+  self-hosted gateway in local/unlocked mode needs no key); the ``slice-mcp`` entry point
+  calls ``load_settings``, which requires it, since the hosted default has auth on.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass
+
+DEFAULT_BASE_URL = "https://api.sliceapp.dev"
+
+
+@dataclass(frozen=True)
+class Settings:
+    base_url: str = DEFAULT_BASE_URL
+    api_key: str | None = None
+
+    @classmethod
+    def from_env(cls, environ: dict | None = None) -> "Settings":
+        env = os.environ if environ is None else environ
+        base_url = (env.get("SLICE_BASE_URL") or DEFAULT_BASE_URL).strip().rstrip("/")
+        if not base_url:
+            base_url = DEFAULT_BASE_URL
+        key = env.get("SLICE_API_KEY")
+        key = key.strip() if isinstance(key, str) and key.strip() else None
+        return cls(base_url=base_url, api_key=key)
+
+    def auth_headers(self) -> dict[str, str]:
+        """The Authorization header the gateway expects, or nothing when no key is set."""
+        if self.api_key:
+            return {"Authorization": f"Bearer {self.api_key}"}
+        return {}
+
+
+def load_settings() -> Settings:
+    """Settings for the ``slice-mcp`` entry point. Exits with a one-line message when
+    SLICE_API_KEY is unset, since the default hosted gateway requires a slice key."""
+    settings = Settings.from_env()
+    if settings.api_key is None:
+        sys.exit("slice-mcp: set SLICE_API_KEY to your slice key (slk_live_...).")
+    return settings

slice_gateway-0.2.3/mcp_server/server.py

@@ -0,0 +1,91 @@
+"""Wire the slice tools into an ``mcp`` FastMCP stdio server.
+
+Thin on purpose: this module only maps the pure tool coroutines in ``mcp_server.tools``
+onto the official SDK's ``@mcp.tool()`` decorators, giving each the user-facing signature
+Claude Code sees (no ``SliceClient`` argument, that is supplied internally from one
+shared, long-lived client). All behavior, formatting, and error handling live in
+``tools``; nothing gateway-specific lives here.
+
+The shared ``SliceClient`` is opened when the server starts and closed on shutdown via the
+server's lifespan, so the process holds exactly one httpx client.
+"""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+
+from mcp.server.fastmcp import FastMCP
+
+from mcp_server import tools
+from mcp_server.client import SliceClient
+from mcp_server.config import Settings
+
+INSTRUCTIONS = (
+    "slice, the AI cost gateway. You're connected to a running slice gateway, so when "
+    "the user first engages, greet them warmly, mention they're connected to slice, and "
+    "offer to show how much of their monthly API budget is left (call get_spend).\n\n"
+    "What you can do here: check spend vs budget (get_spend), list/add/delete model-"
+    "routing rules (list_rules, add_rule, delete_rule), show recent requests "
+    "(get_recent_requests), and show the eval pass rate (get_eval_summary).\n\n"
+    "Write safety: add_rule and delete_rule require confirm=true to actually apply. "
+    "Without it they only preview the change and leave the gateway untouched."
+)
+
+
+def build_server(settings: Settings | None = None) -> FastMCP:
+    settings = settings or Settings.from_env()
+    # One client for the whole process. httpx builds its connection pool lazily, so
+    # constructing it here (before the event loop) is fine; the lifespan closes it.
+    client = SliceClient.build(settings)
+
+    @asynccontextmanager
+    async def lifespan(_server: FastMCP):
+        try:
+            yield {}
+        finally:
+            await client.aclose()
+
+    mcp = FastMCP(name="slice", instructions=INSTRUCTIONS, lifespan=lifespan)
+
+    @mcp.tool(description="Current-month slice spend vs budget, with the warn ratio and whether the cap is hit.")
+    async def get_spend() -> str:
+        return await tools.get_spend(client)
+
+    @mcp.tool(description="List the current switch (model-routing) rules for the slice account.")
+    async def list_rules() -> str:
+        return await tools.list_rules(client)
+
+    @mcp.tool(
+        description=(
+            "The last N slice requests (model, status, cost, routed-from, cached, time). "
+            "N defaults to 10 and is capped at 50."
+        )
+    )
+    async def get_recent_requests(limit: int = tools.RECENT_DEFAULT) -> str:
+        return await tools.get_recent_requests(client, limit)
+
+    @mcp.tool(description="The slice RAGAS eval pass-rate summary (overall and per model).")
+    async def get_eval_summary() -> str:
+        return await tools.get_eval_summary(client)
+
+    @mcp.tool(
+        description=(
+            "Add a slice switch rule routing from_model to to_model for a team. "
+            "Previews the change unless confirm=true is passed, which applies it."
+        )
+    )
+    async def add_rule(
+        team: str, from_model: str, to_model: str, confirm: bool = False
+    ) -> str:
+        return await tools.add_rule(client, team, from_model, to_model, confirm)
+
+    @mcp.tool(
+        description=(
+            "Delete a slice switch rule by its id. Previews the deletion unless "
+            "confirm=true is passed, which applies it."
+        )
+    )
+    async def delete_rule(rule_id: int, confirm: bool = False) -> str:
+        return await tools.delete_rule(client, rule_id, confirm)
+
+    return mcp

slice_gateway-0.2.3/mcp_server/tools.py

@@ -0,0 +1,323 @@
+"""The slice MCP tools: pure ``(SliceClient, args) -> str`` coroutines.
+
+This module is deliberately free of the ``mcp`` SDK so the tests can drive it against a
+mocked gateway with nothing else in the way. Each function makes one (or, for a confirmed
+write, one) gateway call through ``SliceClient`` and returns compact, human-readable text,
+never a raw JSON dump, and never an unhandled exception. Every gateway failure is caught
+and rendered by ``_gateway_error`` into a plain sentence.
+
+Endpoint map (discovered from the existing FastAPI routes, nothing here is invented):
+
+- ``get_spend``            → ``GET  /dashboard/teams``       (spend vs budget, warn ratio, cap)
+- ``list_rules``           → ``GET  /admin/rules``           (the account's switch rules)
+- ``get_recent_requests``  → ``GET  /dashboard/recent?limit=`` (latest requests)
+- ``get_eval_summary``     → ``GET  /admin/eval/summary``     (RAGAS pass rate)
+- ``add_rule``             → ``POST /admin/rules``            (confirm handshake)
+- ``delete_rule``          → ``DELETE /admin/rules/{id}``     (confirm handshake)
+
+Note (flagged for the report): ``/dashboard/recent`` does not expose ``latency_ms``: the
+column exists in the ``requests`` table but the route's SQL and response omit it. Rather
+than change an existing route, ``get_recent_requests`` reports the fields the endpoint
+does return (model, status, cost, routed-from, cached, time) and simply has no latency to
+show. Nothing was added to the gateway.
+"""
+
+from __future__ import annotations
+
+from mcp_server.client import (
+    GatewayError,
+    GatewayUnauthorized,
+    GatewayUnreachable,
+    SliceClient,
+)
+
+# Bounds on the ``limit`` a caller may pass to get_recent_requests. Clamped, not rejected:
+# a request for "too many" should still get an answer. The gateway itself caps at 200.
+RECENT_DEFAULT = 10
+RECENT_MAX = 50
+
+GatewayFailure = (GatewayUnreachable, GatewayUnauthorized, GatewayError)
+
+
+# --- error rendering ---------------------------------------------------------------
+
+
+def _gateway_error(exc: Exception, client: SliceClient) -> str:
+    """One place that turns any gateway failure into a plain, actionable sentence."""
+    if isinstance(exc, GatewayUnreachable):
+        return (
+            f"slice gateway not running at {client.base_url}. "
+            "Start the gateway (uvicorn app.main:app) or set SLICE_BASE_URL to point at it."
+        )
+    if isinstance(exc, GatewayUnauthorized):
+        if not client.has_key:
+            return (
+                "slice gateway returned 401 Unauthorized, but no SLICE_API_KEY is set. "
+                "The gateway has auth enabled: set SLICE_API_KEY to your slice key (slk_...)."
+            )
+        return (
+            "slice gateway returned 401 Unauthorized. The slice key in SLICE_API_KEY was "
+            "rejected (invalid or revoked): check the value."
+        )
+    if isinstance(exc, GatewayError):
+        detail = f": {exc.message}" if exc.message else ""
+        return f"slice gateway returned an error (HTTP {exc.status_code}){detail}."
+    return f"slice gateway call failed: {exc}"
+
+
+# --- formatting helpers ------------------------------------------------------------
+
+
+def _money(value) -> str:
+    """A dollar amount as ``$1.2345``; an em dash for an unknown (null) amount."""
+    if value is None:
+        return "-"
+    try:
+        return f"${float(value):.4f}"
+    except (TypeError, ValueError):
+        return "-"
+
+
+def _pct(value) -> str:
+    if value is None:
+        return "-"
+    try:
+        return f"{float(value) * 100:.1f}%"
+    except (TypeError, ValueError):
+        return "-"
+
+
+# --- read tools --------------------------------------------------------------------
+
+
+async def get_spend(client: SliceClient) -> str:
+    """Current-month spend vs budget, the warn ratio, and whether the cap is hit.
+
+    Reads ``GET /dashboard/teams``, whose ``budget`` block carries the live budget meter
+    for the account: recorded spend, the gate-enforced "used" figure, the cap, and dollars
+    remaining. The cap is "hit" when nothing remains; the warn threshold is
+    ``budget_usd * warn_ratio``.
+    """
+    try:
+        data = await client.request("GET", "/dashboard/teams")
+    except GatewayFailure as exc:
+        return _gateway_error(exc, client)
+    if not isinstance(data, dict):
+        return "slice returned an unexpected response for spend."
+
+    month = data.get("month", "this month")
+    budget_cap = data.get("budget_usd")
+    # Phase 25: the cap is per account; the dashboard says whether it is the config default.
+    cap_note = "  (the default cap, set your own in the dashboard's Settings)" if data.get("budget_default") else ""
+    warn_ratio = data.get("warn_ratio")
+    meter = data.get("budget") or {}
+
+    used = meter.get("budget_used_usd")
+    remaining = meter.get("remaining_usd")
+    spend = meter.get("spend_usd")
+    source = meter.get("budget_source", "unknown")
+
+    cap_hit = remaining is not None and float(remaining) <= 0
+    warn = False
+    if used is not None and budget_cap not in (None, 0) and warn_ratio is not None:
+        try:
+            warn = float(used) >= float(budget_cap) * float(warn_ratio)
+        except (TypeError, ValueError):
+            warn = False
+
+    if cap_hit:
+        status = "CAP HIT: budget exhausted, requests are being blocked"
+    elif warn:
+        status = f"WARNING: over the {_pct(warn_ratio)} warn threshold"
+    else:
+        status = "OK: under budget"
+
+    lines = [
+        f"slice spend: {month}",
+        f"  budget used:  {_money(used)} of {_money(budget_cap)}  (source: {source}){cap_note}",
+        f"  remaining:    {_money(remaining)}",
+        f"  recorded spend (Postgres): {_money(spend)}",
+        f"  warn ratio:   {_pct(warn_ratio)}",
+        f"  status:       {status}",
+    ]
+    return "\n".join(lines)
+
+
+async def list_rules(client: SliceClient) -> str:
+    """The account's current switch rules. Reads ``GET /admin/rules``."""
+    try:
+        data = await client.request("GET", "/admin/rules")
+    except GatewayFailure as exc:
+        return _gateway_error(exc, client)
+    if not isinstance(data, dict):
+        return "slice returned an unexpected response for rules."
+
+    rules = data.get("rules") or []
+    if not rules:
+        return "No switch rules configured for this account."
+
+    lines = [f"slice switch rules ({len(rules)}):"]
+    for rule in rules:
+        rid = rule.get("id", "?")
+        team = rule.get("team", "?")
+        frm = rule.get("from_model", "?")
+        to = rule.get("to_model", "?")
+        lines.append(f"  [#{rid}] team={team}: {frm} → {to}")
+    return "\n".join(lines)
+
+
+async def get_recent_requests(client: SliceClient, limit: int = RECENT_DEFAULT) -> str:
+    """The last N requests (model, status, cost, routed-from, cached, time).
+
+    Reads ``GET /dashboard/recent?limit=N``. ``limit`` is clamped to [1, 50]. Latency is
+    not reported: the endpoint does not expose ``latency_ms`` (see the module note).
+    """
+    try:
+        limit = int(limit)
+    except (TypeError, ValueError):
+        limit = RECENT_DEFAULT
+    limit = max(1, min(limit, RECENT_MAX))
+
+    try:
+        data = await client.request("GET", "/dashboard/recent", params={"limit": limit})
+    except GatewayFailure as exc:
+        return _gateway_error(exc, client)
+    if not isinstance(data, dict):
+        return "slice returned an unexpected response for recent requests."
+
+    requests = data.get("requests") or []
+    if not requests:
+        return "No requests recorded yet."
+
+    lines = [f"slice recent requests (latest {len(requests)}):"]
+    for req in requests:
+        when = req.get("created_at") or "?"
+        model = req.get("model") or "?"
+        status = req.get("status")
+        cost = _money(req.get("cost_usd"))
+        routed = req.get("routed_from")
+        flags = []
+        if routed:
+            flags.append(f"routed from {routed}")
+        if req.get("cached"):
+            flags.append("cached")
+        suffix = f"  ({', '.join(flags)})" if flags else ""
+        lines.append(f"  {when}  {model}  status={status}  cost={cost}{suffix}")
+    return "\n".join(lines)
+
+
+async def get_eval_summary(client: SliceClient) -> str:
+    """The RAGAS eval pass rate. Reads ``GET /admin/eval/summary``."""
+    try:
+        data = await client.request("GET", "/admin/eval/summary")
+    except GatewayFailure as exc:
+        return _gateway_error(exc, client)
+    if not isinstance(data, dict):
+        return "slice returned an unexpected response for the eval summary."
+
+    overall = data.get("overall") or {}
+    count = overall.get("count", 0)
+    passed = overall.get("passed", 0)
+    pass_rate = overall.get("pass_rate")
+
+    if not count:
+        return "No eval scores recorded yet (RAGAS pass rate unavailable)."
+
+    lines = [
+        "slice eval summary (RAGAS):",
+        f"  overall pass rate: {_pct(pass_rate)}  ({passed}/{count} passed)",
+    ]
+    by_model = data.get("by_model") or []
+    if by_model:
+        lines.append("  by model:")
+        for row in by_model:
+            model = row.get("model", "?")
+            lines.append(
+                f"    {model}: {_pct(row.get('pass_rate'))}  "
+                f"({row.get('passed', 0)}/{row.get('count', 0)})"
+            )
+    return "\n".join(lines)
+
+
+# --- write tools (two-call confirm handshake) --------------------------------------
+
+
+def _validate_rule(team: str, from_model: str, to_model: str) -> str | None:
+    """Reject a malformed rule up front, before any preview or write. Message or None."""
+    for name, value in (("team", team), ("from_model", from_model), ("to_model", to_model)):
+        if not isinstance(value, str) or not value.strip():
+            return f"Invalid rule: '{name}' is required and must be a non-empty string."
+    if from_model.strip() == to_model.strip():
+        return "Invalid rule: 'from_model' and 'to_model' must differ."
+    return None
+
+
+async def add_rule(
+    client: SliceClient,
+    team: str,
+    from_model: str,
+    to_model: str,
+    confirm: bool = False,
+) -> str:
+    """Add a switch rule. Previews unless ``confirm=true``; then POSTs ``/admin/rules``.
+
+    Inputs are validated before anything else, so a bad rule is rejected without a preview
+    or a call. With ``confirm`` false/omitted the tool describes exactly what would change
+    and does NOT touch the gateway. Only ``confirm=true`` sends the write.
+    """
+    error = _validate_rule(team, from_model, to_model)
+    if error is not None:
+        return error
+
+    team, from_model, to_model = team.strip(), from_model.strip(), to_model.strip()
+    detail = f"team={team}: {from_model} → {to_model}"
+
+    if not confirm:
+        return (
+            f"Would add rule: {detail}. "
+            "Call again with confirm=true to apply."
+        )
+
+    try:
+        data = await client.request(
+            "POST",
+            "/admin/rules",
+            json_body={"team": team, "from_model": from_model, "to_model": to_model},
+        )
+    except GatewayFailure as exc:
+        return _gateway_error(exc, client)
+
+    rule = data.get("rule") if isinstance(data, dict) else None
+    if isinstance(rule, dict) and rule.get("id") is not None:
+        return f"Added rule #{rule['id']}: {detail}."
+    return f"Added rule: {detail}."
+
+
+async def delete_rule(client: SliceClient, rule_id: int, confirm: bool = False) -> str:
+    """Delete a switch rule by id. Previews unless ``confirm=true``; then DELETEs it.
+
+    The id is validated (a positive integer) before anything else. With ``confirm``
+    false/omitted the tool describes what would be deleted and does NOT touch the gateway.
+    Only ``confirm=true`` sends the write.
+    """
+    try:
+        rule_id = int(rule_id)
+    except (TypeError, ValueError):
+        return "Invalid rule id: it must be an integer."
+    if rule_id <= 0:
+        return "Invalid rule id: it must be a positive integer."
+
+    if not confirm:
+        return (
+            f"Would delete rule #{rule_id}. "
+            "Call again with confirm=true to apply."
+        )
+
+    try:
+        data = await client.request("DELETE", f"/admin/rules/{rule_id}")
+    except GatewayFailure as exc:
+        return _gateway_error(exc, client)
+
+    if isinstance(data, dict) and "deleted" in data:
+        return f"Deleted rule #{data['deleted']}."
+    return f"Deleted rule #{rule_id}."

slice_gateway-0.2.3/pyproject.toml

@@ -0,0 +1,46 @@
+# Builds the `slice-gateway` distribution: the slice CLI (slice login / init / use) and
+# the standalone slice MCP server (slice-mcp). The wheel ships the slice_cli.py module and
+# the mcp_server package, and depends on typer, httpx, and mcp only. None of the server
+# stack (fastapi, langgraph, redis, torch, ...) is imported or required, and the app/
+# server package is never pulled in. Inside the repo, `python -m app.cli` still works via
+# the app/cli.py shim and `python -m mcp_server` runs the server from source.
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "slice-gateway"
+version = "0.2.3"
+description = "Command-line client for slice, the self-hosted LLM gateway."
+readme = "PYPI.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Jishnu Janardanan" }]
+dependencies = [
+    "typer",
+    "httpx",
+    "mcp>=1.9,<2",
+]
+classifiers = [
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://sliceapp.dev"
+Repository = "https://github.com/jjk30/slice"
+
+[project.scripts]
+# `slice login`, `slice init`, `slice use <tool>`. See slice_cli.py.
+slice = "slice_cli:main"
+# `slice-mcp`: the stdio MCP server. See mcp_server/__main__.py.
+slice-mcp = "mcp_server.__main__:main"
+
+[tool.setuptools]
+# Ship the CLI module and the mcp_server package, and nothing else. Listing py-modules and
+# packages explicitly disables package auto-discovery, so the app/ server package (and
+# every other repo folder) is never pulled into the wheel.
+py-modules = ["slice_cli"]
+packages = ["mcp_server"]

{slice_gateway-0.2.2 → slice_gateway-0.2.3/slice_gateway.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slice-gateway
-Version: 0.2.2
+Version: 0.2.3
 Summary: Command-line client for slice, the self-hosted LLM gateway.
 Author: Jishnu Janardanan
 License-Expression: MIT
@@ -15,6 +15,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: typer
 Requires-Dist: httpx
+Requires-Dist: mcp<2,>=1.9
 Dynamic: license-file
 
 # slice-gateway
@@ -43,12 +44,24 @@ This package installs the `slice` command. It logs you in through GitHub, then p
 
 Run `slice use anthropic`, `slice use openai`, `slice use curl`, or `slice use claude-code` to print the exact lines for your tool.
 
+## Claude Code MCP
+
+This package also installs `slice-mcp`, a stdio MCP server. Add it to Claude Code with one command:
+
+    claude mcp add slice -s user -e SLICE_API_KEY=slk_live_... -- slice-mcp
+
+It exposes six read and write tools over your slice account: check spend against budget, list recent requests, show the eval pass rate, and list, add, or delete model-routing rules. It talks to the hosted gateway by default; set `SLICE_BASE_URL` for a self-hosted one.
+
 ## The gateway
 
 This is only the client. The slice gateway itself, the server that does the routing, caching, budgets, and dashboards, lives on GitHub at https://github.com/jjk30/slice.
 
 Homepage: https://sliceapp.dev
 
+## What's new in 0.2.3
+
+The package now installs `slice-mcp`, the slice MCP server, so `pipx install slice-gateway` gives you both the CLI and the Claude Code integration. See the Claude Code MCP section above.
+
 ## What's new in 0.2.2
 
 `slice login` now ends by printing your dashboard link and opening it in the browser.

{slice_gateway-0.2.2 → slice_gateway-0.2.3}/slice_gateway.egg-info/SOURCES.txt

@@ -3,6 +3,12 @@ MANIFEST.in
 PYPI.md
 pyproject.toml
 slice_cli.py
+mcp_server/__init__.py
+mcp_server/__main__.py
+mcp_server/client.py
+mcp_server/config.py
+mcp_server/server.py
+mcp_server/tools.py
 slice_gateway.egg-info/PKG-INFO
 slice_gateway.egg-info/SOURCES.txt
 slice_gateway.egg-info/dependency_links.txt

{slice_gateway-0.2.2 → slice_gateway-0.2.3}/slice_gateway.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 slice = slice_cli:main
+slice-mcp = mcp_server.__main__:main

{slice_gateway-0.2.2 → slice_gateway-0.2.3}/slice_gateway.egg-info/requires.txt

@@ -1,2 +1,3 @@
 typer
 httpx
+mcp<2,>=1.9

slice_gateway-0.2.3/slice_gateway.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+mcp_server
+slice_cli

slice_gateway-0.2.2/pyproject.toml

@@ -1,39 +0,0 @@
-# Builds the `slice-gateway` distribution: the slice CLI only (slice login / init / use).
-# The wheel ships a single top-level module, slice_cli.py, and depends on typer and httpx
-# only. None of the server stack (fastapi, langgraph, redis, torch, ...) is imported or
-# required. Inside the repo, `python -m app.cli` still works via the app/cli.py shim.
-[build-system]
-requires = ["setuptools>=77"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "slice-gateway"
-version = "0.2.2"
-description = "Command-line client for slice, the self-hosted LLM gateway."
-readme = "PYPI.md"
-requires-python = ">=3.11"
-license = "MIT"
-authors = [{ name = "Jishnu Janardanan" }]
-dependencies = [
-    "typer",
-    "httpx",
-]
-classifiers = [
-    "Environment :: Console",
-    "Intended Audience :: Developers",
-    "Programming Language :: Python :: 3",
-    "Topic :: Utilities",
-]
-
-[project.urls]
-Homepage = "https://sliceapp.dev"
-Repository = "https://github.com/jjk30/slice"
-
-[project.scripts]
-# `slice login`, `slice init`, `slice use <tool>`. See slice_cli.py.
-slice = "slice_cli:main"
-
-[tool.setuptools]
-# Ship only the CLI module. Setting py-modules disables package auto-discovery, so the
-# app/ server package is never pulled into the wheel.
-py-modules = ["slice_cli"]

slice_gateway-0.2.2/slice_gateway.egg-info/top_level.txt

@@ -1 +0,0 @@
-slice_cli