@iqai/adk 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -3879,6 +3879,7 @@ __export(tools_exports, {
   McpAbi: () => McpAbi,
   McpAtp: () => McpAtp,
   McpBamm: () => McpBamm,
+  McpClientService: () => McpClientService,
   McpCoinGecko: () => McpCoinGecko,
   McpDiscord: () => McpDiscord,
   McpError: () => McpError,
@@ -3894,6 +3895,7 @@ __export(tools_exports, {
   McpSamplingHandler: () => McpSamplingHandler,
   McpTelegram: () => McpTelegram,
   McpToolset: () => McpToolset,
+  McpUpbit: () => McpUpbit,
   ToolContext: () => ToolContext,
   TransferToAgentTool: () => TransferToAgentTool,
   UserInteractionTool: () => UserInteractionTool,
@@ -3907,956 +3909,953 @@ __export(tools_exports, {
   mcpSchemaToParameters: () => mcpSchemaToParameters,
   normalizeJsonSchema: () => normalizeJsonSchema
 });
-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();
+// 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;
   }
   /**
-   * Executes the tool function with validation
+   * Handle MCP sampling request and convert between formats
    */
-  async runAsync(args, context4) {
+  async handleSamplingRequest(request) {
     try {
-      const validatedArgs = this.schema.parse(args);
-      const result = await Promise.resolve(this.func(validatedArgs, context4));
-      return result ?? {};
+      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;
     } catch (error) {
-      if (error instanceof z.ZodError) {
-        return {
-          error: `Invalid arguments for ${this.name}: ${error.message}`
-        };
+      this.logger.error("Error handling sampling request:", error);
+      if (error instanceof McpError) {
+        throw error;
       }
-      return {
-        error: `Error executing ${this.name}: ${error instanceof Error ? error.message : String(error)}`
-      };
+      throw new McpError(
+        `Sampling request failed: ${error instanceof Error ? error.message : String(error)}`,
+        "SAMPLING_ERROR" /* SAMPLING_ERROR */,
+        error instanceof Error ? error : void 0
+      );
     }
   }
   /**
-   * Returns the function declaration for this tool
+   * Convert MCP messages to ADK Content format
    */
-  getDeclaration() {
-    return this.functionDeclaration;
+  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;
   }
   /**
-   * Builds the function declaration from the Zod schema
+   * Convert a single MCP message to ADK Content format
    */
-  buildDeclaration() {
-    const rawParameters = zodToJsonSchema(this.schema, {
-      target: "jsonSchema7",
-      $refStrategy: "none"
-    });
-    const { $schema, ...parameters } = rawParameters;
-    return {
-      name: this.name,
-      description: this.description,
-      parameters
+  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;
   }
-};
-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.
+   * Convert MCP message content to ADK parts format
    */
-  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`
-      );
+  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 }];
   }
-};
-function newInvocationContextId() {
-  return `e-${crypto.randomUUID()}`;
-}
-var InvocationContext = class _InvocationContext {
-  artifactService;
-  sessionService;
-  memoryService;
   /**
-   * The id of this invocation context. Readonly.
+   * Convert ADK response to MCP response format
    */
-  invocationId;
-  /**
-   * The branch of the invocation context.
-   *
-   * The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of
-   * agent_2, and agent_2 is the parent of agent_3.
-   *
-   * Branch is used when multiple sub-agents shouldn't see their peer agents'
-   * conversation history.
-   */
-  branch;
-  /**
-   * The current agent of this invocation context. Readonly.
-   */
-  agent;
-  /**
-   * The user content that started this invocation. Readonly.
-   */
-  userContent;
-  /**
-   * The current session of this invocation context. Readonly.
-   */
-  session;
-  /**
-   * Whether to end this invocation.
-   *
-   * Set to True in callbacks or tools to terminate this invocation.
-   */
-  endInvocation = false;
-  /**
-   * The queue to receive live requests.
-   */
-  liveRequestQueue;
-  /**
-   * The running streaming tools of this invocation.
-   */
-  activeStreamingTools;
-  /**
-   * Caches necessary, data audio or contents, that are needed by transcription.
-   */
-  transcriptionCache;
-  /**
-   * Configurations for live agents under this invocation.
-   */
-  runConfig;
-  /**
-   * A container to keep track of different kinds of costs incurred as a part
-   * of this invocation.
-   */
-  _invocationCostManager = new InvocationCostManager();
-  /**
-   * Constructor for InvocationContext
-   */
-  constructor(options) {
-    this.artifactService = options.artifactService;
-    this.sessionService = options.sessionService;
-    this.memoryService = options.memoryService;
-    this.invocationId = options.invocationId || newInvocationContextId();
-    this.branch = options.branch;
-    this.agent = options.agent;
-    this.userContent = options.userContent;
-    this.session = options.session;
-    this.endInvocation = options.endInvocation || false;
-    this.liveRequestQueue = options.liveRequestQueue;
-    this.activeStreamingTools = options.activeStreamingTools;
-    this.transcriptionCache = options.transcriptionCache;
-    this.runConfig = options.runConfig;
-  }
-  /**
-   * App name from the session
-   */
-  get appName() {
-    return this.session.appName;
-  }
-  /**
-   * User ID from the session
-   */
-  get userId() {
-    return this.session.userId;
-  }
-  /**
-   * Tracks number of llm calls made.
-   *
-   * @throws {LlmCallsLimitExceededError} If number of llm calls made exceed the set threshold.
-   */
-  incrementLlmCallCount() {
-    this._invocationCostManager.incrementAndEnforceLlmCallsLimit(
-      this.runConfig
-    );
+  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;
   }
   /**
-   * Creates a child invocation context for a sub-agent
+   * Update the ADK handler
    */
-  createChildContext(agent) {
-    return new _InvocationContext({
-      artifactService: this.artifactService,
-      sessionService: this.sessionService,
-      memoryService: this.memoryService,
-      invocationId: this.invocationId,
-      // Keep same invocation ID
-      branch: this.branch ? `${this.branch}.${agent.name}` : agent.name,
-      // Update branch
-      agent,
-      // Update to the new agent
-      userContent: this.userContent,
-      session: this.session,
-      endInvocation: this.endInvocation,
-      liveRequestQueue: this.liveRequestQueue,
-      activeStreamingTools: this.activeStreamingTools,
-      transcriptionCache: this.transcriptionCache,
-      runConfig: this.runConfig
-    });
+  updateHandler(handler) {
+    this.samplingHandler = handler;
+    this.logger.debug("ADK sampling handler updated");
   }
 };
+function createSamplingHandler(handler) {
+  return handler;
+}
 
-// src/tools/common/agent-tool.ts
-init_base_tool();
-function isLlmAgent(agent) {
-  return true;
+// src/tools/mcp/utils.ts
+function withRetry(fn, instance, reinitMethod, maxRetries = 1) {
+  return async (...args) => {
+    let attempt = 0;
+    while (attempt <= maxRetries) {
+      try {
+        return await fn.apply(instance, args);
+      } catch (error) {
+        const isClosedResourceError = error instanceof Error && (error.message.includes("closed") || error.message.includes("ECONNRESET") || error.message.includes("socket hang up"));
+        if (!isClosedResourceError || attempt >= maxRetries) {
+          throw error;
+        }
+        console.warn(
+          `Resource closed, reinitializing (attempt ${attempt + 1}/${maxRetries + 1})...`
+        );
+        try {
+          await reinitMethod(instance);
+        } catch (reinitError) {
+          console.error("Error reinitializing resources:", reinitError);
+          throw new Error(`Failed to reinitialize resources: ${reinitError}`);
+        }
+        attempt++;
+      }
+    }
+    throw new Error("Unexpected end of retry loop");
+  };
 }
-var 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
-   */
+
+// src/tools/mcp/client.ts
+var McpClientService = class {
+  config;
+  client = null;
+  transport = null;
+  isClosing = false;
+  mcpSamplingHandler = null;
+  logger = new Logger({ name: "McpClientService" });
   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;
+    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() {
-    if (this.functionDeclaration) {
-      return this.functionDeclaration;
+  async initialize() {
+    if (this.isClosing) {
+      throw new McpError(
+        "Cannot initialize a client that is being closed",
+        "resource_closed_error" /* RESOURCE_CLOSED_ERROR */
+      );
     }
-    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"
-          }
+    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: ["input"]
+        {
+          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 tool by running the agent with the provided input
+   * Creates a transport based on the configuration.
    */
-  async runAsync(params, context4) {
+  async createTransport() {
     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`
+      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 } : {}
+            }
+          }
         );
       }
-      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
+      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
       });
-      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)}`
+      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/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
+   * Re-initializes the MCP client when a session is closed.
+   * Used by the retry mechanism.
    */
-  get actions() {
-    return this.eventActions;
+  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();
   }
   /**
-   * Lists the filenames of the artifacts attached to the current session
+   * Cleans up resources associated with this client service.
+   * Similar to Python's AsyncExitStack.aclose() functionality.
    */
-  async listArtifacts() {
-    if (!this._invocationContext.artifactService) {
-      throw new Error("Artifact service is not initialized.");
+  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;
     }
-    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
+   * Call an MCP tool with retry capability if the session is closed.
    */
-  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
-          }
+  async callTool(name, args) {
+    try {
+      const wrappedCall = withRetry(
+        async function() {
+          const client = await this.initialize();
+          return client.callTool({
+            name,
+            arguments: args
+          });
         },
-        required: ["query"]
+        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 search
-   * This is a simplified implementation that doesn't actually search, just returns mock results
+   * 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, _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();
-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"
-    });
+  async close() {
+    this.logger.debug("\u{1F51A} Closing MCP client service");
+    await this.cleanupResources();
   }
   /**
-   * Get the function declaration for the tool
+   * Checks if the client is currently connected
    */
-  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
+  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
+            );
           }
-        },
-        required: ["url"]
-      }
-    };
+        }
+      );
+      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"
+      );
+    }
   }
   /**
-   * Execute the HTTP request
+   * Set a new ADK sampling handler
    */
-  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;
+  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);
       });
-      const responseBody = await response.text();
-      return {
-        statusCode: response.status,
-        headers: responseHeaders,
-        body: responseBody
-      };
-    } catch (error) {
-      return {
-        statusCode: 0,
-        headers: {},
-        body: "",
-        error: error instanceof Error ? error.message : String(error)
-      };
     }
   }
   /**
-   * Check if a string is valid JSON
+   * Remove the sampling handler
    */
-  isValidJson(str) {
-    try {
-      JSON.parse(str);
-      return true;
-    } catch (e) {
-      return false;
+  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/common/file-operations-tool.ts
+// src/tools/index.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) {
+
+// 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: "file_operations",
-      description: "Perform file system operations like reading, writing, and managing files"
-    });
-    this.basePath = options?.basePath || process.cwd();
-  }
-  /**
-   * Get the function declaration for the tool
-   */
-  getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type5.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)"
-          },
-          encoding: {
-            type: Type5.STRING,
-            description: "File encoding to use",
-            default: "utf8"
-          }
-        },
-        required: ["operation", "filepath"]
-      }
-    };
+      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();
   }
   /**
-   * Execute the file operation
+   * Executes the tool function with validation
    */
-  async runAsync(args, _context) {
+  async runAsync(args, context4) {
     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}`);
-      }
+      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 {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
+        error: `Error executing ${this.name}: ${error instanceof Error ? error.message : String(error)}`
       };
     }
   }
   /**
-   * Resolve a file path relative to the base path
+   * Returns the function declaration for this tool
    */
-  resolvePath(filepath) {
-    return path.isAbsolute(filepath) ? filepath : path.resolve(this.basePath, filepath);
+  getDeclaration() {
+    return this.functionDeclaration;
   }
   /**
-   * Validate that a path is within the base path for security
+   * Builds the function declaration from the Zod schema
    */
-  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`
-      );
-    }
+  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 {
   /**
-   * Read a file
+   * A counter that keeps track of number of llm calls made.
    */
-  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)}`
-      };
-    }
-  }
+  _numberOfLlmCalls = 0;
   /**
-   * Write to a file
+   * Increments _numberOfLlmCalls and enforces the limit.
    */
-  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)}`
-      };
+  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;
   /**
-   * Append to a file
+   * The id of this invocation context. Readonly.
    */
-  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)}`
-      };
-    }
-  }
+  invocationId;
   /**
-   * Delete a file
+   * The branch of the invocation context.
+   *
+   * The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of
+   * agent_2, and agent_2 is the parent of agent_3.
+   *
+   * Branch is used when multiple sub-agents shouldn't see their peer agents'
+   * conversation history.
    */
-  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)}`
-      };
-    }
+  branch;
+  /**
+   * The current agent of this invocation context. Readonly.
+   */
+  agent;
+  /**
+   * The user content that started this invocation. Readonly.
+   */
+  userContent;
+  /**
+   * The current session of this invocation context. Readonly.
+   */
+  session;
+  /**
+   * Whether to end this invocation.
+   *
+   * Set to True in callbacks or tools to terminate this invocation.
+   */
+  endInvocation = false;
+  /**
+   * The queue to receive live requests.
+   */
+  liveRequestQueue;
+  /**
+   * The running streaming tools of this invocation.
+   */
+  activeStreamingTools;
+  /**
+   * Caches necessary, data audio or contents, that are needed by transcription.
+   */
+  transcriptionCache;
+  /**
+   * Configurations for live agents under this invocation.
+   */
+  runConfig;
+  /**
+   * A container to keep track of different kinds of costs incurred as a part
+   * of this invocation.
+   */
+  _invocationCostManager = new InvocationCostManager();
+  /**
+   * Constructor for InvocationContext
+   */
+  constructor(options) {
+    this.artifactService = options.artifactService;
+    this.sessionService = options.sessionService;
+    this.memoryService = options.memoryService;
+    this.invocationId = options.invocationId || newInvocationContextId();
+    this.branch = options.branch;
+    this.agent = options.agent;
+    this.userContent = options.userContent;
+    this.session = options.session;
+    this.endInvocation = options.endInvocation || false;
+    this.liveRequestQueue = options.liveRequestQueue;
+    this.activeStreamingTools = options.activeStreamingTools;
+    this.transcriptionCache = options.transcriptionCache;
+    this.runConfig = options.runConfig;
   }
   /**
-   * Check if a file exists
+   * App name from the session
    */
-  async fileExists(filepath) {
-    try {
-      await fs.access(filepath);
-      return {
-        success: true,
-        data: true
-      };
-    } catch {
-      return {
-        success: true,
-        data: false
-      };
-    }
+  get appName() {
+    return this.session.appName;
+  }
+  /**
+   * User ID from the session
+   */
+  get userId() {
+    return this.session.userId;
   }
   /**
-   * List directory contents
+   * Tracks number of llm calls made.
+   *
+   * @throws {LlmCallsLimitExceededError} If number of llm calls made exceed the set threshold.
    */
-  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)}`
-      };
-    }
+  incrementLlmCallCount() {
+    this._invocationCostManager.incrementAndEnforceLlmCallsLimit(
+      this.runConfig
+    );
   }
   /**
-   * Create a directory
+   * Creates a child invocation context for a sub-agent
    */
-  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)}`
-      };
-    }
+  createChildContext(agent) {
+    return new _InvocationContext({
+      artifactService: this.artifactService,
+      sessionService: this.sessionService,
+      memoryService: this.memoryService,
+      invocationId: this.invocationId,
+      // Keep same invocation ID
+      branch: this.branch ? `${this.branch}.${agent.name}` : agent.name,
+      // Update branch
+      agent,
+      // Update to the new agent
+      userContent: this.userContent,
+      session: this.session,
+      endInvocation: this.endInvocation,
+      liveRequestQueue: this.liveRequestQueue,
+      activeStreamingTools: this.activeStreamingTools,
+      transcriptionCache: this.transcriptionCache,
+      runConfig: this.runConfig
+    });
   }
 };
 
-// src/tools/common/user-interaction-tool.ts
+// src/tools/common/agent-tool.ts
 init_base_tool();
-import { Type as Type6 } from "@google/genai";
-var UserInteractionTool = class extends BaseTool {
-  constructor() {
+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: "user_interaction",
-      description: "Prompt the user for input during agent execution",
-      isLongRunning: true
+      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: this.description,
+      description,
       parameters: {
-        type: Type6.OBJECT,
+        type: Type.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"
+          input: {
+            type: Type.STRING,
+            description: "The input to provide to the agent"
           }
         },
-        required: ["prompt"]
+        required: ["input"]
       }
     };
   }
   /**
-   * Execute the user interaction
+   * Execute the tool by running the agent with the provided input
    */
-  async runAsync(args, context4) {
+  async runAsync(params, context4) {
     try {
-      const actions = context4.actions;
-      if (!actions || !actions.promptUser) {
-        return {
-          success: false,
-          error: "User interaction is not supported in the current environment"
-        };
-      }
-      if (actions.skipSummarization) {
-        actions.skipSummarization(true);
+      const 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 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 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
       });
-      return {
-        success: true,
-        userInput: response
-      };
+      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) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(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/common/exit-loop-tool.ts
-init_logger();
-init_base_tool();
-var ExitLoopTool = class extends BaseTool {
-  logger = new Logger({ name: "ExitLoopTool" });
+// src/tools/tool-context.ts
+var ToolContext = class extends CallbackContext {
   /**
-   * Constructor for ExitLoopTool
+   * The function call id of the current tool call. This id was
+   * returned in the function call event from LLM to identify a function call.
+   * If LLM didn't return this id, ADK will assign one to it. This id is used
+   * to map function call response to the original function call.
    */
-  constructor() {
-    super({
-      name: "exit_loop",
-      description: "Exits the loop. Call this function only when you are instructed to do so."
+  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
     });
   }
   /**
-   * Execute the exit loop action
+   * Searches the memory of the current user
    */
-  async runAsync(_args, context4) {
-    this.logger.debug("Executing exit loop tool");
-    context4.actions.escalate = true;
+  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/common/get-user-choice-tool.ts
+// 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 Type7 } from "@google/genai";
-var GetUserChoiceTool = class extends BaseTool {
-  logger = new Logger({ name: "GetUserChoiceTool" });
+import { Type as Type3 } from "@google/genai";
+var GoogleSearch = class extends BaseTool {
+  logger = new Logger({ name: "GoogleSearch" });
   /**
-   * Constructor for GetUserChoiceTool
+   * Constructor for GoogleSearch
    */
   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
+      name: "google_search",
+      description: "Search the web using Google"
     });
   }
   /**
@@ -4867,54 +4866,55 @@ var GetUserChoiceTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: Type7.OBJECT,
+        type: Type3.OBJECT,
         properties: {
-          options: {
-            type: Type7.ARRAY,
-            description: "List of options for the user to choose from",
-            items: {
-              type: Type7.STRING
-            }
+          query: {
+            type: Type3.STRING,
+            description: "The search query to execute"
           },
-          question: {
-            type: Type7.STRING,
-            description: "The question or prompt to show the user before presenting options"
+          num_results: {
+            type: Type3.INTEGER,
+            description: "Number of results to return (max 10)",
+            default: 5
           }
         },
-        required: ["options"]
+        required: ["query"]
       }
     };
   }
   /**
-   * Execute the user choice action
-   * This is a long running operation that will return null initially
-   * and the actual choice will be provided asynchronously
+   * Execute the search
+   * This is a simplified implementation that doesn't actually search, just returns mock results
    */
-  async runAsync(args, context4) {
+  async runAsync(args, _context) {
     this.logger.debug(
-      `Executing get_user_choice with options: ${args.options.join(", ")}`
+      `[GoogleSearch] Executing Google search for: ${args.query}`
     );
-    if (args.question) {
-      this.logger.debug(`Question: ${args.question}`);
-    }
-    context4.actions.skipSummarization = true;
-    return null;
+    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/transfer-to-agent-tool.ts
-init_logger();
+// src/tools/common/http-request-tool.ts
 init_base_tool();
-import { Type as Type8 } from "@google/genai";
-var TransferToAgentTool = class extends BaseTool {
-  logger = new Logger({ name: "TransferToAgentTool" });
-  /**
-   * Constructor for TransferToAgentTool
-   */
+import { Type as Type4 } from "@google/genai";
+var HttpRequestTool = class extends BaseTool {
   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."
+      name: "http_request",
+      description: "Make HTTP requests to external APIs and web services"
     });
   }
   /**
@@ -4925,40 +4925,115 @@ var TransferToAgentTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: Type8.OBJECT,
+        type: Type4.OBJECT,
         properties: {
-          agent_name: {
-            type: Type8.STRING,
-            description: "The name of the agent to transfer control to"
+          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: ["agent_name"]
+        required: ["url"]
       }
     };
   }
   /**
-   * Execute the transfer to agent action
+   * Execute the HTTP request
    */
-  async runAsync(args, context4) {
-    this.logger.debug(`Executing transfer to agent: ${args.agent_name}`);
-    context4.actions.transferToAgent = args.agent_name;
+  async runAsync(args, _context) {
+    try {
+      const {
+        url,
+        method = "GET",
+        headers = {},
+        body,
+        params,
+        timeout = 1e4
+      } = args;
+      const urlObj = new URL(url);
+      if (params) {
+        Object.entries(params).forEach(([key, value]) => {
+          urlObj.searchParams.append(key, value);
+        });
+      }
+      const requestHeaders = { ...headers };
+      if (body && !requestHeaders["Content-Type"] && this.isValidJson(body)) {
+        requestHeaders["Content-Type"] = "application/json";
+      }
+      const options = {
+        method,
+        headers: requestHeaders,
+        body,
+        signal: AbortSignal.timeout(timeout)
+      };
+      const response = await fetch(urlObj.toString(), options);
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      const responseBody = await response.text();
+      return {
+        statusCode: response.status,
+        headers: responseHeaders,
+        body: responseBody
+      };
+    } catch (error) {
+      return {
+        statusCode: 0,
+        headers: {},
+        body: "",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Check if a string is valid JSON
+   */
+  isValidJson(str) {
+    try {
+      JSON.parse(str);
+      return true;
+    } catch (e) {
+      return false;
+    }
   }
 };
 
-// src/tools/common/load-memory-tool.ts
-init_logger();
+// src/tools/common/file-operations-tool.ts
 init_base_tool();
-import { Type as Type9 } from "@google/genai";
-var LoadMemoryTool = class extends BaseTool {
-  logger = new Logger({ name: "LoadMemoryTool" });
-  /**
-   * Constructor for LoadMemoryTool
-   */
-  constructor() {
+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: "load_memory",
-      description: "Loads the memory for the current user based on a query."
+      name: "file_operations",
+      description: "Perform file system operations like reading, writing, and managing files"
     });
+    this.basePath = options?.basePath || process.cwd();
   }
   /**
    * Get the function declaration for the tool
@@ -4968,672 +5043,601 @@ var LoadMemoryTool = class extends BaseTool {
       name: this.name,
       description: this.description,
       parameters: {
-        type: Type9.OBJECT,
+        type: Type5.OBJECT,
         properties: {
-          query: {
-            type: Type9.STRING,
-            description: "The query to load memories for"
+          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: ["query"]
+        required: ["operation", "filepath"]
       }
     };
   }
   /**
-   * Execute the memory loading action
+   * Execute the file operation
    */
-  async runAsync(args, context4) {
-    this.logger.debug(`Executing load_memory with query: ${args.query}`);
+  async runAsync(args, _context) {
     try {
-      const searchResult = await context4.searchMemory(args.query);
-      return {
-        memories: searchResult.memories || [],
-        count: searchResult.memories?.length || 0
-      };
+      const resolvedPath = this.resolvePath(args.filepath);
+      this.validatePath(resolvedPath);
+      const encoding = args.encoding || "utf8";
+      switch (args.operation) {
+        case "read":
+          return await this.readFile(resolvedPath, encoding);
+        case "write":
+          return await this.writeFile(
+            resolvedPath,
+            args.content || "",
+            encoding
+          );
+        case "append":
+          return await this.appendFile(
+            resolvedPath,
+            args.content || "",
+            encoding
+          );
+        case "delete":
+          return await this.deleteFile(resolvedPath);
+        case "exists":
+          return await this.fileExists(resolvedPath);
+        case "list":
+          return await this.listDirectory(resolvedPath);
+        case "mkdir":
+          return await this.makeDirectory(resolvedPath);
+        default:
+          throw new Error(`Unsupported operation: ${args.operation}`);
+      }
     } catch (error) {
-      console.error("Error searching memory:", error);
       return {
-        error: "Memory search failed",
-        message: error instanceof Error ? error.message : String(error)
+        success: false,
+        error: 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."
-    });
-  }
   /**
-   * Get the function declaration for the tool
+   * Resolve a file path relative to the base path
    */
-  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: []
-      }
-    };
+  resolvePath(filepath) {
+    return path.isAbsolute(filepath) ? filepath : path.resolve(this.basePath, filepath);
   }
   /**
-   * Execute the load artifacts operation
+   * Validate that a path is within the base path for security
    */
-  async runAsync(args, context4) {
-    const artifactNames = args.artifact_names || [];
-    return { artifact_names: artifactNames };
+  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`
+      );
+    }
   }
   /**
-   * Processes the outgoing LLM request for this tool.
+   * Read a file
    */
-  async processLlmRequest(toolContext, llmRequest) {
-    await super.processLlmRequest(toolContext, llmRequest);
-    await this.appendArtifactsToLlmRequest(toolContext, llmRequest);
+  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)}`
+      };
+    }
   }
   /**
-   * Appends artifacts information to the LLM request
+   * Write to a file
    */
-  async appendArtifactsToLlmRequest(toolContext, llmRequest) {
+  async writeFile(filepath, content, encoding) {
     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
-                );
-              }
-            }
-          }
-        }
-      }
+      const dir = path.dirname(filepath);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(filepath, content, { encoding });
+      return {
+        success: true
+      };
     } catch (error) {
-      console.error("Error appending artifacts to LLM request:", error);
+      return {
+        success: false,
+        error: `Failed to write to file: ${error instanceof Error ? error.message : String(error)}`
+      };
     }
   }
   /**
-   * Extracts function response from a part if it exists
+   * Append to a file
    */
-  extractFunctionResponse(part) {
-    if ("functionResponse" in part && part.functionResponse) {
-      return part.functionResponse;
+  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 null;
   }
-};
-
-// 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;
+  /**
+   * Delete a file
+   */
+  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)}`
+      };
+    }
   }
-};
-
-// src/tools/mcp/sampling-handler.ts
-var McpSamplingHandler = class {
-  logger = new Logger({ name: "McpSamplingHandler" });
-  samplingHandler;
-  constructor(samplingHandler) {
-    this.samplingHandler = samplingHandler;
+  /**
+   * Check if a file exists
+   */
+  async fileExists(filepath) {
+    try {
+      await fs.access(filepath);
+      return {
+        success: true,
+        data: true
+      };
+    } catch {
+      return {
+        success: true,
+        data: false
+      };
+    }
   }
   /**
-   * Handle MCP sampling request and convert between formats
+   * List directory contents
    */
-  async handleSamplingRequest(request) {
+  async listDirectory(dirpath) {
     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 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
+          };
+        })
       );
-      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;
+      return {
+        success: true,
+        data: results
+      };
     } catch (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
-      );
+      return {
+        success: false,
+        error: `Failed to list directory: ${error instanceof Error ? error.message : String(error)}`
+      };
     }
   }
   /**
-   * Convert MCP messages to ADK Content format
+   * Create a directory
    */
-  convertMcpMessagesToADK(mcpMessages, systemPrompt) {
-    const contents = [];
-    if (systemPrompt) {
-      contents.push({
-        role: "user",
-        // System messages are typically sent as user role in content
-        parts: [{ text: systemPrompt }]
-      });
+  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)}`
+      };
     }
-    const transformedMessages = mcpMessages.map(
-      (mcpMessage) => this.convertSingleMcpMessageToADK(mcpMessage)
-    );
-    contents.push(...transformedMessages);
-    return contents;
+  }
+};
+
+// 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
+    });
   }
   /**
-   * Convert a single MCP message to ADK Content format
+   * Get the function declaration for the tool
    */
-  convertSingleMcpMessageToADK(mcpMessage) {
-    const adkRole = mcpMessage.role === "assistant" ? "model" : "user";
-    const adkParts = this.convertMcpContentToADKParts(mcpMessage.content);
-    const adkContent = {
-      role: adkRole,
-      parts: adkParts
+  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"]
+      }
     };
-    this.logger.debug(
-      `Converted MCP message - role: ${mcpMessage.role} -> ${adkRole}, content type: ${mcpMessage.content.type}`
-    );
-    return adkContent;
   }
   /**
-   * Convert MCP message content to ADK parts format
+   * Execute the user interaction
    */
-  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 });
+  async runAsync(args, context4) {
+    try {
+      const actions = context4.actions;
+      if (!actions || !actions.promptUser) {
+        return {
+          success: false,
+          error: "User interaction is not supported in the current environment"
+        };
       }
-      if (mcpContent.data && typeof mcpContent.data === "string") {
-        const mimeType = mcpContent.mimeType || "image/jpeg";
-        parts.push({
-          inlineData: {
-            data: mcpContent.data,
-            mimeType
-          }
-        });
+      if (actions.skipSummarization) {
+        actions.skipSummarization(true);
       }
-      return parts.length > 0 ? parts : [{ text: "" }];
+      const promptOptions = args.options && args.options.length > 0 ? {
+        choices: args.options
+      } : void 0;
+      const response = await actions.promptUser({
+        prompt: args.prompt,
+        defaultValue: args.defaultValue,
+        options: promptOptions
+      });
+      return {
+        success: true,
+        userInput: response
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
-    this.logger.warn(`Unknown MCP content type: ${mcpContent.type}`);
-    const fallbackText = typeof mcpContent.data === "string" ? mcpContent.data : "";
-    return [{ text: fallbackText }];
   }
+};
+
+// 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
+   */
+  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/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" });
   /**
-   * Convert ADK response to MCP response format
+   * Constructor for GetUserChoiceTool
    */
-  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
+  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
+    });
+  }
+  /**
+   * Get the function declaration for the tool
+   */
+  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"]
       }
     };
-    this.logger.debug(`Received content: ${responseText}`);
-    return mcpResponse;
   }
   /**
-   * Update the ADK handler
+   * Execute the user choice action
+   * This is a long running operation that will return null initially
+   * and the actual choice will be provided asynchronously
    */
-  updateHandler(handler) {
-    this.samplingHandler = handler;
-    this.logger.debug("ADK sampling handler updated");
+  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;
   }
 };
-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);
-    }
-  }
+// 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" });
   /**
-   * Initializes and returns an MCP client based on configuration.
-   * Will create a new client if one doesn't exist yet.
+   * Constructor for TransferToAgentTool
    */
-  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;
-    }
+  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."
+    });
   }
   /**
-   * Creates a transport based on the configuration.
+   * Get the function declaration for the tool
    */
-  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 } : {}
-            }
+  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"]
       }
-      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
-      );
-    }
+    };
+  }
+  /**
+   * Execute the transfer to agent action
+   */
+  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" });
   /**
-   * Re-initializes the MCP client when a session is closed.
-   * Used by the retry mechanism.
+   * Constructor for LoadMemoryTool
    */
-  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();
+  constructor() {
+    super({
+      name: "load_memory",
+      description: "Loads the memory for the current user based on a query."
+    });
   }
   /**
-   * Cleans up resources associated with this client service.
-   * Similar to Python's AsyncExitStack.aclose() functionality.
+   * Get the function declaration for the tool
    */
-  async cleanupResources() {
-    try {
-      this.isClosing = true;
-      if (this.client) {
-        try {
-          if (typeof this.client.close === "function") {
-            await this.client.close();
+  getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type9.OBJECT,
+        properties: {
+          query: {
+            type: Type9.STRING,
+            description: "The query to load memories for"
           }
-        } catch (err) {
-        }
-      }
-      if (this.transport && typeof this.transport.close === "function") {
-        await this.transport.close();
+        },
+        required: ["query"]
       }
-      this.logger.debug("\u{1F9F9} Cleaned up MCP client resources");
+    };
+  }
+  /**
+   * 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
+      };
     } catch (error) {
-      this.logger.error("Error cleaning up MCP resources:", error);
-    } finally {
-      this.client = null;
-      this.transport = null;
-      this.isClosing = false;
+      console.error("Error searching memory:", error);
+      return {
+        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."
+    });
+  }
   /**
-   * Call an MCP tool with retry capability if the session is closed.
+   * Get the function declaration for the tool
    */
-  async callTool(name, args) {
-    try {
-      const wrappedCall = withRetry(
-        async function() {
-          const client = await this.initialize();
-          return client.callTool({
-            name,
-            arguments: args
-          });
+  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"
+          }
         },
-        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
-        );
+        required: []
       }
-      throw error;
-    }
+    };
   }
   /**
-   * Closes and cleans up all resources.
-   * Should be called when the service is no longer needed.
-   * Similar to Python's close() method.
+   * Execute the load artifacts operation
    */
-  async close() {
-    this.logger.debug("\u{1F51A} Closing MCP client service");
-    await this.cleanupResources();
+  async runAsync(args, context4) {
+    const artifactNames = args.artifact_names || [];
+    return { artifact_names: artifactNames };
   }
   /**
-   * Checks if the client is currently connected
+   * Processes the outgoing LLM request for this tool.
    */
-  isConnected() {
-    return !!this.client && !this.isClosing;
+  async processLlmRequest(toolContext, llmRequest) {
+    await super.processLlmRequest(toolContext, llmRequest);
+    await this.appendArtifactsToLlmRequest(toolContext, llmRequest);
   }
-  async setupSamplingHandler(client) {
-    if (!this.mcpSamplingHandler) {
-      this.logger.debug(
-        "\u26A0\uFE0F No sampling handler provided - sampling requests will be rejected"
-      );
-      return;
-    }
+  /**
+   * Appends artifacts information to the LLM request
+   */
+  async appendArtifactsToLlmRequest(toolContext, llmRequest) {
     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;
+      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
+                );
+              }
             }
-            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);
-      });
+      console.error("Error appending artifacts to LLM request:", error);
     }
   }
   /**
-   * Remove the sampling handler
+   * Extracts function response from a part if it exists
    */
-  removeSamplingHandler() {
-    this.mcpSamplingHandler = null;
-    if (this.client) {
-      try {
-        this.client.removeRequestHandler?.("sampling/createMessage");
-      } catch (error) {
-        this.logger.error("Failed to remove sampling handler:", error);
-      }
+  extractFunctionResponse(part) {
+    if ("functionResponse" in part && part.functionResponse) {
+      return part.functionResponse;
     }
+    return null;
   }
 };
 
@@ -6028,6 +6032,14 @@ function McpCoinGecko(config = {}) {
   );
   return new McpToolset(mcpConfig);
 }
+function McpUpbit(config = {}) {
+  const mcpConfig = createMcpConfig(
+    "Upbit MCP Client",
+    "@iqai/mcp-upbit",
+    config
+  );
+  return new McpToolset(mcpConfig);
+}
 function McpFilesystem(config = {}) {
   const mcpConfig = createMcpConfig(
     "Filesystem MCP Client",
@@ -13221,6 +13233,7 @@ export {
   McpAbi,
   McpAtp,
   McpBamm,
+  McpClientService,
   McpCoinGecko,
   McpDiscord,
   McpError,
@@ -13236,6 +13249,7 @@ export {
   McpSamplingHandler,
   McpTelegram,
   McpToolset,
+  McpUpbit,
   memory_exports as Memory,
   models_exports as Models,
   OAuth2Credential,