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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-agents-cli
-Version: 1.6.1
+Version: 1.7.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.6.1 → google_agents_cli-1.7.0}/pyproject.toml

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

{google_agents_cli-1.6.1 → google_agents_cli-1.7.0}/src/google/agents/cli/_adk_client.py

@@ -17,8 +17,10 @@
 from __future__ import annotations
 
 import asyncio
+import enum
 import json
 import logging
+import time
 from collections.abc import (
     AsyncGenerator,
     Iterable,
@@ -36,6 +38,20 @@ _APP_INFO_TIMEOUT = 10
 DEFAULT_WS_PATH = "/run_live"
 DEFAULT_TURN_TIMEOUT = 120  # seconds to wait for a turn's turnComplete
 
+# Live sessions where the server keeps working after a turnComplete report it
+# as `interactionStatus`. IN_PROGRESS means more model output is still coming;
+# anything else (IDLE, or its deprecated REQUIRES_ACTION spelling) ends the
+# turn. UNSPECIFIED is the enum's zero value and carries no signal.
+_STATUS_IN_PROGRESS = "IN_PROGRESS"
+_STATUS_UNSPECIFIED = "INTERACTION_STATUS_UNSPECIFIED"
+# An unrecognized status still ends the turn, but gets logged.
+_STATUS_TERMINAL = frozenset({"IDLE", "REQUIRES_ACTION"})
+
+# Fallback for models that don't report interactionStatus: ADK can schedule a
+# NON_BLOCKING tool's response past the terminator, and on the wire that is
+# indistinguishable from a call that is never answered.
+DEFAULT_DEFERRED_RESPONSE_TIMEOUT = 30
+
 # /run_live transcribes it back to text, so output stays gradable.
 DEFAULT_MODALITIES = ("AUDIO",)
 
@@ -285,12 +301,21 @@ async def _stream_live_events(
                 await ws.send(json.dumps({"content": content}))
 
                 boundary = _TurnBoundary()
+                # Set once a turnComplete arrives with a tool call still open.
+                deferred_deadline: float | None = None
                 while True:
+                    if deferred_deadline is None:
+                        timeout = float(DEFAULT_TURN_TIMEOUT)
+                    else:
+                        timeout = max(0.0, deferred_deadline - time.monotonic())
                     try:
-                        raw = await asyncio.wait_for(
-                            ws.recv(), timeout=DEFAULT_TURN_TIMEOUT
-                        )
+                        raw = await asyncio.wait_for(ws.recv(), timeout=timeout)
                     except TimeoutError:
+                        if deferred_deadline is not None:
+                            # Nothing followed the provisional terminator, so it
+                            # was the real end of the turn. An ordinary ending
+                            # for a fire-and-forget tool -- not a stall.
+                            break
                         logging.warning(
                             "Turn %d: no event for %ds, giving up on the turn.",
                             turn_index,
@@ -312,8 +337,23 @@ async def _stream_live_events(
                     if event is None:
                         continue
                     yield event
-                    if boundary.is_terminal(event):
+
+                    state = boundary.classify(event)
+                    if state is _Boundary.TERMINAL:
                         break
+                    if state is _Boundary.PROVISIONAL:
+                        deferred_deadline = (
+                            time.monotonic() + DEFAULT_DEFERRED_RESPONSE_TIMEOUT
+                        )
+                    elif deferred_deadline is not None:
+                        # Only the answer extends the wait: metadata frames
+                        # routinely follow a turnComplete and would hold it open.
+                        if _event_has_function_response(event):
+                            deferred_deadline = None  # full turn budget again
+                        elif _event_has_answer_content(event):
+                            deferred_deadline = (
+                                time.monotonic() + DEFAULT_DEFERRED_RESPONSE_TIMEOUT
+                            )
 
                 yield None  # end of turn
         finally:
@@ -323,15 +363,27 @@ async def _stream_live_events(
                 pass
 
 
+class _Boundary(enum.Enum):
+    """What one event means for the end of the current logical turn."""
+
+    CONTINUE = "continue"
+    PROVISIONAL = "provisional"
+    TERMINAL = "terminal"
+
+
 class _TurnBoundary:
-    """Detect the terminal turnComplete of one logical live turn."""
+    """Detect the end of one logical live turn.
+
+    Some live models answer one prompt with several turns and report
+    ``interactionStatus``; models that omit it use the heuristic below.
+    """
 
     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."""
+    def classify(self, event: dict) -> _Boundary:
+        """Feed one event; report what it means for 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
@@ -343,14 +395,33 @@ class _TurnBoundary:
             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
+        if not event.get("turnComplete"):
+            return _Boundary.CONTINUE
+
+        status = str(event.get("interactionStatus") or "").upper()
+        # UNSPECIFIED carries no signal, so it falls through to the heuristic
+        # below rather than being read as an authoritative end of turn.
+        if status and status != _STATUS_UNSPECIFIED:
+            if status == _STATUS_IN_PROGRESS:
+                return _Boundary.CONTINUE
+            if status not in _STATUS_TERMINAL:
+                logging.debug(
+                    "Unrecognized interactionStatus %r; ending the turn.", status
+                )
+            return _Boundary.TERMINAL
+
+        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 _Boundary.CONTINUE
+        if self._tool_call_open:
+            # A terminator while the call is still unanswered. Either the
+            # response was scheduled past it and the answer is still coming,
+            # or the call is never answered and this really is the end. The
+            # two shapes are identical here, so the caller waits it out.
+            return _Boundary.PROVISIONAL
+        return _Boundary.TERMINAL
 
 
 def _decode_ws_frame(raw) -> dict | None:

{google_agents_cli-1.6.1 → google_agents_cli-1.7.0}/src/google/agents/cli/_modes.py

@@ -25,7 +25,5 @@ MODE_ADK_LIVE = "adk_live"
 # message from these, so adding a mode is one edit per set rather than one per
 # call site.
 RUN_MODES = (MODE_A2A, MODE_ADK, MODE_ADK_LIVE)
-# A local server serves ADK only, so a2a needs a --url.
-LOCAL_RUN_MODES = (MODE_ADK, MODE_ADK_LIVE)
 # eval speaks ADK only.
 EVAL_MODES = (MODE_ADK, MODE_ADK_LIVE)

{google_agents_cli-1.6.1 → google_agents_cli-1.7.0}/src/google/agents/cli/_project.py

@@ -28,6 +28,10 @@ from typing import Any
 import click
 import yaml
 
+# Fallback for manifests written before the framework key existed. Those are all
+# ADK; new projects get the value from their template.
+DEFAULT_FRAMEWORK = "google-adk"
+
 
 @dataclass
 class ProjectConfig:
@@ -41,6 +45,7 @@ class ProjectConfig:
     base_template: str = "adk"
     acli_version: str = ""
     language: str = "python"
+    framework: str = DEFAULT_FRAMEWORK
     session_type: str = "none"
     cicd_runner: str = "skip"
     agent_gateway: bool = False
@@ -80,6 +85,7 @@ class ProjectConfig:
             data.get("acli_version") or data.get("version") or cfg.acli_version
         )
         cfg.language = data.get("language", cfg.language)
+        cfg.framework = data.get("framework", cfg.framework)
 
         create_params = data.get("create_params")
         if create_params is None:

{google_agents_cli-1.6.1 → google_agents_cli-1.7.0}/src/google/agents/cli/deploy/_operation.py

@@ -90,3 +90,15 @@ def clear_operation() -> None:
         del data["pending_operation"]
         with open(METADATA_FILE, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=2)
+
+
+def read_remote_agent_runtime_id() -> str | None:
+    """Read the remote_agent_runtime_id from METADATA_FILE."""
+    value = _read_metadata().get("remote_agent_runtime_id")
+    # Older scaffolds shipped the literal string ``"None"`` as a placeholder, so
+    # treat that (and blank values) as "no id recorded" — otherwise a first deploy
+    # would try to update an engine literally named ``None`` and fail with a 404
+    # instead of creating a new one.
+    if isinstance(value, str) and value.strip().lower() in ("", "none", "null"):
+        return None
+    return value

{google_agents_cli-1.6.1 → google_agents_cli-1.7.0}/src/google/agents/cli/deploy/agent_runtime.py

@@ -43,7 +43,6 @@ from agentplatform._genai.types import (
     ReasoningEngineSpecDeploymentSpecAgentGatewayConfig,
     ReasoningEngineSpecDeploymentSpecAgentGatewayConfigAgentToAnywhereConfig,
     ReasoningEngineSpecDeploymentSpecAgentGatewayConfigClientToAgentConfig,
-    UpdateAgentEngineConfigDict,
 )
 from google.cloud import resourcemanager_v3
 from google.genai.errors import APIError
@@ -51,6 +50,7 @@ from google.iam.v1 import iam_policy_pb2, policy_pb2
 
 from google.agents.cli._agent_platform import AgentPlatformClient
 from google.agents.cli._project import (
+    DEFAULT_FRAMEWORK,
     ProjectConfig,
     find_project_root,
     scaffold_older_than,
@@ -60,6 +60,7 @@ from google.agents.cli.deploy._operation import (
     METADATA_FILE,
     clear_operation,
     read_operation,
+    read_remote_agent_runtime_id,
     write_operation,
 )
 from google.agents.cli.deploy._utils import (
@@ -180,21 +181,21 @@ def _build_runtime_env_vars(
     return env_vars
 
 
-def _existing_plain_env_vars(agent: Any) -> dict[str, str]:
+def _existing_plain_env_vars(agent: AgentEngine) -> dict[str, str]:
     """Plain env vars on a deployed Agent Runtime, as ``{name: value}``.
 
     An update replaces the whole ``deployment_spec.env`` block, so re-sending
     these preserves vars set outside this deploy. Secrets are skipped: the API
     only touches them when secrets are supplied.
     """
-    spec = getattr(agent.api_resource, "spec", None)
-    deployment_spec = getattr(spec, "deployment_spec", None) if spec else None
-    env = getattr(deployment_spec, "env", None) if deployment_spec else None
+    api_resource = agent.api_resource
+    spec = api_resource.spec if api_resource else None
+    deployment_spec = spec.deployment_spec if spec else None
+    env = deployment_spec.env if deployment_spec else None
     result: dict[str, str] = {}
     for var in env or []:
-        name = getattr(var, "name", None)
-        if name:
-            result[name] = getattr(var, "value", "") or ""
+        if var.name:
+            result[var.name] = var.value or ""
     return result
 
 
@@ -227,13 +228,13 @@ def _resolve_identity_type(
     if agent_identity is True:
         return IdentityType.AGENT_IDENTITY
     elif agent_identity is False:
-        return IdentityType.IDENTITY_TYPE_UNSPECIFIED
+        return IdentityType.SERVICE_ACCOUNT
     else:
         # On update, None means "no change", on create it's "do not use Agent Identity"
         if is_updating:
             return None
         else:
-            return IdentityType.IDENTITY_TYPE_UNSPECIFIED
+            return IdentityType.SERVICE_ACCOUNT
 
 
 def _get_resource_name_from_operation(operation_name: str) -> str:
@@ -258,12 +259,14 @@ def build_agent_engine_logs_url(operation_name: str, project: str) -> str:
 
 
 def write_deployment_metadata(
-    remote_agent: Any,
+    remote_agent: AgentEngine,
     cfg: ProjectConfig,
 ) -> None:
     """Write deployment metadata to file."""
+    api_resource = remote_agent.api_resource
+    assert api_resource is not None, "deployed agent has no api_resource"
     metadata = {
-        "remote_agent_runtime_id": remote_agent.api_resource.name,
+        "remote_agent_runtime_id": api_resource.name,
         "deployment_target": "agent_runtime",
         "is_a2a": cfg.is_a2a,
         "language": cfg.language,
@@ -278,20 +281,22 @@ def write_deployment_metadata(
 
 
 def print_deployment_success(
-    remote_agent: Any,
+    remote_agent: AgentEngine,
     location: str,
     project: str,
     cfg: ProjectConfig,
 ) -> None:
     """Print deployment success message with console URL."""
-    resource_name_parts = remote_agent.api_resource.name.split("/")
+    api_resource = remote_agent.api_resource
+    assert api_resource is not None, "deployed agent has no api_resource"
+    resource_name = api_resource.name
+    assert resource_name is not None, "deployed agent has no resource name"
+    resource_name_parts = resource_name.split("/")
     agent_runtime_id = resource_name_parts[-1]
 
     if cfg.is_a2a:
         print("\n✅ Deployment successful!")
-        passthrough_url = build_agent_runtime_passthrough_url(
-            location, remote_agent.api_resource.name
-        )
+        passthrough_url = build_agent_runtime_passthrough_url(location, resource_name)
         a2a_path_factory: Callable[[str], str] | None = get_language_config(
             cfg.language
         ).get("a2a_base_path_factory")
@@ -309,10 +314,10 @@ def print_deployment_success(
     else:
         print("\n✅ Deployment successful!")
 
-    print(f"Agent Runtime ID: {remote_agent.api_resource.name}")
+    print(f"Agent Runtime ID: {resource_name}")
 
-    spec = getattr(remote_agent.api_resource, "spec", None)
-    identity = getattr(spec, "effective_identity", None) if spec else None
+    spec = api_resource.spec
+    identity = spec.effective_identity if spec else None
     if _is_agent_identity_principal(identity):
         print(f"Agent Identity: principal://{identity}")
     else:
@@ -335,10 +340,11 @@ AGENT_IDENTITY_ROLES = (
 )
 
 
-def grant_agent_identity_roles(project: str, agent: Any) -> None:
+def grant_agent_identity_roles(project: str, agent: AgentEngine) -> None:
     """Grant the baseline project roles to an agent's own principal."""
-    spec = getattr(agent.api_resource, "spec", None)
-    effective_identity = getattr(spec, "effective_identity", None) if spec else None
+    api_resource = agent.api_resource
+    spec = api_resource.spec if api_resource else None
+    effective_identity = spec.effective_identity if spec else None
     if not _is_agent_identity_principal(effective_identity):
         logging.warning(
             "The agent's effective identity is '%s', not an Agent Identity "
@@ -364,7 +370,7 @@ def grant_agent_identity_roles(project: str, agent: Any) -> None:
     click.echo("  ✅ Agent identity ready")
 
 
-def setup_agent_identity(client: Any, project: str, display_name: str) -> Any:
+def setup_agent_identity(client: Any, project: str, display_name: str) -> AgentEngine:
     """Create an agent first, so we know which principal should be granted the IAM roles."""
     click.echo(f"\n🔧 Creating agent identity for: {display_name}")
     agent = client.agent_engines.create(
@@ -565,6 +571,62 @@ CLASS_METHODS_BUILDERS: dict[str, Callable[[], list[dict[str, str]]] | None] = {
 }
 
 
+def _resolve_target_agent(
+    client: AgentPlatformClient,
+    display_name: str,
+) -> list[Any]:
+    """Resolve the target agent engine by ID or display name.
+
+    Target resolution:
+    1. Prefer the ID recorded in metadata.
+    2. If it does not exist, fall back to listing by display_name, but only if unambiguous.
+    """
+    target_id = read_remote_agent_runtime_id()
+
+    matching_agents: list[Any] = []
+
+    if target_id:
+        try:
+            # get() guarantees full env/resource_limits are populated
+            existing = client.agent_engines.get(name=target_id)
+            # If the engine was found but its display name was changed out of band, warn or fail?
+            # Issue requests: "Before mutation, validate its project number, location, deployment target, resource name, and actual display name. Reject stale or inconsistent metadata."
+            if existing.api_resource.display_name != display_name:
+                raise click.ClickException(
+                    f"Agent Runtime '{target_id}' has display name "
+                    f"'{existing.api_resource.display_name}', but expected '{display_name}'.\n"
+                    "  If this is correct, pass the correct --service-name.\n"
+                    f"  If the metadata in {METADATA_FILE} is stale, delete it and try again."
+                )
+            matching_agents = [existing]
+        except APIError as e:
+            if e.code == 404:
+                raise click.ClickException(
+                    f"Agent Runtime '{target_id}' not found.\n"
+                    f"  The resource recorded in {METADATA_FILE} may have been deleted.\n"
+                    "  Delete the metadata file to deploy a new engine, or check your permissions."
+                ) from e
+            raise click.ClickException(
+                f"Error reading Agent Runtime '{target_id}': {e}"
+            ) from e
+    else:
+        # Fall back to display_name scan
+        existing_agents = list(client.agent_engines.list())
+        matching_agents = [
+            agent
+            for agent in existing_agents
+            if agent.api_resource.display_name == display_name
+        ]
+        if len(matching_agents) > 1:
+            raise click.ClickException(
+                f"Found {len(matching_agents)} Agent Runtime engines named '{display_name}'.\n"
+                "  A display-name update is ambiguous. Delete the duplicates or "
+                f"ensure the correct resource ID is recorded in {METADATA_FILE}."
+            )
+
+    return matching_agents
+
+
 def deploy_agent_runtime(
     *,
     cfg: ProjectConfig,
@@ -590,6 +652,7 @@ def deploy_agent_runtime(
     agent_gateway_ingress: str | None = None,
     build_args: str | None = None,
     port: int | None = None,
+    framework: str = DEFAULT_FRAMEWORK,
 ) -> AgentEngine | None:
     """Deploy the agent to Vertex AI Agent Runtime.
 
@@ -625,6 +688,9 @@ def deploy_agent_runtime(
             with the same three states as ``agent_gateway_egress``.
         build_args: Comma-separated KEY=VALUE build args.
         port: Container port.
+        framework: Framework label recorded on the deployment. The Console
+            reads it to pick a playground, and it selects which runtime
+            contract the deployment declares.
 
     Returns:
         The deployed AgentEngine instance, or None when no_wait is True.
@@ -684,15 +750,7 @@ def deploy_agent_runtime(
     )
     agentplatform.init(project=project, location=location)
 
-    # Check for existing agent
-    # TODO: b/555644474 - select by resource ID; a display name is not unique,
-    # so more than one match is possible and this silently takes the first.
-    existing_agents = list(client.agent_engines.list())
-    matching_agents = [
-        agent
-        for agent in existing_agents
-        if agent.api_resource.display_name == display_name
-    ]
+    matching_agents = _resolve_target_agent(client, display_name)
 
     # Pre-existence flag must be computed before setup_agent_identity: that call
     # creates a bare identity agent (no deployment spec), but it's still a
@@ -730,16 +788,18 @@ def deploy_agent_runtime(
     migrates_to_agent_identity = False
 
     if matching_agents:
-        resource_name = matching_agents[0].api_resource.name
+        matching_api_resource = matching_agents[0].api_resource
+        assert matching_api_resource is not None, "listed agent has no api_resource"
+        resource_name = matching_api_resource.name
         # list() may return a summary without deployment_spec; get() guarantees
         # the full env/resource_limits are populated.
         existing = client.agent_engines.get(name=resource_name)
-        existing_spec = getattr(existing.api_resource, "spec", None)
+        existing_spec = existing.api_resource.spec
         migrates_to_agent_identity = (
             agent_identity
             and is_update
             and not _is_agent_identity_principal(
-                getattr(existing_spec, "effective_identity", None)
+                existing_spec.effective_identity if existing_spec else None
             )
         )
         # Preserve env vars set outside this deploy; CLI/user values still win.
@@ -762,18 +822,10 @@ def deploy_agent_runtime(
         # are None a plain redeploy must omit resource_limits to preserve the live
         # value — only fill when exactly one side was explicitly supplied.
         if (cpu is None) ^ (memory is None):
-            dep = getattr(existing.api_resource.spec, "deployment_spec", None)
-            limits = getattr(dep, "resource_limits", None) or {}
-            existing_cpu = (
-                limits.get("cpu")
-                if isinstance(limits, dict)
-                else getattr(limits, "cpu", None)
-            )
-            existing_memory = (
-                limits.get("memory")
-                if isinstance(limits, dict)
-                else getattr(limits, "memory", None)
-            )
+            dep = existing_spec.deployment_spec if existing_spec else None
+            limits = (dep.resource_limits if dep else None) or {}
+            existing_cpu = limits.get("cpu")
+            existing_memory = limits.get("memory")
             cpu = cpu if cpu is not None else existing_cpu
             memory = memory if memory is not None else existing_memory
             if cpu is None or memory is None:
@@ -871,15 +923,15 @@ def deploy_agent_runtime(
         image_spec_dict["build_args"] = build_args_dict
     config_kwargs["image_spec"] = image_spec_dict
 
-    # The Console uses agent_framework to decide which playground to render.
-    # The unified app is a google-adk container (it serves the native ADK
-    # reasoning_engine contract), matching the terraform deploy path.
-    config_kwargs["agent_framework"] = "google-adk"
-
-    class_methods_builder = dispatch_language(
-        "deploy", CLASS_METHODS_BUILDERS, cfg.language
-    )
-    config_kwargs["class_methods"] = class_methods_builder()
+    # The Console reads agent_framework to decide which playground to render.
+    config_kwargs["agent_framework"] = framework
+    if framework == DEFAULT_FRAMEWORK:
+        # An `agent_engines.get()` client turns these into Python methods, so
+        # only declare them for the container that serves the ADK contract.
+        class_methods_builder = dispatch_language(
+            "deploy", CLASS_METHODS_BUILDERS, cfg.language
+        )
+        config_kwargs["class_methods"] = class_methods_builder()
 
     if psc_interface_config is not None:
         config_kwargs["psc_interface_config"] = psc_interface_config
@@ -969,7 +1021,7 @@ def _create_api_config(
     action: str,
     agent_gateway_egress: str | None,
     agent_gateway_ingress: str | None,
-) -> UpdateAgentEngineConfigDict:
+) -> dict[str, Any]:
     """Create a config for create/update operations with a patched update mask."""
     api_config = client.agent_engines._create_config(
         mode=action,

{google_agents_cli-1.6.1 → google_agents_cli-1.7.0}/src/google/agents/cli/deploy/cmd_deploy.py

@@ -353,6 +353,17 @@ def _print_cloud_run_next_steps(
     type=int,
     help="Container port (Cloud Run / Agent Runtime).",
 )
+@click.option(
+    "--framework",
+    default=None,
+    show_default="the framework recorded in agents-cli-manifest.yaml",
+    help=(
+        "Framework the deployed container implements (Agent Runtime only). "
+        "Sets agent_framework on the Agent Runtime resource, which the Google "
+        "Cloud console reads to pick a playground. The API owns the accepted "
+        "set and quietly falls back to 'custom' for anything else."
+    ),
+)
 @click.option(
     "--memory",
     default=None,
@@ -514,6 +525,12 @@ def _print_cloud_run_next_steps(
     "governedAccessPath=CLIENT_TO_AGENT. Pass an empty value to unbind. "
     "Omit the flag to leave the current binding alone.",
 )
+@click.option(
+    "--ingress",
+    type=click.Choice(["all", "internal", "internal-and-cloud-load-balancing"]),
+    default=None,
+    help="Ingress traffic allowed to the service (Cloud Run).",
+)
 def cmd_deploy(
     *,
     project,
@@ -523,7 +540,9 @@ def cmd_deploy(
     agent_identity,
     update_env_vars,
     iap,
+    ingress,
     port,
+    framework,
     memory,
     cpu,
     min_instances,
@@ -555,7 +574,7 @@ def cmd_deploy(
     \b
     Dispatches by deployment target configured in agents-cli-manifest.yaml:
       agent_runtime → Agent Runtime deployment
-      cloud_run    → gcloud beta run deploy
+      cloud_run    → gcloud run deploy
       gke          → terraform + docker build + kubectl apply
 
     \b
@@ -674,6 +693,15 @@ def cmd_deploy(
         raise click.ClickException(
             "The --build-args flag is only supported for Agent Runtime deployments."
         )
+    # Checks the flag, not the resolved value, so a Cloud Run project can still
+    # record a framework.
+    if framework is not None and cfg.deployment_target != "agent_runtime":
+        raise click.ClickException(
+            "The --framework flag is only supported for Agent Runtime "
+            f"deployments (current target: {cfg.deployment_target}); Cloud Run "
+            "and GKE record no framework."
+        )
+    framework = cfg.framework if framework is None else framework
     if image and cfg.deployment_target == "agent_runtime":
         raise click.ClickException(
             "The --image flag is only supported for Cloud Run and GKE deployments. "
@@ -684,6 +712,11 @@ def cmd_deploy(
             "The --timeout flag is only supported for Cloud Run deployments "
             f"(current target: {cfg.deployment_target})."
         )
+    if ingress is not None and cfg.deployment_target != "cloud_run":
+        raise click.ClickException(
+            "The --ingress flag is only supported for Cloud Run deployments "
+            f"(current target: {cfg.deployment_target})."
+        )
 
     # CPU / memory / instance / concurrency sizing works on Agent Runtime and
     # Cloud Run, but on GKE these are configured via Terraform and the
@@ -783,6 +816,7 @@ def cmd_deploy(
             agent_gateway_ingress=agent_gateway_ingress,
             build_args=build_args,
             port=port,
+            framework=framework,
             cpu=cpu,
             memory=memory,
             min_instances=min_instances,
@@ -832,6 +866,8 @@ def cmd_deploy(
         args.append("--no-cpu-throttling")
         if timeout is not None:
             args.extend(["--timeout", str(timeout)])
+        if ingress:
+            args.extend(["--ingress", ingress])
         if port:
             args.extend(["--port", str(port)])
         if iap:
@@ -1366,9 +1402,9 @@ def _list_agent_runtime_deployments(project: str | None, location: str) -> None:
 
     for agent in agents:
         res = agent.api_resource
-        display_name = getattr(res, "display_name", None) or "—"
-        name = getattr(res, "name", None) or "—"
-        create_time = getattr(res, "create_time", None)
+        display_name = (res.display_name if res else None) or "—"
+        name = (res.name if res else None) or "—"
+        create_time = res.create_time if res else None
         time_str = create_time.strftime("%Y-%m-%d %H:%M") if create_time else "—"
         table.add_row(display_name, name, time_str)