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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.34.0
+Version: 0.35.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
@@ -626,7 +626,11 @@ produces a final answer. These run **in-process on the `[openai]` extra alone**
 seven of the capabilities `venice mcp-serve` exposes (which adds `venice_video`
 and `venice_image_edit`) — plus `project_search`,
 a read-only [semantic search](#semantic-search) over the project's local
-`venice index` for locating code by meaning before acting on it.
+`venice index` for locating code by meaning before acting on it, and
+`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.)
 
 ```sh
 # One command, multiple steps: the model generates an image, then critiques it.

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

@@ -588,7 +588,11 @@ produces a final answer. These run **in-process on the `[openai]` extra alone**
 seven of the capabilities `venice mcp-serve` exposes (which adds `venice_video`
 and `venice_image_edit`) — plus `project_search`,
 a read-only [semantic search](#semantic-search) over the project's local
-`venice index` for locating code by meaning before acting on it.
+`venice index` for locating code by meaning before acting on it, and
+`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.)
 
 ```sh
 # One command, multiple steps: the model generates an image, then critiques it.

venice_cli-0.35.0/src/venice/__init__.py

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

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

@@ -32,6 +32,7 @@ from dataclasses import dataclass
 from typing import Callable, Dict, List, Optional
 
 from . import _mcp
+from .models import MODEL_TYPES
 
 
 # --------------------------------------------------------------------------- #
@@ -182,6 +183,19 @@ _SEARCH_SCHEMA = _obj(
     required=["query"],
 )
 
+_MODELS_SCHEMA = _obj(
+    {
+        "type": {
+            "type": "string",
+            "enum": ["all", *MODEL_TYPES],
+            "description": "Which catalog type to list model ids for "
+            "(text, code, image, video, music, tts, embedding, upscale), "
+            "or 'all' for a {type: [ids]} map.",
+        },
+    },
+    required=["type"],
+)
+
 # 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).
@@ -282,6 +296,16 @@ _BUILTINS = [
         _CHAT_SCHEMA,
         False,
     ),
+    (
+        "venice_models",
+        "models_tool",
+        "List available Venice model ids for a catalog type (text/code/image/video/"
+        "music/tts/embedding/upscale, or 'all') via the free /models catalog. Use it "
+        "to choose a valid `model` for the other venice_* tools instead of guessing. "
+        "Read-only; not spend-gated.",
+        _MODELS_SCHEMA,
+        False,
+    ),
     (
         "project_search",
         "search_tool",

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

@@ -527,6 +527,11 @@ 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).
+    if client is not None:
+        tools.extend(_agent.builtin_tools(client, only={"venice_models"}))
+
     if assets and client is not None:
         asset_dir = os.environ.get("VENICE_MCP_OUTPUT_DIR") or root
         tools.extend(_agent.builtin_tools(

{venice_cli-0.34.0 → venice_cli-0.35.0}/src/venice/commands/_mcp.py

@@ -29,6 +29,7 @@ from . import bg_remove as _bg
 from . import chat as _chat
 from . import image as _image
 from . import image_edit as _image_edit
+from . import models as _models_cmd
 from . import music as _music
 from . import sfx as _sfx
 from . import tts as _tts
@@ -750,3 +751,33 @@ def search_tool(client, query, *, k: int = 8) -> dict:
     except _index.IndexingError as e:
         return _err(str(e) or f"search: failed (exit {e.exit_code})")
     return {"status": "ok", "results": results, "count": len(results)}
+
+
+def models_tool(client, *, type: str) -> dict:
+    """List available Venice model ids for a catalog `type` (or "all").
+
+    Wraps the free `/models?type=...` GET (`_models.catalog`) so an agent can
+    discover valid model ids before choosing a `model` for the other tools.
+    Read-only; not spend-gated. Returns a flat id list for one type, or a
+    {type: [ids]} map for "all".
+    """
+    valid = _models_cmd.MODEL_TYPES
+    if type != "all" and type not in valid:
+        return _err(
+            f"models: unknown type {type!r}; choose from "
+            + ", ".join(("all", *valid))
+        )
+    types = valid if type == "all" else (type,)
+    by_type = {}
+    for t in types:
+        cat = _models.catalog(client, t)
+        if cat is None:
+            return _err(f"models: /models catalog unavailable for type {t!r}")
+        by_type[t] = [m["id"] for m in cat
+                      if isinstance(m, dict) and m.get("id")]
+    if type == "all":
+        return {"status": "ok", "type": "all",
+                "count": sum(len(v) for v in by_type.values()),
+                "models": by_type}
+    return {"status": "ok", "type": type,
+            "count": len(by_type[type]), "models": by_type[type]}

{venice_cli-0.34.0 → venice_cli-0.35.0}/tests/test_chat.py

@@ -505,8 +505,9 @@ class TestChatAgent(unittest.TestCase):
                     f"{t['function']['name']} leaks control kwarg {banned}",
                 )
         names = {t["function"]["name"] for t in tools}
-        self.assertEqual(len(names), 8)  # seven media/chat tools + project_search
+        self.assertEqual(len(names), 9)  # media/chat + project_search + venice_models
         self.assertIn("project_search", names)
+        self.assertIn("venice_models", names)
 
     def test_tool_error_surfaced_not_fatal(self):
         seq = [
@@ -636,7 +637,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), 9)           # 8 built-ins + 1 remote
+        self.assertEqual(len(names), 10)          # 9 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"])
@@ -650,7 +651,7 @@ class TestChatMcp(unittest.TestCase):
         )
         self.assertEqual(rc, 0)
         attach.assert_not_called()
-        self.assertEqual(len(self._tool_names(calls[0])), 8)  # built-ins only
+        self.assertEqual(len(self._tool_names(calls[0])), 9)  # built-ins only
 
     def test_unknown_mcp_server_exits_2_before_model(self):
         attach = mock.MagicMock()
@@ -738,7 +739,8 @@ 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), 8)
+        self.assertEqual(len(names), 9)  # +venice_models (a deliberate free chat tool)
+        self.assertIn("venice_models", names)
         self.assertNotIn("venice_image_edit", names)
 
     def test_only_can_select_code_asset_extra(self):

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

@@ -246,6 +246,15 @@ class TestCodeFactory(unittest.TestCase):
         self.assertNotIn("venice_chat", names)   # excluded by design
         self.assertIn("venice_video", names)
 
+    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.assertFalse(by["venice_models"].paid)   # read-only, not spend-gated
+
+    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
+
     def test_asset_tools_are_paid(self):
         by = {t.name: t for t in _code.code_tools("/tmp", client=object(),
                                                   assets=True)}

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

@@ -492,5 +492,39 @@ class TestRetrieveBytesParity(unittest.TestCase):
                 _audio.retrieve_bytes(_client(), "m", "q", poll_interval=0, max_wait=-1)
 
 
+class TestModelsTool(_ToolTest):
+    def _catalog(self, *ids):
+        return json.dumps({"data": [{"id": i} for i in ids]}).encode()
+
+    def test_lists_ids_for_one_type(self):
+        with mock.patch("venice.client.urllib.request.urlopen",
+                        _seq(FakeResp(200, self._catalog("m-a", "m-b")))), \
+                self.stdout_guard():
+            out = _mcp.models_tool(_client(), type="image")
+        self.assertEqual(out["status"], "ok")
+        self.assertEqual(out["type"], "image")
+        self.assertEqual(out["models"], ["m-a", "m-b"])
+        self.assertEqual(out["count"], 2)
+
+    def test_all_returns_map_keyed_by_type(self):
+        from venice.commands.models import MODEL_TYPES
+        resps = _seq(*[FakeResp(200, self._catalog(f"{t}-1")) for t in MODEL_TYPES])
+        with mock.patch("venice.client.urllib.request.urlopen", resps), \
+                self.stdout_guard():
+            out = _mcp.models_tool(_client(), type="all")
+        self.assertEqual(out["status"], "ok")
+        self.assertEqual(set(out["models"]), set(MODEL_TYPES))
+        self.assertEqual(out["count"], len(MODEL_TYPES))
+
+    def test_unknown_type_errors_without_http(self):
+        def boom(*a, **kw):
+            raise AssertionError("a bad type must not trigger an HTTP call")
+        with mock.patch("venice.client.urllib.request.urlopen", boom), \
+                self.stdout_guard():
+            out = _mcp.models_tool(_client(), type="bogus")
+        self.assertEqual(out["status"], "error")
+        self.assertIn("unknown type", out["message"])
+
+
 if __name__ == "__main__":
     unittest.main()

venice_cli-0.34.0/src/venice/__init__.py

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