@iqai/adk 0.2.0 → 0.2.1

package/dist/index.js

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