@google/adk 1.6.0 → 2.0.0

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

@@ -5,6 +5,8 @@
  */
 import { Content } from '@google/genai';
 import { Event } from '../events/event.js';
+import { BaseNode, BaseNodeConfig } from '../workflow/base_node.js';
+import type { NodeContext } from '../workflow/node_context.js';
 import { Context } from './context.js';
 import { InvocationContext } from './invocation_context.js';
 /**
@@ -23,8 +25,13 @@ export type BeforeAgentCallback = SingleAgentCallback | SingleAgentCallback[];
 export type AfterAgentCallback = SingleAgentCallback | SingleAgentCallback[];
 /**
  * The config of a base agent.
+ *
+ * Extends {@link BaseNodeConfig}, so every agent also accepts the node-level
+ * options — `retryConfig`, `timeout`, `inputSchema`, `outputSchema`,
+ * `stateSchema`, `rerunOnResume`, `waitForOutput` — which apply when the agent
+ * runs inside a workflow.
  */
-export interface BaseAgentConfig {
+export interface BaseAgentConfig extends BaseNodeConfig {
     name: string;
     description?: string;
     parentAgent?: BaseAgent;
@@ -49,8 +56,13 @@ export declare function isBaseAgent(obj: unknown): obj is BaseAgent;
  * The class is generic over its config type so that {@link clone} can be typed
  * per subclass (e.g. `LlmAgent.clone({instruction})`). The default keeps bare
  * `BaseAgent` references valid as `BaseAgent<BaseAgentConfig>`.
+ *
+ * An agent **is** a {@link BaseNode}, so any agent can be dropped straight into
+ * a workflow graph without a wrapper — mirroring adk-python, where
+ * `BaseAgent(BaseNode)`. {@link runImpl} bridges the two contracts: the node
+ * runner calls it, and it delegates to the agent's own {@link runAsync}.
  */
-export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAgentConfig> {
+export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAgentConfig> extends BaseNode {
     /**
      * A unique symbol to identify ADK agent classes.
      */
@@ -70,13 +82,6 @@ export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAg
      * Agent name cannot be "user", since it's reserved for end-user's input.
      */
     readonly name: string;
-    /**
-     * Description about the agent's capability.
-     *
-     * The model uses this to determine whether to delegate control to the agent.
-     * One-line description is enough and preferred.
-     */
-    readonly description?: string;
     /**
      * Root agent of this agent.
      * Computed dynamically by traversing up the parent chain.
@@ -148,6 +153,29 @@ export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAg
      * @returns An AsyncGenerator that yields the events generated by the agent.
      */
     runAsync(parentContext: InvocationContext): AsyncGenerator<Event, void, void>;
+    /**
+     * Runs this agent as a workflow node.
+     *
+     * The node runner calls this; it delegates to {@link runAsync}, so an agent
+     * behaves identically whether it is run directly or as a node. Mirrors
+     * adk-python `BaseAgent._run_impl`.
+     *
+     * The invocation context comes from {@link NodeContext.getInvocationContext}
+     * rather than the raw field, so the agent runs against whatever view of the
+     * session the workflow wants it to see.
+     *
+     * Unlike adk-python's `_run_impl`, nothing is stamped onto the events here.
+     * Python has to fix up the author and the node path because it authors
+     * in-workflow events as the workflow itself; the TypeScript node runner
+     * already owns both (`enrichEvent` keeps an author the node set, and always
+     * stamps the true node path), so repeating it would be dead code.
+     *
+     * `nodeInput` is intentionally unused: an agent's input is its conversation,
+     * which the workflow supplies through the session. A node that needs to read
+     * its input — an `LlmAgent` injecting it into the prompt, say — does so in
+     * its own wrapper.
+     */
+    protected runImpl(ctx: NodeContext, _nodeInput: unknown): AsyncGenerator<Event, void, void>;
     /**
      * Entry method to run an agent via video/audio-based conversation.
      *

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

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+/**
+ * The function call the framework emits to ask a human to approve a pending
+ * tool call.
+ */
+export declare const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+/** The function call the framework emits to ask a client for credentials. */
+export declare const REQUEST_CREDENTIAL_FUNCTION_CALL_NAME = "adk_request_credential";
+/** The function call the framework emits to ask a client for input. */
+export declare const REQUEST_INPUT_FUNCTION_CALL_NAME = "adk_request_input";
+/**
+ * The first reserved function call in `content`, if it carries one.
+ *
+ * Used to keep client input out of the framework's own control plane. Function
+ * responses are untouched: answering a pending request is exactly what a client
+ * is supposed to do.
+ *
+ * @param content The content to inspect.
+ * @return The reserved call's name, or undefined when there is none.
+ */
+export declare function reservedFunctionCallName(content: Content | undefined): string | undefined;

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

@@ -10,8 +10,7 @@ import { BaseTool } from '../tools/base_tool.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';
-export declare const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
-export declare const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+export { REQUEST_CONFIRMATION_FUNCTION_CALL_NAME, REQUEST_CREDENTIAL_FUNCTION_CALL_NAME, REQUEST_INPUT_FUNCTION_CALL_NAME, reservedFunctionCallName, } from './framework_function_calls.js';
 export declare const functionsExportedForTestingOnly: {
     handleFunctionCallList: typeof handleFunctionCallList;
     generateAuthEvent: typeof generateAuthEvent;

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,12 @@ 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;
 }
 /**
  * An invocation context represents the data of a single invocation of an agent.
@@ -93,9 +114,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.
      */
@@ -135,6 +166,41 @@ 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;
     /**
      * @param params The parameters for creating an invocation context.
      */
@@ -153,5 +219,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';
@@ -112,7 +116,7 @@ export type AfterToolCallback = SingleAfterToolCallback | SingleAfterToolCallbac
 /** 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.
  */
@@ -166,6 +170,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 +251,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 +293,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 +372,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 +411,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/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/run_config.d.ts

@@ -3,13 +3,18 @@
  * 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 {
     NONE = "none",
     SSE = "sse",
+    /**
+     * Bidirectional streaming. Not yet supported; passing this value to
+     * `createRunConfig` throws. Use {@link StreamingMode.SSE} for token
+     * streaming.
+     */
     BIDI = "bidi"
 }
 /**
@@ -38,7 +43,9 @@ export interface RunConfig {
      */
     supportCfc?: boolean;
     /**
-     * Streaming mode, None or StreamingMode.SSE or StreamingMode.BIDI.
+     * Streaming mode. Supported values are {@link StreamingMode.NONE} and
+     * {@link StreamingMode.SSE}. {@link StreamingMode.BIDI} is not yet
+     * supported and is rejected by `createRunConfig`.
      */
     streamingMode?: StreamingMode;
     /**
@@ -63,6 +70,11 @@ 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.
      *
@@ -77,6 +89,44 @@ 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;
+    /**
+     * 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 +142,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 +156,9 @@ export declare function createRunConfig(params?: Partial<RunConfig>): {
     enableAffectiveDialog: boolean;
     proactivity?: ProactivityConfig | undefined;
     realtimeInputConfig?: RealtimeInputConfig | undefined;
+    contextWindowCompression?: ContextWindowCompressionConfig | undefined;
     pauseOnToolCalls: boolean;
+    plainTextToolConfirmation?: boolean | 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 {
     /**