aria-code 0.110.0__tar.gz → 0.112.0__tar.gz

{aria_code-0.110.0/src/aria_code.egg-info → aria_code-0.112.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.110.0
+Version: 0.112.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
@@ -169,8 +169,9 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center"><a href="README_CN.md">简体中文</a> · English</p>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
-  <a href="https://pypi.org/project/aria-code/"><img src="https://img.shields.io/pypi/v/aria-code?style=flat-square&logo=pypi&label=PyPI" alt="PyPI version"></a>
+  <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
+  <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
+  <a href="https://pypi.org/project/aria-code/0.112.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.112.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>
@@ -230,12 +231,16 @@ Aria checks for a newer stable version in the background at startup, at most onc
 ```bash
 aria update --check  # check without installing
 aria update          # install the newest stable version for this install channel
+aria update --to 0.110.0  # choose a specific stable release
+aria update --rollback   # native macOS/Linux: restore the previous managed release offline
 ```
 
 In an interactive session, use `/update --check` or `/update`, then restart Aria. Native updates verify SHA-256 and the downloaded binary's version before switching the command; a failed download or verification leaves the existing command in place. Startup checks only notify. To disable them, set `check_for_update_on_startup` to `false` in `~/.aria-code/config.json`.
 
 For GitHub notifications, open [this repository](https://github.com/artheras/aria-code), select **Watch → Custom → Releases**, and save. Notifications follow your GitHub notification settings. Published stable releases appear on the [release page](https://github.com/artheras/aria-code/releases/latest) once the platform assets and package publishing have completed.
 
+Native macOS/Linux updates retain interrupted transfers and can use the verified official npm platform artifact when GitHub downloads fail. For recovery and a model generation check (`aria health --model --tools --json`), see [updates and model diagnostics](docs/update-and-model-diagnostics.md).
+
 To use a local model, install [Ollama](https://ollama.com/download), pull a coding model, and start Aria in local-only mode:
 
 ```bash

{aria_code-0.110.0 → aria_code-0.112.0}/README.md

@@ -13,8 +13,9 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center"><a href="README_CN.md">简体中文</a> · English</p>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
-  <a href="https://pypi.org/project/aria-code/"><img src="https://img.shields.io/pypi/v/aria-code?style=flat-square&logo=pypi&label=PyPI" alt="PyPI version"></a>
+  <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
+  <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
+  <a href="https://pypi.org/project/aria-code/0.112.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.112.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>
@@ -74,12 +75,16 @@ Aria checks for a newer stable version in the background at startup, at most onc
 ```bash
 aria update --check  # check without installing
 aria update          # install the newest stable version for this install channel
+aria update --to 0.110.0  # choose a specific stable release
+aria update --rollback   # native macOS/Linux: restore the previous managed release offline
 ```
 
 In an interactive session, use `/update --check` or `/update`, then restart Aria. Native updates verify SHA-256 and the downloaded binary's version before switching the command; a failed download or verification leaves the existing command in place. Startup checks only notify. To disable them, set `check_for_update_on_startup` to `false` in `~/.aria-code/config.json`.
 
 For GitHub notifications, open [this repository](https://github.com/artheras/aria-code), select **Watch → Custom → Releases**, and save. Notifications follow your GitHub notification settings. Published stable releases appear on the [release page](https://github.com/artheras/aria-code/releases/latest) once the platform assets and package publishing have completed.
 
+Native macOS/Linux updates retain interrupted transfers and can use the verified official npm platform artifact when GitHub downloads fail. For recovery and a model generation check (`aria health --model --tools --json`), see [updates and model diagnostics](docs/update-and-model-diagnostics.md).
+
 To use a local model, install [Ollama](https://ollama.com/download), pull a coding model, and start Aria in local-only mode:
 
 ```bash

{aria_code-0.110.0 → aria_code-0.112.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.110.0"
+version = "0.112.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.110.0 → aria_code-0.112.0}/src/aria_code/_version.py

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

{aria_code-0.110.0 → aria_code-0.112.0}/src/aria_code/apps/cli/commands/diagnostic_cmds.py

@@ -227,6 +227,29 @@ class DiagnosticCommandsMixin:
             print()
 
     async def cmd_health(self, args: str):
+        try:
+            parts = shlex.split(args)
+        except ValueError:
+            message = "Usage: /health [--model] [--tools] [--json]"
+            self.context.console.print(message) if self.context.has_rich else print(message)
+            return
+        if parts:
+            if any(part not in {"--model", "--tools", "--json"} for part in parts):
+                message = "Usage: /health [--model] [--tools] [--json]"
+                self.context.console.print(message) if self.context.has_rich else print(message)
+                return
+            if not any(part in {"--model", "--tools"} for part in parts):
+                message = "Run /health --model --json to explicitly test model generation."
+                self.context.console.print(message) if self.context.has_rich else print(message)
+                return
+            from aria_code.apps.cli.model_probe import probe_model
+            report = await probe_model(self.terminal.config, self.terminal.api_url, tools="--tools" in parts)
+            message = json.dumps(report.to_dict(), ensure_ascii=False) if "--json" in parts else (
+                f"{report.model} · {report.route} · {report.category}: {report.message}"
+                + (f"\n{report.suggestion}" if report.suggestion else "")
+            )
+            self.context.console.print(message, markup=False) if self.context.has_rich else print(message)
+            return
         import aiohttp
         if self.context.has_rich:
             self.context.console.print()
@@ -251,10 +274,12 @@ class DiagnosticCommandsMixin:
                             self.context.console.print(f"  [green]●[/green] [dim]{label}[/dim]  {detail}")
                         else:
                             print(f"  + {label}  {detail}")
-            except Exception:
+            except Exception as exc:
+                from aria_code.packages.aria_services.provider_health import classify_provider_error
+                category = classify_provider_error(label, exc).category
                 if self.context.has_rich:
-                    self.context.console.print(f"  [red]●[/red] [dim]{label}[/dim]  offline")
+                    self.context.console.print(f"  [red]●[/red] [dim]{label}[/dim]  {category}")
                 else:
-                    print(f"  - {label}  offline")
+                    print(f"  - {label}  {category}")
         if self.context.has_rich:
             self.context.console.print()

aria_code-0.112.0/src/aria_code/apps/cli/model_probe.py

@@ -0,0 +1,166 @@
+"""Explicit model diagnostics using the selected transport, without file tools."""
+from __future__ import annotations
+
+import argparse
+import asyncio
+from dataclasses import asdict, dataclass
+import json
+import time
+
+from aria_code.apps.cli.providers.chat_routing import first_round_route
+from aria_code.packages.aria_services.provider_health import classify_provider_error
+
+
+@dataclass(frozen=True)
+class ModelProbe:
+    model: str
+    route: str
+    success: bool
+    category: str
+    message: str
+    duration_ms: int
+    text_verified: bool = False
+    tools_verified: bool = False
+    provider: str = ""
+    first_token_ms: int | None = None
+    suggestion: str = ""
+    schema: str = "aria.model_probe.v1"
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+_PROBE_TOOL = {"type": "function", "function": {
+    "name": "aria_probe_ping",
+    "description": "A diagnostic echo with no file access or side effects.",
+    "parameters": {"type": "object", "properties": {"echo": {"type": "string"}}, "required": ["echo"]},
+}}
+
+
+async def probe_model(config: dict, api_url: str = "", *, tools: bool = False,
+                      timeout: float = 30) -> ModelProbe:
+    """One text request, optionally one inert tool call and its round trip.
+
+    Do not use the agent gateway: its provider fallback and project tools can
+    hide a broken primary route or perform work. Never change saved settings.
+    """
+    from aria_code.apps.cli.providers.base import AriaSSEProvider, ConfiguredProvider, OllamaProvider
+    from aria_code.packages.aria_sdk.streaming import stream_provider_result
+
+    cfg = dict(config)
+    model = str(cfg.get("model") or "")
+    route = first_round_route(model, cfg, api_url)
+    started = time.monotonic()
+    cancel = asyncio.Event()
+    text_ok = tool_ok = False
+    provider_name = ""
+    first_token = None
+
+    def token(_text):
+        nonlocal first_token
+        if _text.strip() and first_token is None:
+            first_token = round((time.monotonic() - started) * 1000)
+
+    def result(ok, category, message, suggestion=""):
+        return ModelProbe(model, route, ok, category, message,
+                          round((time.monotonic() - started) * 1000),
+                          text_ok, tool_ok, provider_name, first_token, suggestion)
+
+    def failed(error):
+        raw = str(error or "empty_response")
+        if "backend_local_tools_unsupported" in raw or "tool_protocol" in raw:
+            return result(False, "protocol_unsupported", "Backend does not support the local tool protocol.",
+                          "Update the backend protocol or use a direct provider for local project tasks.")
+        issue = classify_provider_error(provider_name or route, error)
+        suggestions = {
+            "auth": "Check credentials and project permissions; for Google Cloud, verify gcloud/ADC authorization.",
+            "configuration": "Set your Google Cloud project: /config set gcp_project=<project-id> or GOOGLE_CLOUD_PROJECT.",
+            "model_unavailable": "Check the selected model ID, project and serving region with /model.",
+            "rate_limited": "Wait for the quota cooldown or check the provider quota.",
+            "timeout": "Check network and provider latency; increase --timeout if needed.",
+            "no_data": "The selected route returned no visible text; check its streaming/model configuration.",
+        }
+        return result(False, issue.category, issue.message,
+                      suggestions.get(issue.category, "Check the selected provider and connection settings."))
+
+    def provider(local_tools=False):
+        if route == "cloud":
+            return AriaSSEProvider(api_url, model, auth_token=cfg.get("auth_token"),
+                                   use_react_gateway=bool(cfg.get("arthera_react_gateway")),
+                                   local_tools=local_tools)
+        if route == "ollama":
+            return OllamaProvider(str(cfg.get("ollama_url") or "http://localhost:11434"), model,
+                                  system_override="Only perform the requested diagnostic.",
+                                  show_market_prefetch_status=False)
+        return ConfiguredProvider(cfg, model)
+
+    async def run():
+        nonlocal text_ok, tool_ok, provider_name
+        reply = await stream_provider_result(provider(), "Reply with the single word READY.", [],
+                                             tools=[], cancel_event=cancel, on_token=token)
+        provider_name = str(reply.get("provider") or route)
+        if not reply.get("success") or not str(reply.get("response") or "").strip():
+            return failed(reply.get("error") or "empty_response")
+        text_ok = True
+        if not tools:
+            return result(True, "ok", "Selected model returned visible text.")
+        diagnostic = provider(local_tools=True)
+        request = "Call aria_probe_ping exactly once with echo='READY'. Do not answer in text before calling it."
+        call = await stream_provider_result(diagnostic, request, [], tools=[_PROBE_TOOL], cancel_event=cancel)
+        if not call.get("success"):
+            return failed(call.get("error"))
+        calls = list(call.get("tool_calls_pending") or [])
+        if len(calls) != 1 or calls[0].get("tool") != "aria_probe_ping" or calls[0].get("params") != {"echo": "READY"}:
+            return result(False, "tool_protocol", "Model did not return the requested diagnostic tool call.",
+                          "Check that this model and transport support function calling.")
+        history = [{"role": "user", "content": request},
+                   {"role": "assistant", "content": "", "tool_calls": [{"id": "aria-probe-1", "type": "function",
+                    "function": {"name": "aria_probe_ping", "arguments": '{"echo":"READY"}'}}]},
+                   {"role": "tool", "name": "aria_probe_ping", "tool_call_id": "aria-probe-1", "content": '{"echo":"READY"}'}]
+        reply = await stream_provider_result(diagnostic, "The diagnostic tool returned READY. Reply READY.", history,
+                                             tools=[], cancel_event=cancel)
+        if not reply.get("success") or not str(reply.get("response") or "").strip():
+            return failed(reply.get("error") or "empty_response")
+        tool_ok = True
+        return result(True, "ok", "Selected model returned text and completed the diagnostic tool round trip.")
+
+    try:
+        return await asyncio.wait_for(run(), timeout=timeout)
+    except asyncio.TimeoutError:
+        return failed("model probe timed out")
+    except Exception as exc:
+        return failed(exc)
+    finally:
+        cancel.set()
+
+
+def main(argv=None) -> int:
+    """Fast standalone equivalent of /health --model; no REPL or agent import."""
+    parser = argparse.ArgumentParser(prog="aria health", description="Probe the selected model without accessing project files")
+    parser.add_argument("--model", action="store_true", help="Send a short text generation request")
+    parser.add_argument("--tools", action="store_true", help="Also verify an inert tool call and its result")
+    parser.add_argument("--model-id", help="Probe this model without changing your saved selection")
+    parser.add_argument("--timeout", type=float, default=30, help="Total probe deadline in seconds (1–60)")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    if not 1 <= args.timeout <= 60:
+        parser.error("--timeout must be between 1 and 60 seconds")
+    from aria_code.apps.cli.bootstrap import initialize_cli_environment, default_config, runtime_paths
+    from aria_code.apps.cli.config_store import load_cli_config
+
+    initialize_cli_environment()
+    cfg = load_cli_config(runtime_paths(), default_config())
+    if args.model_id:
+        cfg["model"] = args.model_id
+    if not (args.model or args.tools):
+        report = ModelProbe(str(cfg.get("model") or ""), first_round_route(str(cfg.get("model") or ""), cfg, cfg.get("api_url")),
+                            False, "not_probed", "Run aria health --model to test generation; add --tools to test function calling.", 0)
+    else:
+        report = asyncio.run(probe_model(cfg, str(cfg.get("api_url") or ""), tools=args.tools, timeout=args.timeout))
+    if args.json:
+        print(json.dumps(report.to_dict(), ensure_ascii=False))
+    else:
+        print(f"{report.model} · {report.route} · {report.category}: {report.message}")
+        if report.suggestion:
+            print(report.suggestion)
+    return 0 if report.success else (2 if report.category == "not_probed" else 1)

{aria_code-0.110.0 → aria_code-0.112.0}/src/aria_code/apps/cli/providers/base.py

@@ -12,6 +12,7 @@ Implement the protocol on any class or pass a coroutine that matches
 from __future__ import annotations
 
 import asyncio
+from contextlib import suppress
 from dataclasses import dataclass, field
 from typing import AsyncGenerator, Optional, Protocol, runtime_checkable
 
@@ -129,27 +130,34 @@ async def _stream_callback_provider(invoke, *, done_provider: str) -> AsyncGener
     task = asyncio.create_task(
         invoke(_on_token, _on_thinking, _on_tool_call, _on_tool_result, _on_status)
     )
-    while not task.done() or not queue.empty():
+    try:
+        while not task.done() or not queue.empty():
+            try:
+                yield await asyncio.wait_for(queue.get(), timeout=0.05)
+            except asyncio.TimeoutError:
+                continue
         try:
-            yield await asyncio.wait_for(queue.get(), timeout=0.05)
-        except asyncio.TimeoutError:
-            continue
+            result = await task
+        except Exception as exc:
+            yield LLMDone(response="", provider=done_provider, success=False, error=str(exc))
+            return
 
-    try:
-        result = await task
-    except Exception as exc:
-        yield LLMDone(response="", provider=done_provider, success=False, error=str(exc))
-        return
-
-    yield LLMDone(
-        response=result.get("response", ""),
-        tool_calls_pending=result.get("tool_calls_pending", []),
-        usage=result.get("usage", {}),
-        provider=result.get("provider", done_provider),
-        success=result.get("success", False),
-        cancelled=result.get("cancelled", False),
-        error=result.get("error", ""),
-    )
+        yield LLMDone(
+            response=result.get("response", ""),
+            tool_calls_pending=result.get("tool_calls_pending", []),
+            usage=result.get("usage", {}),
+            provider=result.get("provider", done_provider),
+            success=result.get("success", False),
+            cancelled=result.get("cancelled", False),
+            error=result.get("error", ""),
+        )
+    finally:
+        # A deadline or an early-closing consumer must also stop the request
+        # behind this callback adapter, rather than leave it running invisibly.
+        if not task.done():
+            task.cancel()
+        with suppress(asyncio.CancelledError, Exception):
+            await task
 
 
 # ── Protocol ─────────────────────────────────────────────────────────────────

{aria_code-0.110.0 → aria_code-0.112.0}/src/aria_code/apps/cli/providers/vertexai_stream.py

@@ -33,6 +33,37 @@ logger = logging.getLogger(__name__)
 
 _EMPTY_ROUND_RETRIES = 2
 
+# Waits before re-sending a request Vertex turned away as busy: 429
+# RESOURCE_EXHAUSTED (quota or shared capacity) and 500/503/504. The 40-task
+# eval run lost inventory-reorder this way, mid-task, to a single 429 that
+# ended the turn. Retried only while the round has produced nothing, so no
+# text or tool call is ever delivered twice.
+_BUSY_BACKOFF = (2, 5, 10, 20, 40)
+_BUSY_CODES = frozenset({429, 500, 503, 504})
+_BUSY_STATUSES = frozenset({"RESOURCE_EXHAUSTED", "UNAVAILABLE", "INTERNAL", "DEADLINE_EXCEEDED"})
+_sleep = asyncio.sleep
+
+
+def _busy(error) -> bool:
+    """True when Vertex refused the request for load, not for anything in it."""
+    return (getattr(error, "code", None) in _BUSY_CODES
+            or str(getattr(error, "status", "") or "").upper() in _BUSY_STATUSES)
+
+
+async def _wait(seconds: float, cancel_event: Optional[asyncio.Event]) -> bool:
+    """Sleep up to *seconds*; True if the user cancelled meanwhile."""
+    if cancel_event is None:
+        await _sleep(seconds)
+        return False
+    waited = 0.0
+    while waited < seconds:
+        if cancel_event.is_set():
+            return True
+        step = min(0.5, seconds - waited)
+        await _sleep(step)
+        waited += step
+    return cancel_event.is_set()
+
 
 def _chunk_text(chunk) -> str:
     """The text parts of a chunk, read without chunk.text.
@@ -311,38 +342,58 @@ class VertexAIProvider(LLMProvider):
             usage = {}
             tool_calls = []
             finish_reasons: list = []
+            busy_tries = 0
             for attempt in range(1 + _EMPTY_ROUND_RETRIES):
-                response_stream = await client.aio.models.generate_content_stream(
-                    model=self.model,
-                    contents=contents,
-                    config=config,
-                )
-                async for chunk in response_stream:
-                    if cancel_event and cancel_event.is_set():
-                        yield LLMDone(response=full_response, provider="vertexai", success=True, cancelled=True)
-                        return
-
-                    text = _chunk_text(chunk)
-                    if text:
-                        full_response += text
-                        yield LLMToken(text=text)
-
-                    if chunk.function_calls:
-                        for fc in chunk.function_calls:
-                            args = {k: v for k, v in fc.args.items()} if fc.args else {}
-                            yield LLMToolCall(tool=fc.name, params=args)
-                            tool_calls.append({"tool": fc.name, "params": args})
-
-                    for candidate in (getattr(chunk, "candidates", None) or []):
-                        reason = getattr(candidate, "finish_reason", None)
-                        if reason:
-                            finish_reasons.append(str(getattr(reason, "name", reason)))
-
-                    if chunk.usage_metadata:
-                        usage = {
-                            "prompt_tokens": chunk.usage_metadata.prompt_token_count,
-                            "completion_tokens": chunk.usage_metadata.candidates_token_count,
-                        }
+                # The SDK sends the request when the stream is first read, so
+                # a 429 surfaces inside the loop below, not at the call. A busy
+                # refusal is not an empty round: it has its own budget and does
+                # not use up one of those retries.
+                while True:
+                    try:
+                        response_stream = await client.aio.models.generate_content_stream(
+                            model=self.model,
+                            contents=contents,
+                            config=config,
+                        )
+                        async for chunk in response_stream:
+                            if cancel_event and cancel_event.is_set():
+                                yield LLMDone(response=full_response, provider="vertexai", success=True, cancelled=True)
+                                return
+
+                            text = _chunk_text(chunk)
+                            if text:
+                                full_response += text
+                                yield LLMToken(text=text)
+
+                            if chunk.function_calls:
+                                for fc in chunk.function_calls:
+                                    args = {k: v for k, v in fc.args.items()} if fc.args else {}
+                                    yield LLMToolCall(tool=fc.name, params=args)
+                                    tool_calls.append({"tool": fc.name, "params": args})
+
+                            for candidate in (getattr(chunk, "candidates", None) or []):
+                                reason = getattr(candidate, "finish_reason", None)
+                                if reason:
+                                    finish_reasons.append(str(getattr(reason, "name", reason)))
+
+                            if chunk.usage_metadata:
+                                usage = {
+                                    "prompt_tokens": chunk.usage_metadata.prompt_token_count,
+                                    "completion_tokens": chunk.usage_metadata.candidates_token_count,
+                                }
+                        break
+                    except APIError as e:
+                        if full_response or tool_calls or not _busy(e) or busy_tries >= len(_BUSY_BACKOFF):
+                            raise
+                        delay = _BUSY_BACKOFF[busy_tries]
+                        busy_tries += 1
+                        finish_reasons = []
+                        logger.info("Vertex is busy (%s %s); retrying in %ss (%d/%d)",
+                                    getattr(e, "code", ""), getattr(e, "status", ""),
+                                    delay, busy_tries, len(_BUSY_BACKOFF))
+                        if await _wait(delay, cancel_event):
+                            yield LLMDone(response="", provider="vertexai", success=True, cancelled=True)
+                            return
                 if full_response.strip() or tool_calls:
                     break
                 logger.info("Vertex returned an empty round (finish_reason %s), attempt %d",