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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.83.2
+Version: 0.83.4
 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.4}/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.4/src/venice/__init__.py

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

{venice_cli-0.83.2 → venice_cli-0.83.4}/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
 
 
@@ -2707,11 +2708,51 @@ def supports_function_calling(models, model_id) -> Optional[bool]:
 # --------------------------------------------------------------------------- #
 # The loop
 # --------------------------------------------------------------------------- #
+_REASONING_FIELDS = ("reasoning_content", "reasoning_details", "reasoning")
+
+
+def _message_field(msg, name):
+    """Read one response-message field from an SDK model or a plain mapping."""
+    if isinstance(msg, dict):
+        return msg.get(name)
+    return getattr(msg, name, None) if msg is not None else None
+
+
+def _request_value(value):
+    """Turn nested SDK response values into request-safe Python values.
+
+    ``reasoning_content`` is normally a string, but the compatible
+    ``reasoning_details`` extension may contain SDK model objects.  Serialize only
+    the selected value recursively instead of dumping the complete response message;
+    the latter also carries response-only metadata rejected by request schemas.
+    """
+    if hasattr(value, "model_dump"):
+        return value.model_dump(exclude_none=True)
+    if isinstance(value, list):
+        return [_request_value(item) for item in value]
+    if isinstance(value, tuple):
+        return [_request_value(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _request_value(item) for key, item in value.items()}
+    return value
+
+
 def _assistant_dict(msg) -> dict:
-    """Reconstruct an assistant turn for the message history (explicit, not
-    model_dump()) so the follow-up tool messages carry the exact tool_call_ids."""
-    d = {"role": "assistant", "content": (getattr(msg, "content", None) or "")}
-    tcs = getattr(msg, "tool_calls", None) if msg is not None else None
+    """Reconstruct the replayable subset of an assistant response.
+
+    Keep content and exact tool-call ids plus one deliberately allowlisted reasoning
+    extension.  Compatible providers use three aliases; when a response unexpectedly
+    carries more than one, preserve the first in ``_REASONING_FIELDS`` order rather
+    than sending conflicting thinking payloads back on the next request.  Do not use a
+    whole-message ``model_dump()``: response-only metadata can be rejected on replay.
+    """
+    d = {"role": "assistant", "content": (_message_field(msg, "content") or "")}
+    for field in _REASONING_FIELDS:
+        value = _message_field(msg, field)
+        if value is not None:
+            d[field] = _request_value(value)
+            break
+    tcs = _message_field(msg, "tool_calls")
     if tcs:
         d["tool_calls"] = [
             {
@@ -3400,9 +3441,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.4}/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.4}/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.4}/src/venice/commands/_repl.py

@@ -309,13 +309,13 @@ def _compose_in_editor(initial: str = "") -> Optional[str]:
 # One turn
 # --------------------------------------------------------------------------- #
 def _stream_turn(oai, chat, model: str, messages: List[dict], gen_kwargs: dict):
-    """One streamed turn; returns (reply_text, usage) for history + budget (#48)."""
+    """One streamed turn; returns (assistant_message, usage) for replay + budget."""
     kwargs = dict(gen_kwargs)
     kwargs["model"] = model
     kwargs["messages"] = messages
     kwargs["stream"] = True
     kwargs["stream_options"] = {"include_usage": True}
-    return chat._consume_stream_full(oai.chat.completions.create(**kwargs))
+    return chat._consume_stream_message_full(oai.chat.completions.create(**kwargs))
 
 
 def _do_turn(oai, openai, chat, text, messages, gen_kwargs, state, args) -> None:
@@ -413,7 +413,9 @@ def _turn(oai, openai, chat, text, messages, gen_kwargs, state, args) -> bool:
                 )
         else:
             _t0 = time.monotonic()
-            reply, usage = _stream_turn(oai, chat, state["model"], messages, gen_kwargs)
+            reply_message, usage = _stream_turn(
+                oai, chat, state["model"], messages, gen_kwargs,
+            )
             if budget is not None:
                 budget.observe(usage)
             if ledger is not None:
@@ -422,7 +424,7 @@ def _turn(oai, openai, chat, text, messages, gen_kwargs, state, args) -> bool:
                 # difference is real -- do not compare a streamed row against a buffered
                 # one and conclude the provider got slower.
                 ledger.record(usage, seconds=time.monotonic() - _t0)
-            messages.append({"role": "assistant", "content": reply})
+            messages.append(reply_message)
     except KeyboardInterrupt:
         # Ctrl-C aborts just this turn -- roll it back and keep the session. With #79's
         # attached steering this is the *second* Ctrl+C (or Ctrl+C at the steer prompt);

{venice_cli-0.83.2 → venice_cli-0.83.4}/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.4}/src/venice/commands/chat.py

@@ -706,9 +706,21 @@ def _consume_stream_full(stream):
     The REPL's auto-compact budget (#48) observes the server-reported prompt
     token count; printing behavior is identical to `_consume_stream`.
     """
+    message, usage = _consume_stream_message_full(stream)
+    return message["content"], usage
+
+
+def _consume_stream_message_full(stream):
+    """Consume a stream and retain its replayable assistant-message extensions.
+
+    The ordinary one-shot surface still returns/prints only visible content.  The
+    multi-turn REPL uses this richer result so Kimi-style reasoning deltas survive in
+    history and the next request can replay the complete assistant turn.
+    """
     citations = None
     usage = None
     parts: list = []
+    reasoning_parts = {field: [] for field in _agent._REASONING_FIELDS}
     for chunk in stream:
         vp = getattr(chunk, "venice_parameters", None)
         if vp is not None and citations is None:
@@ -716,16 +728,33 @@ def _consume_stream_full(stream):
         if getattr(chunk, "usage", None):
             usage = chunk.usage
         if chunk.choices:
-            piece = getattr(chunk.choices[0].delta, "content", None)
+            delta = chunk.choices[0].delta
+            piece = getattr(delta, "content", None)
             if piece:
                 sys.stdout.write(piece)
                 sys.stdout.flush()
                 parts.append(piece)
+            for field in _agent._REASONING_FIELDS:
+                value = getattr(delta, field, None)
+                if value is not None:
+                    reasoning_parts[field].append(_agent._request_value(value))
     if parts:
         sys.stdout.write("\n")
     _print_citations(citations)
     _print_usage(usage)
-    return "".join(parts), usage
+    message = {"role": "assistant", "content": "".join(parts)}
+    for field in _agent._REASONING_FIELDS:
+        values = reasoning_parts[field]
+        if not values:
+            continue
+        if all(isinstance(value, str) for value in values):
+            message[field] = "".join(values)
+        elif all(isinstance(value, list) for value in values):
+            message[field] = [item for value in values for item in value]
+        else:
+            message[field] = values[0] if len(values) == 1 else values
+        break
+    return message, usage
 
 
 def _run_stream(oai, kwargs: dict) -> int:

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

@@ -532,7 +532,7 @@ def _human_pause(acc):
         acc[0] += time.monotonic() - t
 
 
-def _no_tool_turn(oai, model, messages, gen_kwargs, oai_tools, *, ledger=None) -> str:
+def _no_tool_turn(oai, model, messages, gen_kwargs, oai_tools, *, ledger=None) -> dict:
     """One completion with tools advertised but ``tool_choice="none"`` (no side
     effects) -- used for the plan turn and the acceptance-check turn.
 
@@ -550,9 +550,8 @@ def _no_tool_turn(oai, model, messages, gen_kwargs, oai_tools, *, ledger=None) -
         # transcript (see above), so they are the largest rows in the trace -- a trace
         # whose biggest calls read `n/a` would be worse than no trace at all.
         ledger.record(getattr(resp, "usage", None), seconds=time.monotonic() - _t0)
-    if getattr(resp, "choices", None):
-        return resp.choices[0].message.content or ""
-    return ""
+    msg = resp.choices[0].message if getattr(resp, "choices", None) else None
+    return _agent._assistant_dict(msg)
 
 
 # Promoted to `_agent` (#52): the scout subagent firewalls its stdout the same way,
@@ -715,6 +714,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
@@ -856,12 +865,13 @@ def _run_oneshot(args, oai, openai, model, tools, system, gen_kwargs, root, task
             try:
                 # Inside the re-plan loop: each `edit` revision buys another plan turn,
                 # so recording per call (not once) is what makes the total honest.
-                plan_text = _no_tool_turn(oai, model, plan_messages, gen_kwargs,
-                                          oai_tools, ledger=ledger)
+                plan_message = _no_tool_turn(oai, model, plan_messages, gen_kwargs,
+                                             oai_tools, ledger=ledger)
+                plan_text = plan_message.get("content") or ""
             except openai.OpenAIError as e:
                 _finish(ledger, t0, human, json_out=args.json)
                 return _openai.status_to_exit(openai, e, "code")
-            messages.append({"role": "assistant", "content": plan_text})
+            messages.append(plan_message)
 
             if args.plan_only:
                 _finish(ledger, t0, human, json_out=args.json)
@@ -990,14 +1000,17 @@ def _run_oneshot(args, oai, openai, model, tools, system, gen_kwargs, root, task
     if not args.no_verify and not args.no_plan:
         messages.append({"role": "user", "content": _VERIFY_MSG})
         try:
-            report = _no_tool_turn(oai, model, messages, gen_kwargs, oai_tools,
-                                   ledger=ledger)
+            report_message = _no_tool_turn(oai, model, messages, gen_kwargs, oai_tools,
+                                           ledger=ledger)
+            report = report_message.get("content") or ""
             parsed = _parse_verdict(report)
             if parsed is None:      # re-prompt ONCE for the exact verdict line
-                messages.append({"role": "assistant", "content": report})
+                messages.append(report_message)
                 messages.append({"role": "user", "content": _VERIFY_RETRY_MSG})
-                retry = _no_tool_turn(oai, model, messages, gen_kwargs, oai_tools,
-                                      ledger=ledger)
+                retry_message = _no_tool_turn(
+                    oai, model, messages, gen_kwargs, oai_tools, ledger=ledger,
+                )
+                retry = retry_message.get("content") or ""
                 report = f"{report}\n{retry}" if report else retry
                 parsed = _parse_verdict(retry)
         except openai.OpenAIError as e:

{venice_cli-0.83.2 → venice_cli-0.83.4}/tests/test_agent.py

@@ -13,6 +13,7 @@ import tempfile
 import threading
 import time
 import unittest
+from types import SimpleNamespace
 from unittest import mock
 
 from venice.commands import _agent
@@ -46,6 +47,99 @@ def _free_tool():
     return _tool("t", lambda a, *, confirm=False: {"status": "ok"})
 
 
+class TestAssistantReplay(unittest.TestCase):
+    """#129: compatible reasoning fields survive every buffered history seam."""
+
+    def test_synthetic_sdk_message_replays_reasoning_and_exact_tool_call(self):
+        from openai.types.chat import ChatCompletion
+
+        response = ChatCompletion.model_validate({
+            "id": "chatcmpl-test",
+            "object": "chat.completion",
+            "created": 0,
+            "model": "kimi-k3",
+            "choices": [{
+                "index": 0,
+                "finish_reason": "tool_calls",
+                "message": {
+                    "role": "assistant",
+                    "content": "I will inspect it.",
+                    "reasoning_content": "reasoning bytes: \u2603",
+                    "tool_calls": [{
+                        "id": "call-123",
+                        "type": "function",
+                        "function": {"name": "t", "arguments": '{"x":1}'},
+                    }],
+                },
+            }],
+        })
+
+        self.assertEqual(_agent._assistant_dict(response.choices[0].message), {
+            "role": "assistant",
+            "content": "I will inspect it.",
+            "reasoning_content": "reasoning bytes: \u2603",
+            "tool_calls": [{
+                "id": "call-123",
+                "type": "function",
+                "function": {"name": "t", "arguments": '{"x":1}'},
+            }],
+        })
+
+    def test_alias_precedence_is_explicit_and_response_metadata_is_dropped(self):
+        msg = SimpleNamespace(
+            content="visible",
+            tool_calls=None,
+            reasoning_content="preferred",
+            reasoning_details=[{"type": "summary", "text": "other"}],
+            reasoning="last",
+            refusal="response-only",
+        )
+        self.assertEqual(_agent._assistant_dict(msg), {
+            "role": "assistant",
+            "content": "visible",
+            "reasoning_content": "preferred",
+        })
+
+    def test_non_reasoning_message_shape_is_unchanged(self):
+        msg = SimpleNamespace(content=None, tool_calls=None)
+        self.assertEqual(_agent._assistant_dict(msg), {
+            "role": "assistant", "content": "",
+        })
+
+    def test_next_tool_request_includes_reasoning_byte_for_byte(self):
+        first = FakeToolCompletion(
+            tool_calls=[_FnCall("c1", "t", "{}")],
+            reasoning_content="keep this exactly \u2603",
+        )
+        fake, calls = _fake_oai([first, FakeToolCompletion("done")])
+        messages = [{"role": "user", "content": "go"}]
+        with mock.patch.object(sys, "stdout", io.StringIO()), \
+             mock.patch.object(sys, "stderr", io.StringIO()):
+            _agent.run_loop(
+                fake, "kimi-k3", messages, {}, [_free_tool()],
+                max_tool_calls=0, yes=True, json_out=False,
+            )
+        self.assertEqual(
+            calls[1]["messages"][1]["reasoning_content"],
+            "keep this exactly \u2603",
+        )
+
+    def test_forced_final_response_keeps_reasoning_in_history(self):
+        seq = [
+            FakeToolCompletion(tool_calls=[_FnCall("c1", "t", "{}")]),
+            FakeToolCompletion("wrapped", reasoning_content="final thought"),
+        ]
+        fake, _calls = _fake_oai(seq)
+        messages = [{"role": "user", "content": "go"}]
+        with mock.patch.object(sys, "stdout", io.StringIO()), \
+             mock.patch.object(sys, "stderr", io.StringIO()):
+            _agent.run_loop(
+                fake, "kimi-k3", messages, {}, [_free_tool()],
+                max_tool_calls=1, yes=True, json_out=False,
+            )
+        self.assertEqual(messages[-1]["reasoning_content"], "final thought")
+
+
 def _tty(value=True):
     m = mock.MagicMock()
     m.isatty.return_value = value

{venice_cli-0.83.2 → venice_cli-0.83.4}/tests/test_chat.py

@@ -95,18 +95,23 @@ class FakeCompletion:
 
 
 class _Delta:
-    def __init__(self, content):
+    def __init__(self, content, **fields):
         self.content = content
+        for name, value in fields.items():
+            setattr(self, name, value)
 
 
 class _StreamChoice:
-    def __init__(self, content):
-        self.delta = _Delta(content)
+    def __init__(self, content, **fields):
+        self.delta = _Delta(content, **fields)
 
 
 class FakeChunk:
-    def __init__(self, content=None, usage=None, venice_parameters=None):
-        self.choices = [_StreamChoice(content)] if content is not None else []
+    def __init__(self, content=None, usage=None, venice_parameters=None, **delta_fields):
+        self.choices = (
+            [_StreamChoice(content, **delta_fields)]
+            if content is not None or delta_fields else []
+        )
         self.usage = usage
         self.venice_parameters = venice_parameters
 
@@ -166,9 +171,11 @@ class _FnCall:
 
 
 class _ToolMsg:
-    def __init__(self, content=None, tool_calls=None):
+    def __init__(self, content=None, tool_calls=None, **fields):
         self.content = content
         self.tool_calls = tool_calls
+        for name, value in fields.items():
+            setattr(self, name, value)
 
 
 class _ToolChoice:
@@ -180,8 +187,8 @@ class FakeToolCompletion:
     """A completion whose message may carry tool_calls (None => a final answer)."""
 
     def __init__(self, content=None, tool_calls=None, venice_parameters=None,
-                 usage=None):
-        self.choices = [_ToolChoice(_ToolMsg(content, tool_calls))]
+                 usage=None, **message_fields):
+        self.choices = [_ToolChoice(_ToolMsg(content, tool_calls, **message_fields))]
         self.venice_parameters = venice_parameters
         self.usage = usage