@google/adk 0.1.0

package/dist/types/models/llm_response.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content, FinishReason, GenerateContentResponse, GenerateContentResponseUsageMetadata, GroundingMetadata, LiveServerSessionResumptionUpdate, Transcription } from '@google/genai';
+/**
+ * LLM response class that provides the first candidate response from the
+ * model if available. Otherwise, returns error code and message.
+ */
+export interface LlmResponse {
+    /**
+     * The content of the response.
+     */
+    content?: Content;
+    /**
+     * The grounding metadata of the response.
+     */
+    groundingMetadata?: GroundingMetadata;
+    /**
+     * Indicates whether the text content is part of a unfinished text stream.
+     * Only used for streaming mode and when the content is plain text.
+     */
+    partial?: boolean;
+    /**
+     * Indicates whether the response from the model is complete.
+     * Only used for streaming mode.
+     */
+    turnComplete?: boolean;
+    /**
+     * Error code if the response is an error. Code varies by model.
+     */
+    errorCode?: string;
+    /**
+     * Error message if the response is an error.
+     */
+    errorMessage?: string;
+    /**
+     * Flag indicating that LLM was interrupted when generating the content.
+     * Usually it's due to user interruption during a bidi streaming.
+     */
+    interrupted?: boolean;
+    /**
+     * The custom metadata of the LlmResponse.
+     * An optional key-value pair to label an LlmResponse.
+     * NOTE: the entire object must be JSON serializable.
+     */
+    customMetadata?: {
+        [key: string]: any;
+    };
+    /**
+     * The usage metadata of the LlmResponse.
+     */
+    usageMetadata?: GenerateContentResponseUsageMetadata;
+    /**
+     * The finish reason of the response.
+     */
+    finishReason?: FinishReason;
+    /**
+     * The session resumption update of the LlmResponse
+     */
+    liveSessionResumptionUpdate?: LiveServerSessionResumptionUpdate;
+    /**
+     * Audio transcription of user input.
+     */
+    inputTranscription?: Transcription;
+    /**
+     * Audio transcription of model output.
+     */
+    outputTranscription?: Transcription;
+}
+/**
+ * Creates an LlmResponse from a GenerateContentResponse.
+ *
+ * @param response The GenerateContentResponse to create the
+ *   LlmResponse from.
+ * @returns The LlmResponse.
+ */
+export declare function createLlmResponse(response: GenerateContentResponse): LlmResponse;

package/dist/types/models/registry.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseLlm } from './base_llm.js';
+/**
+ * type[BaseLlm] equivalent in TypeScript, represents a class that can be new-ed
+ * to create a BaseLlm instance.
+ */
+export type BaseLlmType = (new (model: string) => BaseLlm) & {
+    readonly supportedModels: Array<string | RegExp>;
+};
+/**
+ * Registry for LLMs.
+ */
+export declare class LLMRegistry {
+    /**
+     * Key is the regex that matches the model name.
+     * Value is the class that implements the model.
+     */
+    private static llmRegistryDict;
+    private static resolveCache;
+    /**
+     * Creates a new LLM instance.
+     * @param model The model name.
+     * @returns The LLM instance.
+     */
+    static newLlm(model: string): BaseLlm;
+    private static _register;
+    /**
+     * Registers a new LLM class.
+     * @param llmCls The class that implements the model.
+     */
+    static register<T extends BaseLlm>(llmCls: (new (model: string) => T) & {
+        readonly supportedModels: Array<string | RegExp>;
+    }): void;
+    /**
+     * 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: string): BaseLlmType;
+}

package/dist/types/plugins/base_plugin.d.ts

@@ -0,0 +1,310 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+import { BaseAgent } from '../agents/base_agent.js';
+import { CallbackContext } from '../agents/callback_context.js';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event } from '../events/event.js';
+import { LlmRequest } from '../models/llm_request.js';
+import { LlmResponse } from '../models/llm_response.js';
+import { BaseTool } from '../tools/base_tool.js';
+import { ToolContext } from '../tools/tool_context.js';
+/**
+ * Base class for creating plugins.
+ *
+ * Plugins provide a structured way to intercept and modify agent, tool, and
+ * LLM behaviors at critical execution points in a callback manner. While agent
+ * callbacks apply to a particular agent, plugins applies globally to all
+ * agents added in the runner. Plugins are best used for adding custom behaviors
+ * like logging, monitoring, caching, or modifying requests and responses at key
+ * stages.
+ *
+ * A plugin can implement one or more methods of callbacks, but should not
+ * implement the same method of callback for multiple times.
+ *
+ * Relation with [Agent
+ * callbacks](https://google.github.io/adk-docs/callbacks/):
+ *
+ * **Execution Order**
+ * Similar to Agent callbacks, Plugins are executed in the order they are
+ * registered. However, Plugin and Agent Callbacks are executed sequentially,
+ * with Plugins takes precedence over agent callbacks. When the callback in a
+ * plugin returns a value, it will short circuit all remaining plugins and
+ * agent callbacks, causing all remaining plugins and agent callbacks
+ * to be skipped.
+ *
+ * **Change Propagation**
+ * Plugins and agent callbacks can both modify the value of the input
+ * parameters, including agent input, tool input, and LLM request/response, etc.
+ * They work in the exactly same way. The modifications will be visible and
+ * passed to the next callback in the chain. For example, if a plugin modifies
+ * the tool input with before_tool_callback, the modified tool input will be
+ * passed to the before_tool_callback of the next plugin, and further passed to
+ * the agent callbacks if not short circuited.
+ *
+ * To use a plugin, implement the desired callback methods and pass an instance
+ * of your custom plugin class to the ADK Runner.
+ *
+ * Example:
+ * A simple plugin that logs every tool call.
+ * ```typescript
+ * class ToolLoggerPlugin extends BasePlugin {
+ *   constructor() {
+ *     super('tool_logger');
+ *   }
+ *
+ *   override async beforeToolCallback(
+ *     {tool, toolArgs, toolContext}: {
+ *       tool: BaseTool,
+ *       toolArgs: Record<string, unknown>,
+ *       toolContext: ToolContext,
+ *     },
+ *   ): Promise<Record<string, unknown> | undefined> {
+ *     this.logger.info(
+ *       `[${this.name}] Calling tool '${tool.name}' with args:
+ * ${JSON.stringify( toolArgs,
+ *       )}`,
+ *     );
+ *     return;
+ *   }
+ *
+ *   override async afterToolCallback(
+ *     {tool, toolArgs, toolContext, result}: {
+ *       tool: BaseTool,
+ *       toolArgs: Record<string, unknown>,
+ *       toolContext: ToolContext,
+ *       result: Record<string, unknown>,
+ *     },
+ *   ): Promise<Record<string, unknown> | undefined> {
+ *     this.logger.info(
+ *       `[${this.name}] Tool '${tool.name}' finished with result:
+ * ${JSON.stringify( result,
+ *       )}`,
+ *     );
+ *     return;
+ *   }
+ * }
+ *
+ * // Add the plugin to ADK Runner
+ * // runner = new Runner({
+ * //   ...
+ * //   plugins: [new ToolLoggerPlugin(), new AgentPolicyPlugin()],
+ * // });
+ * ```
+ */
+export declare abstract class BasePlugin {
+    readonly name: string;
+    /**
+     * Initializes the plugin.
+     *
+     * @param name A unique identifier for this plugin instance.
+     */
+    constructor(name: string);
+    /**
+     * 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.
+     */
+    onUserMessageCallback({ invocationContext, userMessage }: {
+        invocationContext: InvocationContext;
+        userMessage: Content;
+    }): Promise<Content | undefined>;
+    /**
+     * 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.
+     */
+    beforeRunCallback({ invocationContext }: {
+        invocationContext: InvocationContext;
+    }): Promise<Content | undefined>;
+    /**
+     * 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.
+     */
+    onEventCallback({ invocationContext, event }: {
+        invocationContext: InvocationContext;
+        event: Event;
+    }): Promise<Event | undefined>;
+    /**
+     * 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
+     */
+    afterRunCallback({ invocationContext }: {
+        invocationContext: InvocationContext;
+    }): Promise<void>;
+    /**
+     * 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.
+     */
+    beforeAgentCallback({ agent, callbackContext }: {
+        agent: BaseAgent;
+        callbackContext: CallbackContext;
+    }): Promise<Content | undefined>;
+    /**
+     * 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.
+     */
+    afterAgentCallback({ agent, callbackContext }: {
+        agent: BaseAgent;
+        callbackContext: CallbackContext;
+    }): Promise<Content | undefined>;
+    /**
+     * 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.
+     */
+    beforeModelCallback({ callbackContext, llmRequest }: {
+        callbackContext: CallbackContext;
+        llmRequest: LlmRequest;
+    }): Promise<LlmResponse | undefined>;
+    /**
+     * 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.
+     */
+    afterModelCallback({ callbackContext, llmResponse }: {
+        callbackContext: CallbackContext;
+        llmResponse: LlmResponse;
+    }): Promise<LlmResponse | undefined>;
+    /**
+     * 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.
+     */
+    onModelErrorCallback({ callbackContext, llmRequest, error }: {
+        callbackContext: CallbackContext;
+        llmRequest: LlmRequest;
+        error: Error;
+    }): Promise<LlmResponse | undefined>;
+    /**
+     * 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.
+     */
+    beforeToolCallback({ tool, toolArgs, toolContext }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: ToolContext;
+    }): Promise<Record<string, unknown> | undefined>;
+    /**
+     * 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.
+     */
+    afterToolCallback({ tool, toolArgs, toolContext, result }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: ToolContext;
+        result: Record<string, unknown>;
+    }): Promise<Record<string, unknown> | undefined>;
+    /**
+     * 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.
+     */
+    onToolErrorCallback({ tool, toolArgs, toolContext, error }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: ToolContext;
+        error: Error;
+    }): Promise<Record<string, unknown> | undefined>;
+}

package/dist/types/plugins/logging_plugin.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+import { BaseAgent } from '../agents/base_agent.js';
+import { CallbackContext } from '../agents/callback_context.js';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event } from '../events/event.js';
+import { LlmRequest } from '../models/llm_request.js';
+import { LlmResponse } from '../models/llm_response.js';
+import { BaseTool } from '../tools/base_tool.js';
+import { ToolContext } from '../tools/tool_context.js';
+import { BasePlugin } from './base_plugin.js';
+/**
+ * A plugin that logs important information at each callback point.
+ *
+ * This plugin helps printing all critical events in the console. It is not a
+ * replacement of existing logging in ADK. It rather helps terminal based
+ * debugging by showing all logs in the console, and serves as a simple demo for
+ * everyone to leverage when developing new plugins.
+ *
+ * This plugin helps users track the invocation status by logging:
+ * - User messages and invocation context
+ * - Agent execution flow
+ * - LLM requests and responses
+ * - Tool calls with arguments and results
+ * - Events and final responses
+ * - Errors during model and tool execution
+ *
+ * Example:
+ * ```typescript
+ * const loggingPlugin = new LoggingPlugin();
+ * const runner = new Runner({
+ *   agents: [myAgent],
+ *   // ...
+ *   plugins: [loggingPlugin],
+ * });
+ * ```
+ */
+export declare class LoggingPlugin extends BasePlugin {
+    /**
+     * Initialize the logging plugin.
+     *
+     * @param name The name of the plugin instance.
+     */
+    constructor(name?: string);
+    onUserMessageCallback({ invocationContext, userMessage }: {
+        invocationContext: InvocationContext;
+        userMessage: Content;
+    }): Promise<Content | undefined>;
+    beforeRunCallback({ invocationContext }: {
+        invocationContext: InvocationContext;
+    }): Promise<Content | undefined>;
+    onEventCallback({ invocationContext, event }: {
+        invocationContext: InvocationContext;
+        event: Event;
+    }): Promise<Event | undefined>;
+    afterRunCallback({ invocationContext }: {
+        invocationContext: InvocationContext;
+    }): Promise<void>;
+    beforeAgentCallback({ agent, callbackContext }: {
+        agent: BaseAgent;
+        callbackContext: CallbackContext;
+    }): Promise<Content | undefined>;
+    afterAgentCallback({ agent, callbackContext }: {
+        agent: BaseAgent;
+        callbackContext: CallbackContext;
+    }): Promise<Content | undefined>;
+    beforeModelCallback({ callbackContext, llmRequest }: {
+        callbackContext: CallbackContext;
+        llmRequest: LlmRequest;
+    }): Promise<LlmResponse | undefined>;
+    afterModelCallback({ callbackContext, llmResponse }: {
+        callbackContext: CallbackContext;
+        llmResponse: LlmResponse;
+    }): Promise<LlmResponse | undefined>;
+    beforeToolCallback({ tool, toolArgs, toolContext }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: ToolContext;
+    }): Promise<Record<string, unknown> | undefined>;
+    afterToolCallback({ tool, toolArgs, toolContext, result }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: ToolContext;
+        result: Record<string, unknown>;
+    }): Promise<Record<string, unknown> | undefined>;
+    onModelErrorCallback({ callbackContext, llmRequest, error }: {
+        callbackContext: CallbackContext;
+        llmRequest: LlmRequest;
+        error: Error;
+    }): Promise<LlmResponse | undefined>;
+    onToolErrorCallback({ tool, toolArgs, toolContext, error }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: ToolContext;
+        error: Error;
+    }): Promise<Record<string, unknown> | undefined>;
+    private log;
+    private formatContent;
+    private formatArgs;
+}

package/dist/types/plugins/plugin_manager.d.ts

@@ -0,0 +1,155 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+import { BaseAgent } from '../agents/base_agent.js';
+import { CallbackContext } from '../agents/callback_context.js';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event } from '../events/event.js';
+import { LlmRequest } from '../models/llm_request.js';
+import { LlmResponse } from '../models/llm_response.js';
+import { BaseTool } from '../tools/base_tool.js';
+import { ToolContext } from '../tools/tool_context.js';
+import { BasePlugin } from './base_plugin.js';
+/**
+ * Manages the registration and execution of plugins.
+ *
+ * The PluginManager is an internal class that orchestrates the invocation of
+ * plugin callbacks at key points in the SDK's execution lifecycle. It maintains
+ * a list of registered plugins and ensures they are called in the order they
+ * were registered.
+ *
+ * The core execution logic implements an "early exit" strategy: if any plugin
+ * callback returns a non-`undefined` value, the execution of subsequent plugins
+ * for that specific event is halted, and the returned value is propagated up
+ * the call stack. This allows plugins to short-circuit operations like agent
+ * runs, tool calls, or model requests.
+ */
+export declare class PluginManager {
+    private readonly plugins;
+    /**
+     * Initializes the plugin service.
+     *
+     * @param plugins An optional list of plugins to register upon
+     *     initialization.
+     */
+    constructor(plugins?: BasePlugin[]);
+    /**
+     * 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: BasePlugin): void;
+    /**
+     * 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: string): BasePlugin | undefined;
+    /**
+     * 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.
+     */
+    private runCallbacks;
+    /**
+     * Runs the `onUserMessageCallback` for all plugins.
+     */
+    runOnUserMessageCallback({ userMessage, invocationContext }: {
+        userMessage: Content;
+        invocationContext: InvocationContext;
+    }): Promise<Content | undefined>;
+    /**
+     * Runs the `beforeRunCallback` for all plugins.
+     */
+    runBeforeRunCallback({ invocationContext }: {
+        invocationContext: InvocationContext;
+    }): Promise<Content | undefined>;
+    /**
+     * Runs the `afterRunCallback` for all plugins.
+     */
+    runAfterRunCallback({ invocationContext }: {
+        invocationContext: InvocationContext;
+    }): Promise<void>;
+    /**
+     * Runs the `onEventCallback` for all plugins.
+     */
+    runOnEventCallback({ invocationContext, event }: {
+        invocationContext: InvocationContext;
+        event: Event;
+    }): Promise<Event | undefined>;
+    /**
+     * Runs the `beforeAgentCallback` for all plugins.
+     */
+    runBeforeAgentCallback({ agent, callbackContext }: {
+        agent: BaseAgent;
+        callbackContext: CallbackContext;
+    }): Promise<Content | undefined>;
+    /**
+     * Runs the `afterAgentCallback` for all plugins.
+     */
+    runAfterAgentCallback({ agent, callbackContext }: {
+        agent: BaseAgent;
+        callbackContext: CallbackContext;
+    }): Promise<Content | undefined>;
+    /**
+     * Runs the `beforeToolCallback` for all plugins.
+     */
+    runBeforeToolCallback({ tool, toolArgs, toolContext }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: ToolContext;
+    }): Promise<Record<string, unknown> | undefined>;
+    /**
+     * Runs the `afterToolCallback` for all plugins.
+     */
+    runAfterToolCallback({ tool, toolArgs, toolContext, result }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: ToolContext;
+        result: Record<string, unknown>;
+    }): Promise<Record<string, unknown> | undefined>;
+    /**
+     * Runs the `onModelErrorCallback` for all plugins.
+     */
+    runOnModelErrorCallback({ callbackContext, llmRequest, error }: {
+        callbackContext: CallbackContext;
+        llmRequest: LlmRequest;
+        error: Error;
+    }): Promise<LlmResponse | undefined>;
+    /**
+     * Runs the `beforeModelCallback` for all plugins.
+     */
+    runBeforeModelCallback({ callbackContext, llmRequest }: {
+        callbackContext: CallbackContext;
+        llmRequest: LlmRequest;
+    }): Promise<LlmResponse | undefined>;
+    /**
+     * Runs the `afterModelCallback` for all plugins.
+     */
+    runAfterModelCallback({ callbackContext, llmResponse }: {
+        callbackContext: CallbackContext;
+        llmResponse: LlmResponse;
+    }): Promise<LlmResponse | undefined>;
+    /**
+     * Runs the `onToolErrorCallback` for all plugins.
+     */
+    runOnToolErrorCallback({ tool, toolArgs, toolContext, error }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: ToolContext;
+        error: Error;
+    }): Promise<Record<string, unknown> | undefined>;
+}