@google/adk 2.2.1 → 2.4.0

package/dist/cjs/a2a/a2a_remote_agent.js

@@ -63,7 +63,10 @@ const _RemoteA2AAgent = class _RemoteA2AAgent extends import_base_agent.BaseAgen
       this.client = this.a2aConfig.client;
     }
     if (this.a2aConfig.agentCard) {
-      this.card = await (0, import_agent_card.resolveAgentCard)(this.a2aConfig.agentCard);
+      this.card = await (0, import_agent_card.resolveAgentCard)(
+        this.a2aConfig.agentCard,
+        this.a2aConfig.resolveAgentCardOptions
+      );
       if (!this.client) {
         const factory = this.a2aConfig.clientFactory || new import_client.ClientFactory();
         this.client = await factory.createFromAgentCard(this.card);

package/dist/cjs/a2a/agent_card.js

@@ -59,19 +59,21 @@ var import_workflow = require("../workflow/workflow.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const WINDOWS_DRIVE_PROTOCOL = /^[a-z]:$/i;
-async function resolveAgentCard(agentCard) {
+async function resolveAgentCard(agentCard, options = {}) {
   if (typeof agentCard === "object") {
     return agentCard;
   }
-  const url = parseCardUrl(agentCard);
-  if (url && (0, import_ssrf_guard.isHttpUrl)(url)) {
-    await assertHostAllowed(url);
+  const source = agentCard;
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    await refuseLinkLocalHost(source);
     const resolver = new import_client.DefaultAgentCardResolver({
-      fetchImpl: noRedirectFetch(agentCard)
+      fetchImpl: refuseRedirectFetch
     });
-    return resolver.resolve(agentCard);
+    const card = await resolver.resolve(source);
+    validateCardRpcTargets(card, source, options);
+    return card;
   }
+  const url = parseCardUrl(source);
   if (url && url.protocol !== "file:") {
     throw new Error(
       `Unsupported agent card URL scheme "${url.protocol}": ${agentCard}. Use http://, https:// or file://, or pass a filesystem path with no scheme.`
@@ -80,6 +82,31 @@ async function resolveAgentCard(agentCard) {
   return readAgentCardFile(agentCard, url);
 }
 __name(resolveAgentCard, "resolveAgentCard");
+const WINDOWS_DRIVE_PROTOCOL = /^[a-z]:$/i;
+async function refuseLinkLocalHost(source) {
+  const hostname = (0, import_ssrf_guard.normalizeHost)(new URL(source).hostname);
+  if ((0, import_ssrf_guard.isLocalhostHostname)(hostname)) {
+    return;
+  }
+  const addresses = await (0, import_ssrf_guard.resolveHostAddresses)(hostname);
+  if (addresses.some((address) => (0, import_ssrf_guard.isLinkLocalAddress)(address))) {
+    throw new Error(
+      `Refusing to fetch agent card from a link-local address: ${hostname}`
+    );
+  }
+}
+__name(refuseLinkLocalHost, "refuseLinkLocalHost");
+async function refuseRedirectFetch(url, init) {
+  const response = await fetch(url, { ...init, redirect: "manual" });
+  if (response.status === 0 || response.status >= 300 && response.status < 400) {
+    const location = response.headers.get("location");
+    throw new Error(
+      `Refusing to follow a redirect from the agent card endpoint (status ${response.status}, location ${location}): ${url}`
+    );
+  }
+  return response;
+}
+__name(refuseRedirectFetch, "refuseRedirectFetch");
 function parseCardUrl(source) {
   let url;
   try {
@@ -102,32 +129,81 @@ async function readAgentCardFile(source, url) {
   }
 }
 __name(readAgentCardFile, "readAgentCardFile");
-function noRedirectFetch(source) {
-  return async (input, init) => {
-    const response = await fetch(input, { ...init, redirect: "manual" });
-    if (isRedirect(response.status)) {
+function validateCardRpcTargets(card, source, options) {
+  var _a;
+  let parsedSource;
+  try {
+    parsedSource = new URL(source);
+  } catch (err) {
+    throw new Error(
+      `Invalid agent card source URL: ${source}: ${err.message}`
+    );
+  }
+  const rpcUrls = [
+    card.url,
+    ...((_a = card.additionalInterfaces) != null ? _a : []).map((i) => i.url)
+  ];
+  for (const rpcUrl of rpcUrls) {
+    let parsed;
+    try {
+      parsed = new URL(rpcUrl);
+    } catch (err) {
       throw new Error(
-        `Refusing to follow a redirect while fetching the agent card from ${source} (status ${response.status}, location ${response.headers.get("location")}). Configure the final URL instead.`
+        `Invalid RPC URL in agent card: ${rpcUrl}: ${err.message}`
       );
     }
-    return response;
-  };
+    if (parsed.protocol !== "https:" && !isLoopbackHost(parsed.hostname)) {
+      if (options.allowInsecureRpc === true) {
+        import_logger.logger.warn(
+          `SECURITY WARNING: accepting a plaintext http RPC URL on a non-loopback host because \`allowInsecureRpc: true\` was set: ${rpcUrl}. This connection can be intercepted or altered by anything on the network path.`
+        );
+      } else {
+        throw new Error(
+          `Agent card RPC URL must use https, or http on a loopback host: ${rpcUrl}`
+        );
+      }
+    }
+    if (!sameOriginForRpc(parsedSource, parsed)) {
+      if (options.allowCrossOriginRpc === true) {
+        import_logger.logger.warn(
+          `SECURITY WARNING: accepting an agent card RPC URL whose origin differs from the location the card was fetched from because \`allowCrossOriginRpc: true\` was set (fetched from ${source}): ${rpcUrl}.`
+        );
+      } else {
+        throw new Error(
+          `Agent card RPC URL must have the same origin as the location the card was fetched from (${source}): ${rpcUrl}`
+        );
+      }
+    }
+  }
 }
-__name(noRedirectFetch, "noRedirectFetch");
-function isRedirect(status) {
-  return status === 0 || status >= 300 && status < 400;
+__name(validateCardRpcTargets, "validateCardRpcTargets");
+function sameOriginForRpc(source, rpc) {
+  const sourceIsLoopback = isLoopbackHost(source.hostname);
+  const rpcIsLoopback = isLoopbackHost(rpc.hostname);
+  if (sourceIsLoopback && rpcIsLoopback) {
+    return source.protocol === rpc.protocol && effectivePort(source) === effectivePort(rpc);
+  }
+  return source.origin === rpc.origin;
 }
-__name(isRedirect, "isRedirect");
-async function assertHostAllowed(url) {
-  const host = (0, import_ssrf_guard.normalizeHost)(url.hostname);
-  const addresses = await (0, import_ssrf_guard.resolveHostAddresses)(host);
-  if (addresses.some(import_ssrf_guard.isLinkLocalAddress)) {
-    throw new Error(
-      `Refusing to fetch agent card from a link-local address: ${host}`
-    );
+__name(sameOriginForRpc, "sameOriginForRpc");
+function effectivePort(url) {
+  if (url.port) {
+    return url.port;
+  }
+  if (url.protocol === "https:") {
+    return "443";
   }
+  if (url.protocol === "http:") {
+    return "80";
+  }
+  return url.port;
+}
+__name(effectivePort, "effectivePort");
+function isLoopbackHost(hostname) {
+  const bare = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  return bare === "localhost" || bare === "127.0.0.1" || bare === "::1" || bare === "0.0.0.0" || bare === "::" || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(bare);
 }
-__name(assertHostAllowed, "assertHostAllowed");
+__name(isLoopbackHost, "isLoopbackHost");
 async function getA2AAgentCard(agent, transports) {
   return {
     name: agent.name,

package/dist/cjs/a2a/agent_to_a2a.js

@@ -87,7 +87,7 @@ async function toA2a(agent, options = {}) {
   const protocol = (_c = options.protocol) != null ? _c : "http";
   const basePath = options.basePath || "";
   const rpcUrl = `${protocol}://${host}:${port}${basePath}`;
-  const agentCard = options.agentCard ? await (0, import_agent_card.resolveAgentCard)(options.agentCard) : await (0, import_agent_card.getA2AAgentCard)(agent, [
+  const agentCard = options.agentCard ? await (0, import_agent_card.resolveAgentCard)(options.agentCard, options.resolveAgentCardOptions) : await (0, import_agent_card.getA2AAgentCard)(agent, [
     {
       url: `${rpcUrl}/jsonrpc`,
       transport: "JSONRPC"

package/dist/cjs/agents/agent_engine_client.js

@@ -0,0 +1,172 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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_engine_client_exports = {};
+__export(agent_engine_client_exports, {
+  AgentEngineClient: () => AgentEngineClient,
+  AgentExecutionError: () => AgentExecutionError
+});
+module.exports = __toCommonJS(agent_engine_client_exports);
+var import_aiplatform = require("@google-cloud/aiplatform");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const _AgentExecutionError = class _AgentExecutionError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "AgentExecutionError";
+  }
+};
+__name(_AgentExecutionError, "AgentExecutionError");
+let AgentExecutionError = _AgentExecutionError;
+function buildInputStruct(config) {
+  var _a;
+  const value = import_aiplatform.helpers.toValue(config);
+  return (_a = value == null ? void 0 : value.structValue) != null ? _a : void 0;
+}
+__name(buildInputStruct, "buildInputStruct");
+function parseOutput(output) {
+  return import_aiplatform.helpers.fromValue(output);
+}
+__name(parseOutput, "parseOutput");
+function parseFragment(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return void 0;
+  const payload = trimmed.startsWith("data:") ? trimmed.slice(5).trim() : trimmed;
+  if (payload === "[DONE]") return void 0;
+  try {
+    return JSON.parse(payload);
+  } catch (e) {
+    throw new AgentExecutionError(
+      `Failed to parse stream fragment: ${payload}`,
+      e
+    );
+  }
+}
+__name(parseFragment, "parseFragment");
+async function* parseStream(stream) {
+  let buffer = "";
+  for await (const chunk of stream) {
+    const chunkData = chunk == null ? void 0 : chunk.data;
+    if (chunkData === void 0) {
+      if (typeof chunk === "object" && chunk !== null) {
+        yield chunk;
+      }
+      continue;
+    }
+    const dataStr = chunkData instanceof Uint8Array ? new TextDecoder().decode(chunkData) : String(chunkData);
+    buffer += dataStr;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      const fragment = parseFragment(line);
+      if (fragment !== void 0) {
+        yield fragment;
+      }
+    }
+  }
+  const last = parseFragment(buffer);
+  if (last !== void 0) {
+    yield last;
+  }
+}
+__name(parseStream, "parseStream");
+const _AgentEngineClient = class _AgentEngineClient {
+  constructor(config) {
+    this.client = new import_aiplatform.v1.ReasoningEngineExecutionServiceClient({
+      apiEndpoint: `${config.location}-aiplatform.googleapis.com`
+    });
+    this.reasoningEnginePath = this.client.reasoningEnginePath(
+      config.project,
+      config.location,
+      config.reasoningEngineId
+    );
+  }
+  /**
+   * Creates a remote session.
+   *
+   * @returns The `create_session` payload returned by the Agent Engine. When
+   *     `config.sessionId` is omitted the engine generates one, and this is the
+   *     only place the caller can read it back from.
+   */
+  async createSession(config) {
+    try {
+      const [response] = await this.client.queryReasoningEngine({
+        name: this.reasoningEnginePath,
+        classMethod: "create_session",
+        input: buildInputStruct(config)
+      });
+      return response.output ? parseOutput(response.output) : void 0;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new AgentExecutionError(
+        `Failed to create session: ${message}`,
+        err
+      );
+    }
+  }
+  async query(config) {
+    try {
+      const [response] = await this.client.queryReasoningEngine({
+        name: this.reasoningEnginePath,
+        classMethod: "query",
+        input: buildInputStruct(config)
+      });
+      return response.output ? parseOutput(response.output) : void 0;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new AgentExecutionError(`Failed to execute query: ${message}`, err);
+    }
+  }
+  async *streamQuery(config) {
+    try {
+      const stream = this.client.streamQueryReasoningEngine({
+        name: this.reasoningEnginePath,
+        classMethod: "query",
+        input: buildInputStruct(config)
+      });
+      yield* parseStream(stream);
+    } catch (err) {
+      if (err instanceof AgentExecutionError) {
+        throw err;
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      throw new AgentExecutionError(
+        `Failed to execute stream query: ${message}`,
+        err
+      );
+    }
+  }
+};
+__name(_AgentEngineClient, "AgentEngineClient");
+let AgentEngineClient = _AgentEngineClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentEngineClient,
+  AgentExecutionError
+});

package/dist/cjs/agents/base_agent.js

@@ -259,6 +259,22 @@ const _BaseAgent = class _BaseAgent extends (_b = import_base_node.BaseNode, _a
       agent: this
     });
   }
+  /**
+   * The resolved beforeAgentCallback field as a list of SingleAgentCallback.
+   *
+   * This method is only for use by Agent Development Kit.
+   */
+  get canonicalBeforeAgentCallbacks() {
+    return this.beforeAgentCallback;
+  }
+  /**
+   * The resolved afterAgentCallback field as a list of SingleAgentCallback.
+   *
+   * This method is only for use by Agent Development Kit.
+   */
+  get canonicalAfterAgentCallbacks() {
+    return this.afterAgentCallback;
+  }
   /**
    * Runs the before agent callback if it exists.
    *
@@ -268,11 +284,11 @@ const _BaseAgent = class _BaseAgent extends (_b = import_base_node.BaseNode, _a
    */
   async handleBeforeAgentCallback(invocationContext) {
     var _a2;
-    if (this.beforeAgentCallback.length === 0) {
+    if (this.canonicalBeforeAgentCallbacks.length === 0) {
       return void 0;
     }
     const callbackContext = new import_context.Context({ invocationContext });
-    for (const callback of this.beforeAgentCallback) {
+    for (const callback of this.canonicalBeforeAgentCallbacks) {
       const content = await callback(callbackContext);
       if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
         return;
@@ -307,11 +323,11 @@ const _BaseAgent = class _BaseAgent extends (_b = import_base_node.BaseNode, _a
    */
   async handleAfterAgentCallback(invocationContext) {
     var _a2;
-    if (this.afterAgentCallback.length === 0) {
+    if (this.canonicalAfterAgentCallbacks.length === 0) {
       return void 0;
     }
     const callbackContext = new import_context.Context({ invocationContext });
-    for (const callback of this.afterAgentCallback) {
+    for (const callback of this.canonicalAfterAgentCallbacks) {
       const content = await callback(callbackContext);
       if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
         return;