@paean-ai/adk 0.2.17 → 0.2.19

package/dist/esm/models/registry.js

@@ -1,91 +0,0 @@
-/**
- * @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 ${modelNameRegex} from ${_LLMRegistry.llmRegistryDict.get(modelNameRegex)} to ${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(
-        `^${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 ${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/esm/plugins/base_plugin.js

@@ -1,206 +0,0 @@
-/**
- * @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/esm/plugins/logging_plugin.js

@@ -1,192 +0,0 @@
-/**
- * @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: ${invocationContext.invocationId}`);
-    this.log(`   Session ID: ${invocationContext.session.id}`);
-    this.log(`   User ID: ${invocationContext.userId}`);
-    this.log(`   App Name: ${invocationContext.appName}`);
-    this.log(`   Root Agent: ${(_a = invocationContext.agent.name) != null ? _a : "Unknown"}`);
-    this.log(`   User Content: ${this.formatContent(userMessage)}`);
-    if (invocationContext.branch) {
-      this.log(`   Branch: ${invocationContext.branch}`);
-    }
-    return void 0;
-  }
-  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 }) {
-    this.log("\u{1F4E2} EVENT YIELDED");
-    this.log(`   Event ID: ${event.id}`);
-    this.log(`   Author: ${event.author}`);
-    this.log(`   Content: ${this.formatContent(event.content)}`);
-    this.log(`   Final Response: ${isFinalResponse(event)}`);
-    const functionCalls = getFunctionCalls(event);
-    if (functionCalls.length > 0) {
-      const funcCalls = functionCalls.map((fc) => fc.name);
-      this.log(`   Function Calls: ${funcCalls}`);
-    }
-    const functionResponses = getFunctionResponses(event);
-    if (functionResponses.length > 0) {
-      const funcResponses = functionResponses.map((fr) => fr.name);
-      this.log(`   Function Responses: ${funcResponses}`);
-    }
-    if (event.longRunningToolIds && event.longRunningToolIds.length > 0) {
-      this.log(`   Long Running Tools: ${[...event.longRunningToolIds]}`);
-    }
-    return void 0;
-  }
-  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 }) {
-    this.log("\u{1F916} AGENT STARTING");
-    this.log(`   Agent Name: ${callbackContext.agentName}`);
-    this.log(`   Invocation ID: ${callbackContext.invocationId}`);
-    if (callbackContext.invocationContext.branch) {
-      this.log(`   Branch: ${callbackContext.invocationContext.branch}`);
-    }
-    return void 0;
-  }
-  async afterAgentCallback({ agent, 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 }) {
-    var _a;
-    this.log("\u{1F9E0} LLM REQUEST");
-    this.log(`   Model: ${(_a = llmRequest.model) != null ? _a : "default"}`);
-    this.log(`   Agent: ${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: '${sysInstruction}'`);
-    }
-    if (llmRequest.toolsDict) {
-      const toolNames = Object.keys(llmRequest.toolsDict);
-      this.log(`   Available Tools: ${toolNames}`);
-    }
-    return void 0;
-  }
-  async afterModelCallback({ callbackContext, llmResponse }) {
-    this.log("\u{1F9E0} LLM RESPONSE");
-    this.log(`   Agent: ${callbackContext.agentName}`);
-    if (llmResponse.errorCode) {
-      this.log(`   \u274C ERROR - Code: ${llmResponse.errorCode}`);
-      this.log(`   Error Message: ${llmResponse.errorMessage}`);
-    } else {
-      this.log(`   Content: ${this.formatContent(llmResponse.content)}`);
-      if (llmResponse.partial) {
-        this.log(`   Partial: ${llmResponse.partial}`);
-      }
-      if (llmResponse.turnComplete !== void 0) {
-        this.log(`   Turn Complete: ${llmResponse.turnComplete}`);
-      }
-    }
-    if (llmResponse.usageMetadata) {
-      this.log(`   Token Usage - Input: ${llmResponse.usageMetadata.promptTokenCount}, Output: ${llmResponse.usageMetadata.candidatesTokenCount}`);
-    }
-    return void 0;
-  }
-  async beforeToolCallback({ tool, toolArgs, toolContext }) {
-    this.log("\u{1F527} TOOL STARTING");
-    this.log(`   Tool Name: ${tool.name}`);
-    this.log(`   Agent: ${toolContext.agentName}`);
-    this.log(`   Function Call ID: ${toolContext.functionCallId}`);
-    this.log(`   Arguments: ${this.formatArgs(toolArgs)}`);
-    return void 0;
-  }
-  async afterToolCallback({ tool, toolArgs, toolContext, result }) {
-    this.log("\u{1F527} TOOL COMPLETED");
-    this.log(`   Tool Name: ${tool.name}`);
-    this.log(`   Agent: ${toolContext.agentName}`);
-    this.log(`   Function Call ID: ${toolContext.functionCallId}`);
-    this.log(`   Result: ${this.formatArgs(result)}`);
-    return void 0;
-  }
-  async onModelErrorCallback({ callbackContext, llmRequest, 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 }) {
-    this.log("\u{1F527} TOOL ERROR");
-    this.log(`   Tool Name: ${tool.name}`);
-    this.log(`   Agent: ${toolContext.agentName}`);
-    this.log(`   Function Call ID: ${toolContext.functionCallId}`);
-    this.log(`   Arguments: ${this.formatArgs(toolArgs)}`);
-    this.log(`   Error: ${error}`);
-    return void 0;
-  }
-  log(message) {
-    const formattedMessage = `\x1B[90m[${this.name}] ${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: '${text}'`);
-      } else if (part.functionCall) {
-        parts.push(`function_call: ${part.functionCall.name}`);
-      } else if (part.functionResponse) {
-        parts.push(`function_response: ${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/esm/plugins/plugin_manager.js

@@ -1,209 +0,0 @@
-/**
- * @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 '${plugin.name}' already registered.`);
-    }
-    if (Array.from(this.plugins).some((p) => p.name === plugin.name)) {
-      throw new Error(`Plugin with name '${plugin.name}' already registered.`);
-    }
-    this.plugins.add(plugin);
-    logger.info(`Plugin '${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 '${plugin.name}' returned a value for callback '${callbackName}', exiting early.`
-          );
-          return result;
-        }
-      } catch (e) {
-        const errorMessage = `Error in plugin '${plugin.name}' during '${callbackName}' callback: ${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
-};