@google/adk 2.0.0 → 2.1.0

package/dist/esm/tools/google_search_tool.js

@@ -8,15 +8,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * SPDX-License-Identifier: Apache-2.0
  */
 import { isGemini1Model, isGeminiModel } from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
-const _GoogleSearchTool = class _GoogleSearchTool extends BaseTool {
+import { BuiltInTool } from "./built_in_tool.js";
+const _GoogleSearchTool = class _GoogleSearchTool extends BuiltInTool {
   constructor() {
     super({ name: "google_search", description: "Google Search Tool" });
   }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     if (!llmRequest.model) {

package/dist/esm/tools/load_artifacts_tool.js

@@ -9,11 +9,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { Type } from "@google/genai";
 import { appendInstructions } from "../models/llm_request.js";
-import { getLogger } from "../utils/logger.js";
+import { logger } from "../utils/logger.js";
 import {
   BaseTool
 } from "./base_tool.js";
-const logger = getLogger();
 const GEMINI_SUPPORTED_INLINE_MIME_PREFIXES = ["image/", "audio/", "video/"];
 const GEMINI_SUPPORTED_INLINE_MIME_TYPES = /* @__PURE__ */ new Set(["application/pdf"]);
 const TEXT_LIKE_MIME_TYPES = /* @__PURE__ */ new Set([
@@ -110,6 +109,7 @@ NOTE: Call when you need access to artifacts (for example, uploads saved by the
     );
   }
   async appendArtifactsToLlmRequest(toolContext, llmRequest) {
+    var _a, _b;
     if (!toolContext.invocationContext.artifactService) {
       return;
     }
@@ -130,33 +130,57 @@ NOTE: Call when you need access to artifacts (for example, uploads saved by the
   artifacts.`
     ]);
     const contents = llmRequest.contents;
-    if (contents && contents.length > 0) {
-      const lastContent = contents[contents.length - 1];
-      if (lastContent.role === "user" && lastContent.parts && lastContent.parts.length > 0) {
-        const functionResponsePart = lastContent.parts[0];
-        const functionResponse = functionResponsePart.functionResponse;
-        if (functionResponse && functionResponse.name === "load_artifacts") {
-          const response = functionResponse.response || {};
-          const namesToLoad = response["artifact_names"] || [];
-          for (const artifactName of namesToLoad) {
-            let artifact = await toolContext.loadArtifact(artifactName);
-            if (!artifact && !artifactName.startsWith("user:")) {
-              const prefixedName = `user:${artifactName}`;
-              artifact = await toolContext.loadArtifact(prefixedName);
-            }
-            if (!artifact) {
-              logger.warn(`Artifact "${artifactName}" not found, skipping`);
-              continue;
+    if (!contents || contents.length === 0) {
+      return;
+    }
+    let startIndex = 0;
+    for (let i = contents.length - 1; i >= 0; i--) {
+      const content = contents[i];
+      const hasFunctionResponse = (_a = content.parts) == null ? void 0 : _a.some(
+        (part) => part.functionResponse !== void 0
+      );
+      const hasFunctionCall = (_b = content.parts) == null ? void 0 : _b.some(
+        (part) => part.functionCall !== void 0
+      );
+      if (content.role === "model" && !hasFunctionCall || content.role === "user" && !hasFunctionResponse) {
+        startIndex = i;
+        break;
+      }
+    }
+    const namesToLoad = [];
+    for (let i = startIndex; i < contents.length; i++) {
+      const content = contents[i];
+      if (content.role === "user" && content.parts) {
+        for (const part of content.parts) {
+          const functionResponse = part.functionResponse;
+          if (functionResponse && functionResponse.name === this.name) {
+            const response = functionResponse.response || {};
+            const artifactNames2 = response["artifact_names"] || [];
+            for (const name of artifactNames2) {
+              if (name && !namesToLoad.includes(name)) {
+                namesToLoad.push(name);
+              }
             }
-            const artifactPart = asSafePartForLlm(artifact, artifactName);
-            llmRequest.contents.push({
-              role: "user",
-              parts: [{ text: `Artifact ${artifactName} is:` }, artifactPart]
-            });
           }
         }
       }
     }
+    for (const artifactName of namesToLoad) {
+      let artifact = await toolContext.loadArtifact(artifactName);
+      if (!artifact && !artifactName.startsWith("user:")) {
+        const prefixedName = `user:${artifactName}`;
+        artifact = await toolContext.loadArtifact(prefixedName);
+      }
+      if (!artifact) {
+        logger.warn(`Artifact "${artifactName}" not found, skipping`);
+        continue;
+      }
+      const artifactPart = asSafePartForLlm(artifact, artifactName);
+      llmRequest.contents.push({
+        role: "user",
+        parts: [{ text: `Artifact ${artifactName} is:` }, artifactPart]
+      });
+    }
   }
 };
 __name(_LoadArtifactsTool, "LoadArtifactsTool");

package/dist/esm/tools/load_web_page.js

@@ -7,186 +7,26 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { lookup } from "node:dns/promises";
-import { isIP } from "node:net";
 import { z } from "zod";
+import {
+  isHttpUrl,
+  isLocalhostHostname,
+  isNonGlobalAddress,
+  normalizeHost,
+  resolveHostAddresses
+} from "../utils/ssrf_guard.js";
 import { FunctionTool } from "./function_tool.js";
-const ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
 const DEFAULT_TIMEOUT_MS = 3e4;
-const BLOCKED_IPV4_CIDRS = [
-  "0.0.0.0/8",
-  // "this host on this network"
-  "10.0.0.0/8",
-  // private
-  "100.64.0.0/10",
-  // shared address space / CGNAT
-  "127.0.0.0/8",
-  // loopback
-  "169.254.0.0/16",
-  // link-local (includes GCP metadata 169.254.169.254)
-  "172.16.0.0/12",
-  // private
-  "192.0.0.0/24",
-  // IETF protocol assignments
-  "192.0.2.0/24",
-  // TEST-NET-1 (documentation)
-  "192.88.99.0/24",
-  // 6to4 relay anycast (deprecated)
-  "192.168.0.0/16",
-  // private
-  "198.18.0.0/15",
-  // benchmarking
-  "198.51.100.0/24",
-  // TEST-NET-2 (documentation)
-  "203.0.113.0/24",
-  // TEST-NET-3 (documentation)
-  "224.0.0.0/4",
-  // multicast
-  "240.0.0.0/4"
-  // reserved / future use (includes 255.255.255.255)
-].map(parseIpv4Cidr);
-const BLOCKED_IPV6_CIDRS = [
-  "::/128",
-  // unspecified
-  "::1/128",
-  // loopback
-  "64:ff9b:1::/48",
-  // local NAT64
-  "100::/64",
-  // discard-only
-  "2001:db8::/32",
-  // documentation
-  "fc00::/7",
-  // unique-local (ULA, private)
-  "fe80::/10",
-  // link-local
-  "ff00::/8"
-  // multicast
-].map(parseIpv6Cidr);
 function failedToFetchMessage(url) {
   return `Failed to fetch url: ${url}`;
 }
 __name(failedToFetchMessage, "failedToFetchMessage");
-function isBlockedHostname(hostname) {
-  const normalized = hostname.replace(/\.+$/, "").toLowerCase();
-  return normalized === "localhost" || normalized.endsWith(".localhost");
-}
-__name(isBlockedHostname, "isBlockedHostname");
-function normalizeHost(hostname) {
-  return hostname.startsWith("[") ? hostname.slice(1, -1) : hostname;
-}
-__name(normalizeHost, "normalizeHost");
-function parseIpv4(address) {
-  const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(address);
-  if (!match) {
-    return null;
-  }
-  const octets = match.slice(1).map(Number);
-  if (octets.some((octet) => octet > 255)) {
-    return null;
-  }
-  return octets;
-}
-__name(parseIpv4, "parseIpv4");
-function parseIpv6(address) {
-  if (isIP(address) !== 6) {
-    return null;
-  }
-  const [head, tail] = address.split("::");
-  const highGroups = head ? expandHextets(head) : [];
-  const lowGroups = tail ? expandHextets(tail) : [];
-  const compressed = address.includes("::") ? new Array(8 - highGroups.length - lowGroups.length).fill(0) : [];
-  return [...highGroups, ...compressed, ...lowGroups];
-}
-__name(parseIpv6, "parseIpv6");
-function expandHextets(fragment) {
-  const hextets = [];
-  for (const group of fragment.split(":")) {
-    if (group.includes(".")) {
-      const octets = parseIpv4(group);
-      hextets.push(octets[0] << 8 | octets[1], octets[2] << 8 | octets[3]);
-    } else {
-      hextets.push(parseInt(group, 16));
-    }
-  }
-  return hextets;
-}
-__name(expandHextets, "expandHextets");
-function ipv4ToInt(octets) {
-  return (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
-}
-__name(ipv4ToInt, "ipv4ToInt");
-function hextetsToBigInt(hextets) {
-  let value = 0n;
-  for (const hextet of hextets) {
-    value = value << 16n | BigInt(hextet);
-  }
-  return value;
-}
-__name(hextetsToBigInt, "hextetsToBigInt");
-function parseIpv4Cidr(cidr) {
-  const [address, prefix] = cidr.split("/");
-  const mask = 4294967295 << 32 - Number(prefix) >>> 0;
-  return { base: (ipv4ToInt(parseIpv4(address)) & mask) >>> 0, mask };
-}
-__name(parseIpv4Cidr, "parseIpv4Cidr");
-function parseIpv6Cidr(cidr) {
-  const [address, prefix] = cidr.split("/");
-  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 >> 32n === 0xffffn) {
-    return isBlockedIpv4([
-      Number(value >> 24n & 0xffn),
-      Number(value >> 16n & 0xffn),
-      Number(value >> 8n & 0xffn),
-      Number(value & 0xffn)
-    ]);
-  }
-  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);
-  }
-  const hextets = parseIpv6(address);
-  if (hextets) {
-    return isBlockedIpv6(hextets);
-  }
-  return true;
-}
-__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: ${hostname}`);
-  }
-  return addresses;
-}
-__name(resolveHostAddresses, "resolveHostAddresses");
 function assertUrlAllowed(url) {
   const parsed = new URL(url);
-  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
+  if (!isHttpUrl(parsed)) {
     throw new Error(`Unsupported url scheme: ${url}`);
   }
-  if (isBlockedHostname(parsed.hostname)) {
+  if (isLocalhostHostname(parsed.hostname)) {
     throw new Error(`Blocked host: ${parsed.hostname}`);
   }
   return parsed;
@@ -194,7 +34,7 @@ function assertUrlAllowed(url) {
 __name(assertUrlAllowed, "assertUrlAllowed");
 async function validateResolvedAddresses(hostname) {
   const addresses = await resolveHostAddresses(hostname);
-  if (addresses.some(isBlockedAddress)) {
+  if (addresses.some(isNonGlobalAddress)) {
     throw new Error(`Blocked host: ${hostname}`);
   }
 }

package/dist/esm/tools/mcp/load_mcp_resource_tool.js

@@ -71,13 +71,42 @@ before answering questions related to the resources.`
     } catch (e) {
       logger.warn(`Failed to list MCP resources: ${e}`);
     }
-    const lastContent = llmRequest.contents.at(-1);
-    const functionResponse = (_b = (_a = lastContent == null ? void 0 : lastContent.parts) == null ? void 0 : _a[0]) == null ? void 0 : _b.functionResponse;
-    if (!functionResponse || functionResponse.name !== this.name) {
+    const contents = llmRequest.contents;
+    if (!contents || contents.length === 0) {
       return;
     }
-    const response = functionResponse.response || {};
-    const requestedResourceNames = response["resource_names"] || [];
+    let startIndex = 0;
+    for (let i = contents.length - 1; i >= 0; i--) {
+      const content = contents[i];
+      const hasFunctionResponse = (_a = content.parts) == null ? void 0 : _a.some(
+        (part) => part.functionResponse !== void 0
+      );
+      const hasFunctionCall = (_b = content.parts) == null ? void 0 : _b.some(
+        (part) => part.functionCall !== void 0
+      );
+      if (content.role === "model" && !hasFunctionCall || content.role === "user" && !hasFunctionResponse) {
+        startIndex = i;
+        break;
+      }
+    }
+    const requestedResourceNames = [];
+    for (let i = startIndex; i < contents.length; i++) {
+      const content = contents[i];
+      if (content.role === "user" && content.parts) {
+        for (const part of content.parts) {
+          const functionResponse = part.functionResponse;
+          if (functionResponse && functionResponse.name === this.name) {
+            const response = functionResponse.response || {};
+            const names = response["resource_names"] || [];
+            for (const name of names) {
+              if (name && !requestedResourceNames.includes(name)) {
+                requestedResourceNames.push(name);
+              }
+            }
+          }
+        }
+      }
+    }
     for (const resourceName of requestedResourceNames) {
       try {
         const resourceContents = await this.mcpToolset.readResource(resourceName);

package/dist/esm/tools/openapi_tool/auth/auth_helpers.js

@@ -7,7 +7,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import {
+  AuthCredentialTypes
+} from "../../../auth/auth_credential.js";
 function applyCredential(url, headers, credential, authScheme) {
+  var _a;
   if (!credential) return url;
   if (credential.apiKey) {
     let inLocation;
@@ -25,8 +29,15 @@ function applyCredential(url, headers, credential, authScheme) {
     } else {
       headers["Authorization"] = credential.apiKey;
     }
-  } else if (credential.http && credential.http.credentials && credential.http.credentials.token) {
-    headers["Authorization"] = `Bearer ${credential.http.credentials.token}`;
+  } else if (credential.authType === AuthCredentialTypes.HTTP || credential.http) {
+    const httpCredentials = (_a = credential.http) == null ? void 0 : _a.credentials;
+    if (httpCredentials == null ? void 0 : httpCredentials.token) {
+      headers["Authorization"] = `Bearer ${httpCredentials.token}`;
+    } else if ((httpCredentials == null ? void 0 : httpCredentials.username) || (httpCredentials == null ? void 0 : httpCredentials.password)) {
+      throw new Error("Basic Authentication is not supported.");
+    } else {
+      throw new Error("Invalid HTTP auth credentials");
+    }
   }
   return url;
 }

package/dist/esm/tools/openapi_tool/openapi_spec_parser/operation_parser.js

@@ -164,7 +164,7 @@ let OperationParser = class {
     return {
       type: "object",
       properties,
-      required: required.length > 0 ? required : void 0,
+      required,
       title: `${this.operation.operationId || "unnamed"}_Arguments`
     };
   }

package/dist/esm/tools/openapi_tool/rest_api_tool.js

@@ -198,27 +198,25 @@ function prepareRequestBody(requestBody, body, bodyData, headers) {
   const finalData = body !== void 0 ? body : Object.keys(bodyData).length > 0 ? bodyData : void 0;
   if (requestBody && "content" in requestBody) {
     const content = requestBody.content;
-    for (const [mimeType, _mediaTypeObject] of Object.entries(content)) {
-      if (finalData !== void 0) {
-        if (mimeType === "application/json" || mimeType.endsWith("+json")) {
-          headers["Content-Type"] = mimeType;
-          return typeof finalData === "string" ? finalData : JSON.stringify(finalData);
-        } else if (mimeType === "application/x-www-form-urlencoded") {
-          return new URLSearchParams(finalData);
-        } else if (mimeType === "multipart/form-data") {
-          const formData = new FormData();
-          if (typeof finalData === "object" && finalData !== null) {
-            for (const [key, value] of Object.entries(finalData)) {
-              formData.append(key, String(value));
-            }
+    const mimeType = Object.keys(content)[0];
+    if (mimeType && finalData !== void 0) {
+      if (mimeType === "application/json" || mimeType.endsWith("+json")) {
+        headers["Content-Type"] = mimeType;
+        return typeof finalData === "string" ? finalData : JSON.stringify(finalData);
+      } else if (mimeType === "application/x-www-form-urlencoded") {
+        return new URLSearchParams(finalData);
+      } else if (mimeType === "multipart/form-data") {
+        const formData = new FormData();
+        if (typeof finalData === "object" && finalData !== null) {
+          for (const [key, value] of Object.entries(finalData)) {
+            formData.append(key, String(value));
           }
-          return formData;
-        } else if (mimeType === "text/plain") {
-          headers["Content-Type"] = mimeType;
-          return String(finalData);
         }
+        return formData;
+      } else if (mimeType === "text/plain") {
+        headers["Content-Type"] = mimeType;
+        return String(finalData);
       }
-      break;
     }
   } else if (finalData !== void 0) {
     headers["Content-Type"] = "application/json";

package/dist/esm/tools/preload_memory_tool.js

@@ -16,7 +16,7 @@ const _PreloadMemoryTool = class _PreloadMemoryTool extends BaseTool {
   constructor() {
     super({
       // Name and description are not used because this tool only
-      // changes llm_request.
+      // changes the LlmRequest.
       name: "preload_memory",
       description: "preload_memory"
     });

package/dist/esm/tools/retrieval/base_retrieval_tool.js

@@ -0,0 +1,33 @@
+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 { Type } from "@google/genai";
+import { BaseTool } from "../base_tool.js";
+const _BaseRetrievalTool = class _BaseRetrievalTool extends BaseTool {
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          query: {
+            type: Type.STRING,
+            description: "The query to retrieve."
+          }
+        }
+      }
+    };
+  }
+};
+__name(_BaseRetrievalTool, "BaseRetrievalTool");
+let BaseRetrievalTool = _BaseRetrievalTool;
+export {
+  BaseRetrievalTool
+};

package/dist/esm/tools/retrieval/files_retrieval.js

@@ -0,0 +1,81 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+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 __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
+));
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from "../../utils/logger.js";
+import {
+  LlamaIndexRetrieval
+} from "./llama_index_retrieval.js";
+const LLAMA_INDEX_MODULE = "llamaindex";
+const DIRECTORY_READER_MODULE = "@llamaindex/readers/directory";
+async function importOptional(specifier) {
+  try {
+    return await Promise.resolve().then(() => __toESM(require(specifier)));
+  } catch (cause) {
+    throw new Error(
+      `FilesRetrieval needs the optional package '${specifier}', which is not installed. Install '${LLAMA_INDEX_MODULE}' and '@llamaindex/readers', or build the retriever yourself and pass it to LlamaIndexRetrieval.`,
+      { cause }
+    );
+  }
+}
+__name(importOptional, "importOptional");
+const _FilesRetrieval = class _FilesRetrieval extends LlamaIndexRetrieval {
+  constructor(params) {
+    super({
+      name: params.name,
+      description: params.description,
+      retriever: params.retriever
+    });
+    this.inputDir = params.inputDir;
+  }
+  /**
+   * Indexes every file under `inputDir` and returns a tool that retrieves
+   * from it.
+   *
+   * Requires the optional `llamaindex` and `@llamaindex/readers` packages,
+   * and a configured LlamaIndex embedding model.
+   */
+  static async create(params) {
+    logger.info(`Loading data from ${params.inputDir}`);
+    const { SimpleDirectoryReader } = await importOptional(
+      DIRECTORY_READER_MODULE
+    );
+    const { VectorStoreIndex } = await importOptional(LLAMA_INDEX_MODULE);
+    const documents = await new SimpleDirectoryReader().loadData({
+      directoryPath: params.inputDir
+    });
+    const index = await VectorStoreIndex.fromDocuments(documents);
+    return new _FilesRetrieval({ ...params, retriever: index.asRetriever() });
+  }
+};
+__name(_FilesRetrieval, "FilesRetrieval");
+let FilesRetrieval = _FilesRetrieval;
+export {
+  FilesRetrieval
+};

package/dist/esm/tools/retrieval/llama_index_retrieval.js

@@ -0,0 +1,30 @@
+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 { BaseRetrievalTool } from "./base_retrieval_tool.js";
+const _LlamaIndexRetrieval = class _LlamaIndexRetrieval extends BaseRetrievalTool {
+  constructor(params) {
+    super({ name: params.name, description: params.description });
+    this.retriever = params.retriever;
+  }
+  async runAsync({ args }) {
+    var _a;
+    const nodes = await this.retriever.retrieve(String((_a = args["query"]) != null ? _a : ""));
+    const top = nodes[0];
+    if (!top) {
+      throw new Error(`${this.name} retrieved no results for the query.`);
+    }
+    return top.node.text;
+  }
+};
+__name(_LlamaIndexRetrieval, "LlamaIndexRetrieval");
+let LlamaIndexRetrieval = _LlamaIndexRetrieval;
+export {
+  LlamaIndexRetrieval
+};

package/dist/esm/tools/url_context_tool.js

@@ -8,15 +8,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * SPDX-License-Identifier: Apache-2.0
  */
 import { isGemini2OrAbove, isGeminiModel } from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
-const _UrlContextTool = class _UrlContextTool extends BaseTool {
+import { BuiltInTool } from "./built_in_tool.js";
+const _UrlContextTool = class _UrlContextTool extends BuiltInTool {
   constructor() {
     super({ name: "url_context", description: "URL Context Tool" });
   }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     if (!llmRequest.model) {

package/dist/esm/tools/vertex_ai_search_tool.js

@@ -7,15 +7,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getLogger } from "../utils/logger.js";
+import { logger } from "../utils/logger.js";
 import {
   isGemini1Model,
   isGeminiModel,
   isGeminiModelIdCheckDisabled
 } from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
-const logger = getLogger();
-const _VertexAiSearchTool = class _VertexAiSearchTool extends BaseTool {
+import { BuiltInTool } from "./built_in_tool.js";
+const _VertexAiSearchTool = class _VertexAiSearchTool extends BuiltInTool {
   constructor(params) {
     super({ name: "vertex_ai_search", description: "vertex_ai_search" });
     const {
@@ -43,9 +42,6 @@ const _VertexAiSearchTool = class _VertexAiSearchTool extends BaseTool {
     this.maxResults = maxResults;
     this.bypassMultiToolsLimit = bypassMultiToolsLimit;
   }
-  runAsync() {
-    return Promise.resolve();
-  }
   /**
    * Builds the VertexAISearch configuration.
    *
@@ -62,7 +58,7 @@ const _VertexAiSearchTool = class _VertexAiSearchTool extends BaseTool {
       maxResults: this.maxResults
     };
   }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     toolContext,
     llmRequest
   }) {