@google/adk 2.0.0 → 2.1.0

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

@@ -40,6 +40,7 @@ __export(operations_exports, {
   validateDatabaseSchemaVersion: () => validateDatabaseSchemaVersion
 });
 module.exports = __toCommonJS(operations_exports);
+var import_logger = require("../../utils/logger.js");
 var import_optional_peer = require("../../utils/optional_peer.js");
 var import_redact_uri = require("../../utils/redact_uri.js");
 var import_schema = require("./schema.js");
@@ -55,58 +56,264 @@ function driverPeer(packageName, scheme) {
   };
 }
 __name(driverPeer, "driverPeer");
+function safeDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return void 0;
+  }
+}
+__name(safeDecode, "safeDecode");
+function decodeOrRaw(raw) {
+  var _a;
+  return ((_a = safeDecode(raw)) != null ? _a : raw) || void 0;
+}
+__name(decodeOrRaw, "decodeOrRaw");
+function remainingParams(params, exclude) {
+  const result = {};
+  for (const [key, value] of params.entries()) {
+    if (!exclude.includes(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+__name(remainingParams, "remainingParams");
+const RESERVED_OPTION_KEYS = [
+  "host",
+  "schema",
+  "socketPath",
+  "driver",
+  "entities",
+  "user",
+  "password",
+  "dbName",
+  "port",
+  "clientUrl",
+  "driverOptions"
+];
+function parseSocketUri(uri) {
+  var _a, _b;
+  const schemeEnd = uri.indexOf("://");
+  if (schemeEnd === -1) {
+    return null;
+  }
+  const afterScheme = uri.slice(schemeEnd + 3);
+  const authorityEnd = afterScheme.search(/[/?#]/);
+  const authorityRegion = authorityEnd === -1 ? afterScheme : afterScheme.slice(0, authorityEnd);
+  const rest = authorityEnd === -1 ? "" : afterScheme.slice(authorityEnd);
+  const atIndex = authorityRegion.lastIndexOf("@");
+  const rawUserinfo = atIndex === -1 ? void 0 : authorityRegion.slice(0, atIndex);
+  const rawAuthority = atIndex === -1 ? authorityRegion : authorityRegion.slice(atIndex + 1);
+  const restMatch = /^(\/[^?#]*)?(?:\?([^#]*))?/.exec(rest);
+  const rawPath = restMatch == null ? void 0 : restMatch[1];
+  const rawQuery = restMatch == null ? void 0 : restMatch[2];
+  const params = new URLSearchParams(rawQuery != null ? rawQuery : "");
+  const queryHost = params.get("host");
+  const decodedAuthority = (_a = safeDecode(rawAuthority)) != null ? _a : "";
+  let socketPath;
+  let dbNameOverride;
+  let matchedBareSocket = false;
+  if (queryHost == null ? void 0 : queryHost.startsWith("/")) {
+    socketPath = queryHost;
+    if (decodedAuthority && !decodedAuthority.startsWith("/")) {
+      import_logger.logger.warn(
+        `Connection URI names host "${decodedAuthority}" but the ?host= parameter overrides it with the Unix socket "${queryHost}"; connecting to the socket instead. URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`
+      );
+    }
+  } else if (decodedAuthority.startsWith("/")) {
+    socketPath = decodedAuthority;
+  } else if (!decodedAuthority && rawPath) {
+    const segments = rawPath.split("/");
+    const colonIndex = segments.findIndex((segment) => segment.includes(":"));
+    if (colonIndex !== -1) {
+      socketPath = segments.slice(0, colonIndex + 1).join("/");
+      dbNameOverride = segments[colonIndex + 1];
+      matchedBareSocket = true;
+    }
+  }
+  if (!socketPath) {
+    return null;
+  }
+  let user;
+  let password;
+  if (rawUserinfo) {
+    const colonIndex = rawUserinfo.indexOf(":");
+    const rawUser = colonIndex === -1 ? rawUserinfo : rawUserinfo.slice(0, colonIndex);
+    const rawPassword = colonIndex === -1 ? void 0 : rawUserinfo.slice(colonIndex + 1);
+    user = rawUser ? decodeOrRaw(rawUser) : void 0;
+    password = rawPassword ? decodeOrRaw(rawPassword) : void 0;
+  }
+  return {
+    socketPath,
+    user,
+    password,
+    dbName: matchedBareSocket ? dbNameOverride ? decodeOrRaw(dbNameOverride) : void 0 : rawPath ? decodeOrRaw(rawPath.slice(1)) : void 0,
+    schema: (_b = params.get("schema")) != null ? _b : void 0,
+    extraParams: remainingParams(params, RESERVED_OPTION_KEYS)
+  };
+}
+__name(parseSocketUri, "parseSocketUri");
+function buildPostgresOptions(uri, driver) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(uri);
+  } catch {
+    parsedUrl = null;
+  }
+  if (parsedUrl) {
+    const queryHost = parsedUrl.searchParams.get("host");
+    const decodedHostname = parsedUrl.hostname ? safeDecode(parsedUrl.hostname) : void 0;
+    const socketPath = (queryHost == null ? void 0 : queryHost.startsWith("/")) ? queryHost : (decodedHostname == null ? void 0 : decodedHostname.startsWith("/")) ? decodedHostname : void 0;
+    if (socketPath) {
+      if ((queryHost == null ? void 0 : queryHost.startsWith("/")) && decodedHostname && !decodedHostname.startsWith("/")) {
+        import_logger.logger.warn(
+          `Connection URI names host "${decodedHostname}" but the ?host= parameter overrides it with the Unix socket "${queryHost}"; connecting to the socket instead. URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`
+        );
+      }
+      const schema = parsedUrl.searchParams.get("schema");
+      const extraParams = remainingParams(
+        parsedUrl.searchParams,
+        RESERVED_OPTION_KEYS
+      );
+      return {
+        entities: import_schema.ENTITIES,
+        driver,
+        host: socketPath,
+        user: parsedUrl.username ? decodeOrRaw(parsedUrl.username) : void 0,
+        password: parsedUrl.password ? decodeOrRaw(parsedUrl.password) : void 0,
+        dbName: decodeOrRaw(parsedUrl.pathname.slice(1)),
+        ...parsedUrl.port ? { port: Number(parsedUrl.port) } : {},
+        ...schema ? { schema } : {},
+        driverOptions: extraParams
+      };
+    }
+    return { entities: import_schema.ENTITIES, clientUrl: uri, driver };
+  }
+  const socket = parseSocketUri(uri);
+  if (socket) {
+    return {
+      entities: import_schema.ENTITIES,
+      driver,
+      host: socket.socketPath,
+      user: socket.user,
+      password: socket.password,
+      dbName: socket.dbName,
+      ...socket.schema ? { schema: socket.schema } : {},
+      driverOptions: socket.extraParams
+    };
+  }
+  throw new Error(
+    `Unrecognized postgres connection URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`
+  );
+}
+__name(buildPostgresOptions, "buildPostgresOptions");
+function buildMySqlFamilyOptions(uri, driver) {
+  let parsedUrl = null;
+  try {
+    parsedUrl = new URL(uri);
+  } catch {
+  }
+  if (parsedUrl) {
+    const queryHost = parsedUrl.searchParams.get("host");
+    const decodedHostname = parsedUrl.hostname ? safeDecode(parsedUrl.hostname) : void 0;
+    const socketPath = (queryHost == null ? void 0 : queryHost.startsWith("/")) ? queryHost : (decodedHostname == null ? void 0 : decodedHostname.startsWith("/")) ? decodedHostname : void 0;
+    if (socketPath) {
+      if ((queryHost == null ? void 0 : queryHost.startsWith("/")) && decodedHostname && !decodedHostname.startsWith("/")) {
+        import_logger.logger.warn(
+          `Connection URI names host "${decodedHostname}" but the ?host= parameter overrides it with the Unix socket "${queryHost}"; connecting to the socket instead. URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`
+        );
+      }
+      const schema = parsedUrl.searchParams.get("schema");
+      const extraParams = remainingParams(
+        parsedUrl.searchParams,
+        RESERVED_OPTION_KEYS
+      );
+      return {
+        entities: import_schema.ENTITIES,
+        driver,
+        user: parsedUrl.username ? decodeOrRaw(parsedUrl.username) : void 0,
+        password: parsedUrl.password ? decodeOrRaw(parsedUrl.password) : void 0,
+        dbName: decodeOrRaw(parsedUrl.pathname.slice(1)),
+        driverOptions: {
+          socketPath,
+          ...schema ? { schema } : {},
+          ...extraParams
+        }
+      };
+    }
+    return { entities: import_schema.ENTITIES, clientUrl: uri, driver };
+  }
+  const socket = parseSocketUri(uri);
+  if (socket) {
+    return {
+      entities: import_schema.ENTITIES,
+      driver,
+      user: socket.user,
+      password: socket.password,
+      dbName: socket.dbName,
+      driverOptions: {
+        socketPath: socket.socketPath,
+        ...socket.schema ? { schema: socket.schema } : {},
+        ...socket.extraParams
+      }
+    };
+  }
+  throw new Error(
+    `Unrecognized MySQL/MariaDB connection URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`
+  );
+}
+__name(buildMySqlFamilyOptions, "buildMySqlFamilyOptions");
 async function getConnectionOptionsFromUri(uri) {
-  let driver;
   if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
     const { PostgreSqlDriver } = await (0, import_optional_peer.loadOptionalPeer)(
       driverPeer("@mikro-orm/postgresql", "postgres"),
       () => Promise.resolve().then(() => __toESM(require("@mikro-orm/postgresql"), 1))
     );
-    driver = PostgreSqlDriver;
-  } else if (uri.startsWith("mysql://")) {
+    return buildPostgresOptions(uri, PostgreSqlDriver);
+  }
+  if (uri.startsWith("mysql://")) {
     const { MySqlDriver } = await (0, import_optional_peer.loadOptionalPeer)(
       driverPeer("@mikro-orm/mysql", "mysql"),
       () => Promise.resolve().then(() => __toESM(require("@mikro-orm/mysql"), 1))
     );
-    driver = MySqlDriver;
-  } else if (uri.startsWith("mariadb://")) {
+    return buildMySqlFamilyOptions(uri, MySqlDriver);
+  }
+  if (uri.startsWith("mariadb://")) {
     const { MariaDbDriver } = await (0, import_optional_peer.loadOptionalPeer)(
       driverPeer("@mikro-orm/mariadb", "mariadb"),
       () => Promise.resolve().then(() => __toESM(require("@mikro-orm/mariadb"), 1))
     );
-    driver = MariaDbDriver;
-  } else if (uri.startsWith("sqlite://")) {
+    return buildMySqlFamilyOptions(uri, MariaDbDriver);
+  }
+  if (uri.startsWith("sqlite://")) {
     const { SqliteDriver } = await (0, import_optional_peer.loadOptionalPeer)(
       driverPeer("@mikro-orm/sqlite", "sqlite"),
       () => Promise.resolve().then(() => __toESM(require("@mikro-orm/sqlite"), 1))
     );
-    driver = SqliteDriver;
-  } else if (uri.startsWith("mssql://")) {
+    return {
+      entities: import_schema.ENTITIES,
+      dbName: uri === "sqlite://:memory:" ? ":memory:" : uri.substring("sqlite://".length),
+      driver: SqliteDriver
+    };
+  }
+  if (uri.startsWith("mssql://")) {
     const { MsSqlDriver } = await (0, import_optional_peer.loadOptionalPeer)(
       driverPeer("@mikro-orm/mssql", "mssql"),
       () => Promise.resolve().then(() => __toESM(require("@mikro-orm/mssql"), 1))
     );
-    driver = MsSqlDriver;
-  } else {
-    throw new Error(`Unsupported database URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`);
-  }
-  if (uri.startsWith("sqlite://")) {
     return {
       entities: import_schema.ENTITIES,
-      dbName: uri === "sqlite://:memory:" ? ":memory:" : uri.substring("sqlite://".length),
-      driver
+      clientUrl: uri,
+      driver: MsSqlDriver
     };
   }
-  return {
-    entities: import_schema.ENTITIES,
-    clientUrl: uri,
-    driver
-  };
+  throw new Error(`Unsupported database URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`);
 }
 __name(getConnectionOptionsFromUri, "getConnectionOptionsFromUri");
 async function ensureDatabaseCreated(orm) {
   await orm.schema.ensureDatabase();
-  await orm.schema.updateSchema({ safe: true });
+  await orm.schema.update({ safe: true });
 }
 __name(ensureDatabaseCreated, "ensureDatabaseCreated");
 async function validateDatabaseSchemaVersion(orm) {

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

@@ -23,17 +23,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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;
-};
 var schema_exports = {};
 __export(schema_exports, {
   ENTITIES: () => ENTITIES,
+  EVENT_TIMESTAMP_PRECISION: () => EVENT_TIMESTAMP_PRECISION,
   SCHEMA_VERSION_1_JSON: () => SCHEMA_VERSION_1_JSON,
   SCHEMA_VERSION_KEY: () => SCHEMA_VERSION_KEY,
   STORAGE_KEY_COLUMN_LENGTH: () => STORAGE_KEY_COLUMN_LENGTH,
@@ -41,7 +34,12 @@ __export(schema_exports, {
   StorageEvent: () => StorageEvent,
   StorageMetadata: () => StorageMetadata,
   StorageSession: () => StorageSession,
-  StorageUserState: () => StorageUserState
+  StorageUserState: () => StorageUserState,
+  storageAppStateSchema: () => storageAppStateSchema,
+  storageEventSchema: () => storageEventSchema,
+  storageMetadataSchema: () => storageMetadataSchema,
+  storageSessionSchema: () => storageSessionSchema,
+  storageUserStateSchema: () => storageUserStateSchema
 });
 module.exports = __toCommonJS(schema_exports);
 var import_core = require("@mikro-orm/core");
@@ -54,6 +52,7 @@ var import_event = require("../../events/event.js");
 const SCHEMA_VERSION_KEY = "schema_version";
 const SCHEMA_VERSION_1_JSON = "1";
 const STORAGE_KEY_COLUMN_LENGTH = 191;
+const EVENT_TIMESTAMP_PRECISION = 6;
 const _CamelCaseToSnakeCaseJsonType = class _CamelCaseToSnakeCaseJsonType extends import_core.JsonType {
   convertToDatabaseValue(value) {
     return JSON.stringify((0, import_event.transformToSnakeCaseEvent)(value));
@@ -67,175 +66,125 @@ const _CamelCaseToSnakeCaseJsonType = class _CamelCaseToSnakeCaseJsonType extend
 };
 __name(_CamelCaseToSnakeCaseJsonType, "CamelCaseToSnakeCaseJsonType");
 let CamelCaseToSnakeCaseJsonType = _CamelCaseToSnakeCaseJsonType;
-let StorageMetadata = class {
+const KEY_COLUMN = {
+  type: "string",
+  length: STORAGE_KEY_COLUMN_LENGTH,
+  primary: true
+};
+const _StorageMetadata = class _StorageMetadata {
 };
-__name(StorageMetadata, "StorageMetadata");
-__decorateClass([
-  (0, import_core.PrimaryKey)({ type: "string" })
-], StorageMetadata.prototype, "key", 2);
-__decorateClass([
-  (0, import_core.Property)({ type: "string" })
-], StorageMetadata.prototype, "value", 2);
-StorageMetadata = __decorateClass([
-  (0, import_core.Entity)({ tableName: "adk_internal_metadata" })
-], StorageMetadata);
-let StorageAppState = class {
+__name(_StorageMetadata, "StorageMetadata");
+let StorageMetadata = _StorageMetadata;
+const storageMetadataSchema = new import_core.EntitySchema({
+  class: StorageMetadata,
+  tableName: "adk_internal_metadata",
+  properties: {
+    key: { type: "string", primary: true },
+    value: { type: "string" }
+  }
+});
+const _StorageAppState = class _StorageAppState {
   constructor() {
     this.updateTime = /* @__PURE__ */ new Date();
   }
 };
-__name(StorageAppState, "StorageAppState");
-__decorateClass([
-  (0, import_core.PrimaryKey)({
-    type: "string",
-    fieldName: "app_name",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageAppState.prototype, "appName", 2);
-__decorateClass([
-  (0, import_core.Property)({ type: "json" })
-], StorageAppState.prototype, "state", 2);
-__decorateClass([
-  (0, import_core.Property)({
-    type: "datetime",
-    fieldName: "update_time",
-    onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate"),
-    onUpdate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onUpdate")
-  })
-], StorageAppState.prototype, "updateTime", 2);
-StorageAppState = __decorateClass([
-  (0, import_core.Entity)({ tableName: "app_states" })
-], StorageAppState);
-import_core.PrimaryKey.name;
-let StorageUserState = class {
+__name(_StorageAppState, "StorageAppState");
+let StorageAppState = _StorageAppState;
+const storageAppStateSchema = new import_core.EntitySchema({
+  class: StorageAppState,
+  tableName: "app_states",
+  properties: {
+    appName: { ...KEY_COLUMN, fieldName: "app_name" },
+    state: { type: "json" },
+    updateTime: {
+      type: "datetime",
+      fieldName: "update_time",
+      onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate"),
+      onUpdate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onUpdate")
+    }
+  }
+});
+import_core.PrimaryKeyProp;
+const _StorageUserState = class _StorageUserState {
   constructor() {
     this.updateTime = /* @__PURE__ */ new Date();
   }
 };
-__name(StorageUserState, "StorageUserState");
-__decorateClass([
-  (0, import_core.PrimaryKey)({
-    type: "string",
-    fieldName: "app_name",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageUserState.prototype, "appName", 2);
-__decorateClass([
-  (0, import_core.PrimaryKey)({
-    type: "string",
-    fieldName: "user_id",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageUserState.prototype, "userId", 2);
-__decorateClass([
-  (0, import_core.Property)({ type: "json" })
-], StorageUserState.prototype, "state", 2);
-__decorateClass([
-  (0, import_core.Property)({
-    type: "datetime",
-    fieldName: "update_time",
-    onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate"),
-    onUpdate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onUpdate")
-  })
-], StorageUserState.prototype, "updateTime", 2);
-StorageUserState = __decorateClass([
-  (0, import_core.Entity)({ tableName: "user_states" })
-], StorageUserState);
-import_core.PrimaryKey.name;
-let StorageSession = class {
+__name(_StorageUserState, "StorageUserState");
+let StorageUserState = _StorageUserState;
+const storageUserStateSchema = new import_core.EntitySchema({
+  class: StorageUserState,
+  tableName: "user_states",
+  properties: {
+    appName: { ...KEY_COLUMN, fieldName: "app_name" },
+    userId: { ...KEY_COLUMN, fieldName: "user_id" },
+    state: { type: "json" },
+    updateTime: {
+      type: "datetime",
+      fieldName: "update_time",
+      onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate"),
+      onUpdate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onUpdate")
+    }
+  }
+});
+import_core.PrimaryKeyProp;
+const _StorageSession = class _StorageSession {
   constructor() {
     this.createTime = /* @__PURE__ */ new Date();
     this.updateTime = /* @__PURE__ */ new Date();
   }
 };
-__name(StorageSession, "StorageSession");
-__decorateClass([
-  (0, import_core.PrimaryKey)({ type: "string", length: STORAGE_KEY_COLUMN_LENGTH })
-], StorageSession.prototype, "id", 2);
-__decorateClass([
-  (0, import_core.PrimaryKey)({
-    type: "string",
-    fieldName: "app_name",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageSession.prototype, "appName", 2);
-__decorateClass([
-  (0, import_core.PrimaryKey)({
-    type: "string",
-    fieldName: "user_id",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageSession.prototype, "userId", 2);
-__decorateClass([
-  (0, import_core.Property)({ type: "json" })
-], StorageSession.prototype, "state", 2);
-__decorateClass([
-  (0, import_core.Property)({
-    type: "datetime",
-    fieldName: "create_time",
-    onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate")
-  })
-], StorageSession.prototype, "createTime", 2);
-__decorateClass([
-  (0, import_core.Property)({
-    type: "datetime",
-    fieldName: "update_time",
-    onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate")
-  })
-], StorageSession.prototype, "updateTime", 2);
-StorageSession = __decorateClass([
-  (0, import_core.Entity)({ tableName: "sessions" })
-], StorageSession);
-import_core.PrimaryKey.name;
-let StorageEvent = class {
+__name(_StorageSession, "StorageSession");
+let StorageSession = _StorageSession;
+const storageSessionSchema = new import_core.EntitySchema({
+  class: StorageSession,
+  tableName: "sessions",
+  properties: {
+    id: KEY_COLUMN,
+    appName: { ...KEY_COLUMN, fieldName: "app_name" },
+    userId: { ...KEY_COLUMN, fieldName: "user_id" },
+    state: { type: "json" },
+    createTime: {
+      type: "datetime",
+      fieldName: "create_time",
+      onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate")
+    },
+    updateTime: {
+      type: "datetime",
+      fieldName: "update_time",
+      onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate")
+    }
+  }
+});
+import_core.PrimaryKeyProp;
+const _StorageEvent = class _StorageEvent {
 };
-__name(StorageEvent, "StorageEvent");
-__decorateClass([
-  (0, import_core.PrimaryKey)({ type: "string", length: STORAGE_KEY_COLUMN_LENGTH })
-], StorageEvent.prototype, "id", 2);
-__decorateClass([
-  (0, import_core.PrimaryKey)({
-    type: "string",
-    fieldName: "app_name",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageEvent.prototype, "appName", 2);
-__decorateClass([
-  (0, import_core.PrimaryKey)({
-    type: "string",
-    fieldName: "user_id",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageEvent.prototype, "userId", 2);
-__decorateClass([
-  (0, import_core.PrimaryKey)({
-    type: "string",
-    fieldName: "session_id",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageEvent.prototype, "sessionId", 2);
-__decorateClass([
-  (0, import_core.Property)({ type: "string", fieldName: "invocation_id" })
-], StorageEvent.prototype, "invocationId", 2);
-__decorateClass([
-  (0, import_core.Property)({ type: "datetime" })
-], StorageEvent.prototype, "timestamp", 2);
-__decorateClass([
-  (0, import_core.Property)({ type: CamelCaseToSnakeCaseJsonType, fieldName: "event_data" })
-], StorageEvent.prototype, "eventData", 2);
-StorageEvent = __decorateClass([
-  (0, import_core.Entity)({ tableName: "events" })
-], StorageEvent);
+__name(_StorageEvent, "StorageEvent");
+let StorageEvent = _StorageEvent;
+const storageEventSchema = new import_core.EntitySchema({
+  class: StorageEvent,
+  tableName: "events",
+  properties: {
+    id: KEY_COLUMN,
+    appName: { ...KEY_COLUMN, fieldName: "app_name" },
+    userId: { ...KEY_COLUMN, fieldName: "user_id" },
+    sessionId: { ...KEY_COLUMN, fieldName: "session_id" },
+    invocationId: { type: "string", fieldName: "invocation_id" },
+    timestamp: { type: "datetime", length: EVENT_TIMESTAMP_PRECISION },
+    eventData: { type: CamelCaseToSnakeCaseJsonType, fieldName: "event_data" }
+  }
+});
 const ENTITIES = [
-  StorageMetadata,
-  StorageAppState,
-  StorageUserState,
-  StorageSession,
-  StorageEvent
+  storageMetadataSchema,
+  storageAppStateSchema,
+  storageUserStateSchema,
+  storageSessionSchema,
+  storageEventSchema
 ];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ENTITIES,
+  EVENT_TIMESTAMP_PRECISION,
   SCHEMA_VERSION_1_JSON,
   SCHEMA_VERSION_KEY,
   STORAGE_KEY_COLUMN_LENGTH,
@@ -243,5 +192,10 @@ const ENTITIES = [
   StorageEvent,
   StorageMetadata,
   StorageSession,
-  StorageUserState
+  StorageUserState,
+  storageAppStateSchema,
+  storageEventSchema,
+  storageMetadataSchema,
+  storageSessionSchema,
+  storageUserStateSchema
 });

package/dist/cjs/sessions/registry.js

@@ -45,7 +45,11 @@ function getSessionServiceFromUri(uri) {
     return new import_database_session_service.DatabaseSessionService(uri);
   }
   if ((0, import_vertex_ai_session_service.isVertexAiConnectionString)(uri)) {
-    return new import_vertex_ai_session_service.VertexAiSessionService({});
+    return new import_vertex_ai_session_service.VertexAiSessionService({
+      projectId: process.env.GOOGLE_CLOUD_PROJECT,
+      location: process.env.GOOGLE_CLOUD_LOCATION,
+      agentEngineId: process.env.GOOGLE_CLOUD_AGENT_ENGINE_ID
+    });
   }
   throw new Error(`Unsupported session service URI: ${(0, import_redact_uri.redactUriPassword)(uri)}`);
 }

package/dist/cjs/sessions/vertex_ai_session_service.js

@@ -38,7 +38,7 @@ __export(vertex_ai_session_service_exports, {
   quoteFilterLiteral: () => quoteFilterLiteral
 });
 module.exports = __toCommonJS(vertex_ai_session_service_exports);
-var import_client = require("@google-cloud/vertexai/build/src/genai/client.js");
+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_logger = require("../utils/logger.js");
@@ -84,7 +84,7 @@ let VertexAiSessionService = class extends import_base_session_service.BaseSessi
           this.expressModeApiKey ? import_vertex_ai_utils.EXPRESS_MODE_UNSUPPORTED_MESSAGE : "Project ID and Location are required."
         );
       }
-      const client = new import_client.Client({
+      const client = new import_vertexai.Client({
         project: this.projectId,
         location: this.location
       });

package/dist/cjs/telemetry/setup.js

@@ -100,7 +100,7 @@ function getOtelExporters(config = getOtelExportersConfig()) {
         exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter()
       })
     ] : [],
-    logRecordProcessors: enableLogging ? [new import_sdk_logs.BatchLogRecordProcessor(new import_exporter_logs_otlp_http.OTLPLogExporter())] : []
+    logRecordProcessors: enableLogging ? [new import_sdk_logs.BatchLogRecordProcessor({ exporter: new import_exporter_logs_otlp_http.OTLPLogExporter() })] : []
   };
 }
 __name(getOtelExporters, "getOtelExporters");