rtxclaw 0.7.2__tar.gz → 0.7.4__tar.gz

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/MANIFEST.in

@@ -10,16 +10,19 @@ include LICENSE
 include pyproject.toml
 include src/requirements.txt
 recursive-include src/rtxclaw_core/builtin_skills *
-# py.typed markers only from the shipping packages under src/ — a bare
-# `global-include py.typed` also sweeps the local web/venv tree.
+# The web frontend now ships INSIDE the package tree (src/rtxclaw_web);
+# its templates/static assets are pulled in via package-data, but list
+# them here too so a `--sdist` carries the full asset tree.
+recursive-include src/rtxclaw_web/templates *
+recursive-include src/rtxclaw_web/static *
+# py.typed markers only from the shipping packages under src/.
 recursive-include src py.typed
 global-exclude __pycache__/*
 global-exclude *.py[cod]
 # Dev-only trees: never ship in the published sdist. They carry no code
 # the wheel needs (the wheel is only src/rtxclaw_*) and would otherwise
-# leak the local virtualenv + test-fixture host paths / LAN topology.
+# leak test-fixture host paths / LAN topology / doc screenshots.
 prune tests
-prune web
 prune docs
 prune deploy
 prune scripts

{rtxclaw-0.7.2/src/rtxclaw.egg-info → rtxclaw-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rtxclaw
-Version: 0.7.2
+Version: 0.7.4
 Summary: Sovereign-inference TUI chat against an OpenAI-compatible vLLM endpoint.
 Author: rtxclaw.ai
 License-Expression: MIT
@@ -35,6 +35,10 @@ Requires-Dist: markitdown-mcp>=0.0.1a3; extra == "full"
 Requires-Dist: imageio-ffmpeg>=0.5.1; extra == "full"
 Requires-Dist: yt-dlp>=2024.10.7; extra == "full"
 Requires-Dist: youtube-transcript-api>=1.0; extra == "full"
+Provides-Extra: web
+Requires-Dist: flask>=3.1.3; extra == "web"
+Requires-Dist: requests>=2.32; extra == "web"
+Requires-Dist: gunicorn>=23.0; extra == "web"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/pyproject.toml

@@ -24,7 +24,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rtxclaw"
-version = "0.7.2"
+version = "0.7.4"
 description = "Sovereign-inference TUI chat against an OpenAI-compatible vLLM endpoint."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -95,6 +95,16 @@ full = [
     "yt-dlp>=2024.10.7",
     "youtube-transcript-api>=1.0",
 ]
+# Browser chat frontend (rtxclaw_web). The package code + its templates/
+# static asset trees ALWAYS ship in the wheel (see package-data below);
+# this extra only adds the runtime deps needed to actually SERVE it, so a
+# lean `pip install rtxclaw` stays small while `pip install rtxclaw[web]`
+# (or `rtxclaw web start`) can launch the UI with no separate checkout.
+web = [
+    "flask>=3.1.3",
+    "requests>=2.32",
+    "gunicorn>=23.0",
+]
 # Test + lint toolchain — mirrors tests/requirements.txt (minus the
 # `-r ../src/requirements.txt` include, already covered above).
 dev = [
@@ -117,6 +127,9 @@ dev = [
 # via `python -m rtxclaw_tui`.
 [project.scripts]
 rtxclaw = "rtxclaw_tui.app:main"
+# Browser chat frontend (needs the `[web]` extra installed to run). Also
+# reachable as `python -m rtxclaw_web` and `rtxclaw web start`.
+rtxclaw-web = "rtxclaw_web.server:main"
 
 [tool.setuptools]
 package-dir = { "" = "src" }
@@ -140,3 +153,9 @@ include = ["rtxclaw_*"]
 "rtxclaw_core.builtin_skills" = ["**/*"]
 "rtxclaw_core.builtin_commands" = ["**/*"]
 "rtxclaw_core" = ["profile_agents/**/*.md"]
+#   - rtxclaw_web/{templates,static} — Flask resolves them relative to the
+#     package dir (server.py builds absolute paths from __file__), so the
+#     full asset tree (HTML/CSS/JS + onnxruntime wasm + wakeword models)
+#     must ride in the wheel. Screenshots were moved out to docs/ to keep
+#     the wheel lean.
+"rtxclaw_web" = ["templates/**/*", "static/**/*", "README.md"]

{rtxclaw-0.7.2 → rtxclaw-0.7.4/src/rtxclaw.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rtxclaw
-Version: 0.7.2
+Version: 0.7.4
 Summary: Sovereign-inference TUI chat against an OpenAI-compatible vLLM endpoint.
 Author: rtxclaw.ai
 License-Expression: MIT
@@ -35,6 +35,10 @@ Requires-Dist: markitdown-mcp>=0.0.1a3; extra == "full"
 Requires-Dist: imageio-ffmpeg>=0.5.1; extra == "full"
 Requires-Dist: yt-dlp>=2024.10.7; extra == "full"
 Requires-Dist: youtube-transcript-api>=1.0; extra == "full"
+Provides-Extra: web
+Requires-Dist: flask>=3.1.3; extra == "web"
+Requires-Dist: requests>=2.32; extra == "web"
+Requires-Dist: gunicorn>=23.0; extra == "web"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/src/rtxclaw.egg-info/SOURCES.txt

@@ -152,6 +152,7 @@ src/rtxclaw_core/builtin_skills/nodriver-browser/browser
 src/rtxclaw_core/builtin_skills/nodriver-browser/scripts/browser.py
 src/rtxclaw_core/builtin_skills/nodriver-browser/scripts/requirements.txt
 src/rtxclaw_core/builtin_skills/sglang-install/SKILL.md
+src/rtxclaw_core/builtin_skills/skill-builder/SKILL.md
 src/rtxclaw_core/builtin_skills/telegram-render-verify/SKILL.md
 src/rtxclaw_core/builtin_skills/telegram-render-verify/drive.py
 src/rtxclaw_core/builtin_skills/telegram-render-verify/spawn_test_bot.sh
@@ -228,4 +229,39 @@ src/rtxclaw_tui/commands.py
 src/rtxclaw_tui/input_hardening.py
 src/rtxclaw_tui/kanban_panel.py
 src/rtxclaw_tui/monitor_view.py
-src/rtxclaw_tui/py.typed
+src/rtxclaw_tui/py.typed
+src/rtxclaw_web/README.md
+src/rtxclaw_web/__init__.py
+src/rtxclaw_web/__main__.py
+src/rtxclaw_web/server.py
+src/rtxclaw_web/static/agent_mon_mini.js
+src/rtxclaw_web/static/agents.css
+src/rtxclaw_web/static/agents.js
+src/rtxclaw_web/static/app.js
+src/rtxclaw_web/static/favicon.svg
+src/rtxclaw_web/static/goals.css
+src/rtxclaw_web/static/goals.js
+src/rtxclaw_web/static/nav.js
+src/rtxclaw_web/static/realtime.html
+src/rtxclaw_web/static/realtime.js
+src/rtxclaw_web/static/style.css
+src/rtxclaw_web/static/topics.css
+src/rtxclaw_web/static/topics.js
+src/rtxclaw_web/static/wakeword.js
+src/rtxclaw_web/static/models/embedding_model.onnx
+src/rtxclaw_web/static/models/hey_jarvis_v0.1.onnx
+src/rtxclaw_web/static/models/melspectrogram.onnx
+src/rtxclaw_web/static/models/silero_vad.onnx
+src/rtxclaw_web/static/vendor/github-dark.min.css
+src/rtxclaw_web/static/vendor/highlight.min.js
+src/rtxclaw_web/static/vendor/marked.min.js
+src/rtxclaw_web/static/vendor/purify.min.js
+src/rtxclaw_web/static/vendor/onnxruntime/ort-wasm-simd-threaded.mjs
+src/rtxclaw_web/static/vendor/onnxruntime/ort-wasm-simd-threaded.wasm
+src/rtxclaw_web/static/vendor/onnxruntime/ort.wasm.min.js
+src/rtxclaw_web/templates/_nav.html
+src/rtxclaw_web/templates/_nav_items.html
+src/rtxclaw_web/templates/agents.html
+src/rtxclaw_web/templates/goals.html
+src/rtxclaw_web/templates/index.html
+src/rtxclaw_web/templates/topics.html

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/src/rtxclaw.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 rtxclaw = rtxclaw_tui.app:main
+rtxclaw-web = rtxclaw_web.server:main

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/src/rtxclaw.egg-info/requires.txt

@@ -27,3 +27,8 @@ markitdown-mcp>=0.0.1a3
 imageio-ffmpeg>=0.5.1
 yt-dlp>=2024.10.7
 youtube-transcript-api>=1.0
+
+[web]
+flask>=3.1.3
+requests>=2.32
+gunicorn>=23.0

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/src/rtxclaw.egg-info/top_level.txt

@@ -6,3 +6,4 @@ rtxclaw_memory
 rtxclaw_realtime
 rtxclaw_telegram
 rtxclaw_tui
+rtxclaw_web

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/src/rtxclaw_agent/acp_bridge.py

@@ -1085,6 +1085,19 @@ async def _default_run_tool(
         ok, content = await _ask_user_outbound(backend, session_id, call)
         return ok, content, False, False
 
+    # goal_budget runs on the LIVE in-process agent (resume needs the live
+    # supervisor), so it short-circuits the subprocess runner like AskUserQuestion.
+    if call.get("name") == "goal_budget":
+        a = dict(call.get("arguments") or {})
+        try:
+            usd = float(a.get("usd") or 0)
+        except (TypeError, ValueError):
+            return False, "goal_budget: usd must be a number", False, False
+        out = backend.goal_budget(
+            session_id, str(a.get("action") or ""), usd, str(a.get("goal_id") or ""),
+        )
+        return bool(out.get("ok")), str(out.get("message") or ""), False, False
+
     package_parent = str(Path(__file__).resolve().parent.parent)
     env = dict(os.environ)
     existing = env.get("PYTHONPATH", "")
@@ -1227,10 +1240,20 @@ async def _default_run_tool(
             if final is None:
                 final = obj
     except asyncio.CancelledError:
+        # SIGKILL the runner's ENTIRE descendant tree, not just the launcher.
+        # A bare ``proc.kill()`` signals only this ``tool_runner`` process; any
+        # subagent / shell it spawned in its OWN session (``start_new_session``
+        # → a different pgid) is left orphaned to init and keeps running. This
+        # is the in-process-cancel twin of ``TurnState.stop(force)`` and
+        # ``_spawn_subagent_runner``'s cancel path — both already whole-tree.
         try:
-            proc.kill()
-        except ProcessLookupError:
-            pass
+            from rtxclaw_core.tools.runners import _kill_tree
+            _kill_tree(proc, signal.SIGKILL)
+        except Exception:  # noqa: BLE001
+            try:
+                proc.kill()
+            except ProcessLookupError:
+                pass
         try:
             await proc.wait()
         except Exception:  # noqa: BLE001
@@ -2230,6 +2253,39 @@ class CoreBackend:
             return {"ok": False, "message": f"agent unavailable: {exc}"}
         return run_goal_action(agent, goal_id, action)
 
+    def goal_budget(self, session_id: str, action: str, usd: float,
+                    goal_id: str = "") -> dict[str, Any]:
+        """Raise or set a goal's cost budget on the LIVE agent.
+
+        Called when the user explicitly authorizes more spend in chat. Uses the
+        in-process agent so ``topup`` → ``resume_goal`` → ``ensure_started``
+        reaches the live supervisor and the paused goal actually resumes.
+        ``action=set`` sets the absolute budget (0 = unbounded); ``action=topup``
+        adds ``usd`` and resumes a goal paused for ``cost_budget_exhausted``.
+        Defaults to the session's active (or ancestor) goal.
+        """
+        from rtxclaw_core.goal_service import set_goal_budget, topup_goal
+        try:
+            agent = self._get_new_agent()
+        except Exception as exc:  # noqa: BLE001
+            return {"ok": False, "message": f"agent unavailable: {exc}"}
+        session = self._session_for(session_id)
+        gid = str(goal_id
+                  or getattr(session, "cost_ancestor_goal_id", "")
+                  or getattr(session, "goal_id", "") or "")
+        if not gid:
+            return {"ok": False, "message": "no active goal to budget"}
+        try:
+            if action == "set":
+                res = set_goal_budget(agent, gid, float(usd))
+            elif action == "topup":
+                res = topup_goal(agent, gid, float(usd), session)
+            else:
+                return {"ok": False, "message": "action must be 'set' or 'topup'"}
+        except Exception as exc:  # noqa: BLE001
+            return {"ok": False, "message": f"goal_budget failed: {exc}"}
+        return {"ok": bool(res.ok), "message": res.message}
+
     async def run_command(
         self, session_id: str, text: str, *, frontend: str = "api",
     ) -> Mapping[str, Any]:
@@ -2940,6 +2996,27 @@ class CoreBackend:
                         )
                     except Exception:  # noqa: BLE001
                         pass
+                # 1b. SIGKILL the child's engine process subtree from the
+                # DURABLE registry. A subagent (local_llm) turn runs in a
+                # ``tool_runner`` SUBPROCESS that is NOT in this gateway's
+                # in-memory ``_new_backend_active_turns`` map, so step 1 is a
+                # no-op for it — the only thing that reaped its OS process was
+                # the top-level ``_kill_tree`` /proc walk on the aborted turn's
+                # runner. That walk MISSES a grandchild whose own launcher
+                # already died (reparented to init), which is exactly how a
+                # nested ``BatchAgent`` subtree kept running after ``/abort``.
+                # Each subagent records its pid in ``<sid>.engine_pid.json``;
+                # kill that pid + its whole ``/proc`` subtree here so recursive
+                # cancellation walks the parent→child registry instead of
+                # depending on live process ancestry. Downward-only (we only
+                # reached this child via ``parent_session_id``), so the
+                # gateway / orchestrator is never in the kill set. Best-effort.
+                if force_kill:
+                    try:
+                        from rtxclaw_core.agents import engine_pidfile
+                        engine_pidfile.kill_session_engine(sd, str(child_hash))
+                    except Exception:  # noqa: BLE001
+                        pass
                 # 2. Close the child's session log (folds it out of live).
                 if child_ti is not None:
                     try:

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/src/rtxclaw_agent/control_endpoint.py

@@ -214,7 +214,13 @@ async def _handle_session_history(request: Request) -> Response:
         jl = sessions_root() / f"{sid}.jsonl"
         if not jl.exists():
             return None
-        d = load_session_dict(sessions_root(), sid)
+        # ``fold=False``: the header (sessions.db row) is all we need from
+        # load_session_dict — ``scan_history_with_offsets`` below already folds
+        # the log ONCE for the history + tail offset, and yields the turns we
+        # read the last-turn model from. Folding the whole file a second time
+        # here (the old default) doubled the O(file) cost of opening a large
+        # conversation from the sidebar / agent monitor.
+        d = load_session_dict(sessions_root(), sid, fold=False)
         turns, tail_offset, active = scan_history_with_offsets(jl)
         return d, turns, tail_offset, active
 
@@ -225,7 +231,11 @@ async def _handle_session_history(request: Request) -> Response:
     if loaded is None:
         return _error(f"session not found: {sid}", "not_found", 404)
     d, turns, tail_offset, active = loaded
-    all_turns = d.get("turns") or []
+    # The engine-model badge: prefer the most recent COMPLETED turn's model
+    # (from the single scan-fold). An in-flight turn is excluded from ``turns``
+    # by design, so fall back to the session header's model when no completed
+    # turn carries one yet (the live stream then refines the badge anyway).
+    engine_model = _last_turn_model(turns) or (d.get("model") or "")
     return JSONResponse({
         "ok": True,
         "hash": d.get("hash") or sid,
@@ -233,7 +243,7 @@ async def _handle_session_history(request: Request) -> Response:
         "title": d.get("title") or "",
         "engine": d.get("engine") or "",
         "model": d.get("model") or "",
-        "engine_model": _last_turn_model(all_turns),
+        "engine_model": engine_model,
         "updated_at": d.get("last_turn_ts") or d.get("updated_at") or "",
         "messages": _fold_turns_to_messages(turns),
         "tail_offset": tail_offset,

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/src/rtxclaw_agent/web_cli.py

@@ -1,10 +1,10 @@
 """``rtxclaw web`` — lifecycle for the localhost web frontend.
 
 Mirrors ``rtxclaw gateway`` / ``rtxclaw telegram``: a daemon-control CLI for
-the Flask web server at ``<repo>/web/server.py`` (the browser frontend that
-renders the shared command runtime — see ``web/README.md``). Subcommands:
+the Flask web server bundled as ``rtxclaw_web`` (the browser frontend that
+renders the shared command runtime — see ``rtxclaw_web/README.md``). Subcommands:
 
-    rtxclaw web start            # daemonize web/server.py (pidfile + log)
+    rtxclaw web start            # daemonize rtxclaw_web.server (pidfile + log)
     rtxclaw web stop             # SIGTERM the daemon
     rtxclaw web restart          # stop + start
     rtxclaw web status           # pid / uptime / url
@@ -46,17 +46,22 @@ def _rtxclaw_home() -> Path:
 
 
 def _web_dir() -> Path:
-    """Locate the repo's ``web/`` directory (holds ``server.py``).
+    """Locate the packaged web dir (holds ``server.py`` + assets).
 
-    ``$RTXCLAW_WEB_DIR`` overrides; otherwise resolve relative to this
-    module (editable install: ``<repo>/src/rtxclaw_agent/web_cli.py`` →
-    ``<repo>/web``). Raising here with a clear message beats a cryptic
-    FileNotFound deep in Popen.
+    ``$RTXCLAW_WEB_DIR`` overrides; otherwise resolve the installed
+    ``rtxclaw_web`` package location. Works identically for an installed
+    wheel (site-packages/rtxclaw_web) and an editable checkout
+    (``<repo>/src/rtxclaw_web``). Raising here with a clear message beats
+    a cryptic FileNotFound deep in Popen.
     """
     env = os.environ.get("RTXCLAW_WEB_DIR")
     if env:
         return Path(env).expanduser()
-    return Path(__file__).resolve().parents[2] / "web"
+    try:
+        import rtxclaw_web
+        return Path(rtxclaw_web.__file__).resolve().parent
+    except Exception:  # noqa: BLE001 — fall back to the source-tree layout
+        return Path(__file__).resolve().parents[1] / "rtxclaw_web"
 
 
 def _server_py() -> Path:
@@ -124,25 +129,31 @@ def _ensure_web_secret() -> str:
 
 
 def _web_python() -> Path:
-    """Interpreter that can run the Flask server (flask + requests).
+    """Interpreter that can run the Flask server (flask + requests + gunicorn).
+
+    Now that ``rtxclaw_web`` ships inside the wheel, the web deps live in
+    the ``[web]`` extra (``pip install rtxclaw[web]``) and run under the
+    SAME interpreter as the gateway — no separate ``web/venv``. Prefer the
+    current interpreter when the web deps import; otherwise fall back to a
+    legacy ``web/venv`` if one exists (older source checkouts), and finally
+    to ``sys.executable`` so the caller sees a clear ImportError rather than
+    a silent misconfiguration.
 
-    Prefers the web's own venv (``web/venv`` — the README pattern); if
-    missing, bootstraps it once (``python -m venv`` + ``pip install -r
-    web/requirements.txt``). Keeps the web deps isolated from the
-    gateway venv exactly as the standalone server intends.
+    ``$RTXCLAW_WEB_PYTHON`` overrides everything.
     """
-    web_dir = _web_dir()
-    venv_py = web_dir / "venv" / "bin" / "python"
-    if venv_py.exists():
-        return venv_py
-    # Bootstrap the isolated web venv (first run only).
-    subprocess.run([sys.executable, "-m", "venv", str(web_dir / "venv")],
-                   check=True, capture_output=True)
-    req = web_dir / "requirements.txt"
-    if req.exists():
-        subprocess.run([str(venv_py), "-m", "pip", "install", "-q", "-r", str(req)],
-                       check=True)
-    return venv_py
+    override = os.environ.get("RTXCLAW_WEB_PYTHON")
+    if override:
+        return Path(override).expanduser()
+    try:
+        import flask  # noqa: F401
+        import requests  # noqa: F401
+        import gunicorn  # noqa: F401
+        return Path(sys.executable)
+    except Exception:  # noqa: BLE001 — deps not in the current interpreter
+        legacy_venv = _web_dir() / "venv" / "bin" / "python"
+        if legacy_venv.exists():
+            return legacy_venv
+        return Path(sys.executable)
 
 
 def _web_env(*, debug: bool = False) -> dict:
@@ -218,7 +229,7 @@ def _wait_for_listener(host: str, port: int, *, timeout: float = 15.0) -> bool:
 # ---- start / stop -----------------------------------------------------
 
 def start_web_background(*, debug: bool = False) -> dict:
-    """Daemonize ``web/server.py``. Returns a result dict (no stdout).
+    """Daemonize the packaged ``rtxclaw_web`` server. Returns a result dict (no stdout).
 
     ``debug=True`` runs the server with ``RTXCLAW_WEB_DEBUG=1`` (auth
     skipped)."""

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/src/rtxclaw_core/agent.py

@@ -388,6 +388,23 @@ def _prune_global_config_backups(p: Path, *, keep: int) -> None:
             pass
 
 
+def _env_float(name: str, default: float) -> float:
+    """Float from env ``name``, falling back to ``default`` when unset/blank/bad.
+
+    Lets operators override cost-budget defaults without editing a config:
+    e.g. ``RTXCLAW_MAX_GOAL_COST_USD=100 RTXCLAW_MAX_PROMPT_COST_USD=25``.
+    A per-agent ``config.json`` value still wins (it's an explicit field);
+    this only changes the DEFAULT applied when the field is unset.
+    """
+    raw = os.environ.get(name, "")
+    if raw is None or str(raw).strip() == "":
+        return default
+    try:
+        return float(raw)
+    except (TypeError, ValueError):
+        return default
+
+
 @dataclass
 class AgentConfig:
     """Settings for one rtxclaw agent.
@@ -458,14 +475,21 @@ class AgentConfig:
     # Outer /goal turn budget surfaced on /status (global config may override).
     # Retained for display/back-compat; the loop terminator is now the goal
     # COST budget below, not this turn cap.
-    max_goal_turns: int = 100
+    max_goal_turns: int = 0  # 0 == unbounded; cost is the only limit on goal work
     # Outer /goal COST budget (USD). The loop re-drives until the goal's
     # accumulated spend (usage-ledger SUM) reaches this, or the goal is
-    # met/blocked. 0 == unbounded. Default $5.00.
-    max_goal_cost_usd: float = 5.0
+    # met/blocked. 0 == unbounded. Default $50.00 (override:
+    # $RTXCLAW_MAX_GOAL_COST_USD).
+    max_goal_cost_usd: float = field(
+        default_factory=lambda: _env_float("RTXCLAW_MAX_GOAL_COST_USD", 50.0))
     # Per-session COST cap (USD). 0 == unbounded. New auto-turns are refused
     # once the session's accumulated spend crosses this.
     max_session_cost_usd: float = 0.0
+    # Per-PROMPT COST cap (USD) for non-goal interactive turns. 0 == unbounded.
+    # A single user prompt's spend is bounded here; goal turns use the goal
+    # budget, never this. Default $10.00 (override: $RTXCLAW_MAX_PROMPT_COST_USD).
+    max_prompt_cost_usd: float = field(
+        default_factory=lambda: _env_float("RTXCLAW_MAX_PROMPT_COST_USD", 10.0))
     # Override path for the per-model pricing table; "" == ~/.rtxclaw/pricing.json.
     pricing_path: str = ""
     goal_outer_loop_enabled: bool = True

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/src/rtxclaw_core/agent_profiles.py

@@ -373,10 +373,16 @@ def compose_tool_allowlist(cfg: object) -> set[str] | None:
     if strict:
         allowed = set(wl or [])
     else:
-        from rtxclaw_core.tools.registry import BUILTIN_TOOLS, ToolRegistry
+        from rtxclaw_core.tools.registry import (
+            BUILTIN_TOOLS,
+            ToolRegistry,
+            discovered_mcp_tools_sync,
+        )
 
         registry = ToolRegistry(BUILTIN_TOOLS)
         allowed = {t.name for t in registry.core_tools()}
+        for mcp_tool in discovered_mcp_tools_sync():
+            allowed.add(mcp_tool.name)
         if wl:
             allowed |= set(wl)
     disabled = getattr(cfg, "disabled_tools", None) or []

{rtxclaw-0.7.2 → rtxclaw-0.7.4}/src/rtxclaw_core/agents/acp_engine.py

@@ -688,6 +688,11 @@ class AcpEngine(Engine):
             "prompt_tokens": used,
             "completion_tokens": ct,
             "tokens_estimated": estimated,
+            # Tag the provider (the ACP agent label, e.g. "cursor") so the
+            # pricing table resolves this delegate's cost to that provider's
+            # rate instead of the generic default. ``used`` is the real
+            # PromptResponse.usage count when the server reported it.
+            "provider": (self._name or "").lower(),
         }
         if window:
             raw["context_window"] = window