@google/adk 0.2.5 → 0.4.0

package/dist/web/sessions/database_session_service.js

@@ -0,0 +1,368 @@
+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));
+/**
+ * @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://");
+}
+class DatabaseSessionService extends BaseSessionService {
+  constructor(connectionStringOrOptions) {
+    super();
+    this.initialized = false;
+    if (typeof connectionStringOrOptions === "string") {
+      this.options = getConnectionOptionsFromUri(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;
+    }
+    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 {
+          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
+  }) {
+    await this.init();
+    const em = this.orm.em.fork();
+    const where = { appName };
+    if (userId) {
+      where.userId = userId;
+    }
+    const storageSessions = await em.find(StorageSession, where);
+    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 { sessions };
+  }
+  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 {
+            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 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;
+      session.events.push(event);
+      session.lastUpdateTime = storageSession.updateTime.getTime();
+    });
+    return event;
+  }
+}
+export {
+  DatabaseSessionService,
+  isDatabaseConnectionString
+};

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

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MikroORM } from "@mikro-orm/core";
+import { MariaDbDriver } from "@mikro-orm/mariadb";
+import { MsSqlDriver } from "@mikro-orm/mssql";
+import { MySqlDriver } from "@mikro-orm/mysql";
+import { PostgreSqlDriver } from "@mikro-orm/postgresql";
+import { SqliteDriver } from "@mikro-orm/sqlite";
+import {
+  ENTITIES,
+  SCHEMA_VERSION_1_JSON,
+  SCHEMA_VERSION_KEY,
+  StorageMetadata
+} from "./schema.js";
+function getConnectionOptionsFromUri(uri) {
+  let driver;
+  if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
+    driver = PostgreSqlDriver;
+  } else if (uri.startsWith("mysql://")) {
+    driver = MySqlDriver;
+  } else if (uri.startsWith("mariadb://")) {
+    driver = MariaDbDriver;
+  } else if (uri.startsWith("sqlite://")) {
+    driver = SqliteDriver;
+  } else if (uri.startsWith("mssql://")) {
+    driver = MsSqlDriver;
+  } else {
+    throw new Error("Unsupported database URI: ".concat(uri));
+  }
+  if (uri === "sqlite://:memory:") {
+    return {
+      entities: ENTITIES,
+      dbName: ":memory:",
+      driver
+    };
+  }
+  const { host, port, username, password, pathname } = new URL(uri);
+  const hostName = host.split(":")[0];
+  return {
+    entities: ENTITIES,
+    dbName: pathname.slice(1),
+    host: hostName,
+    port: port ? parseInt(port) : void 0,
+    user: username,
+    password,
+    driver
+  };
+}
+async function ensureDatabaseCreated(ormOrUrlOrOptions) {
+  let orm;
+  if (ormOrUrlOrOptions instanceof MikroORM) {
+    orm = ormOrUrlOrOptions;
+  } else if (typeof ormOrUrlOrOptions === "string") {
+    orm = await MikroORM.init(getConnectionOptionsFromUri(ormOrUrlOrOptions));
+  } else {
+    orm = await MikroORM.init(ormOrUrlOrOptions);
+  }
+  await orm.schema.ensureDatabase();
+  await orm.schema.updateSchema();
+}
+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();
+}
+export {
+  ensureDatabaseCreated,
+  getConnectionOptionsFromUri,
+  validateDatabaseSchemaVersion
+};

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

@@ -0,0 +1,172 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 { Entity, JsonType, PrimaryKey, Property } from "@mikro-orm/core";
+import {
+  transformToCamelCaseEvent,
+  transformToSnakeCaseEvent
+} from "../../events/event.js";
+const SCHEMA_VERSION_KEY = "schema_version";
+const SCHEMA_VERSION_1_JSON = "1";
+class CamelCaseToSnakeCaseJsonType extends JsonType {
+  convertToDatabaseValue(value) {
+    return JSON.stringify(transformToSnakeCaseEvent(value));
+  }
+  convertToJSValue(value) {
+    if (typeof value === "string") {
+      return transformToCamelCaseEvent(JSON.parse(value));
+    }
+    return transformToCamelCaseEvent(value);
+  }
+}
+let StorageMetadata = class {
+};
+__decorateClass([
+  PrimaryKey({ type: "string" })
+], StorageMetadata.prototype, "key", 2);
+__decorateClass([
+  Property({ type: "string" })
+], StorageMetadata.prototype, "value", 2);
+StorageMetadata = __decorateClass([
+  Entity({ tableName: "adk_internal_metadata" })
+], StorageMetadata);
+let StorageAppState = class {
+  constructor() {
+    this.updateTime = /* @__PURE__ */ new Date();
+  }
+};
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "app_name" })
+], StorageAppState.prototype, "appName", 2);
+__decorateClass([
+  Property({ type: "json" })
+], StorageAppState.prototype, "state", 2);
+__decorateClass([
+  Property({
+    type: "datetime",
+    fieldName: "update_time",
+    onCreate: () => /* @__PURE__ */ new Date(),
+    onUpdate: () => /* @__PURE__ */ new Date()
+  })
+], StorageAppState.prototype, "updateTime", 2);
+StorageAppState = __decorateClass([
+  Entity({ tableName: "app_states" })
+], StorageAppState);
+PrimaryKey.name;
+let StorageUserState = class {
+  constructor() {
+    this.updateTime = /* @__PURE__ */ new Date();
+  }
+};
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "app_name" })
+], StorageUserState.prototype, "appName", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "user_id" })
+], StorageUserState.prototype, "userId", 2);
+__decorateClass([
+  Property({ type: "json" })
+], StorageUserState.prototype, "state", 2);
+__decorateClass([
+  Property({
+    type: "datetime",
+    fieldName: "update_time",
+    onCreate: () => /* @__PURE__ */ new Date(),
+    onUpdate: () => /* @__PURE__ */ new Date()
+  })
+], StorageUserState.prototype, "updateTime", 2);
+StorageUserState = __decorateClass([
+  Entity({ tableName: "user_states" })
+], StorageUserState);
+PrimaryKey.name;
+let StorageSession = class {
+  constructor() {
+    this.createTime = /* @__PURE__ */ new Date();
+    this.updateTime = /* @__PURE__ */ new Date();
+  }
+};
+__decorateClass([
+  PrimaryKey({ type: "string" })
+], StorageSession.prototype, "id", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "app_name" })
+], StorageSession.prototype, "appName", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "user_id" })
+], StorageSession.prototype, "userId", 2);
+__decorateClass([
+  Property({ type: "json" })
+], StorageSession.prototype, "state", 2);
+__decorateClass([
+  Property({
+    type: "datetime",
+    fieldName: "create_time",
+    onCreate: () => /* @__PURE__ */ new Date()
+  })
+], StorageSession.prototype, "createTime", 2);
+__decorateClass([
+  Property({
+    type: "datetime",
+    fieldName: "update_time",
+    onCreate: () => /* @__PURE__ */ new Date()
+  })
+], StorageSession.prototype, "updateTime", 2);
+StorageSession = __decorateClass([
+  Entity({ tableName: "sessions" })
+], StorageSession);
+PrimaryKey.name;
+let StorageEvent = class {
+};
+__decorateClass([
+  PrimaryKey({ type: "string" })
+], StorageEvent.prototype, "id", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "app_name" })
+], StorageEvent.prototype, "appName", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "user_id" })
+], StorageEvent.prototype, "userId", 2);
+__decorateClass([
+  PrimaryKey({ type: "string", fieldName: "session_id" })
+], StorageEvent.prototype, "sessionId", 2);
+__decorateClass([
+  Property({ type: "string", fieldName: "invocation_id" })
+], StorageEvent.prototype, "invocationId", 2);
+__decorateClass([
+  Property({ type: "datetime" })
+], StorageEvent.prototype, "timestamp", 2);
+__decorateClass([
+  Property({ type: CamelCaseToSnakeCaseJsonType, fieldName: "event_data" })
+], StorageEvent.prototype, "eventData", 2);
+StorageEvent = __decorateClass([
+  Entity({ tableName: "events" })
+], StorageEvent);
+const ENTITIES = [
+  StorageMetadata,
+  StorageAppState,
+  StorageUserState,
+  StorageSession,
+  StorageEvent
+];
+export {
+  ENTITIES,
+  SCHEMA_VERSION_1_JSON,
+  SCHEMA_VERSION_KEY,
+  StorageAppState,
+  StorageEvent,
+  StorageMetadata,
+  StorageSession,
+  StorageUserState
+};