@google/adk 0.2.4 → 0.3.0

package/dist/cjs/memory/in_memory_memory_service.js

@@ -67,7 +67,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/cjs/models/base_llm.js

@@ -73,16 +73,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/cjs/models/gemini_llm_connection.js

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

package/dist/cjs/models/google_llm.js

@@ -38,8 +38,6 @@ var import_llm_response = require("./llm_response.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
-const AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
 class Gemini extends import_base_llm.BaseLlm {
   /**
    * @param params The parameters for creating a Gemini instance.
@@ -252,7 +250,9 @@ class Gemini extends import_base_llm.BaseLlm {
       llmRequest.liveConnectConfig.systemInstruction = {
         role: "system",
         // TODO - b/425992518: validate type casting works well.
-        parts: [(0, import_genai.createPartFromText)(llmRequest.config.systemInstruction)]
+        parts: [
+          (0, import_genai.createPartFromText)(llmRequest.config.systemInstruction)
+        ]
       };
     }
     llmRequest.liveConnectConfig.tools = (_c = llmRequest.config) == null ? void 0 : _c.tools;

package/dist/cjs/plugins/base_plugin.js

@@ -48,13 +48,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;
   }
   /**
@@ -63,13 +64,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;
   }
   /**
@@ -78,13 +80,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;
   }
   /**
@@ -93,10 +96,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;
   }
   /**
@@ -105,13 +109,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;
   }
   /**
@@ -120,13 +125,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;
   }
   /**
@@ -136,13 +142,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;
   }
   /**
@@ -151,13 +158,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;
   }
   /**
@@ -166,15 +174,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;
   }
   /**
@@ -183,15 +192,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;
   }
   /**
@@ -200,33 +210,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/cjs/plugins/logging_plugin.js

@@ -44,7 +44,10 @@ class LoggingPlugin extends import_base_plugin.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: ${invocationContext.invocationId}`);
@@ -58,14 +61,18 @@ class LoggingPlugin extends import_base_plugin.BasePlugin {
     }
     return void 0;
   }
-  async beforeRunCallback({ invocationContext }) {
+  async beforeRunCallback({
+    invocationContext
+  }) {
     var _a;
     this.log("\u{1F3C3} INVOCATION STARTING");
     this.log(`   Invocation ID: ${invocationContext.invocationId}`);
     this.log(`   Starting Agent: ${(_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: ${event.id}`);
     this.log(`   Author: ${event.author}`);
@@ -86,14 +93,18 @@ class LoggingPlugin extends import_base_plugin.BasePlugin {
     }
     return void 0;
   }
-  async afterRunCallback({ invocationContext }) {
+  async afterRunCallback({
+    invocationContext
+  }) {
     var _a;
     this.log("\u2705 INVOCATION COMPLETED");
     this.log(`   Invocation ID: ${invocationContext.invocationId}`);
     this.log(`   Final Agent: ${(_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: ${callbackContext.agentName}`);
     this.log(`   Invocation ID: ${callbackContext.invocationId}`);
@@ -102,13 +113,18 @@ class LoggingPlugin extends import_base_plugin.BasePlugin {
     }
     return void 0;
   }
-  async afterAgentCallback({ agent, callbackContext }) {
+  async afterAgentCallback({
+    callbackContext
+  }) {
     this.log("\u{1F916} AGENT COMPLETED");
     this.log(`   Agent Name: ${callbackContext.agentName}`);
     this.log(`   Invocation ID: ${callbackContext.invocationId}`);
     return void 0;
   }
-  async beforeModelCallback({ callbackContext, llmRequest }) {
+  async beforeModelCallback({
+    callbackContext,
+    llmRequest
+  }) {
     var _a;
     this.log("\u{1F9E0} LLM REQUEST");
     this.log(`   Model: ${(_a = llmRequest.model) != null ? _a : "default"}`);
@@ -126,7 +142,10 @@ class LoggingPlugin extends import_base_plugin.BasePlugin {
     }
     return void 0;
   }
-  async afterModelCallback({ callbackContext, llmResponse }) {
+  async afterModelCallback({
+    callbackContext,
+    llmResponse
+  }) {
     this.log("\u{1F9E0} LLM RESPONSE");
     this.log(`   Agent: ${callbackContext.agentName}`);
     if (llmResponse.errorCode) {
@@ -142,11 +161,17 @@ class LoggingPlugin extends import_base_plugin.BasePlugin {
       }
     }
     if (llmResponse.usageMetadata) {
-      this.log(`   Token Usage - Input: ${llmResponse.usageMetadata.promptTokenCount}, Output: ${llmResponse.usageMetadata.candidatesTokenCount}`);
+      this.log(
+        `   Token Usage - Input: ${llmResponse.usageMetadata.promptTokenCount}, Output: ${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: ${tool.name}`);
     this.log(`   Agent: ${toolContext.agentName}`);
@@ -154,7 +179,11 @@ class LoggingPlugin extends import_base_plugin.BasePlugin {
     this.log(`   Arguments: ${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: ${tool.name}`);
     this.log(`   Agent: ${toolContext.agentName}`);
@@ -162,13 +191,21 @@ class LoggingPlugin extends import_base_plugin.BasePlugin {
     this.log(`   Result: ${this.formatArgs(result)}`);
     return void 0;
   }
-  async onModelErrorCallback({ callbackContext, llmRequest, error }) {
+  async onModelErrorCallback({
+    callbackContext,
+    error
+  }) {
     this.log("\u{1F9E0} LLM ERROR");
     this.log(`   Agent: ${callbackContext.agentName}`);
     this.log(`   Error: ${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: ${tool.name}`);
     this.log(`   Agent: ${toolContext.agentName}`);

package/dist/cjs/plugins/plugin_manager.js

@@ -107,19 +107,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 }),
@@ -129,7 +132,9 @@ class PluginManager {
   /**
    * Runs the `afterRunCallback` for all plugins.
    */
-  async runAfterRunCallback({ invocationContext }) {
+  async runAfterRunCallback({
+    invocationContext
+  }) {
     await this.runCallbacks(
       this.plugins,
       (plugin) => plugin.afterRunCallback({ invocationContext }),
@@ -139,7 +144,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 }),
@@ -149,7 +157,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 }),
@@ -159,7 +170,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 }),
@@ -169,7 +183,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 }),
@@ -179,31 +197,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 }),
@@ -213,7 +239,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 }),
@@ -223,12 +252,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/cjs/plugins/security_plugin.js

@@ -47,7 +47,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."
@@ -112,7 +112,10 @@ class SecurityPlugin extends import_base_plugin.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 */: