@iqai/adk 0.2.1 → 0.2.2

package/dist/index.js

@@ -3879,7 +3879,6 @@ __export(tools_exports, {
   McpAbi: () => McpAbi,
   McpAtp: () => McpAtp,
   McpBamm: () => McpBamm,
-  McpClientService: () => McpClientService,
   McpCoinGecko: () => McpCoinGecko,
   McpDiscord: () => McpDiscord,
   McpError: () => McpError,
@@ -3901,6 +3900,7 @@ __export(tools_exports, {
   UserInteractionTool: () => UserInteractionTool,
   adkToMcpToolType: () => adkToMcpToolType,
   buildFunctionDeclaration: () => buildFunctionDeclaration,
+  convertMcpToolToBaseTool: () => convertMcpToolToBaseTool,
   createFunctionTool: () => createFunctionTool,
   createSamplingHandler: () => createSamplingHandler,
   createTool: () => createTool,
@@ -3909,954 +3909,957 @@ __export(tools_exports, {
   mcpSchemaToParameters: () => mcpSchemaToParameters,
   normalizeJsonSchema: () => normalizeJsonSchema
 });
+init_base_tool();
 
-// src/tools/mcp/client.ts
-init_logger();
-var _indexjs = require('@modelcontextprotocol/sdk/client/index.js');
-var _ssejs = require('@modelcontextprotocol/sdk/client/sse.js');
-var _stdiojs = require('@modelcontextprotocol/sdk/client/stdio.js');
-var _typesjs = require('@modelcontextprotocol/sdk/types.js');
-
-// src/tools/mcp/sampling-handler.ts
-init_logger();
-
-
-
-
-
-// src/tools/mcp/types.ts
-var McpErrorType = /* @__PURE__ */ ((McpErrorType2) => {
-  McpErrorType2["CONNECTION_ERROR"] = "connection_error";
-  McpErrorType2["TOOL_EXECUTION_ERROR"] = "tool_execution_error";
-  McpErrorType2["RESOURCE_CLOSED_ERROR"] = "resource_closed_error";
-  McpErrorType2["TIMEOUT_ERROR"] = "timeout_error";
-  McpErrorType2["INVALID_SCHEMA_ERROR"] = "invalid_schema_error";
-  McpErrorType2["SAMPLING_ERROR"] = "SAMPLING_ERROR";
-  McpErrorType2["INVALID_REQUEST_ERROR"] = "INVALID_REQUEST_ERROR";
-  return McpErrorType2;
-})(McpErrorType || {});
-var McpError = class extends Error {
+// src/tools/base/create-tool.ts
+init_base_tool();
+var _zod = require('zod'); var z = _interopRequireWildcard(_zod);
+var _zodtojsonschema = require('zod-to-json-schema');
+var CreatedTool = class extends BaseTool {
   
   
-  constructor(message, type, originalError) {
-    super(message);
-    this.name = "McpError";
-    this.type = type;
-    this.originalError = originalError;
-  }
-};
-
-// src/tools/mcp/sampling-handler.ts
-var McpSamplingHandler = (_class13 = class {
-  __init22() {this.logger = new Logger({ name: "McpSamplingHandler" })}
   
-  constructor(samplingHandler) {;_class13.prototype.__init22.call(this);
-    this.samplingHandler = samplingHandler;
+  constructor(config) {
+    super({
+      name: config.name,
+      description: config.description,
+      isLongRunning: _nullishCoalesce(config.isLongRunning, () => ( false)),
+      shouldRetryOnFailure: _nullishCoalesce(config.shouldRetryOnFailure, () => ( false)),
+      maxRetryAttempts: _nullishCoalesce(config.maxRetryAttempts, () => ( 3))
+    });
+    this.func = config.fn;
+    this.schema = _nullishCoalesce(config.schema, () => ( z.object({})));
+    this.functionDeclaration = this.buildDeclaration();
   }
   /**
-   * Handle MCP sampling request and convert between formats
+   * Executes the tool function with validation
    */
-  async handleSamplingRequest(request) {
+  async runAsync(args, context4) {
     try {
-      if (request.method !== "sampling/createMessage") {
-        this.logger.error(
-          `Invalid method for sampling handler: ${request.method}. Expected: sampling/createMessage`
-        );
-        throw new McpError(
-          `Invalid method: ${request.method}. This handler only processes sampling/createMessage requests.`,
-          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
-        );
-      }
-      const validationResult = _typesjs.CreateMessageRequestSchema.safeParse(request);
-      if (!validationResult.success) {
-        this.logger.error(
-          "Invalid MCP sampling request:",
-          validationResult.error
-        );
-        throw new McpError(
-          `Invalid sampling request: ${validationResult.error.message}`,
-          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
-        );
-      }
-      const mcpParams = request.params;
-      if (!mcpParams.messages || !Array.isArray(mcpParams.messages)) {
-        throw new McpError(
-          "Invalid sampling request: messages array is required",
-          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
-        );
-      }
-      if (!mcpParams.maxTokens || mcpParams.maxTokens <= 0) {
-        throw new McpError(
-          "Invalid sampling request: maxTokens must be a positive number",
-          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
-        );
-      }
-      this.logger.debug("Converting MCP request to ADK format");
-      const adkContents = this.convertMcpMessagesToADK(
-        mcpParams.messages,
-        mcpParams.systemPrompt
-      );
-      const requestModel = mcpParams.model || "gemini-2.0-flash";
-      const adkRequest = new LlmRequest({
-        model: requestModel,
-        contents: adkContents,
-        config: {
-          temperature: mcpParams.temperature,
-          maxOutputTokens: mcpParams.maxTokens
-        }
-      });
-      this.logger.debug("Calling ADK sampling handler");
-      const adkResponse = await this.samplingHandler(adkRequest);
-      this.logger.debug("Converting ADK response to MCP format");
-      const mcpResponse = this.convertADKResponseToMcp(
-        adkResponse,
-        requestModel
-      );
-      const responseValidation = _typesjs.CreateMessageResultSchema.safeParse(mcpResponse);
-      if (!responseValidation.success) {
-        this.logger.error(
-          "Invalid MCP response generated:",
-          responseValidation.error
-        );
-        throw new McpError(
-          `Invalid response generated: ${responseValidation.error.message}`,
-          "SAMPLING_ERROR" /* SAMPLING_ERROR */
-        );
-      }
-      return mcpResponse;
+      const validatedArgs = this.schema.parse(args);
+      const result = await Promise.resolve(this.func(validatedArgs, context4));
+      return _nullishCoalesce(result, () => ( {}));
     } catch (error) {
-      this.logger.error("Error handling sampling request:", error);
-      if (error instanceof McpError) {
-        throw error;
+      if (error instanceof z.ZodError) {
+        return {
+          error: `Invalid arguments for ${this.name}: ${error.message}`
+        };
       }
-      throw new McpError(
-        `Sampling request failed: ${error instanceof Error ? error.message : String(error)}`,
-        "SAMPLING_ERROR" /* SAMPLING_ERROR */,
-        error instanceof Error ? error : void 0
-      );
+      return {
+        error: `Error executing ${this.name}: ${error instanceof Error ? error.message : String(error)}`
+      };
     }
   }
   /**
-   * Convert MCP messages to ADK Content format
+   * Returns the function declaration for this tool
    */
-  convertMcpMessagesToADK(mcpMessages, systemPrompt) {
-    const contents = [];
-    if (systemPrompt) {
-      contents.push({
-        role: "user",
-        // System messages are typically sent as user role in content
-        parts: [{ text: systemPrompt }]
-      });
-    }
-    const transformedMessages = mcpMessages.map(
-      (mcpMessage) => this.convertSingleMcpMessageToADK(mcpMessage)
-    );
-    contents.push(...transformedMessages);
-    return contents;
+  getDeclaration() {
+    return this.functionDeclaration;
   }
   /**
-   * Convert a single MCP message to ADK Content format
+   * Builds the function declaration from the Zod schema
    */
-  convertSingleMcpMessageToADK(mcpMessage) {
-    const adkRole = mcpMessage.role === "assistant" ? "model" : "user";
-    const adkParts = this.convertMcpContentToADKParts(mcpMessage.content);
-    const adkContent = {
-      role: adkRole,
-      parts: adkParts
+  buildDeclaration() {
+    const rawParameters = _zodtojsonschema.zodToJsonSchema.call(void 0, this.schema, {
+      target: "jsonSchema7",
+      $refStrategy: "none"
+    });
+    const { $schema, ...parameters } = rawParameters;
+    return {
+      name: this.name,
+      description: this.description,
+      parameters
     };
-    this.logger.debug(
-      `Converted MCP message - role: ${mcpMessage.role} -> ${adkRole}, content type: ${mcpMessage.content.type}`
-    );
-    return adkContent;
   }
+};
+function createTool(config) {
+  return new CreatedTool(config);
+}
+
+// src/tools/common/agent-tool.ts
+init_logger();
+
+
+
+// src/agents/invocation-context.ts
+var LlmCallsLimitExceededError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LlmCallsLimitExceededError";
+  }
+};
+var InvocationCostManager = (_class13 = class {constructor() { _class13.prototype.__init22.call(this); }
   /**
-   * Convert MCP message content to ADK parts format
+   * A counter that keeps track of number of llm calls made.
    */
-  convertMcpContentToADKParts(mcpContent) {
-    if (mcpContent.type === "text") {
-      const textContent = mcpContent.text || "";
-      return [{ text: textContent }];
-    }
-    if (mcpContent.type === "image") {
-      const parts = [];
-      if (mcpContent.text && typeof mcpContent.text === "string") {
-        parts.push({ text: mcpContent.text });
-      }
-      if (mcpContent.data && typeof mcpContent.data === "string") {
-        const mimeType = mcpContent.mimeType || "image/jpeg";
-        parts.push({
-          inlineData: {
-            data: mcpContent.data,
-            mimeType
-          }
-        });
-      }
-      return parts.length > 0 ? parts : [{ text: "" }];
+  __init22() {this._numberOfLlmCalls = 0}
+  /**
+   * Increments _numberOfLlmCalls and enforces the limit.
+   */
+  incrementAndEnforceLlmCallsLimit(runConfig) {
+    this._numberOfLlmCalls += 1;
+    if (runConfig && runConfig.maxLlmCalls > 0 && this._numberOfLlmCalls > runConfig.maxLlmCalls) {
+      throw new LlmCallsLimitExceededError(
+        `Max number of llm calls limit of \`${runConfig.maxLlmCalls}\` exceeded`
+      );
     }
-    this.logger.warn(`Unknown MCP content type: ${mcpContent.type}`);
-    const fallbackText = typeof mcpContent.data === "string" ? mcpContent.data : "";
-    return [{ text: fallbackText }];
   }
+}, _class13);
+function newInvocationContextId() {
+  return `e-${crypto.randomUUID()}`;
+}
+var InvocationContext = (_class14 = class _InvocationContext {
+  
+  
+  
   /**
-   * Convert ADK response to MCP response format
+   * The id of this invocation context. Readonly.
    */
-  convertADKResponseToMcp(adkResponse, model) {
-    let responseText = "";
-    if (typeof adkResponse === "string") {
-      responseText = adkResponse;
-    } else {
-      if (adkResponse.content) {
-        if (typeof adkResponse.content === "string") {
-          responseText = adkResponse.content;
-        } else if (adkResponse.content.parts) {
-          responseText = adkResponse.content.parts.map((part) => {
-            return typeof part.text === "string" ? part.text : "";
-          }).join("");
-        }
-      }
-    }
-    const mcpResponse = {
-      model,
-      // Use the model from the request
-      role: "assistant",
-      // ADK responses are always from assistant
-      content: {
-        type: "text",
-        text: responseText
-      }
-    };
-    this.logger.debug(`Received content: ${responseText}`);
-    return mcpResponse;
-  }
+  
   /**
-   * Update the ADK handler
+   * The branch of the invocation context.
+   *
+   * The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of
+   * agent_2, and agent_2 is the parent of agent_3.
+   *
+   * Branch is used when multiple sub-agents shouldn't see their peer agents'
+   * conversation history.
    */
-  updateHandler(handler) {
-    this.samplingHandler = handler;
-    this.logger.debug("ADK sampling handler updated");
-  }
-}, _class13);
-function createSamplingHandler(handler) {
-  return handler;
-}
-
-// src/tools/mcp/utils.ts
-function withRetry(fn, instance, reinitMethod, maxRetries = 1) {
-  return async (...args) => {
-    let attempt = 0;
-    while (attempt <= maxRetries) {
-      try {
-        return await fn.apply(instance, args);
-      } catch (error) {
-        const isClosedResourceError = error instanceof Error && (error.message.includes("closed") || error.message.includes("ECONNRESET") || error.message.includes("socket hang up"));
-        if (!isClosedResourceError || attempt >= maxRetries) {
-          throw error;
-        }
-        console.warn(
-          `Resource closed, reinitializing (attempt ${attempt + 1}/${maxRetries + 1})...`
-        );
-        try {
-          await reinitMethod(instance);
-        } catch (reinitError) {
-          console.error("Error reinitializing resources:", reinitError);
-          throw new Error(`Failed to reinitialize resources: ${reinitError}`);
-        }
-        attempt++;
-      }
-    }
-    throw new Error("Unexpected end of retry loop");
-  };
-}
-
-// src/tools/mcp/client.ts
-var McpClientService = (_class14 = class {
-  
-  __init23() {this.client = null}
-  __init24() {this.transport = null}
-  __init25() {this.isClosing = false}
-  __init26() {this.mcpSamplingHandler = null}
-  __init27() {this.logger = new Logger({ name: "McpClientService" })}
-  constructor(config) {;_class14.prototype.__init23.call(this);_class14.prototype.__init24.call(this);_class14.prototype.__init25.call(this);_class14.prototype.__init26.call(this);_class14.prototype.__init27.call(this);
-    this.config = config;
-    if (config.samplingHandler) {
-      this.mcpSamplingHandler = new McpSamplingHandler(config.samplingHandler);
-    }
-  }
+  
   /**
-   * Initializes and returns an MCP client based on configuration.
-   * Will create a new client if one doesn't exist yet.
+   * The current agent of this invocation context. Readonly.
    */
-  async initialize() {
-    if (this.isClosing) {
-      throw new McpError(
-        "Cannot initialize a client that is being closed",
-        "resource_closed_error" /* RESOURCE_CLOSED_ERROR */
-      );
-    }
-    if (this.client) {
-      return this.client;
-    }
-    try {
-      if (!this.transport) {
-        this.transport = await this.createTransport();
-      }
-      const client = new (0, _indexjs.Client)(
-        {
-          name: this.config.name,
-          version: "0.0.1"
-        },
-        {
-          capabilities: {
-            prompts: {},
-            resources: {},
-            tools: {},
-            sampling: {}
-            // Enable sampling capability
-          }
-        }
-      );
-      const connectPromise = client.connect(this.transport);
-      if (this.config.timeout) {
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(
-              new McpError(
-                `MCP client connection timed out after ${this.config.timeout}ms`,
-                "timeout_error" /* TIMEOUT_ERROR */
-              )
-            );
-          }, this.config.timeout);
-        });
-        await Promise.race([connectPromise, timeoutPromise]);
-      } else {
-        await connectPromise;
-      }
-      await this.setupSamplingHandler(client);
-      this.logger.debug("\u2705 MCP client connected successfully");
-      this.client = client;
-      return client;
-    } catch (error) {
-      await this.cleanupResources();
-      if (!(error instanceof McpError)) {
-        this.logger.error("Failed to initialize MCP client:", error);
-        throw new McpError(
-          `Failed to initialize MCP client: ${error instanceof Error ? error.message : String(error)}`,
-          "connection_error" /* CONNECTION_ERROR */,
-          error instanceof Error ? error : void 0
-        );
-      }
-      throw error;
-    }
-  }
+  
   /**
-   * Creates a transport based on the configuration.
+   * The user content that started this invocation. Readonly.
    */
-  async createTransport() {
-    try {
-      if (this.config.transport.mode === "sse") {
-        this.logger.debug(
-          "\u{1F680} Initializing MCP client in SSE mode",
-          this.config.transport.serverUrl
-        );
-        const headers = {
-          ...this.config.transport.headers || {},
-          ...this.config.headers || {}
-        };
-        return new (0, _ssejs.SSEClientTransport)(
-          new URL(this.config.transport.serverUrl),
-          {
-            requestInit: {
-              headers,
-              ...this.config.timeout ? { timeout: this.config.timeout } : {}
-            }
-          }
-        );
-      }
-      this.logger.debug(
-        "\u{1F680} Initializing MCP client in STDIO mode",
-        this.config.transport.command
-      );
-      return new (0, _stdiojs.StdioClientTransport)({
-        command: this.config.transport.command,
-        args: this.config.transport.args,
-        env: this.config.transport.env
-      });
-    } catch (error) {
-      throw new McpError(
-        `Failed to create transport: ${error instanceof Error ? error.message : String(error)}`,
-        "connection_error" /* CONNECTION_ERROR */,
-        error instanceof Error ? error : void 0
-      );
-    }
+  
+  /**
+   * The current session of this invocation context. Readonly.
+   */
+  
+  /**
+   * Whether to end this invocation.
+   *
+   * Set to True in callbacks or tools to terminate this invocation.
+   */
+  __init23() {this.endInvocation = false}
+  /**
+   * The queue to receive live requests.
+   */
+  
+  /**
+   * The running streaming tools of this invocation.
+   */
+  
+  /**
+   * Caches necessary, data audio or contents, that are needed by transcription.
+   */
+  
+  /**
+   * Configurations for live agents under this invocation.
+   */
+  
+  /**
+   * A container to keep track of different kinds of costs incurred as a part
+   * of this invocation.
+   */
+  __init24() {this._invocationCostManager = new InvocationCostManager()}
+  /**
+   * Constructor for InvocationContext
+   */
+  constructor(options) {;_class14.prototype.__init23.call(this);_class14.prototype.__init24.call(this);
+    this.artifactService = options.artifactService;
+    this.sessionService = options.sessionService;
+    this.memoryService = options.memoryService;
+    this.invocationId = options.invocationId || newInvocationContextId();
+    this.branch = options.branch;
+    this.agent = options.agent;
+    this.userContent = options.userContent;
+    this.session = options.session;
+    this.endInvocation = options.endInvocation || false;
+    this.liveRequestQueue = options.liveRequestQueue;
+    this.activeStreamingTools = options.activeStreamingTools;
+    this.transcriptionCache = options.transcriptionCache;
+    this.runConfig = options.runConfig;
   }
   /**
-   * Re-initializes the MCP client when a session is closed.
-   * Used by the retry mechanism.
+   * App name from the session
    */
-  async reinitialize() {
-    this.logger.debug("\u{1F504} Reinitializing MCP client after closed connection");
-    await this.cleanupResources();
-    this.client = null;
-    this.transport = null;
-    await this.initialize();
+  get appName() {
+    return this.session.appName;
   }
   /**
-   * Cleans up resources associated with this client service.
-   * Similar to Python's AsyncExitStack.aclose() functionality.
+   * User ID from the session
    */
-  async cleanupResources() {
-    try {
-      this.isClosing = true;
-      if (this.client) {
-        try {
-          if (typeof this.client.close === "function") {
-            await this.client.close();
-          }
-        } catch (err) {
-        }
-      }
-      if (this.transport && typeof this.transport.close === "function") {
-        await this.transport.close();
-      }
-      this.logger.debug("\u{1F9F9} Cleaned up MCP client resources");
-    } catch (error) {
-      this.logger.error("Error cleaning up MCP resources:", error);
-    } finally {
-      this.client = null;
-      this.transport = null;
-      this.isClosing = false;
-    }
+  get userId() {
+    return this.session.userId;
   }
   /**
-   * Call an MCP tool with retry capability if the session is closed.
+   * Tracks number of llm calls made.
+   *
+   * @throws {LlmCallsLimitExceededError} If number of llm calls made exceed the set threshold.
    */
-  async callTool(name, args) {
-    try {
-      const wrappedCall = withRetry(
-        async function() {
-          const client = await this.initialize();
-          return client.callTool({
-            name,
-            arguments: args
-          });
-        },
-        this,
-        async (instance) => await instance.reinitialize(),
-        _optionalChain([this, 'access', _145 => _145.config, 'access', _146 => _146.retryOptions, 'optionalAccess', _147 => _147.maxRetries]) || 2
-      );
-      return await wrappedCall();
-    } catch (error) {
-      if (!(error instanceof McpError)) {
-        throw new McpError(
-          `Error calling tool "${name}": ${error instanceof Error ? error.message : String(error)}`,
-          "tool_execution_error" /* TOOL_EXECUTION_ERROR */,
-          error instanceof Error ? error : void 0
-        );
-      }
-      throw error;
-    }
+  incrementLlmCallCount() {
+    this._invocationCostManager.incrementAndEnforceLlmCallsLimit(
+      this.runConfig
+    );
   }
   /**
-   * Closes and cleans up all resources.
-   * Should be called when the service is no longer needed.
-   * Similar to Python's close() method.
+   * Creates a child invocation context for a sub-agent
    */
-  async close() {
-    this.logger.debug("\u{1F51A} Closing MCP client service");
-    await this.cleanupResources();
+  createChildContext(agent) {
+    return new _InvocationContext({
+      artifactService: this.artifactService,
+      sessionService: this.sessionService,
+      memoryService: this.memoryService,
+      invocationId: this.invocationId,
+      // Keep same invocation ID
+      branch: this.branch ? `${this.branch}.${agent.name}` : agent.name,
+      // Update branch
+      agent,
+      // Update to the new agent
+      userContent: this.userContent,
+      session: this.session,
+      endInvocation: this.endInvocation,
+      liveRequestQueue: this.liveRequestQueue,
+      activeStreamingTools: this.activeStreamingTools,
+      transcriptionCache: this.transcriptionCache,
+      runConfig: this.runConfig
+    });
   }
+}, _class14);
+
+// src/tools/common/agent-tool.ts
+init_base_tool();
+function isLlmAgent(agent) {
+  return true;
+}
+var AgentTool = (_class15 = class extends BaseTool {
   /**
-   * Checks if the client is currently connected
+   * The agent used by this tool
    */
-  isConnected() {
-    return !!this.client && !this.isClosing;
+  
+  /**
+   * The function declaration schema
+   */
+  
+  /**
+   * The key to store the tool output in the state
+   */
+  
+  /**
+   * Whether to skip summarization of the agent's response
+   */
+  
+  __init25() {this.logger = new Logger({ name: "AgentTool" })}
+  /**
+   * Create a new agent tool
+   */
+  constructor(config) {
+    super({
+      name: config.name,
+      description: config.description || config.agent.description,
+      isLongRunning: config.isLongRunning || false,
+      shouldRetryOnFailure: config.shouldRetryOnFailure || false,
+      maxRetryAttempts: config.maxRetryAttempts || 3
+    });_class15.prototype.__init25.call(this);;
+    this.agent = config.agent;
+    this.functionDeclaration = config.functionDeclaration;
+    this.outputKey = config.outputKey;
+    this.skipSummarization = config.skipSummarization || false;
   }
-  async setupSamplingHandler(client) {
-    if (!this.mcpSamplingHandler) {
-      this.logger.debug(
-        "\u26A0\uFE0F No sampling handler provided - sampling requests will be rejected"
-      );
-      return;
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    if (this.functionDeclaration) {
+      return this.functionDeclaration;
     }
-    try {
-      client.setRequestHandler(
-        _typesjs.CreateMessageRequestSchema,
-        async (request) => {
-          try {
-            this.logger.debug("Received sampling request:", request);
-            const response = await this.mcpSamplingHandler.handleSamplingRequest(request);
-            this.logger.debug("\u2705 Sampling request completed successfully");
-            return response;
-          } catch (error) {
-            this.logger.error("\u274C Error handling sampling request:", error);
-            if (error instanceof McpError) {
-              throw error;
-            }
-            throw new McpError(
-              `Sampling request failed: ${error instanceof Error ? error.message : String(error)}`,
-              "SAMPLING_ERROR" /* SAMPLING_ERROR */,
-              error instanceof Error ? error : void 0
-            );
+    const description = isLlmAgent(this.agent) ? typeof this.agent.instruction === "string" ? this.agent.instruction : this.description : this.description;
+    return {
+      name: this.name,
+      description,
+      parameters: {
+        type: _genai.Type.OBJECT,
+        properties: {
+          input: {
+            type: _genai.Type.STRING,
+            description: "The input to provide to the agent"
           }
+        },
+        required: ["input"]
+      }
+    };
+  }
+  /**
+   * Execute the tool by running the agent with the provided input
+   */
+  async runAsync(params, context4) {
+    try {
+      const input = params.input || Object.values(params)[0];
+      if (!isLlmAgent(this.agent)) {
+        throw new Error(
+          `Agent ${this.name} does not support running as a tool`
+        );
+      }
+      const parentInvocation = context4._invocationContext;
+      const childInvocationContext = new InvocationContext({
+        invocationId: _uuid.v4.call(void 0, ),
+        agent: this.agent,
+        session: parentInvocation.session,
+        artifactService: parentInvocation.artifactService,
+        sessionService: parentInvocation.sessionService,
+        memoryService: parentInvocation.memoryService,
+        runConfig: parentInvocation.runConfig,
+        userContent: {
+          role: "user",
+          parts: [{ text: String(input) }]
+        },
+        branch: parentInvocation.branch ? `${parentInvocation.branch}.${this.agent.name}` : this.agent.name
+      });
+      let lastEvent = null;
+      for await (const event of this.agent.runAsync(childInvocationContext)) {
+        if (!event.partial) {
+          await childInvocationContext.sessionService.appendEvent(
+            childInvocationContext.session,
+            event
+          );
         }
-      );
-      this.logger.debug("\u{1F3AF} Sampling handler registered successfully");
+        if (event.content && event.author === this.agent.name) {
+          lastEvent = event;
+        }
+      }
+      if (!lastEvent || !lastEvent.content || !lastEvent.content.parts) {
+        return "";
+      }
+      const mergedText = lastEvent.content.parts.filter((part) => part.text !== void 0 && part.text !== null).map((part) => part.text).join("\n");
+      let toolResult;
+      try {
+        toolResult = JSON.parse(mergedText);
+      } catch (e2) {
+        toolResult = mergedText;
+      }
+      if (this.outputKey && _optionalChain([context4, 'optionalAccess', _145 => _145.state])) {
+        context4.state[this.outputKey] = toolResult;
+      }
+      return toolResult;
     } catch (error) {
-      this.logger.error("Failed to setup sampling handler:", error);
-      this.logger.debug(
-        "\u26A0\uFE0F Sampling handler registration failed, continuing without sampling support"
+      this.logger.error(`Error executing agent tool ${this.name}:`, error);
+      throw new Error(
+        `Agent tool execution failed: ${error instanceof Error ? error.message : String(error)}`
       );
     }
   }
+}, _class15);
+
+// src/tools/tool-context.ts
+var ToolContext = class extends CallbackContext {
   /**
-   * Set a new ADK sampling handler
+   * The function call id of the current tool call. This id was
+   * returned in the function call event from LLM to identify a function call.
+   * If LLM didn't return this id, ADK will assign one to it. This id is used
+   * to map function call response to the original function call.
    */
-  setSamplingHandler(handler) {
-    this.mcpSamplingHandler = new McpSamplingHandler(handler);
-    if (this.client) {
-      this.setupSamplingHandler(this.client).catch((error) => {
-        this.logger.error("Failed to update ADK sampling handler:", error);
-      });
+  
+  /**
+   * Constructor for ToolContext
+   */
+  constructor(invocationContext, options = {}) {
+    super(invocationContext, { eventActions: options.eventActions });
+    this.functionCallId = options.functionCallId;
+  }
+  /**
+   * Gets the event actions of the current tool call
+   */
+  get actions() {
+    return this.eventActions;
+  }
+  /**
+   * Lists the filenames of the artifacts attached to the current session
+   */
+  async listArtifacts() {
+    if (!this._invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
     }
+    return await this._invocationContext.artifactService.listArtifactKeys({
+      appName: this._invocationContext.appName,
+      userId: this._invocationContext.userId,
+      sessionId: this._invocationContext.session.id
+    });
   }
   /**
-   * Remove the sampling handler
+   * Searches the memory of the current user
    */
-  removeSamplingHandler() {
-    this.mcpSamplingHandler = null;
-    if (this.client) {
-      try {
-        _optionalChain([this, 'access', _148 => _148.client, 'access', _149 => _149.removeRequestHandler, 'optionalCall', _150 => _150("sampling/createMessage")]);
-      } catch (error) {
-        this.logger.error("Failed to remove sampling handler:", error);
-      }
+  async searchMemory(query) {
+    if (!this._invocationContext.memoryService) {
+      throw new Error("Memory service is not available.");
     }
+    return await this._invocationContext.memoryService.searchMemory({
+      query,
+      appName: this._invocationContext.appName,
+      userId: this._invocationContext.userId
+    });
   }
-}, _class14);
+};
+
+// src/tools/index.ts
+init_function_tool();
+
+// src/tools/function/index.ts
+init_function_tool();
+init_function_utils();
+function createFunctionTool(func, options) {
+  const { FunctionTool: FunctionTool2 } = (init_function_tool(), __toCommonJS(function_tool_exports));
+  return new FunctionTool2(func, options);
+}
 
 // src/tools/index.ts
+init_function_utils();
+
+// src/tools/common/google-search.ts
+init_logger();
 init_base_tool();
 
-// src/tools/base/create-tool.ts
+var GoogleSearch = (_class16 = class extends BaseTool {
+  __init26() {this.logger = new Logger({ name: "GoogleSearch" })}
+  /**
+   * Constructor for GoogleSearch
+   */
+  constructor() {
+    super({
+      name: "google_search",
+      description: "Search the web using Google"
+    });_class16.prototype.__init26.call(this);;
+  }
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: _genai.Type.OBJECT,
+        properties: {
+          query: {
+            type: _genai.Type.STRING,
+            description: "The search query to execute"
+          },
+          num_results: {
+            type: _genai.Type.INTEGER,
+            description: "Number of results to return (max 10)",
+            default: 5
+          }
+        },
+        required: ["query"]
+      }
+    };
+  }
+  /**
+   * Execute the search
+   * This is a simplified implementation that doesn't actually search, just returns mock results
+   */
+  async runAsync(args, _context) {
+    this.logger.debug(
+      `[GoogleSearch] Executing Google search for: ${args.query}`
+    );
+    return {
+      results: [
+        {
+          title: `Result 1 for ${args.query}`,
+          link: "https://example.com/1",
+          snippet: `This is a sample result for the query "${args.query}".`
+        },
+        {
+          title: `Result 2 for ${args.query}`,
+          link: "https://example.com/2",
+          snippet: `Another sample result for "${args.query}".`
+        }
+      ]
+    };
+  }
+}, _class16);
+
+// src/tools/common/http-request-tool.ts
 init_base_tool();
-var _zod = require('zod'); var z = _interopRequireWildcard(_zod);
-var _zodtojsonschema = require('zod-to-json-schema');
-var CreatedTool = class extends BaseTool {
-  
-  
-  
-  constructor(config) {
+
+var HttpRequestTool = class extends BaseTool {
+  constructor() {
     super({
-      name: config.name,
-      description: config.description,
-      isLongRunning: _nullishCoalesce(config.isLongRunning, () => ( false)),
-      shouldRetryOnFailure: _nullishCoalesce(config.shouldRetryOnFailure, () => ( false)),
-      maxRetryAttempts: _nullishCoalesce(config.maxRetryAttempts, () => ( 3))
+      name: "http_request",
+      description: "Make HTTP requests to external APIs and web services"
     });
-    this.func = config.fn;
-    this.schema = _nullishCoalesce(config.schema, () => ( z.object({})));
-    this.functionDeclaration = this.buildDeclaration();
   }
   /**
-   * Executes the tool function with validation
+   * Get the function declaration for the tool
    */
-  async runAsync(args, context4) {
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: _genai.Type.OBJECT,
+        properties: {
+          url: {
+            type: _genai.Type.STRING,
+            description: "The URL to send the request to"
+          },
+          method: {
+            type: _genai.Type.STRING,
+            description: "The HTTP method to use (GET, POST, PUT, DELETE, etc.)",
+            enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
+            default: "GET"
+          },
+          headers: {
+            type: _genai.Type.OBJECT,
+            description: "Request headers to include"
+          },
+          body: {
+            type: _genai.Type.STRING,
+            description: "Request body content (as string, typically JSON)"
+          },
+          params: {
+            type: _genai.Type.OBJECT,
+            description: "URL query parameters to include"
+          },
+          timeout: {
+            type: _genai.Type.INTEGER,
+            description: "Request timeout in milliseconds",
+            default: 1e4
+          }
+        },
+        required: ["url"]
+      }
+    };
+  }
+  /**
+   * Execute the HTTP request
+   */
+  async runAsync(args, _context) {
     try {
-      const validatedArgs = this.schema.parse(args);
-      const result = await Promise.resolve(this.func(validatedArgs, context4));
-      return _nullishCoalesce(result, () => ( {}));
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        return {
-          error: `Invalid arguments for ${this.name}: ${error.message}`
-        };
+      const {
+        url,
+        method = "GET",
+        headers = {},
+        body,
+        params,
+        timeout = 1e4
+      } = args;
+      const urlObj = new URL(url);
+      if (params) {
+        Object.entries(params).forEach(([key, value]) => {
+          urlObj.searchParams.append(key, value);
+        });
+      }
+      const requestHeaders = { ...headers };
+      if (body && !requestHeaders["Content-Type"] && this.isValidJson(body)) {
+        requestHeaders["Content-Type"] = "application/json";
       }
+      const options = {
+        method,
+        headers: requestHeaders,
+        body,
+        signal: AbortSignal.timeout(timeout)
+      };
+      const response = await fetch(urlObj.toString(), options);
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      const responseBody = await response.text();
+      return {
+        statusCode: response.status,
+        headers: responseHeaders,
+        body: responseBody
+      };
+    } catch (error) {
       return {
-        error: `Error executing ${this.name}: ${error instanceof Error ? error.message : String(error)}`
+        statusCode: 0,
+        headers: {},
+        body: "",
+        error: error instanceof Error ? error.message : String(error)
       };
     }
   }
   /**
-   * Returns the function declaration for this tool
+   * Check if a string is valid JSON
    */
-  getDeclaration() {
-    return this.functionDeclaration;
+  isValidJson(str) {
+    try {
+      JSON.parse(str);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+};
+
+// src/tools/common/file-operations-tool.ts
+init_base_tool();
+var _promises = require('fs/promises'); var fs2 = _interopRequireWildcard(_promises);
+var _path = require('path'); var path2 = _interopRequireWildcard(_path);
+
+var FileOperationsTool = class extends BaseTool {
+  
+  constructor(options) {
+    super({
+      name: "file_operations",
+      description: "Perform file system operations like reading, writing, and managing files"
+    });
+    this.basePath = _optionalChain([options, 'optionalAccess', _146 => _146.basePath]) || process.cwd();
   }
   /**
-   * Builds the function declaration from the Zod schema
+   * Get the function declaration for the tool
    */
-  buildDeclaration() {
-    const rawParameters = _zodtojsonschema.zodToJsonSchema.call(void 0, this.schema, {
-      target: "jsonSchema7",
-      $refStrategy: "none"
-    });
-    const { $schema, ...parameters } = rawParameters;
+  getDeclaration() {
     return {
       name: this.name,
       description: this.description,
-      parameters
+      parameters: {
+        type: _genai.Type.OBJECT,
+        properties: {
+          operation: {
+            type: _genai.Type.STRING,
+            description: "The file operation to perform",
+            enum: [
+              "read",
+              "write",
+              "append",
+              "delete",
+              "exists",
+              "list",
+              "mkdir"
+            ]
+          },
+          filepath: {
+            type: _genai.Type.STRING,
+            description: "Path to the file or directory (relative to the base path)"
+          },
+          content: {
+            type: _genai.Type.STRING,
+            description: "Content to write to the file (for write and append operations)"
+          },
+          encoding: {
+            type: _genai.Type.STRING,
+            description: "File encoding to use",
+            default: "utf8"
+          }
+        },
+        required: ["operation", "filepath"]
+      }
     };
   }
-};
-function createTool(config) {
-  return new CreatedTool(config);
-}
-
-// src/tools/common/agent-tool.ts
-init_logger();
-
-
-
-// src/agents/invocation-context.ts
-var LlmCallsLimitExceededError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "LlmCallsLimitExceededError";
-  }
-};
-var InvocationCostManager = (_class15 = class {constructor() { _class15.prototype.__init28.call(this); }
-  /**
-   * A counter that keeps track of number of llm calls made.
-   */
-  __init28() {this._numberOfLlmCalls = 0}
   /**
-   * Increments _numberOfLlmCalls and enforces the limit.
+   * Execute the file operation
    */
-  incrementAndEnforceLlmCallsLimit(runConfig) {
-    this._numberOfLlmCalls += 1;
-    if (runConfig && runConfig.maxLlmCalls > 0 && this._numberOfLlmCalls > runConfig.maxLlmCalls) {
-      throw new LlmCallsLimitExceededError(
-        `Max number of llm calls limit of \`${runConfig.maxLlmCalls}\` exceeded`
-      );
+  async runAsync(args, _context) {
+    try {
+      const resolvedPath = this.resolvePath(args.filepath);
+      this.validatePath(resolvedPath);
+      const encoding = args.encoding || "utf8";
+      switch (args.operation) {
+        case "read":
+          return await this.readFile(resolvedPath, encoding);
+        case "write":
+          return await this.writeFile(
+            resolvedPath,
+            args.content || "",
+            encoding
+          );
+        case "append":
+          return await this.appendFile(
+            resolvedPath,
+            args.content || "",
+            encoding
+          );
+        case "delete":
+          return await this.deleteFile(resolvedPath);
+        case "exists":
+          return await this.fileExists(resolvedPath);
+        case "list":
+          return await this.listDirectory(resolvedPath);
+        case "mkdir":
+          return await this.makeDirectory(resolvedPath);
+        default:
+          throw new Error(`Unsupported operation: ${args.operation}`);
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
   }
-}, _class15);
-function newInvocationContextId() {
-  return `e-${crypto.randomUUID()}`;
-}
-var InvocationContext = (_class16 = class _InvocationContext {
-  
-  
-  
-  /**
-   * The id of this invocation context. Readonly.
-   */
-  
-  /**
-   * The branch of the invocation context.
-   *
-   * The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of
-   * agent_2, and agent_2 is the parent of agent_3.
-   *
-   * Branch is used when multiple sub-agents shouldn't see their peer agents'
-   * conversation history.
-   */
-  
-  /**
-   * The current agent of this invocation context. Readonly.
-   */
-  
-  /**
-   * The user content that started this invocation. Readonly.
-   */
-  
-  /**
-   * The current session of this invocation context. Readonly.
-   */
-  
-  /**
-   * Whether to end this invocation.
-   *
-   * Set to True in callbacks or tools to terminate this invocation.
-   */
-  __init29() {this.endInvocation = false}
-  /**
-   * The queue to receive live requests.
-   */
-  
   /**
-   * The running streaming tools of this invocation.
+   * Resolve a file path relative to the base path
    */
-  
+  resolvePath(filepath) {
+    return path2.default.isAbsolute(filepath) ? filepath : path2.default.resolve(this.basePath, filepath);
+  }
   /**
-   * Caches necessary, data audio or contents, that are needed by transcription.
+   * Validate that a path is within the base path for security
    */
-  
+  validatePath(filepath) {
+    const normalizedPath = path2.default.normalize(filepath);
+    const normalizedBasePath = path2.default.normalize(this.basePath);
+    if (!normalizedPath.startsWith(normalizedBasePath)) {
+      throw new Error(
+        `Access denied: Can't access paths outside the base directory`
+      );
+    }
+  }
   /**
-   * Configurations for live agents under this invocation.
+   * Read a file
    */
-  
+  async readFile(filepath, encoding) {
+    try {
+      const content = await fs2.default.readFile(filepath, { encoding });
+      return {
+        success: true,
+        data: content
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
   /**
-   * A container to keep track of different kinds of costs incurred as a part
-   * of this invocation.
+   * Write to a file
    */
-  __init30() {this._invocationCostManager = new InvocationCostManager()}
+  async writeFile(filepath, content, encoding) {
+    try {
+      const dir = path2.default.dirname(filepath);
+      await fs2.default.mkdir(dir, { recursive: true });
+      await fs2.default.writeFile(filepath, content, { encoding });
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to write to file: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
   /**
-   * Constructor for InvocationContext
+   * Append to a file
    */
-  constructor(options) {;_class16.prototype.__init29.call(this);_class16.prototype.__init30.call(this);
-    this.artifactService = options.artifactService;
-    this.sessionService = options.sessionService;
-    this.memoryService = options.memoryService;
-    this.invocationId = options.invocationId || newInvocationContextId();
-    this.branch = options.branch;
-    this.agent = options.agent;
-    this.userContent = options.userContent;
-    this.session = options.session;
-    this.endInvocation = options.endInvocation || false;
-    this.liveRequestQueue = options.liveRequestQueue;
-    this.activeStreamingTools = options.activeStreamingTools;
-    this.transcriptionCache = options.transcriptionCache;
-    this.runConfig = options.runConfig;
+  async appendFile(filepath, content, encoding) {
+    try {
+      const dir = path2.default.dirname(filepath);
+      await fs2.default.mkdir(dir, { recursive: true });
+      await fs2.default.appendFile(filepath, content, { encoding });
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to append to file: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
   }
   /**
-   * App name from the session
+   * Delete a file
    */
-  get appName() {
-    return this.session.appName;
+  async deleteFile(filepath) {
+    try {
+      await fs2.default.unlink(filepath);
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to delete file: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
   }
   /**
-   * User ID from the session
+   * Check if a file exists
    */
-  get userId() {
-    return this.session.userId;
+  async fileExists(filepath) {
+    try {
+      await fs2.default.access(filepath);
+      return {
+        success: true,
+        data: true
+      };
+    } catch (e3) {
+      return {
+        success: true,
+        data: false
+      };
+    }
   }
   /**
-   * Tracks number of llm calls made.
-   *
-   * @throws {LlmCallsLimitExceededError} If number of llm calls made exceed the set threshold.
+   * List directory contents
    */
-  incrementLlmCallCount() {
-    this._invocationCostManager.incrementAndEnforceLlmCallsLimit(
-      this.runConfig
-    );
+  async listDirectory(dirpath) {
+    try {
+      const entries = await fs2.default.readdir(dirpath, { withFileTypes: true });
+      const results = await Promise.all(
+        entries.map(async (entry) => {
+          const entryPath = path2.default.join(dirpath, entry.name);
+          const stats = await fs2.default.stat(entryPath);
+          return {
+            name: entry.name,
+            path: entryPath,
+            isFile: entry.isFile(),
+            isDirectory: entry.isDirectory(),
+            size: stats.size,
+            created: stats.birthtime,
+            modified: stats.mtime
+          };
+        })
+      );
+      return {
+        success: true,
+        data: results
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to list directory: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
   }
   /**
-   * Creates a child invocation context for a sub-agent
+   * Create a directory
    */
-  createChildContext(agent) {
-    return new _InvocationContext({
-      artifactService: this.artifactService,
-      sessionService: this.sessionService,
-      memoryService: this.memoryService,
-      invocationId: this.invocationId,
-      // Keep same invocation ID
-      branch: this.branch ? `${this.branch}.${agent.name}` : agent.name,
-      // Update branch
-      agent,
-      // Update to the new agent
-      userContent: this.userContent,
-      session: this.session,
-      endInvocation: this.endInvocation,
-      liveRequestQueue: this.liveRequestQueue,
-      activeStreamingTools: this.activeStreamingTools,
-      transcriptionCache: this.transcriptionCache,
-      runConfig: this.runConfig
-    });
+  async makeDirectory(dirpath) {
+    try {
+      await fs2.default.mkdir(dirpath, { recursive: true });
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to create directory: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
   }
-}, _class16);
+};
 
-// src/tools/common/agent-tool.ts
+// src/tools/common/user-interaction-tool.ts
 init_base_tool();
-function isLlmAgent(agent) {
-  return true;
-}
-var AgentTool = (_class17 = class extends BaseTool {
-  /**
-   * The agent used by this tool
-   */
-  
-  /**
-   * The function declaration schema
-   */
-  
-  /**
-   * The key to store the tool output in the state
-   */
-  
-  /**
-   * Whether to skip summarization of the agent's response
-   */
-  
-  __init31() {this.logger = new Logger({ name: "AgentTool" })}
-  /**
-   * Create a new agent tool
-   */
-  constructor(config) {
+
+var UserInteractionTool = class extends BaseTool {
+  constructor() {
     super({
-      name: config.name,
-      description: config.description || config.agent.description,
-      isLongRunning: config.isLongRunning || false,
-      shouldRetryOnFailure: config.shouldRetryOnFailure || false,
-      maxRetryAttempts: config.maxRetryAttempts || 3
-    });_class17.prototype.__init31.call(this);;
-    this.agent = config.agent;
-    this.functionDeclaration = config.functionDeclaration;
-    this.outputKey = config.outputKey;
-    this.skipSummarization = config.skipSummarization || false;
+      name: "user_interaction",
+      description: "Prompt the user for input during agent execution",
+      isLongRunning: true
+    });
   }
   /**
    * Get the function declaration for the tool
    */
   getDeclaration() {
-    if (this.functionDeclaration) {
-      return this.functionDeclaration;
-    }
-    const description = isLlmAgent(this.agent) ? typeof this.agent.instruction === "string" ? this.agent.instruction : this.description : this.description;
     return {
       name: this.name,
-      description,
+      description: this.description,
       parameters: {
         type: _genai.Type.OBJECT,
         properties: {
-          input: {
+          prompt: {
             type: _genai.Type.STRING,
-            description: "The input to provide to the agent"
-          }
-        },
-        required: ["input"]
-      }
-    };
-  }
-  /**
-   * Execute the tool by running the agent with the provided input
-   */
-  async runAsync(params, context4) {
-    try {
-      const input = params.input || Object.values(params)[0];
-      if (!isLlmAgent(this.agent)) {
-        throw new Error(
-          `Agent ${this.name} does not support running as a tool`
-        );
-      }
-      const parentInvocation = context4._invocationContext;
-      const childInvocationContext = new InvocationContext({
-        invocationId: _uuid.v4.call(void 0, ),
-        agent: this.agent,
-        session: parentInvocation.session,
-        artifactService: parentInvocation.artifactService,
-        sessionService: parentInvocation.sessionService,
-        memoryService: parentInvocation.memoryService,
-        runConfig: parentInvocation.runConfig,
-        userContent: {
-          role: "user",
-          parts: [{ text: String(input) }]
-        },
-        branch: parentInvocation.branch ? `${parentInvocation.branch}.${this.agent.name}` : this.agent.name
-      });
-      let lastEvent = null;
-      for await (const event of this.agent.runAsync(childInvocationContext)) {
-        if (!event.partial) {
-          await childInvocationContext.sessionService.appendEvent(
-            childInvocationContext.session,
-            event
-          );
-        }
-        if (event.content && event.author === this.agent.name) {
-          lastEvent = event;
-        }
-      }
-      if (!lastEvent || !lastEvent.content || !lastEvent.content.parts) {
-        return "";
-      }
-      const mergedText = lastEvent.content.parts.filter((part) => part.text !== void 0 && part.text !== null).map((part) => part.text).join("\n");
-      let toolResult;
-      try {
-        toolResult = JSON.parse(mergedText);
-      } catch (e2) {
-        toolResult = mergedText;
-      }
-      if (this.outputKey && _optionalChain([context4, 'optionalAccess', _151 => _151.state])) {
-        context4.state[this.outputKey] = toolResult;
-      }
-      return toolResult;
-    } catch (error) {
-      this.logger.error(`Error executing agent tool ${this.name}:`, error);
-      throw new Error(
-        `Agent tool execution failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-}, _class17);
-
-// src/tools/tool-context.ts
-var ToolContext = class extends CallbackContext {
-  /**
-   * The function call id of the current tool call. This id was
-   * returned in the function call event from LLM to identify a function call.
-   * If LLM didn't return this id, ADK will assign one to it. This id is used
-   * to map function call response to the original function call.
-   */
-  
-  /**
-   * Constructor for ToolContext
-   */
-  constructor(invocationContext, options = {}) {
-    super(invocationContext, { eventActions: options.eventActions });
-    this.functionCallId = options.functionCallId;
+            description: "The prompt message to display to the user"
+          },
+          options: {
+            type: _genai.Type.ARRAY,
+            description: "Optional array of choices to present to the user",
+            items: {
+              type: _genai.Type.STRING
+            }
+          },
+          defaultValue: {
+            type: _genai.Type.STRING,
+            description: "Optional default value for the input field"
+          }
+        },
+        required: ["prompt"]
+      }
+    };
   }
   /**
-   * Gets the event actions of the current tool call
+   * Execute the user interaction
    */
-  get actions() {
-    return this.eventActions;
+  async runAsync(args, context4) {
+    try {
+      const actions = context4.actions;
+      if (!actions || !actions.promptUser) {
+        return {
+          success: false,
+          error: "User interaction is not supported in the current environment"
+        };
+      }
+      if (actions.skipSummarization) {
+        actions.skipSummarization(true);
+      }
+      const promptOptions = args.options && args.options.length > 0 ? {
+        choices: args.options
+      } : void 0;
+      const response = await actions.promptUser({
+        prompt: args.prompt,
+        defaultValue: args.defaultValue,
+        options: promptOptions
+      });
+      return {
+        success: true,
+        userInput: response
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
   }
+};
+
+// src/tools/common/exit-loop-tool.ts
+init_logger();
+init_base_tool();
+var ExitLoopTool = (_class17 = class extends BaseTool {
+  __init27() {this.logger = new Logger({ name: "ExitLoopTool" })}
   /**
-   * Lists the filenames of the artifacts attached to the current session
+   * Constructor for ExitLoopTool
    */
-  async listArtifacts() {
-    if (!this._invocationContext.artifactService) {
-      throw new Error("Artifact service is not initialized.");
-    }
-    return await this._invocationContext.artifactService.listArtifactKeys({
-      appName: this._invocationContext.appName,
-      userId: this._invocationContext.userId,
-      sessionId: this._invocationContext.session.id
-    });
+  constructor() {
+    super({
+      name: "exit_loop",
+      description: "Exits the loop. Call this function only when you are instructed to do so."
+    });_class17.prototype.__init27.call(this);;
   }
   /**
-   * Searches the memory of the current user
+   * Execute the exit loop action
    */
-  async searchMemory(query) {
-    if (!this._invocationContext.memoryService) {
-      throw new Error("Memory service is not available.");
-    }
-    return await this._invocationContext.memoryService.searchMemory({
-      query,
-      appName: this._invocationContext.appName,
-      userId: this._invocationContext.userId
-    });
+  async runAsync(_args, context4) {
+    this.logger.debug("Executing exit loop tool");
+    context4.actions.escalate = true;
   }
-};
-
-// src/tools/index.ts
-init_function_tool();
-
-// src/tools/function/index.ts
-init_function_tool();
-init_function_utils();
-function createFunctionTool(func, options) {
-  const { FunctionTool: FunctionTool2 } = (init_function_tool(), __toCommonJS(function_tool_exports));
-  return new FunctionTool2(func, options);
-}
-
-// src/tools/index.ts
-init_function_utils();
+}, _class17);
 
-// src/tools/common/google-search.ts
+// src/tools/common/get-user-choice-tool.ts
 init_logger();
 init_base_tool();
 
-var GoogleSearch = (_class18 = class extends BaseTool {
-  __init32() {this.logger = new Logger({ name: "GoogleSearch" })}
+var GetUserChoiceTool = (_class18 = class extends BaseTool {
+  __init28() {this.logger = new Logger({ name: "GetUserChoiceTool" })}
   /**
-   * Constructor for GoogleSearch
+   * Constructor for GetUserChoiceTool
    */
   constructor() {
     super({
-      name: "google_search",
-      description: "Search the web using Google"
-    });_class18.prototype.__init32.call(this);;
+      name: "get_user_choice",
+      description: "This tool provides the options to the user and asks them to choose one. Use this tool when you need the user to make a selection between multiple options. Do not list options in your response - use this tool instead.",
+      isLongRunning: true
+    });_class18.prototype.__init28.call(this);;
   }
   /**
    * Get the function declaration for the tool
@@ -4868,54 +4871,53 @@ var GoogleSearch = (_class18 = class extends BaseTool {
       parameters: {
         type: _genai.Type.OBJECT,
         properties: {
-          query: {
-            type: _genai.Type.STRING,
-            description: "The search query to execute"
+          options: {
+            type: _genai.Type.ARRAY,
+            description: "List of options for the user to choose from",
+            items: {
+              type: _genai.Type.STRING
+            }
           },
-          num_results: {
-            type: _genai.Type.INTEGER,
-            description: "Number of results to return (max 10)",
-            default: 5
+          question: {
+            type: _genai.Type.STRING,
+            description: "The question or prompt to show the user before presenting options"
           }
         },
-        required: ["query"]
+        required: ["options"]
       }
     };
   }
   /**
-   * Execute the search
-   * This is a simplified implementation that doesn't actually search, just returns mock results
+   * Execute the user choice action
+   * This is a long running operation that will return null initially
+   * and the actual choice will be provided asynchronously
    */
-  async runAsync(args, _context) {
+  async runAsync(args, context4) {
     this.logger.debug(
-      `[GoogleSearch] Executing Google search for: ${args.query}`
+      `Executing get_user_choice with options: ${args.options.join(", ")}`
     );
-    return {
-      results: [
-        {
-          title: `Result 1 for ${args.query}`,
-          link: "https://example.com/1",
-          snippet: `This is a sample result for the query "${args.query}".`
-        },
-        {
-          title: `Result 2 for ${args.query}`,
-          link: "https://example.com/2",
-          snippet: `Another sample result for "${args.query}".`
-        }
-      ]
-    };
+    if (args.question) {
+      this.logger.debug(`Question: ${args.question}`);
+    }
+    context4.actions.skipSummarization = true;
+    return null;
   }
 }, _class18);
 
-// src/tools/common/http-request-tool.ts
+// src/tools/common/transfer-to-agent-tool.ts
+init_logger();
 init_base_tool();
 
-var HttpRequestTool = class extends BaseTool {
+var TransferToAgentTool = (_class19 = class extends BaseTool {
+  __init29() {this.logger = new Logger({ name: "TransferToAgentTool" })}
+  /**
+   * Constructor for TransferToAgentTool
+   */
   constructor() {
     super({
-      name: "http_request",
-      description: "Make HTTP requests to external APIs and web services"
-    });
+      name: "transfer_to_agent",
+      description: "Transfer the question to another agent when it's more suitable to answer the user's question according to the agent's description. Use this function when you determine that another agent in the system would be better equipped to handle the user's request based on their specialized capabilities and expertise areas."
+    });_class19.prototype.__init29.call(this);;
   }
   /**
    * Get the function declaration for the tool
@@ -4927,113 +4929,38 @@ var HttpRequestTool = class extends BaseTool {
       parameters: {
         type: _genai.Type.OBJECT,
         properties: {
-          url: {
-            type: _genai.Type.STRING,
-            description: "The URL to send the request to"
-          },
-          method: {
-            type: _genai.Type.STRING,
-            description: "The HTTP method to use (GET, POST, PUT, DELETE, etc.)",
-            enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
-            default: "GET"
-          },
-          headers: {
-            type: _genai.Type.OBJECT,
-            description: "Request headers to include"
-          },
-          body: {
+          agent_name: {
             type: _genai.Type.STRING,
-            description: "Request body content (as string, typically JSON)"
-          },
-          params: {
-            type: _genai.Type.OBJECT,
-            description: "URL query parameters to include"
-          },
-          timeout: {
-            type: _genai.Type.INTEGER,
-            description: "Request timeout in milliseconds",
-            default: 1e4
+            description: "The name of the agent to transfer control to"
           }
         },
-        required: ["url"]
+        required: ["agent_name"]
       }
     };
   }
   /**
-   * Execute the HTTP request
-   */
-  async runAsync(args, _context) {
-    try {
-      const {
-        url,
-        method = "GET",
-        headers = {},
-        body,
-        params,
-        timeout = 1e4
-      } = args;
-      const urlObj = new URL(url);
-      if (params) {
-        Object.entries(params).forEach(([key, value]) => {
-          urlObj.searchParams.append(key, value);
-        });
-      }
-      const requestHeaders = { ...headers };
-      if (body && !requestHeaders["Content-Type"] && this.isValidJson(body)) {
-        requestHeaders["Content-Type"] = "application/json";
-      }
-      const options = {
-        method,
-        headers: requestHeaders,
-        body,
-        signal: AbortSignal.timeout(timeout)
-      };
-      const response = await fetch(urlObj.toString(), options);
-      const responseHeaders = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-      });
-      const responseBody = await response.text();
-      return {
-        statusCode: response.status,
-        headers: responseHeaders,
-        body: responseBody
-      };
-    } catch (error) {
-      return {
-        statusCode: 0,
-        headers: {},
-        body: "",
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  /**
-   * Check if a string is valid JSON
+   * Execute the transfer to agent action
    */
-  isValidJson(str) {
-    try {
-      JSON.parse(str);
-      return true;
-    } catch (e) {
-      return false;
-    }
+  async runAsync(args, context4) {
+    this.logger.debug(`Executing transfer to agent: ${args.agent_name}`);
+    context4.actions.transferToAgent = args.agent_name;
   }
-};
+}, _class19);
 
-// src/tools/common/file-operations-tool.ts
+// src/tools/common/load-memory-tool.ts
+init_logger();
 init_base_tool();
-var _promises = require('fs/promises'); var fs2 = _interopRequireWildcard(_promises);
-var _path = require('path'); var path2 = _interopRequireWildcard(_path);
 
-var FileOperationsTool = class extends BaseTool {
-  
-  constructor(options) {
+var LoadMemoryTool = (_class20 = class extends BaseTool {
+  __init30() {this.logger = new Logger({ name: "LoadMemoryTool" })}
+  /**
+   * Constructor for LoadMemoryTool
+   */
+  constructor() {
     super({
-      name: "file_operations",
-      description: "Perform file system operations like reading, writing, and managing files"
-    });
-    this.basePath = _optionalChain([options, 'optionalAccess', _152 => _152.basePath]) || process.cwd();
+      name: "load_memory",
+      description: "Loads the memory for the current user based on a query."
+    });_class20.prototype.__init30.call(this);;
   }
   /**
    * Get the function declaration for the tool
@@ -5045,601 +4972,672 @@ var FileOperationsTool = class extends BaseTool {
       parameters: {
         type: _genai.Type.OBJECT,
         properties: {
-          operation: {
-            type: _genai.Type.STRING,
-            description: "The file operation to perform",
-            enum: [
-              "read",
-              "write",
-              "append",
-              "delete",
-              "exists",
-              "list",
-              "mkdir"
-            ]
-          },
-          filepath: {
-            type: _genai.Type.STRING,
-            description: "Path to the file or directory (relative to the base path)"
-          },
-          content: {
-            type: _genai.Type.STRING,
-            description: "Content to write to the file (for write and append operations)"
-          },
-          encoding: {
+          query: {
             type: _genai.Type.STRING,
-            description: "File encoding to use",
-            default: "utf8"
+            description: "The query to load memories for"
           }
         },
-        required: ["operation", "filepath"]
+        required: ["query"]
       }
     };
   }
   /**
-   * Execute the file operation
-   */
-  async runAsync(args, _context) {
-    try {
-      const resolvedPath = this.resolvePath(args.filepath);
-      this.validatePath(resolvedPath);
-      const encoding = args.encoding || "utf8";
-      switch (args.operation) {
-        case "read":
-          return await this.readFile(resolvedPath, encoding);
-        case "write":
-          return await this.writeFile(
-            resolvedPath,
-            args.content || "",
-            encoding
-          );
-        case "append":
-          return await this.appendFile(
-            resolvedPath,
-            args.content || "",
-            encoding
-          );
-        case "delete":
-          return await this.deleteFile(resolvedPath);
-        case "exists":
-          return await this.fileExists(resolvedPath);
-        case "list":
-          return await this.listDirectory(resolvedPath);
-        case "mkdir":
-          return await this.makeDirectory(resolvedPath);
-        default:
-          throw new Error(`Unsupported operation: ${args.operation}`);
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  /**
-   * Resolve a file path relative to the base path
-   */
-  resolvePath(filepath) {
-    return path2.default.isAbsolute(filepath) ? filepath : path2.default.resolve(this.basePath, filepath);
-  }
-  /**
-   * Validate that a path is within the base path for security
-   */
-  validatePath(filepath) {
-    const normalizedPath = path2.default.normalize(filepath);
-    const normalizedBasePath = path2.default.normalize(this.basePath);
-    if (!normalizedPath.startsWith(normalizedBasePath)) {
-      throw new Error(
-        `Access denied: Can't access paths outside the base directory`
-      );
-    }
-  }
-  /**
-   * Read a file
+   * Execute the memory loading action
    */
-  async readFile(filepath, encoding) {
+  async runAsync(args, context4) {
+    this.logger.debug(`Executing load_memory with query: ${args.query}`);
     try {
-      const content = await fs2.default.readFile(filepath, { encoding });
+      const searchResult = await context4.searchMemory(args.query);
       return {
-        success: true,
-        data: content
+        memories: searchResult.memories || [],
+        count: _optionalChain([searchResult, 'access', _147 => _147.memories, 'optionalAccess', _148 => _148.length]) || 0
       };
     } catch (error) {
+      console.error("Error searching memory:", error);
       return {
-        success: false,
-        error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`
+        error: "Memory search failed",
+        message: error instanceof Error ? error.message : String(error)
       };
     }
   }
-  /**
-   * Write to a file
-   */
-  async writeFile(filepath, content, encoding) {
-    try {
-      const dir = path2.default.dirname(filepath);
-      await fs2.default.mkdir(dir, { recursive: true });
-      await fs2.default.writeFile(filepath, content, { encoding });
-      return {
-        success: true
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Failed to write to file: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
+}, _class20);
+
+// src/tools/common/load-artifacts-tool.ts
+init_base_tool();
+
+var LoadArtifactsTool = class extends BaseTool {
+  constructor() {
+    super({
+      name: "load_artifacts",
+      description: "Loads the artifacts and adds them to the session."
+    });
   }
   /**
-   * Append to a file
+   * Get the function declaration for the tool
    */
-  async appendFile(filepath, content, encoding) {
-    try {
-      const dir = path2.default.dirname(filepath);
-      await fs2.default.mkdir(dir, { recursive: true });
-      await fs2.default.appendFile(filepath, content, { encoding });
-      return {
-        success: true
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Failed to append to file: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: _genai.Type.OBJECT,
+        properties: {
+          artifact_names: {
+            type: _genai.Type.ARRAY,
+            items: {
+              type: _genai.Type.STRING
+            },
+            description: "List of artifact names to load"
+          }
+        },
+        required: []
+      }
+    };
   }
   /**
-   * Delete a file
+   * Execute the load artifacts operation
    */
-  async deleteFile(filepath) {
-    try {
-      await fs2.default.unlink(filepath);
-      return {
-        success: true
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Failed to delete file: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
+  async runAsync(args, context4) {
+    const artifactNames = args.artifact_names || [];
+    return { artifact_names: artifactNames };
   }
   /**
-   * Check if a file exists
+   * Processes the outgoing LLM request for this tool.
    */
-  async fileExists(filepath) {
-    try {
-      await fs2.default.access(filepath);
-      return {
-        success: true,
-        data: true
-      };
-    } catch (e3) {
-      return {
-        success: true,
-        data: false
-      };
-    }
+  async processLlmRequest(toolContext, llmRequest) {
+    await super.processLlmRequest(toolContext, llmRequest);
+    await this.appendArtifactsToLlmRequest(toolContext, llmRequest);
   }
   /**
-   * List directory contents
+   * Appends artifacts information to the LLM request
    */
-  async listDirectory(dirpath) {
+  async appendArtifactsToLlmRequest(toolContext, llmRequest) {
     try {
-      const entries = await fs2.default.readdir(dirpath, { withFileTypes: true });
-      const results = await Promise.all(
-        entries.map(async (entry) => {
-          const entryPath = path2.default.join(dirpath, entry.name);
-          const stats = await fs2.default.stat(entryPath);
-          return {
-            name: entry.name,
-            path: entryPath,
-            isFile: entry.isFile(),
-            isDirectory: entry.isDirectory(),
-            size: stats.size,
-            created: stats.birthtime,
-            modified: stats.mtime
-          };
-        })
-      );
-      return {
-        success: true,
-        data: results
-      };
+      const artifactNames = await toolContext.listArtifacts();
+      if (!artifactNames || artifactNames.length === 0) {
+        return;
+      }
+      const instructions = [
+        `You have a list of artifacts:
+${JSON.stringify(artifactNames)}
+
+When the user asks questions about any of the artifacts, you should call the
+\`load_artifacts\` function to load the artifact. Do not generate any text other
+than the function call.
+`
+      ];
+      if (llmRequest.appendInstructions) {
+        llmRequest.appendInstructions(instructions);
+      }
+      if (llmRequest.contents && llmRequest.contents.length > 0) {
+        const lastContent = llmRequest.contents[llmRequest.contents.length - 1];
+        if (lastContent.parts && lastContent.parts.length > 0) {
+          const firstPart = lastContent.parts[0];
+          const functionResponse = this.extractFunctionResponse(firstPart);
+          if (functionResponse && functionResponse.name === "load_artifacts") {
+            const requestedArtifactNames = functionResponse.response.artifact_names || [];
+            for (const artifactName of requestedArtifactNames) {
+              try {
+                const artifact = await toolContext.loadArtifact(artifactName);
+                if (artifact) {
+                  llmRequest.contents.push({
+                    role: "user",
+                    parts: [
+                      {
+                        text: `Artifact ${artifactName} is:`
+                      },
+                      artifact
+                    ]
+                  });
+                }
+              } catch (error) {
+                console.error(
+                  `Failed to load artifact ${artifactName}:`,
+                  error
+                );
+              }
+            }
+          }
+        }
+      }
     } catch (error) {
-      return {
-        success: false,
-        error: `Failed to list directory: ${error instanceof Error ? error.message : String(error)}`
-      };
+      console.error("Error appending artifacts to LLM request:", error);
     }
   }
   /**
-   * Create a directory
+   * Extracts function response from a part if it exists
    */
-  async makeDirectory(dirpath) {
-    try {
-      await fs2.default.mkdir(dirpath, { recursive: true });
-      return {
-        success: true
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Failed to create directory: ${error instanceof Error ? error.message : String(error)}`
-      };
+  extractFunctionResponse(part) {
+    if ("functionResponse" in part && part.functionResponse) {
+      return part.functionResponse;
     }
+    return null;
   }
 };
 
-// src/tools/common/user-interaction-tool.ts
-init_base_tool();
+// src/tools/mcp/client.ts
+init_logger();
+var _indexjs = require('@modelcontextprotocol/sdk/client/index.js');
+var _ssejs = require('@modelcontextprotocol/sdk/client/sse.js');
+var _stdiojs = require('@modelcontextprotocol/sdk/client/stdio.js');
+var _typesjs = require('@modelcontextprotocol/sdk/types.js');
 
-var UserInteractionTool = class extends BaseTool {
-  constructor() {
-    super({
-      name: "user_interaction",
-      description: "Prompt the user for input during agent execution",
-      isLongRunning: true
-    });
+// src/tools/mcp/sampling-handler.ts
+init_logger();
+
+
+
+
+
+// src/tools/mcp/types.ts
+var McpErrorType = /* @__PURE__ */ ((McpErrorType2) => {
+  McpErrorType2["CONNECTION_ERROR"] = "connection_error";
+  McpErrorType2["TOOL_EXECUTION_ERROR"] = "tool_execution_error";
+  McpErrorType2["RESOURCE_CLOSED_ERROR"] = "resource_closed_error";
+  McpErrorType2["TIMEOUT_ERROR"] = "timeout_error";
+  McpErrorType2["INVALID_SCHEMA_ERROR"] = "invalid_schema_error";
+  McpErrorType2["SAMPLING_ERROR"] = "SAMPLING_ERROR";
+  McpErrorType2["INVALID_REQUEST_ERROR"] = "INVALID_REQUEST_ERROR";
+  return McpErrorType2;
+})(McpErrorType || {});
+var McpError = class extends Error {
+  
+  
+  constructor(message, type, originalError) {
+    super(message);
+    this.name = "McpError";
+    this.type = type;
+    this.originalError = originalError;
   }
-  /**
-   * Get the function declaration for the tool
-   */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: _genai.Type.OBJECT,
-        properties: {
-          prompt: {
-            type: _genai.Type.STRING,
-            description: "The prompt message to display to the user"
-          },
-          options: {
-            type: _genai.Type.ARRAY,
-            description: "Optional array of choices to present to the user",
-            items: {
-              type: _genai.Type.STRING
-            }
-          },
-          defaultValue: {
-            type: _genai.Type.STRING,
-            description: "Optional default value for the input field"
-          }
-        },
-        required: ["prompt"]
-      }
-    };
+};
+
+// src/tools/mcp/sampling-handler.ts
+var McpSamplingHandler = (_class21 = class {
+  __init31() {this.logger = new Logger({ name: "McpSamplingHandler" })}
+  
+  constructor(samplingHandler) {;_class21.prototype.__init31.call(this);
+    this.samplingHandler = samplingHandler;
   }
   /**
-   * Execute the user interaction
+   * Handle MCP sampling request and convert between formats
    */
-  async runAsync(args, context4) {
+  async handleSamplingRequest(request) {
     try {
-      const actions = context4.actions;
-      if (!actions || !actions.promptUser) {
-        return {
-          success: false,
-          error: "User interaction is not supported in the current environment"
-        };
+      if (request.method !== "sampling/createMessage") {
+        this.logger.error(
+          `Invalid method for sampling handler: ${request.method}. Expected: sampling/createMessage`
+        );
+        throw new McpError(
+          `Invalid method: ${request.method}. This handler only processes sampling/createMessage requests.`,
+          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
+        );
       }
-      if (actions.skipSummarization) {
-        actions.skipSummarization(true);
+      const validationResult = _typesjs.CreateMessageRequestSchema.safeParse(request);
+      if (!validationResult.success) {
+        this.logger.error(
+          "Invalid MCP sampling request:",
+          validationResult.error
+        );
+        throw new McpError(
+          `Invalid sampling request: ${validationResult.error.message}`,
+          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
+        );
       }
-      const promptOptions = args.options && args.options.length > 0 ? {
-        choices: args.options
-      } : void 0;
-      const response = await actions.promptUser({
-        prompt: args.prompt,
-        defaultValue: args.defaultValue,
-        options: promptOptions
+      const mcpParams = request.params;
+      if (!mcpParams.messages || !Array.isArray(mcpParams.messages)) {
+        throw new McpError(
+          "Invalid sampling request: messages array is required",
+          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
+        );
+      }
+      if (!mcpParams.maxTokens || mcpParams.maxTokens <= 0) {
+        throw new McpError(
+          "Invalid sampling request: maxTokens must be a positive number",
+          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
+        );
+      }
+      this.logger.debug("Converting MCP request to ADK format");
+      const adkContents = this.convertMcpMessagesToADK(
+        mcpParams.messages,
+        mcpParams.systemPrompt
+      );
+      const requestModel = mcpParams.model || "gemini-2.0-flash";
+      const adkRequest = new LlmRequest({
+        model: requestModel,
+        contents: adkContents,
+        config: {
+          temperature: mcpParams.temperature,
+          maxOutputTokens: mcpParams.maxTokens
+        }
       });
-      return {
-        success: true,
-        userInput: response
-      };
+      this.logger.debug("Calling ADK sampling handler");
+      const adkResponse = await this.samplingHandler(adkRequest);
+      this.logger.debug("Converting ADK response to MCP format");
+      const mcpResponse = this.convertADKResponseToMcp(
+        adkResponse,
+        requestModel
+      );
+      const responseValidation = _typesjs.CreateMessageResultSchema.safeParse(mcpResponse);
+      if (!responseValidation.success) {
+        this.logger.error(
+          "Invalid MCP response generated:",
+          responseValidation.error
+        );
+        throw new McpError(
+          `Invalid response generated: ${responseValidation.error.message}`,
+          "SAMPLING_ERROR" /* SAMPLING_ERROR */
+        );
+      }
+      return mcpResponse;
     } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
+      this.logger.error("Error handling sampling request:", error);
+      if (error instanceof McpError) {
+        throw error;
+      }
+      throw new McpError(
+        `Sampling request failed: ${error instanceof Error ? error.message : String(error)}`,
+        "SAMPLING_ERROR" /* SAMPLING_ERROR */,
+        error instanceof Error ? error : void 0
+      );
     }
   }
-};
-
-// src/tools/common/exit-loop-tool.ts
-init_logger();
-init_base_tool();
-var ExitLoopTool = (_class19 = class extends BaseTool {
-  __init33() {this.logger = new Logger({ name: "ExitLoopTool" })}
   /**
-   * Constructor for ExitLoopTool
+   * Convert MCP messages to ADK Content format
    */
-  constructor() {
-    super({
-      name: "exit_loop",
-      description: "Exits the loop. Call this function only when you are instructed to do so."
-    });_class19.prototype.__init33.call(this);;
+  convertMcpMessagesToADK(mcpMessages, systemPrompt) {
+    const contents = [];
+    if (systemPrompt) {
+      contents.push({
+        role: "user",
+        // System messages are typically sent as user role in content
+        parts: [{ text: systemPrompt }]
+      });
+    }
+    const transformedMessages = mcpMessages.map(
+      (mcpMessage) => this.convertSingleMcpMessageToADK(mcpMessage)
+    );
+    contents.push(...transformedMessages);
+    return contents;
   }
   /**
-   * Execute the exit loop action
+   * Convert a single MCP message to ADK Content format
    */
-  async runAsync(_args, context4) {
-    this.logger.debug("Executing exit loop tool");
-    context4.actions.escalate = true;
+  convertSingleMcpMessageToADK(mcpMessage) {
+    const adkRole = mcpMessage.role === "assistant" ? "model" : "user";
+    const adkParts = this.convertMcpContentToADKParts(mcpMessage.content);
+    const adkContent = {
+      role: adkRole,
+      parts: adkParts
+    };
+    this.logger.debug(
+      `Converted MCP message - role: ${mcpMessage.role} -> ${adkRole}, content type: ${mcpMessage.content.type}`
+    );
+    return adkContent;
   }
-}, _class19);
-
-// src/tools/common/get-user-choice-tool.ts
-init_logger();
-init_base_tool();
-
-var GetUserChoiceTool = (_class20 = class extends BaseTool {
-  __init34() {this.logger = new Logger({ name: "GetUserChoiceTool" })}
   /**
-   * Constructor for GetUserChoiceTool
+   * Convert MCP message content to ADK parts format
    */
-  constructor() {
-    super({
-      name: "get_user_choice",
-      description: "This tool provides the options to the user and asks them to choose one. Use this tool when you need the user to make a selection between multiple options. Do not list options in your response - use this tool instead.",
-      isLongRunning: true
-    });_class20.prototype.__init34.call(this);;
+  convertMcpContentToADKParts(mcpContent) {
+    if (mcpContent.type === "text") {
+      const textContent = mcpContent.text || "";
+      return [{ text: textContent }];
+    }
+    if (mcpContent.type === "image") {
+      const parts = [];
+      if (mcpContent.text && typeof mcpContent.text === "string") {
+        parts.push({ text: mcpContent.text });
+      }
+      if (mcpContent.data && typeof mcpContent.data === "string") {
+        const mimeType = mcpContent.mimeType || "image/jpeg";
+        parts.push({
+          inlineData: {
+            data: mcpContent.data,
+            mimeType
+          }
+        });
+      }
+      return parts.length > 0 ? parts : [{ text: "" }];
+    }
+    this.logger.warn(`Unknown MCP content type: ${mcpContent.type}`);
+    const fallbackText = typeof mcpContent.data === "string" ? mcpContent.data : "";
+    return [{ text: fallbackText }];
   }
   /**
-   * Get the function declaration for the tool
+   * Convert ADK response to MCP response format
    */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: _genai.Type.OBJECT,
-        properties: {
-          options: {
-            type: _genai.Type.ARRAY,
-            description: "List of options for the user to choose from",
-            items: {
-              type: _genai.Type.STRING
-            }
-          },
-          question: {
-            type: _genai.Type.STRING,
-            description: "The question or prompt to show the user before presenting options"
-          }
-        },
-        required: ["options"]
+  convertADKResponseToMcp(adkResponse, model) {
+    let responseText = "";
+    if (typeof adkResponse === "string") {
+      responseText = adkResponse;
+    } else {
+      if (adkResponse.content) {
+        if (typeof adkResponse.content === "string") {
+          responseText = adkResponse.content;
+        } else if (adkResponse.content.parts) {
+          responseText = adkResponse.content.parts.map((part) => {
+            return typeof part.text === "string" ? part.text : "";
+          }).join("");
+        }
+      }
+    }
+    const mcpResponse = {
+      model,
+      // Use the model from the request
+      role: "assistant",
+      // ADK responses are always from assistant
+      content: {
+        type: "text",
+        text: responseText
       }
     };
+    this.logger.debug(`Received content: ${responseText}`);
+    return mcpResponse;
   }
   /**
-   * Execute the user choice action
-   * This is a long running operation that will return null initially
-   * and the actual choice will be provided asynchronously
+   * Update the ADK handler
    */
-  async runAsync(args, context4) {
-    this.logger.debug(
-      `Executing get_user_choice with options: ${args.options.join(", ")}`
-    );
-    if (args.question) {
-      this.logger.debug(`Question: ${args.question}`);
-    }
-    context4.actions.skipSummarization = true;
-    return null;
+  updateHandler(handler) {
+    this.samplingHandler = handler;
+    this.logger.debug("ADK sampling handler updated");
   }
-}, _class20);
+}, _class21);
+function createSamplingHandler(handler) {
+  return handler;
+}
 
-// src/tools/common/transfer-to-agent-tool.ts
-init_logger();
-init_base_tool();
+// src/tools/mcp/utils.ts
+function withRetry(fn, instance, reinitMethod, maxRetries = 1) {
+  return async (...args) => {
+    let attempt = 0;
+    while (attempt <= maxRetries) {
+      try {
+        return await fn.apply(instance, args);
+      } catch (error) {
+        const isClosedResourceError = error instanceof Error && (error.message.includes("closed") || error.message.includes("ECONNRESET") || error.message.includes("socket hang up"));
+        if (!isClosedResourceError || attempt >= maxRetries) {
+          throw error;
+        }
+        console.warn(
+          `Resource closed, reinitializing (attempt ${attempt + 1}/${maxRetries + 1})...`
+        );
+        try {
+          await reinitMethod(instance);
+        } catch (reinitError) {
+          console.error("Error reinitializing resources:", reinitError);
+          throw new Error(`Failed to reinitialize resources: ${reinitError}`);
+        }
+        attempt++;
+      }
+    }
+    throw new Error("Unexpected end of retry loop");
+  };
+}
 
-var TransferToAgentTool = (_class21 = class extends BaseTool {
-  __init35() {this.logger = new Logger({ name: "TransferToAgentTool" })}
-  /**
-   * Constructor for TransferToAgentTool
-   */
-  constructor() {
-    super({
-      name: "transfer_to_agent",
-      description: "Transfer the question to another agent when it's more suitable to answer the user's question according to the agent's description. Use this function when you determine that another agent in the system would be better equipped to handle the user's request based on their specialized capabilities and expertise areas."
-    });_class21.prototype.__init35.call(this);;
+// src/tools/mcp/client.ts
+var McpClientService = (_class22 = class {
+  
+  __init32() {this.client = null}
+  __init33() {this.transport = null}
+  __init34() {this.isClosing = false}
+  __init35() {this.mcpSamplingHandler = null}
+  __init36() {this.logger = new Logger({ name: "McpClientService" })}
+  constructor(config) {;_class22.prototype.__init32.call(this);_class22.prototype.__init33.call(this);_class22.prototype.__init34.call(this);_class22.prototype.__init35.call(this);_class22.prototype.__init36.call(this);
+    this.config = config;
+    if (config.samplingHandler) {
+      this.mcpSamplingHandler = new McpSamplingHandler(config.samplingHandler);
+    }
   }
   /**
-   * Get the function declaration for the tool
+   * Initializes and returns an MCP client based on configuration.
+   * Will create a new client if one doesn't exist yet.
    */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: _genai.Type.OBJECT,
-        properties: {
-          agent_name: {
-            type: _genai.Type.STRING,
-            description: "The name of the agent to transfer control to"
-          }
+  async initialize() {
+    if (this.isClosing) {
+      throw new McpError(
+        "Cannot initialize a client that is being closed",
+        "resource_closed_error" /* RESOURCE_CLOSED_ERROR */
+      );
+    }
+    if (this.client) {
+      return this.client;
+    }
+    try {
+      if (!this.transport) {
+        this.transport = await this.createTransport();
+      }
+      const client = new (0, _indexjs.Client)(
+        {
+          name: this.config.name,
+          version: "0.0.1"
         },
-        required: ["agent_name"]
+        {
+          capabilities: {
+            prompts: {},
+            resources: {},
+            tools: {},
+            sampling: {}
+            // Enable sampling capability
+          }
+        }
+      );
+      const connectPromise = client.connect(this.transport);
+      if (this.config.timeout) {
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(
+              new McpError(
+                `MCP client connection timed out after ${this.config.timeout}ms`,
+                "timeout_error" /* TIMEOUT_ERROR */
+              )
+            );
+          }, this.config.timeout);
+        });
+        await Promise.race([connectPromise, timeoutPromise]);
+      } else {
+        await connectPromise;
       }
-    };
+      await this.setupSamplingHandler(client);
+      this.logger.debug("\u2705 MCP client connected successfully");
+      this.client = client;
+      return client;
+    } catch (error) {
+      await this.cleanupResources();
+      if (!(error instanceof McpError)) {
+        this.logger.error("Failed to initialize MCP client:", error);
+        throw new McpError(
+          `Failed to initialize MCP client: ${error instanceof Error ? error.message : String(error)}`,
+          "connection_error" /* CONNECTION_ERROR */,
+          error instanceof Error ? error : void 0
+        );
+      }
+      throw error;
+    }
   }
   /**
-   * Execute the transfer to agent action
+   * Creates a transport based on the configuration.
    */
-  async runAsync(args, context4) {
-    this.logger.debug(`Executing transfer to agent: ${args.agent_name}`);
-    context4.actions.transferToAgent = args.agent_name;
+  async createTransport() {
+    try {
+      if (this.config.transport.mode === "sse") {
+        this.logger.debug(
+          "\u{1F680} Initializing MCP client in SSE mode",
+          this.config.transport.serverUrl
+        );
+        const headers = {
+          ...this.config.transport.headers || {},
+          ...this.config.headers || {}
+        };
+        return new (0, _ssejs.SSEClientTransport)(
+          new URL(this.config.transport.serverUrl),
+          {
+            requestInit: {
+              headers,
+              ...this.config.timeout ? { timeout: this.config.timeout } : {}
+            }
+          }
+        );
+      }
+      this.logger.debug(
+        "\u{1F680} Initializing MCP client in STDIO mode",
+        this.config.transport.command
+      );
+      return new (0, _stdiojs.StdioClientTransport)({
+        command: this.config.transport.command,
+        args: this.config.transport.args,
+        env: this.config.transport.env
+      });
+    } catch (error) {
+      throw new McpError(
+        `Failed to create transport: ${error instanceof Error ? error.message : String(error)}`,
+        "connection_error" /* CONNECTION_ERROR */,
+        error instanceof Error ? error : void 0
+      );
+    }
   }
-}, _class21);
-
-// src/tools/common/load-memory-tool.ts
-init_logger();
-init_base_tool();
-
-var LoadMemoryTool = (_class22 = class extends BaseTool {
-  __init36() {this.logger = new Logger({ name: "LoadMemoryTool" })}
   /**
-   * Constructor for LoadMemoryTool
+   * Re-initializes the MCP client when a session is closed.
+   * Used by the retry mechanism.
    */
-  constructor() {
-    super({
-      name: "load_memory",
-      description: "Loads the memory for the current user based on a query."
-    });_class22.prototype.__init36.call(this);;
+  async reinitialize() {
+    this.logger.debug("\u{1F504} Reinitializing MCP client after closed connection");
+    await this.cleanupResources();
+    this.client = null;
+    this.transport = null;
+    await this.initialize();
   }
   /**
-   * Get the function declaration for the tool
+   * Cleans up resources associated with this client service.
+   * Similar to Python's AsyncExitStack.aclose() functionality.
    */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: _genai.Type.OBJECT,
-        properties: {
-          query: {
-            type: _genai.Type.STRING,
-            description: "The query to load memories for"
+  async cleanupResources() {
+    try {
+      this.isClosing = true;
+      if (this.client) {
+        try {
+          if (typeof this.client.close === "function") {
+            await this.client.close();
           }
-        },
-        required: ["query"]
+        } catch (err) {
+        }
       }
-    };
-  }
-  /**
-   * Execute the memory loading action
-   */
-  async runAsync(args, context4) {
-    this.logger.debug(`Executing load_memory with query: ${args.query}`);
-    try {
-      const searchResult = await context4.searchMemory(args.query);
-      return {
-        memories: searchResult.memories || [],
-        count: _optionalChain([searchResult, 'access', _153 => _153.memories, 'optionalAccess', _154 => _154.length]) || 0
-      };
+      if (this.transport && typeof this.transport.close === "function") {
+        await this.transport.close();
+      }
+      this.logger.debug("\u{1F9F9} Cleaned up MCP client resources");
     } catch (error) {
-      console.error("Error searching memory:", error);
-      return {
-        error: "Memory search failed",
-        message: error instanceof Error ? error.message : String(error)
-      };
+      this.logger.error("Error cleaning up MCP resources:", error);
+    } finally {
+      this.client = null;
+      this.transport = null;
+      this.isClosing = false;
     }
   }
-}, _class22);
-
-// src/tools/common/load-artifacts-tool.ts
-init_base_tool();
-
-var LoadArtifactsTool = class extends BaseTool {
-  constructor() {
-    super({
-      name: "load_artifacts",
-      description: "Loads the artifacts and adds them to the session."
-    });
-  }
   /**
-   * Get the function declaration for the tool
+   * Call an MCP tool with retry capability if the session is closed.
    */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: _genai.Type.OBJECT,
-        properties: {
-          artifact_names: {
-            type: _genai.Type.ARRAY,
-            items: {
-              type: _genai.Type.STRING
-            },
-            description: "List of artifact names to load"
-          }
+  async callTool(name, args) {
+    try {
+      const wrappedCall = withRetry(
+        async function() {
+          const client = await this.initialize();
+          return client.callTool({
+            name,
+            arguments: args
+          });
         },
-        required: []
+        this,
+        async (instance) => await instance.reinitialize(),
+        _optionalChain([this, 'access', _149 => _149.config, 'access', _150 => _150.retryOptions, 'optionalAccess', _151 => _151.maxRetries]) || 2
+      );
+      return await wrappedCall();
+    } catch (error) {
+      if (!(error instanceof McpError)) {
+        throw new McpError(
+          `Error calling tool "${name}": ${error instanceof Error ? error.message : String(error)}`,
+          "tool_execution_error" /* TOOL_EXECUTION_ERROR */,
+          error instanceof Error ? error : void 0
+        );
       }
-    };
+      throw error;
+    }
   }
   /**
-   * Execute the load artifacts operation
+   * Closes and cleans up all resources.
+   * Should be called when the service is no longer needed.
+   * Similar to Python's close() method.
    */
-  async runAsync(args, context4) {
-    const artifactNames = args.artifact_names || [];
-    return { artifact_names: artifactNames };
+  async close() {
+    this.logger.debug("\u{1F51A} Closing MCP client service");
+    await this.cleanupResources();
   }
   /**
-   * Processes the outgoing LLM request for this tool.
+   * Checks if the client is currently connected
    */
-  async processLlmRequest(toolContext, llmRequest) {
-    await super.processLlmRequest(toolContext, llmRequest);
-    await this.appendArtifactsToLlmRequest(toolContext, llmRequest);
+  isConnected() {
+    return !!this.client && !this.isClosing;
   }
-  /**
-   * Appends artifacts information to the LLM request
-   */
-  async appendArtifactsToLlmRequest(toolContext, llmRequest) {
+  async setupSamplingHandler(client) {
+    if (!this.mcpSamplingHandler) {
+      this.logger.debug(
+        "\u26A0\uFE0F No sampling handler provided - sampling requests will be rejected"
+      );
+      return;
+    }
     try {
-      const artifactNames = await toolContext.listArtifacts();
-      if (!artifactNames || artifactNames.length === 0) {
-        return;
-      }
-      const instructions = [
-        `You have a list of artifacts:
-${JSON.stringify(artifactNames)}
-
-When the user asks questions about any of the artifacts, you should call the
-\`load_artifacts\` function to load the artifact. Do not generate any text other
-than the function call.
-`
-      ];
-      if (llmRequest.appendInstructions) {
-        llmRequest.appendInstructions(instructions);
-      }
-      if (llmRequest.contents && llmRequest.contents.length > 0) {
-        const lastContent = llmRequest.contents[llmRequest.contents.length - 1];
-        if (lastContent.parts && lastContent.parts.length > 0) {
-          const firstPart = lastContent.parts[0];
-          const functionResponse = this.extractFunctionResponse(firstPart);
-          if (functionResponse && functionResponse.name === "load_artifacts") {
-            const requestedArtifactNames = functionResponse.response.artifact_names || [];
-            for (const artifactName of requestedArtifactNames) {
-              try {
-                const artifact = await toolContext.loadArtifact(artifactName);
-                if (artifact) {
-                  llmRequest.contents.push({
-                    role: "user",
-                    parts: [
-                      {
-                        text: `Artifact ${artifactName} is:`
-                      },
-                      artifact
-                    ]
-                  });
-                }
-              } catch (error) {
-                console.error(
-                  `Failed to load artifact ${artifactName}:`,
-                  error
-                );
-              }
+      client.setRequestHandler(
+        _typesjs.CreateMessageRequestSchema,
+        async (request) => {
+          try {
+            this.logger.debug("Received sampling request:", request);
+            const response = await this.mcpSamplingHandler.handleSamplingRequest(request);
+            this.logger.debug("\u2705 Sampling request completed successfully");
+            return response;
+          } catch (error) {
+            this.logger.error("\u274C Error handling sampling request:", error);
+            if (error instanceof McpError) {
+              throw error;
             }
+            throw new McpError(
+              `Sampling request failed: ${error instanceof Error ? error.message : String(error)}`,
+              "SAMPLING_ERROR" /* SAMPLING_ERROR */,
+              error instanceof Error ? error : void 0
+            );
           }
         }
-      }
+      );
+      this.logger.debug("\u{1F3AF} Sampling handler registered successfully");
     } catch (error) {
-      console.error("Error appending artifacts to LLM request:", error);
+      this.logger.error("Failed to setup sampling handler:", error);
+      this.logger.debug(
+        "\u26A0\uFE0F Sampling handler registration failed, continuing without sampling support"
+      );
     }
   }
   /**
-   * Extracts function response from a part if it exists
+   * Set a new ADK sampling handler
    */
-  extractFunctionResponse(part) {
-    if ("functionResponse" in part && part.functionResponse) {
-      return part.functionResponse;
+  setSamplingHandler(handler) {
+    this.mcpSamplingHandler = new McpSamplingHandler(handler);
+    if (this.client) {
+      this.setupSamplingHandler(this.client).catch((error) => {
+        this.logger.error("Failed to update ADK sampling handler:", error);
+      });
     }
-    return null;
   }
-};
+  /**
+   * Remove the sampling handler
+   */
+  removeSamplingHandler() {
+    this.mcpSamplingHandler = null;
+    if (this.client) {
+      try {
+        _optionalChain([this, 'access', _152 => _152.client, 'access', _153 => _153.removeRequestHandler, 'optionalCall', _154 => _154("sampling/createMessage")]);
+      } catch (error) {
+        this.logger.error("Failed to remove sampling handler:", error);
+      }
+    }
+  }
+}, _class22);
 
 // src/tools/mcp/create-tool.ts
 init_logger();
@@ -5818,7 +5816,7 @@ function mcpSchemaToParameters(mcpTool) {
 }
 
 // src/tools/mcp/create-tool.ts
-async function createTool2(mcpTool, client) {
+async function convertMcpToolToBaseTool(mcpTool, client) {
   try {
     return new McpToolAdapter(mcpTool, client);
   } catch (error) {
@@ -5848,7 +5846,7 @@ var McpToolAdapter = (_class23 = class extends BaseTool {
     });_class23.prototype.__init37.call(this);_class23.prototype.__init38.call(this);;
     this.mcpTool = mcpTool;
     this.client = client;
-    if (client.reinitialize && typeof client.reinitialize === "function") {
+    if (client && client.reinitialize && typeof client.reinitialize === "function") {
       this.clientService = client;
     }
   }
@@ -6160,7 +6158,10 @@ var McpToolset = (_class24 = class {
       for (const mcpTool of toolsResponse.tools) {
         if (this.isSelected(mcpTool, context4)) {
           try {
-            const tool = await createTool2(mcpTool, client);
+            const tool = await convertMcpToolToBaseTool(
+              mcpTool,
+              client
+            );
             tools.push(tool);
           } catch (toolError) {
             console.error(
@@ -13323,4 +13324,4 @@ var VERSION = "0.1.0";
 
 
 
-exports.AF_FUNCTION_CALL_ID_PREFIX = AF_FUNCTION_CALL_ID_PREFIX; exports.Agent = LlmAgent; exports.AgentBuilder = AgentBuilder; exports.AgentEvaluator = AgentEvaluator; exports.AgentTool = AgentTool; exports.Agents = agents_exports; exports.AiSdkLlm = AiSdkLlm; exports.AnthropicLlm = AnthropicLlm; exports.ApiKeyCredential = ApiKeyCredential; exports.ApiKeyScheme = ApiKeyScheme; exports.AuthConfig = AuthConfig; exports.AuthCredential = AuthCredential; exports.AuthCredentialType = AuthCredentialType; exports.AuthHandler = AuthHandler; exports.AuthScheme = AuthScheme; exports.AuthSchemeType = AuthSchemeType; exports.AuthTool = AuthTool; exports.AutoFlow = AutoFlow; exports.BaseAgent = BaseAgent; exports.BaseCodeExecutor = BaseCodeExecutor; exports.BaseLLMConnection = BaseLLMConnection; exports.BaseLlm = BaseLlm; exports.BaseLlmFlow = BaseLlmFlow; exports.BaseLlmRequestProcessor = BaseLlmRequestProcessor; exports.BaseLlmResponseProcessor = BaseLlmResponseProcessor; exports.BasePlanner = BasePlanner; exports.BaseSessionService = BaseSessionService; exports.BaseTool = BaseTool; exports.BasicAuthCredential = BasicAuthCredential; exports.BearerTokenCredential = BearerTokenCredential; exports.BuiltInCodeExecutor = BuiltInCodeExecutor; exports.BuiltInPlanner = BuiltInPlanner; exports.CallbackContext = CallbackContext; exports.CodeExecutionUtils = CodeExecutionUtils; exports.CodeExecutorContext = CodeExecutorContext; exports.DatabaseSessionService = DatabaseSessionService; exports.EnhancedAuthConfig = EnhancedAuthConfig; exports.EvalResult = EvalResult; exports.EvalStatus = EvalStatus; exports.Evaluation = evaluation_exports; exports.Evaluator = Evaluator; exports.Event = Event; exports.EventActions = EventActions; exports.Events = events_exports; exports.ExitLoopTool = ExitLoopTool; exports.FileOperationsTool = FileOperationsTool; exports.FinalResponseMatchV2Evaluator = FinalResponseMatchV2Evaluator; exports.Flows = flows_exports; exports.FunctionTool = FunctionTool; exports.GcsArtifactService = GcsArtifactService; exports.GetUserChoiceTool = GetUserChoiceTool; exports.GoogleLlm = GoogleLlm; exports.GoogleSearch = GoogleSearch; exports.HttpRequestTool = HttpRequestTool; exports.HttpScheme = HttpScheme; exports.InMemoryArtifactService = InMemoryArtifactService; exports.InMemoryMemoryService = InMemoryMemoryService; exports.InMemoryRunner = InMemoryRunner; exports.InMemorySessionService = InMemorySessionService; exports.InvocationContext = InvocationContext; exports.LLMRegistry = LLMRegistry; exports.LangGraphAgent = LangGraphAgent; exports.LlmAgent = LlmAgent; exports.LlmCallsLimitExceededError = LlmCallsLimitExceededError; exports.LlmRequest = LlmRequest; exports.LlmResponse = LlmResponse; exports.LoadArtifactsTool = LoadArtifactsTool; exports.LoadMemoryTool = LoadMemoryTool; exports.LocalEvalService = LocalEvalService; exports.LoopAgent = LoopAgent; exports.McpAbi = McpAbi; exports.McpAtp = McpAtp; exports.McpBamm = McpBamm; exports.McpClientService = McpClientService; exports.McpCoinGecko = McpCoinGecko; exports.McpDiscord = McpDiscord; exports.McpError = McpError; exports.McpErrorType = McpErrorType; exports.McpFilesystem = McpFilesystem; exports.McpFraxlend = McpFraxlend; exports.McpGeneric = McpGeneric; exports.McpIqWiki = McpIqWiki; exports.McpMemory = McpMemory; exports.McpNearAgent = McpNearAgent; exports.McpNearIntents = McpNearIntents; exports.McpOdos = McpOdos; exports.McpSamplingHandler = McpSamplingHandler; exports.McpTelegram = McpTelegram; exports.McpToolset = McpToolset; exports.McpUpbit = McpUpbit; exports.Memory = memory_exports; exports.Models = models_exports; exports.OAuth2Credential = OAuth2Credential; exports.OAuth2Scheme = OAuth2Scheme; exports.OpenAiLlm = OpenAiLlm; exports.OpenIdConnectScheme = OpenIdConnectScheme; exports.ParallelAgent = ParallelAgent; exports.PlanReActPlanner = PlanReActPlanner; exports.PrebuiltMetrics = PrebuiltMetrics; exports.REQUEST_EUC_FUNCTION_CALL_NAME = REQUEST_EUC_FUNCTION_CALL_NAME; exports.ReadonlyContext = ReadonlyContext; exports.RougeEvaluator = RougeEvaluator; exports.RunConfig = RunConfig; exports.Runner = Runner; exports.SafetyEvaluatorV1 = SafetyEvaluatorV1; exports.SequentialAgent = SequentialAgent; exports.Sessions = sessions_exports; exports.SingleFlow = SingleFlow; exports.State = State; exports.StreamingMode = StreamingMode; exports.TelemetryService = TelemetryService; exports.ToolContext = ToolContext; exports.Tools = tools_exports; exports.TrajectoryEvaluator = TrajectoryEvaluator; exports.TransferToAgentTool = TransferToAgentTool; exports.UserInteractionTool = UserInteractionTool; exports.VERSION = VERSION; exports.VertexAiSessionService = VertexAiSessionService; exports._findFunctionCallEventIfLastEventIsFunctionResponse = _findFunctionCallEventIfLastEventIsFunctionResponse; exports.adkToMcpToolType = adkToMcpToolType; exports.agentTransferRequestProcessor = requestProcessor8; exports.basicRequestProcessor = requestProcessor2; exports.buildFunctionDeclaration = buildFunctionDeclaration; exports.codeExecutionRequestProcessor = requestProcessor3; exports.codeExecutionResponseProcessor = responseProcessor; exports.contentRequestProcessor = requestProcessor4; exports.createAuthToolArguments = createAuthToolArguments; exports.createBranchContextForSubAgent = createBranchContextForSubAgent; exports.createDatabaseSessionService = createDatabaseSessionService; exports.createFunctionTool = createFunctionTool; exports.createMysqlSessionService = createMysqlSessionService; exports.createPostgresSessionService = createPostgresSessionService; exports.createSamplingHandler = createSamplingHandler; exports.createSqliteSessionService = createSqliteSessionService; exports.createTool = createTool; exports.generateAuthEvent = generateAuthEvent; exports.generateClientFunctionCallId = generateClientFunctionCallId; exports.getLongRunningFunctionCalls = getLongRunningFunctionCalls; exports.getMcpTools = getMcpTools; exports.handleFunctionCallsAsync = handleFunctionCallsAsync; exports.handleFunctionCallsLive = handleFunctionCallsLive; exports.identityRequestProcessor = requestProcessor5; exports.initializeTelemetry = initializeTelemetry; exports.injectSessionState = injectSessionState; exports.instructionsRequestProcessor = requestProcessor6; exports.isEnhancedAuthConfig = isEnhancedAuthConfig; exports.jsonSchemaToDeclaration = jsonSchemaToDeclaration; exports.mcpSchemaToParameters = mcpSchemaToParameters; exports.mergeAgentRun = mergeAgentRun; exports.mergeParallelFunctionResponseEvents = mergeParallelFunctionResponseEvents; exports.newInvocationContextId = newInvocationContextId; exports.nlPlanningRequestProcessor = requestProcessor7; exports.nlPlanningResponseProcessor = responseProcessor2; exports.normalizeJsonSchema = normalizeJsonSchema; exports.populateClientFunctionCallId = populateClientFunctionCallId; exports.registerProviders = registerProviders; exports.removeClientFunctionCallId = removeClientFunctionCallId; exports.requestProcessor = requestProcessor; exports.shutdownTelemetry = shutdownTelemetry; exports.telemetryService = telemetryService; exports.traceLlmCall = traceLlmCall; exports.traceToolCall = traceToolCall; exports.tracer = tracer;
+exports.AF_FUNCTION_CALL_ID_PREFIX = AF_FUNCTION_CALL_ID_PREFIX; exports.Agent = LlmAgent; exports.AgentBuilder = AgentBuilder; exports.AgentEvaluator = AgentEvaluator; exports.AgentTool = AgentTool; exports.Agents = agents_exports; exports.AiSdkLlm = AiSdkLlm; exports.AnthropicLlm = AnthropicLlm; exports.ApiKeyCredential = ApiKeyCredential; exports.ApiKeyScheme = ApiKeyScheme; exports.AuthConfig = AuthConfig; exports.AuthCredential = AuthCredential; exports.AuthCredentialType = AuthCredentialType; exports.AuthHandler = AuthHandler; exports.AuthScheme = AuthScheme; exports.AuthSchemeType = AuthSchemeType; exports.AuthTool = AuthTool; exports.AutoFlow = AutoFlow; exports.BaseAgent = BaseAgent; exports.BaseCodeExecutor = BaseCodeExecutor; exports.BaseLLMConnection = BaseLLMConnection; exports.BaseLlm = BaseLlm; exports.BaseLlmFlow = BaseLlmFlow; exports.BaseLlmRequestProcessor = BaseLlmRequestProcessor; exports.BaseLlmResponseProcessor = BaseLlmResponseProcessor; exports.BasePlanner = BasePlanner; exports.BaseSessionService = BaseSessionService; exports.BaseTool = BaseTool; exports.BasicAuthCredential = BasicAuthCredential; exports.BearerTokenCredential = BearerTokenCredential; exports.BuiltInCodeExecutor = BuiltInCodeExecutor; exports.BuiltInPlanner = BuiltInPlanner; exports.CallbackContext = CallbackContext; exports.CodeExecutionUtils = CodeExecutionUtils; exports.CodeExecutorContext = CodeExecutorContext; exports.DatabaseSessionService = DatabaseSessionService; exports.EnhancedAuthConfig = EnhancedAuthConfig; exports.EvalResult = EvalResult; exports.EvalStatus = EvalStatus; exports.Evaluation = evaluation_exports; exports.Evaluator = Evaluator; exports.Event = Event; exports.EventActions = EventActions; exports.Events = events_exports; exports.ExitLoopTool = ExitLoopTool; exports.FileOperationsTool = FileOperationsTool; exports.FinalResponseMatchV2Evaluator = FinalResponseMatchV2Evaluator; exports.Flows = flows_exports; exports.FunctionTool = FunctionTool; exports.GcsArtifactService = GcsArtifactService; exports.GetUserChoiceTool = GetUserChoiceTool; exports.GoogleLlm = GoogleLlm; exports.GoogleSearch = GoogleSearch; exports.HttpRequestTool = HttpRequestTool; exports.HttpScheme = HttpScheme; exports.InMemoryArtifactService = InMemoryArtifactService; exports.InMemoryMemoryService = InMemoryMemoryService; exports.InMemoryRunner = InMemoryRunner; exports.InMemorySessionService = InMemorySessionService; exports.InvocationContext = InvocationContext; exports.LLMRegistry = LLMRegistry; exports.LangGraphAgent = LangGraphAgent; exports.LlmAgent = LlmAgent; exports.LlmCallsLimitExceededError = LlmCallsLimitExceededError; exports.LlmRequest = LlmRequest; exports.LlmResponse = LlmResponse; exports.LoadArtifactsTool = LoadArtifactsTool; exports.LoadMemoryTool = LoadMemoryTool; exports.LocalEvalService = LocalEvalService; exports.LoopAgent = LoopAgent; exports.McpAbi = McpAbi; exports.McpAtp = McpAtp; exports.McpBamm = McpBamm; exports.McpCoinGecko = McpCoinGecko; exports.McpDiscord = McpDiscord; exports.McpError = McpError; exports.McpErrorType = McpErrorType; exports.McpFilesystem = McpFilesystem; exports.McpFraxlend = McpFraxlend; exports.McpGeneric = McpGeneric; exports.McpIqWiki = McpIqWiki; exports.McpMemory = McpMemory; exports.McpNearAgent = McpNearAgent; exports.McpNearIntents = McpNearIntents; exports.McpOdos = McpOdos; exports.McpSamplingHandler = McpSamplingHandler; exports.McpTelegram = McpTelegram; exports.McpToolset = McpToolset; exports.McpUpbit = McpUpbit; exports.Memory = memory_exports; exports.Models = models_exports; exports.OAuth2Credential = OAuth2Credential; exports.OAuth2Scheme = OAuth2Scheme; exports.OpenAiLlm = OpenAiLlm; exports.OpenIdConnectScheme = OpenIdConnectScheme; exports.ParallelAgent = ParallelAgent; exports.PlanReActPlanner = PlanReActPlanner; exports.PrebuiltMetrics = PrebuiltMetrics; exports.REQUEST_EUC_FUNCTION_CALL_NAME = REQUEST_EUC_FUNCTION_CALL_NAME; exports.ReadonlyContext = ReadonlyContext; exports.RougeEvaluator = RougeEvaluator; exports.RunConfig = RunConfig; exports.Runner = Runner; exports.SafetyEvaluatorV1 = SafetyEvaluatorV1; exports.SequentialAgent = SequentialAgent; exports.Sessions = sessions_exports; exports.SingleFlow = SingleFlow; exports.State = State; exports.StreamingMode = StreamingMode; exports.TelemetryService = TelemetryService; exports.ToolContext = ToolContext; exports.Tools = tools_exports; exports.TrajectoryEvaluator = TrajectoryEvaluator; exports.TransferToAgentTool = TransferToAgentTool; exports.UserInteractionTool = UserInteractionTool; exports.VERSION = VERSION; exports.VertexAiSessionService = VertexAiSessionService; exports._findFunctionCallEventIfLastEventIsFunctionResponse = _findFunctionCallEventIfLastEventIsFunctionResponse; exports.adkToMcpToolType = adkToMcpToolType; exports.agentTransferRequestProcessor = requestProcessor8; exports.basicRequestProcessor = requestProcessor2; exports.buildFunctionDeclaration = buildFunctionDeclaration; exports.codeExecutionRequestProcessor = requestProcessor3; exports.codeExecutionResponseProcessor = responseProcessor; exports.contentRequestProcessor = requestProcessor4; exports.convertMcpToolToBaseTool = convertMcpToolToBaseTool; exports.createAuthToolArguments = createAuthToolArguments; exports.createBranchContextForSubAgent = createBranchContextForSubAgent; exports.createDatabaseSessionService = createDatabaseSessionService; exports.createFunctionTool = createFunctionTool; exports.createMysqlSessionService = createMysqlSessionService; exports.createPostgresSessionService = createPostgresSessionService; exports.createSamplingHandler = createSamplingHandler; exports.createSqliteSessionService = createSqliteSessionService; exports.createTool = createTool; exports.generateAuthEvent = generateAuthEvent; exports.generateClientFunctionCallId = generateClientFunctionCallId; exports.getLongRunningFunctionCalls = getLongRunningFunctionCalls; exports.getMcpTools = getMcpTools; exports.handleFunctionCallsAsync = handleFunctionCallsAsync; exports.handleFunctionCallsLive = handleFunctionCallsLive; exports.identityRequestProcessor = requestProcessor5; exports.initializeTelemetry = initializeTelemetry; exports.injectSessionState = injectSessionState; exports.instructionsRequestProcessor = requestProcessor6; exports.isEnhancedAuthConfig = isEnhancedAuthConfig; exports.jsonSchemaToDeclaration = jsonSchemaToDeclaration; exports.mcpSchemaToParameters = mcpSchemaToParameters; exports.mergeAgentRun = mergeAgentRun; exports.mergeParallelFunctionResponseEvents = mergeParallelFunctionResponseEvents; exports.newInvocationContextId = newInvocationContextId; exports.nlPlanningRequestProcessor = requestProcessor7; exports.nlPlanningResponseProcessor = responseProcessor2; exports.normalizeJsonSchema = normalizeJsonSchema; exports.populateClientFunctionCallId = populateClientFunctionCallId; exports.registerProviders = registerProviders; exports.removeClientFunctionCallId = removeClientFunctionCallId; exports.requestProcessor = requestProcessor; exports.shutdownTelemetry = shutdownTelemetry; exports.telemetryService = telemetryService; exports.traceLlmCall = traceLlmCall; exports.traceToolCall = traceToolCall; exports.tracer = tracer;