google-agents-cli 1.4.2__tar.gz → 1.6.1__tar.gz

{google_agents_cli-1.4.2 → google_agents_cli-1.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-agents-cli
-Version: 1.4.2
+Version: 1.6.1
 Summary: Agents CLI — Agent Development Lifecycle toolchain for ADK
 Author-email: Google LLC <agents-cli-dev-pypi@google.com>
 Requires-Python: >=3.11
@@ -13,17 +13,23 @@ Requires-Dist: click>=8.1.8,<9
 Requires-Dist: PyYAML>=6.0.2,<7
 Requires-Dist: cookiecutter>=2.6.0,<3
 Requires-Dist: jinja2>=3.1.0
-Requires-Dist: google-cloud-aiplatform[evaluation]>=1.156.0,<2
+Requires-Dist: google-cloud-aiplatform[evaluation]>=1.165.0,<2
 Requires-Dist: google-cloud-resource-manager>=1.12.0
 Requires-Dist: google-auth[pyopenssl]>=2.47.0
+Requires-Dist: pyopenssl<26.2
 Requires-Dist: rich>=13.7.0
 Requires-Dist: backoff>=2.2.1
 Requires-Dist: requests>=2.31.0
+Requires-Dist: websockets>=13.0
 Requires-Dist: a2a-sdk>=1.0,<2
+Requires-Dist: protobuf>=5.29.5,<7
 Requires-Dist: tomlkit>=0.13.0,<1
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pathspec>=0.12.1
+Requires-Dist: filelock>=3.12,<4
+Requires-Dist: packaging>=24
+Requires-Dist: pydantic>=2.10,<3
 Requires-Dist: ruff ; extra == "lint"
 Requires-Dist: ty ; extra == "lint"
 Requires-Dist: codespell ; extra == "lint"
@@ -111,7 +117,7 @@ See the [full tutorial](https://google.github.io/agents-cli/guide/quickstart-tut
 | Command | What it does |
 |---------|-------------|
 | `agents-cli setup` | Install CLI + skills to coding agents |
-| `agents-cli scaffold <name>` | Create a new agent project |
+| `agents-cli create <name>` | Create a new agent project |
 | `agents-cli eval run` | Run the agent over the eval dataset and grade the traces |
 | `agents-cli deploy` | Deploy to Google Cloud |
 | `agents-cli publish gemini-enterprise` | Register with Gemini Enterprise |
@@ -124,8 +130,8 @@ See the [full tutorial](https://google.github.io/agents-cli/guide/quickstart-tut
 | `agents-cli login` | Authenticate with Google Cloud or AI Studio |
 | `agents-cli login --status` | Show authentication status |
 | **Scaffold** | |
-| `agents-cli scaffold <name>` | Create a new agent project |
-| `agents-cli scaffold enhance` | Add deployment, CI/CD, or RAG to an existing project |
+| `agents-cli create <name>` | Create a new agent project |
+| `agents-cli scaffold enhance` | Add deployment or CI/CD to an existing project |
 | `agents-cli scaffold upgrade` | Upgrade project to a newer agents-cli version |
 | **Develop** | |
 | `agents-cli run "prompt"` | Run agent with a single prompt |
@@ -145,9 +151,6 @@ See the [full tutorial](https://google.github.io/agents-cli/guide/quickstart-tut
 | `agents-cli publish gemini-enterprise` | Register with Gemini Enterprise |
 | `agents-cli infra single-project` | Provision single-project infrastructure |
 | `agents-cli infra cicd` | Set up CI/CD pipeline + staging/prod infrastructure |
-| **Data** | |
-| `agents-cli infra datastore` | Provision datastore infrastructure for RAG |
-| `agents-cli data-ingestion` | Run data ingestion pipeline |
 | **Other** | |
 | `agents-cli info` | Show project config and CLI version |
 | `agents-cli update` | Force reinstall skills to all IDEs |

{google_agents_cli-1.4.2 → google_agents_cli-1.6.1}/README.md

@@ -76,7 +76,7 @@ See the [full tutorial](https://google.github.io/agents-cli/guide/quickstart-tut
 | Command | What it does |
 |---------|-------------|
 | `agents-cli setup` | Install CLI + skills to coding agents |
-| `agents-cli scaffold <name>` | Create a new agent project |
+| `agents-cli create <name>` | Create a new agent project |
 | `agents-cli eval run` | Run the agent over the eval dataset and grade the traces |
 | `agents-cli deploy` | Deploy to Google Cloud |
 | `agents-cli publish gemini-enterprise` | Register with Gemini Enterprise |
@@ -89,8 +89,8 @@ See the [full tutorial](https://google.github.io/agents-cli/guide/quickstart-tut
 | `agents-cli login` | Authenticate with Google Cloud or AI Studio |
 | `agents-cli login --status` | Show authentication status |
 | **Scaffold** | |
-| `agents-cli scaffold <name>` | Create a new agent project |
-| `agents-cli scaffold enhance` | Add deployment, CI/CD, or RAG to an existing project |
+| `agents-cli create <name>` | Create a new agent project |
+| `agents-cli scaffold enhance` | Add deployment or CI/CD to an existing project |
 | `agents-cli scaffold upgrade` | Upgrade project to a newer agents-cli version |
 | **Develop** | |
 | `agents-cli run "prompt"` | Run agent with a single prompt |
@@ -110,9 +110,6 @@ See the [full tutorial](https://google.github.io/agents-cli/guide/quickstart-tut
 | `agents-cli publish gemini-enterprise` | Register with Gemini Enterprise |
 | `agents-cli infra single-project` | Provision single-project infrastructure |
 | `agents-cli infra cicd` | Set up CI/CD pipeline + staging/prod infrastructure |
-| **Data** | |
-| `agents-cli infra datastore` | Provision datastore infrastructure for RAG |
-| `agents-cli data-ingestion` | Run data ingestion pipeline |
 | **Other** | |
 | `agents-cli info` | Show project config and CLI version |
 | `agents-cli update` | Force reinstall skills to all IDEs |

{google_agents_cli-1.4.2 → google_agents_cli-1.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "google-agents-cli"
-version = "1.4.2"
+version = "1.6.1"
 description = "Agents CLI — Agent Development Lifecycle toolchain for ADK"
 readme = "README.md"
 license = "Apache-2.0"
@@ -16,17 +16,28 @@ dependencies = [
   "PyYAML>=6.0.2,<7",
   "cookiecutter>=2.6.0,<3",
   "jinja2>=3.1.0",
-  "google-cloud-aiplatform[evaluation]>=1.156.0,<2",
+  "google-cloud-aiplatform[evaluation]>=1.165.0,<2",
   "google-cloud-resource-manager>=1.12.0",
   "google-auth[pyopenssl]>=2.47.0",
+  # pyOpenSSL 26.2 forbids mutating a used SSL Context; urllib3 does it per
+  # connection under google-auth's mTLS shim (urllib3#5107). Lift when fixed.
+  "pyopenssl<26.2",
   "rich>=13.7.0",
   "backoff>=2.2.1",
   "requests>=2.31.0",
+  "websockets>=13.0",
   "a2a-sdk>=1.0,<2",
+  # Pin the a2a-sdk (>=5.29.5) .. aiplatform (<7) window so pip won't chase
+  # protobuf 7 and backtrack into old google-api-core (protobuf<5).
+  "protobuf>=5.29.5,<7",
   "tomlkit>=0.13.0,<1",
   "psutil>=5.9.0",
   "python-dotenv>=1.0.0",
   "pathspec>=0.12.1",
+  "filelock>=3.12,<4",
+  "packaging>=24",
+  # 2.10+: earlier versions emit `enum` beside `const`, which the schema sync test sees.
+  "pydantic>=2.10,<3",
 ]
 
 [project.urls]
@@ -53,7 +64,6 @@ include = [
   "src/google/agents/cli/scaffold/deployment_targets/",
   "src/google/agents/cli/scaffold/resources/",
   "src/google/agents/cli/scaffold/sample_data/",
-  "skills/",
 ]
 
 [project.optional-dependencies]
@@ -79,16 +89,27 @@ dev = [
     "pytest-rerunfailures>=15.0",
     "pytest-xdist>=3.6.1",
     "pytest-cov>=4.1.0",
+    "jsonschema>=4.20",
 ]
 
 [tool.ruff]
 line-length = 90
 target-version = "py311"
-include = ["src/google/agents/cli/**/*.py", "tests/**/*.py", "tools/**/*.py"]
+include = [
+  "src/google/agents/cli/**/*.py",
+  "tests/**/*.py",
+  "tools/**/*.py",
+  # First-party extensions ship real code; lint them like the rest.
+  "extensions/**/*.py",
+]
 exclude = [
     "src/google/agents/cli/scaffold/agents",
     "src/google/agents/cli/scaffold/base_templates",
     "src/google/agents/cli/scaffold/deployment_targets",
+    # Generated-project sources, linted by the project's own config (a
+    # different line length, and no `google` namespace on disk), not this one.
+    "extensions/*/template",
+    "src/google/agents/cli/skills/data",
     "tests/cicd/scripts",
 ]
 
@@ -111,10 +132,10 @@ ignore = ["E501", "C901", "RUF001", "UP036", "RUF067", "RUF069"]
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**/*.py" = ["PLR0917"]
-"src/google/agents/cli/_output.py" = ["TID251"]
 
 [tool.ruff.lint.flake8-tidy-imports.banned-api]
 "rich.console.Console" = { msg = "Use `google.agents.cli._output.Console` instead to ensure project-wide defaults (soft_wrap=True) are applied." }
+"agentplatform.Client" = { msg = "Use `google.agents.cli._agent_platform.AgentPlatformClient` instead, so the client retries throttled requests." }
 
 [tool.ruff.lint.pylint]
 max-positional-args = 5
@@ -136,6 +157,7 @@ exclude = [
     "src/google/agents/cli/scaffold/agents/**",
     "src/google/agents/cli/scaffold/base_templates/**",
     "src/google/agents/cli/scaffold/deployment_targets/**",
+    "src/google/agents/cli/skills/data/**",
     "tests/cicd/scripts/**",
 ]
 

{google_agents_cli-1.4.2 → google_agents_cli-1.6.1}/src/google/agents/cli/__init__.py

@@ -16,7 +16,11 @@
 
 import importlib.metadata
 
+# Reported when the CLI runs from a source checkout rather than an installed
+# distribution. Version checks treat it as "unknown, don't block".
+DEV_VERSION = "0.0.0-dev"
+
 try:
     __version__ = importlib.metadata.version("google-agents-cli")
 except importlib.metadata.PackageNotFoundError:
-    __version__ = "0.0.0-dev"
+    __version__ = DEV_VERSION

google_agents_cli-1.6.1/src/google/agents/cli/_adk_client.py

@@ -0,0 +1,382 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Shared ADK FastAPI client: session create + ``/run_sse`` and ``/run_live``."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from collections.abc import (
+    AsyncGenerator,
+    Iterable,
+    Iterator,
+)
+from typing import NamedTuple
+from urllib.parse import urlencode
+
+import requests
+
+_SESSION_TIMEOUT = 30
+_RUN_SSE_TIMEOUT = 120
+_APP_INFO_TIMEOUT = 10
+
+DEFAULT_WS_PATH = "/run_live"
+DEFAULT_TURN_TIMEOUT = 120  # seconds to wait for a turn's turnComplete
+
+# /run_live transcribes it back to text, so output stays gradable.
+DEFAULT_MODALITIES = ("AUDIO",)
+
+
+def create_session(
+    base_url: str,
+    app_name: str,
+    user_id: str,
+    *,
+    headers: dict,
+    prior_events: list[dict] | None = None,
+) -> str:
+    """Create an ADK session and return its ID.
+
+    When ``prior_events`` are supplied, the ADK server seeds the fresh
+    session with them.
+    """
+    session_url = f"{base_url}/apps/{app_name}/users/{user_id}/sessions"
+    body: dict = {}
+    if prior_events:
+        body["events"] = prior_events
+
+    resp = requests.post(
+        session_url, headers=headers, json=body, timeout=_SESSION_TIMEOUT
+    )
+    resp.raise_for_status()
+    return resp.json().get("id")
+
+
+def fetch_app_info(
+    *,
+    base_url: str,
+    app_name: str,
+    headers: dict,
+) -> tuple[str | None, dict]:
+    """Fetch agent metadata from ADK's /apps/{app_name}/app-info endpoint.
+
+    Returns (root_agent_name, agents), where agents is the raw ADK agents
+    map keyed by agent id. root_agent_name may be None if the server omits
+    it; agents may be empty.
+
+    Raises requests.RequestException (or a subclass: ConnectionError,
+    HTTPError, JSONDecodeError) if the endpoint isn't reachable, returns a
+    non-2xx status, or returns a body that isn't valid JSON.
+    """
+    url = f"{base_url}/apps/{app_name}/app-info"
+    resp = requests.get(url, headers=headers, timeout=_APP_INFO_TIMEOUT)
+    resp.raise_for_status()
+    payload = resp.json()
+    # Accept both camelCase and snake_case for cross language compatibility
+    root_agent_name = payload.get("rootAgentName", payload.get("root_agent_name"))
+    agents = payload.get("agents") or {}
+    return root_agent_name, agents
+
+
+def run_sse(
+    base_url: str,
+    app_name: str,
+    session_id: str,
+    *,
+    user_message: dict,
+    headers: dict,
+    user_id: str,
+) -> Iterator[dict]:
+    """Stream ADK events for a single user turn.
+
+    Yields each ``data:`` line's decoded JSON dict as it arrives. Blank
+    lines, non-``data:`` lines, and payloads that fail to JSON-decode are
+    silently skipped.
+    """
+    run_url = f"{base_url}/run_sse"
+    payload = {
+        "appName": app_name,
+        "userId": user_id,
+        "sessionId": session_id,
+        "newMessage": user_message,
+    }
+
+    with requests.post(
+        run_url, headers=headers, json=payload, stream=True, timeout=_RUN_SSE_TIMEOUT
+    ) as resp:
+        resp.raise_for_status()
+        # Honor the server's explicit charset if provided; otherwise,
+        # fall back to UTF-8 rather than latin-1.
+        if "charset" not in resp.headers.get("Content-Type", "").lower():
+            resp.encoding = "utf-8"
+        for line in resp.iter_lines(decode_unicode=True):
+            if not isinstance(line, str) or not line.startswith("data: "):
+                continue
+            data_str = line[len("data: ") :]
+            try:
+                yield json.loads(data_str)
+            except json.JSONDecodeError:
+                continue
+
+
+def _event_parts(event: dict) -> list:
+    """Return event's content parts, or an empty list when it carries none."""
+    content = event.get("content")
+    if not isinstance(content, dict):
+        return []
+    parts = content.get("parts")
+    return parts if isinstance(parts, list) else []
+
+
+def _event_has_function_call(event: dict) -> bool:
+    """Return True if event carries a model function call."""
+    return any(
+        isinstance(part, dict) and part.get("functionCall")
+        for part in _event_parts(event)
+    )
+
+
+def _event_has_function_response(event: dict) -> bool:
+    """Return True if event carries a tool's function response."""
+    return any(
+        isinstance(part, dict) and part.get("functionResponse")
+        for part in _event_parts(event)
+    )
+
+
+def _event_has_answer_content(event: dict) -> bool:
+    """Return true if event carries gradable model answer content."""
+    transcription = event.get("outputTranscription")
+    if isinstance(transcription, dict) and transcription.get("text"):
+        return True
+    return any(
+        isinstance(part, dict) and (part.get("text") or part.get("inlineData"))
+        for part in _event_parts(event)
+    )
+
+
+class FinishedTranscript(NamedTuple):
+    """A completed Live transcription frame."""
+
+    # "user" for input transcription, else the event's author (or "model").
+    author: str
+    # "user" or "model" -- the genai Content role for the rendered text.
+    role: str
+    text: str
+
+
+# Live transcription keys mapped to the Content role they represent.
+_TRANSCRIPTION_KEYS = (
+    ("inputTranscription", "user"),
+    ("outputTranscription", "model"),
+)
+
+
+def finished_transcript(event: dict) -> FinishedTranscript | None:
+    """Return the finished transcript carried by event, else None"""
+    for key, role in _TRANSCRIPTION_KEYS:
+        transcription = event.get(key)
+        if not isinstance(transcription, dict):
+            continue
+        if not transcription.get("finished"):
+            return None  # partial chunk; the finished aggregate carries the text
+        text = transcription.get("text")
+        if not text:
+            return None
+        author = "user" if role == "user" else (event.get("author") or "model")
+        return FinishedTranscript(author=author, role=role, text=text)
+    return None
+
+
+def is_transcription_event(event: dict) -> bool:
+    """True if event is a Live transcription frame (finished or partial)."""
+    # An empty transcription is still a transcription frame, not a malformed one.
+    return any(key in event for key, _ in _TRANSCRIPTION_KEYS)
+
+
+def stream_live_events(
+    ws_base: str,
+    app_name: str,
+    session_id: str,
+    *,
+    user_turns: Iterable[dict],
+    headers: dict,
+    user_id: str,
+) -> Iterator[dict | None]:
+    """Stream ADK events for a Live conversation over one /run_live socket."""
+    return _iter_async(
+        _stream_live_events(
+            ws_base,
+            app_name,
+            session_id,
+            user_turns=user_turns,
+            headers=headers,
+            user_id=user_id,
+        )
+    )
+
+
+def group_turns(stream: Iterable[dict | None]) -> Iterator[list[dict]]:
+    """Batch a stream_live_events stream into one event list per turn."""
+    events: list[dict] = []
+    for item in stream:
+        if item is None:
+            yield events
+            events = []
+        else:
+            events.append(item)
+
+
+def build_run_live_url(
+    ws_base: str,
+    app_name: str,
+    session_id: str,
+    *,
+    user_id: str,
+) -> str:
+    """Build the ADK /run_live WebSocket URL from a ws-base."""
+    base = ws_base.rstrip("/")
+    query = [
+        ("app_name", app_name),
+        ("user_id", user_id),
+        ("session_id", session_id),
+    ]
+    query.extend(("modalities", m) for m in DEFAULT_MODALITIES)
+    return f"{base}{DEFAULT_WS_PATH}?{urlencode(query)}"
+
+
+async def _stream_live_events(
+    ws_base: str,
+    app_name: str,
+    session_id: str,
+    *,
+    user_turns: Iterable[dict],
+    headers: dict,
+    user_id: str,
+) -> AsyncGenerator[dict | None, None]:
+    """Play user_turns over one socket, yielding each event as it arrives."""
+    from websockets.asyncio.client import connect as ws_connect
+    from websockets.exceptions import ConnectionClosed, ConnectionClosedOK
+
+    ws_url = build_run_live_url(ws_base, app_name, session_id, user_id=user_id)
+    user_turns = list(user_turns)
+    expected_turns = len(user_turns)
+    extra_headers = {
+        k: v for k, v in (headers or {}).items() if k.lower() != "content-type"
+    }
+
+    async with ws_connect(ws_url, additional_headers=extra_headers or None) as ws:
+        try:
+            for turn_index, content in enumerate(user_turns):
+                # One `content` frame per turn; ADK validates each frame.
+                await ws.send(json.dumps({"content": content}))
+
+                boundary = _TurnBoundary()
+                while True:
+                    try:
+                        raw = await asyncio.wait_for(
+                            ws.recv(), timeout=DEFAULT_TURN_TIMEOUT
+                        )
+                    except TimeoutError:
+                        logging.warning(
+                            "Turn %d: no event for %ds, giving up on the turn.",
+                            turn_index,
+                            DEFAULT_TURN_TIMEOUT,
+                        )
+                        break
+                    except ConnectionClosedOK:
+                        if turn_index + 1 < expected_turns:
+                            logging.warning(
+                                "Turn %d: the agent closed the stream; "
+                                "%d later turn(s) were never sent.",
+                                turn_index,
+                                expected_turns - turn_index - 1,
+                            )
+                        yield None  # end of turn
+                        return
+
+                    event = _decode_ws_frame(raw)
+                    if event is None:
+                        continue
+                    yield event
+                    if boundary.is_terminal(event):
+                        break
+
+                yield None  # end of turn
+        finally:
+            try:
+                await ws.send(json.dumps({"close": True}))
+            except ConnectionClosed:
+                pass
+
+
+class _TurnBoundary:
+    """Detect the terminal turnComplete of one logical live turn."""
+
+    def __init__(self) -> None:
+        self._tool_call_open = False
+        self._tool_response_seen = False
+
+    def is_terminal(self, event: dict) -> bool:
+        """Feed one event; return True if it ends the current logical turn."""
+        if _event_has_function_call(event):
+            # Anything spoken before the call is not the post-tool answer.
+            self._tool_call_open = True
+            self._tool_response_seen = False
+        elif _event_has_function_response(event):
+            if self._tool_call_open:
+                self._tool_response_seen = True
+        elif _event_has_answer_content(event):
+            self._tool_call_open = False
+            self._tool_response_seen = False
+
+        if event.get("turnComplete"):
+            if self._tool_call_open and self._tool_response_seen:
+                # Terminator for the tool round-trip; keep reading for the answer.
+                self._tool_call_open = False
+                self._tool_response_seen = False
+                return False
+            return True
+        return False
+
+
+def _decode_ws_frame(raw) -> dict | None:
+    """Decode a /run_live frame into an ADK event dict, or None for audio."""
+    if isinstance(raw, (bytes, bytearray)):
+        try:
+            return json.loads(bytes(raw).decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError):
+            return None
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        return None
+
+
+def _iter_async(agen) -> Iterator:
+    """Drive an async generator from sync code on a dedicated event loop."""
+    loop = asyncio.new_event_loop()
+    try:
+        while True:
+            try:
+                yield loop.run_until_complete(agen.__anext__())
+            except StopAsyncIteration:
+                break
+    finally:
+        loop.run_until_complete(agen.aclose())
+        # Finalize websockets' own async generators before closing the loop.
+        loop.run_until_complete(loop.shutdown_asyncgens())
+        loop.close()

google_agents_cli-1.6.1/src/google/agents/cli/_agent_platform.py

@@ -0,0 +1,66 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Shared construction of the Agent Platform SDK client."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import agentplatform
+
+# Retry options applied to every Agent Platform client the CLI builds. Leaving
+# http_status_codes unset keeps the SDK's default retryable set (408/429/500/502/503/504);
+# waits are roughly 1s, 2s, 4s, 8s (full-jittered).
+RETRY_OPTIONS: dict[str, Any] = {
+    "attempts": 5,
+    "initial_delay": 1.0,
+}
+
+
+class AgentPlatformClient:
+    """Agent Platform client configured with CLI-wide defaults (e.g. retries on transient errors).
+
+    Retries are opt-in in the underlying SDK, so constructing ``agentplatform.Client``
+    directly runs without them. A ruff rule enforces using this wrapper instead.
+
+    Args:
+        project: GCP project ID, or None to let the SDK resolve it.
+        location: API location (e.g. ``us-east1``), or None.
+        api_version: Optional API version override (e.g. ``v1beta1``).
+    """
+
+    def __init__(
+        self,
+        *,
+        project: str | None = None,
+        location: str | None = None,
+        api_version: str | None = None,
+    ) -> None:
+        # Lazy: agentplatform is expensive to import, this module is not.
+        import agentplatform
+
+        http_options: dict[str, Any] = {"retry_options": RETRY_OPTIONS}
+        if api_version:
+            http_options["api_version"] = api_version
+
+        self._client: agentplatform.Client = agentplatform.Client(  # noqa: TID251
+            project=project,
+            location=location,
+            http_options=http_options,
+        )
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._client, name)

{google_agents_cli-1.4.2 → google_agents_cli-1.6.1}/src/google/agents/cli/_click.py

@@ -50,6 +50,7 @@ class LazyGroup(click.Group):
         self._lazy_commands: dict[str, tuple[str, str]] = {}
         # name -> experiment label
         self._experiment_gates: dict[str, str] = {}
+        self._overrides: dict[str, click.Command] = {}
 
     def add_lazy_command(
         self,
@@ -81,12 +82,20 @@ class LazyGroup(click.Group):
         return bool(resolve_experiment(label))
 
     def list_commands(self, ctx: click.Context) -> list[str]:
-        names = set(super().list_commands(ctx)) | set(self._lazy_commands)
+        names = (
+            set(super().list_commands(ctx))
+            | set(self._lazy_commands)
+            | set(self._overrides)
+        )
         return sorted(filter(self._is_visible, names))
 
     def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
+        # Overrides are consulted only after the visibility check, so an installed
+        # extension cannot expose a command that is gated off.
         if not self._is_visible(cmd_name):
             return None
+        if cmd_name in self._overrides:
+            return self._overrides[cmd_name]
         if cmd_name in self._lazy_commands and cmd_name not in self.commands:
             import_path, _ = self._lazy_commands[cmd_name]
             module_path, attr = import_path.split(":")
@@ -98,6 +107,9 @@ class LazyGroup(click.Group):
     def format_commands(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
         rows: list[tuple[str, str]] = []
         for name in self.list_commands(ctx):
+            if name in self._overrides:
+                rows.append((name, self._overrides[name].get_short_help_str(limit=1000)))
+                continue
             if name in self.commands:
                 # Don't truncate — Click's default of 45 would cut our docstring summaries.
                 rows.append((name, self.commands[name].get_short_help_str(limit=1000)))