argus-gateway 0.1.0__tar.gz

argus_gateway-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: argus-gateway
+Version: 0.1.0
+Summary: Argus: the security layer for all AI models — an OpenAI-compatible AI gateway with pluggable threat detectors, policy enforcement, audit, and cost intelligence
+Author: Karmendra Pandey
+License: MIT
+Keywords: llm,ai-gateway,proxy,cost,routing,agents
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn>=0.29
+Requires-Dist: httpx>=0.27
+Requires-Dist: tokenecon>=0.2.0
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: httpx>=0.27; extra == "test"
+
+# Argus — the security layer for all AI models
+
+An OpenAI-compatible gateway that sits in front of **any** LLM — OpenAI,
+Anthropic, Bedrock, Gemini, Mistral, vLLM, Ollama, anything with an
+OpenAI-shaped endpoint — and enforces security policy before a model ever
+sees your data.
+
+Every request passes through the policy engine on the way in and on the way
+out. Cost intelligence (tiered routing, graceful budgets, per-task
+attribution) rides along via [tokenecon](https://pypi.org/project/tokenecon/),
+but security is the product.
+
+## The security layer
+
+```
+request -> auth -> INPUT policy -> budget -> route -> model
+                                              -> OUTPUT policy -> audit -> response
+```
+
+**Pluggable detectors** (each scans, the policy decides):
+
+| Detector | Catches | Default action |
+|---|---|---|
+| Secrets | AWS keys, private keys, GitHub/OpenAI tokens, `password = ...` | **block** — never reaches a model |
+| PII | emails, phones, SSNs, credit cards, IPs | **redact** — `[REDACTED:EMAIL]`, request continues |
+| Prompt injection | "ignore previous instructions", role overrides, system-prompt probes, known jailbreaks | **flag** — allowed but marked (one flag away from block) |
+| Blocklist | your own regexes | **block** |
+
+**Policy engine:** per-direction rules (`in` / `out` / `both`) with four
+actions — `allow`, `redact`, `block`, `flag`. Add an ML-based detector later
+by subclassing `Detector`; no other code changes.
+
+**Audit log:** every decision recorded — timestamp, key, task, detector,
+action, redacted snippet. Raw PII and secrets never touch the audit trail.
+`GET /admin/audit` for compliance review.
+
+## Quickstart
+
+```bash
+pip install argus-gateway
+export AIGW_MASTER_KEY="sk-admin-secret"
+export OPENAI_API_KEY="..."
+argus   # serves on 127.0.0.1:4000
+```
+
+Point any OpenAI client at it — one `base_url` change:
+
+```python
+import openai
+client = openai.OpenAI(api_key="<virtual-key>", base_url="http://localhost:4000/v1")
+```
+
+Self-hosted models sit behind the same layer:
+
+```python
+from gateway.providers.generic import GenericProvider
+# vLLM, Ollama, llama.cpp — any OpenAI-shaped endpoint
+```
+
+Every response carries what happened:
+
+```json
+"gateway": {
+  "provider": "openai", "tier": "small", "difficulty": 0.17,
+  "cost_usd": 0.000004, "degraded": false,
+  "security": {"redactions": ["pii:EMAIL"], "flags": ["prompt_injection:INSTRUCTION_OVERRIDE"]}
+}
+```
+
+## Also inside: cost intelligence
+
+- **Tiered routing** — requests scored for difficulty, cheapest capable tier wins
+- **Graceful budgets** — over budget? Falls back to the cheapest tier and flags
+  `degraded: true` instead of failing (hard-stop mode available)
+- **Per-task attribution** — `X-Task-Id` groups an agentic run's turns into one
+  costed task: `GET /admin/tasks/{id}`
+
+## Admin API (`X-Admin-Key` required)
+
+- `POST /admin/keys` — issue virtual keys with budgets (`degrade`/`hard`, daily/monthly)
+- `GET /admin/spend`, `GET /admin/keys/{id}/spend` — spend tracking
+- `GET /admin/tasks/{task_id}` — per-task cost breakdown
+- `GET /admin/audit?limit=&key_id=` — security decisions
+
+## Roadmap
+
+Streaming (SSE), Bedrock/Gemini/Mistral adapters, semantic caching,
+OTEL/Prometheus export, admin UI, SSO/RBAC, ML-based injection detector.
+
+## License
+
+MIT — Karmendra Pandey.

argus_gateway-0.1.0/README.md

@@ -0,0 +1,92 @@
+# Argus — the security layer for all AI models
+
+An OpenAI-compatible gateway that sits in front of **any** LLM — OpenAI,
+Anthropic, Bedrock, Gemini, Mistral, vLLM, Ollama, anything with an
+OpenAI-shaped endpoint — and enforces security policy before a model ever
+sees your data.
+
+Every request passes through the policy engine on the way in and on the way
+out. Cost intelligence (tiered routing, graceful budgets, per-task
+attribution) rides along via [tokenecon](https://pypi.org/project/tokenecon/),
+but security is the product.
+
+## The security layer
+
+```
+request -> auth -> INPUT policy -> budget -> route -> model
+                                              -> OUTPUT policy -> audit -> response
+```
+
+**Pluggable detectors** (each scans, the policy decides):
+
+| Detector | Catches | Default action |
+|---|---|---|
+| Secrets | AWS keys, private keys, GitHub/OpenAI tokens, `password = ...` | **block** — never reaches a model |
+| PII | emails, phones, SSNs, credit cards, IPs | **redact** — `[REDACTED:EMAIL]`, request continues |
+| Prompt injection | "ignore previous instructions", role overrides, system-prompt probes, known jailbreaks | **flag** — allowed but marked (one flag away from block) |
+| Blocklist | your own regexes | **block** |
+
+**Policy engine:** per-direction rules (`in` / `out` / `both`) with four
+actions — `allow`, `redact`, `block`, `flag`. Add an ML-based detector later
+by subclassing `Detector`; no other code changes.
+
+**Audit log:** every decision recorded — timestamp, key, task, detector,
+action, redacted snippet. Raw PII and secrets never touch the audit trail.
+`GET /admin/audit` for compliance review.
+
+## Quickstart
+
+```bash
+pip install argus-gateway
+export AIGW_MASTER_KEY="sk-admin-secret"
+export OPENAI_API_KEY="..."
+argus   # serves on 127.0.0.1:4000
+```
+
+Point any OpenAI client at it — one `base_url` change:
+
+```python
+import openai
+client = openai.OpenAI(api_key="<virtual-key>", base_url="http://localhost:4000/v1")
+```
+
+Self-hosted models sit behind the same layer:
+
+```python
+from gateway.providers.generic import GenericProvider
+# vLLM, Ollama, llama.cpp — any OpenAI-shaped endpoint
+```
+
+Every response carries what happened:
+
+```json
+"gateway": {
+  "provider": "openai", "tier": "small", "difficulty": 0.17,
+  "cost_usd": 0.000004, "degraded": false,
+  "security": {"redactions": ["pii:EMAIL"], "flags": ["prompt_injection:INSTRUCTION_OVERRIDE"]}
+}
+```
+
+## Also inside: cost intelligence
+
+- **Tiered routing** — requests scored for difficulty, cheapest capable tier wins
+- **Graceful budgets** — over budget? Falls back to the cheapest tier and flags
+  `degraded: true` instead of failing (hard-stop mode available)
+- **Per-task attribution** — `X-Task-Id` groups an agentic run's turns into one
+  costed task: `GET /admin/tasks/{id}`
+
+## Admin API (`X-Admin-Key` required)
+
+- `POST /admin/keys` — issue virtual keys with budgets (`degrade`/`hard`, daily/monthly)
+- `GET /admin/spend`, `GET /admin/keys/{id}/spend` — spend tracking
+- `GET /admin/tasks/{task_id}` — per-task cost breakdown
+- `GET /admin/audit?limit=&key_id=` — security decisions
+
+## Roadmap
+
+Streaming (SSE), Bedrock/Gemini/Mistral adapters, semantic caching,
+OTEL/Prometheus export, admin UI, SSO/RBAC, ML-based injection detector.
+
+## License
+
+MIT — Karmendra Pandey.

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

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: argus-gateway
+Version: 0.1.0
+Summary: Argus: the security layer for all AI models — an OpenAI-compatible AI gateway with pluggable threat detectors, policy enforcement, audit, and cost intelligence
+Author: Karmendra Pandey
+License: MIT
+Keywords: llm,ai-gateway,proxy,cost,routing,agents
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn>=0.29
+Requires-Dist: httpx>=0.27
+Requires-Dist: tokenecon>=0.2.0
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: httpx>=0.27; extra == "test"
+
+# Argus — the security layer for all AI models
+
+An OpenAI-compatible gateway that sits in front of **any** LLM — OpenAI,
+Anthropic, Bedrock, Gemini, Mistral, vLLM, Ollama, anything with an
+OpenAI-shaped endpoint — and enforces security policy before a model ever
+sees your data.
+
+Every request passes through the policy engine on the way in and on the way
+out. Cost intelligence (tiered routing, graceful budgets, per-task
+attribution) rides along via [tokenecon](https://pypi.org/project/tokenecon/),
+but security is the product.
+
+## The security layer
+
+```
+request -> auth -> INPUT policy -> budget -> route -> model
+                                              -> OUTPUT policy -> audit -> response
+```
+
+**Pluggable detectors** (each scans, the policy decides):
+
+| Detector | Catches | Default action |
+|---|---|---|
+| Secrets | AWS keys, private keys, GitHub/OpenAI tokens, `password = ...` | **block** — never reaches a model |
+| PII | emails, phones, SSNs, credit cards, IPs | **redact** — `[REDACTED:EMAIL]`, request continues |
+| Prompt injection | "ignore previous instructions", role overrides, system-prompt probes, known jailbreaks | **flag** — allowed but marked (one flag away from block) |
+| Blocklist | your own regexes | **block** |
+
+**Policy engine:** per-direction rules (`in` / `out` / `both`) with four
+actions — `allow`, `redact`, `block`, `flag`. Add an ML-based detector later
+by subclassing `Detector`; no other code changes.
+
+**Audit log:** every decision recorded — timestamp, key, task, detector,
+action, redacted snippet. Raw PII and secrets never touch the audit trail.
+`GET /admin/audit` for compliance review.
+
+## Quickstart
+
+```bash
+pip install argus-gateway
+export AIGW_MASTER_KEY="sk-admin-secret"
+export OPENAI_API_KEY="..."
+argus   # serves on 127.0.0.1:4000
+```
+
+Point any OpenAI client at it — one `base_url` change:
+
+```python
+import openai
+client = openai.OpenAI(api_key="<virtual-key>", base_url="http://localhost:4000/v1")
+```
+
+Self-hosted models sit behind the same layer:
+
+```python
+from gateway.providers.generic import GenericProvider
+# vLLM, Ollama, llama.cpp — any OpenAI-shaped endpoint
+```
+
+Every response carries what happened:
+
+```json
+"gateway": {
+  "provider": "openai", "tier": "small", "difficulty": 0.17,
+  "cost_usd": 0.000004, "degraded": false,
+  "security": {"redactions": ["pii:EMAIL"], "flags": ["prompt_injection:INSTRUCTION_OVERRIDE"]}
+}
+```
+
+## Also inside: cost intelligence
+
+- **Tiered routing** — requests scored for difficulty, cheapest capable tier wins
+- **Graceful budgets** — over budget? Falls back to the cheapest tier and flags
+  `degraded: true` instead of failing (hard-stop mode available)
+- **Per-task attribution** — `X-Task-Id` groups an agentic run's turns into one
+  costed task: `GET /admin/tasks/{id}`
+
+## Admin API (`X-Admin-Key` required)
+
+- `POST /admin/keys` — issue virtual keys with budgets (`degrade`/`hard`, daily/monthly)
+- `GET /admin/spend`, `GET /admin/keys/{id}/spend` — spend tracking
+- `GET /admin/tasks/{task_id}` — per-task cost breakdown
+- `GET /admin/audit?limit=&key_id=` — security decisions
+
+## Roadmap
+
+Streaming (SSE), Bedrock/Gemini/Mistral adapters, semantic caching,
+OTEL/Prometheus export, admin UI, SSO/RBAC, ML-based injection detector.
+
+## License
+
+MIT — Karmendra Pandey.

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

@@ -0,0 +1,27 @@
+README.md
+pyproject.toml
+argus_gateway.egg-info/PKG-INFO
+argus_gateway.egg-info/SOURCES.txt
+argus_gateway.egg-info/dependency_links.txt
+argus_gateway.egg-info/entry_points.txt
+argus_gateway.egg-info/requires.txt
+argus_gateway.egg-info/top_level.txt
+gateway/__init__.py
+gateway/auth.py
+gateway/config.py
+gateway/ledger.py
+gateway/router.py
+gateway/server.py
+gateway/providers/__init__.py
+gateway/providers/anthropic.py
+gateway/providers/base.py
+gateway/providers/generic.py
+gateway/providers/mock.py
+gateway/providers/openai.py
+gateway/security/__init__.py
+gateway/security/audit.py
+gateway/security/detectors.py
+gateway/security/policy.py
+tests/test_router.py
+tests/test_security.py
+tests/test_server.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+argus = gateway.server:run

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

@@ -0,0 +1,8 @@
+fastapi>=0.110
+uvicorn>=0.29
+httpx>=0.27
+tokenecon>=0.2.0
+
+[test]
+pytest>=8
+httpx>=0.27

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

@@ -0,0 +1 @@
+gateway

argus_gateway-0.1.0/gateway/__init__.py

@@ -0,0 +1,7 @@
+"""Argus: the security layer for all AI models.
+
+An OpenAI-compatible AI gateway with pluggable threat detectors, policy
+enforcement, audit logging, and cost intelligence.
+"""
+
+__version__ = "0.1.0"

argus_gateway-0.1.0/gateway/auth.py

@@ -0,0 +1,108 @@
+"""Virtual API keys: issuance, verification, and budget state.
+
+Keys are stored as SHA-256 hashes (the raw key is shown once at creation).
+Budgets are enforced per key; spend is read from the ledger.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import secrets
+import sqlite3
+import time
+from dataclasses import dataclass
+
+
+@dataclass
+class KeyRecord:
+    id: int
+    name: str
+    key_hash: str
+    budget_usd: float
+    period: str  # "daily" | "monthly"
+    mode: str  # "degrade" | "hard"
+    created_at: float
+    revoked: bool = False
+
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS keys (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    key_hash TEXT NOT NULL UNIQUE,
+    budget_usd REAL NOT NULL,
+    period TEXT NOT NULL DEFAULT 'monthly',
+    mode TEXT NOT NULL DEFAULT 'degrade',
+    created_at REAL NOT NULL,
+    revoked INTEGER NOT NULL DEFAULT 0
+);
+"""
+
+
+class KeyStore:
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        with sqlite3.connect(db_path) as c:
+            c.executescript(_SCHEMA)
+
+    @staticmethod
+    def _hash(raw: str) -> str:
+        return hashlib.sha256(raw.encode()).hexdigest()
+
+    def create(
+        self,
+        name: str,
+        budget_usd: float = 10.0,
+        period: str = "monthly",
+        mode: str = "degrade",
+    ) -> tuple[KeyRecord, str]:
+        """Create a key; returns (record, raw_key). Raw key is shown once."""
+        raw = "sk-gw-" + secrets.token_urlsafe(32)
+        rec = KeyRecord(
+            id=0,
+            name=name,
+            key_hash=self._hash(raw),
+            budget_usd=budget_usd,
+            period=period,
+            mode=mode,
+            created_at=time.time(),
+        )
+        with sqlite3.connect(self.db_path) as c:
+            cur = c.execute(
+                "INSERT INTO keys (name, key_hash, budget_usd, period, mode, created_at)"
+                " VALUES (?, ?, ?, ?, ?, ?)",
+                (rec.name, rec.key_hash, rec.budget_usd, rec.period, rec.mode, rec.created_at),
+            )
+            rec.id = cur.lastrowid
+        return rec, raw
+
+    def verify(self, raw: str) -> KeyRecord | None:
+        """Return the key record for a valid, non-revoked key, else None."""
+        with sqlite3.connect(self.db_path) as c:
+            row = c.execute(
+                "SELECT id, name, key_hash, budget_usd, period, mode, created_at, revoked"
+                " FROM keys WHERE key_hash = ?",
+                (self._hash(raw),),
+            ).fetchone()
+        if not row or row[7]:
+            return None
+        return KeyRecord(
+            id=row[0], name=row[1], key_hash=row[2], budget_usd=row[3],
+            period=row[4], mode=row[5], created_at=row[6], revoked=bool(row[7]),
+        )
+
+    def revoke(self, key_id: int) -> None:
+        with sqlite3.connect(self.db_path) as c:
+            c.execute("UPDATE keys SET revoked = 1 WHERE id = ?", (key_id,))
+
+    def list(self) -> list[KeyRecord]:
+        with sqlite3.connect(self.db_path) as c:
+            rows = c.execute(
+                "SELECT id, name, key_hash, budget_usd, period, mode, created_at, revoked"
+                " FROM keys ORDER BY id"
+            ).fetchall()
+        return [
+            KeyRecord(id=r[0], name=r[1], key_hash=r[2], budget_usd=r[3], period=r[4],
+                      mode=r[5], created_at=r[6], revoked=bool(r[7]))
+            for r in rows
+        ]

argus_gateway-0.1.0/gateway/config.py

@@ -0,0 +1,52 @@
+"""Gateway configuration: providers, tiers, and runtime settings.
+
+Providers are declared in code (or loaded from a dict); API keys come from
+the environment. Prices are tokenecon ModelTiers so routing and costing share
+one source of truth.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+from tokenecon import ModelTier
+
+from .providers.base import Provider
+
+
+@dataclass
+class ProviderEntry:
+    """One backend behind the gateway."""
+
+    provider: Provider
+    tier: ModelTier
+    models: List[str]  # model names this backend serves, e.g. ["gpt-4o-mini"]
+    enabled: bool = True
+
+
+@dataclass
+class GatewayConfig:
+    db_path: str = os.environ.get("AIGW_DB", "aigw.db")
+    master_key: str = os.environ.get("AIGW_MASTER_KEY", "sk-admin-changeme")
+    default_budget_usd: float = float(os.environ.get("AIGW_DEFAULT_BUDGET", "10.0"))
+    default_budget_mode: str = os.environ.get("AIGW_BUDGET_MODE", "degrade")  # degrade | hard
+    safety_margin: float = 0.1  # tier-selection margin, mirrors tokenecon router
+    providers: List[ProviderEntry] = field(default_factory=list)
+
+    def models(self) -> List[Dict[str, str]]:
+        """Model catalog in OpenAI /v1/models shape."""
+        out = []
+        for entry in self.providers:
+            if not entry.enabled:
+                continue
+            for m in entry.models:
+                out.append({"id": m, "object": "model", "owned_by": entry.provider.name})
+        return out
+
+    def entry_for_model(self, model: str) -> ProviderEntry | None:
+        for entry in self.providers:
+            if entry.enabled and model in entry.models:
+                return entry
+        return None

argus_gateway-0.1.0/gateway/ledger.py

@@ -0,0 +1,106 @@
+"""Cost ledger: every proxied call recorded; spend queryable per key and per task.
+
+A task groups the turns of one agentic run (client passes X-Task-Id). This is
+the per-task attribution LiteLLM-style gateways don't do.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import time
+from dataclasses import dataclass
+
+
+@dataclass
+class CallEntry:
+    key_id: int
+    task_id: str | None
+    provider: str
+    model: str
+    tier: str
+    input_tokens: int
+    output_tokens: int
+    cost_usd: float
+    degraded: bool = False
+
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS calls (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts REAL NOT NULL,
+    key_id INTEGER NOT NULL,
+    task_id TEXT,
+    provider TEXT NOT NULL,
+    model TEXT NOT NULL,
+    tier TEXT NOT NULL,
+    input_tokens INTEGER NOT NULL,
+    output_tokens INTEGER NOT NULL,
+    cost_usd REAL NOT NULL,
+    degraded INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_calls_key_ts ON calls (key_id, ts);
+CREATE INDEX IF NOT EXISTS idx_calls_task ON calls (task_id);
+"""
+
+
+class Ledger:
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        with sqlite3.connect(db_path) as c:
+            c.executescript(_SCHEMA)
+
+    def record(self, entry: CallEntry) -> int:
+        with sqlite3.connect(self.db_path) as c:
+            cur = c.execute(
+                "INSERT INTO calls (ts, key_id, task_id, provider, model, tier,"
+                " input_tokens, output_tokens, cost_usd, degraded)"
+                " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (time.time(), entry.key_id, entry.task_id, entry.provider,
+                 entry.model, entry.tier, entry.input_tokens, entry.output_tokens,
+                 entry.cost_usd, int(entry.degraded)),
+            )
+            return cur.lastrowid
+
+    def _period_start(self, period: str) -> float:
+        now = time.time()
+        if period == "daily":
+            return now - 86400
+        return now - 30 * 86400  # monthly ~= 30d
+
+    def key_spend(self, key_id: int, period: str = "monthly") -> float:
+        with sqlite3.connect(self.db_path) as c:
+            row = c.execute(
+                "SELECT COALESCE(SUM(cost_usd), 0) FROM calls WHERE key_id = ? AND ts >= ?",
+                (key_id, self._period_start(period)),
+            ).fetchone()
+        return float(row[0])
+
+    def task_spend(self, task_id: str) -> dict:
+        """Totals + per-call breakdown for one task id."""
+        with sqlite3.connect(self.db_path) as c:
+            rows = c.execute(
+                "SELECT ts, provider, model, tier, input_tokens, output_tokens,"
+                " cost_usd, degraded FROM calls WHERE task_id = ? ORDER BY ts",
+                (task_id,),
+            ).fetchall()
+        calls = [
+            {"ts": r[0], "provider": r[1], "model": r[2], "tier": r[3],
+             "input_tokens": r[4], "output_tokens": r[5],
+             "cost_usd": r[6], "degraded": bool(r[7])}
+            for r in rows
+        ]
+        return {
+            "task_id": task_id,
+            "calls": len(calls),
+            "total_cost_usd": round(sum(c["cost_usd"] for c in calls), 6),
+            "total_tokens": sum(c["input_tokens"] + c["output_tokens"] for c in calls),
+            "breakdown": calls,
+        }
+
+    def total_spend(self) -> dict:
+        with sqlite3.connect(self.db_path) as c:
+            row = c.execute(
+                "SELECT COUNT(*), COALESCE(SUM(cost_usd), 0),"
+                " COALESCE(SUM(input_tokens + output_tokens), 0) FROM calls"
+            ).fetchone()
+        return {"calls": row[0], "total_cost_usd": round(row[1], 6), "total_tokens": row[2]}

argus_gateway-0.1.0/gateway/providers/__init__.py

@@ -0,0 +1,5 @@
+"""Provider adapters: one normalized interface per LLM provider."""
+
+from .base import ChatMessage, ChatRequest, ChatResponse, Provider
+
+__all__ = ["ChatMessage", "ChatRequest", "ChatResponse", "Provider"]