@google/adk 1.6.0 → 2.1.0

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

@@ -6,14 +6,29 @@
 import { Content } from '@google/genai';
 import { SessionArtifactService } from '../artifacts/session_artifact_service.js';
 import { BaseCredentialService } from '../auth/credential_service/base_credential_service.js';
+import { Event } from '../events/event.js';
 import { BaseMemoryService } from '../memory/base_memory_service.js';
 import { PluginManager } from '../plugins/plugin_manager.js';
 import { BaseSessionService } from '../sessions/base_session_service.js';
 import { Session } from '../sessions/session.js';
+import { AsyncQueue } from '../utils/async_queue.js';
 import { ActiveStreamingTool } from './active_streaming_tool.js';
 import { BaseAgent } from './base_agent.js';
+import { LiveRequestQueue } from './live_request_queue.js';
 import { RunConfig } from './run_config.js';
 import { TranscriptionEntry } from './transcription_entry.js';
+/**
+ * Workflow: data exposed to `{Class.field}` and `<Class.field from source_node>`
+ * instruction placeholders when an LlmAgent runs as a workflow node. Populated by
+ * `LLMAgentWrapper`; absent for ordinary (non-workflow) agent runs, in which case
+ * those placeholders are left untouched.
+ */
+export interface WorkflowInstructionScope {
+    /** The current node's input, exposing fields for `{Class.field}`. */
+    input?: unknown;
+    /** Predecessor node outputs keyed by node name, for `<Class.field from node>`. */
+    outputsByNode?: Record<string, unknown>;
+}
 /**
  * The parameters for creating an invocation context.
  */
@@ -24,7 +39,7 @@ export interface InvocationContextParams {
     credentialService?: BaseCredentialService;
     invocationId: string;
     branch?: string;
-    agent: BaseAgent;
+    agent?: BaseAgent;
     userContent?: Content;
     session: Session;
     endInvocation?: boolean;
@@ -33,6 +48,16 @@ export interface InvocationContextParams {
     activeStreamingTools?: Record<string, ActiveStreamingTool>;
     pluginManager: PluginManager;
     abortSignal?: AbortSignal;
+    workflowInstructionScope?: WorkflowInstructionScope;
+    isolationScope?: string;
+    /** Nesting depth of node-as-tool executions; used to bound recursion. */
+    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.
@@ -55,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.
@@ -63,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.
  *
  *  ```
@@ -93,9 +118,19 @@ export declare class InvocationContext {
      */
     branch?: string;
     /**
-     * The current agent of this invocation context.
+     * The agent driving this invocation.
+     *
+     * Unset when the root being run is a bare {@link BaseNode} — a `Workflow`
+     * handed straight to the `Runner` — because there is no agent in play at
+     * that level. Nodes deeper in the graph that *are* agents get their own
+     * contexts with this set. Mirrors adk-python, whose field is
+     * `BaseAgent | BaseNode | None` and which passes `None` on the node path.
+     *
+     * Most code reaches this from inside an agent's own execution, where it is
+     * always set; prefer {@link requireAgent} there, so a broken invariant
+     * fails by name rather than as a property access on `undefined`.
      */
-    agent: BaseAgent;
+    agent?: BaseAgent;
     /**
      * The user content that started this invocation.
      */
@@ -106,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;
     /**
@@ -135,6 +170,45 @@ export declare class InvocationContext {
      */
     pluginManager: PluginManager;
     readonly abortSignal?: AbortSignal;
+    /**
+     * An optional channel into which a running tool can push events to be
+     * interleaved into the agent's output stream. Set by the LLM flow around tool
+     * execution so a {@link NodeTool} (running a node/workflow) can surface the
+     * node's intermediate and interrupt events. Cleared once tools finish.
+     */
+    eventQueue?: AsyncQueue<Event>;
+    /**
+     * Workflow: field-resolution scope for `{Class.field}` /
+     * `<Class.field from node>` instruction placeholders (set by
+     * `LLMAgentWrapper`).
+     */
+    workflowInstructionScope?: WorkflowInstructionScope;
+    /**
+     * Workflow: the isolation scope of the node this context runs in. Events
+     * carrying a different scope are withheld from this agent's LLM request.
+     */
+    isolationScope?: string;
+    /**
+     * Nesting depth of node-as-tool ({@link NodeTool}) executions in this
+     * invocation. Incremented each time a node runs as a tool (via a depth+1
+     * clone), so `NodeTool` can bound `node -> tool -> node` recursion.
+     */
+    readonly nodeToolDepth: number;
+    /**
+     * The live request queue feeding the model on the bidirectional (live) path.
+     * Set only for invocations started via `runner.runLive`.
+     */
+    readonly liveRequestQueue?: LiveRequestQueue;
+    /**
+     * The most recent session resumption handle observed on the live path.
+     * Updated as the server emits resumption updates so a reconnect can restore
+     * 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.
      */
@@ -153,5 +227,31 @@ export declare class InvocationContext {
      * @throws If number of llm calls made exceed the set threshold.
      */
     incrementLlmCallCount(): void;
+    /**
+     * Returns a copy of this context with `overrides` applied. The spread carries
+     * every own field over (including the shared cost manager), so the copy keeps
+     * a single LLM-call counter for the invocation.
+     *
+     * Note: this copies own enumerable fields by value — scalar mutable fields
+     * (e.g. `endInvocation`) are decoupled from the original, while object-valued
+     * fields (`session`, …) stay shared by reference.
+     */
+    clone(overrides?: Partial<InvocationContextParams>): InvocationContext;
 }
 export declare function newInvocationContextId(): string;
+/**
+ * The agent driving `ctx`, for code that only runs because one is.
+ *
+ * An LLM flow, an agent transfer, a tool call: each is reached from inside an
+ * agent's own execution, so {@link InvocationContext.agent} is set by
+ * construction. Going through here says that out loud, and turns a violated
+ * assumption into a named error rather than a property access on `undefined`
+ * several frames away.
+ *
+ * A free function rather than an accessor on the class, because a good deal of
+ * code (and most tests) passes a duck-typed context object; a getter would be
+ * simply absent on those, which fails less clearly than not having the agent.
+ *
+ * @throws if the invocation is driving a bare node rather than an agent.
+ */
+export declare function requireAgent(ctx: InvocationContext): BaseAgent;

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

@@ -35,9 +35,15 @@ export declare class LiveRequestQueue {
     /**
      * Retrieves a request from the queue. If the queue is empty, it will
      * wait until a request is available.
+     *
+     * @param abortSignal When provided, a parked (pending) read is released by
+     *     rejecting with an abort error once the signal fires. The live send
+     *     loop passes the connection's abort signal so a waiter is not stranded
+     *     across reconnect/teardown, where it could otherwise steal a request
+     *     from the next connection's send loop.
      * @returns A promise that resolves with the next available request.
      */
-    get(): Promise<LiveRequest>;
+    get(abortSignal?: AbortSignal): Promise<LiveRequest>;
     /**
      * Sends a close signal to the queue.
      */

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

@@ -4,6 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { GenerateContentConfig, Schema } from '@google/genai';
+import { FinishTaskTool } from '../tools/finish_task_tool.js';
+import { type BaseNode } from '../workflow/base_node.js';
+import { NodeContext } from '../workflow/node_context.js';
 import { z as z3 } from 'zod/v3';
 import { z as z4 } from 'zod/v4';
 import { BaseCodeExecutor } from '../code_executors/base_code_executor.js';
@@ -16,6 +19,7 @@ import { LlmResponse } from '../models/llm_response.js';
 import { BaseTool } from '../tools/base_tool.js';
 import { BaseToolset } from '../tools/base_toolset.js';
 import { Context } from './context.js';
+import { SchemaLike } from '../utils/schema.js';
 import { BaseAgent, BaseAgentConfig } from './base_agent.js';
 import { BaseLlmRequestProcessor, BaseLlmResponseProcessor } from './processors/base_llm_processor.js';
 import { BaseContextCompactor } from '../context/base_context_compactor.js';
@@ -43,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[];
 /**
@@ -63,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[];
 /**
@@ -84,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[];
 /**
@@ -106,13 +110,13 @@ 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. */
 export type ExamplesUnion = Example[] | BaseExampleProvider;
 /** A union of tool types that can be provided to an agent. */
-export type ToolUnion = BaseTool | BaseToolset;
+export type ToolUnion = BaseTool | BaseToolset | BaseNode;
 /**
  * The configuration options for creating an LLM-based agent.
  */
@@ -139,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.
@@ -149,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.
@@ -166,6 +172,15 @@ export interface LlmAgentConfig extends BaseAgentConfig {
      *   instruction and input
      */
     includeContents?: 'default' | 'none';
+    /**
+     * The agent's execution mode when run as a workflow node.
+     *
+     * - `single_turn` (default): the agent runs once against the node input.
+     * - `task`: the agent is given a `finish_task` tool and runs a multi-round
+     *   loop until it calls `finish_task`, whose arguments (conforming to
+     *   `outputSchema`) become the node output. Mirrors Python's `Agent(mode=...)`.
+     */
+    mode?: 'single_turn' | 'task';
     /** The input schema when agent is used as a tool. */
     inputSchema?: LlmAgentSchema;
     /** The output schema when agent replies. */
@@ -238,9 +253,34 @@ export declare class LlmAgent extends BaseAgent<LlmAgentConfig> {
     disallowTransferToParent: boolean;
     disallowTransferToPeers: boolean;
     includeContents: 'default' | 'none';
+    /**
+     * Whether {@link includeContents} was set by the caller rather than defaulted.
+     *
+     * A workflow node runs its agent for a single turn on the input the graph
+     * handed it, so the agent must not also read the surrounding conversation —
+     * unless the author asked for it. Mirrors Python checking
+     * `'include_contents' in agent.model_fields_set`.
+     */
+    readonly includeContentsExplicit: boolean;
+    mode?: 'single_turn' | 'task';
     inputSchema?: Schema;
     outputSchema?: Schema;
+    /**
+     * The input schema exactly as it was supplied, before conversion into the
+     * genai dialect.
+     *
+     * `inputSchema` is normalized to a genai `Schema` because that is what the
+     * model API and function declarations require, but that conversion is lossy:
+     * a Zod refinement, transform, or custom error message has no genai
+     * equivalent. Validation therefore uses the original, falling back to the
+     * converted form when the schema was given in the genai dialect to begin
+     * with.
+     */
+    readonly inputSchemaSource?: SchemaLike;
+    /** The output schema as supplied — see {@link inputSchemaSource}. */
+    readonly outputSchemaSource?: SchemaLike;
     outputKey?: string;
+    private _finishTaskTool?;
     beforeModelCallback?: BeforeModelCallback;
     afterModelCallback?: AfterModelCallback;
     beforeToolCallback?: BeforeToolCallback;
@@ -255,6 +295,11 @@ export declare class LlmAgent extends BaseAgent<LlmAgentConfig> {
      * When not set, the agent will inherit the model from its ancestor.
      */
     get canonicalModel(): BaseLlm;
+    /**
+     * The `finish_task` tool for this agent (task mode). Lazily created and cached
+     * so its declaration (derived from `outputSchema`) is stable across turns.
+     */
+    get finishTaskTool(): FinishTaskTool;
     /**
      * The resolved instruction field to construct instruction for this
      * agent.
@@ -329,6 +374,28 @@ export declare class LlmAgent extends BaseAgent<LlmAgentConfig> {
      * @param event The event to process.
      */
     private maybeSaveOutputToState;
+    /**
+     * Validates a value against this agent's output schema, in whichever dialect
+     * it was declared, and returns the parsed value.
+     *
+     * Prefers the schema as supplied ({@link outputSchemaSource}) over the genai
+     * form derived from it, since the conversion drops constraints Zod can
+     * express and genai cannot.
+     *
+     * @throws if the value does not satisfy the schema.
+     */
+    validateOutput(value: unknown): unknown;
+    /**
+     * Runs this agent as a workflow node.
+     *
+     * Where {@link BaseAgent.runImpl} delegates straight to `runAsync`, an
+     * `LlmAgent` has a node input to inject into the conversation, instruction
+     * placeholders to resolve against it, a reply to promote to node output, and
+     * — in `task` mode — a `finish_task` round-trip to drive. All of that lives
+     * in `runLlmAgentAsNode`, mirroring adk-python's `LlmAgent._run_impl`
+     * delegating to `run_llm_agent_as_node`.
+     */
+    protected runImpl(ctx: NodeContext, nodeInput: unknown): AsyncGenerator<Event, void, void>;
     protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
     protected runLiveImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
     /**
@@ -346,6 +413,17 @@ export declare class LlmAgent extends BaseAgent<LlmAgentConfig> {
      * already holds the conversation state associated with the handle.
      */
     private runLiveFlow;
+    private runLivePreprocess;
+    private runSendLoop;
+    private dispatchLiveRequest;
+    /**
+     * Tears down a live attempt: stops the send loop, closes the connection
+     * (swallowing close errors), and waits for the send task to settle. Used
+     * before reconnecting or propagating an error.
+     */
+    private teardownLiveConnection;
+    private runReceiveLoop;
+    private postprocessLive;
     private runOneStepAsync;
     private postprocess;
     /**

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

@@ -33,6 +33,11 @@ export declare function isLoopAgent(obj: unknown): obj is LoopAgent;
  *
  * When sub-agent generates an event with escalate or max_iterations are
  * reached, the loop agent will stop.
+ *
+ * @deprecated Use `Workflow` instead, which expresses the same ordering as a
+ * graph and adds routing, retries, HITL and resumability. This class will be
+ * removed in a future version. Note that a `Workflow` cannot yet be an
+ * `LlmAgent` sub-agent.
  */
 export declare class LoopAgent extends BaseAgent<LoopAgentConfig> {
     /**

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

@@ -25,6 +25,11 @@ export declare function isParallelAgent(obj: unknown): obj is ParallelAgent;
  *
  *  - Running different algorithms simultaneously.
  *  - Generating multiple responses for review by a subsequent evaluation agent.
+ *
+ * @deprecated Use `Workflow` instead, which expresses the same ordering as a
+ * graph and adds routing, retries, HITL and resumability. This class will be
+ * removed in a future version. Note that a `Workflow` cannot yet be an
+ * `LlmAgent` sub-agent.
  */
 export declare class ParallelAgent extends BaseAgent {
     /**

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

@@ -19,10 +19,11 @@ export declare function removeClientFunctionCallId(content: Content): void;
  * @param events: A list of all session events.
  * @param agentName: The name of the agent.
  * @param currentBranch: The current branch of the agent.
+ * @param currentIsolationScope: The isolation scope of the current node, if any.
  *
  * @returns A list of processed contents.
  */
-export declare function getContents(events: Event[], agentName: string, currentBranch?: string): Content[];
+export declare function getContents(events: Event[], agentName: string, currentBranch?: string, currentIsolationScope?: string): Content[];
 /**
  * Get contents for the current turn only (no conversation history).
  *
@@ -41,7 +42,7 @@ export declare function getContents(events: Event[], agentName: string, currentB
  * @returns A list of contents for the current turn only, preserving context
  *     needed for proper tool execution while excluding conversation history.
  */
-export declare function getCurrentTurnContents(events: Event[], agentName: string, currentBranch?: string): Content[];
+export declare function getCurrentTurnContents(events: Event[], agentName: string, currentBranch?: string, currentIsolationScope?: string): Content[];
 /**
  * Merges a list of function_response events into one event.
  *

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

@@ -10,11 +10,14 @@ import { BaseLlmRequestProcessor } from './base_llm_processor.js';
 /**
  * Appends identity instructions to the {@link LlmRequest} system prompt,
  * informing the model of the agent's name and description.
+ *
+ * The instructions are omitted for an agent that cannot transfer control
+ * anywhere, since nothing in the prompt consumes the identity in that case.
  */
 export declare class IdentityLlmRequestProcessor extends BaseLlmRequestProcessor {
     /**
      * Appends agent name and description as identity instructions to the system
-     * prompt of the request.
+     * prompt of the request, unless the agent has no reachable transfer target.
      *
      * @param invocationContext - The current invocation context.
      * @param llmRequest - The request object to append instructions to.

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

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../../events/event.js';
+import { InvocationContext } from '../invocation_context.js';
+import { BaseLlmRequestProcessor } from './base_llm_processor.js';
+/**
+ * Resumes a {@link NodeTool} call that paused for input. When a node/workflow
+ * run inside a node-tool raises a `RequestInput` interrupt, the node-tool's
+ * function call is left pending (no response) and the invocation pauses. On the
+ * next turn, once the user answers the `adk_request_input` interrupt, this
+ * processor re-runs the pending node-tool with the answer(s) threaded as
+ * `resumeInputs`, then emits the tool's function response so the agent can
+ * continue. Analogous to {@link RequestConfirmationLlmRequestProcessor}.
+ */
+export declare class RequestInputLlmRequestProcessor extends BaseLlmRequestProcessor {
+    runAsync(invocationContext: InvocationContext): AsyncGenerator<Event, void, void>;
+}
+export declare const REQUEST_INPUT_LLM_REQUEST_PROCESSOR: RequestInputLlmRequestProcessor;

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

@@ -3,13 +3,23 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { AudioTranscriptionConfig, Modality, ProactivityConfig, RealtimeInputConfig, SpeechConfig } from '@google/genai';
+import { AudioTranscriptionConfig, ContextWindowCompressionConfig, Modality, ProactivityConfig, RealtimeInputConfig, SpeechConfig } from '@google/genai';
 /**
  * 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",
+    /**
+     * 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"
 }
 /**
@@ -38,7 +48,11 @@ export interface RunConfig {
      */
     supportCfc?: boolean;
     /**
-     * Streaming mode, None or StreamingMode.SSE or StreamingMode.BIDI.
+     * 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;
     /**
@@ -63,12 +77,18 @@ export interface RunConfig {
      * Realtime input config for live agents with audio input from user.
      */
     realtimeInputConfig?: RealtimeInputConfig;
+    /**
+     * Context window compression config. When the running context exceeds
+     * `triggerTokens`, the server compresses older history to `targetTokens`.
+     */
+    contextWindowCompression?: ContextWindowCompressionConfig;
     /**
      * 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;
@@ -77,6 +97,48 @@ export interface RunConfig {
      * to intercept and execute tools (Client-Side Tool Execution).
      */
     pauseOnToolCalls?: boolean;
+    /**
+     * If true, a plain-text user reply (e.g. "yes"/"no") may resolve a pending
+     * `requireConfirmation` tool gate. Off by default so an ordinary chat message
+     * on a web/API surface is never silently reinterpreted as a security
+     * 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.
+     *
+     * Off by default: a remote peer is not the human operator, and a peer that
+     * can post to the task would otherwise be able to approve a dangerous tool
+     * call on the operator's behalf — the thing the gate exists to prevent. Turn
+     * it on only where the peer is a trusted relay for a real person: a front-end
+     * that renders the prompt and sends back what they chose.
+     *
+     * A deliberate divergence from adk-python, which refuses a remote-delivered
+     * confirmation outright and offers no way back. The default matches; the
+     * option does not exist there.
+     */
+    allowRemoteToolConfirmation?: boolean;
+    /**
+     * Set by the A2A executor to record that this run's message came from a
+     * remote peer. Not part of the configuration surface: an application setting
+     * it by hand is asserting something about the message's provenance that only
+     * the transport can know.
+     *
+     * Read by the tool-confirmation resume path only. The other two interrupts a
+     * peer can answer — `adk_request_credential` and `adk_request_input` — are
+     * answerable by a client by design: a credential is something a client holds,
+     * and an input request asks for data, not for judgement. Confirmation is the
+     * one that asks a specific human to take responsibility for an action, which
+     * is why it is the one a peer cannot stand in for.
+     *
+     * @internal
+     */
+    remoteDelivered?: boolean;
 }
 /**
  * Creates a {@link RunConfig} with production-safe defaults.
@@ -92,6 +154,7 @@ export interface RunConfig {
  * @param params - Optional partial {@link RunConfig} overriding defaults.
  * @returns A merged {@link RunConfig} object.
  * @throws {Error} When `params.maxLlmCalls` exceeds `Number.MAX_SAFE_INTEGER`.
+ * @throws {Error} When `params.streamingMode` is {@link StreamingMode.BIDI}.
  */
 export declare function createRunConfig(params?: Partial<RunConfig>): {
     maxLlmCalls: number;
@@ -105,5 +168,10 @@ export declare function createRunConfig(params?: Partial<RunConfig>): {
     enableAffectiveDialog: boolean;
     proactivity?: ProactivityConfig | undefined;
     realtimeInputConfig?: RealtimeInputConfig | undefined;
+    contextWindowCompression?: ContextWindowCompressionConfig | undefined;
     pauseOnToolCalls: boolean;
+    plainTextToolConfirmation?: boolean | undefined;
+    a2aMetadata?: Record<string, unknown> | undefined;
+    allowRemoteToolConfirmation?: boolean | undefined;
+    remoteDelivered?: boolean | undefined;
 };

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

@@ -19,6 +19,11 @@ declare const SEQUENTIAL_AGENT_SIGNATURE_SYMBOL: unique symbol;
 export declare function isSequentialAgent(obj: unknown): obj is SequentialAgent;
 /**
  * A shell agent that runs its sub-agents in a sequential order.
+ *
+ * @deprecated Use `Workflow` instead, which expresses the same ordering as a
+ * graph and adds routing, retries, HITL and resumability. This class will be
+ * removed in a future version. Note that a `Workflow` cannot yet be an
+ * `LlmAgent` sub-agent.
  */
 export declare class SequentialAgent extends BaseAgent {
     /**