venice-cli 0.35.0__tar.gz → 0.36.0__tar.gz

{venice_cli-0.35.0 → venice_cli-0.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.35.0
+Version: 0.36.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
@@ -1050,6 +1050,12 @@ safety), it should be settable in config." Currently config-backable:
 Per-invocation flags (`--dry-run`, `--json`, `--resume`, `--seed`, inputs and
 positionals) stay CLI-only by design.
 
+These per-command defaults also apply when a generator runs as an **agent tool**
+inside `venice chat --tools` and `venice code` — e.g. `defaults.image.safe_mode`
+is honored when the model calls `venice_image`, not just on the `venice image`
+CLI. An explicit argument the model puts in the tool call still wins over config.
+(`venice mcp-serve` doesn't yet thread config into its wrappers.)
+
 The **API key is never stored here** — it stays in
 `~/.config/venice/credentials`. Unknown keys are preserved on write, so the
 schema is forward-compatible.

{venice_cli-0.35.0 → venice_cli-0.36.0}/README.md

@@ -1012,6 +1012,12 @@ safety), it should be settable in config." Currently config-backable:
 Per-invocation flags (`--dry-run`, `--json`, `--resume`, `--seed`, inputs and
 positionals) stay CLI-only by design.
 
+These per-command defaults also apply when a generator runs as an **agent tool**
+inside `venice chat --tools` and `venice code` — e.g. `defaults.image.safe_mode`
+is honored when the model calls `venice_image`, not just on the `venice image`
+CLI. An explicit argument the model puts in the tool call still wins over config.
+(`venice mcp-serve` doesn't yet thread config into its wrappers.)
+
 The **API key is never stored here** — it stays in
 `~/.config/venice/credentials`. Unknown keys are preserved on write, so the
 schema is forward-compatible.

venice_cli-0.36.0/src/venice/__init__.py

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

{venice_cli-0.35.0 → venice_cli-0.36.0}/src/venice/commands/_agent.py

@@ -24,6 +24,7 @@ and passes the combined list to :func:`run_loop`. Nothing in the loop changes.
 """
 from __future__ import annotations
 
+import inspect
 import itertools
 import json
 import sys
@@ -31,6 +32,7 @@ import threading
 from dataclasses import dataclass
 from typing import Callable, Dict, List, Optional
 
+from .. import userconfig
 from . import _mcp
 from .models import MODEL_TYPES
 
@@ -354,12 +356,20 @@ def _clean(arguments) -> dict:
     return {k: v for k, v in arguments.items() if k not in _CONTROLLED}
 
 
+def _tool_section(name: str) -> str:
+    """Config section for a tool: `venice_image` -> `image` (matches userconfig
+    `_COMMAND_MAP` / the CLI command). Tools with no matching section (e.g.
+    `venice_models`, `project_search`) simply resolve nothing."""
+    return name[len("venice_"):] if name.startswith("venice_") else name
+
+
 def builtin_tools(
     client,
     *,
     max_spend: Optional[float] = None,
     output_dir: Optional[str] = None,
     only: Optional[set] = None,
+    config: Optional[dict] = None,
 ) -> List[Tool]:
     """Build the in-process venice tools, bound to `client`.
 
@@ -368,23 +378,56 @@ def builtin_tools(
     unknown name raises ValueError so the caller can exit 2). With `only=None` the
     set is exactly `_BUILTINS` (chat's default); passing `only=` also makes the
     `_CODE_ASSET_BUILTINS` extras (e.g. `venice_image_edit`) selectable.
+
+    `config` is a userconfig doc (issue #58): `defaults.<section>.*` values are
+    layered UNDER the model's tool arguments, so an explicit tool arg still wins
+    (precedence: model arg > config default > tool hardcoded default). Only keys
+    in `userconfig._COMMAND_MAP[section]` (the #57 allow-list) that the tool
+    function actually accepts are injected.
     """
 
-    def _make_paid(impl):
+    def _config_defaults(section, impl) -> dict:
+        if config is None:
+            return {}
+        section_map = userconfig._COMMAND_MAP.get(section)
+        if not section_map:
+            return {}
+        try:
+            params = set(inspect.signature(impl).parameters)
+        except (TypeError, ValueError):
+            return {}
+        out: dict = {}
+        for key, (dest, coerce) in section_map.items():
+            if dest not in params:
+                continue  # tool doesn't take this preference
+            raw = userconfig.resolve_default(section, key, config)
+            if raw is None:
+                continue
+            try:
+                out[dest] = coerce(raw)
+            except (TypeError, ValueError):
+                pass  # a bad config value shouldn't break tool building
+        return out
+
+    def _make_paid(impl, section):
+        defaults = _config_defaults(section, impl)
+
         def invoke(arguments, *, confirm: bool = False):
             return impl(
                 client,
                 confirm=confirm,
                 max_spend=max_spend,
                 output_dir=output_dir,
-                **_clean(arguments),
+                **{**defaults, **_clean(arguments)},
             )
 
         return invoke
 
-    def _make_free(impl):
+    def _make_free(impl, section):
+        defaults = _config_defaults(section, impl)
+
         def invoke(arguments, *, confirm: bool = False):
-            return impl(client, **_clean(arguments))
+            return impl(client, **{**defaults, **_clean(arguments)})
 
         return invoke
 
@@ -395,9 +438,9 @@ def builtin_tools(
             description=desc,
             parameters=schema,
             invoke=(
-                _make_paid(getattr(_mcp, impl_name))
+                _make_paid(getattr(_mcp, impl_name), _tool_section(name))
                 if paid
-                else _make_free(getattr(_mcp, impl_name))
+                else _make_free(getattr(_mcp, impl_name), _tool_section(name))
             ),
             paid=paid,
         )

{venice_cli-0.35.0 → venice_cli-0.36.0}/src/venice/commands/_code.py

@@ -449,6 +449,7 @@ def code_tools(
     include_search: bool = False,
     assets: bool = False,
     max_spend=None,
+    config=None,
 ) -> List[_agent.Tool]:
     """Build the coding tools bound to a realpath-resolved project `root`.
 
@@ -530,7 +531,8 @@ def code_tools(
     # A free model-catalog lookup so the agent can pick a valid `model` for the
     # asset tools instead of guessing (needs a client for the /models GET).
     if client is not None:
-        tools.extend(_agent.builtin_tools(client, only={"venice_models"}))
+        tools.extend(_agent.builtin_tools(client, only={"venice_models"},
+                                          config=config))
 
     if assets and client is not None:
         asset_dir = os.environ.get("VENICE_MCP_OUTPUT_DIR") or root
@@ -541,6 +543,7 @@ def code_tools(
                 "venice_music", "venice_tts", "venice_upscale", "venice_bg_remove",
                 "venice_video",
             },
+            config=config,  # #58: asset tools honor defaults.<cmd>.*
         ))
     return tools
 

{venice_cli-0.35.0 → venice_cli-0.36.0}/src/venice/commands/chat.py

@@ -338,6 +338,7 @@ def _tools_for(args, client, models, model):
             max_spend=args.max_spend,
             output_dir=str(args.output) if args.output else None,
             only=set(args.tool) if args.tool else None,
+            config=userconfig.load_config(),  # #58: honor defaults.<cmd>.* in tools
         )
     except ValueError as e:
         print(f"chat: {e}", file=sys.stderr)

{venice_cli-0.35.0 → venice_cli-0.36.0}/src/venice/commands/code.py

@@ -358,6 +358,7 @@ def _run(args) -> int:
         exec_timeout=args.exec_timeout or _code.DEFAULT_EXEC_TIMEOUT,
         include_search=True,
         assets=bool(args.assets),
+        config=userconfig.load_config(),  # #58: honor defaults.<cmd>.* in tools
     )
     system = _system_prompt(args, root, tools)
     gen_kwargs = _gen_kwargs(args)

{venice_cli-0.35.0 → venice_cli-0.36.0}/tests/test_agent.py

@@ -194,5 +194,72 @@ class TestProgress(unittest.TestCase):
         self.assertIn("· t", err.getvalue())  # per-tool-call activity line
 
 
+class TestToolSection(unittest.TestCase):
+    def test_section_derivation(self):
+        self.assertEqual(_agent._tool_section("venice_image"), "image")
+        self.assertEqual(_agent._tool_section("venice_image_edit"), "image_edit")
+        self.assertEqual(_agent._tool_section("project_search"), "project_search")
+
+
+class TestConfigDefaults(unittest.TestCase):
+    """#58: defaults.<cmd>.* are layered UNDER a tool's model-supplied args."""
+
+    def _spy(self):
+        captured = {}
+
+        def image_tool(client, prompt=None, *, hide_watermark=None, steps=None,
+                       safe_mode=None, confirm=False, max_spend=None,
+                       output_dir=None, **kw):
+            captured.update(hide_watermark=hide_watermark, steps=steps,
+                            safe_mode=safe_mode)
+            captured.update(kw)
+            return {"status": "ok"}
+
+        return captured, image_tool
+
+    def _tool(self, spy, doc):
+        from venice.commands import _mcp
+        with mock.patch.object(_mcp, "image_tool", spy):
+            return _agent.builtin_tools(object(), config=doc,
+                                        only={"venice_image"})[0]
+
+    def test_injected_and_model_wins(self):
+        captured, spy = self._spy()
+        doc = {"defaults": {"image": {"hide_watermark": True, "steps": 40}}}
+        tool = self._tool(spy, doc)
+        tool.invoke({"prompt": "p"})                     # model set no preference
+        self.assertIs(captured["hide_watermark"], True)  # from config
+        self.assertEqual(captured["steps"], 40)
+        captured.clear()
+        tool.invoke({"prompt": "p", "hide_watermark": False, "steps": 5})
+        self.assertIs(captured["hide_watermark"], False)  # explicit model arg wins
+        self.assertEqual(captured["steps"], 5)
+
+    def test_no_config_no_injection(self):
+        captured, spy = self._spy()
+        tool = self._tool(spy, None)
+        tool.invoke({"prompt": "p"})
+        self.assertIsNone(captured["hide_watermark"])  # tool's own default applies
+        self.assertIsNone(captured["steps"])
+
+    def test_only_accepted_allowlisted_keys_inject(self):
+        # `preset` is config-backable for image (#57) but image_tool takes no such
+        # param -> must NOT be injected; the accepted key still is.
+        captured, spy = self._spy()
+        doc = {"defaults": {"image": {"preset": "foo", "safe_mode": False}}}
+        tool = self._tool(spy, doc)
+        tool.invoke({"prompt": "p"})
+        self.assertNotIn("preset", captured)
+        self.assertIs(captured["safe_mode"], False)
+
+    def test_string_config_value_is_coerced(self):
+        captured, spy = self._spy()
+        doc = {"defaults": {"image": {"hide_watermark": "true", "steps": "12"}}}
+        tool = self._tool(spy, doc)
+        tool.invoke({"prompt": "p"})
+        self.assertIs(captured["hide_watermark"], True)  # _as_bool
+        self.assertEqual(captured["steps"], 12)          # int
+
+
 if __name__ == "__main__":
     unittest.main()

venice_cli-0.35.0/src/venice/__init__.py

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