@google/adk 2.0.0 → 2.1.0

package/dist/esm/workflow/request_input.js

@@ -9,7 +9,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 var _a;
 import { randomUUID } from "../utils/env_aware_utils.js";
-const REQUEST_INPUT_SIGNATURE_SYMBOL = Symbol.for(
+const REQUEST_INPUT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
   "google.adk.workflow.requestInput"
 );
 _a = REQUEST_INPUT_SIGNATURE_SYMBOL;

package/dist/esm/workflow/run_llm_agent_as_node.js

@@ -50,7 +50,7 @@ async function appendNodeInputAsUserTurn(ctx, nodeInput) {
     branch: ctx.branch,
     content: toUserContent(nodeInput)
   });
-  if (ctx.isolationScope) {
+  if (ctx.isolationScope !== void 0) {
     userEvent.isolationScope = ctx.isolationScope;
   }
   const sessionService = ctx.invocationContext.sessionService;

package/dist/esm/workflow/workflow.js

@@ -42,7 +42,7 @@ import {
   reconstructNodeRuns,
   resolvedInterruptResponses
 } from "./utils/rehydration_utils.js";
-const WORKFLOW_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.workflow");
+const WORKFLOW_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.workflow.workflow");
 const _LoopState = class _LoopState {
   constructor() {
     this.nodes = /* @__PURE__ */ new Map();

package/dist/types/a2a/a2a_event.d.ts

@@ -120,7 +120,13 @@ export declare function createTaskFailedEvent({ taskId, contextId, error, metada
     metadata?: Record<string, unknown>;
 }): TaskStatusUpdateEvent;
 /**
- * Creates an input required event.
+ * Creates an input-required status update.
+ *
+ * A2A has one `input-required` state, so every reason an agent can pause for a
+ * human produces the same status update: a long-running tool asking for input,
+ * and a client message that left an earlier request unanswered. What separates
+ * them travels in `parts` — a validation failure carries a text part marked
+ * `validation_error` — not in the shape of the event, so both go through here.
  */
 export declare function createTaskInputRequiredEvent({ taskId, contextId, parts, metadata, }: {
     taskId: string;
@@ -128,12 +134,3 @@ export declare function createTaskInputRequiredEvent({ taskId, contextId, parts,
     parts: A2APart[];
     metadata?: Record<string, unknown>;
 }): TaskStatusUpdateEvent;
-/**
- * Creates an error message for missing input for a function call.
- */
-export declare function createInputMissingErrorEvent({ taskId, contextId, parts, metadata, }: {
-    parts: A2APart[];
-    taskId: string;
-    contextId: string;
-    metadata?: Record<string, unknown>;
-}): TaskStatusUpdateEvent;

package/dist/types/a2a/a2a_remote_agent.d.ts

@@ -65,6 +65,11 @@ export interface RemoteA2AAgentConfig extends BaseAgentConfig {
      * Callbacks run after receiving a response chunk or event, before conversion.
      */
     afterRequestCallbacks?: AfterA2ARequestCallback[];
+    /**
+     * Optional request-level metadata to include in the A2A message send request.
+     * If omitted, defaults to `context.a2aMetadata` from the current invocation context.
+     */
+    metadata?: Record<string, unknown>;
 }
 /**
  * RemoteA2AAgent delegates execution to a remote agent using the A2A protocol.

package/dist/types/a2a/a2a_remote_agent_utils.d.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Part as A2APart } from '@a2a-js/sdk';
+import { Content } from '@google/genai';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event as AdkEvent } from '../events/event.js';
 import { Session } from '../sessions/session.js';
@@ -38,6 +39,30 @@ export declare function isFunctionCallEvent(event: AdkEvent, callId: string): bo
  *   none is found.
  */
 export declare function getFunctionResponseCallId(event: AdkEvent): string | undefined;
+/**
+ * Ids of credential requests the remote peer raised itself. An id that ANY
+ * non-peer event also issued a call for is excluded: the peer authors its
+ * own session events under its own name (`toAdkEvent` forces
+ * `author = this.name`) and controls `functionCall.id` verbatim, so a bare
+ * id match -- without checking whether some OTHER event also issued a call
+ * for that same id -- would let a peer re-label this agent's own pending
+ * credential request as one the peer had asked for, by sending an
+ * unrelated reply that happens to carry a function_call part whose id
+ * collides with it.
+ */
+export declare function peerRequestedCallIds(events: readonly AdkEvent[], peerName: string): ReadonlySet<string>;
+/**
+ * Converts genai parts to A2A parts for forwarding to the remote peer,
+ * scrubbing credential material the peer did not itself request.
+ *
+ * NOT the single point both session-forwarding paths converge on:
+ * `toMissingRemoteSessionParts` calls `withoutCredentialParts` directly,
+ * since it has to interleave `presentAsUserMessage` between the scrub and
+ * `toA2AParts`. The shared guarantee lives one level down, in
+ * `withoutCredentialParts` -- a third path calling `toA2AParts` directly
+ * would still bypass it.
+ */
+export declare function toForwardableA2AParts(content: Content | undefined, longRunningToolIds: string[] | undefined, peerRequestedIds: ReadonlySet<string>): A2APart[];
 /**
  * Returns A2A content parts for all events not yet seen by the remote agent,
  * along with the A2A context ID found in the most recent remote agent event.

package/dist/types/a2a/agent_card.d.ts

@@ -7,6 +7,15 @@ import { AgentCard, AgentInterface, AgentSkill } from '@a2a-js/sdk';
 import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
 /**
  * Resolves the AgentCard from the provided source.
+ *
+ * A source is either an {@link AgentCard}, an `http(s)://` URL to fetch it
+ * from, a `file://` URL, or a filesystem path. Any other URL scheme throws: a
+ * source that looks like a URL is never read off the local filesystem.
+ *
+ * The card host must not be, or resolve to, a link-local address, and a
+ * redirect from the card endpoint is refused rather than followed. Loopback and
+ * private addresses stay allowed: they are where a locally served or
+ * VPC-internal peer agent lives.
  */
 export declare function resolveAgentCard(agentCard: AgentCard | string): Promise<AgentCard>;
 /**

package/dist/types/a2a/agent_executor.d.ts

@@ -16,7 +16,7 @@ export type RunnerOrRunnerConfig = Runner | RunnerConfig | (() => Runner | Runne
 /**
  * Callback called before execution starts.
  */
-export type BeforeExecuteCallback = (reqCtx: RequestContext) => Promise<void>;
+export type BeforeExecuteCallback = (reqCtx: RequestContext, a2aMetadata?: Record<string, unknown>) => Promise<void>;
 /**
  * Callback called after an ADK event is converted to an A2A event.
  */

package/dist/types/a2a/agent_to_a2a.d.ts

@@ -11,6 +11,8 @@ import { BaseMemoryService } from '../memory/base_memory_service.js';
 import { Runner } from '../runner/runner.js';
 import { BaseSessionService } from '../sessions/base_session_service.js';
 import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
+import { AdkDefaultRequestHandler, getA2aRequestMetadata } from './request_metadata.js';
+export { AdkDefaultRequestHandler, getA2aRequestMetadata };
 /**
  * A request authenticator for the A2A surface.
  *

package/dist/types/a2a/auth.d.ts

@@ -15,7 +15,11 @@ import { A2aUserBuilder } from './agent_to_a2a.js';
  * text on every call.
  *
  * ```ts
- * toA2a(agent, {authentication: bearerTokenUserBuilder(process.env.MY_TOKEN)});
+ * const token = process.env.MY_TOKEN;
+ * if (!token) {
+ *   throw new Error('MY_TOKEN is not set');
+ * }
+ * toA2a(agent, {authentication: bearerTokenUserBuilder(token)});
  * ```
  *
  * A rejected request surfaces as whatever the `@a2a-js/sdk` handler produces

package/dist/types/a2a/executor_context.d.ts

@@ -18,16 +18,22 @@ export interface ExecutorContext {
     events: Event[];
     userContent: Content;
     requestContext: RequestContext;
+    /**
+     * Request-level metadata passed from an incoming A2A request.
+     */
+    a2aMetadata?: Record<string, unknown>;
 }
 /**
  * Creates an A2A Agent Executor context from the given parameters.
  * @param session The session.
  * @param userContent The content of the user.
  * @param requestContext The request context.
+ * @param a2aMetadata Optional request-level metadata.
  * @returns The A2A Agent Executor context.
  */
-export declare function createExecutorContext({ session, userContent, requestContext, }: {
+export declare function createExecutorContext({ session, userContent, requestContext, a2aMetadata, }: {
     session: Session;
     userContent: Content;
     requestContext: RequestContext;
+    a2aMetadata?: Record<string, unknown>;
 }): ExecutorContext;

package/dist/types/a2a/index.d.ts

@@ -12,7 +12,7 @@ export type { A2AStreamEventData, AfterA2ARequestCallback, BeforeA2ARequestCallb
 export { getA2AAgentCard } from './agent_card.js';
 export { A2AAgentExecutor } from './agent_executor.js';
 export type { AfterEventCallback, AfterExecuteCallback, AgentExecutorConfig, BeforeExecuteCallback, RunnerOrRunnerConfig, } from './agent_executor.js';
-export { toA2a } from './agent_to_a2a.js';
+export { AdkDefaultRequestHandler, getA2aRequestMetadata, toA2a, } from './agent_to_a2a.js';
 export type { A2aUserBuilder, ToA2aOptions } from './agent_to_a2a.js';
 export { bearerTokenUserBuilder } from './auth.js';
 export type { ExecutorContext } from './executor_context.js';

package/dist/types/a2a/request_metadata.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Message, MessageSendParams, Task, TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+import { DefaultRequestHandler, RequestContext, ServerCallContext } from '@a2a-js/sdk/server';
+/**
+ * Extracts request-level A2A metadata from a RequestContext.
+ *
+ * Supports @a2a-js/sdk >= 1.0.0 (`ctx.request.metadata`) and @a2a-js/sdk 0.3.x via
+ * `AdkDefaultRequestHandler`.
+ */
+export declare function getA2aRequestMetadata(ctx: RequestContext): Record<string, unknown> | undefined;
+/**
+ * A2A DefaultRequestHandler extension that preserves request-level metadata (`params.metadata`)
+ * across agent executions regardless of @a2a-js/sdk version.
+ */
+export declare class AdkDefaultRequestHandler extends DefaultRequestHandler {
+    sendMessage(params: MessageSendParams, context?: ServerCallContext): Promise<Message | Task>;
+    sendMessageStream(params: MessageSendParams, context?: ServerCallContext): AsyncGenerator<Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
+}

package/dist/types/agents/base_agent.d.ts

@@ -109,11 +109,15 @@ export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAg
      * When a list of callbacks is provided, the callbacks will be called in the
      * order they are listed until a callback does not return undefined.
      *
-     * @param callbackContext: MUST be named 'callbackContext' (enforced).
+     * Each callback takes a single {@link Context} argument. Returning `Content`
+     * skips this agent's own run — its `runAsyncImpl` body and its
+     * `afterAgentCallback` — and emits the returned content as this agent's
+     * response; return `undefined` to let the run proceed.
      *
-     * @return Content: The content to return to the user. When the content is
-     *     present, the agent run will be skipped and the provided content will be
-     *     returned to user.
+     * That skip is scoped to this agent. It sets `endInvocation` on the
+     * invocation context the agent created for itself, which is a copy of its
+     * parent's, so callers above are unaffected: a `SequentialAgent` still runs
+     * the remaining sub-agents.
      */
     readonly beforeAgentCallback: SingleAgentCallback[];
     /**
@@ -122,26 +126,25 @@ export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAg
      * When a list of callbacks is provided, the callbacks will be called in the
      * order they are listed until a callback does not return undefined.
      *
-     * @param callbackContext: MUST be named 'callbackContext' (enforced).
-     *
-     * @return Content: The content to return to the user. When the content is
-     *     present, the provided content will be used as agent response and
-     *     appended to event history as agent response.
+     * Each callback takes a single {@link Context} argument. Returning `Content`
+     * emits it as the agent's response, appended to the event history; return
+     * `undefined` to leave the response as the agent produced it.
      */
     readonly afterAgentCallback: SingleAgentCallback[];
     constructor(config: BaseAgentConfig);
     /**
      * Creates a copy of this agent with the given config fields overridden.
      *
-     * Mirrors adk-python's `BaseAgent.clone(update=...)`. The clone is a detached
-     * root: its `parentAgent` is always `undefined`. Sub-agents are recursively
-     * cloned (and re-parented to the clone) unless `subAgents` is overridden.
-     * Rebuilding via the concrete constructor re-derives all state, so a cloned
-     * `LlmAgent` gets a fresh `requestProcessors` array rather than sharing the
-     * original's. See google/adk-js#534.
+     * The clone is a detached root: its `parentAgent` is always `undefined`.
+     * Sub-agents are recursively cloned (and re-parented to the clone) unless
+     * `subAgents` is overridden. Rebuilding via the concrete constructor
+     * re-derives all state, so a cloned `LlmAgent` gets a fresh
+     * `requestProcessors` array rather than sharing the original's.
+     * See google/adk-js#534.
      *
      * @param overrides Config fields to override on the clone. Overriding
-     *     `parentAgent` is rejected, matching adk-python.
+     *     `parentAgent` is rejected: parentage is assigned only when a parent
+     *     agent is constructed with its sub-agents.
      * @returns A new detached agent instance of the same concrete class.
      */
     clone(overrides?: Partial<TConfig>): this;

package/dist/types/agents/context.d.ts

@@ -9,6 +9,7 @@ import { AuthConfig } from '../auth/auth_tool.js';
 import { EventActions } from '../events/event_actions.js';
 import { SearchMemoryResponse } from '../memory/base_memory_service.js';
 import { State } from '../sessions/state.js';
+import { ResumeInputs } from '../tools/resume_inputs.js';
 import { ToolConfirmation } from '../tools/tool_confirmation.js';
 import { InvocationContext } from './invocation_context.js';
 import { ReadonlyContext } from './readonly_context.js';
@@ -26,6 +27,7 @@ export declare class Context extends ReadonlyContext {
     readonly eventActions: EventActions;
     readonly functionCallId?: string;
     toolConfirmation?: ToolConfirmation;
+    readonly resumeInputs: ResumeInputs;
     readonly abortSignal?: AbortSignal;
     /**
      * @param options The configuration options for the Context.
@@ -38,12 +40,18 @@ export declare class Context extends ReadonlyContext {
      *     call.
      * @param options.toolConfirmation The tool confirmation of the current tool
      *     call.
+     * @param options.resumeInputs The inputs the current tool call is being
+     *     resumed with, if it paused to ask for them, keyed by interrupt id.
+     *     Defaults to empty rather than absent, matching adk-python's
+     *     `Context.resume_inputs`. Carries no approval; see
+     *     {@link ResumeInputs}.
      */
     constructor(options: {
         invocationContext: InvocationContext;
         eventActions?: EventActions;
         functionCallId?: string;
         toolConfirmation?: ToolConfirmation;
+        resumeInputs?: ResumeInputs;
     });
     /**
      * The delta-aware state of the current session.

package/dist/types/agents/functions.d.ts

@@ -7,6 +7,7 @@ import { FunctionCall } from '@google/genai';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event } from '../events/event.js';
 import { BaseTool } from '../tools/base_tool.js';
+import { ResumeInputs } from '../tools/resume_inputs.js';
 import { ToolConfirmation } from '../tools/tool_confirmation.js';
 import { SingleAfterToolCallback, SingleBeforeToolCallback } from './llm_agent.js';
 export { AF_FUNCTION_CALL_ID_PREFIX, generateClientFunctionCallId, populateClientFunctionCallId, } from '../events/event.js';
@@ -39,6 +40,11 @@ export declare function generateRequestConfirmationEvent({ invocationContext, fu
  * Handles function calls.
  * Runtime behavior to pay attention to:
  * - Iterate through each function call in the `functionCallEvent`:
+ *   - Resolve the named tool. If the name is not callable, run the on-tool-
+ *     error callbacks and answer the call with their response, or with the
+ *     resolution error when none handles it, then move to the next call. That
+ *     answer skips the before/after tool callbacks below, so a plugin auditing
+ *     every response does not observe it — as in Python.
  *   - Execute before tool callbacks !!if a callback provides a response, short
  *     circuit the rest.
  *   - Execute the tool.
@@ -47,7 +53,7 @@ export declare function generateRequestConfirmationEvent({ invocationContext, fu
  *   - If the tool is long-running and the response is null, continue. !!state
  * - Merge all function response events into a single event.
  */
-export declare function handleFunctionCallsAsync({ invocationContext, functionCallEvent, toolsDict, beforeToolCallbacks, afterToolCallbacks, filters, toolConfirmationDict, }: {
+export declare function handleFunctionCallsAsync({ invocationContext, functionCallEvent, toolsDict, beforeToolCallbacks, afterToolCallbacks, filters, toolConfirmationDict, resumeInputsDict, }: {
     invocationContext: InvocationContext;
     functionCallEvent: Event;
     toolsDict: Record<string, BaseTool>;
@@ -55,13 +61,22 @@ export declare function handleFunctionCallsAsync({ invocationContext, functionCa
     afterToolCallbacks: SingleAfterToolCallback[];
     filters?: Set<string>;
     toolConfirmationDict?: Record<string, ToolConfirmation>;
+    resumeInputsDict?: Record<string, ResumeInputs>;
 }): Promise<Event | null>;
+/**
+ * Whether `tool` is the placeholder handed to the on-tool-error callbacks for a
+ * function call naming a tool this agent cannot call.
+ *
+ * Lets a plugin tell an unresolvable name from a registered tool that threw
+ * without matching on the error message.
+ */
+export declare function isToolNotFound(tool: unknown): boolean;
 /**
  * The underlying implementation of handleFunctionCalls, but takes a list of
  * function calls instead of an event.
  * This is also used by llm_agent execution flow in preprocessing.
  */
-export declare function handleFunctionCallList({ invocationContext, functionCalls, toolsDict, beforeToolCallbacks, afterToolCallbacks, filters, toolConfirmationDict, }: {
+export declare function handleFunctionCallList({ invocationContext, functionCalls, toolsDict, beforeToolCallbacks, afterToolCallbacks, filters, toolConfirmationDict, resumeInputsDict, }: {
     invocationContext: InvocationContext;
     functionCalls: FunctionCall[];
     toolsDict: Record<string, BaseTool>;
@@ -69,18 +84,69 @@ export declare function handleFunctionCallList({ invocationContext, functionCall
     afterToolCallbacks: SingleAfterToolCallback[];
     filters?: Set<string>;
     toolConfirmationDict?: Record<string, ToolConfirmation>;
+    /**
+     * Inputs to resume a paused tool call with, keyed by function call id. Each
+     * value is itself keyed by interrupt id. Kept apart from
+     * `toolConfirmationDict` so resume inputs can never be mistaken for a human
+     * approval; see {@link ResumeInputs}.
+     */
+    resumeInputsDict?: Record<string, ResumeInputs>;
 }): Promise<Event | null>;
 /**
  * Merges a list of function response events into a single event.
  */
 export declare function mergeParallelFunctionResponseEvents(functionResponseEvents: Event[]): Event;
 /**
- * Finds the function call event that matches the function call ID.
- * Mirrors Python ADK's `find_event_by_function_call_id`.
+ * Finds the most recent event before `endIndex` that contains a function call
+ * with the given ID.
  */
 export declare function findEventByFunctionCallId(events: Event[], functionCallId: string, endIndex?: number): Event | undefined;
 /**
- * Finds the function call event that matches the function response ID of the last event.
- * Mirrors Python ADK's `find_matching_function_call`.
+ * Returns the event containing the function call that the last event's
+ * function response(s) answer, by matching functionCall.id to
+ * functionResponse.id.
+ *
+ * Every function response in the last event is checked, not just the
+ * first one. A single event can carry responses answering calls from
+ * different agents at once -- for example two long-running operations
+ * from sibling sub-agents completing together and being resumed in one
+ * message. Resolving from only `functionResponses[0]` would silently
+ * attribute the rest to whichever agent's call happened to come first,
+ * which is the wrong agent for any response that isn't the first one:
+ * that response would then be processed under a resumed agent's context
+ * it was never meant for, and the agent it actually answers would never
+ * be correctly resumed at all.
+ *
+ * This is a pure lookup: responses with no id, or whose id matches no
+ * function call, are skipped rather than treated as an error, and when
+ * several responses resolve to calls from more than one distinct
+ * author, this does not throw -- it returns the last-resolved match by
+ * iteration order (whichever response is checked last wins). That is a
+ * change from the pre-existing behavior of resolving only
+ * `functionResponses[0]` (which effectively made the first response
+ * win): an external caller of {@link findEventByLastFunctionResponseId}
+ * can now get a different event, and a different id, than before this
+ * fix, even though {@link determineAgentForResumption} itself is
+ * unaffected, since it only reads `.author` and every distinct-author
+ * case is instead surfaced there as a thrown conflict (see
+ * `getConflictingFunctionResponseAuthors`) after that caller's own
+ * resumability gate, not from this function.
  */
 export declare function findMatchingFunctionCall(events: Event[]): Event | undefined;
+/**
+ * Returns the distinct pair of authors when the last event's function
+ * responses resolve to function calls from more than one agent, or
+ * `undefined` when they all resolve to a single agent (or there is
+ * nothing to resolve).
+ *
+ * This performs the same walk as {@link findMatchingFunctionCall} but
+ * reports a conflict instead of silently resolving to one match, so
+ * that a caller can decide when it is safe to raise it. {@link
+ * determineAgentForResumption} is the only current caller, and calls
+ * this only once resumability is confirmed enabled: this function
+ * existing separately from `findMatchingFunctionCall`, rather than
+ * that function throwing directly, is what keeps a session with such
+ * an event from aborting every run (not only resumption attempts) --
+ * see that caller's own comment for why the check has to live there.
+ */
+export declare function getConflictingFunctionResponseAuthors(events: Event[]): [string, string] | undefined;

package/dist/types/agents/invocation_context.d.ts

@@ -54,6 +54,10 @@ export interface InvocationContextParams {
     nodeToolDepth?: number;
     liveRequestQueue?: LiveRequestQueue;
     liveSessionResumptionHandle?: string;
+    /**
+     * Request-level metadata passed from an incoming A2A request or caller.
+     */
+    a2aMetadata?: Record<string, unknown>;
 }
 /**
  * An invocation context represents the data of a single invocation of an agent.
@@ -76,7 +80,7 @@ export interface InvocationContextParams {
  *  An LLM agent runs steps in a loop until:
  *    1. A final response is generated.
  *    2. The agent transfers to another agent.
- *    3. The end_invocation is set to true by any callbacks or tools.
+ *    3. `endInvocation` is set to true by any callbacks or tools.
  *
  *  A step:
  *    1. Calls the LLM only once and yields its response.
@@ -84,7 +88,7 @@ export interface InvocationContextParams {
  *
  *  The summarization of the function response is considered another step, since
  *  it is another llm call.
- *  A step ends when it's done calling llm and tools, or if the end_invocation
+ *  A step ends when it's done calling llm and tools, or if `endInvocation`
  *  is set to true at any time.
  *
  *  ```
@@ -137,7 +141,7 @@ export declare class InvocationContext {
     readonly session: Session;
     /**
      * Whether to end this invocation.
-     * Set to True in callbacks or tools to terminate this invocation.
+     * Set to `true` in callbacks or tools to terminate this invocation.
      */
     endInvocation: boolean;
     /**
@@ -201,6 +205,10 @@ export declare class InvocationContext {
      * server-side state instead of replaying history. Mutable by design.
      */
     liveSessionResumptionHandle?: string;
+    /**
+     * Request-level metadata passed from an incoming A2A request or caller.
+     */
+    readonly a2aMetadata?: Record<string, unknown>;
     /**
      * @param params The parameters for creating an invocation context.
      */

package/dist/types/agents/llm_agent.d.ts

@@ -47,7 +47,7 @@ export type SingleBeforeModelCallback = (params: {
  * A single callback or a list of callbacks.
  *
  * When a list of callbacks is provided, the callbacks will be called in the
- * order they are listed until a callback does not return None.
+ * order they are listed until a callback does not return `undefined`.
  */
 export type BeforeModelCallback = SingleBeforeModelCallback | SingleBeforeModelCallback[];
 /**
@@ -67,7 +67,7 @@ export type SingleAfterModelCallback = (params: {
  * A single callback or a list of callbacks.
  *
  * When a list of callbacks is provided, the callbacks will be called in the
- order they are listed until a callback does not return None.
+ * order they are listed until a callback does not return `undefined`.
  */
 export type AfterModelCallback = SingleAfterModelCallback | SingleAfterModelCallback[];
 /**
@@ -88,7 +88,7 @@ export type SingleBeforeToolCallback = (params: {
  * A single callback or a list of callbacks.
  *
  * When a list of callbacks is provided, the callbacks will be called in the
- * order they are listed until a callback does not return None.
+ * order they are listed until a callback does not return `undefined`.
  */
 export type BeforeToolCallback = SingleBeforeToolCallback | SingleBeforeToolCallback[];
 /**
@@ -110,7 +110,7 @@ export type SingleAfterToolCallback = (params: {
  * A single callback or a list of callbacks.
  *
  * When a list of callbacks is provided, the callbacks will be called in the
- * order they are listed until acallback does not return None.
+ * order they are listed until a callback does not return `undefined`.
  */
 export type AfterToolCallback = SingleAfterToolCallback | SingleAfterToolCallback[];
 /** A list of examples or an example provider. */
@@ -143,8 +143,10 @@ export interface LlmAgentConfig extends BaseAgentConfig {
     /**
      * The additional content generation configurations.
      *
-     * NOTE: not all fields are usable, e.g. tools must be configured via
-     * `tools`, thinking_config must be configured via `planner` in LlmAgent.
+     * Three fields are rejected by the constructor, because the agent owns them:
+     * `tools` (set them through `tools`), `systemInstruction` (through
+     * `instruction`) and `responseSchema` (through `outputSchema`). Every other
+     * field is forwarded to the model as given — `thinkingConfig` included.
      *
      * For example: use this config to adjust model temperature, configure safety
      * settings, etc.
@@ -153,7 +155,7 @@ export interface LlmAgentConfig extends BaseAgentConfig {
     /**
      * Disallows LLM-controlled transferring to the parent agent.
      *
-     * NOTE: Setting this as True also prevents this agent to continue reply to
+     * NOTE: Setting this to `true` also prevents this agent to continue reply to
      * the end-user. This behavior prevents one-way transfer, in which end-user
      * may be stuck with one agent that cannot transfer to other agents in the
      * agent tree.

package/dist/types/agents/processors/agent_transfer_llm_request_processor.d.ts

@@ -16,7 +16,22 @@ import { BaseLlmRequestProcessor } from './base_llm_processor.js';
  */
 export declare class AgentTransferLlmRequestProcessor extends BaseLlmRequestProcessor {
     private readonly toolName;
-    private readonly tool;
+    /**
+     * Builds the `transfer_to_agent` tool for one invocation.
+     *
+     * Built per call rather than shared, because the parameter is an enum of the
+     * agents actually reachable from here. That mirrors adk-python's
+     * `TransferToAgentTool`, and it stops the model inventing a target: an
+     * unknown name now fails argument validation and comes back to the model as
+     * a tool error it can retry, instead of silently setting `transferToAgent`
+     * to an agent that does not exist.
+     *
+     * The parameter is `agent_name`, not `agentName`. It is wire format — it
+     * appears in the declaration sent to the model and in the events that get
+     * persisted — and adk-python spells it `agent_name`, so a transcript
+     * produced by one runtime has to be readable by the other.
+     */
+    private buildTool;
     /**
      * Appends transfer instructions and registers the `transfer_to_agent` tool
      * when the agent has reachable transfer targets.

package/dist/types/agents/readonly_context.d.ts

@@ -36,4 +36,8 @@ export declare class ReadonlyContext {
      * The state of the current session.
      */
     get state(): Readonly<State>;
+    /**
+     * Request-level metadata passed from an incoming A2A request or caller.
+     */
+    get a2aMetadata(): Record<string, unknown> | undefined;
 }