bridgenode-cli 0.1.0__tar.gz

bridgenode_cli-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: bridgenode-cli
+Version: 0.1.0
+Summary: BridgeNode CLI — AI inference su x402 mokėjimu (Solana USDC). Jokių API key.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: bridgenode-llm>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=9.1.1; extra == "dev"
+
+# bridgenode-cli
+
+BridgeNode CLI — AI inference be API key. Mokėjimas: **Solana USDC per x402** (automatinis handshake, fee sponsorship — SOL nereikia).
+
+## Diegimas
+
+```bash
+pip install bridgenode-cli
+```
+
+## Naudojimas
+
+```bash
+# Vienas chat completion (x402 handshake paslėptas, §4.1)
+bridgenode chat "Labas!" --model deepseek-v4-flash
+
+# Smart routing (§5.1/§5.8): auto / eco / premium
+bridgenode chat "Išanalizuok šį kodą" --mode auto
+
+# Modelių sąrašas + kainos (§5.2) — be mokėjimo
+bridgenode models
+```
+
+## Parinktys
+
+| Parinktis | Aprašas |
+|---|---|
+| `--model` | Explicit model id (žr. `bridgenode models`) |
+| `--mode` | `auto` / `eco` / `premium` (smart routing) |
+| `--max-tokens` | Max output tokenų (billing upfront, §4.2) |
+| `--base-url` | Base URL (default: `BRIDGENODE_BASE_URL` / https://bridgenode.cc/v1) |
+| `--max-per-call` / `--daily-cap` | Spending policy (fail-closed) |
+
+## .env
+
+```bash
+# Privalomas — jūsų Solana wallet private key (base58)
+BRIDGENODE_WALLET_KEY=...
+# Neprivalomi: BRIDGENODE_BASE_URL, BRIDGENODE_MAX_PER_CALL, BRIDGENODE_DAILY_CAP
+```
+
+## Apsaugos
+
+- **Kvito verifikacija (Free-Riding apsauga):** po 200 tikrinamas `PAYMENT-RESPONSE` — netikras kvitas → klaida.
+- **Spending policy (fail-closed):** max USD per call / per day — tikrinama PRIEŠ pasirašant.
+
+## Reikalavimai
+
+- Python ≥ 3.11
+- Solana wallet su USDC ATA (rent — agento atsakomybė, §3.3)
+
+## Nuorodos
+
+- Tinklalapis: https://bridgenode.cc
+- Protokolas: x402 V2 (docs.x402.org)

bridgenode_cli-0.1.0/README.md

@@ -0,0 +1,55 @@
+# bridgenode-cli
+
+BridgeNode CLI — AI inference be API key. Mokėjimas: **Solana USDC per x402** (automatinis handshake, fee sponsorship — SOL nereikia).
+
+## Diegimas
+
+```bash
+pip install bridgenode-cli
+```
+
+## Naudojimas
+
+```bash
+# Vienas chat completion (x402 handshake paslėptas, §4.1)
+bridgenode chat "Labas!" --model deepseek-v4-flash
+
+# Smart routing (§5.1/§5.8): auto / eco / premium
+bridgenode chat "Išanalizuok šį kodą" --mode auto
+
+# Modelių sąrašas + kainos (§5.2) — be mokėjimo
+bridgenode models
+```
+
+## Parinktys
+
+| Parinktis | Aprašas |
+|---|---|
+| `--model` | Explicit model id (žr. `bridgenode models`) |
+| `--mode` | `auto` / `eco` / `premium` (smart routing) |
+| `--max-tokens` | Max output tokenų (billing upfront, §4.2) |
+| `--base-url` | Base URL (default: `BRIDGENODE_BASE_URL` / https://bridgenode.cc/v1) |
+| `--max-per-call` / `--daily-cap` | Spending policy (fail-closed) |
+
+## .env
+
+```bash
+# Privalomas — jūsų Solana wallet private key (base58)
+BRIDGENODE_WALLET_KEY=...
+# Neprivalomi: BRIDGENODE_BASE_URL, BRIDGENODE_MAX_PER_CALL, BRIDGENODE_DAILY_CAP
+```
+
+## Apsaugos
+
+- **Kvito verifikacija (Free-Riding apsauga):** po 200 tikrinamas `PAYMENT-RESPONSE` — netikras kvitas → klaida.
+- **Spending policy (fail-closed):** max USD per call / per day — tikrinama PRIEŠ pasirašant.
+
+## Reikalavimai
+
+- Python ≥ 3.11
+- Solana wallet su USDC ATA (rent — agento atsakomybė, §3.3)
+
+## Nuorodos
+
+- Tinklalapis: https://bridgenode.cc
+- Protokolas: x402 V2 (docs.x402.org)

bridgenode_cli-0.1.0/bridgenode_cli/__init__.py

@@ -0,0 +1,6 @@
+"""bridgenode_cli — BridgeNode CLI (§8.4, fix.md 4.4)."""
+
+from .main import main
+
+__all__ = ["main"]
+__version__ = "0.1.0"

bridgenode_cli-0.1.0/bridgenode_cli/main.py

@@ -0,0 +1,131 @@
+"""main.py — bridgenode CLI (§8.4, fix.md 4.4 ž1).
+
+Komandos:
+- `bridgenode chat "<prompt>"` — vienas chat completion per x402 handshake
+  (SDK: 402 → dalinis TX → PAYMENT-SIGNATURE → 200; §4.1)
+- `bridgenode models` — modelių sąrašas + kainos iš GET /v1/models (§5.2)
+
+Parinktys: --model (explicit, §5.1), --mode auto/eco/premium (smart routing,
+§5.1/§5.8), --max-tokens. Visas mokėjimas paslėptas — naudojamas oficialus
+LLMClient (P4). Klaidos → stderr + exit 1; sėkmė → stdout + exit 0.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from typing import Any
+
+from bridgenode_llm import BridgenodeError, LLMClient
+
+
+def _client(args: argparse.Namespace) -> LLMClient:
+    """LLMClient iš CLI argumentų (raktas TIK iš .env, §8.4)."""
+    # None reikšmės neperduodamos — SDK naudoja default'us (§8.5);
+    # kitaip timeout=None patektų į flow timeout skaičiavimą (Ž42)
+    kwargs: dict[str, Any] = {}
+    if args.base_url:
+        kwargs["base_url"] = args.base_url
+    if args.initial_timeout is not None:
+        kwargs["initial_timeout"] = args.initial_timeout
+    if args.retry_timeout is not None:
+        kwargs["retry_timeout"] = args.retry_timeout
+    if args.max_per_call is not None:
+        kwargs["max_per_call_usd"] = args.max_per_call
+    if args.daily_cap is not None:
+        kwargs["daily_cap_usd"] = args.daily_cap
+    return LLMClient(**kwargs)
+
+
+def cmd_chat(args: argparse.Namespace) -> int:
+    """`bridgenode chat "<prompt>" [--model M | --mode auto|eco|premium]`."""
+    if args.model is None and args.mode is None:
+        print("Error: --model or --mode required", file=sys.stderr)
+        return 2
+    try:
+        client = _client(args)
+        messages = [{"role": "user", "content": args.prompt}]
+        resp: dict[str, Any] = client.chat(
+            args.model, messages,
+            max_tokens=args.max_tokens, mode=args.mode)
+    except BridgenodeError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+    content = resp["choices"][0]["message"]["content"]
+    print(content)
+    return 0
+
+
+def cmd_models(args: argparse.Namespace) -> int:
+    """`bridgenode models` — modelių sąrašas + kainos (§5.2).
+
+    Viešas endpointas (be mokėjimo) — tiesioginis HTTP, be SDK (SDK turi
+    tik chat(), protokolas §8.4)."""
+    import httpx
+
+    base_url = (args.base_url or os.environ.get("BRIDGENODE_BASE_URL")
+                or "https://bridgenode.cc/v1").rstrip("/")
+    try:
+        resp = httpx.get(f"{base_url}/models", timeout=30.0)
+        if resp.status_code != 200:
+            raise RuntimeError(f"HTTP {resp.status_code}")
+        data = resp.json()
+    except Exception as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+    models = data.get("data", [])
+    for m in models:
+        pricing = m.get("pricing", {})
+        print(
+            f"{m.get('id', '?'):24} "
+            f"prompt=${pricing.get('prompt', 0):.8f}  "
+            f"completion=${pricing.get('completion', 0):.8f}  "
+            f"context={m.get('context_window', '?')}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="bridgenode",
+        description=(
+            "BridgeNode CLI — AI inference, mokėjimas Solana USDC per x402. "
+            "Jokių API key."
+        ),
+    )
+    parser.add_argument("--base-url", default=None,
+                        help="Base URL (default: BRIDGENODE_BASE_URL / https://bridgenode.cc/v1)")
+    parser.add_argument("--initial-timeout", type=float, default=None,
+                        help="Pradinio request'o timeout s (eilė iki 402, §5.7)")
+    parser.add_argument("--retry-timeout", type=float, default=None,
+                        help="Retry timeout s (≤115s biudžetas, §4.3)")
+    parser.add_argument("--max-per-call", type=float, default=None,
+                        help="Spending policy: max USD per call (ž2)")
+    parser.add_argument("--daily-cap", type=float, default=None,
+                        help="Spending policy: max USD per day (ž2)")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_chat = sub.add_parser("chat", help="Vienas chat completion per x402 (§4.1)")
+    p_chat.add_argument("prompt", help="Prompt tekstas")
+    p_chat.add_argument("--model", default=None,
+                        help="Explicit model id (žr. `bridgenode models`)")
+    p_chat.add_argument("--mode", choices=["auto", "eco", "premium"], default=None,
+                        help="Smart routing profilis (§5.1/§5.8)")
+    p_chat.add_argument("--max-tokens", type=int, default=None,
+                        help="Max output tokenų (billing upfront, §4.2)")
+    p_chat.set_defaults(func=cmd_chat)
+
+    p_models = sub.add_parser("models", help="Modelių sąrašas + kainos (§5.2)")
+    p_models.set_defaults(func=cmd_models)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: bridgenode-cli
+Version: 0.1.0
+Summary: BridgeNode CLI — AI inference su x402 mokėjimu (Solana USDC). Jokių API key.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: bridgenode-llm>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=9.1.1; extra == "dev"
+
+# bridgenode-cli
+
+BridgeNode CLI — AI inference be API key. Mokėjimas: **Solana USDC per x402** (automatinis handshake, fee sponsorship — SOL nereikia).
+
+## Diegimas
+
+```bash
+pip install bridgenode-cli
+```
+
+## Naudojimas
+
+```bash
+# Vienas chat completion (x402 handshake paslėptas, §4.1)
+bridgenode chat "Labas!" --model deepseek-v4-flash
+
+# Smart routing (§5.1/§5.8): auto / eco / premium
+bridgenode chat "Išanalizuok šį kodą" --mode auto
+
+# Modelių sąrašas + kainos (§5.2) — be mokėjimo
+bridgenode models
+```
+
+## Parinktys
+
+| Parinktis | Aprašas |
+|---|---|
+| `--model` | Explicit model id (žr. `bridgenode models`) |
+| `--mode` | `auto` / `eco` / `premium` (smart routing) |
+| `--max-tokens` | Max output tokenų (billing upfront, §4.2) |
+| `--base-url` | Base URL (default: `BRIDGENODE_BASE_URL` / https://bridgenode.cc/v1) |
+| `--max-per-call` / `--daily-cap` | Spending policy (fail-closed) |
+
+## .env
+
+```bash
+# Privalomas — jūsų Solana wallet private key (base58)
+BRIDGENODE_WALLET_KEY=...
+# Neprivalomi: BRIDGENODE_BASE_URL, BRIDGENODE_MAX_PER_CALL, BRIDGENODE_DAILY_CAP
+```
+
+## Apsaugos
+
+- **Kvito verifikacija (Free-Riding apsauga):** po 200 tikrinamas `PAYMENT-RESPONSE` — netikras kvitas → klaida.
+- **Spending policy (fail-closed):** max USD per call / per day — tikrinama PRIEŠ pasirašant.
+
+## Reikalavimai
+
+- Python ≥ 3.11
+- Solana wallet su USDC ATA (rent — agento atsakomybė, §3.3)
+
+## Nuorodos
+
+- Tinklalapis: https://bridgenode.cc
+- Protokolas: x402 V2 (docs.x402.org)

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

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+bridgenode_cli/__init__.py
+bridgenode_cli/main.py
+bridgenode_cli.egg-info/PKG-INFO
+bridgenode_cli.egg-info/SOURCES.txt
+bridgenode_cli.egg-info/dependency_links.txt
+bridgenode_cli.egg-info/entry_points.txt
+bridgenode_cli.egg-info/requires.txt
+bridgenode_cli.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_cli_integration.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+bridgenode = bridgenode_cli.main:main

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

@@ -0,0 +1,4 @@
+bridgenode-llm>=0.1.0
+
+[dev]
+pytest>=9.1.1

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

@@ -0,0 +1 @@
+bridgenode_cli

bridgenode_cli-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "bridgenode-cli"
+version = "0.1.0"
+description = "BridgeNode CLI — AI inference su x402 mokėjimu (Solana USDC). Jokių API key."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "bridgenode-llm>=0.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=9.1.1",
+]
+
+[project.scripts]
+bridgenode = "bridgenode_cli.main:main"
+
+[build-system]
+requires = ["setuptools>=75"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["bridgenode_cli*"]

bridgenode_cli-0.1.0/setup.cfg

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

bridgenode_cli-0.1.0/tests/test_cli.py

@@ -0,0 +1,170 @@
+"""test_cli.py — bridgenode CLI testai (fix.md 4.4 ž1).
+
+Tikrina komandų išvedimą ir argumentų perdavimą su mock'intu LLMClient
+(jokio tinklo, jokio mokėjimo). Pilnas mock-402 kelias — 4.4 ž2.
+"""
+
+from __future__ import annotations
+
+import importlib
+
+import pytest
+
+from bridgenode_llm import BridgenodeError
+
+# ⚠️ import bridgenode_cli.main as cli NEVEIKIA: __init__ `from .main import main`
+# shadow'ina submodulį — cli tampa funkcija. Naudojam importlib.
+cli = importlib.import_module("bridgenode_cli.main")
+
+
+class FakeClient:
+    """LLMClient pakaitalas — fiksuoja kvietimus, grąžina fiktyvius atsakymus."""
+
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        self.chat_calls: list[tuple] = []
+
+    def chat(self, model, messages, max_tokens=None, mode=None):
+        self.chat_calls.append((model, messages, max_tokens, mode))
+        return {
+            "id": "cmpl-1",
+            "object": "chat.completion",
+            "choices": [{"index": 0,
+                         "message": {"role": "assistant", "content": "Labas!"},
+                         "finish_reason": "stop"}],
+        }
+
+
+@pytest.fixture()
+def fake_client(monkeypatch):
+    client = FakeClient()
+    monkeypatch.setattr(cli, "LLMClient", lambda **kw: client)
+    return client
+
+
+# ── chat ─────────────────────────────────────────────────────────────────────
+
+def test_chat_prints_content(fake_client, capsys):
+    rc = cli.main(["chat", "Labas pasauli", "--model", "deepseek-v4-flash"])
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "Labas!" in out
+    assert fake_client.chat_calls[0][0] == "deepseek-v4-flash"
+    assert fake_client.chat_calls[0][1] == [
+        {"role": "user", "content": "Labas pasauli"}]
+
+
+def test_chat_mode_passed(fake_client, capsys):
+    rc = cli.main(["chat", "hi", "--mode", "auto"])
+    assert rc == 0
+    model, messages, max_tokens, mode = fake_client.chat_calls[0]
+    assert model is None
+    assert mode == "auto"
+
+
+def test_chat_model_and_mode(fake_client):
+    """§5.1: abu perduodami — konfliktą sprendžia serveris (model laimi)."""
+    rc = cli.main(["chat", "hi", "--model", "deepseek-v4-flash",
+                   "--mode", "premium"])
+    assert rc == 0
+    model, _m, _mt, mode = fake_client.chat_calls[0]
+    assert model == "deepseek-v4-flash"
+    assert mode == "premium"
+
+
+def test_chat_max_tokens(fake_client):
+    cli.main(["chat", "hi", "--model", "deepseek-v4-flash",
+              "--max-tokens", "128"])
+    _model, _m, max_tokens, _mode = fake_client.chat_calls[0]
+    assert max_tokens == 128
+
+
+def test_chat_requires_model_or_mode(fake_client, capsys):
+    rc = cli.main(["chat", "hi"])
+    assert rc == 2
+    assert "model or --mode" in capsys.readouterr().err
+    assert fake_client.chat_calls == []  # jokio kvietimo — klaida prieš SDK
+
+
+def test_chat_error_exit_1(fake_client, monkeypatch, capsys):
+    def boom(self, *a, **kw):
+        raise BridgenodeError("Unknown model", status_code=400)
+    monkeypatch.setattr(fake_client, "chat", boom)
+    rc = cli.main(["chat", "hi", "--model", "bogus"])
+    assert rc == 1
+    assert "Unknown model" in capsys.readouterr().err
+
+
+# ── models ───────────────────────────────────────────────────────────────────
+
+def _fake_models_response():
+    import httpx
+    return httpx.Response(200, json={"object": "list", "data": [
+        {"id": "deepseek-v4-flash",
+         "pricing": {"prompt": 2e-7, "completion": 4e-7},
+         "context_window": 1048576, "max_output_tokens": 8192},
+        {"id": "deepseek-v4-pro",
+         "pricing": {"prompt": 8.5e-7, "completion": 1.7e-6},
+         "context_window": 1048576, "max_output_tokens": 8192},
+    ]})
+
+
+def test_models_lists_prices(monkeypatch, capsys):
+    import httpx
+    monkeypatch.setattr(httpx, "get", lambda *a, **kw: _fake_models_response())
+    rc = cli.main(["models"])
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "deepseek-v4-flash" in out
+    assert "deepseek-v4-pro" in out
+    assert "prompt=" in out
+    assert "completion=" in out
+
+
+def test_models_error_exit_1(monkeypatch, capsys):
+    import httpx
+    def boom(*a, **kw):
+        raise httpx.HTTPStatusError("HTTP 503", request=httpx.Request("GET", "x"),
+                                    response=httpx.Response(503))
+    monkeypatch.setattr(httpx, "get", boom)
+    rc = cli.main(["models"])
+    assert rc == 1
+    assert "HTTP 503" in capsys.readouterr().err
+
+
+# ── Parser ───────────────────────────────────────────────────────────────────
+
+def test_unknown_command_exits_2(capsys):
+    with pytest.raises(SystemExit) as exc:
+        cli.main(["bogus"])
+    assert exc.value.code == 2
+
+
+def test_missing_prompt_exits_2(capsys):
+    with pytest.raises(SystemExit) as exc:
+        cli.main(["chat"])
+    assert exc.value.code == 2
+
+
+def test_client_kwargs_wired(monkeypatch):
+    """CLI argumentai → LLMClient kwargs (timeout'ai, spending policy).
+
+    Globalios parinktys (--base-url ir kt.) — PRIEŠ subkomandą (argparse).
+    Tikrinama per `chat` (models komanda SDK nenaudoja — tiesioginis HTTP, §5.2).
+    """
+    captured: dict = {}
+
+    def fake_factory(**kw):
+        captured.update(kw)
+        return FakeClient(**kw)
+
+    monkeypatch.setattr(cli, "LLMClient", fake_factory)
+    cli.main(["--base-url", "https://alt.example/v1",
+              "--initial-timeout", "70", "--retry-timeout", "115",
+              "--max-per-call", "0.1", "--daily-cap", "2.0",
+              "chat", "hi", "--model", "deepseek-v4-flash"])
+    assert captured["base_url"] == "https://alt.example/v1"
+    assert captured["initial_timeout"] == 70
+    assert captured["retry_timeout"] == 115
+    assert captured["max_per_call_usd"] == 0.1
+    assert captured["daily_cap_usd"] == 2.0

bridgenode_cli-0.1.0/tests/test_cli_integration.py

@@ -0,0 +1,259 @@
+"""test_cli_integration.py — CLI → realus SDK kelias su mock 402 (fix.md 4.4 ž2).
+
+Pilnas x402 handshake per tikrą `bridgenode_llm` SDK: CLI `chat` → 402
+(PAYMENT-REQUIRED) → dalinis TX → PAYMENT-SIGNATURE → 200 + validus
+PAYMENT-RESPONSE kvitas (fee payer pasirašo MŪSŲ TX žinutę). RPC (mint
+metadata) mock'inta. Jokio realaus tinklo, jokio realaus mokėjimo.
+"""
+
+from __future__ import annotations
+
+import base64
+import importlib
+import json
+
+import httpx
+import pytest
+from solders.keypair import Keypair
+from solders.pubkey import Pubkey
+from solders.transaction import VersionedTransaction
+from x402.mechanisms.svm.mint_cache import MintMetadata
+from x402.schemas import PaymentPayload, SettleResponse
+
+cli = importlib.import_module("bridgenode_cli.main")
+
+NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+WALLET = "BHMDv3ri3LBEZjEzJgDZeUiguVX7LmsCstTXbM3dL8rN"
+TOKEN_PROGRAM = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+BLOCKHASH = "EZ3rST5dvHmbanh75jc4PuLfV96vp9fEYBVeNk4FfM1k"
+API_BASE = "http://test/v1"
+
+_B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+
+def _b58encode(data: bytes) -> str:
+    n = int.from_bytes(data, "big")
+    out = ""
+    while n > 0:
+        n, r = divmod(n, 58)
+        out = _B58_ALPHABET[r] + out
+    pad = 0
+    for b in data:
+        if b == 0:
+            pad += 1
+        else:
+            break
+    return "1" * pad + out
+
+
+def _wallet_key(kp: Keypair) -> str:
+    return _b58encode(bytes(kp))
+
+
+def _envelope(pay_to: str, fee_payer: str, amount: str = "2000") -> dict:
+    return {
+        "x402Version": 2,
+        "error": "PAYMENT-SIGNATURE header is required",
+        "resource": {
+            "url": "https://bridgenode.cc/v1/chat/completions",
+            "description": "AI inference",
+            "mimeType": "application/json",
+        },
+        "accepts": [
+            {
+                "scheme": "exact",
+                "network": NETWORK,
+                "amount": amount,
+                "asset": USDC,
+                "payTo": pay_to,
+                "maxTimeoutSeconds": 30,
+                "extra": {
+                    "feePayer": fee_payer,
+                    "memo": "pi_test123",
+                    "recentBlockhash": BLOCKHASH,
+                    "lastValidBlockHeight": "291470237",
+                },
+            }
+        ],
+    }
+
+
+def _receipt_header(payment_header: str, fee_payer_kp: Keypair,
+                    client_wallet: str, amount: str = "2000") -> str:
+    """Validus PAYMENT-RESPONSE kvitas: fee payer pasirašo MŪSŲ TX žinutę."""
+    payload = PaymentPayload.model_validate_json(base64.b64decode(payment_header))
+    tx = VersionedTransaction.from_bytes(
+        base64.b64decode(payload.payload["transaction"]))
+    msg_bytes = bytes([0x80]) + bytes(tx.message)
+    sig = fee_payer_kp.sign_message(msg_bytes)
+    settle = SettleResponse(
+        success=True,
+        transaction=str(sig),
+        network=NETWORK,
+        payer=client_wallet,
+        amount=amount,
+    )
+    return base64.b64encode(
+        settle.model_dump_json(by_alias=True, exclude_none=True).encode()).decode()
+
+
+def _openai_response() -> dict:
+    return {
+        "id": "cmpl-1",
+        "object": "chat.completion",
+        "created": 1,
+        "model": "deepseek-v4-flash",
+        "choices": [{"index": 0,
+                     "message": {"role": "assistant", "content": "Labas!"},
+                     "finish_reason": "stop"}],
+        "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
+    }
+
+
+@pytest.fixture(autouse=True)
+def _mock_mint_metadata(monkeypatch):
+    """Mint metadata be RPC (SDK scheme reikalauja, testai be tinklo)."""
+    def fake(client, network, mint, cache):
+        return MintMetadata(decimals=6, token_program=Pubkey.from_string(TOKEN_PROGRAM))
+    monkeypatch.setattr(
+        "x402.mechanisms.svm.exact.client.get_cached_mint_metadata", fake)
+
+
+@pytest.fixture()
+def _mock_http(monkeypatch):
+    """httpx.Client → MockTransport (visi SDK request'ai per mock serverį)."""
+    real_client = httpx.Client
+    state: dict = {"transport": None}
+
+    def fake_client(*args, **kwargs):
+        kwargs["transport"] = state["transport"]
+        return real_client(*args, **kwargs)
+
+    monkeypatch.setattr(httpx, "Client", fake_client)
+    return state
+
+
+def _install_server(state: dict, fee_kp: Keypair, client_wallet: str):
+    """Mock serveris: 402 → validus kvitas → 200. Grąžina (handler, seen)."""
+    seen: list[dict] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append({
+            "url": str(request.url),
+            "has_payment": "PAYMENT-SIGNATURE" in request.headers,
+            "body": json.loads(request.content),
+        })
+        if "PAYMENT-SIGNATURE" not in request.headers:
+            env = _envelope(pay_to=WALLET, fee_payer=str(fee_kp.pubkey()))
+            return httpx.Response(
+                402,
+                headers={"PAYMENT-REQUIRED": base64.b64encode(
+                    json.dumps(env).encode()).decode()},
+                json=env,
+            )
+        return httpx.Response(
+            200,
+            json=_openai_response(),
+            headers={"PAYMENT-RESPONSE": _receipt_header(
+                request.headers["PAYMENT-SIGNATURE"], fee_kp, client_wallet)},
+        )
+
+    state["transport"] = httpx.MockTransport(handler)
+    return seen
+
+
+# ── chat: pilnas x402 handshake per realų SDK ────────────────────────────────
+
+def test_cli_chat_full_handshake(monkeypatch, _mock_http, capsys):
+    """CLI chat → realus SDK: 402 → TX → PAYMENT-SIGNATURE → 200 + kvitas."""
+    fee_kp = Keypair()
+    client_kp = Keypair()
+    seen = _install_server(_mock_http, fee_kp, str(client_kp.pubkey()))
+
+    monkeypatch.setenv("BRIDGENODE_WALLET_KEY", _wallet_key(client_kp))
+    rc = cli.main(["--base-url", API_BASE,
+                   "chat", "Labas pasauli", "--model", "deepseek-v4-flash"])
+
+    assert rc == 0
+    assert "Labas!" in capsys.readouterr().out
+    assert len(seen) == 2
+    assert seen[0]["has_payment"] is False
+    assert seen[1]["has_payment"] is True
+    assert seen[0]["body"] == seen[1]["body"]  # price-bind (§4.1.1)
+    assert seen[0]["body"]["model"] == "deepseek-v4-flash"
+
+
+def test_cli_chat_mode_auto(monkeypatch, _mock_http, capsys):
+    """CLI --mode auto → SDK mode perduodamas (smart routing §5.1)."""
+    fee_kp = Keypair()
+    client_kp = Keypair()
+    seen = _install_server(_mock_http, fee_kp, str(client_kp.pubkey()))
+
+    monkeypatch.setenv("BRIDGENODE_WALLET_KEY", _wallet_key(client_kp))
+    rc = cli.main(["--base-url", API_BASE,
+                   "chat", "hi", "--mode", "auto"])
+    assert rc == 0
+    assert seen[0]["body"]["mode"] == "auto"
+
+
+def test_cli_chat_kvitas_verify_fail(monkeypatch, _mock_http, capsys):
+    """Suklastotas kvitas → CLI error (exit 1) — Free-Riding apsauga veikia."""
+    fee_kp = Keypair()
+    client_kp = Keypair()
+    fake_kp = Keypair()
+    seen = _install_server(_mock_http, fee_kp, str(client_kp.pubkey()))
+
+    # Perrašom kvitą po serverio atsakymo — netikras parašas (kito rakto)
+    original = _mock_http["transport"].handler
+
+    def tampered(request: httpx.Request) -> httpx.Response:
+        resp = original(request)
+        if "PAYMENT-SIGNATURE" in request.headers and resp.status_code == 200:
+            payload = PaymentPayload.model_validate_json(
+                base64.b64decode(request.headers["PAYMENT-SIGNATURE"]))
+            tx = VersionedTransaction.from_bytes(
+                base64.b64decode(payload.payload["transaction"]))
+            msg = bytes([0x80]) + bytes(tx.message)
+            fake_sig = fake_kp.sign_message(msg)  # ne fee payer'io raktas
+            settle = SettleResponse(
+                success=True, transaction=str(fake_sig), network=NETWORK,
+                payer=str(client_kp.pubkey()), amount="2000")
+            resp.headers["PAYMENT-RESPONSE"] = base64.b64encode(
+                settle.model_dump_json(by_alias=True, exclude_none=True)
+                .encode()).decode()
+        return resp
+
+    _mock_http["transport"] = httpx.MockTransport(tampered)
+
+    monkeypatch.setenv("BRIDGENODE_WALLET_KEY", _wallet_key(client_kp))
+    rc = cli.main(["--base-url", API_BASE,
+                   "chat", "hi", "--model", "deepseek-v4-flash"])
+    assert rc == 1
+    assert "does not match our TX" in capsys.readouterr().err
+
+
+# ── models: be mokėjimo (§5.2) ───────────────────────────────────────────────
+
+def test_cli_models_integration(monkeypatch, capsys):
+    import httpx
+
+    def fake_get(url, timeout=None):
+        assert str(url).endswith("/v1/models")
+        return httpx.Response(200, json={"object": "list", "data": [
+            {"id": "deepseek-v4-flash",
+             "pricing": {"prompt": 2e-7, "completion": 4e-7},
+             "context_window": 1048576, "max_output_tokens": 8192},
+            {"id": "groq-llama-3.3-70b",
+             "pricing": {"prompt": 7.9e-7, "completion": 9.9e-7},
+             "context_window": 131072, "max_output_tokens": 32768},
+        ]})
+
+    # models — tiesioginis HTTP (be SDK, §5.2 viešas endpointas)
+    monkeypatch.setattr(httpx, "get", fake_get)
+    rc = cli.main(["--base-url", API_BASE, "models"])
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "deepseek-v4-flash" in out
+    assert "groq-llama-3.3-70b" in out
+    assert "prompt=" in out