@google/adk 1.1.0 → 1.2.0

package/dist/esm/integrations/agent_registry/agent_registry.js

@@ -0,0 +1,333 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GoogleAuth } from "google-auth-library";
+import { RemoteA2AAgent } from "../../a2a/a2a_remote_agent.js";
+import { logger } from "../../utils/logger.js";
+import { AgentRegistrySingleMCPToolset } from "./agent_registry_mcp_toolset.js";
+import { cleanName, isGoogleApi } from "./helpers.js";
+import {
+  AGENT_REGISTRY_BASE_URL,
+  ProtocolType
+} from "./types.js";
+export * from "./agent_registry_mcp_toolset.js";
+export * from "./helpers.js";
+export * from "./types.js";
+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 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 = `${AGENT_REGISTRY_BASE_URL}/${path}`;
+    } else {
+      url = `${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 = 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);
+        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) && isGoogleApi(endpointUri)) {
+        Object.assign(headers, await this.getAuthHeaders());
+      }
+      if (this.headerProvider && context) {
+        Object.assign(headers, this.headerProvider(context));
+      }
+      return headers;
+    };
+    return new 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 = cleanName(agentCard2.name);
+      return new RemoteA2AAgent({
+        name: name2,
+        agentCard: agentCard2,
+        description: agentCard2.description,
+        client: options == null ? void 0 : options.client,
+        clientFactory: options == null ? void 0 : options.clientFactory
+      });
+    }
+    const name = cleanName(agentInfo.displayName || agentName);
+    const description = agentInfo.description || "";
+    const version = agentInfo.version || "";
+    const { url, protocolVersion, protocolBinding } = this.getConnectionUri(
+      agentInfo,
+      {
+        protocolType: 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 RemoteA2AAgent({
+      name,
+      agentCard,
+      description,
+      client: options == null ? void 0 : options.client,
+      clientFactory: options == null ? void 0 : options.clientFactory
+    });
+  }
+}
+export {
+  AgentRegistry
+};

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

@@ -0,0 +1,77 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseToolset } from "../../tools/base_toolset.js";
+import {
+  MCPSessionManager
+} from "../../tools/mcp/mcp_session_manager.js";
+import { MCPTool } from "../../tools/mcp/mcp_tool.js";
+import { GCP_MCP_SERVER_DESTINATION_ID } from "./types.js";
+class AgentRegistrySingleMCPToolset extends 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 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 MCPTool(
+        { ...tool, name: prefixedName },
+        sessionManager,
+        tool.name
+      );
+      const toolWithMetadata = mcpTool;
+      if (this.destinationResourceId) {
+        if (!toolWithMetadata.customMetadata) {
+          toolWithMetadata.customMetadata = {};
+        }
+        toolWithMetadata.customMetadata[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() {
+  }
+}
+export {
+  AgentRegistrySingleMCPToolset
+};

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

@@ -0,0 +1,28 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @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;
+}
+export {
+  cleanName,
+  isGoogleApi
+};

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

@@ -0,0 +1,20 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @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 || {});
+export {
+  AGENT_REGISTRY_BASE_URL,
+  GCP_MCP_SERVER_DESTINATION_ID,
+  ProtocolType
+};