@google/adk 0.2.4 → 0.3.0

package/dist/web/memory/in_memory_memory_service.js

@@ -38,7 +38,9 @@ class InMemoryMemoryService {
         if (!wordsInEvent.size) {
           continue;
         }
-        const matchQuery = wordsInQuery.some((queryWord) => wordsInEvent.has(queryWord));
+        const matchQuery = wordsInQuery.some(
+          (queryWord) => wordsInEvent.has(queryWord)
+        );
         if (matchQuery) {
           response.memories.push({
             content: event.content,

package/dist/web/models/base_llm.js

@@ -43,16 +43,20 @@ class BaseLlm {
       llmRequest.contents.push({
         role: "user",
         parts: [
-          { text: "Handle the requests as specified in the System Instruction." }
+          {
+            text: "Handle the requests as specified in the System Instruction."
+          }
         ]
       });
     }
     if (((_a2 = llmRequest.contents[llmRequest.contents.length - 1]) == null ? void 0 : _a2.role) !== "user") {
       llmRequest.contents.push({
         role: "user",
-        parts: [{
-          text: "Continue processing previous requests as instructed. Exit or provide a summary if no more outputs are needed."
-        }]
+        parts: [
+          {
+            text: "Continue processing previous requests as instructed. Exit or provide a summary if no more outputs are needed."
+          }
+        ]
       });
     }
   }

package/dist/web/models/gemini_llm_connection.js

@@ -103,6 +103,7 @@ class GeminiLlmConnection {
     };
   }
   // TODO(b/425992518): GenAI SDK inconsistent API, missing methods.
+  // eslint-disable-next-line require-yield
   receive() {
     return __asyncGenerator(this, null, function* () {
       throw new Error("Not Implemented.");

package/dist/web/models/google_llm.js

@@ -36,14 +36,16 @@ var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")])
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createPartFromText, FinishReason, GoogleGenAI } from "@google/genai";
+import {
+  createPartFromText,
+  FinishReason,
+  GoogleGenAI
+} from "@google/genai";
 import { logger } from "../utils/logger.js";
 import { GoogleLLMVariant } from "../utils/variant_utils.js";
 import { BaseLlm } from "./base_llm.js";
 import { GeminiLlmConnection } from "./gemini_llm_connection.js";
 import { createLlmResponse } from "./llm_response.js";
-const AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
-const AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
 class Gemini extends BaseLlm {
   /**
    * @param params The parameters for creating a Gemini instance.
@@ -264,7 +266,9 @@ class Gemini extends BaseLlm {
       llmRequest.liveConnectConfig.systemInstruction = {
         role: "system",
         // TODO - b/425992518: validate type casting works well.
-        parts: [createPartFromText(llmRequest.config.systemInstruction)]
+        parts: [
+          createPartFromText(llmRequest.config.systemInstruction)
+        ]
       };
     }
     llmRequest.liveConnectConfig.tools = (_c = llmRequest.config) == null ? void 0 : _c.tools;

package/dist/web/plugins/base_plugin.js

@@ -19,13 +19,14 @@ class BasePlugin {
    * This callback helps logging and modifying the user message before the
    * runner starts the invocation.
    *
-   * @param invocationContext The context for the entire invocation.
-   * @param userMessage The message content input by user.
+   * @param params.invocationContext The context for the entire invocation.
+   * @param params.userMessage The message content input by user.
    * @returns An optional `Content` to be returned to the ADK. Returning a
    *     value to replace the user message. Returning `undefined` to proceed
    *     normally.
    */
-  async onUserMessageCallback({ invocationContext, userMessage }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async onUserMessageCallback(params) {
     return;
   }
   /**
@@ -34,13 +35,14 @@ class BasePlugin {
    * This is the first callback to be called in the lifecycle, ideal for global
    * setup or initialization tasks.
    *
-   * @param invocationContext The context for the entire invocation, containing
+   * @param params.invocationContext The context for the entire invocation, containing
    *     session information, the root agent, etc.
    * @returns An optional `Event` to be returned to the ADK. Returning a value
    *     to halt execution of the runner and ends the runner with that event.
    *     Return `undefined` to proceed normally.
    */
-  async beforeRunCallback({ invocationContext }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async beforeRunCallback(params) {
     return;
   }
   /**
@@ -49,13 +51,14 @@ class BasePlugin {
    * This is the ideal place to make modification to the event before the event
    * is handled by the underlying agent app.
    *
-   * @param invocationContext The context for the entire invocation.
-   * @param event The event raised by the runner.
+   * @param params.invocationContext The context for the entire invocation.
+   * @param params.event The event raised by the runner.
    * @returns An optional value. A non-`undefined` return may be used by the
    *     framework to modify or replace the response. Returning `undefined`
    *     allows the original response to be used.
    */
-  async onEventCallback({ invocationContext, event }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async onEventCallback(params) {
     return;
   }
   /**
@@ -64,10 +67,11 @@ class BasePlugin {
    * This is the final callback in the ADK lifecycle, suitable for cleanup,
    * final logging, or reporting tasks.
    *
-   * @param invocationContext The context for the entire invocation.
+   * @param params.invocationContext The context for the entire invocation.
    * @returns undefined
    */
-  async afterRunCallback({ invocationContext }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async afterRunCallback(params) {
     return;
   }
   /**
@@ -76,13 +80,14 @@ class BasePlugin {
    * This callback can be used for logging, setup, or to short-circuit the
    * agent's execution by returning a value.
    *
-   * @param agent The agent that is about to run.
-   * @param callbackContext The context for the agent invocation.
+   * @param params.agent The agent that is about to run.
+   * @param params.callbackContext The context for the agent invocation.
    * @returns An optional `Content` object. If a value is returned, it will
    *     bypass the agent's callbacks and its execution, and return this value
    *     directly. Returning `undefined` allows the agent to proceed normally.
    */
-  async beforeAgentCallback({ agent, callbackContext }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async beforeAgentCallback(params) {
     return;
   }
   /**
@@ -91,13 +96,14 @@ class BasePlugin {
    * This callback can be used to inspect, log, or modify the agent's final
    * result before it is returned.
    *
-   * @param agent The agent that has just run.
-   * @param callbackContext The context for the agent invocation.
+   * @param params.agent The agent that has just run.
+   * @param params.callbackContext The context for the agent invocation.
    * @returns An optional `Content` object. If a value is returned, it will
    *     replace the agent's original result. Returning `undefined` uses the
    *     original, unmodified result.
    */
-  async afterAgentCallback({ agent, callbackContext }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async afterAgentCallback(params) {
     return;
   }
   /**
@@ -107,13 +113,14 @@ class BasePlugin {
    * object. It can also be used to implement caching by returning a cached
    * `LlmResponse`, which would skip the actual model call.
    *
-   * @param callbackContext The context for the current agent call.
-   * @param llmRequest The prepared request object to be sent to the model.
+   * @param params.callbackContext The context for the current agent call.
+   * @param params.llmRequest The prepared request object to be sent to the model.
    * @returns An optional value. The interpretation of a non-`undefined`
    *     trigger an early exit and returns the response immediately. Returning
    *     `undefined` allows the LLM request to proceed normally.
    */
-  async beforeModelCallback({ callbackContext, llmRequest }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async beforeModelCallback(params) {
     return;
   }
   /**
@@ -122,13 +129,14 @@ class BasePlugin {
    * This is the ideal place to log model responses, collect metrics on token
    * usage, or perform post-processing on the raw `LlmResponse`.
    *
-   * @param callbackContext The context for the current agent call.
-   * @param llmResponse The response object received from the model.
+   * @param params.callbackContext The context for the current agent call.
+   * @param params.llmResponse The response object received from the model.
    * @returns An optional value. A non-`undefined` return may be used by the
    *     framework to modify or replace the response. Returning `undefined`
    *     allows the original response to be used.
    */
-  async afterModelCallback({ callbackContext, llmResponse }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async afterModelCallback(params) {
     return;
   }
   /**
@@ -137,15 +145,16 @@ class BasePlugin {
    * This callback provides an opportunity to handle model errors gracefully,
    * potentially providing alternative responses or recovery mechanisms.
    *
-   * @param callbackContext The context for the current agent call.
-   * @param llmRequest The request that was sent to the model when the error
+   * @param params.callbackContext The context for the current agent call.
+   * @param params.llmRequest The request that was sent to the model when the error
    *     occurred.
-   * @param error The exception that was raised during model execution.
+   * @param params.error The exception that was raised during model execution.
    * @returns An optional LlmResponse. If an LlmResponse is returned, it will be
    *     used instead of propagating the error. Returning `undefined` allows
    *     the original error to be raised.
    */
-  async onModelErrorCallback({ callbackContext, llmRequest, error }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async onModelErrorCallback(params) {
     return;
   }
   /**
@@ -154,15 +163,16 @@ class BasePlugin {
    * This callback is useful for logging tool usage, input validation, or
    * modifying the arguments before they are passed to the tool.
    *
-   * @param tool The tool instance that is about to be executed.
-   * @param toolArgs The dictionary of arguments to be used for invoking the
+   * @param params.tool The tool instance that is about to be executed.
+   * @param params.toolArgs The dictionary of arguments to be used for invoking the
    *     tool.
-   * @param toolContext The context specific to the tool execution.
+   * @param params.toolContext The context specific to the tool execution.
    * @returns An optional dictionary. If a dictionary is returned, it will stop
    *     the tool execution and return this response immediately. Returning
    *     `undefined` uses the original, unmodified arguments.
    */
-  async beforeToolCallback({ tool, toolArgs, toolContext }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async beforeToolCallback(params) {
     return;
   }
   /**
@@ -171,33 +181,45 @@ class BasePlugin {
    * This callback allows for inspecting, logging, or modifying the result
    * returned by a tool.
    *
-   * @param tool The tool instance that has just been executed.
-   * @param toolArgs The original arguments that were passed to the tool.
-   * @param toolContext The context specific to the tool execution.
-   * @param result The dictionary returned by the tool invocation.
+   * @param params.tool The tool instance that has just been executed.
+   * @param params.toolArgs The original arguments that were passed to the tool.
+   * @param params.toolContext The context specific to the tool execution.
+   * @param params.result The dictionary returned by the tool invocation.
    * @returns An optional dictionary. If a dictionary is returned, it will
    *     **replace** the original result from the tool. This allows for
    *     post-processing or altering tool outputs. Returning `undefined` uses
    *     the original, unmodified result.
    */
-  async afterToolCallback({ tool, toolArgs, toolContext, result }) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async afterToolCallback(params) {
     return;
   }
   /**
-   * Callback executed when a tool call encounters an error.
-   *
-   * This callback provides an opportunity to handle tool errors gracefully,
-   * potentially providing alternative responses or recovery mechanisms.
-   *
-   * @param tool The tool instance that encountered an error.
-   * @param toolArgs The arguments that were passed to the tool.
-   * @param toolContext The context specific to the tool execution.
-   * @param error The exception that was raised during tool execution.
-   * @returns An optional dictionary. If a dictionary is returned, it will be
-   *     used as the tool response instead of propagating the error. Returning
-   *     `undefined` allows the original error to be raised.
-   */
-  async onToolErrorCallback({ tool, toolArgs, toolContext, error }) {
+     * Callback executed when a tool call encounters an error.
+      tool: BaseTool;
+      toolArgs: Record<string, unknown>;
+      toolContext: ToolContext;
+      result: Record<string, unknown>;
+    }): Promise<Record<string, unknown> | undefined> {
+      return;
+    }
+  
+    /**
+     * Callback executed when a tool call encounters an error.
+     *
+     * This callback provides an opportunity to handle tool errors gracefully,
+     * potentially providing alternative responses or recovery mechanisms.
+     *
+     * @param params.tool The tool instance that encountered an error.
+     * @param params.toolArgs The arguments that were passed to the tool.
+     * @param params.toolContext The context specific to the tool execution.
+     * @param params.error The exception that was raised during tool execution.
+     * @returns An optional dictionary. If a dictionary is returned, it will be
+     *     used as the tool response instead of propagating the error. Returning
+     *     `undefined` allows the original error to be raised.
+     */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async onToolErrorCallback(params) {
     return;
   }
 }

package/dist/web/plugins/logging_plugin.js

@@ -3,7 +3,11 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getFunctionCalls, getFunctionResponses, isFinalResponse } from "../events/event.js";
+import {
+  getFunctionCalls,
+  getFunctionResponses,
+  isFinalResponse
+} from "../events/event.js";
 import { logger } from "../utils/logger.js";
 import { BasePlugin } from "./base_plugin.js";
 class LoggingPlugin extends BasePlugin {
@@ -15,7 +19,10 @@ class LoggingPlugin extends BasePlugin {
   constructor(name = "logging_plugin") {
     super(name);
   }
-  async onUserMessageCallback({ invocationContext, userMessage }) {
+  async onUserMessageCallback({
+    invocationContext,
+    userMessage
+  }) {
     var _a;
     this.log("\u{1F680} USER MESSAGE RECEIVED");
     this.log("   Invocation ID: ".concat(invocationContext.invocationId));
@@ -29,14 +36,18 @@ class LoggingPlugin extends BasePlugin {
     }
     return void 0;
   }
-  async beforeRunCallback({ invocationContext }) {
+  async beforeRunCallback({
+    invocationContext
+  }) {
     var _a;
     this.log("\u{1F3C3} INVOCATION STARTING");
     this.log("   Invocation ID: ".concat(invocationContext.invocationId));
     this.log("   Starting Agent: ".concat((_a = invocationContext.agent.name) != null ? _a : "Unknown"));
     return void 0;
   }
-  async onEventCallback({ invocationContext, event }) {
+  async onEventCallback({
+    event
+  }) {
     this.log("\u{1F4E2} EVENT YIELDED");
     this.log("   Event ID: ".concat(event.id));
     this.log("   Author: ".concat(event.author));
@@ -57,14 +68,18 @@ class LoggingPlugin extends BasePlugin {
     }
     return void 0;
   }
-  async afterRunCallback({ invocationContext }) {
+  async afterRunCallback({
+    invocationContext
+  }) {
     var _a;
     this.log("\u2705 INVOCATION COMPLETED");
     this.log("   Invocation ID: ".concat(invocationContext.invocationId));
     this.log("   Final Agent: ".concat((_a = invocationContext.agent.name) != null ? _a : "Unknown"));
     return void 0;
   }
-  async beforeAgentCallback({ agent, callbackContext }) {
+  async beforeAgentCallback({
+    callbackContext
+  }) {
     this.log("\u{1F916} AGENT STARTING");
     this.log("   Agent Name: ".concat(callbackContext.agentName));
     this.log("   Invocation ID: ".concat(callbackContext.invocationId));
@@ -73,13 +88,18 @@ class LoggingPlugin extends BasePlugin {
     }
     return void 0;
   }
-  async afterAgentCallback({ agent, callbackContext }) {
+  async afterAgentCallback({
+    callbackContext
+  }) {
     this.log("\u{1F916} AGENT COMPLETED");
     this.log("   Agent Name: ".concat(callbackContext.agentName));
     this.log("   Invocation ID: ".concat(callbackContext.invocationId));
     return void 0;
   }
-  async beforeModelCallback({ callbackContext, llmRequest }) {
+  async beforeModelCallback({
+    callbackContext,
+    llmRequest
+  }) {
     var _a;
     this.log("\u{1F9E0} LLM REQUEST");
     this.log("   Model: ".concat((_a = llmRequest.model) != null ? _a : "default"));
@@ -97,7 +117,10 @@ class LoggingPlugin extends BasePlugin {
     }
     return void 0;
   }
-  async afterModelCallback({ callbackContext, llmResponse }) {
+  async afterModelCallback({
+    callbackContext,
+    llmResponse
+  }) {
     this.log("\u{1F9E0} LLM RESPONSE");
     this.log("   Agent: ".concat(callbackContext.agentName));
     if (llmResponse.errorCode) {
@@ -113,11 +136,17 @@ class LoggingPlugin extends BasePlugin {
       }
     }
     if (llmResponse.usageMetadata) {
-      this.log("   Token Usage - Input: ".concat(llmResponse.usageMetadata.promptTokenCount, ", Output: ").concat(llmResponse.usageMetadata.candidatesTokenCount));
+      this.log(
+        "   Token Usage - Input: ".concat(llmResponse.usageMetadata.promptTokenCount, ", Output: ").concat(llmResponse.usageMetadata.candidatesTokenCount)
+      );
     }
     return void 0;
   }
-  async beforeToolCallback({ tool, toolArgs, toolContext }) {
+  async beforeToolCallback({
+    tool,
+    toolArgs,
+    toolContext
+  }) {
     this.log("\u{1F527} TOOL STARTING");
     this.log("   Tool Name: ".concat(tool.name));
     this.log("   Agent: ".concat(toolContext.agentName));
@@ -125,7 +154,11 @@ class LoggingPlugin extends BasePlugin {
     this.log("   Arguments: ".concat(this.formatArgs(toolArgs)));
     return void 0;
   }
-  async afterToolCallback({ tool, toolArgs, toolContext, result }) {
+  async afterToolCallback({
+    tool,
+    toolContext,
+    result
+  }) {
     this.log("\u{1F527} TOOL COMPLETED");
     this.log("   Tool Name: ".concat(tool.name));
     this.log("   Agent: ".concat(toolContext.agentName));
@@ -133,13 +166,21 @@ class LoggingPlugin extends BasePlugin {
     this.log("   Result: ".concat(this.formatArgs(result)));
     return void 0;
   }
-  async onModelErrorCallback({ callbackContext, llmRequest, error }) {
+  async onModelErrorCallback({
+    callbackContext,
+    error
+  }) {
     this.log("\u{1F9E0} LLM ERROR");
     this.log("   Agent: ".concat(callbackContext.agentName));
     this.log("   Error: ".concat(error));
     return void 0;
   }
-  async onToolErrorCallback({ tool, toolArgs, toolContext, error }) {
+  async onToolErrorCallback({
+    tool,
+    toolArgs,
+    toolContext,
+    error
+  }) {
     this.log("\u{1F527} TOOL ERROR");
     this.log("   Tool Name: ".concat(tool.name));
     this.log("   Agent: ".concat(toolContext.agentName));

package/dist/web/plugins/plugin_manager.js

@@ -78,19 +78,22 @@ class PluginManager {
   /**
    * Runs the `onUserMessageCallback` for all plugins.
    */
-  async runOnUserMessageCallback({ userMessage, invocationContext }) {
+  async runOnUserMessageCallback({
+    userMessage,
+    invocationContext
+  }) {
     return await this.runCallbacks(
       this.plugins,
-      (plugin) => plugin.onUserMessageCallback(
-        { userMessage, invocationContext }
-      ),
+      (plugin) => plugin.onUserMessageCallback({ userMessage, invocationContext }),
       "onUserMessageCallback"
     );
   }
   /**
    * Runs the `beforeRunCallback` for all plugins.
    */
-  async runBeforeRunCallback({ invocationContext }) {
+  async runBeforeRunCallback({
+    invocationContext
+  }) {
     return await this.runCallbacks(
       this.plugins,
       (plugin) => plugin.beforeRunCallback({ invocationContext }),
@@ -100,7 +103,9 @@ class PluginManager {
   /**
    * Runs the `afterRunCallback` for all plugins.
    */
-  async runAfterRunCallback({ invocationContext }) {
+  async runAfterRunCallback({
+    invocationContext
+  }) {
     await this.runCallbacks(
       this.plugins,
       (plugin) => plugin.afterRunCallback({ invocationContext }),
@@ -110,7 +115,10 @@ class PluginManager {
   /**
    * Runs the `onEventCallback` for all plugins.
    */
-  async runOnEventCallback({ invocationContext, event }) {
+  async runOnEventCallback({
+    invocationContext,
+    event
+  }) {
     return await this.runCallbacks(
       this.plugins,
       (plugin) => plugin.onEventCallback({ invocationContext, event }),
@@ -120,7 +128,10 @@ class PluginManager {
   /**
    * Runs the `beforeAgentCallback` for all plugins.
    */
-  async runBeforeAgentCallback({ agent, callbackContext }) {
+  async runBeforeAgentCallback({
+    agent,
+    callbackContext
+  }) {
     return await this.runCallbacks(
       this.plugins,
       (plugin) => plugin.beforeAgentCallback({ agent, callbackContext }),
@@ -130,7 +141,10 @@ class PluginManager {
   /**
    * Runs the `afterAgentCallback` for all plugins.
    */
-  async runAfterAgentCallback({ agent, callbackContext }) {
+  async runAfterAgentCallback({
+    agent,
+    callbackContext
+  }) {
     return await this.runCallbacks(
       this.plugins,
       (plugin) => plugin.afterAgentCallback({ agent, callbackContext }),
@@ -140,7 +154,11 @@ class PluginManager {
   /**
    * Runs the `beforeToolCallback` for all plugins.
    */
-  async runBeforeToolCallback({ tool, toolArgs, toolContext }) {
+  async runBeforeToolCallback({
+    tool,
+    toolArgs,
+    toolContext
+  }) {
     return await this.runCallbacks(
       this.plugins,
       (plugin) => plugin.beforeToolCallback({ tool, toolArgs, toolContext }),
@@ -150,31 +168,39 @@ class PluginManager {
   /**
    * Runs the `afterToolCallback` for all plugins.
    */
-  async runAfterToolCallback({ tool, toolArgs, toolContext, result }) {
+  async runAfterToolCallback({
+    tool,
+    toolArgs,
+    toolContext,
+    result
+  }) {
     return await this.runCallbacks(
       this.plugins,
-      (plugin) => plugin.afterToolCallback(
-        { tool, toolArgs, toolContext, result }
-      ),
+      (plugin) => plugin.afterToolCallback({ tool, toolArgs, toolContext, result }),
       "afterToolCallback"
     );
   }
   /**
    * Runs the `onModelErrorCallback` for all plugins.
    */
-  async runOnModelErrorCallback({ callbackContext, llmRequest, error }) {
+  async runOnModelErrorCallback({
+    callbackContext,
+    llmRequest,
+    error
+  }) {
     return await this.runCallbacks(
       this.plugins,
-      (plugin) => plugin.onModelErrorCallback(
-        { callbackContext, llmRequest, error }
-      ),
+      (plugin) => plugin.onModelErrorCallback({ callbackContext, llmRequest, error }),
       "onModelErrorCallback"
     );
   }
   /**
    * Runs the `beforeModelCallback` for all plugins.
    */
-  async runBeforeModelCallback({ callbackContext, llmRequest }) {
+  async runBeforeModelCallback({
+    callbackContext,
+    llmRequest
+  }) {
     return await this.runCallbacks(
       this.plugins,
       (plugin) => plugin.beforeModelCallback({ callbackContext, llmRequest }),
@@ -184,7 +210,10 @@ class PluginManager {
   /**
    * Runs the `afterModelCallback` for all plugins.
    */
-  async runAfterModelCallback({ callbackContext, llmResponse }) {
+  async runAfterModelCallback({
+    callbackContext,
+    llmResponse
+  }) {
     return await this.runCallbacks(
       this.plugins,
       (plugin) => plugin.afterModelCallback({ callbackContext, llmResponse }),
@@ -194,12 +223,15 @@ class PluginManager {
   /**
    * Runs the `onToolErrorCallback` for all plugins.
    */
-  async runOnToolErrorCallback({ tool, toolArgs, toolContext, error }) {
+  async runOnToolErrorCallback({
+    tool,
+    toolArgs,
+    toolContext,
+    error
+  }) {
     return await this.runCallbacks(
       this.plugins,
-      (plugin) => plugin.onToolErrorCallback(
-        { tool, toolArgs, toolContext, error }
-      ),
+      (plugin) => plugin.onToolErrorCallback({ tool, toolArgs, toolContext, error }),
       "onToolErrorCallback"
     );
   }

package/dist/web/plugins/security_plugin.js

@@ -14,7 +14,7 @@ var PolicyOutcome = /* @__PURE__ */ ((PolicyOutcome2) => {
   return PolicyOutcome2;
 })(PolicyOutcome || {});
 class InMemoryPolicyEngine {
-  async evaluate(context) {
+  async evaluate() {
     return Promise.resolve({
       outcome: "ALLOW" /* ALLOW */,
       reason: "For prototyping purpose, all tool calls are allowed."
@@ -79,7 +79,10 @@ class SecurityPlugin extends BasePlugin {
     toolArgs,
     toolContext
   }) {
-    const policyCheckResult = await this.policyEngine.evaluate({ tool, toolArgs });
+    const policyCheckResult = await this.policyEngine.evaluate({
+      tool,
+      toolArgs
+    });
     this.setToolCallCheckState(toolContext, policyCheckResult.outcome);
     switch (policyCheckResult.outcome) {
       case "DENY" /* DENY */: