slice-gateway 0.1.0__tar.gz

slice_gateway-0.1.0/LICENSE

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

slice_gateway-0.1.0/MANIFEST.in

@@ -0,0 +1,25 @@
+# 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.
+prune tests
+prune app
+prune infra
+prune k8s
+prune dashboard
+prune desktop
+prune website
+prune migrations
+prune demo
+prune scripts
+prune guardrails
+prune docs
+prune mcp_server
+prune gateway
+prune pipeline
+prune rag_store
+exclude README.md
+exclude requirements.txt
+exclude docker-compose.yml
+exclude Dockerfile
+exclude pytest.ini
+global-exclude *.pyc
+global-exclude .DS_Store

slice_gateway-0.1.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: slice-gateway
+Version: 0.1.0
+Summary: Command-line client for slice, the self-hosted LLM gateway.
+Author: Jishnu Janardanan
+License-Expression: MIT
+Project-URL: Homepage, https://sliceapp.dev
+Project-URL: Repository, https://github.com/jjk30/slice
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer
+Requires-Dist: httpx
+Dynamic: license-file
+
+# slice-gateway
+
+Command-line client for slice, a self-hosted LLM gateway that routes, caches, and caps your AI spend.
+
+This package installs the `slice` command. It logs you in through GitHub, then prints the environment lines that point your existing tools at a slice gateway. It has no server dependencies. It needs only typer and httpx, plus the standard library.
+
+## Quickstart
+
+1. Install the CLI:
+
+       pip install slice-gateway
+
+2. Log in through GitHub:
+
+       slice login
+
+3. Point a tool at slice. For Claude Code, set three variables:
+
+       export ANTHROPIC_BASE_URL=https://api.sliceapp.dev
+       export ANTHROPIC_API_KEY=sk-ant-api...     # your own Anthropic key
+       export ANTHROPIC_AUTH_TOKEN=slk_live_...   # your slice key, from slice login
+
+`ANTHROPIC_AUTH_TOKEN` goes out as `Authorization: Bearer`, which is where slice reads its key. `ANTHROPIC_API_KEY` stays your own Anthropic key in `x-api-key`, and slice forwards it upstream.
+
+Run `slice use anthropic`, `slice use openai`, `slice use curl`, or `slice use claude-code` to print the exact lines for your tool.
+
+## 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

slice_gateway-0.1.0/PYPI.md

@@ -0,0 +1,31 @@
+# slice-gateway
+
+Command-line client for slice, a self-hosted LLM gateway that routes, caches, and caps your AI spend.
+
+This package installs the `slice` command. It logs you in through GitHub, then prints the environment lines that point your existing tools at a slice gateway. It has no server dependencies. It needs only typer and httpx, plus the standard library.
+
+## Quickstart
+
+1. Install the CLI:
+
+       pip install slice-gateway
+
+2. Log in through GitHub:
+
+       slice login
+
+3. Point a tool at slice. For Claude Code, set three variables:
+
+       export ANTHROPIC_BASE_URL=https://api.sliceapp.dev
+       export ANTHROPIC_API_KEY=sk-ant-api...     # your own Anthropic key
+       export ANTHROPIC_AUTH_TOKEN=slk_live_...   # your slice key, from slice login
+
+`ANTHROPIC_AUTH_TOKEN` goes out as `Authorization: Bearer`, which is where slice reads its key. `ANTHROPIC_API_KEY` stays your own Anthropic key in `x-api-key`, and slice forwards it upstream.
+
+Run `slice use anthropic`, `slice use openai`, `slice use curl`, or `slice use claude-code` to print the exact lines for your tool.
+
+## 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

slice_gateway-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+# 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.1.0"
+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.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

slice_gateway-0.1.0/slice_cli.py

@@ -0,0 +1,242 @@
+"""The ``slice`` CLI (phase 12): log in from the terminal, then point tools at slice.
+
+Installed as a console entry point via pyproject.toml, so ``pip install -e .`` gives the
+``slice`` command. Three subcommands:
+
+- ``slice login``, runs the GitHub device flow against the gateway's ``/auth/device/*``
+  endpoints (the gateway holds the OAuth client id and talks to GitHub; the CLI never
+  does). It shows the user code and URL, opens the browser, polls on the interval, and on
+  success saves the slice key and JWT to ``~/.slice/config.json`` (chmod 600).
+- ``slice init``, confirms the saved config, records the default base URL, and prints
+  the current account status (a ``/auth/me`` call with the saved key).
+- ``slice use <tool>``, prints the env lines that point a tool at slice. For tools where
+  the caller controls headers (SDK, curl) that is the whole story; for ``claude-code`` it
+  prints the three variables (base URL, your Anthropic key in ANTHROPIC_API_KEY, your slice
+  key in ANTHROPIC_AUTH_TOKEN) that run it end to end through slice.
+
+The CLI talks only to the gateway over HTTP; it holds no secrets of its own. The saved
+slice key is a bearer credential, so the config file is written 0600.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+import time
+import webbrowser
+from pathlib import Path
+
+import httpx
+import typer
+
+app = typer.Typer(add_completion=False, help="slice. Log in and point your tools at the gateway.")
+
+CONFIG_DIR = Path.home() / ".slice"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+DEFAULT_BASE_URL = "http://localhost:8080"
+
+# How the device flow gives up if the user never authorizes: the gateway returns the
+# expiry, but cap the CLI's own patience too so a wedged terminal doesn't spin forever.
+POLL_CEILING_SECONDS = 900
+
+
+# --- config file ------------------------------------------------------------
+
+
+def base_url() -> str:
+    """The gateway base URL: the saved one, else ``SLICE_BASE_URL``, else the local default."""
+    saved = load_config().get("base_url")
+    return (saved or os.getenv("SLICE_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+
+
+def load_config() -> dict:
+    try:
+        return json.loads(CONFIG_PATH.read_text())
+    except (FileNotFoundError, ValueError):
+        return {}
+
+
+def save_config(data: dict) -> None:
+    """Write ``~/.slice/config.json`` as 0600 (it holds a bearer credential)."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(data, indent=2) + "\n")
+    os.chmod(CONFIG_PATH, stat.S_IRUSR | stat.S_IWUSR)  # 0600
+
+
+# --- commands ---------------------------------------------------------------
+
+
+@app.command()
+def login(
+    base: str = typer.Option(None, "--base-url", help="Gateway base URL (default: saved / SLICE_BASE_URL / localhost)."),
+    open_browser: bool = typer.Option(True, "--open/--no-open", help="Open the verification URL in a browser."),
+) -> None:
+    """Log in to slice via GitHub (device flow) and save the slice key."""
+    target = (base or base_url()).rstrip("/")
+    existing = load_config()
+
+    with httpx.Client(timeout=30.0) as http:
+        try:
+            started = http.post(f"{target}/auth/device/start")
+        except httpx.HTTPError as exc:
+            _fail(f"Could not reach the gateway at {target}: {exc}")
+        if started.status_code != 200:
+            _fail(f"Login could not start: {_message(started)}")
+        data = started.json()
+        session_id = data["session_id"]
+        user_code = data["user_code"]
+        verification_uri = data["verification_uri"]
+        interval = int(data.get("interval") or 5)
+
+        typer.echo("")
+        typer.secho("  To finish signing in, open:", bold=True)
+        typer.secho(f"    {verification_uri}", fg=typer.colors.CYAN)
+        typer.secho("  and enter this code:", bold=True)
+        typer.secho(f"    {user_code}", fg=typer.colors.GREEN, bold=True)
+        typer.echo("")
+        if open_browser:
+            try:
+                webbrowser.open(verification_uri)
+            except Exception:  # noqa: BLE001, a headless box just shows the URL above.
+                pass
+
+        typer.echo("Waiting for you to authorize in the browser…")
+        deadline = time.monotonic() + POLL_CEILING_SECONDS
+        while time.monotonic() < deadline:
+            time.sleep(max(1, interval))
+            try:
+                polled = http.post(f"{target}/auth/device/poll", json={"session_id": session_id})
+            except httpx.HTTPError as exc:
+                _fail(f"Lost contact with the gateway: {exc}")
+            if polled.status_code != 200:
+                _fail(f"Login failed: {_message(polled)}")
+            body = polled.json()
+            status = body.get("status")
+            if status == "authorized":
+                _save_login(target, existing, body)
+                account = body.get("account") or {}
+                typer.secho(f"Logged in as {account.get('login')}", fg=typer.colors.GREEN, bold=True)
+                return
+            if status == "slow_down":
+                interval = int(body.get("interval") or interval + 5)
+                continue
+            if status == "pending":
+                interval = int(body.get("interval") or interval)
+                continue
+            if status == "expired":
+                _fail("The login request expired before you authorized it. Run `slice login` again.")
+            if status == "denied":
+                _fail("Login was denied on the GitHub page.")
+            _fail(f"Unexpected login status: {status!r}")
+        _fail("Timed out waiting for authorization. Run `slice login` again.")
+
+
+def _save_login(target: str, existing: dict, body: dict) -> None:
+    account = body.get("account") or {}
+    save_config(
+        {
+            **existing,
+            "base_url": target,
+            "slice_key": body.get("slice_key"),
+            "jwt": body.get("jwt"),
+            "login": account.get("login"),
+            "account_id": account.get("id"),
+        }
+    )
+
+
+@app.command()
+def init(
+    base: str = typer.Option(None, "--base-url", help="Set the default gateway base URL."),
+) -> None:
+    """Confirm the saved login, set the default base URL, and show account status."""
+    config = load_config()
+    if base:
+        config["base_url"] = base.rstrip("/")
+        save_config(config)
+    target = (config.get("base_url") or base_url()).rstrip("/")
+    key = config.get("slice_key")
+
+    typer.echo(f"Gateway:  {target}")
+    typer.echo(f"Config:   {CONFIG_PATH}")
+    if not key:
+        typer.secho("Not logged in. Run `slice login` first.", fg=typer.colors.YELLOW)
+        raise typer.Exit(code=1)
+
+    with httpx.Client(timeout=15.0) as http:
+        try:
+            me = http.get(f"{target}/auth/me", headers={"Authorization": f"Bearer {key}"})
+        except httpx.HTTPError as exc:
+            _fail(f"Could not reach the gateway at {target}: {exc}")
+    if me.status_code != 200:
+        typer.secho(f"Saved key was rejected: {_message(me)}", fg=typer.colors.RED)
+        typer.echo("Run `slice login` to get a fresh key.")
+        raise typer.Exit(code=1)
+    account = me.json().get("account") or {}
+    typer.secho(f"Logged in as {account.get('login')} (account {account.get('id')}).", fg=typer.colors.GREEN)
+
+
+@app.command()
+def use(tool: str = typer.Argument(..., help="Which tool: anthropic | openai | curl | claude-code")) -> None:
+    """Print the environment lines that point a tool at slice."""
+    config = load_config()
+    target = base_url()
+    key = config.get("slice_key")
+    if not key:
+        typer.secho("Not logged in. Run `slice login` first.", fg=typer.colors.YELLOW)
+        raise typer.Exit(code=1)
+
+    name = tool.strip().lower()
+    if name in {"anthropic", "sdk", "python"}:
+        typer.echo(f"export ANTHROPIC_BASE_URL={target}")
+        typer.echo(f"export SLICE_KEY={key}")
+        typer.echo("# Send the slice key as the Authorization header, your provider key as x-api-key:")
+        typer.echo('#   Authorization: Bearer $SLICE_KEY')
+        typer.echo('#   x-api-key: <your Anthropic key>')
+    elif name in {"openai", "codex"}:
+        typer.echo(f"export OPENAI_BASE_URL={target}/v1")
+        typer.echo(f"export SLICE_KEY={key}")
+        typer.echo("# Authorization: Bearer $SLICE_KEY, and your provider key in x-api-key.")
+    elif name in {"curl", "http"}:
+        typer.echo(f'curl {target}/v1/messages \\')
+        typer.echo(f'  -H "Authorization: Bearer {key}" \\')
+        typer.echo('  -H "x-api-key: $ANTHROPIC_API_KEY" \\')
+        typer.echo('  -H "content-type: application/json" \\')
+        typer.echo('  -d \'{"model":"claude-sonnet-5","max_tokens":64,"messages":[{"role":"user","content":"hi"}]}\'')
+    elif name in {"claude-code", "claudecode", "cc"}:
+        typer.echo(f"export ANTHROPIC_BASE_URL={target}")
+        typer.echo("export ANTHROPIC_API_KEY=sk-ant-api...     # your own Anthropic key")
+        typer.echo(f"export ANTHROPIC_AUTH_TOKEN={key}   # your slice key, from slice login")
+        typer.echo("# ANTHROPIC_AUTH_TOKEN goes out as Authorization: Bearer, where slice reads its key.")
+        typer.echo("# ANTHROPIC_API_KEY stays your own Anthropic key in x-api-key; slice forwards it.")
+        typer.echo("# Claude Code notes that env auth takes precedence over your claude.ai login while")
+        typer.echo("# these are set, which is expected; unset the three variables to go back to normal.")
+    else:
+        _fail(f"Unknown tool {tool!r}. Try: anthropic | openai | curl | claude-code")
+
+
+# --- helpers ----------------------------------------------------------------
+
+
+def _message(response: httpx.Response) -> str:
+    try:
+        body = response.json()
+    except ValueError:
+        return f"HTTP {response.status_code}"
+    if isinstance(body, dict) and isinstance(body.get("error"), dict):
+        return body["error"].get("message") or f"HTTP {response.status_code}"
+    return f"HTTP {response.status_code}"
+
+
+def _fail(message: str) -> None:
+    typer.secho(message, fg=typer.colors.RED, err=True)
+    raise typer.Exit(code=1)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

slice_gateway-0.1.0/slice_gateway.egg-info/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: slice-gateway
+Version: 0.1.0
+Summary: Command-line client for slice, the self-hosted LLM gateway.
+Author: Jishnu Janardanan
+License-Expression: MIT
+Project-URL: Homepage, https://sliceapp.dev
+Project-URL: Repository, https://github.com/jjk30/slice
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer
+Requires-Dist: httpx
+Dynamic: license-file
+
+# slice-gateway
+
+Command-line client for slice, a self-hosted LLM gateway that routes, caches, and caps your AI spend.
+
+This package installs the `slice` command. It logs you in through GitHub, then prints the environment lines that point your existing tools at a slice gateway. It has no server dependencies. It needs only typer and httpx, plus the standard library.
+
+## Quickstart
+
+1. Install the CLI:
+
+       pip install slice-gateway
+
+2. Log in through GitHub:
+
+       slice login
+
+3. Point a tool at slice. For Claude Code, set three variables:
+
+       export ANTHROPIC_BASE_URL=https://api.sliceapp.dev
+       export ANTHROPIC_API_KEY=sk-ant-api...     # your own Anthropic key
+       export ANTHROPIC_AUTH_TOKEN=slk_live_...   # your slice key, from slice login
+
+`ANTHROPIC_AUTH_TOKEN` goes out as `Authorization: Bearer`, which is where slice reads its key. `ANTHROPIC_API_KEY` stays your own Anthropic key in `x-api-key`, and slice forwards it upstream.
+
+Run `slice use anthropic`, `slice use openai`, `slice use curl`, or `slice use claude-code` to print the exact lines for your tool.
+
+## 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

slice_gateway-0.1.0/slice_gateway.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+MANIFEST.in
+PYPI.md
+pyproject.toml
+slice_cli.py
+slice_gateway.egg-info/PKG-INFO
+slice_gateway.egg-info/SOURCES.txt
+slice_gateway.egg-info/dependency_links.txt
+slice_gateway.egg-info/entry_points.txt
+slice_gateway.egg-info/requires.txt
+slice_gateway.egg-info/top_level.txt

slice_gateway-0.1.0/slice_gateway.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

slice_gateway-0.1.0/slice_gateway.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+slice = slice_cli:main

slice_gateway-0.1.0/slice_gateway.egg-info/requires.txt

@@ -0,0 +1,2 @@
+typer
+httpx

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

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