@google/adk 2.3.0 → 2.5.0

package/dist/cjs/sessions/database_session_service.js

@@ -36,13 +36,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var database_session_service_exports = {};
 __export(database_session_service_exports, {
   DatabaseSessionService: () => DatabaseSessionService,
-  isDatabaseConnectionString: () => isDatabaseConnectionString
+  StaleSessionError: () => import_stale_session_error2.StaleSessionError,
+  isDatabaseConnectionString: () => isDatabaseConnectionString,
+  isStaleSessionError: () => import_stale_session_error2.isStaleSessionError
 });
 module.exports = __toCommonJS(database_session_service_exports);
-var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_id_provider = require("../utils/id_provider.js");
+var import_logger = require("../utils/logger.js");
 var import_base_session_service = require("./base_session_service.js");
 var import_session = require("./session.js");
+var import_stale_session_error = require("./stale_session_error.js");
 var import_state = require("./state.js");
+var import_stale_session_error2 = require("./stale_session_error.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -79,6 +84,84 @@ async function importMikroOrm() {
   } = operations);
 }
 __name(importMikroOrm, "importMikroOrm");
+const STORAGE_UPDATE_MARKER_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.session.storageUpdateMarker"
+);
+function setStorageRevisionMarker(session, revision) {
+  Object.defineProperty(session, STORAGE_UPDATE_MARKER_SYMBOL, {
+    value: revision,
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+}
+__name(setStorageRevisionMarker, "setStorageRevisionMarker");
+function getStorageRevisionMarker(session) {
+  return session[STORAGE_UPDATE_MARKER_SYMBOL];
+}
+__name(getStorageRevisionMarker, "getStorageRevisionMarker");
+const MAX_IN_QUERY_IDS = 500;
+async function sessionMatchesStorageRevision(txEm, session, eventsComplete, totalEventCount) {
+  const sessionWhere = {
+    appName: session.appName,
+    userId: session.userId,
+    sessionId: session.id
+  };
+  const latestStorageEvent = await txEm.findOne(StorageEvent, sessionWhere, {
+    orderBy: { timestamp: "DESC", id: "DESC" }
+  });
+  if (session.events.length === 0) {
+    if (latestStorageEvent !== null) {
+      return false;
+    }
+    if (totalEventCount !== void 0 && totalEventCount !== 0) {
+      return false;
+    }
+    return true;
+  }
+  if ((latestStorageEvent == null ? void 0 : latestStorageEvent.id) !== session.events[session.events.length - 1].id) {
+    return false;
+  }
+  if (totalEventCount !== void 0) {
+    const totalStored = await txEm.count(StorageEvent, sessionWhere);
+    if (totalStored !== totalEventCount) {
+      return false;
+    }
+  }
+  const knownIds = session.events.map((e) => e.id);
+  if (knownIds.length <= MAX_IN_QUERY_IDS) {
+    const unknownEventWhere = {
+      ...sessionWhere,
+      id: { $nin: knownIds }
+    };
+    if (!eventsComplete) {
+      unknownEventWhere.timestamp = {
+        $gte: new Date(session.events[0].timestamp)
+      };
+    }
+    return await txEm.count(StorageEvent, unknownEventWhere) === 0;
+  }
+  const filter = { ...sessionWhere };
+  if (!eventsComplete) {
+    filter.timestamp = { $gte: new Date(session.events[0].timestamp) };
+  }
+  const storedEvents = await txEm.find(StorageEvent, filter, {
+    fields: ["id"]
+  });
+  const knownSet = new Set(knownIds);
+  for (const stored of storedEvents) {
+    if (!knownSet.has(stored.id)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(sessionMatchesStorageRevision, "sessionMatchesStorageRevision");
+function formatDateTime(dateOrEpochMs) {
+  const date = typeof dateOrEpochMs === "number" ? new Date(dateOrEpochMs) : dateOrEpochMs;
+  return date.toISOString().replace("T", " ").replace("Z", "");
+}
+__name(formatDateTime, "formatDateTime");
 function isDatabaseConnectionString(uri) {
   if (!uri) {
     return false;
@@ -87,16 +170,31 @@ function isDatabaseConnectionString(uri) {
 }
 __name(isDatabaseConnectionString, "isDatabaseConnectionString");
 const _DatabaseSessionService = class _DatabaseSessionService extends import_base_session_service.BaseSessionService {
-  constructor(connectionStringOrOptions) {
+  constructor(connectionStringOrOptions, options) {
+    var _a;
     super();
     this.initialized = false;
     if (typeof connectionStringOrOptions === "string") {
       this.connectionString = connectionStringOrOptions;
+      if (options) {
+        const { staleSession, ...mikroOptions } = options;
+        this.options = mikroOptions;
+        this.staleSession = staleSession != null ? staleSession : "reject";
+      } else {
+        this.staleSession = "reject";
+      }
     } else {
-      if (!connectionStringOrOptions.driver) {
+      const { staleSession: firstStaleSession, ...firstMikroOptions } = connectionStringOrOptions;
+      const { staleSession: secondStaleSession, ...secondMikroOptions } = options != null ? options : {};
+      const mergedMikroOptions = {
+        ...firstMikroOptions,
+        ...secondMikroOptions
+      };
+      if (!mergedMikroOptions.driver) {
         throw new Error("Driver is required when passing options object.");
       }
-      this.options = connectionStringOrOptions;
+      this.options = mergedMikroOptions;
+      this.staleSession = (_a = secondStaleSession != null ? secondStaleSession : firstStaleSession) != null ? _a : "reject";
     }
   }
   async init() {
@@ -104,7 +202,11 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
       return;
     }
     await loadMikroOrm();
-    const options = this.connectionString ? await getConnectionOptionsFromUri(this.connectionString) : { ...this.options, entities: ENTITIES };
+    const options = this.connectionString ? {
+      ...await getConnectionOptionsFromUri(this.connectionString),
+      ...this.options,
+      entities: ENTITIES
+    } : { ...this.options, entities: ENTITIES };
     this.options = options;
     this.orm = await MikroORM.init(options);
     await ensureDatabaseCreated(this.orm);
@@ -119,7 +221,7 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
   }) {
     await this.init();
     const em = this.orm.em.fork();
-    const id = sessionId || (0, import_env_aware_utils.randomUUID)();
+    const id = sessionId || (0, import_id_provider.newId)();
     const now = /* @__PURE__ */ new Date();
     const existing = await em.findOne(StorageSession, {
       id,
@@ -182,14 +284,22 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
       userStateModel.state,
       sessionState
     );
-    return (0, import_session.createSession)({
+    const session = (0, import_session.createSession)({
       id,
       appName,
       userId,
       state: mergedState,
       events: [],
-      lastUpdateTime: storageSession.createTime.getTime()
+      lastUpdateTime: storageSession.updateTime.getTime()
+    });
+    setStorageRevisionMarker(session, {
+      marker: storageSession.updateTime.toISOString(),
+      recordedLastUpdateTime: session.lastUpdateTime,
+      unverifiedWrite: true,
+      eventsComplete: true,
+      totalEventCount: 0
     });
+    return session;
   }
   async getSession({
     appName,
@@ -230,7 +340,7 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
       (userStateModel == null ? void 0 : userStateModel.state) || {},
       storageSession.state
     );
-    return (0, import_session.createSession)({
+    const session = (0, import_session.createSession)({
       id: sessionId,
       appName,
       userId,
@@ -238,6 +348,16 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
       events: storageEvents.map((se) => se.eventData),
       lastUpdateTime: storageSession.updateTime.getTime()
     });
+    const eventsComplete = (config == null ? void 0 : config.numRecentEvents) === void 0 && (config == null ? void 0 : config.afterTimestamp) === void 0;
+    const totalEventCount = eventsComplete ? session.events.length : await em.count(StorageEvent, { appName, userId, sessionId });
+    setStorageRevisionMarker(session, {
+      marker: storageSession.updateTime.toISOString(),
+      recordedLastUpdateTime: session.lastUpdateTime,
+      unverifiedWrite: false,
+      eventsComplete,
+      totalEventCount
+    });
+    return session;
   }
   async listSessions({
     appName,
@@ -250,7 +370,7 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
     await this.init();
     const em = this.orm.em.fork();
     const where = { appName };
-    if (userId) {
+    if (userId !== void 0) {
       where.userId = userId;
     }
     const orderBy = order === "asc" ? { updateTime: "ASC", id: "ASC" } : order === "desc" ? { updateTime: "DESC", id: "ASC" } : void 0;
@@ -299,7 +419,7 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
     const appStateModel = await em.findOne(StorageAppState, { appName });
     const appState = (appStateModel == null ? void 0 : appStateModel.state) || {};
     const userStateMap = {};
-    if (userId) {
+    if (userId !== void 0) {
       const u = await em.findOne(StorageUserState, { appName, userId });
       if (u) userStateMap[userId] = u.state;
     } else {
@@ -311,7 +431,7 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
     const sessions = storageSessions.map((ss) => {
       const uState = userStateMap[ss.userId] || {};
       const merged = (0, import_base_session_service.mergeStates)(appState, uState, ss.state);
-      return (0, import_session.createSession)({
+      const session = (0, import_session.createSession)({
         id: ss.id,
         appName: ss.appName,
         userId: ss.userId,
@@ -319,6 +439,13 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
         events: [],
         lastUpdateTime: ss.updateTime.getTime()
       });
+      setStorageRevisionMarker(session, {
+        marker: ss.updateTime.toISOString(),
+        recordedLastUpdateTime: session.lastUpdateTime,
+        unverifiedWrite: false,
+        eventsComplete: false
+      });
+      return session;
     });
     return { sessions, ...paginationMeta };
   }
@@ -336,12 +463,15 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
     session,
     event
   }) {
+    var _a, _b;
     await this.init();
     const em = this.orm.em.fork();
     if (event.partial) {
       return event;
     }
+    const stateDelta = (_b = (_a = event.actions) == null ? void 0 : _a.stateDelta) != null ? _b : {};
     const trimmedEvent = (0, import_base_session_service.trimTempDeltaState)(event);
+    let sessionWasStale = false;
     await em.transactional(async (txEm) => {
       const storageSession = await txEm.findOne(
         StorageSession,
@@ -355,6 +485,40 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
       if (!storageSession) {
         throw new Error(`Session ${session.id} not found for appendEvent`);
       }
+      const storageUpdateTime = storageSession.updateTime.getTime();
+      const storageUpdateMarker = storageSession.updateTime.toISOString();
+      const rev = getStorageRevisionMarker(session);
+      const callerMutatedLastUpdateTime = rev !== void 0 && rev.recordedLastUpdateTime !== session.lastUpdateTime;
+      let isStale = false;
+      if (rev !== void 0 && !callerMutatedLastUpdateTime) {
+        if (rev.marker === storageUpdateMarker) {
+          session.lastUpdateTime = storageUpdateTime;
+        } else if (rev.unverifiedWrite && storageUpdateTime % 1e3 === 0 && Math.abs(storageUpdateTime - rev.recordedLastUpdateTime) < 1e3 && await sessionMatchesStorageRevision(
+          txEm,
+          session,
+          rev.eventsComplete,
+          rev.totalEventCount
+        )) {
+          session.lastUpdateTime = storageUpdateTime;
+        } else {
+          isStale = true;
+        }
+      } else if (rev !== void 0) {
+        isStale = storageUpdateTime > session.lastUpdateTime;
+      } else if (storageUpdateTime > session.lastUpdateTime) {
+        if (await sessionMatchesStorageRevision(txEm, session, false)) {
+          session.lastUpdateTime = storageUpdateTime;
+        } else {
+          isStale = true;
+        }
+      }
+      if (isStale) {
+        if (this.staleSession === "reject") {
+          const message = storageUpdateTime > session.lastUpdateTime ? `The last_update_time provided in the session object ${formatDateTime(session.lastUpdateTime)} is earlier than the update_time in the storage_session ${formatDateTime(storageSession.updateTime)}. Please check if it is a stale session.` : `The session object with last_update_time ${formatDateTime(session.lastUpdateTime)} does not match the storage_session revision with update_time ${formatDateTime(storageSession.updateTime)}. Please check if it is a stale session.`;
+          throw new import_stale_session_error.StaleSessionError(message);
+        }
+        sessionWasStale = true;
+      }
       let appStateModel = await txEm.findOne(StorageAppState, {
         appName: session.appName
       });
@@ -378,24 +542,6 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
         });
         txEm.persist(userStateModel);
       }
-      if (storageSession.updateTime.getTime() > session.lastUpdateTime) {
-        const events = await txEm.find(
-          StorageEvent,
-          {
-            appName: session.appName,
-            userId: session.userId,
-            sessionId: session.id
-          },
-          { orderBy: { timestamp: "ASC" } }
-        );
-        const mergedState = (0, import_base_session_service.mergeStates)(
-          appStateModel.state,
-          userStateModel.state,
-          storageSession.state
-        );
-        session.state = mergedState;
-        session.events = events.map((e) => e.eventData);
-      }
       if (event.actions && event.actions.stateDelta) {
         const appDelta = {};
         const userDelta = {};
@@ -448,15 +594,61 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
         userStateModel.state,
         storageSession.state
       );
-      session.state = newMergedState;
-      const index = session.events.findIndex((e) => e.id === event.id);
-      if (index >= 0) {
-        session.events[index] = event;
-      } else {
-        session.events.push(event);
+      for (const source of [session.state, stateDelta]) {
+        for (const [key, value] of Object.entries(source)) {
+          if (key.startsWith(import_state.State.TEMP_PREFIX)) {
+            newMergedState[key] = value;
+          }
+        }
       }
+      session.state = newMergedState;
+      const isNewEvent = !existingStorageEvent;
+      (0, import_base_session_service.upsertSessionEvent)(session, event);
       session.lastUpdateTime = storageSession.updateTime.getTime();
+      let nextTotalEventCount;
+      if (!callerMutatedLastUpdateTime && !isStale) {
+        if ((rev == null ? void 0 : rev.totalEventCount) !== void 0) {
+          nextTotalEventCount = rev.totalEventCount + (isNewEvent ? 1 : 0);
+        } else if ((rev == null ? void 0 : rev.eventsComplete) === true) {
+          nextTotalEventCount = session.events.length;
+        }
+      }
+      setStorageRevisionMarker(session, {
+        marker: storageSession.updateTime.toISOString(),
+        recordedLastUpdateTime: session.lastUpdateTime,
+        unverifiedWrite: true,
+        eventsComplete: !callerMutatedLastUpdateTime && (rev == null ? void 0 : rev.eventsComplete) === true && !isStale,
+        totalEventCount: nextTotalEventCount
+      });
     });
+    if (sessionWasStale) {
+      try {
+        const storageEvents = await em.find(
+          StorageEvent,
+          {
+            appName: session.appName,
+            userId: session.userId,
+            sessionId: session.id
+          },
+          { orderBy: { timestamp: "ASC" } }
+        );
+        session.events = storageEvents.map((se) => se.eventData);
+        (0, import_base_session_service.upsertSessionEvent)(session, event);
+        const lastRev = getStorageRevisionMarker(session);
+        if (lastRev) {
+          setStorageRevisionMarker(session, {
+            ...lastRev,
+            eventsComplete: true,
+            totalEventCount: session.events.length
+          });
+        }
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        import_logger.logger.warn(
+          `Failed to reload events for stale session ${session.id} after appendEvent; the event was persisted but session.events may be missing concurrent appends: ${message}`
+        );
+      }
+    }
     return event;
   }
 };
@@ -465,5 +657,7 @@ let DatabaseSessionService = _DatabaseSessionService;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DatabaseSessionService,
-  isDatabaseConnectionString
+  StaleSessionError,
+  isDatabaseConnectionString,
+  isStaleSessionError
 });

package/dist/cjs/sessions/db/operations.js

@@ -312,8 +312,77 @@ async function getConnectionOptionsFromUri(uri) {
 }
 __name(getConnectionOptionsFromUri, "getConnectionOptionsFromUri");
 async function ensureDatabaseCreated(orm) {
+  var _a;
   await orm.schema.ensureDatabase();
-  await orm.schema.update({ safe: true });
+  const entityMetadata = [...orm.getMetadata().getAll().values()].filter(
+    (meta) => !meta.embeddable && !meta.virtual && !meta.view
+  );
+  if (entityMetadata.length === 0) {
+    return;
+  }
+  const platform = orm.driver.getPlatform();
+  const schemaHelper = platform.getSchemaHelper();
+  if (typeof (schemaHelper == null ? void 0 : schemaHelper.getAllTables) !== "function") {
+    await orm.schema.create();
+    return;
+  }
+  const connection = orm.driver.getConnection();
+  const defaultSchema = platform.getDefaultSchemaName();
+  const configSchema = orm.config.get("schema");
+  const dbName = orm.config.get("dbName");
+  const isCurrentSchema = /* @__PURE__ */ __name((schemaName) => !schemaName || schemaName === defaultSchema || defaultSchema === void 0 && schemaName === dbName, "isCurrentSchema");
+  const tableKey = /* @__PURE__ */ __name((tableName, schemaName) => {
+    const schemaPart = !schemaName || isCurrentSchema(schemaName) ? "" : schemaName;
+    return `${schemaPart}.${tableName}`.toLowerCase();
+  }, "tableKey");
+  const listedTables = await schemaHelper.getAllTables(connection);
+  const listedTableKeys = new Set(
+    listedTables.map((table) => tableKey(table.table_name, table.schema_name))
+  );
+  const seenTableKeys = /* @__PURE__ */ new Set();
+  const existingTableNames = [];
+  let missingCount = 0;
+  for (const meta of entityMetadata) {
+    const schemaName = (_a = meta.schema) != null ? _a : configSchema;
+    const key = tableKey(meta.tableName, schemaName);
+    if (seenTableKeys.has(key)) {
+      continue;
+    }
+    seenTableKeys.add(key);
+    let exists = listedTableKeys.has(key);
+    if (!exists && defaultSchema === void 0 && !isCurrentSchema(schemaName) && typeof schemaHelper.tableExists === "function") {
+      exists = await schemaHelper.tableExists(
+        connection,
+        meta.tableName,
+        schemaName
+      );
+    }
+    if (exists) {
+      existingTableNames.push(
+        schemaName && schemaName !== defaultSchema ? `${schemaName}.${meta.tableName}` : meta.tableName
+      );
+    } else {
+      missingCount++;
+    }
+  }
+  if (missingCount === 0) {
+    return;
+  }
+  if (existingTableNames.length === 0) {
+    await orm.schema.create();
+    return;
+  }
+  const schemaGenConfig = orm.config.get("schemaGenerator");
+  const previousSkipTables = schemaGenConfig.skipTables;
+  schemaGenConfig.skipTables = [
+    ...previousSkipTables != null ? previousSkipTables : [],
+    ...existingTableNames
+  ];
+  try {
+    await orm.schema.create();
+  } finally {
+    schemaGenConfig.skipTables = previousSkipTables;
+  }
 }
 __name(ensureDatabaseCreated, "ensureDatabaseCreated");
 async function validateDatabaseSchemaVersion(orm) {

package/dist/cjs/sessions/db/schema.js

@@ -98,6 +98,7 @@ const storageAppStateSchema = new import_core.EntitySchema({
     state: { type: "json" },
     updateTime: {
       type: "datetime",
+      length: EVENT_TIMESTAMP_PRECISION,
       fieldName: "update_time",
       onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate"),
       onUpdate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onUpdate")
@@ -121,6 +122,7 @@ const storageUserStateSchema = new import_core.EntitySchema({
     state: { type: "json" },
     updateTime: {
       type: "datetime",
+      length: EVENT_TIMESTAMP_PRECISION,
       fieldName: "update_time",
       onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate"),
       onUpdate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onUpdate")
@@ -146,11 +148,13 @@ const storageSessionSchema = new import_core.EntitySchema({
     state: { type: "json" },
     createTime: {
       type: "datetime",
+      length: EVENT_TIMESTAMP_PRECISION,
       fieldName: "create_time",
       onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate")
     },
     updateTime: {
       type: "datetime",
+      length: EVENT_TIMESTAMP_PRECISION,
       fieldName: "update_time",
       onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate")
     }

package/dist/cjs/sessions/in_memory_session_service.js

@@ -30,7 +30,7 @@ __export(in_memory_session_service_exports, {
 });
 module.exports = __toCommonJS(in_memory_session_service_exports);
 var import_lodash_es = require("lodash-es");
-var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_id_provider = require("../utils/id_provider.js");
 var import_logger = require("../utils/logger.js");
 var import_base_session_service = require("./base_session_service.js");
 var import_session = require("./session.js");
@@ -72,7 +72,7 @@ const _InMemorySessionService = class _InMemorySessionService extends import_bas
     const session = (0, import_session.createSession)({
       // Surrounding whitespace is dropped so that a later lookup by the bare
       // id finds the session, and a blank id gets a generated one.
-      id: (sessionId == null ? void 0 : sessionId.trim()) || (0, import_env_aware_utils.randomUUID)(),
+      id: (sessionId == null ? void 0 : sessionId.trim()) || (0, import_id_provider.newId)(),
       appName,
       userId,
       state: filteredState,

package/dist/cjs/sessions/stale_session_error.js

@@ -0,0 +1,59 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stale_session_error_exports = {};
+__export(stale_session_error_exports, {
+  StaleSessionError: () => StaleSessionError,
+  isStaleSessionError: () => isStaleSessionError
+});
+module.exports = __toCommonJS(stale_session_error_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const STALE_SESSION_ERROR_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.staleSessionError"
+);
+const _StaleSessionError = class _StaleSessionError extends (_b = Error, _a = STALE_SESSION_ERROR_SIGNATURE_SYMBOL, _b) {
+  constructor(message) {
+    super(message);
+    this[_a] = true;
+    this.name = "StaleSessionError";
+    Object.setPrototypeOf(this, _StaleSessionError.prototype);
+  }
+};
+__name(_StaleSessionError, "StaleSessionError");
+let StaleSessionError = _StaleSessionError;
+function isStaleSessionError(obj) {
+  return typeof obj === "object" && obj !== null && (STALE_SESSION_ERROR_SIGNATURE_SYMBOL in obj || obj instanceof Error && obj.name === "StaleSessionError");
+}
+__name(isStaleSessionError, "isStaleSessionError");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StaleSessionError,
+  isStaleSessionError
+});

package/dist/cjs/sessions/vertex_ai_session_service.js

@@ -41,6 +41,7 @@ module.exports = __toCommonJS(vertex_ai_session_service_exports);
 var import_vertexai = require("@google-cloud/vertexai");
 var import_compacted_event = require("../events/compacted_event.js");
 var import_experimental = require("../utils/experimental.js");
+var import_error_utils = require("../utils/error_utils.js");
 var import_logger = require("../utils/logger.js");
 var import_vertex_ai_utils = require("../utils/vertex_ai_utils.js");
 var import_partial_copy = require("../utils/partial_copy.js");
@@ -335,9 +336,16 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
     if (!session) {
       return;
     }
-    await this.sessions.delete({
-      name: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}`
-    });
+    try {
+      await this.sessions.delete({
+        name: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}`
+      });
+    } catch (error) {
+      import_logger.logger.error(
+        `Error deleting session ${sessionId}: ${(0, import_error_utils.formatError)(error)}`
+      );
+      throw error;
+    }
   }
   async appendEvent({
     session,