venice-cli 0.77.0__tar.gz → 0.78.0__tar.gz

{venice_cli-0.77.0 → venice_cli-0.78.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.77.0
+Version: 0.78.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
@@ -28,10 +28,10 @@ Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: Utilities
 Requires-Python: >=3.9
 Provides-Extra: all
-Requires-Dist: mcp>=1.2; (python_version >= '3.10') and extra == 'all'
+Requires-Dist: mcp<2,>=1.2; (python_version >= '3.10') and extra == 'all'
 Requires-Dist: openai>=1.40; extra == 'all'
 Provides-Extra: mcp
-Requires-Dist: mcp>=1.2; (python_version >= '3.10') and extra == 'mcp'
+Requires-Dist: mcp<2,>=1.2; (python_version >= '3.10') and extra == 'mcp'
 Provides-Extra: openai
 Requires-Dist: openai>=1.40; extra == 'openai'
 Provides-Extra: test
@@ -614,7 +614,10 @@ message, keeping the last `N` turns verbatim),
 `/cost` (this session's estimated spend so far; `--session-max-spend` adds a
 cap), `/usage` (a token + cost breakdown for the session, keeping the
 cache-read/cache-write/uncached input split distinct so cache-heavy sessions
-cost out correctly, plus a **wall-clock** row — total, turn count and average
+cost out correctly — the split and the hit rate report `n/a` when the model's
+usage block carried no cache fields at all, so a printed `0.0%` always means the
+provider reported a real zero rather than that nobody looked — plus a
+**wall-clock** row — total, turn count and average
 for the time the CLI kept you waiting, measured from submitting a turn to
 getting the prompt back, so thinking time at the prompt is never counted; it
 accumulates across `--resume`), `/reset` (clear history, keep the system prompt),
@@ -624,7 +627,11 @@ accumulates across `--resume`), `/reset` (clear history, keep the system prompt)
 `git commit`, optionally pre-seeded with `text`),
 `/help`, and `/exit` (or `/quit`, or Ctrl-D). Ctrl-C aborts the current turn
 without ending the session (while a tool-loop turn is running it first pauses to
-steer — see [Mid-run steering](#mid-run-steering-venice-sessions-send)). Tab completes slash-commands (and model ids after
+steer — see [Mid-run steering](#mid-run-steering-venice-sessions-send)); at the
+prompt it just discards the half-typed line and re-prompts. However you leave —
+`/exit`, Ctrl-D, or a Ctrl-C that lands somewhere unexpected — the session is
+flushed to disk first, so slash-command edits like `/model` and `/system` are
+never lost to the way you quit. Tab completes slash-commands (and model ids after
 `/model `, persona names after `/persona `). At a per-tool confirmation prompt, `a` accepts that call **and**
 auto-accepts the rest of the run. `--max-tool-calls 0` runs until the model
 stops on its own (instead of capping at the default and asking to continue).
@@ -1896,6 +1903,7 @@ The player list (`paplay` -> `aplay` -> `ffplay` -> `mpg123` -> `play`
 | `VENICE_EMBED_CA_BUNDLE` | CA bundle to trust for a self-signed embedding backend (`embed`, `index`, `search`, and the `project_search` agent tool) |
 | `VENICE_MCP_MAX_SPEND` | `mcp-serve` auto-approve cap in USD (default `0.10`) |
 | `VENICE_MCP_OUTPUT_DIR` | where `mcp-serve` tools write files (default: cwd) |
+| `VENICE_USAGE_RAW` | set to `1`/`true`/`yes`/`on` to echo each API response's raw `usage` block to **stderr** as one `usage-raw: {...}` line (diagnostic; stdout stays machine-readable) |
 
 ## Commands at a glance
 

{venice_cli-0.77.0 → venice_cli-0.78.0}/README.md

@@ -574,7 +574,10 @@ message, keeping the last `N` turns verbatim),
 `/cost` (this session's estimated spend so far; `--session-max-spend` adds a
 cap), `/usage` (a token + cost breakdown for the session, keeping the
 cache-read/cache-write/uncached input split distinct so cache-heavy sessions
-cost out correctly, plus a **wall-clock** row — total, turn count and average
+cost out correctly — the split and the hit rate report `n/a` when the model's
+usage block carried no cache fields at all, so a printed `0.0%` always means the
+provider reported a real zero rather than that nobody looked — plus a
+**wall-clock** row — total, turn count and average
 for the time the CLI kept you waiting, measured from submitting a turn to
 getting the prompt back, so thinking time at the prompt is never counted; it
 accumulates across `--resume`), `/reset` (clear history, keep the system prompt),
@@ -584,7 +587,11 @@ accumulates across `--resume`), `/reset` (clear history, keep the system prompt)
 `git commit`, optionally pre-seeded with `text`),
 `/help`, and `/exit` (or `/quit`, or Ctrl-D). Ctrl-C aborts the current turn
 without ending the session (while a tool-loop turn is running it first pauses to
-steer — see [Mid-run steering](#mid-run-steering-venice-sessions-send)). Tab completes slash-commands (and model ids after
+steer — see [Mid-run steering](#mid-run-steering-venice-sessions-send)); at the
+prompt it just discards the half-typed line and re-prompts. However you leave —
+`/exit`, Ctrl-D, or a Ctrl-C that lands somewhere unexpected — the session is
+flushed to disk first, so slash-command edits like `/model` and `/system` are
+never lost to the way you quit. Tab completes slash-commands (and model ids after
 `/model `, persona names after `/persona `). At a per-tool confirmation prompt, `a` accepts that call **and**
 auto-accepts the rest of the run. `--max-tool-calls 0` runs until the model
 stops on its own (instead of capping at the default and asking to continue).
@@ -1856,6 +1863,7 @@ The player list (`paplay` -> `aplay` -> `ffplay` -> `mpg123` -> `play`
 | `VENICE_EMBED_CA_BUNDLE` | CA bundle to trust for a self-signed embedding backend (`embed`, `index`, `search`, and the `project_search` agent tool) |
 | `VENICE_MCP_MAX_SPEND` | `mcp-serve` auto-approve cap in USD (default `0.10`) |
 | `VENICE_MCP_OUTPUT_DIR` | where `mcp-serve` tools write files (default: cwd) |
+| `VENICE_USAGE_RAW` | set to `1`/`true`/`yes`/`on` to echo each API response's raw `usage` block to **stderr** as one `usage-raw: {...}` line (diagnostic; stdout stays machine-readable) |
 
 ## Commands at a glance
 

{venice_cli-0.77.0 → venice_cli-0.78.0}/pyproject.toml

@@ -51,7 +51,13 @@ openai = ["openai>=1.40"]
 # The SDK requires Python >=3.10, so the dep is gated by an environment marker:
 # on 3.9 the extra resolves to nothing (the CLI stays 3.9-compatible; only this
 # one optional command needs 3.10+). Imported lazily, like the openai extra.
-mcp = ["mcp>=1.2; python_version>='3.10'"]
+# Upper-bounded as of 2026-07-29 (#95): mcp 2.0.0, published 2026-07-28, deletes
+# `mcp.server.fastmcp` -- `mcp.server` now exposes `mcpserver` instead. The old
+# unbounded `mcp>=1.2` turned that into a red CI on every branch within the hour,
+# on 3.10-3.13 only (2.0 declares requires-python >=3.10, so the 3.9 job kept
+# resolving 1.x and stayed green). 1.29.0 is the current 1.x and still ships
+# FastMCP. Lift this when `mcp_serve.py` is ported to the 2.x server API.
+mcp = ["mcp>=1.2,<2; python_version>='3.10'"]
 # Test-only: `pexpect` drives the real CLI on a pty in tests/test_drive_cli.py.
 # Deliberately NOT in `all` -- `all` is a *runtime* install, and the CI `package`
 # job's "a base install pulls in nothing third-party" proof must stay meaningful.

venice_cli-0.78.0/src/venice/__init__.py

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

{venice_cli-0.77.0 → venice_cli-0.78.0}/src/venice/cli.py

@@ -24,7 +24,17 @@ def main(argv=None) -> int:
     if handler is None:
         parser.print_help(sys.stderr)
         return 2
-    return int(handler(args) or 0)
+    try:
+        return int(handler(args) or 0)
+    except KeyboardInterrupt:
+        # The net under the per-command Ctrl-C handlers (#92). Each of those returns 130
+        # long before the exception could reach here, so this only ever catches what they
+        # miss -- and what they miss used to be a raw traceback. Deliberately silent: the
+        # command that owns the interrupt has already printed its own notice, and this
+        # must not print a second one over it. 130 is what CPython exited with anyway,
+        # so no exit code changes; see the table in the README.
+        print(file=sys.stderr)  # newline past a half-drawn prompt
+        return 130
 
 
 if __name__ == "__main__":

{venice_cli-0.77.0 → venice_cli-0.78.0}/src/venice/commands/_agent.py

@@ -28,12 +28,16 @@ import contextlib
 import io
 import itertools
 import json
+import os
 import sys
 import threading
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
 from typing import Callable, Dict, List, NamedTuple, Optional, Tuple
 
+# Aliased: a bare `config` would be shadowed by the `config=None` keyword argument
+# that `browser_tools` (and its callers) already take further down this module.
+from .. import config as _config
 from .. import userconfig
 from . import _exec
 from . import _mcp
@@ -212,6 +216,70 @@ def _detail(usage: dict, section: str, key: str):
     return None
 
 
+#: The cache sub-fields we recognize inside ``prompt_tokens_details``, in priority
+#: order. `reference/venice-openapi.yaml` documents exactly two (`cached_tokens`,
+#: `cache_creation_input_tokens`); `cache_write_tokens` is OBSERVED on live
+#: kimi/glm/deepseek responses but undocumented, so it is read as a fallback and
+#: must never take precedence over the documented name. Deliberately NOT widened
+#: to the Anthropic/DeepSeek-native top-level aliases (`cache_read_input_tokens`,
+#: `prompt_cache_hit_tokens`): Venice never emits them, and an additive top-level
+#: block would hit the clamp in `record()` -- truncating the write bucket to 0
+#: while `CostLedger`'s "reported" flag swore it was measured, which is a NEW lie.
+#: `_cache_tokens`'s three-state is the honest degradation for a rename (#98).
+_CACHE_READ_KEYS = ("cached_tokens",)
+_CACHE_WRITE_KEYS = ("cache_creation_input_tokens", "cache_write_tokens")
+
+
+def _cache_tokens(usage: dict, keys) -> Optional[int]:
+    """A cache token count from ``prompt_tokens_details``; None when unreported (#98).
+
+    THREE-STATE ON PURPOSE, and that is the whole point of #98. `None` means "this
+    response carried no such field at all", which is NOT the same as a reported zero:
+    the spec marks `prompt_tokens_details` ``nullable: true`` and leaves it out of
+    `required` (its own glm example ships ``prompt_tokens_details: null``), so
+    coercing absence to 0 fabricates a "cache hit rate: 0.0%" that reads as a real
+    measurement. A printed 0.0% must mean the provider said zero.
+
+    Present-but-null and present-but-garbage both count as ABSENT -- a value we cannot
+    read is not a measurement (mirrors :func:`_as_int`'s "a bool is never a token
+    count" rule). :func:`_detail` is kept as-is for `reasoning_tokens`, which stays
+    deliberately two-state: no incident, and no rate hangs off it.
+    """
+    for key in keys:
+        v = _detail(usage, "prompt_tokens_details", key)
+        if isinstance(v, (int, float)) and not isinstance(v, bool):
+            return _as_int(v)
+    return None
+
+
+def _dump_raw_usage(usage) -> None:
+    """Echo one API response's raw `usage` block to stderr when opted in (#98).
+
+    The ledger aggregates, and an aggregate cannot answer "was the field even there?"
+    after the fact -- nothing else persists the raw block, so diagnosing a cache
+    regression used to mean re-running the incident live.
+
+    Off unless $VENICE_USAGE_RAW is explicitly truthy -- a bare truthiness check would
+    turn this ON for ``VENICE_USAGE_RAW=0``. STDERR only: `venice code --json` and every
+    piped command must keep stdout machine-readable.
+
+    Exactly ONE `print`, so each record stays an atomic line -- this fires on subagent
+    and review ledgers too, which run under a ThreadPoolExecutor, and two writes would
+    interleave into garbage under `--parallel`. A diagnostic must never take down the
+    turn that produced it, hence the blanket serialization fallback.
+    """
+    if os.environ.get(_config.ENV_USAGE_RAW, "").strip().lower() not in (
+        "1", "true", "yes", "on"
+    ):
+        return
+    try:
+        raw = usage.model_dump() if hasattr(usage, "model_dump") else usage
+        line = json.dumps(raw, sort_keys=True, default=str)
+    except Exception:  # noqa: BLE001 - a diagnostic must never break the turn
+        line = repr(usage)
+    print(f"usage-raw: {line}", file=sys.stderr)
+
+
 def format_duration(seconds) -> str:
     """A compact human duration: ``4.5s``, ``2m 14s``, ``1h 03m`` (#81).
 
@@ -258,6 +326,16 @@ class CostLedger:
         self.cache_write_tokens = 0
         self.reasoning_tokens = 0
         self.unpriced = False  # saw a turn whose model price was unknown
+        # #98: sticky "at least one recorded turn carried no recognized cache-read
+        # (resp. cache-write) field", mirroring `unpriced`. These exist so a rendered
+        # 0 can be told apart from an absent one -- the buckets above cannot say
+        # "unknown", and `cache hit rate: 0.0%` was being emitted by byte-identical
+        # code for a real miss and for a response with no cache block at all. They
+        # drive DIFFERENT render sites (see `usage_report`): read-reported-but-
+        # write-absent is the normal state for most Venice models, so folding them
+        # into one marker would tag essentially every session.
+        self.cache_read_unreported = False
+        self.cache_write_unreported = False
         # #81: the operator's wall-clock. `elapsed_seconds` is BLOCKED time only --
         # the caller stamps the window and passes the delta, so the ledger never reads
         # a clock and every ledger test stays a pure-function assertion. `turns` counts
@@ -299,6 +377,8 @@ class CostLedger:
             "unpriced": self.unpriced,
             "elapsed_seconds": self.elapsed_seconds,  # #81
             "turns": self.turns,
+            "cache_read_unreported": self.cache_read_unreported,    # #98
+            "cache_write_unreported": self.cache_write_unreported,  # #98
         }
 
     def restore(self, d) -> None:
@@ -328,6 +408,14 @@ class CostLedger:
         self.turns += _as_int(d.get("turns"))
         if d.get("unpriced"):
             self.unpriced = True
+        # #98: sticky-OR like `unpriced`, and falsy-by-default so a pre-#98 envelope
+        # (which has neither key) claims "reported" rather than retroactively marking
+        # every resumed session unknown. The inaccuracy has a one-turn lifetime: the
+        # flags are sticky, so the resumed session's first `record()` sets the truth.
+        if d.get("cache_read_unreported"):
+            self.cache_read_unreported = True
+        if d.get("cache_write_unreported"):
+            self.cache_write_unreported = True
 
     def record_turn(self, seconds) -> None:
         """Add one blocked window's wall-clock and count the turn (#81).
@@ -351,7 +439,19 @@ class CostLedger:
         buckets are subsets of `prompt_tokens` in Venice's OpenAI-normalized
         usage shape, so uncached input is the remainder. With no cache tokens and
         no cache pricing this reduces exactly to the old `pt*in + ct*out`.
+
+        A cache field the response never carried is recorded as *unreported* rather
+        than as zero (#98) -- see :func:`_cache_tokens`. The arithmetic is unchanged
+        by that: every shape that used to yield 0 still yields 0.
+
+        NOT READ: the `/responses` endpoint's second usage shape (`input_tokens` /
+        `input_tokens_details.cached_tokens`). The CLI never calls it today, but if it
+        ever does this ledger silently zeroes rather than erroring.
         """
+        # FIRST, ahead of every bail-out below: `record(None)` dumping `usage-raw: null`
+        # is exactly the diagnostic that was missing -- it separates "the response had
+        # no usage block" from "it had one with no cache fields" (#98).
+        _dump_raw_usage(usage)
         if usage is None:
             return 0.0
         if hasattr(usage, "model_dump"):
@@ -360,10 +460,17 @@ class CostLedger:
             return 0.0
         pt = _as_int(usage.get("prompt_tokens"))
         ct = _as_int(usage.get("completion_tokens"))
-        cache_read = _as_int(_detail(usage, "prompt_tokens_details", "cached_tokens"))
-        cache_write = _as_int(
-            _detail(usage, "prompt_tokens_details", "cache_creation_input_tokens")
-        )
+        # #98: None means the field was absent, which is not a reported zero. The
+        # flags are what `usage_report` needs to refuse to print a fake 0.0%; the
+        # counts fall back to 0 so the cost math below is untouched.
+        raw_read = _cache_tokens(usage, _CACHE_READ_KEYS)
+        raw_write = _cache_tokens(usage, _CACHE_WRITE_KEYS)
+        if raw_read is None:
+            self.cache_read_unreported = True
+        if raw_write is None:
+            self.cache_write_unreported = True
+        cache_read = 0 if raw_read is None else raw_read
+        cache_write = 0 if raw_write is None else raw_write
         reasoning = _as_int(
             _detail(usage, "completion_tokens_details", "reasoning_tokens")
         )
@@ -449,16 +556,35 @@ class CostLedger:
             if self.prompt_tokens else 0.0
         )
         lines = ["session usage:"]
-        lines.append(
-            f"  input   {self.prompt_tokens:>10,} tok  "
-            f"({uncached:,} uncached + {self.cache_read_tokens:,} cache-read "
-            f"+ {self.cache_write_tokens:,} cache-write)"
-        )
+        # #98: the two flags govern DIFFERENT rows on purpose. Read-reported-but-
+        # write-absent is the normal shape for most Venice models, so a shared marker
+        # would decorate the hit rate of nearly every session with a warning about a
+        # bucket the hit rate does not even use.
+        if self.cache_read_unreported and self.cache_write_unreported:
+            # Nothing about the split is known -- don't itemize a breakdown that is
+            # entirely inferred, same reflex as "(no tokens reported)" above.
+            split = "cache breakdown not reported"
+        else:
+            read_part = ("cache-read n/a" if self.cache_read_unreported
+                         else f"{self.cache_read_tokens:,} cache-read")
+            write_part = ("cache-write n/a" if self.cache_write_unreported
+                          else f"{self.cache_write_tokens:,} cache-write")
+            # NOTE: with a side unreported, `uncached` is an UPPER BOUND and the terms
+            # no longer sum to the input total -- the n/a shows where the slack went.
+            split = f"{uncached:,} uncached + {read_part} + {write_part}"
+        lines.append(f"  input   {self.prompt_tokens:>10,} tok  ({split})")
         out = f"  output  {self.completion_tokens:>10,} tok"
         if self.reasoning_tokens:
             out += f"  (incl. {self.reasoning_tokens:,} reasoning)"
         lines.append(out)
-        lines.append(f"  cache hit rate: {hit:.1f}%")
+        if not self.cache_read_unreported:
+            lines.append(f"  cache hit rate: {hit:.1f}%")
+        elif self.cache_read_tokens:
+            # Some turns measured, some didn't: the rate is real but understated
+            # against a prompt total that includes turns it could not see.
+            lines.append(f"  cache hit rate: {hit:.1f}%  [partially unreported]")
+        else:
+            lines.append("  cache hit rate: n/a (no cache fields reported)")
         if self.unpriced and self.total == 0.0:
             lines.append("  cost: (model rate unknown)")
         else:

{venice_cli-0.77.0 → venice_cli-0.78.0}/src/venice/commands/_repl.py

@@ -700,42 +700,63 @@ def run(args, oai, openai, client, models, model, initial=None, *,
                 label=label, auto=state["yes"], session=active,
                 ephemeral=ephemeral)
 
-        # An explicit message (`venice chat -i "hello"`) becomes the first turn.
-        if initial:
-            _do_turn(oai, openai, chat, initial, messages, gen_kwargs, state, args)
+        # The session flush lives in exactly one place -- the `finally` below -- so that
+        # no exit path can skip it (#92). It used to be hand-copied into the ^D handler
+        # and the /exit branch, and the ^D copy was skippable: a SIGINT delivered *inside*
+        # an `except` block is not caught by a sibling clause of the same `try`, so the
+        # `except KeyboardInterrupt` here only ever guarded `input()`, never the recovery
+        # code after it. ^D-then-^C (or a lone ^C hitting the readline EOF/SIGINT race)
+        # landed between the newline and the save, and the save never ran. Same structural
+        # move as #86's ledger `_finish`: one call, in a `finally`, unskippable.
+        try:
+            # An explicit message (`venice chat -i "hello"`) becomes the first turn.
+            if initial:
+                _do_turn(oai, openai, chat, initial, messages, gen_kwargs, state, args)
 
-        while True:
-            try:
-                line = input(_PROMPT)
-            except EOFError:
-                print(file=sys.stderr)  # newline after ^D
-                _autosave(state, messages, gen_kwargs)  # flush /model,/system-only edits
-                return 0
-            except KeyboardInterrupt:
-                print(file=sys.stderr)  # ^C at the prompt: discard the line, re-prompt
-                continue
-            line = line.strip()
-            if not line:
-                continue
-            if line.startswith("/"):
-                # /paste and /edit compose a multi-line turn, then submit it like a
-                # normal message. They're handled here (not in _dispatch_slash, which
-                # lacks `openai`/`chat`) so they can call _do_turn directly. (#65)
-                cmd, _, rest = line[1:].partition(" ")
-                if cmd.lower() in ("paste", "edit"):
-                    text = (_read_paste_block() if cmd.lower() == "paste"
-                            else _compose_in_editor(rest.strip()))
-                    if text:
-                        _do_turn(oai, openai, chat, text, messages, gen_kwargs,
-                                 state, args)
-                    continue
-                if _dispatch_slash(
-                    line, messages, state, args, models, oai=oai, gen_kwargs=gen_kwargs
-                ) == "exit":
-                    _autosave(state, messages, gen_kwargs)
+            while True:
+                try:
+                    line = input(_PROMPT)
+                except EOFError:
+                    print(file=sys.stderr)  # newline after ^D
                     return 0
-                continue
-            _do_turn(oai, openai, chat, line, messages, gen_kwargs, state, args)
+                except KeyboardInterrupt:
+                    print(file=sys.stderr)  # ^C at the prompt: discard the line, re-prompt
+                    continue
+                line = line.strip()
+                if not line:
+                    continue
+                if line.startswith("/"):
+                    # /paste and /edit compose a multi-line turn, then submit it like a
+                    # normal message. They're handled here (not in _dispatch_slash, which
+                    # lacks `openai`/`chat`) so they can call _do_turn directly. (#65)
+                    cmd, _, rest = line[1:].partition(" ")
+                    if cmd.lower() in ("paste", "edit"):
+                        text = (_read_paste_block() if cmd.lower() == "paste"
+                                else _compose_in_editor(rest.strip()))
+                        if text:
+                            _do_turn(oai, openai, chat, text, messages, gen_kwargs,
+                                     state, args)
+                        continue
+                    if _dispatch_slash(
+                        line, messages, state, args, models, oai=oai, gen_kwargs=gen_kwargs
+                    ) == "exit":
+                        return 0
+                    continue
+                _do_turn(oai, openai, chat, line, messages, gen_kwargs, state, args)
+        except KeyboardInterrupt:
+            # Whatever the inner clauses didn't already handle: a ^C inside the ^D
+            # teardown, or during a slash-command's own API call. The per-turn abort
+            # (`_turn`, above) and the at-the-prompt re-prompt fire first and never reach
+            # here, so this is always "something unexpected got interrupted" -- end the
+            # session, the way every other command's Ctrl-C handler does. 130 is what
+            # CPython already exited with; this just makes it deliberate and quiet.
+            print(f"\n{label}: aborted", file=sys.stderr)
+            return 130
+        finally:
+            # Also runs on an unexpected crash, which is new: a session that died mid-run
+            # is now persisted rather than lost. `_autosave` no-ops without an active
+            # session (--ephemeral) and swallows disk errors, so this can't itself fail.
+            _autosave(state, messages, gen_kwargs)
 
 
 def _banner(model, tools_on, resume, messages, *, label="venice chat",

{venice_cli-0.77.0 → venice_cli-0.78.0}/src/venice/config.py

@@ -69,6 +69,14 @@ MEMORY_SUBDIR = "memory"  # under INDEX_DIRNAME (.venice) for the project tier
 MEMORY_FILENAME = "memory.json"
 TASKS_FILENAME = "tasks.json"
 
+# Opt-in verbatim dump of each API response's `usage` block to stderr (#98). The
+# ledger aggregates, and an aggregate cannot answer "was the field even there?"
+# after the fact -- nothing persists the raw block anywhere (`venice code --json`
+# and the session envelope both carry only the summed `CostLedger.to_dict()`), so
+# diagnosing a cache regression meant re-running the incident live. Diagnostic
+# only: stderr, so a piped stdout stays machine-readable.
+ENV_USAGE_RAW = "VENICE_USAGE_RAW"
+
 SFX_POLL_INTERVAL_SEC = 2.0
 SFX_POLL_MAX_WAIT_SEC = 300
 

{venice_cli-0.77.0 → venice_cli-0.78.0}/tests/_drive.py

@@ -188,6 +188,15 @@ class Driver:
     def send(self, line: str) -> None:
         self.child.sendline(line)
 
+    def send_partial(self, text: str) -> None:
+        """Type without submitting -- no trailing newline.
+
+        For testing what happens to a line the user never sent: Ctrl-C at the
+        prompt is supposed to discard it (#92). ``send`` would submit it and turn
+        the half-typed line into a real turn.
+        """
+        self.child.send(text)
+
     def send_secret(self, value: str) -> None:
         """Type a secret, and keep it out of any failure transcript.