@iqai/adk 0.1.13 → 0.1.15

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Part, Content as Content$1, Blob, SpeechConfig, AudioTranscriptionConfig, RealtimeInputConfig, ProactivityConfig, GenerateContentConfig, LiveConnectConfig, GroundingMetadata, GenerateContentResponseUsageMetadata, GoogleGenAI, FunctionCall } from '@google/genai';
-export { Blob, Content } from '@google/genai';
+import { Part, Content, Blob, SpeechConfig, AudioTranscriptionConfig, RealtimeInputConfig, ProactivityConfig, FunctionDeclaration, GroundingMetadata, GenerateContentResponseUsageMetadata, GenerateContentConfig, Schema, LiveConnectConfig, GoogleGenAI, FunctionCall } from '@google/genai';
+export { Blob, Content, FunctionDeclaration, Schema as JSONSchema } from '@google/genai';
 import { LanguageModel } from 'ai';
 import * as z from 'zod/v4';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
@@ -32,41 +32,6 @@ declare class Logger {
     debugArray(title: string, items: Array<Record<string, any>>): void;
 }
 
-/**
- * JSON Schema type for function parameters
- */
-interface JSONSchema {
-    type: string;
-    properties?: Record<string, JSONSchema>;
-    items?: JSONSchema;
-    required?: string[];
-    enum?: string[];
-    description?: string;
-    format?: string;
-    pattern?: string;
-    minimum?: number;
-    maximum?: number;
-    default?: any;
-    [key: string]: any;
-}
-/**
- * Represents a function declaration for the LLM
- */
-interface FunctionDeclaration {
-    /**
-     * Name of the function
-     */
-    name: string;
-    /**
-     * Description of what the function does
-     */
-    description: string;
-    /**
-     * Parameters schema in JSON Schema format
-     */
-    parameters: JSONSchema;
-}
-
 /**
  * Represents the actions attached to an event.
  */
@@ -206,7 +171,7 @@ interface MemoryEntry {
     /**
      * The main content of the memory
      */
-    content: Content$1;
+    content: Content;
     /**
      * The author of the memory
      */
@@ -366,7 +331,7 @@ declare class LiveRequest {
     /**
      * If set, send the content to the model in turn-by-turn mode.
      */
-    content?: Content$1;
+    content?: Content;
     /**
      * If set, send the blob to the model in realtime mode.
      */
@@ -376,7 +341,7 @@ declare class LiveRequest {
      */
     close: boolean;
     constructor(options?: {
-        content?: Content$1;
+        content?: Content;
         blob?: Blob;
         close?: boolean;
     });
@@ -395,7 +360,7 @@ declare class LiveRequestQueue {
     /**
      * Send content to the queue.
      */
-    sendContent(content: Content$1): void;
+    sendContent(content: Content): void;
     /**
      * Send realtime blob to the queue.
      */
@@ -514,10 +479,10 @@ declare class TranscriptionEntry {
     /**
      * The data that can be used for transcription
      */
-    data: Blob | Content$1;
+    data: Blob | Content;
     constructor(options: {
         role?: string;
-        data: Blob | Content$1;
+        data: Blob | Content;
     });
 }
 
@@ -596,7 +561,7 @@ declare class InvocationContext {
     /**
      * The user content that started this invocation. Readonly.
      */
-    readonly userContent?: Content$1;
+    readonly userContent?: Content;
     /**
      * The current session of this invocation context. Readonly.
      */
@@ -638,7 +603,7 @@ declare class InvocationContext {
         invocationId?: string;
         branch?: string;
         agent: BaseAgent;
-        userContent?: Content$1;
+        userContent?: Content;
         session: Session;
         endInvocation?: boolean;
         liveRequestQueue?: LiveRequestQueue;
@@ -675,7 +640,7 @@ declare class ReadonlyContext {
     /**
      * The user content that started this invocation. READONLY field.
      */
-    get userContent(): Content$1 | undefined;
+    get userContent(): Content | undefined;
     /**
      * The current invocation id.
      */
@@ -793,17 +758,6 @@ interface ToolConfig {
      */
     maxRetryAttempts?: number;
 }
-/**
- * LLM request interface for processing outgoing requests
- */
-interface LlmRequest$1 {
-    toolsDict: Record<string, BaseTool>;
-    config?: {
-        tools?: Array<{
-            functionDeclarations?: FunctionDeclaration[];
-        }>;
-    };
-}
 /**
  * API variant types
  */
@@ -886,7 +840,7 @@ declare abstract class BaseTool {
      * @param toolContext The context of the tool
      * @param llmRequest The outgoing LLM request, mutable by this method
      */
-    processLlmRequest(_toolContext: ToolContext, llmRequest: LlmRequest$1): Promise<void>;
+    processLlmRequest(_toolContext: ToolContext, llmRequest: LlmRequest): Promise<void>;
     /**
      * Gets the API variant for this tool
      */
@@ -1009,391 +963,1016 @@ interface CreateToolConfigWithoutSchema {
 declare function createTool<T extends Record<string, any>>(config: CreateToolConfigWithSchema<T>): BaseTool;
 declare function createTool(config: CreateToolConfigWithoutSchema): BaseTool;
 
-/**
- * A tool that wraps a user-defined TypeScript function.
- *
- * This tool automatically generates a function declaration from the function's
- * signature and documentation, making it easy to expose functions to agents.
- */
-declare class FunctionTool<T extends Record<string, any>> extends BaseTool {
-    private func;
-    private mandatoryArgs;
-    private parameterTypes;
+interface File {
+    /** The name of the file with file extension (e.g., "file.csv") */
+    name: string;
+    /** The base64-encoded bytes of the file content */
+    content: string;
+    /** The mime type of the file (e.g., "image/png") */
+    mimeType: string;
+}
+interface CodeExecutionInput {
+    /** The code to execute */
+    code: string;
+    /** The input files available to the code */
+    inputFiles: File[];
+    /** The execution ID for the stateful code execution */
+    executionId?: string;
+}
+interface CodeExecutionResult {
+    /** The standard output of the code execution */
+    stdout: string;
+    /** The standard error of the code execution */
+    stderr: string;
+    /** The output files from the code execution */
+    outputFiles: File[];
+}
+declare class CodeExecutionUtils {
     /**
-     * Creates a new FunctionTool wrapping the provided function.
-     *
-     * @param func The function to wrap
-     * @param options Optional configuration for the tool
+     * Gets the file content as a base64-encoded string
      */
-    constructor(func: (...args: any[]) => any, options?: {
-        name?: string;
-        description?: string;
-        isLongRunning?: boolean;
-        shouldRetryOnFailure?: boolean;
-        maxRetryAttempts?: number;
-        parameterTypes?: Record<string, string>;
-    });
+    static getEncodedFileContent(data: string | ArrayBuffer): string;
+    private static isBase64Encoded;
     /**
-     * Executes the wrapped function with the provided arguments.
+     * Extracts the first code block from the content and truncates everything after it
      */
-    runAsync(args: T, context: ToolContext): Promise<any>;
+    static extractCodeAndTruncateContent(content: Content, codeBlockDelimiters: Array<[string, string]>): string | null;
+    private static escapeRegex;
     /**
-     * Returns the function declaration for this tool.
+     * Builds an executable code part with code string
      */
-    getDeclaration(): FunctionDeclaration;
+    static buildExecutableCodePart(code: string): Part;
     /**
-     * Checks if the wrapped function accepts a toolContext parameter.
+     * Builds the code execution result part from the code execution result
      */
-    private functionAcceptsToolContext;
+    static buildCodeExecutionResultPart(codeExecutionResult: CodeExecutionResult): Part;
     /**
-     * Checks if the wrapped function is async.
+     * Converts the code execution parts to text parts in a Content
      */
-    private isAsyncFunction;
+    static convertCodeExecutionParts(content: Content, codeBlockDelimiter: [string, string], executionResultDelimiters: [string, string]): void;
+}
+
+interface BaseCodeExecutorConfig {
     /**
-     * Extracts the mandatory arguments from a function.
-     * In TypeScript, we can't easily inspect parameter defaults at runtime,
-     * so this is a best-effort approach.
+     * If true, extract and process data files from the model request
+     * and attach them to the code executor.
+     * Supported data file MimeTypes are [text/csv].
+     * Default to false.
      */
-    private getMandatoryArgs;
+    optimizeDataFile?: boolean;
     /**
-     * Checks which mandatory arguments are missing from the provided args.
+     * Whether the code executor is stateful. Default to false.
      */
-    private getMissingMandatoryArgs;
+    stateful?: boolean;
     /**
-     * Extracts the function parameters from the function's signature.
+     * The number of attempts to retry on consecutive code execution errors.
+     * Default to 2.
      */
-    private getFunctionParameters;
+    errorRetryAttempts?: number;
     /**
-     * Converts an argument to the proper type based on the function signature.
+     * The list of the enclosing delimiters to identify the code blocks.
+     * For example, the delimiter ['```python\n', '\n```'] can be
+     * used to identify code blocks with the following format:
+     *
+     * ```python
+     * print("hello")
+     * ```
      */
-    private convertArgumentType;
+    codeBlockDelimiters?: Array<[string, string]>;
     /**
-     * Extracts the type of a specific parameter from the function signature.
+     * The delimiters to format the code execution result.
      */
-    private getParameterType;
+    executionResultDelimiters?: [string, string];
+}
+declare abstract class BaseCodeExecutor {
+    protected readonly config: Required<BaseCodeExecutorConfig>;
+    constructor(config?: BaseCodeExecutorConfig);
+    /**
+     * Executes code and returns the code execution result.
+     */
+    abstract executeCode(invocationContext: InvocationContext, codeExecutionInput: CodeExecutionInput): Promise<CodeExecutionResult>;
+    get optimizeDataFile(): boolean;
+    get stateful(): boolean;
+    get errorRetryAttempts(): number;
+    get codeBlockDelimiters(): Array<[string, string]>;
+    get executionResultDelimiters(): [string, string];
 }
 
 /**
- * Options for building a function declaration
+ * Candidate response from the model.
  */
-interface BuildFunctionDeclarationOptions {
-    name?: string;
-    description?: string;
-    ignoreParams?: string[];
+interface Candidate {
+    content?: Content;
+    groundingMetadata?: GroundingMetadata;
+    finishReason?: string;
+    finishMessage?: string;
 }
 /**
- * Builds a function declaration from a TypeScript function.
- *
- * This utility analyzes the function signature and JSDoc comments to create
- * a FunctionDeclaration object that can be used with LLMs.
- *
- * @param func The function to analyze
- * @param options Options for customizing the declaration
- * @returns A FunctionDeclaration representing the function
+ * Prompt feedback in case of blocked or failed prompt.
  */
-declare function buildFunctionDeclaration(func: (...args: any[]) => any, options?: BuildFunctionDeclarationOptions): FunctionDeclaration;
-
+interface PromptFeedback {
+    blockReason?: string;
+    blockReasonMessage?: string;
+}
 /**
- * Creates a new FunctionTool that wraps a function.
- * This is a convenience function for creating a new FunctionTool.
- *
- * @param func The function to wrap
- * @param options Optional configuration for the tool
- * @returns A new FunctionTool wrapping the function
+ * The response from the model generation API.
  */
-declare function createFunctionTool(func: (...args: any[]) => any, options?: {
-    name?: string;
-    description?: string;
-    isLongRunning?: boolean;
-    shouldRetryOnFailure?: boolean;
-    maxRetryAttempts?: number;
-}): any;
-
+interface GenerateContentResponse {
+    candidates?: Candidate[];
+    usageMetadata?: GenerateContentResponseUsageMetadata;
+    promptFeedback?: PromptFeedback;
+}
 /**
- * Simple GoogleSearch tool implementation
+ * Response from a language model.
  */
-declare class GoogleSearch extends BaseTool {
-    protected logger: Logger;
+declare class LlmResponse {
     /**
-     * Constructor for GoogleSearch
+     * Unique identifier for the response.
      */
-    constructor();
+    id?: string;
     /**
-     * Get the function declaration for the tool
+     * The content generated by the model.
      */
-    getDeclaration(): FunctionDeclaration;
+    content?: Content;
     /**
-     * Execute the search
-     * This is a simplified implementation that doesn't actually search, just returns mock results
+     * The grounding metadata of the response.
      */
-    runAsync(args: {
-        query: string;
-        num_results?: number;
-    }, _context: ToolContext): Promise<any>;
-}
-
-interface HttpRequestResult {
-    statusCode: number;
-    headers: Record<string, string>;
-    body: string;
-    error?: string;
-}
-/**
- * Tool for making HTTP requests to external APIs and web services
- */
-declare class HttpRequestTool extends BaseTool {
-    constructor();
+    groundingMetadata?: GroundingMetadata;
     /**
-     * Get the function declaration for the tool
+     * Indicates whether the text content is part of an unfinished text stream.
      */
-    getDeclaration(): FunctionDeclaration;
+    partial?: boolean;
     /**
-     * Execute the HTTP request
+     * Indicates whether the response from the model is complete.
      */
-    runAsync(args: {
-        url: string;
-        method?: string;
-        headers?: Record<string, string>;
-        body?: string;
-        params?: Record<string, string>;
-        timeout?: number;
-    }, _context: ToolContext): Promise<HttpRequestResult>;
+    turnComplete?: boolean;
     /**
-     * Check if a string is valid JSON
+     * Error code if the response is an error.
      */
-    private isValidJson;
-}
-
-interface FileOperationResult {
-    success: boolean;
-    data?: any;
-    error?: string;
-}
-/**
- * Tool for performing file system operations
- */
-declare class FileOperationsTool extends BaseTool {
-    private basePath;
-    constructor(options?: {
-        basePath?: string;
-    });
+    errorCode?: string;
     /**
-     * Get the function declaration for the tool
+     * Error message if the response is an error.
      */
-    getDeclaration(): FunctionDeclaration;
+    errorMessage?: string;
     /**
-     * Execute the file operation
+     * Flag indicating that LLM was interrupted when generating the content.
      */
-    runAsync(args: {
-        operation: "read" | "write" | "append" | "delete" | "exists" | "list" | "mkdir";
-        filepath: string;
-        content?: string;
-        encoding?: BufferEncoding;
-    }, _context: ToolContext): Promise<FileOperationResult>;
-    /**
-     * Resolve a file path relative to the base path
-     */
-    private resolvePath;
+    interrupted?: boolean;
     /**
-     * Validate that a path is within the base path for security
+     * The custom metadata of the LlmResponse.
      */
-    private validatePath;
+    customMetadata?: Record<string, any>;
     /**
-     * Read a file
+     * The usage metadata of the LlmResponse.
      */
-    private readFile;
+    usageMetadata?: GenerateContentResponseUsageMetadata;
     /**
-     * Write to a file
+     * Index of the candidate response.
      */
-    private writeFile;
+    candidateIndex?: number;
     /**
-     * Append to a file
+     * Reason why the model finished generating.
      */
-    private appendFile;
+    finishReason?: string;
     /**
-     * Delete a file
+     * Error object if the response is an error.
      */
-    private deleteFile;
+    error?: Error;
     /**
-     * Check if a file exists
+     * Creates a new LlmResponse.
      */
-    private fileExists;
+    constructor(data?: Partial<LlmResponse>);
     /**
-     * List directory contents
+     * Creates an LlmResponse from a GenerateContentResponse.
+     *
+     * @param generateContentResponse The GenerateContentResponse to create the LlmResponse from.
+     * @returns The LlmResponse.
      */
-    private listDirectory;
+    static create(generateContentResponse: GenerateContentResponse): LlmResponse;
     /**
-     * Create a directory
+     * Creates an LlmResponse from an error.
+     *
+     * @param error The error object or message.
+     * @param options Additional options for the error response.
+     * @param options.errorCode A specific error code for the response.
+     * @param options.model The model that was being used when the error occurred.
+     * @returns The LlmResponse.
      */
-    private makeDirectory;
+    static fromError(error: unknown, options?: {
+        errorCode?: string;
+        model?: string;
+    }): LlmResponse;
 }
 
-interface UserInteractionResult {
-    success: boolean;
-    userInput?: string;
-    error?: string;
-}
 /**
- * Tool for prompting the user for input
+ * The base class for a live model connection.
  */
-declare class UserInteractionTool extends BaseTool {
-    constructor();
+declare abstract class BaseLLMConnection {
     /**
-     * Get the function declaration for the tool
+     * Sends the conversation history to the model.
+     *
+     * You call this method right after setting up the model connection.
+     * The model will respond if the last content is from user, otherwise it will
+     * wait for new user input before responding.
+     *
+     * @param history The conversation history to send to the model.
      */
-    getDeclaration(): FunctionDeclaration;
+    abstract sendHistory(history: Content[]): Promise<void>;
     /**
-     * Execute the user interaction
+     * Sends a user content to the model.
+     *
+     * The model will respond immediately upon receiving the content.
+     * If you send function responses, all parts in the content should be function
+     * responses.
+     *
+     * @param content The content to send to the model.
      */
-    runAsync(args: {
-        prompt: string;
-        options?: string[];
-        defaultValue?: string;
-    }, context: ToolContext): Promise<UserInteractionResult>;
-}
-
-/**
- * Tool that allows an agent to exit the current execution loop
- */
-declare class ExitLoopTool extends BaseTool {
-    protected logger: Logger;
+    abstract sendContent(content: Content): Promise<void>;
     /**
-     * Constructor for ExitLoopTool
+     * Sends a chunk of audio or a frame of video to the model in realtime.
+     *
+     * The model may not respond immediately upon receiving the blob. It will do
+     * voice activity detection and decide when to respond.
+     *
+     * @param blob The blob to send to the model.
      */
-    constructor();
+    abstract sendRealtime(blob: Blob): Promise<void>;
     /**
-     * Execute the exit loop action
+     * Receives the model response using the llm server connection.
+     *
+     * @returns LlmResponse: The model response.
      */
-    runAsync(_args: Record<string, any>, context: ToolContext): Promise<any>;
+    abstract receive(): AsyncGenerator<LlmResponse, void, unknown>;
+    /**
+     * Closes the llm server connection.
+     */
+    abstract close(): Promise<void>;
 }
 
 /**
- * Tool that allows an agent to get a choice from the user
+ * The BaseLlm class.
  */
-declare class GetUserChoiceTool extends BaseTool {
+declare abstract class BaseLlm {
+    /**
+     * The name of the LLM, e.g. gemini-1.5-flash or gemini-1.5-flash-001.
+     */
+    model: string;
     protected logger: Logger;
     /**
-     * Constructor for GetUserChoiceTool
+     * Constructor for BaseLlm
      */
-    constructor();
+    constructor(model: string);
     /**
-     * Get the function declaration for the tool
+     * Returns a list of supported models in regex for LLMRegistry
      */
-    getDeclaration(): FunctionDeclaration;
+    static supportedModels(): string[];
     /**
-     * Execute the user choice action
-     * This is a long running operation that will return null initially
-     * and the actual choice will be provided asynchronously
+     * Generates one content from the given contents and tools.
+     *
+     * @param llmRequest LlmRequest, the request to send to the LLM.
+     * @param stream bool = false, whether to do streaming call.
+     * @returns a generator of LlmResponse.
+     *
+     * For non-streaming call, it will only yield one LlmResponse.
+     *
+     * For streaming call, it may yield more than one response, but all yielded
+     * responses should be treated as one response by merging the
+     * parts list.
      */
-    runAsync(args: {
-        options: string[];
-        question?: string;
-    }, context: ToolContext): Promise<any>;
-}
-
-/**
- * Tool that allows an agent to transfer control to another agent
- */
-declare class TransferToAgentTool extends BaseTool {
-    protected logger: Logger;
+    generateContentAsync(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
     /**
-     * Constructor for TransferToAgentTool
+     * Implementation method to be overridden by subclasses.
+     * This replaces the abstract generateContentAsync method.
      */
-    constructor();
+    protected abstract generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
     /**
-     * Execute the transfer to agent action
+     * Appends a user content, so that model can continue to output.
+     *
+     * @param llmRequest LlmRequest, the request to send to the LLM.
      */
-    runAsync(args: {
-        agent_name: string;
-    }, context: ToolContext): Promise<any>;
+    protected maybeAppendUserContent(llmRequest: LlmRequest): void;
+    /**
+     * Creates a live connection to the LLM.
+     *
+     * @param llmRequest LlmRequest, the request to send to the LLM.
+     * @returns BaseLLMConnection, the connection to the LLM.
+     */
+    connect(llmRequest: LlmRequest): BaseLLMConnection;
 }
 
 /**
- * Tool that allows an agent to load memories relevant to a query
+ * Abstract base class for all planners.
+ *
+ * The planner allows the agent to generate plans for the queries to guide its action.
  */
-declare class LoadMemoryTool extends BaseTool {
-    protected logger: Logger;
-    /**
-     * Constructor for LoadMemoryTool
-     */
-    constructor();
+declare abstract class BasePlanner {
     /**
-     * Get the function declaration for the tool
+     * Builds the system instruction to be appended to the LLM request for planning.
+     *
+     * @param readonlyContext The readonly context of the invocation
+     * @param llmRequest The LLM request. Readonly.
+     * @returns The planning system instruction, or undefined if no instruction is needed
      */
-    getDeclaration(): FunctionDeclaration;
+    abstract buildPlanningInstruction(readonlyContext: ReadonlyContext, llmRequest: LlmRequest): string | undefined;
     /**
-     * Execute the memory loading action
+     * Processes the LLM response for planning.
+     *
+     * @param callbackContext The callback context of the invocation
+     * @param responseParts The LLM response parts. Readonly.
+     * @returns The processed response parts, or undefined if no processing is needed
      */
-    runAsync(args: {
-        query: string;
-    }, context: ToolContext): Promise<any>;
+    abstract processPlanningResponse(callbackContext: CallbackContext, responseParts: Part[]): Part[] | undefined;
 }
 
 /**
- * Content interface for LLM requests
+ * Type for instruction providers that can be functions
  */
-interface Content {
-    role: string;
-    parts: Part[];
-}
+type InstructionProvider = (ctx: ReadonlyContext) => string | Promise<string>;
 /**
- * Extended LLM request interface with content support
+ * Union type for tools (supporting functions, tools, and toolsets)
  */
-interface ExtendedLlmRequest extends LlmRequest$1 {
-    contents?: Content[];
-    appendInstructions?: (instructions: string[]) => void;
-}
+type ToolUnion = BaseTool | ((...args: any[]) => any);
 /**
- * A tool that loads the artifacts and adds them to the session.
+ * Configuration for LlmAgent
  */
-declare class LoadArtifactsTool extends BaseTool {
-    constructor();
+interface LlmAgentConfig<T extends BaseLlm = BaseLlm> {
     /**
-     * Get the function declaration for the tool
+     * Name of the agent
      */
-    getDeclaration(): FunctionDeclaration;
+    name: string;
     /**
-     * Execute the load artifacts operation
+     * Description of the agent
      */
-    runAsync(args: {
-        artifact_names?: string[];
-    }, context: ToolContext): Promise<{
-        artifact_names: string[];
-    }>;
+    description: string;
     /**
-     * Processes the outgoing LLM request for this tool.
+     * Sub-agents that this agent can delegate to
      */
-    processLlmRequest(toolContext: ToolContext, llmRequest: ExtendedLlmRequest): Promise<void>;
+    subAgents?: BaseAgent[];
     /**
-     * Appends artifacts information to the LLM request
+     * Callback or list of callbacks to be invoked before the agent run
      */
-    private appendArtifactsToLlmRequest;
+    beforeAgentCallback?: BeforeAgentCallback;
     /**
-     * Extracts function response from a part if it exists
+     * Callback or list of callbacks to be invoked after the agent run
      */
-    private extractFunctionResponse;
-}
-
-type McpConfig = {
-    name: string;
-    description: string;
-    transport: McpTransportType;
-    timeout?: number;
-    retryOptions?: {
-        maxRetries?: number;
-        initialDelay?: number;
-        maxDelay?: number;
-    };
-    headers?: Record<string, string>;
-    cacheConfig?: {
-        enabled?: boolean;
-        maxAge?: number;
-        maxSize?: number;
-    };
-    debug?: boolean;
+    afterAgentCallback?: AfterAgentCallback;
     /**
-     * Sampling handler for processing MCP sampling requests.
-     * This allows MCP servers to request LLM completions through your ADK agent.
+     * The LLM model to use
+     * When not set, the agent will inherit the model from its ancestor
+     */
+    model?: string | T | LanguageModel;
+    /**
+     * 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 global_instruction in root agent will take effect
+     */
+    globalInstruction?: string | InstructionProvider;
+    /**
+     * Tools available to this agent
+     */
+    tools?: ToolUnion[];
+    /**
+     * Code executor for this agent
+     */
+    codeExecutor?: BaseCodeExecutor;
+    /**
+     * Disallows LLM-controlled transferring to the parent agent
+     */
+    disallowTransferToParent?: boolean;
+    /**
+     * Disallows LLM-controlled transferring to the peer agents
+     */
+    disallowTransferToPeers?: boolean;
+    /**
+     * Whether to include contents in the model request
+     */
+    includeContents?: "default" | "none";
+    /**
+     * The output key in session state to store the output of the agent
+     */
+    outputKey?: string;
+    /**
+     * Instructs the agent to make a plan and execute it step by step
+     */
+    planner?: BasePlanner;
+    /**
+     * Memory service for long-term storage and retrieval
+     */
+    memoryService?: BaseMemoryService;
+    /**
+     * Session service for managing conversations
+     */
+    sessionService?: BaseSessionService;
+    /**
+     * Artifact service for file storage and management
+     */
+    artifactService?: BaseArtifactService;
+    /**
+     * User ID for the session
+     */
+    userId?: string;
+    /**
+     * Application name
+     */
+    appName?: string;
+    /**
+     * 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.
+     */
+    generateContentConfig?: GenerateContentConfig;
+    /**
+     * The input schema when agent is used as a tool
+     */
+    inputSchema?: any;
+    /**
+     * The output schema when agent replies
+     * NOTE: when this is set, agent can ONLY reply and CANNOT use any tools
+     */
+    outputSchema?: any;
+}
+/**
+ * LLM-based Agent
+ */
+declare class LlmAgent<T extends BaseLlm = BaseLlm> extends BaseAgent {
+    /**
+     * The model to use for the agent
+     * When not set, the agent will inherit the model from its ancestor
+     */
+    model: string | T | LanguageModel;
+    /**
+     * 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 global_instruction in root agent will take effect
+     */
+    globalInstruction: string | InstructionProvider;
+    /**
+     * Tools available to this agent
+     */
+    tools: ToolUnion[];
+    /**
+     * Code executor for this agent
+     */
+    codeExecutor?: BaseCodeExecutor;
+    /**
+     * Disallows LLM-controlled transferring to the parent agent
+     */
+    disallowTransferToParent: boolean;
+    /**
+     * Disallows LLM-controlled transferring to the peer agents
+     */
+    disallowTransferToPeers: boolean;
+    /**
+     * Whether to include contents in the model request
+     */
+    includeContents: "default" | "none";
+    /**
+     * The output key in session state to store the output of the agent
+     */
+    outputKey?: string;
+    /**
+     * Instructs the agent to make a plan and execute it step by step
+     */
+    planner?: BasePlanner;
+    /**
+     * Memory service for long-term storage and retrieval
+     */
+    private memoryService?;
+    /**
+     * Session service for managing conversations
+     */
+    private sessionService?;
+    /**
+     * Artifact service for file storage and management
+     */
+    private artifactService?;
+    /**
+     * User ID for the session
+     */
+    private userId?;
+    /**
+     * Application name
+     */
+    private appName?;
+    /**
+     * Additional content generation configurations
+     */
+    generateContentConfig?: GenerateContentConfig;
+    /**
+     * The input schema when agent is used as a tool
+     */
+    inputSchema?: any;
+    /**
+     * The output schema when agent replies
+     */
+    outputSchema?: any;
+    protected logger: Logger;
+    /**
+     * Constructor for LlmAgent
+     */
+    constructor(config: LlmAgentConfig<T>);
+    /**
+     * The resolved model field as BaseLLM
+     * This method is only for use by Agent Development Kit
+     */
+    get canonicalModel(): BaseLlm;
+    /**
+     * The resolved instruction field to construct instruction for this agent
+     * This method is only for use by Agent Development Kit
+     */
+    canonicalInstruction(ctx: ReadonlyContext): Promise<[string, boolean]>;
+    /**
+     * The resolved global_instruction field to construct global instruction
+     * This method is only for use by Agent Development Kit
+     */
+    canonicalGlobalInstruction(ctx: ReadonlyContext): Promise<[string, 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(ctx?: ReadonlyContext): Promise<BaseTool[]>;
+    /**
+     * Gets the appropriate LLM flow for this agent
+     * This matches the Python implementation's _llm_flow property
+     */
+    private get llmFlow();
+    /**
+     * Saves the model output to state if needed
+     * This matches the Python implementation's __maybe_save_output_to_state
+     */
+    private maybeSaveOutputToState;
+    /**
+     * Core logic to run this agent via text-based conversation
+     * This matches the Python implementation's _run_async_impl
+     */
+    protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, unknown>;
+}
+
+/**
+ * Type for agents that can be used as tools
+ */
+type BaseAgentType = LlmAgent;
+/**
+ * Configuration for AgentTool
+ */
+interface AgentToolConfig {
+    /**
+     * Name of the tool
+     */
+    name: string;
+    /**
+     * Description of the tool
+     */
+    description?: string;
+    /**
+     * The agent that will be used as a tool
+     */
+    agent: BaseAgentType;
+    /**
+     * Optional function declaration schema override
+     */
+    functionDeclaration?: FunctionDeclaration;
+    /**
+     * Optional key to store the tool output in the state
+     */
+    outputKey?: string;
+    /**
+     * Optional flag to skip summarization of the agent's response
+     */
+    skipSummarization?: boolean;
+    /**
+     * Whether the tool is a long running operation
+     */
+    isLongRunning?: boolean;
+    /**
+     * Whether the tool execution should be retried on failure
+     */
+    shouldRetryOnFailure?: boolean;
+    /**
+     * Maximum retry attempts
+     */
+    maxRetryAttempts?: number;
+}
+/**
+ * A tool that uses an agent to perform a task.
+ *
+ * This tool allows specialized agents to be used as reusable tools
+ * within other agents, enabling modular agent composition and
+ * domain-specific expertise as services.
+ */
+declare class AgentTool extends BaseTool {
+    /**
+     * The agent used by this tool
+     */
+    private agent;
+    /**
+     * The function declaration schema
+     */
+    private functionDeclaration?;
+    /**
+     * The key to store the tool output in the state
+     */
+    outputKey?: string;
+    /**
+     * Whether to skip summarization of the agent's response
+     */
+    private skipSummarization;
+    protected logger: Logger;
+    /**
+     * Create a new agent tool
+     */
+    constructor(config: AgentToolConfig);
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the tool by running the agent with the provided input
+     */
+    runAsync(params: Record<string, any>, context: ToolContext): Promise<any>;
+}
+
+/**
+ * A tool that wraps a user-defined TypeScript function.
+ *
+ * This tool automatically generates a function declaration from the function's
+ * signature and documentation, making it easy to expose functions to agents.
+ */
+declare class FunctionTool<T extends Record<string, any>> extends BaseTool {
+    private func;
+    private mandatoryArgs;
+    private parameterTypes;
+    /**
+     * Creates a new FunctionTool wrapping the provided function.
+     *
+     * @param func The function to wrap
+     * @param options Optional configuration for the tool
+     */
+    constructor(func: (...args: any[]) => any, options?: {
+        name?: string;
+        description?: string;
+        isLongRunning?: boolean;
+        shouldRetryOnFailure?: boolean;
+        maxRetryAttempts?: number;
+        parameterTypes?: Record<string, string>;
+    });
+    /**
+     * Executes the wrapped function with the provided arguments.
+     */
+    runAsync(args: T, context: ToolContext): Promise<any>;
+    /**
+     * Returns the function declaration for this tool.
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Checks if the wrapped function accepts a toolContext parameter.
+     */
+    private functionAcceptsToolContext;
+    /**
+     * Checks if the wrapped function is async.
+     */
+    private isAsyncFunction;
+    /**
+     * Extracts the mandatory arguments from a function.
+     * In TypeScript, we can't easily inspect parameter defaults at runtime,
+     * so this is a best-effort approach.
+     */
+    private getMandatoryArgs;
+    /**
+     * Checks which mandatory arguments are missing from the provided args.
+     */
+    private getMissingMandatoryArgs;
+    /**
+     * Extracts the function parameters from the function's signature.
+     */
+    private getFunctionParameters;
+    /**
+     * Converts an argument to the proper type based on the function signature.
+     */
+    private convertArgumentType;
+    /**
+     * Extracts the type of a specific parameter from the function signature.
+     */
+    private getParameterType;
+}
+
+/**
+ * Options for building a function declaration
+ */
+interface BuildFunctionDeclarationOptions {
+    name?: string;
+    description?: string;
+    ignoreParams?: string[];
+}
+/**
+ * Builds a function declaration from a TypeScript function.
+ *
+ * This utility analyzes the function signature and JSDoc comments to create
+ * a FunctionDeclaration object that can be used with LLMs.
+ *
+ * @param func The function to analyze
+ * @param options Options for customizing the declaration
+ * @returns A FunctionDeclaration representing the function
+ */
+declare function buildFunctionDeclaration(func: (...args: any[]) => any, options?: BuildFunctionDeclarationOptions): FunctionDeclaration;
+
+/**
+ * Creates a new FunctionTool that wraps a function.
+ * This is a convenience function for creating a new FunctionTool.
+ *
+ * @param func The function to wrap
+ * @param options Optional configuration for the tool
+ * @returns A new FunctionTool wrapping the function
+ */
+declare function createFunctionTool(func: (...args: any[]) => any, options?: {
+    name?: string;
+    description?: string;
+    isLongRunning?: boolean;
+    shouldRetryOnFailure?: boolean;
+    maxRetryAttempts?: number;
+}): any;
+
+/**
+ * Simple GoogleSearch tool implementation
+ */
+declare class GoogleSearch extends BaseTool {
+    protected logger: Logger;
+    /**
+     * Constructor for GoogleSearch
+     */
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the search
+     * This is a simplified implementation that doesn't actually search, just returns mock results
+     */
+    runAsync(args: {
+        query: string;
+        num_results?: number;
+    }, _context: ToolContext): Promise<any>;
+}
+
+interface HttpRequestResult {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+    error?: string;
+}
+/**
+ * Tool for making HTTP requests to external APIs and web services
+ */
+declare class HttpRequestTool extends BaseTool {
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the HTTP request
+     */
+    runAsync(args: {
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+        body?: string;
+        params?: Record<string, string>;
+        timeout?: number;
+    }, _context: ToolContext): Promise<HttpRequestResult>;
+    /**
+     * Check if a string is valid JSON
+     */
+    private isValidJson;
+}
+
+interface FileOperationResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+}
+/**
+ * Tool for performing file system operations
+ */
+declare class FileOperationsTool extends BaseTool {
+    private basePath;
+    constructor(options?: {
+        basePath?: string;
+    });
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the file operation
+     */
+    runAsync(args: {
+        operation: "read" | "write" | "append" | "delete" | "exists" | "list" | "mkdir";
+        filepath: string;
+        content?: string;
+        encoding?: BufferEncoding;
+    }, _context: ToolContext): Promise<FileOperationResult>;
+    /**
+     * Resolve a file path relative to the base path
+     */
+    private resolvePath;
+    /**
+     * Validate that a path is within the base path for security
+     */
+    private validatePath;
+    /**
+     * Read a file
+     */
+    private readFile;
+    /**
+     * Write to a file
+     */
+    private writeFile;
+    /**
+     * Append to a file
+     */
+    private appendFile;
+    /**
+     * Delete a file
+     */
+    private deleteFile;
+    /**
+     * Check if a file exists
+     */
+    private fileExists;
+    /**
+     * List directory contents
+     */
+    private listDirectory;
+    /**
+     * Create a directory
+     */
+    private makeDirectory;
+}
+
+interface UserInteractionResult {
+    success: boolean;
+    userInput?: string;
+    error?: string;
+}
+/**
+ * Tool for prompting the user for input
+ */
+declare class UserInteractionTool extends BaseTool {
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the user interaction
+     */
+    runAsync(args: {
+        prompt: string;
+        options?: string[];
+        defaultValue?: string;
+    }, context: ToolContext): Promise<UserInteractionResult>;
+}
+
+/**
+ * Tool that allows an agent to exit the current execution loop
+ */
+declare class ExitLoopTool extends BaseTool {
+    protected logger: Logger;
+    /**
+     * Constructor for ExitLoopTool
+     */
+    constructor();
+    /**
+     * Execute the exit loop action
+     */
+    runAsync(_args: Record<string, any>, context: ToolContext): Promise<any>;
+}
+
+/**
+ * Tool that allows an agent to get a choice from the user
+ */
+declare class GetUserChoiceTool extends BaseTool {
+    protected logger: Logger;
+    /**
+     * Constructor for GetUserChoiceTool
+     */
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the user choice action
+     * This is a long running operation that will return null initially
+     * and the actual choice will be provided asynchronously
+     */
+    runAsync(args: {
+        options: string[];
+        question?: string;
+    }, context: ToolContext): Promise<any>;
+}
+
+/**
+ * Tool that allows an agent to transfer control to another agent
+ */
+declare class TransferToAgentTool extends BaseTool {
+    protected logger: Logger;
+    /**
+     * Constructor for TransferToAgentTool
+     */
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the transfer to agent action
+     */
+    runAsync(args: {
+        agent_name: string;
+    }, context: ToolContext): Promise<any>;
+}
+
+/**
+ * Tool that allows an agent to load memories relevant to a query
+ */
+declare class LoadMemoryTool extends BaseTool {
+    protected logger: Logger;
+    /**
+     * Constructor for LoadMemoryTool
+     */
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the memory loading action
+     */
+    runAsync(args: {
+        query: string;
+    }, context: ToolContext): Promise<any>;
+}
+
+/**
+ * A tool that loads the artifacts and adds them to the session.
+ */
+declare class LoadArtifactsTool extends BaseTool {
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the load artifacts operation
+     */
+    runAsync(args: {
+        artifact_names?: string[];
+    }, context: ToolContext): Promise<{
+        artifact_names: string[];
+    }>;
+    /**
+     * Processes the outgoing LLM request for this tool.
+     */
+    processLlmRequest(toolContext: ToolContext, llmRequest: LlmRequest): Promise<void>;
+    /**
+     * Appends artifacts information to the LLM request
+     */
+    private appendArtifactsToLlmRequest;
+    /**
+     * Extracts function response from a part if it exists
+     */
+    private extractFunctionResponse;
+}
+
+type McpConfig = {
+    name: string;
+    description: string;
+    transport: McpTransportType;
+    timeout?: number;
+    retryOptions?: {
+        maxRetries?: number;
+        initialDelay?: number;
+        maxDelay?: number;
+    };
+    headers?: Record<string, string>;
+    cacheConfig?: {
+        enabled?: boolean;
+        maxAge?: number;
+        maxSize?: number;
+    };
+    debug?: boolean;
+    /**
+     * Sampling handler for processing MCP sampling requests.
+     * This allows MCP servers to request LLM completions through your ADK agent.
      */
     samplingHandler?: SamplingHandler;
 };
@@ -1497,11 +2076,11 @@ declare function jsonSchemaToDeclaration(name: string, description: string, sche
  * Normalizes a JSON Schema to ensure it's properly formatted
  * Handles edge cases and ensures consistency
  */
-declare function normalizeJsonSchema(schema: Record<string, any>): JSONSchema;
+declare function normalizeJsonSchema(schema: Record<string, any>): Schema;
 /**
  * Converts MCP tool inputSchema to parameters format expected by BaseTool
  */
-declare function mcpSchemaToParameters(mcpTool: Tool): JSONSchema;
+declare function mcpSchemaToParameters(mcpTool: Tool): Schema;
 
 /**
  * MCP Sampling Handler class that handles message format conversion
@@ -1854,6 +2433,10 @@ declare function getMcpTools(config: McpConfig, toolFilter?: string[] | ((tool:
  * Tools module exports
  */
 
+type index$6_AgentTool = AgentTool;
+declare const index$6_AgentTool: typeof AgentTool;
+type index$6_AgentToolConfig = AgentToolConfig;
+type index$6_BaseAgentType = BaseAgentType;
 type index$6_BaseTool = BaseTool;
 declare const index$6_BaseTool: typeof BaseTool;
 type index$6_BuildFunctionDeclarationOptions = BuildFunctionDeclarationOptions;
@@ -1921,7 +2504,7 @@ declare const index$6_jsonSchemaToDeclaration: typeof jsonSchemaToDeclaration;
 declare const index$6_mcpSchemaToParameters: typeof mcpSchemaToParameters;
 declare const index$6_normalizeJsonSchema: typeof normalizeJsonSchema;
 declare namespace index$6 {
-  export { index$6_BaseTool as BaseTool, type index$6_BuildFunctionDeclarationOptions as BuildFunctionDeclarationOptions, type index$6_CreateToolConfig as CreateToolConfig, type index$6_CreateToolConfigWithSchema as CreateToolConfigWithSchema, type index$6_CreateToolConfigWithoutSchema as CreateToolConfigWithoutSchema, index$6_ExitLoopTool as ExitLoopTool, index$6_FileOperationsTool as FileOperationsTool, index$6_FunctionTool as FunctionTool, index$6_GetUserChoiceTool as GetUserChoiceTool, index$6_GoogleSearch as GoogleSearch, index$6_HttpRequestTool as HttpRequestTool, index$6_LoadArtifactsTool as LoadArtifactsTool, index$6_LoadMemoryTool as LoadMemoryTool, index$6_McpAbi as McpAbi, index$6_McpAtp as McpAtp, index$6_McpBamm as McpBamm, index$6_McpCoinGecko as McpCoinGecko, type index$6_McpConfig as McpConfig, index$6_McpDiscord as McpDiscord, index$6_McpError as McpError, index$6_McpErrorType as McpErrorType, index$6_McpFilesystem as McpFilesystem, index$6_McpFraxlend as McpFraxlend, index$6_McpGeneric as McpGeneric, index$6_McpIqWiki as McpIqWiki, index$6_McpMemory as McpMemory, index$6_McpNearAgent as McpNearAgent, index$6_McpNearIntents as McpNearIntents, index$6_McpOdos as McpOdos, index$6_McpSamplingHandler as McpSamplingHandler, type index$6_McpSamplingRequest as McpSamplingRequest, type index$6_McpSamplingResponse as McpSamplingResponse, type index$6_McpServerConfig as McpServerConfig, index$6_McpTelegram as McpTelegram, index$6_McpToolset as McpToolset, type index$6_McpTransportType as McpTransportType, type index$6_SamplingHandler as SamplingHandler, type index$6_ToolConfig as ToolConfig, index$6_ToolContext as ToolContext, index$6_TransferToAgentTool as TransferToAgentTool, index$6_UserInteractionTool as UserInteractionTool, index$6_adkToMcpToolType as adkToMcpToolType, index$6_buildFunctionDeclaration as buildFunctionDeclaration, index$6_createFunctionTool as createFunctionTool, index$6_createSamplingHandler as createSamplingHandler, index$6_createTool as createTool, index$6_getMcpTools as getMcpTools, index$6_jsonSchemaToDeclaration as jsonSchemaToDeclaration, index$6_mcpSchemaToParameters as mcpSchemaToParameters, index$6_normalizeJsonSchema as normalizeJsonSchema };
+  export { index$6_AgentTool as AgentTool, type index$6_AgentToolConfig as AgentToolConfig, type index$6_BaseAgentType as BaseAgentType, index$6_BaseTool as BaseTool, type index$6_BuildFunctionDeclarationOptions as BuildFunctionDeclarationOptions, type index$6_CreateToolConfig as CreateToolConfig, type index$6_CreateToolConfigWithSchema as CreateToolConfigWithSchema, type index$6_CreateToolConfigWithoutSchema as CreateToolConfigWithoutSchema, index$6_ExitLoopTool as ExitLoopTool, index$6_FileOperationsTool as FileOperationsTool, index$6_FunctionTool as FunctionTool, index$6_GetUserChoiceTool as GetUserChoiceTool, index$6_GoogleSearch as GoogleSearch, index$6_HttpRequestTool as HttpRequestTool, index$6_LoadArtifactsTool as LoadArtifactsTool, index$6_LoadMemoryTool as LoadMemoryTool, index$6_McpAbi as McpAbi, index$6_McpAtp as McpAtp, index$6_McpBamm as McpBamm, index$6_McpCoinGecko as McpCoinGecko, type index$6_McpConfig as McpConfig, index$6_McpDiscord as McpDiscord, index$6_McpError as McpError, index$6_McpErrorType as McpErrorType, index$6_McpFilesystem as McpFilesystem, index$6_McpFraxlend as McpFraxlend, index$6_McpGeneric as McpGeneric, index$6_McpIqWiki as McpIqWiki, index$6_McpMemory as McpMemory, index$6_McpNearAgent as McpNearAgent, index$6_McpNearIntents as McpNearIntents, index$6_McpOdos as McpOdos, index$6_McpSamplingHandler as McpSamplingHandler, type index$6_McpSamplingRequest as McpSamplingRequest, type index$6_McpSamplingResponse as McpSamplingResponse, type index$6_McpServerConfig as McpServerConfig, index$6_McpTelegram as McpTelegram, index$6_McpToolset as McpToolset, type index$6_McpTransportType as McpTransportType, type index$6_SamplingHandler as SamplingHandler, type index$6_ToolConfig as ToolConfig, index$6_ToolContext as ToolContext, index$6_TransferToAgentTool as TransferToAgentTool, index$6_UserInteractionTool as UserInteractionTool, index$6_adkToMcpToolType as adkToMcpToolType, index$6_buildFunctionDeclaration as buildFunctionDeclaration, index$6_createFunctionTool as createFunctionTool, index$6_createSamplingHandler as createSamplingHandler, index$6_createTool as createTool, index$6_getMcpTools as getMcpTools, index$6_jsonSchemaToDeclaration as jsonSchemaToDeclaration, index$6_mcpSchemaToParameters as mcpSchemaToParameters, index$6_normalizeJsonSchema as normalizeJsonSchema };
 }
 
 /**
@@ -1942,7 +2525,7 @@ declare class LlmRequest {
     /**
      * The contents to send to the model.
      */
-    contents: Content$1[];
+    contents: Content[];
     /**
      * Additional config for the generate content request.
      * Tools in generate_content_config should not be set.
@@ -1958,241 +2541,39 @@ declare class LlmRequest {
     toolsDict: Record<string, BaseTool>;
     constructor(data?: {
         model?: string;
-        contents?: Content$1[];
+        contents?: Content[];
         config?: GenerateContentConfig;
         liveConnectConfig?: LiveConnectConfig;
-        toolsDict?: Record<string, BaseTool>;
-    });
-    /**
-     * Appends instructions to the system instruction.
-     * @param instructions The instructions to append.
-     */
-    appendInstructions(instructions: string[]): void;
-    /**
-     * Appends tools to the request.
-     * @param tools The tools to append.
-     */
-    appendTools(tools: BaseTool[]): void;
-    /**
-     * Sets the output schema for the request.
-     * @param baseModel The base model to set as the output schema.
-     */
-    setOutputSchema(baseModel: any): void;
-    /**
-     * Extracts the system instruction as plain text from Content or string.
-     * System instructions can be either string or Content type.
-     * @returns The system instruction as a string, or undefined if not set.
-     */
-    getSystemInstructionText(): string | undefined;
-    /**
-     * Extracts text content from a Content object.
-     * Used for extracting text from message contents.
-     * @param content The Content object to extract text from.
-     * @returns The extracted text as a string.
-     */
-    static extractTextFromContent(content: any): string;
-}
-
-/**
- * Candidate response from the model.
- */
-interface Candidate {
-    content?: Content$1;
-    groundingMetadata?: GroundingMetadata;
-    finishReason?: string;
-    finishMessage?: string;
-}
-/**
- * Prompt feedback in case of blocked or failed prompt.
- */
-interface PromptFeedback {
-    blockReason?: string;
-    blockReasonMessage?: string;
-}
-/**
- * The response from the model generation API.
- */
-interface GenerateContentResponse {
-    candidates?: Candidate[];
-    usageMetadata?: GenerateContentResponseUsageMetadata;
-    promptFeedback?: PromptFeedback;
-}
-/**
- * Response from a language model.
- */
-declare class LlmResponse {
-    /**
-     * Unique identifier for the response.
-     */
-    id?: string;
-    /**
-     * The content generated by the model.
-     */
-    content?: Content$1;
-    /**
-     * The grounding metadata of the response.
-     */
-    groundingMetadata?: GroundingMetadata;
-    /**
-     * Indicates whether the text content is part of an unfinished text stream.
-     */
-    partial?: boolean;
-    /**
-     * Indicates whether the response from the model is complete.
-     */
-    turnComplete?: boolean;
-    /**
-     * Error code if the response is an error.
-     */
-    errorCode?: string;
-    /**
-     * Error message if the response is an error.
-     */
-    errorMessage?: string;
-    /**
-     * Flag indicating that LLM was interrupted when generating the content.
-     */
-    interrupted?: boolean;
-    /**
-     * The custom metadata of the LlmResponse.
-     */
-    customMetadata?: Record<string, any>;
-    /**
-     * The usage metadata of the LlmResponse.
-     */
-    usageMetadata?: GenerateContentResponseUsageMetadata;
-    /**
-     * Index of the candidate response.
-     */
-    candidateIndex?: number;
-    /**
-     * Reason why the model finished generating.
-     */
-    finishReason?: string;
-    /**
-     * Error object if the response is an error.
-     */
-    error?: Error;
-    /**
-     * Creates a new LlmResponse.
-     */
-    constructor(data?: Partial<LlmResponse>);
-    /**
-     * Creates an LlmResponse from a GenerateContentResponse.
-     *
-     * @param generateContentResponse The GenerateContentResponse to create the LlmResponse from.
-     * @returns The LlmResponse.
-     */
-    static create(generateContentResponse: GenerateContentResponse): LlmResponse;
-    /**
-     * Creates an LlmResponse from an error.
-     *
-     * @param error The error object or message.
-     * @param options Additional options for the error response.
-     * @param options.errorCode A specific error code for the response.
-     * @param options.model The model that was being used when the error occurred.
-     * @returns The LlmResponse.
-     */
-    static fromError(error: unknown, options?: {
-        errorCode?: string;
-        model?: string;
-    }): LlmResponse;
-}
-
-/**
- * The base class for a live model connection.
- */
-declare abstract class BaseLLMConnection {
-    /**
-     * Sends the conversation history to the model.
-     *
-     * You call this method right after setting up the model connection.
-     * The model will respond if the last content is from user, otherwise it will
-     * wait for new user input before responding.
-     *
-     * @param history The conversation history to send to the model.
-     */
-    abstract sendHistory(history: Content$1[]): Promise<void>;
-    /**
-     * Sends a user content to the model.
-     *
-     * The model will respond immediately upon receiving the content.
-     * If you send function responses, all parts in the content should be function
-     * responses.
-     *
-     * @param content The content to send to the model.
-     */
-    abstract sendContent(content: Content$1): Promise<void>;
-    /**
-     * Sends a chunk of audio or a frame of video to the model in realtime.
-     *
-     * The model may not respond immediately upon receiving the blob. It will do
-     * voice activity detection and decide when to respond.
-     *
-     * @param blob The blob to send to the model.
-     */
-    abstract sendRealtime(blob: Blob): Promise<void>;
-    /**
-     * Receives the model response using the llm server connection.
-     *
-     * @returns LlmResponse: The model response.
-     */
-    abstract receive(): AsyncGenerator<LlmResponse, void, unknown>;
-    /**
-     * Closes the llm server connection.
-     */
-    abstract close(): Promise<void>;
-}
-
-/**
- * The BaseLlm class.
- */
-declare abstract class BaseLlm {
-    /**
-     * The name of the LLM, e.g. gemini-1.5-flash or gemini-1.5-flash-001.
-     */
-    model: string;
-    protected logger: Logger;
-    /**
-     * Constructor for BaseLlm
-     */
-    constructor(model: string);
-    /**
-     * Returns a list of supported models in regex for LLMRegistry
-     */
-    static supportedModels(): string[];
-    /**
-     * Generates one content from the given contents and tools.
-     *
-     * @param llmRequest LlmRequest, the request to send to the LLM.
-     * @param stream bool = false, whether to do streaming call.
-     * @returns a generator of LlmResponse.
-     *
-     * For non-streaming call, it will only yield one LlmResponse.
-     *
-     * For streaming call, it may yield more than one response, but all yielded
-     * responses should be treated as one response by merging the
-     * parts list.
+        toolsDict?: Record<string, BaseTool>;
+    });
+    /**
+     * Appends instructions to the system instruction.
+     * @param instructions The instructions to append.
      */
-    generateContentAsync(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    appendInstructions(instructions: string[]): void;
     /**
-     * Implementation method to be overridden by subclasses.
-     * This replaces the abstract generateContentAsync method.
+     * Appends tools to the request.
+     * @param tools The tools to append.
      */
-    protected abstract generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    appendTools(tools: BaseTool[]): void;
     /**
-     * Appends a user content, so that model can continue to output.
-     *
-     * @param llmRequest LlmRequest, the request to send to the LLM.
+     * Sets the output schema for the request.
+     * @param baseModel The base model to set as the output schema.
      */
-    protected maybeAppendUserContent(llmRequest: LlmRequest): void;
+    setOutputSchema(baseModel: any): void;
     /**
-     * Creates a live connection to the LLM.
-     *
-     * @param llmRequest LlmRequest, the request to send to the LLM.
-     * @returns BaseLLMConnection, the connection to the LLM.
+     * Extracts the system instruction as plain text from Content or string.
+     * System instructions can be either string or Content type.
+     * @returns The system instruction as a string, or undefined if not set.
      */
-    connect(llmRequest: LlmRequest): BaseLLMConnection;
+    getSystemInstructionText(): string | undefined;
+    /**
+     * Extracts text content from a Content object.
+     * Used for extracting text from message contents.
+     * @param content The Content object to extract text from.
+     * @returns The extracted text as a string.
+     */
+    static extractTextFromContent(content: any): string;
 }
 
 /**
@@ -2234,10 +2615,6 @@ declare class GoogleLlm extends BaseLlm {
      * Convert LlmRequest contents to GoogleGenAI format
      */
     private convertContents;
-    /**
-     * Convert LlmRequest config to GoogleGenAI format
-     */
-    private convertConfig;
     /**
      * Preprocesses the request based on the API backend.
      */
@@ -2427,1199 +2804,862 @@ declare class AiSdkLlm extends BaseLlm {
      */
     private convertToAiSdkMessages;
     /**
-     * Convert ADK tools to AI SDK tools format
-     */
-    private convertToAiSdkTools;
-    /**
-     * Convert ADK Content to AI SDK CoreMessage
-     */
-    private contentToAiSdkMessage;
-    /**
-     * Map ADK role to AI SDK role
-     */
-    private mapRole;
-    /**
-     * Map AI SDK finish reason to ADK finish reason
-     */
-    private mapFinishReason;
-}
-
-/**
- * Type for LLM constructor with static methods
- */
-interface LLMClass {
-    new (model: string): BaseLlm;
-    supportedModels(): string[];
-}
-/**
- * Registry for LLMs
- */
-declare class LLMRegistry {
-    /**
-     * Map of model name regex to LLM class
-     */
-    private static llmRegistry;
-    private static logger;
-    /**
-     * Creates a new LLM instance
-     *
-     * @param model The model name
-     * @returns The LLM instance
-     */
-    static newLLM(model: string): BaseLlm;
-    /**
-     * Resolves the LLM class from the model name
-     *
-     * @param model The model name
-     * @returns The LLM class
-     */
-    static resolve(model: string): LLMClass | null;
-    /**
-     * Registers a new LLM class
-     *
-     * @param modelNameRegex The regex to match model names
-     * @param llmClass The LLM class
-     */
-    static register(modelNameRegex: string, llmClass: LLMClass): void;
-    /**
-     * Registers all model patterns from an LLM class
-     *
-     * @param llmClass The LLM class
-     */
-    static registerLLM(llmClass: LLMClass): void;
-    /**
-     * Logs all registered models for debugging
-     */
-    static logRegisteredModels(): void;
-}
-
-/**
- * Register all LLM providers
- */
-declare function registerProviders(): void;
-
-/**
- * Configuration for model built-in thinking features
- * Compatible with google.genai.types.ThinkingConfig
- */
-interface ThinkingConfig {
-    /**
-     * Whether to include the thinking process in the response
-     */
-    includeThinking?: boolean;
-    /**
-     * Additional thinking configuration options
-     */
-    [key: string]: any;
-}
-
-/**
- * Authentication scheme types
- */
-declare enum AuthSchemeType {
-    APIKEY = "apiKey",
-    HTTP = "http",
-    OAUTH2 = "oauth2",
-    OPENID_CONNECT = "openIdConnect"
-}
-/**
- * Base class for authentication schemes
- */
-declare abstract class AuthScheme {
-    /**
-     * The type of authentication scheme
-     */
-    type: AuthSchemeType;
-    constructor(type: AuthSchemeType);
-}
-/**
- * API Key authentication scheme
- */
-declare class ApiKeyScheme extends AuthScheme {
-    /**
-     * Where the API key is sent
-     */
-    in: "query" | "header" | "cookie";
-    /**
-     * Name of the parameter
-     */
-    name: string;
-    /**
-     * Description of the API key
-     */
-    description?: string;
-    /**
-     * Constructor for ApiKeyScheme
-     */
-    constructor(config: {
-        in: "query" | "header" | "cookie";
-        name: string;
-        description?: string;
-    });
-}
-/**
- * HTTP authentication scheme
- */
-declare class HttpScheme extends AuthScheme {
-    /**
-     * The HTTP authentication scheme
-     */
-    scheme: "basic" | "bearer" | "digest" | "other";
-    /**
-     * Bearer format when scheme is 'bearer'
-     */
-    bearerFormat?: string;
-    /**
-     * Description of the scheme
-     */
-    description?: string;
-    /**
-     * Constructor for HttpScheme
-     */
-    constructor(config: {
-        scheme: "basic" | "bearer" | "digest" | "other";
-        bearerFormat?: string;
-        description?: string;
-    });
-}
-/**
- * OAuth flow configuration
- */
-interface OAuthFlow {
-    authorizationUrl?: string;
-    tokenUrl?: string;
-    refreshUrl?: string;
-    scopes: Record<string, string>;
-}
-/**
- * OAuth flows configuration
- */
-interface OAuthFlows {
-    implicit?: OAuthFlow;
-    password?: OAuthFlow;
-    clientCredentials?: OAuthFlow;
-    authorizationCode?: OAuthFlow;
-}
-/**
- * OAuth2 authentication scheme
- */
-declare class OAuth2Scheme extends AuthScheme {
-    /**
-     * OAuth flows
-     */
-    flows: OAuthFlows;
-    /**
-     * Description of the scheme
-     */
-    description?: string;
-    /**
-     * Constructor for OAuth2Scheme
-     */
-    constructor(config: {
-        flows: OAuthFlows;
-        description?: string;
-    });
-}
-/**
- * OpenID Connect authentication scheme
- */
-declare class OpenIdConnectScheme extends AuthScheme {
-    /**
-     * OpenID Connect URL
-     */
-    openIdConnectUrl: string;
-    /**
-     * Description of the scheme
-     */
-    description?: string;
-    /**
-     * Constructor for OpenIdConnectScheme
-     */
-    constructor(config: {
-        openIdConnectUrl: string;
-        description?: string;
-    });
-}
-
-/**
- * Authentication configuration for tools
- */
-declare class AuthConfig {
+     * Convert ADK tools to AI SDK tools format
+     */
+    private convertToAiSdkTools;
     /**
-     * The authentication scheme
+     * Convert ADK Content to AI SDK CoreMessage
      */
-    authScheme: AuthScheme;
+    private contentToAiSdkMessage;
     /**
-     * Additional context properties
+     * Map ADK role to AI SDK role
      */
-    context?: Record<string, any>;
+    private mapRole;
     /**
-     * Constructor for AuthConfig
+     * Map AI SDK finish reason to ADK finish reason
      */
-    constructor(config: {
-        authScheme: AuthScheme;
-        context?: Record<string, any>;
-    });
+    private mapFinishReason;
 }
 
 /**
- * Handler for authentication in tools
+ * Type for LLM constructor with static methods
  */
-declare class AuthHandler {
+interface LLMClass {
+    new (model: string): BaseLlm;
+    supportedModels(): string[];
+}
+/**
+ * Registry for LLMs
+ */
+declare class LLMRegistry {
     /**
-     * The authentication configuration
+     * Map of model name regex to LLM class
      */
-    authConfig: AuthConfig;
+    private static llmRegistry;
+    private static logger;
     /**
-     * The authentication credential
+     * Creates a new LLM instance
+     *
+     * @param model The model name
+     * @returns The LLM instance
      */
-    credential?: AuthCredential;
+    static newLLM(model: string): BaseLlm;
     /**
-     * Constructor for AuthHandler
+     * Resolves the LLM class from the model name
+     *
+     * @param model The model name
+     * @returns The LLM class
      */
-    constructor(config: {
-        authConfig: AuthConfig;
-        credential?: AuthCredential;
-    });
+    static resolve(model: string): LLMClass | null;
     /**
-     * Gets the authentication token
+     * Registers a new LLM class
+     *
+     * @param modelNameRegex The regex to match model names
+     * @param llmClass The LLM class
      */
-    getToken(): string | undefined;
+    static register(modelNameRegex: string, llmClass: LLMClass): void;
     /**
-     * Gets headers for HTTP requests
+     * Registers all model patterns from an LLM class
+     *
+     * @param llmClass The LLM class
      */
-    getHeaders(): Record<string, string>;
+    static registerLLM(llmClass: LLMClass): void;
     /**
-     * Refreshes the token if necessary
+     * Logs all registered models for debugging
      */
-    refreshToken(): Promise<void>;
+    static logRegisteredModels(): void;
 }
 
 /**
- * Base class for LLM request processors.
- */
-declare abstract class BaseLlmRequestProcessor {
-    /**
-     * Runs the processor on the given invocation context and LLM request.
-     * @param invocationContext The invocation context
-     * @param llmRequest The LLM request to process
-     * @returns An async generator yielding events
-     */
-    abstract runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, unknown>;
-}
-/**
- * Base class for LLM response processors.
+ * Register all LLM providers
  */
-declare abstract class BaseLlmResponseProcessor {
-    /**
-     * Processes the LLM response.
-     * @param invocationContext The invocation context
-     * @param llmResponse The LLM response to process
-     * @returns An async generator yielding events
-     */
-    abstract runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event, void, unknown>;
-}
+declare function registerProviders(): void;
 
 /**
- * Auth LLM request processor that handles authentication information
- * to build the LLM request with credential processing
+ * Configuration for model built-in thinking features
+ * Compatible with google.genai.types.ThinkingConfig
  */
-declare class AuthLlmRequestProcessor extends BaseLlmRequestProcessor {
+interface ThinkingConfig {
     /**
-     * Processes authentication information from session events
-     * and resumes function calls that required authentication
+     * Whether to include the thinking process in the response
      */
-    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
+    includeThinking?: boolean;
     /**
-     * Parses and stores authentication response in session state
+     * Additional thinking configuration options
      */
-    private parseAndStoreAuthResponse;
+    [key: string]: any;
 }
+
 /**
- * Exported request processor instance for use in flow configurations
+ * Authentication scheme types
  */
-declare const requestProcessor$7: AuthLlmRequestProcessor;
-
+declare enum AuthSchemeType {
+    APIKEY = "apiKey",
+    HTTP = "http",
+    OAUTH2 = "oauth2",
+    OPENID_CONNECT = "openIdConnect"
+}
 /**
- * Enhanced auth configuration with credential handling
- * This extends the basic AuthConfig with raw and exchanged credentials
+ * Base class for authentication schemes
  */
-declare class EnhancedAuthConfig {
-    /**
-     * The authentication scheme
-     */
-    authScheme: AuthScheme;
+declare abstract class AuthScheme {
     /**
-     * Raw auth credential used to collect credentials
-     * Used in auth schemes that need to exchange credentials (e.g. OAuth2, OIDC)
+     * The type of authentication scheme
      */
-    rawAuthCredential?: AuthCredential;
+    type: AuthSchemeType;
+    constructor(type: AuthSchemeType);
+}
+/**
+ * API Key authentication scheme
+ */
+declare class ApiKeyScheme extends AuthScheme {
     /**
-     * Exchanged auth credential after processing
-     * Filled by ADK and client working together
+     * Where the API key is sent
      */
-    exchangedAuthCredential?: AuthCredential;
+    in: "query" | "header" | "cookie";
     /**
-     * User-specified key for credential storage and retrieval
+     * Name of the parameter
      */
-    credentialKey?: string;
+    name: string;
     /**
-     * Additional context properties
+     * Description of the API key
      */
-    context?: Record<string, any>;
+    description?: string;
     /**
-     * Constructor for EnhancedAuthConfig
+     * Constructor for ApiKeyScheme
      */
     constructor(config: {
-        authScheme: AuthScheme;
-        rawAuthCredential?: AuthCredential;
-        exchangedAuthCredential?: AuthCredential;
-        credentialKey?: string;
-        context?: Record<string, any>;
+        in: "query" | "header" | "cookie";
+        name: string;
+        description?: string;
     });
-    /**
-     * Generates a credential key based on auth scheme and raw credential
-     * Used for saving/loading credentials from credential service
-     */
-    private generateCredentialKey;
-    /**
-     * Gets the credential key for storage
-     */
-    getCredentialKey(): string;
 }
 /**
- * Arguments for the special long-running function tool used to request
- * end-user credentials
+ * HTTP authentication scheme
  */
-interface AuthToolArguments extends Record<string, unknown> {
+declare class HttpScheme extends AuthScheme {
     /**
-     * The ID of the function call that requires authentication
+     * The HTTP authentication scheme
      */
-    function_call_id: string;
+    scheme: "basic" | "bearer" | "digest" | "other";
     /**
-     * The authentication configuration
+     * Bearer format when scheme is 'bearer'
      */
-    auth_config: AuthConfig | EnhancedAuthConfig;
-}
-/**
- * Auth tool for handling credential requests
- */
-declare class AuthTool {
+    bearerFormat?: string;
     /**
-     * Processes auth tool arguments and returns appropriate response
+     * Description of the scheme
      */
-    static processAuthRequest(args: AuthToolArguments): Promise<{
-        status: string;
-        authConfig?: AuthConfig | EnhancedAuthConfig;
-        credentialKey?: string;
-    }>;
+    description?: string;
     /**
-     * Validates auth tool arguments
+     * Constructor for HttpScheme
      */
-    static validateAuthArguments(args: any): args is AuthToolArguments;
+    constructor(config: {
+        scheme: "basic" | "bearer" | "digest" | "other";
+        bearerFormat?: string;
+        description?: string;
+    });
 }
 /**
- * Creates an AuthToolArguments object with proper typing
- */
-declare function createAuthToolArguments(functionCallId: string, authConfig: AuthConfig | EnhancedAuthConfig): AuthToolArguments;
-/**
- * Type guard to check if an auth config is enhanced
- */
-declare function isEnhancedAuthConfig(config: AuthConfig | EnhancedAuthConfig): config is EnhancedAuthConfig;
-
-/**
- * Types of authentication credentials
+ * OAuth flow configuration
  */
-declare enum AuthCredentialType {
-    API_KEY = "api_key",
-    BASIC = "basic",
-    BEARER = "bearer",
-    OAUTH2 = "oauth2",
-    CUSTOM = "custom"
+interface OAuthFlow {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: Record<string, string>;
 }
 /**
- * Base class for authentication credentials
+ * OAuth flows configuration
  */
-declare abstract class AuthCredential {
-    /**
-     * Type of credential
-     */
-    type: AuthCredentialType;
-    /**
-     * Constructor for AuthCredential
-     */
-    constructor(type: AuthCredentialType);
-    /**
-     * Gets the authentication token
-     */
-    abstract getToken(): string | undefined;
-    /**
-     * Gets headers for HTTP requests
-     */
-    abstract getHeaders(config: AuthConfig): Record<string, string>;
-    /**
-     * Whether the token can be refreshed
-     */
-    canRefresh(): boolean;
-    /**
-     * Refreshes the token
-     */
-    refresh(): Promise<void>;
+interface OAuthFlows {
+    implicit?: OAuthFlow;
+    password?: OAuthFlow;
+    clientCredentials?: OAuthFlow;
+    authorizationCode?: OAuthFlow;
 }
 /**
- * API Key credential
+ * OAuth2 authentication scheme
  */
-declare class ApiKeyCredential extends AuthCredential {
-    /**
-     * The API key
-     */
-    apiKey: string;
+declare class OAuth2Scheme extends AuthScheme {
     /**
-     * Constructor for ApiKeyCredential
+     * OAuth flows
      */
-    constructor(apiKey: string);
+    flows: OAuthFlows;
     /**
-     * Gets the API key as the token
+     * Description of the scheme
      */
-    getToken(): string;
+    description?: string;
     /**
-     * Gets headers for HTTP requests
+     * Constructor for OAuth2Scheme
      */
-    getHeaders(config: AuthConfig): Record<string, string>;
+    constructor(config: {
+        flows: OAuthFlows;
+        description?: string;
+    });
 }
 /**
- * Basic authentication credential
+ * OpenID Connect authentication scheme
  */
-declare class BasicAuthCredential extends AuthCredential {
-    /**
-     * The username
-     */
-    username: string;
-    /**
-     * The password
-     */
-    password: string;
+declare class OpenIdConnectScheme extends AuthScheme {
     /**
-     * Constructor for BasicAuthCredential
+     * OpenID Connect URL
      */
-    constructor(username: string, password: string);
+    openIdConnectUrl: string;
     /**
-     * Gets the encoded basic auth token
+     * Description of the scheme
      */
-    getToken(): string;
+    description?: string;
     /**
-     * Gets headers for HTTP requests
+     * Constructor for OpenIdConnectScheme
      */
-    getHeaders(): Record<string, string>;
+    constructor(config: {
+        openIdConnectUrl: string;
+        description?: string;
+    });
 }
+
 /**
- * Bearer token credential
+ * Authentication configuration for tools
  */
-declare class BearerTokenCredential extends AuthCredential {
-    /**
-     * The bearer token
-     */
-    token: string;
+declare class AuthConfig {
     /**
-     * Constructor for BearerTokenCredential
+     * The authentication scheme
      */
-    constructor(token: string);
+    authScheme: AuthScheme;
     /**
-     * Gets the bearer token
+     * Additional context properties
      */
-    getToken(): string;
+    context?: Record<string, any>;
     /**
-     * Gets headers for HTTP requests
+     * Constructor for AuthConfig
      */
-    getHeaders(): Record<string, string>;
+    constructor(config: {
+        authScheme: AuthScheme;
+        context?: Record<string, any>;
+    });
 }
+
 /**
- * OAuth2 token credential with refresh capability
+ * Handler for authentication in tools
  */
-declare class OAuth2Credential extends AuthCredential {
-    /**
-     * The access token
-     */
-    accessToken: string;
-    /**
-     * The refresh token
-     */
-    refreshToken?: string;
+declare class AuthHandler {
     /**
-     * When the token expires
+     * The authentication configuration
      */
-    expiresAt?: Date;
+    authConfig: AuthConfig;
     /**
-     * Function to refresh the token
+     * The authentication credential
      */
-    private refreshFunction?;
+    credential?: AuthCredential;
     /**
-     * Constructor for OAuth2Credential
+     * Constructor for AuthHandler
      */
     constructor(config: {
-        accessToken: string;
-        refreshToken?: string;
-        expiresIn?: number;
-        refreshFunction?: (refreshToken: string) => Promise<{
-            accessToken: string;
-            refreshToken?: string;
-            expiresIn?: number;
-        }>;
+        authConfig: AuthConfig;
+        credential?: AuthCredential;
     });
     /**
-     * Gets the access token
+     * Gets the authentication token
      */
-    getToken(): string;
+    getToken(): string | undefined;
     /**
      * Gets headers for HTTP requests
      */
     getHeaders(): Record<string, string>;
     /**
-     * Whether the token can be refreshed
-     */
-    canRefresh(): boolean;
-    /**
-     * Whether the token is expired
-     */
-    isExpired(): boolean;
-    /**
-     * Refreshes the token
+     * Refreshes the token if necessary
      */
-    refresh(): Promise<void>;
-}
-
-/**
- * Models module exports - consolidated to match Python structure
- */
-
-type index$5_AiSdkLlm = AiSdkLlm;
-declare const index$5_AiSdkLlm: typeof AiSdkLlm;
-type index$5_AnthropicLlm = AnthropicLlm;
-declare const index$5_AnthropicLlm: typeof AnthropicLlm;
-type index$5_ApiKeyCredential = ApiKeyCredential;
-declare const index$5_ApiKeyCredential: typeof ApiKeyCredential;
-type index$5_ApiKeyScheme = ApiKeyScheme;
-declare const index$5_ApiKeyScheme: typeof ApiKeyScheme;
-type index$5_AuthConfig = AuthConfig;
-declare const index$5_AuthConfig: typeof AuthConfig;
-type index$5_AuthCredential = AuthCredential;
-declare const index$5_AuthCredential: typeof AuthCredential;
-type index$5_AuthCredentialType = AuthCredentialType;
-declare const index$5_AuthCredentialType: typeof AuthCredentialType;
-type index$5_AuthHandler = AuthHandler;
-declare const index$5_AuthHandler: typeof AuthHandler;
-type index$5_AuthScheme = AuthScheme;
-declare const index$5_AuthScheme: typeof AuthScheme;
-type index$5_AuthSchemeType = AuthSchemeType;
-declare const index$5_AuthSchemeType: typeof AuthSchemeType;
-type index$5_BaseLLMConnection = BaseLLMConnection;
-declare const index$5_BaseLLMConnection: typeof BaseLLMConnection;
-type index$5_BaseLlm = BaseLlm;
-declare const index$5_BaseLlm: typeof BaseLlm;
-type index$5_BaseMemoryService = BaseMemoryService;
-type index$5_BasicAuthCredential = BasicAuthCredential;
-declare const index$5_BasicAuthCredential: typeof BasicAuthCredential;
-type index$5_BearerTokenCredential = BearerTokenCredential;
-declare const index$5_BearerTokenCredential: typeof BearerTokenCredential;
-declare const index$5_Blob: typeof Blob;
-type index$5_FunctionDeclaration = FunctionDeclaration;
-type index$5_GoogleLlm = GoogleLlm;
-declare const index$5_GoogleLlm: typeof GoogleLlm;
-type index$5_HttpScheme = HttpScheme;
-declare const index$5_HttpScheme: typeof HttpScheme;
-type index$5_JSONSchema = JSONSchema;
-type index$5_LLMRegistry = LLMRegistry;
-declare const index$5_LLMRegistry: typeof LLMRegistry;
-type index$5_LlmRequest = LlmRequest;
-declare const index$5_LlmRequest: typeof LlmRequest;
-type index$5_LlmResponse = LlmResponse;
-declare const index$5_LlmResponse: typeof LlmResponse;
-type index$5_OAuth2Credential = OAuth2Credential;
-declare const index$5_OAuth2Credential: typeof OAuth2Credential;
-type index$5_OAuth2Scheme = OAuth2Scheme;
-declare const index$5_OAuth2Scheme: typeof OAuth2Scheme;
-type index$5_OAuthFlow = OAuthFlow;
-type index$5_OAuthFlows = OAuthFlows;
-type index$5_OpenAiLlm = OpenAiLlm;
-declare const index$5_OpenAiLlm: typeof OpenAiLlm;
-type index$5_OpenIdConnectScheme = OpenIdConnectScheme;
-declare const index$5_OpenIdConnectScheme: typeof OpenIdConnectScheme;
-type index$5_SearchMemoryResponse = SearchMemoryResponse;
-type index$5_Session = Session;
-type index$5_State = State;
-declare const index$5_State: typeof State;
-type index$5_ThinkingConfig = ThinkingConfig;
-declare const index$5_registerProviders: typeof registerProviders;
-declare namespace index$5 {
-  export { index$5_AiSdkLlm as AiSdkLlm, index$5_AnthropicLlm as AnthropicLlm, index$5_ApiKeyCredential as ApiKeyCredential, index$5_ApiKeyScheme as ApiKeyScheme, index$5_AuthConfig as AuthConfig, index$5_AuthCredential as AuthCredential, index$5_AuthCredentialType as AuthCredentialType, index$5_AuthHandler as AuthHandler, index$5_AuthScheme as AuthScheme, index$5_AuthSchemeType as AuthSchemeType, index$5_BaseLLMConnection as BaseLLMConnection, index$5_BaseLlm as BaseLlm, type index$5_BaseMemoryService as BaseMemoryService, index$5_BasicAuthCredential as BasicAuthCredential, index$5_BearerTokenCredential as BearerTokenCredential, index$5_Blob as Blob, Content$1 as Content, type index$5_FunctionDeclaration as FunctionDeclaration, index$5_GoogleLlm as GoogleLlm, index$5_HttpScheme as HttpScheme, type index$5_JSONSchema as JSONSchema, index$5_LLMRegistry as LLMRegistry, index$5_LlmRequest as LlmRequest, index$5_LlmResponse as LlmResponse, index$5_OAuth2Credential as OAuth2Credential, index$5_OAuth2Scheme as OAuth2Scheme, type index$5_OAuthFlow as OAuthFlow, type index$5_OAuthFlows as OAuthFlows, index$5_OpenAiLlm as OpenAiLlm, index$5_OpenIdConnectScheme as OpenIdConnectScheme, type index$5_SearchMemoryResponse as SearchMemoryResponse, type index$5_Session as Session, index$5_State as State, type index$5_ThinkingConfig as ThinkingConfig, index$5_registerProviders as registerProviders };
+    refreshToken(): Promise<void>;
 }
 
 /**
- * Options for creating an Event.
+ * Base class for LLM request processors.
  */
-interface EventOpts {
-    invocationId?: string;
-    author: string;
-    actions?: EventActions;
-    longRunningToolIds?: Set<string>;
-    branch?: string;
-    id?: string;
-    timestamp?: number;
-    content?: any;
-    partial?: boolean;
+declare abstract class BaseLlmRequestProcessor {
+    /**
+     * Runs the processor on the given invocation context and LLM request.
+     * @param invocationContext The invocation context
+     * @param llmRequest The LLM request to process
+     * @returns An async generator yielding events
+     */
+    abstract runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, unknown>;
 }
 /**
- * Represents an event in a conversation between agents and users.
- * It is used to store the content of the conversation, as well as the actions
- * taken by the agents like function calls, etc.
+ * Base class for LLM response processors.
  */
-declare class Event extends LlmResponse {
-    /** The invocation ID of the event. */
-    invocationId: string;
-    /** 'user' or the name of the agent, indicating who appended the event to the session. */
-    author: string;
-    /** The actions taken by the agent. */
-    actions: EventActions;
-    /**
-     * Set of ids of the long running function calls.
-     * Agent client will know from this field about which function call is long running.
-     * Only valid for function call event.
-     */
-    longRunningToolIds?: Set<string>;
-    /**
-     * The branch of the event.
-     * 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 unique identifier of the event. */
-    id: string;
-    /** The timestamp of the event (seconds since epoch). */
-    timestamp: number;
-    /**
-     * Constructor for Event.
-     */
-    constructor(opts: EventOpts);
-    /**
-     * Returns whether the event is the final response of the agent.
-     */
-    isFinalResponse(): boolean;
-    /**
-     * Returns the function calls in the event.
-     */
-    getFunctionCalls(): any[];
-    /**
-     * Returns the function responses in the event.
-     */
-    getFunctionResponses(): any[];
-    /**
-     * Returns whether the event has a trailing code execution result.
-     */
-    hasTrailingCodeExecutionResult(): boolean;
+declare abstract class BaseLlmResponseProcessor {
     /**
-     * Generates a new random ID for an event.
+     * Processes the LLM response.
+     * @param invocationContext The invocation context
+     * @param llmResponse The LLM response to process
+     * @returns An async generator yielding events
      */
-    static newId(): string;
+    abstract runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event, void, unknown>;
 }
 
 /**
- * Single agent callback type
- */
-type SingleAgentCallback = (callbackContext: CallbackContext) => Promise<Content$1 | undefined> | Content$1 | undefined;
-/**
- * Before agent callback type
+ * Auth LLM request processor that handles authentication information
+ * to build the LLM request with credential processing
  */
-type BeforeAgentCallback = SingleAgentCallback | SingleAgentCallback[];
+declare class AuthLlmRequestProcessor extends BaseLlmRequestProcessor {
+    /**
+     * Processes authentication information from session events
+     * and resumes function calls that required authentication
+     */
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
+    /**
+     * Parses and stores authentication response in session state
+     */
+    private parseAndStoreAuthResponse;
+}
 /**
- * After agent callback type
+ * Exported request processor instance for use in flow configurations
  */
-type AfterAgentCallback = SingleAgentCallback | SingleAgentCallback[];
+declare const requestProcessor$7: AuthLlmRequestProcessor;
+
 /**
- * Base class for all agents in Agent Development Kit.
+ * Enhanced auth configuration with credential handling
+ * This extends the basic AuthConfig with raw and exchanged credentials
  */
-declare abstract class BaseAgent {
-    /**
-     * The agent's name.
-     * Agent name must be a valid identifier and unique within the agent tree.
-     * Agent name cannot be "user", since it's reserved for end-user's input.
-     */
-    name: string;
+declare class EnhancedAuthConfig {
     /**
-     * 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.
+     * The authentication scheme
      */
-    description: string;
+    authScheme: AuthScheme;
     /**
-     * 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.
+     * Raw auth credential used to collect credentials
+     * Used in auth schemes that need to exchange credentials (e.g. OAuth2, OIDC)
      */
-    parentAgent?: BaseAgent;
+    rawAuthCredential?: AuthCredential;
     /**
-     * The sub-agents of this agent.
+     * Exchanged auth credential after processing
+     * Filled by ADK and client working together
      */
-    subAgents: BaseAgent[];
+    exchangedAuthCredential?: AuthCredential;
     /**
-     * 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.
-     *
-     * Args:
-     *   callbackContext: The callback context.
-     *
-     * Returns:
-     *   Content | undefined: 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.
+     * User-specified key for credential storage and retrieval
      */
-    beforeAgentCallback?: BeforeAgentCallback;
+    credentialKey?: string;
     /**
-     * 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.
-     *
-     * Args:
-     *   callbackContext: The callback context.
-     *
-     * Returns:
-     *   Content | undefined: 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.
+     * Additional context properties
      */
-    afterAgentCallback?: AfterAgentCallback;
+    context?: Record<string, any>;
     /**
-     * Constructor for BaseAgent
+     * Constructor for EnhancedAuthConfig
      */
     constructor(config: {
-        name: string;
-        description?: string;
-        subAgents?: BaseAgent[];
-        beforeAgentCallback?: BeforeAgentCallback;
-        afterAgentCallback?: AfterAgentCallback;
+        authScheme: AuthScheme;
+        rawAuthCredential?: AuthCredential;
+        exchangedAuthCredential?: AuthCredential;
+        credentialKey?: string;
+        context?: Record<string, any>;
     });
     /**
-     * Entry method to run an agent via text-based conversation.
-     */
-    runAsync(parentContext: InvocationContext): AsyncGenerator<Event, void, unknown>;
-    /**
-     * Entry method to run an agent via video/audio-based conversation.
-     */
-    runLive(parentContext: InvocationContext): AsyncGenerator<Event, void, unknown>;
-    /**
-     * Internal implementation for runAsync
-     */
-    private runAsyncInternal;
-    /**
-     * Internal implementation for runLive
-     */
-    private runLiveInternal;
-    /**
-     * Core logic to run this agent via text-based conversation.
-     *
-     * @param ctx - The invocation context for this agent.
-     * @yields Event - The events generated by the agent.
+     * Generates a credential key based on auth scheme and raw credential
+     * Used for saving/loading credentials from credential service
      */
-    protected runAsyncImpl(_ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
+    private generateCredentialKey;
     /**
-     * Core logic to run this agent via video/audio-based conversation.
-     *
-     * @param ctx - The invocation context for this agent.
-     * @yields Event - The events generated by the agent.
+     * Gets the credential key for storage
      */
-    protected runLiveImpl(_ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
+    getCredentialKey(): string;
+}
+/**
+ * Arguments for the special long-running function tool used to request
+ * end-user credentials
+ */
+interface AuthToolArguments extends Record<string, unknown> {
     /**
-     * Gets the root agent of this agent.
+     * The ID of the function call that requires authentication
      */
-    get rootAgent(): BaseAgent;
+    function_call_id: string;
     /**
-     * Finds the agent with the given name in this agent and its descendants.
-     *
-     * @param name - The name of the agent to find.
-     * @returns The agent with the matching name, or undefined if no such agent is found.
+     * The authentication configuration
      */
-    findAgent(name: string): BaseAgent | undefined;
+    auth_config: AuthConfig | EnhancedAuthConfig;
+}
+/**
+ * Auth tool for handling credential requests
+ */
+declare class AuthTool {
     /**
-     * Finds the agent with the given name in this agent's descendants.
-     *
-     * @param name - The name of the agent to find.
-     * @returns The agent with the matching name, or undefined if no such agent is found.
+     * Processes auth tool arguments and returns appropriate response
      */
-    findSubAgent(name: string): BaseAgent | undefined;
+    static processAuthRequest(args: AuthToolArguments): Promise<{
+        status: string;
+        authConfig?: AuthConfig | EnhancedAuthConfig;
+        credentialKey?: string;
+    }>;
     /**
-     * Creates a new invocation context for this agent.
+     * Validates auth tool arguments
      */
-    private createInvocationContext;
+    static validateAuthArguments(args: any): args is AuthToolArguments;
+}
+/**
+ * Creates an AuthToolArguments object with proper typing
+ */
+declare function createAuthToolArguments(functionCallId: string, authConfig: AuthConfig | EnhancedAuthConfig): AuthToolArguments;
+/**
+ * Type guard to check if an auth config is enhanced
+ */
+declare function isEnhancedAuthConfig(config: AuthConfig | EnhancedAuthConfig): config is EnhancedAuthConfig;
+
+/**
+ * Types of authentication credentials
+ */
+declare enum AuthCredentialType {
+    API_KEY = "api_key",
+    BASIC = "basic",
+    BEARER = "bearer",
+    OAUTH2 = "oauth2",
+    CUSTOM = "custom"
+}
+/**
+ * Base class for authentication credentials
+ */
+declare abstract class AuthCredential {
     /**
-     * The resolved beforeAgentCallback field as a list of SingleAgentCallback.
-     * This method is only for use by Agent Development Kit.
+     * Type of credential
      */
-    get canonicalBeforeAgentCallbacks(): SingleAgentCallback[];
+    type: AuthCredentialType;
     /**
-     * The resolved afterAgentCallback field as a list of SingleAgentCallback.
-     * This method is only for use by Agent Development Kit.
+     * Constructor for AuthCredential
      */
-    get canonicalAfterAgentCallbacks(): SingleAgentCallback[];
+    constructor(type: AuthCredentialType);
     /**
-     * Runs the beforeAgentCallback if it exists.
-     *
-     * @returns An event if callback provides content or changed state.
+     * Gets the authentication token
      */
-    private handleBeforeAgentCallback;
+    abstract getToken(): string | undefined;
     /**
-     * Runs the afterAgentCallback if it exists.
-     *
-     * @returns An event if callback provides content or changed state.
+     * Gets headers for HTTP requests
      */
-    private handleAfterAgentCallback;
+    abstract getHeaders(config: AuthConfig): Record<string, string>;
     /**
-     * Validates the agent name.
+     * Whether the token can be refreshed
      */
-    private validateName;
+    canRefresh(): boolean;
     /**
-     * Sets parent agent for sub-agents.
+     * Refreshes the token
      */
-    private setParentAgentForSubAgents;
-}
-
-interface File {
-    /** The name of the file with file extension (e.g., "file.csv") */
-    name: string;
-    /** The base64-encoded bytes of the file content */
-    content: string;
-    /** The mime type of the file (e.g., "image/png") */
-    mimeType: string;
-}
-interface CodeExecutionInput {
-    /** The code to execute */
-    code: string;
-    /** The input files available to the code */
-    inputFiles: File[];
-    /** The execution ID for the stateful code execution */
-    executionId?: string;
-}
-interface CodeExecutionResult {
-    /** The standard output of the code execution */
-    stdout: string;
-    /** The standard error of the code execution */
-    stderr: string;
-    /** The output files from the code execution */
-    outputFiles: File[];
+    refresh(): Promise<void>;
 }
-declare class CodeExecutionUtils {
-    /**
-     * Gets the file content as a base64-encoded string
-     */
-    static getEncodedFileContent(data: string | ArrayBuffer): string;
-    private static isBase64Encoded;
+/**
+ * API Key credential
+ */
+declare class ApiKeyCredential extends AuthCredential {
     /**
-     * Extracts the first code block from the content and truncates everything after it
+     * The API key
      */
-    static extractCodeAndTruncateContent(content: Content$1, codeBlockDelimiters: Array<[string, string]>): string | null;
-    private static escapeRegex;
+    apiKey: string;
     /**
-     * Builds an executable code part with code string
+     * Constructor for ApiKeyCredential
      */
-    static buildExecutableCodePart(code: string): Part;
+    constructor(apiKey: string);
     /**
-     * Builds the code execution result part from the code execution result
+     * Gets the API key as the token
      */
-    static buildCodeExecutionResultPart(codeExecutionResult: CodeExecutionResult): Part;
+    getToken(): string;
     /**
-     * Converts the code execution parts to text parts in a Content
+     * Gets headers for HTTP requests
      */
-    static convertCodeExecutionParts(content: Content$1, codeBlockDelimiter: [string, string], executionResultDelimiters: [string, string]): void;
+    getHeaders(config: AuthConfig): Record<string, string>;
 }
-
-interface BaseCodeExecutorConfig {
-    /**
-     * If true, extract and process data files from the model request
-     * and attach them to the code executor.
-     * Supported data file MimeTypes are [text/csv].
-     * Default to false.
-     */
-    optimizeDataFile?: boolean;
+/**
+ * Basic authentication credential
+ */
+declare class BasicAuthCredential extends AuthCredential {
     /**
-     * Whether the code executor is stateful. Default to false.
+     * The username
      */
-    stateful?: boolean;
+    username: string;
     /**
-     * The number of attempts to retry on consecutive code execution errors.
-     * Default to 2.
+     * The password
      */
-    errorRetryAttempts?: number;
+    password: string;
     /**
-     * The list of the enclosing delimiters to identify the code blocks.
-     * For example, the delimiter ['```python\n', '\n```'] can be
-     * used to identify code blocks with the following format:
-     *
-     * ```python
-     * print("hello")
-     * ```
+     * Constructor for BasicAuthCredential
      */
-    codeBlockDelimiters?: Array<[string, string]>;
+    constructor(username: string, password: string);
     /**
-     * The delimiters to format the code execution result.
+     * Gets the encoded basic auth token
      */
-    executionResultDelimiters?: [string, string];
-}
-declare abstract class BaseCodeExecutor {
-    protected readonly config: Required<BaseCodeExecutorConfig>;
-    constructor(config?: BaseCodeExecutorConfig);
+    getToken(): string;
     /**
-     * Executes code and returns the code execution result.
+     * Gets headers for HTTP requests
      */
-    abstract executeCode(invocationContext: InvocationContext, codeExecutionInput: CodeExecutionInput): Promise<CodeExecutionResult>;
-    get optimizeDataFile(): boolean;
-    get stateful(): boolean;
-    get errorRetryAttempts(): number;
-    get codeBlockDelimiters(): Array<[string, string]>;
-    get executionResultDelimiters(): [string, string];
+    getHeaders(): Record<string, string>;
 }
-
 /**
- * Abstract base class for all planners.
- *
- * The planner allows the agent to generate plans for the queries to guide its action.
+ * Bearer token credential
  */
-declare abstract class BasePlanner {
+declare class BearerTokenCredential extends AuthCredential {
     /**
-     * Builds the system instruction to be appended to the LLM request for planning.
-     *
-     * @param readonlyContext The readonly context of the invocation
-     * @param llmRequest The LLM request. Readonly.
-     * @returns The planning system instruction, or undefined if no instruction is needed
+     * The bearer token
      */
-    abstract buildPlanningInstruction(readonlyContext: ReadonlyContext, llmRequest: LlmRequest): string | undefined;
+    token: string;
     /**
-     * Processes the LLM response for planning.
-     *
-     * @param callbackContext The callback context of the invocation
-     * @param responseParts The LLM response parts. Readonly.
-     * @returns The processed response parts, or undefined if no processing is needed
+     * Constructor for BearerTokenCredential
      */
-    abstract processPlanningResponse(callbackContext: CallbackContext, responseParts: Part[]): Part[] | undefined;
-}
-
-/**
- * Type for instruction providers that can be functions
- */
-type InstructionProvider = (ctx: ReadonlyContext) => string | Promise<string>;
-/**
- * Union type for tools (supporting functions, tools, and toolsets)
- */
-type ToolUnion = BaseTool | ((...args: any[]) => any);
-/**
- * Configuration for LlmAgent
- */
-interface LlmAgentConfig<T extends BaseLlm = BaseLlm> {
+    constructor(token: string);
     /**
-     * Name of the agent
+     * Gets the bearer token
      */
-    name: string;
+    getToken(): string;
     /**
-     * Description of the agent
+     * Gets headers for HTTP requests
      */
-    description: string;
+    getHeaders(): Record<string, string>;
+}
+/**
+ * OAuth2 token credential with refresh capability
+ */
+declare class OAuth2Credential extends AuthCredential {
     /**
-     * The LLM model to use
-     * When not set, the agent will inherit the model from its ancestor
+     * The access token
      */
-    model?: string | T | LanguageModel;
+    accessToken: string;
     /**
-     * Instructions for the LLM model, guiding the agent's behavior
+     * The refresh token
      */
-    instruction?: string | InstructionProvider;
+    refreshToken?: string;
     /**
-     * Instructions for all the agents in the entire agent tree
-     * ONLY the global_instruction in root agent will take effect
+     * When the token expires
      */
-    globalInstruction?: string | InstructionProvider;
+    expiresAt?: Date;
     /**
-     * Tools available to this agent
+     * Function to refresh the token
      */
-    tools?: ToolUnion[];
+    private refreshFunction?;
     /**
-     * Code executor for this agent
+     * Constructor for OAuth2Credential
      */
-    codeExecutor?: BaseCodeExecutor;
+    constructor(config: {
+        accessToken: string;
+        refreshToken?: string;
+        expiresIn?: number;
+        refreshFunction?: (refreshToken: string) => Promise<{
+            accessToken: string;
+            refreshToken?: string;
+            expiresIn?: number;
+        }>;
+    });
     /**
-     * Disallows LLM-controlled transferring to the parent agent
+     * Gets the access token
      */
-    disallowTransferToParent?: boolean;
+    getToken(): string;
     /**
-     * Disallows LLM-controlled transferring to the peer agents
+     * Gets headers for HTTP requests
      */
-    disallowTransferToPeers?: boolean;
+    getHeaders(): Record<string, string>;
     /**
-     * Whether to include contents in the model request
+     * Whether the token can be refreshed
      */
-    includeContents?: "default" | "none";
+    canRefresh(): boolean;
     /**
-     * The output key in session state to store the output of the agent
+     * Whether the token is expired
      */
-    outputKey?: string;
+    isExpired(): boolean;
     /**
-     * Instructs the agent to make a plan and execute it step by step
+     * Refreshes the token
      */
-    planner?: BasePlanner;
+    refresh(): Promise<void>;
+}
+
+/**
+ * Models module exports - consolidated to match Python structure
+ */
+
+type index$5_AiSdkLlm = AiSdkLlm;
+declare const index$5_AiSdkLlm: typeof AiSdkLlm;
+type index$5_AnthropicLlm = AnthropicLlm;
+declare const index$5_AnthropicLlm: typeof AnthropicLlm;
+type index$5_ApiKeyCredential = ApiKeyCredential;
+declare const index$5_ApiKeyCredential: typeof ApiKeyCredential;
+type index$5_ApiKeyScheme = ApiKeyScheme;
+declare const index$5_ApiKeyScheme: typeof ApiKeyScheme;
+type index$5_AuthConfig = AuthConfig;
+declare const index$5_AuthConfig: typeof AuthConfig;
+type index$5_AuthCredential = AuthCredential;
+declare const index$5_AuthCredential: typeof AuthCredential;
+type index$5_AuthCredentialType = AuthCredentialType;
+declare const index$5_AuthCredentialType: typeof AuthCredentialType;
+type index$5_AuthHandler = AuthHandler;
+declare const index$5_AuthHandler: typeof AuthHandler;
+type index$5_AuthScheme = AuthScheme;
+declare const index$5_AuthScheme: typeof AuthScheme;
+type index$5_AuthSchemeType = AuthSchemeType;
+declare const index$5_AuthSchemeType: typeof AuthSchemeType;
+type index$5_BaseLLMConnection = BaseLLMConnection;
+declare const index$5_BaseLLMConnection: typeof BaseLLMConnection;
+type index$5_BaseLlm = BaseLlm;
+declare const index$5_BaseLlm: typeof BaseLlm;
+type index$5_BaseMemoryService = BaseMemoryService;
+type index$5_BasicAuthCredential = BasicAuthCredential;
+declare const index$5_BasicAuthCredential: typeof BasicAuthCredential;
+type index$5_BearerTokenCredential = BearerTokenCredential;
+declare const index$5_BearerTokenCredential: typeof BearerTokenCredential;
+declare const index$5_Blob: typeof Blob;
+declare const index$5_Content: typeof Content;
+declare const index$5_FunctionDeclaration: typeof FunctionDeclaration;
+type index$5_GoogleLlm = GoogleLlm;
+declare const index$5_GoogleLlm: typeof GoogleLlm;
+type index$5_HttpScheme = HttpScheme;
+declare const index$5_HttpScheme: typeof HttpScheme;
+type index$5_LLMRegistry = LLMRegistry;
+declare const index$5_LLMRegistry: typeof LLMRegistry;
+type index$5_LlmRequest = LlmRequest;
+declare const index$5_LlmRequest: typeof LlmRequest;
+type index$5_LlmResponse = LlmResponse;
+declare const index$5_LlmResponse: typeof LlmResponse;
+type index$5_OAuth2Credential = OAuth2Credential;
+declare const index$5_OAuth2Credential: typeof OAuth2Credential;
+type index$5_OAuth2Scheme = OAuth2Scheme;
+declare const index$5_OAuth2Scheme: typeof OAuth2Scheme;
+type index$5_OAuthFlow = OAuthFlow;
+type index$5_OAuthFlows = OAuthFlows;
+type index$5_OpenAiLlm = OpenAiLlm;
+declare const index$5_OpenAiLlm: typeof OpenAiLlm;
+type index$5_OpenIdConnectScheme = OpenIdConnectScheme;
+declare const index$5_OpenIdConnectScheme: typeof OpenIdConnectScheme;
+type index$5_SearchMemoryResponse = SearchMemoryResponse;
+type index$5_Session = Session;
+type index$5_State = State;
+declare const index$5_State: typeof State;
+type index$5_ThinkingConfig = ThinkingConfig;
+declare const index$5_registerProviders: typeof registerProviders;
+declare namespace index$5 {
+  export { index$5_AiSdkLlm as AiSdkLlm, index$5_AnthropicLlm as AnthropicLlm, index$5_ApiKeyCredential as ApiKeyCredential, index$5_ApiKeyScheme as ApiKeyScheme, index$5_AuthConfig as AuthConfig, index$5_AuthCredential as AuthCredential, index$5_AuthCredentialType as AuthCredentialType, index$5_AuthHandler as AuthHandler, index$5_AuthScheme as AuthScheme, index$5_AuthSchemeType as AuthSchemeType, index$5_BaseLLMConnection as BaseLLMConnection, index$5_BaseLlm as BaseLlm, type index$5_BaseMemoryService as BaseMemoryService, index$5_BasicAuthCredential as BasicAuthCredential, index$5_BearerTokenCredential as BearerTokenCredential, index$5_Blob as Blob, index$5_Content as Content, index$5_FunctionDeclaration as FunctionDeclaration, index$5_GoogleLlm as GoogleLlm, index$5_HttpScheme as HttpScheme, Schema as JSONSchema, index$5_LLMRegistry as LLMRegistry, index$5_LlmRequest as LlmRequest, index$5_LlmResponse as LlmResponse, index$5_OAuth2Credential as OAuth2Credential, index$5_OAuth2Scheme as OAuth2Scheme, type index$5_OAuthFlow as OAuthFlow, type index$5_OAuthFlows as OAuthFlows, index$5_OpenAiLlm as OpenAiLlm, index$5_OpenIdConnectScheme as OpenIdConnectScheme, type index$5_SearchMemoryResponse as SearchMemoryResponse, type index$5_Session as Session, index$5_State as State, type index$5_ThinkingConfig as ThinkingConfig, index$5_registerProviders as registerProviders };
+}
+
+/**
+ * Options for creating an Event.
+ */
+interface EventOpts {
+    invocationId?: string;
+    author: string;
+    actions?: EventActions;
+    longRunningToolIds?: Set<string>;
+    branch?: string;
+    id?: string;
+    timestamp?: number;
+    content?: any;
+    partial?: boolean;
+}
+/**
+ * Represents an event in a conversation between agents and users.
+ * It is used to store the content of the conversation, as well as the actions
+ * taken by the agents like function calls, etc.
+ */
+declare class Event extends LlmResponse {
+    /** The invocation ID of the event. */
+    invocationId: string;
+    /** 'user' or the name of the agent, indicating who appended the event to the session. */
+    author: string;
+    /** The actions taken by the agent. */
+    actions: EventActions;
     /**
-     * Memory service for long-term storage and retrieval
+     * Set of ids of the long running function calls.
+     * Agent client will know from this field about which function call is long running.
+     * Only valid for function call event.
      */
-    memoryService?: BaseMemoryService;
+    longRunningToolIds?: Set<string>;
     /**
-     * Session service for managing conversations
+     * The branch of the event.
+     * 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.
      */
-    sessionService?: BaseSessionService;
+    branch?: string;
+    /** The unique identifier of the event. */
+    id: string;
+    /** The timestamp of the event (seconds since epoch). */
+    timestamp: number;
     /**
-     * Artifact service for file storage and management
+     * Constructor for Event.
      */
-    artifactService?: BaseArtifactService;
+    constructor(opts: EventOpts);
     /**
-     * User ID for the session
+     * Returns whether the event is the final response of the agent.
      */
-    userId?: string;
+    isFinalResponse(): boolean;
     /**
-     * Application name
+     * Returns the function calls in the event.
      */
-    appName?: string;
+    getFunctionCalls(): any[];
     /**
-     * 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.
+     * Returns the function responses in the event.
      */
-    generateContentConfig?: GenerateContentConfig;
+    getFunctionResponses(): any[];
     /**
-     * The input schema when agent is used as a tool
+     * Returns whether the event has a trailing code execution result.
      */
-    inputSchema?: any;
+    hasTrailingCodeExecutionResult(): boolean;
     /**
-     * The output schema when agent replies
-     * NOTE: when this is set, agent can ONLY reply and CANNOT use any tools
+     * Generates a new random ID for an event.
      */
-    outputSchema?: any;
+    static newId(): string;
 }
+
 /**
- * LLM-based Agent
+ * Single agent callback type
  */
-declare class LlmAgent<T extends BaseLlm = BaseLlm> extends BaseAgent {
-    /**
-     * The model to use for the agent
-     * When not set, the agent will inherit the model from its ancestor
-     */
-    model: string | T | LanguageModel;
-    /**
-     * 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 global_instruction in root agent will take effect
-     */
-    globalInstruction: string | InstructionProvider;
+type SingleAgentCallback = (callbackContext: CallbackContext) => Promise<Content | undefined> | Content | undefined;
+/**
+ * Before agent callback type
+ */
+type BeforeAgentCallback = SingleAgentCallback | SingleAgentCallback[];
+/**
+ * After agent callback type
+ */
+type AfterAgentCallback = SingleAgentCallback | SingleAgentCallback[];
+/**
+ * Base class for all agents in Agent Development Kit.
+ */
+declare abstract class BaseAgent {
     /**
-     * Tools available to this agent
+     * The agent's name.
+     * Agent name must be a valid identifier and unique within the agent tree.
+     * Agent name cannot be "user", since it's reserved for end-user's input.
      */
-    tools: ToolUnion[];
+    name: string;
     /**
-     * Code executor for this agent
+     * 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.
      */
-    codeExecutor?: BaseCodeExecutor;
+    description: string;
     /**
-     * Disallows LLM-controlled transferring to the parent agent
+     * 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.
      */
-    disallowTransferToParent: boolean;
+    parentAgent?: BaseAgent;
     /**
-     * Disallows LLM-controlled transferring to the peer agents
+     * The sub-agents of this agent.
      */
-    disallowTransferToPeers: boolean;
+    subAgents: BaseAgent[];
     /**
-     * Whether to include contents in the model request
+     * 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.
+     *
+     * Args:
+     *   callbackContext: The callback context.
+     *
+     * Returns:
+     *   Content | undefined: 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.
      */
-    includeContents: "default" | "none";
+    beforeAgentCallback?: BeforeAgentCallback;
     /**
-     * The output key in session state to store the output of the agent
+     * 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.
+     *
+     * Args:
+     *   callbackContext: The callback context.
+     *
+     * Returns:
+     *   Content | undefined: 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.
      */
-    outputKey?: string;
+    afterAgentCallback?: AfterAgentCallback;
     /**
-     * Instructs the agent to make a plan and execute it step by step
+     * Constructor for BaseAgent
      */
-    planner?: BasePlanner;
+    constructor(config: {
+        name: string;
+        description?: string;
+        subAgents?: BaseAgent[];
+        beforeAgentCallback?: BeforeAgentCallback;
+        afterAgentCallback?: AfterAgentCallback;
+    });
     /**
-     * Memory service for long-term storage and retrieval
+     * Entry method to run an agent via text-based conversation.
      */
-    private memoryService?;
+    runAsync(parentContext: InvocationContext): AsyncGenerator<Event, void, unknown>;
     /**
-     * Session service for managing conversations
+     * Entry method to run an agent via video/audio-based conversation.
      */
-    private sessionService?;
+    runLive(parentContext: InvocationContext): AsyncGenerator<Event, void, unknown>;
     /**
-     * Artifact service for file storage and management
+     * Internal implementation for runAsync
      */
-    private artifactService?;
+    private runAsyncInternal;
     /**
-     * User ID for the session
+     * Internal implementation for runLive
      */
-    private userId?;
+    private runLiveInternal;
     /**
-     * Application name
+     * Core logic to run this agent via text-based conversation.
+     *
+     * @param ctx - The invocation context for this agent.
+     * @yields Event - The events generated by the agent.
      */
-    private appName?;
+    protected runAsyncImpl(_ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
     /**
-     * Additional content generation configurations
+     * Core logic to run this agent via video/audio-based conversation.
+     *
+     * @param ctx - The invocation context for this agent.
+     * @yields Event - The events generated by the agent.
      */
-    generateContentConfig?: GenerateContentConfig;
+    protected runLiveImpl(_ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
     /**
-     * The input schema when agent is used as a tool
+     * Gets the root agent of this agent.
      */
-    inputSchema?: any;
+    get rootAgent(): BaseAgent;
     /**
-     * The output schema when agent replies
+     * Finds the agent with the given name in this agent and its descendants.
+     *
+     * @param name - The name of the agent to find.
+     * @returns The agent with the matching name, or undefined if no such agent is found.
      */
-    outputSchema?: any;
-    protected logger: Logger;
+    findAgent(name: string): BaseAgent | undefined;
     /**
-     * Constructor for LlmAgent
+     * Finds the agent with the given name in this agent's descendants.
+     *
+     * @param name - The name of the agent to find.
+     * @returns The agent with the matching name, or undefined if no such agent is found.
      */
-    constructor(config: LlmAgentConfig<T>);
+    findSubAgent(name: string): BaseAgent | undefined;
     /**
-     * The resolved model field as BaseLLM
-     * This method is only for use by Agent Development Kit
+     * Creates a new invocation context for this agent.
      */
-    get canonicalModel(): BaseLlm;
+    private createInvocationContext;
     /**
-     * The resolved instruction field to construct instruction for this agent
-     * This method is only for use by Agent Development Kit
+     * The resolved beforeAgentCallback field as a list of SingleAgentCallback.
+     * This method is only for use by Agent Development Kit.
      */
-    canonicalInstruction(ctx: ReadonlyContext): Promise<[string, boolean]>;
+    get canonicalBeforeAgentCallbacks(): SingleAgentCallback[];
     /**
-     * The resolved global_instruction field to construct global instruction
-     * This method is only for use by Agent Development Kit
+     * The resolved afterAgentCallback field as a list of SingleAgentCallback.
+     * This method is only for use by Agent Development Kit.
      */
-    canonicalGlobalInstruction(ctx: ReadonlyContext): Promise<[string, boolean]>;
+    get canonicalAfterAgentCallbacks(): SingleAgentCallback[];
     /**
-     * The resolved tools field as a list of BaseTool based on the context
-     * This method is only for use by Agent Development Kit
+     * Runs the beforeAgentCallback if it exists.
+     *
+     * @returns An event if callback provides content or changed state.
      */
-    canonicalTools(ctx?: ReadonlyContext): Promise<BaseTool[]>;
+    private handleBeforeAgentCallback;
     /**
-     * Gets the appropriate LLM flow for this agent
-     * This matches the Python implementation's _llm_flow property
+     * Runs the afterAgentCallback if it exists.
+     *
+     * @returns An event if callback provides content or changed state.
      */
-    private get llmFlow();
+    private handleAfterAgentCallback;
     /**
-     * Saves the model output to state if needed
-     * This matches the Python implementation's __maybe_save_output_to_state
+     * Validates the agent name.
      */
-    private maybeSaveOutputToState;
+    private validateName;
     /**
-     * Core logic to run this agent via text-based conversation
-     * This matches the Python implementation's _run_async_impl
+     * Sets parent agent for sub-agents.
      */
-    protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, unknown>;
+    private setParentAgentForSubAgents;
 }
 
 /**
@@ -3895,10 +3935,14 @@ interface AgentBuilderConfig {
     instruction?: string;
     tools?: BaseTool[];
     planner?: BasePlanner;
+    codeExecutor?: BaseCodeExecutor;
     subAgents?: BaseAgent[];
+    beforeAgentCallback?: BeforeAgentCallback;
+    afterAgentCallback?: AfterAgentCallback;
     maxIterations?: number;
     nodes?: LangGraphNode[];
     rootNode?: string;
+    outputKey?: string;
 }
 /**
  * Session configuration options
@@ -3906,6 +3950,8 @@ interface AgentBuilderConfig {
 interface SessionOptions {
     userId?: string;
     appName?: string;
+    state?: Record<string, any>;
+    sessionId?: string;
 }
 /**
  * Message part interface for flexible message input
@@ -3916,7 +3962,7 @@ interface MessagePart extends Part {
 /**
  * Full message interface for advanced usage
  */
-interface FullMessage extends Content$1 {
+interface FullMessage extends Content {
     parts?: MessagePart[];
 }
 /**
@@ -3962,13 +4008,21 @@ type AgentType = "llm" | "sequential" | "parallel" | "loop" | "langgraph";
  *   .withInstruction("You are a research assistant")
  *   .build();
  *
+ * // With code executor for running code
+ * const { runner } = await AgentBuilder
+ *   .create("code-agent")
+ *   .withModel("gemini-2.5-flash")
+ *   .withCodeExecutor(new ContainerCodeExecutor())
+ *   .withInstruction("You can execute code to solve problems")
+ *   .build();
+ *
  * // With memory and artifact services
  * const { runner } = await AgentBuilder
  *   .create("persistent-agent")
  *   .withModel("gemini-2.5-flash")
  *   .withMemory(new RedisMemoryService())
  *   .withArtifactService(new S3ArtifactService())
- *   .withSession(new DatabaseSessionService(), { userId: "user123", appName: "myapp" })
+ *   .withSessionService(new DatabaseSessionService(), { userId: "user123", appName: "myapp" })
  *   .build();
  *
  * // Multi-agent workflow
@@ -3980,10 +4034,12 @@ type AgentType = "llm" | "sequential" | "parallel" | "loop" | "langgraph";
  */
 declare class AgentBuilder {
     private config;
-    private sessionConfig?;
+    private sessionService?;
+    private sessionOptions?;
     private memoryService?;
     private artifactService?;
     private agentType;
+    private existingSession?;
     /**
      * Private constructor - use static create() method
      */
@@ -4030,6 +4086,36 @@ declare class AgentBuilder {
      * @returns This builder instance for chaining
      */
     withPlanner(planner: BasePlanner): this;
+    /**
+     * Set the code executor for the agent
+     * @param codeExecutor The code executor to use for running code
+     * @returns This builder instance for chaining
+     */
+    withCodeExecutor(codeExecutor: BaseCodeExecutor): this;
+    /**
+     * Set the output key for the agent
+     * @param outputKey The output key in session state to store the output of the agent
+     * @returns This builder instance for chaining
+     */
+    withOutputKey(outputKey: string): this;
+    /**
+     * Add sub-agents to the agent
+     * @param subAgents Sub-agents to add to the agent
+     * @returns This builder instance for chaining
+     */
+    withSubAgents(subAgents: BaseAgent[]): this;
+    /**
+     * Set the before agent callback
+     * @param callback Callback to invoke before agent execution
+     * @returns This builder instance for chaining
+     */
+    withBeforeAgentCallback(callback: BeforeAgentCallback): this;
+    /**
+     * Set the after agent callback
+     * @param callback Callback to invoke after agent execution
+     * @returns This builder instance for chaining
+     */
+    withAfterAgentCallback(callback: AfterAgentCallback): this;
     /**
      * Configure as a sequential agent
      * @param subAgents Sub-agents to execute in sequence
@@ -4062,7 +4148,14 @@ declare class AgentBuilder {
      * @param options Session configuration options (userId and appName)
      * @returns This builder instance for chaining
      */
-    withSession(service: BaseSessionService, options?: SessionOptions): this;
+    withSessionService(service: BaseSessionService, options?: SessionOptions): this;
+    /**
+     * Configure with an existing session instance
+     * @param session Existing session to use
+     * @returns This builder instance for chaining
+     * @throws Error if no session service has been configured via withSessionService()
+     */
+    withSession(session: Session): this;
     /**
      * Configure memory service for the agent
      * @param memoryService Memory service to use for conversation history and context
@@ -4782,7 +4875,7 @@ declare function populateClientFunctionCallId(modelResponseEvent: Event): void;
 /**
  * Removes client function call IDs from content
  */
-declare function removeClientFunctionCallId(content: Content$1): void;
+declare function removeClientFunctionCallId(content: Content): void;
 /**
  * Gets long running function call IDs from a list of function calls
  */
@@ -4990,7 +5083,7 @@ declare class Runner<T extends BaseAgent = BaseAgent> {
     run({ userId, sessionId, newMessage, runConfig, }: {
         userId: string;
         sessionId: string;
-        newMessage: Content$1;
+        newMessage: Content;
         runConfig?: RunConfig;
     }): Generator<Event, void, unknown>;
     /**
@@ -4999,7 +5092,7 @@ declare class Runner<T extends BaseAgent = BaseAgent> {
     runAsync({ userId, sessionId, newMessage, runConfig, }: {
         userId: string;
         sessionId: string;
-        newMessage: Content$1;
+        newMessage: Content;
         runConfig?: RunConfig;
     }): AsyncGenerator<Event, void, unknown>;
     /**
@@ -5107,4 +5200,4 @@ declare const traceLlmCall: (invocationContext: InvocationContext, eventId: stri
 
 declare const VERSION = "0.1.0";
 
-export { AF_FUNCTION_CALL_ID_PREFIX, type AfterAgentCallback, LlmAgent as Agent, AgentBuilder, type AgentBuilderConfig, type AgentType, index$4 as Agents, AiSdkLlm, AnthropicLlm, ApiKeyCredential, ApiKeyScheme, AuthConfig, AuthCredential, AuthCredentialType, AuthHandler, AuthScheme, AuthSchemeType, AuthTool, type AuthToolArguments, AutoFlow, BaseAgent, BaseCodeExecutor, type BaseCodeExecutorConfig, BaseLLMConnection, BaseLlm, BaseLlmFlow, BaseLlmRequestProcessor, BaseLlmResponseProcessor, type BaseMemoryService, BasePlanner, BaseSessionService, BaseTool, BasicAuthCredential, BearerTokenCredential, type BeforeAgentCallback, type BuildFunctionDeclarationOptions, type BuiltAgent, BuiltInCodeExecutor, BuiltInPlanner, CallbackContext, type CodeExecutionInput, type CodeExecutionResult, CodeExecutionUtils, CodeExecutorContext, type CreateToolConfig, type CreateToolConfigWithSchema, type CreateToolConfigWithoutSchema, DatabaseSessionService, EnhancedAuthConfig, type EnhancedRunner, Event, EventActions, index$1 as Events, ExitLoopTool, type File, FileOperationsTool, index as Flows, type FullMessage, type FunctionDeclaration, FunctionTool, GcsArtifactService, type GetSessionConfig, GetUserChoiceTool, GoogleLlm, GoogleSearch, HttpRequestTool, HttpScheme, InMemoryArtifactService, InMemoryMemoryService, InMemoryRunner, InMemorySessionService, type InstructionProvider, InvocationContext, type JSONSchema, LLMRegistry, LangGraphAgent, type LangGraphAgentConfig, type LangGraphNode, type ListSessionsResponse, LlmAgent, type LlmAgentConfig, LlmCallsLimitExceededError, LlmRequest, LlmResponse, LoadArtifactsTool, LoadMemoryTool, LoopAgent, type LoopAgentConfig, McpAbi, McpAtp, McpBamm, McpCoinGecko, type McpConfig, McpDiscord, McpError, McpErrorType, McpFilesystem, McpFraxlend, McpGeneric, McpIqWiki, McpMemory, McpNearAgent, McpNearIntents, McpOdos, McpSamplingHandler, type McpSamplingRequest, type McpSamplingResponse, type McpServerConfig, McpTelegram, McpToolset, type McpTransportType, index$3 as Memory, type MessagePart, index$5 as Models, OAuth2Credential, OAuth2Scheme, type OAuthFlow, type OAuthFlows, OpenAiLlm, OpenIdConnectScheme, ParallelAgent, type ParallelAgentConfig, PlanReActPlanner, REQUEST_EUC_FUNCTION_CALL_NAME, ReadonlyContext, RunConfig, Runner, type SamplingHandler, type SearchMemoryResponse, SequentialAgent, type SequentialAgentConfig, type Session, type SessionOptions, index$2 as Sessions, type SingleAgentCallback, SingleFlow, State, StreamingMode, type TelemetryConfig, TelemetryService, type ThinkingConfig, type ToolConfig, ToolContext, type ToolUnion, index$6 as Tools, TransferToAgentTool, UserInteractionTool, VERSION, VertexAiSessionService, _findFunctionCallEventIfLastEventIsFunctionResponse, adkToMcpToolType, requestProcessor$2 as agentTransferRequestProcessor, requestProcessor$6 as basicRequestProcessor, buildFunctionDeclaration, requestProcessor as codeExecutionRequestProcessor, responseProcessor as codeExecutionResponseProcessor, requestProcessor$3 as contentRequestProcessor, createAuthToolArguments, createBranchContextForSubAgent, createDatabaseSessionService, createFunctionTool, createMysqlSessionService, createPostgresSessionService, createSamplingHandler, createSqliteSessionService, createTool, generateAuthEvent, generateClientFunctionCallId, getLongRunningFunctionCalls, getMcpTools, handleFunctionCallsAsync, handleFunctionCallsLive, requestProcessor$5 as identityRequestProcessor, initializeTelemetry, injectSessionState, requestProcessor$4 as instructionsRequestProcessor, isEnhancedAuthConfig, jsonSchemaToDeclaration, mcpSchemaToParameters, mergeAgentRun, mergeParallelFunctionResponseEvents, newInvocationContextId, requestProcessor$1 as nlPlanningRequestProcessor, responseProcessor$1 as nlPlanningResponseProcessor, normalizeJsonSchema, populateClientFunctionCallId, registerProviders, removeClientFunctionCallId, requestProcessor$7 as requestProcessor, shutdownTelemetry, telemetryService, traceLlmCall, traceToolCall, tracer };
+export { AF_FUNCTION_CALL_ID_PREFIX, type AfterAgentCallback, LlmAgent as Agent, AgentBuilder, type AgentBuilderConfig, AgentTool, type AgentToolConfig, type AgentType, index$4 as Agents, AiSdkLlm, AnthropicLlm, ApiKeyCredential, ApiKeyScheme, AuthConfig, AuthCredential, AuthCredentialType, AuthHandler, AuthScheme, AuthSchemeType, AuthTool, type AuthToolArguments, AutoFlow, BaseAgent, type BaseAgentType, BaseCodeExecutor, type BaseCodeExecutorConfig, BaseLLMConnection, BaseLlm, BaseLlmFlow, BaseLlmRequestProcessor, BaseLlmResponseProcessor, type BaseMemoryService, BasePlanner, BaseSessionService, BaseTool, BasicAuthCredential, BearerTokenCredential, type BeforeAgentCallback, type BuildFunctionDeclarationOptions, type BuiltAgent, BuiltInCodeExecutor, BuiltInPlanner, CallbackContext, type CodeExecutionInput, type CodeExecutionResult, CodeExecutionUtils, CodeExecutorContext, type CreateToolConfig, type CreateToolConfigWithSchema, type CreateToolConfigWithoutSchema, DatabaseSessionService, EnhancedAuthConfig, type EnhancedRunner, Event, EventActions, index$1 as Events, ExitLoopTool, type File, FileOperationsTool, index as Flows, type FullMessage, FunctionTool, GcsArtifactService, type GetSessionConfig, GetUserChoiceTool, GoogleLlm, GoogleSearch, HttpRequestTool, HttpScheme, InMemoryArtifactService, InMemoryMemoryService, InMemoryRunner, InMemorySessionService, type InstructionProvider, InvocationContext, LLMRegistry, LangGraphAgent, type LangGraphAgentConfig, type LangGraphNode, type ListSessionsResponse, LlmAgent, type LlmAgentConfig, LlmCallsLimitExceededError, LlmRequest, LlmResponse, LoadArtifactsTool, LoadMemoryTool, LoopAgent, type LoopAgentConfig, McpAbi, McpAtp, McpBamm, McpCoinGecko, type McpConfig, McpDiscord, McpError, McpErrorType, McpFilesystem, McpFraxlend, McpGeneric, McpIqWiki, McpMemory, McpNearAgent, McpNearIntents, McpOdos, McpSamplingHandler, type McpSamplingRequest, type McpSamplingResponse, type McpServerConfig, McpTelegram, McpToolset, type McpTransportType, index$3 as Memory, type MessagePart, index$5 as Models, OAuth2Credential, OAuth2Scheme, type OAuthFlow, type OAuthFlows, OpenAiLlm, OpenIdConnectScheme, ParallelAgent, type ParallelAgentConfig, PlanReActPlanner, REQUEST_EUC_FUNCTION_CALL_NAME, ReadonlyContext, RunConfig, Runner, type SamplingHandler, type SearchMemoryResponse, SequentialAgent, type SequentialAgentConfig, type Session, type SessionOptions, index$2 as Sessions, type SingleAgentCallback, SingleFlow, State, StreamingMode, type TelemetryConfig, TelemetryService, type ThinkingConfig, type ToolConfig, ToolContext, type ToolUnion, index$6 as Tools, TransferToAgentTool, UserInteractionTool, VERSION, VertexAiSessionService, _findFunctionCallEventIfLastEventIsFunctionResponse, adkToMcpToolType, requestProcessor$2 as agentTransferRequestProcessor, requestProcessor$6 as basicRequestProcessor, buildFunctionDeclaration, requestProcessor as codeExecutionRequestProcessor, responseProcessor as codeExecutionResponseProcessor, requestProcessor$3 as contentRequestProcessor, createAuthToolArguments, createBranchContextForSubAgent, createDatabaseSessionService, createFunctionTool, createMysqlSessionService, createPostgresSessionService, createSamplingHandler, createSqliteSessionService, createTool, generateAuthEvent, generateClientFunctionCallId, getLongRunningFunctionCalls, getMcpTools, handleFunctionCallsAsync, handleFunctionCallsLive, requestProcessor$5 as identityRequestProcessor, initializeTelemetry, injectSessionState, requestProcessor$4 as instructionsRequestProcessor, isEnhancedAuthConfig, jsonSchemaToDeclaration, mcpSchemaToParameters, mergeAgentRun, mergeParallelFunctionResponseEvents, newInvocationContextId, requestProcessor$1 as nlPlanningRequestProcessor, responseProcessor$1 as nlPlanningResponseProcessor, normalizeJsonSchema, populateClientFunctionCallId, registerProviders, removeClientFunctionCallId, requestProcessor$7 as requestProcessor, shutdownTelemetry, telemetryService, traceLlmCall, traceToolCall, tracer };