@google/adk 2.2.1 → 2.4.0

package/dist/esm/utils/env_aware_utils.js

@@ -38,14 +38,10 @@ function randomUUID() {
 __name(randomUUID, "randomUUID");
 function base64Encode(data) {
   if (isBrowser()) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
     let strData = "";
-    if (typeof data === "string") {
-      strData = data;
-    } else {
-      const len = data.byteLength;
-      for (let i = 0; i < len; i++) {
-        strData += String.fromCharCode(data[i]);
-      }
+    for (let i = 0; i < bytes.length; i++) {
+      strData += String.fromCharCode(bytes[i]);
     }
     return window.btoa(strData);
   }
@@ -54,7 +50,9 @@ function base64Encode(data) {
 __name(base64Encode, "base64Encode");
 function base64Decode(data) {
   if (isBrowser()) {
-    return window.atob(data);
+    const binary = window.atob(data);
+    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+    return new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes);
   }
   return Buffer.from(data, "base64").toString();
 }

package/dist/esm/utils/error_utils.js

@@ -29,16 +29,14 @@ function truncateBody(body) {
   return body.length > MAX_RESPONSE_BODY_LENGTH ? body.slice(0, MAX_RESPONSE_BODY_LENGTH) + TRUNCATION_MARKER : body;
 }
 __name(truncateBody, "truncateBody");
-function baseMessage(err) {
-  if (err instanceof Error) {
-    return err.message;
-  }
-  if (typeof err === "string") {
-    return err;
+function getErrorMessage(err) {
+  const record = asRecord(err);
+  if (record !== void 0 && typeof record["message"] === "string") {
+    return record["message"];
   }
   return String(err);
 }
-__name(baseMessage, "baseMessage");
+__name(getErrorMessage, "getErrorMessage");
 function extractHttpDetails(err) {
   var _a, _b;
   const record = asRecord(err);
@@ -71,7 +69,7 @@ function formatErrorRecursive(err, seen) {
   }
   if (typeof err === "object") {
     if (seen.has(err)) {
-      return baseMessage(err);
+      return getErrorMessage(err);
     }
     seen.add(err);
   }
@@ -79,7 +77,7 @@ function formatErrorRecursive(err, seen) {
     return err.errors.map((sub) => formatErrorRecursive(sub, seen)).join(" | ");
   }
   const http = extractHttpDetails(err);
-  const base = baseMessage(err);
+  const base = getErrorMessage(err);
   const cause = (_a = asRecord(err)) == null ? void 0 : _a["cause"];
   const causeMessage = cause !== void 0 ? formatErrorRecursive(cause, seen) : void 0;
   let message = base.length > 0 ? base : UNKNOWN_ERROR;
@@ -97,5 +95,6 @@ function formatError(err) {
 }
 __name(formatError, "formatError");
 export {
-  formatError
+  formatError,
+  getErrorMessage
 };

package/dist/esm/utils/failover_utils.js

@@ -21,9 +21,9 @@ async function* runWithRouting(items, context, router, runFn) {
   }
   const triedKeys = /* @__PURE__ */ new Set([selectedKey]);
   while (true) {
-    const generatorOrPromise = runFn(selectedItem);
     let firstYielded = false;
     try {
+      const generatorOrPromise = runFn(selectedItem);
       if (isAsyncGenerator(generatorOrPromise)) {
         for await (const result2 of generatorOrPromise) {
           yield result2;

package/dist/esm/utils/file_extension_utils.js

@@ -13,7 +13,17 @@ import {
 } from "../code_executors/code_execution_utils.js";
 const MIME_TYPE_MAP = {
   ".js": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".cjs": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".mjs": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".ts": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".cts": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".mts": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
   ".py": { mimeType: "text/x-python", encoding: FileContentEncoding.UTF8 },
+  ".sh": { mimeType: "text/x-shellscript", encoding: FileContentEncoding.UTF8 },
+  ".bash": {
+    mimeType: "text/x-shellscript",
+    encoding: FileContentEncoding.UTF8
+  },
   ".md": { mimeType: "text/markdown", encoding: FileContentEncoding.UTF8 },
   ".txt": { mimeType: "text/plain", encoding: FileContentEncoding.UTF8 },
   ".html": { mimeType: "text/html", encoding: FileContentEncoding.UTF8 },
@@ -27,6 +37,7 @@ const MIME_TYPE_MAP = {
   ".png": { mimeType: "image/png", encoding: FileContentEncoding.BASE64 },
   ".jpg": { mimeType: "image/jpeg", encoding: FileContentEncoding.BASE64 },
   ".jpeg": { mimeType: "image/jpeg", encoding: FileContentEncoding.BASE64 },
+  ".gif": { mimeType: "image/gif", encoding: FileContentEncoding.BASE64 },
   ".pdf": { mimeType: "application/pdf", encoding: FileContentEncoding.BASE64 }
 };
 const EXTENSION_TO_LANGUAGE = {

package/dist/esm/utils/file_utils.js

@@ -9,6 +9,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { getMimeTypeAndEncoding } from "./file_extension_utils.js";
 function isInsideDir(resolvedPath, resolvedBaseDir) {
   return resolvedPath === resolvedBaseDir || resolvedPath.startsWith(resolvedBaseDir + path.sep);
 }
@@ -59,33 +60,11 @@ async function materializeFiles(files, dir) {
   return createdFiles;
 }
 __name(materializeFiles, "materializeFiles");
-const EXTENSION_TO_MIME_TYPE = {
-  "pdf": "application/pdf",
-  "jpg": "image/jpeg",
-  "jpeg": "image/jpeg",
-  "png": "image/png",
-  "gif": "image/gif",
-  "csv": "text/csv",
-  "json": "application/json",
-  "xml": "application/xml",
-  "sh": "text/x-shellscript",
-  "bash": "text/x-shellscript",
-  "py": "text/x-python",
-  "js": "text/javascript",
-  "cjs": "text/javascript",
-  "mjs": "text/javascript",
-  "ts": "text/javascript",
-  "cts": "text/javascript",
-  "mts": "text/javascript"
-};
 function guessMimeType(filePath) {
-  var _a;
-  const ext = ((_a = filePath.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
-  return EXTENSION_TO_MIME_TYPE[ext] || "application/octet-stream";
+  return getMimeTypeAndEncoding(path.extname(filePath)).mimeType;
 }
 __name(guessMimeType, "guessMimeType");
 export {
-  EXTENSION_TO_MIME_TYPE,
   guessMimeType,
   materializeFiles
 };

package/dist/esm/utils/gemini_schema_util.js

@@ -45,6 +45,9 @@ function toGeminiSchema(mcpSchema) {
   }
   function recursiveConvert(mcp) {
     var _a;
+    if (typeof mcp === "boolean") {
+      mcp = { type: "object" };
+    }
     const sourceType = (_a = mcp.anyOf) != null ? _a : mcp.type;
     let isNullable = false;
     let nonNullTypes;
@@ -135,7 +138,7 @@ function toGeminiSchema(mcpSchema) {
         geminiSchema.required = mcp.required;
       }
     } else if (geminiType === Type.ARRAY) {
-      if (mcp.items) {
+      if (mcp.items || mcp.items === false) {
         geminiSchema.items = recursiveConvert(mcp.items);
       }
     }
@@ -174,7 +177,6 @@ const GEMINI_REJECTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
   "default",
   "format"
 ]);
-const EMPTY_OBJECT_PLACEHOLDER = "dummy_DO_NOT_GENERATE";
 function toGeminiSchemaField(key) {
   return toSnakeCaseName(key).replace(
     /_([a-z0-9])/g,
@@ -186,6 +188,23 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 __name(isPlainObject, "isPlainObject");
+function normalizeJsonSchemaType(jsonSchemaType) {
+  if (typeof jsonSchemaType === "string") {
+    if (jsonSchemaType === "null") {
+      return [void 0, true];
+    }
+    return [jsonSchemaType, false];
+  }
+  if (Array.isArray(jsonSchemaType)) {
+    const nullable = jsonSchemaType.includes("null");
+    const nonNullTypes = jsonSchemaType.filter(
+      (t) => typeof t === "string" && t !== "null"
+    );
+    return [nonNullTypes[0], nullable];
+  }
+  return [void 0, false];
+}
+__name(normalizeJsonSchemaType, "normalizeJsonSchemaType");
 function convertSchemaField(field, value) {
   if (field === "type") {
     return toGeminiType(typeof value === "string" ? value : void 0);
@@ -215,14 +234,14 @@ function openApiSchemaToGeminiSchema(openApiSchema) {
     throw new TypeError("openapi_schema must be a dictionary");
   }
   const source = { ...openApiSchema };
+  const [schemaType, nullable] = normalizeJsonSchemaType(source["type"]);
+  source["type"] = schemaType;
+  if (nullable) {
+    source["nullable"] = true;
+  }
   if (!source["type"]) {
     source["type"] = "object";
   }
-  const properties = source["properties"];
-  const hasProperties = isPlainObject(properties) && Object.keys(properties).length > 0;
-  if (source["type"] === "object" && !hasProperties) {
-    source["properties"] = { [EMPTY_OBJECT_PLACEHOLDER]: { type: "string" } };
-  }
   const converted = {};
   for (const [key, value] of Object.entries(source)) {
     const field = toGeminiSchemaField(key);
@@ -235,6 +254,7 @@ function openApiSchemaToGeminiSchema(openApiSchema) {
 }
 __name(openApiSchemaToGeminiSchema, "openApiSchemaToGeminiSchema");
 export {
+  normalizeJsonSchemaType,
   openApiSchemaToGeminiSchema,
   toGeminiSchema
 };

package/dist/esm/utils/json_utils.js

@@ -0,0 +1,21 @@
+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 isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isJsonObject, "isJsonObject");
+function toJsonObject(value) {
+  return isJsonObject(value) ? value : {};
+}
+__name(toJsonObject, "toJsonObject");
+export {
+  isJsonObject,
+  toJsonObject
+};

package/dist/esm/utils/live_connection_utils.js

@@ -178,12 +178,11 @@ const _LiveResponseAggregator = class _LiveResponseAggregator {
           yield this.buildFullTextResponse(this.text, this.isThought);
           this.text = "";
           this.isThought = false;
-        } else {
-          yield {
-            interrupted: serverContent.interrupted,
-            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
-          };
         }
+        yield {
+          interrupted: serverContent.interrupted,
+          ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+        };
       }
     }
     if (message.toolCall) {

package/dist/esm/utils/logger_node.js

@@ -9,6 +9,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import * as winston from "winston";
 import { LogLevel, setLogger } from "./logger.js";
+const WINSTON_LEVEL_NAMES = {
+  [LogLevel.DEBUG]: "debug",
+  [LogLevel.INFO]: "info",
+  [LogLevel.WARN]: "warn",
+  [LogLevel.ERROR]: "error"
+};
 const _WinstonLogger = class _WinstonLogger {
   constructor() {
     this.logLevel = LogLevel.INFO;
@@ -19,6 +25,10 @@ const _WinstonLogger = class _WinstonLogger {
         "warn": LogLevel.WARN,
         "error": LogLevel.ERROR
       },
+      // `levels` above inverts winston's npm ordering, so `error` (3) is the
+      // most permissive and leaves winston pass-through. Every method already
+      // gates on `this.logLevel`; a lower value here would double-gate and
+      // drop records.
       level: "error",
       format: winston.format.combine(
         winston.format.label({ label: "ADK" }),
@@ -42,7 +52,7 @@ const _WinstonLogger = class _WinstonLogger {
     if (this.logLevel > level) {
       return;
     }
-    this.logger.log(level.toString(), messages.join(" "));
+    this.logger.log(WINSTON_LEVEL_NAMES[level], messages.join(" "));
   }
   debug(...messages) {
     if (this.logLevel > LogLevel.DEBUG) {

package/dist/esm/utils/object_notation_utils.js

@@ -19,7 +19,8 @@ const toCamelCaseKey = /* @__PURE__ */ __name((key) => key.replace(
   /_([a-z])/g,
   (_match, letter) => letter.toUpperCase()
 ), "toCamelCaseKey");
-const toSnakeCaseKey = /* @__PURE__ */ __name((key) => key.replace(/[A-Z]/g, (g) => "_" + g.toLowerCase()), "toSnakeCaseKey");
+const CAMEL_BOUNDARY = /(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/g;
+const toSnakeCaseKey = /* @__PURE__ */ __name((key) => key.replace(CAMEL_BOUNDARY, "_").toLowerCase().replace(/-/g, "_"), "toSnakeCaseKey");
 function toNotation(obj, converter, parentKey = "", preserveKeys = []) {
   if (Array.isArray(obj)) {
     return obj.map(
@@ -50,5 +51,6 @@ function toNotation(obj, converter, parentKey = "", preserveKeys = []) {
 __name(toNotation, "toNotation");
 export {
   toCamelCase,
-  toSnakeCase
+  toSnakeCase,
+  toSnakeCaseKey
 };

package/dist/esm/utils/output_schema_utils.js

@@ -7,10 +7,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { isGemini } from "../models/google_llm.js";
 import { isGemini2OrAbove } from "./model_name.js";
 import { getGoogleLlmVariant, GoogleLLMVariant } from "./variant_utils.js";
-function canUseOutputSchemaWithTools(modelString) {
-  return getGoogleLlmVariant() === GoogleLLMVariant.VERTEX_AI && isGemini2OrAbove(modelString);
+function canUseOutputSchemaWithTools(model) {
+  const modelString = typeof model === "string" ? model : model.model;
+  const variant = isGemini(model) ? model.apiBackend : getGoogleLlmVariant();
+  return variant === GoogleLLMVariant.VERTEX_AI && isGemini2OrAbove(modelString);
 }
 __name(canUseOutputSchemaWithTools, "canUseOutputSchemaWithTools");
 export {

package/dist/esm/utils/streaming_utils.js

@@ -206,7 +206,7 @@ const _NonProgressiveStrategy = class _NonProgressiveStrategy {
     this.thoughtText = "";
   }
   async *processResponse(llmResponse) {
-    var _a;
+    var _a, _b;
     if ((_a = llmResponse.content) == null ? void 0 : _a.parts) {
       const nonTextParts = [];
       let sawTextPart = false;
@@ -226,7 +226,8 @@ const _NonProgressiveStrategy = class _NonProgressiveStrategy {
         nonTextParts.push(part);
       }
       if (nonTextParts.length > 0) {
-        if (this.thoughtText || this.text) {
+        const startsWithInlineData = !!((_b = llmResponse.content.parts[0]) == null ? void 0 : _b.inlineData);
+        if (!startsWithInlineData && (this.thoughtText || this.text)) {
           const parts = [];
           if (this.thoughtText) {
             parts.push({ text: this.thoughtText, thought: true });
@@ -277,13 +278,12 @@ const _NonProgressiveStrategy = class _NonProgressiveStrategy {
 };
 __name(_NonProgressiveStrategy, "NonProgressiveStrategy");
 let NonProgressiveStrategy = _NonProgressiveStrategy;
-const _StreamingResponseAggregator = class _StreamingResponseAggregator {
-  constructor(isProgressiveMode = isFeatureEnabled(
-    FeatureName.PROGRESSIVE_SSE_STREAMING
-  )) {
-    this.isProgressiveMode = isProgressiveMode;
+const _GeminiStreamingResponseAggregator = class _GeminiStreamingResponseAggregator {
+  constructor({
+    isProgressiveMode = isFeatureEnabled(FeatureName.PROGRESSIVE_SSE_STREAMING)
+  } = {}) {
     this.lastThoughtSignature = {};
-    this.strategy = this.isProgressiveMode ? new ProgressiveStrategy() : new NonProgressiveStrategy();
+    this.strategy = isProgressiveMode ? new ProgressiveStrategy() : new NonProgressiveStrategy();
   }
   async *processResponse(response) {
     var _a, _b;
@@ -356,13 +356,13 @@ const _StreamingResponseAggregator = class _StreamingResponseAggregator {
     };
   }
 };
-__name(_StreamingResponseAggregator, "StreamingResponseAggregator");
-let StreamingResponseAggregator = _StreamingResponseAggregator;
+__name(_GeminiStreamingResponseAggregator, "GeminiStreamingResponseAggregator");
+let GeminiStreamingResponseAggregator = _GeminiStreamingResponseAggregator;
 function isEmptyContentPart(part) {
   return !part.functionCall && !part.functionResponse && !part.fileData && !part.inlineData && !part.executableCode && !part.codeExecutionResult && (!part.text || part.text === "");
 }
 __name(isEmptyContentPart, "isEmptyContentPart");
 export {
-  StreamingResponseAggregator,
+  GeminiStreamingResponseAggregator,
   isEmptyContentPart
 };

package/dist/esm/utils/task.js

@@ -16,7 +16,7 @@ const _Task = class _Task {
       this.isDone = true;
     }, "markDone");
     this.promise = executable(this.abortController.signal);
-    this.promise.then(markDone).catch(markDone);
+    this.promise.then(markDone, markDone);
   }
   /**
    * Cancels the task execution.

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.2.1";
+const version = "2.4.0";
 export {
   version
 };

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

@@ -8,6 +8,7 @@ import { Client, ClientFactory } from '@a2a-js/sdk/client';
 import { BaseAgent, BaseAgentConfig } from '../agents/base_agent.js';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event as AdkEvent } from '../events/event.js';
+import { ResolveAgentCardOptions } from './agent_card.js';
 export { AGENT_CARD_PATH };
 /**
  * Type alias for A2A stream event data.
@@ -45,6 +46,14 @@ export interface RemoteA2AAgentConfig extends BaseAgentConfig {
      * Loaded AgentCard or URL to AgentCard.
      */
     agentCard?: AgentCard | string;
+    /**
+     * Controls how a fetched agent card's RPC URL(s) are validated against
+     * the location the card was fetched from. Only relevant when
+     * {@link RemoteA2AAgentConfig.agentCard} is a URL rather than an
+     * already-loaded card object; see {@link ResolveAgentCardOptions} for
+     * what each option relaxes and why both default to failing closed.
+     */
+    resolveAgentCardOptions?: ResolveAgentCardOptions;
     /**
      * Optional pre-initialized Client for connection pooling.
      */

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

@@ -5,6 +5,49 @@
  */
 import { AgentCard, AgentInterface, AgentSkill } from '@a2a-js/sdk';
 import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
+/**
+ * Options controlling how a fetched agent card's RPC URL(s) are validated
+ * against the location the card was fetched from. See `validateCardRpcTargets`
+ * for what each check defends against and why
+ * both default to failing closed.
+ */
+export interface ResolveAgentCardOptions {
+    /**
+     * Explicit escape hatch to accept a plaintext http:// RPC URL on a
+     * non-loopback host.
+     *
+     * This is intentionally insecure: an RPC URL that isn't https and isn't
+     * on this machine can be intercepted or altered by anything on the
+     * network path, even when its origin matches the card's own. Only set
+     * this for a card source you know serves plain http on a host you
+     * trust (e.g. a private, internal service reached over a channel
+     * that's secured some other way). When set to `true`, a loud warning is
+     * logged for each RPC URL this affects.
+     *
+     * Defaults to `false`: RPC URLs must be https, or http on a loopback
+     * host (localhost, 127.0.0.0/8, ::1, 0.0.0.0, or ::).
+     */
+    allowInsecureRpc?: boolean;
+    /**
+     * Explicit escape hatch to accept an RPC URL whose origin differs from
+     * the location the card was fetched from.
+     *
+     * This is intentionally permissive: it is what lets a compromised or
+     * misconfigured card-hosting endpoint redirect all subsequent A2A
+     * traffic for this agent, including whatever credential material the
+     * request-forwarding path carries, to a different origin than the one
+     * that was actually configured and fetched. The A2A spec allows a card
+     * to point RPC at a different origin than where the card itself is
+     * served from (e.g. static card hosting separate from the API
+     * backend), which is the legitimate case this exists for -- only set
+     * this when that's a shape you actually expect. When set to `true`, a
+     * loud warning is logged for each RPC URL this affects.
+     *
+     * Defaults to `false`: every RPC URL must share the origin the card
+     * was fetched from.
+     */
+    allowCrossOriginRpc?: boolean;
+}
 /**
  * Resolves the AgentCard from the provided source.
  *
@@ -17,7 +60,7 @@ import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
  * 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>;
+export declare function resolveAgentCard(agentCard: AgentCard | string, options?: ResolveAgentCardOptions): Promise<AgentCard>;
 /**
  * Converts an ADK agent to an A2A AgentCard.
  */

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

@@ -11,6 +11,7 @@ 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 { ResolveAgentCardOptions } from './agent_card.js';
 import { AdkDefaultRequestHandler, getA2aRequestMetadata } from './request_metadata.js';
 export { AdkDefaultRequestHandler, getA2aRequestMetadata };
 /**
@@ -39,6 +40,14 @@ export interface ToA2aOptions {
     basePath?: string;
     /** Optional pre-built AgentCard object or path to agent card JSON */
     agentCard?: AgentCard | string;
+    /**
+     * Controls how a fetched agent card's RPC URL(s) are validated against
+     * the location the card was fetched from. Only relevant when
+     * {@link ToA2aOptions.agentCard} is a URL rather than an already-loaded
+     * card object or file path; see {@link ResolveAgentCardOptions} for
+     * what each option relaxes and why both default to failing closed.
+     */
+    resolveAgentCardOptions?: ResolveAgentCardOptions;
     /** Optional pre-built Runner object */
     runner?: Runner;
     /** Optional session service */

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

@@ -10,6 +10,7 @@
 export { AGENT_CARD_PATH, RemoteA2AAgent } from './a2a_remote_agent.js';
 export type { A2AStreamEventData, AfterA2ARequestCallback, BeforeA2ARequestCallback, RemoteA2AAgentConfig, } from './a2a_remote_agent.js';
 export { getA2AAgentCard } from './agent_card.js';
+export type { ResolveAgentCardOptions } from './agent_card.js';
 export { A2AAgentExecutor } from './agent_executor.js';
 export type { AfterEventCallback, AfterExecuteCallback, AgentExecutorConfig, BeforeExecuteCallback, RunnerOrRunnerConfig, } from './agent_executor.js';
 export { AdkDefaultRequestHandler, getA2aRequestMetadata, toA2a, } from './agent_to_a2a.js';

package/dist/types/agents/agent_engine_client.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface AgentEngineConfig {
+    project: string;
+    location: string;
+    reasoningEngineId: string;
+}
+export interface SessionConfig {
+    userId?: string;
+    sessionId?: string;
+}
+export interface QueryConfig extends SessionConfig {
+    message: unknown;
+    [key: string]: unknown;
+}
+export declare class AgentExecutionError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare class AgentEngineClient {
+    private client;
+    private reasoningEnginePath;
+    constructor(config: AgentEngineConfig);
+    /**
+     * 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.
+     */
+    createSession(config: SessionConfig): Promise<unknown>;
+    query(config: QueryConfig): Promise<unknown>;
+    streamQuery(config: QueryConfig): AsyncGenerator<unknown, void, unknown>;
+}

package/dist/types/agents/base_agent.d.ts

@@ -224,6 +224,18 @@ export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAg
      * @return The invocation context for this agent.
      */
     protected createInvocationContext(parentContext: InvocationContext): InvocationContext;
+    /**
+     * The resolved beforeAgentCallback field as a list of SingleAgentCallback.
+     *
+     * This method is only for use by Agent Development Kit.
+     */
+    get canonicalBeforeAgentCallbacks(): SingleAgentCallback[];
+    /**
+     * The resolved afterAgentCallback field as a list of SingleAgentCallback.
+     *
+     * This method is only for use by Agent Development Kit.
+     */
+    get canonicalAfterAgentCallbacks(): SingleAgentCallback[];
     /**
      * Runs the before agent callback if it exists.
      *