brevitas-systems 0.2.0__tar.gz

brevitas_systems-0.2.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: brevitas-systems
+Version: 0.2.0
+Summary: Lossless token savings + per-pipeline/agent tracking between your agents and the model.
+License: Proprietary
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: tiktoken>=0.7.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: fastapi>=0.111.0
+Requires-Dist: uvicorn[standard]>=0.29.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: retrieval
+Requires-Dist: sentence-transformers>=2.2.0; extra == "retrieval"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.28.0; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.30.0; extra == "openai"
+Provides-Extra: all
+Requires-Dist: sentence-transformers>=2.2.0; extra == "all"
+Requires-Dist: anthropic>=0.28.0; extra == "all"
+Requires-Dist: openai>=1.30.0; extra == "all"
+
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+site: https://brevitassystems.com
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

brevitas_systems-0.2.0/README.md

@@ -0,0 +1,38 @@
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+site: https://brevitassystems.com
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

brevitas_systems-0.2.0/brevitas/__init__.py

@@ -0,0 +1,71 @@
+"""
+Brevitas — drop lossless token savings between your agents and the model.
+
+Quick start (importable service — recommended):
+    from brevitas import BrevitasClient
+
+    client = BrevitasClient(provider="openai", api_key="sk-...")
+    response, savings = client.chat(
+        messages=[{"role": "system", "content": BRAND_PROMPT},
+                  {"role": "user", "content": "Write a tweet for our oak table."}],
+        model="gpt-4o", session_id="marketing-agent",
+    )
+    print(savings.savings_pct, savings.cache_placement["strategy"])
+
+The client auto-routes every call (cache vs retrieve), keeps the prefix byte-identical so
+provider caching fires, learns each provider's real cache-hit rate, and reports honest
+savings. Lossless — never drops load-bearing content; fails safe to full context.
+
+Quick start (SDK wrapper around an existing client):
+    import anthropic, brevitas
+    client = brevitas.wrap(anthropic.Anthropic(api_key="sk-ant-..."))
+
+    # All calls are now automatically compressed
+    response = client.messages.create(
+        model="claude-sonnet-4-6",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "..."}],
+    )
+
+Quick start (zero-code proxy):
+    $ brevitas start --api-key bvt_... --port 4242
+    $ export ANTHROPIC_BASE_URL=http://localhost:4242
+    # Your existing code works unchanged.
+"""
+from .config import configure, get as get_config
+from .session import BrevitasSession
+from .labels import start_run, agent, get_pipeline, get_agent, get_run_id, resolve_labels
+from token_efficiency_model.lossless import BrevitasClient, SavingsReport, BrevitasRouter
+
+
+def wrap(client, session: BrevitasSession | None = None):
+    """
+    Wrap an Anthropic or OpenAI client.
+
+    Returns a drop-in replacement that compresses messages before each call
+    and tracks multi-hop context within the same pipeline run.
+
+    Args:
+        client:  An anthropic.Anthropic or openai.OpenAI instance.
+        session: Optional existing BrevitasSession (creates a new one if omitted).
+    """
+    # Anthropic detection: has .messages attribute with a .create method
+    if hasattr(client, "messages") and hasattr(getattr(client, "messages", None), "create"):
+        from .wrappers.anthropic import BrevitasAnthropicClient
+        return BrevitasAnthropicClient(client, session=session)
+
+    # OpenAI detection: has .chat.completions
+    if hasattr(client, "chat") and hasattr(getattr(client, "chat", None), "completions"):
+        from .wrappers.openai import BrevitasOpenAIClient
+        return BrevitasOpenAIClient(client, session=session)
+
+    raise TypeError(
+        f"brevitas.wrap() does not recognise client type {type(client).__name__!r}. "
+        "Pass an anthropic.Anthropic or openai.OpenAI instance."
+    )
+
+
+__all__ = ["BrevitasClient", "SavingsReport", "BrevitasRouter",
+           "configure", "get_config", "wrap", "BrevitasSession",
+           "start_run", "agent", "get_pipeline", "get_agent", "get_run_id", "resolve_labels"]
+__version__ = "0.2.0"

brevitas_systems-0.2.0/brevitas/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

brevitas_systems-0.2.0/brevitas/_compress.py

@@ -0,0 +1,174 @@
+"""
+Shared compression + usage-reporting logic used by both the SDK wrappers and the proxy.
+All compression is done by calling the Brevitas REST API so every call is tracked.
+"""
+from __future__ import annotations
+
+import httpx
+
+from .config import get as _cfg
+from .session import BrevitasSession
+
+try:
+    import tiktoken
+    _enc = tiktoken.get_encoding("cl100k_base")
+    def _count_tokens(text: str) -> int:
+        return len(_enc.encode(text, disallowed_special=()))
+except Exception:
+    def _count_tokens(text: str) -> int:
+        return max(1, int(len(text.split()) * 1.3))
+
+
+def count_messages_tokens(messages: list[dict]) -> int:
+    total = 0
+    for m in messages:
+        content = m.get("content", "")
+        if isinstance(content, str):
+            total += _count_tokens(content)
+        elif isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "text":
+                    total += _count_tokens(block.get("text", ""))
+    return total
+
+
+def compress_messages(
+    messages: list[dict],
+    session: BrevitasSession,
+    task: str = "",
+    complexity: float = 0.5,
+    compression_level: int = 2,
+    prune_budget: int = 5,
+    pipeline: str = "",
+    agent: str = "",
+    run_id: str = "",
+) -> tuple[list[dict], int, int]:
+    """
+    Compress a messages list via the Brevitas API, preserving prefix stability.
+    Only the LAST user message is compressed (volatile tail).
+    All earlier messages (system + tools + prior turns = stable prefix) are left BYTE-IDENTICAL.
+    Returns (compressed_messages, baseline_tokens, compressed_tokens).
+    If compression fails or is disabled, returns the original messages unchanged.
+    """
+    cfg = _cfg()
+    if not cfg.get("enabled") or not cfg.get("api_key"):
+        baseline = count_messages_tokens(messages)
+        return messages, baseline, baseline
+
+    baseline_tokens = count_messages_tokens(messages)
+
+    # Find the index of the last user-role message (volatile tail)
+    last_user_idx = -1
+    for i in range(len(messages) - 1, -1, -1):
+        if messages[i].get("role") == "user":
+            last_user_idx = i
+            break
+
+    # If no user message, return unchanged
+    if last_user_idx < 0:
+        return messages, baseline_tokens, baseline_tokens
+
+    # Extract only the last user message for compression
+    last_msg = messages[last_user_idx]
+    content = last_msg.get("content", "")
+    if isinstance(content, str):
+        last_text = content
+    elif isinstance(content, list):
+        parts = [b.get("text", "") for b in content if isinstance(b, dict) and b.get("type") == "text"]
+        last_text = " ".join(parts)
+    else:
+        return messages, baseline_tokens, baseline_tokens
+
+    prior = session.prior_context()
+
+    try:
+        resp = httpx.post(
+            f"{cfg['base_url']}/v1/compress",
+            headers={"X-API-Key": cfg["api_key"]},
+            json={
+                "task": task or (last_text[:200] if last_text else ""),
+                "messages": [last_text],  # Only compress the last user message
+                "prior_context": prior,
+                "complexity": complexity,
+                "compression_level": compression_level,
+                "prune_budget": prune_budget,
+                "pipeline": pipeline,
+                "agent": agent,
+                "run_id": run_id,
+                # report_usage() below records the billing row via /v1/usage;
+                # don't also record here or every call double-counts.
+                "meter": False,
+            },
+            timeout=cfg.get("timeout", 30),
+        )
+        resp.raise_for_status()
+        data = resp.json()
+    except Exception:
+        return messages, baseline_tokens, baseline_tokens
+
+    compressed_texts = data.get("compressed_messages", [last_text])
+
+    # Rebuild messages: prefix stays IDENTICAL, only last user message may change
+    out_messages: list[dict] = []
+    for i, m in enumerate(messages):
+        if i == last_user_idx and compressed_texts:
+            # Replace only the last user message with its compressed version
+            new_m = dict(m)
+            if isinstance(m.get("content"), list):
+                new_m["content"] = [{"type": "text", "text": compressed_texts[0]}]
+            else:
+                new_m["content"] = compressed_texts[0]
+            out_messages.append(new_m)
+        else:
+            # All other messages pass through unchanged (same dict, same content)
+            out_messages.append(m)
+
+    # Remember the pipeline's quality estimate so report_usage() can forward it
+    # to the billing quality gate (otherwise savings are never billed).
+    session.last_quality = data.get("quality_proxy")
+
+    # Use the server's authoritative counts for BOTH baseline and optimized so
+    # report_usage compares like-for-like. The client-side baseline counted only
+    # the messages (not prior_context), while optimized comes from the server and
+    # includes pruned context — mixing them made multi-hop calls look like a loss
+    # (compressed >= baseline) and get dropped from billing.
+    server_baseline = data.get("baseline_tokens")
+    if server_baseline:
+        baseline_tokens = int(server_baseline)
+    compressed_tokens = data.get("optimized_tokens", count_messages_tokens(out_messages))
+    return out_messages, baseline_tokens, compressed_tokens
+
+
+def report_usage(
+    provider: str,
+    model: str,
+    baseline_tokens: int,
+    compressed_tokens: int,
+    session: BrevitasSession,
+    pipeline: str = "",
+    agent: str = "",
+    run_id: str = "",
+) -> None:
+    """Report usage to Brevitas for billing. Fire-and-forget."""
+    cfg = _cfg()
+    if not cfg.get("api_key") or baseline_tokens <= compressed_tokens:
+        return
+    try:
+        httpx.post(
+            f"{cfg['base_url']}/v1/usage",
+            headers={"X-API-Key": cfg["api_key"]},
+            json={
+                "provider": provider,
+                "model": model,
+                "baseline_tokens": baseline_tokens,
+                "compressed_tokens": compressed_tokens,
+                "session_id": session.session_id,
+                "pipeline": pipeline,
+                "agent": agent,
+                "run_id": run_id,
+                "quality_score": session.last_quality,
+            },
+            timeout=5,
+        )
+    except Exception:
+        pass  # billing reporting is best-effort; never break the user's pipeline

brevitas_systems-0.2.0/brevitas/cli.py

@@ -0,0 +1,107 @@
+"""
+brevitas CLI
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+import click
+
+try:
+    from rich.console import Console
+    from rich.table import Table
+    _console = Console()
+except ImportError:
+    _console = None
+
+
+def _print(msg: str) -> None:
+    if _console:
+        _console.print(msg)
+    else:
+        print(msg)
+
+
+@click.group()
+def main() -> None:
+    """Brevitas — drop compression between your agents."""
+
+
+@main.command()
+@click.option("--port",     default=4242,                    show_default=True, help="Proxy listen port")
+@click.option("--api-key",  default="",  envvar="BREVITAS_API_KEY",            help="Your Brevitas API key")
+@click.option("--base-url", default="http://localhost:8000", envvar="BREVITAS_BASE_URL", show_default=True, help="Brevitas API base URL")
+@click.option("--host",     default="127.0.0.1",             show_default=True, help="Bind host")
+def start(port: int, api_key: str, base_url: str, host: str) -> None:
+    """Start the local Brevitas proxy server."""
+    if api_key:
+        os.environ["BREVITAS_API_KEY"]  = api_key
+    if base_url:
+        os.environ["BREVITAS_BASE_URL"] = base_url
+
+    from . import configure
+    configure(api_key=api_key or os.getenv("BREVITAS_API_KEY", ""), base_url=base_url)
+
+    _print(f"\n[bold green]Brevitas proxy starting on {host}:{port}[/bold green]")
+    _print(f"  Compression API → [cyan]{base_url}[/cyan]")
+    _print("\n[dim]Set your SDK base URL:[/dim]")
+    _print(f"  [yellow]ANTHROPIC_BASE_URL=http://{host}:{port}[/yellow]")
+    _print(f"  [yellow]OPENAI_BASE_URL=http://{host}:{port}/openai[/yellow]\n")
+
+    try:
+        import uvicorn
+        from .proxy import proxy_app
+        uvicorn.run(proxy_app, host=host, port=port, log_level="warning")
+    except ImportError:
+        _print("[red]uvicorn not installed. Run: pip install brevitas-systems[/red]")
+        sys.exit(1)
+
+
+@main.command()
+@click.argument("key")
+@click.argument("value")
+def config(key: str, value: str) -> None:
+    """Set a config value (api-key, base-url)."""
+    cfg_map = {"api-key": "BREVITAS_API_KEY", "base-url": "BREVITAS_BASE_URL"}
+    env_key = cfg_map.get(key.lower())
+    if not env_key:
+        _print(f"[red]Unknown config key '{key}'. Valid: {list(cfg_map)}[/red]")
+        sys.exit(1)
+    _print(f"[green]Set {env_key}={value}[/green]")
+    _print(f"[dim]Add to your shell profile: export {env_key}={value}[/dim]")
+
+
+@main.command()
+@click.option("--api-key",  default="", envvar="BREVITAS_API_KEY")
+@click.option("--base-url", default="http://localhost:8000", envvar="BREVITAS_BASE_URL")
+def status(api_key: str, base_url: str) -> None:
+    """Check connectivity to the Brevitas API."""
+    import httpx
+    _print(f"\nChecking [cyan]{base_url}/v1/health[/cyan] …")
+    try:
+        r = httpx.get(f"{base_url}/v1/health", timeout=5)
+        if r.status_code == 200:
+            _print("[green]✓ Brevitas API reachable[/green]")
+        else:
+            _print(f"[yellow]API returned {r.status_code}[/yellow]")
+    except Exception as e:
+        _print(f"[red]✗ Could not reach API: {e}[/red]")
+        return
+
+    if api_key:
+        try:
+            r = httpx.get(f"{base_url}/v1/stats", headers={"X-API-Key": api_key}, timeout=5)
+            if r.status_code == 200:
+                data = r.json()
+                _print(f"[green]✓ API key valid[/green]")
+                _print(f"  Total calls:       {data.get('total_calls', 0)}")
+                _print(f"  Total tokens saved: {data.get('total_tokens_saved', 0):,}")
+                _print(f"  Total cost saved:  ${data.get('total_cost_saved_usd', 0):.4f}")
+                _print(f"  Brevitas fee owed: ${data.get('total_brevitas_fee_usd', 0):.4f}")
+            else:
+                _print(f"[red]✗ API key invalid (status {r.status_code})[/red]")
+        except Exception as e:
+            _print(f"[red]✗ Stats check failed: {e}[/red]")
+    else:
+        _print("[dim]No API key set — set BREVITAS_API_KEY to check usage[/dim]")

brevitas_systems-0.2.0/brevitas/config.py

@@ -0,0 +1,24 @@
+import os
+
+_cfg: dict = {
+    "api_key":  os.getenv("BREVITAS_API_KEY", ""),
+    "base_url": os.getenv("BREVITAS_BASE_URL", "http://localhost:8000"),
+    "enabled":  os.getenv("BREVITAS_ENABLED", "true").lower() != "false",
+    "timeout":  30,
+}
+
+
+def configure(
+    api_key: str = "",
+    base_url: str = "",
+    enabled: bool = True,
+    timeout: int = 30,
+) -> None:
+    if api_key:   _cfg["api_key"]  = api_key
+    if base_url:  _cfg["base_url"] = base_url.rstrip("/")
+    _cfg["enabled"] = enabled
+    _cfg["timeout"] = timeout
+
+
+def get() -> dict:
+    return dict(_cfg)

brevitas_systems-0.2.0/brevitas/labels.py

@@ -0,0 +1,86 @@
+"""
+Contextvar-based label propagation for tracking pipeline/agent/run_id.
+
+Resolution order (highest to lowest priority):
+1. Per-call _brevitas_meta override
+2. Contextvar value (set by start_run/agent context managers)
+3. Default (empty string)
+"""
+from contextvars import ContextVar
+from contextlib import contextmanager
+import secrets
+from typing import Optional, Dict, Any
+
+
+# Context variables for label propagation
+_pipeline_var: ContextVar[str] = ContextVar("brevitas_pipeline", default="")
+_agent_var: ContextVar[str] = ContextVar("brevitas_agent", default="")
+_run_id_var: ContextVar[str] = ContextVar("brevitas_run_id", default="")
+
+
+def start_run(pipeline: str = "", run_id: str = "") -> str:
+    """
+    Start a new run context, setting pipeline and run_id labels.
+    Auto-generates run_id if not provided.
+    Returns the run_id.
+    """
+    if not run_id:
+        run_id = "run_" + secrets.token_urlsafe(12)
+
+    _pipeline_var.set(pipeline)
+    _run_id_var.set(run_id)
+    return run_id
+
+
+def get_pipeline() -> str:
+    """Get the current pipeline label from contextvar."""
+    return _pipeline_var.get("")
+
+
+def get_agent() -> str:
+    """Get the current agent label from contextvar."""
+    return _agent_var.get("")
+
+
+def get_run_id() -> str:
+    """Get the current run_id label from contextvar."""
+    return _run_id_var.get("")
+
+
+@contextmanager
+def agent(agent_name: str):
+    """
+    Context manager to set the agent label for all calls within the block.
+    Example:
+        with agent("copywriter"):
+            client.messages.create(...)  # auto-tagged with agent="copywriter"
+    """
+    token = _agent_var.set(agent_name)
+    try:
+        yield
+    finally:
+        _agent_var.reset(token)
+
+
+def resolve_labels(
+    _brevitas_meta: Optional[Dict[str, Any]] = None,
+) -> Dict[str, str]:
+    """
+    Resolve labels using the priority order:
+    1. Per-call _brevitas_meta override (highest)
+    2. Contextvar value (set by start_run/agent)
+    3. Default empty string (lowest)
+
+    Args:
+        _brevitas_meta: Optional per-call override dict with 'pipeline', 'agent', 'run_id'
+
+    Returns:
+        Dict with 'pipeline', 'agent', 'run_id' keys
+    """
+    _brevitas_meta = _brevitas_meta or {}
+
+    return {
+        "pipeline": _brevitas_meta.get("pipeline") or get_pipeline(),
+        "agent": _brevitas_meta.get("agent") or get_agent(),
+        "run_id": _brevitas_meta.get("run_id") or get_run_id(),
+    }