@google/adk 2.2.1 → 2.4.0

package/dist/cjs/runner/runner.js

@@ -43,6 +43,7 @@ var import_run_config = require("../agents/run_config.js");
 var import_scoped_artifact_service = require("../artifacts/scoped_artifact_service.js");
 var import_session_artifact_service = require("../artifacts/session_artifact_service.js");
 var import_built_in_code_executor = require("../code_executors/built_in_code_executor.js");
+var import_abort_events = require("../events/abort_events.js");
 var import_event = require("../events/event.js");
 var import_event_actions = require("../events/event_actions.js");
 var import_internal_metadata = require("../events/internal_metadata.js");
@@ -73,8 +74,8 @@ const _Runner = class _Runner {
    */
   constructor(input) {
     this[_a] = true;
-    var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
-    const appName = (_b = (_a2 = input.app) == null ? void 0 : _a2.name) != null ? _b : input.appName;
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const appName = (_b = input.appName) != null ? _b : (_a2 = input.app) == null ? void 0 : _a2.name;
     const agent = (_d = (_c = input.app) == null ? void 0 : _c.rootAgent) != null ? _d : input.agent;
     if (!agent) {
       throw new Error(
@@ -91,6 +92,20 @@ const _Runner = class _Runner {
     this.memoryService = input.memoryService;
     this.credentialService = input.credentialService;
     this.resumabilityConfig = (_i = (_h = input.app) == null ? void 0 : _h.resumabilityConfig) != null ? _i : input.resumabilityConfig;
+    this.autoCreateSession = (_j = input.autoCreateSession) != null ? _j : false;
+  }
+  /**
+   * Looks the session up, creating it first when `autoCreateSession` is set.
+   *
+   * A runner with no `appName` cannot address a session, so it falls through to
+   * the plain lookup rather than creating one under an undefined app name.
+   */
+  async resolveSession(userId, sessionId) {
+    const key = { appName: this.appName, userId, sessionId };
+    if (this.autoCreateSession && this.appName) {
+      return this.sessionService.getOrCreateSession(key);
+    }
+    return this.sessionService.getSession(key);
   }
   /**
    * Runs the agent with a new, ephemeral session.
@@ -151,12 +166,8 @@ const _Runner = class _Runner {
         ctx,
         this,
         async function* () {
-          var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
-          const session = await this.sessionService.getSession({
-            appName: this.appName,
-            userId,
-            sessionId
-          });
+          var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+          const session = await this.resolveSession(userId, sessionId);
           if ((_a2 = params.abortSignal) == null ? void 0 : _a2.aborted) {
             return;
           }
@@ -267,35 +278,45 @@ const _Runner = class _Runner {
               }
               yield earlyExitEvent;
             } else {
-              for await (const event of this.runRoot(invocationContext)) {
-                if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
-                  return;
-                }
-                const modifiedEvent = await this.pluginManager.runOnEventCallback({
-                  invocationContext,
-                  event
-                });
-                const outputEvent = modifiedEvent ? {
-                  ...withInternalMetadataOf(event, modifiedEvent),
-                  id: event.id,
-                  invocationId: event.invocationId,
-                  timestamp: event.timestamp,
-                  author: modifiedEvent.author || event.author,
-                  branch: (_i = modifiedEvent.branch) != null ? _i : event.branch
-                } : event;
-                if (!event.partial) {
-                  await this.sessionService.appendEvent({
-                    session,
-                    event: outputEvent
-                  });
+              let abortSealed = false;
+              const sealAbortedInvocation = /* @__PURE__ */ __name(() => {
+                abortSealed = true;
+                return this.synthesizeAbortEvents(invocationContext);
+              }, "sealAbortedInvocation");
+              try {
+                for await (const event of this.runRoot(invocationContext)) {
+                  if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
+                    break;
+                  }
+                  const outputEvent = await this.processAndAppendEvent(
+                    invocationContext,
+                    event
+                  );
+                  if ((_i = params.abortSignal) == null ? void 0 : _i.aborted) {
+                    break;
+                  }
+                  yield outputEvent;
                 }
                 if ((_j = params.abortSignal) == null ? void 0 : _j.aborted) {
+                  for (const abortEvent of await sealAbortedInvocation()) {
+                    yield abortEvent;
+                  }
                   return;
                 }
-                yield outputEvent;
+              } finally {
+                if (((_k = params.abortSignal) == null ? void 0 : _k.aborted) && !abortSealed) {
+                  try {
+                    await sealAbortedInvocation();
+                  } catch (e) {
+                    import_logger.logger.error(
+                      `Failed to seal aborted invocation ${invocationContext.invocationId}.`,
+                      e
+                    );
+                  }
+                }
               }
               await this.pluginManager.runAfterRunCallback({ invocationContext });
-              if ((_k = params.abortSignal) == null ? void 0 : _k.aborted) {
+              if ((_l = params.abortSignal) == null ? void 0 : _l.aborted) {
                 return;
               }
             }
@@ -327,6 +348,56 @@ const _Runner = class _Runner {
     }
     yield* (0, import_run_node_as_invocation.runNodeAsInvocation)(this.agent, invocationContext);
   }
+  /**
+   * Runs the on_event plugin callbacks on an event and appends the result to
+   * the session unless it is partial.
+   *
+   * @returns The event as streamed to the caller.
+   */
+  async processAndAppendEvent(invocationContext, event) {
+    var _a2;
+    const modifiedEvent = await this.pluginManager.runOnEventCallback({
+      invocationContext,
+      event
+    });
+    const outputEvent = modifiedEvent ? {
+      ...withInternalMetadataOf(event, modifiedEvent),
+      id: event.id,
+      invocationId: event.invocationId,
+      timestamp: event.timestamp,
+      author: modifiedEvent.author || event.author,
+      branch: (_a2 = modifiedEvent.branch) != null ? _a2 : event.branch
+    } : event;
+    if (!event.partial) {
+      await this.sessionService.appendEvent({
+        session: invocationContext.session,
+        event: outputEvent
+      });
+    }
+    return outputEvent;
+  }
+  /**
+   * Seals an aborted invocation in session history: answers its dangling
+   * function calls with error responses, or records a plain abort event when
+   * there is nothing to answer.
+   *
+   * @returns The synthetic events after plugin processing and persistence.
+   */
+  async synthesizeAbortEvents(invocationContext) {
+    const abortEvents = (0, import_abort_events.buildAbortEvents)({
+      events: invocationContext.session.events,
+      invocationId: invocationContext.invocationId,
+      rootAgentName: this.agent.name,
+      branch: invocationContext.branch
+    });
+    const outputEvents = [];
+    for (const event of abortEvents) {
+      outputEvents.push(
+        await this.processAndAppendEvent(invocationContext, event)
+      );
+    }
+    return outputEvents;
+  }
   /**
    * Saves artifacts from the message parts and replaces the inline data with
    * a file name placeholder and optional file reference.
@@ -573,7 +644,8 @@ function isLiveModelMediaEventWithInlineData(event) {
 }
 __name(isLiveModelMediaEventWithInlineData, "isLiveModelMediaEventWithInlineData");
 function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
-  const event = findEventByLastFunctionResponseId(session.events);
+  const lastEvent = session.events[session.events.length - 1];
+  const event = lastEvent && !(0, import_abort_events.isAbortEvent)(lastEvent) ? findEventByLastFunctionResponseId(session.events) : null;
   const isResumable = Boolean(resumabilityConfig == null ? void 0 : resumabilityConfig.isResumable);
   if (event && event.author && isResumable) {
     const conflictingAuthors = (0, import_functions.getConflictingFunctionResponseAuthors)(
@@ -597,7 +669,7 @@ function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
   for (let i = session.events.length - 1; i >= 0; i--) {
     import_logger.logger.debug("event:", (0, import_redact_inline_data.stringifyWithRedactedInlineData)(session.events[i]));
     const event2 = session.events[i];
-    if (event2.author === "user" || !event2.author) {
+    if (event2.author === "user" || !event2.author || (0, import_abort_events.isAbortEvent)(event2)) {
       continue;
     }
     if (event2.author === rootAgent.name) {

package/dist/cjs/sessions/base_session_service.js

@@ -28,7 +28,8 @@ __export(base_session_service_exports, {
   BaseSessionService: () => BaseSessionService,
   mergeStates: () => mergeStates,
   trimTempDeltaState: () => trimTempDeltaState,
-  trimTempState: () => trimTempState
+  trimTempState: () => trimTempState,
+  upsertSessionEvent: () => upsertSessionEvent
 });
 module.exports = __toCommonJS(base_session_service_exports);
 var import_lodash_es = require("lodash-es");
@@ -72,12 +73,7 @@ const _BaseSessionService = class _BaseSessionService {
     }
     event = trimTempDeltaState(event);
     this.updateSessionState({ session, event });
-    const index = session.events.findIndex((e) => e.id === event.id);
-    if (index >= 0) {
-      session.events[index] = event;
-    } else {
-      session.events.push(event);
-    }
+    upsertSessionEvent(session, event);
     return event;
   }
   /**
@@ -107,6 +103,15 @@ const _BaseSessionService = class _BaseSessionService {
 };
 __name(_BaseSessionService, "BaseSessionService");
 let BaseSessionService = _BaseSessionService;
+function upsertSessionEvent(session, event) {
+  const index = session.events.findIndex((e) => e.id === event.id);
+  if (index >= 0) {
+    session.events[index] = event;
+  } else {
+    session.events.push(event);
+  }
+}
+__name(upsertSessionEvent, "upsertSessionEvent");
 function trimTempDeltaState(event) {
   if (!event.actions || !event.actions.stateDelta) {
     return event;
@@ -149,5 +154,6 @@ __name(mergeStates, "mergeStates");
   BaseSessionService,
   mergeStates,
   trimTempDeltaState,
-  trimTempState
+  trimTempState,
+  upsertSessionEvent
 });

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_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,11 @@ async function importMikroOrm() {
   } = operations);
 }
 __name(importMikroOrm, "importMikroOrm");
+function formatDateTime(dateOrEpochMs) {
+  const date = typeof dateOrEpochMs === "number" ? new Date(dateOrEpochMs) : dateOrEpochMs;
+  return date.toISOString().replace("T", " ").slice(0, 19);
+}
+__name(formatDateTime, "formatDateTime");
 function isDatabaseConnectionString(uri) {
   if (!uri) {
     return false;
@@ -87,16 +97,20 @@ 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;
+      this.staleSession = (_a = options == null ? void 0 : options.staleSession) != null ? _a : "reject";
     } else {
       if (!connectionStringOrOptions.driver) {
         throw new Error("Driver is required when passing options object.");
       }
-      this.options = connectionStringOrOptions;
+      const { staleSession, ...mikroOptions } = connectionStringOrOptions;
+      this.options = mikroOptions;
+      this.staleSession = staleSession != null ? staleSession : "reject";
     }
   }
   async init() {
@@ -342,6 +356,7 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
       return event;
     }
     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 +370,14 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
       if (!storageSession) {
         throw new Error(`Session ${session.id} not found for appendEvent`);
       }
+      if (storageSession.updateTime.getTime() > session.lastUpdateTime) {
+        if (this.staleSession === "reject") {
+          throw new import_stale_session_error.StaleSessionError(
+            `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.`
+          );
+        }
+        sessionWasStale = true;
+      }
       let appStateModel = await txEm.findOne(StorageAppState, {
         appName: session.appName
       });
@@ -378,24 +401,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 = {};
@@ -449,14 +454,29 @@ const _DatabaseSessionService = class _DatabaseSessionService extends import_bas
         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);
-      }
+      (0, import_base_session_service.upsertSessionEvent)(session, event);
       session.lastUpdateTime = storageSession.updateTime.getTime();
     });
+    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);
+      } 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 +485,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

@@ -293,7 +293,7 @@ async function getConnectionOptionsFromUri(uri) {
     );
     return {
       entities: import_schema.ENTITIES,
-      dbName: uri === "sqlite://:memory:" ? ":memory:" : uri.substring("sqlite://".length),
+      dbName: uri === "sqlite://:memory:" || uri === "sqlite:///:memory:" ? ":memory:" : uri.substring("sqlite://".length),
       driver: SqliteDriver
     };
   }

package/dist/cjs/sessions/in_memory_session_service.js

@@ -70,7 +70,9 @@ const _InMemorySessionService = class _InMemorySessionService extends import_bas
     var _a;
     const filteredState = state ? (0, import_base_session_service.trimTempState)(state) : void 0;
     const session = (0, import_session.createSession)({
-      id: sessionId || (0, import_env_aware_utils.randomUUID)(),
+      // 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)(),
       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/state.js

@@ -102,16 +102,19 @@ const _State = class _State {
   /**
    * Returns the value of the state dict for the given key.
    *
+   * Only keys the state holds itself are found. Names inherited from
+   * `Object.prototype`, such as `toString`, are treated as missing.
+   *
    * @param key The key to get the value for.
    * @param defaultValue The default value to return if the key is not found.
    * @return The value of the state for the given key, or the default value if
    *     not found.
    */
   get(key, defaultValue) {
-    if (key in this.delta) {
+    if (Object.hasOwn(this.delta, key)) {
       return this.delta[key];
     }
-    if (key in this.value) {
+    if (Object.hasOwn(this.value, key)) {
       return this.value[key];
     }
     return defaultValue;
@@ -129,10 +132,11 @@ const _State = class _State {
     (0, import_state_write_order.recordStateWrite)(this.value, this.delta, key);
   }
   /**
-   * Whether the state has pending delta.
+   * Whether the state holds the given key, either as a stored value or as a
+   * pending delta. Names inherited from `Object.prototype` are not keys.
    */
   has(key) {
-    return key in this.value || key in this.delta;
+    return Object.hasOwn(this.value, key) || Object.hasOwn(this.delta, key);
   }
   /**
    * Whether the state has pending delta.

package/dist/cjs/sessions/vertex_ai_session_service.js

@@ -65,17 +65,22 @@ function quoteFilterLiteral(value) {
   return `"${escaped}"`;
 }
 __name(quoteFilterLiteral, "quoteFilterLiteral");
+function toStateMap(state) {
+  return Object.assign(/* @__PURE__ */ Object.create(null), state);
+}
+__name(toStateMap, "toStateMap");
 let VertexAiSessionService = class extends import_base_session_service.BaseSessionService {
   constructor(options) {
     super();
     this.agentEngineId = options.agentEngineId;
-    this.projectId = options.projectId;
-    this.location = options.location;
     this.expressModeApiKey = (0, import_vertex_ai_utils.getExpressModeApiKey)(
-      this.projectId,
-      this.location,
+      options.projectId,
+      options.location,
       options.expressModeApiKey
     );
+    const useEnvironment = !options.expressModeApiKey;
+    this.projectId = options.projectId || (useEnvironment ? process.env["GOOGLE_CLOUD_PROJECT"] : void 0);
+    this.location = options.location || (useEnvironment ? process.env["GOOGLE_CLOUD_LOCATION"] : void 0);
     if (options.sessions) {
       this.sessions = options.sessions;
     } else {
@@ -161,7 +166,7 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
       id,
       appName,
       userId,
-      state: getSessionResponse.sessionState,
+      state: toStateMap(getSessionResponse.sessionState),
       events: [],
       lastUpdateTime: getSessionResponse.updateTime ? Date.parse(getSessionResponse.updateTime) : Date.now()
     });
@@ -176,13 +181,14 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
     const sessionResourceName = `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}`;
     try {
       let getSessionResponse;
-      let eventsIterator = [];
+      const eventsIterator = [];
+      const listConfig = {};
+      let pageToken;
       if (config && config.numRecentEvents === 0) {
         getSessionResponse = await this.sessions.get({
           name: sessionResourceName
         });
       } else {
-        const listConfig = {};
         if (config && config.afterTimestamp) {
           listConfig.filter = `timestamp>="${new Date(
             config.afterTimestamp
@@ -196,7 +202,9 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
           })
         ]);
         getSessionResponse = sessionRes;
-        eventsIterator = eventsRes.sessionEvents || [];
+        const firstPage = eventsRes;
+        eventsIterator.push(...firstPage.sessionEvents || []);
+        pageToken = firstPage.nextPageToken;
       }
       const sessionObj = getSessionResponse;
       if (sessionObj.userId !== userId) {
@@ -204,20 +212,29 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
           `Session ${sessionId} does not belong to user ${userId}.`
         );
       }
+      while (pageToken) {
+        const eventsRes = await this.sessions.events.listInternal({
+          name: sessionResourceName,
+          config: {
+            ...listConfig,
+            pageToken
+          }
+        });
+        eventsIterator.push(...eventsRes.sessionEvents || []);
+        pageToken = eventsRes.nextPageToken;
+      }
       const session = (0, import_session.createSession)({
         id: sessionId,
         appName,
         userId,
-        state: sessionObj.sessionState,
+        state: toStateMap(sessionObj.sessionState),
         events: [],
         lastUpdateTime: sessionObj.updateTime ? Date.parse(sessionObj.updateTime) : Date.now()
       });
-      for (const event of eventsIterator) {
+      const recentEvents = config && config.numRecentEvents ? eventsIterator.slice(-config.numRecentEvents) : eventsIterator;
+      for (const event of recentEvents) {
         session.events.push(_fromApiEvent(event));
       }
-      if (config && config.numRecentEvents) {
-        session.events = session.events.slice(-config.numRecentEvents);
-      }
       return session;
     } catch (error) {
       const err = error;
@@ -256,7 +273,7 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
             id,
             appName,
             userId: sessionObj.userId,
-            state: sessionObj.sessionState,
+            state: toStateMap(sessionObj.sessionState),
             events: [],
             lastUpdateTime: sessionObj.updateTime ? new Date(sessionObj.updateTime).getTime() : Date.now()
           })
@@ -502,7 +519,9 @@ function _fromApiEvent(apiEventObj) {
     }
   }
   const eventActions = {
-    stateDelta: actions["stateDelta"] || {},
+    stateDelta: toStateMap(
+      actions["stateDelta"]
+    ),
     artifactDelta: actions["artifactDelta"] || {},
     requestedAuthConfigs: actions.requestedAuthConfigs || {},
     requestedToolConfirmations: actions["requestedToolConfirmations"] || {},