@google/adk 2.0.0 → 2.1.0

package/dist/esm/runner/runner.js

@@ -12,7 +12,10 @@ import { createPartFromText, Modality } from "@google/genai";
 import { context, trace } from "@opentelemetry/api";
 import { isBaseAgent } from "../agents/base_agent.js";
 import { reservedFunctionCallName } from "../agents/framework_function_calls.js";
-import { findMatchingFunctionCall } from "../agents/functions.js";
+import {
+  findMatchingFunctionCall,
+  getConflictingFunctionResponseAuthors
+} from "../agents/functions.js";
 import {
   InvocationContext,
   newInvocationContextId,
@@ -21,6 +24,9 @@ import {
 import { isLlmAgent } from "../agents/llm_agent.js";
 import { createRunConfig } from "../agents/run_config.js";
 import { ScopedArtifactService } from "../artifacts/scoped_artifact_service.js";
+import {
+  isSessionArtifactService
+} from "../artifacts/session_artifact_service.js";
 import {
   BuiltInCodeExecutor,
   isBuiltInCodeExecutor
@@ -35,11 +41,12 @@ import {
 import { isBaseToolset } from "../tools/base_toolset.js";
 import { logger } from "../utils/logger.js";
 import { isGemini2OrAbove } from "../utils/model_name.js";
+import { stringifyWithRedactedInlineData } from "../utils/redact_inline_data.js";
 import {
   asRunnableRoot,
   runNodeAsInvocation
 } from "../workflow/run_node_as_invocation.js";
-const RUNNER_SIGNATURE_SYMBOL = Symbol.for("google.adk.runner");
+const RUNNER_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.runner");
 function isRunner(obj) {
   return typeof obj === "object" && obj !== null && RUNNER_SIGNATURE_SYMBOL in obj && obj[RUNNER_SIGNATURE_SYMBOL] === true;
 }
@@ -146,7 +153,9 @@ const _Runner = class _Runner {
                 `Session lookup failed: appName must be provided in runner constructor (or via app.name)`
               );
             }
-            throw new Error(`Session not found: ${sessionId}`);
+            throw new Error(
+              `Session not found: ${sessionId} (appName=${this.appName}, userId=${userId})`
+            );
           }
           if (runConfig.supportCfc && isLlmAgent(this.agent)) {
             const modelName = this.agent.canonicalModel.model;
@@ -160,7 +169,7 @@ const _Runner = class _Runner {
             }
           }
           const invocationContext = new InvocationContext({
-            artifactService: this.artifactService ? new ScopedArtifactService(
+            artifactService: this.artifactService ? isSessionArtifactService(this.artifactService) ? this.artifactService : new ScopedArtifactService(
               this.artifactService,
               this.appName,
               userId,
@@ -174,6 +183,7 @@ const _Runner = class _Runner {
             session,
             userContent: newMessage,
             runConfig,
+            a2aMetadata: runConfig.a2aMetadata,
             pluginManager: this.pluginManager,
             abortSignal: params.abortSignal
           });
@@ -193,9 +203,8 @@ const _Runner = class _Runner {
             }
             if (runConfig.saveInputBlobsAsArtifacts) {
               newMessage = await this.saveArtifacts(
+                invocationContext.artifactService,
                 invocationContext.invocationId,
-                session.userId,
-                session.id,
                 newMessage
               );
               if ((_d = params.abortSignal) == null ? void 0 : _d.aborted) {
@@ -308,21 +317,15 @@ const _Runner = class _Runner {
    * Saves artifacts from the message parts and replaces the inline data with
    * a file name placeholder and optional file reference.
    *
+   * @param artifactService The session-scoped artifact service to save to.
    * @param invocationId The current invocation ID.
-   * @param userId The user ID of the session.
-   * @param sessionId The session ID of the session.
    * @param message The message containing parts to process.
    */
-  async saveArtifacts(invocationId, userId, sessionId, message) {
+  async saveArtifacts(artifactService, invocationId, message) {
     var _a2;
-    if (!this.artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
+    if (!artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
       return message;
     }
-    const sessionKey = {
-      appName: this.appName,
-      userId,
-      sessionId
-    };
     const newParts = [];
     let modified = false;
     for (let i = 0; i < message.parts.length; i++) {
@@ -334,20 +337,16 @@ const _Runner = class _Runner {
       try {
         const inlineData = part.inlineData;
         const fileName = inlineData.displayName || `artifact_${invocationId}_${i}`;
-        const version = await this.artifactService.saveArtifact({
-          ...sessionKey,
+        const version = await artifactService.saveArtifact({
           filename: fileName,
           artifact: part
         });
         newParts.push(createPartFromText(`[Uploaded Artifact: "${fileName}"]`));
         try {
-          const artifactVersion = await this.artifactService.getArtifactVersion(
-            {
-              ...sessionKey,
-              filename: fileName,
-              version
-            }
-          );
+          const artifactVersion = await artifactService.getArtifactVersion({
+            filename: fileName,
+            version
+          });
           if ((artifactVersion == null ? void 0 : artifactVersion.canonicalUri) && /^(gs|https?):/i.test(artifactVersion.canonicalUri)) {
             newParts.push({
               fileData: {
@@ -397,7 +396,7 @@ const _Runner = class _Runner {
    * Whether the agent to run can transfer to any other agent in the agent tree.
    *
    * @param agentToRun The agent to check for transferability.
-   * @returns True if the agent can transfer, False otherwise.
+   * @returns True if the agent can transfer, false otherwise.
    */
   isRoutableLlmAgent(agentToRun) {
     return isRoutableLlmAgent(agentToRun);
@@ -460,7 +459,7 @@ const _Runner = class _Runner {
             return;
           }
           const invocationContext = new InvocationContext({
-            artifactService: this.artifactService ? new ScopedArtifactService(
+            artifactService: this.artifactService ? isSessionArtifactService(this.artifactService) ? this.artifactService : new ScopedArtifactService(
               this.artifactService,
               this.appName,
               params.userId,
@@ -473,6 +472,7 @@ const _Runner = class _Runner {
             agent,
             session,
             runConfig,
+            a2aMetadata: runConfig.a2aMetadata,
             pluginManager: this.pluginManager,
             liveRequestQueue: params.liveRequestQueue,
             abortSignal: params.abortSignal,
@@ -550,6 +550,14 @@ function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
   const event = findEventByLastFunctionResponseId(session.events);
   const isResumable = Boolean(resumabilityConfig == null ? void 0 : resumabilityConfig.isResumable);
   if (event && event.author && isResumable) {
+    const conflictingAuthors = getConflictingFunctionResponseAuthors(
+      session.events
+    );
+    if (conflictingAuthors) {
+      throw new Error(
+        `Function responses in the last event resolve to function calls from more than one agent (at least "${conflictingAuthors[0]}" and "${conflictingAuthors[1]}"); cannot determine a single agent to resume.`
+      );
+    }
     const resumedAgent = rootAgent.findAgent(event.author);
     if (resumedAgent) {
       return resumedAgent;
@@ -561,7 +569,7 @@ function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
     }
   }
   for (let i = session.events.length - 1; i >= 0; i--) {
-    logger.debug("event:", JSON.stringify(session.events[i]));
+    logger.debug("event:", stringifyWithRedactedInlineData(session.events[i]));
     const event2 = session.events[i];
     if (event2.author === "user" || !event2.author) {
       continue;

package/dist/esm/sessions/database_session_service.js

@@ -1,36 +1,72 @@
 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 {
-  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";
+let MikroORM;
+let LockMode;
+let ENTITIES;
+let StorageAppState;
+let StorageEvent;
+let StorageSession;
+let StorageUserState;
+let ensureDatabaseCreated;
+let getConnectionOptionsFromUri;
+let validateDatabaseSchemaVersion;
+let mikroOrmLoad;
+function loadMikroOrm() {
+  mikroOrmLoad != null ? mikroOrmLoad : mikroOrmLoad = importMikroOrm();
+  return mikroOrmLoad;
+}
+__name(loadMikroOrm, "loadMikroOrm");
+async function importMikroOrm() {
+  const [core, schema, operations] = await Promise.all([
+    Promise.resolve().then(() => __toESM(require("@mikro-orm/core"), 1)),
+    Promise.resolve().then(() => __toESM(require("./db/schema.js"), 1)),
+    Promise.resolve().then(() => __toESM(require("./db/operations.js"), 1))
+  ]);
+  ({ MikroORM, LockMode } = core);
+  ({ ENTITIES, StorageAppState, StorageEvent, StorageSession, StorageUserState } = schema);
+  ({
+    ensureDatabaseCreated,
+    getConnectionOptionsFromUri,
+    validateDatabaseSchemaVersion
+  } = operations);
+}
+__name(importMikroOrm, "importMikroOrm");
 function isDatabaseConnectionString(uri) {
   if (!uri) {
     return false;
@@ -48,20 +84,17 @@ const _DatabaseSessionService = class _DatabaseSessionService extends BaseSessio
       if (!connectionStringOrOptions.driver) {
         throw new Error("Driver is required when passing options object.");
       }
-      this.options = {
-        ...connectionStringOrOptions,
-        entities: ENTITIES
-      };
+      this.options = connectionStringOrOptions;
     }
   }
   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 loadMikroOrm();
+    const options = this.connectionString ? await getConnectionOptionsFromUri(this.connectionString) : { ...this.options, entities: ENTITIES };
+    this.options = options;
+    this.orm = await MikroORM.init(options);
     await ensureDatabaseCreated(this.orm);
     await validateDatabaseSchemaVersion(this.orm);
     this.initialized = true;
@@ -396,8 +429,8 @@ const _DatabaseSessionService = class _DatabaseSessionService extends BaseSessio
         });
         txEm.persist(newStorageEvent);
       }
-      await txEm.commit();
       storageSession.updateTime = new Date(event.timestamp);
+      txEm.persist([appStateModel, userStateModel, storageSession]);
       const newMergedState = mergeStates(
         appStateModel.state,
         userStateModel.state,

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

@@ -28,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { logger } from "../../utils/logger.js";
 import { loadOptionalPeer } from "../../utils/optional_peer.js";
 import { redactUriPassword } from "../../utils/redact_uri.js";
 import {
@@ -43,58 +44,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("/")) {
+      logger.warn(
+        `Connection URI names host "${decodedAuthority}" but the ?host= parameter overrides it with the Unix socket "${queryHost}"; connecting to the socket instead. 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("/")) {
+        logger.warn(
+          `Connection URI names host "${decodedHostname}" but the ?host= parameter overrides it with the Unix socket "${queryHost}"; connecting to the socket instead. URI: ${redactUriPassword(uri)}`
+        );
+      }
+      const schema = parsedUrl.searchParams.get("schema");
+      const extraParams = remainingParams(
+        parsedUrl.searchParams,
+        RESERVED_OPTION_KEYS
+      );
+      return {
+        entities: 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: ENTITIES, clientUrl: uri, driver };
+  }
+  const socket = parseSocketUri(uri);
+  if (socket) {
+    return {
+      entities: 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: ${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("/")) {
+        logger.warn(
+          `Connection URI names host "${decodedHostname}" but the ?host= parameter overrides it with the Unix socket "${queryHost}"; connecting to the socket instead. URI: ${redactUriPassword(uri)}`
+        );
+      }
+      const schema = parsedUrl.searchParams.get("schema");
+      const extraParams = remainingParams(
+        parsedUrl.searchParams,
+        RESERVED_OPTION_KEYS
+      );
+      return {
+        entities: 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: ENTITIES, clientUrl: uri, driver };
+  }
+  const socket = parseSocketUri(uri);
+  if (socket) {
+    return {
+      entities: 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: ${redactUriPassword(uri)}`
+  );
+}
+__name(buildMySqlFamilyOptions, "buildMySqlFamilyOptions");
 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://")) {
+    return buildPostgresOptions(uri, PostgreSqlDriver);
+  }
+  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://")) {
+    return buildMySqlFamilyOptions(uri, MySqlDriver);
+  }
+  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://")) {
+    return buildMySqlFamilyOptions(uri, MariaDbDriver);
+  }
+  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://")) {
+    return {
+      entities: ENTITIES,
+      dbName: uri === "sqlite://:memory:" ? ":memory:" : uri.substring("sqlite://".length),
+      driver: SqliteDriver
+    };
+  }
+  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: ${redactUriPassword(uri)}`);
-  }
-  if (uri.startsWith("sqlite://")) {
     return {
       entities: ENTITIES,
-      dbName: uri === "sqlite://:memory:" ? ":memory:" : uri.substring("sqlite://".length),
-      driver
+      clientUrl: uri,
+      driver: MsSqlDriver
     };
   }
-  return {
-    entities: ENTITIES,
-    clientUrl: uri,
-    driver
-  };
+  throw new Error(`Unsupported database 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) {