@google/adk 2.0.0 → 2.2.0

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

@@ -16,6 +16,7 @@ import { Example } from '../examples/example.js';
 import { BaseLlm } from '../models/base_llm.js';
 import { LlmRequest } from '../models/llm_request.js';
 import { LlmResponse } from '../models/llm_response.js';
+import type { BasePlanner } from '../planners/base_planner.js';
 import { BaseTool } from '../tools/base_tool.js';
 import { BaseToolset } from '../tools/base_toolset.js';
 import { Context } from './context.js';
@@ -47,7 +48,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 +68,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 +89,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 +111,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 +144,12 @@ 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. That includes `thinkingConfig`,
+     * unless `planner` is a `BuiltInPlanner` with its own `thinkingConfig`: the
+     * planner's `thinkingConfig` then takes precedence.
      *
      * For example: use this config to adjust model temperature, configure safety
      * settings, etc.
@@ -153,7 +158,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.
@@ -224,6 +229,13 @@ export interface LlmAgentConfig extends BaseAgentConfig {
      * Instructs the agent to make a plan and execute it step by step.
      */
     codeExecutor?: BaseCodeExecutor;
+    /**
+     * Instructs the agent to make a plan and execute it step by step.
+     *
+     * NOTE: to use the model's built-in thinking features, set `thinkingConfig`
+     * on a `BuiltInPlanner`.
+     */
+    planner?: BasePlanner;
 }
 /**
  * A unique symbol to identify ADK agent classes.
@@ -286,6 +298,7 @@ export declare class LlmAgent extends BaseAgent<LlmAgentConfig> {
     requestProcessors: BaseLlmRequestProcessor[];
     responseProcessors: BaseLlmResponseProcessor[];
     codeExecutor?: BaseCodeExecutor;
+    planner?: BasePlanner;
     constructor(config: LlmAgentConfig);
     /**
      * The resolved BaseLlm instance.

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/processors/nl_planning_processor.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../../events/event.js';
+import { LlmRequest } from '../../models/llm_request.js';
+import { LlmResponse } from '../../models/llm_response.js';
+import { InvocationContext } from '../invocation_context.js';
+import { BaseLlmRequestProcessor, BaseLlmResponseProcessor } from './base_llm_processor.js';
+/**
+ * Prepares the LLM request for the agent's planner.
+ *
+ * Applies a `BuiltInPlanner`'s thinking config, appends the planner's
+ * planning instruction, and clears the `thought` flag on every request part
+ * so that earlier planning output goes back to the model as plain text.
+ */
+export declare class NlPlanningRequestProcessor extends BaseLlmRequestProcessor {
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
+}
+/**
+ * Replaces the LLM response parts with the planner's processed parts.
+ *
+ * Partial responses are processed too.
+ */
+export declare class NlPlanningResponseProcessor extends BaseLlmResponseProcessor {
+    runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event, void, void>;
+}
+export declare const NL_PLANNING_REQUEST_PROCESSOR: NlPlanningRequestProcessor;
+export declare const NL_PLANNING_RESPONSE_PROCESSOR: NlPlanningResponseProcessor;

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;
 }

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

@@ -8,12 +8,17 @@ import { AudioTranscriptionConfig, ContextWindowCompressionConfig, Modality, Pro
  * The streaming mode for the run config.
  */
 export declare enum StreamingMode {
+    /** Deliver the response as a single event once the turn completes. */
     NONE = "none",
+    /**
+     * Deliver the response incrementally, as a series of partial events
+     * followed by a final event carrying the complete text.
+     */
     SSE = "sse",
     /**
-     * Bidirectional streaming. Not yet supported; passing this value to
-     * `createRunConfig` throws. Use {@link StreamingMode.SSE} for token
-     * streaming.
+     * Reserved. Bidirectional streaming is reached through `Runner.runLive()`,
+     * not through this value: `runLive` itself calls `createRunConfig`, which
+     * rejects `BIDI`. Use {@link StreamingMode.SSE} for incremental responses.
      */
     BIDI = "bidi"
 }
@@ -43,9 +48,11 @@ export interface RunConfig {
      */
     supportCfc?: boolean;
     /**
-     * Streaming mode. Supported values are {@link StreamingMode.NONE} and
-     * {@link StreamingMode.SSE}. {@link StreamingMode.BIDI} is not yet
-     * supported and is rejected by `createRunConfig`.
+     * How the response is delivered. Defaults to {@link StreamingMode.NONE},
+     * which emits one event when the turn completes; set
+     * {@link StreamingMode.SSE} to receive partial events as the response is
+     * produced. {@link StreamingMode.BIDI} is rejected by `createRunConfig`;
+     * bidirectional streaming is reached through `Runner.runLive()` instead.
      */
     streamingMode?: StreamingMode;
     /**
@@ -79,8 +86,9 @@ export interface RunConfig {
      * A limit on the total number of llm calls for a given run.
      *
      * Valid Values:
-     *   - More than 0 and less than sys.maxsize: The bound on the number of llm
-     *     calls is enforced, if the value is set in this range.
+     *   - More than 0 and at most `Number.MAX_SAFE_INTEGER`: The bound on the
+     *     number of llm calls is enforced. `createRunConfig()` throws for
+     *     anything larger.
      *   - Less than or equal to 0: This allows for unbounded number of llm calls.
      */
     maxLlmCalls?: number;
@@ -96,6 +104,10 @@ export interface RunConfig {
      * decision; interactive front-ends (e.g. `adk run`) opt in explicitly.
      */
     plainTextToolConfirmation?: boolean;
+    /**
+     * Request-level metadata passed from an incoming A2A request or caller.
+     */
+    a2aMetadata?: Record<string, unknown>;
     /**
      * If true, a `requireConfirmation` gate may be answered by a message that
      * arrived over A2A.
@@ -159,6 +171,7 @@ export declare function createRunConfig(params?: Partial<RunConfig>): {
     contextWindowCompression?: ContextWindowCompressionConfig | undefined;
     pauseOnToolCalls: boolean;
     plainTextToolConfirmation?: boolean | undefined;
+    a2aMetadata?: Record<string, unknown> | undefined;
     allowRemoteToolConfirmation?: boolean | undefined;
     remoteDelivered?: boolean | undefined;
 };

package/dist/types/artifacts/scoped_artifact_service.d.ts

@@ -6,6 +6,14 @@
 import { Part } from '@google/genai';
 import { ArtifactVersion, BaseArtifactService } from './base_artifact_service.js';
 import { SessionArtifactService, SessionLoadArtifactRequest, SessionSaveArtifactRequest } from './session_artifact_service.js';
+/**
+ * A unique symbol to identify session-scoped artifact services.
+ *
+ * Resolves to the same symbol as the one used by `isSessionArtifactService` in
+ * `session_artifact_service.ts` because `Symbol.for` looks up the global
+ * symbol registry.
+ */
+declare const SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL: unique symbol;
 /**
  * A wrapper that scopes a BaseArtifactService to a specific session.
  */
@@ -14,6 +22,10 @@ export declare class ScopedArtifactService implements SessionArtifactService {
     private readonly appName;
     private readonly userId;
     private readonly sessionId;
+    /**
+     * Brands this class as a session-scoped artifact service.
+     */
+    readonly [SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL] = true;
     constructor(delegate: BaseArtifactService, appName: string, userId: string, sessionId: string);
     saveArtifact(request: SessionSaveArtifactRequest): Promise<number>;
     loadArtifact(request: SessionLoadArtifactRequest): Promise<Part | undefined>;
@@ -23,3 +35,4 @@ export declare class ScopedArtifactService implements SessionArtifactService {
     listArtifactVersions(filename: string): Promise<ArtifactVersion[]>;
     getArtifactVersion(request: SessionLoadArtifactRequest): Promise<ArtifactVersion | undefined>;
 }
+export {};

package/dist/types/artifacts/session_artifact_service.d.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Part } from '@google/genai';
-import { ArtifactVersion } from './base_artifact_service.js';
+import { ArtifactVersion, BaseArtifactService } from './base_artifact_service.js';
 export interface SessionSaveArtifactRequest {
     filename: string;
     artifact: Part;
@@ -23,3 +23,10 @@ export interface SessionArtifactService {
     listArtifactVersions(filename: string): Promise<ArtifactVersion[]>;
     getArtifactVersion(request: SessionLoadArtifactRequest): Promise<ArtifactVersion | undefined>;
 }
+/**
+ * Type guard to check if an object implements SessionArtifactService.
+ *
+ * @param service The artifact service to check.
+ * @returns True if the service is a session-scoped artifact service.
+ */
+export declare function isSessionArtifactService(service: BaseArtifactService | SessionArtifactService): service is SessionArtifactService;