@google/adk 2.3.0 → 2.5.0

package/dist/cjs/a2a/a2a_remote_agent.js

@@ -33,6 +33,7 @@ var import_sdk = require("@a2a-js/sdk");
 var import_client = require("@a2a-js/sdk/client");
 var import_base_agent = require("../agents/base_agent.js");
 var import_event = require("../events/event.js");
+var import_instrumentation = require("../telemetry/api/instrumentation.js");
 var import_env_aware_utils = require("../utils/env_aware_utils.js");
 var import_logger = require("../utils/logger.js");
 var import_a2a_event = require("./a2a_event.js");
@@ -46,6 +47,18 @@ var import_metadata_converter_utils = require("./metadata_converter_utils.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+function createTracePropagatingClientFactory() {
+  const fetchImpl = (0, import_instrumentation.propagateTraceContext)();
+  return new import_client.ClientFactory(
+    import_client.ClientFactoryOptions.createFrom(import_client.ClientFactoryOptions.default, {
+      transports: [
+        new import_client.JsonRpcTransportFactory({ fetchImpl }),
+        new import_client.RestTransportFactory({ fetchImpl })
+      ]
+    })
+  );
+}
+__name(createTracePropagatingClientFactory, "createTracePropagatingClientFactory");
 const _RemoteA2AAgent = class _RemoteA2AAgent extends import_base_agent.BaseAgent {
   constructor(a2aConfig) {
     super(a2aConfig);
@@ -56,6 +69,7 @@ const _RemoteA2AAgent = class _RemoteA2AAgent extends import_base_agent.BaseAgen
     }
   }
   async init() {
+    var _a;
     if (this.isInitialized) {
       return;
     }
@@ -68,7 +82,7 @@ const _RemoteA2AAgent = class _RemoteA2AAgent extends import_base_agent.BaseAgen
         this.a2aConfig.resolveAgentCardOptions
       );
       if (!this.client) {
-        const factory = this.a2aConfig.clientFactory || new import_client.ClientFactory();
+        const factory = (_a = this.a2aConfig.clientFactory) != null ? _a : createTracePropagatingClientFactory();
         this.client = await factory.createFromAgentCard(this.card);
       }
     }
@@ -84,7 +98,8 @@ const _RemoteA2AAgent = class _RemoteA2AAgent extends import_base_agent.BaseAgen
       }
       const userFnCall = (0, import_a2a_remote_agent_utils.getUserFunctionCallAt)(
         context.session,
-        events.length - 1
+        events.length - 1,
+        this.name
       );
       let parts;
       let taskId = void 0;

package/dist/cjs/a2a/a2a_remote_agent_utils.js

@@ -46,7 +46,8 @@ var import_part_converter_utils = require("./part_converter_utils.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-function getUserFunctionCallAt(session, index) {
+function getUserFunctionCallAt(session, index, agentName) {
+  var _a, _b;
   const events = session.events;
   if (index < 0 || index >= events.length) {
     return void 0;
@@ -55,13 +56,16 @@ function getUserFunctionCallAt(session, index) {
   if (candidate.author !== "user") {
     return void 0;
   }
-  const fnCallId = getFunctionResponseCallId(candidate);
-  if (!fnCallId) {
+  const fnCallIds = (_b = (_a = candidate.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.map((part) => {
+    var _a2;
+    return (_a2 = part.functionResponse) == null ? void 0 : _a2.id;
+  }).filter((id) => !!id);
+  if (!(fnCallIds == null ? void 0 : fnCallIds.length)) {
     return void 0;
   }
   for (let i = index - 1; i >= 0; i--) {
     const request = events[i];
-    if (!isFunctionCallEvent(request, fnCallId)) {
+    if (request.author !== agentName || !fnCallIds.some((callId) => isFunctionCallEvent(request, callId))) {
       continue;
     }
     const metadata = request.customMetadata || {};

package/dist/cjs/a2a/agent_card.js

@@ -43,12 +43,11 @@ module.exports = __toCommonJS(agent_card_exports);
 var import_client = require("@a2a-js/sdk/client");
 var fs = __toESM(require("node:fs/promises"), 1);
 var import_node_url = require("node:url");
-var import_invocation_context = require("../agents/invocation_context.js");
 var import_llm_agent = require("../agents/llm_agent.js");
 var import_loop_agent = require("../agents/loop_agent.js");
 var import_parallel_agent = require("../agents/parallel_agent.js");
-var import_readonly_context = require("../agents/readonly_context.js");
 var import_sequential_agent = require("../agents/sequential_agent.js");
+var import_instrumentation = require("../telemetry/api/instrumentation.js");
 var import_base_tool = require("../tools/base_tool.js");
 var import_base_toolset = require("../tools/base_toolset.js");
 var import_logger = require("../utils/logger.js");
@@ -67,7 +66,7 @@ async function resolveAgentCard(agentCard, options = {}) {
   if (source.startsWith("http://") || source.startsWith("https://")) {
     await refuseLinkLocalHost(source);
     const resolver = new import_client.DefaultAgentCardResolver({
-      fetchImpl: refuseRedirectFetch
+      fetchImpl: tracePropagatingRefuseRedirectFetch
     });
     const card = await resolver.resolve(source);
     validateCardRpcTargets(card, source, options);
@@ -107,6 +106,7 @@ async function refuseRedirectFetch(url, init) {
   return response;
 }
 __name(refuseRedirectFetch, "refuseRedirectFetch");
+const tracePropagatingRefuseRedirectFetch = (0, import_instrumentation.propagateTraceContext)(refuseRedirectFetch);
 function parseCardUrl(source) {
   let url;
   try {
@@ -273,7 +273,7 @@ async function buildLLMAgentSkills(agent) {
     {
       id: agent.name,
       name: "model",
-      description: await buildDescriptionFromInstructions(agent),
+      description: buildAgentDescription(agent),
       tags: ["llm"]
     }
   ];
@@ -342,7 +342,7 @@ function buildAgentDescription(agent) {
   if (agent.description) {
     descriptionParts.push(agent.description);
   }
-  if (agent.subAgents.length > 0) {
+  if (!(0, import_llm_agent.isLlmAgent)(agent) && agent.subAgents.length > 0) {
     if ((0, import_loop_agent.isLoopAgent)(agent)) {
       descriptionParts.push(buildLoopAgentDescription(agent));
     } else if ((0, import_parallel_agent.isParallelAgent)(agent)) {
@@ -420,82 +420,6 @@ function buildLoopAgentDescription(agent) {
   return `${descriptions.join(" ")} in a loop (max ${maxIterations} iterations).`;
 }
 __name(buildLoopAgentDescription, "buildLoopAgentDescription");
-async function buildDescriptionFromInstructions(agent) {
-  const descriptionParts = [];
-  if (agent.description) {
-    descriptionParts.push(agent.description);
-  }
-  if (agent.instruction) {
-    let instructionStr;
-    if (typeof agent.instruction === "function") {
-      const dummyContext = new import_readonly_context.ReadonlyContext(
-        new import_invocation_context.InvocationContext({
-          agent
-        })
-      );
-      try {
-        instructionStr = await agent.instruction(dummyContext);
-      } catch (e) {
-        import_logger.logger.warn("Failed to resolve dynamic instruction for AgentCard", e);
-        instructionStr = "";
-      }
-    } else {
-      instructionStr = agent.instruction;
-    }
-    if (instructionStr) {
-      descriptionParts.push(replacePronouns(instructionStr));
-    }
-  }
-  const root = agent.rootAgent;
-  if ((0, import_llm_agent.isLlmAgent)(root) && root.globalInstruction) {
-    let globalInstructionStr;
-    if (typeof root.globalInstruction === "function") {
-      const dummyContext = new import_readonly_context.ReadonlyContext(
-        new import_invocation_context.InvocationContext({
-          agent
-        })
-      );
-      try {
-        globalInstructionStr = await root.globalInstruction(dummyContext);
-      } catch (e) {
-        import_logger.logger.warn(
-          "Failed to resolve dynamic global instruction for AgentCard",
-          e
-        );
-        globalInstructionStr = "";
-      }
-    } else {
-      globalInstructionStr = root.globalInstruction;
-    }
-    if (globalInstructionStr) {
-      descriptionParts.push(replacePronouns(globalInstructionStr));
-    }
-  }
-  if (descriptionParts.length > 0) {
-    return descriptionParts.join(" ");
-  } else {
-    return getDefaultAgentDescription(agent);
-  }
-}
-__name(buildDescriptionFromInstructions, "buildDescriptionFromInstructions");
-function replacePronouns(instruction) {
-  const substitutions = [
-    { original: "you were", target: "I was" },
-    { original: "you are", target: "I am" },
-    { original: "you're", target: "I am" },
-    { original: "you've", target: "I have" },
-    { original: "yours", target: "mine" },
-    { original: "your", target: "my" },
-    { original: "you", target: "I" }
-  ];
-  let result = instruction;
-  for (const sub of substitutions) {
-    const pattern = new RegExp(`\\b${sub.original}\\b`, "gi");
-    result = result.replace(pattern, sub.target);
-  }
-  return result;
-}
-__name(replacePronouns, "replacePronouns");
 function getDefaultAgentDescription(agent) {
   if ((0, import_loop_agent.isLoopAgent)(agent)) {
     return "A loop workflow agent";

package/dist/cjs/a2a/agent_to_a2a.js

@@ -44,6 +44,7 @@ var import_sdk = require("@a2a-js/sdk");
 var import_server = require("@a2a-js/sdk/server");
 var import_run_config = require("../agents/run_config.js");
 var import_in_memory_session_service = require("../sessions/in_memory_session_service.js");
+var import_instrumentation = require("../telemetry/api/instrumentation.js");
 var import_logger = require("../utils/logger.js");
 var import_optional_peer = require("../utils/optional_peer.js");
 var import_agent_card = require("./agent_card.js");
@@ -63,6 +64,10 @@ async function loadExpressBindings() {
   return { express: expressModule.default, a2aExpress };
 }
 __name(loadExpressBindings, "loadExpressBindings");
+function continueRemoteTrace(req, _res, next) {
+  (0, import_instrumentation.runWithRemoteTraceContext)(req.headers, () => next());
+}
+__name(continueRemoteTrace, "continueRemoteTrace");
 function resolveA2aUserBuilder(options, a2aExpress) {
   if (options.authentication) {
     return options.authentication;
@@ -124,6 +129,7 @@ async function toA2a(agent, options = {}) {
   );
   app.use(
     `${basePath}/rest`,
+    continueRemoteTrace,
     a2aExpress.restHandler({
       requestHandler,
       userBuilder
@@ -131,6 +137,7 @@ async function toA2a(agent, options = {}) {
   );
   app.use(
     `${basePath}/jsonrpc`,
+    continueRemoteTrace,
     a2aExpress.jsonRpcHandler({
       requestHandler,
       userBuilder

package/dist/cjs/a2a/event_converter_utils.js

@@ -79,7 +79,12 @@ function messageToAdkEvent(msg, invocationId, agentName, branch) {
   return {
     ...createAdkEventFromMetadata(msg),
     invocationId,
-    author: msg.role === import_a2a_event.MessageRole.USER ? import_a2a_event.MessageRole.USER : agentName,
+    // The role on a peer's message is the peer's own claim and must not decide
+    // authorship: letting `user` through here lets a remote agent post events
+    // that read as the local user's, which is a trust anchor elsewhere (tool
+    // confirmations are approved only from user-authored events). Attribute the
+    // event to the peer, the same way the task and status converters below do.
+    author: agentName,
     branch,
     content,
     turnComplete: true,
@@ -194,8 +199,10 @@ function createAdkEventFromMetadata(a2aEvent) {
     // (set it to a shared ancestor branch, or omit it) to leak its content
     // into an unrelated sibling agent's LLM context. Every caller of the
     // `*ToAdkEvent` functions in this file force-sets `branch` from its own
-    // local `InvocationContext` instead, the same way `author` is handled.
-    author: metadata[import_metadata_converter_utils.A2AMetadataKeys.AUTHOR],
+    // local `InvocationContext` instead, the same way `author` is handled:
+    // `author` is likewise never restored from peer metadata here, since every
+    // converter sets it from the local context after the spread, so reading it
+    // from metadata would be dead and read as if a peer could set the author.
     partial: metadata[import_metadata_converter_utils.A2AMetadataKeys.PARTIAL],
     errorCode: metadata[import_metadata_converter_utils.A2AMetadataKeys.ERROR_CODE],
     errorMessage: metadata[import_metadata_converter_utils.A2AMetadataKeys.ERROR_MESSAGE],

package/dist/cjs/agents/agent_engine_client.js

@@ -0,0 +1,399 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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_error_utils = require("../utils/error_utils.js");
+var import_optional_peer = require("../utils/optional_peer.js");
+/**
+ * @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;
+const WIRE_KEY_ALIASES = [
+  ["userId", "user_id"],
+  ["sessionId", "session_id"],
+  ["expireTime", "expire_time"],
+  ["runConfig", "run_config"],
+  ["stateDelta", "state_delta"]
+];
+function toWireInput(config) {
+  var _a;
+  const input = { ...config };
+  delete input["classMethod"];
+  for (const [camel, snake] of WIRE_KEY_ALIASES) {
+    input[snake] = (_a = input[snake]) != null ? _a : input[camel];
+    delete input[camel];
+  }
+  for (const key of Object.keys(input)) {
+    if (input[key] === void 0) {
+      delete input[key];
+    }
+  }
+  return input;
+}
+__name(toWireInput, "toWireInput");
+function buildInputStruct(sdkHelpers, input) {
+  var _a;
+  const value = sdkHelpers.toValue(input);
+  return (_a = value == null ? void 0 : value.structValue) != null ? _a : void 0;
+}
+__name(buildInputStruct, "buildInputStruct");
+function parseOutput(sdkHelpers, output) {
+  return sdkHelpers.fromValue(output);
+}
+__name(parseOutput, "parseOutput");
+const IGNORED_SSE_FIELDS = /* @__PURE__ */ new Set([
+  "event",
+  "id",
+  "retry"
+]);
+const DONE_SENTINEL = "[DONE]";
+function parseFragment(payload) {
+  try {
+    return JSON.parse(payload);
+  } catch (e) {
+    throw new AgentExecutionError(
+      `Failed to parse stream fragment: ${payload}`,
+      e
+    );
+  }
+}
+__name(parseFragment, "parseFragment");
+function* dispatchEvent(dataLines) {
+  if (dataLines.length === 0) {
+    return;
+  }
+  const lines = dataLines.splice(0);
+  const payload = lines.join("\n").trim();
+  if (payload === "" || payload === DONE_SENTINEL) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = parseFragment(payload);
+  } catch (e) {
+    if (lines.length === 1) {
+      throw e;
+    }
+    const values = [];
+    try {
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed !== "" && trimmed !== DONE_SENTINEL) {
+          values.push(JSON.parse(trimmed));
+        }
+      }
+    } catch {
+      throw e;
+    }
+    yield* values;
+    return;
+  }
+  yield parsed;
+}
+__name(dispatchEvent, "dispatchEvent");
+function* processLine(rawLine, dataLines) {
+  const line = (rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine).replace(/^[ \t]+/, "");
+  if (line === "") {
+    yield* dispatchEvent(dataLines);
+    return;
+  }
+  if (line.startsWith(":")) {
+    return;
+  }
+  const colon = line.indexOf(":");
+  const field = colon === -1 ? line : line.slice(0, colon);
+  if (IGNORED_SSE_FIELDS.has(field)) {
+    return;
+  }
+  if (field === "data") {
+    if (dataLines.length === 1) {
+      const buffered = dataLines[0].trim();
+      if (buffered === DONE_SENTINEL) {
+        yield* dispatchEvent(dataLines);
+      } else if (buffered !== "") {
+        try {
+          JSON.parse(buffered);
+          yield* dispatchEvent(dataLines);
+        } catch {
+        }
+      }
+    }
+    const value = colon === -1 ? "" : line.slice(colon + 1);
+    dataLines.push(value.startsWith(" ") ? value.slice(1) : value);
+    return;
+  }
+  yield* dispatchEvent(dataLines);
+  const trimmed = line.trim();
+  if (trimmed === "" || trimmed === DONE_SENTINEL) {
+    return;
+  }
+  yield parseFragment(trimmed);
+}
+__name(processLine, "processLine");
+async function* parseStream(stream) {
+  var _a;
+  const decoder = new TextDecoder("utf-8");
+  const dataLines = [];
+  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;
+    }
+    buffer += chunkData instanceof Uint8Array ? decoder.decode(chunkData, { stream: true }) : String(chunkData);
+    const lines = buffer.split("\n");
+    buffer = (_a = lines.pop()) != null ? _a : "";
+    for (const line of lines) {
+      yield* processLine(line, dataLines);
+    }
+  }
+  buffer += decoder.decode();
+  for (const line of buffer.split("\n")) {
+    yield* processLine(line, dataLines);
+  }
+  yield* dispatchEvent(dataLines);
+}
+__name(parseStream, "parseStream");
+const _AgentEngineClient = class _AgentEngineClient {
+  constructor(config) {
+    var _a;
+    this.apiEndpoint = (_a = config.apiEndpoint) != null ? _a : config.location === "global" ? "aiplatform.googleapis.com" : `${config.location}-aiplatform.googleapis.com`;
+    this.reasoningEnginePath = `projects/${config.project}/locations/${config.location}/reasoningEngines/${config.reasoningEngineId}`;
+  }
+  /**
+   * Creates a remote session.
+   *
+   * Calls the `async_create_session` class method unless `config.classMethod`
+   * names another one.
+   *
+   * @returns The 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) {
+    return this.callQueryMethod({
+      config,
+      defaultClassMethod: "async_create_session",
+      errorPrefix: "Failed to create session"
+    });
+  }
+  /**
+   * Reads a remote session.
+   *
+   * Calls the `async_get_session` class method unless `config.classMethod`
+   * names another one.
+   *
+   * @throws {@link AgentExecutionError} if the user id or the session id is
+   *     missing, or if the call fails.
+   */
+  async getSession(config) {
+    var _a, _b;
+    const userId = (_a = config.user_id) != null ? _a : config.userId;
+    const sessionId = (_b = config.session_id) != null ? _b : config.sessionId;
+    if (!userId || !sessionId) {
+      throw new AgentExecutionError(
+        "Failed to get session: user_id and session_id are required"
+      );
+    }
+    return this.callQueryMethod({
+      config,
+      defaultClassMethod: "async_get_session",
+      errorPrefix: "Failed to get session"
+    });
+  }
+  /**
+   * Lists the remote sessions of a user.
+   *
+   * Calls the `async_list_sessions` class method unless `config.classMethod`
+   * names another one.
+   */
+  async listSessions(config) {
+    return this.callQueryMethod({
+      config,
+      defaultClassMethod: "async_list_sessions",
+      errorPrefix: "Failed to list sessions"
+    });
+  }
+  /**
+   * Deletes a remote session.
+   *
+   * Calls the `async_delete_session` class method unless `config.classMethod`
+   * names another one.
+   */
+  async deleteSession(config) {
+    await this.callQueryMethod({
+      config,
+      defaultClassMethod: "async_delete_session",
+      errorPrefix: "Failed to delete session"
+    });
+  }
+  /**
+   * Sends a query and waits for the whole response.
+   *
+   * Calls the `query` class method unless `config.classMethod` names another
+   * one.
+   */
+  async query(config) {
+    return this.callQueryMethod({
+      config,
+      defaultClassMethod: "query",
+      errorPrefix: "Failed to execute query"
+    });
+  }
+  /**
+   * Sends a query and yields each streamed response value.
+   *
+   * Calls the `async_stream_query` class method unless `config.classMethod`
+   * names another one. The stream can be server-sent events or
+   * newline-delimited JSON.
+   */
+  async *streamQuery(config) {
+    var _a;
+    try {
+      const { helpers: sdkHelpers, client } = await this.getClient();
+      const stream = client.streamQueryReasoningEngine({
+        name: this.reasoningEnginePath,
+        classMethod: (_a = config.classMethod) != null ? _a : "async_stream_query",
+        input: buildInputStruct(sdkHelpers, toWireInput(config))
+      });
+      yield* parseStream(stream);
+    } catch (err) {
+      if (err instanceof AgentExecutionError) {
+        throw err;
+      }
+      throw new AgentExecutionError(
+        `Failed to execute stream query: ${(0, import_error_utils.getErrorMessage)(err)}`,
+        err
+      );
+    }
+  }
+  /**
+   * Closes the underlying gRPC client.
+   *
+   * Does nothing if no call has created the client yet, and is safe to call
+   * more than once. A later call creates a new client.
+   */
+  async close() {
+    const pending = this.clientPromise;
+    if (!pending) {
+      return;
+    }
+    this.clientPromise = void 0;
+    let loaded;
+    try {
+      loaded = await pending;
+    } catch {
+      return;
+    }
+    await loaded.client.close();
+  }
+  async callQueryMethod({
+    config,
+    defaultClassMethod,
+    errorPrefix
+  }) {
+    var _a;
+    try {
+      const { helpers: sdkHelpers, client } = await this.getClient();
+      const [response] = await client.queryReasoningEngine({
+        name: this.reasoningEnginePath,
+        classMethod: (_a = config.classMethod) != null ? _a : defaultClassMethod,
+        input: buildInputStruct(sdkHelpers, toWireInput(config))
+      });
+      return response.output ? parseOutput(sdkHelpers, response.output) : void 0;
+    } catch (err) {
+      throw new AgentExecutionError(
+        `${errorPrefix}: ${(0, import_error_utils.getErrorMessage)(err)}`,
+        err
+      );
+    }
+  }
+  /**
+   * Resolves the SDK helpers and the gRPC client, loading the optional peer on
+   * first use.
+   *
+   * A created client is kept. A failure is not kept, so the next call tries
+   * again, for example once the peer is installed.
+   */
+  getClient() {
+    if (!this.clientPromise) {
+      const promise = this.createClient();
+      this.clientPromise = promise;
+      promise.catch(() => {
+        if (this.clientPromise === promise) {
+          this.clientPromise = void 0;
+        }
+      });
+    }
+    return this.clientPromise;
+  }
+  async createClient() {
+    const aiplatform = await (0, import_optional_peer.loadOptionalPeer)(
+      { packageName: "@google-cloud/aiplatform", feature: "AgentEngineClient" },
+      () => Promise.resolve().then(() => __toESM(require("@google-cloud/aiplatform"), 1))
+    );
+    return {
+      helpers: aiplatform.helpers,
+      client: new aiplatform.v1.ReasoningEngineExecutionServiceClient({
+        apiEndpoint: this.apiEndpoint
+      })
+    };
+  }
+};
+__name(_AgentEngineClient, "AgentEngineClient");
+let AgentEngineClient = _AgentEngineClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentEngineClient,
+  AgentExecutionError
+});