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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.35.0
+Version: 0.37.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
@@ -630,7 +630,9 @@ a read-only [semantic search](#semantic-search) over the project's local
 `venice_models`, a read-only lookup that lists model ids for a given catalog
 type (its single `type` arg — text/code/image/video/music/tts/embedding/upscale,
 or `all`) so the model can pick a valid `model` for the other tools instead of
-guessing. (`venice code` gets `venice_models` too.)
+guessing, and `venice_model_details` (single `model` arg) which returns one
+model's pricing (cost), input context/prompt-length limits, and capabilities so
+the agent can budget its input. (`venice code` gets both too.)
 
 ```sh
 # One command, multiple steps: the model generates an image, then critiques it.
@@ -1050,6 +1052,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.37.0}/README.md

@@ -592,7 +592,9 @@ a read-only [semantic search](#semantic-search) over the project's local
 `venice_models`, a read-only lookup that lists model ids for a given catalog
 type (its single `type` arg — text/code/image/video/music/tts/embedding/upscale,
 or `all`) so the model can pick a valid `model` for the other tools instead of
-guessing. (`venice code` gets `venice_models` too.)
+guessing, and `venice_model_details` (single `model` arg) which returns one
+model's pricing (cost), input context/prompt-length limits, and capabilities so
+the agent can budget its input. (`venice code` gets both too.)
 
 ```sh
 # One command, multiple steps: the model generates an image, then critiques it.
@@ -1012,6 +1014,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.37.0/src/venice/__init__.py

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

{venice_cli-0.35.0 → venice_cli-0.37.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
 
@@ -196,6 +198,13 @@ _MODELS_SCHEMA = _obj(
     required=["type"],
 )
 
+_MODEL_DETAILS_SCHEMA = _obj(
+    {
+        "model": _p("string", "The model id to describe (e.g. from venice_models)."),
+    },
+    required=["model"],
+)
+
 # 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).
@@ -306,6 +315,15 @@ _BUILTINS = [
         _MODELS_SCHEMA,
         False,
     ),
+    (
+        "venice_model_details",
+        "model_details_tool",
+        "Get one model's details -- pricing (cost), input context/prompt-length "
+        "limits (your input budget), and capabilities -- so you can budget input "
+        "and confirm a model fits before using it. Read-only; not spend-gated.",
+        _MODEL_DETAILS_SCHEMA,
+        False,
+    ),
     (
         "project_search",
         "search_tool",
@@ -354,12 +372,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 +394,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 +454,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.37.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`.
 
@@ -527,10 +528,12 @@ def code_tools(
             _SEARCH_SCHEMA, search_invoke, paid=False,
         ))
 
-    # 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).
+    # 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).
     if client is not None:
-        tools.extend(_agent.builtin_tools(client, only={"venice_models"}))
+        tools.extend(_agent.builtin_tools(
+            client, only={"venice_models", "venice_model_details"}, config=config))
 
     if assets and client is not None:
         asset_dir = os.environ.get("VENICE_MCP_OUTPUT_DIR") or root
@@ -541,6 +544,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.37.0}/src/venice/commands/_mcp.py

@@ -781,3 +781,28 @@ def models_tool(client, *, type: str) -> dict:
                 "models": by_type}
     return {"status": "ok", "type": type,
             "count": len(by_type[type]), "models": by_type[type]}
+
+
+def model_details_tool(client, *, model: str) -> dict:
+    """Details for one model id: pricing (cost), context/prompt-length limits, and
+    capabilities -- so an agent can budget its input and confirm a model fits
+    before using it. Read-only; not spend-gated. May scan the catalog by type to
+    locate the id.
+    """
+    if not model or not str(model).strip():
+        return _err("models: a model id is required")
+    m = _models_cmd._find_model(client, str(model).strip())
+    if m is None:
+        return _err(f"models: no model with id {model!r}")
+    spec = m.get("model_spec") if isinstance(m.get("model_spec"), dict) else {}
+    return {
+        "status": "ok",
+        "id": m.get("id"),
+        "type": m.get("type"),
+        "name": spec.get("name") or m.get("name"),
+        "pricing": spec.get("pricing"),
+        "available_context_tokens": spec.get("availableContextTokens"),
+        "prompt_character_limit": spec.get("promptCharacterLimit"),
+        "capabilities": spec.get("capabilities"),
+        "traits": spec.get("traits"),
+    }

{venice_cli-0.35.0 → venice_cli-0.37.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.37.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.37.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 → venice_cli-0.37.0}/tests/test_chat.py

@@ -505,9 +505,10 @@ class TestChatAgent(unittest.TestCase):
                     f"{t['function']['name']} leaks control kwarg {banned}",
                 )
         names = {t["function"]["name"] for t in tools}
-        self.assertEqual(len(names), 9)  # media/chat + project_search + venice_models
+        self.assertEqual(len(names), 10)  # media/chat + project_search + models(+details)
         self.assertIn("project_search", names)
         self.assertIn("venice_models", names)
+        self.assertIn("venice_model_details", names)
 
     def test_tool_error_surfaced_not_fatal(self):
         seq = [
@@ -637,7 +638,7 @@ class TestChatMcp(unittest.TestCase):
         names = self._tool_names(calls[0])
         self.assertIn("fs__read", names)          # remote tool advertised
         self.assertIn("venice_image", names)      # alongside the built-ins
-        self.assertEqual(len(names), 10)          # 9 built-ins + 1 remote
+        self.assertEqual(len(names), 11)          # 10 built-ins + 1 remote
         self.assertEqual(attach.specs, [("fs", {"command": "srv", "args": []})])
         tool_msgs = [m for m in calls[1]["messages"] if m.get("role") == "tool"]
         self.assertIn("127.0.0.1", tool_msgs[0]["content"])
@@ -651,7 +652,7 @@ class TestChatMcp(unittest.TestCase):
         )
         self.assertEqual(rc, 0)
         attach.assert_not_called()
-        self.assertEqual(len(self._tool_names(calls[0])), 9)  # built-ins only
+        self.assertEqual(len(self._tool_names(calls[0])), 10)  # built-ins only
 
     def test_unknown_mcp_server_exits_2_before_model(self):
         attach = mock.MagicMock()
@@ -739,8 +740,9 @@ class TestBuiltinToolsRegistry(unittest.TestCase):
         # chat's default advertisement must not grow when code gains asset tools
         from venice.commands import _agent
         names = {t.name for t in _agent.builtin_tools(object())}
-        self.assertEqual(len(names), 9)  # +venice_models (a deliberate free chat tool)
+        self.assertEqual(len(names), 10)  # +venice_models +venice_model_details (free)
         self.assertIn("venice_models", names)
+        self.assertIn("venice_model_details", names)
         self.assertNotIn("venice_image_edit", names)
 
     def test_only_can_select_code_asset_extra(self):

{venice_cli-0.35.0 → venice_cli-0.37.0}/tests/test_code.py

@@ -249,11 +249,14 @@ class TestCodeFactory(unittest.TestCase):
     def test_models_tool_present_with_client(self):
         by = {t.name: t for t in _code.code_tools("/tmp", client=object())}
         self.assertIn("venice_models", by)   # free model-catalog lookup for the agent
+        self.assertIn("venice_model_details", by)   # cost/context-limit lookup
         self.assertFalse(by["venice_models"].paid)   # read-only, not spend-gated
+        self.assertFalse(by["venice_model_details"].paid)
 
     def test_models_tool_absent_without_client(self):
         names = {t.name for t in _code.code_tools("/tmp")}
         self.assertNotIn("venice_models", names)   # needs a client for the /models GET
+        self.assertNotIn("venice_model_details", names)
 
     def test_asset_tools_are_paid(self):
         by = {t.name: t for t in _code.code_tools("/tmp", client=object(),

{venice_cli-0.35.0 → venice_cli-0.37.0}/tests/test_mcp_tools.py

@@ -526,5 +526,36 @@ class TestModelsTool(_ToolTest):
         self.assertIn("unknown type", out["message"])
 
 
+class TestModelDetailsTool(_ToolTest):
+    def test_returns_curated_details(self):
+        # `text` is first in MODEL_TYPES, so _find_model matches on the first GET.
+        spec = {"name": "Big", "pricing": {"input": {"usd": 1.5}},
+                "availableContextTokens": 131072, "promptCharacterLimit": 1500,
+                "capabilities": {"supportsFunctionCalling": True},
+                "traits": ["default"]}
+        catalog = json.dumps(
+            {"data": [{"id": "big-model", "type": "text", "model_spec": spec}]}
+        ).encode()
+        with mock.patch("venice.client.urllib.request.urlopen",
+                        _seq(FakeResp(200, catalog))), self.stdout_guard():
+            out = _mcp.model_details_tool(_client(), model="big-model")
+        self.assertEqual(out["status"], "ok")
+        self.assertEqual(out["id"], "big-model")
+        self.assertEqual(out["available_context_tokens"], 131072)
+        self.assertEqual(out["prompt_character_limit"], 1500)
+        self.assertEqual(out["pricing"], {"input": {"usd": 1.5}})
+        self.assertTrue(out["capabilities"]["supportsFunctionCalling"])
+
+    def test_unknown_model_errors(self):
+        from venice.commands.models import MODEL_TYPES
+        empty = json.dumps({"data": []}).encode()
+        resps = _seq(*[FakeResp(200, empty) for _ in MODEL_TYPES])
+        with mock.patch("venice.client.urllib.request.urlopen", resps), \
+                self.stdout_guard():
+            out = _mcp.model_details_tool(_client(), model="nope")
+        self.assertEqual(out["status"], "error")
+        self.assertIn("no model", out["message"])
+
+
 if __name__ == "__main__":
     unittest.main()

venice_cli-0.35.0/src/venice/__init__.py

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