@google/adk 1.6.0 → 2.1.0

package/dist/esm/runner/runner.js

@@ -1,21 +1,32 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-import { createPartFromText } from "@google/genai";
+import { createPartFromText, Modality } from "@google/genai";
 import { context, trace } from "@opentelemetry/api";
-import { findMatchingFunctionCall } from "../agents/functions.js";
+import { isBaseAgent } from "../agents/base_agent.js";
+import { reservedFunctionCallName } from "../agents/framework_function_calls.js";
+import {
+  findMatchingFunctionCall,
+  getConflictingFunctionResponseAuthors
+} 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";
 import { ScopedArtifactService } from "../artifacts/scoped_artifact_service.js";
+import {
+  isSessionArtifactService
+} from "../artifacts/session_artifact_service.js";
 import {
   BuiltInCodeExecutor,
   isBuiltInCodeExecutor
@@ -30,12 +41,18 @@ import {
 import { isBaseToolset } from "../tools/base_toolset.js";
 import { logger } from "../utils/logger.js";
 import { isGemini2OrAbove } from "../utils/model_name.js";
-const RUNNER_SIGNATURE_SYMBOL = Symbol.for("google.adk.runner");
+import { stringifyWithRedactedInlineData } from "../utils/redact_inline_data.js";
+import {
+  asRunnableRoot,
+  runNodeAsInvocation
+} from "../workflow/run_node_as_invocation.js";
+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;
 }
+__name(isRunner, "isRunner");
 _a = RUNNER_SIGNATURE_SYMBOL;
-class Runner {
+const _Runner = class _Runner {
   /**
    * Creates a new Runner instance.
    *
@@ -52,7 +69,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]);
@@ -113,6 +130,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 {
@@ -135,7 +153,9 @@ 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;
@@ -149,7 +169,7 @@ 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,
@@ -159,10 +179,11 @@ 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,
+            a2aMetadata: runConfig.a2aMetadata,
             pluginManager: this.pluginManager,
             abortSignal: params.abortSignal
           });
@@ -182,9 +203,8 @@ 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) {
@@ -205,10 +225,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 = await this.pluginManager.runBeforeRunCallback({
               invocationContext
@@ -231,9 +253,7 @@ class Runner {
               }
               yield earlyExitEvent;
             } else {
-              for await (const event of invocationContext.agent.runAsync(
-                invocationContext
-              )) {
+              for await (const event of this.runRoot(invocationContext)) {
                 if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
                   return;
                 }
@@ -270,29 +290,42 @@ class Runner {
       );
     } finally {
       span.end();
-      const toolsets = getAllToolsets(this.agent);
+      const toolsets = isBaseAgent(this.agent) ? getAllToolsets(this.agent) : [];
       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.
+   */
+  async *runRoot(invocationContext) {
+    if (isBaseAgent(this.agent)) {
+      yield* requireAgent(invocationContext).runAsync(invocationContext);
+      return;
+    }
+    yield* runNodeAsInvocation(this.agent, invocationContext);
+  }
   /**
    * 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++) {
@@ -304,20 +337,16 @@ 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: {
@@ -367,27 +396,180 @@ 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);
   }
-  // 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.
+   */
+  async *runLive(params) {
+    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* runAsyncGeneratorWithOtelContext(
+        ctx,
+        this,
+        async function* () {
+          var _a3, _b2, _c2, _d2;
+          const session = 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 ? isSessionArtifactService(this.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,
+            a2aMetadata: runConfig.a2aMetadata,
+            pluginManager: this.pluginManager,
+            liveRequestQueue: params.liveRequestQueue,
+            abortSignal: params.abortSignal,
+            liveSessionResumptionHandle: params.liveSessionResumptionHandle
+          });
+          invocationContext.agent = this.determineAgentForResumption(
+            session,
+            agent
+          );
+          const beforeRunCallbackResponse = 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
+            });
+            await this.sessionService.appendEvent({
+              session,
+              event: earlyExitEvent
+            });
+            yield earlyExitEvent;
+            return;
+          }
+          for await (const event of requireAgent(invocationContext).runLive(
+            invocationContext
+          )) {
+            if ((_c2 = params.abortSignal) == null ? void 0 : _c2.aborted) {
+              return;
+            }
+            const modifiedEvent = 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)) {
+              await this.sessionService.appendEvent({
+                session,
+                event: eventToProcess
+              });
+            }
+            yield eventToProcess;
+          }
+          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);
   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;
     }
-    logger.warn(
-      `Function response from an unknown agent: ${event.author}, event id: ${event.id}`
-    );
+    if (!isWorkflowNodeEvent(event)) {
+      logger.warn(
+        `Function response from an unknown agent: ${event.author}, event id: ${event.id}`
+      );
+    }
   }
   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;
@@ -397,9 +579,11 @@ function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
     }
     const agent = rootAgent.findSubAgent(event2.author);
     if (!agent) {
-      logger.warn(
-        `Event from an unknown agent: ${event2.author}, event id: ${event2.id}`
-      );
+      if (!isWorkflowNodeEvent(event2)) {
+        logger.warn(
+          `Event from an unknown agent: ${event2.author}, event id: ${event2.id}`
+        );
+      }
       continue;
     }
     if (isRoutableLlmAgent(agent)) {
@@ -408,6 +592,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) {
@@ -421,10 +611,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();
@@ -442,9 +634,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 '${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/esm/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,6 +64,9 @@ class BaseSessionService {
       if (key.startsWith(State.TEMP_PREFIX)) {
         continue;
       }
+      if (!shouldApplyDeltaWrite(session.state, event.actions.stateDelta, key)) {
+        continue;
+      }
       Object.defineProperty(session.state, key, {
         value,
         writable: true,
@@ -69,7 +75,9 @@ class BaseSessionService {
       });
     }
   }
-}
+};
+__name(_BaseSessionService, "BaseSessionService");
+let BaseSessionService = _BaseSessionService;
 function trimTempDeltaState(event) {
   if (!event.actions || !event.actions.stateDelta) {
     return event;
@@ -81,9 +89,11 @@ function trimTempDeltaState(event) {
       filteredStateDelta[key] = value;
     }
   }
+  carryDeltaStamps(stateDelta, filteredStateDelta);
   event.actions.stateDelta = filteredStateDelta;
   return event;
 }
+__name(trimTempDeltaState, "trimTempDeltaState");
 function trimTempState(state) {
   const filteredState = /* @__PURE__ */ Object.create(null);
   for (const [key, value] of Object.entries(state)) {
@@ -93,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)) {
@@ -103,6 +114,7 @@ function mergeStates(appState = {}, userState = {}, sessionState = {}) {
   }
   return merged;
 }
+__name(mergeStates, "mergeStates");
 export {
   BaseSessionService,
   mergeStates,

package/dist/esm/sessions/database_session_service.js

@@ -1,41 +1,80 @@
 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;
   }
   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;
@@ -45,20 +84,17 @@ class DatabaseSessionService extends BaseSessionService {
       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;
@@ -393,8 +429,8 @@ class DatabaseSessionService extends BaseSessionService {
         });
         txEm.persist(newStorageEvent);
       }
-      await txEm.commit();
       storageSession.updateTime = new Date(event.timestamp);
+      txEm.persist([appStateModel, userStateModel, storageSession]);
       const newMergedState = mergeStates(
         appStateModel.state,
         userStateModel.state,
@@ -411,7 +447,9 @@ class DatabaseSessionService extends BaseSessionService {
     });
     return event;
   }
-}
+};
+__name(_DatabaseSessionService, "DatabaseSessionService");
+let DatabaseSessionService = _DatabaseSessionService;
 export {
   DatabaseSessionService,
   isDatabaseConnectionString