@google/adk 1.1.0 → 1.2.0

package/dist/web/sessions/in_memory_session_service.js

@@ -104,25 +104,81 @@ class InMemorySessionService extends BaseSessionService {
   }
   listSessions({
     appName,
-    userId
+    userId,
+    limit,
+    offset,
+    page,
+    order
   }) {
     if (!this.sessions[appName] || !this.sessions[appName][userId]) {
-      return Promise.resolve({ sessions: [] });
+      if (limit !== void 0) {
+        const effectiveOffset2 = page !== void 0 ? (page - 1) * limit : offset != null ? offset : 0;
+        const effectivePage2 = page !== void 0 ? page : limit === 0 ? 1 : Math.floor(effectiveOffset2 / limit) + 1;
+        return Promise.resolve({
+          sessions: [],
+          page: effectivePage2,
+          limit,
+          totalItems: 0,
+          totalPages: 0
+        });
+      }
+      return Promise.resolve({
+        sessions: [],
+        page: 1,
+        limit: 0,
+        totalItems: 0,
+        totalPages: 0
+      });
     }
-    const sessionsWithoutEvents = [];
-    for (const session of Object.values(this.sessions[appName][userId])) {
-      sessionsWithoutEvents.push(
-        createSession({
-          id: session.id,
-          appName: session.appName,
-          userId: session.userId,
-          state: {},
-          events: [],
-          lastUpdateTime: session.lastUpdateTime
-        })
+    const all = Object.values(this.sessions[appName][userId]).map(
+      (session) => createSession({
+        id: session.id,
+        appName: session.appName,
+        userId: session.userId,
+        state: {},
+        events: [],
+        lastUpdateTime: session.lastUpdateTime
+      })
+    );
+    if (order === "asc") {
+      all.sort(
+        (a, b) => a.lastUpdateTime - b.lastUpdateTime || a.id.localeCompare(b.id)
+      );
+    } else if (order === "desc") {
+      all.sort(
+        (a, b) => b.lastUpdateTime - a.lastUpdateTime || a.id.localeCompare(b.id)
       );
     }
-    return Promise.resolve({ sessions: sessionsWithoutEvents });
+    if (limit === void 0) {
+      const totalItems2 = all.length;
+      const sliced = offset ? all.slice(offset) : all;
+      return Promise.resolve({
+        sessions: sliced,
+        page: 1,
+        limit: totalItems2,
+        totalItems: totalItems2,
+        totalPages: totalItems2 === 0 ? 0 : 1
+      });
+    }
+    const totalItems = all.length;
+    const totalPages = limit === 0 ? 0 : Math.ceil(totalItems / limit);
+    let effectiveOffset;
+    let effectivePage;
+    if (page !== void 0) {
+      effectiveOffset = (page - 1) * limit;
+      effectivePage = page;
+    } else {
+      effectiveOffset = offset != null ? offset : 0;
+      effectivePage = limit === 0 ? 1 : Math.floor(effectiveOffset / limit) + 1;
+    }
+    const paginated = all.slice(effectiveOffset, effectiveOffset + limit);
+    return Promise.resolve({
+      sessions: paginated,
+      page: effectivePage,
+      limit,
+      totalItems,
+      totalPages
+    });
   }
   async deleteSession({
     appName,

package/dist/web/sessions/registry.js

@@ -13,6 +13,10 @@ import {
   InMemorySessionService,
   isInMemoryConnectionString
 } from "./in_memory_session_service.js";
+import {
+  VertexAiSessionService,
+  isVertexAiConnectionString
+} from "./vertex_ai_session_service.js";
 function getSessionServiceFromUri(uri) {
   if (isInMemoryConnectionString(uri)) {
     return new InMemorySessionService();
@@ -20,6 +24,9 @@ function getSessionServiceFromUri(uri) {
   if (isDatabaseConnectionString(uri)) {
     return new DatabaseSessionService(uri);
   }
+  if (isVertexAiConnectionString(uri)) {
+    return new VertexAiSessionService({});
+  }
   throw new Error("Unsupported session service URI: ".concat(uri));
 }
 export {

package/dist/web/sessions/vertex_ai_session_service.js

@@ -0,0 +1,414 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client } from "@google-cloud/vertexai/build/src/genai/client.js";
+import { isCompactedEvent } from "../events/compacted_event.js";
+import { experimental } from "../utils/experimental.js";
+import { logger } from "../utils/logger.js";
+import { getExpressModeApiKey } from "../utils/vertex_ai_utils.js";
+import { partialCopy } from "../utils/partial_copy.js";
+import {
+  BaseSessionService
+} from "./base_session_service.js";
+import { createSession } from "./session.js";
+const DEFAULT_MAX_ATTEMPTS = 30;
+const GRPC_NOT_FOUND = 5;
+const HTTP_NOT_FOUND = 404;
+function isVertexAiConnectionString(uri) {
+  return (uri == null ? void 0 : uri.startsWith("vertexai://")) || false;
+}
+let VertexAiSessionService = class extends BaseSessionService {
+  constructor(options) {
+    super();
+    this.agentEngineId = options.agentEngineId;
+    this.projectId = options.projectId;
+    this.location = options.location;
+    this.expressModeApiKey = getExpressModeApiKey(
+      this.projectId,
+      this.location,
+      options.expressModeApiKey
+    );
+    if (!options.sessions) {
+      if (!this.expressModeApiKey && (!this.projectId || !this.location)) {
+        throw new Error(
+          "Either (Project ID and Location) or an expressModeApiKey is required."
+        );
+      }
+    }
+    if (options.sessions) {
+      this.sessions = options.sessions;
+    } else {
+      const client = new Client({
+        project: this.projectId,
+        location: this.location
+      });
+      this.sessions = client.agentEnginesInternal.sessions;
+    }
+  }
+  getReasoningEngineId(appName) {
+    if (this.agentEngineId) {
+      return this.agentEngineId;
+    }
+    if (/^\d+$/.test(appName)) {
+      return appName;
+    }
+    const pattern = /^projects\/([a-zA-Z0-9-_]+)\/locations\/([a-zA-Z0-9-_]+)\/reasoningEngines\/(\d+)$/;
+    const match = appName.match(pattern);
+    if (!match) {
+      throw new Error(
+        "App name ".concat(appName, " is not valid. It should either be the full ReasoningEngine resource name, or the reasoning engine id.")
+      );
+    }
+    return match[3];
+  }
+  async createSession({
+    appName,
+    userId,
+    state,
+    sessionId
+  }) {
+    var _a;
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    let apiResponse = await this.sessions.createInternal({
+      name: "reasoningEngines/".concat(reasoningEngineId),
+      userId,
+      config: __spreadValues(__spreadValues({}, state ? { sessionState: state } : {}), sessionId ? { sessionId } : {})
+    });
+    const operationName = apiResponse.name;
+    let attempts = 0;
+    while (!apiResponse.done && attempts < DEFAULT_MAX_ATTEMPTS) {
+      const [nextResponse] = await Promise.all([
+        this.sessions.getSessionOperationInternal({
+          operationName
+        }),
+        new Promise((resolve) => setTimeout(resolve, 1e3))
+      ]);
+      apiResponse = nextResponse;
+      attempts++;
+    }
+    if (!apiResponse.done) {
+      throw new Error(
+        "Session creation operation ".concat(operationName, " did not complete in time.")
+      );
+    }
+    const getSessionResponse = apiResponse.response;
+    const id = ((_a = getSessionResponse.name) == null ? void 0 : _a.split("/").pop()) || "";
+    return createSession({
+      id,
+      appName,
+      userId,
+      state: getSessionResponse.sessionState,
+      events: [],
+      lastUpdateTime: getSessionResponse.updateTime ? Date.parse(getSessionResponse.updateTime) : Date.now()
+    });
+  }
+  async getSession({
+    appName,
+    userId,
+    sessionId,
+    config
+  }) {
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    const sessionResourceName = "reasoningEngines/".concat(reasoningEngineId, "/sessions/").concat(sessionId);
+    try {
+      let getSessionResponse;
+      let eventsIterator = [];
+      if (config && config.numRecentEvents === 0) {
+        getSessionResponse = await this.sessions.get({
+          name: sessionResourceName
+        });
+      } else {
+        const listConfig = {};
+        if (config && config.afterTimestamp) {
+          listConfig.filter = 'timestamp>="'.concat(new Date(
+            config.afterTimestamp
+          ).toISOString(), '"');
+        }
+        const [sessionRes, eventsRes] = await Promise.all([
+          this.sessions.get({ name: sessionResourceName }),
+          this.sessions.events.listInternal({
+            name: sessionResourceName,
+            config: listConfig
+          })
+        ]);
+        getSessionResponse = sessionRes;
+        eventsIterator = eventsRes.sessionEvents || [];
+      }
+      const sessionObj = getSessionResponse;
+      if (sessionObj.userId !== userId) {
+        throw new Error(
+          "Session ".concat(sessionId, " does not belong to user ").concat(userId, ".")
+        );
+      }
+      const session = createSession({
+        id: sessionId,
+        appName,
+        userId,
+        state: sessionObj.sessionState,
+        events: [],
+        lastUpdateTime: sessionObj.updateTime ? Date.parse(sessionObj.updateTime) : Date.now()
+      });
+      for (const event of eventsIterator) {
+        session.events.push(_fromApiEvent(event));
+      }
+      if (config && config.numRecentEvents) {
+        session.events = session.events.slice(-config.numRecentEvents);
+      }
+      return session;
+    } catch (error) {
+      const err = error;
+      if (err.code === GRPC_NOT_FOUND || err.code === HTTP_NOT_FOUND) {
+        return void 0;
+      }
+      logger.error("Error getting session from Vertex AI: ".concat(err.message));
+      throw error;
+    }
+  }
+  async listSessions({
+    appName,
+    userId,
+    limit,
+    offset,
+    page,
+    order
+  }) {
+    var _a;
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    const adkSessions = [];
+    let pageToken = void 0;
+    do {
+      const response = await this.sessions.listInternal({
+        name: "reasoningEngines/".concat(reasoningEngineId),
+        config: __spreadValues(__spreadValues({}, userId ? { filter: 'user_id="'.concat(userId, '"') } : {}), pageToken ? { pageToken } : {})
+      });
+      const sessions = response.sessions || [];
+      for (const sessionObj of sessions) {
+        const id = ((_a = sessionObj.name) == null ? void 0 : _a.split("/").pop()) || "";
+        adkSessions.push(
+          createSession({
+            id,
+            appName,
+            userId: sessionObj.userId,
+            state: sessionObj.sessionState,
+            events: [],
+            lastUpdateTime: sessionObj.updateTime ? new Date(sessionObj.updateTime).getTime() : Date.now()
+          })
+        );
+      }
+      pageToken = response.nextPageToken;
+    } while (pageToken);
+    if (order === "asc") {
+      adkSessions.sort(
+        (a, b) => a.lastUpdateTime - b.lastUpdateTime || a.id.localeCompare(b.id)
+      );
+    } else if (order === "desc") {
+      adkSessions.sort(
+        (a, b) => b.lastUpdateTime - a.lastUpdateTime || a.id.localeCompare(b.id)
+      );
+    }
+    if (limit === void 0) {
+      const totalItems2 = adkSessions.length;
+      const sliced = offset ? adkSessions.slice(offset) : adkSessions;
+      return {
+        sessions: sliced,
+        page: 1,
+        limit: totalItems2,
+        totalItems: totalItems2,
+        totalPages: totalItems2 === 0 ? 0 : 1
+      };
+    }
+    const totalItems = adkSessions.length;
+    const totalPages = limit === 0 ? 0 : Math.ceil(totalItems / limit);
+    let effectiveOffset;
+    let effectivePage;
+    if (page !== void 0) {
+      effectiveOffset = (page - 1) * limit;
+      effectivePage = page;
+    } else {
+      effectiveOffset = offset != null ? offset : 0;
+      effectivePage = limit === 0 ? 1 : Math.floor(effectiveOffset / limit) + 1;
+    }
+    return {
+      sessions: adkSessions.slice(effectiveOffset, effectiveOffset + limit),
+      page: effectivePage,
+      limit,
+      totalItems,
+      totalPages
+    };
+  }
+  async deleteSession({
+    appName,
+    userId: _userId,
+    sessionId
+  }) {
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    await this.sessions.delete({
+      name: "reasoningEngines/".concat(reasoningEngineId, "/sessions/").concat(sessionId)
+    });
+  }
+  async appendEvent({
+    session,
+    event
+  }) {
+    await super.appendEvent({ session, event });
+    session.lastUpdateTime = event.timestamp;
+    const reasoningEngineId = this.getReasoningEngineId(session.appName);
+    const customMetadata = __spreadValues({}, event.customMetadata);
+    if (isCompactedEvent(event)) {
+      customMetadata._compaction = {
+        startTime: event.startTime,
+        endTime: event.endTime,
+        compactedContent: event.compactedContent
+      };
+    }
+    if (event.usageMetadata) {
+      customMetadata._usage_metadata = event.usageMetadata;
+    }
+    const config = partialCopy(event, [
+      "content",
+      "actions",
+      "errorCode",
+      "errorMessage"
+    ]);
+    config.eventMetadata = __spreadProps(__spreadValues({}, partialCopy(event, [
+      "partial",
+      "turnComplete",
+      "interrupted",
+      "branch",
+      "longRunningToolIds",
+      "groundingMetadata"
+    ])), {
+      customMetadata: Object.keys(customMetadata).length > 0 ? customMetadata : void 0
+    });
+    config.rawEvent = JSON.parse(JSON.stringify(event));
+    const params = {
+      name: "reasoningEngines/".concat(reasoningEngineId, "/sessions/").concat(session.id),
+      author: event.author || "user",
+      invocationId: event.invocationId || "inv-".concat(Date.now()),
+      timestamp: new Date(event.timestamp).toISOString(),
+      config
+    };
+    try {
+      await this.sessions.events.append(params);
+    } catch (error) {
+      logger.warn(
+        "Failed to append event with rawEvent, falling back...",
+        error
+      );
+      delete config.rawEvent;
+      await this.sessions.events.append({
+        name: "reasoningEngines/".concat(reasoningEngineId, "/sessions/").concat(session.id),
+        author: event.author || "user",
+        invocationId: event.invocationId || "inv-".concat(Date.now()),
+        timestamp: new Date(event.timestamp).toISOString(),
+        config
+      });
+    }
+    return event;
+  }
+};
+VertexAiSessionService = __decorateClass([
+  experimental
+], VertexAiSessionService);
+function _fromApiEvent(apiEventObj) {
+  var _a, _b, _c;
+  const rawEvent = apiEventObj.rawEvent;
+  if (rawEvent) {
+    const event2 = JSON.parse(JSON.stringify(rawEvent));
+    event2.id = ((_a = apiEventObj.name) == null ? void 0 : _a.split("/").pop()) || "";
+    event2.invocationId = apiEventObj.invocationId || "";
+    event2.author = apiEventObj.author;
+    if (apiEventObj.timestamp) {
+      event2.timestamp = new Date(apiEventObj.timestamp).getTime();
+    }
+    return event2;
+  }
+  const actions = apiEventObj.actions || {};
+  const eventMetadata = apiEventObj.eventMetadata || {};
+  let customMetadata = eventMetadata.customMetadata;
+  let compactionData = null;
+  let usageMetadataData = null;
+  if (customMetadata) {
+    if (customMetadata._compaction) {
+      compactionData = customMetadata._compaction;
+      delete customMetadata._compaction;
+    }
+    if (customMetadata._usage_metadata) {
+      usageMetadataData = customMetadata._usage_metadata;
+      delete customMetadata._usage_metadata;
+    }
+    if (Object.keys(customMetadata).length === 0) {
+      customMetadata = void 0;
+    }
+  }
+  const eventActions = {
+    stateDelta: actions["stateDelta"] || {},
+    artifactDelta: actions["artifactDelta"] || {},
+    requestedAuthConfigs: actions.requestedAuthConfigs || {},
+    requestedToolConfirmations: actions["requestedToolConfirmations"] || {},
+    skipSummarization: actions["skipSummarization"],
+    transferToAgent: actions["transferAgent"],
+    escalate: actions["escalate"],
+    compaction: compactionData || void 0
+  };
+  const event = {
+    id: ((_b = apiEventObj.name) == null ? void 0 : _b.split("/").pop()) || "",
+    invocationId: apiEventObj.invocationId || "",
+    author: apiEventObj.author,
+    actions: eventActions,
+    content: apiEventObj.content,
+    timestamp: apiEventObj.timestamp ? new Date(apiEventObj.timestamp).getTime() : Date.now(),
+    errorCode: (_c = apiEventObj.errorCode) == null ? void 0 : _c.toString(),
+    errorMessage: apiEventObj.errorMessage,
+    partial: eventMetadata["partial"],
+    turnComplete: eventMetadata["turnComplete"],
+    interrupted: eventMetadata["interrupted"],
+    branch: eventMetadata["branch"],
+    customMetadata,
+    longRunningToolIds: eventMetadata["longRunningToolIds"],
+    usageMetadata: usageMetadataData
+  };
+  if (compactionData) {
+    event.isCompacted = true;
+    event.startTime = compactionData.startTime;
+    event.endTime = compactionData.endTime;
+    event.compactedContent = compactionData.compactedContent;
+  }
+  return event;
+}
+export {
+  VertexAiSessionService,
+  isVertexAiConnectionString
+};

package/dist/web/tools/agent_tool.js

@@ -14,6 +14,7 @@ import { InMemoryMemoryService } from "../memory/in_memory_memory_service.js";
 import { Runner } from "../runner/runner.js";
 import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
 import { GoogleLLMVariant } from "../utils/variant_utils.js";
+import { State } from "../sessions/state.js";
 import { BaseTool } from "./base_tool.js";
 import { ForwardingArtifactService } from "./forwarding_artifact_service.js";
 const AGENT_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.agentTool");
@@ -68,9 +69,6 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
     toolContext
   }) {
     var _a2, _b2, _c, _d, _e, _f;
-    if (this.skipSummarization) {
-      toolContext.actions.skipSummarization = true;
-    }
     const hasInputSchema = isLlmAgent(this.agent) && this.agent.inputSchema;
     const content = {
       role: "user",
@@ -112,7 +110,14 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
           return;
         }
         if (event.actions.stateDelta) {
-          toolContext.state.update(event.actions.stateDelta);
+          const filteredDelta = Object.fromEntries(
+            Object.entries(event.actions.stateDelta).filter(
+              ([key]) => !key.startsWith(State.TEMP_PREFIX)
+            )
+          );
+          if (Object.keys(filteredDelta).length > 0) {
+            toolContext.state.update(filteredDelta);
+          }
         }
         lastEvent = event;
       }
@@ -130,7 +135,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
       return "";
     }
     const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;
-    const mergedText = lastEvent.content.parts.map((part) => part.text).filter((text) => text).join("\n");
+    const mergedText = lastEvent.content.parts.filter((part) => !part.thought).map((part) => part.text).filter((text) => text).join("\n");
     return hasOutputSchema ? JSON.parse(mergedText) : mergedText;
   }
 }

package/dist/web/tools/exit_loop_tool.js

@@ -7,18 +7,27 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { BaseTool } from "./base_tool.js";
 class ExitLoopTool extends BaseTool {
+  /** Creates an ExitLoopTool with its fixed name and description. */
   constructor() {
     super({
       name: "exit_loop",
       description: "Exits the loop.\n\nCall this function only when you are instructed to do so."
     });
   }
+  /** Returns the function declaration for this tool. */
   _getDeclaration() {
     return {
       name: this.name,
       description: this.description
     };
   }
+  /**
+   * Sets `escalate` and `skipSummarization` on the event actions, signalling
+   * the {@link LoopAgent} to stop iterating.
+   *
+   * @param request The tool request containing the current tool context.
+   * @returns An empty string response.
+   */
   async runAsync({
     toolContext
   }) {

package/dist/web/tools/function_tool.js

@@ -46,7 +46,8 @@ class FunctionTool extends (_b = BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL,
     this.parameters = options.parameters;
   }
   /**
-   * Provide a schema for the function.
+   * Returns the function declaration derived from the tool's name, description,
+   * and parameter schema.
    */
   _getDeclaration() {
     return {
@@ -56,7 +57,11 @@ class FunctionTool extends (_b = BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL,
     };
   }
   /**
-   * Logic for running the tool.
+   * Validates the model-provided arguments against the parameter schema and
+   * invokes the user-defined `execute` function.
+   *
+   * @param req The tool request containing arguments and tool context.
+   * @returns A promise resolving to the function's return value.
    */
   async runAsync(req) {
     try {

package/dist/web/tools/google_maps_grounding_tool.js

@@ -0,0 +1,54 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  isGemini1Model,
+  isGeminiModel,
+  isGeminiModelIdCheckDisabled
+} from "../utils/model_name.js";
+import { BaseTool } from "./base_tool.js";
+function applyGoogleMapsGrounding(llmRequest) {
+  if (!llmRequest.model) {
+    return;
+  }
+  const modelCheckDisabled = isGeminiModelIdCheckDisabled();
+  llmRequest.config = llmRequest.config || {};
+  llmRequest.config.tools = llmRequest.config.tools || [];
+  if (isGemini1Model(llmRequest.model)) {
+    throw new Error(
+      "Google Maps grounding tool cannot be used with Gemini 1.x models."
+    );
+  }
+  if (isGeminiModel(llmRequest.model) || modelCheckDisabled) {
+    llmRequest.config.tools.push({
+      googleMaps: {}
+    });
+    return;
+  }
+  throw new Error(
+    "Google maps tool is not supported for model ".concat(llmRequest.model)
+  );
+}
+class GoogleMapsGroundingTool extends BaseTool {
+  constructor() {
+    super({ name: "google_maps", description: "Google Maps Grounding Tool" });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    applyGoogleMapsGrounding(llmRequest);
+  }
+}
+const GOOGLE_MAPS_GROUNDING = new GoogleMapsGroundingTool();
+export {
+  GOOGLE_MAPS_GROUNDING,
+  GoogleMapsGroundingTool,
+  applyGoogleMapsGrounding
+};

package/dist/web/tools/long_running_tool.js

@@ -37,7 +37,8 @@ class LongRunningFunctionTool extends FunctionTool {
     super(__spreadProps(__spreadValues({}, options), { isLongRunning: true }));
   }
   /**
-   * Provide a schema for the function.
+   * Returns the function declaration with an appended instruction warning the
+   * model not to re-invoke the tool while it is still running.
    */
   _getDeclaration() {
     const declaration = super._getDeclaration();