proxyagent 0.1.0__tar.gz → 0.2.0__tar.gz

proxyagent-0.1.0/README.md → proxyagent-0.2.0/PKG-INFO

@@ -1,3 +1,35 @@
+Metadata-Version: 2.4
+Name: proxyagent
+Version: 0.2.0
+Summary: Run any agent (Claude, Codex, custom) on any machine — with no API key on the machine. A secure, self-hosted proxy for models and tools.
+Project-URL: Homepage, https://github.com/teddyoweh/proxyagent
+Author-email: Spawn Labs <teddy@spawnlabs.ai>
+License-Expression: Apache-2.0
+Keywords: agents,claude,codex,gateway,llm,proxy,security,tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Requires-Dist: uvicorn[standard]>=0.27
+Provides-Extra: all
+Requires-Dist: cryptography>=42.0; extra == 'all'
+Requires-Dist: psycopg[binary]>=3.1; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3.1; extra == 'postgres'
+Provides-Extra: secure
+Requires-Dist: cryptography>=42.0; extra == 'secure'
+Description-Content-Type: text/markdown
+
 <div align="center">
 
 # proxyagent
@@ -73,6 +105,31 @@ export PROXYAGENT_TOOLS='[{"name":"crm","url":"https://hooks.you.com/crm","heade
 # the proxy executes calls to managed tools server-side (keys stay here).
 ```
 
+## Credentials, storage & cost
+
+By default provider keys come from the **environment** and stay local. Or **add** them
+once and they're stored **encrypted** (`proxy_agent_keys`) — locally in SQLite, or in
+**Postgres** if you point at one. Either way the machine never sees them.
+
+```bash
+export PROXYAGENT_SECRET_KEY=…                 # enables at-rest encryption (Fernet)
+proxyagent provider add anthropic --key sk-ant-…          # stored, encrypted
+proxyagent provider add openai --key sk-…  --kind api_key
+# OAuth: store an access token →  proxyagent provider add anthropic --key <oauth-token> --kind oauth
+proxyagent provider ls
+
+# Postgres-backed (shared, multi-instance): tables proxy_agent_keys / _tokens / _calls
+export PROXYAGENT_DATABASE_URL=postgresql://user:pass@host/db    # pip install 'proxyagent[postgres]'
+```
+
+Every call is traced in `proxy_agent_calls` with **token usage, latency, and computed
+cost** (per-model pricing, override via `PROXYAGENT_PRICING`). See it live:
+
+```bash
+proxyagent usage          # totals: requests · tokens · $ cost
+proxyagent logs           # per-request trace incl. cost
+```
+
 ## Security model
 - **Real keys never leave the proxy** — read from env, never persisted, never logged, never returned.
 - **Machine tokens are stored hashed** (SHA-256); plaintext shown once. A stolen DB yields nothing usable.

proxyagent-0.1.0/PKG-INFO → proxyagent-0.2.0/README.md

@@ -1,28 +1,3 @@
-Metadata-Version: 2.4
-Name: proxyagent
-Version: 0.1.0
-Summary: Run any agent (Claude, Codex, custom) on any machine — with no API key on the machine. A secure, self-hosted proxy for models and tools.
-Project-URL: Homepage, https://github.com/teddyoweh/proxyagent
-Author-email: Spawn Labs <teddy@spawnlabs.ai>
-License-Expression: Apache-2.0
-Keywords: agents,claude,codex,gateway,llm,proxy,security,tools
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Security
-Requires-Python: >=3.10
-Requires-Dist: fastapi>=0.110
-Requires-Dist: httpx>=0.27
-Requires-Dist: pydantic>=2.0
-Requires-Dist: rich>=13.0
-Requires-Dist: typer>=0.12
-Requires-Dist: uvicorn[standard]>=0.27
-Provides-Extra: dev
-Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
-Requires-Dist: pytest>=8.0; extra == 'dev'
-Description-Content-Type: text/markdown
-
 <div align="center">
 
 # proxyagent
@@ -98,6 +73,31 @@ export PROXYAGENT_TOOLS='[{"name":"crm","url":"https://hooks.you.com/crm","heade
 # the proxy executes calls to managed tools server-side (keys stay here).
 ```
 
+## Credentials, storage & cost
+
+By default provider keys come from the **environment** and stay local. Or **add** them
+once and they're stored **encrypted** (`proxy_agent_keys`) — locally in SQLite, or in
+**Postgres** if you point at one. Either way the machine never sees them.
+
+```bash
+export PROXYAGENT_SECRET_KEY=…                 # enables at-rest encryption (Fernet)
+proxyagent provider add anthropic --key sk-ant-…          # stored, encrypted
+proxyagent provider add openai --key sk-…  --kind api_key
+# OAuth: store an access token →  proxyagent provider add anthropic --key <oauth-token> --kind oauth
+proxyagent provider ls
+
+# Postgres-backed (shared, multi-instance): tables proxy_agent_keys / _tokens / _calls
+export PROXYAGENT_DATABASE_URL=postgresql://user:pass@host/db    # pip install 'proxyagent[postgres]'
+```
+
+Every call is traced in `proxy_agent_calls` with **token usage, latency, and computed
+cost** (per-model pricing, override via `PROXYAGENT_PRICING`). See it live:
+
+```bash
+proxyagent usage          # totals: requests · tokens · $ cost
+proxyagent logs           # per-request trace incl. cost
+```
+
 ## Security model
 - **Real keys never leave the proxy** — read from env, never persisted, never logged, never returned.
 - **Machine tokens are stored hashed** (SHA-256); plaintext shown once. A stolen DB yields nothing usable.

{proxyagent-0.1.0 → proxyagent-0.2.0}/proxyagent/__init__.py

@@ -16,7 +16,7 @@ from typing import Optional
 
 from .harness import run  # noqa: F401  (the headline SDK call)
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 __all__ = ["run", "serve", "create_app", "Config", "Admin", "__version__"]
 
 
@@ -61,5 +61,21 @@ class Admin:
     def revoke(self, token_id: str) -> None:
         self._c.delete(f"/admin/tokens/{token_id}").raise_for_status()
 
+    def add_provider(self, provider: str, secret: str, kind: str = "api_key",
+                     label: Optional[str] = None) -> str:
+        r = self._c.post("/admin/providers", json={
+            "provider": provider, "secret": secret, "kind": kind, "label": label})
+        r.raise_for_status()
+        return r.json()["id"]
+
+    def providers(self) -> dict:
+        return self._c.get("/admin/providers").json()
+
+    def remove_provider(self, cred_id: str) -> None:
+        self._c.delete(f"/admin/providers/{cred_id}").raise_for_status()
+
     def logs(self, limit: int = 100) -> list:
         return self._c.get("/admin/logs", params={"limit": limit}).json()["logs"]
+
+    def usage(self) -> dict:
+        return self._c.get("/admin/usage").json()

{proxyagent-0.1.0 → proxyagent-0.2.0}/proxyagent/cli.py

@@ -68,6 +68,58 @@ def run_harness(
 
 token_app = typer.Typer(help="Mint / list / revoke machine tokens.")
 app.add_typer(token_app, name="token")
+provider_app = typer.Typer(help="Add / list / remove provider credentials (stored, encrypted).")
+app.add_typer(provider_app, name="provider")
+
+
+@provider_app.command("add")
+def provider_add(
+    provider: str = typer.Argument(..., help="anthropic | openai"),
+    key: str = typer.Option(..., "--key", "--secret", help="API key, or OAuth access token with --kind oauth."),
+    kind: str = typer.Option("api_key", "--kind", help="api_key | oauth"),
+    label: str = typer.Option(None, "--label"),
+    proxy: str = typer.Option("http://127.0.0.1:8080", "--proxy"),
+    admin: str = typer.Option(None, "--admin"),
+):
+    """Store a provider credential (encrypted if PROXYAGENT_SECRET_KEY is set)."""
+    with _admin_client(proxy, admin) as c:
+        r = c.post("/admin/providers", json={"provider": provider, "secret": key,
+                                             "kind": kind, "label": label})
+    if r.status_code >= 400:
+        err.print(f"[red]✗[/red] {r.text}"); raise typer.Exit(1)
+    d = r.json()
+    note = "[green]encrypted[/green]" if d["stored"] == "encrypted" else "[yellow]plaintext — set PROXYAGENT_SECRET_KEY[/yellow]"
+    console.print(f"[green]✓[/green] stored [cyan]{provider}[/cyan] ({kind}) · {note}")
+
+
+@provider_app.command("ls")
+def provider_ls(proxy: str = typer.Option("http://127.0.0.1:8080", "--proxy"),
+                admin: str = typer.Option(None, "--admin")):
+    """List stored provider credentials (secrets never shown)."""
+    with _admin_client(proxy, admin) as c:
+        r = c.get("/admin/providers")
+    if r.status_code >= 400:
+        err.print(f"[red]✗[/red] {r.text}"); raise typer.Exit(1)
+    d = r.json()
+    t = Table(title=f"Provider credentials  ·  encryption {'on' if d['encryption'] else 'OFF'}")
+    for col in ("ID", "Provider", "Kind", "Label", "Active"):
+        t.add_column(col)
+    for k in d["credentials"]:
+        t.add_row(k["id"], k["provider"], k["kind"], k.get("label") or "",
+                  "[green]yes[/green]" if k["active"] else "no")
+    console.print(t)
+    console.print(f"[dim]configured (env+stored): {', '.join(d['configured']) or 'none'}[/dim]")
+
+
+@provider_app.command("rm")
+def provider_rm(cred_id: str, proxy: str = typer.Option("http://127.0.0.1:8080", "--proxy"),
+                admin: str = typer.Option(None, "--admin")):
+    """Remove a stored credential."""
+    with _admin_client(proxy, admin) as c:
+        r = c.delete(f"/admin/providers/{cred_id}")
+    if r.status_code >= 400:
+        err.print(f"[red]✗[/red] {r.text}"); raise typer.Exit(1)
+    console.print(f"[green]✓[/green] removed {cred_id}")
 
 
 @token_app.command("new")
@@ -132,14 +184,35 @@ def logs(limit: int = 50, proxy: str = typer.Option("http://127.0.0.1:8080", "--
         err.print(f"[red]✗[/red] {r.text}"); raise typer.Exit(1)
     rows = r.json()["logs"]
     t = Table(title="Requests")
-    for col in ("Token", "Provider", "Model", "Status", "In", "Out", "ms"):
+    for col in ("Token", "Provider", "Model", "Status", "In", "Out", "Cost", "ms"):
         t.add_column(col)
     for g in rows:
+        cost = g.get("cost_usd")
         t.add_row(g.get("token_label") or "", g.get("provider") or "", (g.get("model") or "")[:28],
                   str(g.get("status") or ""), str(g.get("prompt_tokens") or "-"),
-                  str(g.get("completion_tokens") or "-"), str(g.get("latency_ms") or ""))
+                  str(g.get("completion_tokens") or "-"),
+                  f"${cost:.4f}" if cost else "-", str(g.get("latency_ms") or ""))
     console.print(t)
 
 
+@app.command()
+def usage(proxy: str = typer.Option("http://127.0.0.1:8080", "--proxy"),
+          admin: str = typer.Option(None, "--admin")):
+    """Totals: requests, tokens, and cost across all proxied calls."""
+    with _admin_client(proxy, admin) as c:
+        r = c.get("/admin/usage")
+    if r.status_code >= 400:
+        err.print(f"[red]✗[/red] {r.text}"); raise typer.Exit(1)
+    d = r.json()
+    u = d["usage"]
+    console.print(Panel.fit(
+        f"[bold]{u['requests']}[/bold] requests   "
+        f"[bold]{u['prompt_tokens']:,}[/bold] in · [bold]{u['completion_tokens']:,}[/bold] out   "
+        f"[green]${u.get('cost_usd', 0):.4f}[/green]\n"
+        f"[dim]backend: {d.get('backend')} · providers: {', '.join(d['providers']) or 'none'} · "
+        f"encryption: {'on' if d.get('encryption') else 'off'}[/dim]",
+        title="usage", border_style="green"))
+
+
 if __name__ == "__main__":
     app()

proxyagent-0.2.0/proxyagent/crypto.py

@@ -0,0 +1,44 @@
+"""At-rest encryption for stored provider credentials.
+
+If `PROXYAGENT_SECRET_KEY` is set (and `cryptography` is installed), provider secrets
+are encrypted with Fernet before they touch the database. Without a key, secrets are
+stored as-is and we warn loudly — fine for a laptop, not for a shared Postgres.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import os
+
+_PREFIX = "enc:"
+
+
+def _fernet():
+    key = os.environ.get("PROXYAGENT_SECRET_KEY")
+    if not key:
+        return None
+    try:
+        from cryptography.fernet import Fernet
+    except ImportError:
+        return None
+    derived = base64.urlsafe_b64encode(hashlib.sha256(key.encode()).digest())
+    return Fernet(derived)
+
+
+def encryption_available() -> bool:
+    return _fernet() is not None
+
+
+def encrypt(value: str) -> str:
+    f = _fernet()
+    return _PREFIX + f.encrypt(value.encode()).decode() if f else value
+
+
+def decrypt(value: str) -> str:
+    if value and value.startswith(_PREFIX):
+        f = _fernet()
+        if not f:
+            raise RuntimeError("PROXYAGENT_SECRET_KEY required to decrypt a stored credential")
+        return f.decrypt(value[len(_PREFIX):].encode()).decode()
+    return value

proxyagent-0.2.0/proxyagent/db.py

@@ -0,0 +1,87 @@
+"""Storage backend — SQLite by default (local), or Postgres when a URL is given.
+
+Set `PROXYAGENT_DATABASE_URL=postgresql://…` (or pass `database_url=`) and everything
+lands in Postgres; otherwise it's a local SQLite file. Tables are prefixed
+`proxy_agent_` so they sit cleanly in a shared database.
+"""
+
+from __future__ import annotations
+
+import os
+import sqlite3
+import threading
+
+
+def database_url() -> str | None:
+    return os.environ.get("PROXYAGENT_DATABASE_URL") or os.environ.get("DATABASE_URL")
+
+
+def is_postgres(url: str | None) -> bool:
+    return bool(url) and url.startswith(("postgres://", "postgresql://"))
+
+
+class DB:
+    """Tiny cross-backend wrapper. Use `?` placeholders everywhere; we translate for
+    Postgres. Thread-safe via a lock (fine for a proxy's scale)."""
+
+    def __init__(self, sqlite_path: str = ":memory:", url: str | None = None):
+        self._lock = threading.RLock()
+        self.url = url if url is not None else database_url()
+        self.pg = is_postgres(self.url)
+        if self.pg:
+            import psycopg  # type: ignore
+            self._conn = psycopg.connect(self.url, autocommit=True)
+        else:
+            self._conn = sqlite3.connect(sqlite_path, check_same_thread=False)
+            self._conn.row_factory = sqlite3.Row
+
+    def _q(self, sql: str) -> str:
+        return sql.replace("?", "%s") if self.pg else sql
+
+    def execute(self, sql: str, params: tuple = ()):  # returns rowcount-ish handle
+        with self._lock:
+            if self.pg:
+                cur = self._conn.cursor()
+                cur.execute(self._q(sql), params)
+                return cur
+            cur = self._conn.execute(sql, params)
+            self._conn.commit()
+            return cur
+
+    def fetchone(self, sql: str, params: tuple = ()) -> dict | None:
+        with self._lock:
+            if self.pg:
+                cur = self._conn.cursor()
+                cur.execute(self._q(sql), params)
+                row = cur.fetchone()
+                if not row:
+                    return None
+                cols = [d[0] for d in cur.description]
+                return dict(zip(cols, row))
+            r = self._conn.execute(sql, params).fetchone()
+            return dict(r) if r else None
+
+    def fetchall(self, sql: str, params: tuple = ()) -> list[dict]:
+        with self._lock:
+            if self.pg:
+                cur = self._conn.cursor()
+                cur.execute(self._q(sql), params)
+                rows = cur.fetchall()
+                cols = [d[0] for d in cur.description]
+                return [dict(zip(cols, r)) for r in rows]
+            rows = self._conn.execute(sql, params).fetchall()
+            return [dict(r) for r in rows]
+
+    def executescript(self, script: str) -> None:
+        with self._lock:
+            if self.pg:
+                cur = self._conn.cursor()
+                for stmt in [s for s in script.split(";") if s.strip()]:
+                    cur.execute(stmt)
+            else:
+                self._conn.executescript(script)
+                self._conn.commit()
+
+    def close(self) -> None:
+        with self._lock:
+            self._conn.close()

proxyagent-0.2.0/proxyagent/pricing.py

@@ -0,0 +1,62 @@
+"""Cost tracking — turn token usage into dollars.
+
+Prices are USD per 1M tokens (input, output). Matched by a prefix of the model name,
+so "claude-sonnet-4-5-2025…" picks up "claude-sonnet". Override / extend via
+`PROXYAGENT_PRICING` (JSON: {"model-prefix": [in_per_mtok, out_per_mtok]}).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+# Indicative list prices (USD / 1M tokens). Tune freely.
+DEFAULT_PRICES: dict[str, tuple[float, float]] = {
+    # Anthropic
+    "claude-opus": (15.0, 75.0),
+    "claude-sonnet": (3.0, 15.0),
+    "claude-haiku": (0.80, 4.0),
+    "claude-3-opus": (15.0, 75.0),
+    "claude-3-5-sonnet": (3.0, 15.0),
+    "claude-3-5-haiku": (0.80, 4.0),
+    # OpenAI
+    "gpt-4o-mini": (0.15, 0.60),
+    "gpt-4o": (2.50, 10.0),
+    "gpt-4.1-mini": (0.40, 1.60),
+    "gpt-4.1": (2.0, 8.0),
+    "o3-mini": (1.10, 4.40),
+    "o3": (2.0, 8.0),
+    "gpt-5": (1.25, 10.0),
+}
+
+
+def _prices() -> dict[str, tuple[float, float]]:
+    prices = dict(DEFAULT_PRICES)
+    raw = os.environ.get("PROXYAGENT_PRICING")
+    if raw:
+        try:
+            for k, v in json.loads(raw).items():
+                prices[k] = (float(v[0]), float(v[1]))
+        except Exception:
+            pass
+    return prices
+
+
+def price_for(model: str) -> tuple[float, float] | None:
+    if not model:
+        return None
+    prices = _prices()
+    # longest matching prefix wins (so gpt-4o-mini beats gpt-4o)
+    best = None
+    for prefix, p in prices.items():
+        if model.startswith(prefix) and (best is None or len(prefix) > len(best[0])):
+            best = (prefix, p)
+    return best[1] if best else None
+
+
+def cost_usd(model: str, input_tokens: int | None, output_tokens: int | None) -> float | None:
+    p = price_for(model or "")
+    if p is None:
+        return None
+    cin, cout = p
+    return round((input_tokens or 0) / 1e6 * cin + (output_tokens or 0) / 1e6 * cout, 6)

{proxyagent-0.1.0 → proxyagent-0.2.0}/proxyagent/providers.py

@@ -12,6 +12,7 @@ import json
 
 import httpx
 
+from . import pricing
 from .config import Config, PROVIDERS
 from .store import Store, now_ms
 
@@ -22,6 +23,21 @@ ROUTES = {
 }
 
 
+def resolve_auth(provider, store: Store | None) -> tuple[dict, bool]:
+    """Auth headers for an upstream call. A stored credential (proxy_agent_keys) wins
+    over the env key; returns ({}, False) when nothing is configured."""
+    cred = store.get_credential(provider.name) if store else None
+    if cred:
+        secret, kind = cred["secret"], cred["kind"]
+        if kind == "oauth":
+            return {"Authorization": f"Bearer {secret}", **provider.extra_headers}, True
+        if provider.auth_style == "x-api-key":
+            return {"x-api-key": secret, **provider.extra_headers}, True
+        return {"Authorization": f"Bearer {secret}", **provider.extra_headers}, True
+    headers = provider.auth_headers()
+    return headers, bool(headers)
+
+
 def scope_allows(scope: list[str], provider: str, model: str) -> bool:
     """A scope entry is a glob over 'provider:model', e.g. 'anthropic:claude-*', or '*'."""
     target = f"{provider}:{model or '*'}"
@@ -44,11 +60,13 @@ async def forward(
 ):
     """Forward a request upstream. Returns (status, headers, body_iter_or_dict, log_after)."""
     provider = PROVIDERS[provider_name]
-    if not provider.key:
-        return 502, {}, {"error": f"provider '{provider_name}' not configured on the proxy"}, None
+    auth, ok = resolve_auth(provider, store)
+    if not ok:
+        return 502, {}, {"error": f"provider '{provider_name}' not configured on the proxy "
+                                  f"(set {provider.key_env} or `proxyagent provider add {provider_name}`)"}, None
 
     url = provider.base_url + upstream_path
-    headers = {"content-type": "application/json", **provider.auth_headers()}
+    headers = {"content-type": "application/json", **auth}
     model = body.get("model", "")
     t0 = now_ms()
 
@@ -57,7 +75,8 @@ async def forward(
             token_id=token["id"], token_label=token.get("label"), provider=provider_name,
             model=model, status=status, prompt_tokens=ptok, completion_tokens=ctok,
             latency_ms=now_ms() - t0, streamed=1 if streaming else 0,
-            tools_used=json.dumps(tools_used or []), error=err,
+            tools_used=json.dumps(tools_used or []), cost_usd=pricing.cost_usd(model, ptok, ctok),
+            error=err,
         )
 
     if streaming:

{proxyagent-0.1.0 → proxyagent-0.2.0}/proxyagent/server.py

@@ -14,6 +14,7 @@ from fastapi import FastAPI, Header, HTTPException, Request
 from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
 from pydantic import BaseModel
 
+from . import crypto
 from .config import Config, PROVIDERS
 from .providers import ROUTES, forward, scope_allows
 from .security import token_matches
@@ -30,6 +31,14 @@ class TokenBody(BaseModel):
     rate_limit: int = 0
 
 
+class ProviderBody(BaseModel):
+    provider: str
+    secret: str
+    kind: str = "api_key"            # api_key | oauth
+    label: str | None = None
+    refresh: str | None = None
+
+
 def create_app(config: Config | None = None) -> FastAPI:
     config = config or Config.load()
     store = Store(config.db_path)
@@ -163,17 +172,50 @@ def create_app(config: Config | None = None) -> FastAPI:
         require_admin(authorization, x_admin_token)
         return {"logs": store.list_logs(limit)}
 
+    def _configured() -> list[str]:
+        env = set(config.configured_providers())
+        db = {c["provider"] for c in store.list_credentials() if c["active"]}
+        return sorted(env | db)
+
     @app.get("/admin/usage")
     async def usage_ep(authorization: str | None = Header(None),
                        x_admin_token: str | None = Header(None)):
         require_admin(authorization, x_admin_token)
-        return {"usage": store.usage_summary(),
-                "providers": config.configured_providers(),
-                "tools": tools.list()}
+        return {"usage": store.usage_summary(), "providers": _configured(),
+                "tools": tools.list(), "backend": store.backend,
+                "encryption": crypto.encryption_available()}
+
+    # -- provider credentials (proxy_agent_keys) -------------------------- #
+    @app.post("/admin/providers")
+    async def add_provider(body: ProviderBody, authorization: str | None = Header(None),
+                           x_admin_token: str | None = Header(None)):
+        require_admin(authorization, x_admin_token)
+        if body.provider not in PROVIDERS:
+            raise HTTPException(400, f"unknown provider; known: {list(PROVIDERS)}")
+        cid = store.add_credential(body.provider, body.secret, kind=body.kind,
+                                   label=body.label, refresh=body.refresh)
+        return {"id": cid, "provider": body.provider, "kind": body.kind,
+                "stored": "encrypted" if crypto.encryption_available() else "plaintext"}
+
+    @app.get("/admin/providers")
+    async def list_providers(authorization: str | None = Header(None),
+                             x_admin_token: str | None = Header(None)):
+        require_admin(authorization, x_admin_token)
+        return {"credentials": store.list_credentials(), "configured": _configured(),
+                "encryption": crypto.encryption_available()}
+
+    @app.delete("/admin/providers/{cid}")
+    async def del_provider(cid: str, authorization: str | None = Header(None),
+                           x_admin_token: str | None = Header(None)):
+        require_admin(authorization, x_admin_token)
+        if not store.remove_credential(cid):
+            raise HTTPException(404, "no such credential")
+        return {"ok": True}
 
     @app.get("/healthz")
     async def healthz():
-        return {"ok": True, "providers": config.configured_providers(), "tools": tools.names()}
+        return {"ok": True, "providers": _configured(), "tools": tools.names(),
+                "backend": store.backend}
 
     # ------------------------------------------------------------------ #
     # Dashboard

proxyagent-0.2.0/proxyagent/store.py

@@ -0,0 +1,154 @@
+"""Persistence — machine tokens, stored provider credentials, and call traces+cost.
+
+Backend is SQLite (local) or Postgres (via URL) — see db.py. Tables:
+  * proxy_agent_tokens  — machine tokens (hashed)
+  * proxy_agent_keys    — provider credentials you add (api_key / oauth), encrypted
+  * proxy_agent_calls   — every proxied request: usage, latency, cost, tools, errors
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from pathlib import Path
+
+from . import crypto
+from .db import DB
+from .security import hash_token, new_token, mask
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS proxy_agent_tokens (
+    id TEXT PRIMARY KEY, hash TEXT NOT NULL UNIQUE, label TEXT,
+    scope_json TEXT NOT NULL DEFAULT '["*"]', rate_limit INTEGER NOT NULL DEFAULT 0,
+    created_ms BIGINT, expires_ms BIGINT, revoked INTEGER NOT NULL DEFAULT 0,
+    last_used_ms BIGINT, masked TEXT
+);
+CREATE TABLE IF NOT EXISTS proxy_agent_keys (
+    id TEXT PRIMARY KEY, provider TEXT NOT NULL, kind TEXT NOT NULL DEFAULT 'api_key',
+    secret TEXT NOT NULL, refresh TEXT, expires_ms BIGINT, label TEXT,
+    created_ms BIGINT, meta_json TEXT, active INTEGER NOT NULL DEFAULT 1
+);
+CREATE TABLE IF NOT EXISTS proxy_agent_calls (
+    id TEXT PRIMARY KEY, ts_ms BIGINT, token_id TEXT, token_label TEXT,
+    provider TEXT, model TEXT, status INTEGER,
+    prompt_tokens INTEGER, completion_tokens INTEGER, latency_ms INTEGER,
+    streamed INTEGER, tools_used TEXT, cost_usd DOUBLE PRECISION, error TEXT
+);
+"""
+
+
+def now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+class Store:
+    def __init__(self, path: str | Path = ":memory:", url: str | None = None):
+        self.db = DB(str(path), url=url)
+        self.db.executescript(_SCHEMA)
+        self.backend = "postgres" if self.db.pg else "sqlite"
+
+    # -- machine tokens ---------------------------------------------------- #
+
+    def create_token(self, label, scope, *, ttl_seconds=None, rate_limit=0):
+        plain = new_token()
+        tid = "tok_" + uuid.uuid4().hex[:12]
+        expires = now_ms() + ttl_seconds * 1000 if ttl_seconds else None
+        self.db.execute(
+            """INSERT INTO proxy_agent_tokens
+               (id, hash, label, scope_json, rate_limit, created_ms, expires_ms, masked)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+            (tid, hash_token(plain), label, json.dumps(scope), rate_limit, now_ms(),
+             expires, mask(plain)),
+        )
+        return plain, self.get_token(tid)
+
+    def get_token(self, tid):
+        return self.db.fetchone("SELECT * FROM proxy_agent_tokens WHERE id=?", (tid,))
+
+    def get_token_by_hash(self, h):
+        return self.db.fetchone("SELECT * FROM proxy_agent_tokens WHERE hash=?", (h,))
+
+    def list_tokens(self):
+        return self.db.fetchall("SELECT * FROM proxy_agent_tokens ORDER BY created_ms DESC")
+
+    def revoke_token(self, tid):
+        cur = self.db.execute("UPDATE proxy_agent_tokens SET revoked=1 WHERE id=?", (tid,))
+        return cur.rowcount > 0
+
+    def touch_token(self, tid):
+        self.db.execute("UPDATE proxy_agent_tokens SET last_used_ms=? WHERE id=?", (now_ms(), tid))
+
+    def recent_request_count(self, tid, window_ms=60_000):
+        r = self.db.fetchone(
+            "SELECT COUNT(*) c FROM proxy_agent_calls WHERE token_id=? AND ts_ms>=?",
+            (tid, now_ms() - window_ms))
+        return (r or {}).get("c", 0)
+
+    # -- provider credentials (proxy_agent_keys) --------------------------- #
+
+    def add_credential(self, provider, secret, *, kind="api_key", refresh=None,
+                       expires_ms=None, label=None, meta=None):
+        cid = "key_" + uuid.uuid4().hex[:12]
+        # one active credential per provider: deactivate older ones
+        self.db.execute("UPDATE proxy_agent_keys SET active=0 WHERE provider=?", (provider,))
+        self.db.execute(
+            """INSERT INTO proxy_agent_keys
+               (id, provider, kind, secret, refresh, expires_ms, label, created_ms, meta_json, active)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1)""",
+            (cid, provider, kind, crypto.encrypt(secret),
+             crypto.encrypt(refresh) if refresh else None, expires_ms, label, now_ms(),
+             json.dumps(meta or {})),
+        )
+        return cid
+
+    def get_credential(self, provider):
+        """Active credential for a provider, decrypted. None → fall back to env."""
+        r = self.db.fetchone(
+            "SELECT * FROM proxy_agent_keys WHERE provider=? AND active=1 ORDER BY created_ms DESC",
+            (provider,))
+        if not r:
+            return None
+        r = dict(r)
+        r["secret"] = crypto.decrypt(r["secret"])
+        if r.get("refresh"):
+            r["refresh"] = crypto.decrypt(r["refresh"])
+        return r
+
+    def list_credentials(self):
+        rows = self.db.fetchall("SELECT * FROM proxy_agent_keys ORDER BY created_ms DESC")
+        # never return the secret material
+        return [{"id": r["id"], "provider": r["provider"], "kind": r["kind"],
+                 "label": r["label"], "active": bool(r["active"]),
+                 "created_ms": r["created_ms"]} for r in rows]
+
+    def remove_credential(self, cid):
+        cur = self.db.execute("DELETE FROM proxy_agent_keys WHERE id=?", (cid,))
+        return cur.rowcount > 0
+
+    # -- call traces (proxy_agent_calls) ----------------------------------- #
+
+    def log_request(self, **kw):
+        kw.setdefault("id", "call_" + uuid.uuid4().hex[:12])
+        kw.setdefault("ts_ms", now_ms())
+        cols = ["id", "ts_ms", "token_id", "token_label", "provider", "model", "status",
+                "prompt_tokens", "completion_tokens", "latency_ms", "streamed",
+                "tools_used", "cost_usd", "error"]
+        self.db.execute(
+            f"INSERT INTO proxy_agent_calls ({','.join(cols)}) VALUES ({','.join('?' * len(cols))})",
+            tuple(kw.get(c) for c in cols))
+
+    def list_logs(self, limit=200):
+        return self.db.fetchall("SELECT * FROM proxy_agent_calls ORDER BY ts_ms DESC LIMIT ?", (limit,))
+
+    def usage_summary(self):
+        r = self.db.fetchone(
+            """SELECT COUNT(*) requests,
+                      COALESCE(SUM(prompt_tokens),0) prompt_tokens,
+                      COALESCE(SUM(completion_tokens),0) completion_tokens,
+                      COALESCE(SUM(cost_usd),0) cost_usd
+               FROM proxy_agent_calls""")
+        return r or {"requests": 0, "prompt_tokens": 0, "completion_tokens": 0, "cost_usd": 0}
+
+    def close(self):
+        self.db.close()

{proxyagent-0.1.0 → proxyagent-0.2.0}/proxyagent/ui/index.html

@@ -46,6 +46,7 @@
       <div class="card stat"><div class="n" id="s_req">0</div><div class="l">Requests</div></div>
       <div class="card stat"><div class="n" id="s_in">0</div><div class="l">Input tokens</div></div>
       <div class="card stat"><div class="n" id="s_out">0</div><div class="l">Output tokens</div></div>
+      <div class="card stat"><div class="n" id="s_cost" style="color:var(--grn)">$0</div><div class="l">Cost</div></div>
       <div class="card stat"><div class="n" id="s_tools">0</div><div class="l">Proxied tools</div></div>
     </div>
 
@@ -85,8 +86,9 @@ async function boot() {
     document.getElementById("s_req").textContent = u.usage.requests;
     document.getElementById("s_in").textContent = u.usage.prompt_tokens;
     document.getElementById("s_out").textContent = u.usage.completion_tokens;
+    document.getElementById("s_cost").textContent = "$" + (u.usage.cost_usd || 0).toFixed(4);
     document.getElementById("s_tools").textContent = (u.tools||[]).length;
-    document.getElementById("provs").textContent = "providers: " + ((u.providers||[]).join(", ") || "none");
+    document.getElementById("provs").textContent = `${u.backend||"sqlite"} · providers: ` + ((u.providers||[]).join(", ") || "none");
     refreshTokens(); refreshLogs();
   } catch (e) { document.getElementById("gateerr").textContent = "Invalid admin token."; }
 }

{proxyagent-0.1.0 → proxyagent-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "proxyagent"
-version = "0.1.0"
+version = "0.2.0"
 description = "Run any agent (Claude, Codex, custom) on any machine — with no API key on the machine. A secure, self-hosted proxy for models and tools."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -29,6 +29,9 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = ["pytest>=8.0", "pytest-asyncio>=0.23"]
+postgres = ["psycopg[binary]>=3.1"]      # store keys/calls in Postgres via PROXYAGENT_DATABASE_URL
+secure = ["cryptography>=42.0"]          # encrypt stored provider credentials at rest
+all = ["psycopg[binary]>=3.1", "cryptography>=42.0"]
 
 [project.scripts]
 proxyagent = "proxyagent.cli:app"

{proxyagent-0.1.0 → proxyagent-0.2.0}/tests/test_proxy.py

@@ -70,3 +70,40 @@ def test_healthz_and_ui():
     c = _client()
     assert c.get("/healthz").json()["ok"] is True
     assert "proxyagent" in c.get("/").text
+
+
+def test_pricing():
+    from proxyagent.pricing import cost_usd
+    # 1M in @ $3, 1M out @ $15 for sonnet
+    assert cost_usd("claude-sonnet-4-5", 1_000_000, 1_000_000) == 18.0
+    assert cost_usd("gpt-4o-mini", 1_000_000, 0) == 0.15
+    assert cost_usd("unknown-model", 100, 100) is None
+
+
+def test_credential_storage_and_resolution():
+    from proxyagent.config import PROVIDERS
+    from proxyagent.providers import resolve_auth
+    s = Store(":memory:")
+    # env fallback when nothing stored
+    headers, ok = resolve_auth(PROVIDERS["openai"], s)
+    cid = s.add_credential("openai", "sk-real-key", kind="api_key", label="prod")
+    cred = s.get_credential("openai")
+    assert cred["secret"] == "sk-real-key"               # decrypted roundtrip
+    # list never leaks the secret
+    listed = s.list_credentials()
+    assert listed[0]["provider"] == "openai" and "secret" not in listed[0]
+    # resolve_auth now uses the stored credential
+    headers, ok = resolve_auth(PROVIDERS["openai"], s)
+    assert ok and headers["Authorization"] == "Bearer sk-real-key"
+    assert s.remove_credential(cid)
+
+
+def test_provider_admin_endpoints():
+    c = _client()
+    r = c.post("/admin/providers", headers=ADMIN, json={"provider": "anthropic", "secret": "sk-ant-x"})
+    assert r.status_code == 200 and r.json()["provider"] == "anthropic"
+    listed = c.get("/admin/providers", headers=ADMIN).json()
+    assert "anthropic" in listed["configured"]
+    # unknown provider rejected
+    assert c.post("/admin/providers", headers=ADMIN,
+                  json={"provider": "nope", "secret": "x"}).status_code == 400

proxyagent-0.1.0/proxyagent/store.py

@@ -1,148 +0,0 @@
-"""Persistence — machine tokens (hashed) + a full request/usage audit log.
-
-SQLite, guarded by a lock so it's safe across the server's worker threads.
-"""
-
-from __future__ import annotations
-
-import json
-import sqlite3
-import threading
-import time
-import uuid
-from pathlib import Path
-
-from .security import hash_token, new_token, mask
-
-_SCHEMA = """
-CREATE TABLE IF NOT EXISTS tokens (
-    id          TEXT PRIMARY KEY,
-    hash        TEXT NOT NULL UNIQUE,
-    label       TEXT,
-    scope_json  TEXT NOT NULL DEFAULT '["*"]',   -- allowed "provider:model" globs
-    rate_limit  INTEGER NOT NULL DEFAULT 0,       -- max requests/min (0 = unlimited)
-    created_ms  INTEGER,
-    expires_ms  INTEGER,                          -- NULL = never
-    revoked     INTEGER NOT NULL DEFAULT 0,
-    last_used_ms INTEGER,
-    masked      TEXT
-);
-CREATE TABLE IF NOT EXISTS logs (
-    id           TEXT PRIMARY KEY,
-    ts_ms        INTEGER,
-    token_id     TEXT,
-    token_label  TEXT,
-    provider     TEXT,
-    model        TEXT,
-    status       INTEGER,
-    prompt_tokens     INTEGER,
-    completion_tokens INTEGER,
-    latency_ms   INTEGER,
-    streamed     INTEGER,
-    tools_used   TEXT,
-    error        TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_logs_ts ON logs (ts_ms DESC);
-CREATE INDEX IF NOT EXISTS idx_logs_token ON logs (token_id);
-"""
-
-
-def now_ms() -> int:
-    return int(time.time() * 1000)
-
-
-class Store:
-    def __init__(self, path: str | Path = ":memory:"):
-        self._lock = threading.RLock()
-        self._conn = sqlite3.connect(str(path), check_same_thread=False)
-        self._conn.row_factory = sqlite3.Row
-        self._conn.executescript(_SCHEMA)
-        self._conn.commit()
-
-    # -- tokens ------------------------------------------------------------ #
-
-    def create_token(self, label: str, scope: list[str], *, ttl_seconds: int | None = None,
-                     rate_limit: int = 0) -> tuple[str, dict]:
-        """Mint a token. Returns (plaintext_once, row). Plaintext is never stored."""
-        plain = new_token()
-        tid = "tok_" + uuid.uuid4().hex[:12]
-        expires = now_ms() + ttl_seconds * 1000 if ttl_seconds else None
-        with self._lock:
-            self._conn.execute(
-                """INSERT INTO tokens (id, hash, label, scope_json, rate_limit, created_ms,
-                                       expires_ms, masked)
-                   VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
-                (tid, hash_token(plain), label, json.dumps(scope), rate_limit, now_ms(),
-                 expires, mask(plain)),
-            )
-            self._conn.commit()
-        return plain, self.get_token(tid)
-
-    def get_token(self, tid: str) -> dict | None:
-        with self._lock:
-            r = self._conn.execute("SELECT * FROM tokens WHERE id=?", (tid,)).fetchone()
-        return dict(r) if r else None
-
-    def get_token_by_hash(self, h: str) -> dict | None:
-        with self._lock:
-            r = self._conn.execute("SELECT * FROM tokens WHERE hash=?", (h,)).fetchone()
-        return dict(r) if r else None
-
-    def list_tokens(self) -> list[dict]:
-        with self._lock:
-            rows = self._conn.execute("SELECT * FROM tokens ORDER BY created_ms DESC").fetchall()
-        return [dict(r) for r in rows]
-
-    def revoke_token(self, tid: str) -> bool:
-        with self._lock:
-            cur = self._conn.execute("UPDATE tokens SET revoked=1 WHERE id=?", (tid,))
-            self._conn.commit()
-        return cur.rowcount > 0
-
-    def touch_token(self, tid: str) -> None:
-        with self._lock:
-            self._conn.execute("UPDATE tokens SET last_used_ms=? WHERE id=?", (now_ms(), tid))
-            self._conn.commit()
-
-    def recent_request_count(self, tid: str, window_ms: int = 60_000) -> int:
-        with self._lock:
-            r = self._conn.execute(
-                "SELECT COUNT(*) c FROM logs WHERE token_id=? AND ts_ms>=?",
-                (tid, now_ms() - window_ms),
-            ).fetchone()
-        return r["c"]
-
-    # -- logs / usage ------------------------------------------------------ #
-
-    def log_request(self, **kw) -> None:
-        kw.setdefault("id", "log_" + uuid.uuid4().hex[:12])
-        kw.setdefault("ts_ms", now_ms())
-        cols = ["id", "ts_ms", "token_id", "token_label", "provider", "model", "status",
-                "prompt_tokens", "completion_tokens", "latency_ms", "streamed", "tools_used", "error"]
-        vals = [kw.get(c) for c in cols]
-        with self._lock:
-            self._conn.execute(
-                f"INSERT INTO logs ({','.join(cols)}) VALUES ({','.join('?' * len(cols))})", vals
-            )
-            self._conn.commit()
-
-    def list_logs(self, limit: int = 200) -> list[dict]:
-        with self._lock:
-            rows = self._conn.execute(
-                "SELECT * FROM logs ORDER BY ts_ms DESC LIMIT ?", (limit,)
-            ).fetchall()
-        return [dict(r) for r in rows]
-
-    def usage_summary(self) -> dict:
-        with self._lock:
-            r = self._conn.execute(
-                """SELECT COUNT(*) requests,
-                          COALESCE(SUM(prompt_tokens),0) prompt_tokens,
-                          COALESCE(SUM(completion_tokens),0) completion_tokens
-                   FROM logs"""
-            ).fetchone()
-        return dict(r)
-
-    def close(self) -> None:
-        with self._lock:
-            self._conn.close()