@google/adk 1.5.0 → 2.0.0

package/dist/web/runner/runner.js

@@ -23,6 +23,7 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __await = function(promise, isYieldStar) {
   this[0] = promise;
   this[1] = isYieldStar;
@@ -73,12 +74,15 @@ var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")])
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-import { createPartFromText } from "@google/genai";
+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 {
   InvocationContext,
-  newInvocationContextId
+  newInvocationContextId,
+  requireAgent
 } from "../agents/invocation_context.js";
 import { isLlmAgent } from "../agents/llm_agent.js";
 import { createRunConfig } from "../agents/run_config.js";
@@ -97,12 +101,17 @@ import {
 import { isBaseToolset } from "../tools/base_toolset.js";
 import { logger } from "../utils/logger.js";
 import { isGemini2OrAbove } from "../utils/model_name.js";
+import {
+  asRunnableRoot,
+  runNodeAsInvocation
+} from "../workflow/run_node_as_invocation.js";
 const RUNNER_SIGNATURE_SYMBOL = Symbol.for("google.adk.runner");
 function isRunner(obj) {
   return typeof obj === "object" && obj !== null && RUNNER_SIGNATURE_SYMBOL in obj && obj[RUNNER_SIGNATURE_SYMBOL] === true;
 }
+__name(isRunner, "isRunner");
 _a = RUNNER_SIGNATURE_SYMBOL;
-class Runner {
+const _Runner = class _Runner {
   /**
    * Creates a new Runner instance.
    *
@@ -119,7 +128,7 @@ class Runner {
       );
     }
     this.appName = appName;
-    this.agent = agent;
+    this.agent = asRunnableRoot(agent);
     const appPlugins = (_f = (_e = input.app) == null ? void 0 : _e.plugins) != null ? _f : [];
     const configPlugins = (_g = input.plugins) != null ? _g : [];
     this.pluginManager = new PluginManager([...appPlugins, ...configPlugins]);
@@ -183,6 +192,7 @@ class Runner {
       if (newMessage && !newMessage.role) {
         newMessage.role = "user";
       }
+      rejectReservedFunctionCalls(newMessage);
       const span = tracer.startSpan("invocation");
       const ctx = trace.setSpan(context.active(), span);
       try {
@@ -191,7 +201,7 @@ class Runner {
           this,
           function() {
             return __asyncGenerator(this, null, function* () {
-              var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+              var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
               const session = yield new __await(this.sessionService.getSession({
                 appName: this.appName,
                 userId,
@@ -230,7 +240,7 @@ class Runner {
                 memoryService: this.memoryService,
                 credentialService: this.credentialService,
                 invocationId: newInvocationContextId(),
-                agent: this.agent,
+                agent: isBaseAgent(this.agent) ? this.agent : void 0,
                 session,
                 userContent: newMessage,
                 runConfig,
@@ -276,10 +286,12 @@ class Runner {
                   return;
                 }
               }
-              invocationContext.agent = this.determineAgentForResumption(
-                session,
-                this.agent
-              );
+              if (isBaseAgent(this.agent)) {
+                invocationContext.agent = this.determineAgentForResumption(
+                  session,
+                  this.agent
+                );
+              }
               if (newMessage) {
                 const beforeRunCallbackResponse = yield new __await(this.pluginManager.runBeforeRunCallback({
                   invocationContext
@@ -303,28 +315,32 @@ class Runner {
                   yield earlyExitEvent;
                 } else {
                   try {
-                    for (var iter = __forAwait(invocationContext.agent.runAsync(
-                      invocationContext
-                    )), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+                    for (var iter = __forAwait(this.runRoot(invocationContext)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
                       const event = temp.value;
                       if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
                         return;
                       }
-                      if (!event.partial) {
-                        yield new __await(this.sessionService.appendEvent({ session, event }));
-                      }
                       const modifiedEvent = yield new __await(this.pluginManager.runOnEventCallback({
                         invocationContext,
                         event
                       }));
-                      if ((_i = params.abortSignal) == null ? void 0 : _i.aborted) {
-                        return;
+                      const outputEvent = modifiedEvent ? __spreadProps(__spreadValues({}, modifiedEvent), {
+                        id: event.id,
+                        invocationId: event.invocationId,
+                        timestamp: event.timestamp,
+                        author: modifiedEvent.author || event.author,
+                        branch: (_i = modifiedEvent.branch) != null ? _i : event.branch
+                      }) : event;
+                      if (!event.partial) {
+                        yield new __await(this.sessionService.appendEvent({
+                          session,
+                          event: outputEvent
+                        }));
                       }
-                      if (modifiedEvent) {
-                        yield modifiedEvent;
-                      } else {
-                        yield event;
+                      if ((_j = params.abortSignal) == null ? void 0 : _j.aborted) {
+                        return;
                       }
+                      yield outputEvent;
                     }
                   } catch (temp) {
                     error = [temp];
@@ -337,7 +353,7 @@ class Runner {
                     }
                   }
                   yield new __await(this.pluginManager.runAfterRunCallback({ invocationContext }));
-                  if ((_j = params.abortSignal) == null ? void 0 : _j.aborted) {
+                  if ((_k = params.abortSignal) == null ? void 0 : _k.aborted) {
                     return;
                   }
                 }
@@ -347,11 +363,32 @@ class Runner {
         ));
       } finally {
         span.end();
-        const toolsets = getAllToolsets(this.agent);
+        const toolsets = isBaseAgent(this.agent) ? getAllToolsets(this.agent) : [];
         yield new __await(Promise.allSettled(toolsets.map((t) => t.close())));
       }
     });
   }
+  /**
+   * Runs whatever this runner was given as its root.
+   *
+   * An agent is run through `runAsync`, as always. A bare node — a `Workflow`
+   * handed to the runner directly — is driven by {@link runNodeAsInvocation}.
+   *
+   * Only the execution differs. Everything around it (the run callbacks, event
+   * persistence, cancellation) is shared, so the node path cannot drift from
+   * the agent path on the things that are not about execution. adk-python has
+   * two separate loops here and a TODO noting its node one lacks tracing and
+   * plugins; there is nothing to lack if there is only one loop.
+   */
+  runRoot(invocationContext) {
+    return __asyncGenerator(this, null, function* () {
+      if (isBaseAgent(this.agent)) {
+        yield* __yieldStar(requireAgent(invocationContext).runAsync(invocationContext));
+        return;
+      }
+      yield* __yieldStar(runNodeAsInvocation(this.agent, invocationContext));
+    });
+  }
   /**
    * Saves artifacts from the message parts and replaces the inline data with
    * a file name placeholder and optional file reference.
@@ -447,8 +484,166 @@ class Runner {
   isRoutableLlmAgent(agentToRun) {
     return isRoutableLlmAgent(agentToRun);
   }
-  // TODO - b/425992518: Implement runLive and related methods.
+  /**
+   * Runs the agent in the live (bidirectional streaming) mode.
+   *
+   * Model media events that carry raw inline bytes (audio, video, or image)
+   * are yielded but not appended to the session to avoid persisting large
+   * blobs; events with `fileData` references and most other live events
+   * (transcriptions, tool calls, usage) are persisted as in `runAsync`.
+   *
+   * This feature is **experimental** and its API may change.
+   *
+   * @param params.userId The user ID of the session.
+   * @param params.sessionId The session ID of the session.
+   * @param params.liveRequestQueue The queue used to feed the live model.
+   * @param params.runConfig The run config for the agent.
+   * @param params.abortSignal Optional signal to abort the live run.
+   * @param params.liveSessionResumptionHandle Optional session resumption
+   *     handle observed from a prior `runLive` cycle on the same conversation.
+   *     When set, the agent's live flow opens the connection with
+   *     `liveConnectConfig.sessionResumption.handle` so the server restores its
+   *     state instead of relying on client-side history replay.
+   * @yields The events generated by the agent.
+   */
+  runLive(params) {
+    return __asyncGenerator(this, null, function* () {
+      var _a2, _b, _c, _d;
+      if (!params.liveRequestQueue) {
+        throw new Error("liveRequestQueue is required for runLive.");
+      }
+      if (!isBaseAgent(this.agent)) {
+        throw new Error("runLive is only supported for agents.");
+      }
+      const agent = this.agent;
+      const runConfig = createRunConfig(params.runConfig);
+      if (!((_a2 = runConfig.responseModalities) == null ? void 0 : _a2.length)) {
+        runConfig.responseModalities = [Modality.AUDIO];
+      }
+      if ((_b = agent.subAgents) == null ? void 0 : _b.length) {
+        if (runConfig.responseModalities.includes(Modality.AUDIO)) {
+          (_c = runConfig.outputAudioTranscription) != null ? _c : runConfig.outputAudioTranscription = {};
+        }
+        (_d = runConfig.inputAudioTranscription) != null ? _d : runConfig.inputAudioTranscription = {};
+      }
+      const span = tracer.startSpan("invocation");
+      const ctx = trace.setSpan(context.active(), span);
+      try {
+        yield* __yieldStar(runAsyncGeneratorWithOtelContext(
+          ctx,
+          this,
+          function() {
+            return __asyncGenerator(this, null, function* () {
+              var _a3, _b2, _c2, _d2;
+              const session = yield new __await(this.sessionService.getOrCreateSession({
+                appName: this.appName,
+                userId: params.userId,
+                sessionId: params.sessionId
+              }));
+              if ((_a3 = params.abortSignal) == null ? void 0 : _a3.aborted) {
+                return;
+              }
+              const invocationContext = new InvocationContext({
+                artifactService: this.artifactService ? new ScopedArtifactService(
+                  this.artifactService,
+                  this.appName,
+                  params.userId,
+                  params.sessionId
+                ) : void 0,
+                sessionService: this.sessionService,
+                memoryService: this.memoryService,
+                credentialService: this.credentialService,
+                invocationId: newInvocationContextId(),
+                agent,
+                session,
+                runConfig,
+                pluginManager: this.pluginManager,
+                liveRequestQueue: params.liveRequestQueue,
+                abortSignal: params.abortSignal,
+                liveSessionResumptionHandle: params.liveSessionResumptionHandle
+              });
+              invocationContext.agent = this.determineAgentForResumption(
+                session,
+                agent
+              );
+              const beforeRunCallbackResponse = yield new __await(this.pluginManager.runBeforeRunCallback({
+                invocationContext
+              }));
+              if ((_b2 = params.abortSignal) == null ? void 0 : _b2.aborted) {
+                return;
+              }
+              if (beforeRunCallbackResponse) {
+                const earlyExitEvent = createEvent({
+                  invocationId: invocationContext.invocationId,
+                  author: "model",
+                  content: beforeRunCallbackResponse
+                });
+                yield new __await(this.sessionService.appendEvent({
+                  session,
+                  event: earlyExitEvent
+                }));
+                yield earlyExitEvent;
+                return;
+              }
+              try {
+                for (var iter = __forAwait(requireAgent(invocationContext).runLive(
+                  invocationContext
+                )), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+                  const event = temp.value;
+                  if ((_c2 = params.abortSignal) == null ? void 0 : _c2.aborted) {
+                    return;
+                  }
+                  const modifiedEvent = yield new __await(this.pluginManager.runOnEventCallback({
+                    invocationContext,
+                    event
+                  }));
+                  if ((_d2 = params.abortSignal) == null ? void 0 : _d2.aborted) {
+                    return;
+                  }
+                  const eventToProcess = modifiedEvent != null ? modifiedEvent : event;
+                  if (!eventToProcess.partial && !isLiveModelMediaEventWithInlineData(eventToProcess)) {
+                    yield new __await(this.sessionService.appendEvent({
+                      session,
+                      event: eventToProcess
+                    }));
+                  }
+                  yield eventToProcess;
+                }
+              } catch (temp) {
+                error = [temp];
+              } finally {
+                try {
+                  more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+                } finally {
+                  if (error)
+                    throw error[0];
+                }
+              }
+              yield new __await(this.pluginManager.runAfterRunCallback({ invocationContext }));
+            });
+          }
+        ));
+      } finally {
+        span.end();
+      }
+    });
+  }
+};
+__name(_Runner, "Runner");
+let Runner = _Runner;
+function isLiveModelMediaEventWithInlineData(event) {
+  var _a2;
+  const parts = (_a2 = event.content) == null ? void 0 : _a2.parts;
+  if (!(parts == null ? void 0 : parts.length)) {
+    return false;
+  }
+  return parts.some((part) => {
+    var _a3, _b;
+    const mimeType = (_b = (_a3 = part.inlineData) == null ? void 0 : _a3.mimeType) == null ? void 0 : _b.toLowerCase();
+    return mimeType !== void 0 && (mimeType.startsWith("audio/") || mimeType.startsWith("video/") || mimeType.startsWith("image/"));
+  });
 }
+__name(isLiveModelMediaEventWithInlineData, "isLiveModelMediaEventWithInlineData");
 function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
   const event = findEventByLastFunctionResponseId(session.events);
   const isResumable = Boolean(resumabilityConfig == null ? void 0 : resumabilityConfig.isResumable);
@@ -457,9 +652,11 @@ function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
     if (resumedAgent) {
       return resumedAgent;
     }
-    logger.warn(
-      "Function response from an unknown agent: ".concat(event.author, ", event id: ").concat(event.id)
-    );
+    if (!isWorkflowNodeEvent(event)) {
+      logger.warn(
+        "Function response from an unknown agent: ".concat(event.author, ", event id: ").concat(event.id)
+      );
+    }
   }
   for (let i = session.events.length - 1; i >= 0; i--) {
     logger.debug("event:", JSON.stringify(session.events[i]));
@@ -472,9 +669,11 @@ function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
     }
     const agent = rootAgent.findSubAgent(event2.author);
     if (!agent) {
-      logger.warn(
-        "Event from an unknown agent: ".concat(event2.author, ", event id: ").concat(event2.id)
-      );
+      if (!isWorkflowNodeEvent(event2)) {
+        logger.warn(
+          "Event from an unknown agent: ".concat(event2.author, ", event id: ").concat(event2.id)
+        );
+      }
       continue;
     }
     if (isRoutableLlmAgent(agent)) {
@@ -483,6 +682,12 @@ function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
   }
   return rootAgent;
 }
+__name(determineAgentForResumption, "determineAgentForResumption");
+function isWorkflowNodeEvent(event) {
+  var _a2;
+  return Boolean((_a2 = event.nodeInfo) == null ? void 0 : _a2.path);
+}
+__name(isWorkflowNodeEvent, "isWorkflowNodeEvent");
 function isRoutableLlmAgent(agentToRun) {
   let agent = agentToRun;
   while (agent) {
@@ -496,10 +701,12 @@ function isRoutableLlmAgent(agentToRun) {
   }
   return true;
 }
+__name(isRoutableLlmAgent, "isRoutableLlmAgent");
 function findEventByLastFunctionResponseId(events) {
   var _a2;
   return (_a2 = findMatchingFunctionCall(events)) != null ? _a2 : null;
 }
+__name(findEventByLastFunctionResponseId, "findEventByLastFunctionResponseId");
 function getAllToolsets(agent) {
   const toolsets = [];
   const visited = /* @__PURE__ */ new Set();
@@ -517,9 +724,20 @@ function getAllToolsets(agent) {
       traverse(sub);
     }
   }
+  __name(traverse, "traverse");
   traverse(agent);
   return toolsets;
 }
+__name(getAllToolsets, "getAllToolsets");
+function rejectReservedFunctionCalls(newMessage) {
+  const reserved = reservedFunctionCallName(newMessage);
+  if (reserved) {
+    throw new Error(
+      "A client message may not contain a '".concat(reserved, "' function call: it is ") + "raised by the framework, and can only be answered with a function response."
+    );
+  }
+}
+__name(rejectReservedFunctionCalls, "rejectReservedFunctionCalls");
 export {
   Runner,
   determineAgentForResumption,

package/dist/web/sessions/base_session_service.js

@@ -1,5 +1,7 @@
 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
@@ -7,7 +9,8 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { cloneDeep } from "lodash-es";
 import { State } from "./state.js";
-class BaseSessionService {
+import { carryDeltaStamps, shouldApplyDeltaWrite } from "./state_write_order.js";
+const _BaseSessionService = class _BaseSessionService {
   /**
    * Gets a session or creates one if it doesn't exist.
    *
@@ -61,26 +64,38 @@ class BaseSessionService {
       if (key.startsWith(State.TEMP_PREFIX)) {
         continue;
       }
-      session.state[key] = value;
+      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 = {};
+  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 = {};
+  const filteredState = /* @__PURE__ */ Object.create(null);
   for (const [key, value] of Object.entries(state)) {
     if (!key.startsWith(State.TEMP_PREFIX)) {
       filteredState[key] = value;
@@ -88,6 +103,7 @@ function trimTempState(state) {
   }
   return filteredState;
 }
+__name(trimTempState, "trimTempState");
 function mergeStates(appState = {}, userState = {}, sessionState = {}) {
   const merged = cloneDeep(sessionState);
   for (const [k, v] of Object.entries(appState)) {
@@ -98,6 +114,7 @@ function mergeStates(appState = {}, userState = {}, sessionState = {}) {
   }
   return merged;
 }
+__name(mergeStates, "mergeStates");
 export {
   BaseSessionService,
   mergeStates,

package/dist/web/sessions/database_session_service.js

@@ -19,6 +19,7 @@ var __spreadValues = (a, b) => {
   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
@@ -54,7 +55,8 @@ function isDatabaseConnectionString(uri) {
   }
   return uri.startsWith("postgres://") || uri.startsWith("postgresql://") || uri.startsWith("mysql://") || uri.startsWith("mariadb://") || uri.startsWith("mssql://") || uri.startsWith("sqlite://");
 }
-class DatabaseSessionService extends BaseSessionService {
+__name(isDatabaseConnectionString, "isDatabaseConnectionString");
+const _DatabaseSessionService = class _DatabaseSessionService extends BaseSessionService {
   constructor(connectionStringOrOptions) {
     super();
     this.initialized = false;
@@ -429,7 +431,9 @@ class DatabaseSessionService extends BaseSessionService {
     });
     return event;
   }
-}
+};
+__name(_DatabaseSessionService, "DatabaseSessionService");
+let DatabaseSessionService = _DatabaseSessionService;
 export {
   DatabaseSessionService,
   isDatabaseConnectionString

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

@@ -6,6 +6,7 @@ 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))
@@ -27,31 +28,55 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
  * 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 Promise.resolve().then(() => __toESM(require("@mikro-orm/postgresql"), 1));
+    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 Promise.resolve().then(() => __toESM(require("@mikro-orm/mysql"), 1));
+    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 Promise.resolve().then(() => __toESM(require("@mikro-orm/mariadb"), 1));
+    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 Promise.resolve().then(() => __toESM(require("@mikro-orm/sqlite"), 1));
+    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 Promise.resolve().then(() => __toESM(require("@mikro-orm/mssql"), 1));
+    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(uri));
+    throw new Error("Unsupported database URI: ".concat(redactUriPassword(uri)));
   }
   if (uri.startsWith("sqlite://")) {
     return {
@@ -66,10 +91,12 @@ async function getConnectionOptionsFromUri(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, {
@@ -89,6 +116,7 @@ async function validateDatabaseSchemaVersion(orm) {
   });
   await em.persist(newVersion).flush();
 }
+__name(validateDatabaseSchemaVersion, "validateDatabaseSchemaVersion");
 export {
   ensureDatabaseCreated,
   getConnectionOptionsFromUri,