@google/adk 2.0.0 → 2.2.0

package/dist/web/sessions/base_session_service.js

@@ -1,123 +0,0 @@
-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 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { cloneDeep } from "lodash-es";
-import { State } from "./state.js";
-import { carryDeltaStamps, shouldApplyDeltaWrite } from "./state_write_order.js";
-const _BaseSessionService = class _BaseSessionService {
-  /**
-   * Gets a session or creates one if it doesn't exist.
-   *
-   * @param request The request to get or create a session.
-   * @return A promise that resolves to the session instance.
-   */
-  async getOrCreateSession(request) {
-    if (!request.sessionId) {
-      return this.createSession(request);
-    }
-    const session = await this.getSession({
-      appName: request.appName,
-      userId: request.userId,
-      sessionId: request.sessionId
-    });
-    if (session) {
-      return session;
-    }
-    return this.createSession(request);
-  }
-  /**
-   * Appends an event to a session.
-   *
-   * @param request The request to append an event.
-   * @return A promise that resolves to the event that was appended.
-   */
-  async appendEvent({ session, event }) {
-    if (event.partial) {
-      return event;
-    }
-    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);
-    }
-    return event;
-  }
-  /**
-   * Updates the session state based on the event.
-   *
-   * @param request The request to update the session state.
-   */
-  updateSessionState({ session, event }) {
-    if (!event.actions || !event.actions.stateDelta) {
-      return;
-    }
-    for (const [key, value] of Object.entries(event.actions.stateDelta)) {
-      if (key.startsWith(State.TEMP_PREFIX)) {
-        continue;
-      }
-      if (!shouldApplyDeltaWrite(session.state, event.actions.stateDelta, key)) {
-        continue;
-      }
-      Object.defineProperty(session.state, key, {
-        value,
-        writable: true,
-        enumerable: true,
-        configurable: true
-      });
-    }
-  }
-};
-__name(_BaseSessionService, "BaseSessionService");
-let BaseSessionService = _BaseSessionService;
-function trimTempDeltaState(event) {
-  if (!event.actions || !event.actions.stateDelta) {
-    return event;
-  }
-  const stateDelta = event.actions.stateDelta;
-  const filteredStateDelta = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of Object.entries(stateDelta)) {
-    if (!key.startsWith(State.TEMP_PREFIX)) {
-      filteredStateDelta[key] = value;
-    }
-  }
-  carryDeltaStamps(stateDelta, filteredStateDelta);
-  event.actions.stateDelta = filteredStateDelta;
-  return event;
-}
-__name(trimTempDeltaState, "trimTempDeltaState");
-function trimTempState(state) {
-  const filteredState = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of Object.entries(state)) {
-    if (!key.startsWith(State.TEMP_PREFIX)) {
-      filteredState[key] = value;
-    }
-  }
-  return filteredState;
-}
-__name(trimTempState, "trimTempState");
-function mergeStates(appState = {}, userState = {}, sessionState = {}) {
-  const merged = cloneDeep(sessionState);
-  for (const [k, v] of Object.entries(appState)) {
-    merged[State.APP_PREFIX + k] = v;
-  }
-  for (const [k, v] of Object.entries(userState)) {
-    merged[State.USER_PREFIX + k] = v;
-  }
-  return merged;
-}
-__name(mergeStates, "mergeStates");
-export {
-  BaseSessionService,
-  mergeStates,
-  trimTempDeltaState,
-  trimTempState
-};

package/dist/web/sessions/database_session_service.js

@@ -1,440 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import {
-  LockMode,
-  MikroORM
-} from "@mikro-orm/core";
-import { randomUUID } from "../utils/env_aware_utils.js";
-import {
-  BaseSessionService,
-  mergeStates,
-  trimTempDeltaState
-} from "./base_session_service.js";
-import {
-  ensureDatabaseCreated,
-  getConnectionOptionsFromUri,
-  validateDatabaseSchemaVersion
-} from "./db/operations.js";
-import {
-  ENTITIES,
-  StorageAppState,
-  StorageEvent,
-  StorageSession,
-  StorageUserState
-} from "./db/schema.js";
-import { createSession } from "./session.js";
-import { State } from "./state.js";
-function isDatabaseConnectionString(uri) {
-  if (!uri) {
-    return false;
-  }
-  return uri.startsWith("postgres://") || uri.startsWith("postgresql://") || uri.startsWith("mysql://") || uri.startsWith("mariadb://") || uri.startsWith("mssql://") || uri.startsWith("sqlite://");
-}
-__name(isDatabaseConnectionString, "isDatabaseConnectionString");
-const _DatabaseSessionService = class _DatabaseSessionService extends BaseSessionService {
-  constructor(connectionStringOrOptions) {
-    super();
-    this.initialized = false;
-    if (typeof connectionStringOrOptions === "string") {
-      this.connectionString = connectionStringOrOptions;
-    } else {
-      if (!connectionStringOrOptions.driver) {
-        throw new Error("Driver is required when passing options object.");
-      }
-      this.options = __spreadProps(__spreadValues({}, connectionStringOrOptions), {
-        entities: ENTITIES
-      });
-    }
-  }
-  async init() {
-    if (this.initialized) {
-      return;
-    }
-    if (this.connectionString && (!this.options || !this.options.driver)) {
-      this.options = await getConnectionOptionsFromUri(this.connectionString);
-    }
-    this.orm = await MikroORM.init(this.options);
-    await ensureDatabaseCreated(this.orm);
-    await validateDatabaseSchemaVersion(this.orm);
-    this.initialized = true;
-  }
-  async createSession({
-    appName,
-    userId,
-    state,
-    sessionId
-  }) {
-    await this.init();
-    const em = this.orm.em.fork();
-    const id = sessionId || randomUUID();
-    const now = /* @__PURE__ */ new Date();
-    const existing = await em.findOne(StorageSession, {
-      id,
-      appName,
-      userId
-    });
-    if (existing) {
-      throw new Error("Session with id ".concat(id, " already exists."));
-    }
-    let appStateModel = await em.findOne(StorageAppState, { appName });
-    if (!appStateModel) {
-      appStateModel = em.create(StorageAppState, {
-        appName,
-        state: {},
-        updateTime: now
-      });
-      em.persist(appStateModel);
-    }
-    let userStateModel = await em.findOne(StorageUserState, { appName, userId });
-    if (!userStateModel) {
-      userStateModel = em.create(StorageUserState, {
-        appName,
-        userId,
-        state: {}
-      });
-      em.persist(userStateModel);
-    }
-    const appStateDelta = {};
-    const userStateDelta = {};
-    const sessionState = {};
-    if (state) {
-      for (const [key, value] of Object.entries(state)) {
-        if (key.startsWith(State.APP_PREFIX)) {
-          appStateDelta[key.replace(State.APP_PREFIX, "")] = value;
-        } else if (key.startsWith(State.USER_PREFIX)) {
-          userStateDelta[key.replace(State.USER_PREFIX, "")] = value;
-        } else if (!key.startsWith(State.TEMP_PREFIX)) {
-          sessionState[key] = value;
-        }
-      }
-    }
-    if (Object.keys(appStateDelta).length > 0) {
-      appStateModel.state = __spreadValues(__spreadValues({}, appStateModel.state), appStateDelta);
-    }
-    if (Object.keys(userStateDelta).length > 0) {
-      userStateModel.state = __spreadValues(__spreadValues({}, userStateModel.state), userStateDelta);
-    }
-    const storageSession = em.create(StorageSession, {
-      id,
-      appName,
-      userId,
-      state: sessionState,
-      createTime: now,
-      updateTime: now
-    });
-    em.persist(storageSession);
-    await em.flush();
-    const mergedState = mergeStates(
-      appStateModel.state,
-      userStateModel.state,
-      sessionState
-    );
-    return createSession({
-      id,
-      appName,
-      userId,
-      state: mergedState,
-      events: [],
-      lastUpdateTime: storageSession.createTime.getTime()
-    });
-  }
-  async getSession({
-    appName,
-    userId,
-    sessionId,
-    config
-  }) {
-    await this.init();
-    const em = this.orm.em.fork();
-    const storageSession = await em.findOne(StorageSession, {
-      appName,
-      userId,
-      id: sessionId
-    });
-    if (!storageSession) {
-      return void 0;
-    }
-    const eventWhere = {
-      appName,
-      userId,
-      sessionId
-    };
-    if (config == null ? void 0 : config.afterTimestamp) {
-      eventWhere.timestamp = { $gt: new Date(config.afterTimestamp) };
-    }
-    const storageEvents = await em.find(StorageEvent, eventWhere, {
-      orderBy: { timestamp: "DESC" },
-      limit: config == null ? void 0 : config.numRecentEvents
-    });
-    storageEvents.reverse();
-    const appStateModel = await em.findOne(StorageAppState, { appName });
-    const userStateModel = await em.findOne(StorageUserState, {
-      appName,
-      userId
-    });
-    const mergedState = mergeStates(
-      (appStateModel == null ? void 0 : appStateModel.state) || {},
-      (userStateModel == null ? void 0 : userStateModel.state) || {},
-      storageSession.state
-    );
-    return createSession({
-      id: sessionId,
-      appName,
-      userId,
-      state: mergedState,
-      events: storageEvents.map((se) => se.eventData),
-      lastUpdateTime: storageSession.updateTime.getTime()
-    });
-  }
-  async listSessions({
-    appName,
-    userId,
-    limit,
-    offset,
-    page,
-    order
-  }) {
-    await this.init();
-    const em = this.orm.em.fork();
-    const where = { appName };
-    if (userId) {
-      where.userId = userId;
-    }
-    const orderBy = order === "asc" ? { updateTime: "ASC", id: "ASC" } : order === "desc" ? { updateTime: "DESC", id: "ASC" } : void 0;
-    let storageSessions;
-    let paginationMeta;
-    if (limit !== void 0) {
-      const totalItems = await em.count(StorageSession, where);
-      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;
-      }
-      storageSessions = await em.find(StorageSession, where, {
-        orderBy,
-        limit,
-        offset: effectiveOffset
-      });
-      paginationMeta = { page: effectivePage, limit, totalItems, totalPages };
-    } else if (offset) {
-      const totalItems = await em.count(StorageSession, where);
-      storageSessions = await em.find(StorageSession, where, {
-        orderBy,
-        offset
-      });
-      paginationMeta = {
-        page: 1,
-        limit: totalItems,
-        totalItems,
-        totalPages: totalItems === 0 ? 0 : 1
-      };
-    } else {
-      storageSessions = await em.find(StorageSession, where, { orderBy });
-      const totalItems = storageSessions.length;
-      paginationMeta = {
-        page: 1,
-        limit: totalItems,
-        totalItems,
-        totalPages: totalItems === 0 ? 0 : 1
-      };
-    }
-    const appStateModel = await em.findOne(StorageAppState, { appName });
-    const appState = (appStateModel == null ? void 0 : appStateModel.state) || {};
-    const userStateMap = {};
-    if (userId) {
-      const u = await em.findOne(StorageUserState, { appName, userId });
-      if (u) userStateMap[userId] = u.state;
-    } else {
-      const allUserStates = await em.find(StorageUserState, { appName });
-      for (const u of allUserStates) {
-        userStateMap[u.userId] = u.state;
-      }
-    }
-    const sessions = storageSessions.map((ss) => {
-      const uState = userStateMap[ss.userId] || {};
-      const merged = mergeStates(appState, uState, ss.state);
-      return createSession({
-        id: ss.id,
-        appName: ss.appName,
-        userId: ss.userId,
-        state: merged,
-        events: [],
-        lastUpdateTime: ss.updateTime.getTime()
-      });
-    });
-    return __spreadValues({ sessions }, paginationMeta);
-  }
-  async deleteSession({
-    appName,
-    userId,
-    sessionId
-  }) {
-    await this.init();
-    const em = this.orm.em.fork();
-    await em.nativeDelete(StorageSession, { appName, userId, id: sessionId });
-    await em.nativeDelete(StorageEvent, { appName, userId, sessionId });
-  }
-  async appendEvent({
-    session,
-    event
-  }) {
-    await this.init();
-    const em = this.orm.em.fork();
-    if (event.partial) {
-      return event;
-    }
-    const trimmedEvent = trimTempDeltaState(event);
-    await em.transactional(async (txEm) => {
-      const storageSession = await txEm.findOne(
-        StorageSession,
-        {
-          appName: session.appName,
-          userId: session.userId,
-          id: session.id
-        },
-        { lockMode: LockMode.PESSIMISTIC_WRITE }
-      );
-      if (!storageSession) {
-        throw new Error("Session ".concat(session.id, " not found for appendEvent"));
-      }
-      let appStateModel = await txEm.findOne(StorageAppState, {
-        appName: session.appName
-      });
-      if (!appStateModel) {
-        appStateModel = txEm.create(StorageAppState, {
-          appName: session.appName,
-          state: {},
-          updateTime: /* @__PURE__ */ new Date()
-        });
-        txEm.persist(appStateModel);
-      }
-      let userStateModel = await txEm.findOne(StorageUserState, {
-        appName: session.appName,
-        userId: session.userId
-      });
-      if (!userStateModel) {
-        userStateModel = txEm.create(StorageUserState, {
-          appName: session.appName,
-          userId: session.userId,
-          state: {}
-        });
-        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 = 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 = {};
-        const sessionDelta = {};
-        for (const [key, value] of Object.entries(event.actions.stateDelta)) {
-          if (key.startsWith(State.APP_PREFIX)) {
-            appDelta[key.replace(State.APP_PREFIX, "")] = value;
-          } else if (key.startsWith(State.USER_PREFIX)) {
-            userDelta[key.replace(State.USER_PREFIX, "")] = value;
-          } else if (!key.startsWith(State.TEMP_PREFIX)) {
-            sessionDelta[key] = value;
-          }
-        }
-        if (Object.keys(appDelta).length > 0) {
-          appStateModel.state = __spreadValues(__spreadValues({}, appStateModel.state), appDelta);
-        }
-        if (Object.keys(userDelta).length > 0) {
-          userStateModel.state = __spreadValues(__spreadValues({}, userStateModel.state), userDelta);
-        }
-        if (Object.keys(sessionDelta).length > 0) {
-          storageSession.state = __spreadValues(__spreadValues({}, storageSession.state), sessionDelta);
-        }
-      }
-      const existingStorageEvent = await txEm.findOne(StorageEvent, {
-        id: trimmedEvent.id,
-        appName: session.appName,
-        userId: session.userId,
-        sessionId: session.id
-      });
-      if (existingStorageEvent) {
-        existingStorageEvent.eventData = trimmedEvent;
-        existingStorageEvent.timestamp = new Date(trimmedEvent.timestamp);
-        txEm.persist(existingStorageEvent);
-      } else {
-        const newStorageEvent = txEm.create(StorageEvent, {
-          id: trimmedEvent.id,
-          appName: session.appName,
-          userId: session.userId,
-          sessionId: session.id,
-          invocationId: trimmedEvent.invocationId,
-          timestamp: new Date(trimmedEvent.timestamp),
-          eventData: trimmedEvent
-        });
-        txEm.persist(newStorageEvent);
-      }
-      await txEm.commit();
-      storageSession.updateTime = new Date(event.timestamp);
-      const newMergedState = mergeStates(
-        appStateModel.state,
-        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);
-      }
-      session.lastUpdateTime = storageSession.updateTime.getTime();
-    });
-    return event;
-  }
-};
-__name(_DatabaseSessionService, "DatabaseSessionService");
-let DatabaseSessionService = _DatabaseSessionService;
-export {
-  DatabaseSessionService,
-  isDatabaseConnectionString
-};

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

@@ -1,124 +0,0 @@
-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 { loadOptionalPeer } from "../../utils/optional_peer.js";
-import { redactUriPassword } from "../../utils/redact_uri.js";
-import {
-  ENTITIES,
-  SCHEMA_VERSION_1_JSON,
-  SCHEMA_VERSION_KEY,
-  StorageMetadata
-} from "./schema.js";
-function driverPeer(packageName, scheme) {
-  return {
-    packageName,
-    feature: 'DatabaseSessionService with a "'.concat(scheme, '" connection string')
-  };
-}
-__name(driverPeer, "driverPeer");
-async function getConnectionOptionsFromUri(uri) {
-  let driver;
-  if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
-    const { PostgreSqlDriver } = await loadOptionalPeer(
-      driverPeer("@mikro-orm/postgresql", "postgres"),
-      () => Promise.resolve().then(() => __toESM(require("@mikro-orm/postgresql"), 1))
-    );
-    driver = PostgreSqlDriver;
-  } else if (uri.startsWith("mysql://")) {
-    const { MySqlDriver } = await loadOptionalPeer(
-      driverPeer("@mikro-orm/mysql", "mysql"),
-      () => Promise.resolve().then(() => __toESM(require("@mikro-orm/mysql"), 1))
-    );
-    driver = MySqlDriver;
-  } else if (uri.startsWith("mariadb://")) {
-    const { MariaDbDriver } = await loadOptionalPeer(
-      driverPeer("@mikro-orm/mariadb", "mariadb"),
-      () => Promise.resolve().then(() => __toESM(require("@mikro-orm/mariadb"), 1))
-    );
-    driver = MariaDbDriver;
-  } else if (uri.startsWith("sqlite://")) {
-    const { SqliteDriver } = await loadOptionalPeer(
-      driverPeer("@mikro-orm/sqlite", "sqlite"),
-      () => Promise.resolve().then(() => __toESM(require("@mikro-orm/sqlite"), 1))
-    );
-    driver = SqliteDriver;
-  } else if (uri.startsWith("mssql://")) {
-    const { MsSqlDriver } = await loadOptionalPeer(
-      driverPeer("@mikro-orm/mssql", "mssql"),
-      () => Promise.resolve().then(() => __toESM(require("@mikro-orm/mssql"), 1))
-    );
-    driver = MsSqlDriver;
-  } else {
-    throw new Error("Unsupported database URI: ".concat(redactUriPassword(uri)));
-  }
-  if (uri.startsWith("sqlite://")) {
-    return {
-      entities: ENTITIES,
-      dbName: uri === "sqlite://:memory:" ? ":memory:" : uri.substring("sqlite://".length),
-      driver
-    };
-  }
-  return {
-    entities: ENTITIES,
-    clientUrl: uri,
-    driver
-  };
-}
-__name(getConnectionOptionsFromUri, "getConnectionOptionsFromUri");
-async function ensureDatabaseCreated(orm) {
-  await orm.schema.ensureDatabase();
-  await orm.schema.updateSchema({ safe: true });
-}
-__name(ensureDatabaseCreated, "ensureDatabaseCreated");
-async function validateDatabaseSchemaVersion(orm) {
-  const em = orm.em.fork();
-  const existing = await em.findOne(StorageMetadata, {
-    key: SCHEMA_VERSION_KEY
-  });
-  if (existing) {
-    if (existing.value !== SCHEMA_VERSION_1_JSON) {
-      throw new Error(
-        "ADK Database schema version ".concat(existing.value, " is not compatible.")
-      );
-    }
-    return;
-  }
-  const newVersion = em.create(StorageMetadata, {
-    key: SCHEMA_VERSION_KEY,
-    value: SCHEMA_VERSION_1_JSON
-  });
-  await em.persist(newVersion).flush();
-}
-__name(validateDatabaseSchemaVersion, "validateDatabaseSchemaVersion");
-export {
-  ensureDatabaseCreated,
-  getConnectionOptionsFromUri,
-  validateDatabaseSchemaVersion
-};