@softactivate/adk 1.1.0

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

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AgentCard } from '@a2a-js/sdk';
+import express from 'express';
+import { BaseAgent } from '../agents/base_agent.js';
+import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
+import { BaseMemoryService } from '../memory/base_memory_service.js';
+import { Runner } from '../runner/runner.js';
+import { BaseSessionService } from '../sessions/base_session_service.js';
+/**
+ * Options for the `toA2a` function.
+ */
+export interface ToA2aOptions {
+    /** The host for the A2A RPC URL (default: "localhost") */
+    host?: string;
+    /** The port for the A2A RPC URL (default: 8000) */
+    port?: number;
+    /** The protocol for the A2A RPC URL (default: "http") */
+    protocol?: string;
+    /** The base path for the A2A RPC URL (default: "a2a") */
+    basePath?: string;
+    /** Optional pre-built AgentCard object or path to agent card JSON */
+    agentCard?: AgentCard | string;
+    /** Optional pre-built Runner object */
+    runner?: Runner;
+    /** Optional session service */
+    sessionService?: BaseSessionService;
+    /** Optional memory service */
+    memoryService?: BaseMemoryService;
+    /** Optional artifact service */
+    artifactService?: BaseArtifactService;
+    /** Optional existing express application */
+    app?: express.Application;
+}
+/**
+ * Converts an ADK agent to an Express application with A2A handlers.
+ *
+ * @param agent The ADK agent to convert
+ * @param options Configuration options
+ * @returns An Express application
+ */
+export declare function toA2a(agent: BaseAgent, options?: ToA2aOptions): Promise<express.Application>;

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

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Message } from '@a2a-js/sdk';
+import { Event as AdkEvent } from '../events/event.js';
+import { A2AEvent } from './a2a_event.js';
+/**
+ * Converts a session Event to an A2A Message.
+ */
+export declare function toA2AMessage(event: AdkEvent, { appName, userId, sessionId, }: {
+    appName: string;
+    userId: string;
+    sessionId: string;
+}): Message;
+/**
+ * Converts an A2A Event to a Session Event.
+ */
+export declare function toAdkEvent(event: A2AEvent, invocationId: string, agentName: string): AdkEvent | undefined;

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

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Task, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+import { Content as GenAIContent } from '@google/genai';
+import { Event as AdkEvent } from '../events/event.js';
+import { ExecutorContext } from './executor_context.js';
+/**
+ * Processes a list of ADK events and determines the final task status update event.
+ * If any of the ADK events contain an error, a TaskFailedEvent is returned immediately.
+ * If there are no errors, it checks for any input required events. If found, it returns a TaskInputRequiredEvent.
+ * If there are no input required events, it returns a TaskCompletedEvent.
+ *
+ * @param adkEvents - The list of ADK events to process.
+ * @param context - The executor context containing relevant information for processing the events.
+ * @returns A TaskStatusUpdateEvent representing the final status of the task after processing the ADK events.
+ */
+export declare function getFinalTaskStatusUpdate(adkEvents: AdkEvent[], context: ExecutorContext): TaskStatusUpdateEvent;
+/**
+ * Returns input required task status update events if the provided user request does not contain responses for all function calls in the task status.
+ */
+export declare function getTaskInputRequiredEvent(task: Task, genAIContent: GenAIContent): TaskStatusUpdateEvent | undefined;

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

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { RequestContext } from '@a2a-js/sdk/server';
+import { Content } from '@google/genai';
+import { Event } from '../events/event.js';
+import { Session } from '../sessions/session.js';
+/**
+ * The A2A Agent Executor context.
+ */
+export interface ExecutorContext {
+    userId: string;
+    sessionId: string;
+    appName: string;
+    readonlyState: Record<string, unknown>;
+    events: Event[];
+    userContent: Content;
+    requestContext: RequestContext;
+}
+/**
+ * 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.
+ * @returns The A2A Agent Executor context.
+ */
+export declare function createExecutorContext({ session, userContent, requestContext, }: {
+    session: Session;
+    userContent: Content;
+    requestContext: RequestContext;
+}): ExecutorContext;

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

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event as AdkEvent } from '../events/event.js';
+import { EventActions as AdkEventActions } from '../events/event_actions.js';
+import { A2AEvent } from './a2a_event.js';
+/**
+ * Keys for metadata that will be stored in A2A message metadata and related to ADK events.
+ */
+export declare enum A2AMetadataKeys {
+    APP_NAME = "adk_app_name",
+    USER_ID = "adk_user_id",
+    SESSION_ID = "adk_session_id",
+    INVOCATION_ID = "adk_invocation_id",
+    AUTHOR = "adk_author",
+    BRANCH = "adk_branch",
+    DATA_PART_TYPE = "adk_type",
+    PARTIAL = "adk_partial",
+    ESCALATE = "adk_escalate",
+    TRANSFER_TO_AGENT = "adk_transfer_to_agent",
+    IS_LONG_RUNNING = "adk_is_long_running",
+    THOUGHT = "adk_thought",
+    ERROR_CODE = "adk_error_code",
+    ERROR_MESSAGE = "adk_error_message",
+    CITATION_METADATA = "adk_citation_metadata",
+    GROUNDING_METADATA = "adk_grounding_metadata",
+    USAGE_METADATA = "adk_usage_metadata",
+    CUSTOM_METADATA = "adk_custom_metadata",
+    VIDEO_METADATA = "adk_video_metadata"
+}
+/**
+ * Keys for metadata that will be stored in ADK event metadata and related to A2A messages.
+ */
+export declare enum AdkMetadataKeys {
+    TASK_ID = "a2a:task_id",
+    CONTEXT_ID = "a2a:context_id"
+}
+/**
+ * Creates ADK Event metadata from an A2A Event.
+ */
+export declare function getAdkEventMetadata(a2aEvent: A2AEvent): Record<string, unknown>;
+/**
+ * Creates A2A Event metadata from an ADK Event.
+ */
+export declare function getA2AEventMetadata(adkEvent: AdkEvent, { appName, userId, sessionId, }: {
+    appName: string;
+    userId: string;
+    sessionId: string;
+}): Record<string, unknown>;
+/**
+ * Creates A2A Session metadata from ADK Event invocation metadata.
+ */
+export declare function getA2ASessionMetadata({ appName, userId, sessionId, }: {
+    appName: string;
+    userId: string;
+    sessionId: string;
+}): Record<string, unknown>;
+/**
+ * Creates A2A Event metadata from ADK Event actions.
+ */
+export declare function getA2AEventMetadataFromActions(actions: AdkEventActions): Record<string, unknown>;

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

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DataPart as A2ADataPart, FilePart as A2AFilePart, Part as A2APart, TextPart as A2ATextPart, Message } from '@a2a-js/sdk';
+import { Content as GenAIContent, Part as GenAIPart } from '@google/genai';
+/**
+ * Converts GenAI Parts to A2A Parts.
+ */
+export declare function toA2AParts(parts?: GenAIPart[], longRunningToolIDs?: string[]): A2APart[];
+/**
+ * Converts a GenAI Part to an A2A Part.
+ */
+export declare function toA2APart(part: GenAIPart, longRunningToolIDs?: string[]): A2APart;
+/**
+ * Converts a GenAI Text Part to an A2A Text Part.
+ */
+export declare function toA2ATextPart(part: GenAIPart): A2APart;
+/**
+ * Converts a GenAI File Part to an A2A File Part.
+ */
+export declare function toA2AFilePart(part: GenAIPart): A2APart;
+/**
+ * Converts a GenAI Data Part to an A2A Data Part.
+ */
+export declare function toA2ADataPart(part: GenAIPart, longRunningToolIDs?: string[]): A2APart;
+export declare function toGenAIContent(a2aMessage: Message): GenAIContent;
+/**
+ * Converts an A2A Part to a GenAI Part.
+ */
+export declare function toGenAIParts(a2aParts: A2APart[]): GenAIPart[];
+/**
+ * Converts an A2A Part to a GenAI Part.
+ */
+export declare function toGenAIPart(a2aPart: A2APart): GenAIPart;
+/**
+ * Converts an A2A Text Part to a GenAI Part.
+ */
+export declare function toGenAIPartText(a2aPart: A2ATextPart): GenAIPart;
+/**
+ * Converts an A2A File Part to a GenAI Part.
+ */
+export declare function toGenAIPartFile(a2aPart: A2AFilePart): GenAIPart;
+/**
+ * Converts an A2A Data Part to a GenAI Part.
+ */
+export declare function toGenAIPartData(a2aPart: A2ADataPart): GenAIPart;

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

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LiveRequestQueue } from './live_request_queue.js';
+/**
+ * The parameters for creating an ActiveStreamingTool.
+ */
+export interface ActiveStreamingToolParams {
+    task?: Promise<void>;
+    stream?: LiveRequestQueue;
+}
+/**
+ * Manages streaming tool related resources during invocation.
+ */
+export declare class ActiveStreamingTool {
+    /**
+     * The active task of this streaming tool.
+     * TODO: Replace 'Promise<void>' with a proper Task type if available in this
+     * env.
+     */
+    task?: Promise<void>;
+    /**
+     * The active (input) streams of this streaming tool.
+     */
+    stream?: LiveRequestQueue;
+    constructor(params?: ActiveStreamingToolParams);
+}

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

@@ -0,0 +1,194 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+import { Event } from '../events/event.js';
+import { Context } from './context.js';
+import { InvocationContext } from './invocation_context.js';
+/**
+ * A single callback function for an agent.
+ */
+export type SingleAgentCallback = (context: Context) => Promise<Content | undefined> | (Content | undefined);
+/**
+ * Type for before agent callbacks, which can be a single callback or
+ * an array of callbacks.
+ */
+export type BeforeAgentCallback = SingleAgentCallback | SingleAgentCallback[];
+/**
+ * Type for after agent callbacks, which can be a single callback or
+ * an array of callbacks.
+ */
+export type AfterAgentCallback = SingleAgentCallback | SingleAgentCallback[];
+/**
+ * The config of a base agent.
+ */
+export interface BaseAgentConfig {
+    name: string;
+    description?: string;
+    parentAgent?: BaseAgent;
+    subAgents?: BaseAgent[];
+    beforeAgentCallback?: BeforeAgentCallback;
+    afterAgentCallback?: AfterAgentCallback;
+}
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all BaseAgent instances.
+ */
+declare const BASE_AGENT_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of BaseAgent.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of BaseAgent, false otherwise.
+ */
+export declare function isBaseAgent(obj: unknown): obj is BaseAgent;
+/**
+ * Base class for all agents in Agent Development Kit.
+ */
+export declare abstract class BaseAgent {
+    /**
+     * A unique symbol to identify ADK agent classes.
+     */
+    readonly [BASE_AGENT_SIGNATURE_SYMBOL] = true;
+    /**
+     * The agent's name.
+     * Agent name must be a JS identifier and unique within the agent tree.
+     * 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.
+     */
+    get rootAgent(): BaseAgent;
+    /**
+     * The parent agent of this agent.
+     *
+     * Note that an agent can ONLY be added as sub-agent once.
+     *
+     * If you want to add one agent twice as sub-agent, consider to create two
+     * agent instances with identical config, but with different name and add them
+     * to the agent tree.
+     *
+     * The parent agent is the agent that created this agent.
+     */
+    parentAgent?: BaseAgent;
+    /**
+     * The sub-agents of this agent.
+     */
+    readonly subAgents: BaseAgent[];
+    /**
+     * Callback or list of callbacks to be invoked before the agent run.
+     *
+     * 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 agent run will be skipped and the provided content will be
+     *     returned to user.
+     */
+    readonly beforeAgentCallback: SingleAgentCallback[];
+    /**
+     * Callback or list of callbacks to be invoked after the agent run.
+     *
+     * 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.
+     */
+    readonly afterAgentCallback: SingleAgentCallback[];
+    constructor(config: BaseAgentConfig);
+    /**
+     * Entry method to run an agent via text-based conversation.
+     *
+     * @param parentContext The invocation context of the parent agent.
+     * @yields The events generated by the agent.
+     * @returns An AsyncGenerator that yields the events generated by the agent.
+     */
+    runAsync(parentContext: InvocationContext): AsyncGenerator<Event, void, void>;
+    /**
+     * Entry method to run an agent via video/audio-based conversation.
+     *
+     * @param parentContext The invocation context of the parent agent.
+     * @yields The events generated by the agent.
+     * @returns An AsyncGenerator that yields the events generated by the agent.
+     */
+    runLive(parentContext: InvocationContext): AsyncGenerator<Event, void, void>;
+    /**
+     * Core logic to run this agent via text-based conversation.
+     *
+     * @param context The invocation context of the agent.
+     * @yields The events generated by the agent.
+     * @returns An AsyncGenerator that yields the events generated by the agent.
+     */
+    protected abstract runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
+    /**
+     * Core logic to run this agent via video/audio-based conversation.
+     *
+     * @param context The invocation context of the agent.
+     * @yields The events generated by the agent.
+     * @returns An AsyncGenerator that yields the events generated by the agent.
+     */
+    protected abstract runLiveImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
+    /**
+     * Finds the agent with the given name in this agent and its descendants.
+     *
+     * @param name The name of the agent to find.
+     * @return The agent with the given name, or undefined if not found.
+     */
+    findAgent(name: string): BaseAgent | undefined;
+    /**
+     * Finds the agent with the given name in this agent's descendants.
+     *
+     * @param name The name of the agent to find.
+     * @return The agent with the given name, or undefined if not found.
+     */
+    findSubAgent(name: string): BaseAgent | undefined;
+    /**
+     * Creates an invocation context for this agent.
+     *
+     * @param parentContext The invocation context of the parent agent.
+     * @return The invocation context for this agent.
+     */
+    protected createInvocationContext(parentContext: InvocationContext): InvocationContext;
+    /**
+     * Runs the before agent callback if it exists.
+     *
+     * @param invocationContext The invocation context of the agent.
+     * @return The event to return to the user, or undefined if no event is
+     *     generated.
+     */
+    protected handleBeforeAgentCallback(invocationContext: InvocationContext): Promise<Event | undefined>;
+    /**
+     * Runs the after agent callback if it exists.
+     *
+     * @param invocationContext The invocation context of the agent.
+     * @return The event to return to the user, or undefined if no event is
+     *     generated.
+     */
+    protected handleAfterAgentCallback(invocationContext: InvocationContext): Promise<Event | undefined>;
+    private setParentAgentForSubAgents;
+}
+/**
+ * Gets the canonical callback from the given callback.
+ *
+ * @param callbacks The callback or list of callbacks to get the canonical
+ *     callback from.
+ * @return The canonical callback.
+ */
+export declare function getCannonicalCallback<T>(callbacks?: T | T[]): T[];
+export {};

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

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part } from '@google/genai';
+import { AuthCredential } from '../auth/auth_credential.js';
+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 { ToolConfirmation } from '../tools/tool_confirmation.js';
+import { InvocationContext } from './invocation_context.js';
+import { ReadonlyContext } from './readonly_context.js';
+/**
+ * The context of various callbacks within an agent run.
+ *
+ * This class provides the context for callbacks and tool invocations, including
+ * access to the invocation context, function call ID, event actions, and
+ * authentication response. It also provides methods for requesting credentials,
+ * retrieving authentication responses, loading and saving artifacts, and
+ * searching memory.
+ */
+export declare class Context extends ReadonlyContext {
+    private readonly _state;
+    readonly eventActions: EventActions;
+    readonly functionCallId?: string;
+    toolConfirmation?: ToolConfirmation;
+    readonly abortSignal?: AbortSignal;
+    /**
+     * @param options The configuration options for the Context.
+     * @param options.invocationContext The invocation context.
+     * @param options.eventActions The event actions of the current call.
+     * @param options.functionCallId The function call id of the current tool call.
+     *     This id was returned in the function call event from LLM to identify a
+     *     function call. If LLM didn't return this id, ADK will assign one to it.
+     *     This id is used to map function call response to the original function
+     *     call.
+     * @param options.toolConfirmation The tool confirmation of the current tool
+     *     call.
+     */
+    constructor(options: {
+        invocationContext: InvocationContext;
+        eventActions?: EventActions;
+        functionCallId?: string;
+        toolConfirmation?: ToolConfirmation;
+    });
+    /**
+     * The delta-aware state of the current session.
+     */
+    get state(): State;
+    get actions(): EventActions;
+    /**
+     * Loads an artifact attached to the current session.
+     *
+     * @param filename The filename of the artifact.
+     * @param version The version of the artifact. If not provided, the latest
+     *     version will be used.
+     * @return A promise that resolves to the loaded artifact.
+     */
+    loadArtifact(filename: string, version?: number): Promise<Part | undefined>;
+    /**
+     * Saves an artifact attached to the current session.
+     *
+     * @param filename The filename of the artifact.
+     * @param artifact The artifact to save.
+     * @return A promise that resolves to the version of the saved artifact.
+     */
+    saveArtifact(filename: string, artifact: Part): Promise<number>;
+    requestCredential(authConfig: AuthConfig): void;
+    /**
+     * Gets the auth credential for the given auth config.
+     *
+     * @param authConfig The auth config to get the auth credential for.
+     * @return The auth credential for the given auth config.
+     */
+    getAuthResponse(authConfig: AuthConfig): AuthCredential | undefined;
+    /**
+     * Lists the filenames of the artifacts attached to the current session.
+     *
+     * @return A promise that resolves to a list of artifact filenames.
+     */
+    listArtifacts(): Promise<string[]>;
+    /**
+     * Searches the memory of the current user.
+     *
+     * @param query The query to search memory for.
+     * @return A promise that resolves to SearchMemoryResponse containing the
+     *     matching memories.
+     */
+    searchMemory(query: string): Promise<SearchMemoryResponse>;
+    /**
+     * Requests confirmation for the current tool call.
+     */
+    requestConfirmation({ hint, payload }: {
+        hint?: string;
+        payload?: unknown;
+    }): void;
+}

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

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content, 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 { ToolConfirmation } from '../tools/tool_confirmation.js';
+import { SingleAfterToolCallback, SingleBeforeToolCallback } from './llm_agent.js';
+export declare const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
+export declare const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+export declare const functionsExportedForTestingOnly: {
+    handleFunctionCallList: typeof handleFunctionCallList;
+    generateAuthEvent: typeof generateAuthEvent;
+    generateRequestConfirmationEvent: typeof generateRequestConfirmationEvent;
+};
+export declare function generateClientFunctionCallId(): string;
+/**
+ * Populates client-side function call IDs.
+ *
+ * It iterates through all function calls in the event and assigns a
+ * unique client-side ID to each one that doesn't already have an ID.
+ */
+export declare function populateClientFunctionCallId(modelResponseEvent: Event): void;
+/**
+ * Removes the client-generated function call IDs from a given content object.
+ *
+ * When sending content back to the server, these IDs are
+ * specific to the client-side and should not be included in requests to the
+ * model.
+ */
+export declare function removeClientFunctionCallId(content: Content): void;
+/**
+ * Returns a set of function call ids of the long running tools.
+ */
+export declare function getLongRunningFunctionCalls(functionCalls: FunctionCall[], toolsDict: Record<string, BaseTool>): Set<string>;
+/**
+ * Generates an authentication event.
+ *
+ * It iterates through requested auth configurations in a function response
+ * event and creates a new function call for each.
+ */
+export declare function generateAuthEvent(invocationContext: InvocationContext, functionResponseEvent: Event): Event | undefined;
+/**
+ * Generates a request confirmation event from a function response event.
+ */
+export declare function generateRequestConfirmationEvent({ invocationContext, functionCallEvent, functionResponseEvent, }: {
+    invocationContext: InvocationContext;
+    functionCallEvent: Event;
+    functionResponseEvent: Event;
+}): Event | undefined;
+/**
+ * Handles function calls.
+ * Runtime behavior to pay attention to:
+ * - Iterate through each function call in the `functionCallEvent`:
+ *   - Execute before tool callbacks !!if a callback provides a response, short
+ *     circuit the rest.
+ *   - Execute the tool.
+ *   - Execute after tool callbacks !!if a callback provides a response, short
+ *     circuit the rest.
+ *   - 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, }: {
+    invocationContext: InvocationContext;
+    functionCallEvent: Event;
+    toolsDict: Record<string, BaseTool>;
+    beforeToolCallbacks: SingleBeforeToolCallback[];
+    afterToolCallbacks: SingleAfterToolCallback[];
+    filters?: Set<string>;
+    toolConfirmationDict?: Record<string, ToolConfirmation>;
+}): Promise<Event | null>;
+/**
+ * Handles function calls and yields events from {@link AgentTool} sub-agents
+ * as they are produced, then yields the final merged function-response event
+ * last.
+ *
+ * Non-{@link AgentTool} calls are delegated to {@link handleFunctionCallList}
+ * (preserving plugin/before/after-callback semantics). {@link AgentTool} calls
+ * are streamed via {@link AgentTool.runAsyncWithEvents} so the parent runner
+ * can surface sub-agent activity in real time. The caller is expected to
+ * identify the terminal function-response event via
+ * {@link getFunctionResponses}.
+ */
+export declare function handleFunctionCallsStreamingAsync({ invocationContext, functionCallEvent, toolsDict, beforeToolCallbacks, afterToolCallbacks, toolConfirmationDict, }: {
+    invocationContext: InvocationContext;
+    functionCallEvent: Event;
+    toolsDict: Record<string, BaseTool>;
+    beforeToolCallbacks: SingleBeforeToolCallback[];
+    afterToolCallbacks: SingleAfterToolCallback[];
+    toolConfirmationDict?: Record<string, ToolConfirmation>;
+}): AsyncGenerator<Event>;
+/**
+ * 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, }: {
+    invocationContext: InvocationContext;
+    functionCalls: FunctionCall[];
+    toolsDict: Record<string, BaseTool>;
+    beforeToolCallbacks: SingleBeforeToolCallback[];
+    afterToolCallbacks: SingleAfterToolCallback[];
+    filters?: Set<string>;
+    toolConfirmationDict?: Record<string, ToolConfirmation>;
+}): Promise<Event | null>;
+/**
+ * Merges a list of function response events into a single event.
+ */
+export declare function mergeParallelFunctionResponseEvents(functionResponseEvents: Event[]): Event;