@softactivate/adk 1.1.0 → 1.2.0

package/dist/cjs/integrations/agent_registry/agent_registry.js

@@ -0,0 +1,362 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_registry_exports = {};
+__export(agent_registry_exports, {
+  AgentRegistry: () => AgentRegistry
+});
+module.exports = __toCommonJS(agent_registry_exports);
+var import_google_auth_library = require("google-auth-library");
+var import_a2a_remote_agent = require("../../a2a/a2a_remote_agent.js");
+var import_logger = require("../../utils/logger.js");
+var import_agent_registry_mcp_toolset = require("./agent_registry_mcp_toolset.js");
+var import_helpers = require("./helpers.js");
+var import_types = require("./types.js");
+__reExport(agent_registry_exports, require("./agent_registry_mcp_toolset.js"), module.exports);
+__reExport(agent_registry_exports, require("./helpers.js"), module.exports);
+__reExport(agent_registry_exports, require("./types.js"), module.exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const TRANSPORT_MAPPING = {
+  "HTTP_JSON": "HTTP+JSON",
+  "JSONRPC": "JSONRPC",
+  "GRPC": "GRPC"
+};
+class AgentRegistry {
+  constructor(options) {
+    if (!options.projectId || !options.location) {
+      throw new Error("project_id and location must be provided");
+    }
+    this.projectId = options.projectId;
+    this.location = options.location;
+    this.basePath = `projects/${this.projectId}/locations/${this.location}`;
+    this.headerProvider = options.headerProvider;
+    this.auth = new import_google_auth_library.GoogleAuth({
+      scopes: ["https://www.googleapis.com/auth/cloud-platform"]
+    });
+  }
+  /**
+   * Resolves default Google Cloud credentials and returns standard headers.
+   * Automatically caches, fetches, and handles refreshing expired OAuth tokens.
+   * Injects the billing/quota project identifier `x-goog-user-project` if present.
+   */
+  async getAuthHeaders() {
+    try {
+      const client = await this.auth.getClient();
+      const headers = await client.getRequestHeaders(
+        "https://agentregistry.googleapis.com"
+      );
+      const authHeaders = {};
+      const rawHeaders = headers;
+      const authKey = Object.keys(rawHeaders).find(
+        (k) => k.toLowerCase() === "authorization"
+      );
+      let token = authKey ? rawHeaders[authKey] : void 0;
+      if (!token && client.credentials && client.credentials.access_token) {
+        token = `Bearer ${client.credentials.access_token}`;
+      }
+      if (token) {
+        authHeaders["Authorization"] = token;
+      }
+      authHeaders["Content-Type"] = "application/json";
+      const quotaProjectId = client.quotaProjectId || this.auth.quotaProjectId;
+      if (quotaProjectId) {
+        authHeaders["x-goog-user-project"] = quotaProjectId;
+      }
+      return authHeaders;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to refresh Google Cloud credentials: ${msg}`);
+    }
+  }
+  /**
+   * Helper function to execute HTTP GET requests against the Agent Registry API.
+   * Handles path resolution, search query params compilation, and auth headers fetching.
+   */
+  async makeRequest(path, params) {
+    let url;
+    if (path.startsWith("projects/")) {
+      url = `${import_types.AGENT_REGISTRY_BASE_URL}/${path}`;
+    } else {
+      url = `${import_types.AGENT_REGISTRY_BASE_URL}/${this.basePath}/${path}`;
+    }
+    if (params && Object.keys(params).length > 0) {
+      const searchParams = new URLSearchParams(params);
+      url += `?${searchParams.toString()}`;
+    }
+    try {
+      const headers = await this.getAuthHeaders();
+      const res = await fetch(url, {
+        method: "GET",
+        headers
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(
+          `API request failed with status ${res.status}: ${text}`
+        );
+      }
+      return await res.json();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("API request failed")) {
+        throw err;
+      }
+      throw new Error(`API request failed: ${msg}`);
+    }
+  }
+  /**
+   * Parses connection interfaces list from registry metadata and returns the first match
+   * corresponding to requested protocol types and binding options.
+   */
+  getConnectionUri(resourceDetails, filters) {
+    const protocols = [];
+    if (resourceDetails.protocols) {
+      protocols.push(...resourceDetails.protocols);
+    }
+    if (resourceDetails.interfaces) {
+      protocols.push({ interfaces: resourceDetails.interfaces });
+    }
+    for (const p of protocols) {
+      if ((filters == null ? void 0 : filters.protocolType) && p.type !== filters.protocolType) {
+        continue;
+      }
+      const protocolVersion = p.protocolVersion;
+      const interfaces = p.interfaces || [];
+      for (const i of interfaces) {
+        const mappedBinding = i.protocolBinding ? TRANSPORT_MAPPING[i.protocolBinding] : void 0;
+        if ((filters == null ? void 0 : filters.protocolBinding) && mappedBinding !== filters.protocolBinding) {
+          continue;
+        }
+        if (i.url) {
+          return { url: i.url, protocolVersion, protocolBinding: mappedBinding };
+        }
+      }
+    }
+    return {};
+  }
+  // --- MCP Server Methods ---
+  async listMcpServers(options) {
+    const params = {};
+    if (options == null ? void 0 : options.filterStr) {
+      params["filter"] = options.filterStr;
+    }
+    if (options == null ? void 0 : options.pageSize) {
+      params["pageSize"] = String(options.pageSize);
+    }
+    if (options == null ? void 0 : options.pageToken) {
+      params["pageToken"] = options.pageToken;
+    }
+    return this.makeRequest("mcpServers", params);
+  }
+  async getMcpServer(name) {
+    return this.makeRequest(name);
+  }
+  async getMcpToolset(mcpServerName, options) {
+    var _a, _b;
+    const serverDetails = await this.getMcpServer(mcpServerName);
+    const name = (0, import_helpers.cleanName)(serverDetails.displayName || mcpServerName);
+    const mcpServerId = serverDetails.mcpServerId;
+    let endpointUri = this.getConnectionUri(serverDetails, {
+      protocolBinding: "JSONRPC"
+    }).url;
+    if (!endpointUri) {
+      endpointUri = this.getConnectionUri(serverDetails, {
+        protocolBinding: "HTTP+JSON"
+      }).url;
+    }
+    if (!endpointUri) {
+      throw new Error(
+        `MCP Server endpoint URI not found for: ${mcpServerName}`
+      );
+    }
+    let authScheme = options == null ? void 0 : options.authScheme;
+    if (mcpServerId && !authScheme) {
+      try {
+        const bindingsData = await this.makeRequest("bindings");
+        const bindings = bindingsData.bindings || [];
+        for (const b of bindings) {
+          const targetId = ((_a = b.target) == null ? void 0 : _a.identifier) || "";
+          if (targetId.endsWith(mcpServerId)) {
+            const authProvider = (_b = b.authProviderBinding) == null ? void 0 : _b.authProvider;
+            if (authProvider) {
+              authScheme = {
+                type: "gcpAuthProviderScheme",
+                name: authProvider,
+                continueUri: options == null ? void 0 : options.continueUri
+              };
+              break;
+            }
+          }
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        import_logger.logger.warn(
+          `Failed to fetch bindings for MCP Server ${mcpServerName}: ${msg}`
+        );
+      }
+    }
+    const connectionParams = {
+      type: "StreamableHTTPConnectionParams",
+      url: endpointUri
+    };
+    const combinedHeaderProvider = async (context) => {
+      const headers = {};
+      if (!authScheme && !(options == null ? void 0 : options.authCredential) && (0, import_helpers.isGoogleApi)(endpointUri)) {
+        Object.assign(headers, await this.getAuthHeaders());
+      }
+      if (this.headerProvider && context) {
+        Object.assign(headers, this.headerProvider(context));
+      }
+      return headers;
+    };
+    return new import_agent_registry_mcp_toolset.AgentRegistrySingleMCPToolset({
+      destinationResourceId: mcpServerId,
+      connectionParams,
+      prefix: name,
+      headerProvider: combinedHeaderProvider,
+      authScheme,
+      authCredential: options == null ? void 0 : options.authCredential
+    });
+  }
+  // --- Endpoint Methods ---
+  async listEndpoints(options) {
+    const params = {};
+    if (options == null ? void 0 : options.filterStr) {
+      params["filter"] = options.filterStr;
+    }
+    if (options == null ? void 0 : options.pageSize) {
+      params["pageSize"] = String(options.pageSize);
+    }
+    if (options == null ? void 0 : options.pageToken) {
+      params["pageToken"] = options.pageToken;
+    }
+    return this.makeRequest("endpoints", params);
+  }
+  async getEndpoint(name) {
+    return this.makeRequest(name);
+  }
+  async getModelName(endpointName) {
+    const endpointDetails = await this.getEndpoint(endpointName);
+    const { url } = this.getConnectionUri(endpointDetails);
+    if (!url) {
+      throw new Error(`Connection URI not found for endpoint: ${endpointName}`);
+    }
+    const uri = url.replace(/:\w+$/, "");
+    if (uri.startsWith("projects/")) {
+      return uri;
+    }
+    const match = uri.match(/(projects\/.+)/);
+    if (match) {
+      return match[1];
+    }
+    return uri;
+  }
+  // --- Agent Methods ---
+  async listAgents(options) {
+    const params = {};
+    if (options == null ? void 0 : options.filterStr) {
+      params["filter"] = options.filterStr;
+    }
+    if (options == null ? void 0 : options.pageSize) {
+      params["pageSize"] = String(options.pageSize);
+    }
+    if (options == null ? void 0 : options.pageToken) {
+      params["pageToken"] = options.pageToken;
+    }
+    return this.makeRequest("agents", params);
+  }
+  async getAgentInfo(name) {
+    return this.makeRequest(name);
+  }
+  async getRemoteA2AAgent(agentName, options) {
+    const agentInfo = await this.getAgentInfo(agentName);
+    const card = agentInfo.card || {};
+    const cardContent = card.content;
+    if (card.type === "A2A_AGENT_CARD" && cardContent) {
+      const agentCard2 = cardContent;
+      const name2 = (0, import_helpers.cleanName)(agentCard2.name);
+      return new import_a2a_remote_agent.RemoteA2AAgent({
+        name: name2,
+        agentCard: agentCard2,
+        description: agentCard2.description,
+        client: options == null ? void 0 : options.client,
+        clientFactory: options == null ? void 0 : options.clientFactory
+      });
+    }
+    const name = (0, import_helpers.cleanName)(agentInfo.displayName || agentName);
+    const description = agentInfo.description || "";
+    const version = agentInfo.version || "";
+    const { url, protocolVersion, protocolBinding } = this.getConnectionUri(
+      agentInfo,
+      {
+        protocolType: import_types.ProtocolType.A2A_AGENT
+      }
+    );
+    if (!url) {
+      throw new Error(`A2A connection URI not found for Agent: ${agentName}`);
+    }
+    const skills = (agentInfo.skills || []).map(
+      (s) => ({
+        id: s.id,
+        name: s.name,
+        description: s.description || "",
+        tags: s.tags || [],
+        examples: s.examples || []
+      })
+    );
+    const agentCard = {
+      name,
+      description,
+      version,
+      preferredTransport: protocolBinding || "HTTP+JSON",
+      protocolVersion: protocolVersion || "0.3.0",
+      url,
+      skills,
+      capabilities: {
+        streaming: false
+      },
+      defaultInputModes: ["text"],
+      defaultOutputModes: ["text"]
+    };
+    return new import_a2a_remote_agent.RemoteA2AAgent({
+      name,
+      agentCard,
+      description,
+      client: options == null ? void 0 : options.client,
+      clientFactory: options == null ? void 0 : options.clientFactory
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentRegistry,
+  ...require("./agent_registry_mcp_toolset.js"),
+  ...require("./helpers.js"),
+  ...require("./types.js")
+});

package/dist/cjs/integrations/agent_registry/agent_registry_mcp_toolset.js

@@ -0,0 +1,103 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_registry_mcp_toolset_exports = {};
+__export(agent_registry_mcp_toolset_exports, {
+  AgentRegistrySingleMCPToolset: () => AgentRegistrySingleMCPToolset
+});
+module.exports = __toCommonJS(agent_registry_mcp_toolset_exports);
+var import_base_toolset = require("../../tools/base_toolset.js");
+var import_mcp_session_manager = require("../../tools/mcp/mcp_session_manager.js");
+var import_mcp_tool = require("../../tools/mcp/mcp_tool.js");
+var import_types2 = require("./types.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class AgentRegistrySingleMCPToolset extends import_base_toolset.BaseToolset {
+  constructor(options) {
+    super(options.toolFilter || [], options.prefix);
+    this.destinationResourceId = options.destinationResourceId;
+    this.connectionParams = options.connectionParams;
+    this.headerProvider = options.headerProvider;
+    this.authScheme = options.authScheme;
+    this.authCredential = options.authCredential;
+  }
+  /**
+   * Connects to the underlying MCP server, retrieves tool definitions, prefixes tool names,
+   * and injects destination telemetry metadata.
+   */
+  async getTools(context) {
+    var _a, _b, _c;
+    const headers = {};
+    if (this.headerProvider) {
+      const providerHeaders = await this.headerProvider(context);
+      Object.assign(headers, providerHeaders);
+    }
+    const connectionParamsCopy = {
+      ...this.connectionParams,
+      transportOptions: {
+        ...this.connectionParams.transportOptions,
+        requestInit: {
+          ...(_a = this.connectionParams.transportOptions) == null ? void 0 : _a.requestInit,
+          headers: {
+            ...(_c = (_b = this.connectionParams.transportOptions) == null ? void 0 : _b.requestInit) == null ? void 0 : _c.headers,
+            ...headers
+          }
+        }
+      }
+    };
+    const sessionManager = new import_mcp_session_manager.MCPSessionManager(connectionParamsCopy);
+    const session = await sessionManager.createSession();
+    const listResult = await session.listTools();
+    const tools = listResult.tools.map((tool) => {
+      const prefixedName = this.prefix ? `${this.prefix}_${tool.name}` : tool.name;
+      const mcpTool = new import_mcp_tool.MCPTool(
+        { ...tool, name: prefixedName },
+        sessionManager,
+        tool.name
+      );
+      const toolWithMetadata = mcpTool;
+      if (this.destinationResourceId) {
+        if (!toolWithMetadata.customMetadata) {
+          toolWithMetadata.customMetadata = {};
+        }
+        toolWithMetadata.customMetadata[import_types2.GCP_MCP_SERVER_DESTINATION_ID] = this.destinationResourceId;
+      }
+      return mcpTool;
+    });
+    const filter = this.toolFilter;
+    if (!filter || Array.isArray(filter) && filter.length === 0) {
+      return tools;
+    }
+    return tools.filter((t) => this.isToolSelected(t, context));
+  }
+  async close() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentRegistrySingleMCPToolset
+});

package/dist/cjs/integrations/agent_registry/helpers.js

@@ -0,0 +1,57 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var helpers_exports = {};
+__export(helpers_exports, {
+  cleanName: () => cleanName,
+  isGoogleApi: () => isGoogleApi
+});
+module.exports = __toCommonJS(helpers_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isGoogleApi(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname === "googleapis.com" || parsed.hostname.endsWith(".googleapis.com");
+  } catch {
+    return false;
+  }
+}
+function cleanName(name) {
+  let clean = name.replace(/[^a-zA-Z0-9_]/g, "_");
+  clean = clean.replace(/_+/g, "_");
+  clean = clean.replace(/^_+|_+$/g, "");
+  if (clean && !/^[a-zA-Z_]/.test(clean)) {
+    clean = "_" + clean;
+  }
+  return clean;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cleanName,
+  isGoogleApi
+});

package/dist/cjs/integrations/agent_registry/types.js

@@ -0,0 +1,50 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  AGENT_REGISTRY_BASE_URL: () => AGENT_REGISTRY_BASE_URL,
+  GCP_MCP_SERVER_DESTINATION_ID: () => GCP_MCP_SERVER_DESTINATION_ID,
+  ProtocolType: () => ProtocolType
+});
+module.exports = __toCommonJS(types_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const AGENT_REGISTRY_BASE_URL = "https://agentregistry.googleapis.com/v1alpha";
+const GCP_MCP_SERVER_DESTINATION_ID = "gcp.mcp.server.destination.id";
+var ProtocolType = /* @__PURE__ */ ((ProtocolType2) => {
+  ProtocolType2["TYPE_UNSPECIFIED"] = "TYPE_UNSPECIFIED";
+  ProtocolType2["A2A_AGENT"] = "A2A_AGENT";
+  ProtocolType2["CUSTOM"] = "CUSTOM";
+  return ProtocolType2;
+})(ProtocolType || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_REGISTRY_BASE_URL,
+  GCP_MCP_SERVER_DESTINATION_ID,
+  ProtocolType
+});