@google/adk 0.1.0

package/dist/web/models/registry.js

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from "../utils/logger.js";
+import { Gemini } from "./google_llm.js";
+class LRUCache {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const item = this.cache.get(key);
+    if (item) {
+      this.cache.delete(key);
+      this.cache.set(key, item);
+    }
+    return item;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      const lruKey = this.cache.keys().next().value;
+      if (lruKey !== void 0) {
+        this.cache.delete(lruKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+}
+const _LLMRegistry = class _LLMRegistry {
+  /**
+   * Creates a new LLM instance.
+   * @param model The model name.
+   * @returns The LLM instance.
+   */
+  static newLlm(model) {
+    return new (_LLMRegistry.resolve(model))(model);
+  }
+  static _register(modelNameRegex, llmCls) {
+    if (_LLMRegistry.llmRegistryDict.has(modelNameRegex)) {
+      logger.info(
+        "Updating LLM class for ".concat(modelNameRegex, " from ").concat(_LLMRegistry.llmRegistryDict.get(modelNameRegex), " to ").concat(llmCls)
+      );
+    }
+    _LLMRegistry.llmRegistryDict.set(modelNameRegex, llmCls);
+  }
+  /**
+   * Registers a new LLM class.
+   * @param llmCls The class that implements the model.
+   */
+  static register(llmCls) {
+    for (const regex of llmCls.supportedModels) {
+      _LLMRegistry._register(regex, llmCls);
+    }
+  }
+  /**
+   * Resolves the model to a BaseLlm subclass.
+   * @param model The model name.
+   * @returns The BaseLlm subclass.
+   * @throws If the model is not found.
+   */
+  static resolve(model) {
+    const cachedLlm = _LLMRegistry.resolveCache.get(model);
+    if (cachedLlm) {
+      return cachedLlm;
+    }
+    for (const [regex, llmClass] of _LLMRegistry.llmRegistryDict.entries()) {
+      const pattern = new RegExp(
+        "^".concat(regex instanceof RegExp ? regex.source : regex, "$"),
+        regex instanceof RegExp ? regex.flags : void 0
+      );
+      if (pattern.test(model)) {
+        _LLMRegistry.resolveCache.set(model, llmClass);
+        return llmClass;
+      }
+    }
+    throw new Error("Model ".concat(model, " not found."));
+  }
+};
+/**
+ * Key is the regex that matches the model name.
+ * Value is the class that implements the model.
+ */
+_LLMRegistry.llmRegistryDict = /* @__PURE__ */ new Map();
+_LLMRegistry.resolveCache = new LRUCache(32);
+let LLMRegistry = _LLMRegistry;
+LLMRegistry.register(Gemini);
+export {
+  LLMRegistry
+};

package/dist/web/plugins/base_plugin.js

@@ -0,0 +1,206 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BasePlugin {
+  /**
+   * Initializes the plugin.
+   *
+   * @param name A unique identifier for this plugin instance.
+   */
+  constructor(name) {
+    this.name = name;
+  }
+  /**
+   * Callback executed when a user message is received before an invocation
+   * starts.
+   *
+   * 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.
+   * @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 }) {
+    return;
+  }
+  /**
+   * Callback executed before the ADK runner runs.
+   *
+   * 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
+   *     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 }) {
+    return;
+  }
+  /**
+   * Callback executed after an event is yielded from runner.
+   *
+   * 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.
+   * @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 }) {
+    return;
+  }
+  /**
+   * Callback executed after an ADK runner run has completed.
+   *
+   * 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.
+   * @returns undefined
+   */
+  async afterRunCallback({ invocationContext }) {
+    return;
+  }
+  /**
+   * Callback executed before an agent's primary logic is invoked.
+   *
+   * 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.
+   * @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 }) {
+    return;
+  }
+  /**
+   * Callback executed after an agent's primary logic has completed.
+   *
+   * 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.
+   * @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 }) {
+    return;
+  }
+  /**
+   * Callback executed before a request is sent to the model.
+   *
+   * This provides an opportunity to inspect, log, or modify the `LlmRequest`
+   * 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.
+   * @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 }) {
+    return;
+  }
+  /**
+   * Callback executed after a response is received from the model.
+   *
+   * 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.
+   * @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 }) {
+    return;
+  }
+  /**
+   * Callback executed when a model call encounters an error.
+   *
+   * 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
+   *     occurred.
+   * @param 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 }) {
+    return;
+  }
+  /**
+   * Callback executed before a tool is called.
+   *
+   * 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
+   *     tool.
+   * @param 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 }) {
+    return;
+  }
+  /**
+   * Callback executed after a tool has been called.
+   *
+   * 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.
+   * @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 }) {
+    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 }) {
+    return;
+  }
+}
+export {
+  BasePlugin
+};

package/dist/web/plugins/logging_plugin.js

@@ -0,0 +1,192 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getFunctionCalls, getFunctionResponses, isFinalResponse } from "../events/event.js";
+import { logger } from "../utils/logger.js";
+import { BasePlugin } from "./base_plugin.js";
+class LoggingPlugin extends BasePlugin {
+  /**
+   * Initialize the logging plugin.
+   *
+   * @param name The name of the plugin instance.
+   */
+  constructor(name = "logging_plugin") {
+    super(name);
+  }
+  async onUserMessageCallback({ invocationContext, userMessage }) {
+    var _a;
+    this.log("\u{1F680} USER MESSAGE RECEIVED");
+    this.log("   Invocation ID: ".concat(invocationContext.invocationId));
+    this.log("   Session ID: ".concat(invocationContext.session.id));
+    this.log("   User ID: ".concat(invocationContext.userId));
+    this.log("   App Name: ".concat(invocationContext.appName));
+    this.log("   Root Agent: ".concat((_a = invocationContext.agent.name) != null ? _a : "Unknown"));
+    this.log("   User Content: ".concat(this.formatContent(userMessage)));
+    if (invocationContext.branch) {
+      this.log("   Branch: ".concat(invocationContext.branch));
+    }
+    return void 0;
+  }
+  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 }) {
+    this.log("\u{1F4E2} EVENT YIELDED");
+    this.log("   Event ID: ".concat(event.id));
+    this.log("   Author: ".concat(event.author));
+    this.log("   Content: ".concat(this.formatContent(event.content)));
+    this.log("   Final Response: ".concat(isFinalResponse(event)));
+    const functionCalls = getFunctionCalls(event);
+    if (functionCalls.length > 0) {
+      const funcCalls = functionCalls.map((fc) => fc.name);
+      this.log("   Function Calls: ".concat(funcCalls));
+    }
+    const functionResponses = getFunctionResponses(event);
+    if (functionResponses.length > 0) {
+      const funcResponses = functionResponses.map((fr) => fr.name);
+      this.log("   Function Responses: ".concat(funcResponses));
+    }
+    if (event.longRunningToolIds && event.longRunningToolIds.length > 0) {
+      this.log("   Long Running Tools: ".concat([...event.longRunningToolIds]));
+    }
+    return void 0;
+  }
+  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 }) {
+    this.log("\u{1F916} AGENT STARTING");
+    this.log("   Agent Name: ".concat(callbackContext.agentName));
+    this.log("   Invocation ID: ".concat(callbackContext.invocationId));
+    if (callbackContext.invocationContext.branch) {
+      this.log("   Branch: ".concat(callbackContext.invocationContext.branch));
+    }
+    return void 0;
+  }
+  async afterAgentCallback({ agent, 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 }) {
+    var _a;
+    this.log("\u{1F9E0} LLM REQUEST");
+    this.log("   Model: ".concat((_a = llmRequest.model) != null ? _a : "default"));
+    this.log("   Agent: ".concat(callbackContext.agentName));
+    if (llmRequest.config && llmRequest.config.systemInstruction) {
+      let sysInstruction = llmRequest.config.systemInstruction;
+      if (sysInstruction.length > 200) {
+        sysInstruction = sysInstruction.substring(0, 200) + "...";
+      }
+      this.log("   System Instruction: '".concat(sysInstruction, "'"));
+    }
+    if (llmRequest.toolsDict) {
+      const toolNames = Object.keys(llmRequest.toolsDict);
+      this.log("   Available Tools: ".concat(toolNames));
+    }
+    return void 0;
+  }
+  async afterModelCallback({ callbackContext, llmResponse }) {
+    this.log("\u{1F9E0} LLM RESPONSE");
+    this.log("   Agent: ".concat(callbackContext.agentName));
+    if (llmResponse.errorCode) {
+      this.log("   \u274C ERROR - Code: ".concat(llmResponse.errorCode));
+      this.log("   Error Message: ".concat(llmResponse.errorMessage));
+    } else {
+      this.log("   Content: ".concat(this.formatContent(llmResponse.content)));
+      if (llmResponse.partial) {
+        this.log("   Partial: ".concat(llmResponse.partial));
+      }
+      if (llmResponse.turnComplete !== void 0) {
+        this.log("   Turn Complete: ".concat(llmResponse.turnComplete));
+      }
+    }
+    if (llmResponse.usageMetadata) {
+      this.log("   Token Usage - Input: ".concat(llmResponse.usageMetadata.promptTokenCount, ", Output: ").concat(llmResponse.usageMetadata.candidatesTokenCount));
+    }
+    return void 0;
+  }
+  async beforeToolCallback({ tool, toolArgs, toolContext }) {
+    this.log("\u{1F527} TOOL STARTING");
+    this.log("   Tool Name: ".concat(tool.name));
+    this.log("   Agent: ".concat(toolContext.agentName));
+    this.log("   Function Call ID: ".concat(toolContext.functionCallId));
+    this.log("   Arguments: ".concat(this.formatArgs(toolArgs)));
+    return void 0;
+  }
+  async afterToolCallback({ tool, toolArgs, toolContext, result }) {
+    this.log("\u{1F527} TOOL COMPLETED");
+    this.log("   Tool Name: ".concat(tool.name));
+    this.log("   Agent: ".concat(toolContext.agentName));
+    this.log("   Function Call ID: ".concat(toolContext.functionCallId));
+    this.log("   Result: ".concat(this.formatArgs(result)));
+    return void 0;
+  }
+  async onModelErrorCallback({ callbackContext, llmRequest, 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 }) {
+    this.log("\u{1F527} TOOL ERROR");
+    this.log("   Tool Name: ".concat(tool.name));
+    this.log("   Agent: ".concat(toolContext.agentName));
+    this.log("   Function Call ID: ".concat(toolContext.functionCallId));
+    this.log("   Arguments: ".concat(this.formatArgs(toolArgs)));
+    this.log("   Error: ".concat(error));
+    return void 0;
+  }
+  log(message) {
+    const formattedMessage = "\x1B[90m[".concat(this.name, "] ").concat(message, "\x1B[0m");
+    logger.info(formattedMessage);
+  }
+  formatContent(content, maxLength = 200) {
+    if (!content || !content.parts) {
+      return "None";
+    }
+    const parts = [];
+    for (const part of content.parts) {
+      if (part.text) {
+        let text = part.text.trim();
+        if (text.length > maxLength) {
+          text = text.substring(0, maxLength) + "...";
+        }
+        parts.push("text: '".concat(text, "'"));
+      } else if (part.functionCall) {
+        parts.push("function_call: ".concat(part.functionCall.name));
+      } else if (part.functionResponse) {
+        parts.push("function_response: ".concat(part.functionResponse.name));
+      } else if (part.codeExecutionResult) {
+        parts.push("code_execution_result");
+      } else {
+        parts.push("other_part");
+      }
+    }
+    return parts.join(" | ");
+  }
+  formatArgs(args, maxLength = 300) {
+    if (!args) {
+      return "{}";
+    }
+    let formatted = JSON.stringify(args);
+    if (formatted.length > maxLength) {
+      formatted = formatted.substring(0, maxLength) + "...}";
+    }
+    return formatted;
+  }
+}
+export {
+  LoggingPlugin
+};

package/dist/web/plugins/plugin_manager.js

@@ -0,0 +1,209 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from "../utils/logger.js";
+class PluginManager {
+  /**
+   * Initializes the plugin service.
+   *
+   * @param plugins An optional list of plugins to register upon
+   *     initialization.
+   */
+  constructor(plugins) {
+    this.plugins = /* @__PURE__ */ new Set();
+    if (plugins) {
+      for (const plugin of plugins) {
+        this.registerPlugin(plugin);
+      }
+    }
+  }
+  /**
+   * Registers a new plugin.
+   *
+   * @param plugin The plugin instance to register.
+   * @throws If the same exact plugin or a plugin with the same name is already
+   *     registered.
+   */
+  registerPlugin(plugin) {
+    if (this.plugins.has(plugin)) {
+      throw new Error("Plugin '".concat(plugin.name, "' already registered."));
+    }
+    if (Array.from(this.plugins).some((p) => p.name === plugin.name)) {
+      throw new Error("Plugin with name '".concat(plugin.name, "' already registered."));
+    }
+    this.plugins.add(plugin);
+    logger.info("Plugin '".concat(plugin.name, "' registered."));
+  }
+  /**
+   * Retrieves a registered plugin by its name.
+   *
+   * @param pluginName The name of the plugin to retrieve.
+   * @returns The plugin instance if found, otherwise `undefined`.
+   */
+  getPlugin(pluginName) {
+    return Array.from(this.plugins).find((p) => p.name === pluginName);
+  }
+  /**
+   * Runs the same callback for all plugins. This is a utility method to reduce
+   * duplication below.
+   *
+   * @param plugins The set of plugins to run
+   * @param callback A closure containing the callback method to run on each
+   *     plugin
+   * @param callbackName The name of the function being called in the closure
+   *     above. Used for logging purposes.
+   * @returns A promise containing the plugin method result. Must be casted to
+   *     the proper type for the plugin method.
+   */
+  async runCallbacks(plugins, callback, callbackName) {
+    for (const plugin of plugins) {
+      try {
+        const result = await callback(plugin);
+        if (result !== void 0) {
+          logger.debug(
+            "Plugin '".concat(plugin.name, "' returned a value for callback '").concat(callbackName, "', exiting early.")
+          );
+          return result;
+        }
+      } catch (e) {
+        const errorMessage = "Error in plugin '".concat(plugin.name, "' during '").concat(callbackName, "' callback: ").concat(e);
+        logger.error(errorMessage);
+        throw new Error(errorMessage);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Runs the `onUserMessageCallback` for all plugins.
+   */
+  async runOnUserMessageCallback({ userMessage, invocationContext }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.onUserMessageCallback(
+        { userMessage, invocationContext }
+      ),
+      "onUserMessageCallback"
+    );
+  }
+  /**
+   * Runs the `beforeRunCallback` for all plugins.
+   */
+  async runBeforeRunCallback({ invocationContext }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.beforeRunCallback({ invocationContext }),
+      "beforeRunCallback"
+    );
+  }
+  /**
+   * Runs the `afterRunCallback` for all plugins.
+   */
+  async runAfterRunCallback({ invocationContext }) {
+    await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.afterRunCallback({ invocationContext }),
+      "afterRunCallback"
+    );
+  }
+  /**
+   * Runs the `onEventCallback` for all plugins.
+   */
+  async runOnEventCallback({ invocationContext, event }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.onEventCallback({ invocationContext, event }),
+      "onEventCallback"
+    );
+  }
+  /**
+   * Runs the `beforeAgentCallback` for all plugins.
+   */
+  async runBeforeAgentCallback({ agent, callbackContext }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.beforeAgentCallback({ agent, callbackContext }),
+      "beforeAgentCallback"
+    );
+  }
+  /**
+   * Runs the `afterAgentCallback` for all plugins.
+   */
+  async runAfterAgentCallback({ agent, callbackContext }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.afterAgentCallback({ agent, callbackContext }),
+      "afterAgentCallback"
+    );
+  }
+  /**
+   * Runs the `beforeToolCallback` for all plugins.
+   */
+  async runBeforeToolCallback({ tool, toolArgs, toolContext }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.beforeToolCallback({ tool, toolArgs, toolContext }),
+      "beforeToolCallback"
+    );
+  }
+  /**
+   * Runs the `afterToolCallback` for all plugins.
+   */
+  async runAfterToolCallback({ tool, toolArgs, toolContext, result }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.afterToolCallback(
+        { tool, toolArgs, toolContext, result }
+      ),
+      "afterToolCallback"
+    );
+  }
+  /**
+   * Runs the `onModelErrorCallback` for all plugins.
+   */
+  async runOnModelErrorCallback({ callbackContext, llmRequest, error }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.onModelErrorCallback(
+        { callbackContext, llmRequest, error }
+      ),
+      "onModelErrorCallback"
+    );
+  }
+  /**
+   * Runs the `beforeModelCallback` for all plugins.
+   */
+  async runBeforeModelCallback({ callbackContext, llmRequest }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.beforeModelCallback({ callbackContext, llmRequest }),
+      "beforeModelCallback"
+    );
+  }
+  /**
+   * Runs the `afterModelCallback` for all plugins.
+   */
+  async runAfterModelCallback({ callbackContext, llmResponse }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.afterModelCallback({ callbackContext, llmResponse }),
+      "afterModelCallback"
+    );
+  }
+  /**
+   * Runs the `onToolErrorCallback` for all plugins.
+   */
+  async runOnToolErrorCallback({ tool, toolArgs, toolContext, error }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.onToolErrorCallback(
+        { tool, toolArgs, toolContext, error }
+      ),
+      "onToolErrorCallback"
+    );
+  }
+}
+export {
+  PluginManager
+};