@softactivate/adk 1.1.0

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

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyContext } from './readonly_context.js';
+/**
+ * Populates values in the instruction template, e.g. state, artifact, etc.
+ *
+ * ```
+ * async function buildInstruction(
+ *     readonlyContext: ReadonlyContext,
+ * ): Promise<string> {
+ *   return await injectSessionState(
+ *       'You can inject a state variable like {var_name} or an artifact ' +
+ *       '{artifact.file_name} into the instruction template.',
+ *       readonlyContext,
+ *   );
+ * }
+ *
+ * const agent = new LlmAgent({
+ *     model: 'gemini-1.5-flash',
+ *     name: 'agent',
+ *     instruction: buildInstruction,
+ * });
+ * ```
+ *
+ * @param template The instruction template.
+ * @param readonlyContext The read-only context
+ * @returns The instruction template with values populated.
+ */
+export declare function injectSessionState(template: string, readonlyContext: ReadonlyContext): Promise<string>;

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

@@ -0,0 +1,162 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
+import { BaseCredentialService } from '../auth/credential_service/base_credential_service.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 { 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';
+/**
+ * The parameters for creating an invocation context.
+ */
+export interface InvocationContextParams {
+    artifactService?: BaseArtifactService;
+    sessionService?: BaseSessionService;
+    memoryService?: BaseMemoryService;
+    credentialService?: BaseCredentialService;
+    invocationId: string;
+    branch?: string;
+    agent: BaseAgent;
+    userContent?: Content;
+    session: Session;
+    endInvocation?: boolean;
+    transcriptionCache?: TranscriptionEntry[];
+    runConfig?: RunConfig;
+    liveRequestQueue?: LiveRequestQueue;
+    activeStreamingTools?: Record<string, ActiveStreamingTool>;
+    pluginManager: PluginManager;
+    abortSignal?: AbortSignal;
+}
+/**
+ * An invocation context represents the data of a single invocation of an agent.
+ *
+ * An invocation:
+ *     1. Starts with a user message and ends with a final response.
+ *     2. Can contain one or multiple agent calls.
+ *     3. Is handled by runner.runAsync().
+ *
+ *   An invocation runs an agent until it does not request to transfer to
+ * another agent.
+ *
+ *   An agent call:
+ *     1. Is handled by agent.runAsync().
+ *     2. Ends when agent.runAsync() ends.
+ *
+ *   An LLM agent call is an agent with a BaseLLMFlow.
+ *  An LLM agent call can contain one or multiple steps.
+ *
+ *  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.
+ *
+ *  A step:
+ *    1. Calls the LLM only once and yields its response.
+ *   2. Calls the tools and yields their responses if requested.
+ *
+ *  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
+ *  is set to true at any time.
+ *
+ *  ```
+ *     ┌─────────────────────── invocation ──────────────────────────┐
+ *     ┌──────────── llm_agent_call_1 ────────────┐ ┌─ agent_call_2 ─┐
+ *     ┌──── step_1 ────────┐ ┌───── step_2 ──────┐
+ *     [call_llm] [call_tool] [call_llm] [transfer]
+ *  ```
+ */
+export declare class InvocationContext {
+    readonly artifactService?: BaseArtifactService;
+    readonly sessionService?: BaseSessionService;
+    readonly memoryService?: BaseMemoryService;
+    readonly credentialService?: BaseCredentialService;
+    /**
+     * The id of this invocation context.
+     */
+    readonly invocationId: string;
+    /**
+     * The branch of the invocation context.
+     *
+     * The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of
+     * agent_2, and agent_2 is the parent of agent_3.
+     *
+     * Branch is used when multiple sub-agents shouldn't see their peer agents'
+     * conversation history.
+     */
+    branch?: string;
+    /**
+     * The current agent of this invocation context.
+     */
+    agent: BaseAgent;
+    /**
+     * The user content that started this invocation.
+     */
+    readonly userContent?: Content;
+    /**
+     * The current session of this invocation context.
+     */
+    readonly session: Session;
+    /**
+     * Whether to end this invocation.
+     * Set to True in callbacks or tools to terminate this invocation.
+     */
+    endInvocation: boolean;
+    /**
+     * Caches necessary, data audio or contents, that are needed by transcription.
+     */
+    transcriptionCache?: TranscriptionEntry[];
+    /**
+     * Configurations for live agents under this invocation.
+     */
+    runConfig?: RunConfig;
+    /**
+     * A container to keep track of different kinds of costs incurred as a part of
+     * this invocation.
+     */
+    private readonly invocationCostManager;
+    /**
+     * The queue to receive live requests.
+     */
+    liveRequestQueue?: LiveRequestQueue;
+    /**
+     * The running streaming tools of this invocation.
+     */
+    activeStreamingTools?: Record<string, ActiveStreamingTool>;
+    /**
+     * The manager for keeping track of plugins in this invocation.
+     */
+    pluginManager: PluginManager;
+    /**
+     * The abort signal for the invocation.
+     */
+    readonly abortSignal?: AbortSignal;
+    /**
+     * @param params The parameters for creating an invocation context.
+     */
+    constructor(params: InvocationContextParams);
+    /**
+     * The app name of the current session.
+     */
+    get appName(): string;
+    /**
+     * The user ID of the current session.
+     */
+    get userId(): string;
+    /**
+     * Tracks number of llm calls made.
+     *
+     * @throws If number of llm calls made exceed the set threshold.
+     */
+    incrementLlmCallCount(): void;
+}
+export declare function newInvocationContextId(): string;

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

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ActivityEnd, ActivityStart, Blob, Content } from '@google/genai';
+/**
+ * Request sent to live agents.
+ */
+export interface LiveRequest {
+    /** If set, send the content to the model in turn-by-turn mode. */
+    content?: Content;
+    /** If set, send the blob to the model in realtime mode. */
+    blob?: Blob;
+    /** If set, signal the start of user activity to the model. */
+    activityStart?: ActivityStart;
+    /** If set, signal the end of user activity to the model. */
+    activityEnd?: ActivityEnd;
+    /** If set, close the queue. */
+    close?: boolean;
+}
+/**
+ * Queue used to send LiveRequest in a live (bidirectional streaming) way.
+ */
+export declare class LiveRequestQueue {
+    private readonly queue;
+    private readonly resolveFnFifoQueue;
+    private isClosed;
+    /**
+     * Adds a request to the queue. If there is a pending `get()` call, it
+     * will be resolved with the given request.
+     * @param req The request to send.
+     */
+    send(req: LiveRequest): void;
+    /**
+     * Retrieves a request from the queue. If the queue is empty, it will
+     * wait until a request is available.
+     * @returns A promise that resolves with the next available request.
+     */
+    get(): Promise<LiveRequest>;
+    /**
+     * Sends a close signal to the queue.
+     */
+    close(): void;
+    /**
+     * Sends a content object to the queue.
+     * @param content The content to send.
+     */
+    sendContent(content: Content): void;
+    /**
+     * Sends a blob to the model in realtime mode.
+     * @param blob The blob to send.
+     */
+    sendRealtime(blob: Blob): void;
+    /**
+     * Sends an activity start signal to mark the beginning of user input.
+     */
+    sendActivityStart(): void;
+    /**
+     * Sends an activity end signal to mark the end of user input.
+     */
+    sendActivityEnd(): void;
+    /**
+     * Implements the async iterator protocol.
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<LiveRequest, void, undefined>;
+}

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

@@ -0,0 +1,351 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GenerateContentConfig, Schema } from '@google/genai';
+import { z as z3 } from 'zod/v3';
+import { z as z4 } from 'zod/v4';
+import { BaseCodeExecutor } from '../code_executors/base_code_executor.js';
+import { Event } from '../events/event.js';
+import { BaseExampleProvider } from '../examples/base_example_provider.js';
+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 { BaseTool } from '../tools/base_tool.js';
+import { BaseToolset } from '../tools/base_toolset.js';
+import { Context } from './context.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';
+import { InvocationContext } from './invocation_context.js';
+import { ReadonlyContext } from './readonly_context.js';
+/**
+ * Input/output schema type for agent.
+ */
+export type LlmAgentSchema = z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape> | Schema;
+/** An object that can provide an instruction string. */
+export type InstructionProvider = (context: ReadonlyContext) => string | Promise<string>;
+/**
+ * A callback that runs before a request is sent to the model.
+ *
+ * @param params.context The current callback context.
+ * @param params.request The raw model request. Callback can mutate the request.
+ * @returns The content to return to the user. When present, the model call
+ *     will be skipped and the provided content will be returned to user.
+ */
+export type SingleBeforeModelCallback = (params: {
+    context: Context;
+    request: LlmRequest;
+}) => LlmResponse | undefined | Promise<LlmResponse | undefined>;
+/**
+ * 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.
+ */
+export type BeforeModelCallback = SingleBeforeModelCallback | SingleBeforeModelCallback[];
+/**
+ * A callback that runs after a response is received from the model.
+ *
+ * @param params.context The current callback context.
+ * @param params.response The actual model response.
+ * @returns The content to return to the user. When present, the actual model
+ *     response will be ignored and the provided content will be returned to
+ *     user.
+ */
+export type SingleAfterModelCallback = (params: {
+    context: Context;
+    response: LlmResponse;
+}) => LlmResponse | undefined | Promise<LlmResponse | undefined>;
+/**
+ * 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.
+ */
+export type AfterModelCallback = SingleAfterModelCallback | SingleAfterModelCallback[];
+/**
+ * A callback that runs before a tool is called.
+ *
+ * @param params.tool The tool to be called.
+ * @param params.args The arguments to the tool.
+ * @param params.context Context for the tool call.
+ * @returns The tool response. When present, the returned tool response will
+ *     be used and the framework will skip calling the actual tool.
+ */
+export type SingleBeforeToolCallback = (params: {
+    tool: BaseTool;
+    args: Record<string, unknown>;
+    context: Context;
+}) => Record<string, unknown> | undefined | Promise<Record<string, unknown> | undefined>;
+/**
+ * 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.
+ */
+export type BeforeToolCallback = SingleBeforeToolCallback | SingleBeforeToolCallback[];
+/**
+ * A callback that runs after a tool is called.
+ *
+ * @param params.tool The tool to be called.
+ * @param params.args The arguments to the tool.
+ * @param params.context Context for the tool call.
+ * @param params.response The response from the tool.
+ * @returns When present, the returned record will be used as tool result.
+ */
+export type SingleAfterToolCallback = (params: {
+    tool: BaseTool;
+    args: Record<string, unknown>;
+    context: Context;
+    response: Record<string, unknown>;
+}) => Record<string, unknown> | undefined | Promise<Record<string, unknown> | undefined>;
+/**
+ * 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.
+ */
+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;
+/**
+ * The configuration options for creating an LLM-based agent.
+ */
+export interface LlmAgentConfig extends BaseAgentConfig {
+    /**
+     * The model to use for the agent.
+     */
+    model?: string | BaseLlm;
+    /** Instructions for the LLM model, guiding the agent's behavior. */
+    instruction?: string | InstructionProvider;
+    /**
+     * Instructions for all the agents in the entire agent tree.
+     *
+     * ONLY the globalInstruction in root agent will take effect.
+     *
+     * For example: use globalInstruction to make all agents have a stable
+     * identity or personality.
+     */
+    globalInstruction?: string | InstructionProvider;
+    /** Tools available to this agent. */
+    tools?: ToolUnion[];
+    /**
+     * 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.
+     *
+     * For example: use this config to adjust model temperature, configure safety
+     * settings, etc.
+     */
+    generateContentConfig?: GenerateContentConfig;
+    /**
+     * Disallows LLM-controlled transferring to the parent agent.
+     *
+     * NOTE: Setting this as 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.
+     */
+    disallowTransferToParent?: boolean;
+    /** Disallows LLM-controlled transferring to the peer agents. */
+    disallowTransferToPeers?: boolean;
+    /**
+     * Controls content inclusion in model requests.
+     *
+     * Options:
+     *   default: Model receives relevant conversation history
+     *   none: Model receives no prior history, operates solely on current
+     *   instruction and input
+     */
+    includeContents?: 'default' | 'none';
+    /** The input schema when agent is used as a tool. */
+    inputSchema?: LlmAgentSchema;
+    /** The output schema when agent replies. */
+    outputSchema?: LlmAgentSchema;
+    /**
+     * The key in session state to store the output of the agent.
+     *
+     * Typically use cases:
+     * - Extracts agent reply for later use, such as in tools, callbacks, etc.
+     * - Connects agents to coordinate with each other.
+     */
+    outputKey?: string;
+    /**
+     * Callbacks to be called before calling the LLM.
+     */
+    beforeModelCallback?: BeforeModelCallback;
+    /**
+     * Callbacks to be called after calling the LLM.
+     */
+    afterModelCallback?: AfterModelCallback;
+    /**
+     * Callbacks to be called before calling the tool.
+     */
+    beforeToolCallback?: BeforeToolCallback;
+    /**
+     * Callbacks to be called after calling the tool.
+     */
+    afterToolCallback?: AfterToolCallback;
+    /**
+     * Processors to run before the LLM request is sent.
+     */
+    requestProcessors?: BaseLlmRequestProcessor[];
+    /**
+     * Processors to run after the LLM response is received.
+     */
+    responseProcessors?: BaseLlmResponseProcessor[];
+    /**
+     * A list of context compactors to evaluate in priority order.
+     * Modifies the session history to keep context overhead within limits.
+     */
+    contextCompactors?: BaseContextCompactor[];
+    /**
+     * Instructs the agent to make a plan and execute it step by step.
+     */
+    codeExecutor?: BaseCodeExecutor;
+}
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all LlmAgent instances.
+ */
+declare const LLM_AGENT_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of LlmAgent.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of LlmAgent, false otherwise.
+ */
+export declare function isLlmAgent(obj: unknown): obj is LlmAgent;
+/**
+ * An agent that uses a large language model to generate responses.
+ */
+export declare class LlmAgent extends BaseAgent {
+    /** A unique symbol to identify ADK LLM agent class. */
+    readonly [LLM_AGENT_SIGNATURE_SYMBOL] = true;
+    model?: string | BaseLlm;
+    instruction: string | InstructionProvider;
+    globalInstruction: string | InstructionProvider;
+    tools: ToolUnion[];
+    generateContentConfig?: GenerateContentConfig;
+    disallowTransferToParent: boolean;
+    disallowTransferToPeers: boolean;
+    includeContents: 'default' | 'none';
+    inputSchema?: Schema;
+    outputSchema?: Schema;
+    outputKey?: string;
+    beforeModelCallback?: BeforeModelCallback;
+    afterModelCallback?: AfterModelCallback;
+    beforeToolCallback?: BeforeToolCallback;
+    afterToolCallback?: AfterToolCallback;
+    requestProcessors: BaseLlmRequestProcessor[];
+    responseProcessors: BaseLlmResponseProcessor[];
+    codeExecutor?: BaseCodeExecutor;
+    constructor(config: LlmAgentConfig);
+    /**
+     * The resolved BaseLlm instance.
+     *
+     * When not set, the agent will inherit the model from its ancestor.
+     */
+    get canonicalModel(): BaseLlm;
+    /**
+     * The resolved instruction field to construct instruction for this
+     * agent.
+     *
+     * This method is only for use by Agent Development Kit.
+     * @param context The context to retrieve the session state.
+     * @returns The resolved instruction field.
+     */
+    canonicalInstruction(context: ReadonlyContext): Promise<{
+        instruction: string;
+        requireStateInjection: boolean;
+    }>;
+    /**
+     * The resolved globalInstruction field to construct global instruction.
+     *
+     * This method is only for use by Agent Development Kit.
+     * @param context The context to retrieve the session state.
+     * @returns The resolved globalInstruction field.
+     */
+    canonicalGlobalInstruction(context: ReadonlyContext): Promise<{
+        instruction: string;
+        requireStateInjection: boolean;
+    }>;
+    /**
+     * The resolved tools field as a list of BaseTool based on the context.
+     *
+     * This method is only for use by Agent Development Kit.
+     */
+    canonicalTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    /**
+     * Normalizes a callback or an array of callbacks into an array of callbacks.
+     *
+     * @param callback The callback or an array of callbacks.
+     * @returns An array of callbacks.
+     */
+    private static normalizeCallbackArray;
+    /**
+     * The resolved beforeModelCallback field as a list of
+     * SingleBeforeModelCallback.
+     *
+     * This method is only for use by Agent Development Kit.
+     */
+    get canonicalBeforeModelCallbacks(): SingleBeforeModelCallback[];
+    /**
+     * The resolved afterModelCallback field as a list of
+     * SingleAfterModelCallback.
+     *
+     * This method is only for use by Agent Development Kit.
+     */
+    get canonicalAfterModelCallbacks(): SingleAfterModelCallback[];
+    /**
+     * The resolved beforeToolCallback field as a list of
+     * BeforeToolCallback.
+     *
+     * This method is only for use by Agent Development Kit.
+     */
+    get canonicalBeforeToolCallbacks(): SingleBeforeToolCallback[];
+    /**
+     * The resolved afterToolCallback field as a list of AfterToolCallback.
+     *
+     * This method is only for use by Agent Development Kit.
+     */
+    get canonicalAfterToolCallbacks(): SingleAfterToolCallback[];
+    /**
+     * Saves the agent's final response to the session state if configured.
+     *
+     * It extracts the text content from the final response event, optionally
+     * parses it as JSON based on the output schema, and stores the result in the
+     * session state using the specified output key.
+     *
+     * @param event The event to process.
+     */
+    private maybeSaveOutputToState;
+    protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
+    protected runLiveImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
+    private runLiveFlow;
+    private runOneStepAsync;
+    private postprocess;
+    /**
+     * Retrieves an agent from the agent tree by its name.
+     *
+     * Performing a depth-first search to locate the agent with the given name.
+     * - Starts searching from the root agent of the current invocation context.
+     * - Traverses down the agent tree to find the specified agent.
+     *
+     * @param invocationContext The current invocation context.
+     * @param agentName The name of the agent to retrieve.
+     * @returns The agent with the given name.
+     * @throws Error if the agent is not found.
+     */
+    private getAgentByName;
+    protected callLlmAsync(invocationContext: InvocationContext, llmRequest: LlmRequest, modelResponseEvent: Event): AsyncGenerator<LlmResponse, void, void>;
+    private handleBeforeModelCallback;
+    private handleAfterModelCallback;
+    protected runAndHandleError<T extends LlmResponse | Event>(responseGenerator: AsyncGenerator<T, void, void>, invocationContext: InvocationContext, llmRequest: LlmRequest, modelResponseEvent: Event): AsyncGenerator<T, void, void>;
+}
+export {};

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

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../events/event.js';
+import { BaseAgent, BaseAgentConfig } from './base_agent.js';
+import { InvocationContext } from './invocation_context.js';
+/**
+ * The configuration options for creating a loop agent.
+ */
+export interface LoopAgentConfig extends BaseAgentConfig {
+    /**
+     * The maximum number of iterations the loop agent will run.
+     *
+     * If not provided, the loop agent will run indefinitely.
+     */
+    maxIterations?: number;
+}
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all LoopAgent instances.
+ */
+declare const LOOP_AGENT_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of LoopAgent.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of LoopAgent, false otherwise.
+ */
+export declare function isLoopAgent(obj: unknown): obj is LoopAgent;
+/**
+ * A shell agent that run its sub-agents in a loop.
+ *
+ * When sub-agent generates an event with escalate or max_iterations are
+ * reached, the loop agent will stop.
+ */
+export declare class LoopAgent extends BaseAgent {
+    /**
+     * A unique symbol to identify ADK loop agent class.
+     */
+    readonly [LOOP_AGENT_SIGNATURE_SYMBOL] = true;
+    readonly maxIterations: number;
+    constructor(config: LoopAgentConfig);
+    protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
+    protected runLiveImpl(_context: InvocationContext): AsyncGenerator<Event, void, void>;
+}
+export {};

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

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../events/event.js';
+import { BaseAgent } from './base_agent.js';
+import { InvocationContext } from './invocation_context.js';
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all ParallelAgent instances.
+ */
+declare const PARALLEL_AGENT_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of ParallelAgent.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of ParallelAgent, false otherwise.
+ */
+export declare function isParallelAgent(obj: unknown): obj is ParallelAgent;
+/**
+ * A shell agent that run its sub-agents in parallel in isolated manner.
+ *
+ * This approach is beneficial for scenarios requiring multiple perspectives or
+ * attempts on a single task, such as:
+ *
+ *  - Running different algorithms simultaneously.
+ *  - Generating multiple responses for review by a subsequent evaluation agent.
+ */
+export declare class ParallelAgent extends BaseAgent {
+    /**
+     * A unique symbol to identify ADK parallel agent class.
+     */
+    readonly [PARALLEL_AGENT_SIGNATURE_SYMBOL] = true;
+    protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
+    protected runLiveImpl(_context: InvocationContext): AsyncGenerator<Event, void, void>;
+}
+export {};