venice-cli 0.41.0__tar.gz → 0.43.0__tar.gz

{venice_cli-0.41.0 → venice_cli-0.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.41.0
+Version: 0.43.0
 Summary: A stdlib-only Python CLI for the Venice.ai API: audio, video, images, chat, and embeddings.
 Project-URL: Homepage, https://github.com/gobha-me/venice-cli
 Project-URL: Repository, https://github.com/gobha-me/venice-cli
@@ -647,7 +647,13 @@ guessing, and `venice_model_details` (single `model` arg) which returns one
 model's pricing (cost), `capabilities` (text models — supportsVision etc.),
 `constraints` (image/media — aspect ratios, resolutions, qualities, prompt-length
 limit), and the full `model_spec`, so the agent can budget input and confirm a
-model fits. (`venice code` gets both too.)
+model fits, and `venice_vision`, which sends a local image (`input_path`, as a
+base64 data-URL) or an `image_url` to a vision-capable text model and returns
+what it sees — the agent's eyes, so it can inspect its own generations
+(watermarks, character consistency, glitches) instead of working blind; an
+optional `prompt` directs the question, and when `model` is omitted a
+`supportsVision` model is auto-picked from the catalog. Not spend-gated.
+(`venice code` gets all three too.)
 
 ```sh
 # One command, multiple steps: the model generates an image, then critiques it.
@@ -671,6 +677,14 @@ Details and safety:
   the block is handed back to the model, which adapts. `--yes` auto-approves every
   paid call (this bypasses the per-call cap — `--max-tool-calls` still bounds the
   count). The model itself can never raise its spending authority.
+- **Session spend cap** (`--session-max-spend`, #66) meters the *chat completions
+  themselves* — not just paid tools. Each turn's server-reported `usage` is
+  priced against the session model's per-1M-token catalog rate; once the running
+  total reaches the cap the loop stops starting new turns and forces a final
+  answer (chat has no pre-call quote, so it bounds *further* spend, not a turn
+  already in flight). Config-backable via `defaults.chat.session_max_spend` /
+  `defaults.code.session_max_spend`. Distinct from `--max-spend` (the per-call
+  tool cap). A model with unknown pricing is counted (tokens) but not charged.
 - `--output DIR` sets where generated files are written (default: cwd).
 - **Non-streamed in v1.** The tool path buffers each turn, so `--stream` is ignored
   when `--tools` is on; `--json` prints the final completion object.
@@ -681,6 +695,7 @@ Details and safety:
 | `--tool NAME` | restrict to this tool (repeatable; default: all of them) |
 | `--max-tool-calls N` | cap tool invocations before forcing an answer (default 8) |
 | `--max-spend USD` | per-call auto-approve cap for paid tools |
+| `--session-max-spend USD` | cap total chat-completion spend for the session |
 | `--yes` / `-y` | auto-approve every paid tool call and side-effecting MCP tool |
 | `--output DIR` / `-o` | directory for generated files |
 | `--mcp NAME` | attach a registered external MCP server's tools (repeatable) |
@@ -913,6 +928,7 @@ complete — a loud stderr warning is printed).
 | `read_file` / `list_dir` / `grep` | read a file, list a dir, regex-search the tree | no |
 | `git` | read-only git (`status`/`diff`/`log`/`show`/…) | no |
 | `project_search` | semantic search over the `.venice` index (if built) | no |
+| `venice_vision` | describe/inspect a local image or image URL via a vision-capable model | no |
 | `write_file` | create/overwrite a file (atomic) | yes |
 | `edit_file` | replace an exact, unique string in a file | yes |
 | `apply_patch` | apply a batch of edits grouped per file, atomically per file (use `occurrence=N` for non-unique strings) | yes |

{venice_cli-0.41.0 → venice_cli-0.43.0}/README.md

@@ -609,7 +609,13 @@ guessing, and `venice_model_details` (single `model` arg) which returns one
 model's pricing (cost), `capabilities` (text models — supportsVision etc.),
 `constraints` (image/media — aspect ratios, resolutions, qualities, prompt-length
 limit), and the full `model_spec`, so the agent can budget input and confirm a
-model fits. (`venice code` gets both too.)
+model fits, and `venice_vision`, which sends a local image (`input_path`, as a
+base64 data-URL) or an `image_url` to a vision-capable text model and returns
+what it sees — the agent's eyes, so it can inspect its own generations
+(watermarks, character consistency, glitches) instead of working blind; an
+optional `prompt` directs the question, and when `model` is omitted a
+`supportsVision` model is auto-picked from the catalog. Not spend-gated.
+(`venice code` gets all three too.)
 
 ```sh
 # One command, multiple steps: the model generates an image, then critiques it.
@@ -633,6 +639,14 @@ Details and safety:
   the block is handed back to the model, which adapts. `--yes` auto-approves every
   paid call (this bypasses the per-call cap — `--max-tool-calls` still bounds the
   count). The model itself can never raise its spending authority.
+- **Session spend cap** (`--session-max-spend`, #66) meters the *chat completions
+  themselves* — not just paid tools. Each turn's server-reported `usage` is
+  priced against the session model's per-1M-token catalog rate; once the running
+  total reaches the cap the loop stops starting new turns and forces a final
+  answer (chat has no pre-call quote, so it bounds *further* spend, not a turn
+  already in flight). Config-backable via `defaults.chat.session_max_spend` /
+  `defaults.code.session_max_spend`. Distinct from `--max-spend` (the per-call
+  tool cap). A model with unknown pricing is counted (tokens) but not charged.
 - `--output DIR` sets where generated files are written (default: cwd).
 - **Non-streamed in v1.** The tool path buffers each turn, so `--stream` is ignored
   when `--tools` is on; `--json` prints the final completion object.
@@ -643,6 +657,7 @@ Details and safety:
 | `--tool NAME` | restrict to this tool (repeatable; default: all of them) |
 | `--max-tool-calls N` | cap tool invocations before forcing an answer (default 8) |
 | `--max-spend USD` | per-call auto-approve cap for paid tools |
+| `--session-max-spend USD` | cap total chat-completion spend for the session |
 | `--yes` / `-y` | auto-approve every paid tool call and side-effecting MCP tool |
 | `--output DIR` / `-o` | directory for generated files |
 | `--mcp NAME` | attach a registered external MCP server's tools (repeatable) |
@@ -875,6 +890,7 @@ complete — a loud stderr warning is printed).
 | `read_file` / `list_dir` / `grep` | read a file, list a dir, regex-search the tree | no |
 | `git` | read-only git (`status`/`diff`/`log`/`show`/…) | no |
 | `project_search` | semantic search over the `.venice` index (if built) | no |
+| `venice_vision` | describe/inspect a local image or image URL via a vision-capable model | no |
 | `write_file` | create/overwrite a file (atomic) | yes |
 | `edit_file` | replace an exact, unique string in a file | yes |
 | `apply_patch` | apply a batch of edits grouped per file, atomically per file (use `occurrence=N` for non-unique strings) | yes |

venice_cli-0.43.0/src/venice/__init__.py

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

{venice_cli-0.41.0 → venice_cli-0.43.0}/src/venice/commands/_agent.py

@@ -34,6 +34,7 @@ from typing import Callable, Dict, List, Optional
 
 from .. import userconfig
 from . import _mcp
+from . import _models
 from . import _compact
 from .models import MODEL_TYPES
 
@@ -72,6 +73,126 @@ def to_openai_tools(tools: List[Tool]) -> List[dict]:
     ]
 
 
+# --------------------------------------------------------------------------- #
+# Cost ledger (#66): meter chat-completion spend across an agent run.
+#
+# Paid *tools* are already spend-gated (`check_spend` in `_mcp`); the model
+# calls themselves were not. This ledger accumulates per-turn cost from the
+# server-reported `usage` block and the catalog's per-1M-token pricing, so a
+# session `--max-spend` can stop a runaway loop. Accounting is post-response
+# (chat pricing is dynamic; there is no pre-call quote), so the gate fires
+# *between* turns: once accumulated cost crosses the cap, no new paid turn
+# starts and the loop forces a final answer (mirroring --max-tool-calls).
+# --------------------------------------------------------------------------- #
+def _usd_per_token(pricing, key) -> Optional[float]:
+    """`pricing.<key>.usd` as a per-token rate (catalog prices are per 1M)."""
+    if not isinstance(pricing, dict):
+        return None
+    node = pricing.get(key)
+    if isinstance(node, dict) and isinstance(node.get("usd"), (int, float)):
+        return float(node["usd"]) / 1_000_000.0
+    return None
+
+
+class CostLedger:
+    """Accumulates estimated USD spend for one agent run.
+
+    `max_spend` is the session cap (USD-equivalent; None = unmetered). The
+    ledger is bound to a model's pricing on first use via :meth:`bind_pricing`;
+    an unknown price means the turn's tokens are counted but not charged
+    (degrade gracefully rather than hard-block on a missing price).
+    """
+
+    def __init__(self, max_spend: Optional[float] = None):
+        # A non-positive cap means "uncapped" (mirrors --max-tool-calls 0).
+        cap = float(max_spend) if max_spend is not None else None
+        self.max_spend = cap if (cap is not None and cap > 0) else None
+        self.total = 0.0
+        self.prompt_tokens = 0
+        self.completion_tokens = 0
+        self.unpriced = False  # saw a turn whose model price was unknown
+        self._in = None        # per-token input rate (USD)
+        self._out = None       # per-token output rate (USD)
+
+    def bind_pricing(self, pricing) -> None:
+        """Set the per-token rates from a catalog `model_spec.pricing` block."""
+        self._in = _usd_per_token(pricing, "input")
+        self._out = _usd_per_token(pricing, "output")
+
+    def record(self, usage) -> float:
+        """Add one turn's `usage` (dict or SDK obj); return this turn's cost."""
+        if usage is None:
+            return 0.0
+        if hasattr(usage, "model_dump"):
+            usage = usage.model_dump()
+        if not isinstance(usage, dict):
+            return 0.0
+        pt = usage.get("prompt_tokens") or 0
+        ct = usage.get("completion_tokens") or 0
+        if not isinstance(pt, (int, float)):
+            pt = 0
+        if not isinstance(ct, (int, float)):
+            ct = 0
+        self.prompt_tokens += int(pt)
+        self.completion_tokens += int(ct)
+        cost = 0.0
+        if self._in is not None or self._out is not None:
+            cost = float(pt) * (self._in or 0.0) + float(ct) * (self._out or 0.0)
+        else:
+            self.unpriced = True
+        self.total += cost
+        return cost
+
+    def over(self) -> bool:
+        """True when accumulated spend has reached/exceeded the cap."""
+        return self.max_spend is not None and self.total >= self.max_spend
+
+    def summary(self) -> str:
+        """A one-line human-readable total (for stderr / --json)."""
+        if self.unpriced and self.total == 0.0:
+            return (
+                f"cost: (unpriced — model rate unknown) "
+                f"tokens prompt={self.prompt_tokens} completion={self.completion_tokens}"
+            )
+        s = f"cost: ${self.total:.4f}"
+        if self.max_spend is not None:
+            s += f" / cap ${self.max_spend:.2f}"
+        s += f" (tokens prompt={self.prompt_tokens} completion={self.completion_tokens})"
+        if self.unpriced:
+            s += " [partially unpriced]"
+        return s
+
+
+def _pricing_for(models, model_id):
+    """The catalog `model_spec.pricing` block for `model_id`, or None."""
+    for m in models or []:
+        if isinstance(m, dict) and m.get("id") == model_id:
+            spec = m.get("model_spec")
+            if isinstance(spec, dict):
+                return spec.get("pricing")
+    return None
+
+
+def ledger_from_args(args, models, model_id) -> Optional[CostLedger]:
+    """The session CostLedger for a parsed-args namespace, or None when the run
+    isn't spend-capped (#66).
+
+    Enabled by ``--session-max-spend`` (or ``defaults.<cmd>.session_max_spend``)
+    -- DISTINCT from ``--max-spend``, which is the *per-call* auto-approve cap
+    for paid tools. Bound to the session model's catalog pricing; an unknown
+    price degrades to token-counting without charging (the ledger still reports
+    usage). `models` is the text catalog the command already fetched.
+    """
+    cap = getattr(args, "session_max_spend", None)
+    if cap is None:
+        return None
+    ledger = CostLedger(max_spend=cap)
+    pricing = _pricing_for(models, model_id)
+    if pricing is not None:
+        ledger.bind_pricing(pricing)
+    return ledger
+
+
 def dispatch_map(tools: List[Tool]) -> Dict[str, Tool]:
     return {t.name: t for t in tools}
 
@@ -208,6 +329,22 @@ _MODEL_DETAILS_SCHEMA = _obj(
     required=["model"],
 )
 
+_VISION_SCHEMA = _obj(
+    {
+        "input_path": _p("string", "Path to a local image file to look at."),
+        "image_url": _p("string", "URL of an image (instead of input_path)."),
+        "prompt": _p(
+            "string",
+            "What to ask about the image (default: describe it in detail).",
+        ),
+        "model": _p(
+            "string",
+            "A vision-capable text model id (default: auto-picked from the catalog).",
+        ),
+        "max_tokens": _p("integer"),
+    },
+)
+
 # Schema for a tool folded in ONLY via `only=` (e.g. `venice code --assets`), so it
 # is not part of chat's default advertised set. Curated subset of
 # `_mcp.image_edit_tool`; `confirm`/`max_spend`/`output_dir` omitted (loop-injected).
@@ -330,6 +467,16 @@ _BUILTINS = [
         _MODEL_DETAILS_SCHEMA,
         False,
     ),
+    (
+        "venice_vision",
+        "vision_tool",
+        "Look at an image (a local input_path OR an image_url) with a vision-capable "
+        "Venice text model and return what it sees as text. Optional prompt directs "
+        "the question (default: a detailed description). Auto-picks a supportsVision "
+        "model when model is omitted (see venice_model_details). Not spend-gated.",
+        _VISION_SCHEMA,
+        False,
+    ),
     (
         "project_search",
         "search_tool",
@@ -493,19 +640,7 @@ def supports_function_calling(models, model_id) -> Optional[bool]:
     None when it can't be determined (no catalog, model absent, or the field is
     missing) -- the caller then attempts the loop with a soft note.
     """
-    if not models:
-        return None
-    for m in models:
-        if not isinstance(m, dict) or m.get("id") != model_id:
-            continue
-        spec = m.get("model_spec") or {}
-        caps = spec.get("capabilities")
-        if not isinstance(caps, dict):
-            return None
-        norm = {str(k).lower().replace("_", ""): v for k, v in caps.items()}
-        val = norm.get("supportsfunctioncalling")
-        return bool(val) if val is not None else None
-    return None
+    return _models.supports_capability(models, model_id, "supportsFunctionCalling")
 
 
 # --------------------------------------------------------------------------- #
@@ -684,6 +819,7 @@ def run_loop(
     yes: bool,
     json_out: bool,
     budget: Optional[_compact.Budget] = None,
+    ledger: Optional[CostLedger] = None,
 ) -> int:
     """Drive the function-calling loop until the model stops (or the cap is hit).
 
@@ -700,6 +836,13 @@ def run_loop(
     system message (keeping the system prompt + last `budget.keep_turns` turns
     verbatim). Compaction mutates `messages` in place and is best-effort: a
     failed summary call leaves the history alone.
+
+    `ledger` (issue #66) meters chat-completion spend: each turn's `usage` is
+    recorded against the session model's per-token rate, and once accumulated
+    cost reaches `ledger.max_spend` the loop stops starting new paid turns and
+    forces a final answer (the model wraps up with the history it has). The
+    gate is post-response (chat has no pre-call quote), so it bounds *further*
+    spend rather than preempting a turn already in flight.
     """
     oai_tools = to_openai_tools(tools)
     dispatch = dispatch_map(tools)
@@ -710,7 +853,29 @@ def run_loop(
     unlimited = max_tool_calls is None or max_tool_calls <= 0
     show = not json_out  # progress feedback (further TTY-gated inside the helpers)
 
+    def _force_final(reason: str) -> int:
+        print(reason, file=sys.stderr)
+        with _Spinner("finishing", enabled=show):
+            resp = oai.chat.completions.create(
+                model=model,
+                messages=messages,
+                tools=oai_tools,
+                tool_choice="none",
+                **base_kwargs,
+            )
+        if ledger is not None:
+            ledger.record(getattr(resp, "usage", None))
+        msg = resp.choices[0].message if getattr(resp, "choices", None) else None
+        messages.append(_assistant_dict(msg))
+        return _emit_final(resp, json_out)
+
     while True:
+        # Spend gate (#66): don't start a new paid turn once the cap is hit.
+        if ledger is not None and ledger.over():
+            return _force_final(
+                f"chat: reached --max-spend ({ledger.summary()}); "
+                "requesting a final answer"
+            )
         _compact.maybe_compact(
             oai, model, messages, budget, base_kwargs,
             on_compact=lambda b, a: _progress(
@@ -727,6 +892,8 @@ def run_loop(
             )
         if budget is not None:
             budget.observe(getattr(resp, "usage", None))
+        if ledger is not None:
+            ledger.record(getattr(resp, "usage", None))
         msg = resp.choices[0].message if getattr(resp, "choices", None) else None
         messages.append(_assistant_dict(msg))
         tool_calls = getattr(msg, "tool_calls", None) if msg is not None else None
@@ -759,11 +926,6 @@ def run_loop(
             )
 
         if not unlimited and calls_made >= max_tool_calls:
-            print(
-                f"chat: reached --max-tool-calls ({max_tool_calls}); "
-                "requesting a final answer",
-                file=sys.stderr,
-            )
             # The forced-final is the turn a long, over-budget run most needs
             # compacted -- it returns without re-entering the loop, so compact
             # here too or it ships the full history (#48).
@@ -773,14 +935,7 @@ def run_loop(
                     f"(auto-compacted history: {b} -> {a} messages)", enabled=show,
                 ),
             )
-            with _Spinner("finishing", enabled=show):
-                resp = oai.chat.completions.create(
-                    model=model,
-                    messages=messages,
-                    tools=oai_tools,
-                    tool_choice="none",
-                    **base_kwargs,
-                )
-            msg = resp.choices[0].message if getattr(resp, "choices", None) else None
-            messages.append(_assistant_dict(msg))
-            return _emit_final(resp, json_out)
+            return _force_final(
+                f"chat: reached --max-tool-calls ({max_tool_calls}); "
+                "requesting a final answer"
+            )

{venice_cli-0.41.0 → venice_cli-0.43.0}/src/venice/commands/_code.py

@@ -662,11 +662,14 @@ def code_tools(
         ))
 
     # Free model-catalog lookups so the agent can pick a valid `model` for the
-    # asset tools (and see cost/context limits) instead of guessing (need a client
-    # for the /models GET).
+    # asset tools (and see cost/context limits) instead of guessing, plus
+    # venice_vision so it can see images (screenshots/mockups/its own
+    # generations) instead of working blind (need a client for the API calls).
     if client is not None:
         tools.extend(_agent.builtin_tools(
-            client, only={"venice_models", "venice_model_details"}, config=config))
+            client,
+            only={"venice_models", "venice_model_details", "venice_vision"},
+            config=config))
 
     if assets and client is not None:
         asset_dir = os.environ.get("VENICE_MCP_OUTPUT_DIR") or root

{venice_cli-0.41.0 → venice_cli-0.43.0}/src/venice/commands/_mcp.py

@@ -4,7 +4,7 @@ Import-clean by design: this module must NOT import `mcp` (or `openai`) at modul
 scope, so `venice --help` and the base, stdlib-only install keep working, and the
 tests here run on Python 3.9 where the `mcp` SDK cannot even be installed. The thin
 FastMCP wiring lives in `venice.mcp_server`; everything with real logic lives here:
-the lazy `import_mcp` probe, the spend gate, the output-dir resolver, and the seven
+the lazy `import_mcp` probe, the spend gate, the output-dir resolver, and the
 print-free `*_tool` functions the server delegates to.
 
 CRITICAL invariant -- an MCP stdio server owns **stdout** for JSON-RPC framing, so
@@ -569,6 +569,110 @@ def chat_tool(
     return out
 
 
+DEFAULT_VISION_PROMPT = "Describe this image in detail."
+
+
+def _vision_default(models: List[dict]) -> Optional[str]:
+    """The default-trait text model if vision-capable, else the first
+    catalog model advertising supportsVision, else None."""
+    default = _models.default_model(models)
+    if default and _models.supports_capability(models, default, "supportsVision"):
+        return default
+    for m in models:
+        mid = m.get("id") if isinstance(m, dict) else None
+        if mid and _models.supports_capability(models, mid, "supportsVision"):
+            return mid
+    return None
+
+
+def vision_tool(
+    client,
+    input_path: Optional[str] = None,
+    *,
+    image_url: Optional[str] = None,
+    prompt: Optional[str] = None,
+    model: Optional[str] = None,
+    max_tokens: Optional[int] = None,
+) -> dict:
+    """Describe/inspect an image via a multimodal /chat/completions call.
+
+    The image is a local `input_path` (sent as a base64 data: URL) or an
+    `image_url` passed through verbatim -- exactly one of the two. The model
+    must be vision-capable: an explicit non-vision `model` is rejected
+    client-side (the API would reject the image content anyway); when `model`
+    is omitted the default-trait text model is used if it advertises
+    supportsVision, else the first catalog model that does. Cheap relative to
+    media generation, so it is not spend-gated. Needs the `[openai]` extra.
+    """
+    if bool(input_path) == bool(image_url):
+        return _err("vision: exactly one of input_path or image_url is required")
+
+    openai = _openai.import_openai("vision")  # stderr hint if missing
+    if openai is None:
+        return _err('vision: needs the openai package: pip install "venice-cli[openai]"')
+
+    if input_path:
+        p = Path(input_path)
+        rc = _shared.check_image_file(p, label="vision")  # stderr detail
+        if rc is not None:
+            return _err(f"vision: invalid input file (exit {rc})")
+        url = _shared.encode_data_url(p, default_mime="image/png")
+    else:
+        url = image_url
+
+    models = _models.catalog(client, "text")
+    if model:
+        resolved, rc = _models.resolve_model(
+            model, models, label="vision", noun="text model"
+        )
+        if rc is not None:
+            return _err(f"vision: could not resolve model (exit {rc})")
+        if _models.supports_capability(models, resolved, "supportsVision") is False:
+            return _err(
+                f"vision: model {resolved!r} does not advertise supportsVision; "
+                "pick a vision-capable model (see venice_model_details) or omit model"
+            )
+    else:
+        if models is None:
+            return _err("vision: could not fetch the model catalog; pass model explicitly")
+        resolved = _vision_default(models)
+        if resolved is None:
+            return _err(
+                "vision: no vision-capable text model found in the catalog; "
+                "pass model (see venice_models / venice_model_details)"
+            )
+
+    kwargs: dict = {
+        "model": resolved,
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": (prompt or DEFAULT_VISION_PROMPT).strip()},
+                    {"type": "image_url", "image_url": {"url": url}},
+                ],
+            }
+        ],
+    }
+    if max_tokens is not None:
+        kwargs["max_tokens"] = int(max_tokens)
+
+    oai = _openai.build_openai(openai, client)
+    try:
+        resp = oai.chat.completions.create(**kwargs)
+    except openai.OpenAIError as e:
+        return _err(f"vision: API error: {e}")
+
+    content = ""
+    if getattr(resp, "choices", None):
+        content = resp.choices[0].message.content or ""
+    out = {"status": "ok", "content": content, "model": resolved}
+    usage = _chat._as_dict(getattr(resp, "usage", None))
+    if usage:
+        out["usage"] = usage
+    return out
+
+
 def video_tool(
     client,
     prompt: str,

{venice_cli-0.41.0 → venice_cli-0.43.0}/src/venice/commands/_models.py

@@ -41,6 +41,31 @@ def default_model(models: List[dict]) -> Optional[str]:
     return None
 
 
+def supports_capability(models, model_id, key) -> Optional[bool]:
+    """Whether `model_id` advertises the boolean capability `key` in the catalog.
+
+    `key` is matched case/underscore-insensitively against
+    `model_spec.capabilities` (e.g. "supportsVision"). True/False when the model
+    is found and carries the field; None when it can't be determined (no
+    catalog, model absent, or the field missing) -- callers treat None as
+    "unknown, attempt anyway".
+    """
+    if not models:
+        return None
+    want = str(key).lower().replace("_", "")
+    for m in models:
+        if not isinstance(m, dict) or m.get("id") != model_id:
+            continue
+        spec = m.get("model_spec") or {}
+        caps = spec.get("capabilities")
+        if not isinstance(caps, dict):
+            return None
+        norm = {str(k).lower().replace("_", ""): v for k, v in caps.items()}
+        val = norm.get(want)
+        return bool(val) if val is not None else None
+    return None
+
+
 def resolve_model(
     requested: Optional[str],
     models: Optional[List[dict]],

{venice_cli-0.41.0 → venice_cli-0.43.0}/src/venice/commands/_repl.py

@@ -42,6 +42,7 @@ Commands:
   /auto            auto-accept paid/side-effecting tool calls for following turns
   /manual          confirm each paid/side-effecting tool call (undo /auto)
   /compact [N]     summarize older history to shrink the context (keeps last N turns)
+  /cost            show this session's estimated spend (needs --session-max-spend to cap)
   /reset           clear the conversation (keeps the system prompt)
   /save [file]     write the transcript JSON (default: the --resume file)
   /help            show this help
@@ -51,8 +52,8 @@ Anything else is sent to the model as your next message."""
 # Slash-commands, in help order -- the single source of truth for tab-completion
 # (#40). Keep in sync with `_dispatch_slash` and `_HELP`.
 _COMMANDS = (
-    "/system", "/model", "/models", "/auto", "/manual", "/compact", "/reset",
-    "/save", "/help", "/exit", "/quit",
+    "/system", "/model", "/models", "/auto", "/manual", "/compact", "/cost",
+    "/reset", "/save", "/help", "/exit", "/quit",
 )
 
 
@@ -236,12 +237,19 @@ def _do_turn(oai, openai, chat, text, messages, gen_kwargs, state, args) -> None
     the stream's final chunk.
     """
     budget = state.get("budget")
+    ledger = state.get("ledger")
     _compact.maybe_compact(
         oai, state["model"], messages, budget, gen_kwargs,
         on_compact=lambda b, a: print(
             f"(auto-compacted history: {b} -> {a} messages)", file=sys.stderr,
         ),
     )
+    # Spend gate (#66): refuse a new turn once the session cap is hit (the
+    # tool-loop gates mid-run; a streamed turn gates here).
+    if ledger is not None and ledger.over():
+        print(f"(max-spend reached: {ledger.summary()}; turn skipped)",
+              file=sys.stderr)
+        return
     mark = len(messages)
     messages.append({"role": "user", "content": text})
     try:
@@ -252,11 +260,14 @@ def _do_turn(oai, openai, chat, text, messages, gen_kwargs, state, args) -> None
                 yes=state["yes"],
                 json_out=False,
                 budget=budget,
+                ledger=ledger,
             )
         else:
             reply, usage = _stream_turn(oai, chat, state["model"], messages, gen_kwargs)
             if budget is not None:
                 budget.observe(usage)
+            if ledger is not None:
+                ledger.record(usage)
             messages.append({"role": "assistant", "content": reply})
     except KeyboardInterrupt:
         # Ctrl-C aborts just this turn -- roll it back and keep the session.
@@ -346,6 +357,15 @@ def _dispatch_slash(line, messages, state, args, models, oai=None, gen_kwargs=No
             )
         else:
             print("(nothing to compact)", file=sys.stderr)
+    elif cmd == "cost":
+        # Session spend so far (#66). The ledger exists only when the session is
+        # spend-capped; otherwise there's nothing to report.
+        led = state.get("ledger")
+        if led is None:
+            print("(no session cost tracking; start with --session-max-spend)",
+                  file=sys.stderr)
+        else:
+            print(led.summary(), file=sys.stderr)
     elif cmd == "save":
         target = rest or getattr(args, "resume", None)
         if not target:
@@ -432,6 +452,9 @@ def run(args, oai, openai, client, models, model, initial=None, *,
         # Auto-compaction (#48) is opt-in: `--auto-compact` or
         # `defaults.<cmd>.auto_compact` (it costs a summarization call).
         state["budget"] = _compact.budget_from_args(args)
+        # Spend cap (#66): `--max-spend` / `defaults.*.max_spend` meters the
+        # session's model calls (asset tools are gated separately).
+        state["ledger"] = _agent.ledger_from_args(args, models, model)
 
         if _rl is not None:
             _install_completer(_rl, models, stack)

{venice_cli-0.41.0 → venice_cli-0.43.0}/src/venice/commands/chat.py

@@ -153,6 +153,14 @@ def register(subparsers) -> None:
         help="Per-call auto-approve cap for paid tools (default: $0.10 / "
         "$VENICE_MCP_MAX_SPEND). Over-cap calls prompt on a TTY.",
     )
+    ag.add_argument(
+        "--session-max-spend", type=float, default=None, metavar="USD",
+        dest="session_max_spend",
+        help="Cap total chat-completion spend for this session (#66). Meters the "
+        "model's own calls (not just paid tools) from server token usage; at the "
+        "cap the agent stops starting new turns and wraps up. Distinct from "
+        "--max-spend (the per-call tool cap).",
+    )
     ag.add_argument("--yes", "-y", action="store_true", default=None,
                     help="Auto-approve every paid tool call and every side-effecting "
                     "external MCP tool (skips the confirm gate).")
@@ -443,6 +451,7 @@ def _run_agent(args, oai, openai, client, models, model, kwargs) -> Optional[int
                 yes=bool(args.yes),
                 json_out=args.json,
                 budget=_compact.budget_from_args(args),  # #48 auto-compact parity
+                ledger=_agent.ledger_from_args(args, models, model),  # #66 spend cap
             )
         except openai.OpenAIError as e:
             return _openai.status_to_exit(openai, e, "chat")