@google/adk 2.4.0 → 2.5.0

package/dist/cjs/runner/runner.js

@@ -33,7 +33,6 @@ __export(runner_exports, {
 });
 module.exports = __toCommonJS(runner_exports);
 var import_genai = require("@google/genai");
-var import_api = require("@opentelemetry/api");
 var import_base_agent = require("../agents/base_agent.js");
 var import_framework_function_calls = require("../agents/framework_function_calls.js");
 var import_functions = require("../agents/functions.js");
@@ -48,11 +47,13 @@ var import_event = require("../events/event.js");
 var import_event_actions = require("../events/event_actions.js");
 var import_internal_metadata = require("../events/internal_metadata.js");
 var import_plugin_manager = require("../plugins/plugin_manager.js");
-var import_tracing = require("../telemetry/tracing.js");
+var import_instrumentation = require("../telemetry/api/instrumentation.js");
 var import_base_toolset = require("../tools/base_toolset.js");
+var import_error_utils = require("../utils/error_utils.js");
 var import_logger = require("../utils/logger.js");
 var import_model_name = require("../utils/model_name.js");
 var import_redact_inline_data = require("../utils/redact_inline_data.js");
+var import_workflow = require("../workflow/index.js");
 var import_run_node_as_invocation = require("../workflow/run_node_as_invocation.js");
 /**
  * @license
@@ -60,6 +61,10 @@ var import_run_node_as_invocation = require("../workflow/run_node_as_invocation.
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
+const TOOLSET_CLEANUP_TIMEOUT_MS = 1e4;
+const TOOLSET_CLEANUP_TIMEOUT_SYMBOL = /* @__PURE__ */ Symbol(
+  "google.adk.runner.toolsetCleanupTimeout"
+);
 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;
@@ -159,59 +164,57 @@ const _Runner = class _Runner {
       newMessage.role = "user";
     }
     rejectReservedFunctionCalls(newMessage);
-    const span = import_tracing.tracer.startSpan("invocation");
-    const ctx = import_api.trace.setSpan(import_api.context.active(), span);
+    const runnerCtx = this;
     try {
-      yield* (0, import_tracing.runAsyncGeneratorWithOtelContext)(
-        ctx,
-        this,
+      yield* (0, import_instrumentation.recordInvocation)(
+        { entrypoint: this.agent, sessionId, runConfig },
         async function* () {
-          var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-          const session = await this.resolveSession(userId, sessionId);
+          var _a2, _b, _c, _d, _e;
+          const session = await runnerCtx.resolveSession(userId, sessionId);
           if ((_a2 = params.abortSignal) == null ? void 0 : _a2.aborted) {
             return;
           }
           if (!session) {
-            if (!this.appName) {
+            if (!runnerCtx.appName) {
               throw new Error(
                 `Session lookup failed: appName must be provided in runner constructor (or via app.name)`
               );
             }
             throw new Error(
-              `Session not found: ${sessionId} (appName=${this.appName}, userId=${userId})`
+              `Session not found: ${sessionId} (appName=${runnerCtx.appName}, userId=${userId})`
             );
           }
-          if (runConfig.supportCfc && (0, import_llm_agent.isLlmAgent)(this.agent)) {
-            const modelName = this.agent.canonicalModel.model;
+          if (runConfig.supportCfc && (0, import_llm_agent.isLlmAgent)(runnerCtx.agent)) {
+            const modelName = runnerCtx.agent.canonicalModel.model;
             if (!(0, import_model_name.isGemini2OrAbove)(modelName)) {
               throw new Error(
-                `CFC is not supported for model: ${modelName} in agent: ${this.agent.name}`
+                `CFC is not supported for model: ${modelName} in agent: ${runnerCtx.agent.name}`
               );
             }
-            if (!(0, import_built_in_code_executor.isBuiltInCodeExecutor)(this.agent.codeExecutor)) {
-              this.agent.codeExecutor = new import_built_in_code_executor.BuiltInCodeExecutor();
+            if (!(0, import_built_in_code_executor.isBuiltInCodeExecutor)(runnerCtx.agent.codeExecutor)) {
+              runnerCtx.agent.codeExecutor = new import_built_in_code_executor.BuiltInCodeExecutor();
             }
           }
           const invocationContext = new import_invocation_context.InvocationContext({
-            artifactService: this.artifactService ? (0, import_session_artifact_service.isSessionArtifactService)(this.artifactService) ? this.artifactService : new import_scoped_artifact_service.ScopedArtifactService(
-              this.artifactService,
-              this.appName,
+            artifactService: runnerCtx.artifactService ? (0, import_session_artifact_service.isSessionArtifactService)(runnerCtx.artifactService) ? runnerCtx.artifactService : new import_scoped_artifact_service.ScopedArtifactService(
+              runnerCtx.artifactService,
+              runnerCtx.appName,
               userId,
               sessionId
             ) : void 0,
-            sessionService: this.sessionService,
-            memoryService: this.memoryService,
-            credentialService: this.credentialService,
+            sessionService: runnerCtx.sessionService,
+            memoryService: runnerCtx.memoryService,
+            credentialService: runnerCtx.credentialService,
             invocationId: (0, import_invocation_context.newInvocationContextId)(),
-            agent: (0, import_base_agent.isBaseAgent)(this.agent) ? this.agent : void 0,
+            agent: (0, import_base_agent.isBaseAgent)(runnerCtx.agent) ? runnerCtx.agent : void 0,
             session,
             userContent: newMessage,
             runConfig,
             a2aMetadata: runConfig.a2aMetadata,
-            pluginManager: this.pluginManager,
+            pluginManager: runnerCtx.pluginManager,
             abortSignal: params.abortSignal
           });
-          const pluginUserMessage = await this.pluginManager.runOnUserMessageCallback({
+          const pluginUserMessage = await runnerCtx.pluginManager.runOnUserMessageCallback({
             userMessage: newMessage,
             invocationContext
           });
@@ -226,7 +229,7 @@ const _Runner = class _Runner {
               throw new Error("No parts in the newMessage.");
             }
             if (runConfig.saveInputBlobsAsArtifacts) {
-              newMessage = await this.saveArtifacts(
+              newMessage = await runnerCtx.saveArtifacts(
                 invocationContext.artifactService,
                 invocationContext.invocationId,
                 newMessage
@@ -235,7 +238,7 @@ const _Runner = class _Runner {
                 return;
               }
             }
-            await this.sessionService.appendEvent({
+            await runnerCtx.sessionService.appendEvent({
               session,
               event: (0, import_event.createEvent)({
                 invocationId: invocationContext.invocationId,
@@ -250,83 +253,137 @@ const _Runner = class _Runner {
               return;
             }
           }
-          if ((0, import_base_agent.isBaseAgent)(this.agent)) {
-            invocationContext.agent = this.determineAgentForResumption(
+          if ((0, import_base_agent.isBaseAgent)(runnerCtx.agent)) {
+            invocationContext.agent = runnerCtx.determineAgentForResumption(
               session,
-              this.agent
+              runnerCtx.agent
             );
           }
           if (newMessage) {
-            const beforeRunCallbackResponse = await this.pluginManager.runBeforeRunCallback({
-              invocationContext
-            });
-            if ((_f = params.abortSignal) == null ? void 0 : _f.aborted) {
-              return;
-            }
-            if (beforeRunCallbackResponse) {
-              const earlyExitEvent = (0, import_event.createEvent)({
-                invocationId: invocationContext.invocationId,
-                author: "model",
-                content: beforeRunCallbackResponse
-              });
-              await this.sessionService.appendEvent({
-                session,
-                event: earlyExitEvent
-              });
-              if ((_g = params.abortSignal) == null ? void 0 : _g.aborted) {
-                return;
-              }
-              yield earlyExitEvent;
-            } else {
-              let abortSealed = false;
-              const sealAbortedInvocation = /* @__PURE__ */ __name(() => {
-                abortSealed = true;
-                return this.synthesizeAbortEvents(invocationContext);
-              }, "sealAbortedInvocation");
-              try {
-                for await (const event of this.runRoot(invocationContext)) {
-                  if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
-                    break;
-                  }
-                  const outputEvent = await this.processAndAppendEvent(
-                    invocationContext,
-                    event
-                  );
-                  if ((_i = params.abortSignal) == null ? void 0 : _i.aborted) {
-                    break;
-                  }
-                  yield outputEvent;
-                }
-                if ((_j = params.abortSignal) == null ? void 0 : _j.aborted) {
-                  for (const abortEvent of await sealAbortedInvocation()) {
-                    yield abortEvent;
-                  }
-                  return;
-                }
-              } finally {
-                if (((_k = params.abortSignal) == null ? void 0 : _k.aborted) && !abortSealed) {
-                  try {
-                    await sealAbortedInvocation();
-                  } catch (e) {
-                    import_logger.logger.error(
-                      `Failed to seal aborted invocation ${invocationContext.invocationId}.`,
-                      e
-                    );
-                  }
-                }
-              }
-              await this.pluginManager.runAfterRunCallback({ invocationContext });
-              if ((_l = params.abortSignal) == null ? void 0 : _l.aborted) {
-                return;
-              }
-            }
+            yield* runnerCtx.runWithPluginLifecycle(
+              invocationContext,
+              () => runnerCtx.runAsyncWithPlugins(invocationContext)
+            );
           }
         }
       );
     } finally {
-      span.end();
-      const toolsets = (0, import_base_agent.isBaseAgent)(this.agent) ? getAllToolsets(this.agent) : [];
-      await Promise.allSettled(toolsets.map((t) => t.close()));
+      await this.close();
+    }
+  }
+  /**
+   * Closes the runner and cleans up all toolsets reachable from the root agent
+   * or workflow.
+   */
+  async close() {
+    await cleanupToolsets(collectToolsets(this.agent));
+  }
+  async *runAsyncWithPlugins(invocationContext) {
+    var _a2, _b, _c, _d, _e, _f;
+    const beforeRunCallbackResponse = await this.pluginManager.runBeforeRunCallback({
+      invocationContext
+    });
+    if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+      return;
+    }
+    if (beforeRunCallbackResponse) {
+      const earlyExitEvent = (0, import_event.createEvent)({
+        invocationId: invocationContext.invocationId,
+        author: "model",
+        content: beforeRunCallbackResponse
+      });
+      await this.sessionService.appendEvent({
+        session: invocationContext.session,
+        event: earlyExitEvent
+      });
+      if ((_b = invocationContext.abortSignal) == null ? void 0 : _b.aborted) {
+        return;
+      }
+      yield earlyExitEvent;
+    } else {
+      let abortSealed = false;
+      const sealAbortedInvocation = /* @__PURE__ */ __name(() => {
+        abortSealed = true;
+        return this.synthesizeAbortEvents(invocationContext);
+      }, "sealAbortedInvocation");
+      try {
+        for await (const event of this.runRoot(invocationContext)) {
+          if ((_c = invocationContext.abortSignal) == null ? void 0 : _c.aborted) {
+            break;
+          }
+          const outputEvent = await this.processAndAppendEvent(
+            invocationContext,
+            event
+          );
+          if ((_d = invocationContext.abortSignal) == null ? void 0 : _d.aborted) {
+            break;
+          }
+          yield outputEvent;
+        }
+        if ((_e = invocationContext.abortSignal) == null ? void 0 : _e.aborted) {
+          for (const abortEvent of await sealAbortedInvocation()) {
+            yield abortEvent;
+          }
+          return;
+        }
+      } finally {
+        if (((_f = invocationContext.abortSignal) == null ? void 0 : _f.aborted) && !abortSealed) {
+          try {
+            await sealAbortedInvocation();
+          } catch (e) {
+            import_logger.logger.error(
+              `Failed to seal aborted invocation ${invocationContext.invocationId}.`,
+              e
+            );
+          }
+        }
+      }
+    }
+  }
+  /** Finalizes a started run, including when its consumer closes the iterator. */
+  async *runWithPluginLifecycle(invocationContext, execute) {
+    let failed = false;
+    let completed = false;
+    try {
+      yield* execute();
+      completed = true;
+    } catch (error) {
+      if (!(0, import_error_utils.isInvocationCancellation)(error, invocationContext.abortSignal)) {
+        failed = true;
+        await this.notifyRunError(invocationContext, error);
+      }
+      throw error;
+    } finally {
+      if (!failed) {
+        await this.finishRun(invocationContext, !completed);
+      }
+    }
+  }
+  async finishRun(invocationContext, closingEarly) {
+    try {
+      await this.pluginManager.runAfterRunCallback({ invocationContext });
+    } catch (error) {
+      await this.notifyRunError(invocationContext, error);
+      if (!closingEarly) {
+        throw error;
+      }
+      import_logger.logger.error(
+        `afterRunCallback failed while closing invocation ${invocationContext.invocationId}.`,
+        error
+      );
+    }
+  }
+  async notifyRunError(invocationContext, error) {
+    try {
+      await this.pluginManager.runOnRunErrorCallback({
+        invocationContext,
+        error: (0, import_error_utils.toError)(error)
+      });
+    } catch (callbackError) {
+      import_logger.logger.error(
+        "Run error notification failed; preserving the original error.",
+        callbackError
+      );
     }
   }
   /**
@@ -517,6 +574,7 @@ const _Runner = class _Runner {
       throw new Error("runLive is only supported for agents.");
     }
     const agent = this.agent;
+    const { sessionId } = params;
     const runConfig = (0, import_run_config.createRunConfig)(params.runConfig);
     if (!((_a2 = runConfig.responseModalities) == null ? void 0 : _a2.length)) {
       runConfig.responseModalities = [import_genai.Modality.AUDIO];
@@ -527,92 +585,92 @@ const _Runner = class _Runner {
       }
       (_d = runConfig.inputAudioTranscription) != null ? _d : runConfig.inputAudioTranscription = {};
     }
-    const span = import_tracing.tracer.startSpan("invocation");
-    const ctx = import_api.trace.setSpan(import_api.context.active(), span);
-    try {
-      yield* (0, import_tracing.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 import_invocation_context.InvocationContext({
-            artifactService: this.artifactService ? (0, import_session_artifact_service.isSessionArtifactService)(this.artifactService) ? this.artifactService : new import_scoped_artifact_service.ScopedArtifactService(
-              this.artifactService,
-              this.appName,
-              params.userId,
-              params.sessionId
-            ) : void 0,
-            sessionService: this.sessionService,
-            memoryService: this.memoryService,
-            credentialService: this.credentialService,
-            invocationId: (0, import_invocation_context.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 = (0, import_event.createEvent)({
-              invocationId: invocationContext.invocationId,
-              author: "model",
-              content: beforeRunCallbackResponse
-            });
-            await this.sessionService.appendEvent({
-              session,
-              event: earlyExitEvent
-            });
-            yield earlyExitEvent;
-            return;
-          }
-          for await (const event of (0, import_invocation_context.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 ? withInternalMetadataOf(event, modifiedEvent) : event;
-            if (!eventToProcess.partial && !isLiveModelMediaEventWithInlineData(eventToProcess)) {
-              await this.sessionService.appendEvent({
-                session,
-                event: eventToProcess
-              });
-            }
-            yield eventToProcess;
-          }
-          await this.pluginManager.runAfterRunCallback({ invocationContext });
+    const runnerCtx = this;
+    yield* (0, import_instrumentation.recordInvocation)(
+      { entrypoint: agent, sessionId, runConfig },
+      async function* () {
+        var _a3;
+        const session = await runnerCtx.sessionService.getOrCreateSession({
+          appName: runnerCtx.appName,
+          userId: params.userId,
+          sessionId: params.sessionId
+        });
+        if ((_a3 = params.abortSignal) == null ? void 0 : _a3.aborted) {
+          return;
         }
-      );
-    } finally {
-      span.end();
+        const invocationContext = new import_invocation_context.InvocationContext({
+          artifactService: runnerCtx.artifactService ? (0, import_session_artifact_service.isSessionArtifactService)(runnerCtx.artifactService) ? runnerCtx.artifactService : new import_scoped_artifact_service.ScopedArtifactService(
+            runnerCtx.artifactService,
+            runnerCtx.appName,
+            params.userId,
+            params.sessionId
+          ) : void 0,
+          sessionService: runnerCtx.sessionService,
+          memoryService: runnerCtx.memoryService,
+          credentialService: runnerCtx.credentialService,
+          invocationId: (0, import_invocation_context.newInvocationContextId)(),
+          agent,
+          session,
+          runConfig,
+          a2aMetadata: runConfig.a2aMetadata,
+          pluginManager: runnerCtx.pluginManager,
+          liveRequestQueue: params.liveRequestQueue,
+          abortSignal: params.abortSignal,
+          liveSessionResumptionHandle: params.liveSessionResumptionHandle
+        });
+        invocationContext.agent = runnerCtx.determineAgentForResumption(
+          session,
+          agent
+        );
+        yield* runnerCtx.runWithPluginLifecycle(
+          invocationContext,
+          () => runnerCtx.runLiveWithPlugins(invocationContext)
+        );
+      }
+    );
+  }
+  async *runLiveWithPlugins(invocationContext) {
+    var _a2, _b, _c;
+    const beforeRunCallbackResponse = await this.pluginManager.runBeforeRunCallback({
+      invocationContext
+    });
+    if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+      return;
+    }
+    if (beforeRunCallbackResponse) {
+      const earlyExitEvent = (0, import_event.createEvent)({
+        invocationId: invocationContext.invocationId,
+        author: "model",
+        content: beforeRunCallbackResponse
+      });
+      await this.sessionService.appendEvent({
+        session: invocationContext.session,
+        event: earlyExitEvent
+      });
+      yield earlyExitEvent;
+      return;
+    }
+    for await (const event of (0, import_invocation_context.requireAgent)(invocationContext).runLive(
+      invocationContext
+    )) {
+      if ((_b = invocationContext.abortSignal) == null ? void 0 : _b.aborted) {
+        return;
+      }
+      const modifiedEvent = await this.pluginManager.runOnEventCallback({
+        invocationContext,
+        event
+      });
+      if ((_c = invocationContext.abortSignal) == null ? void 0 : _c.aborted) {
+        return;
+      }
+      const eventToProcess = modifiedEvent ? withInternalMetadataOf(event, modifiedEvent) : event;
+      if (!eventToProcess.partial && !isLiveModelMediaEventWithInlineData(eventToProcess)) {
+        await this.sessionService.appendEvent({
+          session: invocationContext.session,
+          event: eventToProcess
+        });
+      }
+      yield eventToProcess;
     }
   }
 };
@@ -715,28 +773,87 @@ function findEventByLastFunctionResponseId(events) {
   return (_a2 = (0, import_functions.findMatchingFunctionCall)(events)) != null ? _a2 : null;
 }
 __name(findEventByLastFunctionResponseId, "findEventByLastFunctionResponseId");
-function getAllToolsets(agent) {
-  const toolsets = [];
+function collectToolsets(root) {
+  const toolsets = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   function traverse(curr) {
-    if (visited.has(curr)) return;
+    if (visited.has(curr)) {
+      return;
+    }
     visited.add(curr);
     if ((0, import_llm_agent.isLlmAgent)(curr)) {
       for (const tool of curr.tools) {
         if ((0, import_base_toolset.isBaseToolset)(tool)) {
-          toolsets.push(tool);
+          toolsets.add(tool);
         }
       }
     }
-    for (const sub of curr.subAgents) {
-      traverse(sub);
+    if ((0, import_base_agent.isBaseAgent)(curr)) {
+      for (const sub of curr.subAgents) {
+        traverse(sub);
+      }
+    }
+    if ((0, import_workflow.isWorkflow)(curr) && curr.graph) {
+      for (const node of curr.graph.nodes) {
+        traverse(node);
+      }
+    }
+    if ((0, import_workflow.isParallelWorker)(curr)) {
+      traverse(curr.inner);
     }
   }
   __name(traverse, "traverse");
-  traverse(agent);
+  traverse(root);
   return toolsets;
 }
-__name(getAllToolsets, "getAllToolsets");
+__name(collectToolsets, "collectToolsets");
+function formatToolsetCloseError(err) {
+  const formatted = (0, import_error_utils.formatError)(err);
+  if (formatted !== "[object Object]") {
+    return formatted;
+  }
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return formatted;
+  }
+}
+__name(formatToolsetCloseError, "formatToolsetCloseError");
+async function cleanupToolsets(toolsets) {
+  await Promise.allSettled(
+    [...toolsets].map(async (toolset) => {
+      var _a2;
+      const toolsetName = ((_a2 = toolset.constructor) == null ? void 0 : _a2.name) || "BaseToolset";
+      let timeoutId;
+      try {
+        import_logger.logger.debug(`Closing toolset: ${toolsetName}`);
+        const result = await Promise.race([
+          toolset.close().then(() => void 0),
+          new Promise((resolve) => {
+            timeoutId = setTimeout(
+              () => resolve(TOOLSET_CLEANUP_TIMEOUT_SYMBOL),
+              TOOLSET_CLEANUP_TIMEOUT_MS
+            );
+          })
+        ]);
+        if (result === TOOLSET_CLEANUP_TIMEOUT_SYMBOL) {
+          import_logger.logger.warn(`Toolset ${toolsetName} cleanup timed out`);
+        } else {
+          import_logger.logger.debug(`Successfully closed toolset: ${toolsetName}`);
+        }
+      } catch (e) {
+        import_logger.logger.error(
+          `Error closing toolset ${toolsetName}: ${formatToolsetCloseError(e)}`
+        );
+      } finally {
+        if (timeoutId !== void 0) {
+          clearTimeout(timeoutId);
+        }
+      }
+    })
+  );
+}
+__name(cleanupToolsets, "cleanupToolsets");
 function rejectReservedFunctionCalls(newMessage) {
   const reserved = (0, import_framework_function_calls.reservedFunctionCallName)(newMessage);
   if (reserved) {

package/dist/cjs/sessions/base_session_service.js

@@ -71,8 +71,8 @@ const _BaseSessionService = class _BaseSessionService {
     if (event.partial) {
       return event;
     }
-    event = trimTempDeltaState(event);
     this.updateSessionState({ session, event });
+    event = trimTempDeltaState(event);
     upsertSessionEvent(session, event);
     return event;
   }
@@ -86,9 +86,6 @@ const _BaseSessionService = class _BaseSessionService {
       return;
     }
     for (const [key, value] of Object.entries(event.actions.stateDelta)) {
-      if (key.startsWith(import_state.State.TEMP_PREFIX)) {
-        continue;
-      }
       if (!(0, import_state_write_order.shouldApplyDeltaWrite)(session.state, event.actions.stateDelta, key)) {
         continue;
       }