venice-cli 0.83.2__tar.gz → 0.83.3__tar.gz

{venice_cli-0.83.2 → venice_cli-0.83.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.83.2
+Version: 0.83.3
 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
@@ -662,6 +662,12 @@ parameters, `max-tool-calls`, the `venice code` sandbox root, and the running
 token/cost usage — so resuming restores the whole context, not just the messages.
 The API key is never written to a session.
 
+`venice code` also assigns each session an opaque `prompt_cache_key`, sent as an
+OpenAI-compatible routing hint so successive plan, tool-loop, and verification calls
+stay on cache-affine backend infrastructure when the provider supports it. The key is
+not a credential. It survives `--resume` and `/reset`; disposable subagents receive
+their own keys, while compaction's deliberately fresh summary request receives none.
+
 One-shot `venice code "task"` runs are sessions too (they persist unless
 `--ephemeral`), so an unattended `--auto` run is resumable, inspectable, and —
 new in this release — **steerable while it runs** (see below).

{venice_cli-0.83.2 → venice_cli-0.83.3}/README.md

@@ -622,6 +622,12 @@ parameters, `max-tool-calls`, the `venice code` sandbox root, and the running
 token/cost usage — so resuming restores the whole context, not just the messages.
 The API key is never written to a session.
 
+`venice code` also assigns each session an opaque `prompt_cache_key`, sent as an
+OpenAI-compatible routing hint so successive plan, tool-loop, and verification calls
+stay on cache-affine backend infrastructure when the provider supports it. The key is
+not a credential. It survives `--resume` and `/reset`; disposable subagents receive
+their own keys, while compaction's deliberately fresh summary request receives none.
+
 One-shot `venice code "task"` runs are sessions too (they persist unless
 `--ephemeral`), so an unattended `--auto` run is resumable, inspectable, and —
 new in this release — **steerable while it runs** (see below).

venice_cli-0.83.3/src/venice/__init__.py

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

{venice_cli-0.83.2 → venice_cli-0.83.3}/src/venice/commands/_agent.py

@@ -46,6 +46,7 @@ from . import _mcp
 from . import _memory
 from . import _models
 from . import _compact
+from . import _openai
 from .models import MODEL_TYPES
 
 
@@ -3400,9 +3401,13 @@ def _run_disposable(
         {"role": "system", "content": sys_prompt},
         {"role": "user", "content": task},
     ]
+    # #128: this is a fresh conversation, not a continuation of the parent. Replace
+    # (rather than inherit) its routing key; every call inside this disposable loop
+    # then shares affinity, while two workers cannot collide on one backend identity.
+    child_kwargs = _openai.with_prompt_cache_key(base_kwargs)
     with _capture_stdout() as buf:
         run_loop(
-            oai, model, messages, base_kwargs, tools,
+            oai, model, messages, child_kwargs, tools,
             max_tool_calls=max_tool_calls, yes=True, json_out=False,
             budget=budget, ledger=ledger,
         )

{venice_cli-0.83.2 → venice_cli-0.83.3}/src/venice/commands/_compact.py

@@ -50,6 +50,8 @@ import time
 from dataclasses import dataclass
 from typing import List, Optional, Tuple
 
+from . import _openai
+
 # Rough chars-per-token for English/code text. Deliberately conservative
 # (overestimate tokens) so the fallback triggers compaction a little early
 # rather than a little late; real counts from `usage` override it anyway.
@@ -315,7 +317,10 @@ def compact_messages(
     prefix, tail = split
     sys_msgs = messages[: len(messages) - len(prefix) - len(tail)]
 
-    kwargs = dict(base_kwargs or {})
+    # #128: compaction is a deliberately fresh summarization conversation. Reusing
+    # the parent session's routing identity would mix unrelated prefixes on one cache
+    # affinity key; preserve all other generation/Venice parameters while stripping it.
+    kwargs = _openai.without_prompt_cache_key(base_kwargs)
     kwargs.pop("stream", None)
     kwargs.pop("stream_options", None)
     kwargs.pop("tools", None)

{venice_cli-0.83.2 → venice_cli-0.83.3}/src/venice/commands/_openai.py

@@ -13,7 +13,55 @@ catalog, so the missing-SDK path never touches the network.
 """
 from __future__ import annotations
 
+import os
 import sys
+from typing import Optional
+
+
+_PROMPT_CACHE_KEY = "prompt_cache_key"
+
+
+def prompt_cache_key(kwargs: Optional[dict]) -> Optional[str]:
+    """The OpenAI-compatible cache-affinity key carried by ``extra_body``.
+
+    The project supports ``openai>=1.40``, predating the SDK's typed
+    ``prompt_cache_key`` argument. Keeping the wire field in ``extra_body`` makes it
+    available on every supported SDK version; the SDK merges it into the request's
+    top-level JSON object.
+    """
+    extra = (kwargs or {}).get("extra_body")
+    value = extra.get(_PROMPT_CACHE_KEY) if isinstance(extra, dict) else None
+    return value if isinstance(value, str) and value else None
+
+
+def with_prompt_cache_key(kwargs: Optional[dict], key: Optional[str] = None) -> dict:
+    """Copy generation kwargs and set one opaque prompt-cache routing key.
+
+    A missing ``key`` mints a new conversation identity. Nested ``extra_body`` is
+    copied before mutation so a disposable subagent can replace its parent's key
+    without changing the parent session or its Venice extension parameters.
+    """
+    out = dict(kwargs or {})
+    extra = out.get("extra_body")
+    extra = dict(extra) if isinstance(extra, dict) else {}
+    extra[_PROMPT_CACHE_KEY] = key or f"venice-{os.urandom(16).hex()}"
+    out["extra_body"] = extra
+    return out
+
+
+def without_prompt_cache_key(kwargs: Optional[dict]) -> dict:
+    """Copy generation kwargs without a parent conversation's affinity key."""
+    out = dict(kwargs or {})
+    extra = out.get("extra_body")
+    if not isinstance(extra, dict) or _PROMPT_CACHE_KEY not in extra:
+        return out
+    extra = dict(extra)
+    extra.pop(_PROMPT_CACHE_KEY, None)
+    if extra:
+        out["extra_body"] = extra
+    else:
+        out.pop("extra_body", None)
+    return out
 
 
 def import_openai(label: str):

{venice_cli-0.83.2 → venice_cli-0.83.3}/src/venice/commands/_review.py

@@ -56,7 +56,7 @@ import threading
 import time
 from typing import Dict, List, Optional, Tuple
 
-from . import _agent, _code, _exec
+from . import _agent, _code, _exec, _openai
 from ._exec import (  # shared exec rails (#33): one gate for every git shell-out
     DEFAULT_EXEC_TIMEOUT,
     MAX_OUTPUT_CHARS,
@@ -584,6 +584,9 @@ def _retry_for_verdict(oai, model: str, report: str, base_kwargs: dict,
     it is supposed to be bounded by.
     """
     _t0 = time.monotonic()
+    # #128: this retry is intentionally a fresh one-shot, not a continuation of the
+    # author or reviewer conversation, so it must not borrow either affinity identity.
+    retry_kwargs = _openai.without_prompt_cache_key(base_kwargs)
     resp = oai.chat.completions.create(
         model=model,
         messages=[
@@ -591,7 +594,7 @@ def _retry_for_verdict(oai, model: str, report: str, base_kwargs: dict,
             {"role": "assistant", "content": report or ""},
             {"role": "user", "content": RETRY_MSG},
         ],
-        **base_kwargs,
+        **retry_kwargs,
     )
     if ledger is not None:
         ledger.record(getattr(resp, "usage", None), seconds=time.monotonic() - _t0)

{venice_cli-0.83.2 → venice_cli-0.83.3}/src/venice/commands/code.py

@@ -715,6 +715,16 @@ def _run(args) -> int:
     # venice_scout). `_gen_kwargs` reads only args.temperature/max_tokens -- no
     # dependency on `tools`, so the reorder is safe.
     gen_kwargs = PROFILE.build_gen_kwargs(args)
+    # #128: Venice can route requests carrying one stable prompt_cache_key to the
+    # same cache-bearing backend. Restore the saved key when one exists; old sessions
+    # receive a key on first resume, and fresh/ephemeral runs mint one before the plan
+    # turn so plan -> execute -> verify all share affinity. It rides in extra_body for
+    # compatibility with the project's openai>=1.40 floor and is persisted automatically
+    # with the session's generation kwargs.
+    saved_cache_key = (
+        _openai.prompt_cache_key(session.gen_kwargs) if session is not None else None
+    )
+    gen_kwargs = _openai.with_prompt_cache_key(gen_kwargs, saved_cache_key)
     # #52 planner slice: the session's shared dispatch record list. scout/spawn append
     # every launched dispatch to it; venice_merge (and the --json envelope) roll it up.
     dispatches = [] if planner else None

{venice_cli-0.83.2 → venice_cli-0.83.3}/tests/test_code_command.py

@@ -138,6 +138,10 @@ class TestCodeCommand(unittest.TestCase):
         self.assertEqual(calls[0]["tool_choice"], "none")   # plan
         self.assertEqual(calls[1]["tool_choice"], "auto")   # execute loop
         self.assertEqual(calls[3]["tool_choice"], "none")   # acceptance check
+        # #128: every phase of one top-level conversation shares backend affinity.
+        keys = [c["extra_body"]["prompt_cache_key"] for c in calls]
+        self.assertTrue(keys[0].startswith("venice-"))
+        self.assertEqual(len(set(keys)), 1)
         # auto -> confirm=True -> the write actually happened
         with open(os.path.join(self.root, "hello.py")) as f:
             self.assertEqual(f.read(), "def hi():\n    return 1\n")
@@ -505,6 +509,7 @@ class TestCodeCommand(unittest.TestCase):
             captured["root"] = root
             captured["system_reseed"] = system_reseed
             captured["ledger"] = kw.get("ledger")
+            captured["gen_kwargs"] = gen_kwargs
             return 0
 
         stdin = mock.MagicMock()
@@ -530,6 +535,9 @@ class TestCodeCommand(unittest.TestCase):
         # #117: the REPL is HANDED the hoisted ledger rather than building its own,
         # because the rails already mirror into that object.
         self.assertIsNotNone(captured["ledger"])
+        self.assertTrue(
+            captured["gen_kwargs"]["extra_body"]["prompt_cache_key"].startswith(
+                "venice-"))
 
     # --- session resume (#47) ---
     def _mk_zone(self):
@@ -612,6 +620,51 @@ class TestCodeCommand(unittest.TestCase):
         self.assertEqual(captured["root"], saved_root)   # faithful restore
         self.assertEqual(captured["session_id"], sess.id)
 
+    def test_prompt_cache_key_survives_save_reset_and_resume(self):
+        zone, _session = self._mk_zone()
+        rc, first_calls = self._run_interactive(
+            _code_args(task="first", root=self.root, interactive=True, auto=True),
+            [FakeToolCompletion("done")], ["/exit"], zone,
+        )
+        self.assertEqual(rc, 0)
+        first_key = first_calls[0]["extra_body"]["prompt_cache_key"]
+
+        with mock.patch.dict(os.environ, {"VENICE_SESSIONS_DIR": zone}):
+            saved = _session.load(_session.most_recent("code").id, "code")
+        self.assertEqual(
+            saved.gen_kwargs["extra_body"]["prompt_cache_key"], first_key)
+
+        rc, resumed_calls = self._run_interactive(
+            _code_args(resume=saved.id, root=self.root, auto=True),
+            [FakeToolCompletion("done again")],
+            ["/reset", "second", "/exit"], zone,
+        )
+        self.assertEqual(rc, 0)
+        self.assertEqual(
+            resumed_calls[0]["extra_body"]["prompt_cache_key"], first_key)
+
+    def test_old_session_without_a_cache_key_is_upgraded_on_resume(self):
+        zone, _session = self._mk_zone()
+        old = _session.new_session(
+            "code", label="venice code", model="llama-3.3-70b", root=self.root,
+            gen_kwargs={"temperature": 0.4},
+            messages=[{"role": "system", "content": "old"}],
+        )
+        with mock.patch.dict(os.environ, {"VENICE_SESSIONS_DIR": zone}):
+            _session.save(old)
+
+        rc, calls = self._run_interactive(
+            _code_args(resume=old.id, root=self.root, auto=True),
+            [FakeToolCompletion("continued")], ["continue", "/exit"], zone,
+        )
+        self.assertEqual(rc, 0)
+        key = calls[0]["extra_body"]["prompt_cache_key"]
+        self.assertTrue(key.startswith("venice-"))
+        with mock.patch.dict(os.environ, {"VENICE_SESSIONS_DIR": zone}):
+            upgraded = _session.load(old.id, "code")
+        self.assertEqual(
+            upgraded.gen_kwargs["extra_body"]["prompt_cache_key"], key)
+
 
 class TestOneShotSteering(unittest.TestCase):
     """#78: one-shot `venice code` runs persist a steerable session + drain steers.

{venice_cli-0.83.2 → venice_cli-0.83.3}/tests/test_compact.py

@@ -259,6 +259,23 @@ class TestCompactMessages(unittest.TestCase):
         self.assertEqual(calls[0]["temperature"], 0.2)
         self.assertEqual(calls[0]["max_tokens"], _compact.SUMMARY_MAX_TOKENS)
 
+    def test_fresh_summary_does_not_reuse_parent_cache_affinity(self):
+        msgs = _history(6)
+        fake, calls = _fake_oai()
+        original = {"extra_body": {
+            "prompt_cache_key": "parent-key",
+            "venice_parameters": {"include_venice_system_prompt": False},
+        }}
+        _compact.compact_messages(
+            fake, "m", msgs, keep_turns=2, base_kwargs=original)
+        self.assertNotIn("prompt_cache_key", calls[0]["extra_body"])
+        self.assertEqual(
+            calls[0]["extra_body"]["venice_parameters"],
+            {"include_venice_system_prompt": False},
+        )
+        self.assertEqual(
+            original["extra_body"]["prompt_cache_key"], "parent-key")
+
 
 class TestBuildSummaryPrompt(unittest.TestCase):
     def test_tool_messages_rendered_as_text(self):

{venice_cli-0.83.2 → venice_cli-0.83.3}/tests/test_review.py

@@ -696,6 +696,32 @@ class TestRunCycle(_RepoBase):
                                     rounds=1)
         self.assertEqual(out["verdict"], "clean")
 
+    def test_verdict_retry_does_not_reuse_parent_cache_affinity(self):
+        oai = mock.MagicMock()
+        oai.chat.completions.create.return_value = FakeToolCompletion(
+            content="REVIEW: CLEAN")
+
+        def _stub(*a, **kw):
+            return {"status": "ok", "tool_calls": 0, "truncated": False,
+                    "report": "SCOPE: x\nFINDINGS: none\n(no sentinel)"}
+
+        base = {"extra_body": {
+            "prompt_cache_key": "parent-key",
+            "venice_parameters": {"include_venice_system_prompt": False},
+        }}
+        with mock.patch.object(_agent, "run_review", _stub):
+            out = _review.run_cycle(
+                oai, "m", self.collected, base, root=self.root, rounds=1)
+        self.assertEqual(out["verdict"], "clean")
+        sent = oai.chat.completions.create.call_args.kwargs
+        self.assertNotIn("prompt_cache_key", sent["extra_body"])
+        self.assertEqual(
+            sent["extra_body"]["venice_parameters"],
+            {"include_venice_system_prompt": False},
+        )
+        self.assertEqual(
+            base["extra_body"]["prompt_cache_key"], "parent-key")
+
     def test_verdict_retry_tokens_are_counted(self):
         # The retry runs outside `_run_disposable`, so nothing else records it. An
         # uncounted call is also an UNCAPPED one -- `--max-tokens` was silently not

{venice_cli-0.83.2 → venice_cli-0.83.3}/tests/test_shared_openai.py

@@ -182,6 +182,41 @@ class TestSupportsCapability(unittest.TestCase):
 
 # --- _openai ---
 
+
+class TestPromptCacheAffinity(unittest.TestCase):
+    def test_mints_an_opaque_key_without_mutating_the_input(self):
+        original = {"temperature": 0.2}
+        out = _openai.with_prompt_cache_key(original)
+        key = _openai.prompt_cache_key(out)
+        self.assertIsInstance(key, str)
+        self.assertTrue(key.startswith("venice-"))
+        self.assertNotIn("extra_body", original)
+
+    def test_explicit_key_preserves_venice_parameters(self):
+        original = {"extra_body": {"venice_parameters": {"enable_web_search": True}}}
+        out = _openai.with_prompt_cache_key(original, "session-key")
+        self.assertEqual(_openai.prompt_cache_key(out), "session-key")
+        self.assertEqual(out["extra_body"]["venice_parameters"],
+                         {"enable_web_search": True})
+        self.assertNotIn("prompt_cache_key", original["extra_body"])
+
+    def test_strip_keeps_other_extra_body_fields_and_does_not_mutate(self):
+        original = {"extra_body": {
+            "prompt_cache_key": "parent",
+            "venice_parameters": {"character_slug": "x"},
+        }}
+        out = _openai.without_prompt_cache_key(original)
+        self.assertIsNone(_openai.prompt_cache_key(out))
+        self.assertEqual(out["extra_body"],
+                         {"venice_parameters": {"character_slug": "x"}})
+        self.assertEqual(_openai.prompt_cache_key(original), "parent")
+
+    def test_strip_removes_empty_extra_body(self):
+        out = _openai.without_prompt_cache_key(
+            {"temperature": 0.1, "extra_body": {"prompt_cache_key": "x"}})
+        self.assertEqual(out, {"temperature": 0.1})
+
+
 class _StubConnErr(Exception):
     pass
 

{venice_cli-0.83.2 → venice_cli-0.83.3}/tests/test_spawn.py

@@ -234,6 +234,28 @@ class TestRunScout(_ScoutBase):
         self.assertIn("SCOUT", first_msgs[0]["content"])
         self.assertEqual(first_msgs[1], {"role": "user", "content": "investigate"})
 
+    def test_each_disposable_conversation_replaces_the_parent_cache_key(self):
+        parent = {"extra_body": {
+            "prompt_cache_key": "parent-key",
+            "venice_parameters": {"include_venice_system_prompt": False},
+        }}
+        fake, calls = _fake_openai_seq([
+            FakeToolCompletion(_REPORT), FakeToolCompletion(_REPORT),
+        ])
+        tools = _code.read_only_tools(self.root)
+        _agent.run_scout(fake, "m", "one", tools, parent, max_tool_calls=4)
+        _agent.run_scout(fake, "m", "two", tools, parent, max_tool_calls=4)
+
+        keys = [c["extra_body"]["prompt_cache_key"] for c in calls]
+        self.assertNotIn("parent-key", keys)
+        self.assertNotEqual(keys[0], keys[1])
+        for call in calls:
+            self.assertEqual(
+                call["extra_body"]["venice_parameters"],
+                {"include_venice_system_prompt": False},
+            )
+        self.assertEqual(parent["extra_body"]["prompt_cache_key"], "parent-key")
+
     def test_focus_hint_threaded_into_system(self):
         seq = [FakeToolCompletion(_REPORT)]
         fake, calls = _fake_openai_seq(seq)

venice_cli-0.83.2/src/venice/__init__.py

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