teardrop-cli 0.1.0__py3-none-any.whl

teardrop_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

teardrop_cli/_fixtures.py

@@ -0,0 +1,132 @@
+"""Test fixture helpers shared across test modules."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+
+def make_jwt_payload(
+    sub: str = "user@example.com",
+    org: str = "acme",
+    role: str = "admin",
+) -> MagicMock:
+    """Return a minimal JwtPayloadBase-like mock."""
+    payload = MagicMock()
+    payload.sub = sub
+    payload.org = org
+    payload.role = role
+    payload.model_dump = lambda: {"sub": sub, "org": org, "role": role}
+    return payload
+
+
+def make_sse_events(text: str) -> list[MagicMock]:
+    """Build a minimal sequence of SSE events for a successful agent run."""
+    events = []
+
+    # text chunk
+    chunk = MagicMock()
+    chunk.type = "text_msg_content"
+    chunk.data = {"content": text}
+    events.append(chunk)
+
+    # usage summary
+    usage = MagicMock()
+    usage.type = "usage_summary"
+    usage.data = {"input_tokens": 5, "output_tokens": 10, "total_cost_usd": 0.0001}
+    events.append(usage)
+
+    # done
+    done = MagicMock()
+    done.type = "done"
+    done.data = None
+    events.append(done)
+
+    return events
+
+
+def make_llm_config(
+    org_id: str = "org-1",
+    provider: str = "anthropic",
+    model: str = "claude-haiku-4-5-20251001",
+    has_api_key: bool = False,
+    api_base: str | None = None,
+    max_tokens: int = 4096,
+    temperature: float = 0.0,
+    timeout_seconds: int = 120,
+    routing_preference: str = "default",
+    is_byok: bool = False,
+) -> MagicMock:
+    """Return a minimal OrgLlmConfig-like mock."""
+    data = {
+        "org_id": org_id,
+        "provider": provider,
+        "model": model,
+        "has_api_key": has_api_key,
+        "api_base": api_base,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "timeout_seconds": timeout_seconds,
+        "routing_preference": routing_preference,
+        "is_byok": is_byok,
+        "created_at": "2026-04-16T10:00:00Z",
+        "updated_at": "2026-04-16T10:00:00Z",
+    }
+    obj = MagicMock()
+    obj.model_dump = lambda: dict(data)
+    for k, v in data.items():
+        setattr(obj, k, v)
+    return obj
+
+
+def make_siwe_session(
+    session_id: str = "siwe_sess_1",
+    status: str = "pending",
+    nonce: str = "abc123nonce",
+    jwt: str | None = None,
+) -> MagicMock:
+    """Return a minimal SiweSession-like mock."""
+    data = {
+        "id": session_id,
+        "status": status,
+        "nonce": nonce,
+        "jwt": jwt,
+    }
+    obj = MagicMock()
+    obj.model_dump = lambda: dict(data)
+    for k, v in data.items():
+        setattr(obj, k, v)
+    return obj
+
+
+def make_benchmarks_response(models: list[dict] | None = None) -> MagicMock:
+    """Return a minimal ModelBenchmarksResponse-like mock."""
+    if models is None:
+        models = [
+            {
+                "provider": "anthropic",
+                "model": "claude-haiku-4-5-20251001",
+                "display_name": "Claude Haiku 4.5",
+                "context_window": 200000,
+                "supports_tools": True,
+                "supports_streaming": True,
+                "quality_tier": 2,
+                "pricing": {
+                    "tokens_in_cost_per_1k": 0.08,
+                    "tokens_out_cost_per_1k": 0.24,
+                    "tool_call_cost": 0.0,
+                },
+                "benchmarks": {
+                    "total_runs_7d": 1250,
+                    "avg_latency_ms": 485.5,
+                    "p95_latency_ms": 1200.0,
+                    "avg_cost_usdc_per_run": 12.5,
+                    "avg_tokens_per_sec": 45.2,
+                },
+            }
+        ]
+    data = {"models": models, "updated_at": "2026-04-16T12:00:00Z"}
+    obj = MagicMock()
+    obj.model_dump = lambda: dict(data)
+    obj.models = models
+    obj.updated_at = data["updated_at"]
+    return obj

teardrop_cli/_lazy.py

@@ -0,0 +1,67 @@
+"""Lazy subcommand loading for Typer/Click apps.
+
+Defers module imports until a subcommand is actually invoked, keeping
+``teardrop --help`` fast by avoiding top-level imports of heavy
+dependencies (httpx, teardrop_sdk, etc.).
+"""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+import click
+
+if TYPE_CHECKING:
+    pass
+
+
+class LazyGroup(click.Group):
+    """A Click Group that imports subcommand modules on demand."""
+
+    def __init__(
+        self,
+        *args,
+        lazy_subcommands: dict[str, str] | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        # Maps command name -> "module.path:attr_name"
+        self._lazy: dict[str, str] = lazy_subcommands or {}
+
+    # ------------------------------------------------------------------
+    # Click Group overrides
+    # ------------------------------------------------------------------
+
+    def list_commands(self, ctx: click.Context) -> list[str]:
+        base = super().list_commands(ctx)
+        return sorted(set(base) | set(self._lazy.keys()))
+
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
+        if cmd_name in self._lazy:
+            return self._load(cmd_name)
+        return super().get_command(ctx, cmd_name)
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _load(self, cmd_name: str) -> click.Command:
+        import_path = self._lazy[cmd_name]
+        if ":" in import_path:
+            modname, attr = import_path.rsplit(":", 1)
+        else:
+            # Legacy dot-separated (last segment is attribute)
+            modname, attr = import_path.rsplit(".", 1)
+
+        mod = importlib.import_module(modname)
+        cmd = getattr(mod, attr)
+
+        # Typer apps must be converted to Click commands before use
+        # Import here to avoid top-level dependency on typer
+        import typer
+
+        if isinstance(cmd, typer.Typer):
+            cmd = typer.main.get_command(cmd)
+
+        return cmd

teardrop_cli/cli.py

@@ -0,0 +1,41 @@
+"""Main CLI entry point for teardrop-cli.
+
+The root command is a plain Click Group (via LazyGroup) so that unknown
+kwargs like ``lazy_subcommands`` are forwarded correctly.  Subcommand
+modules are imported only when the subcommand is actually invoked, keeping
+``teardrop --help`` well under 100 ms.
+"""
+
+from __future__ import annotations
+
+import click
+
+from teardrop_cli._lazy import LazyGroup
+
+
+@click.group(
+    name="teardrop",
+    cls=LazyGroup,
+    lazy_subcommands={
+        "auth": "teardrop_cli.commands.auth:app",
+        "agent": "teardrop_cli.commands.agent:app",
+        "billing": "teardrop_cli.commands.billing:app",
+        "llm-config": "teardrop_cli.commands.llm_config:app",
+        "marketplace": "teardrop_cli.commands.marketplace:app",
+        "mcp": "teardrop_cli.commands.mcp:app",
+        "models": "teardrop_cli.commands.models:app",
+        "tools": "teardrop_cli.commands.tools:app",
+    },
+    context_settings={"help_option_names": ["-h", "--help"]},
+    invoke_without_command=True,
+)
+@click.version_option(package_name="teardrop-cli", prog_name="teardrop")
+@click.pass_context
+def app(ctx: click.Context) -> None:
+    """Teardrop AI — crypto-native agent orchestration & marketplace."""
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+if __name__ == "__main__":
+    app()

teardrop_cli/commands/agent.py

@@ -0,0 +1,190 @@
+"""agent commands: run."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from typing import Annotated
+
+import typer
+
+app = typer.Typer(
+    name="agent",
+    help="Run prompts against the Teardrop AI agent.",
+    no_args_is_help=True,
+)
+
+
+@app.callback()
+def _callback() -> None:
+    """Run prompts against the Teardrop AI agent."""
+
+
+# SSE event type constants (must match teardrop_sdk's streaming module)
+_EV_TEXT = "text_msg_content"
+_EV_TOOL_START = "tool_call_start"
+_EV_TOOL_END = "tool_call_end"
+_EV_USAGE = "usage_summary"
+_EV_BILLING = "billing_settlement"
+_EV_ERROR = "error"
+_EV_DONE = "done"
+
+
+@app.command()
+def run(
+    prompt: Annotated[str, typer.Argument(help="The prompt to send to the agent.")],
+    thread_id: Annotated[
+        str | None, typer.Option("--thread-id", "-t", help="Continue an existing thread.")
+    ] = None,
+    model: Annotated[str | None, typer.Option("--model", "-m", help="Model override.")] = None,
+    as_json: Annotated[
+        bool,
+        typer.Option("--json", help="Emit raw SSE events as JSON lines (machine-readable)."),
+    ] = False,
+    base_url: Annotated[
+        str | None, typer.Option("--base-url", help="Override the API base URL.", hidden=True)
+    ] = None,
+) -> None:
+    """Send a prompt to the agent and stream the response."""
+    from teardrop import PaymentRequiredError, RateLimitError
+
+    from teardrop_cli import config
+    from teardrop_cli.formatting import print_error
+
+    client = config.get_client(base_url)
+
+    try:
+        if as_json:
+            asyncio.run(_run_json(client, prompt, thread_id=thread_id, model=model))
+        else:
+            asyncio.run(_run_rich(client, prompt, thread_id=thread_id, model=model))
+    except PaymentRequiredError:
+        print_error(
+            "Insufficient balance.",
+            hint=f"Top up your account at {config.get_base_url()}/billing",
+        )
+        raise typer.Exit(2) from None
+    except RateLimitError as exc:
+        retry = getattr(exc, "retry_after", None)
+        hint = f"Retry in {retry}s." if retry else "Please wait before retrying."
+        print_error("Rate limited.", hint=hint)
+        raise typer.Exit(3) from None
+    except KeyboardInterrupt:
+        raise typer.Exit(130) from None
+
+
+# ---------------------------------------------------------------------------
+# Rich streaming renderer
+# ---------------------------------------------------------------------------
+
+
+async def _run_rich(client, prompt: str, *, thread_id, model) -> None:
+    """Stream response with Rich Live rendering."""
+    from rich.live import Live
+    from rich.markdown import Markdown
+
+    from teardrop_cli.formatting import _print_billing_settlement, _print_usage_summary, console
+
+    try:
+        accumulated = ""
+        tool_depth = 0
+
+        live = Live(
+            Markdown(""),
+            console=console,
+            refresh_per_second=15,
+            auto_refresh=True,
+            transient=False,
+        )
+
+        # Show a quick spinner before first token arrives
+        first_token = True
+
+        with live:
+            async for event in client.run(prompt, thread_id=thread_id, model=model):
+                ev_type: str = getattr(event, "type", "") or ""
+                data = getattr(event, "data", None)
+
+                if ev_type == _EV_TEXT:
+                    if first_token:
+                        first_token = False
+                    chunk = _extract_text(data)
+                    accumulated += chunk
+                    live.update(Markdown(accumulated))
+
+                elif ev_type == _EV_TOOL_START:
+                    tool_depth += 1
+                    tool_name = _extract_tool_name(data)
+                    indicator = f"\n\n*[Tool: {tool_name}…]*"
+                    live.update(Markdown(accumulated + indicator))
+
+                elif ev_type == _EV_TOOL_END:
+                    tool_depth = max(0, tool_depth - 1)
+                    if tool_depth == 0:
+                        live.update(Markdown(accumulated))
+
+                elif ev_type == _EV_USAGE:
+                    if isinstance(data, dict):
+                        live.stop()
+                        _print_usage_summary(data)
+
+                elif ev_type == _EV_BILLING:
+                    if isinstance(data, dict):
+                        _print_billing_settlement(data)
+
+                elif ev_type == _EV_ERROR:
+                    msg = _extract_text(data) or "Unknown agent error"
+                    live.stop()
+                    from teardrop_cli.formatting import print_error
+
+                    print_error(f"Agent error: {msg}")
+                    raise typer.Exit(5)
+
+                elif ev_type == _EV_DONE:
+                    break
+
+        console.print()  # trailing newline after stream
+    finally:
+        await client.close()
+
+
+# ---------------------------------------------------------------------------
+# JSON streaming renderer (machine-readable)
+# ---------------------------------------------------------------------------
+
+
+async def _run_json(client, prompt: str, *, thread_id, model) -> None:
+    """Emit each SSE event as a JSON line to stdout."""
+    try:
+        async for event in client.run(prompt, thread_id=thread_id, model=model):
+            line = json.dumps(
+                {
+                    "type": getattr(event, "type", None),
+                    "data": getattr(event, "data", None),
+                },
+                default=str,
+            )
+            sys.stdout.write(line + "\n")
+            sys.stdout.flush()
+    finally:
+        await client.close()
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _extract_text(data) -> str:
+    if isinstance(data, dict):
+        return data.get("content", data.get("message", data.get("text", "")))
+    if isinstance(data, str):
+        return data
+    return ""
+
+
+def _extract_tool_name(data) -> str:
+    if isinstance(data, dict):
+        return data.get("tool_name", data.get("name", "unknown"))
+    return "unknown"