@google/adk 2.0.0 → 2.2.0

package/dist/esm/utils/logger_node.js

@@ -0,0 +1,81 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as winston from "winston";
+import { LogLevel, setLogger } from "./logger.js";
+const _WinstonLogger = class _WinstonLogger {
+  constructor() {
+    this.logLevel = LogLevel.INFO;
+    this.logger = winston.createLogger({
+      levels: {
+        "debug": LogLevel.DEBUG,
+        "info": LogLevel.INFO,
+        "warn": LogLevel.WARN,
+        "error": LogLevel.ERROR
+      },
+      level: "error",
+      format: winston.format.combine(
+        winston.format.label({ label: "ADK" }),
+        winston.format((info) => {
+          info.level = info.level.toUpperCase();
+          return info;
+        })(),
+        winston.format.colorize(),
+        winston.format.timestamp(),
+        winston.format.printf((info) => {
+          return `${info.level}: [${info.label}] ${info.timestamp} ${info.message}`;
+        })
+      ),
+      transports: [new winston.transports.Console()]
+    });
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  log(level, ...messages) {
+    if (this.logLevel > level) {
+      return;
+    }
+    this.logger.log(level.toString(), messages.join(" "));
+  }
+  debug(...messages) {
+    if (this.logLevel > LogLevel.DEBUG) {
+      return;
+    }
+    this.logger.debug(messages.join(" "));
+  }
+  info(...messages) {
+    if (this.logLevel > LogLevel.INFO) {
+      return;
+    }
+    this.logger.info(messages.join(" "));
+  }
+  warn(...messages) {
+    if (this.logLevel > LogLevel.WARN) {
+      return;
+    }
+    this.logger.warn(messages.join(" "));
+  }
+  error(...messages) {
+    if (this.logLevel > LogLevel.ERROR) {
+      return;
+    }
+    this.logger.error(messages.join(" "));
+  }
+};
+__name(_WinstonLogger, "WinstonLogger");
+let WinstonLogger = _WinstonLogger;
+function installNodeLogger() {
+  setLogger(new WinstonLogger());
+}
+__name(installNodeLogger, "installNodeLogger");
+export {
+  WinstonLogger,
+  installNodeLogger
+};

package/dist/esm/utils/model_name.js

@@ -53,12 +53,23 @@ function isGemini2OrAbove(modelString) {
   return parsedVersion.valid && parsedVersion.major >= 2;
 }
 __name(isGemini2OrAbove, "isGemini2OrAbove");
-function isGemini3xFlashLive(modelString) {
+function isGemini3xLive(modelString) {
   if (!modelString) {
     return false;
   }
   const modelName = extractModelName(modelString);
-  return modelName.startsWith("gemini-3.") && modelName.includes("-flash-live");
+  return modelName.startsWith("gemini-3.") && modelName.includes("-live") && !isGemini35LiveTranslate(modelString);
+}
+__name(isGemini3xLive, "isGemini3xLive");
+function isGemini35LiveTranslate(modelString) {
+  if (!modelString) {
+    return false;
+  }
+  return extractModelName(modelString).startsWith("gemini-3.5-live-translate");
+}
+__name(isGemini35LiveTranslate, "isGemini35LiveTranslate");
+function isGemini3xFlashLive(modelString) {
+  return isGemini3xLive(modelString);
 }
 __name(isGemini3xFlashLive, "isGemini3xFlashLive");
 function isGeminiModelIdCheckDisabled() {
@@ -69,7 +80,9 @@ export {
   extractModelName,
   isGemini1Model,
   isGemini2OrAbove,
+  isGemini35LiveTranslate,
   isGemini3xFlashLive,
+  isGemini3xLive,
   isGeminiModel,
   isGeminiModelIdCheckDisabled
 };

package/dist/esm/utils/redact_inline_data.js

@@ -0,0 +1,19 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function stringifyWithRedactedInlineData(value) {
+  return JSON.stringify(
+    value,
+    (key, val) => key === "inlineData" && typeof val === "object" && val !== null && "data" in val && typeof val.data === "string" ? { ...val, data: `<redacted ${val.data.length} chars>` } : val
+  );
+}
+__name(stringifyWithRedactedInlineData, "stringifyWithRedactedInlineData");
+export {
+  stringifyWithRedactedInlineData
+};

package/dist/esm/utils/redact_uri.js

@@ -11,7 +11,21 @@ const SECRET_QUERY_PARAMS = /* @__PURE__ */ new Set([
   "password",
   "passwd",
   "pwd",
-  "sslpassword"
+  "sslpassword",
+  // OAuth2 callback/authorization-response URIs carry their own secrets as
+  // query parameters rather than in userinfo: an authorization `code` is a
+  // single-use, bearer-equivalent credential, and a token response echoed
+  // back via URI can carry `access_token`/`id_token`/`refresh_token`.
+  // Only the query string is scanned: in the implicit and hybrid flows those
+  // token parameters arrive in the fragment, which is left untouched.
+  // `client_secret` is not meant to travel in a URL at all, but is included
+  // here in case a misconfigured flow puts it there anyway.
+  "code",
+  "access_token",
+  "id_token",
+  "refresh_token",
+  "client_secret",
+  "code_verifier"
 ]);
 function redactUriPassword(uri) {
   try {

package/dist/esm/utils/schema.js

@@ -89,7 +89,7 @@ function objectSchemaFields(schema) {
   return fields != null ? fields : void 0;
 }
 __name(objectSchemaFields, "objectSchemaFields");
-const UNRESOLVABLE_REF = Symbol("unresolvable-ref");
+const UNRESOLVABLE_REF = /* @__PURE__ */ Symbol("unresolvable-ref");
 function compileField(fieldSchema, document) {
   try {
     return compileJsonSchema(inlineRefs(fieldSchema, document));

package/dist/esm/utils/simple_zod_to_json.js

@@ -86,6 +86,11 @@ function zodObjectToSchema(schema) {
   if (isZodV3Schema(schema)) {
     return toJSONSchemaV3(schema, {
       target: "openApi3",
+      // The genai `Schema` type has no `$ref`, so a pointer back at an earlier
+      // occurrence of a reused sub-schema reaches the model as an untyped
+      // parameter. Inline every occurrence instead. A cycle has no finite
+      // inlining and degrades to an unconstrained schema.
+      $refStrategy: "none",
       emailStrategy: "format:email",
       postProcess: /* @__PURE__ */ __name((jsonSchema) => {
         var _a, _b, _c, _d, _e, _f, _g;

package/dist/{web/tools/load_web_page.js → esm/utils/ssrf_guard.js}

@@ -9,11 +9,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
-import { z } from "zod";
-import { FunctionTool } from "./function_tool.js";
-const ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
-const DEFAULT_TIMEOUT_MS = 3e4;
-const BLOCKED_IPV4_CIDRS = [
+const HTTP_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
+const NON_GLOBAL_IPV4_CIDRS = [
   "0.0.0.0/8",
   // "this host on this network"
   "10.0.0.0/8",
@@ -45,7 +42,7 @@ const BLOCKED_IPV4_CIDRS = [
   "240.0.0.0/4"
   // reserved / future use (includes 255.255.255.255)
 ].map(parseIpv4Cidr);
-const BLOCKED_IPV6_CIDRS = [
+const NON_GLOBAL_IPV6_CIDRS = [
   "::/128",
   // unspecified
   "::1/128",
@@ -63,19 +60,57 @@ const BLOCKED_IPV6_CIDRS = [
   "ff00::/8"
   // multicast
 ].map(parseIpv6Cidr);
-function failedToFetchMessage(url) {
-  return "Failed to fetch url: ".concat(url);
-}
-__name(failedToFetchMessage, "failedToFetchMessage");
-function isBlockedHostname(hostname) {
+const LINK_LOCAL_IPV4_CIDR = parseIpv4Cidr("169.254.0.0/16");
+const LINK_LOCAL_IPV6_CIDR = parseIpv6Cidr("fe80::/10");
+const IPV4_MAPPED_CIDR = parseIpv6Cidr("::ffff:0:0/96");
+const NAT64_CIDR = parseIpv6Cidr("64:ff9b::/96");
+const SIX_TO_FOUR_CIDR = parseIpv6Cidr("2002::/16");
+const IPV4_COMPATIBLE_CIDR = parseIpv6Cidr("::/96");
+function isHttpUrl(url) {
+  return HTTP_SCHEMES.has(url.protocol);
+}
+__name(isHttpUrl, "isHttpUrl");
+function isLocalhostHostname(hostname) {
   const normalized = hostname.replace(/\.+$/, "").toLowerCase();
   return normalized === "localhost" || normalized.endsWith(".localhost");
 }
-__name(isBlockedHostname, "isBlockedHostname");
+__name(isLocalhostHostname, "isLocalhostHostname");
 function normalizeHost(hostname) {
   return hostname.startsWith("[") ? hostname.slice(1, -1) : hostname;
 }
 __name(normalizeHost, "normalizeHost");
+function isNonGlobalAddress(address) {
+  return classifyAddress(address, isNonGlobalIpv4, isNonGlobalIpv6);
+}
+__name(isNonGlobalAddress, "isNonGlobalAddress");
+function isLinkLocalAddress(address) {
+  return classifyAddress(address, isLinkLocalIpv4, isLinkLocalIpv6);
+}
+__name(isLinkLocalAddress, "isLinkLocalAddress");
+async function resolveHostAddresses(hostname) {
+  if (isIP(hostname) !== 0) {
+    return [hostname];
+  }
+  const records = await lookup(hostname, { all: true });
+  const addresses = [...new Set(records.map((record) => record.address))];
+  if (addresses.length === 0) {
+    throw new Error(`Unable to resolve host: ${hostname}`);
+  }
+  return addresses;
+}
+__name(resolveHostAddresses, "resolveHostAddresses");
+function classifyAddress(address, matchesIpv4, matchesIpv6) {
+  const octets = parseIpv4(address);
+  if (octets) {
+    return matchesIpv4(octets);
+  }
+  const hextets = parseIpv6(address);
+  if (hextets) {
+    return matchesIpv6(hextets);
+  }
+  return true;
+}
+__name(classifyAddress, "classifyAddress");
 function parseIpv4(address) {
   const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(address);
   if (!match) {
@@ -117,9 +152,9 @@ function ipv4ToInt(octets) {
 }
 __name(ipv4ToInt, "ipv4ToInt");
 function hextetsToBigInt(hextets) {
-  let value = /* @__PURE__ */ BigInt("0");
+  let value = 0n;
   for (const hextet of hextets) {
-    value = value << /* @__PURE__ */ BigInt("16") | BigInt(hextet);
+    value = value << 16n | BigInt(hextet);
   }
   return value;
 }
@@ -135,108 +170,61 @@ function parseIpv6Cidr(cidr) {
   return { base: hextetsToBigInt(parseIpv6(address)), prefix: Number(prefix) };
 }
 __name(parseIpv6Cidr, "parseIpv6Cidr");
-function isBlockedIpv4(octets) {
-  const value = ipv4ToInt(octets);
-  return BLOCKED_IPV4_CIDRS.some(
-    ({ base, mask }) => (value & mask) >>> 0 === base
-  );
-}
-__name(isBlockedIpv4, "isBlockedIpv4");
-function isBlockedIpv6(hextets) {
-  const value = hextetsToBigInt(hextets);
-  if (value >> /* @__PURE__ */ BigInt("32") === /* @__PURE__ */ BigInt("0xffff")) {
-    return isBlockedIpv4([
-      Number(value >> /* @__PURE__ */ BigInt("24") & /* @__PURE__ */ BigInt("0xff")),
-      Number(value >> /* @__PURE__ */ BigInt("16") & /* @__PURE__ */ BigInt("0xff")),
-      Number(value >> /* @__PURE__ */ BigInt("8") & /* @__PURE__ */ BigInt("0xff")),
-      Number(value & /* @__PURE__ */ BigInt("0xff"))
-    ]);
+function matchesIpv4Cidr(octets, { base, mask }) {
+  return (ipv4ToInt(octets) & mask) >>> 0 === base;
+}
+__name(matchesIpv4Cidr, "matchesIpv4Cidr");
+function matchesIpv6Cidr(hextets, { base, prefix }) {
+  const shift = BigInt(128 - prefix);
+  return hextetsToBigInt(hextets) >> shift === base >> shift;
+}
+__name(matchesIpv6Cidr, "matchesIpv6Cidr");
+function embeddedIpv4(hextets) {
+  if (matchesIpv6Cidr(hextets, SIX_TO_FOUR_CIDR)) {
+    return hextetsToOctets(hextets[1], hextets[2]);
   }
-  return BLOCKED_IPV6_CIDRS.some(
-    ({ base, prefix }) => value >> BigInt(128 - prefix) === base >> BigInt(128 - prefix)
-  );
-}
-__name(isBlockedIpv6, "isBlockedIpv6");
-function isBlockedAddress(address) {
-  const octets = parseIpv4(address);
-  if (octets) {
-    return isBlockedIpv4(octets);
+  if (matchesIpv6Cidr(hextets, IPV4_MAPPED_CIDR) || matchesIpv6Cidr(hextets, NAT64_CIDR)) {
+    return hextetsToOctets(hextets[6], hextets[7]);
   }
-  const hextets = parseIpv6(address);
-  if (hextets) {
-    return isBlockedIpv6(hextets);
+  if (matchesIpv6Cidr(hextets, IPV4_COMPATIBLE_CIDR) && (hextets[6] !== 0 || hextets[7] > 1)) {
+    return hextetsToOctets(hextets[6], hextets[7]);
   }
-  return true;
+  return null;
 }
-__name(isBlockedAddress, "isBlockedAddress");
-async function resolveHostAddresses(hostname) {
-  if (isIP(hostname) !== 0) {
-    return [hostname];
-  }
-  const records = await lookup(hostname, { all: true });
-  const addresses = [...new Set(records.map((record) => record.address))];
-  if (addresses.length === 0) {
-    throw new Error("Unable to resolve host: ".concat(hostname));
-  }
-  return addresses;
+__name(embeddedIpv4, "embeddedIpv4");
+function hextetsToOctets(high, low) {
+  return [high >> 8, high & 255, low >> 8, low & 255];
 }
-__name(resolveHostAddresses, "resolveHostAddresses");
-function assertUrlAllowed(url) {
-  const parsed = new URL(url);
-  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
-    throw new Error("Unsupported url scheme: ".concat(url));
-  }
-  if (isBlockedHostname(parsed.hostname)) {
-    throw new Error("Blocked host: ".concat(parsed.hostname));
-  }
-  return parsed;
+__name(hextetsToOctets, "hextetsToOctets");
+function isNonGlobalIpv4(octets) {
+  return NON_GLOBAL_IPV4_CIDRS.some((cidr) => matchesIpv4Cidr(octets, cidr));
 }
-__name(assertUrlAllowed, "assertUrlAllowed");
-async function validateResolvedAddresses(hostname) {
-  const addresses = await resolveHostAddresses(hostname);
-  if (addresses.some(isBlockedAddress)) {
-    throw new Error("Blocked host: ".concat(hostname));
+__name(isNonGlobalIpv4, "isNonGlobalIpv4");
+function isNonGlobalIpv6(hextets) {
+  const embedded = embeddedIpv4(hextets);
+  if (embedded) {
+    return isNonGlobalIpv4(embedded);
   }
+  return NON_GLOBAL_IPV6_CIDRS.some((cidr) => matchesIpv6Cidr(hextets, cidr));
 }
-__name(validateResolvedAddresses, "validateResolvedAddresses");
-function decodeHtmlEntities(text) {
-  return text.replace(/&nbsp;/g, " ").replace(/&#39;/g, "'").replace(/&#x27;/g, "'").replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
-}
-__name(decodeHtmlEntities, "decodeHtmlEntities");
-function htmlToText(html) {
-  const withoutCode = html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<!--[\s\S]*?-->/g, " ");
-  const text = decodeHtmlEntities(withoutCode.replace(/<[^>]+>/g, "\n"));
-  return text.split("\n").map((line) => line.trim()).filter((line) => line.split(/\s+/).filter(Boolean).length > 3).join("\n");
-}
-__name(htmlToText, "htmlToText");
-async function loadWebPage(url, options) {
-  var _a;
-  const timeoutMs = (_a = options == null ? void 0 : options.timeoutMs) != null ? _a : DEFAULT_TIMEOUT_MS;
-  try {
-    const parsed = assertUrlAllowed(url);
-    await validateResolvedAddresses(normalizeHost(parsed.hostname));
-    const response = await fetch(url, {
-      redirect: "manual",
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-    if (response.status !== 200) {
-      return failedToFetchMessage(url);
-    }
-    return htmlToText(await response.text());
-  } catch (e) {
-    return failedToFetchMessage(url);
+__name(isNonGlobalIpv6, "isNonGlobalIpv6");
+function isLinkLocalIpv4(octets) {
+  return matchesIpv4Cidr(octets, LINK_LOCAL_IPV4_CIDR);
+}
+__name(isLinkLocalIpv4, "isLinkLocalIpv4");
+function isLinkLocalIpv6(hextets) {
+  const embedded = embeddedIpv4(hextets);
+  if (embedded) {
+    return isLinkLocalIpv4(embedded);
   }
+  return matchesIpv6Cidr(hextets, LINK_LOCAL_IPV6_CIDR);
 }
-__name(loadWebPage, "loadWebPage");
-const LOAD_WEB_PAGE = new FunctionTool({
-  name: "load_web_page",
-  description: "Fetches the content at the given URL and returns the readable text extracted from the page.",
-  parameters: z.object({
-    url: z.string().describe("The URL to fetch and extract text from.")
-  }),
-  execute: /* @__PURE__ */ __name(({ url }) => loadWebPage(url), "execute")
-});
+__name(isLinkLocalIpv6, "isLinkLocalIpv6");
 export {
-  LOAD_WEB_PAGE,
-  loadWebPage
+  isHttpUrl,
+  isLinkLocalAddress,
+  isLocalhostHostname,
+  isNonGlobalAddress,
+  normalizeHost,
+  resolveHostAddresses
 };

package/dist/esm/version.js

@@ -5,7 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "2.0.0";
+const version = "2.2.0";
 export {
   version
 };

package/dist/esm/workflow/base_node.js

@@ -17,7 +17,7 @@ import {
   prepareRetryConfig
 } from "./retry_config.js";
 import { createRequestInputEvent } from "./utils/hitl_utils.js";
-const BASE_NODE_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.baseNode");
+const BASE_NODE_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.workflow.baseNode");
 _a = BASE_NODE_SIGNATURE_SYMBOL;
 const _BaseNode = class _BaseNode {
   constructor(config) {

package/dist/esm/workflow/graph.js

@@ -11,7 +11,7 @@ var _a;
 import { logger } from "../utils/logger.js";
 import { parseEdgeItems } from "./utils/graph_parser.js";
 import { validateGraph } from "./utils/graph_validation.js";
-const EDGE_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.edge");
+const EDGE_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.workflow.edge");
 const DEFAULT_ROUTE = "__DEFAULT__";
 _a = EDGE_SIGNATURE_SYMBOL;
 const _Edge = class _Edge {

package/dist/esm/workflow/nodes/node_tool.js

@@ -16,7 +16,7 @@ import {
 } from "../../utils/simple_zod_to_json.js";
 import { NodeContext } from "../node_context.js";
 import { executeChildNode } from "../node_runner.js";
-const NODE_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.nodeTool");
+const NODE_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.workflow.nodeTool");
 const MAX_NODE_TOOL_DEPTH = 8;
 const _NodeTool = class _NodeTool extends (_b = BaseTool, _a = NODE_TOOL_SIGNATURE_SYMBOL, _b) {
   constructor(node, name, description) {
@@ -97,7 +97,7 @@ const _NodeTool = class _NodeTool extends (_b = BaseTool, _a = NODE_TOOL_SIGNATU
       // not the node name doubled.
       nodePath: "",
       runId,
-      resumeInputs: collectResumeInputs(toolContext)
+      resumeInputs: toolContext.resumeInputs
     });
     const base = childIc.branch;
     const segment = `${this.name}@${runId}`;
@@ -116,15 +116,6 @@ function isNodeTool(value) {
   return typeof value === "object" && value !== null && NODE_TOOL_SIGNATURE_SYMBOL in value && value[NODE_TOOL_SIGNATURE_SYMBOL] === true;
 }
 __name(isNodeTool, "isNodeTool");
-function collectResumeInputs(toolContext) {
-  var _a2;
-  const payload = (_a2 = toolContext.toolConfirmation) == null ? void 0 : _a2.payload;
-  if (payload && typeof payload === "object") {
-    return payload;
-  }
-  return {};
-}
-__name(collectResumeInputs, "collectResumeInputs");
 export {
   NodeTool,
   isNodeTool

package/dist/esm/workflow/request_input.js

@@ -9,7 +9,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 var _a;
 import { randomUUID } from "../utils/env_aware_utils.js";
-const REQUEST_INPUT_SIGNATURE_SYMBOL = Symbol.for(
+const REQUEST_INPUT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
   "google.adk.workflow.requestInput"
 );
 _a = REQUEST_INPUT_SIGNATURE_SYMBOL;

package/dist/esm/workflow/run_llm_agent_as_node.js

@@ -50,7 +50,7 @@ async function appendNodeInputAsUserTurn(ctx, nodeInput) {
     branch: ctx.branch,
     content: toUserContent(nodeInput)
   });
-  if (ctx.isolationScope) {
+  if (ctx.isolationScope !== void 0) {
     userEvent.isolationScope = ctx.isolationScope;
   }
   const sessionService = ctx.invocationContext.sessionService;

package/dist/esm/workflow/workflow.js

@@ -42,7 +42,7 @@ import {
   reconstructNodeRuns,
   resolvedInterruptResponses
 } from "./utils/rehydration_utils.js";
-const WORKFLOW_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.workflow");
+const WORKFLOW_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.workflow.workflow");
 const _LoopState = class _LoopState {
   constructor() {
     this.nodes = /* @__PURE__ */ new Map();

package/dist/types/a2a/a2a_event.d.ts

@@ -120,7 +120,13 @@ export declare function createTaskFailedEvent({ taskId, contextId, error, metada
     metadata?: Record<string, unknown>;
 }): TaskStatusUpdateEvent;
 /**
- * Creates an input required event.
+ * Creates an input-required status update.
+ *
+ * A2A has one `input-required` state, so every reason an agent can pause for a
+ * human produces the same status update: a long-running tool asking for input,
+ * and a client message that left an earlier request unanswered. What separates
+ * them travels in `parts` — a validation failure carries a text part marked
+ * `validation_error` — not in the shape of the event, so both go through here.
  */
 export declare function createTaskInputRequiredEvent({ taskId, contextId, parts, metadata, }: {
     taskId: string;
@@ -128,12 +134,3 @@ export declare function createTaskInputRequiredEvent({ taskId, contextId, parts,
     parts: A2APart[];
     metadata?: Record<string, unknown>;
 }): TaskStatusUpdateEvent;
-/**
- * Creates an error message for missing input for a function call.
- */
-export declare function createInputMissingErrorEvent({ taskId, contextId, parts, metadata, }: {
-    parts: A2APart[];
-    taskId: string;
-    contextId: string;
-    metadata?: Record<string, unknown>;
-}): TaskStatusUpdateEvent;

package/dist/types/a2a/a2a_remote_agent.d.ts

@@ -65,6 +65,11 @@ export interface RemoteA2AAgentConfig extends BaseAgentConfig {
      * Callbacks run after receiving a response chunk or event, before conversion.
      */
     afterRequestCallbacks?: AfterA2ARequestCallback[];
+    /**
+     * Optional request-level metadata to include in the A2A message send request.
+     * If omitted, defaults to `context.a2aMetadata` from the current invocation context.
+     */
+    metadata?: Record<string, unknown>;
 }
 /**
  * RemoteA2AAgent delegates execution to a remote agent using the A2A protocol.

package/dist/types/a2a/a2a_remote_agent_utils.d.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Part as A2APart } from '@a2a-js/sdk';
+import { Content } from '@google/genai';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event as AdkEvent } from '../events/event.js';
 import { Session } from '../sessions/session.js';
@@ -38,6 +39,30 @@ export declare function isFunctionCallEvent(event: AdkEvent, callId: string): bo
  *   none is found.
  */
 export declare function getFunctionResponseCallId(event: AdkEvent): string | undefined;
+/**
+ * Ids of credential requests the remote peer raised itself. An id that ANY
+ * non-peer event also issued a call for is excluded: the peer authors its
+ * own session events under its own name (`toAdkEvent` forces
+ * `author = this.name`) and controls `functionCall.id` verbatim, so a bare
+ * id match -- without checking whether some OTHER event also issued a call
+ * for that same id -- would let a peer re-label this agent's own pending
+ * credential request as one the peer had asked for, by sending an
+ * unrelated reply that happens to carry a function_call part whose id
+ * collides with it.
+ */
+export declare function peerRequestedCallIds(events: readonly AdkEvent[], peerName: string): ReadonlySet<string>;
+/**
+ * Converts genai parts to A2A parts for forwarding to the remote peer,
+ * scrubbing credential material the peer did not itself request.
+ *
+ * NOT the single point both session-forwarding paths converge on:
+ * `toMissingRemoteSessionParts` calls `withoutCredentialParts` directly,
+ * since it has to interleave `presentAsUserMessage` between the scrub and
+ * `toA2AParts`. The shared guarantee lives one level down, in
+ * `withoutCredentialParts` -- a third path calling `toA2AParts` directly
+ * would still bypass it.
+ */
+export declare function toForwardableA2AParts(content: Content | undefined, longRunningToolIds: string[] | undefined, peerRequestedIds: ReadonlySet<string>): A2APart[];
 /**
  * Returns A2A content parts for all events not yet seen by the remote agent,
  * along with the A2A context ID found in the most recent remote agent event.

package/dist/types/a2a/agent_card.d.ts

@@ -7,6 +7,15 @@ import { AgentCard, AgentInterface, AgentSkill } from '@a2a-js/sdk';
 import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
 /**
  * Resolves the AgentCard from the provided source.
+ *
+ * A source is either an {@link AgentCard}, an `http(s)://` URL to fetch it
+ * from, a `file://` URL, or a filesystem path. Any other URL scheme throws: a
+ * source that looks like a URL is never read off the local filesystem.
+ *
+ * The card host must not be, or resolve to, a link-local address, and a
+ * redirect from the card endpoint is refused rather than followed. Loopback and
+ * private addresses stay allowed: they are where a locally served or
+ * VPC-internal peer agent lives.
  */
 export declare function resolveAgentCard(agentCard: AgentCard | string): Promise<AgentCard>;
 /**

package/dist/types/a2a/agent_executor.d.ts

@@ -16,7 +16,7 @@ export type RunnerOrRunnerConfig = Runner | RunnerConfig | (() => Runner | Runne
 /**
  * Callback called before execution starts.
  */
-export type BeforeExecuteCallback = (reqCtx: RequestContext) => Promise<void>;
+export type BeforeExecuteCallback = (reqCtx: RequestContext, a2aMetadata?: Record<string, unknown>) => Promise<void>;
 /**
  * Callback called after an ADK event is converted to an A2A event.
  */

package/dist/types/a2a/agent_to_a2a.d.ts

@@ -11,6 +11,8 @@ import { BaseMemoryService } from '../memory/base_memory_service.js';
 import { Runner } from '../runner/runner.js';
 import { BaseSessionService } from '../sessions/base_session_service.js';
 import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
+import { AdkDefaultRequestHandler, getA2aRequestMetadata } from './request_metadata.js';
+export { AdkDefaultRequestHandler, getA2aRequestMetadata };
 /**
  * A request authenticator for the A2A surface.
  *