venice-cli 0.25.0__tar.gz → 0.26.0__tar.gz

{venice_cli-0.25.0 → venice_cli-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.25.0
+Version: 0.26.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
@@ -731,6 +731,27 @@ The URL can also come from `$VENICE_EMBED_BASE_URL`, and a key (if the backend
 needs one) from `$VENICE_EMBED_API_KEY` — env only, never `config.json`. Both
 are config-backable per-flag via `defaults.embed.*` (see `venice config`).
 
+**Self-signed backends.** A local embedder fronted by Traefik/Caddy often serves
+a private or self-signed TLS cert, which the OpenAI SDK rejects
+(`embed: connection error`, exit 8). Two opt-in escape hatches — **applied only
+to `--embed-base-url`, never the Venice endpoint**:
+
+```sh
+# Trust a private CA (verification stays ON -- preferred):
+venice embed --embed-base-url https://embed.local/v1 --embed-model bge-m3 \
+    --embed-ca-bundle /etc/ssl/my-ca.pem "hi"          # or $VENICE_EMBED_CA_BUNDLE
+
+# Disable verification entirely (self-signed, no CA handy -- prints a warning):
+venice embed --embed-base-url https://embed.local/v1 --embed-model bge-m3 \
+    --embed-insecure "hi"
+```
+
+`--embed-ca-bundle` is config-backable (`defaults.embed.embed_ca_bundle`) and
+reads `$VENICE_EMBED_CA_BUNDLE`. `--embed-insecure` is CLI-only by design —
+turning verification off should always be an explicit, visible choice, never
+something a stale env var or config file switches on. The two are mutually
+exclusive, and passing either without `--embed-base-url` is an error (exit 2).
+
 ## Semantic search
 
 `venice index` builds a local semantic index of a project tree, and `venice
@@ -826,8 +847,14 @@ three possible ways, then executes and finally self-checks the criteria:
 
 Non-interactive with neither `--auto` nor `--plan-only` **aborts (exit 2)** before any
 model call — side-effecting work never runs unattended without an explicit opt-in.
-After execution a final turn reports each criterion MET/NOT MET; with `--json` that
-lands in the envelope and the **exit code reflects it** (0 = all met, 1 = not met).
+After execution a final turn reports each criterion MET/NOT MET and ends with an
+`ACCEPTANCE: PASS`/`FAIL` verdict; with `--json` the verdict lands in the envelope
+(`acceptance.verdict` = `pass`/`fail`/`unknown`). The verdict parse is
+case/format-tolerant and **re-prompts once** for the verdict line if the first reply
+lacks it, so a correct run whose model phrased its verdict loosely still exits 0. The
+**exit code reflects it**: 0 = all met (or check skipped), 1 = not met, 10 = the model
+never emitted a parseable verdict even after the re-prompt (the work may still be
+complete — a loud stderr warning is printed).
 
 **Tools** (path-sandboxed to the project root; mutating tools confirm unless `--auto`):
 
@@ -910,8 +937,9 @@ working directory), or a per-call `output_dir`. The API key is read the usual
 way (`$VENICE_API_KEY` or the credentials file) and is never echoed.
 
 Only stdout carries the JSON-RPC protocol; the server's own diagnostics go to
-stderr. `venice image-edit` exists as a CLI command, but it and the video tools
-are not exposed over MCP yet (tracked separately).
+stderr. Video generation and image editing are exposed over MCP too: the
+`venice_video` and `venice_image_edit` tools cover the same capabilities as the
+`venice video` and `venice image-edit` CLI commands.
 
 The reverse direction — venice as an MCP **client**, calling *other* servers'
 tools inside `venice chat` — is [`venice chat --mcp`](#external-mcp-tools---mcp).
@@ -994,6 +1022,7 @@ Veo 3.1, Kling, Runway Gen4, LTX-2, Wan 2.7, Seedance 2.0, and more.
 | 7 | poll timeout |
 | 8 | network / connection error |
 | 9 | disk write error |
+| 10 | acceptance verdict unparseable / ambiguous (`venice code`) |
 | 130 | Ctrl-C |
 
 ## Audio playback caveat
@@ -1019,6 +1048,7 @@ The player list (`paplay` -> `aplay` -> `ffplay` -> `mpg123` -> `play`
 | `VENICE_BASE_URL` | override the API base URL (testing, proxy) |
 | `VENICE_EMBED_BASE_URL` | `embed` alternate OpenAI-compatible endpoint (local backend) |
 | `VENICE_EMBED_API_KEY` | key for `VENICE_EMBED_BASE_URL` (if the backend needs one) |
+| `VENICE_EMBED_CA_BUNDLE` | CA bundle to trust for `VENICE_EMBED_BASE_URL` TLS (self-signed backend) |
 | `VENICE_MCP_MAX_SPEND` | `mcp-serve` auto-approve cap in USD (default `0.10`) |
 | `VENICE_MCP_OUTPUT_DIR` | where `mcp-serve` tools write files (default: cwd) |
 
@@ -1041,7 +1071,7 @@ The player list (`paplay` -> `aplay` -> `ffplay` -> `mpg123` -> `play`
 | `venice contact-sheet DIR_OR_GLOB [--cols N] [--cell WxH] [--label] [...]` | tile images into one contact sheet (no API call) |
 | `venice chat MESSAGE [--system S] [--model M] [--web-search on] [...]` | one-shot chat completion (OpenAI SDK) |
 | `venice chat [-i] [--resume FILE]` | interactive multi-turn REPL (conversation state, `/`-commands, transcripts) |
-| `venice embed [TEXT] [--from-file PATH] [--model M] [--dimensions N] [--json] [--embed-base-url URL --embed-model M]` | text embeddings (OpenAI SDK; alt/local backend) |
+| `venice embed [TEXT] [--from-file PATH] [--model M] [--dimensions N] [--json] [--embed-base-url URL --embed-model M [--embed-ca-bundle PATH \| --embed-insecure]]` | text embeddings (OpenAI SDK; alt/local backend) |
 | `venice index [PATH] [--model M] [...]` / `venice search QUERY [-k N] [--json]` | build / query a local semantic index of a project tree |
 | `venice code [TASK] [--auto\|--manual] [--plan-only] [-i] [--root DIR] [--json] [...]` | coding agent: plan → accept → edit/run a project (needs `[openai]` + tool-calling model) |
 | `venice mcp-serve` | run an MCP server (stdio) exposing venice tools (needs `[mcp]`) |

{venice_cli-0.25.0 → venice_cli-0.26.0}/README.md

@@ -693,6 +693,27 @@ The URL can also come from `$VENICE_EMBED_BASE_URL`, and a key (if the backend
 needs one) from `$VENICE_EMBED_API_KEY` — env only, never `config.json`. Both
 are config-backable per-flag via `defaults.embed.*` (see `venice config`).
 
+**Self-signed backends.** A local embedder fronted by Traefik/Caddy often serves
+a private or self-signed TLS cert, which the OpenAI SDK rejects
+(`embed: connection error`, exit 8). Two opt-in escape hatches — **applied only
+to `--embed-base-url`, never the Venice endpoint**:
+
+```sh
+# Trust a private CA (verification stays ON -- preferred):
+venice embed --embed-base-url https://embed.local/v1 --embed-model bge-m3 \
+    --embed-ca-bundle /etc/ssl/my-ca.pem "hi"          # or $VENICE_EMBED_CA_BUNDLE
+
+# Disable verification entirely (self-signed, no CA handy -- prints a warning):
+venice embed --embed-base-url https://embed.local/v1 --embed-model bge-m3 \
+    --embed-insecure "hi"
+```
+
+`--embed-ca-bundle` is config-backable (`defaults.embed.embed_ca_bundle`) and
+reads `$VENICE_EMBED_CA_BUNDLE`. `--embed-insecure` is CLI-only by design —
+turning verification off should always be an explicit, visible choice, never
+something a stale env var or config file switches on. The two are mutually
+exclusive, and passing either without `--embed-base-url` is an error (exit 2).
+
 ## Semantic search
 
 `venice index` builds a local semantic index of a project tree, and `venice
@@ -788,8 +809,14 @@ three possible ways, then executes and finally self-checks the criteria:
 
 Non-interactive with neither `--auto` nor `--plan-only` **aborts (exit 2)** before any
 model call — side-effecting work never runs unattended without an explicit opt-in.
-After execution a final turn reports each criterion MET/NOT MET; with `--json` that
-lands in the envelope and the **exit code reflects it** (0 = all met, 1 = not met).
+After execution a final turn reports each criterion MET/NOT MET and ends with an
+`ACCEPTANCE: PASS`/`FAIL` verdict; with `--json` the verdict lands in the envelope
+(`acceptance.verdict` = `pass`/`fail`/`unknown`). The verdict parse is
+case/format-tolerant and **re-prompts once** for the verdict line if the first reply
+lacks it, so a correct run whose model phrased its verdict loosely still exits 0. The
+**exit code reflects it**: 0 = all met (or check skipped), 1 = not met, 10 = the model
+never emitted a parseable verdict even after the re-prompt (the work may still be
+complete — a loud stderr warning is printed).
 
 **Tools** (path-sandboxed to the project root; mutating tools confirm unless `--auto`):
 
@@ -872,8 +899,9 @@ working directory), or a per-call `output_dir`. The API key is read the usual
 way (`$VENICE_API_KEY` or the credentials file) and is never echoed.
 
 Only stdout carries the JSON-RPC protocol; the server's own diagnostics go to
-stderr. `venice image-edit` exists as a CLI command, but it and the video tools
-are not exposed over MCP yet (tracked separately).
+stderr. Video generation and image editing are exposed over MCP too: the
+`venice_video` and `venice_image_edit` tools cover the same capabilities as the
+`venice video` and `venice image-edit` CLI commands.
 
 The reverse direction — venice as an MCP **client**, calling *other* servers'
 tools inside `venice chat` — is [`venice chat --mcp`](#external-mcp-tools---mcp).
@@ -956,6 +984,7 @@ Veo 3.1, Kling, Runway Gen4, LTX-2, Wan 2.7, Seedance 2.0, and more.
 | 7 | poll timeout |
 | 8 | network / connection error |
 | 9 | disk write error |
+| 10 | acceptance verdict unparseable / ambiguous (`venice code`) |
 | 130 | Ctrl-C |
 
 ## Audio playback caveat
@@ -981,6 +1010,7 @@ The player list (`paplay` -> `aplay` -> `ffplay` -> `mpg123` -> `play`
 | `VENICE_BASE_URL` | override the API base URL (testing, proxy) |
 | `VENICE_EMBED_BASE_URL` | `embed` alternate OpenAI-compatible endpoint (local backend) |
 | `VENICE_EMBED_API_KEY` | key for `VENICE_EMBED_BASE_URL` (if the backend needs one) |
+| `VENICE_EMBED_CA_BUNDLE` | CA bundle to trust for `VENICE_EMBED_BASE_URL` TLS (self-signed backend) |
 | `VENICE_MCP_MAX_SPEND` | `mcp-serve` auto-approve cap in USD (default `0.10`) |
 | `VENICE_MCP_OUTPUT_DIR` | where `mcp-serve` tools write files (default: cwd) |
 
@@ -1003,7 +1033,7 @@ The player list (`paplay` -> `aplay` -> `ffplay` -> `mpg123` -> `play`
 | `venice contact-sheet DIR_OR_GLOB [--cols N] [--cell WxH] [--label] [...]` | tile images into one contact sheet (no API call) |
 | `venice chat MESSAGE [--system S] [--model M] [--web-search on] [...]` | one-shot chat completion (OpenAI SDK) |
 | `venice chat [-i] [--resume FILE]` | interactive multi-turn REPL (conversation state, `/`-commands, transcripts) |
-| `venice embed [TEXT] [--from-file PATH] [--model M] [--dimensions N] [--json] [--embed-base-url URL --embed-model M]` | text embeddings (OpenAI SDK; alt/local backend) |
+| `venice embed [TEXT] [--from-file PATH] [--model M] [--dimensions N] [--json] [--embed-base-url URL --embed-model M [--embed-ca-bundle PATH \| --embed-insecure]]` | text embeddings (OpenAI SDK; alt/local backend) |
 | `venice index [PATH] [--model M] [...]` / `venice search QUERY [-k N] [--json]` | build / query a local semantic index of a project tree |
 | `venice code [TASK] [--auto\|--manual] [--plan-only] [-i] [--root DIR] [--json] [...]` | coding agent: plan → accept → edit/run a project (needs `[openai]` + tool-calling model) |
 | `venice mcp-serve` | run an MCP server (stdio) exposing venice tools (needs `[mcp]`) |

venice_cli-0.26.0/src/venice/__init__.py

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

{venice_cli-0.25.0 → venice_cli-0.26.0}/src/venice/commands/_openai.py

@@ -33,17 +33,32 @@ def import_openai(label: str):
     return openai
 
 
-def build_openai(module, client=None, *, base_url=None, api_key=None):
+def build_openai(module, client=None, *, base_url=None, api_key=None, verify=None):
     """Build an SDK client pointed at Venice, borrowing the lean client's auth.
 
     When `base_url` is given (an alternate OpenAI-compatible backend, e.g. a
     local embeddings server), use it and `api_key` directly instead of the
     Venice client -- which may then be None. Local servers usually need no key,
     so `api_key` falls back to a placeholder the SDK accepts.
+
+    `verify` overrides TLS verification for that alternate backend (a CA-bundle
+    path to trust a private CA, or False to disable checks for a self-signed
+    cert). It is opt-in and only reaches non-Venice endpoints. When set we hand
+    the SDK an httpx client (httpx ships transitively with the openai SDK). The
+    client is not explicitly closed -- fine for a one-shot CLI process that exits
+    right after; don't copy this into a long-lived caller without closing it.
     """
+    extra = {}
+    if verify is not None:
+        import httpx
+        extra["http_client"] = httpx.Client(verify=verify)
     if base_url is not None:
-        return module.OpenAI(api_key=api_key or "not-needed", base_url=base_url)
-    return module.OpenAI(api_key=client.api_key, base_url=client.base_url)
+        return module.OpenAI(
+            api_key=api_key or "not-needed", base_url=base_url, **extra
+        )
+    return module.OpenAI(
+        api_key=client.api_key, base_url=client.base_url, **extra
+    )
 
 
 def status_to_exit(module, e, label: str) -> int:

{venice_cli-0.25.0 → venice_cli-0.26.0}/src/venice/commands/code.py

@@ -16,7 +16,11 @@ a controlling LLM identically:
    (``--auto`` -> every tool auto-approved) or manual (per-step confirm gate on the
    ``paid=True`` write/edit/run tools).
 4. **Acceptance check.** A final ``tool_choice="none"`` turn reports each criterion
-   met/unmet; ``--json`` emits it structured and the exit code reflects it.
+   met/unmet and ends with an ``ACCEPTANCE: PASS``/``FAIL`` verdict. The parse is
+   format-tolerant and re-prompts once for the verdict line if the first reply lacks
+   it; ``--json`` emits the verdict structured. The exit code reflects it: 0 = pass
+   (or check skipped), 1 = fail, 10 = verdict unparseable even after the re-prompt
+   (the work may still be complete).
 
 Unlike ``venice chat --tools`` (which degrades to plain chat), ``venice code`` errors
 out on a non-tool-calling model -- coding without tools is pointless.
@@ -31,6 +35,7 @@ import contextlib
 import io
 import json
 import os
+import re
 import sys
 from typing import List, Optional
 
@@ -74,6 +79,20 @@ _VERIFY_MSG = (
     "that is exactly 'ACCEPTANCE: PASS' if every criterion is met, or "
     "'ACCEPTANCE: FAIL' otherwise."
 )
+_VERIFY_RETRY_MSG = (
+    "Your reply did not end with the required verdict line. Reply with nothing but a "
+    "single line that is exactly 'ACCEPTANCE: PASS' if every acceptance criterion is "
+    "met, or 'ACCEPTANCE: FAIL' otherwise."
+)
+
+_VERDICT_RE = re.compile(r"ACCEPTANCE:\s*(PASS|FAIL)", re.IGNORECASE)
+
+
+def _parse_verdict(report: Optional[str]) -> Optional[str]:
+    """'pass' / 'fail' from the last ACCEPTANCE sentinel in the report, or None if
+    no recognizable verdict is present (case/whitespace/markdown tolerant)."""
+    m = _VERDICT_RE.findall(report or "")
+    return m[-1].lower() if m else None
 
 
 def register(subparsers) -> None:
@@ -437,18 +456,28 @@ def _run_oneshot(args, oai, openai, model, tools, system, gen_kwargs, root, task
         return _openai.status_to_exit(openai, e, "code")
 
     # --- Acceptance check ---
-    passed = None
+    verdict = None          # None = skipped; else 'pass' | 'fail' | 'unknown'
     report = None
     if not args.no_verify and not args.no_plan:
         messages.append({"role": "user", "content": _VERIFY_MSG})
         try:
             report = _no_tool_turn(oai, model, messages, gen_kwargs, oai_tools)
+            parsed = _parse_verdict(report)
+            if parsed is None:      # re-prompt ONCE for the exact verdict line
+                messages.append({"role": "assistant", "content": report})
+                messages.append({"role": "user", "content": _VERIFY_RETRY_MSG})
+                retry = _no_tool_turn(oai, model, messages, gen_kwargs, oai_tools)
+                report = f"{report}\n{retry}" if report else retry
+                parsed = _parse_verdict(retry)
         except openai.OpenAIError as e:
             return _openai.status_to_exit(openai, e, "code")
-        passed = "ACCEPTANCE: PASS" in (report or "").upper()
+        verdict = parsed or "unknown"
         if not args.json:
             print("\n=== Acceptance check ===", file=sys.stderr)
             print(report, file=sys.stderr)
+        if verdict == "unknown":
+            print("code: could not parse an ACCEPTANCE verdict from the model "
+                  "(work may be complete) -- exiting 10", file=sys.stderr)
 
     if args.json:
         envelope = {
@@ -456,8 +485,12 @@ def _run_oneshot(args, oai, openai, model, tools, system, gen_kwargs, root, task
             "final": final_text,
         }
         if report is not None:
-            envelope["acceptance"] = {"passed": passed, "report": report}
+            envelope["acceptance"] = {
+                "verdict": verdict,                                    # pass|fail|unknown
+                "passed": {"pass": True, "fail": False}.get(verdict),  # None when unknown
+                "report": report,
+            }
         json.dump(envelope, sys.stdout, indent=2, default=str)
         sys.stdout.write("\n")
 
-    return 1 if passed is False else 0
+    return {None: 0, "pass": 0, "fail": 1, "unknown": 10}[verdict]

{venice_cli-0.25.0 → venice_cli-0.26.0}/src/venice/commands/embed.py

@@ -71,6 +71,28 @@ def register(subparsers) -> None:
             "server has its own catalog, so it is taken as given)."
         ),
     )
+    tls = p.add_mutually_exclusive_group()
+    tls.add_argument(
+        "--embed-ca-bundle",
+        dest="embed_ca_bundle",
+        default=None,
+        metavar="PATH",
+        help=(
+            "Trust this CA-bundle file when verifying the --embed-base-url TLS "
+            "cert (for a local backend behind a private/self-signed CA). Keeps "
+            "verification on; also $VENICE_EMBED_CA_BUNDLE."
+        ),
+    )
+    tls.add_argument(
+        "--embed-insecure",
+        dest="embed_insecure",
+        action="store_true",
+        help=(
+            "Disable TLS verification for --embed-base-url entirely (self-signed "
+            "certs). Only applies to the alternate backend, never Venice; prints "
+            "a warning. Prefer --embed-ca-bundle."
+        ),
+    )
     p.add_argument(
         "--dimensions",
         type=int,
@@ -154,13 +176,33 @@ def _resolve_backend(openai, args) -> tuple:
                 file=sys.stderr,
             )
             return None, None, 2
+        # TLS override, opt-in and non-Venice only: --embed-insecure wins (the
+        # CLI already blocks passing both), else a CA bundle, else the SDK default.
+        verify = False if args.embed_insecure else (args.embed_ca_bundle or None)
+        if verify is False:
+            print(
+                "embed: WARNING: TLS verification disabled (--embed-insecure) "
+                f"for {args.embed_base_url}",
+                file=sys.stderr,
+            )
         oai = _openai.build_openai(
             openai,
             base_url=args.embed_base_url,
             api_key=os.environ.get(config.ENV_EMBED_API_KEY),
+            verify=verify,
         )
         return oai, model, None
 
+    # The Venice endpoint's TLS is not overridable -- reject the flags here so
+    # they can't silently no-op against Venice.
+    if args.embed_insecure or args.embed_ca_bundle:
+        print(
+            "embed: --embed-insecure/--embed-ca-bundle only apply with "
+            "--embed-base-url",
+            file=sys.stderr,
+        )
+        return None, None, 2
+
     try:
         client = build_client_from_auth()
     except auth.AuthError as e:
@@ -186,6 +228,8 @@ def _run(args) -> int:
     # apply_defaults, which only fills a dest that is still None.
     if args.embed_base_url is None:
         args.embed_base_url = os.environ.get(config.ENV_EMBED_BASE_URL)
+    if args.embed_ca_bundle is None:
+        args.embed_ca_bundle = os.environ.get(config.ENV_EMBED_CA_BUNDLE)
     userconfig.apply_defaults(args, "embed")
 
     openai = _openai.import_openai("embed")

{venice_cli-0.25.0 → venice_cli-0.26.0}/src/venice/config.py

@@ -18,6 +18,10 @@ DEFAULT_BASE_URL = "https://api.venice.ai/api/v1"
 # usually need none, and secrets don't belong in config.json).
 ENV_EMBED_BASE_URL = "VENICE_EMBED_BASE_URL"
 ENV_EMBED_API_KEY = "VENICE_EMBED_API_KEY"
+# Trust a private CA when the alternate backend serves a self-signed cert. Only
+# ever applied to --embed-base-url, never the Venice endpoint. (--embed-insecure
+# has no env/config knob by design -- disabling verification stays a CLI choice.)
+ENV_EMBED_CA_BUNDLE = "VENICE_EMBED_CA_BUNDLE"
 
 # `venice index`/`venice search` keep a semantic-search store *project-local*
 # (unlike everything above, which is user-global under ~/.config/venice). The

{venice_cli-0.25.0 → venice_cli-0.26.0}/src/venice/userconfig.py

@@ -217,6 +217,7 @@ _COMMAND_MAP = {
         "encoding_format": ("encoding_format", str),
         "embed_base_url": ("embed_base_url", str),
         "embed_model": ("embed_model", str),
+        "embed_ca_bundle": ("embed_ca_bundle", str),
     },
     "index": {
         "model": ("model", str),

{venice_cli-0.25.0 → venice_cli-0.26.0}/tests/test_code_command.py

@@ -102,6 +102,62 @@ class TestCodeCommand(unittest.TestCase):
             _code_args(task="x", root=self.root, auto=True), seq)
         self.assertEqual(rc, 1)
 
+    # --- #37: the verdict parse is case/format-tolerant (no false-fail) ---
+    def test_acceptance_pass_loose_parse(self):
+        seq = [
+            FakeToolCompletion("plan"),
+            FakeToolCompletion("did the work"),
+            FakeToolCompletion("- works: MET\n**acceptance: pass**"),  # lower + markdown
+        ]
+        rc, calls = self._run(
+            _code_args(task="x", root=self.root, auto=True), seq)
+        self.assertEqual(rc, 0)
+        self.assertEqual(len(calls), 3)                 # no re-prompt fired
+
+    # --- #37: unparseable verdict -> re-prompt once -> recovers to exit 0 ---
+    def test_acceptance_unknown_reprompt_recovers(self):
+        seq = [
+            FakeToolCompletion("plan"),
+            FakeToolCompletion("did the work"),
+            FakeToolCompletion("All acceptance criteria are met."),    # no sentinel
+            FakeToolCompletion("ACCEPTANCE: PASS"),                    # re-prompt reply
+        ]
+        rc, calls = self._run(
+            _code_args(task="x", root=self.root, auto=True), seq)
+        self.assertEqual(rc, 0)
+        self.assertEqual(len(calls), 4)                 # extra re-prompt turn
+        self.assertEqual(calls[3]["tool_choice"], "none")
+
+    # --- #37: still no verdict after the re-prompt -> exit 10 + warning ---
+    def test_acceptance_unknown_persists_exits_10(self):
+        err = io.StringIO()
+        seq = [
+            FakeToolCompletion("plan"),
+            FakeToolCompletion("did the work"),
+            FakeToolCompletion("All criteria met."),                   # no sentinel
+            FakeToolCompletion("Looks good."),                         # still none
+        ]
+        rc, calls = self._run(
+            _code_args(task="x", root=self.root, auto=True), seq, stderr=err)
+        self.assertEqual(rc, 10)
+        self.assertEqual(len(calls), 4)
+        self.assertIn("exiting 10", err.getvalue())
+
+    def test_json_verdict_unknown(self):
+        out = io.StringIO()
+        seq = [
+            FakeToolCompletion("plan"),
+            FakeToolCompletion("did the work"),
+            FakeToolCompletion("All criteria met."),
+            FakeToolCompletion("Still looks good."),
+        ]
+        rc, _calls = self._run(
+            _code_args(task="x", root=self.root, auto=True, json=True), seq, stdout=out)
+        self.assertEqual(rc, 10)
+        env = json.loads(out.getvalue())
+        self.assertEqual(env["acceptance"]["verdict"], "unknown")
+        self.assertIsNone(env["acceptance"]["passed"])
+
     # --- fail-safe: non-TTY without --auto aborts before any model call ---
     def test_non_tty_without_auto_aborts(self):
         err = io.StringIO()
@@ -138,6 +194,7 @@ class TestCodeCommand(unittest.TestCase):
         self.assertEqual(env["plan"], "plan text")
         self.assertIn("wrote n.py", env["final"])
         self.assertTrue(env["acceptance"]["passed"])
+        self.assertEqual(env["acceptance"]["verdict"], "pass")
         self.assertEqual(env["root"], self.root)
 
     # --- --no-plan skips plan + verify ---

{venice_cli-0.25.0 → venice_cli-0.26.0}/tests/test_embed.py

@@ -21,6 +21,7 @@ def _args(**ov):
         text=None, from_file=None, model=None,
         dimensions=None, encoding_format=None, json=False,
         embed_base_url=None, embed_model=None,
+        embed_ca_bundle=None, embed_insecure=False,
     )
     base.update(ov)
     return argparse.Namespace(**base)
@@ -123,7 +124,7 @@ class TestEmbed(unittest.TestCase):
         env = {
             k: v for k, v in os.environ.items()
             if k not in ("VENICE_API_KEY", "VENICE_EMBED_BASE_URL",
-                         "VENICE_EMBED_API_KEY")
+                         "VENICE_EMBED_API_KEY", "VENICE_EMBED_CA_BUNDLE")
         }
         env.update(extra_env or {})
         with mock.patch.dict(os.environ, env, clear=True), \
@@ -332,6 +333,86 @@ class TestEmbed(unittest.TestCase):
         self.assertEqual(captured["model"], "cfg-embed")
         self.assertEqual(urlopen.call_count, 0)
 
+    # --- TLS override for the alternate backend (#28) ---
+
+    def test_ca_bundle_reaches_sdk_on_alt_path(self):
+        with mock.patch("httpx.Client", return_value="httpx-sentinel") as Hx:
+            rc, built, captured, urlopen = self._run_alt(
+                _args(text="hi", embed_base_url="https://embed.local/v1",
+                      embed_model="local-embed", embed_ca_bundle="/ca.pem"),
+                FakeEmbeddings([(0, [1.0])]),
+            )
+        self.assertEqual(rc, 0)
+        Hx.assert_called_once_with(verify="/ca.pem")
+        self.assertEqual(built["http_client"], "httpx-sentinel")
+
+    def test_insecure_disables_verification_and_warns(self):
+        err = io.StringIO()
+        with mock.patch("httpx.Client", return_value="httpx-sentinel") as Hx:
+            rc, built, captured, urlopen = self._run_alt(
+                _args(text="hi", embed_base_url="https://embed.local/v1",
+                      embed_model="local-embed", embed_insecure=True),
+                FakeEmbeddings([(0, [1.0])]), stderr=err,
+            )
+        self.assertEqual(rc, 0)
+        Hx.assert_called_once_with(verify=False)
+        self.assertEqual(built["http_client"], "httpx-sentinel")
+        self.assertIn("TLS verification disabled", err.getvalue())
+
+    def test_ca_bundle_from_env_on_alt_path(self):
+        with mock.patch("httpx.Client", return_value="httpx-sentinel") as Hx:
+            rc, built, captured, urlopen = self._run_alt(
+                _args(text="hi", embed_base_url="https://embed.local/v1",
+                      embed_model="local-embed"),
+                FakeEmbeddings([(0, [1.0])]),
+                extra_env={"VENICE_EMBED_CA_BUNDLE": "/env-ca.pem"},
+            )
+        self.assertEqual(rc, 0)
+        Hx.assert_called_once_with(verify="/env-ca.pem")
+
+    def test_ca_bundle_from_config_on_alt_path(self):
+        doc = {"version": 1, "mcpServers": {}, "defaults": {"embed": {
+            "embed_ca_bundle": "/cfg-ca.pem"}}}
+        with mock.patch("httpx.Client", return_value="httpx-sentinel") as Hx:
+            rc, built, captured, urlopen = self._run_alt(
+                _args(text="hi", embed_base_url="https://embed.local/v1",
+                      embed_model="local-embed"),
+                FakeEmbeddings([(0, [1.0])]), doc=doc,
+            )
+        self.assertEqual(rc, 0)
+        Hx.assert_called_once_with(verify="/cfg-ca.pem")
+
+    def test_insecure_without_base_url_is_rejected(self):
+        err = io.StringIO()
+        rc, fake, captured = self._run(
+            _args(text="hi", embed_insecure=True), FakeEmbeddings([(0, [1.0])]),
+            stderr=err,
+        )
+        self.assertEqual(rc, 2)
+        self.assertEqual(fake.embeddings.create.call_count, 0)
+        self.assertIn("only apply with --embed-base-url", err.getvalue())
+
+    def test_ca_bundle_without_base_url_is_rejected(self):
+        err = io.StringIO()
+        rc, fake, captured = self._run(
+            _args(text="hi", embed_ca_bundle="/ca.pem"),
+            FakeEmbeddings([(0, [1.0])]), stderr=err,
+        )
+        self.assertEqual(rc, 2)
+        self.assertEqual(fake.embeddings.create.call_count, 0)
+        self.assertIn("only apply with --embed-base-url", err.getvalue())
+
+    def test_ca_bundle_and_insecure_are_mutually_exclusive(self):
+        from venice.commands import embed
+        parser = argparse.ArgumentParser()
+        sub = parser.add_subparsers()
+        embed.register(sub)
+        with mock.patch.object(sys, "stderr", io.StringIO()), \
+             self.assertRaises(SystemExit):
+            parser.parse_args(
+                ["embed", "--embed-ca-bundle", "/ca.pem", "--embed-insecure"]
+            )
+
 
 if __name__ == "__main__":
     unittest.main()

{venice_cli-0.25.0 → venice_cli-0.26.0}/tests/test_shared_openai.py

@@ -179,6 +179,35 @@ class TestBuildOpenAI(unittest.TestCase):
             stub.built, {"api_key": "not-needed", "base_url": "http://localhost:1234/v1"}
         )
 
+    def test_verify_ca_bundle_builds_httpx_client(self):
+        stub = _StubOpenAI()
+        with mock.patch("httpx.Client") as HttpxClient:
+            HttpxClient.return_value = "httpx-sentinel"
+            _openai.build_openai(
+                stub, base_url="https://embed.local/v1", verify="/ca.pem"
+            )
+        HttpxClient.assert_called_once_with(verify="/ca.pem")
+        self.assertEqual(stub.built["http_client"], "httpx-sentinel")
+        self.assertEqual(stub.built["base_url"], "https://embed.local/v1")
+
+    def test_verify_false_disables_verification(self):
+        stub = _StubOpenAI()
+        with mock.patch("httpx.Client") as HttpxClient:
+            HttpxClient.return_value = "httpx-sentinel"
+            _openai.build_openai(
+                stub, base_url="https://embed.local/v1", verify=False
+            )
+        HttpxClient.assert_called_once_with(verify=False)
+        self.assertEqual(stub.built["http_client"], "httpx-sentinel")
+
+    def test_verify_none_adds_no_http_client(self):
+        stub = _StubOpenAI()
+        # Default path must not touch httpx or pass http_client at all.
+        with mock.patch("httpx.Client") as HttpxClient:
+            _openai.build_openai(stub, base_url="http://localhost:1234/v1")
+        HttpxClient.assert_not_called()
+        self.assertNotIn("http_client", stub.built)
+
 
 class TestStatusToExit(unittest.TestCase):
 

venice_cli-0.25.0/src/venice/__init__.py

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