venice-cli 0.28.0__tar.gz → 0.30.0__tar.gz

{venice_cli-0.28.0 → venice_cli-0.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.28.0
+Version: 0.30.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
@@ -558,10 +558,12 @@ venice chat --resume session.json
 ```
 
 In-REPL slash-commands: `/system [text]` (show/set the system prompt),
-`/model [name]` (switch model), `/reset` (clear history, keep the system
-prompt), `/save [file]` (write the transcript JSON; defaults to the `--resume`
-file), `/help`, and `/exit` (or `/quit`, or Ctrl-D). Ctrl-C aborts the current
-turn without ending the session.
+`/model [name]` (switch model; with no name, show the current one and list the
+catalog), `/models` (list the available models, marking the current and the
+default), `/reset` (clear history, keep the system prompt), `/save [file]`
+(write the transcript JSON; defaults to the `--resume` file), `/help`, and
+`/exit` (or `/quit`, or Ctrl-D). Ctrl-C aborts the current turn without ending
+the session. Tab completes slash-commands (and model ids after `/model `).
 
 ### Venice extensions
 
@@ -886,7 +888,7 @@ complete — a loud stderr warning is printed).
 | `write_file` | create/overwrite a file (atomic) | yes |
 | `edit_file` | replace an exact, unique string in a file | yes |
 | `run` | run a shell command (`/bin/sh -c`) at the root | yes |
-| `venice_image` / `venice_image_edit` / `venice_sfx` / `venice_music` / `venice_tts` / `venice_upscale` / `venice_bg_remove` | generate/edit images & audio into the project — **opt-in with `--assets`** | yes |
+| `venice_image` / `venice_image_edit` / `venice_sfx` / `venice_music` / `venice_tts` / `venice_upscale` / `venice_bg_remove` / `venice_video` | generate/edit images, audio & video into the project — **opt-in with `--assets`** | yes |
 
 **Safety.** Every filesystem path is resolved and confined to the project root
 (default: cwd, or `--root` / `$VENICE_CODE_ROOT`); a path that escapes the root, names
@@ -909,7 +911,7 @@ forced cwd, timeout, and env-scrub — which is why it always confirms. git muta
 | `--root DIR` | project directory to sandbox to (default: cwd) |
 | `--max-tool-calls N` | cap tool invocations before forcing a final answer (default 25) |
 | `--exec-timeout SECS` | timeout for `run`/`git` (default 120) |
-| `--assets` | also expose the in-process asset-generation tools (image / image-edit / sfx / music / tts / upscale / bg-remove) so the agent can create images & audio in the project; paid — each confirms per call unless `--auto` |
+| `--assets` | also expose the in-process asset-generation tools (image / image-edit / sfx / music / tts / upscale / bg-remove / video) so the agent can create images, audio & video in the project; paid — each confirms per call unless `--auto` |
 | `-i`, `--json`, `--model`, `--system` | interactive REPL · JSON envelope · model · extra system instructions |
 
 With `--assets`, generated files land in `$VENICE_MCP_OUTPUT_DIR` or, by default, under

{venice_cli-0.28.0 → venice_cli-0.30.0}/README.md

@@ -520,10 +520,12 @@ venice chat --resume session.json
 ```
 
 In-REPL slash-commands: `/system [text]` (show/set the system prompt),
-`/model [name]` (switch model), `/reset` (clear history, keep the system
-prompt), `/save [file]` (write the transcript JSON; defaults to the `--resume`
-file), `/help`, and `/exit` (or `/quit`, or Ctrl-D). Ctrl-C aborts the current
-turn without ending the session.
+`/model [name]` (switch model; with no name, show the current one and list the
+catalog), `/models` (list the available models, marking the current and the
+default), `/reset` (clear history, keep the system prompt), `/save [file]`
+(write the transcript JSON; defaults to the `--resume` file), `/help`, and
+`/exit` (or `/quit`, or Ctrl-D). Ctrl-C aborts the current turn without ending
+the session. Tab completes slash-commands (and model ids after `/model `).
 
 ### Venice extensions
 
@@ -848,7 +850,7 @@ complete — a loud stderr warning is printed).
 | `write_file` | create/overwrite a file (atomic) | yes |
 | `edit_file` | replace an exact, unique string in a file | yes |
 | `run` | run a shell command (`/bin/sh -c`) at the root | yes |
-| `venice_image` / `venice_image_edit` / `venice_sfx` / `venice_music` / `venice_tts` / `venice_upscale` / `venice_bg_remove` | generate/edit images & audio into the project — **opt-in with `--assets`** | yes |
+| `venice_image` / `venice_image_edit` / `venice_sfx` / `venice_music` / `venice_tts` / `venice_upscale` / `venice_bg_remove` / `venice_video` | generate/edit images, audio & video into the project — **opt-in with `--assets`** | yes |
 
 **Safety.** Every filesystem path is resolved and confined to the project root
 (default: cwd, or `--root` / `$VENICE_CODE_ROOT`); a path that escapes the root, names
@@ -871,7 +873,7 @@ forced cwd, timeout, and env-scrub — which is why it always confirms. git muta
 | `--root DIR` | project directory to sandbox to (default: cwd) |
 | `--max-tool-calls N` | cap tool invocations before forcing a final answer (default 25) |
 | `--exec-timeout SECS` | timeout for `run`/`git` (default 120) |
-| `--assets` | also expose the in-process asset-generation tools (image / image-edit / sfx / music / tts / upscale / bg-remove) so the agent can create images & audio in the project; paid — each confirms per call unless `--auto` |
+| `--assets` | also expose the in-process asset-generation tools (image / image-edit / sfx / music / tts / upscale / bg-remove / video) so the agent can create images, audio & video in the project; paid — each confirms per call unless `--auto` |
 | `-i`, `--json`, `--model`, `--system` | interactive REPL · JSON envelope · model · extra system instructions |
 
 With `--assets`, generated files land in `$VENICE_MCP_OUTPUT_DIR` or, by default, under

venice_cli-0.30.0/src/venice/__init__.py

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

{venice_cli-0.28.0 → venice_cli-0.30.0}/src/venice/commands/_agent.py

@@ -202,6 +202,21 @@ _IMAGE_EDIT_SCHEMA = _obj(
     required=["prompt"],
 )
 
+_VIDEO_SCHEMA = _obj(
+    {
+        "prompt": _p("string", "What the video should depict."),
+        "model": _p("string", "Video model id (default: the catalog default)."),
+        "duration": _p("string", "Clip length, e.g. '5s'."),
+        "negative_prompt": _p("string"),
+        "resolution": _p("string", "Output resolution tier, e.g. 720p/1080p."),
+        "aspect_ratio": _p("string", "Output aspect ratio, e.g. 16:9."),
+        "no_audio": _p("boolean", "Generate silent video (no soundtrack)."),
+        "image_url": _p("string", "URL of a start/reference image (image-to-video)."),
+        "end_image_url": _p("string", "URL of an end frame to interpolate toward."),
+    },
+    required=["prompt"],
+)
+
 # (tool name, `_mcp` impl attribute, description, schema, paid). The impl is
 # stored by NAME and resolved via getattr(_mcp, ...) at builtin_tools() time, so a
 # single source of truth wins and tests can patch `_mcp.<impl>`.
@@ -292,6 +307,15 @@ _CODE_ASSET_BUILTINS = [
         _IMAGE_EDIT_SCHEMA,
         True,
     ),
+    (
+        "venice_video",
+        "video_tool",
+        "Generate a short video via Venice's async video queue (blocks with a capped "
+        "wait; can be slow). Optionally image-to-video from image_url. Writes an .mp4 "
+        "and returns its path. Dynamic pricing, so it always needs confirmation.",
+        _VIDEO_SCHEMA,
+        True,
+    ),
 ]
 
 # Loop-controlled kwargs the model must never supply (stripped defensively).

{venice_cli-0.28.0 → venice_cli-0.30.0}/src/venice/commands/_code.py

@@ -459,7 +459,7 @@ def code_tools(
 
     When `assets` and a `client` are supplied, the in-process asset-generation tools
     (`venice_image`/`venice_image_edit`/`venice_sfx`/`venice_music`/`venice_tts`/
-    `venice_upscale`/`venice_bg_remove`) are folded in via `_agent.builtin_tools`,
+    `venice_upscale`/`venice_bg_remove`/`venice_video`) are folded in via `_agent.builtin_tools`,
     so the agent can create images/audio in the project. They are paid and route
     through the same confirm/spend gate; generated files land in
     ``$VENICE_MCP_OUTPUT_DIR`` or, by default, under `root`.
@@ -534,6 +534,7 @@ def code_tools(
             only={
                 "venice_image", "venice_image_edit", "venice_sfx",
                 "venice_music", "venice_tts", "venice_upscale", "venice_bg_remove",
+                "venice_video",
             },
         ))
     return tools

{venice_cli-0.28.0 → venice_cli-0.30.0}/src/venice/commands/_repl.py

@@ -37,13 +37,20 @@ _PROMPT = "you> "
 _HELP = """\
 Commands:
   /system [text]   show, or set, the system prompt (reseeds the conversation)
-  /model [name]    show, or switch, the model for following turns
+  /model [name]    switch model; with no name, show the current one and list the catalog
+  /models          list the available models (marks the current and default)
   /reset           clear the conversation (keeps the system prompt)
   /save [file]     write the transcript JSON (default: the --resume file)
   /help            show this help
   /exit, /quit     leave the REPL
 Anything else is sent to the model as your next message."""
 
+# Slash-commands, in help order -- the single source of truth for tab-completion
+# (#40). Keep in sync with `_dispatch_slash` and `_HELP`.
+_COMMANDS = (
+    "/system", "/model", "/models", "/reset", "/save", "/help", "/exit", "/quit",
+)
+
 
 class _TranscriptError(Exception):
     """A --resume transcript file is missing or malformed. Message is printable."""
@@ -114,6 +121,91 @@ def _current_system(messages: List[dict]) -> Optional[str]:
     return None
 
 
+# --------------------------------------------------------------------------- #
+# Model listing (#39) + tab-completion (#40)
+# --------------------------------------------------------------------------- #
+def _format_model_list(models, current: Optional[str]) -> str:
+    """One id per line for `/models` and bare `/model`.
+
+    Marks the current model with ``*`` and the catalog's default-trait model with
+    a trailing ``(default)``; appends ``model_spec.name`` when present. Reuses the
+    already-fetched `models` list (no catalog re-fetch). Returns a printable block.
+    """
+    if not models:
+        return "(model catalog unavailable; pass --model or /model <id> to switch)"
+    default = _models.default_model(models)
+    lines = []
+    for m in models:
+        if not isinstance(m, dict):
+            continue
+        mid = m.get("id")
+        if not mid:
+            continue
+        spec = m.get("model_spec") if isinstance(m.get("model_spec"), dict) else {}
+        name = spec.get("name")
+        marker = "*" if mid == current else " "
+        tags = " (default)" if mid == default else ""
+        line = f"  {marker} {mid}{tags}"
+        if name:
+            line += f"  -- {name}"
+        lines.append(line)
+    return "\n".join(lines) if lines else "(no models advertised)"
+
+
+def _make_completer(models, rl):
+    """Build a `readline` completer over the slash-commands and model ids (#40).
+
+    `rl` is the readline module (injected so the closure is unit-testable without
+    a real terminal). The returned ``completer(text, state)`` completes the leading
+    ``/command`` token, and model ids after ``/model ``; it is a no-op on non-slash
+    lines so ordinary prose is never auto-completed.
+    """
+    model_ids = [
+        m.get("id") for m in (models or [])
+        if isinstance(m, dict) and m.get("id")
+    ]
+
+    def completer(text, state):
+        buf = rl.get_line_buffer()
+        if not buf.lstrip().startswith("/"):
+            return None
+        # Empty prefix left of the token => we're completing the command word.
+        if not buf[: rl.get_begidx()].strip():
+            candidates = _COMMANDS
+        elif buf.lstrip().split(maxsplit=1)[0].lower() == "/model":
+            candidates = model_ids
+        else:
+            candidates = ()
+        matches = [c for c in candidates if c.startswith(text)]
+        return matches[state] if state < len(matches) else None
+
+    return completer
+
+
+def _install_completer(rl, models, stack) -> None:
+    """Register the tab-completer for the session, restoring the previous one on exit.
+
+    Sets whitespace-only delimiters so a leading ``/command`` is one token, installs
+    the `_make_completer` closure, and binds Tab (libedit vs GNU readline). The
+    `stack` callback restores the prior completer + delims so we never leak into a
+    parent readline context (e.g. a REPL launched from another readline program).
+    """
+    prev_completer = rl.get_completer()
+    prev_delims = rl.get_completer_delims()
+
+    def _restore():
+        rl.set_completer(prev_completer)
+        rl.set_completer_delims(prev_delims)
+
+    stack.callback(_restore)
+    rl.set_completer_delims(" \t\n")
+    rl.set_completer(_make_completer(models, rl))
+    if "libedit" in (getattr(rl, "__doc__", "") or ""):
+        rl.parse_and_bind("bind ^I rl_complete")
+    else:
+        rl.parse_and_bind("tab: complete")
+
+
 # --------------------------------------------------------------------------- #
 # One turn
 # --------------------------------------------------------------------------- #
@@ -195,6 +287,9 @@ def _dispatch_slash(line, messages, state, args, models) -> str:
                 print(f"(model -> {new})", file=sys.stderr)
         else:
             print(f"model: {state['model']}", file=sys.stderr)
+            print(_format_model_list(models, state["model"]), file=sys.stderr)
+    elif cmd == "models":
+        print(_format_model_list(models, state["model"]), file=sys.stderr)
     elif cmd == "save":
         target = rest or getattr(args, "resume", None)
         if not target:
@@ -231,9 +326,9 @@ def run(args, oai, openai, client, models, model, initial=None, *,
     from . import chat  # lazy: chat imports this module at top (avoid a cycle)
 
     try:
-        import readline  # noqa: F401  (line editing + in-session history)
+        import readline as _rl  # line editing + in-session history + completion
     except Exception:  # pragma: no cover - platform without readline
-        pass
+        _rl = None
 
     try:
         messages = _seed_messages(args)
@@ -267,6 +362,9 @@ def run(args, oai, openai, client, models, model, initial=None, *,
                 tools_on = False   # model lacks function calling -> plain chat
         state = {"model": model, "tools": tools, "tools_on": tools_on}
 
+        if _rl is not None:
+            _install_completer(_rl, models, stack)
+
         _banner(model, tools_on, getattr(args, "resume", None), messages, label=label)
 
         # An explicit message (`venice chat -i "hello"`) becomes the first turn.

{venice_cli-0.28.0 → venice_cli-0.30.0}/src/venice/commands/code.py

@@ -171,8 +171,9 @@ def register(subparsers) -> None:
     grp.add_argument(
         "--assets", action="store_true", dest="assets", default=None,
         help="Also expose the in-process asset-generation tools (venice_image, "
-        "image_edit, sfx, music, tts, upscale, bg_remove) so the agent can create "
-        "images/audio in the project. Paid: each confirms per call unless --auto.",
+        "image_edit, sfx, music, tts, upscale, bg_remove, video) so the agent can "
+        "create images/audio/video in the project. Paid: each confirms per call "
+        "unless --auto.",
     )
 
     it = p.add_argument_group("Interactive")

{venice_cli-0.28.0 → venice_cli-0.30.0}/tests/test_chat.py

@@ -760,6 +760,13 @@ class TestBuiltinToolsRegistry(unittest.TestCase):
             self.assertNotIn(banned, props)
         self.assertEqual(_agent._IMAGE_EDIT_SCHEMA.get("required"), ["prompt"])
 
+    def test_video_schema_excludes_controlled(self):
+        from venice.commands import _agent
+        props = _agent._VIDEO_SCHEMA["properties"]
+        for banned in ("confirm", "max_spend", "output_dir"):
+            self.assertNotIn(banned, props)
+        self.assertEqual(_agent._VIDEO_SCHEMA.get("required"), ["prompt"])
+
 
 if __name__ == "__main__":
     unittest.main()

{venice_cli-0.28.0 → venice_cli-0.30.0}/tests/test_code.py

@@ -18,7 +18,7 @@ def _tools(root, **kw):
 
 _ASSET_NAMES = {
     "venice_image", "venice_image_edit", "venice_sfx", "venice_music",
-    "venice_tts", "venice_upscale", "venice_bg_remove",
+    "venice_tts", "venice_upscale", "venice_bg_remove", "venice_video",
 }
 
 
@@ -242,9 +242,9 @@ class TestCodeFactory(unittest.TestCase):
     def test_assets_present_when_enabled(self):
         names = {t.name for t in _code.code_tools("/tmp", client=object(),
                                                   assets=True)}
-        self.assertTrue(_ASSET_NAMES <= names)   # all 7 folded in
+        self.assertTrue(_ASSET_NAMES <= names)   # all 8 folded in
         self.assertNotIn("venice_chat", names)   # excluded by design
-        self.assertNotIn("venice_video", names)  # deferred
+        self.assertIn("venice_video", names)
 
     def test_asset_tools_are_paid(self):
         by = {t.name: t for t in _code.code_tools("/tmp", client=object(),

{venice_cli-0.28.0 → venice_cli-0.30.0}/tests/test_code_command.py

@@ -111,6 +111,7 @@ class TestCodeCommand(unittest.TestCase):
         names = self._exec_tool_names(calls)
         self.assertIn("venice_image", names)
         self.assertIn("venice_image_edit", names)
+        self.assertIn("venice_video", names)
         self.assertNotIn("venice_chat", names)   # excluded by design
 
     def test_assets_absent_by_default(self):
@@ -146,6 +147,27 @@ class TestCodeCommand(unittest.TestCase):
         # the model supplied only prompt; control kwargs are injected, not from args
         self.assertEqual(stub.call_args.kwargs.get("prompt"), "a hero sprite")
 
+    def test_video_asset_dispatches_with_confirm_under_auto(self):
+        seq = [
+            FakeToolCompletion("plan"),
+            FakeToolCompletion(tool_calls=[
+                _FnCall("c1", "venice_video",
+                        json.dumps({"prompt": "a koi pond at dawn"}))]),
+            FakeToolCompletion("made the clip"),
+            FakeToolCompletion("ACCEPTANCE: PASS"),
+        ]
+        with mock.patch(
+            "venice.commands._mcp.video_tool",
+            return_value={"status": "ok", "path": "/x.mp4", "bytes": 1},
+        ) as stub:
+            rc, calls = self._run(
+                _code_args(task="film", root=self.root, auto=True, assets=True), seq)
+        self.assertEqual(rc, 0)
+        self.assertEqual(stub.call_count, 1)
+        # --auto -> confirm=True bypasses the spend gate
+        self.assertTrue(stub.call_args.kwargs.get("confirm"))
+        self.assertEqual(stub.call_args.kwargs.get("prompt"), "a koi pond at dawn")
+
     def test_acceptance_fail_returns_1(self):
         seq = [
             FakeToolCompletion("plan"),

{venice_cli-0.28.0 → venice_cli-0.30.0}/tests/test_repl.py

@@ -27,6 +27,8 @@ from tests.test_chat import (
     _args,
 )
 
+from venice.commands import _repl  # noqa: E402
+
 _EMPTY_CFG = {"version": 1, "mcpServers": {}, "defaults": {}}
 
 
@@ -290,6 +292,126 @@ class TestRepl(unittest.TestCase):
         self.assertEqual([m["role"] for m in calls[1]["messages"]], ["user"])
         self.assertEqual(calls[1]["messages"][0]["content"], "again")
 
+    # ------------------------------------------------------------------ #
+    # #39: /models listing + bare /model listing
+    # ------------------------------------------------------------------ #
+    def test_slash_models_lists_catalog(self):
+        err = io.StringIO()
+        rc, fake, calls = _run_repl(
+            _args(interactive=True), [], ["/models", "/exit"], stderr=err,
+        )
+        self.assertEqual(rc, 0)
+        self.assertEqual(len(calls), 0)  # listing never calls the model
+        out = err.getvalue()
+        self.assertIn("llama-3.3-70b", out)
+        self.assertIn("venice-uncensored", out)
+        self.assertIn("(default)", out)           # default-trait model marked
+        self.assertIn("* llama-3.3-70b", out)     # current model marked
+
+    def test_bare_model_shows_current_and_lists(self):
+        err = io.StringIO()
+        rc, fake, calls = _run_repl(
+            _args(interactive=True), [], ["/model", "/exit"], stderr=err,
+        )
+        self.assertEqual(rc, 0)
+        out = err.getvalue()
+        self.assertIn("model: llama-3.3-70b", out)  # current still shown
+        self.assertIn("venice-uncensored", out)     # ...plus the catalog list
+
+
+class _FakeRL:
+    """Minimal readline stand-in: the completer needs only these two hooks."""
+
+    def __init__(self, buffer, begidx, *, doc=""):
+        self._buffer = buffer
+        self._begidx = begidx
+        self.__doc__ = doc
+
+    def get_line_buffer(self):
+        return self._buffer
+
+    def get_begidx(self):
+        return self._begidx
+
+
+_CATALOG = [
+    {"id": "llama-3.3-70b", "model_spec": {"traits": ["default"]}},
+    {"id": "venice-uncensored", "model_spec": {"traits": []}},
+]
+
+
+class TestReplCompletion(unittest.TestCase):
+    """#40: the readline completer (unit-tested via an injected fake rl)."""
+
+    def _complete_all(self, buffer, begidx, text):
+        comp = _repl._make_completer(_CATALOG, _FakeRL(buffer, begidx))
+        out, state = [], 0
+        while (m := comp(text, state)) is not None:
+            out.append(m)
+            state += 1
+        return out
+
+    def test_commands_include_models(self):
+        self.assertIn("/models", _repl._COMMANDS)
+
+    def test_completes_slash_command(self):
+        self.assertEqual(self._complete_all("/mo", 0, "/mo"), ["/model", "/models"])
+
+    def test_completes_model_id_after_model(self):
+        self.assertEqual(
+            self._complete_all("/model ven", 7, "ven"), ["venice-uncensored"]
+        )
+
+    def test_bare_model_space_lists_all_ids(self):
+        self.assertEqual(
+            self._complete_all("/model ", 7, ""),
+            ["llama-3.3-70b", "venice-uncensored"],
+        )
+
+    def test_no_completion_off_slash_lines(self):
+        self.assertEqual(self._complete_all("hello wor", 6, "wor"), [])
+
+    def test_other_commands_get_no_model_ids(self):
+        # after `/save ` we offer nothing (filename completion is deferred)
+        self.assertEqual(self._complete_all("/save ", 6, ""), [])
+
+    def test_completer_tolerates_empty_catalog(self):
+        comp = _repl._make_completer(None, _FakeRL("/model ", 7))
+        self.assertIsNone(comp("", 0))  # no ids, no crash
+
+    def test_install_completer_restores_on_exit(self):
+        class RL:
+            def __init__(self):
+                self.completer = "PREV"
+                self.delims = "PREVDELIMS"
+                self.bound = None
+                self.__doc__ = ""  # not libedit -> "tab: complete"
+
+            def get_completer(self):
+                return self.completer
+
+            def get_completer_delims(self):
+                return self.delims
+
+            def set_completer(self, c):
+                self.completer = c
+
+            def set_completer_delims(self, d):
+                self.delims = d
+
+            def parse_and_bind(self, s):
+                self.bound = s
+
+        rl = RL()
+        with contextlib.ExitStack() as stack:
+            _repl._install_completer(rl, _CATALOG, stack)
+            self.assertTrue(callable(rl.completer))   # our completer is installed
+            self.assertEqual(rl.delims, " \t\n")
+            self.assertEqual(rl.bound, "tab: complete")
+        # leaving the REPL restores the prior completer + delims (no leak)
+        self.assertEqual(rl.completer, "PREV")
+        self.assertEqual(rl.delims, "PREVDELIMS")
+
 
 if __name__ == "__main__":
     unittest.main()

venice_cli-0.28.0/src/venice/__init__.py

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