@iqai/adk 0.2.1 → 0.2.3

package/dist/index.mjs

@@ -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,637 +3909,111 @@ __export(tools_exports, {
   mcpSchemaToParameters: () => mcpSchemaToParameters,
   normalizeJsonSchema: () => normalizeJsonSchema
 });
+init_base_tool();
 
-// src/tools/mcp/client.ts
-init_logger();
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { CreateMessageRequestSchema as CreateMessageRequestSchema2 } from "@modelcontextprotocol/sdk/types.js";
-
-// src/tools/mcp/sampling-handler.ts
-init_logger();
-import {
-  CreateMessageRequestSchema,
-  CreateMessageResultSchema
-} from "@modelcontextprotocol/sdk/types.js";
-
-// 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 {
-  type;
-  originalError;
-  constructor(message, type, originalError) {
-    super(message);
-    this.name = "McpError";
-    this.type = type;
-    this.originalError = originalError;
-  }
-};
-
-// src/tools/mcp/sampling-handler.ts
-var McpSamplingHandler = class {
-  logger = new Logger({ name: "McpSamplingHandler" });
-  samplingHandler;
-  constructor(samplingHandler) {
-    this.samplingHandler = samplingHandler;
+// src/tools/base/create-tool.ts
+init_base_tool();
+import * as z from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+var CreatedTool = class extends BaseTool {
+  func;
+  schema;
+  functionDeclaration;
+  constructor(config) {
+    super({
+      name: config.name,
+      description: config.description,
+      isLongRunning: config.isLongRunning ?? false,
+      shouldRetryOnFailure: config.shouldRetryOnFailure ?? false,
+      maxRetryAttempts: config.maxRetryAttempts ?? 3
+    });
+    this.func = config.fn;
+    this.schema = 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 = 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 = 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 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(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();
+import { Type } from "@google/genai";
+import { v4 as uuidv42 } from "uuid";
+
+// src/agents/invocation-context.ts
+var LlmCallsLimitExceededError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LlmCallsLimitExceededError";
+  }
+};
+var InvocationCostManager = class {
   /**
-   * 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: "" }];
+  _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 }];
   }
+};
+function newInvocationContextId() {
+  return `e-${crypto.randomUUID()}`;
+}
+var InvocationContext = class _InvocationContext {
+  artifactService;
+  sessionService;
+  memoryService;
   /**
-   * Convert ADK response to MCP response format
-   */
-  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
-   */
-  updateHandler(handler) {
-    this.samplingHandler = handler;
-    this.logger.debug("ADK sampling handler updated");
-  }
-};
-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 = class {
-  config;
-  client = null;
-  transport = null;
-  isClosing = false;
-  mcpSamplingHandler = null;
-  logger = new Logger({ name: "McpClientService" });
-  constructor(config) {
-    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.
-   */
-  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 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.
-   */
-  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 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 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
-      );
-    }
-  }
-  /**
-   * Re-initializes the MCP client when a session is closed.
-   * Used by the retry mechanism.
-   */
-  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();
-  }
-  /**
-   * Cleans up resources associated with this client service.
-   * Similar to Python's AsyncExitStack.aclose() functionality.
-   */
-  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;
-    }
-  }
-  /**
-   * Call an MCP tool with retry capability if the session is closed.
-   */
-  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(),
-        this.config.retryOptions?.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;
-    }
-  }
-  /**
-   * Closes and cleans up all resources.
-   * Should be called when the service is no longer needed.
-   * Similar to Python's close() method.
-   */
-  async close() {
-    this.logger.debug("\u{1F51A} Closing MCP client service");
-    await this.cleanupResources();
-  }
-  /**
-   * Checks if the client is currently connected
-   */
-  isConnected() {
-    return !!this.client && !this.isClosing;
-  }
-  async setupSamplingHandler(client) {
-    if (!this.mcpSamplingHandler) {
-      this.logger.debug(
-        "\u26A0\uFE0F No sampling handler provided - sampling requests will be rejected"
-      );
-      return;
-    }
-    try {
-      client.setRequestHandler(
-        CreateMessageRequestSchema2,
-        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) {
-      this.logger.error("Failed to setup sampling handler:", error);
-      this.logger.debug(
-        "\u26A0\uFE0F Sampling handler registration failed, continuing without sampling support"
-      );
-    }
-  }
-  /**
-   * Set a new ADK sampling handler
-   */
-  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);
-      });
-    }
-  }
-  /**
-   * Remove the sampling handler
-   */
-  removeSamplingHandler() {
-    this.mcpSamplingHandler = null;
-    if (this.client) {
-      try {
-        this.client.removeRequestHandler?.("sampling/createMessage");
-      } catch (error) {
-        this.logger.error("Failed to remove sampling handler:", error);
-      }
-    }
-  }
-};
-
-// src/tools/index.ts
-init_base_tool();
-
-// src/tools/base/create-tool.ts
-init_base_tool();
-import * as z from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
-var CreatedTool = class extends BaseTool {
-  func;
-  schema;
-  functionDeclaration;
-  constructor(config) {
-    super({
-      name: config.name,
-      description: config.description,
-      isLongRunning: config.isLongRunning ?? false,
-      shouldRetryOnFailure: config.shouldRetryOnFailure ?? false,
-      maxRetryAttempts: config.maxRetryAttempts ?? 3
-    });
-    this.func = config.fn;
-    this.schema = config.schema ?? z.object({});
-    this.functionDeclaration = this.buildDeclaration();
-  }
-  /**
-   * Executes the tool function with validation
-   */
-  async runAsync(args, context4) {
-    try {
-      const validatedArgs = this.schema.parse(args);
-      const result = await Promise.resolve(this.func(validatedArgs, context4));
-      return result ?? {};
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        return {
-          error: `Invalid arguments for ${this.name}: ${error.message}`
-        };
-      }
-      return {
-        error: `Error executing ${this.name}: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-  /**
-   * Returns the function declaration for this tool
-   */
-  getDeclaration() {
-    return this.functionDeclaration;
-  }
-  /**
-   * Builds the function declaration from the Zod schema
-   */
-  buildDeclaration() {
-    const rawParameters = zodToJsonSchema(this.schema, {
-      target: "jsonSchema7",
-      $refStrategy: "none"
-    });
-    const { $schema, ...parameters } = rawParameters;
-    return {
-      name: this.name,
-      description: this.description,
-      parameters
-    };
-  }
-};
-function createTool(config) {
-  return new CreatedTool(config);
-}
-
-// src/tools/common/agent-tool.ts
-init_logger();
-import { Type } from "@google/genai";
-import { v4 as uuidv42 } from "uuid";
-
-// src/agents/invocation-context.ts
-var LlmCallsLimitExceededError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "LlmCallsLimitExceededError";
-  }
-};
-var InvocationCostManager = class {
-  /**
-   * A counter that keeps track of number of llm calls made.
-   */
-  _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`
-      );
-    }
-  }
-};
-function newInvocationContextId() {
-  return `e-${crypto.randomUUID()}`;
-}
-var InvocationContext = class _InvocationContext {
-  artifactService;
-  sessionService;
-  memoryService;
-  /**
-   * The id of this invocation context. Readonly.
+   * The id of this invocation context. Readonly.
    */
   invocationId;
   /**
@@ -4656,265 +4130,630 @@ var InvocationContext = class _InvocationContext {
   }
 };
 
-// src/tools/common/agent-tool.ts
+// src/tools/common/agent-tool.ts
+init_base_tool();
+function isLlmAgent(agent) {
+  return true;
+}
+var AgentTool = class extends BaseTool {
+  /**
+   * The agent used by this tool
+   */
+  agent;
+  /**
+   * The function declaration schema
+   */
+  functionDeclaration;
+  /**
+   * The key to store the tool output in the state
+   */
+  outputKey;
+  /**
+   * Whether to skip summarization of the agent's response
+   */
+  skipSummarization;
+  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
+    });
+    this.agent = config.agent;
+    this.functionDeclaration = config.functionDeclaration;
+    this.outputKey = config.outputKey;
+    this.skipSummarization = config.skipSummarization || false;
+  }
+  /**
+   * 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,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          input: {
+            type: 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: uuidv42(),
+        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 {
+        toolResult = mergedText;
+      }
+      if (this.outputKey && context4?.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)}`
+      );
+    }
+  }
+};
+
+// 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.
+   */
+  functionCallId;
+  /**
+   * 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
+    });
+  }
+  /**
+   * Searches the memory of the current user
+   */
+  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
+    });
+  }
+};
+
+// 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();
+import { Type as Type3 } from "@google/genai";
+var GoogleSearch = class extends BaseTool {
+  logger = new Logger({ name: "GoogleSearch" });
+  /**
+   * Constructor for GoogleSearch
+   */
+  constructor() {
+    super({
+      name: "google_search",
+      description: "Search the web using Google"
+    });
+  }
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type3.OBJECT,
+        properties: {
+          query: {
+            type: Type3.STRING,
+            description: "The search query to execute"
+          },
+          num_results: {
+            type: Type3.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}".`
+        }
+      ]
+    };
+  }
+};
+
+// src/tools/common/http-request-tool.ts
 init_base_tool();
-function isLlmAgent(agent) {
-  return true;
-}
-var AgentTool = class extends BaseTool {
-  /**
-   * The agent used by this tool
-   */
-  agent;
-  /**
-   * The function declaration schema
-   */
-  functionDeclaration;
+import { Type as Type4 } from "@google/genai";
+var HttpRequestTool = class extends BaseTool {
+  constructor() {
+    super({
+      name: "http_request",
+      description: "Make HTTP requests to external APIs and web services"
+    });
+  }
   /**
-   * The key to store the tool output in the state
+   * Get the function declaration for the tool
    */
-  outputKey;
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type4.OBJECT,
+        properties: {
+          url: {
+            type: Type4.STRING,
+            description: "The URL to send the request to"
+          },
+          method: {
+            type: Type4.STRING,
+            description: "The HTTP method to use (GET, POST, PUT, DELETE, etc.)",
+            enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
+            default: "GET"
+          },
+          headers: {
+            type: Type4.OBJECT,
+            description: "Request headers to include"
+          },
+          body: {
+            type: Type4.STRING,
+            description: "Request body content (as string, typically JSON)"
+          },
+          params: {
+            type: Type4.OBJECT,
+            description: "URL query parameters to include"
+          },
+          timeout: {
+            type: Type4.INTEGER,
+            description: "Request timeout in milliseconds",
+            default: 1e4
+          }
+        },
+        required: ["url"]
+      }
+    };
+  }
   /**
-   * Whether to skip summarization of the agent's response
+   * Execute the HTTP request
    */
-  skipSummarization;
-  logger = new Logger({ name: "AgentTool" });
+  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)
+      };
+    }
+  }
   /**
-   * Create a new agent tool
+   * Check if a string is valid JSON
    */
-  constructor(config) {
+  isValidJson(str) {
+    try {
+      JSON.parse(str);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+};
+
+// src/tools/common/file-operations-tool.ts
+init_base_tool();
+import fs from "fs/promises";
+import path from "path";
+import { Type as Type5 } from "@google/genai";
+var FileOperationsTool = class extends BaseTool {
+  basePath;
+  constructor(options) {
     super({
-      name: config.name,
-      description: config.description || config.agent.description,
-      isLongRunning: config.isLongRunning || false,
-      shouldRetryOnFailure: config.shouldRetryOnFailure || false,
-      maxRetryAttempts: config.maxRetryAttempts || 3
+      name: "file_operations",
+      description: "Perform file system operations like reading, writing, and managing files"
     });
-    this.agent = config.agent;
-    this.functionDeclaration = config.functionDeclaration;
-    this.outputKey = config.outputKey;
-    this.skipSummarization = config.skipSummarization || false;
+    this.basePath = options?.basePath || process.cwd();
   }
   /**
    * 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: Type.OBJECT,
+        type: Type5.OBJECT,
         properties: {
-          input: {
-            type: Type.STRING,
-            description: "The input to provide to the agent"
+          operation: {
+            type: Type5.STRING,
+            description: "The file operation to perform",
+            enum: [
+              "read",
+              "write",
+              "append",
+              "delete",
+              "exists",
+              "list",
+              "mkdir"
+            ]
+          },
+          filepath: {
+            type: Type5.STRING,
+            description: "Path to the file or directory (relative to the base path)"
+          },
+          content: {
+            type: Type5.STRING,
+            description: "Content to write to the file (for write and append operations)"
+          },
+          encoding: {
+            type: Type5.STRING,
+            description: "File encoding to use",
+            default: "utf8"
           }
         },
-        required: ["input"]
+        required: ["operation", "filepath"]
       }
     };
   }
   /**
-   * Execute the tool by running the agent with the provided input
+   * Execute the file operation
    */
-  async runAsync(params, context4) {
+  async runAsync(args, _context) {
     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: uuidv42(),
-        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 {
-        toolResult = mergedText;
-      }
-      if (this.outputKey && context4?.state) {
-        context4.state[this.outputKey] = toolResult;
+      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}`);
       }
-      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)}`
-      );
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
   }
-};
-
-// 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.
+   * Resolve a file path relative to the base path
    */
-  functionCallId;
+  resolvePath(filepath) {
+    return path.isAbsolute(filepath) ? filepath : path.resolve(this.basePath, filepath);
+  }
   /**
-   * Constructor for ToolContext
+   * Validate that a path is within the base path for security
    */
-  constructor(invocationContext, options = {}) {
-    super(invocationContext, { eventActions: options.eventActions });
-    this.functionCallId = options.functionCallId;
+  validatePath(filepath) {
+    const normalizedPath = path.normalize(filepath);
+    const normalizedBasePath = path.normalize(this.basePath);
+    if (!normalizedPath.startsWith(normalizedBasePath)) {
+      throw new Error(
+        `Access denied: Can't access paths outside the base directory`
+      );
+    }
   }
   /**
-   * Gets the event actions of the current tool call
+   * Read a file
    */
-  get actions() {
-    return this.eventActions;
+  async readFile(filepath, encoding) {
+    try {
+      const content = await fs.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)}`
+      };
+    }
   }
   /**
-   * Lists the filenames of the artifacts attached to the current session
+   * Write to a file
    */
-  async listArtifacts() {
-    if (!this._invocationContext.artifactService) {
-      throw new Error("Artifact service is not initialized.");
+  async writeFile(filepath, content, encoding) {
+    try {
+      const dir = path.dirname(filepath);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.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)}`
+      };
     }
-    return await this._invocationContext.artifactService.listArtifactKeys({
-      appName: this._invocationContext.appName,
-      userId: this._invocationContext.userId,
-      sessionId: this._invocationContext.session.id
-    });
   }
   /**
-   * Searches the memory of the current user
+   * Append to a file
    */
-  async searchMemory(query) {
-    if (!this._invocationContext.memoryService) {
-      throw new Error("Memory service is not available.");
+  async appendFile(filepath, content, encoding) {
+    try {
+      const dir = path.dirname(filepath);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.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)}`
+      };
     }
-    return await this._invocationContext.memoryService.searchMemory({
-      query,
-      appName: this._invocationContext.appName,
-      userId: this._invocationContext.userId
-    });
   }
-};
-
-// 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();
-import { Type as Type3 } from "@google/genai";
-var GoogleSearch = class extends BaseTool {
-  logger = new Logger({ name: "GoogleSearch" });
   /**
-   * Constructor for GoogleSearch
+   * Delete a file
    */
-  constructor() {
-    super({
-      name: "google_search",
-      description: "Search the web using Google"
-    });
+  async deleteFile(filepath) {
+    try {
+      await fs.unlink(filepath);
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to delete file: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
   }
   /**
-   * Get the function declaration for the tool
+   * Check if a file exists
    */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type3.OBJECT,
-        properties: {
-          query: {
-            type: Type3.STRING,
-            description: "The search query to execute"
-          },
-          num_results: {
-            type: Type3.INTEGER,
-            description: "Number of results to return (max 10)",
-            default: 5
-          }
-        },
-        required: ["query"]
-      }
-    };
+  async fileExists(filepath) {
+    try {
+      await fs.access(filepath);
+      return {
+        success: true,
+        data: true
+      };
+    } catch {
+      return {
+        success: true,
+        data: false
+      };
+    }
   }
   /**
-   * Execute the search
-   * This is a simplified implementation that doesn't actually search, just returns mock results
+   * List directory contents
    */
-  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}".`
-        }
-      ]
-    };
+  async listDirectory(dirpath) {
+    try {
+      const entries = await fs.readdir(dirpath, { withFileTypes: true });
+      const results = await Promise.all(
+        entries.map(async (entry) => {
+          const entryPath = path.join(dirpath, entry.name);
+          const stats = await fs.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)}`
+      };
+    }
+  }
+  /**
+   * Create a directory
+   */
+  async makeDirectory(dirpath) {
+    try {
+      await fs.mkdir(dirpath, { recursive: true });
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to create directory: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
   }
 };
 
-// src/tools/common/http-request-tool.ts
+// src/tools/common/user-interaction-tool.ts
 init_base_tool();
-import { Type as Type4 } from "@google/genai";
-var HttpRequestTool = class extends BaseTool {
+import { Type as Type6 } from "@google/genai";
+var UserInteractionTool = class extends BaseTool {
   constructor() {
     super({
-      name: "http_request",
-      description: "Make HTTP requests to external APIs and web services"
+      name: "user_interaction",
+      description: "Prompt the user for input during agent execution",
+      isLongRunning: true
     });
   }
   /**
@@ -4925,115 +4764,102 @@ var HttpRequestTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: Type4.OBJECT,
+        type: Type6.OBJECT,
         properties: {
-          url: {
-            type: Type4.STRING,
-            description: "The URL to send the request to"
-          },
-          method: {
-            type: Type4.STRING,
-            description: "The HTTP method to use (GET, POST, PUT, DELETE, etc.)",
-            enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
-            default: "GET"
-          },
-          headers: {
-            type: Type4.OBJECT,
-            description: "Request headers to include"
-          },
-          body: {
-            type: Type4.STRING,
-            description: "Request body content (as string, typically JSON)"
+          prompt: {
+            type: Type6.STRING,
+            description: "The prompt message to display to the user"
           },
-          params: {
-            type: Type4.OBJECT,
-            description: "URL query parameters to include"
+          options: {
+            type: Type6.ARRAY,
+            description: "Optional array of choices to present to the user",
+            items: {
+              type: Type6.STRING
+            }
           },
-          timeout: {
-            type: Type4.INTEGER,
-            description: "Request timeout in milliseconds",
-            default: 1e4
+          defaultValue: {
+            type: Type6.STRING,
+            description: "Optional default value for the input field"
           }
         },
-        required: ["url"]
+        required: ["prompt"]
       }
     };
   }
   /**
-   * Execute the HTTP request
+   * Execute the user interaction
    */
-  async runAsync(args, _context) {
+  async runAsync(args, context4) {
     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 actions = context4.actions;
+      if (!actions || !actions.promptUser) {
+        return {
+          success: false,
+          error: "User interaction is not supported in the current environment"
+        };
       }
-      const requestHeaders = { ...headers };
-      if (body && !requestHeaders["Content-Type"] && this.isValidJson(body)) {
-        requestHeaders["Content-Type"] = "application/json";
+      if (actions.skipSummarization) {
+        actions.skipSummarization(true);
       }
-      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 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 responseBody = await response.text();
       return {
-        statusCode: response.status,
-        headers: responseHeaders,
-        body: responseBody
+        success: true,
+        userInput: response
       };
     } catch (error) {
       return {
-        statusCode: 0,
-        headers: {},
-        body: "",
+        success: false,
         error: error instanceof Error ? error.message : String(error)
       };
     }
   }
+};
+
+// src/tools/common/exit-loop-tool.ts
+init_logger();
+init_base_tool();
+var ExitLoopTool = class extends BaseTool {
+  logger = new Logger({ name: "ExitLoopTool" });
   /**
-   * Check if a string is valid JSON
+   * Constructor for ExitLoopTool
    */
-  isValidJson(str) {
-    try {
-      JSON.parse(str);
-      return true;
-    } catch (e) {
-      return false;
-    }
+  constructor() {
+    super({
+      name: "exit_loop",
+      description: "Exits the loop. Call this function only when you are instructed to do so."
+    });
+  }
+  /**
+   * Execute the exit loop action
+   */
+  async runAsync(_args, context4) {
+    this.logger.debug("Executing exit loop tool");
+    context4.actions.escalate = true;
   }
 };
 
-// src/tools/common/file-operations-tool.ts
+// src/tools/common/get-user-choice-tool.ts
+init_logger();
 init_base_tool();
-import fs from "fs/promises";
-import path from "path";
-import { Type as Type5 } from "@google/genai";
-var FileOperationsTool = class extends BaseTool {
-  basePath;
-  constructor(options) {
+import { Type as Type7 } from "@google/genai";
+var GetUserChoiceTool = class extends BaseTool {
+  logger = new Logger({ name: "GetUserChoiceTool" });
+  /**
+   * Constructor for GetUserChoiceTool
+   */
+  constructor() {
     super({
-      name: "file_operations",
-      description: "Perform file system operations like reading, writing, and managing files"
+      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
     });
-    this.basePath = options?.basePath || process.cwd();
   }
   /**
    * Get the function declaration for the tool
@@ -5043,601 +4869,773 @@ var FileOperationsTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: Type5.OBJECT,
+        type: Type7.OBJECT,
         properties: {
-          operation: {
-            type: Type5.STRING,
-            description: "The file operation to perform",
-            enum: [
-              "read",
-              "write",
-              "append",
-              "delete",
-              "exists",
-              "list",
-              "mkdir"
-            ]
-          },
-          filepath: {
-            type: Type5.STRING,
-            description: "Path to the file or directory (relative to the base path)"
-          },
-          content: {
-            type: Type5.STRING,
-            description: "Content to write to the file (for write and append operations)"
+          options: {
+            type: Type7.ARRAY,
+            description: "List of options for the user to choose from",
+            items: {
+              type: Type7.STRING
+            }
           },
-          encoding: {
-            type: Type5.STRING,
-            description: "File encoding to use",
-            default: "utf8"
+          question: {
+            type: Type7.STRING,
+            description: "The question or prompt to show the user before presenting options"
           }
         },
-        required: ["operation", "filepath"]
+        required: ["options"]
       }
     };
   }
   /**
-   * Execute the file operation
+   * 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) {
-    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}`);
+  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;
+  }
+};
+
+// src/tools/common/transfer-to-agent-tool.ts
+init_logger();
+init_base_tool();
+import { Type as Type8 } from "@google/genai";
+var TransferToAgentTool = class extends BaseTool {
+  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."
+    });
+  }
+  /**
+   * Get the function declaration for the tool
+   */
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type8.OBJECT,
+        properties: {
+          agent_name: {
+            type: Type8.STRING,
+            description: "The name of the agent to transfer control to"
+          }
+        },
+        required: ["agent_name"]
       }
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
+    };
   }
   /**
-   * Resolve a file path relative to the base path
+   * Execute the transfer to agent action
    */
-  resolvePath(filepath) {
-    return path.isAbsolute(filepath) ? filepath : path.resolve(this.basePath, filepath);
+  async runAsync(args, context4) {
+    this.logger.debug(`Executing transfer to agent: ${args.agent_name}`);
+    context4.actions.transferToAgent = args.agent_name;
   }
+};
+
+// src/tools/common/load-memory-tool.ts
+init_logger();
+init_base_tool();
+import { Type as Type9 } from "@google/genai";
+var LoadMemoryTool = class extends BaseTool {
+  logger = new Logger({ name: "LoadMemoryTool" });
   /**
-   * Validate that a path is within the base path for security
+   * Constructor for LoadMemoryTool
    */
-  validatePath(filepath) {
-    const normalizedPath = path.normalize(filepath);
-    const normalizedBasePath = path.normalize(this.basePath);
-    if (!normalizedPath.startsWith(normalizedBasePath)) {
-      throw new Error(
-        `Access denied: Can't access paths outside the base directory`
-      );
-    }
+  constructor() {
+    super({
+      name: "load_memory",
+      description: "Loads the memory for the current user based on a query."
+    });
   }
   /**
-   * Read a file
+   * Get the function declaration for the tool
    */
-  async readFile(filepath, encoding) {
-    try {
-      const content = await fs.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)}`
-      };
-    }
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type9.OBJECT,
+        properties: {
+          query: {
+            type: Type9.STRING,
+            description: "The query to load memories for"
+          }
+        },
+        required: ["query"]
+      }
+    };
   }
   /**
-   * Write to a file
+   * Execute the memory loading action
    */
-  async writeFile(filepath, content, encoding) {
+  async runAsync(args, context4) {
+    this.logger.debug(`Executing load_memory with query: ${args.query}`);
     try {
-      const dir = path.dirname(filepath);
-      await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(filepath, content, { encoding });
+      const searchResult = await context4.searchMemory(args.query);
       return {
-        success: true
+        memories: searchResult.memories || [],
+        count: searchResult.memories?.length || 0
       };
     } catch (error) {
+      console.error("Error searching memory:", error);
       return {
-        success: false,
-        error: `Failed to write to file: ${error instanceof Error ? error.message : String(error)}`
+        error: "Memory search failed",
+        message: error instanceof Error ? error.message : String(error)
       };
     }
   }
+};
+
+// src/tools/common/load-artifacts-tool.ts
+init_base_tool();
+import { Type as Type10 } from "@google/genai";
+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 = path.dirname(filepath);
-      await fs.mkdir(dir, { recursive: true });
-      await fs.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: Type10.OBJECT,
+        properties: {
+          artifact_names: {
+            type: Type10.ARRAY,
+            items: {
+              type: Type10.STRING
+            },
+            description: "List of artifact names to load"
+          }
+        },
+        required: []
+      }
+    };
   }
   /**
-   * Delete a file
+   * Execute the load artifacts operation
    */
-  async deleteFile(filepath) {
-    try {
-      await fs.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 fs.access(filepath);
-      return {
-        success: true,
-        data: true
-      };
-    } catch {
-      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 fs.readdir(dirpath, { withFileTypes: true });
-      const results = await Promise.all(
-        entries.map(async (entry) => {
-          const entryPath = path.join(dirpath, entry.name);
-          const stats = await fs.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 fs.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();
-import { Type as Type6 } from "@google/genai";
-var UserInteractionTool = class extends BaseTool {
-  constructor() {
-    super({
-      name: "user_interaction",
-      description: "Prompt the user for input during agent execution",
-      isLongRunning: true
-    });
+// src/tools/mcp/client.ts
+init_logger();
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { CreateMessageRequestSchema as CreateMessageRequestSchema2 } from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/mcp/sampling-handler.ts
+init_logger();
+import {
+  CreateMessageRequestSchema,
+  CreateMessageResultSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// 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 {
+  type;
+  originalError;
+  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: Type6.OBJECT,
-        properties: {
-          prompt: {
-            type: Type6.STRING,
-            description: "The prompt message to display to the user"
-          },
-          options: {
-            type: Type6.ARRAY,
-            description: "Optional array of choices to present to the user",
-            items: {
-              type: Type6.STRING
-            }
-          },
-          defaultValue: {
-            type: Type6.STRING,
-            description: "Optional default value for the input field"
-          }
-        },
-        required: ["prompt"]
-      }
-    };
+};
+
+// src/tools/mcp/sampling-handler.ts
+var McpSamplingHandler = class {
+  logger = new Logger({ name: "McpSamplingHandler" });
+  samplingHandler;
+  constructor(samplingHandler) {
+    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 = 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 = 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 = class extends BaseTool {
-  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."
-    });
+  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;
   }
-};
-
-// src/tools/common/get-user-choice-tool.ts
-init_logger();
-init_base_tool();
-import { Type as Type7 } from "@google/genai";
-var GetUserChoiceTool = class extends BaseTool {
-  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
-    });
+  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: Type7.OBJECT,
-        properties: {
-          options: {
-            type: Type7.ARRAY,
-            description: "List of options for the user to choose from",
-            items: {
-              type: Type7.STRING
-            }
-          },
-          question: {
-            type: Type7.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");
   }
 };
+function createSamplingHandler(handler) {
+  return handler;
+}
 
-// src/tools/common/transfer-to-agent-tool.ts
-init_logger();
-init_base_tool();
-import { Type as Type8 } from "@google/genai";
-var TransferToAgentTool = class extends BaseTool {
-  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."
-    });
+// 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 = class {
+  config;
+  client = null;
+  transport = null;
+  isClosing = false;
+  mcpSamplingHandler = null;
+  logger = new Logger({ name: "McpClientService" });
+  constructor(config) {
+    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: Type8.OBJECT,
-        properties: {
-          agent_name: {
-            type: Type8.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 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 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 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
+      );
+    }
   }
-};
-
-// src/tools/common/load-memory-tool.ts
-init_logger();
-init_base_tool();
-import { Type as Type9 } from "@google/genai";
-var LoadMemoryTool = class extends BaseTool {
-  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."
-    });
+  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: Type9.OBJECT,
-        properties: {
-          query: {
-            type: Type9.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: searchResult.memories?.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;
     }
   }
-};
-
-// src/tools/common/load-artifacts-tool.ts
-init_base_tool();
-import { Type as Type10 } from "@google/genai";
-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: Type10.OBJECT,
-        properties: {
-          artifact_names: {
-            type: Type10.ARRAY,
-            items: {
-              type: Type10.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(),
+        this.config.retryOptions?.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(
+        CreateMessageRequestSchema2,
+        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);
+      });
+    }
+  }
+  /**
+   * Remove the sampling handler
+   */
+  removeSamplingHandler() {
+    this.mcpSamplingHandler = null;
+    if (this.client) {
+      try {
+        this.client.removeRequestHandler?.("sampling/createMessage");
+      } catch (error) {
+        this.logger.error("Failed to remove sampling handler:", error);
+      }
     }
-    return null;
   }
 };
 
@@ -5818,9 +5816,13 @@ function mcpSchemaToParameters(mcpTool) {
 }
 
 // src/tools/mcp/create-tool.ts
-async function createTool2(mcpTool, client) {
+async function convertMcpToolToBaseTool(params) {
   try {
-    return new McpToolAdapter(mcpTool, client);
+    return new McpToolAdapter(
+      params.mcpTool,
+      params.client,
+      params.toolHandler
+    );
   } catch (error) {
     if (!(error instanceof McpError)) {
       throw new McpError(
@@ -5836,8 +5838,9 @@ var McpToolAdapter = class extends BaseTool {
   mcpTool;
   client;
   clientService = null;
+  toolHandler;
   logger = new Logger({ name: "McpToolAdapter" });
-  constructor(mcpTool, client) {
+  constructor(mcpTool, client, handler) {
     const metadata = mcpTool.metadata || {};
     super({
       name: mcpTool.name || `mcp_${Date.now()}`,
@@ -5848,7 +5851,8 @@ var McpToolAdapter = class extends BaseTool {
     });
     this.mcpTool = mcpTool;
     this.client = client;
-    if (client.reinitialize && typeof client.reinitialize === "function") {
+    this.toolHandler = handler;
+    if (client && client.reinitialize && typeof client.reinitialize === "function") {
       this.clientService = client;
     }
   }
@@ -5902,6 +5906,9 @@ var McpToolAdapter = class extends BaseTool {
         });
         return result;
       }
+      if (this.toolHandler) {
+        return await this.toolHandler(this.name, args);
+      }
       throw new McpError(
         `Cannot execute MCP tool ${this.name}: No execution method found`,
         "tool_execution_error" /* TOOL_EXECUTION_ERROR */
@@ -6160,7 +6167,10 @@ var McpToolset = 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(
@@ -13233,7 +13243,6 @@ export {
   McpAbi,
   McpAtp,
   McpBamm,
-  McpClientService,
   McpCoinGecko,
   McpDiscord,
   McpError,
@@ -13286,6 +13295,7 @@ export {
   requestProcessor3 as codeExecutionRequestProcessor,
   responseProcessor as codeExecutionResponseProcessor,
   requestProcessor4 as contentRequestProcessor,
+  convertMcpToolToBaseTool,
   createAuthToolArguments,
   createBranchContextForSubAgent,
   createDatabaseSessionService,