google/adk-python

This system is the Google Agent Development Kit (ADK), a Python framework for building, managing, and deploying AI agents. It provides core infrastructure for agent lifecycle management, multi-agent orchestration, and secure execution environments, including support for remote sandboxes and code execution. The kit also includes comprehensive tooling for integrating with external services, handling authentication, and evaluating agent performance through structured testing and simulation.

107 changes.

This period marks the GA release of ADK v2.0, characterized by a comprehensive architectural overhaul to support modular, lazy-loaded components and robust authentication. The work focused on introducing new agent planning, memory, and evaluation frameworks while establishing a secure, JSON-based session storage system with migration tools. Extensive test coverage was added to validate the new plugin system, A2A interoperability, and diverse tool integrations.

115 changes.

This period focused on expanding the ADK ecosystem through extensive new integrations, including Agent Registry, A2A protocols, and various cloud services like Firestore, Redis, and GCS. It also introduced a dedicated workflow orchestration module and enhanced agent capabilities with environment simulation, skills, and live streaming support. Comprehensive testing and sample applications were added to validate these new features and demonstrate advanced usage patterns.

The ADK CLI now collects and reports usage metrics to Google's Clearcut service. This change introduces a local telemetry system that queues command execution data, flags, and environment details (OS, Python version, TTY status) to a local JSONL file, grouping commands by parent terminal session with a one-hour inactivity timeout. A background reporter flushes these queued metrics to the production Clearcut endpoint with exponential backoff retries and rate-limit handling.

_src/google/adk/cli/\telemetry · high confidence

Introduces a new sample agent in \contributing/samples/adk\_team/adk\_stale\_agent\ that audits GitHub repositories for stale issues. The agent uses a GraphQL-powered unified history trace to reconstruct issue conversations, including comments, description edits, and timeline events. It employs an LLM to analyze maintainer intent, distinguishing between questions (stale candidates) and status updates (active). The sample includes configuration for thresholds, concurrency, and rate-limiting, along with a main entry point that processes issues in batches and reports failures.

_contributing/samples/adk\_team/adk\_stale\agent · high confidence

Users can now run code and manage files in a persistent remote sandbox via the new DaytonaEnvironment integration. This feature, marked as experimental, provides file CRUD and shell execution capabilities backed by a Daytona sandbox, requiring the daytona extra (pip install google-adk\[daytona\]). The implementation ensures proper resource cleanup by closing the underlying AsyncDaytona client when the environment is closed.

src/google/adk/integrations/daytona · high confidence

Users can now use the E2B integration to run agent workloads in a persistent remote sandbox. This new E2BEnvironment class provides file CRUD, shell execution, and on-demand software installs inside an isolated E2B workspace. The sandbox is created on initialization and killed on close, with a configurable timeout to manage resource usage. If the sandbox expires due to inactivity, the next operation transparently recreates a fresh one, though any installed packages or files will be lost. This feature is currently experimental and requires the e2b extra package.

src/google/adk/integrations/e2b · high confidence

Introduces the \LiveKitRunner\ and \LiveKitToolset\ to bridge an unmodified ADK live agent with LiveKit rooms, enabling WebRTC and SIP/telephony ingress. The runner handles audio/video transport, publishes transcriptions on standard LiveKit channels, and exposes call-specific tools (\end\_call\, \transfer\_call\, \send\_dtmf\) that agents can invoke to manage the conversation. This integration is marked as experimental.

src/google/adk/integrations/livekit · high confidence

A new sample demonstrating how to configure a ManagedAgent for server-side code execution. It shows how to enable the built-in code execution tool by passing the raw \types.Tool(code\_execution=types.ToolCodeExecution())\ configuration in the \tools\ argument, provision a remote sandbox via the \environment\ parameter, and handle multi-turn interactions that reuse the same sandbox.

_contributing/samples/managed\_agent/code\execution · high confidence

A new sample in \contributing/samples/managed\_agent/basic\ demonstrates a \ManagedAgent\ configured with the built-in \google\_search\ tool. This sample illustrates how to provision a remote sandbox for autonomous server-side research loops and how to chain multi-turn conversations by automatically recovering the previous interaction ID from session events.

_contributing/samples/managed\agent/basic · high confidence

Users can now integrate Oracle Cloud Infrastructure (OCI) Generative AI models with the Google ADK by installing the optional \google-adk\[oci\]\ dependency. This new integration introduces the \OCIGenAILlm\ class, which maps ADK model requests to OCI's inference API, supporting multimodal inputs (images, audio, video, documents) via inline data and file URIs, as well as structured output configurations like JSON schemas. The implementation handles the translation of content roles, tool calls, and media blocks to ensure compatibility with OCI's message format.

src/google/adk/integrations/oci · high confidence

Users can now retrieve parameters from Google Cloud Parameter Manager using the new ParameterManagerClient. This client supports authentication via service account JSON keys, pre-existing authorization tokens, or default credentials, and allows specifying a regional location to dynamically resolve the appropriate API endpoint (including mTLS support).

_src/google/adk/integrations/parameter\manager · high confidence

Users can now use Vertex AI Agent Engine Computer Use Sandboxes as the remote browser environment for ADK agents. This new integration in src/google/adk/integrations/vmaas provides the AgentEngineSandboxComputer class, which supports both auto-provisioning of new sandboxes and bringing your own existing sandbox (BYOS). It handles session binding to ensure invocations share a sandbox, manages access token caching and refresh, and allows creation of sandboxes from templates or snapshots for faster startup.

src/google/adk/integrations/vmaas · high confidence

This change introduces a new, handcrafted Pub/Sub toolset (located in src/google/adk/tools/pubsub) that provides three specific tools: publish\_message, pull\_messages, and acknowledge\_messages. Unlike the auto-generated API tools, these are customized to offer better handling of base64 encoding for published messages and a richer subscribe-side API that allows users to pull and acknowledge messages individually. The toolset includes configuration classes for credentials and tool settings, and implements a cached publisher client that keys on options to improve performance while disabling batching for synchronous publishing.

src/google/adk/tools/pubsub · high confidence

Added a new sample demonstrating how to configure a ManagedAgent's system instruction using an InstructionProvider. This sample shows how to dynamically build instructions based on session state (such as response language) and apply a consistent persona and output format across all turns.

_contributing/samples/managed\_agent/system\instruction · high confidence

A new sample in \contributing/samples/managed\_agent/single\_turn\ demonstrates how a local \LlmAgent\ can act as a coordinator for server-backed \ManagedAgent\ specialists. The sample configures two specialists—a search agent using \google\_search\ and a code execution agent—and shows how ADK automatically exposes these single-turn sub-agents as inline tools, allowing the coordinator to call them within a single turn and compose the final answer.

_contributing/samples/managed\_agent/single\turn · high confidence

The browser UI assets now include a new 32x32 color SVG icon for the ADK application and a JavaScript audio processor. The audio processor handles real-time audio input by resampling the browser's native sample rate to the 16 kHz PCM format required by the Live API, using linear interpolation to maintain audio quality.

src/google/adk/cli/browser/assets · high confidence

The Agent Builder Assistant now includes a suite of built-in tools for managing project structure and files. Users can explore project structures and receive path suggestions via \explore\_project\, read and parse YAML configuration files with metadata extraction using \read\_config\_files\, and write validated configurations with schema compliance checks via \write\_config\_files\. File operations are supported through \read\_files\, \write\_files\, and \delete\_files\ (with optional backups), while \cleanup\_unused\_files\ helps identify files not currently in use. Additionally, \search\_adk\_source\ allows regex-based searching of the ADK source code, and \query\_schema\ provides dynamic access to AgentConfig schema details.

_src/google/adk/cli/built\_in\agents/tools · high confidence

The \src/google/adk/agents\ package has been reorganized to support a new agent architecture. The module now uses lazy loading for all public exports (e.g., \LlmAgent\, \ParallelAgent\, \SequentialAgent\) to improve startup performance. New agent types have been introduced, including \ManagedAgent\ for interacting with the Managed Agents API, and configuration classes (\LlmAgentConfig\, \ParallelAgentConfig\, etc.) to support YAML-based agent definitions. The package also includes a new \\_agent\_router\ module to handle multi-agent routing and branch path recovery, and a \StreamingMode\ enum to define streaming behaviors (None, SSE, Bidi). Additionally, the \BaseAgent\ class now explicitly inherits from \abc.ABC\ and includes support for callbacks and state management.

src/google/adk/agents · high confidence

Added a new MongoDB integration module that provides a \MongoDbToolset\ for agents to perform vector and hybrid search against MongoDB Atlas or MongoDB 8.0+ deployments. The toolset exposes \mongodb\_vector\_search\ and \mongodb\_hybrid\_search\ tools, allowing models to query collections using vector similarity and combined full-text/vector ranking. It handles connection management via PyMongo, integrates with Vertex AI for query embedding, and includes configurable settings for limits, timeouts, and index names.

src/google/adk/integrations/mongodb · high confidence

The ADK Labs module now includes an experimental OpenAI integration that supports both the standard Chat Completions API and the new OpenAI Responses API. Users can instantiate \OpenAILlm\ for standard models or \OpenAIResponsesLlm\ (and \AzureOpenAIResponsesLlm\) to access Responses-specific features. The integration allows passing a pre-configured \AsyncOpenAI\ client to support custom base URLs or third-party OpenAI-compatible endpoints, and includes schema enforcement helpers to ensure strict JSON schema compliance for tool definitions.

src/google/adk/labs/openai · high confidence

This change introduces an experimental credential service layer within the ADK authentication module, providing a standardized interface for loading and saving OAuth tool credentials. It includes a base abstract class and two concrete implementations: an in-memory store for temporary testing and a session-state-backed store for persistence across agent invocations. By integrating with the CallbackContext, this service allows tools to automatically persist and retrieve credentials based on the current app and user context, addressing the need for long-lived authentication without manual management.

_src/google/adk/auth/credential\service · high confidence

The repository is initialized with essential configuration files, including a comprehensive .gitignore that excludes Python build artifacts, IDE settings, and AI coding tool configurations (such as .adk/, .claude/, and .cursor/), and a .pre-commit-config.yaml that enforces code formatting, license headers, and compliance checks. The project also includes AGENTS.md to provide context for AI coding assistants, a standard Apache 2.0 LICENSE, and constraints files (constraints-3.10.txt, constraints-3.11.txt) to pin transitive dependencies for Python 3.10 and 3.11, ensuring reproducible builds and protecting against supply chain attacks.

(repo-wide) · high confidence

This change adds a new set of converters in the \src/google/adk/a2a/converters\ module that enable Google ADK agents to communicate using the Agent-to-Agent (A2A) protocol. The implementation includes \request\_converter.py\ to map incoming A2A \RequestContext\ objects into ADK runner arguments, \event\_converter.py\ and \from\_adk\_event.py\ to translate ADK internal events into A2A \TaskStatusUpdateEvent\ and \TaskArtifactUpdateEvent\ structures, and \to\_adk\_event.py\ to convert inbound A2A messages back into ADK events. The \part\_converter.py\ module handles the serialization and deserialization of content parts (text, files, function calls) between the A2A and GenAI formats, while \long\_running\_functions.py\ manages the state and event generation for long-running tool executions. These components are gated behind the \a2a\_experimental\ decorator, indicating the feature is currently experimental.

src/google/adk/a2a/converters · high confidence

Adds a new sample agent in \contributing/samples/adk\_team/adk\_issue\_monitoring\_agent\ that uses the Google Agent Development Kit (ADK) to automatically audit GitHub repository issues for spam, SEO links, and promotional content. The agent pre-filters comments to exclude maintainers and bots, truncates long text, and invokes the Gemini LLM only when necessary to save costs. When spam is detected, it applies a configurable \spam\ label and posts an alert comment for maintainers, while ensuring idempotency to prevent duplicate actions. The sample includes configuration for deep clean or daily sweep modes, concurrency limits, and retry logic for GitHub API calls.

_contributing/samples/adk\_team/adk\_issue\_monitoring\agent · high confidence

Adds a new Python-based sample agent that uses the Google ADK to automatically triage GitHub pull requests. The agent identifies the component owner for a PR and assigns them as the assignee, without applying labels. It supports two modes: an interactive local mode via the ADK web interface (requiring user approval) and an automated GitHub Actions workflow mode. The sample includes the agent logic, configuration settings, and utility functions for interacting with the GitHub API.

_contributing/samples/adk\_team/adk\_pr\_triaging\agent · high confidence

Users can now instantiate an APIHubToolset to automatically generate tools from a specified API Hub resource. This new component fetches API specifications (via OpenAPI/YAML) and exposes them as executable tools, supporting configuration for authentication schemes, service account credentials, and tool filtering. It integrates with the existing ADK toolset interface, allowing agents to interact with APIs managed in Google Cloud's API Hub.

_src/google/adk/tools/apihub\tool · high confidence

A new Agent Builder Assistant is now available in the ADK CLI, providing an intelligent interface to design, configure, and generate YAML-based multi-agent architectures. This assistant helps users define agent structures (such as Sequential, Parallel, and Loop patterns), manage project file organization, and validate configurations against the ADK AgentConfig schema. It includes built-in capabilities for searching ADK documentation and source code, allowing users to quickly prototype and implement complex agent systems directly from the CLI.

_src/google/adk/cli/built\_in\agents · high confidence

Added the Agent Registry client library, enabling users to discover registered agents and MCP servers via search capabilities and automatically resolve their connection details. The integration supports creating ready-to-use ADK components, including RemoteA2aAgent instances with mTLS and authentication handling, as well as McpToolset wrappers that attach destination metadata for telemetry. It also includes strict typing, eager import validation for the a2a-sdk dependency, and credential management for Google API endpoints.

_src/google/adk/integrations/agent\registry · high confidence

Adds the AntigravityAgent, a new ADK node that wraps a pre-configured google.antigravity.Agent, allowing users to run Antigravity SDK agents as native ADK components. The integration bridges ADK sub-agents to the Antigravity SDK as client-side tools, captures tool outcomes for accurate function responses, and translates SDK trajectory steps into ADK events. It also includes a single-turn mode for use as a sub-agent and bypasses Protobuf version checks to ensure compatibility.

src/google/adk/labs/antigravity · high confidence

Added a new CloudRunSandboxCodeExecutor that runs Python code inside a Cloud Run sandbox using the local 'sandbox' CLI tool. This executor enforces a default 300-second timeout to prevent agents from hanging on non-terminating code, disables stateful execution and data file optimization, and filters out harmless network namespace cleanup warnings from stderr.

_src/google/adk/integrations/cloud\run · high confidence

Adds a new ComputerUseToolset that exposes computer-environment controls (click, type, scroll, navigate, wait) as tools for LLM agents. The toolset normalizes coordinates from a virtual 1000x1000 space to the actual screen size, supports optional safety confirmation flows, and validates URLs before navigation to block private or link-local addresses (with an option to allow private network access). It also allows excluding predefined methods from exposure and adapts tools via a provided adapter function.

_src/google/adk/tools/computer\use · high confidence

Adds a new Data Agent toolset that enables users to interact with Gemini Data Analytics agents. The toolset includes read-only capabilities such as listing accessible agents, retrieving agent information, and asking agents questions. It also supports full agent lifecycle management (create, update, delete) when the \enable\_data\_agent\_modification\ configuration flag is set to true. Users can configure the toolset with specific Google Cloud locations, custom API endpoints, and result row limits.

_src/google/adk/tools/data\agent · high confidence

The environment tools are now packaged as an EnvironmentToolset that provides four tools—Execute, ReadFile, EditFile, and WriteFile—along with an injected system instruction that guides tool selection. Output is truncated to a configurable limit (default 30,000 characters), and ReadFile now supports optional start\_line/end\_line parameters with integer validation. EditFile handles cross-platform line breaks and escapes regex characters to ensure reliable surgical replacements.

src/google/adk/tools/environment · high confidence

Adds a new \EventarcToolset\ to the Google ADK that enables agents to publish structured CloudEvents to Google Cloud Eventarc Advanced message buses. The integration includes a generic \publish\_message\ tool for flexible event emission and a \create\_publish\_tool\ method that allows developers to generate domain-specific tools with static or dynamic attribute bindings (including support for runtime context callables and explicit \OMIT\ behavior). The implementation features a thread-safe, TTL-based client cache for the \PublisherAsyncClient\ to optimize resource usage, along with configuration models for credentials and publish timeouts.

src/google/adk/integrations/eventarc · high confidence

This change adds new integration components for Google Cloud Firestore within the ADK integrations module. It introduces \FirestoreSessionService\ to handle session persistence, event storage, and state management (app, user, and session states) using a hierarchical Firestore structure, including logic for locking, compaction, and deterministic event reading. Additionally, it provides \FirestoreMemoryService\ to extract keywords from session events and store them in a dedicated memories collection, enabling keyword-based memory search functionality while filtering out common stop words.

src/google/adk/integrations/firestore · high confidence

Adds a new \GcpAuthProvider\ integration that manages the complete lifecycle of access tokens using the Google Cloud Platform Agent Identity Credentials service. Users can register this provider with the \CredentialManager\ and configure it via \GcpAuthProviderScheme\ to automatically handle credential retrieval, including support for 2-legged and 3-legged OAuth flows with consent polling. The implementation routes requests to either the IAM Connector or Agent Identity services based on the resource name pattern and uses thread-local client caching to ensure thread safety.

_src/google/adk/integrations/agent\identity · high confidence

This change adds the \McpTool\ and \McpToolset\ components to the ADK tools package, enabling agents to interact with external Model Context Protocol (MCP) servers. The implementation includes a new \MCPSessionManager\ for handling connection lifecycles (stdio, SSE, and Streamable HTTP), session pooling, and idle eviction. It introduces experimental authentication support for MCP tool listing and execution, allowing users to configure credentials and custom HTTP headers. The toolset also supports tool filtering, name prefixing, and graceful error handling to prevent transport crashes from crashing the ADK runner. Additionally, it provides a \to\_mcp\_server\ function to expose an ADK agent as an MCP server itself, and includes schema conversion utilities to map ADK tool definitions to MCP formats.

_src/google/adk/tools/mcp\tool · high confidence

The \src/google/adk/optimization\ module now provides a framework for automatically improving agent prompts and instructions. It includes a base \AgentOptimizer\ interface and a \Sampler\ abstraction for evaluating candidate agents. Two concrete optimizers are added: \SimplePromptOptimizer\, which iteratively refines an agent's system prompt using a specified LLM, and \GEPARootAgentOptimizer\ (along with \GEPARootAgentPromptOptimizer\), which integrates with the GEPA library to optimize both core agent instructions and associated skill instructions based on evaluation feedback. The \LocalEvalSampler\ connects this infrastructure to the ADK's \LocalEvalService\, handling evaluation sets, custom metrics, and scoring. Configuration classes allow tuning of models, iteration counts, and evaluation sets.

src/google/adk/optimization · high confidence

The \src/google/adk/apps\ module now provides configuration and implementation for LLM context compaction and agent resumption. Users can enable resumability via \ResumabilityConfig\ to pause and resume invocations, and configure event compaction via \EventsCompactionConfig\ to manage session history size. The \App\ class exposes these configurations alongside the root agent and plugins. Compaction is driven by \EventsCompactionConfig\ triggers (sliding-window or token-threshold) and uses the new \LlmEventSummarizer\ to generate summaries of conversation history, including thoughts and tool calls, while preserving language and tool grounding. The \base\_events\_summarizer\ defines the interface for custom summarizers, and \compaction.py\ handles the logic for identifying valid compaction ranges and estimating token counts.

src/google/adk/apps · high confidence

The \src/google/adk/tools/google\_api\_tool\ module now provides auto-generated toolsets for Google APIs (BigQuery, Calendar, Gmail, YouTube, Slides, Sheets, and Docs) that convert Google Discovery documents to OpenAPI v3 specifications. Users can now interact with these APIs via the \GoogleApiToolset\ and its specific subclasses, which support authentication via OAuth2 client credentials or Google Service Accounts. The toolsets also include support for mutual TLS (mTLS) for secure API communication, allow custom discovery URLs, and enable the injection of additional HTTP headers and OAuth scopes.

_src/google/adk/tools/google\_api\tool · high confidence

A new \src/google/adk/workflow\ package has been added to provide a structured, graph-based workflow engine. This module introduces core components including \Workflow\, \BaseNode\, \FunctionNode\, \JoinNode\, and \Graph\, along with a \DynamicNodeScheduler\ to handle execution, state tracking, and resumption. It also includes a \@node\ decorator for wrapping functions and a \NodeRunner\ for per-node execution, establishing a new foundation for building complex, multi-step agent workflows.

src/google/adk/workflow · high confidence

The \src/google/adk/skills\ module is now available, providing a system to dynamically load agent instructions, resources, and scripts at runtime. This includes data models for skills (Frontmatter, Script, Resources), utility functions to load skills from local directories or Google Cloud Storage (GCS), and a \SkillRegistry\ interface for managing skill discovery. The feature is marked as experimental and subject to change. Additionally, importing \DEFAULT\_SKILL\_SYSTEM\_INSTRUCTION\ from this module is deprecated in favor of importing it from \google.adk.tools.skill\_toolset\.

src/google/adk/skills · high confidence

Adds a new Bigtable toolset under \src/google/adk/tools/bigtable\ that provides an integrated way for AI agents to interact with Google Cloud Bigtable. The toolset includes metadata tools for listing and inspecting instances, tables, and clusters, as well as a query tool for executing parameterized GoogleSQL queries. It introduces a \BigtableParameterizedViewTool\ that securely injects user context (like \user\_id\) into query parameters, restricting access to specific user data without exposing those parameters to the LLM. The feature is marked as experimental and includes configuration for credentials and query result limits.

src/google/adk/tools/bigtable · high confidence

Adds a new experimental Environment Simulation capability that allows users to intercept and mock tool calls during agent execution. This feature introduces an \EnvironmentSimulationFactory\ to create callbacks or plugins, an \EnvironmentSimulationEngine\ to orchestrate simulation logic, and configuration models (\EnvironmentSimulationConfig\, \ToolSimulationConfig\, \InjectionConfig\) to define how tools should be simulated. Users can configure injection rules to introduce specific errors, latency, or custom responses with a given probability, or select mock strategies (such as \MOCK\_STRATEGY\_TOOL\_SPEC\) to generate realistic LLM-based responses. The engine also includes a \ToolConnectionAnalyzer\ that uses an LLM to map stateful dependencies between tools (identifying creating vs. consuming tools) to maintain consistency in generated mock data, and supports providing historical tracing and environment data to improve the realism of the simulation.

_src/google/adk/tools/environment\simulation · high confidence

Adds a new \src/google/adk/tools/spanner\ module providing two experimental toolsets: \SpannerToolset\ for data operations (metadata queries, read-only SQL execution with configurable result modes, similarity search, and vector store similarity search) and \SpannerAdminToolset\ for instance and database administration (listing/creating instances and databases). The tools are gated behind the \experimental\ feature decorator, use a \spanner\ name prefix, and support fine-grained access control via a \database\_role\ setting.

src/google/adk/tools/spanner · high confidence

This change introduces a new, experimental credential exchanger module in the ADK authentication layer. It provides a base interface (BaseCredentialExchanger) and a registry system to manage credential exchange logic, replacing previous ad-hoc implementations. The primary implementation, OAuth2CredentialExchanger, now supports both the Authorization Code and Client Credentials grant types, allowing users to obtain access tokens for these flows. Additionally, the implementation ensures that synchronous OAuth2 token calls are executed off the main event loop to prevent blocking, and it correctly handles the exchange process without exposing the OAuth client secret to the client side.

src/google/adk/auth/exchanger · high confidence

The ADK now includes a centralized feature registry and a set of decorators (\@experimental\, \@stable\, \@working\_in\_progress\) to manage the lifecycle and availability of various capabilities. This system allows developers to explicitly gate features like BigQuery toolsets, Spanner vector stores, and progressive SSE streaming behind feature flags, ensuring that experimental or work-in-progress functionalities are opt-in by default while stable features are enabled automatically. Users can now control which ADK components are active in their applications through this unified configuration mechanism.

src/google/adk/features · high confidence

This change adds a new GCS integration module to the ADK integrations, exposing two distinct toolsets: GCSToolset for storage operations (listing, creating, and deleting objects, plus retrieving object data and metadata) and GCSAdminToolset for bucket administration (listing, creating, updating, and deleting buckets). The integration introduces a GCSCredentialsConfig for managing authentication scopes and a GCSToolSettings model that enforces a configurable local file root to safely confine any local file access used by the tools. The GCSAdminToolset is marked as experimental, and the previous get\_bucket implementation in the storage tool is deprecated in favor of the new admin tool.

src/google/adk/integrations/gcs · high confidence

The new \google.adk.live\ package provides the core infrastructure for live, bidirectional streaming interactions with agents. It introduces \LiveRequest\ and \LiveRequestQueue\ to manage real-time input streams (including audio blobs, content, and activity signals) and integrates audio caching, transcription management, and streaming tool lifecycle handling to support low-latency, multimodal agent execution.

src/google/adk/live · high confidence

The \src/google/adk/models\ package now uses a lazy-loading registry (\LLMRegistry\) to resolve model names (like \gemini-\\, \claude-\\, \gpt-\*\) to their specific LLM implementations only when needed, significantly reducing cold-start import times. This change also introduces an explicit \LlmCapabilities\ system, allowing models to self-report supported features (such as \output\_schema\_and\_tools\) rather than relying on fragile name-based detection, which is now deprecated and emits a warning for legacy behavior.

src/google/adk/models · high confidence

Added a new \google.adk.environment\ module that allows agents to execute shell commands and manage files within a sandboxed working directory. This includes a \BaseEnvironment\ abstract class defining the interface for execution, file reading, and writing, and a \LocalEnvironment\ implementation that runs commands via local subprocesses. The local environment supports configurable timeouts, automatically terminates the entire process tree (including child processes) upon timeout or cancellation to prevent hanging, and manages temporary workspace directories.

src/google/adk/environment · high confidence

The code execution capabilities are now organized under a new \src/google/adk/code\executors\ package, providing a unified \BaseCodeExecutor\ interface and a lazy-loading public API. This update introduces several distinct execution backends: \UnsafeLocalCodeExecutor\ for local Python execution with timeout and \\\main\\_\ support, \ContainerCodeExecutor\ for sandboxed execution via Docker with hardened defaults, \GkeCodeExecutor\ for Kubernetes-based execution in job or sandbox modes, \VertexAiCodeExecutor\ for Vertex AI Code Interpreter integration, \AgentEngineSandboxCodeExecutor\ for Vertex AI Agent Engine sandboxes with automatic provisioning, and \BuiltInCodeExecutor\ to delegate execution to the Gemini model's native tools. The package also includes \CodeExecutorContext\ for managing persistent session state and execution metadata.

_src/google/adk/code\executors · high confidence

The evaluation module now includes a new \LocalEvalService\ and \BaseEvalService\ to run evaluations locally, alongside a new \AgentEvaluator\ that supports custom metrics, rubric-based evaluation, and parallel execution. A new \LlmAudioUserSimulator\ enables audio generation during user simulation, with \\_audio\_utils\ handling PCM resampling for the Live API. The module also introduces new Pydantic data models for \EvalSet\, \EvalCase\, and \AppDetails\, and adds utilities for GCS-based eval set management and path validation.

src/google/adk/evaluation · high confidence

The session service module has been restructured to support lazy loading of backend implementations (InMemory, Database, and Vertex AI) to reduce cold-start overhead, and introduces a new secure mechanism for loading legacy v0 session data. A new restricted pickle loader (\_restricted\_pickle.py) now safely unpickles historical event actions by only allowing a strict allowlist of data types, preventing arbitrary code execution from untrusted payloads. Additionally, the module now includes dedicated utilities for session rewind (\_rewind\_utils.py) and a new SqliteSessionService for lightweight local storage, alongside a migration path to upgrade existing databases to the new JSON-based schema.

src/google/adk/sessions · high confidence

The Agent Development Kit now includes a new planner module in \src/google/adk/planners\ that allows agents to generate structured plans before executing actions. This release adds \PlanReActPlanner\, which guides the LLM to produce a natural language plan, interleave tool usage with reasoning, and return a final answer while stripping internal planning tags (e.g., \/\PLANNING\/\) from the output. It also introduces \BuiltInPlanner\, which leverages the model's native thinking features via a configurable \thinking\config\. These planners are exposed through the \\\init\\_.py\ module alongside a \BasePlanner\ abstract class, enabling users to choose between structured external planning and built-in model capabilities.

src/google/adk/planners · high confidence

Users can now migrate legacy v0 session databases (which used SQLAlchemy with Pickle serialization) to the new v1 JSON-based schema using the \adk migrate session\ CLI command. This change adds a migration framework including a runner (\migration\_runner.py\), schema version detection utilities (\\_schema\_check\_utils.py\), and specific migration scripts (e.g., \migrate\_from\_sqlalchemy\_pickle.py\) that safely deserialize legacy event actions using a restricted unpickler and convert data to the new JSON format. The tooling supports multi-step migrations via temporary SQLite files and ensures database credentials are redacted in logs during the process.

src/google/adk/sessions/migration · high confidence

The ADK now provides a structured artifact service layer that persists and retrieves files (artifacts) scoped to an app, user, and optional session. This change introduces \GcsArtifactService\ for Google Cloud Storage, \FileArtifactService\ for local filesystem storage, and \InMemoryArtifactService\ for testing, all implementing a common \BaseArtifactService\ interface. Artifacts are stored with versioning and metadata (including creation time and MIME type), and access is strictly validated to prevent path traversal and cross-user/app scope leakage. URI parsing and construction utilities ensure artifacts are referenced via scoped \artifact://\ URIs, and the in-memory service includes support for session rewinding via a specific tombstone convention.

src/google/adk/artifacts · high confidence

The \src/google/adk/auth\ module now provides a comprehensive authentication system for the Agent Development Kit. It introduces a \CredentialManager\ to orchestrate the full lifecycle of credentials, including loading, exchanging, and refreshing tokens. The framework supports OAuth2 and OpenID Connect flows, featuring automatic token refresh, PKCE support, and client-credentials grant types. Security is enhanced by redacting secrets from logs and error messages, and by stripping OAuth2 client secrets from data passed to the client. The system also includes an \AuthProviderRegistry\ for pluggable custom authentication providers and an \OAuth2DiscoveryManager\ for auto-discovering authorization and token endpoints via RFC8414 and RFC9728.

src/google/adk/auth · high confidence

The telemetry module has been rebuilt to provide native OpenTelemetry instrumentation, replacing the previous implementation. This change introduces a new schema version (v2) that aligns with OpenTelemetry GenAI semantic conventions, featuring new span names like \invoke\_workflow\ and metrics such as \gen\_ai.invoke\_agent.duration\ and \gen\_ai.invoke\_agent.inference\_calls\. It includes a request-driven metric reader designed for the Vertex AI Agent Engine to ensure metrics are exported without adding latency to requests. Additionally, the module adds support for experimental telemetry features, context cache tracking, and per-feature enabling of experimental metrics.

src/google/adk/telemetry · high confidence

The ADK now ships with several new built-in plugins: ReflectAndRetryModelPlugin and ReflectAndRetryToolPlugin provide self-healing capabilities by automatically reflecting on and retrying model or tool errors; AutoTracingPlugin automatically instruments Python functions with OpenTelemetry spans while redacting sensitive credentials; ContextFilterPlugin reduces LLM context size by filtering out older invocations; and GlobalInstructionPlugin applies application-wide instructions to all agents. These plugins are registered in the plugins module and extend the BasePlugin interface for global agent behavior modification.

src/google/adk/plugins · high confidence

Adds the internal infrastructure for task delegation within the LLM agent runtime. This includes new data models for task requests and results, as well as a \FinishTaskTool\ that allows an agent to signal task completion and validate its output against a defined schema. These components enable the agent framework to handle structured task workflows and result serialization.

src/google/adk/agents/llm · high confidence

The new LangchainTool adapter in the ADK integrations package now honors the \return\_direct\ attribute of wrapped Langchain tools. When a wrapped tool has \return\_direct\ enabled, the ADK will skip result summarization and return the raw output directly to the user, which is useful for tools that produce final answers or require immediate feedback without further model processing.

src/google/adk/integrations/langchain · high confidence

The \src/google/adk/a2a/executor\ module introduces a new \A2aAgentExecutor\ that bridges A2A requests to ADK agents, featuring a configurable interceptor framework (before-agent, after-event, after-agent) and a new implementation (\\_A2aAgentExecutor\) that supports native task modes and includes artifacts from the \artifact\_service\ in A2A events. This location provides the executor logic, configuration (\A2aAgentExecutorConfig\), context management, and a \TaskResultAggregator\ to handle task state transitions, while the \a2a\_experimental\ decorator marks these capabilities as experimental.

src/google/adk/a2a/executor · high confidence

A new request interceptor has been added to the ADK-A2A agent integration to automatically inject the 'new agent version' extension header into outgoing A2A requests. This ensures that client calls include the necessary extension identifier, supporting compatibility with updated A2A protocol versions.

src/google/adk/a2a/agent/interceptors · high confidence

The \contributing/samples/a2a\ directory now includes several new sample applications demonstrating Agent-to-Agent (A2A) patterns in the Agent Development Kit (ADK). The \a2a\_auth\ sample shows how to implement OAuth authentication workflows where a remote BigQuery agent surfaces authentication requests to a local root agent. The \a2a\_state\_forwarding\ sample demonstrates how to forward state between agents. The \a2a\_human\_in\_loop\ sample illustrates human-in-the-loop approval workflows using long-running tools, where a remote approval agent can pause execution and wait for human input via the ADK Web UI. Additionally, \a2a\_basic\ and \a2a\_root\ samples provide foundational examples of local/remote agent delegation and using remote agents as root agents.

contributing/samples/a2a · high confidence

Added new utility modules in \src/google/adk/a2a/utils\ to facilitate the conversion of ADK agents and workflows into A2A-compliant ASGI applications. The \agent\_card\_builder.py\ module introduces an \AgentCardBuilder\ class that automatically generates A2A agent cards by extracting skills, capabilities, and metadata from various agent types (including LLM agents, workflows, and sub-agents). The \agent\_to\_a2a.py\ module provides a \to\_a2a()\ function that wraps an ADK agent or workflow into a Starlette application, supporting features such as custom RPC URLs, path prefixes, persistent task stores, push notification configuration, and custom lifespan events. These utilities enable users to easily expose their ADK agents as A2A services using standard ASGI servers like Uvicorn.

src/google/adk/a2a/utils · high confidence

This change introduces two new sample agents in the \adk\_team\ directory: the ADK Answering Agent and the ADK Issue Formatting Agent. The Answering Agent automates responses to GitHub discussions by analyzing open questions, retrieving context from a Vertex AI Search document store, and posting comments (with optional user approval in interactive mode). It supports interactive, batch, and automated GitHub Actions workflows, and includes a script to upload documentation to the knowledge base. The Issue Formatting Agent validates new and existing issues against bug report and feature request templates, posting comments to request missing information. Both agents are configurable via environment variables, support the Gemini model, and are designed to operate on the \google/adk-python\ repository.

_contributing/samples/adk\_team/adk\_answering\agent · high confidence

The \src/google/adk/cli/utils\ package has been introduced to centralize core CLI capabilities. It includes an \AgentLoader\ and \NestedAgentLoader\ to discover and load agents from various directory structures (including nested paths), and an \AgentChangeEventHandler\ to enable hot-reloading of agents when source files change. The package also adds a \DotAdkFolder\ manager and \local\_storage\ utilities to handle per-agent session and artifact persistence in a \.adk\ directory, while \gcp\_utils\ and \\_onboarding\ provide the Express Mode authentication flow and Google Cloud project configuration. Additional helpers cover graph serialization/visualization for the web UI, environment variable loading with \.env\ precedence, and GCS-based evaluation storage.

src/google/adk/cli/utils · high confidence

A new sample agent has been added to the ADK team samples that integrates with Vertex AI Search to retrieve documentation and knowledge base entries. The agent requires the VERTEXAI\_DATASTORE\_ID environment variable to initialize the search tool and includes a callback that appends source citations (title, URI, and snippet) to the model's response for transparency.

_contributing/samples/adk\_team/adk\_knowledge\agent · high confidence

This change introduces a new set of sample agents in the \contributing/samples/adk\_team/adk\_documentation\ directory to automate documentation maintenance. The \adk\_docs\_updater\ agent processes specific documentation issues to create pull requests for doc updates based on code changes. The \adk\_release\_analyzer\ agent compares two ADK Python releases to identify documentation gaps and automatically generates GitHub issues with update instructions, utilizing a multi-agent architecture (Planner, Loop, Summary) and the \gemini-3.1-pro-preview\ model for complex analysis. Both agents include strict path confinement to ensure file operations are restricted to a managed local repository directory, preventing access to arbitrary system paths. Additionally, a \adk\_pr\_agent\ sample is provided to demonstrate generating pull request descriptions from PR metadata.

_contributing/samples/adk\_team/adk\documentation · high confidence

Added a family of single-concept samples in \contributing/samples/evaluation\ that evaluate a shared \home\_automation\_agent\ using the \adk eval\ CLI. The samples demonstrate deterministic reference-based scoring (\basic\_criteria\), \.test.json\ vs \.evalset.json\ conventions (\test\_file\_vs\_evalset\), custom metrics (\custom\_metric\ with a \temperature\_safety\_score\ example), LLM-judged semantic matching (\llm\_judge\_match\), rubric-based quality scoring (\rubric\_criteria\), and dynamic user simulation (\user\_simulation\). Each sample isolates eval data and criteria configuration to show how to compare evaluation techniques side by side.

contributing/samples/evaluation · high confidence

Added the ApplicationIntegrationToolset and IntegrationConnectorTool classes, enabling agents to interact with Google Cloud Application Integration resources and Integration Connector connections. The toolset automatically generates tools from OpenAPI specifications for integrations or entity operations/actions for connections, handling authentication via service accounts or dynamic OAuth flows. Users can now expose specific triggers or entity operations as callable tools within their agents.

_src/google/adk/tools/application\_integration\tool · high confidence

Users can now wrap and use CrewAI tools within the Google ADK framework via the new \CrewaiTool\ class. This integration handles argument validation and type coercion by leveraging CrewAI's Pydantic-based \args\_schema\, ensuring that function arguments are correctly preprocessed and validated before execution. The tool automatically sanitizes names (replacing spaces with underscores) and manages context injection, allowing seamless interoperability between CrewAI's tool definitions and ADK's execution engine.

src/google/adk/integrations/crewai · high confidence

Users can now register and retrieve skills from the GCP Agent Registry API via the new GCPSkillRegistry class. This integration handles authentication (including mTLS support), validates skill names against expected patterns, and constructs API requests to the agentregistry/skill endpoint.

_src/google/adk/integrations/skill\registry · high confidence

This update introduces a suite of new samples in the \contributing/samples\ directory to demonstrate key ADK capabilities. The \hitl\ area now includes examples for long-running tools (with manual approval simulation), proactive user clarification via the \request\_input\ tool, and tool confirmation flows (both manual and automatic via \FunctionTool\). Additionally, new \config\ samples provide reference implementations for basic agent configuration, callback wiring (agent, model, and tool hooks), custom agent classes, and \generate\_content\ settings like temperature and thinking config.

contributing/samples/hitl · high confidence

A new integration plugin has been added to screen both user prompts and model responses using Google Cloud Model Armor. Users can configure specific template names for input and output screening, set custom blocked messages, and control whether requests are blocked on screening failures. The plugin integrates with the agent's callback system to sanitize content in both unary and live execution modes.

_src/google/adk/integrations/model\armor · high confidence

The \src/google/adk/a2a/agent\ module now provides a new implementation of \RemoteA2aAgent\ that supports per-invocation authentication headers via \CardRequestInterceptor\ and \RequestInterceptor\ hooks, allowing dynamic injection of credentials during agent card resolution and message requests. It also introduces a \forward\_session\_id\_as\_context\id\ configuration option to map local session IDs to the remote agent's context, and includes a robust \\\deepcopy\\_\ method to prevent serialization errors when cloning agent configurations.

src/google/adk/a2a/agent · high confidence

A new \SecretManagerClient\ is now available in the \google.adk.integrations.secret\_manager\ package, providing a simplified interface for retrieving secrets from Google Cloud Secret Manager. This client supports authentication via service account JSON keys, pre-existing authorization tokens, or Application Default Credentials, and introduces support for regional endpoints (including mTLS) when a specific location is provided. It also identifies itself with a \google-adk\ user agent string.

_src/google/adk/integrations/secret\manager · high confidence

Users can now deploy ADK agents on Slack using the new \SlackRunner\ class. This integration supports Socket Mode and automatically manages conversation sessions based on channel IDs and thread timestamps, allowing agents to respond to app mentions, direct messages, and threaded conversations.

src/google/adk/integrations/slack · high confidence

This update adds several new sample agents to the contributing/samples/models directory, including an Azure OpenAI Responses sample that demonstrates streaming partial function-call arguments, and hello-world samples for Anthropic, Apigee LLM, Gemma, Gemma3 Ollama, and LiteLLM. The Apigee LLM sample introduces a flexible model string format (apigee/\[provider\]/\[version\]/model\_id) to dynamically target different backend providers and API versions. Additionally, the existing hello\_world\_anthropic sample has been updated to use the new Claude model identifier (claude-3-5-sonnet-v2@20241022).

contributing/samples/models · high confidence

The contributing/samples/tools directory now includes several new demonstration agents and fixes to existing ones. New samples cover agent tool grounding metadata, combining built-in multi-tools (Google Search and Vertex AI Search) with workarounds for model limitations, streaming function call arguments, long-running asynchronous functions, and parallel function execution with thread-safe state management. Additionally, a sample demonstrates using structured output schemas alongside other tools, and existing samples have been repaired to ensure they run correctly.

contributing/samples/tools · high confidence

The evaluation framework now includes a new \simulation\ sub-package that introduces \LlmAudioUserSimulator\, allowing evaluation scenarios to generate user messages with synthesized audio (via Google Cloud TTS or other audio models) alongside text. This simulator supports configurable voice personas, audio encoding, and options to include or exclude text in the final user content. The package also adds \LlmBackedUserSimulator\ with support for custom instructions and function call history, pre-built user personas with specific behavioral traits, and a \PerTurnUserSimulatorQualityV1\ evaluator to assess simulation fidelity against conversation plans and personas.

src/google/adk/evaluation/simulation · high confidence

Added \ConnectionsClient\ and \IntegrationClient\ classes to handle API interactions for Google Cloud Connectors and Application Integration respectively. The \ConnectionsClient\ manages connection details, entity schemas, and action schemas, while the \IntegrationClient\ generates OpenAPI specifications for integrations and connections, supporting dynamic endpoint resolution and credential handling.

_src/google/adk/tools/application\_integration\tool/clients · high confidence

This update adds a suite of new samples to the contributing directory. The code\_execution samples demonstrate various ways to execute code within agents, including using the Agent Engine Sandbox, the built-in executor, a GKE-based sandbox, and a custom executor that injects Japanese font support for matplotlib. The MCP samples showcase integration with the Model Context Protocol, featuring agents that connect to MCP servers via SSE and stdio, support dynamic per-request headers, and interact with PostgreSQL databases.

contributing/samples/mcp · high confidence

Added two new ADK CLI plugins to support conformance testing: a recording plugin that captures LLM request/response pairs and tool call/result data into YAML files, and a replay plugin that replays these recorded interactions to verify agent behavior. The recording plugin uses the new CallbackContext to intercept callbacks and store state per invocation, while the replay plugin loads these recordings and returns pre-recorded responses instead of executing live tool calls or LLM requests. These plugins enable deterministic testing of agent interactions by allowing tests to record real interactions and then replay them for verification.

src/google/adk/cli/conformance, src/google/adk/cli/plugins · high confidence

This update adds four new samples to the \contributing/samples/context\_management\ directory to demonstrate advanced context handling. The \cache\_analysis\ sample provides a research assistant agent and an experiment script to benchmark explicit ADK context caching against implicit model caching, tracking metrics like \cached\_content\_token\_count\. The \history\_management\ sample shows how to use a \before\_model\_callback\ to slice the conversation history, keeping only the most recent turns in the context window. The \memory\ sample demonstrates using \load\_memory\_tool\ and \preload\_memory\_tool\ to persist and retrieve user state across separate sessions. Finally, the \migrate\_session\_db\ sample includes a recipe and a v1.15.0 SQLite database to demonstrate how to use the \adk migrate session\ command to upgrade legacy session schemas to the current version.

_contributing/samples/context\management · high confidence

Added several new demonstration samples in the core directory: an abort sample showing how agent execution halts immediately when a client disconnects; an app sample demonstrating application-level configuration including plugins, event compaction, and context caching; an artifacts sample for saving and loading media (images, audio, video) and text reports; a callbacks sample illustrating how to intercept and modify tool calls and LLM responses; an empty agent template; and an updated hello world sample with dice rolling and prime checking.

contributing/samples/core · high confidence

The session storage backend now introduces a new v1 database schema that replaces the legacy v0 schema. This change brings several key improvements for users relying on database-backed sessions: event data is now stored using JSON serialization instead of pickle, enhancing security by restricting unpickling of legacy data and preventing potential injection vulnerabilities. Timestamps are handled with microsecond precision across all supported databases (including SQL Server and MySQL), ensuring accurate optimistic concurrency checks and preventing false 'stale session' rejections. Additionally, the new schema includes proper foreign key constraints with cascade deletes for events, deterministic event ordering, and UTC-based timestamp storage to avoid timezone-related inconsistencies.

src/google/adk/sessions/schemas · high confidence

The repository now includes a suite of new scripts in the \scripts/\ directory to enforce code quality, manage dependencies, and streamline releases. \check\_new\_py\_files.py\ and \compliance\_checks.py\ act as pre-commit and CI gates, enforcing private-by-default naming for new Python files, requiring unit guides, checking for internal links, and validating FastAPI decorator order. Dependency management is handled by \update\constraints.sh\, which generates and validates \constraints-\.txt\ files using \uv\ to protect against supply chain attacks. Release workflows are supported by \curate\_changelog.py\ for drafting changelog highlights, \db\_migration.sh\ for upgrading session databases via Alembic, \generate\_agent\_config\_schema.py\ for producing JSON schemas, and \verify\_release\_artifact.py\ to ensure new wheels do not regress importability compared to the previous release.

scripts · high confidence

The Agent Development Kit now includes a structured system for managing few-shot examples in prompts. This change introduces an \Example\ data model and a \BaseExampleProvider\ interface, allowing users to define custom example sources. A concrete \VertexAiExampleStore\ implementation is provided to retrieve relevant examples from Vertex AI's example store based on user queries. Additionally, utility functions are added to convert these examples into formatted text strings suitable for system instructions, handling various content types including text, function calls, and function responses.

src/google/adk/examples · high confidence

This update adds several new sample agents in the \contributing/samples/integrations\ directory to demonstrate advanced integration patterns. The \agent\_registry\_agent\ sample shows how to discover and use agents and MCP servers registered in Google Cloud via the \AgentRegistry\ client. The \antigravity\_agent\ samples demonstrate wrapping the Google Antigravity SDK as an ADK agent, covering standalone usage, use as an ADK sub-agent, and integration into an ADK \Workflow\ with an \LlmAgent\ planner node. Additionally, the \api\_registry\_agent\ sample illustrates using \AgentRegistry\ to access BigQuery tools via an MCP server, and the \application\_integration\_agent\ sample shows how to interact with external applications like Jira using the \ApplicationIntegrationToolset\.

contributing/samples/integrations · high confidence

Added several new sample applications to the \contributing/samples\ directory to demonstrate various agent patterns. The \legacy\_workflows\ directory includes examples of sequential agent pipelines, such as a non-LLM sequential agent, a simple sequential agent with dice rolling and prime checking, and a code review pipeline using a Writer-Reviewer-Refactorer sequence. The \patterns\ directory introduces samples for context offloading with artifacts (using a sales assistant to manage large data), a fields planner with built-in planning, JSON passing between agents (a pizza ordering workflow), and a workflow triage system that dynamically selects and executes specialized code or math agents in parallel.

_contributing/samples/legacy\workflows, contributing/samples/patterns · high confidence

Added a suite of new samples in \contributing/samples/live\ demonstrating live bidirectional streaming capabilities with the ADK. These include a single-agent example with dice rolling and prime checking, a multi-agent setup for delegating tasks, a parallel tools agent, a non-blocking tool agent for background tasks, a streaming tools agent for continuous monitoring (stock prices, video streams), and a tool callbacks agent for auditing and security checks. The samples also include an API server example for direct WebSocket interaction and debug utilities for audio playback.

contributing/samples/live · high confidence

The OpenAPI tool now uses a dedicated credential exchange subsystem to handle authentication. This introduces an \AutoAuthCredentialExchanger\ that automatically routes requests to specific exchangers based on the auth scheme: \OAuth2CredentialExchanger\ for OAuth2 and OpenID Connect (including automatic refresh of expired tokens), and \ServiceAccountCredentialExchanger\ for Google Service Accounts (supporting both access tokens and ID tokens for service-to-service auth like Cloud Run). This modular approach replaces previous inline logic, providing cleaner handling of bearer token generation, token expiration checks, and service account credential fetching.

_src/google/adk/tools/openapi\_tool/auth/credential\exchangers · high confidence

This update adds several new samples to the multi-agent directory, introducing new ways to structure agent workflows. The \hello\_world\_ma\ and \multi\_agent\_llm\_config\ samples demonstrate a 'DicePrimeBot' that delegates tasks to specialized sub-agents for rolling dice and checking prime numbers, with the latter showing how to define these agents via YAML configuration files. A new \single\_turn\_sub\_agent\ sample illustrates the recommended pattern for using \single\_turn\ mode agents to perform autonomous, structured tasks (like phone recommendations) without direct user interaction, preserving internal tool calls in session history. Additionally, \multi\_agent\_basic\_config\ provides a YAML-based example of a learning assistant delegating to code and math tutors, while \multi\_agent\_loop\_config\ and \multi\_agent\_seq\_config\ showcase iterative refinement loops and sequential code-writing pipelines using \LoopAgent\ and \SequentialAgent\ respectively.

_contributing/samples/multi\agent · high confidence

Added four new sample agents in the contributing/samples/multimodal directory to demonstrate advanced capabilities: a Computer Use Agent that automates browser tasks via Playwright and the ComputerUseToolset using the gemini-2.5-computer-use-preview model; an Image Generation Agent that creates images using the imagen-3.0-generate-002 model and manages artifacts; a basic Multimodal Agent using gemini-2.5-flash-image for direct text-and-image interaction; and a Static Non-Text Content Agent that processes mixed static instructions containing inline images and document references (via Gemini Files API or Vertex AI GCS/HTTPS URIs).

contributing/samples/multimodal · high confidence

Added two new sample plugins under \contributing/samples/plugins/\. The \plugin\_basic\ sample demonstrates a \CountInvocationPlugin\ that tracks and prints agent, tool, and LLM request counts using lifecycle callbacks. The \plugin\_reflect\_tool\_retry\ sample introduces a \ReflectAndRetryToolPlugin\ (with a \CustomRetryPlugin\ variant) that provides self-healing, concurrent-safe error recovery for tool failures, including handling hallucinated tool names and non-exception error responses.

_contributing/samples/plugins/plugin\_basic, contributing/samples/plugins/plugin\_reflect\_tool\retry · high confidence

The ADK now includes a new retrieval module providing three tools: FilesRetrieval (using LlamaIndex to index local files), LlamaIndexRetrieval (generic LlamaIndex integration), and VertexAiRagRetrieval (integrating with Vertex AI RAG). FilesRetrieval allows users to specify a custom embedding model, defaulting to gemini-embedding-2-preview. All retrieval tools are lazily loaded to avoid blocking the event loop and to prompt users to install optional extensions if dependencies are missing. Additionally, when the JSON\_SCHEMA\_FOR\_FUNC\_DECL feature is enabled, these tools use JSON schema for their function declarations, and they return a 'no match' message instead of raising an error when no results are found.

src/google/adk/tools/retrieval · high confidence

A new sample application has been added to the contributing samples directory that demonstrates how to use the DebugLoggingPlugin. This sample configures an LLM agent with weather and calculation tools, and enables the plugin to capture detailed debug information—including LLM requests, responses, tool calls, and session state—into a YAML file for debugging purposes.

_contributing/samples/plugins/plugin\_debug\logging · high confidence

Added a new sample in \contributing/samples/managed\_agent/remote\_mcp\ that shows how to wire a \ManagedAgent\ to a remote MCP server (specifically Google Maps Grounding Lite) for server-side tool execution. This sample highlights the use of \RemoteMcpServer\ with a \header\_provider\ callback to handle runtime authentication (e.g., API keys) without the client directly connecting to the MCP server, contrasting with client-side \McpToolset\ usage.

_contributing/samples/managed\_agent/remote\mcp · high confidence

Added a new sample in \contributing/samples/managed\_agent/custom\_agent\ that demonstrates the full lifecycle of a custom managed agent resource. This sample shows how to provision a persistent, named agent with a specific persona and server-side tools (like Google Search) using the GEAP/Vertex backend, drive interactions with it via \adk run\ or \adk web\, and finally delete the resource. It serves as a concrete example for users who need reusable, server-managed agents rather than inline configurations.

_contributing/samples/managed\_agent/custom\agent · high confidence

This location adds sample agents demonstrating how to execute code and skills in isolated remote sandboxes using \E2BEnvironment\ and \DaytonaEnvironment\, alongside local execution via \LocalEnvironment\. The samples show how to wire these environments with \EnvironmentToolset\ for general command execution and with \SkillToolset\ for directory-loaded skills, providing concrete patterns for safe, remote code execution and dynamic skill loading.

_contributing/samples/environment\_and\skills · high confidence

Added the \adk-verify-snippets\ skill, which extracts Python code blocks from Markdown files, executes them in isolated subprocesses, and generates a pass/fail report including load status, run status, and optional code coverage. The skill handles ADK components (Workflows, Agents, Apps) by running them against the Gemini API when a key is provided, classifies snippets as runnable, load-only, or skipped (via \\<!-- verify-snippets: ignore --\>\ annotations), and enforces a 120-second timeout per snippet. It is designed for validating documentation samples without modifying source files.

.agents/skills/adk-verify-snippets · high confidence

Added new samples in \contributing/samples/workflows\ demonstrating how to embed agents as workflow nodes (including task and single-turn modes with retry routing), configure API key and OAuth2 authentication on function nodes, and implement dynamic fan-out/fan-in patterns using \ctx.run\_node()\. These samples provide concrete examples of workflow graph construction, credential handling, and parallel task scheduling.

contributing/samples/workflows · high confidence

The platform module now provides a set of abstracted services for random number generation, time retrieval, UUID creation, and thread creation. These components allow the runtime to inject platform-specific implementations (e.g., for deterministic testing or specialized environments) via context variables, while defaulting to standard library behaviors. This enables more robust and testable workflows by decoupling core logic from system-specific primitives.

src/google/adk/platform · high confidence

A new Redis integration for the Google Agent Development Kit (ADK) enables persistent session storage, allowing agent sessions, conversation events, and state to be stored and retrieved via Redis. The \RedisSessionService\ supports automatic scoping of app, user, and session state, configurable time-to-live (TTL) for expiring stale sessions, and flexible connection options including URI, individual parameters, or pre-configured clients. Users can now manage sessions (create, retrieve, list, delete) with filtered event histories and benefit from automatic merging of state deltas across turns.

src/google/adk/integrations/redis · high confidence

Added sample files in the contributing/samples directory demonstrating how to register custom memory services with the ADK CLI. The new dummy\_services.py provides two dummy memory service implementations (FooMemoryService and BarMemoryService) for testing purposes. The services.py file shows how to register a Python-based service factory (FooMemoryService) with the service registry using the 'foo' scheme. The services.yaml file demonstrates YAML-based registration for the BarMemoryService using the 'bar' scheme. These samples illustrate the two supported methods for custom service registration: Python factory functions and YAML configuration files.

contributing/samples · high confidence

Added utility functions in src/google/adk/a2a/logs/log\_utils.py to generate structured, human-readable logs for A2A (Agent-to-Agent) requests and responses. This new logging capability formats message parts, metadata, and task status details for better debugging. Crucially, the implementation ensures that raw file bytes are excluded from log output to prevent sensitive data leakage or log bloat, while still providing summaries for text and data parts.

src/google/adk/a2a/logs · high confidence

The Agent Builder Assistant now enforces strict path boundaries when handling file operations. New utility functions in the built-in agents utils module sanitize generated file paths to remove stray quotes and whitespace, and resolve them against a defined root directory. If a requested path attempts to escape this root (e.g., via \..\ traversal or absolute paths pointing outside), the system raises an error, preventing unauthorized access to files outside the allowed workspace.

_src/google/adk/cli/built\_in\agents/utils · high confidence

The ADK triaging agent sample has been updated to treat content from GitHub as untrusted, addressing a security concern in how the agent processes external data. This change ensures that the agent's interaction with GitHub issues and labels follows safer handling practices for external inputs.

_contributing/samples/adk\_team/adk\_triaging\agent · high confidence

The ADK CLI has been reorganized from a flat structure into a proper Python package under \src/google/adk/cli\. The main entry point is now lazy-loaded via \src/google/adk/cli/\_\init\\.py\ to improve startup performance, and the command-line interface is explicitly exposed through \src/google/adk/cli/\\main\\_.py\. This change introduces a modular architecture with dedicated modules for specific functionalities, including \api\_server.py\ for production endpoints, \dev\_server.py\ for development, \cli\_deploy.py\ for deployment commands, \cli\_eval.py\ for evaluation workflows, and \cli\_create.py\ for project scaffolding. Additionally, \adk\_web\_server.py\ now wraps \DevServer\ with a deprecation warning to guide users toward the new API server structure.

src/google/adk/cli · high confidence

The \src/google/adk/flows\ package has been reorganized to improve modularity. Core logic for LLM flows, including live execution, prompt assembly, tool handling, and context processing, has been relocated into the \flows/llm\_flows\ subpackage. To maintain compatibility with existing code, the original module locations now serve as backward-compatibility shims that re-export the symbols from their new homes. Additionally, several components, such as \AudioCacheManager\ and \AudioTranscriber\, have been moved to the \google.adk.live\ package and are now deprecated in the flows module, with users advised to import them from the new location.

src/google/adk/flows · high confidence

The \src/google/adk/utils\ package has been introduced to centralize shared infrastructure code previously scattered across the framework. This new location provides foundational utilities for callable introspection and specification (\\_callable\_utils\), a robust callback pipeline with argument adaptation (\\_callback\_pipeline\), and client-side tracking headers for API usage (\\_client\_labels\_utils\, \\_google\_client\_headers\). It also includes helpers for safe JSON parsing (\\_json\_utils\), lazy module loading for performance (\\_lazy\), mutual TLS (mTLS) endpoint resolution and session configuration (\\_mtls\_utils\), and telemetry consent management (\\_telemetry\_config\). Additionally, it introduces a \CachePerformanceAnalyzer\ for monitoring context caching efficiency, an \AgentInfo\ model for exposing agent metadata, and debug output formatting tools (\\_debug\_output\), all serving as the internal backbone for the ADK's agent execution and tool-calling systems.

src/google/adk/utils · high confidence

The API Hub client in the Agent Development Kit has been updated to use mutual TLS (mTLS) with client certificates for API Hub calls, improving security and connectivity reliability. Additionally, a fix ensures that impersonated credentials are correctly acquired, resolving previous issues where authentication might fail. The client also includes stricter validation for JSON responses from the API Hub service.

_src/google/adk/tools/apihub\tool/clients · high confidence

The BigQuery tools have been moved from \tools/bigquery\ to \integrations/bigquery\ to align with the standard ADK directory structure. This update introduces \BigQueryToolConfig\, allowing users to set \default\_project\_id\ and \default\_dataset\_id\ so the model no longer needs to ask for these values at the start of every conversation. It also adds a \compute\_project\_id\ guardrail to restrict query execution to a specific project, and implements SQL injection protections by validating table/column identifiers and escaping string literals. Additionally, the integration now supports hyphenated column names and lazy-loads the optional Dataplex dependency to prevent import failures when catalog search is not used.

src/google/adk/integrations/bigquery · high confidence

The BigQuery tools located in \src/google/adk/tools/bigquery\ are now deprecated and emit a \DeprecationWarning\ when imported. All public classes and functions (such as \BigQueryToolset\, \BigQueryCredentialsConfig\, and \get\_bigquery\_skill\) are now forwarded to the new \google.adk.integrations.bigquery\ module. Users should update their imports to use the \integrations\ path to avoid deprecation warnings and ensure future compatibility.

src/google/adk/tools/bigquery · high confidence

ADK now routes imports for the MCP SDK, HTTP client, Vertex AI, and ROUGE scorer through a dedicated \dependencies\ package. This change allows the application to support both MCP SDK 1.x and 2.x simultaneously by automatically selecting the correct HTTP library (\httpx\ or \httpx2\) and handling API renames (such as \FastMCP\ to \MCPServer\) at the import layer, ensuring compatibility without requiring changes to downstream code.

src/google/adk/dependencies · high confidence

The ApiRegistry integration in src/google/adk/integrations/api\_registry is now deprecated in favor of AgentRegistry, emitting a DeprecationWarning upon import or instantiation. Additionally, the registry now supports mutual TLS (mTLS) for API requests, allowing users to configure secure connections via the GOOGLE\_API\_USE\_MTLS\_ENDPOINT environment variable and client certificates.

_src/google/adk/integrations/api\registry · high confidence

The \agent\_simulator\ module has been renamed to \environment\_simulation\. All imports from \google.adk.tools.agent\_simulator\ (including \AgentSimulatorFactory\, \AgentSimulatorConfig\, \AgentSimulatorEngine\, and related strategies) now emit deprecation warnings and forward to the new \google.adk.tools.environment\_simulation\ package. Additionally, \AgentSimulatorConfig\ now accepts a \tracing\ parameter instead of the deprecated \tracing\_path\. Users should update their imports to use the new \environment\_simulation\ names.

_src/google/adk/tools/agent\simulator · high confidence

The OpenAPI tool now generates more robust Python signatures by defaulting the 'required' field to False for parameters and ensuring that request bodies without explicit names are correctly named 'body'. Additionally, the parser now handles non-numeric OpenAPI response keys in return documentation and prefers 'application/json' for return type docs, resolving issues with Gemini schema generation and parameter descriptions.

_src/google/adk/tools/openapi\tool/common · high confidence

The A2A integration now includes a compatibility layer (\_compat.py) that supports both a2a-sdk 0.3.x and 1.x, allowing the library to function regardless of which SDK version is installed. Additionally, A2A-specific features are marked as experimental with a customizable warning message, which users can suppress by setting the ADK\_SUPPRESS\_A2A\_EXPERIMENTAL\_FEATURE\_WARNINGS environment variable.

src/google/adk/a2a · high confidence

The ADK session event system has been restructured to support durable runtime features, including session rewinding and dynamic execution branches. Users can now rewind a session to a previous state, with the framework ensuring that rewound invocations are correctly excluded from event compaction and LLM context building. The event model now tracks hierarchical node paths and execution branches, enabling better isolation and state management in complex workflows. Additionally, the event actions model supports tool confirmation flows, UI widget rendering metadata, and more resilient serialization for agent state and session state deltas.

src/google/adk/events · high confidence

The memory subsystem has been restructured to support lazy loading of service implementations (InMemoryMemoryService, VertexAiMemoryBankService, and VertexAiRagMemoryService) to reduce cold start times. A new MemoryEntry schema now includes id and custom\_metadata fields, and the base service interface exposes add\_events\_to\_memory for incremental event ingestion. The in-memory service now uses Unicode-aware keyword extraction to correctly match Latin words embedded in non-Latin text (e.g., Japanese or Chinese) and is thread-safe for concurrent access.

src/google/adk/memory · high confidence

The authentication module has been restructured to introduce a dedicated credential refresher system. This change adds a base interface (BaseCredentialRefresher) and a registry (CredentialRefresherRegistry) to manage credential refresh logic by type. Specifically, it implements an OAuth2CredentialRefresher that checks token expiration and performs refreshes. A key behavioral improvement is that synchronous OAuth2 token refresh calls are now executed off the main event loop using asyncio.to\_thread, preventing potential blocking issues. The implementation also correctly handles missing authlib dependencies and logs errors without crashing, returning the stale credential on failure to allow subsequent retries.

src/google/adk/auth/refresher · high confidence

The errors module now exposes specific exception classes to improve error handling clarity: StaleSessionError (for optimistic concurrency failures), SessionNotFoundError (when a session is missing), AlreadyExistsError (for duplicate resource creation), InputValidationError (for invalid user input), NotFoundError (for missing entities), and ToolExecutionError (which includes an optional semantic error type for OpenTelemetry tracing). These changes allow applications to catch and handle distinct failure modes more precisely rather than relying on generic exceptions.

src/google/adk/errors · high confidence

The OpenAPI tooling has been restructured into a dedicated \openapi\_spec\_parser\ module, introducing a new \OpenApiSpecParser\ that sanitizes schema types for Pydantic compatibility and supports preserving original property names. The \OpenAPIToolset\ now exposes configuration options for SSL verification, custom headers, and a pluggable \httpx\_client\_factory\ for advanced HTTP client control. Authentication is significantly improved with a new \ToolAuthHandler\ that automatically refreshes OAuth2 credentials, handles 401 errors with bounded retry logic, and ensures stable credential key generation to prevent cross-user leaks.

_src/google/adk/tools/openapi\_tool/openapi\_spec\parser · high confidence

The OpenAPI tool's authentication helpers have been updated to correctly support Google Service Account credentials by exposing an OAuth2 client-credentials security scheme. Previously, the tool may have failed to automatically exchange service account credentials for access tokens because it did not recognize the flow; this change ensures the credential manager identifies the client-credentials flow and properly handles the token exchange, while also adding support for basic authentication.

_src/google/adk/tools/openapi\tool/auth · high confidence

The \google.adk.tools\ package now uses lazy loading for all tool imports to reduce cold-start overhead, exposing a unified public API via \\_\init\\_.py\. Internally, function tool declarations have been refactored to leverage Pydantic's \create\_model\ and \model\_json\_schema\ capabilities, replacing manual type parsing. This change introduces new utility modules for handling JSON schema sanitization (including specific fixes for Vertex AI \anyOf\ schemas and Gemini enum constraints), automatic function calling parameter parsing, and artifact service forwarding, ensuring more robust and consistent tool schema generation across different LLM backends.

src/google/adk/tools · high confidence

The CLI's embedded browser now serves updated compiled assets from the adk-web project, including new JavaScript chunks that incorporate KaTeX for math rendering and RxJS for reactive state management. Additionally, a new \adk\_favicon.svg\ file has been added to provide a branded icon for the browser window.

src/google/adk/cli/browser · high confidence

A new shared component-owner map has been introduced in the \contributing/samples/adk\_team\ directory to serve as the single source of truth for issue and pull request triaging. This \component\_owners.py\ file defines a mapping of component labels to their respective GitHub owners and is imported by both the \adk\_triaging\_agent\ (for issues) and \adk\_pr\_triaging\_agent\ (for PRs), ensuring that both agents use identical ownership data and preventing drift between the two triaging workflows.

_contributing/samples/adk\team · high confidence

This update introduces several fixes and optimizations to the workflow engine to improve stability and performance. It resolves issues where workflow nodes would incorrectly replay as complete instead of rerunning on resume, and fixes a crash when rehydrating raw Content outputs. The engine now correctly scopes replay sequences to the current invocation and prevents replay divergence hangs in sequence barriers. Additionally, performance is enhanced by optimizing event rehydration with indexing to avoid O(n^2) deep comparisons, and by ensuring jittered retry delays remain within configured maximums. Security is improved by stopping the OAuth client secret from being sent to the client or included in credential request events.

src/google/adk/workflow/utils · high confidence

Added integration test fixtures for agent evaluation scenarios; Added integration tests for A2A client-server interactions; Added integration tests for GCP Agent Identity authentication flows; Added integration tests for Gemma, Gemini, and LiteLLM model backends; Added integration tests for OCI Generative AI LLM provider; Added microbenchmark for LLM request content building; Added remote integration tests for Pub/Sub and Eventarc trigger endpoints; Added telemetry functional test suite and golden-record infrastructure; Added test package initialization files; Added tests for Model Armor guardrail plugin configuration and behavior; Added unit tests for A2A event, part, and request converters; Added unit tests for A2A log formatting utilities; Added unit tests for A2A utility functions; Added unit tests for ADK CLI telemetry metrics collection and reporting; Added unit tests for API Hub client and secret client deprecation; Added unit tests for APIHubToolset; Added unit tests for Agent Identity credential providers; Added unit tests for AgentSimulatorConfig deprecation handling; Added unit tests for Application Integration Tool clients; Added unit tests for Application Integration Toolset and Integration Connector Tool; Added unit tests for Bigtable tools and toolset; Added unit tests for CLI conformance testing infrastructure; Added unit tests for CLI deployers, plugins, and web server components; Added unit tests for CLI utility modules; Added unit tests for Cloud Run sandbox code executor; Added unit tests for DaytonaEnvironment integration; Added unit tests for E2BEnvironment integration; Added unit tests for EditFileTool and ReadFileTool; Added unit tests for Firestore integration services; Added unit tests for Google API tooling components; Added unit tests for InMemory and SessionState credential services; Added unit tests for InMemory, Vertex AI Memory Bank, and Vertex AI RAG memory services; Added unit tests for LLM flow context processing; Added unit tests for LangchainTool integration; Added unit tests for LocalEnvironment file operations and process tree cleanup; Added unit tests for MCP tool integration and session management; Added unit tests for MongoDB integration toolset and search tools; Added unit tests for OAuth2 credential refresher and registry; Added unit tests for OpenAI Labs LLM adapters; Added unit tests for OpenAPI spec parser and toolset components; Added unit tests for OpenAPI tool authentication helpers; Added unit tests for OpenAPI tool common utilities; Added unit tests for ParameterManagerClient initialization; Added unit tests for PlanReActPlanner output processing; Added unit tests for Redis session service integration; Added unit tests for RemoteA2aAgent; Added unit tests for SecretManagerClient initialization and configuration; Added unit tests for Spanner tools and toolsets; Added unit tests for VMAAS sandbox integration components; Added unit tests for agent configuration, cloning, and routing; Added unit tests for artifact services and utilities; Added unit tests for built-in ADK plugins; Added unit tests for credential exchanger registry and OAuth2 exchange logic; Added unit tests for database schema detection and migration utilities; Added unit tests for evaluation simulation components; Added unit tests for event handling, serialization, and path utilities; Added unit tests for example utilities and Vertex AI example store; Added unit tests for live streaming configurations, tool lifecycle, and multi-agent interactions; Added unit tests for platform random, time, and UUID providers; Added unit tests for repository compliance and pre-commit scripts; Added unit tests for runner pause, resume, rewind, and debug capabilities; Added unit tests for skills utilities, models, and prompt formatting; Added unit tests for the A2A agent executor and interceptor framework; Added unit tests for the A2A compatibility shim; Added unit tests for the ADK 2.0 Workflow engine; Added unit tests for the ADK feature registry and decorator system; Added unit tests for the Antigravity SDK agent wrapper; Added unit tests for the ApiRegistry integration; Added unit tests for the App class and event compaction logic; Added unit tests for the BigQuery ADK skill; Added unit tests for the BigQuery integration; Added unit tests for the Cloud Pub/Sub tool integration; Added unit tests for the ComputerUse toolset and base computer components; Added unit tests for the CrewAI integration tool; Added unit tests for the Data Agent toolset and its individual tools; Added unit tests for the Eventarc integration toolset; Added unit tests for the GCP Skill Registry integration; Added unit tests for the GCS integration toolsets and client; Added unit tests for the LiveKit voice and telephony integration; Added unit tests for the OCI Generative AI LLM integration; Added unit tests for the Slack integration runner; Added unit tests for the authentication subsystem; Added unit tests for the environment simulation tool; Added unit tests for the evaluation module; Added unit tests for the google.adk.live package; Added unit tests for the utils package; New integration test suite for ADK agents and evaluation; New session service unit tests and shared contract testing infrastructure; New telemetry functional test harness and golden-comparison framework; New unit test suite for import loading, release dependencies, and runner behavior.

The Agent Development Kit (ADK) has reached version 2.0.0 GA, raising the minimum Python version to 3.10 and adding support for Python 3.14. This release updates core dependencies, including FastAPI (\>=0.133), Google GenAI SDK (\>=2.19), and Pydantic (\>=2.12), while introducing new optional extras for features like A2A, Agent Identity, and various Google Cloud integrations. Sample requirements files have been added to reflect these new version constraints.

(dependencies) · high confidence

This release updates the Google Agent Development Kit (ADK) to version 2.9.0. The package now exposes a lazy-loading entry point in \src/google/adk/\_\init\\_.py\, allowing users to import core components like \Agent\, \Context\, \Event\, \Runner\, and \Workflow\ directly from the top-level namespace without incurring the full import cost of the SDK. The release also includes the \Runner\ implementation, which manages agent execution, session state, and event handling, along with the \OpenAPIToolset\ and \RestApiTool\ for integrating REST APIs as agent tools.

src/google/adk · high confidence

Adds an \_\init\\_.py file to the src/google/adk/integrations directory to make it a proper Python package, and introduces a README.md that defines the scope, contribution guidelines, and dependency management strategy (using optional extras) for external tool and service integrations.

src/google/adk/integrations · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 47.

• Code Health 28
• Architecture 99
• Maturity 75
• Readiness 53
• Security 76
• Domain Modelling 100
• Accessibility 63

• 300 commits — 128 feature/other, 172 fixes

• src/google — 224 commits
• tests/unittests — 43 commits
• docs/guides — 11 commits
• contributing/samples — 8 commits
• (root) — 7 commits
• .github/workflows — 5 commits
• tests/integration — 2 commits

• fix: chore: fix strict mypy errors in transfer_to_agent_tool
• fix: fix!: confine GCS tool local file paths to a configured root
• fix: fix!: raise SessionNotFoundError when appending to an unknown session
• fix: fix!: rerun a failed node on resume instead of replaying it as complete
• fix: fix!: retry a nested workflow when a node inside it fails
• fix: fix(a2a): quote a fetched card description and drop relayed auth responses
• fix: fix(a2a): require https for a non-loopback agent card URL
• fix: fix(a2a): stop a completed task delegation breaking later peer delegations
• fix: fix(agents): accept the default hint in request_confirmation
• fix: fix(agents): allow descriptionless BaseNode in LlmAgent tools
• fix: fix(agents): trigger after_agent_callback on cancellation
• fix: fix(artifacts): give concurrent gcs artifact saves distinct versions
• fix: fix(auth): declare that AuthHandler.generate_auth_uri can return None
• fix: fix(auth): report an auth scheme that carries no OAuth2 flows
• fix: fix(bigquery): lazy-load Dataplex so BigQueryToolset imports without it
• fix: fix(callables): extract unified CallableSpec and resolve doc and unwrap edge cases
• fix: fix(cli): explicitly set memory_service_uri='memory://' when --in_memory is passed
• fix: fix(cli): sync the Agent Engine class-method catalogue with its source
• fix: fix(cli): validate the test name on every dev server test endpoint
• fix: fix(compaction): stop backwards prompt token scan at compaction boundary
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

google/adk-python was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.