@iqai/adk 0.0.2 → 0.0.3

package/dist/index.mjs

@@ -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();
@@ -2768,6 +2776,702 @@ var LoadMemoryTool = class extends BaseTool {
   }
 };
 
+// src/tools/mcp/client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@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 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 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 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(),
+        this.config.retryOptions?.maxRetries || 2
+      );
+      return await wrappedCall();
+    } catch (error) {
+      if (!(error instanceof McpError)) {
+        throw new McpError(
+          `Error calling tool "${name}": ${error instanceof Error ? error.message : String(error)}`,
+          "tool_execution_error" /* TOOL_EXECUTION_ERROR */,
+          error instanceof Error ? error : void 0
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Closes and cleans up all resources.
+   * Should be called when the service is no longer needed.
+   * Similar to Python's close() method.
+   */
+  async close() {
+    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: metadata.isLongRunning ?? false,
+      shouldRetryOnFailure: metadata.shouldRetryOnFailure ?? false,
+      maxRetryAttempts: 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 && !this.config.cacheConfig?.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 (this.config.cacheConfig?.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, {
@@ -5690,6 +6394,9 @@ export {
   LangGraphAgent,
   LoadMemoryTool,
   LoopAgent,
+  McpError,
+  McpErrorType,
+  McpToolset,
   memory_exports as Memory,
   models_exports as Models,
   OAuth2Credential,
@@ -5712,10 +6419,15 @@ export {
   TransferToAgentTool,
   UserInteractionTool,
   VERSION,
+  adkToMcpToolType,
   buildFunctionDeclaration,
   cloneSession,
   createFunctionTool,
   generateSessionId,
+  getMcpTools,
+  jsonSchemaToDeclaration,
+  mcpSchemaToParameters,
+  normalizeJsonSchema,
   registerProviders,
   validateSession
 };