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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.36.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.

{venice_cli-0.36.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.

venice_cli-0.37.0/src/venice/__init__.py

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

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

@@ -198,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).
@@ -308,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",

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

@@ -528,11 +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"},
-                                          config=config))
+        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

{venice_cli-0.36.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.36.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.36.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.36.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.36.0/src/venice/__init__.py

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