@google/adk 2.1.0 → 2.2.1

package/dist/types/examples/example_util.d.ts

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { Session } from '../sessions/session.js';
 import { BaseExampleProvider } from './base_example_provider.js';
 import { Example } from './example.js';
 /**
@@ -20,6 +21,15 @@ import { Example } from './example.js';
  *   suitable for inclusion in a system instruction.
  */
 export declare function convertExamplesToText(examples: Example[], model?: string): string;
+/**
+ * Gets the latest message from the user.
+ *
+ * @param session - The session to inspect.
+ * @returns The latest message from the user. If not found, returns an empty
+ *   string.
+ */
+export declare function getLatestMessageFromUser(session: Session): string;
+export declare const _getLatestMessageFromUser: typeof getLatestMessageFromUser;
 /**
  * Builds the few-shot portion of a system instruction from a list of examples
  * or a {@link BaseExampleProvider}.
@@ -31,8 +41,9 @@ export declare function convertExamplesToText(examples: Example[], model?: strin
  *   when `examples` is a provider. Ignored when `examples` is an array.
  * @param model - Optional model name forwarded to
  *   {@link convertExamplesToText} to select the function-call fence style.
- * @returns A formatted string ready to be appended to a system instruction.
+ * @returns A promise resolving to a formatted string ready to be appended to a
+ *   system instruction.
  * @throws {Error} When `examples` is neither an array nor a
  *   {@link BaseExampleProvider}.
  */
-export declare function buildExampleSi(examples: Example[] | BaseExampleProvider, query: string, model?: string): string;
+export declare function buildExampleSi(examples: Example[] | BaseExampleProvider, query: string, model?: string): Promise<string>;

package/dist/types/examples/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Examples subsystem barrel export.
+ *
+ * Re-exports all `examples` modules (`Example`, `BaseExampleProvider`,
+ * `VertexAiExampleStore`, `example_util`) alongside compatibility references
+ * for `BaseCodeExecutor`, `BuiltInCodeExecutor`, `CodeExecutorContext`,
+ * `ContainerCodeExecutor`, `UnsafeLocalCodeExecutor`, `VertexAiCodeExecutor`,
+ * and `code_execution_utils`.
+ */
+export * from './base_example_provider.js';
+export * from './example.js';
+export * from './example_util.js';
+export * from './vertex_ai_example_store.js';

package/dist/types/examples/vertex_ai_example_store.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export { VertexAiExampleStore } from './example.js';
+export type { ExampleStoreApiClient, SearchExamplesRequest, SearchExamplesResponse, SearchExamplesResult, StoredContentsExample, } from './example.js';

package/dist/types/index.d.ts

@@ -29,14 +29,23 @@ export type { GCPSkillRegistryOptions } from './skills/gcp_skill_registry.js';
 export { loadAllSkillsInDir, loadSkillFromDir, loadSkillFromZipBuffer, validateSkillDir, } from './skills/loader.js';
 export { LOAD_WEB_PAGE, loadWebPage } from './tools/load_web_page.js';
 export type { LoadWebPageOptions } from './tools/load_web_page.js';
+export { credentialToParam, dictToAuthScheme, INTERNAL_AUTH_PREFIX, openidDictToSchemeCredential, openidUrlToSchemeCredential, serviceAccountDictToSchemeCredential, serviceAccountSchemeCredential, tokenToSchemeCredential, } from './tools/openapi_tool/auth/auth_helpers.js';
+export { AutoAuthCredentialExchanger } from './tools/openapi_tool/auth/credential_exchangers/auto_auth_credential_exchanger.js';
+export type { CustomCredentialExchangers } from './tools/openapi_tool/auth/credential_exchangers/auto_auth_credential_exchanger.js';
+export { AuthCredentialMissingError, BaseAuthCredentialExchanger, } from './tools/openapi_tool/auth/credential_exchangers/base_auth_credential_exchanger.js';
+export { exchangeCredential, OAuth2BearerExchanger, } from './tools/openapi_tool/auth/credential_exchangers/oauth2_exchanger.js';
+export { ServiceAccountCredentialExchanger } from './tools/openapi_tool/auth/credential_exchangers/service_account_exchanger.js';
+export { createApiParameter, generateParamDoc, generateReturnDoc, getTypeHint, } from './tools/openapi_tool/common/common.js';
+export type { ApiParameterInit } from './tools/openapi_tool/common/common.js';
 export { OpenApiSpecParser } from './tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js';
 export type { OperationEndpoint, ParsedOperation, } from './tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js';
 export { OperationParser } from './tools/openapi_tool/openapi_spec_parser/operation_parser.js';
 export type { ApiParameter } from './tools/openapi_tool/openapi_spec_parser/operation_parser.js';
-export { ToolAuthHandler } from './tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js';
-export type { AuthPreparationResult } from './tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js';
+export { ToolAuthHandler, ToolContextCredentialStore, } from './tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js';
+export type { AuthPreparationResult, ToolAuthHandlerOptions, } from './tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js';
 export { OpenAPIToolset } from './tools/openapi_tool/openapi_toolset.js';
-export { createRestApiTool, RestApiTool, } from './tools/openapi_tool/rest_api_tool.js';
+export { createRestApiTool, createRestApiToolFromJson, RestApiTool, } from './tools/openapi_tool/rest_api_tool.js';
+export type { ParsedOperationInput } from './tools/openapi_tool/rest_api_tool.js';
 export { FilesRetrieval } from './tools/retrieval/files_retrieval.js';
 export type { FilesRetrievalConstructorParams, FilesRetrievalParams, } from './tools/retrieval/files_retrieval.js';
 export { LoadSkillResourceTool } from './tools/skill/load_skill_resource_tool.js';

package/dist/types/memory/memory_entry.d.ts

@@ -15,6 +15,21 @@ export interface MemoryEntry {
      * The content of the memory entry, as originally produced during a session.
      */
     content: Content;
+    /**
+     * The unique identifier of the memory.
+     *
+     * When set on an entry passed to `addMemory`, a service that supports
+     * caller-chosen identifiers uses it as the last component of the created
+     * memory's resource name instead of generating one.
+     */
+    id?: string;
+    /**
+     * Optional custom metadata associated with the memory.
+     *
+     * A service that also accepts request-level metadata merges this on top of
+     * it, so a key declared here wins over the same key on the request.
+     */
+    customMetadata?: Record<string, unknown>;
     /**
      * The author of the memory. Common values are `'user'` and `'model'`, but
      * this can also be the name of an agent when the content was produced by a

package/dist/types/memory/vertex_ai_memory_bank_service.d.ts

@@ -38,6 +38,15 @@ export declare class VertexAiMemoryBankService implements BaseMemoryService {
     }): Promise<void>;
     /**
      * Adds explicit memory items using Vertex Memory Bank.
+     *
+     * When a `MemoryEntry.id` is set, it is forwarded as the `memoryId` of the
+     * created memory, so the caller picks the last component of the memory
+     * resource name instead of letting the service generate one. An explicit
+     * `customMetadata['memoryId']` takes precedence over `MemoryEntry.id`.
+     *
+     * The id is forwarded unvalidated, so an id the API rejects fails the create
+     * call. Vertex accepts up to 63 characters from `[a-z0-9-]`, starting with a
+     * letter and ending with a letter or number.
      */
     addMemory(request: {
         appName: string;

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

@@ -16,6 +16,20 @@ export declare function collectFunctionDeclarations(llmRequest: LlmRequest): Fun
  *
  * A single-value `enum` is used rather than `const`, because it is semantically
  * identical and more widely supported across constraint engines.
+ *
+ * Every branch sets `additionalProperties: false`, and that is load-bearing
+ * rather than tidy. Omitted, JSON Schema permits extra keys, so a decoder may
+ * emit `,"` after the last required key instead of `}`. The object then never
+ * has to close: the model keeps writing until the output runs out, and the
+ * reply arrives as truncated JSON. Whether it closes in time is left to
+ * sampling, which is why one session can answer a question cleanly and mangle
+ * the next. Closing the branch makes `}` the only legal token once `text` is
+ * written.
+ *
+ * It is set on the envelope only, never pushed into a tool's own argument
+ * schema. Those belong to the caller; some describe objects that legitimately
+ * accept keys they do not list, and forbidding those here would make a valid
+ * call impossible to express.
  */
 export declare function buildToolChoiceSchema(declarations: FunctionDeclaration[]): Record<string, unknown>;
 /** Renders tool declarations into instructions the model can act on. */
@@ -66,3 +80,18 @@ export declare function stripAdkIdentityPreamble(systemPrompt: string): string;
 export declare function isAbortError(error: unknown): boolean;
 export declare function finalText(text: string): LlmResponse;
 export declare function errorResponse(error: unknown): LlmResponse;
+/** Shown when a reply is JSON, is broken, and holds no readable answer. */
+export declare const TRUNCATED_REPLY = "The model started an answer and did not finish it. Ask again.";
+/** True when a reply is the JSON envelope rather than plain prose. */
+export declare function looksLikeEnvelope(raw: string): boolean;
+/**
+ * Reads the answer out of a truncated `{"kind":"final","text":"…` envelope.
+ *
+ * A constrained reply that stops early is usually still readable: the answer
+ * sits in `text` and only the closing quote and brace are missing. Scanning it
+ * out by hand beats `JSON.parse`, which needs the whole document, and beats
+ * showing the envelope to the caller.
+ *
+ * Returns undefined when there is no `text` key to read.
+ */
+export declare function salvageFinalText(raw: string): string | undefined;

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

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content, GenerateContentConfig, GenerateContentResponse, GenerateContentResponseUsageMetadata, Part } from '@google/genai';
+import { LlmResponse } from './llm_response.js';
+/** The most times one generation is resumed after the model pauses it. */
+export declare const MAX_RESUMES = 256;
+/** The contents and config of a request that resumes a paused generation. */
+export interface ResumeRequest {
+    contents: Content[];
+    config: GenerateContentConfig;
+}
+/**
+ * Returns the token that resumes `response`, or undefined if it did not pause
+ * or has no token.
+ */
+export declare function resumeToken(response: GenerateContentResponse): string | undefined;
+/**
+ * One generation, carried across the requests that resume it after the model
+ * pauses it.
+ */
+export declare class GeminiContinuation {
+    private readonly config?;
+    private readonly contents;
+    private readonly parts;
+    private usage?;
+    private token?;
+    private resumes;
+    constructor(contents: Content[], config?: GenerateContentConfig | undefined);
+    /**
+     * Adds one request's output to the generation: its parts to the content and
+     * its usage to the total.
+     */
+    addOutput(newParts: Part[], newUsage: GenerateContentResponseUsageMetadata | undefined): void;
+    /**
+     * Returns the request that resumes the generation after a request that
+     * ended with `nextToken`. Returns undefined if the request did not pause,
+     * returned the previous token again, or the generation was already resumed
+     * {@link MAX_RESUMES} times.
+     */
+    resumeRequest(nextToken: string | undefined): ResumeRequest | undefined;
+    /** Returns `response` with the content and usage of all requests, if resumed. */
+    complete(response: GenerateContentResponse): LlmResponse;
+    /**
+     * Returns the final streamed `response`, with usage summed across all
+     * requests if resumed.
+     */
+    withSummedUsage(response: LlmResponse): LlmResponse;
+    /** Returns whether a request that ended with `nextToken` is resumed. */
+    willResume(nextToken: string): boolean;
+    /** Whether the generation took more than one request. */
+    private get resumed();
+    private content;
+    private buildResumeRequest;
+    /** Appends `newParts`, joining text as the streaming aggregator does. */
+    private appendParts;
+}

package/dist/types/planners/base_planner.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part } from '@google/genai';
+import { Context } from '../agents/context.js';
+import { ReadonlyContext } from '../agents/readonly_context.js';
+import { LlmRequest } from '../models/llm_request.js';
+/**
+ * A unique symbol to identify ADK planner classes.
+ * Defined once and shared by all BasePlanner instances.
+ */
+declare const BASE_PLANNER_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of BasePlanner.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of BasePlanner, false otherwise.
+ */
+export declare function isBasePlanner(obj: unknown): obj is BasePlanner;
+/**
+ * Abstract base class for all planners.
+ *
+ * The planner allows the agent to generate plans for the queries to guide its
+ * action.
+ */
+export declare abstract class BasePlanner {
+    /** A unique symbol to identify ADK base planner class. */
+    readonly [BASE_PLANNER_SIGNATURE_SYMBOL] = true;
+    /**
+     * Builds the system instruction to be appended to the LLM request for
+     * planning.
+     *
+     * @param readonlyContext The readonly context of the invocation.
+     * @param llmRequest The LLM request. Readonly.
+     * @returns The planning system instruction, or undefined if no instruction is
+     *     needed.
+     */
+    abstract buildPlanningInstruction(readonlyContext: ReadonlyContext, llmRequest: LlmRequest): string | undefined;
+    /**
+     * Processes the LLM response for planning.
+     *
+     * @param callbackContext The callback context of the invocation.
+     * @param responseParts The LLM response parts. Readonly.
+     * @returns The processed response parts, or undefined if no processing is
+     *     needed.
+     */
+    abstract processPlanningResponse(callbackContext: Context, responseParts: Part[]): Part[] | undefined;
+}
+export {};

package/dist/types/planners/built_in_planner.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part, ThinkingConfig } from '@google/genai';
+import { Context } from '../agents/context.js';
+import { ReadonlyContext } from '../agents/readonly_context.js';
+import { LlmRequest } from '../models/llm_request.js';
+import { BasePlanner } from './base_planner.js';
+/**
+ * A unique symbol to identify ADK built-in planner classes.
+ * Defined once and shared by all BuiltInPlanner instances.
+ */
+declare const BUILT_IN_PLANNER_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of BuiltInPlanner.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of BuiltInPlanner, false
+ *     otherwise.
+ */
+export declare function isBuiltInPlanner(obj: unknown): obj is BuiltInPlanner;
+/**
+ * The built-in planner that uses model's built-in thinking features.
+ */
+export declare class BuiltInPlanner extends BasePlanner {
+    /** A unique symbol to identify ADK built-in planner class. */
+    readonly [BUILT_IN_PLANNER_SIGNATURE_SYMBOL] = true;
+    /**
+     * Config for model built-in thinking features. An error will be returned if
+     * this field is set for models that don't support thinking.
+     */
+    thinkingConfig: ThinkingConfig;
+    /**
+     * Initializes the built-in planner.
+     *
+     * @param options.thinkingConfig Config for model built-in thinking features.
+     *     An error will be returned if this field is set for models that don't
+     *     support thinking.
+     */
+    constructor(options: {
+        thinkingConfig: ThinkingConfig;
+    });
+    /**
+     * Applies the thinking config to the LLM request.
+     *
+     * @param llmRequest The LLM request to apply the thinking config to.
+     */
+    applyThinkingConfig(llmRequest: LlmRequest): void;
+    buildPlanningInstruction(_readonlyContext: ReadonlyContext, _llmRequest: LlmRequest): string | undefined;
+    processPlanningResponse(_callbackContext: Context, _responseParts: Part[]): Part[] | undefined;
+}
+export {};

package/dist/types/planners/plan_re_act_planner.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part } from '@google/genai';
+import { Context } from '../agents/context.js';
+import { ReadonlyContext } from '../agents/readonly_context.js';
+import { LlmRequest } from '../models/llm_request.js';
+import { BasePlanner } from './base_planner.js';
+/**
+ * Plan-Re-Act planner that constrains the LLM response to generate a plan
+ * before any action/observation.
+ *
+ * Note: this planner does not require the model to support built-in thinking
+ * features or setting the thinking config.
+ */
+export declare class PlanReActPlanner extends BasePlanner {
+    buildPlanningInstruction(_readonlyContext: ReadonlyContext, _llmRequest: LlmRequest): string;
+    processPlanningResponse(_callbackContext: Context, responseParts: Part[]): Part[] | undefined;
+}

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

@@ -121,13 +121,13 @@ export declare abstract class BasePlugin {
      * This callback helps logging and modifying the user message before the
      * runner starts the invocation.
      *
-     * @param params.invocationContext The context for the entire invocation.
-     * @param params.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.
      */
-    onUserMessageCallback(params: {
+    onUserMessageCallback(_params: {
         invocationContext: InvocationContext;
         userMessage: Content;
     }): Promise<Content | undefined>;
@@ -137,13 +137,13 @@ export declare abstract class BasePlugin {
      * This is the first callback to be called in the lifecycle, ideal for global
      * setup or initialization tasks.
      *
-     * @param params.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.
      */
-    beforeRunCallback(params: {
+    beforeRunCallback(_params: {
         invocationContext: InvocationContext;
     }): Promise<Content | undefined>;
     /**
@@ -152,15 +152,15 @@ export declare abstract class BasePlugin {
      * This is the ideal place to make modification to the event before the event
      * is handled by the underlying agent app.
      *
-     * @param params.invocationContext The context for the entire invocation.
-     * @param params.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. Copy `params.event` when
-     *     constructing a replacement to preserve fields that are not being
-     *     modified, such as event actions. Returning `undefined` allows the
+     *     framework to modify or replace the response. Copy the incoming
+     *     `event` when constructing a replacement to preserve fields that are not
+     *     being modified, such as event actions. Returning `undefined` allows the
      *     original response to be used.
      */
-    onEventCallback(params: {
+    onEventCallback(_params: {
         invocationContext: InvocationContext;
         event: Event;
     }): Promise<Event | undefined>;
@@ -170,10 +170,10 @@ export declare abstract class BasePlugin {
      * This is the final callback in the ADK lifecycle, suitable for cleanup,
      * final logging, or reporting tasks.
      *
-     * @param params.invocationContext The context for the entire invocation.
+     * @param _params.invocationContext The context for the entire invocation.
      * @returns undefined
      */
-    afterRunCallback(params: {
+    afterRunCallback(_params: {
         invocationContext: InvocationContext;
     }): Promise<void>;
     /**
@@ -182,13 +182,13 @@ export declare abstract class BasePlugin {
      * This callback can be used for logging, setup, or to short-circuit the
      * agent's execution by returning a value.
      *
-     * @param params.agent The agent that is about to run.
-     * @param params.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.
      */
-    beforeAgentCallback(params: {
+    beforeAgentCallback(_params: {
         agent: BaseAgent;
         callbackContext: Context;
     }): Promise<Content | undefined>;
@@ -198,13 +198,13 @@ export declare abstract class BasePlugin {
      * This callback can be used to inspect, log, or modify the agent's final
      * result before it is returned.
      *
-     * @param params.agent The agent that has just run.
-     * @param params.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.
      */
-    afterAgentCallback(params: {
+    afterAgentCallback(_params: {
         agent: BaseAgent;
         callbackContext: Context;
     }): Promise<Content | undefined>;
@@ -248,13 +248,13 @@ export declare abstract class BasePlugin {
      * object. It can also be used to implement caching by returning a cached
      * `LlmResponse`, which would skip the actual model call.
      *
-     * @param params.callbackContext The context for the current agent call.
-     * @param params.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.
      */
-    beforeModelCallback(params: {
+    beforeModelCallback(_params: {
         callbackContext: Context;
         llmRequest: LlmRequest;
     }): Promise<LlmResponse | undefined>;
@@ -264,13 +264,13 @@ export declare abstract 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 params.callbackContext The context for the current agent call.
-     * @param params.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.
      */
-    afterModelCallback(params: {
+    afterModelCallback(_params: {
         callbackContext: Context;
         llmResponse: LlmResponse;
     }): Promise<LlmResponse | undefined>;
@@ -280,15 +280,15 @@ export declare abstract class BasePlugin {
      * This callback provides an opportunity to handle model errors gracefully,
      * potentially providing alternative responses or recovery mechanisms.
      *
-     * @param params.callbackContext The context for the current agent call.
-     * @param params.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 params.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.
      */
-    onModelErrorCallback(params: {
+    onModelErrorCallback(_params: {
         callbackContext: Context;
         llmRequest: LlmRequest;
         error: Error;
@@ -299,13 +299,13 @@ export declare abstract class BasePlugin {
      * This callback provides an opportunity to inspect, log, or modify the
      * available tools before they are selected.
      *
-     * @param params.callbackContext The context for the current agent call.
-     * @param params.tools The available tools.
+     * @param _params.callbackContext The context for the current agent call.
+     * @param _params.tools The available tools.
      * @returns An optional value. A non-`undefined` return may be used by the
      *     framework to modify or replace the available tools. Returning
      *     `undefined` allows the original tools to be used.
      */
-    beforeToolSelection(params: {
+    beforeToolSelection(_params: {
         callbackContext: Context;
         tools: Readonly<Record<string, BaseTool>>;
     }): Promise<Readonly<Record<string, BaseTool>> | undefined>;
@@ -315,10 +315,10 @@ export declare abstract class BasePlugin {
      * This callback provides an opportunity to inspect or modify the context
      * before it is compacted.
      *
-     * @param params.invocationContext The context for the entire invocation.
-     * @param params.trigger The trigger for the context compaction.
+     * @param _params.invocationContext The context for the entire invocation.
+     * @param _params.trigger The trigger for the context compaction.
      */
-    beforeContextCompaction(params: {
+    beforeContextCompaction(_params: {
         invocationContext: InvocationContext;
         trigger: ContextCompactionTrigger;
     }): Promise<void>;
@@ -328,10 +328,10 @@ export declare abstract class BasePlugin {
      * This callback provides an opportunity to inspect the context
      * after it has been compacted.
      *
-     * @param params.invocationContext The context for the entire invocation.
-     * @param params.trigger The trigger for the context compaction.
+     * @param _params.invocationContext The context for the entire invocation.
+     * @param _params.trigger The trigger for the context compaction.
      */
-    afterContextCompaction(params: {
+    afterContextCompaction(_params: {
         invocationContext: InvocationContext;
         trigger: ContextCompactionTrigger;
     }): Promise<void>;
@@ -341,15 +341,15 @@ export declare abstract class BasePlugin {
      * This callback is useful for logging tool usage, input validation, or
      * modifying the arguments before they are passed to the tool.
      *
-     * @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
+     * @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 params.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.
      */
-    beforeToolCallback(params: {
+    beforeToolCallback(_params: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: Context;
@@ -360,16 +360,16 @@ export declare abstract class BasePlugin {
      * This callback allows for inspecting, logging, or modifying the result
      * returned by a tool.
      *
-     * @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.
+     * @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.
      */
-    afterToolCallback(params: {
+    afterToolCallback(_params: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: Context;
@@ -391,15 +391,15 @@ export declare abstract class BasePlugin {
      * 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.
+     * @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.
      */
-    onToolErrorCallback(params: {
+    onToolErrorCallback(_params: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: Context;