@iqai/adk 0.1.12 → 0.1.14

package/dist/index.d.mts

@@ -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,2617 +963,2687 @@ 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.
+     * The LLM model to use
+     * When not set, the agent will inherit the model from its ancestor
      */
-    processLlmRequest(toolContext: ToolContext, llmRequest: ExtendedLlmRequest): Promise<void>;
+    model?: string | T | LanguageModel;
     /**
-     * Appends artifacts information to the LLM request
+     * Instructions for the LLM model, guiding the agent's behavior
      */
-    private appendArtifactsToLlmRequest;
+    instruction?: string | InstructionProvider;
     /**
-     * Extracts function response from a part if it exists
+     * Instructions for all the agents in the entire agent tree
+     * ONLY the global_instruction in root agent will take effect
      */
-    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;
+    globalInstruction?: string | InstructionProvider;
     /**
-     * Sampling handler for processing MCP sampling requests.
-     * This allows MCP servers to request LLM completions through your ADK agent.
+     * Tools available to this agent
      */
-    samplingHandler?: SamplingHandler;
-};
-type McpTransportType = {
-    mode: "stdio";
-    command: string;
-    args: string[];
-    env?: Record<string, string>;
-} | {
-    mode: "sse";
-    serverUrl: string;
-    headers?: HeadersInit;
-};
-/**
- * Error types specific to the MCP client
- */
-declare enum McpErrorType {
-    CONNECTION_ERROR = "connection_error",
-    TOOL_EXECUTION_ERROR = "tool_execution_error",
-    RESOURCE_CLOSED_ERROR = "resource_closed_error",
-    TIMEOUT_ERROR = "timeout_error",
-    INVALID_SCHEMA_ERROR = "invalid_schema_error",
-    SAMPLING_ERROR = "SAMPLING_ERROR",
-    INVALID_REQUEST_ERROR = "INVALID_REQUEST_ERROR"
-}
-/**
- * Custom error class for MCP-related errors
- */
-declare class McpError extends Error {
-    type: McpErrorType;
-    originalError?: Error;
-    constructor(message: string, type: McpErrorType, originalError?: Error);
-}
-type McpSamplingRequest = z$1.infer<typeof CreateMessageRequestSchema>;
-type McpSamplingResponse = z$1.infer<typeof CreateMessageResultSchema>;
-type SamplingHandler = (request: LlmRequest) => Promise<string | LlmResponse>;
-
-declare class McpClientService {
-    private config;
-    private client;
-    private transport;
-    private isClosing;
-    private mcpSamplingHandler;
-    protected logger: Logger;
-    constructor(config: McpConfig);
+    tools?: ToolUnion[];
     /**
-     * Initializes and returns an MCP client based on configuration.
-     * Will create a new client if one doesn't exist yet.
+     * Code executor for this agent
      */
-    initialize(): Promise<Client>;
+    codeExecutor?: BaseCodeExecutor;
     /**
-     * Creates a transport based on the configuration.
+     * Disallows LLM-controlled transferring to the parent agent
      */
-    private createTransport;
+    disallowTransferToParent?: boolean;
     /**
-     * Re-initializes the MCP client when a session is closed.
-     * Used by the retry mechanism.
+     * Disallows LLM-controlled transferring to the peer agents
      */
-    reinitialize(): Promise<void>;
+    disallowTransferToPeers?: boolean;
     /**
-     * Cleans up resources associated with this client service.
-     * Similar to Python's AsyncExitStack.aclose() functionality.
+     * Whether to include contents in the model request
      */
-    private cleanupResources;
+    includeContents?: "default" | "none";
     /**
-     * Call an MCP tool with retry capability if the session is closed.
+     * The output key in session state to store the output of the agent
      */
-    callTool(name: string, args: Record<string, any>): Promise<any>;
+    outputKey?: string;
     /**
-     * Closes and cleans up all resources.
-     * Should be called when the service is no longer needed.
-     * Similar to Python's close() method.
+     * Instructs the agent to make a plan and execute it step by step
      */
-    close(): Promise<void>;
+    planner?: BasePlanner;
     /**
-     * Checks if the client is currently connected
+     * Memory service for long-term storage and retrieval
      */
-    isConnected(): boolean;
-    private setupSamplingHandler;
+    memoryService?: BaseMemoryService;
     /**
-     * Set a new ADK sampling handler
+     * Session service for managing conversations
      */
-    setSamplingHandler(handler: SamplingHandler): void;
+    sessionService?: BaseSessionService;
     /**
-     * Remove the sampling handler
+     * Artifact service for file storage and management
      */
-    removeSamplingHandler(): void;
+    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;
 }
-
-/**
- * Converts an ADK-style BaseTool to an MCP tool format
- * Similar to Python's adk_to_mcp_tool_type function
- */
-declare function adkToMcpToolType(tool: BaseTool): Tool;
-/**
- * Converts MCP JSONSchema to ADK's FunctionDeclaration format
- * Similar to handling in McpToolAdapter's getDeclaration
- */
-declare function jsonSchemaToDeclaration(name: string, description: string, schema: Record<string, any> | undefined): FunctionDeclaration;
-/**
- * Normalizes a JSON Schema to ensure it's properly formatted
- * Handles edge cases and ensures consistency
- */
-declare function normalizeJsonSchema(schema: Record<string, any>): JSONSchema;
-/**
- * Converts MCP tool inputSchema to parameters format expected by BaseTool
- */
-declare function mcpSchemaToParameters(mcpTool: Tool): JSONSchema;
-
 /**
- * MCP Sampling Handler class that handles message format conversion
- * between MCP format and ADK format
+ * LLM-based Agent
  */
-declare class McpSamplingHandler {
+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;
-    private samplingHandler;
-    constructor(samplingHandler: SamplingHandler);
     /**
-     * Handle MCP sampling request and convert between formats
+     * Constructor for LlmAgent
      */
-    handleSamplingRequest(request: McpSamplingRequest): Promise<McpSamplingResponse>;
+    constructor(config: LlmAgentConfig<T>);
     /**
-     * Convert MCP messages to ADK Content format
+     * The resolved model field as BaseLLM
+     * This method is only for use by Agent Development Kit
      */
-    private convertMcpMessagesToADK;
+    get canonicalModel(): BaseLlm;
     /**
-     * Convert a single MCP message to ADK Content format
+     * The resolved instruction field to construct instruction for this agent
+     * This method is only for use by Agent Development Kit
      */
-    private convertSingleMcpMessageToADK;
+    canonicalInstruction(ctx: ReadonlyContext): Promise<[string, boolean]>;
     /**
-     * Convert MCP message content to ADK parts format
+     * The resolved global_instruction field to construct global instruction
+     * This method is only for use by Agent Development Kit
      */
-    private convertMcpContentToADKParts;
+    canonicalGlobalInstruction(ctx: ReadonlyContext): Promise<[string, boolean]>;
     /**
-     * Convert ADK response to MCP response format
+     * The resolved tools field as a list of BaseTool based on the context
+     * This method is only for use by Agent Development Kit
      */
-    private convertADKResponseToMcp;
+    canonicalTools(ctx?: ReadonlyContext): Promise<BaseTool[]>;
     /**
-     * Update the ADK handler
+     * Gets the appropriate LLM flow for this agent
+     * This matches the Python implementation's _llm_flow property
      */
-    updateHandler(handler: SamplingHandler): void;
+    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>;
 }
+
 /**
- * Helper function to create a sampling handler with proper TypeScript types.
- *
- * @param handler - Function that handles sampling requests
- * @returns Properly typed ADK sampling handler
- *
- * @example
- * ```typescript
- * import { createSamplingHandler, Gemini } from "@iqai/adk";
- *
- * const llm = new Gemini("gemini-2.0-flash-exp");
- *
- * // Example 1: Return full LlmResponse
- * const samplingHandler1 = createSamplingHandler(async (request) => {
- *   const responses = [];
- *   for await (const response of llm.generateContentAsync(request)) {
- *     responses.push(response);
- *   }
- *   return responses[responses.length - 1];
- * });
- *
- * // Example 2: Return simple string
- * const samplingHandler2 = createSamplingHandler(async (request) => {
- *   const lastMessage = request.contents[request.contents.length - 1].parts[0].text;
- *   return await runner.ask(lastMessage);
- * });
- *
- * // Example 3: Direct function reference
- * const samplingHandler3 = createSamplingHandler(runner.ask);
- * ```
- */
-declare function createSamplingHandler(handler: SamplingHandler): SamplingHandler;
-
-/**
- * Simplified MCP Server Wrappers
- *
- * This module provides simplified wrapper functions for IQAI MCP servers and popular third-party MCP servers.
- * Instead of manually configuring McpToolset with verbose configuration objects, you can use these
- * convenience functions with flexible configuration objects.
- *
- * @example
- * ```typescript
- * // Old verbose way:
- * const toolset = new McpToolset({
- *   name: "Near Intents Swaps MCP Client",
- *   description: "Client for Near Intents Swaps",
- *   debug: env.DEBUG,
- *   retryOptions: { maxRetries: 2, initialDelay: 200 },
- *   transport: {
- *     mode: "stdio",
- *     command: "npx",
- *     args: ["-y", "@iqai/mcp-near"],
- *     env: {
- *       ACCOUNT_ID: env.ACCOUNT_ID,
- *       ACCOUNT_KEY: env.ACCOUNT_KEY,
- *       NEAR_NETWORK_ID: "testnet",
- *       PATH: env.PATH
- *     },
- *   },
- * });
- *
- * // New simplified way:
- * const toolset = McpNearAgent({
- *   env: {
- *     ACCOUNT_ID: env.ACCOUNT_ID,
- *     ACCOUNT_KEY: env.ACCOUNT_KEY,
- *     NEAR_NETWORK_ID: "testnet",
- *     PATH: env.PATH
- *   }
- * });
- *
- * // Usage with LLM Agent:
- * const nearTools = await toolset.getTools();
- * const agent = new LlmAgent({
- *   name: "near_assistant",
- *   model: "gemini-2.5-flash",
- *   tools: nearTools,
- * });
- * ```
- *
- * @example
- * ```typescript
- * // Multiple MCP servers:
- * const atpTools = await McpAtp({
- *   env: {
- *     ATP_WALLET_PRIVATE_KEY: env.WALLET_PRIVATE_KEY,
- *     ATP_API_KEY: env.ATP_API_KEY
- *   }
- * }).getTools();
- *
- * const fraxlendTools = await McpFraxlend({
- *   env: {
- *     WALLET_PRIVATE_KEY: env.WALLET_PRIVATE_KEY
- *   }
- * }).getTools();
- *
- * const agent = new LlmAgent({
- *   name: "defi_assistant",
- *   model: "gemini-2.5-flash",
- *   tools: [...atpTools, ...fraxlendTools],
- * });
- * ```
- *
- * @example
- * ```typescript
- * // Using MCP servers with sampling handlers:
- * import { createSamplingHandler, LlmResponse } from "@iqai/adk";
- *
- * const samplingHandler = createSamplingHandler(async (request) => {
- *   // Handle MCP sampling requests
- *   return new LlmResponse({
- *     content: {
- *       role: "model",
- *       parts: [{ text: "Response from sampling handler" }],
- *     },
- *   });
- * });
- *
- * const nearTools = await McpNearAgent({
- *   env: {
- *     ACCOUNT_ID: env.ACCOUNT_ID,
- *     ACCOUNT_KEY: env.ACCOUNT_KEY,
- *     NEAR_NETWORK_ID: "testnet",
- *     PATH: env.PATH
- *   },
- *   samplingHandler
- * }).getTools();
- *
- * const agent = new LlmAgent({
- *   name: "near_assistant",
- *   model: "gemini-2.5-flash",
- *   tools: nearTools,
- * });
- * ```
+ * Type for agents that can be used as tools
  */
+type BaseAgentType = LlmAgent;
 /**
- * Base configuration interface for MCP servers
+ * Configuration for AgentTool
  */
-interface McpServerConfig {
-    /** Environment variables to pass to the MCP server */
-    env?: Record<string, any>;
-    /** Enable debug logging */
-    debug?: boolean;
-    /** Custom description for the MCP server */
+interface AgentToolConfig {
+    /**
+     * Name of the tool
+     */
+    name: string;
+    /**
+     * Description of the tool
+     */
     description?: string;
-    /** Retry configuration */
-    retryOptions?: {
-        maxRetries?: number;
-        initialDelay?: number;
-    };
-    /** Sampling handler for processing MCP sampling requests */
-    samplingHandler?: SamplingHandler;
+    /**
+     * 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;
 }
 /**
- * MCP ABI - Smart contract ABI interactions for Ethereum-compatible blockchains
- *
- * Required env vars: CONTRACT_ABI, CONTRACT_ADDRESS
- * Optional env vars: CONTRACT_NAME, CHAIN_ID, RPC_URL, WALLET_PRIVATE_KEY
- */
-declare function McpAbi(config?: McpServerConfig): McpToolset;
-/**
- * MCP ATP - Interact with the IQ AI Agent Tokenization Platform
+ * A tool that uses an agent to perform a task.
  *
- * Required env vars: ATP_WALLET_PRIVATE_KEY, ATP_API_KEY
+ * 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 function McpAtp(config?: McpServerConfig): McpToolset;
-/**
- * MCP BAMM - Borrow Automated Market Maker operations on Fraxtal
- *
- * Required env vars: WALLET_PRIVATE_KEY
- */
-declare function McpBamm(config?: McpServerConfig): McpToolset;
-/**
- * MCP FRAXLEND - Interact with the Fraxlend lending platform
- *
- * Required env vars: WALLET_PRIVATE_KEY
- */
-declare function McpFraxlend(config?: McpServerConfig): McpToolset;
-/**
- * MCP IQWiki - Access and manage IQ.wiki data and user activities
- *
- * No required env vars
- */
-declare function McpIqWiki(config?: McpServerConfig): McpToolset;
-/**
- * MCP NEAR Agent - NEAR Protocol blockchain integration with AI-driven event processing
- *
- * Required env vars: ACCOUNT_ID, ACCOUNT_KEY
- * Optional env vars: NEAR_NETWORK_ID, NEAR_NODE_URL, NEAR_GAS_LIMIT
- */
-declare function McpNearAgent(config?: McpServerConfig): McpToolset;
-/**
- * MCP Near Intents Swaps - NEAR Protocol intent swaps functionality
- *
- * Required env vars: ACCOUNT_ID, ACCOUNT_KEY
- * Optional env vars: NEAR_NETWORK_ID, NEAR_NODE_URL, NEAR_GAS_LIMIT
- */
-declare function McpNearIntentSwaps(config?: McpServerConfig): McpToolset;
-/**
- * MCP ODOS - Interact with decentralized exchanges through ODOS aggregation
- *
- * Required env vars: WALLET_PRIVATE_KEY
- */
-declare function McpOdos(config?: McpServerConfig): McpToolset;
-/**
- * MCP Telegram - Interact with Telegram bots and channels
- *
- * Required env vars: TELEGRAM_BOT_TOKEN
- */
-declare function McpTelegram(config?: McpServerConfig): McpToolset;
+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>;
+}
+
 /**
- * MCP Discord - Interact with Discord via MCP protocol
+ * A tool that wraps a user-defined TypeScript function.
  *
- * Required env vars: DISCORD_TOKEN
- * Optional env vars: PATH
+ * This tool automatically generates a function declaration from the function's
+ * signature and documentation, making it easy to expose functions to agents.
  */
-declare function McpDiscord(config?: McpServerConfig): McpToolset;
+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;
+}
+
 /**
- * MCP CoinGecko - Access cryptocurrency market data and analytics
- *
- * Optional env vars: COINGECKO_PRO_API_KEY, COINGECKO_DEMO_API_KEY, COINGECKO_ENVIRONMENT
+ * Options for building a function declaration
  */
-declare function McpCoinGecko(config?: McpServerConfig): McpToolset;
+interface BuildFunctionDeclarationOptions {
+    name?: string;
+    description?: string;
+    ignoreParams?: string[];
+}
 /**
- * Popular third-party MCP servers
- * These can be added as we expand support for community MCP servers
+ * 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;
+
 /**
- * MCP Filesystem - File system operations (third-party)
+ * Creates a new FunctionTool that wraps a function.
+ * This is a convenience function for creating a new FunctionTool.
  *
- * Optional env vars: ALLOWED_DIRECTORIES (comma-separated list)
+ * @param func The function to wrap
+ * @param options Optional configuration for the tool
+ * @returns A new FunctionTool wrapping the function
  */
-declare function McpFilesystem(config?: McpServerConfig): McpToolset;
+declare function createFunctionTool(func: (...args: any[]) => any, options?: {
+    name?: string;
+    description?: string;
+    isLongRunning?: boolean;
+    shouldRetryOnFailure?: boolean;
+    maxRetryAttempts?: number;
+}): any;
+
 /**
- * MCP Memory - Memory and note-taking capabilities (third-party)
- *
- * No required env vars
+ * Simple GoogleSearch tool implementation
  */
-declare function McpMemory(config?: McpServerConfig): McpToolset;
+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;
+}
 /**
- * Generic MCP server function for any package
- *
- * @param packageName The npm package name of the MCP server
- * @param config Configuration object with environment variables and optional sampling handler
- * @param name Optional custom name for the client
+ * Tool for making HTTP requests to external APIs and web services
  */
-declare function McpGeneric(packageName: string, config?: McpServerConfig, name?: string): McpToolset;
+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;
+}
 /**
- * A class for managing MCP tools similar to Python's MCPToolset.
- * Provides functionality to retrieve and use tools from an MCP server.
+ * Tool for performing file system operations
  */
-declare class McpToolset {
-    private config;
-    private clientService;
-    private toolFilter;
-    private tools;
-    private isClosing;
-    constructor(config: McpConfig, toolFilter?: string[] | ((tool: any, context?: ToolContext) => boolean) | null);
+declare class FileOperationsTool extends BaseTool {
+    private basePath;
+    constructor(options?: {
+        basePath?: string;
+    });
     /**
-     * Checks if a tool should be included based on the tool filter.
-     * Similar to Python's _is_selected method.
+     * Get the function declaration for the tool
      */
-    private isSelected;
+    getDeclaration(): FunctionDeclaration;
     /**
-     * Initializes the client service and establishes a connection.
+     * Execute the file operation
      */
-    initialize(): Promise<McpClientService>;
+    runAsync(args: {
+        operation: "read" | "write" | "append" | "delete" | "exists" | "list" | "mkdir";
+        filepath: string;
+        content?: string;
+        encoding?: BufferEncoding;
+    }, _context: ToolContext): Promise<FileOperationResult>;
     /**
-     * Set a sampling handler for this MCP toolset.
-     * This allows MCP servers to request LLM completions through your ADK agent.
-     *
-     * @param handler - ADK sampling handler that receives ADK-formatted messages
+     * Resolve a file path relative to the base path
      */
-    setSamplingHandler(handler: SamplingHandler): void;
+    private resolvePath;
     /**
-     * Remove the sampling handler
+     * Validate that a path is within the base path for security
      */
-    removeSamplingHandler(): void;
+    private validatePath;
     /**
-     * Retrieves tools from the MCP server and converts them to BaseTool instances.
-     * Similar to Python's get_tools method.
+     * Read a file
      */
-    getTools(context?: ToolContext): Promise<BaseTool[]>;
+    private readFile;
     /**
-     * Converts ADK tools to MCP tool format for bidirectional support
+     * Write to a file
      */
-    convertADKToolsToMCP(tools: BaseTool[]): any[];
+    private writeFile;
     /**
-     * Refreshes the tool cache by clearing it and fetching tools again
+     * Append to a file
      */
-    refreshTools(context?: ToolContext): Promise<BaseTool[]>;
+    private appendFile;
     /**
-     * Closes the connection to the MCP server.
-     * Similar to Python's close method.
+     * Delete a file
      */
-    close(): Promise<void>;
+    private deleteFile;
     /**
-     * Disposes of all resources. This method should be called when the toolset is no longer needed.
-     * Provides alignment with disposal patterns common in TypeScript.
+     * Check if a file exists
      */
-    dispose(): Promise<void>;
+    private fileExists;
+    /**
+     * List directory contents
+     */
+    private listDirectory;
+    /**
+     * Create a directory
+     */
+    private makeDirectory;
 }
-/**
- * Retrieves and converts tools from an MCP server.
- *
- * This function:
- * 1. Connects to the MCP server (local or sse).
- * 2. Retrieves all available tools.
- * 3. Converts them into BaseTool instances.
- * 4. Returns them as a BaseTool array.
- */
-declare function getMcpTools(config: McpConfig, toolFilter?: string[] | ((tool: any, context?: ToolContext) => boolean)): Promise<BaseTool[]>;
 
+interface UserInteractionResult {
+    success: boolean;
+    userInput?: string;
+    error?: string;
+}
 /**
- * Tools module exports
+ * Tool for prompting the user for input
  */
-
-type index$6_BaseTool = BaseTool;
-declare const index$6_BaseTool: typeof BaseTool;
-type index$6_BuildFunctionDeclarationOptions = BuildFunctionDeclarationOptions;
-type index$6_CreateToolConfig<T extends Record<string, any> = Record<string, never>> = CreateToolConfig<T>;
-type index$6_CreateToolConfigWithSchema<T extends Record<string, any>> = CreateToolConfigWithSchema<T>;
-type index$6_CreateToolConfigWithoutSchema = CreateToolConfigWithoutSchema;
-type index$6_ExitLoopTool = ExitLoopTool;
-declare const index$6_ExitLoopTool: typeof ExitLoopTool;
-type index$6_FileOperationsTool = FileOperationsTool;
-declare const index$6_FileOperationsTool: typeof FileOperationsTool;
-type index$6_FunctionTool<T extends Record<string, any>> = FunctionTool<T>;
-declare const index$6_FunctionTool: typeof FunctionTool;
-type index$6_GetUserChoiceTool = GetUserChoiceTool;
-declare const index$6_GetUserChoiceTool: typeof GetUserChoiceTool;
-type index$6_GoogleSearch = GoogleSearch;
-declare const index$6_GoogleSearch: typeof GoogleSearch;
-type index$6_HttpRequestTool = HttpRequestTool;
-declare const index$6_HttpRequestTool: typeof HttpRequestTool;
-type index$6_LoadArtifactsTool = LoadArtifactsTool;
-declare const index$6_LoadArtifactsTool: typeof LoadArtifactsTool;
-type index$6_LoadMemoryTool = LoadMemoryTool;
-declare const index$6_LoadMemoryTool: typeof LoadMemoryTool;
-declare const index$6_McpAbi: typeof McpAbi;
-declare const index$6_McpAtp: typeof McpAtp;
-declare const index$6_McpBamm: typeof McpBamm;
-declare const index$6_McpCoinGecko: typeof McpCoinGecko;
-type index$6_McpConfig = McpConfig;
-declare const index$6_McpDiscord: typeof McpDiscord;
-type index$6_McpError = McpError;
-declare const index$6_McpError: typeof McpError;
-type index$6_McpErrorType = McpErrorType;
-declare const index$6_McpErrorType: typeof McpErrorType;
-declare const index$6_McpFilesystem: typeof McpFilesystem;
-declare const index$6_McpFraxlend: typeof McpFraxlend;
-declare const index$6_McpGeneric: typeof McpGeneric;
-declare const index$6_McpIqWiki: typeof McpIqWiki;
-declare const index$6_McpMemory: typeof McpMemory;
-declare const index$6_McpNearAgent: typeof McpNearAgent;
-declare const index$6_McpNearIntentSwaps: typeof McpNearIntentSwaps;
-declare const index$6_McpOdos: typeof McpOdos;
-type index$6_McpSamplingHandler = McpSamplingHandler;
-declare const index$6_McpSamplingHandler: typeof McpSamplingHandler;
-type index$6_McpSamplingRequest = McpSamplingRequest;
-type index$6_McpSamplingResponse = McpSamplingResponse;
-type index$6_McpServerConfig = McpServerConfig;
-declare const index$6_McpTelegram: typeof McpTelegram;
-type index$6_McpToolset = McpToolset;
-declare const index$6_McpToolset: typeof McpToolset;
-type index$6_McpTransportType = McpTransportType;
-type index$6_SamplingHandler = SamplingHandler;
-type index$6_ToolConfig = ToolConfig;
-type index$6_ToolContext = ToolContext;
-declare const index$6_ToolContext: typeof ToolContext;
-type index$6_TransferToAgentTool = TransferToAgentTool;
-declare const index$6_TransferToAgentTool: typeof TransferToAgentTool;
-type index$6_UserInteractionTool = UserInteractionTool;
-declare const index$6_UserInteractionTool: typeof UserInteractionTool;
-declare const index$6_adkToMcpToolType: typeof adkToMcpToolType;
-declare const index$6_buildFunctionDeclaration: typeof buildFunctionDeclaration;
-declare const index$6_createFunctionTool: typeof createFunctionTool;
-declare const index$6_createSamplingHandler: typeof createSamplingHandler;
-declare const index$6_createTool: typeof createTool;
-declare const index$6_getMcpTools: typeof getMcpTools;
-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_McpNearIntentSwaps as McpNearIntentSwaps, 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 };
+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>;
 }
 
 /**
- * LLM request class that allows passing in tools, output schema and system
- * instructions to the model.
- *
- * Attributes:
- *   model: The model name.
- *   contents: The contents to send to the model.
- *   config: Additional config for the generate content request.
- *   toolsDict: The tools dictionary.
+ * Tool that allows an agent to exit the current execution loop
  */
-declare class LlmRequest {
+declare class ExitLoopTool extends BaseTool {
+    protected logger: Logger;
     /**
-     * The model name.
+     * Constructor for ExitLoopTool
      */
-    model?: string;
+    constructor();
     /**
-     * The contents to send to the model.
+     * Execute the exit loop action
      */
-    contents: Content$1[];
+    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;
     /**
-     * Additional config for the generate content request.
-     * Tools in generate_content_config should not be set.
+     * Constructor for GetUserChoiceTool
      */
-    config?: GenerateContentConfig;
+    constructor();
     /**
-     * Live connect config for the request.
+     * Get the function declaration for the tool
      */
-    liveConnectConfig: LiveConnectConfig;
+    getDeclaration(): FunctionDeclaration;
     /**
-     * The tools dictionary.
+     * Execute the user choice action
+     * This is a long running operation that will return null initially
+     * and the actual choice will be provided asynchronously
      */
-    toolsDict: Record<string, BaseTool>;
-    constructor(data?: {
-        model?: string;
-        contents?: Content$1[];
-        config?: GenerateContentConfig;
-        liveConnectConfig?: LiveConnectConfig;
-        toolsDict?: Record<string, BaseTool>;
-    });
+    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;
     /**
-     * Appends instructions to the system instruction.
-     * @param instructions The instructions to append.
+     * Constructor for TransferToAgentTool
      */
-    appendInstructions(instructions: string[]): void;
+    constructor();
     /**
-     * Appends tools to the request.
-     * @param tools The tools to append.
+     * Execute the transfer to agent action
      */
-    appendTools(tools: BaseTool[]): void;
+    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;
     /**
-     * Sets the output schema for the request.
-     * @param baseModel The base model to set as the output schema.
+     * Constructor for LoadMemoryTool
      */
-    setOutputSchema(baseModel: any): void;
+    constructor();
     /**
-     * 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.
+     * Get the function declaration for the tool
      */
-    getSystemInstructionText(): string | undefined;
+    getDeclaration(): FunctionDeclaration;
     /**
-     * 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.
+     * Execute the memory loading action
      */
-    static extractTextFromContent(content: any): string;
+    runAsync(args: {
+        query: string;
+    }, context: ToolContext): Promise<any>;
 }
 
 /**
- * Candidate response from the model.
+ * A tool that loads the artifacts and adds them to the session.
  */
-interface Candidate {
-    content?: Content$1;
-    groundingMetadata?: GroundingMetadata;
-    finishReason?: string;
-    finishMessage?: string;
+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;
+};
+type McpTransportType = {
+    mode: "stdio";
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+} | {
+    mode: "sse";
+    serverUrl: string;
+    headers?: HeadersInit;
+};
 /**
- * Prompt feedback in case of blocked or failed prompt.
+ * Error types specific to the MCP client
  */
-interface PromptFeedback {
-    blockReason?: string;
-    blockReasonMessage?: string;
+declare enum McpErrorType {
+    CONNECTION_ERROR = "connection_error",
+    TOOL_EXECUTION_ERROR = "tool_execution_error",
+    RESOURCE_CLOSED_ERROR = "resource_closed_error",
+    TIMEOUT_ERROR = "timeout_error",
+    INVALID_SCHEMA_ERROR = "invalid_schema_error",
+    SAMPLING_ERROR = "SAMPLING_ERROR",
+    INVALID_REQUEST_ERROR = "INVALID_REQUEST_ERROR"
 }
 /**
- * The response from the model generation API.
+ * Custom error class for MCP-related errors
  */
-interface GenerateContentResponse {
-    candidates?: Candidate[];
-    usageMetadata?: GenerateContentResponseUsageMetadata;
-    promptFeedback?: PromptFeedback;
+declare class McpError extends Error {
+    type: McpErrorType;
+    originalError?: Error;
+    constructor(message: string, type: McpErrorType, originalError?: Error);
 }
-/**
- * Response from a language model.
- */
-declare class LlmResponse {
-    /**
-     * Unique identifier for the response.
-     */
-    id?: string;
+type McpSamplingRequest = z$1.infer<typeof CreateMessageRequestSchema>;
+type McpSamplingResponse = z$1.infer<typeof CreateMessageResultSchema>;
+type SamplingHandler = (request: LlmRequest) => Promise<string | LlmResponse>;
+
+declare class McpClientService {
+    private config;
+    private client;
+    private transport;
+    private isClosing;
+    private mcpSamplingHandler;
+    protected logger: Logger;
+    constructor(config: McpConfig);
     /**
-     * The content generated by the model.
+     * Initializes and returns an MCP client based on configuration.
+     * Will create a new client if one doesn't exist yet.
      */
-    content?: Content$1;
+    initialize(): Promise<Client>;
     /**
-     * The grounding metadata of the response.
+     * Creates a transport based on the configuration.
      */
-    groundingMetadata?: GroundingMetadata;
+    private createTransport;
     /**
-     * Indicates whether the text content is part of an unfinished text stream.
+     * Re-initializes the MCP client when a session is closed.
+     * Used by the retry mechanism.
      */
-    partial?: boolean;
+    reinitialize(): Promise<void>;
     /**
-     * Indicates whether the response from the model is complete.
+     * Cleans up resources associated with this client service.
+     * Similar to Python's AsyncExitStack.aclose() functionality.
      */
-    turnComplete?: boolean;
+    private cleanupResources;
     /**
-     * Error code if the response is an error.
+     * Call an MCP tool with retry capability if the session is closed.
      */
-    errorCode?: string;
+    callTool(name: string, args: Record<string, any>): Promise<any>;
     /**
-     * Error message if the response is an error.
+     * Closes and cleans up all resources.
+     * Should be called when the service is no longer needed.
+     * Similar to Python's close() method.
      */
-    errorMessage?: string;
+    close(): Promise<void>;
     /**
-     * Flag indicating that LLM was interrupted when generating the content.
+     * Checks if the client is currently connected
      */
-    interrupted?: boolean;
+    isConnected(): boolean;
+    private setupSamplingHandler;
     /**
-     * The custom metadata of the LlmResponse.
+     * Set a new ADK sampling handler
      */
-    customMetadata?: Record<string, any>;
+    setSamplingHandler(handler: SamplingHandler): void;
     /**
-     * The usage metadata of the LlmResponse.
+     * Remove the sampling handler
      */
-    usageMetadata?: GenerateContentResponseUsageMetadata;
+    removeSamplingHandler(): void;
+}
+
+/**
+ * Converts an ADK-style BaseTool to an MCP tool format
+ * Similar to Python's adk_to_mcp_tool_type function
+ */
+declare function adkToMcpToolType(tool: BaseTool): Tool;
+/**
+ * Converts MCP JSONSchema to ADK's FunctionDeclaration format
+ * Similar to handling in McpToolAdapter's getDeclaration
+ */
+declare function jsonSchemaToDeclaration(name: string, description: string, schema: Record<string, any> | undefined): FunctionDeclaration;
+/**
+ * Normalizes a JSON Schema to ensure it's properly formatted
+ * Handles edge cases and ensures consistency
+ */
+declare function normalizeJsonSchema(schema: Record<string, any>): Schema;
+/**
+ * Converts MCP tool inputSchema to parameters format expected by BaseTool
+ */
+declare function mcpSchemaToParameters(mcpTool: Tool): Schema;
+
+/**
+ * MCP Sampling Handler class that handles message format conversion
+ * between MCP format and ADK format
+ */
+declare class McpSamplingHandler {
+    protected logger: Logger;
+    private samplingHandler;
+    constructor(samplingHandler: SamplingHandler);
     /**
-     * Index of the candidate response.
+     * Handle MCP sampling request and convert between formats
      */
-    candidateIndex?: number;
+    handleSamplingRequest(request: McpSamplingRequest): Promise<McpSamplingResponse>;
     /**
-     * Reason why the model finished generating.
+     * Convert MCP messages to ADK Content format
      */
-    finishReason?: string;
+    private convertMcpMessagesToADK;
     /**
-     * Error object if the response is an error.
+     * Convert a single MCP message to ADK Content format
      */
-    error?: Error;
+    private convertSingleMcpMessageToADK;
     /**
-     * Creates a new LlmResponse.
+     * Convert MCP message content to ADK parts format
      */
-    constructor(data?: Partial<LlmResponse>);
+    private convertMcpContentToADKParts;
     /**
-     * Creates an LlmResponse from a GenerateContentResponse.
-     *
-     * @param generateContentResponse The GenerateContentResponse to create the LlmResponse from.
-     * @returns The LlmResponse.
+     * Convert ADK response to MCP response format
      */
-    static create(generateContentResponse: GenerateContentResponse): LlmResponse;
+    private convertADKResponseToMcp;
     /**
-     * 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.
+     * Update the ADK handler
      */
-    static fromError(error: unknown, options?: {
-        errorCode?: string;
-        model?: string;
-    }): LlmResponse;
+    updateHandler(handler: SamplingHandler): void;
 }
+/**
+ * Helper function to create a sampling handler with proper TypeScript types.
+ *
+ * @param handler - Function that handles sampling requests
+ * @returns Properly typed ADK sampling handler
+ *
+ * @example
+ * ```typescript
+ * import { createSamplingHandler, Gemini } from "@iqai/adk";
+ *
+ * const llm = new Gemini("gemini-2.0-flash-exp");
+ *
+ * // Example 1: Return full LlmResponse
+ * const samplingHandler1 = createSamplingHandler(async (request) => {
+ *   const responses = [];
+ *   for await (const response of llm.generateContentAsync(request)) {
+ *     responses.push(response);
+ *   }
+ *   return responses[responses.length - 1];
+ * });
+ *
+ * // Example 2: Return simple string
+ * const samplingHandler2 = createSamplingHandler(async (request) => {
+ *   const lastMessage = request.contents[request.contents.length - 1].parts[0].text;
+ *   return await runner.ask(lastMessage);
+ * });
+ *
+ * // Example 3: Direct function reference
+ * const samplingHandler3 = createSamplingHandler(runner.ask);
+ * ```
+ */
+declare function createSamplingHandler(handler: SamplingHandler): SamplingHandler;
 
 /**
- * The base class for a live model connection.
+ * Simplified MCP Server Wrappers
+ *
+ * This module provides simplified wrapper functions for IQAI MCP servers and popular third-party MCP servers.
+ * Instead of manually configuring McpToolset with verbose configuration objects, you can use these
+ * convenience functions with flexible configuration objects.
+ *
+ * @example
+ * ```typescript
+ * // Old verbose way:
+ * const toolset = new McpToolset({
+ *   name: "Near Intents Swaps MCP Client",
+ *   description: "Client for Near Intents Swaps",
+ *   debug: env.DEBUG,
+ *   retryOptions: { maxRetries: 2, initialDelay: 200 },
+ *   transport: {
+ *     mode: "stdio",
+ *     command: "npx",
+ *     args: ["-y", "@iqai/mcp-near"],
+ *     env: {
+ *       ACCOUNT_ID: env.ACCOUNT_ID,
+ *       ACCOUNT_KEY: env.ACCOUNT_KEY,
+ *       NEAR_NETWORK_ID: "testnet",
+ *       PATH: env.PATH
+ *     },
+ *   },
+ * });
+ *
+ * // New simplified way:
+ * const toolset = McpNearAgent({
+ *   env: {
+ *     ACCOUNT_ID: env.ACCOUNT_ID,
+ *     ACCOUNT_KEY: env.ACCOUNT_KEY,
+ *     NEAR_NETWORK_ID: "testnet",
+ *     PATH: env.PATH
+ *   }
+ * });
+ *
+ * // Usage with LLM Agent:
+ * const nearTools = await toolset.getTools();
+ * const agent = new LlmAgent({
+ *   name: "near_assistant",
+ *   model: "gemini-2.5-flash",
+ *   tools: nearTools,
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multiple MCP servers:
+ * const atpTools = await McpAtp({
+ *   env: {
+ *     ATP_WALLET_PRIVATE_KEY: env.WALLET_PRIVATE_KEY,
+ *     ATP_API_KEY: env.ATP_API_KEY
+ *   }
+ * }).getTools();
+ *
+ * const fraxlendTools = await McpFraxlend({
+ *   env: {
+ *     WALLET_PRIVATE_KEY: env.WALLET_PRIVATE_KEY
+ *   }
+ * }).getTools();
+ *
+ * const agent = new LlmAgent({
+ *   name: "defi_assistant",
+ *   model: "gemini-2.5-flash",
+ *   tools: [...atpTools, ...fraxlendTools],
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using MCP servers with sampling handlers:
+ * import { createSamplingHandler, LlmResponse } from "@iqai/adk";
+ *
+ * const samplingHandler = createSamplingHandler(async (request) => {
+ *   // Handle MCP sampling requests
+ *   return new LlmResponse({
+ *     content: {
+ *       role: "model",
+ *       parts: [{ text: "Response from sampling handler" }],
+ *     },
+ *   });
+ * });
+ *
+ * const nearTools = await McpNearAgent({
+ *   env: {
+ *     ACCOUNT_ID: env.ACCOUNT_ID,
+ *     ACCOUNT_KEY: env.ACCOUNT_KEY,
+ *     NEAR_NETWORK_ID: "testnet",
+ *     PATH: env.PATH
+ *   },
+ *   samplingHandler
+ * }).getTools();
+ *
+ * const agent = new LlmAgent({
+ *   name: "near_assistant",
+ *   model: "gemini-2.5-flash",
+ *   tools: nearTools,
+ * });
+ * ```
+ */
+/**
+ * Base configuration interface for MCP servers
+ */
+interface McpServerConfig {
+    /** Environment variables to pass to the MCP server */
+    env?: Record<string, any>;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom description for the MCP server */
+    description?: string;
+    /** Retry configuration */
+    retryOptions?: {
+        maxRetries?: number;
+        initialDelay?: number;
+    };
+    /** Sampling handler for processing MCP sampling requests */
+    samplingHandler?: SamplingHandler;
+}
+/**
+ * MCP ABI - Smart contract ABI interactions for Ethereum-compatible blockchains
+ *
+ * Required env vars: CONTRACT_ABI, CONTRACT_ADDRESS
+ * Optional env vars: CONTRACT_NAME, CHAIN_ID, RPC_URL, WALLET_PRIVATE_KEY
+ */
+declare function McpAbi(config?: McpServerConfig): McpToolset;
+/**
+ * MCP ATP - Interact with the IQ AI Agent Tokenization Platform
+ *
+ * Required env vars: ATP_WALLET_PRIVATE_KEY, ATP_API_KEY
+ */
+declare function McpAtp(config?: McpServerConfig): McpToolset;
+/**
+ * MCP BAMM - Borrow Automated Market Maker operations on Fraxtal
+ *
+ * Required env vars: WALLET_PRIVATE_KEY
+ */
+declare function McpBamm(config?: McpServerConfig): McpToolset;
+/**
+ * MCP FRAXLEND - Interact with the Fraxlend lending platform
+ *
+ * Required env vars: WALLET_PRIVATE_KEY
+ */
+declare function McpFraxlend(config?: McpServerConfig): McpToolset;
+/**
+ * MCP IQWiki - Access and manage IQ.wiki data and user activities
+ *
+ * No required env vars
+ */
+declare function McpIqWiki(config?: McpServerConfig): McpToolset;
+/**
+ * MCP NEAR Agent - NEAR Protocol blockchain integration with AI-driven event processing
+ *
+ * Required env vars: ACCOUNT_ID, ACCOUNT_KEY
+ * Optional env vars: NEAR_NETWORK_ID, NEAR_NODE_URL, NEAR_GAS_LIMIT
+ */
+declare function McpNearAgent(config?: McpServerConfig): McpToolset;
+/**
+ * MCP Near Intents Swaps - NEAR Protocol intent swaps functionality
+ *
+ * Required env vars: ACCOUNT_ID, ACCOUNT_KEY
+ * Optional env vars: NEAR_NETWORK_ID, NEAR_NODE_URL, NEAR_GAS_LIMIT
+ */
+declare function McpNearIntents(config?: McpServerConfig): McpToolset;
+/**
+ * MCP ODOS - Interact with decentralized exchanges through ODOS aggregation
+ *
+ * Required env vars: WALLET_PRIVATE_KEY
+ */
+declare function McpOdos(config?: McpServerConfig): McpToolset;
+/**
+ * MCP Telegram - Interact with Telegram bots and channels
+ *
+ * Required env vars: TELEGRAM_BOT_TOKEN
  */
-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>;
-}
-
+declare function McpTelegram(config?: McpServerConfig): McpToolset;
 /**
- * The BaseLlm class.
+ * MCP Discord - Interact with Discord via MCP protocol
+ *
+ * Required env vars: DISCORD_TOKEN
+ * Optional env vars: PATH
  */
-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.
-     */
-    generateContentAsync(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
-    /**
-     * Implementation method to be overridden by subclasses.
-     * This replaces the abstract generateContentAsync method.
-     */
-    protected abstract generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
-    /**
-     * Appends a user content, so that model can continue to output.
-     *
-     * @param llmRequest LlmRequest, the request to send to the LLM.
-     */
-    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;
-}
-
+declare function McpDiscord(config?: McpServerConfig): McpToolset;
 /**
- * Google LLM Variant enum
+ * MCP CoinGecko - Access cryptocurrency market data and analytics
+ *
+ * Optional env vars: COINGECKO_PRO_API_KEY, COINGECKO_DEMO_API_KEY, COINGECKO_ENVIRONMENT
  */
-declare enum GoogleLLMVariant {
-    VERTEX_AI = "VERTEX_AI",
-    GEMINI_API = "GEMINI_API"
-}
+declare function McpCoinGecko(config?: McpServerConfig): McpToolset;
 /**
- * Integration for Gemini models.
+ * Popular third-party MCP servers
+ * These can be added as we expand support for community MCP servers
  */
-declare class GoogleLlm extends BaseLlm {
-    private _apiClient?;
-    private _liveApiClient?;
-    private _apiBackend?;
-    private _trackingHeaders?;
-    /**
-     * Constructor for Gemini
-     */
-    constructor(model?: string);
-    /**
-     * Provides the list of supported models.
-     */
-    static supportedModels(): string[];
-    /**
-     * Main content generation method - handles both streaming and non-streaming
-     */
-    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
-    /**
-     * Connects to the Gemini model and returns an llm connection.
-     */
-    connect(_llmRequest: LlmRequest): BaseLLMConnection;
-    /**
-     * Check if response has inline data
-     */
-    private hasInlineData;
-    /**
-     * Convert LlmRequest contents to GoogleGenAI format
-     */
-    private convertContents;
-    /**
-     * Convert LlmRequest config to GoogleGenAI format
-     */
-    private convertConfig;
-    /**
-     * Preprocesses the request based on the API backend.
-     */
-    private preprocessRequest;
-    /**
-     * Sets display_name to null for the Gemini API (non-Vertex) backend.
-     */
-    private removeDisplayNameIfPresent;
-    /**
-     * Builds function declaration log string.
-     */
-    private buildFunctionDeclarationLog;
-    /**
-     * Provides the api client.
-     */
-    get apiClient(): GoogleGenAI;
-    /**
-     * Gets the API backend type.
-     */
-    get apiBackend(): GoogleLLMVariant;
-    /**
-     * Gets the tracking headers.
-     */
-    get trackingHeaders(): Record<string, string>;
-    /**
-     * Gets the live API version.
-     */
-    get liveApiVersion(): string;
-    /**
-     * Gets the live API client.
-     */
-    get liveApiClient(): GoogleGenAI;
-}
-
 /**
- * Anthropic LLM implementation using Claude models
+ * MCP Filesystem - File system operations (third-party)
+ *
+ * Optional env vars: ALLOWED_DIRECTORIES (comma-separated list)
  */
-declare class AnthropicLlm extends BaseLlm {
-    private _client?;
-    protected logger: Logger;
-    /**
-     * Constructor for Anthropic LLM
-     */
-    constructor(model?: string);
-    /**
-     * Provides the list of supported models
-     */
-    static supportedModels(): string[];
-    /**
-     * Main content generation method - handles both streaming and non-streaming
-     */
-    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
-    /**
-     * Live connection is not supported for Anthropic models
-     */
-    connect(_llmRequest: LlmRequest): BaseLLMConnection;
-    /**
-     * Convert Anthropic Message to ADK LlmResponse
-     */
-    private anthropicMessageToLlmResponse;
-    /**
-     * Convert ADK Content to Anthropic MessageParam
-     */
-    private contentToAnthropicMessage;
-    /**
-     * Convert ADK Part to Anthropic content block
-     */
-    private partToAnthropicBlock;
-    /**
-     * Convert Anthropic content block to ADK Part
-     */
-    private anthropicBlockToPart;
-    /**
-     * Convert ADK function declaration to Anthropic tool param
-     */
-    private functionDeclarationToAnthropicTool;
-    /**
-     * Convert ADK role to Anthropic role format
-     */
-    private toAnthropicRole;
-    /**
-     * Convert Anthropic stop reason to ADK finish reason
-     */
-    private toAdkFinishReason;
-    /**
-     * Update type strings in schema to lowercase for Anthropic compatibility
-     */
-    private updateTypeString;
-    /**
-     * Gets the Anthropic client
-     */
-    private get client();
-}
-
+declare function McpFilesystem(config?: McpServerConfig): McpToolset;
 /**
- * OpenAI LLM implementation using GPT models
- * Enhanced with comprehensive debug logging similar to Google LLM
+ * MCP Memory - Memory and note-taking capabilities (third-party)
+ *
+ * No required env vars
+ */
+declare function McpMemory(config?: McpServerConfig): McpToolset;
+/**
+ * Generic MCP server function for any package
+ *
+ * @param packageName The npm package name of the MCP server
+ * @param config Configuration object with environment variables and optional sampling handler
+ * @param name Optional custom name for the client
+ */
+declare function McpGeneric(packageName: string, config?: McpServerConfig, name?: string): McpToolset;
+
+/**
+ * A class for managing MCP tools similar to Python's MCPToolset.
+ * Provides functionality to retrieve and use tools from an MCP server.
  */
-declare class OpenAiLlm extends BaseLlm {
-    private _client?;
-    /**
-     * Constructor for OpenAI LLM
-     */
-    constructor(model?: string);
-    /**
-     * Provides the list of supported models
-     */
-    static supportedModels(): string[];
-    /**
-     * Main content generation method - handles both streaming and non-streaming
-     */
-    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
-    /**
-     * Live connection is not supported for OpenAI models
-     */
-    connect(_llmRequest: LlmRequest): BaseLLMConnection;
-    /**
-     * Create LlmResponse from streaming chunk - similar to Google's LlmResponse.create
-     */
-    private createChunkResponse;
-    /**
-     * Convert OpenAI message to ADK LlmResponse
-     */
-    private openAiMessageToLlmResponse;
-    /**
-     * Convert ADK Content to OpenAI ChatCompletionMessage
-     */
-    private contentToOpenAiMessage;
+declare class McpToolset {
+    private config;
+    private clientService;
+    private toolFilter;
+    private tools;
+    private isClosing;
+    constructor(config: McpConfig, toolFilter?: string[] | ((tool: any, context?: ToolContext) => boolean) | null);
     /**
-     * Convert ADK Part to OpenAI message content
+     * Checks if a tool should be included based on the tool filter.
+     * Similar to Python's _is_selected method.
      */
-    private partToOpenAiContent;
+    private isSelected;
     /**
-     * Convert ADK function declaration to OpenAI tool
+     * Initializes the client service and establishes a connection.
      */
-    private functionDeclarationToOpenAiTool;
+    initialize(): Promise<McpClientService>;
     /**
-     * Convert ADK role to OpenAI role format
+     * Set a sampling handler for this MCP toolset.
+     * This allows MCP servers to request LLM completions through your ADK agent.
+     *
+     * @param handler - ADK sampling handler that receives ADK-formatted messages
      */
-    private toOpenAiRole;
+    setSamplingHandler(handler: SamplingHandler): void;
     /**
-     * Convert OpenAI finish reason to ADK finish reason
+     * Remove the sampling handler
      */
-    private toAdkFinishReason;
+    removeSamplingHandler(): void;
     /**
-     * Preprocess request similar to Google LLM
+     * Retrieves tools from the MCP server and converts them to BaseTool instances.
+     * Similar to Python's get_tools method.
      */
-    private preprocessRequest;
+    getTools(context?: ToolContext): Promise<BaseTool[]>;
     /**
-     * Preprocess individual parts for OpenAI compatibility
+     * Converts ADK tools to MCP tool format for bidirectional support
      */
-    private preprocessPart;
+    convertADKToolsToMCP(tools: BaseTool[]): any[];
     /**
-     * Detect content type for flow control
-     * This is a simplified implementation - you may need to adjust based on your specific requirements
+     * Refreshes the tool cache by clearing it and fetching tools again
      */
-    private getContentType;
+    refreshTools(context?: ToolContext): Promise<BaseTool[]>;
     /**
-     * Check if response has inline data (similar to Google LLM)
+     * Closes the connection to the MCP server.
+     * Similar to Python's close method.
      */
-    private hasInlineData;
+    close(): Promise<void>;
     /**
-     * Gets the OpenAI client
+     * Disposes of all resources. This method should be called when the toolset is no longer needed.
+     * Provides alignment with disposal patterns common in TypeScript.
      */
-    private get client();
+    dispose(): Promise<void>;
 }
-
 /**
- * AI SDK integration that accepts a pre-configured LanguageModel.
- * Enables ADK to work with any provider supported by Vercel's AI SDK.
+ * Retrieves and converts tools from an MCP server.
+ *
+ * This function:
+ * 1. Connects to the MCP server (local or sse).
+ * 2. Retrieves all available tools.
+ * 3. Converts them into BaseTool instances.
+ * 4. Returns them as a BaseTool array.
  */
-declare class AiSdkLlm extends BaseLlm {
-    private modelInstance;
-    protected logger: Logger;
-    /**
-     * Constructor accepts a pre-configured LanguageModel instance
-     * @param model - Pre-configured LanguageModel from provider(modelName)
-     */
-    constructor(modelInstance: LanguageModel);
-    /**
-     * Returns empty array - following Python ADK pattern
-     */
-    static supportedModels(): string[];
-    protected generateContentAsyncImpl(request: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
-    /**
-     * Convert ADK LlmRequest to AI SDK CoreMessage format
-     */
-    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;
-}
+declare function getMcpTools(config: McpConfig, toolFilter?: string[] | ((tool: any, context?: ToolContext) => boolean)): Promise<BaseTool[]>;
 
 /**
- * Type for LLM constructor with static methods
+ * Tools module exports
  */
-interface LLMClass {
-    new (model: string): BaseLlm;
-    supportedModels(): string[];
+
+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;
+type index$6_CreateToolConfig<T extends Record<string, any> = Record<string, never>> = CreateToolConfig<T>;
+type index$6_CreateToolConfigWithSchema<T extends Record<string, any>> = CreateToolConfigWithSchema<T>;
+type index$6_CreateToolConfigWithoutSchema = CreateToolConfigWithoutSchema;
+type index$6_ExitLoopTool = ExitLoopTool;
+declare const index$6_ExitLoopTool: typeof ExitLoopTool;
+type index$6_FileOperationsTool = FileOperationsTool;
+declare const index$6_FileOperationsTool: typeof FileOperationsTool;
+type index$6_FunctionTool<T extends Record<string, any>> = FunctionTool<T>;
+declare const index$6_FunctionTool: typeof FunctionTool;
+type index$6_GetUserChoiceTool = GetUserChoiceTool;
+declare const index$6_GetUserChoiceTool: typeof GetUserChoiceTool;
+type index$6_GoogleSearch = GoogleSearch;
+declare const index$6_GoogleSearch: typeof GoogleSearch;
+type index$6_HttpRequestTool = HttpRequestTool;
+declare const index$6_HttpRequestTool: typeof HttpRequestTool;
+type index$6_LoadArtifactsTool = LoadArtifactsTool;
+declare const index$6_LoadArtifactsTool: typeof LoadArtifactsTool;
+type index$6_LoadMemoryTool = LoadMemoryTool;
+declare const index$6_LoadMemoryTool: typeof LoadMemoryTool;
+declare const index$6_McpAbi: typeof McpAbi;
+declare const index$6_McpAtp: typeof McpAtp;
+declare const index$6_McpBamm: typeof McpBamm;
+declare const index$6_McpCoinGecko: typeof McpCoinGecko;
+type index$6_McpConfig = McpConfig;
+declare const index$6_McpDiscord: typeof McpDiscord;
+type index$6_McpError = McpError;
+declare const index$6_McpError: typeof McpError;
+type index$6_McpErrorType = McpErrorType;
+declare const index$6_McpErrorType: typeof McpErrorType;
+declare const index$6_McpFilesystem: typeof McpFilesystem;
+declare const index$6_McpFraxlend: typeof McpFraxlend;
+declare const index$6_McpGeneric: typeof McpGeneric;
+declare const index$6_McpIqWiki: typeof McpIqWiki;
+declare const index$6_McpMemory: typeof McpMemory;
+declare const index$6_McpNearAgent: typeof McpNearAgent;
+declare const index$6_McpNearIntents: typeof McpNearIntents;
+declare const index$6_McpOdos: typeof McpOdos;
+type index$6_McpSamplingHandler = McpSamplingHandler;
+declare const index$6_McpSamplingHandler: typeof McpSamplingHandler;
+type index$6_McpSamplingRequest = McpSamplingRequest;
+type index$6_McpSamplingResponse = McpSamplingResponse;
+type index$6_McpServerConfig = McpServerConfig;
+declare const index$6_McpTelegram: typeof McpTelegram;
+type index$6_McpToolset = McpToolset;
+declare const index$6_McpToolset: typeof McpToolset;
+type index$6_McpTransportType = McpTransportType;
+type index$6_SamplingHandler = SamplingHandler;
+type index$6_ToolConfig = ToolConfig;
+type index$6_ToolContext = ToolContext;
+declare const index$6_ToolContext: typeof ToolContext;
+type index$6_TransferToAgentTool = TransferToAgentTool;
+declare const index$6_TransferToAgentTool: typeof TransferToAgentTool;
+type index$6_UserInteractionTool = UserInteractionTool;
+declare const index$6_UserInteractionTool: typeof UserInteractionTool;
+declare const index$6_adkToMcpToolType: typeof adkToMcpToolType;
+declare const index$6_buildFunctionDeclaration: typeof buildFunctionDeclaration;
+declare const index$6_createFunctionTool: typeof createFunctionTool;
+declare const index$6_createSamplingHandler: typeof createSamplingHandler;
+declare const index$6_createTool: typeof createTool;
+declare const index$6_getMcpTools: typeof getMcpTools;
+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_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 };
 }
+
 /**
- * Registry for LLMs
+ * LLM request class that allows passing in tools, output schema and system
+ * instructions to the model.
+ *
+ * Attributes:
+ *   model: The model name.
+ *   contents: The contents to send to the model.
+ *   config: Additional config for the generate content request.
+ *   toolsDict: The tools dictionary.
  */
-declare class LLMRegistry {
+declare class LlmRequest {
     /**
-     * Map of model name regex to LLM class
+     * The model name.
      */
-    private static llmRegistry;
-    private static logger;
+    model?: string;
     /**
-     * Creates a new LLM instance
-     *
-     * @param model The model name
-     * @returns The LLM instance
+     * The contents to send to the model.
      */
-    static newLLM(model: string): BaseLlm;
+    contents: Content[];
     /**
-     * Resolves the LLM class from the model name
-     *
-     * @param model The model name
-     * @returns The LLM class
+     * Additional config for the generate content request.
+     * Tools in generate_content_config should not be set.
      */
-    static resolve(model: string): LLMClass | null;
+    config?: GenerateContentConfig;
     /**
-     * Registers a new LLM class
-     *
-     * @param modelNameRegex The regex to match model names
-     * @param llmClass The LLM class
+     * Live connect config for the request.
      */
-    static register(modelNameRegex: string, llmClass: LLMClass): void;
+    liveConnectConfig: LiveConnectConfig;
     /**
-     * Registers all model patterns from an LLM class
-     *
-     * @param llmClass The LLM class
+     * The tools dictionary.
+     */
+    toolsDict: Record<string, BaseTool>;
+    constructor(data?: {
+        model?: string;
+        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.
      */
-    static registerLLM(llmClass: LLMClass): void;
+    appendTools(tools: BaseTool[]): void;
     /**
-     * Logs all registered models for debugging
+     * Sets the output schema for the request.
+     * @param baseModel The base model to set as the output schema.
      */
-    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 {
+    setOutputSchema(baseModel: any): void;
     /**
-     * Whether to include the thinking process in the response
+     * 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.
      */
-    includeThinking?: boolean;
+    getSystemInstructionText(): string | undefined;
     /**
-     * Additional thinking configuration options
+     * 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.
      */
-    [key: string]: any;
+    static extractTextFromContent(content: any): string;
 }
 
 /**
- * Authentication scheme types
- */
-declare enum AuthSchemeType {
-    APIKEY = "apiKey",
-    HTTP = "http",
-    OAUTH2 = "oauth2",
-    OPENID_CONNECT = "openIdConnect"
-}
-/**
- * Base class for authentication schemes
+ * Google LLM Variant enum
  */
-declare abstract class AuthScheme {
-    /**
-     * The type of authentication scheme
-     */
-    type: AuthSchemeType;
-    constructor(type: AuthSchemeType);
+declare enum GoogleLLMVariant {
+    VERTEX_AI = "VERTEX_AI",
+    GEMINI_API = "GEMINI_API"
 }
 /**
- * API Key authentication scheme
+ * Integration for Gemini models.
  */
-declare class ApiKeyScheme extends AuthScheme {
+declare class GoogleLlm extends BaseLlm {
+    private _apiClient?;
+    private _liveApiClient?;
+    private _apiBackend?;
+    private _trackingHeaders?;
     /**
-     * Where the API key is sent
+     * Constructor for Gemini
      */
-    in: "query" | "header" | "cookie";
+    constructor(model?: string);
     /**
-     * Name of the parameter
+     * Provides the list of supported models.
      */
-    name: string;
+    static supportedModels(): string[];
     /**
-     * Description of the API key
+     * Main content generation method - handles both streaming and non-streaming
      */
-    description?: string;
+    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
     /**
-     * Constructor for ApiKeyScheme
+     * Connects to the Gemini model and returns an llm connection.
      */
-    constructor(config: {
-        in: "query" | "header" | "cookie";
-        name: string;
-        description?: string;
-    });
-}
-/**
- * HTTP authentication scheme
- */
-declare class HttpScheme extends AuthScheme {
+    connect(_llmRequest: LlmRequest): BaseLLMConnection;
     /**
-     * The HTTP authentication scheme
+     * Check if response has inline data
      */
-    scheme: "basic" | "bearer" | "digest" | "other";
+    private hasInlineData;
     /**
-     * Bearer format when scheme is 'bearer'
+     * Convert LlmRequest contents to GoogleGenAI format
      */
-    bearerFormat?: string;
+    private convertContents;
     /**
-     * Description of the scheme
+     * Preprocesses the request based on the API backend.
      */
-    description?: string;
+    private preprocessRequest;
     /**
-     * Constructor for HttpScheme
+     * Sets display_name to null for the Gemini API (non-Vertex) backend.
      */
-    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 {
+    private removeDisplayNameIfPresent;
     /**
-     * OAuth flows
+     * Builds function declaration log string.
      */
-    flows: OAuthFlows;
+    private buildFunctionDeclarationLog;
     /**
-     * Description of the scheme
+     * Provides the api client.
      */
-    description?: string;
+    get apiClient(): GoogleGenAI;
     /**
-     * Constructor for OAuth2Scheme
+     * Gets the API backend type.
      */
-    constructor(config: {
-        flows: OAuthFlows;
-        description?: string;
-    });
-}
-/**
- * OpenID Connect authentication scheme
- */
-declare class OpenIdConnectScheme extends AuthScheme {
+    get apiBackend(): GoogleLLMVariant;
     /**
-     * OpenID Connect URL
+     * Gets the tracking headers.
      */
-    openIdConnectUrl: string;
+    get trackingHeaders(): Record<string, string>;
     /**
-     * Description of the scheme
+     * Gets the live API version.
      */
-    description?: string;
+    get liveApiVersion(): string;
     /**
-     * Constructor for OpenIdConnectScheme
+     * Gets the live API client.
      */
-    constructor(config: {
-        openIdConnectUrl: string;
-        description?: string;
-    });
+    get liveApiClient(): GoogleGenAI;
 }
 
 /**
- * Authentication configuration for tools
+ * Anthropic LLM implementation using Claude models
  */
-declare class AuthConfig {
+declare class AnthropicLlm extends BaseLlm {
+    private _client?;
+    protected logger: Logger;
     /**
-     * The authentication scheme
+     * Constructor for Anthropic LLM
      */
-    authScheme: AuthScheme;
+    constructor(model?: string);
     /**
-     * Additional context properties
+     * Provides the list of supported models
      */
-    context?: Record<string, any>;
+    static supportedModels(): string[];
     /**
-     * Constructor for AuthConfig
+     * Main content generation method - handles both streaming and non-streaming
      */
-    constructor(config: {
-        authScheme: AuthScheme;
-        context?: Record<string, any>;
-    });
-}
-
-/**
- * Handler for authentication in tools
- */
-declare class AuthHandler {
+    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
     /**
-     * The authentication configuration
+     * Live connection is not supported for Anthropic models
      */
-    authConfig: AuthConfig;
+    connect(_llmRequest: LlmRequest): BaseLLMConnection;
     /**
-     * The authentication credential
+     * Convert Anthropic Message to ADK LlmResponse
      */
-    credential?: AuthCredential;
+    private anthropicMessageToLlmResponse;
     /**
-     * Constructor for AuthHandler
+     * Convert ADK Content to Anthropic MessageParam
      */
-    constructor(config: {
-        authConfig: AuthConfig;
-        credential?: AuthCredential;
-    });
+    private contentToAnthropicMessage;
     /**
-     * Gets the authentication token
+     * Convert ADK Part to Anthropic content block
      */
-    getToken(): string | undefined;
+    private partToAnthropicBlock;
     /**
-     * Gets headers for HTTP requests
+     * Convert Anthropic content block to ADK Part
      */
-    getHeaders(): Record<string, string>;
+    private anthropicBlockToPart;
     /**
-     * Refreshes the token if necessary
+     * Convert ADK function declaration to Anthropic tool param
      */
-    refreshToken(): Promise<void>;
-}
-
-/**
- * Base class for LLM request processors.
- */
-declare abstract class BaseLlmRequestProcessor {
+    private functionDeclarationToAnthropicTool;
     /**
-     * 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
+     * Convert ADK role to Anthropic role format
      */
-    abstract runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, unknown>;
-}
-/**
- * Base class for LLM response processors.
- */
-declare abstract class BaseLlmResponseProcessor {
+    private toAnthropicRole;
     /**
-     * Processes the LLM response.
-     * @param invocationContext The invocation context
-     * @param llmResponse The LLM response to process
-     * @returns An async generator yielding events
+     * Convert Anthropic stop reason to ADK finish reason
      */
-    abstract runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event, void, unknown>;
-}
-
-/**
- * Auth LLM request processor that handles authentication information
- * to build the LLM request with credential processing
- */
-declare class AuthLlmRequestProcessor extends BaseLlmRequestProcessor {
+    private toAdkFinishReason;
     /**
-     * Processes authentication information from session events
-     * and resumes function calls that required authentication
+     * Update type strings in schema to lowercase for Anthropic compatibility
      */
-    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
+    private updateTypeString;
     /**
-     * Parses and stores authentication response in session state
+     * Gets the Anthropic client
      */
-    private parseAndStoreAuthResponse;
+    private get client();
 }
-/**
- * Exported request processor instance for use in flow configurations
- */
-declare const requestProcessor$7: AuthLlmRequestProcessor;
 
 /**
- * Enhanced auth configuration with credential handling
- * This extends the basic AuthConfig with raw and exchanged credentials
+ * OpenAI LLM implementation using GPT models
+ * Enhanced with comprehensive debug logging similar to Google LLM
  */
-declare class EnhancedAuthConfig {
+declare class OpenAiLlm extends BaseLlm {
+    private _client?;
     /**
-     * The authentication scheme
+     * Constructor for OpenAI LLM
      */
-    authScheme: AuthScheme;
+    constructor(model?: string);
     /**
-     * Raw auth credential used to collect credentials
-     * Used in auth schemes that need to exchange credentials (e.g. OAuth2, OIDC)
+     * Provides the list of supported models
      */
-    rawAuthCredential?: AuthCredential;
+    static supportedModels(): string[];
     /**
-     * Exchanged auth credential after processing
-     * Filled by ADK and client working together
+     * Main content generation method - handles both streaming and non-streaming
      */
-    exchangedAuthCredential?: AuthCredential;
+    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
     /**
-     * User-specified key for credential storage and retrieval
+     * Live connection is not supported for OpenAI models
      */
-    credentialKey?: string;
+    connect(_llmRequest: LlmRequest): BaseLLMConnection;
     /**
-     * Additional context properties
+     * Create LlmResponse from streaming chunk - similar to Google's LlmResponse.create
      */
-    context?: Record<string, any>;
+    private createChunkResponse;
     /**
-     * Constructor for EnhancedAuthConfig
+     * Convert OpenAI message to ADK LlmResponse
      */
-    constructor(config: {
-        authScheme: AuthScheme;
-        rawAuthCredential?: AuthCredential;
-        exchangedAuthCredential?: AuthCredential;
-        credentialKey?: string;
-        context?: Record<string, any>;
-    });
+    private openAiMessageToLlmResponse;
     /**
-     * Generates a credential key based on auth scheme and raw credential
-     * Used for saving/loading credentials from credential service
+     * Convert ADK Content to OpenAI ChatCompletionMessage
      */
-    private generateCredentialKey;
+    private contentToOpenAiMessage;
     /**
-     * Gets the credential key for storage
+     * Convert ADK Part to OpenAI message content
      */
-    getCredentialKey(): string;
-}
-/**
- * Arguments for the special long-running function tool used to request
- * end-user credentials
- */
-interface AuthToolArguments extends Record<string, unknown> {
+    private partToOpenAiContent;
     /**
-     * The ID of the function call that requires authentication
+     * Convert ADK function declaration to OpenAI tool
      */
-    function_call_id: string;
+    private functionDeclarationToOpenAiTool;
     /**
-     * The authentication configuration
+     * Convert ADK role to OpenAI role format
      */
-    auth_config: AuthConfig | EnhancedAuthConfig;
-}
-/**
- * Auth tool for handling credential requests
- */
-declare class AuthTool {
+    private toOpenAiRole;
     /**
-     * Processes auth tool arguments and returns appropriate response
+     * Convert OpenAI finish reason to ADK finish reason
      */
-    static processAuthRequest(args: AuthToolArguments): Promise<{
-        status: string;
-        authConfig?: AuthConfig | EnhancedAuthConfig;
-        credentialKey?: string;
-    }>;
+    private toAdkFinishReason;
     /**
-     * Validates auth tool arguments
+     * Preprocess request similar to Google LLM
      */
-    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 {
+    private preprocessRequest;
     /**
-     * Type of credential
+     * Preprocess individual parts for OpenAI compatibility
      */
-    type: AuthCredentialType;
+    private preprocessPart;
     /**
-     * Constructor for AuthCredential
+     * Detect content type for flow control
+     * This is a simplified implementation - you may need to adjust based on your specific requirements
      */
-    constructor(type: AuthCredentialType);
+    private getContentType;
     /**
-     * Gets the authentication token
+     * Check if response has inline data (similar to Google LLM)
      */
-    abstract getToken(): string | undefined;
+    private hasInlineData;
     /**
-     * Gets headers for HTTP requests
+     * Gets the OpenAI client
      */
-    abstract getHeaders(config: AuthConfig): Record<string, string>;
+    private get client();
+}
+
+/**
+ * AI SDK integration that accepts a pre-configured LanguageModel.
+ * Enables ADK to work with any provider supported by Vercel's AI SDK.
+ */
+declare class AiSdkLlm extends BaseLlm {
+    private modelInstance;
+    protected logger: Logger;
     /**
-     * Whether the token can be refreshed
+     * Constructor accepts a pre-configured LanguageModel instance
+     * @param model - Pre-configured LanguageModel from provider(modelName)
      */
-    canRefresh(): boolean;
+    constructor(modelInstance: LanguageModel);
     /**
-     * Refreshes the token
+     * Returns empty array - following Python ADK pattern
      */
-    refresh(): Promise<void>;
-}
-/**
- * API Key credential
- */
-declare class ApiKeyCredential extends AuthCredential {
+    static supportedModels(): string[];
+    protected generateContentAsyncImpl(request: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
     /**
-     * The API key
+     * Convert ADK LlmRequest to AI SDK CoreMessage format
      */
-    apiKey: string;
+    private convertToAiSdkMessages;
     /**
-     * Constructor for ApiKeyCredential
+     * Convert ADK tools to AI SDK tools format
      */
-    constructor(apiKey: string);
+    private convertToAiSdkTools;
     /**
-     * Gets the API key as the token
+     * Convert ADK Content to AI SDK CoreMessage
      */
-    getToken(): string;
+    private contentToAiSdkMessage;
     /**
-     * Gets headers for HTTP requests
+     * Map ADK role to AI SDK role
      */
-    getHeaders(config: AuthConfig): Record<string, string>;
+    private mapRole;
+    /**
+     * Map AI SDK finish reason to ADK finish reason
+     */
+    private mapFinishReason;
 }
+
 /**
- * Basic authentication credential
+ * Type for LLM constructor with static methods
  */
-declare class BasicAuthCredential extends AuthCredential {
+interface LLMClass {
+    new (model: string): BaseLlm;
+    supportedModels(): string[];
+}
+/**
+ * Registry for LLMs
+ */
+declare class LLMRegistry {
     /**
-     * The username
+     * Map of model name regex to LLM class
      */
-    username: string;
+    private static llmRegistry;
+    private static logger;
     /**
-     * The password
+     * Creates a new LLM instance
+     *
+     * @param model The model name
+     * @returns The LLM instance
      */
-    password: string;
+    static newLLM(model: string): BaseLlm;
     /**
-     * Constructor for BasicAuthCredential
+     * Resolves the LLM class from the model name
+     *
+     * @param model The model name
+     * @returns The LLM class
      */
-    constructor(username: string, password: string);
+    static resolve(model: string): LLMClass | null;
     /**
-     * Gets the encoded basic auth token
+     * Registers a new LLM class
+     *
+     * @param modelNameRegex The regex to match model names
+     * @param llmClass The LLM class
      */
-    getToken(): string;
+    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;
+    /**
+     * Logs all registered models for debugging
+     */
+    static logRegisteredModels(): void;
 }
+
 /**
- * Bearer token credential
+ * Register all LLM providers
  */
-declare class BearerTokenCredential extends AuthCredential {
-    /**
-     * The bearer token
-     */
-    token: string;
-    /**
-     * Constructor for BearerTokenCredential
-     */
-    constructor(token: string);
+declare function registerProviders(): void;
+
+/**
+ * Configuration for model built-in thinking features
+ * Compatible with google.genai.types.ThinkingConfig
+ */
+interface ThinkingConfig {
     /**
-     * Gets the bearer token
+     * Whether to include the thinking process in the response
      */
-    getToken(): string;
+    includeThinking?: boolean;
     /**
-     * Gets headers for HTTP requests
+     * Additional thinking configuration options
      */
-    getHeaders(): Record<string, string>;
+    [key: string]: any;
+}
+
+/**
+ * Authentication scheme types
+ */
+declare enum AuthSchemeType {
+    APIKEY = "apiKey",
+    HTTP = "http",
+    OAUTH2 = "oauth2",
+    OPENID_CONNECT = "openIdConnect"
 }
 /**
- * OAuth2 token credential with refresh capability
+ * Base class for authentication schemes
  */
-declare class OAuth2Credential extends AuthCredential {
+declare abstract class AuthScheme {
     /**
-     * The access token
+     * The type of authentication scheme
      */
-    accessToken: string;
+    type: AuthSchemeType;
+    constructor(type: AuthSchemeType);
+}
+/**
+ * API Key authentication scheme
+ */
+declare class ApiKeyScheme extends AuthScheme {
     /**
-     * The refresh token
+     * Where the API key is sent
      */
-    refreshToken?: string;
+    in: "query" | "header" | "cookie";
     /**
-     * When the token expires
+     * Name of the parameter
      */
-    expiresAt?: Date;
+    name: string;
     /**
-     * Function to refresh the token
+     * Description of the API key
      */
-    private refreshFunction?;
+    description?: string;
     /**
-     * Constructor for OAuth2Credential
+     * Constructor for ApiKeyScheme
      */
     constructor(config: {
-        accessToken: string;
-        refreshToken?: string;
-        expiresIn?: number;
-        refreshFunction?: (refreshToken: string) => Promise<{
-            accessToken: string;
-            refreshToken?: string;
-            expiresIn?: number;
-        }>;
+        in: "query" | "header" | "cookie";
+        name: string;
+        description?: string;
     });
+}
+/**
+ * HTTP authentication scheme
+ */
+declare class HttpScheme extends AuthScheme {
     /**
-     * Gets the access token
-     */
-    getToken(): string;
-    /**
-     * Gets headers for HTTP requests
+     * The HTTP authentication scheme
      */
-    getHeaders(): Record<string, string>;
+    scheme: "basic" | "bearer" | "digest" | "other";
     /**
-     * Whether the token can be refreshed
+     * Bearer format when scheme is 'bearer'
      */
-    canRefresh(): boolean;
+    bearerFormat?: string;
     /**
-     * Whether the token is expired
+     * Description of the scheme
      */
-    isExpired(): boolean;
+    description?: string;
     /**
-     * Refreshes the token
+     * Constructor for HttpScheme
      */
-    refresh(): Promise<void>;
+    constructor(config: {
+        scheme: "basic" | "bearer" | "digest" | "other";
+        bearerFormat?: string;
+        description?: string;
+    });
 }
-
 /**
- * Models module exports - consolidated to match Python structure
+ * OAuth flow configuration
  */
-
-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 };
+interface OAuthFlow {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: Record<string, string>;
 }
-
 /**
- * Options for creating an Event.
+ * OAuth flows configuration
  */
-interface EventOpts {
-    invocationId?: string;
-    author: string;
-    actions?: EventActions;
-    longRunningToolIds?: Set<string>;
-    branch?: string;
-    id?: string;
-    timestamp?: number;
-    content?: any;
-    partial?: boolean;
+interface OAuthFlows {
+    implicit?: OAuthFlow;
+    password?: OAuthFlow;
+    clientCredentials?: OAuthFlow;
+    authorizationCode?: OAuthFlow;
 }
 /**
- * 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.
+ * OAuth2 authentication scheme
  */
-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;
+declare class OAuth2Scheme extends AuthScheme {
     /**
-     * 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.
+     * OAuth flows
      */
-    longRunningToolIds?: Set<string>;
+    flows: OAuthFlows;
     /**
-     * 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.
+     * Description of the scheme
      */
-    branch?: string;
-    /** The unique identifier of the event. */
-    id: string;
-    /** The timestamp of the event (seconds since epoch). */
-    timestamp: number;
+    description?: string;
     /**
-     * Constructor for Event.
+     * Constructor for OAuth2Scheme
      */
-    constructor(opts: EventOpts);
+    constructor(config: {
+        flows: OAuthFlows;
+        description?: string;
+    });
+}
+/**
+ * OpenID Connect authentication scheme
+ */
+declare class OpenIdConnectScheme extends AuthScheme {
     /**
-     * Returns whether the event is the final response of the agent.
+     * OpenID Connect URL
      */
-    isFinalResponse(): boolean;
+    openIdConnectUrl: string;
     /**
-     * Returns the function calls in the event.
+     * Description of the scheme
      */
-    getFunctionCalls(): any[];
+    description?: string;
     /**
-     * Returns the function responses in the event.
+     * Constructor for OpenIdConnectScheme
      */
-    getFunctionResponses(): any[];
+    constructor(config: {
+        openIdConnectUrl: string;
+        description?: string;
+    });
+}
+
+/**
+ * Authentication configuration for tools
+ */
+declare class AuthConfig {
     /**
-     * Returns whether the event has a trailing code execution result.
+     * The authentication scheme
      */
-    hasTrailingCodeExecutionResult(): boolean;
+    authScheme: AuthScheme;
     /**
-     * Generates a new random ID for an event.
+     * Additional context properties
      */
-    static newId(): string;
+    context?: Record<string, any>;
+    /**
+     * Constructor for AuthConfig
+     */
+    constructor(config: {
+        authScheme: AuthScheme;
+        context?: Record<string, any>;
+    });
 }
 
 /**
- * Single agent callback type
- */
-type SingleAgentCallback = (callbackContext: CallbackContext) => Promise<Content$1 | undefined> | Content$1 | 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.
+ * Handler for authentication in tools
  */
-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 AuthHandler {
     /**
-     * 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 configuration
      */
-    description: string;
+    authConfig: AuthConfig;
     /**
-     * The parent agent of this agent.
-     * Note that an agent can ONLY be added as sub-agent once.
-     * If you want to add one agent twice as sub-agent, consider to create two agent
-     * instances with identical config, but with different name and add them to the
-     * agent tree.
+     * The authentication credential
      */
-    parentAgent?: BaseAgent;
+    credential?: AuthCredential;
     /**
-     * The sub-agents of this agent.
+     * Constructor for AuthHandler
      */
-    subAgents: BaseAgent[];
+    constructor(config: {
+        authConfig: AuthConfig;
+        credential?: 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.
+     * Gets the authentication token
      */
-    beforeAgentCallback?: BeforeAgentCallback;
+    getToken(): string | undefined;
     /**
-     * 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.
+     * Gets headers for HTTP requests
      */
-    afterAgentCallback?: AfterAgentCallback;
+    getHeaders(): Record<string, string>;
     /**
-     * Constructor for BaseAgent
+     * Refreshes the token if necessary
      */
-    constructor(config: {
-        name: string;
-        description?: string;
-        subAgents?: BaseAgent[];
-        beforeAgentCallback?: BeforeAgentCallback;
-        afterAgentCallback?: AfterAgentCallback;
-    });
+    refreshToken(): Promise<void>;
+}
+
+/**
+ * Base class for LLM request processors.
+ */
+declare abstract class BaseLlmRequestProcessor {
     /**
-     * Entry method to run an agent via text-based conversation.
+     * 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
      */
-    runAsync(parentContext: InvocationContext): AsyncGenerator<Event, void, unknown>;
+    abstract runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, unknown>;
+}
+/**
+ * Base class for LLM response processors.
+ */
+declare abstract class BaseLlmResponseProcessor {
     /**
-     * Entry method to run an agent via video/audio-based conversation.
+     * Processes the LLM response.
+     * @param invocationContext The invocation context
+     * @param llmResponse The LLM response to process
+     * @returns An async generator yielding events
      */
-    runLive(parentContext: InvocationContext): AsyncGenerator<Event, void, unknown>;
+    abstract runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event, void, unknown>;
+}
+
+/**
+ * Auth LLM request processor that handles authentication information
+ * to build the LLM request with credential processing
+ */
+declare class AuthLlmRequestProcessor extends BaseLlmRequestProcessor {
     /**
-     * Internal implementation for runAsync
+     * Processes authentication information from session events
+     * and resumes function calls that required authentication
      */
-    private runAsyncInternal;
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
     /**
-     * Internal implementation for runLive
+     * Parses and stores authentication response in session state
      */
-    private runLiveInternal;
+    private parseAndStoreAuthResponse;
+}
+/**
+ * Exported request processor instance for use in flow configurations
+ */
+declare const requestProcessor$7: AuthLlmRequestProcessor;
+
+/**
+ * Enhanced auth configuration with credential handling
+ * This extends the basic AuthConfig with raw and exchanged credentials
+ */
+declare class EnhancedAuthConfig {
     /**
-     * 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.
+     * The authentication scheme
      */
-    protected runAsyncImpl(_ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
+    authScheme: AuthScheme;
     /**
-     * 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.
+     * Raw auth credential used to collect credentials
+     * Used in auth schemes that need to exchange credentials (e.g. OAuth2, OIDC)
      */
-    protected runLiveImpl(_ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
+    rawAuthCredential?: AuthCredential;
     /**
-     * Gets the root agent of this agent.
+     * Exchanged auth credential after processing
+     * Filled by ADK and client working together
      */
-    get rootAgent(): BaseAgent;
+    exchangedAuthCredential?: AuthCredential;
     /**
-     * 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.
+     * User-specified key for credential storage and retrieval
      */
-    findAgent(name: string): BaseAgent | undefined;
+    credentialKey?: string;
     /**
-     * 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.
+     * Additional context properties
      */
-    findSubAgent(name: string): BaseAgent | undefined;
+    context?: Record<string, any>;
     /**
-     * Creates a new invocation context for this agent.
+     * Constructor for EnhancedAuthConfig
      */
-    private createInvocationContext;
+    constructor(config: {
+        authScheme: AuthScheme;
+        rawAuthCredential?: AuthCredential;
+        exchangedAuthCredential?: AuthCredential;
+        credentialKey?: string;
+        context?: Record<string, any>;
+    });
     /**
-     * The resolved beforeAgentCallback field as a list of SingleAgentCallback.
-     * This method is only for use by Agent Development Kit.
+     * Generates a credential key based on auth scheme and raw credential
+     * Used for saving/loading credentials from credential service
      */
-    get canonicalBeforeAgentCallbacks(): SingleAgentCallback[];
+    private generateCredentialKey;
     /**
-     * The resolved afterAgentCallback field as a list of SingleAgentCallback.
-     * This method is only for use by Agent Development Kit.
+     * Gets the credential key for storage
      */
-    get canonicalAfterAgentCallbacks(): SingleAgentCallback[];
+    getCredentialKey(): string;
+}
+/**
+ * Arguments for the special long-running function tool used to request
+ * end-user credentials
+ */
+interface AuthToolArguments extends Record<string, unknown> {
     /**
-     * Runs the beforeAgentCallback if it exists.
-     *
-     * @returns An event if callback provides content or changed state.
+     * The ID of the function call that requires authentication
      */
-    private handleBeforeAgentCallback;
+    function_call_id: string;
     /**
-     * Runs the afterAgentCallback if it exists.
-     *
-     * @returns An event if callback provides content or changed state.
+     * The authentication configuration
      */
-    private handleAfterAgentCallback;
+    auth_config: AuthConfig | EnhancedAuthConfig;
+}
+/**
+ * Auth tool for handling credential requests
+ */
+declare class AuthTool {
     /**
-     * Validates the agent name.
+     * Processes auth tool arguments and returns appropriate response
      */
-    private validateName;
+    static processAuthRequest(args: AuthToolArguments): Promise<{
+        status: string;
+        authConfig?: AuthConfig | EnhancedAuthConfig;
+        credentialKey?: string;
+    }>;
     /**
-     * Sets parent agent for sub-agents.
+     * Validates auth tool arguments
      */
-    private setParentAgentForSubAgents;
+    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;
 
-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[];
+/**
+ * Types of authentication credentials
+ */
+declare enum AuthCredentialType {
+    API_KEY = "api_key",
+    BASIC = "basic",
+    BEARER = "bearer",
+    OAUTH2 = "oauth2",
+    CUSTOM = "custom"
 }
-declare class CodeExecutionUtils {
+/**
+ * Base class for authentication credentials
+ */
+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>;
     /**
-     * Gets the file content as a base64-encoded string
+     * Whether the token can be refreshed
      */
-    static getEncodedFileContent(data: string | ArrayBuffer): string;
-    private static isBase64Encoded;
+    canRefresh(): boolean;
     /**
-     * Extracts the first code block from the content and truncates everything after it
+     * Refreshes the token
      */
-    static extractCodeAndTruncateContent(content: Content$1, codeBlockDelimiters: Array<[string, string]>): string | null;
-    private static escapeRegex;
+    refresh(): Promise<void>;
+}
+/**
+ * API Key credential
+ */
+declare class ApiKeyCredential extends AuthCredential {
     /**
-     * Builds an executable code part with code string
+     * The API key
      */
-    static buildExecutableCodePart(code: string): Part;
+    apiKey: string;
     /**
-     * Builds the code execution result part from the code execution result
+     * Constructor for ApiKeyCredential
      */
-    static buildCodeExecutionResultPart(codeExecutionResult: CodeExecutionResult): Part;
+    constructor(apiKey: string);
     /**
-     * Converts the code execution parts to text parts in a Content
+     * Gets the API key as the token
      */
-    static convertCodeExecutionParts(content: Content$1, codeBlockDelimiter: [string, string], executionResultDelimiters: [string, string]): void;
-}
-
-interface BaseCodeExecutorConfig {
+    getToken(): string;
     /**
-     * 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.
+     * Gets headers for HTTP requests
      */
-    optimizeDataFile?: boolean;
+    getHeaders(config: AuthConfig): Record<string, string>;
+}
+/**
+ * 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 +3919,12 @@ interface AgentBuilderConfig {
     instruction?: string;
     tools?: BaseTool[];
     planner?: BasePlanner;
+    codeExecutor?: BaseCodeExecutor;
     subAgents?: BaseAgent[];
     maxIterations?: number;
     nodes?: LangGraphNode[];
     rootNode?: string;
+    outputKey?: string;
 }
 /**
  * Session configuration options
@@ -3906,6 +3932,8 @@ interface AgentBuilderConfig {
 interface SessionOptions {
     userId?: string;
     appName?: string;
+    state?: Record<string, any>;
+    sessionId?: string;
 }
 /**
  * Message part interface for flexible message input
@@ -3916,7 +3944,7 @@ interface MessagePart extends Part {
 /**
  * Full message interface for advanced usage
  */
-interface FullMessage extends Content$1 {
+interface FullMessage extends Content {
     parts?: MessagePart[];
 }
 /**
@@ -3962,13 +3990,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 +4016,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 +4068,18 @@ 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;
     /**
      * Configure as a sequential agent
      * @param subAgents Sub-agents to execute in sequence
@@ -4062,7 +4112,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 +4839,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 +5047,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 +5056,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 +5164,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, McpNearIntentSwaps, 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 };