@softactivate/adk 1.1.0 → 1.2.0

package/dist/esm/code_executors/agent_engine_sandbox_code_executor.js

@@ -0,0 +1,281 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client } from "@google-cloud/vertexai";
+import { Language } from "@google-cloud/vertexai/build/src/genai/types.js";
+import { experimental } from "../utils/experimental.js";
+import { guessMimeType } from "../utils/file_utils.js";
+const SANDBOX_PATTERN = /^projects\/([a-zA-Z0-9-_]+)\/locations\/([a-zA-Z0-9-_]+)\/reasoningEngines\/(\d+)\/sandboxEnvironments\/(\d+)$/;
+const ENGINE_PATTERN = /^projects\/([a-zA-Z0-9-_]+)\/locations\/([a-zA-Z0-9-_]+)\/reasoningEngines\/(\d+)$/;
+import { logger } from "../utils/logger.js";
+import { BaseCodeExecutor } from "./base_code_executor.js";
+import {
+  CodeExecutionLanguage
+} from "./code_execution_utils.js";
+const DEFAULT_MAX_ATTEMPTS = 180;
+const DEFAULT_SANDBOX_TTL = "31536000s";
+const DEFAULT_SANDBOX_DISPLAY_NAME = "default_sandbox";
+const DEFAULT_ENGINE_DISPLAY_NAME = "default_engine";
+function mapLanguage(lang) {
+  switch (lang) {
+    case CodeExecutionLanguage.PYTHON:
+      return Language.LANGUAGE_PYTHON;
+    case CodeExecutionLanguage.JAVASCRIPT:
+      return Language.LANGUAGE_JAVASCRIPT;
+    default:
+      throw new Error(`Unsupported language for Agent Engine Sandbox: ${lang}`);
+  }
+}
+let AgentEngineSandboxCodeExecutor = class extends BaseCodeExecutor {
+  constructor(options = {}) {
+    super();
+    this.sandboxResourceName = options.sandboxResourceName;
+    this.agentEngineResourceName = options.agentEngineResourceName;
+    this.projectId = options.projectId || process.env.GOOGLE_CLOUD_PROJECT;
+    this.location = options.location || process.env.GOOGLE_CLOUD_LOCATION || "us-central1";
+    if (this.sandboxResourceName) {
+      const match = this.sandboxResourceName.match(SANDBOX_PATTERN);
+      if (match) {
+        this.projectId = match[1];
+        this.location = match[2];
+      } else {
+        throw new Error(
+          `Invalid sandbox resource name: ${this.sandboxResourceName}`
+        );
+      }
+    } else if (this.agentEngineResourceName) {
+      const match = this.agentEngineResourceName.match(ENGINE_PATTERN);
+      if (match) {
+        this.projectId = match[1];
+        this.location = match[2];
+      } else {
+        throw new Error(
+          `Invalid agent engine resource name: ${this.agentEngineResourceName}`
+        );
+      }
+    }
+    if (options.client) {
+      this.client = options.client;
+    } else {
+      if (!this.projectId) {
+        throw new Error("Project ID is required.");
+      }
+      this.client = new Client({
+        project: this.projectId,
+        location: this.location
+      });
+    }
+  }
+  async executeCode(params) {
+    var _a;
+    const { invocationContext, codeExecutionInput } = params;
+    const language = mapLanguage(codeExecutionInput.language);
+    const agentEngineName = await this.getOrCreateAgentEngine();
+    const sandboxName = await this.getOrCreateSandbox(
+      invocationContext,
+      agentEngineName,
+      language
+    );
+    const inputs = [
+      {
+        mimeType: "application/json",
+        data: Buffer.from(
+          JSON.stringify({ code: codeExecutionInput.code })
+        ).toString("base64")
+      }
+    ];
+    if (codeExecutionInput.inputFiles) {
+      for (const file of codeExecutionInput.inputFiles) {
+        inputs.push({
+          mimeType: file.mimeType,
+          data: file.content,
+          // Assumed to be already base64 encoded based on CodeExecutionInput definition
+          metadata: {
+            attributes: {
+              file_name: Buffer.from(file.name).toString("base64")
+            }
+          }
+        });
+      }
+    }
+    logger.debug(`Executing code in sandbox ${sandboxName}...`);
+    const response = await this.client.agentEnginesInternal.sandboxes.executeCodeInternal({
+      name: sandboxName,
+      inputs
+    });
+    let stdout = "";
+    let stderr = "";
+    const outputFiles = [];
+    if (response.outputs) {
+      for (const output of response.outputs) {
+        const attributes = ((_a = output.metadata) == null ? void 0 : _a.attributes) || {};
+        const encodedFileName = attributes["file_name"];
+        const fileName = encodedFileName ? Buffer.from(encodedFileName, "base64").toString("utf-8") : void 0;
+        if (output.mimeType === "application/json" && !fileName) {
+          if (output.data) {
+            const jsonStr = Buffer.from(output.data, "base64").toString(
+              "utf-8"
+            );
+            try {
+              const jsonData = JSON.parse(jsonStr);
+              if (jsonData.msg_out !== void 0) {
+                stdout = jsonData.msg_out;
+              } else {
+                stdout = "";
+              }
+              if (jsonData.msg_err !== void 0) {
+                stderr = jsonData.msg_err;
+              } else {
+                stderr = "";
+              }
+            } catch (e) {
+              logger.warn("Failed to parse JSON output from sandbox", e);
+              stdout = jsonStr;
+            }
+          }
+        } else {
+          let mimeType = output.mimeType;
+          const name = fileName || "output_file";
+          if (!mimeType) {
+            mimeType = guessMimeType(name);
+          }
+          outputFiles.push({
+            name,
+            content: output.data || "",
+            mimeType
+          });
+        }
+      }
+    }
+    return {
+      stdout,
+      stderr,
+      outputFiles
+    };
+  }
+  async getOrCreateAgentEngine() {
+    if (this.agentEngineResourceName) {
+      return this.agentEngineResourceName;
+    }
+    if (!this.agentEngineCreationPromise) {
+      this.agentEngineCreationPromise = (async () => {
+        logger.debug(
+          "No Agent Engine resource name provided. Creating a new one..."
+        );
+        const operation = await this.client.agentEnginesInternal.createInternal(
+          {
+            config: {
+              displayName: DEFAULT_ENGINE_DISPLAY_NAME
+            }
+          }
+        );
+        let apiResponse = operation;
+        let attempts = 0;
+        while (!apiResponse.done && attempts < DEFAULT_MAX_ATTEMPTS) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+          apiResponse = await this.client.agentEnginesInternal.getAgentOperationInternal({
+            operationName: operation.name
+          });
+          attempts++;
+        }
+        if (!apiResponse.done) {
+          throw new Error(
+            `Agent Engine creation operation ${operation.name} did not complete in time.`
+          );
+        }
+        const response = apiResponse.response;
+        this.agentEngineResourceName = response.name;
+        logger.debug(`Created Agent Engine: ${this.agentEngineResourceName}`);
+        return this.agentEngineResourceName;
+      })();
+    }
+    return this.agentEngineCreationPromise;
+  }
+  async getOrCreateSandbox(invocationContext, agentEngineName, language) {
+    var _a, _b;
+    if (this.sandboxResourceName) {
+      return this.sandboxResourceName;
+    }
+    const stateKey = `sandbox_name_${language.toLowerCase()}`;
+    let sandboxName = (_b = (_a = invocationContext.session) == null ? void 0 : _a.state) == null ? void 0 : _b[stateKey];
+    let createNewSandbox = false;
+    if (!sandboxName) {
+      createNewSandbox = true;
+    } else {
+      try {
+        const sandbox = await this.client.agentEnginesInternal.sandboxes.getInternal({
+          name: sandboxName
+        });
+        if (!sandbox || sandbox.state !== "STATE_RUNNING") {
+          createNewSandbox = true;
+        }
+      } catch (error) {
+        logger.debug(
+          `Failed to get sandbox ${sandboxName}, will create a new one`,
+          error
+        );
+        createNewSandbox = true;
+      }
+    }
+    if (createNewSandbox) {
+      logger.debug(`Creating a new ${language} code execution sandbox...`);
+      const operation = await this.client.agentEnginesInternal.sandboxes.createInternal({
+        name: agentEngineName,
+        spec: {
+          codeExecutionEnvironment: {
+            codeLanguage: language
+          }
+        },
+        config: {
+          displayName: DEFAULT_SANDBOX_DISPLAY_NAME,
+          ttl: DEFAULT_SANDBOX_TTL
+        }
+      });
+      let apiResponse = operation;
+      let attempts = 0;
+      while (!apiResponse.done && attempts < DEFAULT_MAX_ATTEMPTS) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        apiResponse = await this.client.agentEnginesInternal.sandboxes.getSandboxOperationInternal(
+          {
+            operationName: operation.name
+          }
+        );
+        attempts++;
+      }
+      if (!apiResponse.done) {
+        throw new Error(
+          `Sandbox creation operation ${operation.name} did not complete in time.`
+        );
+      }
+      const response = apiResponse.response;
+      sandboxName = response.name;
+      if (invocationContext.session) {
+        if (!invocationContext.session.state) {
+          invocationContext.session.state = {};
+        }
+        invocationContext.session.state[stateKey] = sandboxName;
+      }
+    }
+    return sandboxName;
+  }
+};
+AgentEngineSandboxCodeExecutor = __decorateClass([
+  experimental
+], AgentEngineSandboxCodeExecutor);
+export {
+  AgentEngineSandboxCodeExecutor
+};

package/dist/esm/code_executors/code_execution_utils.js

@@ -47,7 +47,7 @@ function extractCodeAndTruncateContent(content, codeBlockDelimiters) {
   const leadingDelimiterPattern = codeBlockDelimiters.map((d) => d[0]).join("|");
   const trailingDelimiterPattern = codeBlockDelimiters.map((d) => d[1]).join("|");
   const match = new RegExp(
-    `?<prefix>.*?)(${leadingDelimiterPattern})(?<codeStr>.*?)(${trailingDelimiterPattern})(?<suffix>.*?)$`,
+    `(?<prefix>.*?)(${leadingDelimiterPattern})(?<codeStr>.*?)(${trailingDelimiterPattern})(?<suffix>.*?)$`,
     "s"
   ).exec(responseText);
   const { prefix, codeStr } = (match == null ? void 0 : match.groups) || {};

package/dist/esm/common.js

@@ -64,6 +64,7 @@ import {
   isBaseExampleProvider
 } from "./examples/base_example_provider.js";
 import { InMemoryMemoryService } from "./memory/in_memory_memory_service.js";
+import { VertexAiMemoryBankService } from "./memory/vertex_ai_memory_bank_service.js";
 import { ApigeeLlm } from "./models/apigee_llm.js";
 import { BaseLlm, isBaseLlm } from "./models/base_llm.js";
 import { Gemini, geminiInitParams } from "./models/google_llm.js";
@@ -208,6 +209,7 @@ export {
   TruncatingContextCompactor,
   URL_CONTEXT,
   UrlContextTool,
+  VertexAiMemoryBankService,
   VertexAiSearchTool,
   VertexRagRetrievalTool,
   createEvent,

package/dist/esm/events/event.js

@@ -79,6 +79,7 @@ const PRESERVE_KEYS_CAMEL_CASE = [
   "actions.requestedAuthConfigs",
   "actions.requestedToolConfirmations",
   "actions.customMetadata",
+  "customMetadata",
   "content.parts.functionCall.args",
   "content.parts.functionResponse.response"
 ];
@@ -88,6 +89,7 @@ const PRESERVE_KEYS_SNAKE_CASE = [
   "actions.requested_auth_configs",
   "actions.requested_tool_confirmations",
   "actions.custom_metadata",
+  "custom_metadata",
   "content.parts.function_call.args",
   "content.parts.function_response.response"
 ];

package/dist/esm/index.js

@@ -9,15 +9,21 @@ import { AGENT_CARD_PATH, RemoteA2AAgent } from "./a2a/a2a_remote_agent.js";
 import { getA2AAgentCard } from "./a2a/agent_card.js";
 import { A2AAgentExecutor } from "./a2a/agent_executor.js";
 import { toA2a } from "./a2a/agent_to_a2a.js";
+import { InvocationContext } from "./agents/invocation_context.js";
 import { FileArtifactService } from "./artifacts/file_artifact_service.js";
 import { GcsArtifactService } from "./artifacts/gcs_artifact_service.js";
 import { getArtifactServiceFromUri } from "./artifacts/registry.js";
+import {
+  AgentEngineSandboxCodeExecutor
+} from "./code_executors/agent_engine_sandbox_code_executor.js";
+import { CodeExecutionLanguage } from "./code_executors/code_execution_utils.js";
 import {
   UnsafeLocalCodeExecutor
 } from "./code_executors/unsafe_local_code_executor.js";
 export * from "./common.js";
 import { DatabaseSessionService } from "./sessions/database_session_service.js";
 import { getSessionServiceFromUri } from "./sessions/registry.js";
+import { VertexAiSessionService } from "./sessions/vertex_ai_session_service.js";
 import {
   loadAllSkillsInDir,
   loadSkillFromDir,
@@ -25,6 +31,7 @@ import {
 } from "./skills/loader.js";
 import { RunSkillInlineScriptTool } from "./tools/skill/run_skill_inline_script_tool.js";
 import { RunSkillScriptTool } from "./tools/skill/run_skill_script_tool.js";
+export * from "./integrations/agent_registry/agent_registry.js";
 export * from "./telemetry/google_cloud.js";
 export * from "./telemetry/setup.js";
 export * from "./tools/mcp/mcp_session_manager.js";
@@ -33,13 +40,17 @@ export * from "./tools/mcp/mcp_toolset.js";
 export {
   A2AAgentExecutor,
   AGENT_CARD_PATH,
+  AgentEngineSandboxCodeExecutor,
+  CodeExecutionLanguage,
   DatabaseSessionService,
   FileArtifactService,
   GcsArtifactService,
+  InvocationContext,
   RemoteA2AAgent,
   RunSkillInlineScriptTool,
   RunSkillScriptTool,
   UnsafeLocalCodeExecutor,
+  VertexAiSessionService,
   getA2AAgentCard,
   getArtifactServiceFromUri,
   getSessionServiceFromUri,

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
+};