google-agents-cli 1.0.0__tar.gz → 1.1.0__tar.gz

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-agents-cli
-Version: 1.0.0
+Version: 1.1.0
 Summary: Agents CLI — Agent Development Lifecycle toolchain for ADK
 Author-email: Google LLC <agents-cli-dev-pypi@google.com>
 Requires-Python: >=3.11

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "google-agents-cli"
-version = "1.0.0"
+version = "1.1.0"
 description = "Agents CLI — Agent Development Lifecycle toolchain for ADK"
 readme = "README.md"
 license = "Apache-2.0"

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/skills/google-agents-cli-adk-code/SKILL.md

@@ -12,7 +12,7 @@ description: >
 metadata:
   author: Google
   license: Apache-2.0
-  version: 1.0.0
+  version: 1.1.0
   requires:
     bins:
       - agents-cli

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/skills/google-agents-cli-deploy/SKILL.md

@@ -4,7 +4,7 @@ description: >
   This skill should be used when the user wants to "deploy an agent",
   "deploy my ADK agent", "set up CI/CD", "configure secrets",
   "troubleshoot a deployment", or needs guidance on Agent Runtime,
-  Cloud Run, or GKE deployment targets.
+  Cloud Run, or GKE deployment targets, or awareness of Agent Gateway.
   Covers deployment workflows, service accounts, rollback, and production infrastructure.
   Part of the Google ADK (Agent Development Kit) skills suite.
   Do NOT use for API code patterns (use google-agents-cli-adk-code), evaluation
@@ -12,7 +12,7 @@ description: >
 metadata:
   author: Google
   license: Apache-2.0
-  version: 1.0.0
+  version: 1.1.0
   requires:
     bins:
       - agents-cli
@@ -47,7 +47,6 @@ Choose the right deployment target based on your requirements:
 
 | Criteria | Agent Runtime | Cloud Run | GKE |
 |----------|-------------|-----------|-----|
-| **Languages** | Python | Python | Python (+ others via custom containers) |
 | **Scaling** | Managed auto-scaling (configurable min/max, concurrency) | Fully configurable (min/max instances, concurrency, CPU allocation) | Full Kubernetes scaling (HPA, VPA, node auto-provisioning) |
 | **Networking** | VPC-SC and PSC-I supported (private VPC connectivity via network attachments) | Full VPC support, direct VPC egress, IAP, ingress rules | Full Kubernetes networking |
 | **Session state** | Native `VertexAiSessionService` (persistent, managed) | In-memory (dev), Cloud SQL, or Agent Platform Sessions backend | In-memory (dev), Cloud SQL, or Agent Platform Sessions backend |
@@ -58,6 +57,8 @@ Choose the right deployment target based on your requirements:
 
 **Ask the user** which deployment target fits their needs. Each is a valid production choice with different trade-offs.
 
+All three targets are container-based, so any language works.
+
 > **Product name mapping:** "Agent Engine" / "Vertex AI Agent Engine" is now **Agent Runtime**. Use `--deployment-target agent_runtime`.
 
 > **Ambient / scheduled / event-driven agents:** ADK's `trigger_sources` registers `/apps/{app}/trigger/*` endpoints on the same FastAPI app for **all** targets. On **Cloud Run** / **GKE** these are public HTTP routes you point a Pub/Sub push subscription or Eventarc trigger at; on **Agent Runtime** the same routes are reachable through the Agent Engine `/api` passthrough (e.g. `.../reasoningEngines/v1/{resource}/api/apps/{app}/trigger/pubsub`). Cloud Run remains the simplest target for unauthenticated trigger sources. See `/google-agents-cli-adk-code` (`references/adk-python.md`, section "12. Event-Driven / Ambient Agents") for the `trigger_sources` pattern.
@@ -359,6 +360,31 @@ For registering deployed agents with Gemini Enterprise, see `/google-agents-cli-
 
 ---
 
+## Agent Gateway & Semantic Governance (Gemini Enterprise Agent Platform)
+
+> **Note:** There are no `agents-cli` commands for these yet. Deploy your agent as usual
+> with `agents-cli deploy`, then configure Agent Gateway and Semantic Governance separately
+> (via Terraform or the Cloud Console).
+
+**Agent Gateway** is the networking + security entry/exit point for all agent interactions
+(user↔agent, agent↔tool, agent↔agent) — it centralizes access control and governed
+connectivity (ingress/egress). It is not a deployment target. Deploy your agent with
+`agents-cli deploy`, then attach it to a gateway one of two ways:
+
+- **Add the existing agent to a gateway** via the Console / docs flow — see [Route Agent Runtime traffic through Agent Gateway](https://docs.cloud.google.com/gemini-enterprise-agent-platform/scale/runtime/agent-gateway-runtime-deploy) ("For existing agents").
+- **Manage the gateway in Terraform** with [`google_network_services_agent_gateway`](https://registry.terraform.io/providers/hashicorp/google/latest/docs/resources/network_services_agent_gateway) (currently in the `google-beta` provider) — recommended for production, so `agents-cli deploy` owns the agent version and CI/CD handles updates.
+
+Background: [Agent Gateway overview](https://docs.cloud.google.com/gemini-enterprise-agent-platform/govern/gateways/agent-gateway-overview).
+
+**Semantic Governance Policies (SGP)** add a natural-language security/compliance layer
+that keeps an agent's tool invocations aligned with user intent and organizational
+constraints.
+
+- Overview: https://docs.cloud.google.com/gemini-enterprise-agent-platform/govern/policies/semantic-governance-overview
+- Configure: https://docs.cloud.google.com/gemini-enterprise-agent-platform/govern/policies/configure-semantic-governance
+
+---
+
 ## Related Skills
 
 - `/google-agents-cli-workflow` — Development workflow, coding guidelines, and operational rules

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/skills/google-agents-cli-eval/SKILL.md

@@ -11,7 +11,7 @@ description: >
 metadata:
   author: Google
   license: Apache-2.0
-  version: 1.0.0
+  version: 1.1.0
   requires:
     bins:
       - agents-cli

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/skills/google-agents-cli-eval/references/metrics-guide.md

@@ -44,7 +44,7 @@ Custom metrics are declared in `eval_config.yaml` (or `.json`) under `custom_met
 
 Code-based metrics default to **local in-process execution** (no GCP project or region required); opt into the Vertex AI sandbox with `execution: "remote"`.
 
-> **Scaffolded default metric.** The scaffolded `eval_config.yaml` ships `custom_response_quality` as a local LLM-judge in `tests/eval/metrics.py` (referenced via `custom_function_file`, run in-process via `google-genai`). It grades on either backend — `genai.Client()` uses `GEMINI_API_KEY` (AI Studio) or ADC (Vertex) — and reads each case's `reference` (ground truth) when present. To grade with the managed Vertex eval service instead, replace it with a built-in metric or an `LLMMetric` (`prompt_template`).
+> **Scaffolded default metric.** The scaffolded `eval_config.yaml` ships `custom_response_quality` as a local LLM-judge in `tests/eval/response_quality.py` (referenced via `custom_function_file`, run in-process via `google-genai`). It grades on either backend — `genai.Client()` uses `GEMINI_API_KEY` (AI Studio) or ADC (Vertex) — and reads each case's `reference` (ground truth) when present. To grade with the managed Vertex eval service instead, replace it with a built-in metric or an `LLMMetric` (`prompt_template`).
 
 ### Example
 

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/skills/google-agents-cli-observability/SKILL.md

@@ -13,7 +13,7 @@ description: >
 metadata:
   author: Google
   license: Apache-2.0
-  version: 1.0.0
+  version: 1.1.0
   requires:
     bins:
       - agents-cli

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/skills/google-agents-cli-publish/SKILL.md

@@ -15,7 +15,7 @@ description: >
 metadata:
   author: Google
   license: Apache-2.0
-  version: 1.0.0
+  version: 1.1.0
   requires:
     bins:
       - agents-cli
@@ -197,6 +197,6 @@ Docs: https://docs.cloud.google.com/agent-registry/manage-agents
 
 ## Related Skills
 
-- `/google-agents-cli-deploy` — Deployment targets, CI/CD pipelines, and production workflows
+- `/google-agents-cli-deploy` — Deployment targets, CI/CD pipelines, and production workflows (also covers Agent Gateway governed ingress/egress and Semantic Governance awareness)
 - `/google-agents-cli-workflow` — Development workflow, coding guidelines, and operational rules
 - `/google-agents-cli-scaffold` — Project creation and enhancement with `agents-cli scaffold create` / `scaffold enhance`

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/skills/google-agents-cli-scaffold/SKILL.md

@@ -12,7 +12,7 @@ description: >
 metadata:
   author: Google
   license: Apache-2.0
-  version: 1.0.0
+  version: 1.1.0
   requires:
     bins:
       - agents-cli

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/skills/google-agents-cli-workflow/SKILL.md

@@ -12,7 +12,7 @@ description: >
 metadata:
   author: Google
   license: Apache-2.0
-  version: 1.0.0
+  version: 1.1.0
   requires:
     bins:
       - agents-cli
@@ -26,8 +26,8 @@ metadata:
 > **Before writing agent code, make sure a scaffolded project exists (see Phase 2).** Skipping scaffolding loses eval boilerplate, CI/CD config, and project conventions.
 
 
-> Requires: google-agents-cli ~= 1.0.0
-> If version is behind, run: uv tool install "google-agents-cli~=1.0.0"
+> Requires: google-agents-cli ~= 1.1.0
+> If version is behind, run: uv tool install "google-agents-cli~=1.1.0"
 
 > Check version: agents-cli info
 > [Install uv](https://docs.astral.sh/uv/getting-started/installation/index.md) first if needed.
@@ -68,13 +68,15 @@ Users name products inconsistently (Vertex AI → Agent Platform, Agent Engine
 
 ## Phase 0: Understand
 
-Before writing or scaffolding anything, understand what you're building.
+Before writing or scaffolding anything, understand what you're building — through a **design dialogue**, not a checklist. Load `references/brainstorming.md` and follow it: ask **one question at a time**, propose 2–3 architecture approaches for non-trivial agents, and validate the design before any scaffolding.
 
 If `.agents-cli-spec.md` exists in the current directory, read it — it is your primary source of truth. Otherwise:
 
-Do NOT proceed to planning, scaffolding, or coding. Ask the user the questions below and wait for their answers. You MUST have the user's answers before moving on. Do not assume, research, or fill in the blanks yourself. The user's intent drives everything — skipping this step leads to wasted work.
+Do NOT proceed to planning, scaffolding, or coding until the user approves the spec. Do not assume, research, or fill in the blanks yourself — the user's intent drives everything.
 
-**Always ask:**
+**Scale the ceremony to complexity:** a trivial agent (single tool, fixed persona) needs only a couple of questions, a 2–3 sentence spec, and one approval; a complex agent (multi-agent, RAG, external APIs/auth, safety-critical) gets the full treatment in `references/brainstorming.md`.
+
+**Topics to cover** (one question at a time, adapting to the user — see the playbook):
 
 1. **What problem will the agent solve?** — Core purpose and capabilities
 2. **External APIs or data sources needed?** — Tools, integrations, auth requirements
@@ -90,7 +92,7 @@ Do NOT proceed to planning, scaffolding, or coding. Ask the user the questions b
 - If **Cloud Run** or **GKE** chosen → **Session storage?** In-memory (default), Cloud SQL (persistent), or Agent Platform Sessions (managed).
 - If **deployment with CI/CD** chosen → **Git repository?** Does one already exist, or should one be created? If creating, public or private?
 
-Once you have the user's answers, write the spec to `.agents-cli-spec.md` using the template in `references/spec-template.md`, then get the user's approval. See `/google-agents-cli-scaffold` for how these choices map to CLI flags.
+Once the design is agreed, write the spec to `.agents-cli-spec.md` using the template in `references/spec-template.md`, self-review it, then get the user's approval. See `/google-agents-cli-scaffold` for how these choices map to CLI flags.
 
 Once you have a clear understanding, proceed to **Phase 1**.
 
@@ -291,6 +293,7 @@ When you need specific infrastructure files (Terraform, CI/CD, Dockerfile) but d
 | `references/internals.md` | Underlying tools and commands that `agents-cli` wraps (adk, pytest, ruff, uvicorn) |
 | `references/samples.md` | Keyword-indexed catalog of ADK reference samples to study before scaffolding |
 | `references/spec-template.md` | `.agents-cli-spec.md` template and optional sections |
+| `references/brainstorming.md` | Phase 0 design-dialogue playbook (one-at-a-time Q&A, approaches, gates) |
 | `references/terminology.md` | Product-name → CLI-value mapping |
 | `references/commands.md` | Per-phase `agents-cli` command index |
 

google_agents_cli-1.1.0/skills/google-agents-cli-workflow/references/brainstorming.md

@@ -0,0 +1,116 @@
+# Phase 0 Brainstorming Playbook
+
+Turn the user's idea into an agreed `.agents-cli-spec.md` through a collaborative dialogue —
+*before* any sample study, scaffolding, or code. Adapt the depth to the agent's complexity.
+
+## HARD-GATE
+
+Do NOT study samples, scaffold, run `agents-cli create`, or write any code until the user has
+approved the spec. This applies even to "obvious" agents — unexamined assumptions cause the most
+wasted work.
+
+## Scale to complexity
+
+- **Trivial agent** — single tool or none, fixed persona, no external auth, no RAG, no multi-agent.
+  → A couple of adaptive questions, a 2–3 sentence spec, one approval. Don't force the full process.
+- **Complex agent** — multi-agent / orchestration, RAG, external APIs with auth, or safety-critical.
+  → Full treatment below: adaptive Q&A across all topics, 2–3 approaches, sectioned design with
+  approval per section, self-review, and a user-review gate.
+
+When unsure, start light and escalate as complexity surfaces.
+
+## One question at a time
+
+- Ask a single question per message; let the answer shape the next. **Even two questions in one
+  message is a batch** — ask the one that most shapes the design first (usually problem/scope before
+  integrations), and let the answer pick the next.
+- **Ask at least one clarifying question before proposing approaches, and never present a full spec in
+  your first reply.** Jumping straight to a finished spec is the most common failure — it skips the
+  dialogue this phase exists for. (Exceptions: a trivial agent, or a genuinely non-interactive run.)
+- Prefer multiple-choice questions — they are easier to answer than open-ended ones.
+- Cover the Phase 0 topics (problem, tools/APIs + auth, safety, deployment, plus the context-based
+  ones in `SKILL.md`), but follow the user's lead rather than a fixed script.
+- YAGNI: prune features that don't serve the stated purpose.
+
+## When you can't ask (non-interactive, sparse, or deferred input)
+
+Asking is always the default. But when you genuinely can't get an answer — a non-interactive run, a
+one-liner "just build it", **or the user defers a choice to you ("whatever's standard", "you pick",
+"the simplest")** — make a concrete choice and **list it in the spec under an `## Assumptions`
+heading**, each as a one-line decision the user can correct (e.g. "Assumed the public icanhazdadjoke
+API; no auth"). A deferred or vague answer is an assumption to surface, **not a fact to state in the
+spec body**. Always check the axes users most often leave implicit: **data sources, auth method,
+schedule/cadence, and which model.**
+
+Non-interactive ≠ skip the thinking. For non-trivial agents you must still record the approaches you
+weighed and the one you chose, flag oversized scope, and route any retrieval need to the RAG recipe —
+then commit to a design. The user-review gate is how they catch a wrong assumption.
+
+## Propose 2–3 approaches (non-trivial agents)
+
+Once you understand the goal, present 2–3 *agent architecture* options with trade-offs. **End with one
+explicit recommendation — "I recommend Option X because Y" — before asking the user to choose.** Never
+present a neutral menu and leave the decision unframed; a default-with-reasoning is faster to confirm
+or override. Typical axes:
+
+- **Single-agent vs multi-agent / orchestration** — one agent with tools, or a coordinator delegating
+  to sub-agents.
+- **Tool / integration choices** — which APIs or data sources, and how auth is handled.
+- **Retrieval / RAG** — if any capability is "search / look up over our docs, incidents, tickets, or
+  knowledge base", that is retrieval: route it to the `rag-vector-search` / `rag-agent-search`
+  clone-and-study recipes and list the recipe in the spec's Reference Samples (RAG is not a scaffold
+  flag, and is never a removed `agentic_rag` template / `--datastore` / `infra datastore`). Don't
+  silently downgrade a stated retrieval need to a plain tool call, and flag retrieval even when it's
+  deferred to a later phase.
+- **Deployment shape** — prototype-first (recommended) vs a deployment target.
+
+## Present the design in sections
+
+For complex agents, present the design in sections and get approval after each — scale each section to
+its complexity (a sentence if straightforward, a short paragraph if nuanced):
+
+- **Architecture** — single vs multi-agent, sub-agents and their roles.
+- **Tools** — each tool's purpose, API, and auth.
+- **Data flow** — inputs, retrieval, state/memory.
+- **Safety** — concrete guardrails, not generic statements.
+- **Success criteria** — measurable outcomes for evaluation.
+
+Be ready to revisit earlier sections when something doesn't fit.
+
+## Right-size the scope first
+
+If the request spans multiple sub-systems — **3+ specialist/sub-agents, several integrations, or
+distinct data/team domains** — stop and flag it *before* designing. Over-scoped agents are the biggest
+cause of wasted work. Recommend the smallest end-to-end slice that proves the architecture (often one
+coordinator + one specialist), and defer the rest under a `## Future Phases` heading in the spec. This
+holds even non-interactively: name the full scope, recommend a first slice, defer the remainder —
+never silently spec the whole thing as one build.
+
+## Write the spec
+
+Once the design is agreed, write `.agents-cli-spec.md` using `references/spec-template.md`. Write it to
+the **project's working directory** (the cwd where the user is building), not a temporary/scratch
+location — Phase 0 resumes by reading `./.agents-cli-spec.md`, so a spec saved elsewhere is lost next
+session. Name the path in your approval message.
+
+**Self-review before showing the user:**
+
+1. **Placeholders** — any "TBD"/"TODO"/vague requirement? Fill them in.
+2. **Consistency** — do sections contradict each other? Does the architecture match the tools/use cases?
+3. **Scope** — 3+ sub-agents/integrations? If so, did you flag it and carve out a first slice, with the
+   rest under `## Future Phases`? A spec that builds everything at once is a red flag.
+4. **Measurable success criteria** — each criterion is a number, threshold, or pass/fail eval, not
+   "works well" / "comprehensive".
+5. **Ambiguity** — could a requirement be read two ways? Pick one and make it explicit.
+
+Fix issues inline, then continue.
+
+## User-review gate
+
+Ask the user to review `.agents-cli-spec.md` before moving on:
+
+> "Spec written to `.agents-cli-spec.md`. Please review it and tell me if you want changes before we
+> look at reference samples and scaffold."
+
+If they request changes, make them and re-run the self-review. Only once they approve do you proceed
+to **Phase 1 (study samples)** → **Phase 2 (scaffold)**.

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/skills/google-agents-cli-workflow/references/samples.md

@@ -9,13 +9,13 @@ is no `adk@<sample>`.
 git clone --filter=tree:0 --sparse https://github.com/google/adk-samples /tmp/adk-samples
 cd /tmp/adk-samples
 git sparse-checkout add python/agents/<sample>   # most samples
-git sparse-checkout add core/<sample>            # RAG samples (see below)
+git sparse-checkout add core/python/<sample>     # RAG samples (see below)
 ```
 
 Pull in another sample later with one more `git sparse-checkout add <path>`. Start from the key
 files listed under each sample below.
 
-## RAG samples (`core/`)
+## RAG samples (`core/python/`)
 
 Both ground an agent on your own documents. Pick **`rag-agent-search`** for managed search over
 unstructured files (PDF/HTML/TXT), or **`rag-vector-search`** when you need custom

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/src/google/agents/cli/_runner.py

@@ -14,9 +14,11 @@
 
 """Subprocess helpers for agents CLI."""
 
+import io
 import os
 import shlex
 import subprocess
+import sys
 from pathlib import Path
 
 import click
@@ -24,6 +26,24 @@ import click
 from google.agents.cli import _tools
 
 
+def redact_cmd(args: list[str]) -> str:
+    """Mask sensitive information in command arguments and return joined string.
+
+    Masks arguments like --github-pat and environment variables containing secrets.
+    """
+    redacted_cmd_list = list(args)
+    for i, arg in enumerate(args):
+        if arg == "--github-pat" and i + 1 < len(args):
+            redacted_cmd_list[i + 1] = "[REDACTED]"
+        elif any(
+            secret in arg
+            for secret in ["GITHUB_PAT", "GH_TOKEN", "GITHUB_TOKEN", "GITHUB_APP_KEY"]
+        ):
+            redacted_cmd_list[i] = "[REDACTED]"
+
+    return shlex.join(redacted_cmd_list)
+
+
 def run(
     args: list[str],
     *,
@@ -55,11 +75,10 @@ def run(
         resolve_executable: If True, resolve the executable path using require_tool.
             Defaults to True.
 
-
     Returns:
         CompletedProcess instance.
     """
-    cmd_str = shlex.join(args)
+    cmd_str = redact_cmd(args)
 
     if print_cmd:
         click.secho(f"  ▸ {cmd_str}", fg="cyan", dim=True)
@@ -68,26 +87,72 @@ def run(
     if env is not None:
         run_env = {**os.environ, **env}
 
+    # Capture output as UTF-8 text (replacing undecodable bytes) unless we're
+    # piping raw bytes to stdin, where child output must stay bytes. Without an
+    # explicit encoding, subprocess uses the locale codec + strict errors, which
+    # raises UnicodeDecodeError on non-UTF-8 locales (e.g. cp1252 on Windows).
+    text_mode = input_data is None
+    text_kwargs = {"encoding": "utf-8", "errors": "replace"} if text_mode else {}
+
     if capture:
         result = run_resolved(
             args,
             resolve_executable=resolve_executable,
             capture_output=True,
-            text=input_data is None,
-            cwd=cwd,
+            text=text_mode,
+            cwd=str(cwd) if cwd else None,
             input=input_data,
             env=run_env,
             timeout=timeout,
+            **text_kwargs,
         )
     else:
-        result = run_resolved(
-            args,
-            resolve_executable=resolve_executable,
-            cwd=cwd,
-            input=input_data,
-            env=run_env,
-            timeout=timeout,
-        )
+        # Under click.testing.CliRunner, sys.stdout is a StringIO-like object
+        # that doesn't have a fileno(). Subprocess on Windows requires a fileno.
+        # We check carefully to avoid issues with mocks or unusual environments.
+        use_fallback = True
+        if hasattr(sys.stdout, "fileno") and callable(sys.stdout.fileno):
+            try:
+                sys.stdout.fileno()
+                use_fallback = False
+            except (io.UnsupportedOperation, AttributeError, OSError):
+                pass
+
+        if not use_fallback:
+            result = run_resolved(
+                args,
+                resolve_executable=resolve_executable,
+                stdout=sys.stdout,
+                stderr=sys.stderr,
+                cwd=str(cwd) if cwd else None,
+                input=input_data,
+                env=run_env,
+                timeout=timeout,
+            )
+        else:
+            # Fallback to capture and manual emit for environments without a
+            # real stdout fileno (e.g. click.testing.CliRunner).
+            result = run_resolved(
+                args,
+                resolve_executable=resolve_executable,
+                capture_output=True,
+                text=text_mode,
+                cwd=str(cwd) if cwd else None,
+                input=input_data,
+                env=run_env,
+                timeout=timeout,
+                **text_kwargs,
+            )
+            # stdout/stderr are bytes when input_data is set (text=False).
+            for stream, content in (
+                (sys.stdout, result.stdout),
+                (sys.stderr, result.stderr),
+            ):
+                if not content:
+                    continue
+                if isinstance(content, bytes):
+                    content = content.decode(errors="replace")
+                stream.write(content)
 
     if check and result.returncode != 0:
         error_msg = check_err_msg or f"Command failed: {cmd_str}"

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/src/google/agents/cli/_tools.py

@@ -19,6 +19,7 @@ import re
 import shlex
 import shutil
 import subprocess
+import threading
 from functools import cache
 from pathlib import Path
 
@@ -150,6 +151,7 @@ def require_tool(name: str, install_hint: str = "") -> str:
 
 def run_npx_skills(args: list[str], spinner_msg: str) -> list[str]:
     """Run an npx skills command, streaming output in real-time.
+
     Always starts with ``["npx", "-y", SKILLS_NPX_PACKAGE]`` and appends
     the additional ``args`` provided.
     Streams stdout/stderr line-by-line, filtering npm/npx boilerplate.
@@ -184,19 +186,29 @@ def run_npx_skills(args: list[str], spinner_msg: str) -> list[str]:
 
     summary_lines: list[str] = []
     failure_lines: list[str] = []
-    # Leave stderr attached to the terminal (stderr=None) rather than capturing
-    # it. We only ever echo stderr, so piping it would just add a second stream
-    # we'd have to drain concurrently to avoid a pipe-buffer deadlock.
+    # Pipe stderr and drain it concurrently in a background thread to avoid
+    # pipe-buffer deadlock.
     proc = popen_resolved(
         full_args,
         stdout=subprocess.PIPE,
-        stderr=None,
+        stderr=subprocess.PIPE,
         text=True,
         encoding="utf-8",
         errors="replace",
         env=child_env,
     )
 
+    stderr_capture = {"data": ""}
+
+    def _drain_stderr() -> None:
+        try:
+            stderr_capture["data"] = proc.stderr.read() if proc.stderr else ""
+        except Exception:
+            stderr_capture["data"] = ""
+
+    stderr_thread = threading.Thread(target=_drain_stderr, daemon=True)
+    stderr_thread.start()
+
     # Read stdout line-by-line
     assert proc.stdout is not None
     for line in proc.stdout:
@@ -241,9 +253,14 @@ def run_npx_skills(args: list[str], spinner_msg: str) -> list[str]:
             summary_lines.append(clean)
 
     proc.wait()
+    stderr_thread.join()
 
     if proc.returncode != 0:
-        # stderr already streamed to the terminal above.
+        stderr = stderr_capture["data"]
+        click.secho("  Error running npx skills:", fg="red")
+        if stderr.strip():
+            for line in stderr.strip().splitlines():
+                click.echo(f"  {line}")
         raise click.ClickException("npx skills failed")
 
     if failure_lines:

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/src/google/agents/cli/deploy/agent_runtime.py

@@ -614,7 +614,7 @@ def deploy_agent_runtime(
     )
     click.echo(f"   Operation: {operation.name}")
     click.echo(
-        "   If this command is interrupted, run 'google-agents deploy --status' to check progress."
+        "   If this command is interrupted, run 'agents-cli deploy --status' to check progress."
     )
 
     # Block until the operation completes

google_agents_cli-1.1.0/src/google/agents/cli/eval/__init__.py

@@ -0,0 +1,26 @@
+# 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
+#
+#     http://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.
+
+import os
+
+# Quiet third-party output that clutters (but never affects) eval results. This
+# runs before any eval command module body -- and before the eval SDK, litellm,
+# and tqdm are imported -- because Python executes this package __init__ first.
+# That ordering matters: litellm and tqdm read these env vars only at import
+# time, and in-process commands (e.g. `eval grade`) import the SDK at module
+# load. Subprocesses (e.g. `eval generate`'s inference runner) inherit these
+# too. setdefault so users can still opt in for debugging (LITELLM_LOG=DEBUG,
+# TQDM_DISABLE= to re-enable). litellm ERROR-level messages still surface.
+os.environ.setdefault("TQDM_DISABLE", "1")
+os.environ.setdefault("LITELLM_LOG", "ERROR")

{google_agents_cli-1.0.0 → google_agents_cli-1.1.0}/src/google/agents/cli/eval/_inference_runner.py

@@ -36,12 +36,40 @@ sees a corrupt artifact):
 
 import copy
 import json
+import logging
 import os
 import sys
 import traceback
 from pathlib import Path
 
 
+def _quiet_known_noise():
+    """Drop third-party log/warning spam that never affects eval results.
+
+    These only clutter the output during an otherwise-successful run:
+
+    * ADK's benign "App name mismatch" warning -- the eval SDK always loads the
+      agent under a fixed internal app name, so it never matches the directory
+      name. It's logged once per case and reads like an error, so drop just that
+      message while keeping every other ADK log record.
+    * ADK's experimental-feature ``UserWarning`` (e.g. JSON_SCHEMA_FOR_FUNC_DECL).
+
+    litellm and tqdm noise is quieted via env vars set by ``eval generate``.
+    Best-effort: if ADK's logger name or message text changes, the filter simply
+    no-ops and the warning reappears -- nothing breaks.
+    """
+    import warnings
+
+    class _DropAppNameMismatch(logging.Filter):
+        def filter(self, record):
+            return not record.getMessage().startswith("App name mismatch")
+
+    logging.getLogger("google_adk.google.adk.runners").addFilter(_DropAppNameMismatch())
+    warnings.filterwarnings(
+        "ignore", message=r".*\[EXPERIMENTAL\].*", category=UserWarning
+    )
+
+
 def _unwrap_agent(loaded):
     """Return the root agent if ``loaded`` is an ADK ``App`` wrapper."""
     try:
@@ -302,6 +330,7 @@ def main(argv=None):
     import vertexai
     from vertexai import types
 
+    _quiet_known_noise()
     _patch_eval_tool_introspection()
 
     argv = list(sys.argv[1:] if argv is None else argv)