Skip to content
CAI
Software that uses CAICheck a score

google/adk-python

44.9

Weak · 5 November 2026

237.3k

lines of production code

Python

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Cloud Run sandbox code executor

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

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

Add CrewAI tool integration

Users can now wrap and use CrewAI tools within the ADK framework via the new \CrewaiTool\ class and \CrewaiToolConfig\. This integration handles argument validation and type coercion, automatically sanitizes tool names by replacing spaces with underscores, and manages context injection for CrewAI-specific parameter schemas.

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

Add ElevenLabs STT and TTS integrations for live voice agents

Users can now build cascaded live voice agents using ElevenLabs for speech-to-text and text-to-speech. The integration provides \ElevenLabsSTT\ as a \LiveIngress\ that streams audio to ElevenLabs' Scribe v2 Realtime WebSocket recognizer, emitting partial transcripts and turn-finished events. It also provides \ElevenLabsTTS\ as a \LiveEgress\ that synthesizes model output into PCM audio chunks, supporting sentence splitting and barge-in cancellation via the \CascadeLive\ wrapper.

_src/google/adk/integrations/eleven\labs · high confidence

Add LiveKit integration for voice and telephony agents

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 LiveKit's standard 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 and requires the \google-adk\[livekit\]\ extra.

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

Add ManagedAgent code-execution sample

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, as ManagedAgent does not support the \code\_executor\ field used by LlmAgent. The sample also illustrates provisioning a remote sandbox via the \environment\ parameter and handling 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. The sample shows how to instantiate the agent with a remote sandbox environment, allowing it to autonomously perform server-side research loops and synthesize results. It also illustrates multi-turn chaining, where follow-up interactions automatically recover and reuse the previous sandbox and interaction context.

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

Add OCI Generative AI provider integration

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, implemented in \src/google/adk/integrations/oci\, provides the \OCIGenAILlm\ class which maps ADK content and configuration to OCI's specific API structures, supporting multimodal inputs (images, audio, video, documents) and structured output formats.

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

Add OpenSandbox integration for persistent remote agent workspaces

Users can now use the OpenSandbox integration to run agent commands in persistent remote sandboxes. This new \OpenSandboxEnvironment\ class allows agents to maintain state across executions by attaching to existing sandboxes or creating new ones with configurable container images, timeouts, and network policies. The integration is available as an optional extra (\pip install google-adk\[opensandbox\]\) and is currently marked as experimental.

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

Add Parameter Manager integration to ADK

Users can now retrieve rendered parameter values 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

Add experimental Pub/Sub tools for publishing and subscribing to messages

This change introduces a new, handcrafted Pub/Sub toolset (PubSubToolset) that provides three tools: publish\_message, pull\_messages, and acknowledge\_messages. Unlike the auto-generated Google API tools, these are custom-built 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 (PubSubToolConfig, PubSubCredentialsConfig) and a client module with a cached publisher/subscriber client implementation to optimize performance. The tools are marked as experimental and are available under the google.adk.tools.pubsub module.

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

Add sample for human-in-the-loop tool gating via classifier

A new sample in \contributing/samples/hitl/classifier\_tool\_gate\ demonstrates how to use a classifier from \google.adk.labs.classifiers\ to gate tool calls. The sample implements a \before\_tool\_callback\ that evaluates whether a tool call is risky (e.g., deleting data or contacting a customer) and either blocks it or prompts the user for confirmation based on the classifier's probability score.

_contributing/samples/hitl/classifier\_tool\gate · high confidence

Added ADK icon and audio processing assets for the CLI browser UI

The CLI's browser-based interface now includes a dedicated ADK icon (ADK-512-color.svg) for visual branding and an audio processor module (audio-processor.js) that handles microphone input. The audio processor automatically resamples incoming audio streams to the 16 kHz sample rate required by the Live API using linear interpolation, ensuring compatibility with the browser's native audio capture rates.

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

Added sample demonstrating DebugLoggingPlugin usage

A new sample plugin located at contributing/samples/plugins/plugin\_debug\_logging has been added to the repository. This sample provides a complete example of how to integrate the DebugLoggingPlugin into an ADK application, showing users how to capture detailed debug information—including LLM requests, responses, tool calls, and session state—into a YAML file for troubleshooting purposes.

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

Agent Builder Assistant gains built-in project management tools

The ADK CLI now includes a suite of tools for the Agent Builder Assistant to manage project files and configurations. Users can read, write, and delete files with optional backups, clean up unused files, and explore project structures. Configuration files can be read to extract metadata or written with comprehensive validation against the AgentConfig schema before saving. Additionally, the assistant can search the ADK source code using regex patterns and query the ADK knowledge base for relevant information.

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

Experimental A2A-ADK event and part conversion layer

This change introduces a new set of converters in \src/google/adk/a2a/converters\ that bridge the gap between the Agent Development Kit (ADK) and the Agent-to-Agent (A2A) protocol. The module provides bidirectional conversion capabilities: \from\_adk\_event.py\ and \event\_converter.py\ translate ADK internal events into A2A \TaskStatusUpdateEvent\ and \TaskArtifactUpdateEvent\ structures, while \to\_adk\_event.py\ maps incoming A2A messages and task updates back into ADK \Event\ objects. The \part\_converter.py\ module handles the granular conversion of content parts (text, file, data) between GenAI and A2A formats, preserving metadata such as long-running function call IDs, thought signatures, and media control fields. Additionally, \request\_converter.py\ adapts A2A \RequestContext\ objects into ADK \AgentRunRequest\ formats, and \long\_running\_functions.py\ manages the state and lifecycle of long-running tool executions across the protocol boundary. All components are gated behind the \a2a\_experimental\ decorator, indicating they are available for testing but subject to change.

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

Experimental Antigravity SDK agent wrapper

Adds the Antigravity integration to the ADK labs, introducing the AntigravityAgent class that wraps a pre-configured google.antigravity.Agent as a native ADK BaseAgent node. This allows users to run Antigravity SDK agents within the ADK framework, with support for streaming events, handling sub-agents as client-side tools, and managing conversation state. The integration includes event conversion utilities to translate Antigravity SDK steps into ADK events, and a mechanism to expose ADK sub-agents as tools to the Antigravity harness. Also in this area: Agent mode handling, compaction safety, and auth security hardening; Preserve model thinking, client tool responses, and sub-agent hierarchy in ADK events.

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

Experimental credential service for loading and saving OAuth2 tokens

An experimental credential service has been added to the authentication module, providing a base interface and two concrete implementations: an in-memory store and a session-state-backed store. This allows the system to persist OAuth2 access and refresh tokens across invocations. The session-state implementation specifically enhances security by stripping the OAuth2 client secret before storage and re-attaching it upon load, ensuring sensitive client credentials are not persisted in session data.

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

Initial project scaffolding and development tooling

The repository is initialized with essential project files, including an Apache 2.0 license, a comprehensive .gitignore for Python and IDE artifacts, and a pre-commit configuration that enforces code formatting (isort, pyink, ruff), license headers, and documentation link checks. An AGENTS.md file provides project context for AI coding assistants, and constraints files for Python 3.10 and 3.11 are added to protect against transitive dependency supply-chain issues.

(repo-wide) · high confidence

Introduce ADK Plugin System with Built-in Error Recovery and Integrity Plugins

The ADK now includes a structured plugin system that allows global interception and modification of agent, tool, and LLM behaviors. This release introduces several built-in plugins: \ReflectAndRetryModelPlugin\ and \ReflectAndRetryToolPlugin\ provide self-healing capabilities by automatically retrying model or tool calls on failure; \ToolCallIntegrityPlugin\ adds HMAC-based security to verify the integrity of function calls in session history; \ContextFilterPlugin\ helps manage context size by filtering out older invocations; \GlobalInstructionPlugin\ replaces the deprecated \global\_instructions\ field to apply app-wide instructions; and \AutoTracingPlugin\ enables automatic OpenTelemetry instrumentation for debugging and monitoring. The \BasePlugin\ class and \PluginManager\ provide the foundation for registering and executing these plugins.

src/google/adk/plugins · high confidence

Introduce ADK Pull Request Triaging Agent sample

Adds a new Python-based agent sample that automatically assigns pull request owners based on component mapping. The agent identifies the relevant component from PR changes, looks up the designated owner from a shared \component\_owners\ map, and assigns that user to the PR. It supports both an interactive local mode (via \adk web\) where users approve assignments, and an automated GitHub Actions workflow mode that runs on PR events. The sample includes configuration for GitHub API access, environment variable setup, and a shared ownership map to ensure consistency across triaging agents.

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

Introduce ADK Stale Agent sample for auditing GitHub issues

A new sample agent is added to \contributing/samples/adk\_team/adk\_stale\_agent\ that uses the Google ADK and a Gemini LLM to audit GitHub issues for staleness. The agent fetches issue history via GraphQL, analyzes maintainer intent to distinguish between active discussions and stale requests, and automatically applies stale labels, closes issues past the threshold, and alerts maintainers to silent description edits. The sample includes configuration for thresholds and concurrency, robust HTTP retry logic, and a main entry point that processes issues in batches and exits with a non-zero status if any audit fails.

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

Introduce ADK planners for structured agent reasoning

The Agent Development Kit (ADK) now includes a new planners module that enables agents to generate structured plans before executing actions. This release adds a base planner interface and two concrete implementations: BuiltInPlanner, which leverages model-native thinking features via a configurable thinking\_config, and PlanReActPlanner, which enforces a Plan-Re-Act workflow using internal tags to separate planning, reasoning, and final answers. PlanReActPlanner processes LLM responses by stripping these internal tags and preserving clean text and function calls, allowing users to build agents with explicit, interpretable reasoning steps.

src/google/adk/planners · high confidence

Introduce Agent Builder Assistant built-in agent

A new built-in Agent Builder Assistant is now available in the ADK CLI, enabling users to design and configure multi-agent systems via YAML. This agent provides intelligent architecture suggestions, generates schema-compliant YAML configurations, and manages project files. It includes built-in capabilities for searching ADK documentation and source code, and is accessible through the ADK web interface or programmatically via the \AgentBuilderAssistant\ factory.

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

Introduce Agent Registry integration for discovering and binding agents and MCP servers

Adds the Agent Registry client library, enabling users to discover agents and MCP servers, resolve runtime bindings for deployed agents, and manage authentication schemes and credentials (including mTLS support) when connecting to remote agents and tools.

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

Introduce CascadeLive for real-time voice conversations with Gemini STT and TTS

The \google.adk.live\ package is now exported, providing the \CascadeLive\ model and \CascadeLiveConnection\ to enable real-time, bidirectional voice interactions. This feature chains a text LLM with speech-to-text (STT) and text-to-speech (TTS) transforms, supporting barge-in capabilities and streaming audio output. The package includes built-in adapters for Gemini-based STT (\GeminiSTT\) and TTS (\GeminiTTS\), along with utilities for managing live request queues, audio caching, and transcription events.

src/google/adk/live · high confidence

Introduce ComputerUseToolset with URL safety validation and coordinate normalization

Users can now use the new ComputerUseToolset to expose computer control capabilities to agents. This toolset automatically normalizes LLM-supplied coordinates from a virtual space (default 1000x1000) to the actual screen dimensions, ensuring consistent interaction across different display sizes. It also includes built-in safety validation for the \navigate\ action, refusing URLs that target private or link-local addresses unless \allow\_private\_network\_access\ is explicitly enabled. The toolset allows excluding specific predefined functions from exposure and supports adapting tools via an adapter function.

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

Introduce Data Agent tools for querying and managing Gemini Data Analytics agents

This change adds a new Data Agent toolset to the Google ADK, providing tools to interact with the Gemini Data Analytics API. Users can now list accessible data agents, retrieve agent information, and ask data agents questions. Additionally, when the \enable\_data\_agent\_modification\ configuration flag is set to true, the toolset exposes tools to create, update, and delete data agents. The toolset supports configuration for API endpoints, location-based routing, and pagination parameters for listing agents.

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

Introduce EnvironmentToolset for file I/O and command execution

The environment tools are now available as a unified EnvironmentToolset that provides four tools: Execute (run shell commands), ReadFile (read file contents with optional line ranges), EditFile (surgical text replacement in existing files), and WriteFile (create or overwrite files). The toolset injects an environment-level system instruction on each LLM call to guide tool selection, and output truncation is configurable via max\_output\_chars (default 30,000 characters). ReadFile validates that start\_line and end\_line are integers, EditFile normalizes cross-platform line breaks and escapes regex characters to ensure exact matching, and all tools include telemetry hooks for error detection.

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

Introduce Firestore integration for ADK sessions and memory

Added new \FirestoreSessionService\ and \FirestoreMemoryService\ implementations for the Google ADK, enabling persistent session storage and keyword-based memory search backed by Google Cloud Firestore. The session service manages the \adk-session\ hierarchy (app, user, session, events) with process-level locking to serialize event appends, handles state merging, and ensures deterministic, timezone-correct event reads. The memory service extracts keywords from session events (filtering out common stop words) and stores them in a \memories\ collection for efficient retrieval via Firestore array queries. Also in this area: 18 commits (15 fixes) fixing src/google; 1 commit (1 fix) fixing src/google/adk/integrations.

src/google/adk/integrations/firestore · low confidence · unverified

Introduce GCP Agent Identity authentication provider

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 polling for pending consent in 3-legged OAuth flows and caching REST clients for thread safety. The provider intelligently routes requests to either the standard Agent Identity service or the legacy IAM Connector service based on the resource name pattern.

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

Introduce GCPSkillRegistry for GCP-based skill discovery

Users can now discover and load skills from the GCP Agent Registry via the new GCPSkillRegistry class. This integration handles authentication (including mTLS support), validates registry IDs to ensure safe URL path segments, and fetches skills using the agentregistry/skill API endpoint.

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

Introduce LLM-based event compaction and app resumability

The \src/google/adk/apps\ module now provides the core infrastructure for LLM-driven event compaction and application resumability. Users can configure \EventsCompactionConfig\ to trigger compaction via token thresholds or sliding-window intervals, using the new \LlmEventSummarizer\ to condense conversation history, tool calls, and thoughts into compacted events while preserving language and tool grounding. Additionally, \ResumabilityConfig\ enables pausing and resuming long-running invocations, and the \App\ entry point supports lazy-loading to reduce cold-start latency.

src/google/adk/apps · high confidence

Introduce MCP Tool integration with session management and error handling

This change adds the \McpTool\ and \McpToolset\ components to the ADK, enabling agents to interact with external Model Context Protocol (MCP) servers. The implementation includes robust session management via \MCPSessionManager\ to handle connection lifecycles, graceful error handling for transport crashes and JSON-RPC errors, and support for MCP SDK 2.x alongside 1.x. It also introduces authentication support (including API keys), configurable timeouts, and the ability to expose an ADK agent as an MCP server via \to\_mcp\_server\. Users can now integrate MCP tools into their agents with proper session reuse per connection and improved reliability.

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

Introduce Model Armor guardrail plugin for input, output, and tool screening

Users can now integrate Google Cloud Model Armor as a guardrail plugin to screen agent interactions. The new \ModelArmorPlugin\ hooks into the agent lifecycle via \before\_model\_callback\, \after\_model\_callback\, and \after\_tool\_callback\ to sanitize user prompts, model responses, and tool outputs respectively. Configuration is handled through \ModelArmorConfig\, allowing users to specify distinct Model Armor templates for each stage and customize blocked messages. The plugin supports advanced behaviors such as continuing with de-identified text when only Sensitive Data Protection filters match (if \deidentify\_sensitive\_data\ is enabled) and blocking on screening failures. It also handles large tool outputs by chunking them to stay within Model Armor's token limits.

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

Introduce Redis-backed persistent session storage for ADK

Adds a new Redis integration for the Google Agent Development Kit (ADK) that enables persistent session storage, allowing agent sessions, conversation events, and state to be stored and retrieved via Redis. The \RedisSessionService\ supports automatic merging and synchronization of app, user, and session-scoped state, configurable time-to-live (TTL) for expiring stale sessions, and flexible connection options including URI, individual parameters, or pre-configured clients. This change introduces the core implementation files (\\_redis\_session\_service.py\, \\config.py\), public exports (\\\init\\_.py\), and documentation (\README.md\) for this new capability. Also in this area: 18 commits (15 fixes) fixing src/google; Agent Builder Assistant now validates against the installed ADK version.

src/google/adk/integrations/redis · medium confidence · unverified

Introduce artifact storage services with security and reliability fixes

The \src/google/adk/artifacts\ module now provides \FileArtifactService\ for local filesystem persistence and \GcsArtifactService\ for Google Cloud Storage, both implementing the \BaseArtifactService\ interface. These services enforce strict security by validating path segments to prevent cross-user access and path traversal, scoping reads and deletes to the requesting app, and rejecting reserved or traversing paths. The GCS implementation ensures concurrent saves receive distinct versions, keeps internal bookkeeping keys out of user metadata, and correctly handles nested artifact paths. The file service preserves creation timestamps and handles Windows path normalization.

src/google/adk/artifacts · high confidence

Introduce auto-generated Google API tools with mTLS and service account support

The \google\_api\_tool\ package now provides auto-generated toolsets for Google APIs (BigQuery, Calendar, Gmail, YouTube, Slides, Sheets, Docs) based on the Google API Discovery Service. Users can instantiate these toolsets with OAuth2 client credentials or service account authentication, and the tools automatically support mutual TLS (mTLS) when client certificates are available. The implementation also allows injecting custom HTTP headers, specifying additional OAuth scopes, and using a custom discovery URL.

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

Introduce dedicated client classes for Google Cloud Connectors and Application Integration

Added \ConnectionsClient\ and \IntegrationClient\ to the Application Integration toolset to handle API interactions with Google Cloud Connectors and Application Integration respectively. \ConnectionsClient\ manages connection details, entity schemas, and action schemas, while \IntegrationClient\ generates OpenAPI specifications for integrations and connections, supporting dynamic trigger lists and connection template overrides.

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

Introduce experimental Bigtable tools for agents

Adds a new Bigtable toolset (BigtableToolset) to the ADK, providing tools to list and inspect Bigtable instances, tables, and clusters, as well as to execute GoogleSQL queries against Bigtable tables. The query tool supports parameterized queries and secure parameter injection via parameterized views, allowing agents to run SQL with user-specific context (e.g., user\_id) without exposing those parameters to the LLM. The toolset is marked experimental and includes credential configuration and settings for controlling query result limits.

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

Introduce experimental Spanner toolsets for AI agents

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, and vector similarity search) and \SpannerAdminToolset\ for instance and database administration. These tools are designed to let AI agents interact with Google Cloud Spanner databases securely, featuring built-in SQL identifier validation, resource cleanup, and fine-grained access controls via database roles.

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

Introduce feature registry and decorator system for ADK capabilities

The ADK now includes a centralized feature registry and decorator system that allows capabilities to be explicitly marked as experimental, working in progress, or stable. This system introduces decorators (\@experimental\, \@stable\, \@working\_in\_progress\) that enforce feature gates, raising errors if a feature is used without being enabled. It also provides a \FeatureName\ enum listing all supported features (such as \BIG\_QUERY\_TOOLSET\, \MONGODB\_TOOLSET\, and \PROGRESSIVE\_SSE\_STREAMING\) and utilities like \is\_feature\_enabled\ and \override\_feature\_enabled\ to manage feature states, giving users fine-grained control over which experimental or stable features are active in their applications.

src/google/adk/features · high confidence

Introduce lazy-loading agent module and new ManagedAgent for server-side orchestration

The agents package now uses lazy loading to reduce import overhead, exposing core classes like LlmAgent, ParallelAgent, and Context via a new \_\init\\_.py. A new ManagedAgent class allows agents to be backed by the Managed Agents API (interactions.create), supporting server-side tools and remote MCP servers with streaming-only execution. Additionally, a new StreamingMode enum (SSE, BIDI, NONE) provides granular control over how agent responses are streamed to clients, and a private \_agent\_router module handles multi-agent routing and branch path recovery for resumed sessions.

src/google/adk/agents · high confidence

Introduce lazy-loading model registry and new model capabilities

The models package now uses a lazy-loading registry to resolve LLM classes (Gemini, Claude, Apigee, LiteLLM, etc.) only when needed, reducing cold-start overhead. This change adds support for context caching via GeminiContextCacheManager and ServiceTier configuration, exposes log probabilities in LlmResponse, and introduces new fields for live session management (session ID, resumption updates, GoAway signals) and transcription handling.

src/google/adk/models · high confidence

Introduce local subprocess execution environment

Added a new LocalEnvironment class that allows agents to execute shell commands locally via asyncio subprocesses. This environment manages a working directory (creating a temporary one if none is provided), merges custom environment variables, and handles command execution with configurable timeouts. It ensures robust process termination by signaling the entire process group (SIGTERM followed by SIGKILL) to prevent hanging child processes from blocking output pipes.

src/google/adk/environment · high confidence

Introduce modular code executors with lazy loading and sandboxed execution

The code execution capabilities in ADK have been reorganized into a new \src/google/adk/code\executors\ package, replacing the previous \BuiltInCodeExecutionTool\ with a \BuiltInCodeExecutor\ that delegates to the model. This update introduces several new executor implementations: \AgentEngineSandboxCodeExecutor\ for Vertex AI Code Execution Sandboxes (with automatic Agent Engine provisioning), \GkeCodeExecutor\ for Kubernetes-based execution (supporting both Job and Sandbox modes with gVisor isolation), \ContainerCodeExecutor\ for Docker-based execution (with hardened defaults like disabled networking), and \VertexAiCodeExecutor\ for Vertex AI Code Interpreter Extensions. To improve startup performance, all optional executors are now lazy-loaded via \\\getattr\\\, requiring the \google-adk\[extensions\]\ extra for installation. The \UnsafeLocalCodeExecutor\ has also been updated to support timeouts and correctly handle \if \\name\\_ == "\_\main\\_"\ blocks.

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

Introduce new memory service architecture with SQLite, In-Memory, and Vertex AI implementations

The memory subsystem has been restructured around a new \BaseMemoryService\ abstract class, exposing a unified interface for session ingestion, event delta updates, and memory search. This change introduces three concrete implementations: \SqliteMemoryService\ for persistent local storage with FTS5 search capabilities, \InMemoryMemoryService\ for thread-safe prototyping with Unicode-aware keyword matching, and cloud-backed services (\VertexAiMemoryBankService\ and \VertexAiRagMemoryService\) for Vertex AI integration. The public API is now exported via a lazy-loading \\_\init\\_.py\ to optimize cold-start performance, and the underlying data model has been standardized on the new \MemoryEntry\ schema.

src/google/adk/memory · high confidence

Introduce structured authentication framework with credential management and security hardening

This change introduces a new authentication subsystem in \src/google/adk/auth\ that centralizes credential handling, OAuth2 token exchange, and HTTP header generation. For users, this means a unified \CredentialManager\ now orchestrates the full lifecycle of authentication credentials, supporting pluggable custom auth providers via \AuthProviderRegistry\ and automatic OAuth2 token refresh. The framework introduces strict security hardening by redacting sensitive fields (such as client secrets, access tokens, and passwords) from Python \repr\ outputs and error messages to prevent accidental leakage in logs, and explicitly strips OAuth2 client secrets from session state and client-facing responses before they are persisted or transmitted. It also adds support for mTLS endpoints for Google OAuth2 token requests and provides a stable, digest-based credential key generation mechanism to ensure consistent credential loading and prevent cross-user credential leaks.

src/google/adk/auth · high confidence

Introduces ADK events module with abort handling, branch paths, and rewind logic

The new \src/google/adk/events\ module provides core infrastructure for managing agent session history. It adds synthetic abort events to seal cancelled invocations and prevent orphaned tool calls from being replayed, introduces \\_BranchPath\ and \\_NodePathBuilder\ utilities to track hierarchical execution branches and node positions, and implements \\_apply\rewinds\ to correctly filter out rewound events from the live history. Additionally, it enforces privacy by stripping internal metadata (keys prefixed with \\\_adk\internal\\) from events and sessions exposed to callers. Also in this area: 18 commits (15 fixes) fixing src/google; Improved agent state isolation and interrupt handling in parallel workflows.

src/google/adk/events · medium confidence · unverified

Introduces local telemetry collection and reporting for the ADK CLI

The ADK CLI now collects and reports usage metrics to Google's Clearcut service. This change adds a metrics collector that groups commands by terminal session (using parent PID and a 1-hour inactivity timeout), records command names and flags (capped at 50 flags and 64 characters to limit PII), and queues the data in a local JSONL file. A background reporter flushes these metrics to the production endpoint with exponential backoff retries and respects server-side rate-limiting responses (HTTP 429) by locking further submissions for a specified duration.

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

Introduction of A2A support with SDK compatibility layer and experimental warnings

This change introduces the initial A2A (Agent-to-Agent) integration for the ADK, starting with a new \src/google/adk/a2a\ package. To ensure stability across different SDK versions, a compatibility layer (\\_compat.py\) has been added to abstract differences between a2a-sdk 0.3.x and 1.x, allowing the rest of the ADK to remain version-agnostic. Additionally, an experimental decorator (\a2a\_experimental\) is provided to mark A2A components, issuing specific warnings to users that these features are subject to breaking changes, with an option to suppress these warnings via the \ADK\_SUPPRESS\_A2A\_EXPERIMENTAL\_FEATURE\_WARNINGS\ environment variable.

src/google/adk/a2a · high confidence

Introduction of OpenAPI Tool module in Agent Development Kit

The Agent Development Kit (ADK) now includes a new OpenAPI tool module located at src/google/adk/tools/openapi\_tool. This addition exposes the OpenAPIToolset and RestApiTool classes, enabling users to integrate OpenAPI specifications into their agent workflows. The module also includes a common subpackage to support shared utilities for these tools.

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

Introduction of the experimental ADK Skills system

The ADK Skills system is now available, enabling agents to dynamically load instructions, resources, and scripts at runtime. This feature introduces a \SkillRegistry\ interface for managing skills, utility functions to load skills from local directories or Google Cloud Storage (GCS), and models for skill frontmatter and scripts. The system supports both synchronous and asynchronous loading, handles binary assets, and includes a prompt formatting utility to generate XML representations of available skills. As this is an experimental feature under active development, the API is subject to change.

src/google/adk/skills · high confidence

New A2A Agent Executor with interceptor framework and artifact support

The \src/google/adk/a2a/executor\ module introduces a new \A2aAgentExecutor\ that bridges A2A requests to ADK agents, featuring a configurable interceptor framework (\ExecuteInterceptor\) to hook into the execution lifecycle (before agent, after event, after agent). It includes a new implementation (\\_A2aAgentExecutor\) alongside a legacy path, a \TaskResultAggregator\ to track final task states, and a built-in interceptor (\include\_artifacts\_in\_a2a\_event\_interceptor\) that enriches A2A events with artifacts from the ADK \artifact\_service\. The executor also handles task cancellation and ensures proper event queuing for both A2A SDK 0.3.x and 1.x compatibility.

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

New A2A integration extension interceptor added

A new request interceptor has been introduced in the ADK A2A agent module to automatically inject the 'new agent version' extension header into outgoing A2A requests. This ensures that client calls include the specific extension identifier required for compatibility with updated A2A integration standards.

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

New A2A sample samples for authentication, state forwarding, and human-in-the-loop workflows

The \contributing/samples/a2a\ directory now includes several new sample agents demonstrating advanced 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 auth requests to a local root agent. The \a2a\_state\_forwarding\ sample demonstrates state management across agent boundaries. The \a2a\_human\_in\_loop\ sample implements a reimbursement workflow with long-running tools that require human approval for amounts over $100, using \ResumabilityConfig\ to properly route approval responses back to the remote approval agent. The \a2a\_basic\ and \a2a\_root\ samples provide foundational examples of local sub-agent integration and remote A2A agents as root agents respectively.

contributing/samples/a2a · high confidence

New A2A utility module for converting ADK agents to ASGI applications

Added a new \src/google/adk/a2a/utils\ package providing utilities to expose ADK agents as A2A-compliant services. The \to\_a2a()\ function converts a \BaseAgent\ or \Workflow\ into a Starlette ASGI application, supporting configuration for RPC URLs, path prefixes, custom runners, and persistent task stores. The \AgentCardBuilder\ class automatically generates A2A agent cards from ADK agents, extracting skills and capabilities, and supports skill-level security metadata definitions.

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

New ADK Answering and Issue Formatting Agents for GitHub Discussions and Issues

This location introduces two new sample agents for the \google/adk-python\ repository: 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 (e.g., \LLM\_MODEL\_NAME\, \INTERACTIVE\) and use the Google ADK framework.

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

New ADK CLI utility module for agent management and local storage

The \src/google/adk/cli/utils\ package has been introduced to centralize core CLI capabilities. It provides an \AgentLoader\ and \NestedAgentLoader\ to discover and load agents from various directory structures (including nested paths and YAML configs) with caching and isolation. A \DotAdkFolder\ manager and \local\_storage\ service handle per-agent local persistence for sessions and artifacts. The module also includes utilities for GCP authentication and Express Mode onboarding, file-system change detection for hot-reloading agents, and serialization/visualization of agent graphs for the web UI.

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

New ADK Issue Monitoring Agent sample for automated spam detection

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 avoid unnecessary LLM invocations, truncates long text, and uses a Gemini model to identify suspicious activity. 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

Added a new sample agent (\adk\_knowledge\_agent\) that integrates with Vertex AI Search to find ADK knowledge and documentation. The agent requires the \VERTEXAI\_DATASTORE\_ID\ environment variable to initialize the search tool and includes a callback to append citation references (title, URI, snippet) to the model's response for improved transparency.

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

New ADK documentation and release analysis sample agents

This location introduces a new set of sample agents for the ADK team to automate documentation maintenance. The \adk\_documentation\ package provides an \adk\_docs\_updater\ agent that reads GitHub issues and updates documentation based on code changes, and an \adk\_release\_analyzer\ agent that compares repository releases to identify documentation gaps and generate issues. The \adk\_pr\_agent\ sample provides a tool to generate pull request descriptions. These samples include tools for interacting with GitHub and local git repositories, with specific security measures to confine file operations to a managed directory.

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

New ADK evaluation samples for the home-automation agent

This location introduces a family of single-concept samples that demonstrate how to evaluate the shared \home\_automation\_agent\ using the \adk eval\ CLI. The samples cover deterministic reference matching (\basic\_criteria\), custom metrics (\custom\_metric\), LLM-as-a-judge semantic matching (\llm\_judge\_match\), rubric-based quality scoring (\rubric\_criteria\), user simulation (\user\_simulation\), informational efficiency metrics (\efficiency\_metrics\), and file-convention differences (\test\_file\_vs\_evalset\). Each sample provides the necessary eval data, configuration, and documentation to compare these evaluation techniques side by side.

contributing/samples/evaluation · high confidence

New APIHubToolset for generating tools from API Hub resources

Users can now instantiate an APIHubToolset to automatically generate tools from a specified API Hub resource. This toolset supports authentication via access tokens or service account JSON, allows filtering specific tools, and enables lazy loading of API specifications to optimize initialization time.

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

New Application Integration and Integration Connector toolset

Added the \ApplicationIntegrationToolset\ and \IntegrationConnectorTool\ classes in \src/google/adk/tools/application\_integration\_tool\, enabling agents to interact with Google Cloud Application Integration resources and Integration Connector connections. The toolset generates tools from OpenAPI specs for integrations or entity operations/actions for connections, handling authentication via service accounts or dynamic OAuth flows, and supports filtering specific triggers or operations.

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

New BigQuery integration with configurable toolset and security controls

The BigQuery integration has been migrated to the standard \integrations/bigquery\ layout, introducing a new \BigQueryToolset\ that bundles metadata, query, data insights, and catalog search tools. Users can now configure default \project\_id\ and \dataset\_id\ to reduce model friction, enforce write safety via \WriteMode\ (blocked, protected, or allowed), and restrict compute to a specific project using \compute\_project\_id\. The integration includes built-in SQL injection guards for dynamic identifiers and string literals, supports Customer-Managed Encryption Keys (CMEK) for query results, and provides a pre-packaged \bigquery-ai-ml\ skill for AI/ML SQL functions. Additionally, sync tool functions are now executed off the event loop via an async adapter to prevent blocking.

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

New Human-in-the-Loop Tool Confirmation sample

Added a new sample demonstrating the Tool Confirmation feature in the ADK, showing how to implement Human-in-the-Loop flows for sensitive actions like fund transfers or account closures. The sample includes an agent with tools that either manually request confirmation via \tool\_context.request\_confirmation()\ or automatically require it using \FunctionTool(require\_confirmation=True)\, along with test cases covering approved, declined, and bypassed confirmation scenarios.

_contributing/samples/hitl/tool\confirmation · high confidence

New ModelConsultTool for mid-task advisor escalation

Added the \ModelConsultTool\ and supporting context-handover layer in \src/google/adk/tools/model\_consult\, enabling a fast executor model to consult a stronger advisor model mid-task. The tool packages the executor's session history (with configurable character and event budgets) into a single prompt block, allowing the advisor to provide strategic guidance, course corrections, or validation before the executor commits to substantive work or declares a task complete.

_src/google/adk/tools/model\consult · high confidence

New OpenTelemetry-based telemetry system with schema versioning and GCP integration

The telemetry module has been rewritten to use native OpenTelemetry instrumentation, replacing the previous implementation. This introduces a new telemetry schema (v2) aligned with OpenTelemetry GenAI semantic conventions, featuring new metrics for agent and workflow invocations, tool calls, and token usage. Users can opt into the new schema via the ADK\_TELELEMETRY\_SCHEMA\_VERSION\_OPT\_IN environment variable, with v2 becoming the default on Vertex Agent Engine. The system now supports per-request telemetry configuration, experimental feature gating, and native export to Google Cloud Trace, Monitoring, and Logging via OTLP, including mTLS support. A new SQLite-based span exporter is available for local development to persist traces across process restarts.

src/google/adk/telemetry · high confidence

New RemoteA2aAgent implementation with interceptors and config options

The A2A agent module has been restructured with a new \RemoteA2aAgent\ implementation located in \src/google/adk/a2a/agent\. This update introduces \RequestInterceptor\ and \CardRequestInterceptor\ hooks, allowing users to modify A2A requests and inject per-invocation HTTP headers (such as authentication tokens) when fetching remote agent cards. The \A2aRemoteAgentConfig\ class now exposes a \forward\_session\_id\_as\_context\id\ option to control session ID forwarding and includes a robust \\\deepcopy\\_\ method to prevent serialization errors. The package also exports dedicated configuration and error classes (\A2aCardRequestConfig\, \A2AClientError\, etc.) to support these new capabilities. Also in this area: 2 commits (1 fix) modifying src/google/adk/a2a; 3 commits (3 fixes) fixing src/google/adk/a2a; Agent mode handling, compaction safety, and auth security hardening; Agent Builder Assistant now validates against the installed ADK version.

src/google/adk/a2a/agent · medium confidence · unverified

New SecretManagerClient integration with regional endpoint support

A new SecretManagerClient has been added to 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. It also introduces support for regional endpoints, allowing users to specify a location to use regional API endpoints (including mTLS) instead of the global default, and includes a 'google-adk' user agent in API requests.

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

New Slack integration via SlackRunner

Users can now deploy ADK agents on Slack using the new SlackRunner, which connects to a Slack App via Socket Mode. The integration automatically manages conversation sessions by mapping Slack channel IDs and thread timestamps to ADK session IDs, handling app mentions and direct messages while sanitizing session identifiers to ensure compatibility with ADK's session service.

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

New Vertex AI Agent Engine Sandbox integration for computer use

Added a new integration module at \src/google/adk/integrations/vmaas\ that enables agents to use Vertex AI Agent Engine Sandboxes as remote browser environments. This includes \AgentEngineSandboxComputer\ for executing computer-use actions (clicking, typing, navigating) in a sandboxed browser, \AgentEngineEnvironment\ for running shell commands and file operations in a persistent sandbox workspace, and supporting classes like \SandboxManager\ and \SandboxClient\ to handle sandbox lifecycle (creation, pausing, resuming from templates/snapshots) and Chrome DevTools Protocol (CDP) communication. The integration supports auto-provisioning of agent engines and sandboxes, bring-your-own-sandbox (BYOS) modes, and automatic access token refresh.

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

New Vertex AI example store integration and example utilities

The examples module now includes a VertexAiExampleStore that retrieves relevant few-shot examples from a Vertex AI example store to improve model responses. This feature requires the 'google-cloud-agentplatform' and 'pandas' packages. Additionally, utility functions have been added to convert these examples into text format suitable for system instructions, supporting both direct example lists and provider-based retrieval.

src/google/adk/examples · high confidence

New agent optimization infrastructure with GEPA and simple prompt optimizers

The \src/google/adk/optimization\ module introduces a new optimization framework for improving agent instructions. It provides an \AgentOptimizer\ base class and a \Sampler\ interface to decouple optimization logic from evaluation. Two concrete optimizers are included: \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 for these components is managed via Pydantic models, and the system handles edge cases such as failed inferences and missing metric scores gracefully.

src/google/adk/optimization · high confidence

New and updated model integration samples

Added new samples for Azure Responses streaming (demonstrating partial function-call argument streaming), xAI Grok 4.6 on Vertex AI (using the OpenAI-compatible endpoint with Application Default Credentials), and NVIDIA NIM. Updated the Anthropic, Apigee, Gemma, and Ollama samples to use the new \InMemoryRunner\ API and \google.genai\ types, replacing the legacy \Runner\ and session management patterns.

contributing/samples/models · high confidence

New audio user simulator and per-turn quality evaluation in ADK evaluation framework

The evaluation framework now supports audio-based user simulations and granular quality checks. A new LlmAudioUserSimulator generates audio user messages by combining text generation with a pluggable audio model (defaulting to Google Cloud Text-to-Speech via \_CloudTTSLlm), allowing evaluations to test agents against audio inputs. Additionally, a post-hoc PerTurnUserSimulatorQualityV1 evaluator has been introduced to assess the quality of user simulator interactions turn-by-turn, checking for adherence to conversation plans, appropriate stopping conditions, and conversational tone. These components are organized under the new simulation sub-package, which also includes LlmBackedUserSimulator enhancements like custom instructions and persona support.

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

New classifier module for workflow routing

A new classifiers module has been added to the labs package, introducing a workflow node that routes execution paths based on LLM-generated classifications. This feature allows workflows to branch dynamically by asking typed questions (binary, choice, or score) about input data, with the node emitting the chosen label or boolean result as the route. The implementation includes a base classifier interface, a concrete LLM-based classifier that parses model responses into probability distributions, and specific typed answer models to ensure structured routing decisions. Also in this area: 18 commits (15 fixes) fixing src/google.

src/google/adk/labs/classifiers · medium confidence · unverified

New code execution and MCP integration samples

Added new sample agents in the contributing/samples directory to demonstrate code execution and Model Context Protocol (MCP) integration. The code\_execution samples showcase four execution backends: a built-in executor for local stateless execution, an Agent Engine sandbox for stateful cloud execution, a GKE sandbox for secure isolated execution, and a custom Vertex AI executor that demonstrates environment customization (e.g., adding Japanese fonts). The MCP samples provide reference implementations for connecting to MCP servers via SSE and stdio transports, including a demo of using an Agent as a tool to wrap MCP capabilities, a sample for passing dynamic HTTP headers for multi-tenancy, and a PostgreSQL agent that connects to a database via the postgres-mcp server.

contributing/samples/mcp · high confidence

New code execution and MCP integration samples

Added new sample agents in the contributing/samples directory to demonstrate code execution and Model Context Protocol (MCP) integration. The code\_execution samples showcase four execution backends: a built-in executor for local stateless execution, an Agent Engine sandbox for stateful cloud execution, a GKE sandbox for secure isolated execution, and a custom Vertex AI executor that demonstrates environment customization (e.g., adding Japanese fonts). The MCP samples provide reference implementations for connecting to MCP servers via SSE and stdio transports, including a demo of using an Agent as a tool to wrap MCP capabilities, a sample for passing dynamic HTTP headers for multi-tenancy, and a PostgreSQL agent that connects to a database via the postgres-mcp server. Also in this area: 2 commits (1 fix) modifying contributing.

_contributing/samples/code\execution · medium confidence · unverified

New configuration-based agent samples and human-in-the-loop tooling

This update introduces several new sample configurations for building agents, including a basic agent setup, a callback configuration demonstrating various agent, model, and tool hooks, a custom agent class implementation, and a generate-content configuration with specific model parameters. Additionally, it adds a human-in-the-loop sample for handling reimbursement approvals, featuring tools for automatic approval of small amounts and pending status for larger ones requiring manager intervention.

_contributing/samples/config, contributing/samples/hitl/tool\_human\_in\_the\_loop\config · high confidence

New conformance testing CLI and infrastructure for ADK Python

The \adk conformance\ command suite is now available, providing tools to generate and run conformance tests against the ADK web server. Users can create test cases from \spec.yaml\ files using the \adk conformance record\ command (previously \create\), which interacts with the web server via a new \AdkWebServerClient\ to record LLM interactions and tool calls into YAML files. The suite includes a replay mode (\adk conformance test\) that verifies agent behavior against these recordings, handling long-running tool calls and SSE streaming. It also normalizes tool declarations and relays agent output to ensure consistent comparison, and generates detailed Markdown reports of test results.

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

New context management samples for caching, history, memory, and database migration

Added four new sample applications in the \contributing/samples/context\_management\ directory to demonstrate key context management capabilities. The \cache\_analysis\ sample provides a research assistant agent and an experiment script to benchmark ADK explicit context caching against implicit caching, tracking token usage metrics for models like Gemini 2.5 Flash. The \history\_management\ sample shows how to use a \before\_model\_callback\ to slice the conversation history, maintaining only the most recent turns in the context window. The \memory\ sample demonstrates the use of \load\_memory\_tool\ and \preload\_memory\_tool\ to persist and retrieve user state across sessions. Finally, the \migrate\_session\_db\ sample includes a recipe and a legacy database file to illustrate how to upgrade session databases from older ADK versions to the current schema using the \adk migrate session\ command.

_contributing/samples/context\management · high confidence

New core samples for agent lifecycle, configuration, and observability

Added new demonstration samples in \contributing/samples/core\ that showcase key ADK capabilities. The \abort\ sample illustrates cooperative task cancellation, ensuring agent execution halts immediately when a client disconnects. The \app\ sample demonstrates application-level configuration, including custom plugins for invocation counting, event compaction, and context caching. The \artifacts\ sample shows how to save and load media (images, audio, video) and text reports as versioned artifacts. Additionally, the \callbacks\ sample provides examples of intercepting and modifying tool calls and LLM responses using \before\_tool\, \before\_model\, and \after\_model\ callbacks.

contributing/samples/core · high confidence

New developer tooling and release automation scripts

The repository now includes several new scripts in the \scripts/\ directory to enforce code quality, manage dependencies, and streamline releases. \check\_new\_py\_files.py\ and \compliance\_checks.py\ enforce new conventions for Python files under \src/google/adk/\, including a private-by-default naming rule, mandatory unit guides, and checks for FastAPI decorator ordering and mTLS usage. \update\_constraints.sh\ automates the generation and validation of transitive dependency constraints for multiple Python versions using \uv\. \curate\_changelog.py\ automates the drafting of release highlights and cleanup of changelog entries using Gemini. Additionally, \db\_migration.sh\ provides a utility for upgrading ADK session databases, and \generate\_agent\_config\_schema.py\ produces the \AgentConfig.json\ schema.

scripts · high confidence

New evaluation framework with efficiency metrics, custom metrics, and audio simulation support

The ADK evaluation module introduces a comprehensive set of new capabilities for assessing agent performance. Users can now track informational efficiency metrics—such as tool call count, inference call count, token usage, and invocation duration—which report per-invocation values averaged across turns without passing or failing eval cases. The framework supports custom metrics via user-provided Python functions, allowing tailored evaluation logic. Additionally, audio simulation is now supported through the LlmAudioUserSimulator, which handles TTS synthesis and resampling for Live API sessions. The module also includes robust data models for eval sets and cases, managers for persisting results to GCS or local storage, and utilities for path validation and retry options to ensure reliable eval execution.

src/google/adk/evaluation · high confidence

New experimental OAuth2 credential exchange infrastructure

This change introduces a new credential exchanger module in \src/google/adk/auth/exchanger\, providing an experimental \CredentialExchangerRegistry\ to manage different credential types and a new \OAuth2CredentialExchanger\ that supports both the authorization code and client credentials grant types. The implementation ensures synchronous OAuth2 token calls are executed off the main event loop to prevent blocking, and it includes logic to handle token updates and session creation via \authlib\. This replaces previous ad-hoc handling and provides a structured way to exchange OAuth2 credentials within the ADK.

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

New human-in-the-loop sample for tool confirmation with partial approval

Added a new sample in \contributing/samples/hitl/human\_tool\_confirmation\ that demonstrates how to implement human-in-the-loop tool confirmation. The sample includes an agent with a \reimburse\ tool gated by a threshold and a \request\_time\_off\ tool that supports partial approval via a confirmation payload. It also provides a test fixture verifying the pause/resume flow where a user can approve a request with a reduced number of days.

_contributing/samples/hitl/human\_tool\confirmation · high confidence

New integration samples for Agent Registry, Antigravity, and Application Integration

This update adds several new sample agents in the \contributing/samples/integrations\ directory. The \agent\_registry\_agent\ sample demonstrates discovering and using agents and MCP servers via the \AgentRegistry\ client. The \antigravity\_agent\ samples showcase the new \AntigravityAgent\ wrapper, including standalone usage, integration as an ADK sub-agent, nesting ADK sub-agents within an Antigravity root, and chaining them in an ADK \Workflow\. Additionally, the \api\_registry\_agent\ sample illustrates using \AgentRegistry\ to access BigQuery tools via an MCP server, and the \application\_integration\_agent\ sample shows interacting with Jira using the \ApplicationIntegrationToolset\.

contributing/samples/integrations · high confidence

New legacy workflow and agent pattern samples added

This update adds several new sample applications to the \contributing/samples\ directory to demonstrate various agent orchestration patterns. In \legacy\_workflows\, new examples include a non-LLM sequential agent, a simple sequential agent with dice rolling and prime checking, and a code pipeline (write, review, refactor) using the legacy \SequentialAgent\ API. In \patterns\, new samples demonstrate context offloading with artifacts for large data, a fields planner using \BuiltInPlanner\, JSON passing between agents in a pizza ordering scenario, and a workflow triage system that dynamically selects and executes specialized code or math agents in parallel.

contributing/samples/patterns · high confidence

New live streaming samples for voice, multi-agent, and tool behaviors

Added several new samples under \contributing/samples/live\ demonstrating bidirectional streaming capabilities. The \cascade\ sample shows a voice agent using \CascadeLive\ with configurable STT/TTS providers (Gemini or ElevenLabs), supporting barge-in and tool use. The \api\_server\_example\ provides a standalone Python client for live audio/text streaming. Additional samples include \multi\_agent\ for delegating tasks between agents, \parallel\_tools\_agent\ for concurrent tool execution, and \non\_blocking\_tool\_agent\ demonstrating background tool execution with \types.Behavior.NON\_BLOCKING\.

contributing/samples/live · high confidence

New migration tooling for DatabaseSessionService schema upgrades

The \src/google/adk/sessions/migration\ area now provides the infrastructure to migrate \DatabaseSessionService\ databases to the new JSON-based schema (v1). This includes a \migration\_runner\ that orchestrates upgrades, a \README\ detailing the process for adding future schema versions, and utility scripts for handling schema detection, async URL normalization, and credential redaction in logs. A specific migration script (\migrate\_from\_sqlalchemy\_pickle\) is included to convert legacy v0 pickle-based event data to the new JSON format, with safeguards such as restricted unpickling and local-time timestamp handling to ensure data integrity during the transition.

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

New modular CLI deployment system for ADK Python

The \src/google/adk/cli/deployers\ directory now provides a modular, factory-based deployment system for ADK Python projects, supporting both Google Cloud Run and local Docker environments. This change introduces a generalized Dockerfile template that improves security and reliability by using exec-form RUN/CMD instructions to prevent shell injection, validating app names to ensure safe Dockerfile generation, and correctly handling the \AGENT\_GATEWAY\_ROOT\_CERTIFICATES\ build argument for secure certificate installation. Users can now deploy agents to Cloud Run or run them locally via Docker with flexible environment variable injection and provider-specific argument passthrough.

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

New modular credential exchangers for OpenAPI tool authentication

The OpenAPI tool now uses a new, extensible authentication layer in \src/google/adk/tools/openapi\_tool/auth/credential\_exchangers\. This change introduces an \AutoAuthCredentialExchanger\ that automatically routes authentication requests to specialized exchangers based on the scheme: \OAuth2CredentialExchanger\ handles OAuth2 and OpenID Connect tokens (including automatic refresh of expired tokens), and \ServiceAccountCredentialExchanger\ handles Google Service Accounts, supporting both access tokens and ID tokens (required for services like Cloud Run). This modular approach replaces previous inline logic, making it easier to customize or extend authentication behavior for different security schemes.

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

New multi-agent sample configurations and single-turn sub-agent pattern

This update adds several new sample configurations to the multi-agent directory, demonstrating different orchestration patterns. It introduces a config-based learning assistant that delegates to specialized code and math tutors, a sequential code pipeline (write, review, refactor), and a loop-based iterative writing workflow with a critic and refiner. Additionally, it provides a new LLM-based multi-agent sample for rolling dice and checking primes, and a dedicated sample for the single-turn sub-agent pattern, which allows sub-agents to execute autonomously in one cycle while preserving internal tool interactions in the session history.

_contributing/samples/multi\agent · high confidence

New multimodal sample agents for computer use, image generation, and static non-text content

Added four new sample agents in the contributing/samples/multimodal directory to demonstrate advanced capabilities. The computer\_use sample provides a Playwright-based agent that automates Chromium browser tasks using the ComputerUseToolset and the gemini-2.5-computer-use-preview-10-2025 model. The generate\_image sample introduces an agent that leverages the Vertex AI imagen-3.0-generate-002 model to create images and manage artifacts. The multimodal sample showcases the gemini-2.5-flash-image model for direct text-and-image input/output. Finally, the static\_non\_text\_content sample demonstrates how to embed mixed content (inline images and file references) into agent instructions, supporting both Gemini Developer API file uploads and Vertex AI GCS/HTTPS file access. Also in this area: 2 commits (1 fix) modifying contributing.

contributing/samples/multimodal · medium confidence · unverified

New platform abstraction layer for runtime services

A new \src/google/adk/platform\ module has been introduced to abstract core runtime services, allowing the framework to support different execution environments. This location contributes specific provider modules for random number generation (\\_random.py\), system time (\time.py\), unique ID generation (\uuid.py\), and thread creation (\thread.py\). Each module exposes functions to get the current value (e.g., \get\_random\, \get\_time\, \new\_uuid\) and allows users to inject custom providers via setter functions (e.g., \set\_random\_provider\, \set\_time\_provider\), enabling features like deterministic testing or platform-specific optimizations.

src/google/adk/platform · high confidence

New plugin samples for invocation counting and tool retry logic

Added two new sample plugins under \contributing/samples/plugins\: \plugin\_basic\ demonstrates a \CountInvocationPlugin\ that tracks agent, tool, and LLM request counts using lifecycle callbacks, while \plugin\_reflect\_tool\_retry\ provides a \ReflectAndRetryToolPlugin\ sample that implements self-healing, concurrent-safe error recovery for tool failures, including handling hallucinated tool names.

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

New retrieval tools with lazy loading and configurable embeddings

The ADK now includes a new retrieval module offering three tools: FilesRetrieval (using LlamaIndex), LlamaIndexRetrieval, and VertexAiRagRetrieval. FilesRetrieval allows users to specify a custom embedding model or use the default gemini-embedding-2-preview. All retrieval tools use lazy loading to avoid blocking the event loop and require the google-adk\[extensions\] package. Additionally, when the JSON\_SCHEMA\_FOR\_FUNC\_DECL feature is enabled, these tools declare their parameters using JSON Schema instead of the legacy schema format.

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

New sample agents demonstrating structured I/O, HITL, and multi-agent patterns

Added a set of new sample agents in the \contributing/samples\ directory to illustrate key ADK capabilities. These include examples of agents with typed \input\_schema\ and \output\_schema\ for structured data handling, a Human-in-the-Loop (HITL) sample using the \request\_input\ tool, and multi-agent workflows featuring single-turn and task-mode sub-agents. Additional samples demonstrate integration with CrewAI and Langchain tools, live voice workflows, Azure OpenAI streaming, and LiteLLM structured outputs.

google-adk · high confidence

New sample for creating and managing custom agent resources

Added a new sample in \contributing/samples/managed\_agent/custom\_agent\ that demonstrates the full lifecycle of a custom managed agent. This sample shows how to provision a persistent, named agent resource with a specific persona and server-side tools (Google Search) using the GEAP/Vertex backend, drive interactions with it, and subsequently 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

New samples for remote sandbox environments and skill toolsets

This location adds sample agents demonstrating how to run code and skills in isolated remote sandboxes using the new \E2BEnvironment\ and \DaytonaEnvironment\ integrations, alongside updated examples for \SkillToolset\ execution in both local and remote environments. Users can now see how to configure agents to download and analyze datasets safely in E2B or Daytona sandboxes, and how to load and execute skill scripts (like calculation and text formatting) within those remote workspaces or locally via \LocalEnvironment\.

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

New session service architecture with lazy loading and secure legacy migration

The session service module has been restructured to introduce lazy loading for \DatabaseSessionService\, \InMemorySessionService\, and \VertexAiSessionService\, improving cold-start performance by deferring heavy imports until the services are actually used. A new \SqliteSessionService\ has been added to provide a lightweight, schema-flexible storage backend using \aiosqlite\ and JSON columns, alongside a migration path from the legacy SQLAlchemy-based \DatabaseSessionService\. To address security concerns with the legacy v0 schema, a restricted pickle unpickler (\\_restricted\_pickle.py\) now limits deserialization to a strict allowlist of data types, preventing arbitrary code execution from untrusted session payloads. Additionally, session rewind logic has been extracted into a dedicated utility module (\\_rewind\_utils.py\) to handle state and artifact reversal, and the \State\ class now supports optional Pydantic schema validation for type-safe state mutations.

src/google/adk/sessions · high confidence

New skill to verify Python code snippets in documentation

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 with per-snippet coverage. The skill distinguishes between runnable snippets (containing ADK components like \Workflow\, \Agent\, or \App\) and load-only snippets, supports ignoring specific blocks via HTML comments, and requires a Gemini API key for snippets that interact with the live API.

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

New tool samples for agents, grounding, parallel execution, and structured output

The contributing/samples/tools directory now includes several new demonstration agents: an agent tool with grounding metadata using Vertex AI Search, a sample combining built-in Google Search and Vertex AI Search tools, a function tools sample showing standard and generator-based tools with progress streaming, a long-running functions sample for asynchronous operations, a model consult sample for escalating complex policy decisions to an advisor model, an output schema sample combining structured responses with tools, and a parallel functions sample demonstrating concurrent async tool execution.

contributing/samples/tools · high confidence

New workflow orchestration framework with parallel execution and human-in-the-loop support

The \src/google/adk/workflow\ package introduces a new workflow engine that allows users to define complex, multi-step agent flows using a graph-based model. Key capabilities include parallel execution of nodes via the \parallel\_worker\ flag and \max\_parallel\_workers\ parameter, support for human-in-the-loop (HITL) interactions through \RequestInput\ and authentication resumption, and robust error handling with configurable \RetryConfig\. Users can now wrap functions or agents as nodes using the \@node\ decorator or \FunctionNode\ class, manage state and inputs via \parameter\_binding\, and orchestrate execution with \Workflow\, \JoinNode\, and \NodeRunner\ components. Also in this area: 18 commits (15 fixes) fixing src/google; Agent mode handling, compaction safety, and auth security hardening; Improved sync generator execution and abort handling in workflow nodes; Agent Builder Assistant now validates against the installed ADK version.

src/google/adk/workflow · medium confidence · unverified

New workflow samples for agents, authentication, and dynamic execution

Added new samples in \contributing/samples/workflows\ demonstrating key ADK capabilities: embedding \task\ and \single\_turn\ mode Agents as workflow nodes with tool confirmation (\agent\_in\_workflow\), requiring API key and OAuth2 authentication on FunctionNodes (\auth\_api\_key\, \auth\_oauth\), and performing dynamic fan-out/fan-in and loop-based execution via \ctx.run\_node()\ (\dynamic\_fan\_out\_fan\_in\, \dynamic\_nodes\).

contributing/samples/workflows · high confidence

New workflow utility modules for graph parsing, validation, and rehydration

This change introduces a new \src/google/adk/workflow/utils\ package containing core utilities for workflow graph construction and execution. The \build\_node\ function now supports \parameter\_binding\ to control how function parameters are bound (state vs. node input), and sub-agents dynamically attached to a parent default to 'chat' mode. Graph validation has been extracted to enforce constraints such as forbidding routed edges from START, detecting unconditional cycles, and validating schema mismatches. Rehydration and replay logic is centralized in \ReplayManager\ and \\_replay\_interceptor\, which use an indexed event system to prevent O(n^2) performance issues and ensure deterministic replay ordering via a sequence barrier. Additional utilities handle agent transfers, retry configurations with jittered delays, and Human-in-the-Loop (HITL) interrupt management. Also in this area: 18 commits (15 fixes) fixing src/google; Agent mode handling, compaction safety, and auth security hardening; Improved sync generator execution and abort handling in workflow nodes; Agent Builder Assistant now validates against the installed ADK version.

src/google/adk/workflow/utils · medium confidence · unverified

Sample code for registering custom memory services via Python and YAML

Added sample files in the contributing/samples directory demonstrating how to register custom memory services with the ADK CLI. The new dummy\_services.py file provides two example implementations (FooMemoryService and BarMemoryService) that return fixed responses. The services.py file shows how to register a custom service factory programmatically using the CLI's service registry, while services.yaml provides an alternative YAML-based registration method for the BarMemoryService. These samples illustrate the --memory\_service\_uri flag usage for both Python-based and configuration-based service registration.

contributing/samples · high confidence

Structured A2A request and response logging with file payload protection

Added utility functions in the A2A logs module to format A2A request and response data into structured, human-readable log entries. This includes detailed logging of message parts (text, data, and file metadata) while explicitly excluding raw file bytes from log lines to prevent sensitive or large binary data from cluttering debug output. The implementation supports both A2A SDK 0.3.x and 1.x via a compatibility layer and ensures proper handling of client events and task statuses in the logs.

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

Security

Path traversal protection and path normalization in Agent Builder file tools

The Agent Builder Assistant now sanitizes file paths generated by the model to remove stray quotes and whitespace, and enforces a strict root-directory boundary when resolving file operations. By validating that resolved paths remain within the designated root directory (defined in session state or the current working directory), the CLI blocks path-traversal attempts that could access files outside the intended scope, ensuring safer file interactions for users.

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

Architecture

ADK v2.0.0 introduces a modular LLM flow architecture with backward-compatibility shims

The framework has been restructured for the v2.0.0 release, relocating core LLM flow logic into a new \google.adk.flows\ package. This change introduces a processor-based pipeline (request and response processors) for managing LLM interactions, including new capabilities for context caching, event compaction, and agent transfer. To ensure a smooth transition, the previous module locations are now deprecated shims that re-export the new symbols, allowing existing code to continue working while encouraging migration to the new modular structure.

src/google/adk/flows · high confidence

New internal utility package for callable introspection, callbacks, and client configuration

The \src/google/adk/utils\ package has been introduced to centralize shared infrastructure for the ADK. It provides a unified callable introspection system (\\_callable\_utils\) that standardizes how FunctionTools and FunctionNodes inspect function signatures, docstrings, and type hints. A new callback pipeline (\\_callback\_pipeline\) handles invocation and argument adaptation for event listeners. Client-side concerns are addressed with utilities for generating tracking headers (\\_google\_client\_headers\), managing mTLS endpoints (\\_mtls\_utils\), and resolving GCP metadata defaults (\\_gcp\_metadata\). Additional helpers include safe JSON parsing, lazy package loading, per-event-loop caching, and schema validation utilities.

src/google/adk/utils · high confidence

Behavioural changes

1 commit (0 fixes) modifying src/google/adk/integrations/fsspec

A change to existing behaviour in src/google/adk/integrations/fsspec — 1 commit, 2 files: “feat(artifacts): add experimental FsspecArtifactService with read and listing support”.

src/google/adk/integrations/fsspec · medium confidence · unverified

1 commit (0 fixes) modifying src/google/adk/integrations/teams

A change to existing behaviour in src/google/adk/integrations/teams — 1 commit, 2 files: “feat(integrations): add TeamsRunner for Microsoft Teams”.

src/google/adk/integrations/teams · medium confidence · unverified

11 commits (5 fixes) modifying src/google/adk/tools/environment\_simulation

A change to existing behaviour in src/google/adk/tools/environment\_simulation — 11 commits (5 fixs), 8 files: “feat(tools): add semantic argument matching to Environment Simulation injections”; “refactor(types): type the environment simulation tools for strict mypy”; “fix: use asyncio.sleep to avoid blocking event loop”; and 8 more.

_src/google/adk/tools/environment\simulation · medium confidence · unverified

13 commits (6 fixes) modifying src/google/adk/integrations/gcs

A change to existing behaviour in src/google/adk/integrations/gcs — 13 commits (6 fixs), 7 files: “chore: fix mypy strict type errors in adk integrations”; “refactor(types): type the integrations, skills and MCP tool packages for strict mypy”; “fix(tools): stop gcs clients being shared across credentials”; and 8 more.

src/google/adk/integrations/gcs · medium confidence · unverified

2 commits (0 fixes) modifying contributing/samples/managed\_agent/remote\_mcp

A change to existing behaviour in contributing/samples/managed\_agent/remote\_mcp — 2 commits, 3 files: “docs(agents): update ManagedAgent examples and tests to antigravity-preview-09-2026”; “docs(samples): add ManagedAgent remote MCP (Maps Grounding Lite) sample”.

_contributing/samples/managed\_agent/remote\mcp · medium confidence · unverified

2 commits (0 fixes) modifying contributing/samples/managed\_agent/single\_turn

A change to existing behaviour in contributing/samples/managed\_agent/single\_turn — 2 commits, 3 files: “docs(agents): update ManagedAgent examples and tests to antigravity-preview-09-2026”; “docs(samples): Add ManagedAgent single-turn sub-agent sample”.

_contributing/samples/managed\_agent/single\turn · medium confidence · unverified

2 commits (0 fixes) modifying contributing/samples/managed\_agent/system\_instruction

A change to existing behaviour in contributing/samples/managed\_agent/system\_instruction — 2 commits, 3 files: “docs(agents): update ManagedAgent examples and tests to antigravity-preview-09-2026”; “docs(agents): add system-instruction sample and guide section”.

_contributing/samples/managed\_agent/system\instruction · medium confidence · unverified

2 commits (0 fixes) modifying src/google/adk/tools/tool\_args\_matcher

A change to existing behaviour in src/google/adk/tools/tool\_args\_matcher — 2 commits, 2 files: “feat(tools): add semantic argument matching to Environment Simulation injections”; “feat(tools): add extensible tool argument matcher”.

_src/google/adk/tools/tool\_args\matcher · medium confidence · unverified

5 commits (0 fixes) modifying src/google/adk/integrations

A change to existing behaviour in src/google/adk/integrations — 5 commits, 3 files: “refactor(types): type the integrations, skills and MCP tool packages for strict mypy”; “chore: adds \_\init\\_.py for integrations/ folder”; “chore: Add README for integrations folder”.

src/google/adk/integrations · medium confidence · unverified

5 commits (0 fixes) modifying src/google/adk/integrations/e2b

A change to existing behaviour in src/google/adk/integrations/e2b — 5 commits, 2 files: “feat(features): promote 16 toolset and integration features to stable”; “feat(integrations): Add E2BEnvironment for remote sandbox workspaces”; “feat(integrations): Add DaytonaEnvironment for remote sandbox workspaces”; and 2 more.

src/google/adk/integrations/e2b · medium confidence · unverified

7 commits (2 fixes) modifying src/google/adk/integrations/daytona

A change to existing behaviour in src/google/adk/integrations/daytona — 7 commits (2 fixs), 2 files: “refactor(types): type the integrations, skills and MCP tool packages for strict mypy”; “feat(features): promote 16 toolset and integration features to stable”; “feat(integrations): Add DaytonaEnvironment for remote sandbox workspaces”; and 3 more.

src/google/adk/integrations/daytona · medium confidence · unverified

9 commits (0 fixes) modifying src/google/adk/integrations/mongodb

A change to existing behaviour in src/google/adk/integrations/mongodb — 9 commits, 7 files: “feat: add MongoDB toolset with vector and hybrid search”; “feat(integrations): add vector search retrieval to MongoDbMemoryService”; “docs: add security section to MongoDB integration README”; and 6 more.

src/google/adk/integrations/mongodb · medium confidence · unverified

ADK CLI v2.0.0 GA: New modular architecture and expanded deployment options

The ADK CLI has been upgraded to version 2.0.0 GA, introducing a complete architectural refactor of the command-line interface. The monolithic CLI tool has been modularized into distinct components for creation (\cli\_create\), evaluation (\cli\_eval\), and deployment (\cli\_deploy\), with a new \DeployerFactory\ pattern supporting generalized Docker and Cloud Run deployments. The \adk create\ command now supports both Python code and YAML configuration types, defaulting to the \gemini-3.5-flash\ model. Deployment capabilities have expanded to include direct support for Agent Engine and GKE, alongside new options for Cloud Build private worker pools and Cloud Run sandboxes. The CLI also introduces new features for evaluation, including \adk eval\ with detailed result reporting and support for custom metrics, and adds \--enable\_features\/\--disable\_features\ flags for runtime feature toggling.

src/google/adk/cli · high confidence

API Hub client now supports mTLS and fixes credential acquisition

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

BigQuery tools deprecated in favor of integrations/bigquery

The BigQuery tools located in \src/google/adk/tools/bigquery\ are now deprecated and emit a \DeprecationWarning\ when imported. All public symbols (such as \BigQueryToolset\, \BigQueryCredentialsConfig\, and \get\_bigquery\_skill\) and submodules (including \client\, \config\, \query\_tool\, \search\_tool\, \data\_insights\_tool\, \metadata\_tool\, \bigquery\_skill\, and \bigquery\_toolset\) have been moved to \google.adk.integrations.bigquery\. Existing code using the old \google.adk.tools.bigquery\ path will continue to function via backward-compatible forwarding, but users should migrate their imports to the new \integrations\ location to avoid deprecation warnings.

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

Centralized external dependency imports for MCP, HTTP, and evaluation tools

The ADK now routes imports for the MCP SDK, HTTP client libraries, Vertex AI, and ROUGE evaluation through a dedicated \src/google/adk/dependencies\ package. This change consolidates external dependencies into a single seam, allowing the codebase to support both MCP SDK 1.x and 2.x (resolving API differences like \FastMCP\/\MCPServer\ and \httpx\/\httpx2\) and ensuring that evaluation metrics correctly handle non-English responses in ROUGE-1 matching. Users benefit from improved compatibility with newer SDK versions and more robust evaluation capabilities without needing to manage these complex import resolutions themselves.

src/google/adk/dependencies · high confidence

Deprecate ApiRegistry in favor of AgentRegistry with mTLS support

The ApiRegistry integration in src/google/adk/integrations/api\_registry is now deprecated and users should migrate to AgentRegistry. This update introduces mutual TLS (mTLS) support for API registry requests, allowing secure connections when client certificates are available, and ensures that authentication credentials are only attached to Google API endpoints rather than arbitrary MCP server URLs.

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

Deprecation of agent\_simulator in favor of environment\_simulation

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

Human-in-the-loop sample now correctly processes long-running tool outcomes

The human-in-the-loop sample in \contributing/samples/hitl/human\_in\_loop\ has been updated to properly handle long-running tools like \ask\_for\_approval\. The \main.py\ script now captures the initial pending response, simulates an external approval, and sends the updated result back to the agent via a \FunctionResponse\ with the matching ID. This ensures the agent correctly transitions from a pending state to executing the final action (e.g., \reimburse\), as verified by the new test cases for auto-approval and manual approval flows.

_contributing/samples/hitl/human\_in\loop · high confidence

Introduces lazy loading for tools and new internal utility modules

The \src/google/adk/tools\ package now uses lazy loading for its public exports via a \\_\getattr\\_\ implementation and a \\_LAZY\_MAPPING\ dictionary, which defers the import of heavy tool modules until they are actually accessed to improve cold-start performance. This change also introduces several new internal utility modules, including \\_automatic\_function\_calling\_util\ for Pydantic-based schema generation, \\_function\_tool\_declarations\ for building FunctionDeclaration objects, \\_confirmation\_utils\ for handling tool execution confirmation gates, \\_forwarding\_artifact\_service\ for delegating artifact operations to the tool context, and \\_gemini\_schema\_util\ for sanitizing and normalizing JSON schemas for the Gemini API.

src/google/adk/tools · high confidence

Langchain tools now respect the return\_direct flag

When wrapping a Langchain tool using LangchainTool, the adapter now checks the underlying tool's return\_direct attribute. If this flag is true, the tool's result is returned directly to the model without summarization, allowing for immediate handling of specific outputs rather than generic summaries.

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

New modular credential refresher architecture for OAuth2

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

New structured error classes for sessions, invocations, and tools

The errors module now provides specific exception classes to replace generic exceptions, improving error handling precision. InvocationNotFoundError is raised when an invocation ID is missing during rewind, inheriting from ValueError for backward compatibility. StaleSessionError handles optimistic concurrency failures during session writes. ToolExecutionError now includes a semantic error type (e.g., BAD\_REQUEST, NOT\_FOUND) to support OpenTelemetry span attributes. Additionally, new exceptions include SessionNotFoundError for missing sessions, AlreadyExistsError for duplicate resource creation, InputValidationError for invalid user input, and NotFoundError as a base for missing entity errors.

src/google/adk/errors · high confidence

OpenAI integration moved to stable location with backward-compatible aliases

The OpenAI model implementations have been moved from the experimental \google.adk.labs.openai\ package to the stable \google.adk.integrations.openai\ location. To ensure existing code continues to work without modification, the \labs.openai\ module now re-exports the classes (\OpenAILlm\, \OpenAIResponsesLlm\, \AzureOpenAIResponsesLlm\, and \OpenAIGenerateContentConfig\) from the new location. Users are encouraged to update their imports to use the stable \google.adk.integrations.openai\ path for new code.

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

OpenAPI toolset now supports preserving original property names and customizing HTTP clients

The OpenAPI toolset and its underlying spec parser have been refactored to expose new configuration options for users. You can now set \preserve\_property\_names=True\ when initializing the toolset to keep original parameter names (e.g., camelCase) instead of converting them to snake\_case, which is useful for APIs that do not accept normalized names. Additionally, the toolset now accepts an \httpx\_client\_factory\ argument, allowing you to provide a custom \httpx.AsyncClient\ for all generated tools, enabling advanced HTTP configurations like custom proxies or HTTP/2 support. The parser also now correctly handles operation-level parameter overrides and treats empty security requirements as optional authentication.

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

Service account authentication now uses OAuth2 client-credentials scheme

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

Updated browser assets and added ADK favicon

The browser bundle has been updated with new compiled JavaScript chunks (including parsers for ABNF, Mermaid journey diagrams, and tree views) and a new \adk\_favicon.svg\ file, reflecting the latest changes from the adk-web repository.

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

Fixes

18 commits (15 fixes) fixing src/google

A fix in src/google — 18 commits (15 fixs), 89 files: “fix: serialize Firestore event payloads and wrap nested state arrays”; “fix: treat an empty session id as absent in DatabaseSessionService”; “feat(integrations): add vector search retrieval to MongoDbMemoryService”; and 15 more. Also in this area: 2 commits (1 fix) modifying src/google/adk/integrations; OpenAI integration moved out of labs with new installable extra.

_src/google/adk/integrations/openai, src/google/adk/integrations/typesafe, src/google/adk/plugins/bigquery\_agent\_analytics\sql · medium confidence · unverified

5 commits (3 fixes) fixing src/google/adk/integrations/eventarc

A fix in src/google/adk/integrations/eventarc — 5 commits (3 fixs), 5 files: “feat(eventarc): add Eventarc Advanced toolset for ADK”; “fix: key Eventarc client cache by full credential identity and scopes”; “fix: scope cached Eventarc publisher clients per running event loop”; and 1 more.

src/google/adk/integrations/eventarc · medium confidence · unverified

Improved database schema support for JSON and timestamp precision

The session storage layer now includes a new shared schema module that enhances compatibility across different database backends. It introduces a DynamicJSON type that uses native JSONB on PostgreSQL and LONGTEXT on MySQL to prevent data truncation, while falling back to standard TEXT elsewhere. Additionally, a PreciseTimestamp type ensures microsecond-precision storage on SQL Server (using DATETIME2(6)) to fix optimistic concurrency issues, and handles SQLite float timestamps correctly by converting them to UTC datetimes.

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

Test coverage

Added unit tests for the models package

Added a comprehensive suite of unit tests in tests/unittests/models covering the LLM model implementations and related utilities. The new tests verify the behavior of specific model adapters including Anthropic (Claude), Apigee, Gemini, Gemma, and LiteLLM, as well as supporting components like CacheMetadata, LlmCapabilities, FallbackModel, and custom client injection. These tests ensure correct request/response handling, streaming, error propagation, and configuration for these model integrations. Also in this area: 23 commits adding/updating tests in tests; 1 commit adding/updating tests in tests/unittests/telemetry; Added unit tests for example utilities and Vertex AI example store; Added unit tests for workflow utility functions; Added live integration tests for AgentEngineEnvironment; and 117 more.

tests · high confidence · unverified

Dependencies

Google ADK v2.11.0 release with lazy-loaded public API

The Google Agent Development Kit (ADK) has been updated to version 2.11.0. This release introduces a lazy-loading mechanism for the top-level public API (importing google.adk), which defers the import of heavy modules like Agent, Context, Event, Runner, and Workflow until they are actually used, improving import performance. The package also includes a py.typed marker file to enable static type checking for consumers of the library.

src/google/adk · high confidence

Initial release of Google ADK v2.6 with Python 3.14 support and expanded integrations

This entry introduces the Google Agent Development Kit (ADK) v2.6, establishing a new baseline for the library. The package now requires Python 3.10 or higher and explicitly supports Python 3.14. Core dependencies have been updated, including FastAPI (\>=0.133), Google GenAI (\>=2.19), and Pydantic (\>=2.12). The release adds extensive optional dependencies for integrations such as A2A, Agent Identity, MCP, and various Google Cloud services (BigQuery, Bigtable, Spanner, Firestore, etc.), alongside support for third-party tools like CrewAI, LangGraph, and OpenAI. Sample requirements files are also provided for specific integration scenarios like authentication and knowledge agents.

(dependencies) · high confidence

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

How this codebase got here

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 43 → 45 (+2.3)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 29 → 29 (+0.0)
  • Architecture 92 → 93 (+0.9)
  • Maturity 48 → 76 (+28.0)
  • Readiness 46 → 46 (+0.0)
  • Security 86 → 81 (-5.6)
  • Domain Modelling 73 → 73 (+0.0)
  • Accessibility 59 → 57 (-2.0)
  • Performance 100 → 100 (+0.0)

Resolved (67)

  • AnthropicLlm.generate_content_async (cyclomatic 16) (src/google/adk/models/anthropic_llm.py)
  • AutoTracingPlugin._wrap_module (cognitive 22) (src/google/adk/plugins/auto_tracing_plugin.py)
  • Duplicated block (12–22 lines × 2) (src/google/adk/artifacts/gcs_artifact_service.py)
  • Duplicated block (12–31 lines × 2) (src/google/adk/integrations/openai/_openai_schema.py)
  • Duplicated block (13 lines × 2) (src/google/adk/tools/skill_toolset.py)
  • Duplicated block (13–17 lines × 2) (src/google/adk/models/google_llm.py)
  • Duplicated block (14 lines × 4) (src/google/adk/tools/spanner/metadata_tool.py)
  • Duplicated block (19 lines × 2) (src/google/adk/flows/llm_flows/tools/_error_handler.py)
  • Duplicated block (30 lines × 2) (src/google/adk/integrations/parameter_manager/parameter_client.py)
  • Duplicated block (32 lines × 2) (src/google/adk/skills/_utils.py)
  • Duplicated block (36–60 lines × 3) (src/google/adk/tools/spanner/metadata_tool.py)
  • Duplicated block (8 lines × 2) (src/google/adk/integrations/redis/_redis_session_service.py)
  • Duplicated block (9–10 lines × 2) (src/google/adk/sessions/in_memory_session_service.py)
  • Hotspot: contributing/samples/integrations/gcp_auth/client/main.py (contributing/samples/integrations/gcp_auth/client/main.py)
  • Hotspot: src/google/adk/a2a/converters/part_converter.py (src/google/adk/a2a/converters/part_converter.py)
  • Hotspot: src/google/adk/integrations/eventarc/_domain_specific_publish.py (src/google/adk/integrations/eventarc/_domain_specific_publish.py)
  • Hotspot: src/google/adk/tools/bash_tool.py (src/google/adk/tools/bash_tool.py)
  • Low cohesion: BaseLlmFlow (LCOM4 6) (src/google/adk/flows/llm_flows/base_llm_flow.py)
  • Medium: security finding (details withheld)
  • Members sharing a duplicated core (23 members, 50+ identical tokens) (contributing/samples/a2a/a2a_basic/remote_a2a/check_prime_agent/agent.py)
  • …and 47 more

New (140)

  • A2aAgentExecutor._handle_request (cyclomatic 18) (src/google/adk/a2a/executor/a2a_agent_executor.py)
  • AgentEvaluator.evaluate_eval_set (cognitive 17) (src/google/adk/evaluation/agent_evaluator.py)
  • AgentEvaluator.evaluate_eval_set (cyclomatic 17) (src/google/adk/evaluation/agent_evaluator.py)
  • AutoTracingPlugin._wrap_class (cognitive 18) (src/google/adk/plugins/auto_tracing_plugin.py)
  • BigQueryAgentAnalyticsPlugin.init (cognitive 17) (src/google/adk/plugins/bigquery_agent_analytics_plugin.py)
  • BigQueryAgentAnalyticsPlugin._drain_workflow_node_observations (cognitive 16) (src/google/adk/plugins/bigquery_agent_analytics_plugin.py)
  • BigQueryAgentAnalyticsPlugin._record_workflow_node_observation (cognitive 46) (src/google/adk/plugins/bigquery_agent_analytics_plugin.py)
  • BigQueryAgentAnalyticsPlugin._record_workflow_node_observation (cyclomatic 24) (src/google/adk/plugins/bigquery_agent_analytics_plugin.py)
  • Change coupling: init.py ↔ adk_web_server.py (src/google/adk/apps/init.py)
  • Change coupling: response_evaluator.py ↔ trajectory_evaluator.py (src/google/adk/evaluation/response_evaluator.py)
  • ChatCompletionsResponseHandler.process_chunk (cyclomatic 18) (src/google/adk/models/apigee_llm.py)
  • ChatCompletionsResponseHandler.process_response (cognitive 37) (src/google/adk/models/apigee_llm.py)
  • ChatCompletionsResponseHandler.process_response (cyclomatic 22) (src/google/adk/models/apigee_llm.py)
  • ContainerCodeExecutor._get_output_files (cognitive 22) (src/google/adk/code_executors/container_code_executor.py)
  • CredentialManager._refresh_credential (cognitive 17) (src/google/adk/auth/credential_manager.py)
  • Duplicated block (11 lines × 2) (src/google/adk/integrations/openai/_openai_decisions_classifier.py)
  • Duplicated block (12 lines × 2) (src/google/adk/a2a/agent/_remote_a2a_agent.py)
  • Duplicated block (12 lines × 2) (src/google/adk/evaluation/_multi_run_aggregation_methods.py)
  • Duplicated block (12 lines × 2) (src/google/adk/plugins/plugin_manager.py)
  • Duplicated block (14 lines × 4) (src/google/adk/tools/spanner/metadata_tool.py)
  • …and 120 more

Changes since last survey

  • 269 commits — 82 feature/other, 187 fixes

By area

  • src/google — 195 commits
  • tests/unittests — 33 commits
  • docs/guides — 22 commits
  • (root) — 9 commits
  • contributing/samples — 6 commits
  • .agents/skills — 3 commits
  • .github/workflows — 1 commit

Notable commits

  • fix: fix!: close malformed live WebSockets instead of wedging them
  • fix: fix(a2a): propagate task cancellation to active runner invocations
  • fix: fix(antigravity): extract subagent names from step tool calls and avoid root_agent_subagent fallback
  • fix: fix(apps): close LLM stream on early exit in LlmEventSummarizer
  • fix: fix(auth): support raw token strings in HTTP and API key auth resume
  • fix: fix(bigquery): improve error messages when write_mode is BLOCKED
  • fix: fix(cli): monitor ASGI receive channel for client disconnect in /run_sse
  • fix: fix(compaction): cancel in-flight summarization when invocation aborts
  • fix: fix(eval): preserve live usage without extra inference calls
  • fix: fix(flows): elide system instruction markers from relayed agent text
  • fix: fix(flows): run on_model_error callbacks when a model call is cancelled
  • fix: fix(live): drop saved audio from history replayed to the CascadeLive reasoner
  • fix: fix(live): log live event and request identifiers instead of contents
  • fix: fix(live): make CascadeLive reply to history that ends with a user turn
  • fix: fix(live): stop adding set_model_response to live sessions
  • fix: fix(otel): degrade gracefully when OTel exporter packages are missing
  • fix: fix(plugins): answer failed tool calls in eval traces and skip HITL tools
  • fix: fix(plugins): mark truncated eval turns not ready
  • fix: fix(plugins): prevent BQAA offload data loss and preserve binary MIME
  • fix: fix(runner): close isolated runs that end on a terminal node outcome
  • …and 249 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 5 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 54a6bbbfc59e247c6552555cffcdf2faf4810699 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.11.2+preprod-f68843d12c58.