@iqai/adk 0.0.2 → 0.0.4

package/dist/index.js

@@ -114,7 +114,7 @@ var init_base_tool = __esm({
         }
         return {
           error: "Execution failed",
-          message: _optionalChain([lastError, 'optionalAccess', _ => _.message]) || "Unknown error occurred",
+          message: _optionalChain([lastError, 'optionalAccess', _2 => _2.message]) || "Unknown error occurred",
           tool: this.name
         };
       }
@@ -254,14 +254,14 @@ var init_function_tool = __esm({
        * @param options Optional configuration for the tool
        */
       constructor(func, options) {
-        const name = _optionalChain([options, 'optionalAccess', _2 => _2.name]) || func.name;
-        const description = _optionalChain([options, 'optionalAccess', _3 => _3.description]) || _optionalChain([(func.toString().match(/\/\*\*([\s\S]*?)\*\//) || []), 'access', _4 => _4[1], 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]) || "";
+        const name = _optionalChain([options, 'optionalAccess', _3 => _3.name]) || func.name;
+        const description = _optionalChain([options, 'optionalAccess', _4 => _4.description]) || _optionalChain([(func.toString().match(/\/\*\*([\s\S]*?)\*\//) || []), 'access', _5 => _5[1], 'optionalAccess', _6 => _6.trim, 'call', _7 => _7()]) || "";
         super({
           name,
           description,
-          isLongRunning: _optionalChain([options, 'optionalAccess', _7 => _7.isLongRunning]) || false,
-          shouldRetryOnFailure: _optionalChain([options, 'optionalAccess', _8 => _8.shouldRetryOnFailure]) || false,
-          maxRetryAttempts: _optionalChain([options, 'optionalAccess', _9 => _9.maxRetryAttempts]) || 3
+          isLongRunning: _optionalChain([options, 'optionalAccess', _8 => _8.isLongRunning]) || false,
+          shouldRetryOnFailure: _optionalChain([options, 'optionalAccess', _9 => _9.shouldRetryOnFailure]) || false,
+          maxRetryAttempts: _optionalChain([options, 'optionalAccess', _10 => _10.maxRetryAttempts]) || 3
         });
         this.mandatoryArgs = [];
         this.func = func;
@@ -587,13 +587,13 @@ var StreamingMode = /* @__PURE__ */ ((StreamingMode2) => {
 })(StreamingMode || {});
 var RunConfig = class {
   constructor(config) {
-    this.speechConfig = _optionalChain([config, 'optionalAccess', _10 => _10.speechConfig]);
-    this.responseModalities = _optionalChain([config, 'optionalAccess', _11 => _11.responseModalities]);
-    this.saveInputBlobsAsArtifacts = _optionalChain([config, 'optionalAccess', _12 => _12.saveInputBlobsAsArtifacts]) || false;
-    this.supportCFC = _optionalChain([config, 'optionalAccess', _13 => _13.supportCFC]) || false;
-    this.streamingMode = _optionalChain([config, 'optionalAccess', _14 => _14.streamingMode]) || "NONE" /* NONE */;
+    this.speechConfig = _optionalChain([config, 'optionalAccess', _11 => _11.speechConfig]);
+    this.responseModalities = _optionalChain([config, 'optionalAccess', _12 => _12.responseModalities]);
+    this.saveInputBlobsAsArtifacts = _optionalChain([config, 'optionalAccess', _13 => _13.saveInputBlobsAsArtifacts]) || false;
+    this.supportCFC = _optionalChain([config, 'optionalAccess', _14 => _14.supportCFC]) || false;
+    this.streamingMode = _optionalChain([config, 'optionalAccess', _15 => _15.streamingMode]) || "NONE" /* NONE */;
     this.stream = this.streamingMode !== "NONE" /* NONE */;
-    this.outputAudioTranscription = _optionalChain([config, 'optionalAccess', _15 => _15.outputAudioTranscription]);
+    this.outputAudioTranscription = _optionalChain([config, 'optionalAccess', _16 => _16.outputAudioTranscription]);
   }
 };
 
@@ -685,7 +685,7 @@ var InvocationContext = class _InvocationContext {
     session.metadata = { ...this.metadata };
     session.updatedAt = /* @__PURE__ */ new Date();
     Object.entries(this.variables).forEach(([key, value]) => {
-      _optionalChain([session, 'optionalAccess', _16 => _16.state, 'access', _17 => _17.set, 'call', _18 => _18(key, value)]);
+      _optionalChain([session, 'optionalAccess', _17 => _17.state, 'access', _18 => _18.set, 'call', _19 => _19(key, value)]);
     });
     await this.sessionService.updateSession(session);
     if (this.memoryService) {
@@ -705,7 +705,7 @@ var InvocationContext = class _InvocationContext {
     }
     const searchOptions = {
       ...options,
-      sessionId: _optionalChain([options, 'optionalAccess', _19 => _19.sessionId]) || this.sessionId
+      sessionId: _optionalChain([options, 'optionalAccess', _20 => _20.sessionId]) || this.sessionId
     };
     return await this.memoryService.searchMemory(query, searchOptions);
   }
@@ -1482,7 +1482,7 @@ var LoopAgent = class extends BaseAgent {
           messages: conditionMessages,
           config
         });
-        const content = _optionalChain([conditionResponse, 'access', _20 => _20.content, 'optionalAccess', _21 => _21.toLowerCase, 'call', _22 => _22()]) || "";
+        const content = _optionalChain([conditionResponse, 'access', _21 => _21.content, 'optionalAccess', _22 => _22.toLowerCase, 'call', _23 => _23()]) || "";
         const shouldContinue = content.includes("yes") && !content.includes("no");
         if (process.env.DEBUG === "true") {
           console.log(
@@ -1886,12 +1886,12 @@ var LangGraphAgent = class extends BaseAgent {
         };
       }
     }
-    const lastNodeResult = _optionalChain([this, 'access', _23 => _23.results, 'access', _24 => _24[this.results.length - 1], 'optionalAccess', _25 => _25.result]);
+    const lastNodeResult = _optionalChain([this, 'access', _24 => _24.results, 'access', _25 => _25[this.results.length - 1], 'optionalAccess', _26 => _26.result]);
     if (this.isLLMResponse(lastNodeResult)) {
       return lastNodeResult;
     }
     return {
-      content: `Graph execution complete. Final result from node "${_optionalChain([this, 'access', _26 => _26.results, 'access', _27 => _27[this.results.length - 1], 'optionalAccess', _28 => _28.node])}": ${typeof lastNodeResult === "string" ? lastNodeResult : JSON.stringify(lastNodeResult, null, 2)}`,
+      content: `Graph execution complete. Final result from node "${_optionalChain([this, 'access', _27 => _27.results, 'access', _28 => _28[this.results.length - 1], 'optionalAccess', _29 => _29.node])}": ${typeof lastNodeResult === "string" ? lastNodeResult : JSON.stringify(lastNodeResult, null, 2)}`,
       role: "assistant"
     };
   }
@@ -2000,12 +2000,12 @@ Node output: ${this.extractTextContent(result.content)}` : ""}`,
         return;
       }
     }
-    const lastNodeResult = _optionalChain([this, 'access', _29 => _29.results, 'access', _30 => _30[this.results.length - 1], 'optionalAccess', _31 => _31.result]);
+    const lastNodeResult = _optionalChain([this, 'access', _30 => _30.results, 'access', _31 => _31[this.results.length - 1], 'optionalAccess', _32 => _32.result]);
     if (this.isLLMResponse(lastNodeResult)) {
       yield lastNodeResult;
     } else {
       yield {
-        content: `Graph execution complete. Final result from node "${_optionalChain([this, 'access', _32 => _32.results, 'access', _33 => _33[this.results.length - 1], 'optionalAccess', _34 => _34.node])}": ${typeof lastNodeResult === "string" ? lastNodeResult : JSON.stringify(lastNodeResult, null, 2)}`,
+        content: `Graph execution complete. Final result from node "${_optionalChain([this, 'access', _33 => _33.results, 'access', _34 => _34[this.results.length - 1], 'optionalAccess', _35 => _35.node])}": ${typeof lastNodeResult === "string" ? lastNodeResult : JSON.stringify(lastNodeResult, null, 2)}`,
         role: "assistant"
       };
     }
@@ -2023,11 +2023,19 @@ __export(tools_exports, {
   GoogleSearch: () => GoogleSearch,
   HttpRequestTool: () => HttpRequestTool,
   LoadMemoryTool: () => LoadMemoryTool,
+  McpError: () => McpError,
+  McpErrorType: () => McpErrorType,
+  McpToolset: () => McpToolset,
   ToolContext: () => ToolContext,
   TransferToAgentTool: () => TransferToAgentTool,
   UserInteractionTool: () => UserInteractionTool,
+  adkToMcpToolType: () => adkToMcpToolType,
   buildFunctionDeclaration: () => buildFunctionDeclaration,
-  createFunctionTool: () => createFunctionTool
+  createFunctionTool: () => createFunctionTool,
+  getMcpTools: () => getMcpTools,
+  jsonSchemaToDeclaration: () => jsonSchemaToDeclaration,
+  mcpSchemaToParameters: () => mcpSchemaToParameters,
+  normalizeJsonSchema: () => normalizeJsonSchema
 });
 init_base_tool();
 init_function_tool();
@@ -2233,7 +2241,7 @@ var FileOperationsTool = class extends BaseTool {
       name: "file_operations",
       description: "Perform file system operations like reading, writing, and managing files"
     });
-    this.basePath = _optionalChain([options, 'optionalAccess', _35 => _35.basePath]) || process.cwd();
+    this.basePath = _optionalChain([options, 'optionalAccess', _36 => _36.basePath]) || process.cwd();
   }
   /**
    * Get the function declaration for the tool
@@ -2756,7 +2764,7 @@ var LoadMemoryTool = class extends BaseTool {
       const searchResult = await context.searchMemory(args.query);
       return {
         memories: searchResult.memories || [],
-        count: _optionalChain([searchResult, 'access', _36 => _36.memories, 'optionalAccess', _37 => _37.length]) || 0
+        count: _optionalChain([searchResult, 'access', _37 => _37.memories, 'optionalAccess', _38 => _38.length]) || 0
       };
     } catch (error) {
       console.error("Error searching memory:", error);
@@ -2768,6 +2776,702 @@ var LoadMemoryTool = class extends BaseTool {
   }
 };
 
+// src/tools/mcp/client.ts
+var _indexjs = require('@modelcontextprotocol/sdk/client/index.js');
+var _ssejs = require('@modelcontextprotocol/sdk/client/sse.js');
+var _stdiojs = require('@modelcontextprotocol/sdk/client/stdio.js');
+
+// src/tools/mcp/types.ts
+var McpErrorType = /* @__PURE__ */ ((McpErrorType2) => {
+  McpErrorType2["CONNECTION_ERROR"] = "connection_error";
+  McpErrorType2["TOOL_EXECUTION_ERROR"] = "tool_execution_error";
+  McpErrorType2["RESOURCE_CLOSED_ERROR"] = "resource_closed_error";
+  McpErrorType2["TIMEOUT_ERROR"] = "timeout_error";
+  McpErrorType2["INVALID_SCHEMA_ERROR"] = "invalid_schema_error";
+  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/utils.ts
+function withRetry(fn, instance, reinitMethod, maxRetries = 1) {
+  return async (...args) => {
+    let attempt = 0;
+    while (attempt <= maxRetries) {
+      try {
+        return await fn.apply(instance, args);
+      } catch (error) {
+        const isClosedResourceError = error instanceof Error && (error.message.includes("closed") || error.message.includes("ECONNRESET") || error.message.includes("socket hang up"));
+        if (!isClosedResourceError || attempt >= maxRetries) {
+          throw error;
+        }
+        console.warn(
+          `Resource closed, reinitializing (attempt ${attempt + 1}/${maxRetries + 1})...`
+        );
+        try {
+          await reinitMethod(instance);
+        } catch (reinitError) {
+          console.error("Error reinitializing resources:", reinitError);
+          throw new Error(`Failed to reinitialize resources: ${reinitError}`);
+        }
+        attempt++;
+      }
+    }
+    throw new Error("Unexpected end of retry loop");
+  };
+}
+
+// src/tools/mcp/client.ts
+var McpClientService = class {
+  constructor(config) {
+    this.client = null;
+    this.transport = null;
+    this.isClosing = false;
+    this.config = config;
+  }
+  /**
+   * Initializes and returns an MCP client based on configuration.
+   * Will create a new client if one doesn't exist yet.
+   */
+  async initialize() {
+    if (this.isClosing) {
+      throw new McpError(
+        "Cannot initialize a client that is being closed",
+        "resource_closed_error" /* RESOURCE_CLOSED_ERROR */
+      );
+    }
+    if (this.client) {
+      return this.client;
+    }
+    try {
+      if (!this.transport) {
+        this.transport = await this.createTransport();
+      }
+      const client = new (0, _indexjs.Client)(
+        {
+          name: this.config.name,
+          version: "0.0.1"
+        },
+        {
+          capabilities: {
+            prompts: {},
+            resources: {},
+            tools: {}
+          }
+        }
+      );
+      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;
+      }
+      if (this.config.debug) {
+        console.log("\u2705 MCP client connected successfully");
+      }
+      this.client = client;
+      return client;
+    } catch (error) {
+      await this.cleanupResources();
+      if (!(error instanceof McpError)) {
+        console.error("Failed to initialize MCP client:", error);
+        throw new McpError(
+          `Failed to initialize MCP client: ${error instanceof Error ? error.message : String(error)}`,
+          "connection_error" /* CONNECTION_ERROR */,
+          error instanceof Error ? error : void 0
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Creates a transport based on the configuration.
+   */
+  async createTransport() {
+    try {
+      if (this.config.transport.mode === "sse") {
+        if (this.config.debug) {
+          console.log(
+            "\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 } : {}
+            }
+          }
+        );
+      }
+      if (this.config.debug) {
+        console.log(
+          "\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
+      );
+    }
+  }
+  /**
+   * Re-initializes the MCP client when a session is closed.
+   * Used by the retry mechanism.
+   */
+  async reinitialize() {
+    if (this.config.debug) {
+      console.log("\u{1F504} Reinitializing MCP client after closed connection");
+    }
+    await this.cleanupResources();
+    this.client = null;
+    this.transport = null;
+    await this.initialize();
+  }
+  /**
+   * Cleans up resources associated with this client service.
+   * Similar to Python's AsyncExitStack.aclose() functionality.
+   */
+  async cleanupResources() {
+    try {
+      this.isClosing = true;
+      if (this.client) {
+        try {
+          if (typeof this.client.close === "function") {
+            await this.client.close();
+          }
+        } catch (err) {
+        }
+      }
+      if (this.transport && typeof this.transport.close === "function") {
+        await this.transport.close();
+      }
+      if (this.config.debug) {
+        console.log("\u{1F9F9} Cleaned up MCP client resources");
+      }
+    } catch (error) {
+      console.error("Error cleaning up MCP resources:", error);
+    } finally {
+      this.client = null;
+      this.transport = null;
+      this.isClosing = false;
+    }
+  }
+  /**
+   * Call an MCP tool with retry capability if the session is closed.
+   */
+  async callTool(name, args) {
+    try {
+      const wrappedCall = withRetry(
+        async function() {
+          const client = await this.initialize();
+          return client.callTool({
+            name,
+            arguments: args
+          });
+        },
+        this,
+        async (instance) => await instance.reinitialize(),
+        _optionalChain([this, 'access', _39 => _39.config, 'access', _40 => _40.retryOptions, 'optionalAccess', _41 => _41.maxRetries]) || 2
+      );
+      return await wrappedCall();
+    } catch (error) {
+      if (!(error instanceof McpError)) {
+        throw new McpError(
+          `Error calling tool "${name}": ${error instanceof Error ? error.message : String(error)}`,
+          "tool_execution_error" /* TOOL_EXECUTION_ERROR */,
+          error instanceof Error ? error : void 0
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Closes and cleans up all resources.
+   * Should be called when the service is no longer needed.
+   * Similar to Python's close() method.
+   */
+  async close() {
+    if (this.config.debug) {
+      console.log("\u{1F51A} Closing MCP client service");
+    }
+    await this.cleanupResources();
+  }
+  /**
+   * Checks if the client is currently connected
+   */
+  isConnected() {
+    return !!this.client && !this.isClosing;
+  }
+};
+
+// src/tools/mcp/create-tool.ts
+init_base_tool();
+
+// src/tools/mcp/schema-conversion.ts
+function adkToMcpToolType(tool) {
+  const declaration = tool.getDeclaration();
+  const params = declarationToJsonSchema(declaration);
+  return {
+    name: tool.name,
+    description: tool.description || "",
+    inputSchema: {
+      type: "object",
+      properties: params
+    }
+  };
+}
+function declarationToJsonSchema(declaration) {
+  if (!declaration.parameters) {
+    return {};
+  }
+  if (declaration.parameters.properties) {
+    return declaration.parameters.properties;
+  }
+  return declaration.parameters;
+}
+function jsonSchemaToDeclaration(name, description, schema) {
+  let parameters;
+  if (schema) {
+    if (typeof schema === "object" && "type" in schema && typeof schema.type === "string") {
+      parameters = schema;
+    } else {
+      parameters = {
+        type: "object",
+        properties: schema
+      };
+    }
+  } else {
+    parameters = {
+      type: "object",
+      properties: {}
+    };
+  }
+  return {
+    name,
+    description,
+    parameters
+  };
+}
+function normalizeJsonSchema(schema) {
+  if (!schema) {
+    return { type: "object", properties: {} };
+  }
+  const normalizedSchema = { ...schema };
+  if (!normalizedSchema.type) {
+    normalizedSchema.type = determineSchemaType(normalizedSchema);
+  }
+  switch (normalizedSchema.type) {
+    case "object":
+      return normalizeObjectSchema(normalizedSchema);
+    case "array":
+      return normalizeArraySchema(normalizedSchema);
+    case "string":
+      return normalizeStringSchema(normalizedSchema);
+    case "number":
+    case "integer":
+      return normalizeNumberSchema(normalizedSchema);
+    case "boolean":
+      return { type: "boolean" };
+    case "null":
+      return { type: "null" };
+    default:
+      return normalizedSchema;
+  }
+}
+function determineSchemaType(schema) {
+  if (schema.properties || schema.required || schema.additionalProperties !== void 0) {
+    return "object";
+  }
+  if (schema.items) {
+    return "array";
+  }
+  if (schema.enum !== void 0) {
+    if (schema.enum.length === 0) return "string";
+    const firstItem = schema.enum[0];
+    if (typeof firstItem === "string") return "string";
+    if (typeof firstItem === "number") return "number";
+    if (typeof firstItem === "boolean") return "boolean";
+    return "string";
+  }
+  if (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern) {
+    return "string";
+  }
+  if (schema.minimum !== void 0 || schema.maximum !== void 0 || schema.exclusiveMinimum !== void 0 || schema.exclusiveMaximum !== void 0) {
+    return schema.multipleOf === void 0 || schema.multipleOf % 1 === 0 ? "integer" : "number";
+  }
+  return "object";
+}
+function normalizeObjectSchema(schema) {
+  const normalizedSchema = {
+    type: "object",
+    properties: {}
+  };
+  if (schema.properties) {
+    normalizedSchema.properties = {};
+    for (const [key, value] of Object.entries(schema.properties)) {
+      normalizedSchema.properties[key] = normalizeJsonSchema(
+        value
+      );
+    }
+  }
+  if (schema.required) normalizedSchema.required = schema.required;
+  if (schema.additionalProperties !== void 0)
+    normalizedSchema.additionalProperties = schema.additionalProperties;
+  if (schema.title) normalizedSchema.title = schema.title;
+  if (schema.description) normalizedSchema.description = schema.description;
+  return normalizedSchema;
+}
+function normalizeArraySchema(schema) {
+  const normalizedSchema = {
+    type: "array"
+  };
+  if (schema.items) {
+    normalizedSchema.items = normalizeJsonSchema(
+      schema.items
+    );
+  }
+  if (schema.minItems !== void 0)
+    normalizedSchema.minItems = schema.minItems;
+  if (schema.maxItems !== void 0)
+    normalizedSchema.maxItems = schema.maxItems;
+  if (schema.uniqueItems !== void 0)
+    normalizedSchema.uniqueItems = schema.uniqueItems;
+  if (schema.title) normalizedSchema.title = schema.title;
+  if (schema.description) normalizedSchema.description = schema.description;
+  return normalizedSchema;
+}
+function normalizeStringSchema(schema) {
+  const normalizedSchema = {
+    type: "string"
+  };
+  if (schema.minLength !== void 0)
+    normalizedSchema.minLength = schema.minLength;
+  if (schema.maxLength !== void 0)
+    normalizedSchema.maxLength = schema.maxLength;
+  if (schema.pattern) normalizedSchema.pattern = schema.pattern;
+  if (schema.format) normalizedSchema.format = schema.format;
+  if (schema.enum) normalizedSchema.enum = schema.enum;
+  if (schema.title) normalizedSchema.title = schema.title;
+  if (schema.description) normalizedSchema.description = schema.description;
+  return normalizedSchema;
+}
+function normalizeNumberSchema(schema) {
+  const normalizedSchema = {
+    type: schema.type
+  };
+  if (schema.minimum !== void 0) normalizedSchema.minimum = schema.minimum;
+  if (schema.maximum !== void 0) normalizedSchema.maximum = schema.maximum;
+  if (schema.exclusiveMinimum !== void 0)
+    normalizedSchema.exclusiveMinimum = schema.exclusiveMinimum;
+  if (schema.exclusiveMaximum !== void 0)
+    normalizedSchema.exclusiveMaximum = schema.exclusiveMaximum;
+  if (schema.multipleOf !== void 0)
+    normalizedSchema.multipleOf = schema.multipleOf;
+  if (schema.enum) normalizedSchema.enum = schema.enum;
+  if (schema.title) normalizedSchema.title = schema.title;
+  if (schema.description) normalizedSchema.description = schema.description;
+  return normalizedSchema;
+}
+function mcpSchemaToParameters(mcpTool) {
+  let schema;
+  if (mcpTool.inputSchema) {
+    schema = mcpTool.inputSchema;
+  } else if (mcpTool.parameters) {
+    schema = mcpTool.parameters;
+  }
+  if (!schema) {
+    return {
+      type: "object",
+      properties: {}
+    };
+  }
+  return normalizeJsonSchema(schema);
+}
+
+// src/tools/mcp/create-tool.ts
+async function createTool(mcpTool, client) {
+  try {
+    return new McpToolAdapter(mcpTool, client);
+  } catch (error) {
+    if (!(error instanceof McpError)) {
+      throw new McpError(
+        `Failed to create tool from MCP tool: ${error instanceof Error ? error.message : String(error)}`,
+        "invalid_schema_error" /* INVALID_SCHEMA_ERROR */,
+        error instanceof Error ? error : void 0
+      );
+    }
+    throw error;
+  }
+}
+var McpToolAdapter = class extends BaseTool {
+  constructor(mcpTool, client) {
+    const metadata = mcpTool.metadata || {};
+    super({
+      name: mcpTool.name || `mcp_${Date.now()}`,
+      description: mcpTool.description || "MCP Tool",
+      isLongRunning: _nullishCoalesce(metadata.isLongRunning, () => ( false)),
+      shouldRetryOnFailure: _nullishCoalesce(metadata.shouldRetryOnFailure, () => ( false)),
+      maxRetryAttempts: _nullishCoalesce(metadata.maxRetryAttempts, () => ( 3))
+    });
+    this.clientService = null;
+    this.mcpTool = mcpTool;
+    this.client = client;
+    if (client.reinitialize && typeof client.reinitialize === "function") {
+      this.clientService = client;
+    }
+  }
+  getDeclaration() {
+    try {
+      const parameters = mcpSchemaToParameters(this.mcpTool);
+      return {
+        name: this.name,
+        description: this.description,
+        parameters
+      };
+    } catch (error) {
+      throw new McpError(
+        `Failed to convert schema for tool ${this.name}: ${error instanceof Error ? error.message : String(error)}`,
+        "invalid_schema_error" /* INVALID_SCHEMA_ERROR */,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async runAsync(args, _context) {
+    if (process.env.DEBUG === "true") {
+      console.log(`Executing MCP tool ${this.name} with args:`, args);
+    }
+    try {
+      if (typeof this.mcpTool.execute === "function") {
+        return await this.mcpTool.execute(args);
+      }
+      if (this.clientService) {
+        return await this.clientService.callTool(this.name, args);
+      }
+      if (this.client && typeof this.client.callTool === "function") {
+        if (this.shouldRetryOnFailure) {
+          const executeWithRetry = withRetry(
+            async () => {
+              return await this.client.callTool({
+                name: this.name,
+                arguments: args
+              });
+            },
+            this,
+            async () => {
+              console.warn(
+                `MCP tool ${this.name} encountered a closed resource, but cannot reinitialize client.`
+              );
+            },
+            this.maxRetryAttempts
+          );
+          return await executeWithRetry();
+        }
+        const result = await this.client.callTool({
+          name: this.name,
+          arguments: args
+        });
+        return result;
+      }
+      throw new McpError(
+        `Cannot execute MCP tool ${this.name}: No execution method found`,
+        "tool_execution_error" /* TOOL_EXECUTION_ERROR */
+      );
+    } catch (error) {
+      if (!(error instanceof McpError)) {
+        console.error(`Error executing MCP tool ${this.name}:`, error);
+        throw new McpError(
+          `Error executing MCP tool ${this.name}: ${error instanceof Error ? error.message : String(error)}`,
+          "tool_execution_error" /* TOOL_EXECUTION_ERROR */,
+          error instanceof Error ? error : void 0
+        );
+      }
+      throw error;
+    }
+  }
+};
+
+// src/tools/mcp/index.ts
+var McpToolset = class {
+  constructor(config, toolFilter = null) {
+    this.clientService = null;
+    this.toolFilter = null;
+    this.tools = [];
+    this.isClosing = false;
+    this.config = config;
+    this.toolFilter = toolFilter;
+    this.clientService = new McpClientService(config);
+  }
+  /**
+   * Checks if a tool should be included based on the tool filter.
+   * Similar to Python's _is_selected method.
+   */
+  isSelected(tool, context) {
+    if (!this.toolFilter) {
+      return true;
+    }
+    if (typeof this.toolFilter === "function") {
+      return this.toolFilter(tool, context);
+    }
+    if (Array.isArray(this.toolFilter)) {
+      return this.toolFilter.includes(tool.name);
+    }
+    return true;
+  }
+  /**
+   * Initializes the client service and establishes a connection.
+   */
+  async initialize() {
+    if (this.isClosing) {
+      throw new McpError(
+        "Cannot initialize a toolset that is being closed",
+        "resource_closed_error" /* RESOURCE_CLOSED_ERROR */
+      );
+    }
+    if (!this.clientService) {
+      this.clientService = new McpClientService(this.config);
+    }
+    await this.clientService.initialize();
+    return this.clientService;
+  }
+  /**
+   * Retrieves tools from the MCP server and converts them to BaseTool instances.
+   * Similar to Python's get_tools method.
+   */
+  async getTools(context) {
+    try {
+      if (this.isClosing) {
+        throw new McpError(
+          "Cannot get tools from a toolset that is being closed",
+          "resource_closed_error" /* RESOURCE_CLOSED_ERROR */
+        );
+      }
+      if (this.tools.length > 0 && !_optionalChain([this, 'access', _42 => _42.config, 'access', _43 => _43.cacheConfig, 'optionalAccess', _44 => _44.enabled]) === false) {
+        return this.tools;
+      }
+      if (!this.clientService) {
+        await this.initialize();
+      }
+      const client = await this.clientService.initialize();
+      const toolsResponse = await client.listTools();
+      if (!toolsResponse.tools || !Array.isArray(toolsResponse.tools)) {
+        console.warn("MCP server returned no tools or invalid tools array");
+        return [];
+      }
+      const tools = [];
+      for (const mcpTool of toolsResponse.tools) {
+        if (this.isSelected(mcpTool, context)) {
+          try {
+            const tool = await createTool(mcpTool, client);
+            tools.push(tool);
+          } catch (toolError) {
+            console.error(
+              `Failed to create tool from MCP tool "${mcpTool.name}":`,
+              toolError
+            );
+          }
+        }
+      }
+      if (_optionalChain([this, 'access', _45 => _45.config, 'access', _46 => _46.cacheConfig, 'optionalAccess', _47 => _47.enabled]) !== false) {
+        this.tools = tools;
+      }
+      return tools;
+    } catch (error) {
+      if (!(error instanceof McpError)) {
+        console.error("Error retrieving MCP tools:", error);
+        throw new McpError(
+          `Error retrieving MCP tools: ${error instanceof Error ? error.message : String(error)}`,
+          "connection_error" /* CONNECTION_ERROR */,
+          error instanceof Error ? error : void 0
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Converts ADK tools to MCP tool format for bidirectional support
+   */
+  convertADKToolsToMCP(tools) {
+    return tools.map((tool) => adkToMcpToolType(tool));
+  }
+  /**
+   * Refreshes the tool cache by clearing it and fetching tools again
+   */
+  async refreshTools(context) {
+    this.tools = [];
+    return this.getTools(context);
+  }
+  /**
+   * Closes the connection to the MCP server.
+   * Similar to Python's close method.
+   */
+  async close() {
+    if (this.isClosing) {
+      return;
+    }
+    try {
+      this.isClosing = true;
+      if (this.clientService) {
+        await this.clientService.close();
+        this.clientService = null;
+      }
+      this.tools = [];
+      if (this.config.debug) {
+        console.log("\u2705 MCP toolset closed successfully");
+      }
+    } catch (error) {
+      console.error("Error closing MCP toolset:", error);
+    } finally {
+      this.isClosing = false;
+    }
+  }
+  /**
+   * Disposes of all resources. This method should be called when the toolset is no longer needed.
+   * Provides alignment with disposal patterns common in TypeScript.
+   */
+  async dispose() {
+    await this.close();
+  }
+};
+async function getMcpTools(config, toolFilter) {
+  const toolset = new McpToolset(config, toolFilter);
+  try {
+    return await toolset.getTools();
+  } finally {
+    await toolset.close().catch((err) => console.error("Error closing toolset:", err));
+  }
+}
+
 // src/models/index.ts
 var models_exports = {};
 __export(models_exports, {
@@ -2947,7 +3651,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
    * Convert Anthropic tool calls to ADK tool calls
    */
   convertToolCalls(toolUses) {
-    if (!_optionalChain([toolUses, 'optionalAccess', _38 => _38.length])) {
+    if (!_optionalChain([toolUses, 'optionalAccess', _48 => _48.length])) {
       return void 0;
     }
     return toolUses.map((toolUse) => ({
@@ -2962,7 +3666,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
    * Extract tool uses from response content
    */
   extractToolUses(content) {
-    if (!_optionalChain([content, 'optionalAccess', _39 => _39.length])) return [];
+    if (!_optionalChain([content, 'optionalAccess', _49 => _49.length])) return [];
     const toolUses = [];
     for (const block of content) {
       if (process.env.DEBUG === "true") {
@@ -3101,7 +3805,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
       const llmResponse = new LLMResponse({
         role: "assistant",
         content,
-        tool_calls: _optionalChain([toolCalls, 'optionalAccess', _40 => _40.length]) ? toolCalls : void 0,
+        tool_calls: _optionalChain([toolCalls, 'optionalAccess', _50 => _50.length]) ? toolCalls : void 0,
         raw_response: apiResponse
       });
       if (process.env.DEBUG === "true") {
@@ -3110,7 +3814,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
           JSON.stringify(
             {
               role: llmResponse.role,
-              content: _optionalChain([llmResponse, 'access', _41 => _41.content, 'optionalAccess', _42 => _42.substring, 'call', _43 => _43(0, 50)]) + (llmResponse.content && llmResponse.content.length > 50 ? "..." : ""),
+              content: _optionalChain([llmResponse, 'access', _51 => _51.content, 'optionalAccess', _52 => _52.substring, 'call', _53 => _53(0, 50)]) + (llmResponse.content && llmResponse.content.length > 50 ? "..." : ""),
               tool_calls: llmResponse.tool_calls ? `[${llmResponse.tool_calls.length} calls]` : "undefined"
             },
             null,
@@ -3135,17 +3839,17 @@ var AnthropicLLM = class extends BaseLLM {
    */
   constructor(model, config) {
     super(model);
-    this.apiKey = _optionalChain([config, 'optionalAccess', _44 => _44.apiKey]) || process.env.ANTHROPIC_API_KEY || "";
-    this.baseURL = _optionalChain([config, 'optionalAccess', _45 => _45.baseURL]) || "https://api.anthropic.com/v1";
+    this.apiKey = _optionalChain([config, 'optionalAccess', _54 => _54.apiKey]) || process.env.ANTHROPIC_API_KEY || "";
+    this.baseURL = _optionalChain([config, 'optionalAccess', _55 => _55.baseURL]) || "https://api.anthropic.com/v1";
     if (!this.apiKey) {
       throw new Error(
         "Anthropic API key is required. Provide it in config or set ANTHROPIC_API_KEY environment variable."
       );
     }
     this.defaultParams = {
-      temperature: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _46 => _46.defaultParams, 'optionalAccess', _47 => _47.temperature]), () => ( 0.7)),
-      top_p: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _48 => _48.defaultParams, 'optionalAccess', _49 => _49.top_p]), () => ( 1)),
-      max_tokens: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _50 => _50.defaultParams, 'optionalAccess', _51 => _51.max_tokens]), () => ( 1024))
+      temperature: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _56 => _56.defaultParams, 'optionalAccess', _57 => _57.temperature]), () => ( 0.7)),
+      top_p: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _58 => _58.defaultParams, 'optionalAccess', _59 => _59.top_p]), () => ( 1)),
+      max_tokens: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _60 => _60.defaultParams, 'optionalAccess', _61 => _61.max_tokens]), () => ( 1024))
     };
   }
   /**
@@ -3231,7 +3935,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
    * Convert ADK function declarations to Anthropic tool format
    */
   convertFunctionsToTools(functions) {
-    if (!_optionalChain([functions, 'optionalAccess', _52 => _52.length])) {
+    if (!_optionalChain([functions, 'optionalAccess', _62 => _62.length])) {
       return [];
     }
     return functions.map((func) => ({
@@ -3244,7 +3948,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
    * Convert Anthropic tool calls to ADK tool calls
    */
   convertToolUses(toolUses) {
-    if (!_optionalChain([toolUses, 'optionalAccess', _53 => _53.length])) {
+    if (!_optionalChain([toolUses, 'optionalAccess', _63 => _63.length])) {
       return [];
     }
     return toolUses.map((toolUse) => ({
@@ -3259,7 +3963,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
    * Extract tool uses from response content
    */
   extractToolUses(content) {
-    if (!_optionalChain([content, 'optionalAccess', _54 => _54.length])) return [];
+    if (!_optionalChain([content, 'optionalAccess', _64 => _64.length])) return [];
     const toolUses = [];
     for (const block of content) {
       if (process.env.DEBUG === "true") {
@@ -3336,7 +4040,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         temperature: _nullishCoalesce(llmRequest.config.temperature, () => ( this.defaultParams.temperature)),
         max_tokens: _nullishCoalesce(llmRequest.config.max_tokens, () => ( this.defaultParams.max_tokens)),
         top_p: _nullishCoalesce(llmRequest.config.top_p, () => ( this.defaultParams.top_p)),
-        tools: _optionalChain([tools, 'optionalAccess', _55 => _55.length]) ? tools : void 0
+        tools: _optionalChain([tools, 'optionalAccess', _65 => _65.length]) ? tools : void 0
       };
       if (process.env.DEBUG === "true") {
         console.log("Anthropic API Request:", {
@@ -3388,7 +4092,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
           JSON.stringify(
             {
               role: llmResponse.role,
-              content: _optionalChain([llmResponse, 'access', _56 => _56.content, 'optionalAccess', _57 => _57.substring, 'call', _58 => _58(0, 50)]) + (llmResponse.content && llmResponse.content.length > 50 ? "..." : ""),
+              content: _optionalChain([llmResponse, 'access', _66 => _66.content, 'optionalAccess', _67 => _67.substring, 'call', _68 => _68(0, 50)]) + (llmResponse.content && llmResponse.content.length > 50 ? "..." : ""),
               tool_calls: llmResponse.tool_calls ? `[${llmResponse.tool_calls.length} calls]` : "undefined"
             },
             null,
@@ -3436,9 +4140,9 @@ var GoogleLLM = class extends BaseLLM {
   constructor(model, config) {
     super(model);
     const apiKey = process.env.GOOGLE_API_KEY;
-    const projectId = _optionalChain([config, 'optionalAccess', _59 => _59.projectId]) || process.env.GOOGLE_CLOUD_PROJECT;
-    const location = _optionalChain([config, 'optionalAccess', _60 => _60.location]) || process.env.GOOGLE_CLOUD_LOCATION;
-    const useVertexAI = _optionalChain([process, 'access', _61 => _61.env, 'access', _62 => _62.USE_VERTEX_AI, 'optionalAccess', _63 => _63.toLowerCase, 'call', _64 => _64()]) === "true";
+    const projectId = _optionalChain([config, 'optionalAccess', _69 => _69.projectId]) || process.env.GOOGLE_CLOUD_PROJECT;
+    const location = _optionalChain([config, 'optionalAccess', _70 => _70.location]) || process.env.GOOGLE_CLOUD_LOCATION;
+    const useVertexAI = _optionalChain([process, 'access', _71 => _71.env, 'access', _72 => _72.USE_VERTEX_AI, 'optionalAccess', _73 => _73.toLowerCase, 'call', _74 => _74()]) === "true";
     if (!useVertexAI && !apiKey) {
       throw new Error(
         "Google API Key is required. Provide via config or GOOGLE_API_KEY env var."
@@ -3463,9 +4167,9 @@ var GoogleLLM = class extends BaseLLM {
     }
     this.ai = new (0, _genai.GoogleGenAI)(options);
     this.defaultParams = {
-      temperature: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _65 => _65.defaultParams, 'optionalAccess', _66 => _66.temperature]), () => ( 0.7)),
-      topP: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _67 => _67.defaultParams, 'optionalAccess', _68 => _68.top_p]), () => ( 1)),
-      maxOutputTokens: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _69 => _69.defaultParams, 'optionalAccess', _70 => _70.maxOutputTokens]), () => ( 1024))
+      temperature: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _75 => _75.defaultParams, 'optionalAccess', _76 => _76.temperature]), () => ( 0.7)),
+      topP: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _77 => _77.defaultParams, 'optionalAccess', _78 => _78.top_p]), () => ( 1)),
+      maxOutputTokens: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _79 => _79.defaultParams, 'optionalAccess', _80 => _80.maxOutputTokens]), () => ( 1024))
     };
   }
   /**
@@ -3603,7 +4307,7 @@ var GoogleLLM = class extends BaseLLM {
       );
       parts.push({ text: "" });
     }
-    if (googleRole === "function" && (parts.length !== 1 || !_optionalChain([parts, 'access', _71 => _71[0], 'optionalAccess', _72 => _72.functionResponse]))) {
+    if (googleRole === "function" && (parts.length !== 1 || !_optionalChain([parts, 'access', _81 => _81[0], 'optionalAccess', _82 => _82.functionResponse]))) {
       console.error(
         `[GoogleLLM] convertMessage - Invalid parts for 'function' role. Expected 1 functionResponse part. Got:`,
         JSON.stringify(parts),
@@ -3711,13 +4415,13 @@ var GoogleLLM = class extends BaseLLM {
       role: "assistant",
       content: null
     });
-    if (typeof _optionalChain([response, 'optionalAccess', _73 => _73.candidates, 'optionalAccess', _74 => _74[0], 'optionalAccess', _75 => _75.content, 'optionalAccess', _76 => _76.parts, 'optionalAccess', _77 => _77[0], 'optionalAccess', _78 => _78.text]) === "string") {
+    if (typeof _optionalChain([response, 'optionalAccess', _83 => _83.candidates, 'optionalAccess', _84 => _84[0], 'optionalAccess', _85 => _85.content, 'optionalAccess', _86 => _86.parts, 'optionalAccess', _87 => _87[0], 'optionalAccess', _88 => _88.text]) === "string") {
       result.content = response.candidates[0].content.parts[0].text;
     }
-    if (_optionalChain([response, 'optionalAccess', _79 => _79.candidates, 'optionalAccess', _80 => _80[0], 'optionalAccess', _81 => _81.content, 'optionalAccess', _82 => _82.parts, 'optionalAccess', _83 => _83[0], 'optionalAccess', _84 => _84.text])) {
+    if (_optionalChain([response, 'optionalAccess', _89 => _89.candidates, 'optionalAccess', _90 => _90[0], 'optionalAccess', _91 => _91.content, 'optionalAccess', _92 => _92.parts, 'optionalAccess', _93 => _93[0], 'optionalAccess', _94 => _94.text])) {
       result.content = response.candidates[0].content.parts[0].text;
     }
-    if (_optionalChain([response, 'optionalAccess', _85 => _85.candidates, 'optionalAccess', _86 => _86[0], 'optionalAccess', _87 => _87.content, 'optionalAccess', _88 => _88.parts, 'optionalAccess', _89 => _89[0], 'optionalAccess', _90 => _90.functionCall])) {
+    if (_optionalChain([response, 'optionalAccess', _95 => _95.candidates, 'optionalAccess', _96 => _96[0], 'optionalAccess', _97 => _97.content, 'optionalAccess', _98 => _98.parts, 'optionalAccess', _99 => _99[0], 'optionalAccess', _100 => _100.functionCall])) {
       const functionCall = response.candidates[0].content.parts[0].functionCall;
       result.function_call = {
         name: functionCall.name,
@@ -3764,10 +4468,10 @@ var GoogleLLM = class extends BaseLLM {
       if (stream) {
         const streamingResult = await this.ai.models.generateContentStream(requestOptions);
         for await (const chunk of streamingResult) {
-          if (!_optionalChain([chunk, 'access', _91 => _91.candidates, 'optionalAccess', _92 => _92[0], 'optionalAccess', _93 => _93.content, 'optionalAccess', _94 => _94.parts, 'optionalAccess', _95 => _95[0], 'optionalAccess', _96 => _96.text])) {
+          if (!_optionalChain([chunk, 'access', _101 => _101.candidates, 'optionalAccess', _102 => _102[0], 'optionalAccess', _103 => _103.content, 'optionalAccess', _104 => _104.parts, 'optionalAccess', _105 => _105[0], 'optionalAccess', _106 => _106.text])) {
             continue;
           }
-          const partialText = _optionalChain([chunk, 'access', _97 => _97.candidates, 'access', _98 => _98[0], 'optionalAccess', _99 => _99.content, 'optionalAccess', _100 => _100.parts, 'access', _101 => _101[0], 'optionalAccess', _102 => _102.text]) || "";
+          const partialText = _optionalChain([chunk, 'access', _107 => _107.candidates, 'access', _108 => _108[0], 'optionalAccess', _109 => _109.content, 'optionalAccess', _110 => _110.parts, 'access', _111 => _111[0], 'optionalAccess', _112 => _112.text]) || "";
           const partialResponse = new LLMResponse({
             content: partialText,
             role: "assistant",
@@ -3879,10 +4583,10 @@ var OpenAILLMConnection = class extends BaseLLMConnection {
       for await (const chunk of stream) {
         if (chunk.choices.length === 0) continue;
         const delta = chunk.choices[0].delta;
-        if (_optionalChain([delta, 'optionalAccess', _103 => _103.content])) {
+        if (_optionalChain([delta, 'optionalAccess', _113 => _113.content])) {
           responseContent += delta.content;
         }
-        if (_optionalChain([delta, 'optionalAccess', _104 => _104.function_call])) {
+        if (_optionalChain([delta, 'optionalAccess', _114 => _114.function_call])) {
           if (!functionCall) {
             functionCall = {
               name: delta.function_call.name || "",
@@ -3893,7 +4597,7 @@ var OpenAILLMConnection = class extends BaseLLMConnection {
             functionCall.arguments += delta.function_call.arguments || "";
           }
         }
-        if (_optionalChain([delta, 'optionalAccess', _105 => _105.tool_calls])) {
+        if (_optionalChain([delta, 'optionalAccess', _115 => _115.tool_calls])) {
           for (const toolDelta of delta.tool_calls) {
             const id = toolDelta.id || "";
             let tool = toolCalls.find((t) => t.id === id);
@@ -3901,20 +4605,20 @@ var OpenAILLMConnection = class extends BaseLLMConnection {
               tool = {
                 id,
                 function: {
-                  name: _optionalChain([toolDelta, 'access', _106 => _106.function, 'optionalAccess', _107 => _107.name]) || "",
-                  arguments: _optionalChain([toolDelta, 'access', _108 => _108.function, 'optionalAccess', _109 => _109.arguments]) || ""
+                  name: _optionalChain([toolDelta, 'access', _116 => _116.function, 'optionalAccess', _117 => _117.name]) || "",
+                  arguments: _optionalChain([toolDelta, 'access', _118 => _118.function, 'optionalAccess', _119 => _119.arguments]) || ""
                 }
               };
               toolCalls.push(tool);
             } else {
-              tool.function.name += _optionalChain([toolDelta, 'access', _110 => _110.function, 'optionalAccess', _111 => _111.name]) || "";
-              tool.function.arguments += _optionalChain([toolDelta, 'access', _112 => _112.function, 'optionalAccess', _113 => _113.arguments]) || "";
+              tool.function.name += _optionalChain([toolDelta, 'access', _120 => _120.function, 'optionalAccess', _121 => _121.name]) || "";
+              tool.function.arguments += _optionalChain([toolDelta, 'access', _122 => _122.function, 'optionalAccess', _123 => _123.arguments]) || "";
             }
           }
         }
         if (this.responseCallback) {
           const response = new LLMResponse({
-            content: _optionalChain([delta, 'optionalAccess', _114 => _114.content]) || null,
+            content: _optionalChain([delta, 'optionalAccess', _124 => _124.content]) || null,
             role: "assistant",
             function_call: functionCall,
             tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
@@ -4016,16 +4720,16 @@ var OpenAILLM = class extends BaseLLM {
   constructor(model, config) {
     super(model);
     this.client = new (0, _openai2.default)({
-      apiKey: _optionalChain([config, 'optionalAccess', _115 => _115.apiKey]) || process.env.OPENAI_API_KEY,
-      baseURL: _optionalChain([config, 'optionalAccess', _116 => _116.baseURL]),
-      organization: _optionalChain([config, 'optionalAccess', _117 => _117.organization])
+      apiKey: _optionalChain([config, 'optionalAccess', _125 => _125.apiKey]) || process.env.OPENAI_API_KEY,
+      baseURL: _optionalChain([config, 'optionalAccess', _126 => _126.baseURL]),
+      organization: _optionalChain([config, 'optionalAccess', _127 => _127.organization])
     });
     this.defaultParams = {
-      temperature: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _118 => _118.defaultParams, 'optionalAccess', _119 => _119.temperature]), () => ( 0.7)),
-      top_p: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _120 => _120.defaultParams, 'optionalAccess', _121 => _121.top_p]), () => ( 1)),
-      max_tokens: _optionalChain([config, 'optionalAccess', _122 => _122.defaultParams, 'optionalAccess', _123 => _123.max_tokens]),
-      frequency_penalty: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _124 => _124.defaultParams, 'optionalAccess', _125 => _125.frequency_penalty]), () => ( 0)),
-      presence_penalty: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _126 => _126.defaultParams, 'optionalAccess', _127 => _127.presence_penalty]), () => ( 0))
+      temperature: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _128 => _128.defaultParams, 'optionalAccess', _129 => _129.temperature]), () => ( 0.7)),
+      top_p: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _130 => _130.defaultParams, 'optionalAccess', _131 => _131.top_p]), () => ( 1)),
+      max_tokens: _optionalChain([config, 'optionalAccess', _132 => _132.defaultParams, 'optionalAccess', _133 => _133.max_tokens]),
+      frequency_penalty: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _134 => _134.defaultParams, 'optionalAccess', _135 => _135.frequency_penalty]), () => ( 0)),
+      presence_penalty: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _136 => _136.defaultParams, 'optionalAccess', _137 => _137.presence_penalty]), () => ( 0))
     };
   }
   /**
@@ -4135,16 +4839,16 @@ var OpenAILLM = class extends BaseLLM {
    */
   convertResponse(response) {
     const result = new LLMResponse({
-      content: _optionalChain([response, 'access', _128 => _128.message, 'optionalAccess', _129 => _129.content]) || null,
-      role: _optionalChain([response, 'access', _130 => _130.message, 'optionalAccess', _131 => _131.role]) || "assistant"
+      content: _optionalChain([response, 'access', _138 => _138.message, 'optionalAccess', _139 => _139.content]) || null,
+      role: _optionalChain([response, 'access', _140 => _140.message, 'optionalAccess', _141 => _141.role]) || "assistant"
     });
-    if (_optionalChain([response, 'access', _132 => _132.message, 'optionalAccess', _133 => _133.function_call])) {
+    if (_optionalChain([response, 'access', _142 => _142.message, 'optionalAccess', _143 => _143.function_call])) {
       result.function_call = {
         name: response.message.function_call.name,
         arguments: response.message.function_call.arguments
       };
     }
-    if (_optionalChain([response, 'access', _134 => _134.message, 'optionalAccess', _135 => _135.tool_calls])) {
+    if (_optionalChain([response, 'access', _144 => _144.message, 'optionalAccess', _145 => _145.tool_calls])) {
       result.tool_calls = response.message.tool_calls.map((tool) => ({
         id: tool.id,
         function: {
@@ -4164,24 +4868,24 @@ var OpenAILLM = class extends BaseLLM {
         `OpenAI: Converting chunk - delta: ${JSON.stringify(chunk.delta || {})}`
       );
     }
-    const content = _optionalChain([chunk, 'access', _136 => _136.delta, 'optionalAccess', _137 => _137.content]);
+    const content = _optionalChain([chunk, 'access', _146 => _146.delta, 'optionalAccess', _147 => _147.content]);
     const result = new LLMResponse({
       content: content !== void 0 ? content : null,
-      role: _optionalChain([chunk, 'access', _138 => _138.delta, 'optionalAccess', _139 => _139.role]) || "assistant",
+      role: _optionalChain([chunk, 'access', _148 => _148.delta, 'optionalAccess', _149 => _149.role]) || "assistant",
       is_partial: true
     });
-    if (_optionalChain([chunk, 'access', _140 => _140.delta, 'optionalAccess', _141 => _141.function_call])) {
+    if (_optionalChain([chunk, 'access', _150 => _150.delta, 'optionalAccess', _151 => _151.function_call])) {
       result.function_call = {
         name: chunk.delta.function_call.name || "",
         arguments: chunk.delta.function_call.arguments || ""
       };
     }
-    if (_optionalChain([chunk, 'access', _142 => _142.delta, 'optionalAccess', _143 => _143.tool_calls])) {
+    if (_optionalChain([chunk, 'access', _152 => _152.delta, 'optionalAccess', _153 => _153.tool_calls])) {
       result.tool_calls = chunk.delta.tool_calls.map((tool) => ({
         id: tool.id || "",
         function: {
-          name: _optionalChain([tool, 'access', _144 => _144.function, 'optionalAccess', _145 => _145.name]) || "",
-          arguments: _optionalChain([tool, 'access', _146 => _146.function, 'optionalAccess', _147 => _147.arguments]) || ""
+          name: _optionalChain([tool, 'access', _154 => _154.function, 'optionalAccess', _155 => _155.name]) || "",
+          arguments: _optionalChain([tool, 'access', _156 => _156.function, 'optionalAccess', _157 => _157.arguments]) || ""
         }
       }));
     }
@@ -4239,7 +4943,7 @@ var OpenAILLM = class extends BaseLLM {
           }
           if (process.env.DEBUG === "true") {
             console.log(
-              `OpenAI: Chunk received - delta: "${_optionalChain([choice, 'access', _148 => _148.delta, 'optionalAccess', _149 => _149.content]) || ""}"`,
+              `OpenAI: Chunk received - delta: "${_optionalChain([choice, 'access', _158 => _158.delta, 'optionalAccess', _159 => _159.content]) || ""}"`,
               `responseChunk content: "${responseChunk.content || ""}"`,
               `is_partial: ${responseChunk.is_partial}`,
               `accumulated: "${accumulatedContent.substring(0, 30)}${accumulatedContent.length > 30 ? "..." : ""}"`
@@ -4480,7 +5184,7 @@ var OAuth2Credential = class extends AuthCredential {
         "Cannot refresh token: no refresh token or refresh function"
       );
     }
-    const result = await _optionalChain([this, 'access', _150 => _150.refreshFunction, 'optionalCall', _151 => _151(this.refreshToken)]);
+    const result = await _optionalChain([this, 'access', _160 => _160.refreshFunction, 'optionalCall', _161 => _161(this.refreshToken)]);
     if (!result) {
       throw new Error("Failed to refresh token");
     }
@@ -4518,7 +5222,7 @@ var AuthHandler = class {
    * Gets the authentication token
    */
   getToken() {
-    return _optionalChain([this, 'access', _152 => _152.credential, 'optionalAccess', _153 => _153.getToken, 'call', _154 => _154()]);
+    return _optionalChain([this, 'access', _162 => _162.credential, 'optionalAccess', _163 => _163.getToken, 'call', _164 => _164()]);
   }
   /**
    * Gets headers for HTTP requests
@@ -4533,7 +5237,7 @@ var AuthHandler = class {
    * Refreshes the token if necessary
    */
   async refreshToken() {
-    if (_optionalChain([this, 'access', _155 => _155.credential, 'optionalAccess', _156 => _156.canRefresh, 'call', _157 => _157()])) {
+    if (_optionalChain([this, 'access', _165 => _165.credential, 'optionalAccess', _166 => _166.canRefresh, 'call', _167 => _167()])) {
       await this.credential.refresh();
     }
   }
@@ -4709,7 +5413,7 @@ var InMemoryMemoryService = class {
     };
     const normalizedQuery = query.toLowerCase().trim();
     const queryTerms = normalizedQuery.split(/\s+/);
-    const sessionsToSearch = _optionalChain([options, 'optionalAccess', _158 => _158.sessionId]) ? this.sessions.has(options.sessionId) ? [this.sessions.get(options.sessionId)] : [] : Array.from(this.sessions.values());
+    const sessionsToSearch = _optionalChain([options, 'optionalAccess', _168 => _168.sessionId]) ? this.sessions.has(options.sessionId) ? [this.sessions.get(options.sessionId)] : [] : Array.from(this.sessions.values());
     for (const session of sessionsToSearch) {
       const matchedEvents = [];
       const scores = [];
@@ -4735,7 +5439,7 @@ var InMemoryMemoryService = class {
           }
         }
         const score = queryTerms.length > 0 ? termMatches / queryTerms.length : 0;
-        if (_optionalChain([options, 'optionalAccess', _159 => _159.threshold]) !== void 0 && score < options.threshold) {
+        if (_optionalChain([options, 'optionalAccess', _169 => _169.threshold]) !== void 0 && score < options.threshold) {
           continue;
         }
         if (score > 0) {
@@ -4755,7 +5459,7 @@ var InMemoryMemoryService = class {
     response.memories.sort(
       (a, b) => (_nullishCoalesce(b.relevanceScore, () => ( 0))) - (_nullishCoalesce(a.relevanceScore, () => ( 0)))
     );
-    if (_optionalChain([options, 'optionalAccess', _160 => _160.limit]) !== void 0 && options.limit > 0) {
+    if (_optionalChain([options, 'optionalAccess', _170 => _170.limit]) !== void 0 && options.limit > 0) {
       response.memories = response.memories.slice(0, options.limit);
     }
     return response;
@@ -5004,17 +5708,17 @@ var InMemorySessionService = class {
     let sessions = Array.from(this.sessions.values()).filter(
       (session) => session.userId === userId
     );
-    if (_optionalChain([options, 'optionalAccess', _161 => _161.createdAfter])) {
+    if (_optionalChain([options, 'optionalAccess', _171 => _171.createdAfter])) {
       sessions = sessions.filter(
         (session) => session.createdAt >= options.createdAfter
       );
     }
-    if (_optionalChain([options, 'optionalAccess', _162 => _162.updatedAfter])) {
+    if (_optionalChain([options, 'optionalAccess', _172 => _172.updatedAfter])) {
       sessions = sessions.filter(
         (session) => session.updatedAt >= options.updatedAfter
       );
     }
-    if (_optionalChain([options, 'optionalAccess', _163 => _163.metadataFilter])) {
+    if (_optionalChain([options, 'optionalAccess', _173 => _173.metadataFilter])) {
       sessions = sessions.filter((session) => {
         for (const [key, value] of Object.entries(options.metadataFilter)) {
           if (session.metadata[key] !== value) {
@@ -5025,7 +5729,7 @@ var InMemorySessionService = class {
       });
     }
     sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
-    if (_optionalChain([options, 'optionalAccess', _164 => _164.limit]) !== void 0 && options.limit > 0) {
+    if (_optionalChain([options, 'optionalAccess', _174 => _174.limit]) !== void 0 && options.limit > 0) {
       sessions = sessions.slice(0, options.limit);
     }
     return sessions;
@@ -5060,7 +5764,7 @@ var InMemorySessionService = class {
     if (event.is_partial) {
       return event;
     }
-    if (_optionalChain([event, 'access', _165 => _165.actions, 'optionalAccess', _166 => _166.stateDelta])) {
+    if (_optionalChain([event, 'access', _175 => _175.actions, 'optionalAccess', _176 => _176.stateDelta])) {
       for (const [key, value] of Object.entries(event.actions.stateDelta)) {
         if (key.startsWith("_temp_")) {
           continue;
@@ -5164,7 +5868,7 @@ var PostgresSessionService = class {
   }
   async listSessions(userId, options) {
     let query = this.db.select().from(this.sessionsTable).where(_drizzleorm.eq.call(void 0, this.sessionsTable.userId, userId));
-    if (_optionalChain([options, 'optionalAccess', _167 => _167.limit]) !== void 0 && options.limit > 0) {
+    if (_optionalChain([options, 'optionalAccess', _177 => _177.limit]) !== void 0 && options.limit > 0) {
       query = query.limit(options.limit);
     }
     const results = await query;
@@ -5191,12 +5895,12 @@ var PostgresSessionService = class {
     if (event.is_partial) {
       return event;
     }
-    if (_optionalChain([event, 'access', _168 => _168.actions, 'optionalAccess', _169 => _169.stateDelta])) {
+    if (_optionalChain([event, 'access', _178 => _178.actions, 'optionalAccess', _179 => _179.stateDelta])) {
       for (const [key, value] of Object.entries(event.actions.stateDelta)) {
         if (key.startsWith("_temp_")) {
           continue;
         }
-        _optionalChain([session, 'access', _170 => _170.state, 'optionalAccess', _171 => _171.set, 'call', _172 => _172(key, value)]);
+        _optionalChain([session, 'access', _180 => _180.state, 'optionalAccess', _181 => _181.set, 'call', _182 => _182(key, value)]);
       }
     }
     if (!session.events) {
@@ -5341,7 +6045,7 @@ var PgLiteSessionService = class {
   async listSessions(userId, options) {
     await this.ensureInitialized();
     let query = this.db.select().from(this.sessionsTable).where(_drizzleorm.eq.call(void 0, this.sessionsTable.userId, userId));
-    if (_optionalChain([options, 'optionalAccess', _173 => _173.limit]) !== void 0 && options.limit > 0) {
+    if (_optionalChain([options, 'optionalAccess', _183 => _183.limit]) !== void 0 && options.limit > 0) {
       query = query.limit(options.limit);
     }
     const results = await query;
@@ -5370,12 +6074,12 @@ var PgLiteSessionService = class {
     if (event.is_partial) {
       return event;
     }
-    if (_optionalChain([event, 'access', _174 => _174.actions, 'optionalAccess', _175 => _175.stateDelta])) {
+    if (_optionalChain([event, 'access', _184 => _184.actions, 'optionalAccess', _185 => _185.stateDelta])) {
       for (const [key, value] of Object.entries(event.actions.stateDelta)) {
         if (key.startsWith("_temp_")) {
           continue;
         }
-        _optionalChain([session, 'access', _176 => _176.state, 'optionalAccess', _177 => _177.set, 'call', _178 => _178(key, value)]);
+        _optionalChain([session, 'access', _186 => _186.state, 'optionalAccess', _187 => _187.set, 'call', _188 => _188(key, value)]);
       }
     }
     if (!session.events) {
@@ -5718,4 +6422,12 @@ var VERSION = "0.1.0";
 
 
 
-exports.Agent = Agent; exports.Agents = agents_exports; exports.AnthropicLLM = AnthropicLLM; exports.AnthropicLLMConnection = AnthropicLLMConnection; 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.BaseAgent = BaseAgent; exports.BaseLLM = BaseLLM; exports.BaseLLMConnection = BaseLLMConnection; exports.BaseTool = BaseTool; exports.BasicAuthCredential = BasicAuthCredential; exports.BearerTokenCredential = BearerTokenCredential; exports.ExitLoopTool = ExitLoopTool; exports.FileOperationsTool = FileOperationsTool; exports.FunctionTool = FunctionTool; exports.GetUserChoiceTool = GetUserChoiceTool; exports.GoogleLLM = GoogleLLM; exports.GoogleSearch = GoogleSearch; exports.HttpRequestTool = HttpRequestTool; exports.HttpScheme = HttpScheme; exports.InMemoryMemoryService = InMemoryMemoryService; exports.InMemoryRunner = InMemoryRunner; exports.InMemorySessionService = InMemorySessionService; exports.InvocationContext = InvocationContext; exports.LLMRegistry = LLMRegistry; exports.LLMRequest = LLMRequest; exports.LLMResponse = LLMResponse; exports.LangGraphAgent = LangGraphAgent; exports.LoadMemoryTool = LoadMemoryTool; exports.LoopAgent = LoopAgent; exports.Memory = memory_exports; exports.Models = models_exports; exports.OAuth2Credential = OAuth2Credential; exports.OAuth2Scheme = OAuth2Scheme; exports.OpenAILLM = OpenAILLM; exports.OpenAILLMConnection = OpenAILLMConnection; exports.OpenIdConnectScheme = OpenIdConnectScheme; exports.ParallelAgent = ParallelAgent; exports.PersistentMemoryService = PersistentMemoryService; exports.PgLiteSessionService = PgLiteSessionService; exports.PostgresSessionService = PostgresSessionService; exports.RunConfig = RunConfig; exports.Runner = Runner; exports.SequentialAgent = SequentialAgent; exports.SessionState = SessionState; exports.Sessions = sessions_exports; exports.StreamingMode = StreamingMode; exports.ToolContext = ToolContext; exports.Tools = tools_exports; exports.TransferToAgentTool = TransferToAgentTool; exports.UserInteractionTool = UserInteractionTool; exports.VERSION = VERSION; exports.buildFunctionDeclaration = buildFunctionDeclaration; exports.cloneSession = cloneSession; exports.createFunctionTool = createFunctionTool; exports.generateSessionId = generateSessionId; exports.registerProviders = registerProviders; exports.validateSession = validateSession;
+
+
+
+
+
+
+
+
+exports.Agent = Agent; exports.Agents = agents_exports; exports.AnthropicLLM = AnthropicLLM; exports.AnthropicLLMConnection = AnthropicLLMConnection; 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.BaseAgent = BaseAgent; exports.BaseLLM = BaseLLM; exports.BaseLLMConnection = BaseLLMConnection; exports.BaseTool = BaseTool; exports.BasicAuthCredential = BasicAuthCredential; exports.BearerTokenCredential = BearerTokenCredential; exports.ExitLoopTool = ExitLoopTool; exports.FileOperationsTool = FileOperationsTool; exports.FunctionTool = FunctionTool; exports.GetUserChoiceTool = GetUserChoiceTool; exports.GoogleLLM = GoogleLLM; exports.GoogleSearch = GoogleSearch; exports.HttpRequestTool = HttpRequestTool; exports.HttpScheme = HttpScheme; exports.InMemoryMemoryService = InMemoryMemoryService; exports.InMemoryRunner = InMemoryRunner; exports.InMemorySessionService = InMemorySessionService; exports.InvocationContext = InvocationContext; exports.LLMRegistry = LLMRegistry; exports.LLMRequest = LLMRequest; exports.LLMResponse = LLMResponse; exports.LangGraphAgent = LangGraphAgent; exports.LoadMemoryTool = LoadMemoryTool; exports.LoopAgent = LoopAgent; exports.McpError = McpError; exports.McpErrorType = McpErrorType; exports.McpToolset = McpToolset; exports.Memory = memory_exports; exports.Models = models_exports; exports.OAuth2Credential = OAuth2Credential; exports.OAuth2Scheme = OAuth2Scheme; exports.OpenAILLM = OpenAILLM; exports.OpenAILLMConnection = OpenAILLMConnection; exports.OpenIdConnectScheme = OpenIdConnectScheme; exports.ParallelAgent = ParallelAgent; exports.PersistentMemoryService = PersistentMemoryService; exports.PgLiteSessionService = PgLiteSessionService; exports.PostgresSessionService = PostgresSessionService; exports.RunConfig = RunConfig; exports.Runner = Runner; exports.SequentialAgent = SequentialAgent; exports.SessionState = SessionState; exports.Sessions = sessions_exports; exports.StreamingMode = StreamingMode; exports.ToolContext = ToolContext; exports.Tools = tools_exports; exports.TransferToAgentTool = TransferToAgentTool; exports.UserInteractionTool = UserInteractionTool; exports.VERSION = VERSION; exports.adkToMcpToolType = adkToMcpToolType; exports.buildFunctionDeclaration = buildFunctionDeclaration; exports.cloneSession = cloneSession; exports.createFunctionTool = createFunctionTool; exports.generateSessionId = generateSessionId; exports.getMcpTools = getMcpTools; exports.jsonSchemaToDeclaration = jsonSchemaToDeclaration; exports.mcpSchemaToParameters = mcpSchemaToParameters; exports.normalizeJsonSchema = normalizeJsonSchema; exports.registerProviders = registerProviders; exports.validateSession = validateSession;