aria-code 0.101.0__tar.gz → 0.103.0__tar.gz

{aria_code-0.101.0/src/aria_code.egg-info → aria_code-0.103.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.101.0
+Version: 0.103.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code
@@ -263,7 +263,7 @@ aria-code -p "Fix the failing tests and run them" --format jsonl --allow-tools e
 | --- | --- |
 | Local Ollama | An installed and running Ollama model; no cloud account for local inference. |
 | Direct cloud provider | That provider's API credentials and network access. |
-| Direct Google Cloud Vertex AI | `GOOGLE_CLOUD_PROJECT` and either a `gcloud auth login` (Aria uses Vertex AI's OpenAI-compatible endpoint with that login's token) or Application Default Credentials with `aria-code[google]`. `GOOGLE_CLOUD_LOCATION` defaults to `global`. |
+| Direct Google Cloud Vertex AI | `GOOGLE_CLOUD_PROJECT` and either a `gcloud auth login` (Aria uses Vertex AI's OpenAI-compatible endpoint with that login's token) or Application Default Credentials with `aria-code[google]`. `GOOGLE_CLOUD_LOCATION` defaults to `global`. Any model your project can use works without an API key: `/model google/gemini-3.5-flash`, the Gemini 3 previews (served only from `global`), or Gemma and other Model Garden managed models by their id (`/model google/<id>`), which go through Vertex's OpenAI-compatible endpoint. |
 | Arthera hosted service | Install `aria-code[google]` and sign in through `/login` in the CLI. Arthera account sign-in does not grant Vertex AI credentials to your own machine. |
 
 Install extras only for features you use; see [pyproject.toml](pyproject.toml) for the current package options. Local inference can work offline, but live market data, remote integrations, sign-in, and cloud models cannot.

{aria_code-0.101.0 → aria_code-0.103.0}/README.md

@@ -107,7 +107,7 @@ aria-code -p "Fix the failing tests and run them" --format jsonl --allow-tools e
 | --- | --- |
 | Local Ollama | An installed and running Ollama model; no cloud account for local inference. |
 | Direct cloud provider | That provider's API credentials and network access. |
-| Direct Google Cloud Vertex AI | `GOOGLE_CLOUD_PROJECT` and either a `gcloud auth login` (Aria uses Vertex AI's OpenAI-compatible endpoint with that login's token) or Application Default Credentials with `aria-code[google]`. `GOOGLE_CLOUD_LOCATION` defaults to `global`. |
+| Direct Google Cloud Vertex AI | `GOOGLE_CLOUD_PROJECT` and either a `gcloud auth login` (Aria uses Vertex AI's OpenAI-compatible endpoint with that login's token) or Application Default Credentials with `aria-code[google]`. `GOOGLE_CLOUD_LOCATION` defaults to `global`. Any model your project can use works without an API key: `/model google/gemini-3.5-flash`, the Gemini 3 previews (served only from `global`), or Gemma and other Model Garden managed models by their id (`/model google/<id>`), which go through Vertex's OpenAI-compatible endpoint. |
 | Arthera hosted service | Install `aria-code[google]` and sign in through `/login` in the CLI. Arthera account sign-in does not grant Vertex AI credentials to your own machine. |
 
 Install extras only for features you use; see [pyproject.toml](pyproject.toml) for the current package options. Local inference can work offline, but live market data, remote integrations, sign-in, and cloud models cannot.

{aria_code-0.101.0 → aria_code-0.103.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.101.0"
+version = "0.103.0"
 description = "Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.101.0 → aria_code-0.103.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.101.0"
+__version__ = "0.103.0"

{aria_code-0.101.0 → aria_code-0.103.0}/src/aria_code/apps/cli/commands/model_cmds.py

@@ -5,6 +5,8 @@ Extracted from aria_cli.py. Methods' __globals__ are rebound to aria_cli's names
 by _rebind_mixin_globals() called at module load time.
 """
 from __future__ import annotations
+
+from aria_code.apps.cli.i18n import ui_text
 from aria_code.packages.aria_core.paths import aria_home
 
 
@@ -194,11 +196,24 @@ class ModelCommandsMixin:
             _mod  = _mod.strip()
             _local_backends = {"ollama", "lmstudio", "vllm", "llamacpp", "jan", "custom"}
             if _prov not in _local_backends:
-                # Cloud provider — check API key
+                # Cloud provider — check API key. Google models also run on
+                # Vertex AI with Google Cloud credentials and no key; this
+                # refused every `/model google/…` without a Gemini API key,
+                # so a team running on Google Cloud could not pick Gemini 3
+                # or Gemma at all.
+                from aria_code.apps.cli.providers.base import google_cloud_available
                 _key = _get_provider_key(_prov)
-                if not _key:
-                    msg = (f"⚠ {_prov} API key 未配置。"
-                           f"运行: /apikey set {_prov} <key>")
+                _vertex_ok = _prov in ("google", "gemini", "vertexai") and google_cloud_available()
+                if not _key and not _vertex_ok:
+                    if _prov in ("google", "gemini", "vertexai"):
+                        msg = ui_text(self,
+                                      f"⚠ 需要 Google Cloud 凭据或 API key：运行 gcloud auth application-default login，"
+                                      f"或 /apikey set {_prov} <key>",
+                                      f"⚠ Needs Google Cloud credentials or an API key: run "
+                                      f"gcloud auth application-default login, or /apikey set {_prov} <key>")
+                    else:
+                        msg = (f"⚠ {_prov} API key 未配置。"
+                               f"运行: /apikey set {_prov} <key>")
                     self.context.console.print(f"[yellow]{msg}[/yellow]") if self.context.has_rich else print(msg)
                     return
             self.terminal.config["local_provider"] = _prov

{aria_code-0.101.0 → aria_code-0.103.0}/src/aria_code/apps/cli/headless.py

@@ -11,6 +11,33 @@ on whichever module loaded last.
 
 from __future__ import annotations
 
+def _headless_approval(config: dict, auto_approve, always_allow):
+    """Answer approvals with what the operator granted up front, and nothing more.
+
+    ``auto_approve`` and ``always_allow`` are read at call time from the module
+    that is actually running (aria_cli, aria_code.aria_cli or __main__ under
+    ``python -m``), which is where --dangerously-skip-permissions and
+    --allow-tools set them.
+    """
+    from aria_code.runtime.approval import ApprovalDecision
+
+    def decide(tool_name: str, params: dict):
+        if not (auto_approve() or tool_name in (always_allow() or ())):
+            return ApprovalDecision.deny("no one is here to approve it; pass --allow-tools or "
+                                         "--dangerously-skip-permissions")
+        if tool_name == "run_command":
+            return ApprovalDecision.allow(policy=config.get("command_policy", "safe"), user_approved=True)
+        return ApprovalDecision.allow()
+
+    return decide
+
+
+def _apply_approval_decision(params: dict, decision) -> dict:
+    from aria_code.runtime.approval import apply_approval_decision
+
+    return apply_approval_decision(params, decision)
+
+
 class HeadlessMixin:
     """run_prompt, _run_prompt_turn, _finish_prompt and run_watch for ArtheraTerminal."""
 
@@ -138,6 +165,8 @@ class HeadlessMixin:
                 # already handles provider selection and cloud→Ollama fallback,
                 # which is what the two branches here were open-coding.
                 from aria_code.apps.cli.providers.runtime_bridge import run_chat_via_runtime
+                # This method runs on aria_cli's names; these two live here.
+                from aria_code.apps.cli.headless import _apply_approval_decision, _headless_approval
 
                 _turn = await run_chat_via_runtime(
                     prompt=prompt, history=[],
@@ -147,14 +176,19 @@ class HeadlessMixin:
                     thinking_mode=thinking_mode, user_context=user_context,
                     auth_token=auth_token, project_context=_PROJECT_CONTEXT,
                     max_rounds=int(self.config.get("max_rounds", 30) or 30),
-                    # No approval UI exists in headless mode. Leaving the confirm
-                    # set populated would block every write on a prompt nobody is
-                    # there to answer; the operator opts in with
-                    # --dangerously-skip-permissions or --allow-tools.
-                    confirm_tools=(
-                        frozenset() if _auto_approve_session
-                        else frozenset(_CONFIRM_TOOLS) - _session_always_allow
-                    ),
+                    # No approval UI exists in headless mode; the operator opts in
+                    # with --dangerously-skip-permissions or --allow-tools. Those
+                    # used to take the tools out of the confirm set, so no
+                    # approval ever happened — and an approval is what lets
+                    # run_command past the default "safe" policy (the REPL's
+                    # "allow" upgrades it to balanced). Every `python3 script.py`
+                    # was blocked: the evals' agents wrote scripts they could not
+                    # run, then computed by hand or stopped. Now the confirm set
+                    # stays, and the pre-approval answers it the way the REPL would.
+                    confirm_tools=frozenset(_CONFIRM_TOOLS),
+                    approval_callback=_headless_approval(
+                        self.config, lambda: _auto_approve_session, lambda: _session_always_allow),
+                    approval_applier=_apply_approval_decision,
                     on_tool_call=events.tool_started,
                     on_tool_result=events.tool_completed,
                     return_result=True,

{aria_code-0.101.0 → aria_code-0.103.0}/src/aria_code/apps/cli/providers/base.py

@@ -336,6 +336,13 @@ def _adc_available() -> bool:
     return os.path.isfile(os.path.join(folder, "application_default_credentials.json"))
 
 
+def google_cloud_available() -> bool:
+    """Credentials Vertex AI can use: application-default credentials or a gcloud CLI."""
+    import shutil
+
+    return _adc_available() or bool(shutil.which("gcloud"))
+
+
 def _google_api_key(config: dict) -> str:
     import os
 
@@ -408,6 +415,30 @@ def google_readiness(config: dict) -> str:
     return ""
 
 
+def is_vertex_open_model(model: str) -> bool:
+    """A model Vertex serves through its OpenAI-compatible endpoint, not generateContent.
+
+    Gemma ("gemma-4-26b-a4b-it-maas", "gemma-3-27b-it") and other Model Garden
+    managed models ("…-maas") are open models: the Gemini API does not serve
+    them, and the native SDK path 404'd.
+    """
+    name = str(model or "").lower().split("/")[-1]
+    return name.startswith("gemma") or name.endswith("-maas")
+
+
+def _adc_access_token() -> str:
+    """An access token from application-default credentials, or "" if there are none."""
+    try:
+        import google.auth
+        import google.auth.transport.requests
+
+        credentials, _ = google.auth.default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
+        credentials.refresh(google.auth.transport.requests.Request())
+        return str(credentials.token or "")
+    except Exception:
+        return ""
+
+
 def vertex_openai_endpoint(config: dict) -> dict:
     """Vertex AI's OpenAI-compatible endpoint and a token from the gcloud login.
 
@@ -423,16 +454,21 @@ def vertex_openai_endpoint(config: dict) -> dict:
     import os
     import shutil
 
-    if not shutil.which("gcloud"):
+    # Application-default credentials first (a CI runner signed in with
+    # Workload Identity Federation, a service account, `gcloud auth
+    # application-default login`), then the gcloud CLI's own login.
+    adc_token = _adc_access_token() if _adc_available() else ""
+    if not adc_token and not shutil.which("gcloud"):
         return {}
     try:
-        project = (os.getenv("GOOGLE_CLOUD_PROJECT") or str(config.get("gcp_project") or "")
-                   or _gcloud("config", "get-value", "project", timeout=10)).strip()
+        project = (os.getenv("GOOGLE_CLOUD_PROJECT") or str(config.get("gcp_project") or "")).strip()
+        if not project and shutil.which("gcloud"):
+            project = _gcloud("config", "get-value", "project", timeout=10).strip()
         if not project or project == "(unset)":
             return {"error": "vertex_needs_project: set GOOGLE_CLOUD_PROJECT, /config set gcp_project=<id>, "
                              "or `gcloud config set project <id>`"}
         location = (os.getenv("GOOGLE_CLOUD_LOCATION") or str(config.get("gcp_location") or "") or "global").strip()
-        token = _gcloud("auth", "print-access-token")
+        token = adc_token or _gcloud("auth", "print-access-token")
     except Exception as exc:          # timeout, permissions: report, never hang the chat
         return {"error": f"vertex_gcloud_failed: {type(exc).__name__}"}
     if not token:
@@ -515,6 +551,45 @@ class ConfiguredProvider:
         self.config["local_provider"] = self.backend
         self.system_override = system_override
 
+    async def _stream_vertex_open_model(self, prepared: list, tools: list, cancel_event):
+        """Gemma and other managed open models, through Vertex's OpenAI-compatible endpoint."""
+        from aria_code.local_llm_provider import LocalLLMProvider
+
+        vertex = await asyncio.to_thread(vertex_openai_endpoint, self.config)
+        if not vertex or vertex.get("error"):
+            yield LLMDone(response="", provider="vertexai", success=False,
+                          error=(vertex or {}).get("error") or
+                          "vertex_needs_credentials: run `gcloud auth application-default login` "
+                          "or set GOOGLE_APPLICATION_CREDENTIALS")
+            return
+        cfg = dict(self.config)
+        cfg.update({
+            "model": f"google/{self.model}",
+            "local_provider": "custom",
+            "custom_endpoint": vertex["base_url"],
+            "custom_model": f"google/{self.model}",
+            "local_api_key": vertex["token"],
+        })
+        provider = LocalLLMProvider.from_config(cfg)
+        async for event in provider.stream(prepared, tools=tools, cancel_event=cancel_event):
+            kind = event.get("type")
+            if kind == "token":
+                yield LLMToken(text=str(event.get("text", "")))
+            elif kind == "thinking":
+                yield LLMThinking(content=str(event.get("text", "")))
+            elif kind == "tool_call":
+                yield LLMToolCall(tool=str(event.get("name", "")), params=dict(event.get("arguments") or {}))
+            elif kind == "error":
+                yield LLMDone(response="", provider="vertexai", success=False,
+                              error=str(event.get("message") or "provider_error"))
+                return
+            elif kind == "done":
+                yield LLMDone(response=str(event.get("text") or ""), usage=dict(event.get("usage") or {}),
+                              provider="vertexai", success=True,
+                              cancelled=str(event.get("stop_reason") or "") == "cancelled")
+                return
+        yield LLMDone(response="", provider="vertexai", success=False, error="empty_response")
+
     def _messages(self, messages: list) -> list:
         prepared = [dict(message) for message in messages]
         if not self.system_override:
@@ -539,6 +614,11 @@ class ConfiguredProvider:
         native_vertex = self.backend in ("vertexai", "vertex-ai", "google-genai") or (
             self.backend in ("google", "gemini") and _opt_in(self.config, "use_vertexai")
         )
+        if self.backend in ("google", "gemini", "vertexai", "vertex-ai", "google-genai") \
+                and is_vertex_open_model(self.model):
+            async for evt in self._stream_vertex_open_model(prepared, tools, cancel_event):
+                yield evt
+            return
         if native_vertex and self.backend in ("google", "gemini") and _gcloud_login_only(self.config):
             # The SDK route accepts only application-default credentials. With
             # just a `gcloud auth login` it failed outright, so a logged-in

{aria_code-0.101.0 → aria_code-0.103.0}/src/aria_code/apps/cli/providers/vertexai_stream.py

@@ -116,10 +116,14 @@ class VertexAIProvider(LLMProvider):
 
             if self._use_vertex():
                 project = os.getenv("GOOGLE_CLOUD_PROJECT") or self.config.get("gcp_project")
+                # global, not us-central1: the Gemini 3 previews
+                # (gemini-3-flash-preview, gemini-3.1-pro-preview) are served
+                # only from the global endpoint and 404 in a region, and the
+                # global endpoint serves 2.5 as well.
                 location = (
                     os.getenv("GOOGLE_CLOUD_LOCATION")
                     or self.config.get("gcp_location")
-                    or "us-central1"
+                    or "global"
                 )
                 kwargs = {"vertexai": True, "location": location}
                 if project:

{aria_code-0.101.0 → aria_code-0.103.0}/src/aria_code/model_capability.py

@@ -202,6 +202,12 @@ _CAPABILITY_TABLE: Dict[str, ModelCapability] = {
     "gemini-1.5-pro":           ModelCapability(tool_calls=True, format="openai_native", context_window=2097152, temperature=0.2, size_class="large",  vision=True),
     "gemini-1.5-flash":         ModelCapability(tool_calls=True, format="openai_native", context_window=1048576, temperature=0.2, size_class="medium", vision=True),
     "gemini":                   ModelCapability(tool_calls=True, format="openai_native", context_window=1048576, temperature=0.2, size_class="large",  vision=True),
+    # Gemma served on Vertex AI (Model Garden, managed): "gemma-4-…-maas",
+    # "gemma-3-…". These used to match nothing and fell to the default — no
+    # tools, a 4K window — so a coding task on Gemma was refused as a
+    # tool-less route. Ollama's "gemma3:27b" ids keep their own entries above.
+    "gemma-4":                  ModelCapability(tool_calls=True, format="openai_native", context_window=131072,  temperature=0.2, size_class="medium", vision=True, notes="Gemma 4 on Vertex AI"),
+    "gemma-3":                  ModelCapability(tool_calls=True, format="openai_native", context_window=131072,  temperature=0.2, size_class="medium", vision=True, notes="Gemma 3 on Vertex AI"),
     # ── OpenAI (cloud, via providers/llm/openai_compat.py) ────────────────
     "gpt-5":                    ModelCapability(tool_calls=True, format="openai_native", context_window=400000, temperature=0.2, size_class="large",  vision=True, thinking=True),
     "gpt-4.1":                  ModelCapability(tool_calls=True, format="openai_native", context_window=1047576, temperature=0.2, size_class="large",  vision=True),

{aria_code-0.101.0 → aria_code-0.103.0/src/aria_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.101.0
+Version: 0.103.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code
@@ -263,7 +263,7 @@ aria-code -p "Fix the failing tests and run them" --format jsonl --allow-tools e
 | --- | --- |
 | Local Ollama | An installed and running Ollama model; no cloud account for local inference. |
 | Direct cloud provider | That provider's API credentials and network access. |
-| Direct Google Cloud Vertex AI | `GOOGLE_CLOUD_PROJECT` and either a `gcloud auth login` (Aria uses Vertex AI's OpenAI-compatible endpoint with that login's token) or Application Default Credentials with `aria-code[google]`. `GOOGLE_CLOUD_LOCATION` defaults to `global`. |
+| Direct Google Cloud Vertex AI | `GOOGLE_CLOUD_PROJECT` and either a `gcloud auth login` (Aria uses Vertex AI's OpenAI-compatible endpoint with that login's token) or Application Default Credentials with `aria-code[google]`. `GOOGLE_CLOUD_LOCATION` defaults to `global`. Any model your project can use works without an API key: `/model google/gemini-3.5-flash`, the Gemini 3 previews (served only from `global`), or Gemma and other Model Garden managed models by their id (`/model google/<id>`), which go through Vertex's OpenAI-compatible endpoint. |
 | Arthera hosted service | Install `aria-code[google]` and sign in through `/login` in the CLI. Arthera account sign-in does not grant Vertex AI credentials to your own machine. |
 
 Install extras only for features you use; see [pyproject.toml](pyproject.toml) for the current package options. Local inference can work offline, but live market data, remote integrations, sign-in, and cloud models cannot.

{aria_code-0.101.0 → aria_code-0.103.0}/src/aria_code.egg-info/SOURCES.txt

@@ -602,6 +602,7 @@ tests/test_google_cloud_models.py
 tests/test_google_cloud_routing.py
 tests/test_google_login.py
 tests/test_google_search_provider.py
+tests/test_headless_command_approval.py
 tests/test_headless_is_agentic.py
 tests/test_honest_surfaces.py
 tests/test_image_gen_tools.py
@@ -762,6 +763,7 @@ tests/test_verification_policy.py
 tests/test_version_consistency.py
 tests/test_version_counter.py
 tests/test_vertex_empty_rounds.py
+tests/test_vertex_models.py
 tests/test_video_analysis.py
 tests/test_video_editor.py
 tests/test_vscode_mcp.py

aria_code-0.103.0/tests/test_headless_command_approval.py

@@ -0,0 +1,58 @@
+"""-p with --dangerously-skip-permissions can run the scripts it writes.
+
+Those flags used to take the tools out of the confirm set, so no approval
+ever happened, and an approval is what lifts run_command past the default
+"safe" policy. In the Vertex evals the agent wrote calculate_reorder.py, was
+told "blocked by the security policy", and then computed by hand (a wrong
+total) or stopped (no output file).
+"""
+
+from __future__ import annotations
+
+import inspect
+import shlex
+import sys
+
+from aria_code.apps.cli.headless import _apply_approval_decision, _headless_approval
+
+
+def test_a_granted_session_approves_commands_with_the_upgrade():
+    decide = _headless_approval({"command_policy": "safe"}, lambda: True, lambda: set())
+    decision = decide("run_command", {"command": "python3 calc.py"})
+    params = {"command": "python3 calc.py"}
+    _apply_approval_decision(params, decision)
+    assert decision.approved and params["user_approved"] is True and params["policy"] == "safe"
+
+
+def test_allow_tools_grants_only_what_it_names():
+    decide = _headless_approval({}, lambda: False, lambda: {"run_command"})
+    assert decide("run_command", {"command": "pytest"}).approved
+    assert not decide("write_file", {"path": "a.py"}).approved
+
+
+def test_nothing_granted_is_refused_with_the_way_to_grant_it():
+    decision = _headless_approval({}, lambda: False, lambda: set())("run_command", {"command": "ls"})
+    assert not decision.approved and "--allow-tools" in decision.reason
+
+
+def test_an_approved_script_runs_under_the_safe_policy(tmp_path, monkeypatch):
+    from aria_code.apps.cli.tools.system_tools import tool_run_command
+
+    monkeypatch.setenv("ARIA_ARTIFACT_ROOT", str(tmp_path / "artifacts"))
+    (tmp_path / "calc.py").write_text("print(2 + 3)\n")
+    params = {"command": f"{shlex.quote(sys.executable)} calc.py", "policy": "safe", "cwd": str(tmp_path),
+              "permission_mode": "workspace-write", "network_enabled": False}
+    blocked = tool_run_command(dict(params), has_rich=False)
+    assert not blocked["success"] and "blocked by policy" in blocked["error"]
+    decision = _headless_approval({"command_policy": "safe"}, lambda: True, lambda: set())("run_command", params)
+    _apply_approval_decision(params, decision)
+    assert tool_run_command(params, has_rich=False)["data"]["stdout"].strip() == "5"
+
+
+def test_the_headless_turn_keeps_the_confirm_set_and_answers_it():
+    import aria_code.aria_cli as cli
+
+    source = inspect.getsource(cli.ArtheraTerminal._run_prompt_turn)
+    assert "confirm_tools=frozenset(_CONFIRM_TOOLS)" in source
+    assert "approval_callback=_headless_approval(" in source
+    assert "lambda: _auto_approve_session" in source

aria_code-0.103.0/tests/test_vertex_models.py

@@ -0,0 +1,122 @@
+"""Gemini 3.x and Gemma on Google Cloud, without a Gemini API key.
+
+- `/model google/<anything>` refused without a Gemini API key, though the
+  model runs on Vertex AI with Google Cloud credentials.
+- The native Vertex path defaulted to us-central1; the Gemini 3 previews are
+  served only from the global endpoint.
+- Gemma ids matched no capability entry (no tools, a 4K window) and went to
+  the Gemini API, which does not serve them.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import io
+import sys
+from types import SimpleNamespace
+
+import pytest
+
+from aria_code.apps.cli.providers import base
+from aria_code.model_capability import get_model_capability
+
+
+@pytest.mark.parametrize("model", ["google/gemma-4-26b-a4b-it-maas", "gemma-3-27b-it", "vertexai/gemma-4-31b-it"])
+def test_gemma_on_vertex_has_tools_and_a_real_window(model):
+    capability = get_model_capability(model)
+    assert capability.tool_calls and capability.context_window >= 131072
+
+
+def test_ollama_gemma_keeps_its_own_entry():
+    assert get_model_capability("gemma3:27b").format == "ollama_native"
+
+
+@pytest.mark.parametrize("model, open_model", [
+    ("gemma-4-26b-a4b-it-maas", True), ("gemma-3-27b-it", True), ("llama-4-maverick-17b-128e-instruct-maas", True),
+    ("gemini-3.5-flash", False), ("gemini-3.1-pro-preview", False),
+])
+def test_which_models_take_the_openai_compatible_endpoint(model, open_model):
+    assert base.is_vertex_open_model(model) is open_model
+
+
+def test_gemma_streams_through_vertex_openai_compatible_endpoint(monkeypatch):
+    import aria_code.local_llm_provider as local_llm
+
+    monkeypatch.setattr(base, "vertex_openai_endpoint", lambda config: {
+        "token": "tok", "project": "p", "location": "global",
+        "base_url": "https://aiplatform.googleapis.com/v1/projects/p/locations/global/endpoints/openapi"})
+    seen = {}
+
+    class FakeProvider:
+        async def stream(self, messages, tools=None, cancel_event=None):
+            yield {"type": "tool_call", "name": "read_file", "arguments": {"path": "a.py"}}
+            yield {"type": "done", "text": "ok"}
+
+    def from_config(cfg):
+        seen.update(cfg)
+        return FakeProvider()
+
+    monkeypatch.setattr(local_llm.LocalLLMProvider, "from_config", staticmethod(from_config))
+    provider = base.ConfiguredProvider({"local_provider": "google"}, "google/gemma-4-26b-a4b-it-maas")
+
+    async def run():
+        return [e async for e in provider.stream([{"role": "user", "content": "hi"}], tools=[])]
+
+    events = asyncio.run(run())
+    assert seen["custom_model"] == "google/gemma-4-26b-a4b-it-maas"
+    assert seen["custom_endpoint"].endswith("/locations/global/endpoints/openapi")
+    assert [type(e).__name__ for e in events] == ["LLMToolCall", "LLMDone"]
+    assert events[-1].success
+
+
+def test_gemma_without_credentials_says_how_to_sign_in(monkeypatch):
+    monkeypatch.setattr(base, "vertex_openai_endpoint", lambda config: {})
+    provider = base.ConfiguredProvider({}, "google/gemma-4-26b-a4b-it-maas")
+
+    async def run():
+        return [e async for e in provider.stream([{"role": "user", "content": "hi"}], tools=[])]
+
+    done = asyncio.run(run())[-1]
+    assert not done.success and "application-default login" in done.error
+
+
+def test_native_vertex_defaults_to_the_global_endpoint(monkeypatch):
+    from aria_code.apps.cli.providers.vertexai_stream import VertexAIProvider
+
+    monkeypatch.delenv("GOOGLE_CLOUD_LOCATION", raising=False)
+    monkeypatch.setenv("GOOGLE_CLOUD_PROJECT", "p")
+    made = {}
+    genai = pytest.importorskip("google.genai")
+    monkeypatch.setattr(genai, "Client", lambda **kw: made.update(kw) or object())
+    VertexAIProvider(model="gemini-3-flash-preview", config={})._get_client()
+    assert made["vertexai"] is True and made["location"] == "global"
+
+
+def test_model_command_accepts_google_models_with_cloud_credentials(monkeypatch):
+    sys.argv = ["aria-code"]
+    import aria_code.aria_cli as cli
+    from rich.console import Console
+
+    monkeypatch.setattr(base, "google_cloud_available", lambda: True)
+    terminal = cli.ArtheraTerminal(dict(cli.DEFAULT_CONFIG))
+    monkeypatch.setattr(terminal.commands.context, "console", Console(file=io.StringIO(), color_system=None))
+    asyncio.run(terminal.commands.cmd_model("google/gemini-3.5-flash"))
+    assert terminal.config["model"] == "gemini-3.5-flash" and terminal.config["local_provider"] == "google"
+
+
+def test_model_command_without_credentials_names_both_ways(monkeypatch):
+    sys.argv = ["aria-code"]
+    import aria_code.aria_cli as cli
+    from rich.console import Console
+
+    monkeypatch.setattr(base, "google_cloud_available", lambda: False)
+    terminal = cli.ArtheraTerminal(dict(cli.DEFAULT_CONFIG, ui_lang="en"))
+    console = Console(file=io.StringIO(), color_system=None, width=200)
+    monkeypatch.setattr(terminal.commands.context, "console", console)
+    import aria_code.apps.cli.commands.model_cmds as model_cmds
+    monkeypatch.setattr(model_cmds, "_get_provider_key", lambda provider: "", raising=False)
+    before = terminal.config["model"]
+    asyncio.run(terminal.commands.cmd_model("google/gemini-3.5-flash"))
+    assert terminal.config["model"] == before
+    text = console.file.getvalue()
+    assert "application-default login" in text and "/apikey set google" in text