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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: venice-cli
-Version: 0.26.0
+Version: 0.28.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
@@ -803,6 +803,26 @@ venice index . --embed-base-url http://localhost:1234/v1 --embed-model bge-m3
 venice search "parse the queue response"   # uses the index's own backend/model
 ```
 
+**Self-signed backends.** Both commands accept the same TLS escape hatches as
+`venice embed` — **applied only to a local backend, never the Venice endpoint**:
+
+```sh
+venice index . --embed-base-url https://embed.local/v1 --embed-model bge-m3 \
+    --embed-ca-bundle /etc/ssl/my-ca.pem        # trust a private CA (or $VENICE_EMBED_CA_BUNDLE)
+venice search "parse the queue response" --embed-ca-bundle /etc/ssl/my-ca.pem
+venice index . --embed-base-url https://embed.local/v1 --embed-model bge-m3 \
+    --embed-insecure                            # disable verification (warns; CLI-only)
+```
+
+`--embed-ca-bundle` reads `$VENICE_EMBED_CA_BUNDLE` and is config-backable
+(`defaults.index.embed_ca_bundle` / `defaults.search.embed_ca_bundle`);
+`--embed-insecure` is CLI-only, mutually exclusive with it, and errors (exit 2) if
+the flags don't apply (no `--embed-base-url` for `index`, or a Venice-built index
+for `search`). For `search` the CA bundle is supplied fresh at query time — it is
+never baked into the index — and the `project_search` agent tool also honours
+`$VENICE_EMBED_CA_BUNDLE`, so a `venice chat`/`venice code` session can search an
+index built against a self-signed embedder.
+
 The index is machine-generated: `venice index` drops a self-ignoring
 `.venice/.gitignore`, so it won't be committed even if your repo doesn't already
 ignore `.venice/`. Config-backable per-flag via `defaults.index.*` /
@@ -866,6 +886,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 |
 
 **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
@@ -888,10 +909,17 @@ 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` |
 | `-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
+the project root, and paid calls are capped per call by `$VENICE_MCP_MAX_SPEND` (default
+**$0.10**) — **except** that `--auto` auto-approves every call and so bypasses that cap;
+`--auto --assets` can incur up to `--max-tool-calls` paid generations, so use a cheap
+model and a sane `--max-tool-calls` when running unattended.
+
 Per-flag config defaults live under `defaults.code.*` (e.g. `model`, `root`, `auto`,
-`max_tool_calls`).
+`assets`, `max_tool_calls`).
 
 ## MCP server
 
@@ -1048,7 +1076,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_EMBED_CA_BUNDLE` | CA bundle to trust for a self-signed embedding backend (`embed`, `index`, `search`, and the `project_search` agent tool) |
 | `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) |
 
@@ -1072,7 +1100,7 @@ The player list (`paplay` -> `aplay` -> `ffplay` -> `mpg123` -> `play`
 | `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 [--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 index [PATH] [--model M] [--embed-base-url URL --embed-model M [--embed-ca-bundle PATH \| --embed-insecure]] [...]` / `venice search QUERY [-k N] [--json] [--embed-ca-bundle PATH \| --embed-insecure]` | 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 config add\|list\|remove\|show` | manage the MCP server registry |

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

@@ -765,6 +765,26 @@ venice index . --embed-base-url http://localhost:1234/v1 --embed-model bge-m3
 venice search "parse the queue response"   # uses the index's own backend/model
 ```
 
+**Self-signed backends.** Both commands accept the same TLS escape hatches as
+`venice embed` — **applied only to a local backend, never the Venice endpoint**:
+
+```sh
+venice index . --embed-base-url https://embed.local/v1 --embed-model bge-m3 \
+    --embed-ca-bundle /etc/ssl/my-ca.pem        # trust a private CA (or $VENICE_EMBED_CA_BUNDLE)
+venice search "parse the queue response" --embed-ca-bundle /etc/ssl/my-ca.pem
+venice index . --embed-base-url https://embed.local/v1 --embed-model bge-m3 \
+    --embed-insecure                            # disable verification (warns; CLI-only)
+```
+
+`--embed-ca-bundle` reads `$VENICE_EMBED_CA_BUNDLE` and is config-backable
+(`defaults.index.embed_ca_bundle` / `defaults.search.embed_ca_bundle`);
+`--embed-insecure` is CLI-only, mutually exclusive with it, and errors (exit 2) if
+the flags don't apply (no `--embed-base-url` for `index`, or a Venice-built index
+for `search`). For `search` the CA bundle is supplied fresh at query time — it is
+never baked into the index — and the `project_search` agent tool also honours
+`$VENICE_EMBED_CA_BUNDLE`, so a `venice chat`/`venice code` session can search an
+index built against a self-signed embedder.
+
 The index is machine-generated: `venice index` drops a self-ignoring
 `.venice/.gitignore`, so it won't be committed even if your repo doesn't already
 ignore `.venice/`. Config-backable per-flag via `defaults.index.*` /
@@ -828,6 +848,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 |
 
 **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
@@ -850,10 +871,17 @@ 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` |
 | `-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
+the project root, and paid calls are capped per call by `$VENICE_MCP_MAX_SPEND` (default
+**$0.10**) — **except** that `--auto` auto-approves every call and so bypasses that cap;
+`--auto --assets` can incur up to `--max-tool-calls` paid generations, so use a cheap
+model and a sane `--max-tool-calls` when running unattended.
+
 Per-flag config defaults live under `defaults.code.*` (e.g. `model`, `root`, `auto`,
-`max_tool_calls`).
+`assets`, `max_tool_calls`).
 
 ## MCP server
 
@@ -1010,7 +1038,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_EMBED_CA_BUNDLE` | CA bundle to trust for a self-signed embedding backend (`embed`, `index`, `search`, and the `project_search` agent tool) |
 | `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) |
 
@@ -1034,7 +1062,7 @@ The player list (`paplay` -> `aplay` -> `ffplay` -> `mpg123` -> `play`
 | `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 [--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 index [PATH] [--model M] [--embed-base-url URL --embed-model M [--embed-ca-bundle PATH \| --embed-insecure]] [...]` / `venice search QUERY [-k N] [--json] [--embed-ca-bundle PATH \| --embed-insecure]` | 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 config add\|list\|remove\|show` | manage the MCP server registry |

venice_cli-0.28.0/src/venice/__init__.py

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

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

@@ -180,6 +180,28 @@ _SEARCH_SCHEMA = _obj(
     required=["query"],
 )
 
+# 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).
+_IMAGE_EDIT_SCHEMA = _obj(
+    {
+        "prompt": _p("string", "Text directions for the edit, e.g. 'change the sky to a sunrise'."),
+        "input_path": _p("string", "Path to a local base image to edit."),
+        "image_url": _p("string", "URL of a base image (instead of input_path)."),
+        "layer_paths": {
+            "type": "array",
+            "items": {"type": "string"},
+            "description": "One or two local mask/overlay images (routes to /image/multi-edit).",
+        },
+        "model": _p("string", "Edit model id (default: the server picks one)."),
+        "aspect_ratio": _p("string", "Output aspect ratio ('auto' infers from the input)."),
+        "resolution": _p("string", "Output resolution tier, e.g. 1K/2K/4K."),
+        "output_format": _p("string", "Output image format: png, jpeg, or webp."),
+        "no_safe_mode": _p("boolean", "Disable safe mode (defaults to on)."),
+    },
+    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>`.
@@ -256,6 +278,22 @@ _BUILTINS = [
     ),
 ]
 
+# Extra paid tools NOT advertised by chat's default set. Folded in only when a
+# caller passes `only=` (e.g. `venice code --assets`), so chat's default stays 8
+# while `code_tools` can still select them by name.
+_CODE_ASSET_BUILTINS = [
+    (
+        "venice_image_edit",
+        "image_edit_tool",
+        "Edit/inpaint an existing image via Venice /image/edit from a text prompt "
+        "(base = a local input_path or an image_url; optional layer_paths route to "
+        "/image/multi-edit for masks). Writes the result and returns its path. "
+        "Dynamic pricing, so it always needs confirmation.",
+        _IMAGE_EDIT_SCHEMA,
+        True,
+    ),
+]
+
 # Loop-controlled kwargs the model must never supply (stripped defensively).
 _CONTROLLED = ("confirm", "max_spend", "output_dir")
 
@@ -273,11 +311,13 @@ def builtin_tools(
     output_dir: Optional[str] = None,
     only: Optional[set] = None,
 ) -> List[Tool]:
-    """Build the 7 in-process venice tools, bound to `client`.
+    """Build the in-process venice tools, bound to `client`.
 
     `max_spend`/`output_dir` are baked into the paid tools' closures; `confirm` is
     passed per-call by the loop. `only` restricts the set to the named tools (an
-    unknown name raises ValueError so the caller can exit 2).
+    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.
     """
 
     def _make_paid(impl):
@@ -298,6 +338,7 @@ def builtin_tools(
 
         return invoke
 
+    source = _BUILTINS if only is None else _BUILTINS + _CODE_ASSET_BUILTINS
     tools = [
         Tool(
             name=name,
@@ -310,7 +351,7 @@ def builtin_tools(
             ),
             paid=paid,
         )
-        for (name, impl_name, desc, schema, paid) in _BUILTINS
+        for (name, impl_name, desc, schema, paid) in source
     ]
 
     if only is not None:

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

@@ -447,6 +447,8 @@ def code_tools(
     *,
     exec_timeout: int = DEFAULT_EXEC_TIMEOUT,
     include_search: bool = False,
+    assets: bool = False,
+    max_spend=None,
 ) -> List[_agent.Tool]:
     """Build the coding tools bound to a realpath-resolved project `root`.
 
@@ -454,6 +456,13 @@ def code_tools(
     (`write_file`/`edit_file`/`run`) are ``paid=True`` and route through the confirm
     gate. `project_search` (reusing the free `_mcp.search_tool`) is added only when
     `include_search` and a `client` are supplied and a `.venice` index exists.
+
+    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`,
+    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`.
     """
     root = os.path.realpath(root)
 
@@ -517,6 +526,16 @@ def code_tools(
             "Read-only.",
             _SEARCH_SCHEMA, search_invoke, paid=False,
         ))
+
+    if assets and client is not None:
+        asset_dir = os.environ.get("VENICE_MCP_OUTPUT_DIR") or root
+        tools.extend(_agent.builtin_tools(
+            client, max_spend=max_spend, output_dir=asset_dir,
+            only={
+                "venice_image", "venice_image_edit", "venice_sfx",
+                "venice_music", "venice_tts", "venice_upscale", "venice_bg_remove",
+            },
+        ))
     return tools
 
 

{venice_cli-0.26.0 → venice_cli-0.28.0}/src/venice/commands/_index.py

@@ -407,24 +407,47 @@ def _sha256(data: bytes) -> str:
 # --------------------------------------------------------------------------- #
 # Embedding backend resolution + batched embedding
 # --------------------------------------------------------------------------- #
-def _resolve_backend(openai, *, embed_base_url, embed_model, model):
+def _resolve_backend(openai, *, embed_base_url, embed_model, model,
+                     ca_bundle=None, insecure=False):
     """Return (oai_client, model, backend_meta, exit_code). exit_code None on success.
 
     Mirrors ``embed._resolve_backend`` but stdout-free and primitive-arg. Local
     backend (--embed-base-url) skips Venice auth+catalog; Venice path validates
-    --model against the free /models catalog.
+    --model against the free /models catalog. TLS overrides (`ca_bundle`/`insecure`,
+    #42) apply to the local backend only -- the Venice endpoint's TLS is not
+    overridable, so the flags are rejected there.
     """
     if embed_base_url:
         if not embed_model:
             print("index: --embed-model is required with --embed-base-url", file=sys.stderr)
             return None, 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 insecure else (ca_bundle or None)
+        if verify is False:
+            print(
+                "index: WARNING: TLS verification disabled (--embed-insecure) "
+                f"for {embed_base_url}",
+                file=sys.stderr,
+            )
         oai = _openai.build_openai(
             openai, base_url=embed_base_url,
             api_key=os.environ.get(config.ENV_EMBED_API_KEY),
+            verify=verify,
         )
         meta = {"backend": "local", "model": embed_model, "base_url": embed_base_url}
         return oai, embed_model, meta, None
 
+    # The Venice endpoint's TLS is not overridable -- reject the flags here so they
+    # can't silently no-op against Venice.
+    if insecure or ca_bundle:
+        print(
+            "index: --embed-insecure/--embed-ca-bundle only apply with "
+            "--embed-base-url",
+            file=sys.stderr,
+        )
+        return None, None, None, 2
+
     try:
         client = build_client_from_auth()
     except auth.AuthError as e:
@@ -437,19 +460,47 @@ def _resolve_backend(openai, *, embed_base_url, embed_model, model):
     return _openai.build_openai(openai, client), resolved, {"backend": "venice", "model": resolved}, None
 
 
-def _backend_from_meta(openai, meta: dict):
+def _backend_from_meta(openai, meta: dict, *, ca_bundle=None, insecure=False):
     """Rebuild the SDK client for `venice search` from stored index meta.
 
     The query MUST be embedded with the same backend/model/dims as the index, so
     everything comes from meta -- never re-resolved against a (possibly changed)
     catalog. The local-backend key is re-supplied from $VENICE_EMBED_API_KEY.
+
+    TLS overrides (#42) apply to a local-backend index only and are supplied fresh
+    at query time -- a CA path is machine-local, so it is never baked into the
+    store. `ca_bundle` falls back to $VENICE_EMBED_CA_BUNDLE so the no-CLI
+    `project_search` agent tool also reaches a self-signed embedder; `insecure` has
+    no env knob (CLI-only). On a Venice-built index the flags don't apply and are
+    rejected (exit 2) -- but the env fallback is consulted on the local path only,
+    so a globally-set $VENICE_EMBED_CA_BUNDLE never breaks searching a Venice index.
     """
     if meta.get("backend") == "local":
+        if ca_bundle is None:
+            ca_bundle = os.environ.get(config.ENV_EMBED_CA_BUNDLE)
+        verify = False if insecure else (ca_bundle or None)
+        if verify is False:
+            print(
+                "search: WARNING: TLS verification disabled (--embed-insecure) "
+                f"for {meta.get('base_url')}",
+                file=sys.stderr,
+            )
         oai = _openai.build_openai(
             openai, base_url=meta.get("base_url"),
             api_key=os.environ.get(config.ENV_EMBED_API_KEY),
+            verify=verify,
         )
         return oai, meta.get("model"), None
+
+    # Venice-built index: TLS is not overridable. Reject explicitly-passed flags
+    # loudly (parity with embed/index).
+    if insecure or ca_bundle:
+        print(
+            "search: --embed-insecure/--embed-ca-bundle only apply to a "
+            "local-backend index",
+            file=sys.stderr,
+        )
+        return None, None, 2
     try:
         client = build_client_from_auth()
     except auth.AuthError as e:
@@ -504,6 +555,7 @@ def _meta_conflict(old_meta: dict, backend_meta: dict, dimensions: Optional[int]
 def build_index(root, *, model=None, embed_base_url=None, embed_model=None,
                 dimensions=None, rebuild=False, excludes=None, batch=DEFAULT_BATCH,
                 chunk_lines=DEFAULT_CHUNK_LINES, chunk_overlap=DEFAULT_CHUNK_OVERLAP,
+                ca_bundle=None, insecure=False,
                 on_progress: Optional[Callable[[str], None]] = None) -> dict:
     """Build/update the index under `root`. Returns a summary dict on success;
     raises IndexingError(exit_code) on failure. stdout-free (progress -> on_progress
@@ -520,7 +572,8 @@ def build_index(root, *, model=None, embed_base_url=None, embed_model=None,
         raise IndexingError("", 2)
 
     oai, resolved_model, backend_meta, rc = _resolve_backend(
-        openai, embed_base_url=embed_base_url, embed_model=embed_model, model=model)
+        openai, embed_base_url=embed_base_url, embed_model=embed_model, model=model,
+        ca_bundle=ca_bundle, insecure=insecure)
     if rc is not None:
         raise IndexingError("", rc)
 
@@ -687,7 +740,7 @@ def _preview(root: Path, rel: str, start: int, end: int, stored_sha: Optional[st
 
 
 def search_index(store_dir, query: str, *, k: int = DEFAULT_TOP_K,
-                 with_preview: bool = True) -> List[dict]:
+                 with_preview: bool = True, ca_bundle=None, insecure=False) -> List[dict]:
     """Embed `query` with the index's own backend/model and return the top-`k`
     chunks as dicts ``{path, start, end, score[, preview, changed]}``. stdout-free;
     raises IndexingError(exit_code) on failure."""
@@ -702,7 +755,7 @@ def search_index(store_dir, query: str, *, k: int = DEFAULT_TOP_K,
     openai = _openai.import_openai("search")
     if openai is None:
         raise IndexingError("", 2)
-    oai, model, rc = _backend_from_meta(openai, meta)
+    oai, model, rc = _backend_from_meta(openai, meta, ca_bundle=ca_bundle, insecure=insecure)
     if rc is not None:
         raise IndexingError("", rc)
 

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

@@ -168,6 +168,12 @@ def register(subparsers) -> None:
         metavar="SECS",
         help=f"Timeout for run/git commands (default: {_code.DEFAULT_EXEC_TIMEOUT}).",
     )
+    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.",
+    )
 
     it = p.add_argument_group("Interactive")
     it.add_argument(
@@ -350,6 +356,7 @@ def _run(args) -> int:
         root, client,
         exec_timeout=args.exec_timeout or _code.DEFAULT_EXEC_TIMEOUT,
         include_search=True,
+        assets=bool(args.assets),
     )
     system = _system_prompt(args, root, tools)
     gen_kwargs = _gen_kwargs(args)

{venice_cli-0.26.0 → venice_cli-0.28.0}/src/venice/commands/index.py

@@ -44,6 +44,17 @@ def register(subparsers) -> None:
         "--embed-model", dest="embed_model", default=None, metavar="NAME",
         help="Model id for --embed-base-url (required with it).",
     )
+    tls = p.add_mutually_exclusive_group()
+    tls.add_argument(
+        "--embed-ca-bundle", dest="embed_ca_bundle", default=None, metavar="PATH",
+        help="CA bundle (PEM) to verify a self-signed --embed-base-url; also "
+             "$VENICE_EMBED_CA_BUNDLE. Alternate backend only.",
+    )
+    tls.add_argument(
+        "--embed-insecure", dest="embed_insecure", action="store_true",
+        help="Disable TLS verification for --embed-base-url (alternate backend "
+             "only). Insecure -- prefer --embed-ca-bundle.",
+    )
     p.add_argument(
         "--dimensions", type=int, default=None,
         help="Truncate embedding vectors to this many dimensions (if supported).",
@@ -77,6 +88,8 @@ def _run(args) -> int:
     # (which only fills a dest still None), same as `venice embed`.
     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, "index")
 
     def _progress(msg: str) -> None:
@@ -95,6 +108,8 @@ def _run(args) -> int:
             chunk_lines=args.chunk_lines or _index.DEFAULT_CHUNK_LINES,
             chunk_overlap=(args.chunk_overlap if args.chunk_overlap is not None
                            else _index.DEFAULT_CHUNK_OVERLAP),
+            ca_bundle=args.embed_ca_bundle,
+            insecure=args.embed_insecure,
             on_progress=_progress,
         )
     except _index.IndexingError as e:

{venice_cli-0.26.0 → venice_cli-0.28.0}/src/venice/commands/search.py

@@ -8,9 +8,10 @@ lives in the print-free ``commands._index``; this wraps it for the CLI.
 from __future__ import annotations
 
 import json
+import os
 import sys
 
-from .. import userconfig
+from .. import config, userconfig
 from . import _index
 
 
@@ -36,6 +37,17 @@ def register(subparsers) -> None:
         "-k", "--top-k", dest="top_k", type=int, default=None,
         help=f"Number of results to return (default: {_index.DEFAULT_TOP_K}).",
     )
+    tls = p.add_mutually_exclusive_group()
+    tls.add_argument(
+        "--embed-ca-bundle", dest="embed_ca_bundle", default=None, metavar="PATH",
+        help="CA bundle (PEM) to verify a self-signed embedding backend when the "
+             "index was built with --embed-base-url; also $VENICE_EMBED_CA_BUNDLE.",
+    )
+    tls.add_argument(
+        "--embed-insecure", dest="embed_insecure", action="store_true",
+        help="Disable TLS verification for a local-backend index's embedding "
+             "endpoint. Insecure -- prefer --embed-ca-bundle.",
+    )
     p.add_argument(
         "--json", action="store_true",
         help="Print results as a JSON object instead of text.",
@@ -44,6 +56,11 @@ def register(subparsers) -> None:
 
 
 def _run(args) -> int:
+    # Backend TLS flags follow CLI > env > config, same as `venice embed`/`index`;
+    # insecure is CLI-only (no env). The gate against a Venice-built index lives in
+    # the engine (a CA path is machine-local -- never stored in the index meta).
+    if args.embed_ca_bundle is None:
+        args.embed_ca_bundle = os.environ.get(config.ENV_EMBED_CA_BUNDLE)
     userconfig.apply_defaults(args, "search")
 
     store_dir = _index.discover_store(args.index_path)
@@ -55,7 +72,8 @@ def _run(args) -> int:
 
     try:
         results = _index.search_index(
-            store_dir, args.query, k=args.top_k or _index.DEFAULT_TOP_K)
+            store_dir, args.query, k=args.top_k or _index.DEFAULT_TOP_K,
+            ca_bundle=args.embed_ca_bundle, insecure=args.embed_insecure)
     except _index.IndexingError as e:
         if str(e):
             print(f"search: {e}", file=sys.stderr)

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

@@ -224,18 +224,21 @@ _COMMAND_MAP = {
         "dimensions": ("dimensions", int),
         "embed_base_url": ("embed_base_url", str),
         "embed_model": ("embed_model", str),
+        "embed_ca_bundle": ("embed_ca_bundle", str),
         "batch": ("batch", int),
         "chunk_lines": ("chunk_lines", int),
         "chunk_overlap": ("chunk_overlap", int),
     },
     "search": {
         "top_k": ("top_k", int),
+        "embed_ca_bundle": ("embed_ca_bundle", str),
     },
     "code": {
         "model": ("model", str),
         "system": ("system", str),
         "root": ("root", str),
         "auto": ("auto", _as_bool),
+        "assets": ("assets", _as_bool),
         "max_tool_calls": ("max_tool_calls", int),
         "exec_timeout": ("exec_timeout", int),
     },

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

@@ -731,5 +731,35 @@ class TestChatMcp(unittest.TestCase):
         self.assertEqual(attach.specs, [("fs", {"command": "srv"})])
 
 
+class TestBuiltinToolsRegistry(unittest.TestCase):
+    """`_agent.builtin_tools` source-selection (backs `venice code --assets`, #45)."""
+
+    def test_only_none_stays_eight(self):
+        # 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.assertNotIn("venice_image_edit", names)
+
+    def test_only_can_select_code_asset_extra(self):
+        from venice.commands import _agent
+        tools = _agent.builtin_tools(object(), only={"venice_image_edit"})
+        self.assertEqual([t.name for t in tools], ["venice_image_edit"])
+        self.assertTrue(tools[0].paid)
+
+    def test_only_mixes_builtins_and_extras(self):
+        from venice.commands import _agent
+        names = {t.name for t in _agent.builtin_tools(
+            object(), only={"venice_image", "venice_image_edit"})}
+        self.assertEqual(names, {"venice_image", "venice_image_edit"})
+
+    def test_image_edit_schema_excludes_controlled(self):
+        from venice.commands import _agent
+        props = _agent._IMAGE_EDIT_SCHEMA["properties"]
+        for banned in ("confirm", "max_spend", "output_dir"):
+            self.assertNotIn(banned, props)
+        self.assertEqual(_agent._IMAGE_EDIT_SCHEMA.get("required"), ["prompt"])
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -16,6 +16,12 @@ def _tools(root, **kw):
     return {t.name: t for t in _code.code_tools(root, **kw)}
 
 
+_ASSET_NAMES = {
+    "venice_image", "venice_image_edit", "venice_sfx", "venice_music",
+    "venice_tts", "venice_upscale", "venice_bg_remove",
+}
+
+
 class TestCodeTools(unittest.TestCase):
     def setUp(self):
         self.tmp = tempfile.mkdtemp()
@@ -224,6 +230,34 @@ class TestCodeFactory(unittest.TestCase):
                                                   include_search=True)}
         self.assertNotIn("project_search", names)  # no .venice index discoverable
 
+    def test_assets_absent_by_default(self):
+        names = {t.name for t in _code.code_tools("/tmp", client=object())}
+        self.assertEqual(names & _ASSET_NAMES, set())
+
+    def test_assets_need_a_client(self):
+        # the flag alone (no client) folds nothing in
+        names = {t.name for t in _code.code_tools("/tmp", assets=True)}
+        self.assertEqual(names & _ASSET_NAMES, set())
+
+    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.assertNotIn("venice_chat", names)   # excluded by design
+        self.assertNotIn("venice_video", names)  # deferred
+
+    def test_asset_tools_are_paid(self):
+        by = {t.name: t for t in _code.code_tools("/tmp", client=object(),
+                                                  assets=True)}
+        for n in _ASSET_NAMES:
+            self.assertTrue(by[n].paid, f"{n} should be paid")
+
+    def test_asset_schemas_exclude_control_kwargs(self):
+        for t in _code.code_tools("/tmp", client=object(), assets=True):
+            props = t.parameters.get("properties", {})
+            for banned in ("confirm", "max_spend", "output_dir"):
+                self.assertNotIn(banned, props, f"{t.name} leaks {banned}")
+
     def test_controlled_kwargs_stripped_from_model_args(self):
         # a model that smuggles confirm=True must not self-approve a paid tool
         with tempfile.TemporaryDirectory() as d:

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

@@ -23,7 +23,7 @@ def _code_args(**ov):
         task=None, root=None, model=None, system=None, temperature=None,
         max_tokens=None, json=False, auto=None, manual=None, yes=None,
         plan_only=False, no_plan=False, no_verify=False, max_tool_calls=None,
-        exec_timeout=None, interactive=False, resume=None,
+        exec_timeout=None, interactive=False, resume=None, assets=None,
     )
     base.update(ov)
     return argparse.Namespace(**base)
@@ -92,6 +92,60 @@ class TestCodeCommand(unittest.TestCase):
         with open(os.path.join(self.root, "hello.py")) as f:
             self.assertEqual(f.read(), "def hi():\n    return 1\n")
 
+    # --- --assets exposes the in-process asset tools ---
+    def _exec_tool_names(self, calls):
+        # the execute turn is the one advertising tools with tool_choice="auto"
+        execs = [c for c in calls if c.get("tool_choice") == "auto"]
+        self.assertTrue(execs, "no execute turn recorded")
+        return {t["function"]["name"] for t in execs[0]["tools"]}
+
+    def test_assets_flag_exposes_asset_tools(self):
+        seq = [
+            FakeToolCompletion("plan"),
+            FakeToolCompletion("nothing to do"),           # execute (auto), no calls
+            FakeToolCompletion("ACCEPTANCE: PASS"),
+        ]
+        rc, calls = self._run(
+            _code_args(task="draw", root=self.root, auto=True, assets=True), seq)
+        self.assertEqual(rc, 0)
+        names = self._exec_tool_names(calls)
+        self.assertIn("venice_image", names)
+        self.assertIn("venice_image_edit", names)
+        self.assertNotIn("venice_chat", names)   # excluded by design
+
+    def test_assets_absent_by_default(self):
+        seq = [
+            FakeToolCompletion("plan"),
+            FakeToolCompletion("nothing to do"),
+            FakeToolCompletion("ACCEPTANCE: PASS"),
+        ]
+        rc, calls = self._run(
+            _code_args(task="x", root=self.root, auto=True), seq)
+        self.assertEqual(rc, 0)
+        self.assertNotIn("venice_image", self._exec_tool_names(calls))
+
+    def test_assets_tool_dispatches_with_confirm_under_auto(self):
+        seq = [
+            FakeToolCompletion("plan"),
+            FakeToolCompletion(tool_calls=[
+                _FnCall("c1", "venice_image",
+                        json.dumps({"prompt": "a hero sprite"}))]),
+            FakeToolCompletion("made the sprite"),
+            FakeToolCompletion("ACCEPTANCE: PASS"),
+        ]
+        with mock.patch(
+            "venice.commands._mcp.image_tool",
+            return_value={"status": "ok", "paths": ["/x.png"], "count": 1},
+        ) as stub:
+            rc, calls = self._run(
+                _code_args(task="draw", 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"))
+        # 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_acceptance_fail_returns_1(self):
         seq = [
             FakeToolCompletion("plan"),

{venice_cli-0.26.0 → venice_cli-0.28.0}/tests/test_index.py

@@ -68,7 +68,8 @@ def write(root, rel, content, *, binary=False):
 
 def _no_key_env():
     return {k: v for k, v in os.environ.items()
-            if k not in ("VENICE_API_KEY", "VENICE_EMBED_BASE_URL", "VENICE_EMBED_API_KEY")}
+            if k not in ("VENICE_API_KEY", "VENICE_EMBED_BASE_URL",
+                         "VENICE_EMBED_API_KEY", "VENICE_EMBED_CA_BUNDLE")}
 
 
 class _EngineBase(unittest.TestCase):
@@ -323,7 +324,8 @@ class TestMissingOpenai(_EngineBase):
 class TestIndexCLI(unittest.TestCase):
     def _args(self, root, **ov):
         base = dict(path=root, model=None, embed_base_url="http://local/v1",
-                    embed_model="m", dimensions=None, rebuild=False, exclude=None,
+                    embed_model="m", embed_ca_bundle=None, embed_insecure=False,
+                    dimensions=None, rebuild=False, exclude=None,
                     batch=None, chunk_lines=None, chunk_overlap=None)
         base.update(ov)
         return argparse.Namespace(**base)
@@ -345,6 +347,111 @@ class TestIndexCLI(unittest.TestCase):
         self.assertEqual(out.getvalue().strip(),
                          str(_index.store_file(_index.store_dir_for_root(tmp.name))))
 
+    # --- #42: TLS override reaches the SDK through CLI env/config layering ---
+
+    def _run_tls(self, *, env=None, doc=None, **arg_ov):
+        """Drive index._run against the local backend with httpx.Client patched to
+        a sentinel; returns (rc, Hx_mock) so a test can assert the verify value."""
+        from venice.commands import index
+        tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(tmp.cleanup)
+        write(tmp.name, "a.py", "alpha\n")
+        base_env = _no_key_env()
+        if env:
+            base_env.update(env)
+        fake, _ = fake_openai()
+        with mock.patch("httpx.Client", return_value="httpx-sentinel") as Hx, \
+             mock.patch("openai.OpenAI", return_value=fake), \
+             mock.patch("venice.userconfig.load_config",
+                        return_value=doc or _clean_doc()), \
+             mock.patch.dict(os.environ, base_env, clear=True), \
+             mock.patch.object(sys, "stdout", io.StringIO()), \
+             mock.patch.object(sys, "stderr", io.StringIO()):
+            rc = index._run(self._args(tmp.name, **arg_ov))
+        return rc, Hx
+
+    def test_ca_bundle_from_flag(self):
+        rc, Hx = self._run_tls(embed_ca_bundle="/flag-ca.pem")
+        self.assertEqual(rc, 0)
+        Hx.assert_called_once_with(verify="/flag-ca.pem")
+
+    def test_ca_bundle_from_env(self):
+        rc, Hx = self._run_tls(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(self):
+        doc = {"version": 1, "mcpServers": {}, "defaults": {
+            "index": {"embed_ca_bundle": "/cfg-ca.pem"}}}
+        rc, Hx = self._run_tls(doc=doc)
+        self.assertEqual(rc, 0)
+        Hx.assert_called_once_with(verify="/cfg-ca.pem")
+
+    def test_flag_beats_env(self):
+        rc, Hx = self._run_tls(embed_ca_bundle="/flag-ca.pem",
+                               env={"VENICE_EMBED_CA_BUNDLE": "/env-ca.pem"})
+        self.assertEqual(rc, 0)
+        Hx.assert_called_once_with(verify="/flag-ca.pem")
+
+
+class TestIndexTLS(_EngineBase):
+    """#42: TLS escape hatch on the local embedding backend (engine level)."""
+
+    def _build(self, *, stderr=None, **ov):
+        """build_index on self.root via the local backend, httpx.Client patched to
+        a sentinel. Returns (Hx_mock, OAI_mock); propagates IndexingError."""
+        write(self.root, "a.txt", "alpha\n")
+        fake, _ = fake_openai()
+        kw = dict(embed_base_url="http://local/v1", embed_model="m")
+        kw.update(ov)
+        with mock.patch("httpx.Client", return_value="httpx-sentinel") as Hx, \
+             mock.patch("openai.OpenAI", return_value=fake) as OAI, \
+             mock.patch.dict(os.environ, _no_key_env(), clear=True), \
+             mock.patch.object(sys, "stderr", stderr or io.StringIO()):
+            _index.build_index(self.root, **kw)
+        return Hx, OAI
+
+    def test_ca_bundle_reaches_sdk_on_alt_path(self):
+        Hx, OAI = self._build(ca_bundle="/ca.pem")
+        Hx.assert_called_once_with(verify="/ca.pem")
+        self.assertEqual(OAI.call_args.kwargs["http_client"], "httpx-sentinel")
+
+    def test_insecure_disables_verification_and_warns(self):
+        err = io.StringIO()
+        Hx, OAI = self._build(insecure=True, stderr=err)
+        Hx.assert_called_once_with(verify=False)
+        self.assertEqual(OAI.call_args.kwargs["http_client"], "httpx-sentinel")
+        self.assertIn("TLS verification disabled", err.getvalue())
+
+    def test_no_override_builds_no_http_client(self):
+        Hx, OAI = self._build()
+        Hx.assert_not_called()
+        self.assertNotIn("http_client", OAI.call_args.kwargs)
+
+    def test_insecure_without_base_url_is_rejected(self):
+        err = io.StringIO()
+        with self.assertRaises(_index.IndexingError) as cm:
+            self._build(embed_base_url=None, insecure=True, stderr=err)
+        self.assertEqual(cm.exception.exit_code, 2)
+        self.assertIn("only apply with --embed-base-url", err.getvalue())
+
+    def test_ca_bundle_without_base_url_is_rejected(self):
+        err = io.StringIO()
+        with self.assertRaises(_index.IndexingError) as cm:
+            self._build(embed_base_url=None, ca_bundle="/ca.pem", stderr=err)
+        self.assertEqual(cm.exception.exit_code, 2)
+        self.assertIn("only apply with --embed-base-url", err.getvalue())
+
+    def test_ca_bundle_and_insecure_are_mutually_exclusive(self):
+        from venice.commands import index
+        parser = argparse.ArgumentParser()
+        sub = parser.add_subparsers()
+        index.register(sub)
+        with mock.patch.object(sys, "stderr", io.StringIO()), \
+             self.assertRaises(SystemExit):
+            parser.parse_args(
+                ["index", "--embed-ca-bundle", "/ca.pem", "--embed-insecure"])
+
 
 if __name__ == "__main__":
     unittest.main()

{venice_cli-0.26.0 → venice_cli-0.28.0}/tests/test_search.py

@@ -108,7 +108,8 @@ class TestDiscovery(_Base):
 
 class TestSearchCLI(_Base):
     def _args(self, **ov):
-        base = dict(query="alpha", index_path=self.root, top_k=None, json=False)
+        base = dict(query="alpha", index_path=self.root, top_k=None, json=False,
+                    embed_ca_bundle=None, embed_insecure=False)
         base.update(ov)
         return argparse.Namespace(**base)
 
@@ -178,5 +179,103 @@ class TestSearchTool(_Base):
         self.assertEqual(res["status"], "error")
 
 
+class TestSearchTLS(_Base):
+    """#42: TLS override supplied at query time reaches the SDK even though the
+    backend base_url comes from stored index meta (a local-backed index)."""
+
+    def _search_tls(self, *, env=None, stderr=None, **ov):
+        """search_index against the local-backed store with httpx.Client patched
+        to a sentinel; returns (Hx_mock, OAI_mock)."""
+        fake, _ = fake_openai()
+        base_env = _no_key_env()
+        if env:
+            base_env.update(env)
+        with mock.patch("httpx.Client", return_value="httpx-sentinel") as Hx, \
+             mock.patch("openai.OpenAI", return_value=fake) as OAI, \
+             mock.patch.dict(os.environ, base_env, clear=True), \
+             mock.patch.object(sys, "stderr", stderr or io.StringIO()):
+            _index.search_index(self.store, "alpha", **ov)
+        return Hx, OAI
+
+    def test_ca_bundle_reaches_sdk_at_query_time(self):
+        Hx, OAI = self._search_tls(ca_bundle="/ca.pem")
+        Hx.assert_called_once_with(verify="/ca.pem")
+        self.assertEqual(OAI.call_args.kwargs["http_client"], "httpx-sentinel")
+
+    def test_insecure_disables_verification_and_warns(self):
+        err = io.StringIO()
+        Hx, _ = self._search_tls(insecure=True, stderr=err)
+        Hx.assert_called_once_with(verify=False)
+        self.assertIn("TLS verification disabled", err.getvalue())
+
+    def test_no_override_builds_no_http_client(self):
+        Hx, OAI = self._search_tls()
+        Hx.assert_not_called()
+        self.assertNotIn("http_client", OAI.call_args.kwargs)
+
+    def test_env_ca_bundle_picked_up_when_no_arg(self):
+        # The no-CLI project_search path: search_index falls back to the env var so
+        # the agent tool also reaches a self-signed embedder.
+        Hx, _ = self._search_tls(env={"VENICE_EMBED_CA_BUNDLE": "/env-ca.pem"})
+        Hx.assert_called_once_with(verify="/env-ca.pem")
+
+    def test_explicit_ca_bundle_beats_env(self):
+        Hx, _ = self._search_tls(ca_bundle="/arg-ca.pem",
+                                 env={"VENICE_EMBED_CA_BUNDLE": "/env-ca.pem"})
+        Hx.assert_called_once_with(verify="/arg-ca.pem")
+
+    def test_project_search_tool_uses_env_ca_bundle(self):
+        # End-to-end for the agent path: _mcp.search_tool -> search_index picks up
+        # the env CA bundle. Discovery is cwd-based, so chdir into the indexed root.
+        cwd = os.getcwd()
+        self.addCleanup(os.chdir, cwd)
+        os.chdir(self.root)
+        fake, _ = fake_openai()
+        with mock.patch("httpx.Client", return_value="httpx-sentinel") as Hx, \
+             mock.patch("openai.OpenAI", return_value=fake), \
+             mock.patch.dict(os.environ, {**_no_key_env(),
+                                          "VENICE_EMBED_CA_BUNDLE": "/env-ca.pem"},
+                             clear=True), \
+             mock.patch.object(sys, "stderr", io.StringIO()):
+            from venice.commands import _mcp
+            res = _mcp.search_tool(object(), "alpha", k=1)
+        self.assertEqual(res["status"], "ok")
+        Hx.assert_called_once_with(verify="/env-ca.pem")
+
+
+class TestBackendFromMetaGate(unittest.TestCase):
+    """#42: on a Venice-built index the TLS flags don't apply. Explicit flags are
+    rejected (exit 2); a globally-set env CA bundle is ignored, never tripping the
+    gate -- so project_search over a Venice index keeps working."""
+
+    def test_explicit_flags_rejected_on_venice_index(self):
+        import openai
+        err = io.StringIO()
+        with mock.patch.object(sys, "stderr", err):
+            oai, model, rc = _index._backend_from_meta(
+                openai, {"backend": "venice", "model": "m"}, ca_bundle="/ca.pem")
+        self.assertEqual(rc, 2)
+        self.assertIsNone(oai)
+        self.assertIn("only apply to a local-backend index", err.getvalue())
+
+    def test_env_ca_bundle_does_not_trip_venice_gate(self):
+        import openai
+        from venice import auth
+        err = io.StringIO()
+        # env set + no explicit flag: the venice path never consults env, so the
+        # TLS gate is NOT tripped -- we fall through to auth (stubbed to fail).
+        with mock.patch.dict(os.environ, {**_no_key_env(),
+                                          "VENICE_EMBED_CA_BUNDLE": "/env-ca.pem"},
+                             clear=True), \
+             mock.patch("venice.commands._index.build_client_from_auth",
+                        side_effect=auth.AuthError("no key")), \
+             mock.patch.object(sys, "stderr", err):
+            oai, model, rc = _index._backend_from_meta(
+                openai, {"backend": "venice", "model": "m"})
+        self.assertEqual(rc, 2)
+        self.assertNotIn("only apply to a local-backend index", err.getvalue())
+        self.assertIn("no key", err.getvalue())
+
+
 if __name__ == "__main__":
     unittest.main()

venice_cli-0.26.0/src/venice/__init__.py

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