@google/adk 1.2.0 → 1.3.0

package/dist/types/agents/processors/content_processor_utils.d.ts

@@ -34,3 +34,29 @@ export declare function getContents(events: Event[], agentName: string, currentB
  *     needed for proper tool execution while excluding conversation history.
  */
 export declare function getCurrentTurnContents(events: Event[], agentName: string, currentBranch?: string): Content[];
+/**
+ * Merges a list of function_response events into one event.
+ *
+ * The key goal is to ensure:
+ *  1. function_call and function_response are always of the same number.
+ *  2. The function_call and function_response are consecutively in the content.
+ *
+ * @param events: A list of function_response events.
+ *
+ * NOTE:
+ * function_response_events must fulfill these requirements:
+ * 1. The list is in increasing order of timestamp;
+ * 2. the first event is the initial function_response event;
+ * 3. all later events should contain at least one function_response part that
+ * related to the function_call event. Caveat: This implementation doesn't
+ * support when a parallel function_call event contains async function_call of
+ * the same name.
+ *
+ * @returns
+ *    A merged event, that is
+ *      1. All later function_response will replace function_response part in
+ *          the initial function_response event.
+ *      2. All non-function_response parts will be appended to the part list of
+ *          the initial function_response event.
+ */
+export declare function mergeFunctionResponseEvents(events: Event[]): Event;

package/dist/types/agents/processors/content_request_processor.d.ts

@@ -7,7 +7,23 @@ import { Event } from '../../events/event.js';
 import { LlmRequest } from '../../models/llm_request.js';
 import { InvocationContext } from '../invocation_context.js';
 import { BaseLlmRequestProcessor } from './base_llm_processor.js';
+/**
+ * Populates {@link LlmRequest.contents} from the session event history.
+ *
+ * When a {@link CompactedEvent} exists in the session, only the most recent
+ * compacted event and the raw events that follow it are included, eliding
+ * earlier history. The extent of context included depends on the agent's
+ * `includeContents` setting: `'default'` sends the full visible history while
+ * any other value sends only the current-turn context.
+ */
 export declare class ContentRequestProcessor implements BaseLlmRequestProcessor {
+    /**
+     * Fills {@link LlmRequest.contents} based on the session event history and
+     * agent configuration.
+     *
+     * @param invocationContext - The current invocation context.
+     * @param llmRequest - The request whose contents field will be populated.
+     */
     runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
 }
 export declare const CONTENT_REQUEST_PROCESSOR: ContentRequestProcessor;

package/dist/types/agents/processors/context_compactor_request_processor.d.ts

@@ -17,6 +17,18 @@ import { BaseLlmRequestProcessor } from './base_llm_processor.js';
  */
 export declare class ContextCompactorRequestProcessor implements BaseLlmRequestProcessor {
     private compactors;
+    /**
+     * @param compactors - Ordered list of compactors to evaluate; the first one
+     *   that reports it should compact will perform the compaction.
+     */
     constructor(compactors: BaseContextCompactor[]);
+    /**
+     * Evaluates compactors in priority order. The first compactor that indicates
+     * it should compact will compact the session history, fire plugin hooks, and
+     * yield any newly generated events. Iteration stops after one compaction.
+     *
+     * @param invocationContext - The current invocation context.
+     * @param _llmRequest - Unused; present to satisfy the {@link BaseLlmRequestProcessor} interface.
+     */
     runAsync(invocationContext: InvocationContext, _llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
 }

package/dist/types/agents/processors/identity_llm_request_processor.d.ts

@@ -12,6 +12,13 @@ import { BaseLlmRequestProcessor } from './base_llm_processor.js';
  * informing the model of the agent's name and description.
  */
 export declare class IdentityLlmRequestProcessor extends BaseLlmRequestProcessor {
+    /**
+     * Appends agent name and description as identity instructions to the system
+     * prompt of the request.
+     *
+     * @param invocationContext - The current invocation context.
+     * @param llmRequest - The request object to append instructions to.
+     */
     runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, undefined>;
 }
 export declare const IDENTITY_LLM_REQUEST_PROCESSOR: IdentityLlmRequestProcessor;

package/dist/types/agents/processors/request_confirmation_llm_request_processor.d.ts

@@ -12,7 +12,15 @@ import { BaseLlmRequestProcessor } from './base_llm_processor.js';
  * corresponding tools before the next LLM turn.
  */
 export declare class RequestConfirmationLlmRequestProcessor extends BaseLlmRequestProcessor {
-    /** Handles tool confirmation information to build the LLM request. */
+    /**
+     * Resumes tool calls that were paused for user confirmation, re-invoking
+     * them with the confirmed or denied decision before the next LLM turn.
+     *
+     * @param invocationContext - The current invocation context, including the
+     *   session event history used to locate pending confirmation responses.
+     * @yields Function response events for tools that have been confirmed and
+     *   are ready to resume.
+     */
     runAsync(invocationContext: InvocationContext): AsyncGenerator<Event, void, void>;
 }
 export declare const REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR: RequestConfirmationLlmRequestProcessor;

package/dist/types/agents/processors/tool_filter_request_processor.d.ts

@@ -7,8 +7,19 @@ import { Event } from '../../events/event.js';
 import { LlmRequest } from '../../models/llm_request.js';
 import { InvocationContext } from '../invocation_context.js';
 import { BaseLlmRequestProcessor } from './base_llm_processor.js';
+/**
+ * Filters the set of tools on the {@link LlmRequest} by delegating to the
+ * active plugin manager's `beforeToolSelection` hook. If no plugin restricts
+ * the tool set, the request is left unchanged.
+ */
 export declare class ToolFilterRequestProcessor extends BaseLlmRequestProcessor {
-    /** Filters the set of tools on the request based on plugins. */
+    /**
+     * Invokes plugin-based tool filtering and updates {@link LlmRequest.allowedTools}
+     * with the reduced tool set if any plugin returns a filtered result.
+     *
+     * @param invocationContext - The current invocation context.
+     * @param llmRequest - The request whose allowed tools may be restricted.
+     */
     runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
 }
 export declare const TOOL_FILTER_REQUEST_PROCESSOR: ToolFilterRequestProcessor;

package/dist/types/common.d.ts

@@ -34,6 +34,7 @@ export { InMemoryArtifactService } from './artifacts/in_memory_artifact_service.
 export { AuthCredentialTypes } from './auth/auth_credential.js';
 export type { AuthCredential, HttpAuth, HttpCredentials, OAuth2Auth, ServiceAccount, ServiceAccountCredential, } from './auth/auth_credential.js';
 export { AuthHandler } from './auth/auth_handler.js';
+export { AUTH_PREPROCESSOR, AuthPreprocessor } from './auth/auth_preprocessor.js';
 export { AuthProviderRegistry } from './auth/auth_provider_registry.js';
 export { OAuthGrantType } from './auth/auth_schemes.js';
 export type { AuthScheme, OpenIdConnectWithConfig } from './auth/auth_schemes.js';
@@ -123,15 +124,28 @@ export type { DataStoreParams, SearchEngineParams, VertexAISearchConfig, VertexA
 export { VertexRagRetrievalTool } from './tools/vertex_rag_retrieval_tool.js';
 export { LogLevel, getLogger, setLogLevel, setLogger } from './utils/logger.js';
 export type { Logger } from './utils/logger.js';
-export { isGemini2OrAbove } from './utils/model_name.js';
+export { isGemini2OrAbove, isGemini3xFlashLive } from './utils/model_name.js';
 export { zodObjectToSchema } from './utils/simple_zod_to_json.js';
 export { GoogleLLMVariant } from './utils/variant_utils.js';
 export { version } from './version.js';
+export { GCPSkillRegistry } from './skills/gcp_skill_registry.js';
+export type { GCPSkillRegistryOptions } from './skills/gcp_skill_registry.js';
+export { loadAllSkillsInDir, loadSkillFromDir, loadSkillFromZipBuffer, validateSkillDir, } from './skills/loader.js';
 export type { Frontmatter, Resources, Script, Skill } from './skills/skill.js';
+export type { SkillRegistry } from './skills/skill_registry.js';
 export { ListSkillsTool } from './tools/skill/list_skills_tool.js';
 export { LoadSkillResourceTool } from './tools/skill/load_skill_resource_tool.js';
 export { LoadSkillTool } from './tools/skill/load_skill_tool.js';
+export { SearchSkillsTool } from './tools/skill/search_skills_tool.js';
 export { SkillToolset } from './tools/skill/skill_toolset.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 { OpenAPIToolset } from './tools/openapi_tool/openapi_toolset.js';
+export { RestApiTool, createRestApiTool, } from './tools/openapi_tool/rest_api_tool.js';
 export * from './artifacts/base_artifact_service.js';
 export * from './features/feature_registry.js';
 export * from './memory/base_memory_service.js';

package/dist/types/context/summarizers/llm_summarizer.d.ts

@@ -7,8 +7,14 @@ import { CompactedEvent } from '../../events/compacted_event.js';
 import { Event } from '../../events/event.js';
 import { BaseLlm } from '../../models/base_llm.js';
 import { BaseSummarizer } from './base_summarizer.js';
+/** Options for constructing an {@link LlmSummarizer}. */
 export interface LlmSummarizerOptions {
+    /** The LLM instance used to generate the summary. */
     llm: BaseLlm;
+    /**
+     * Optional system prompt prepended to the formatted events. Defaults to a
+     * built-in summarization prompt when omitted.
+     */
     prompt?: string;
 }
 /**
@@ -18,6 +24,17 @@ export interface LlmSummarizerOptions {
 export declare class LlmSummarizer implements BaseSummarizer {
     private readonly llm;
     private readonly prompt;
+    /**
+     * @param options - Configuration specifying the LLM and optional prompt.
+     */
     constructor(options: LlmSummarizerOptions);
+    /**
+     * Summarizes a list of events into a single {@link CompactedEvent} using the
+     * configured LLM.
+     *
+     * @param events - The events to summarize. Must be non-empty.
+     * @returns A promise resolving to the compacted representation.
+     * @throws {Error} If `events` is empty or the LLM returns no content.
+     */
     summarize(events: Event[]): Promise<CompactedEvent>;
 }

package/dist/types/events/event_actions.d.ts

@@ -3,8 +3,8 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { AuthConfig } from '../auth/auth_tool.js';
 import { ToolConfirmation } from '../tools/tool_confirmation.js';
-type AuthConfig = any;
 /**
  * Represents the actions attached to an event.
  */
@@ -89,4 +89,3 @@ export declare function createEventActions(state?: Partial<EventActions>): Event
  * @returns A new {@link EventActions} containing the merged result.
  */
 export declare function mergeEventActions(sources: Array<Partial<EventActions>>, target?: EventActions): EventActions;
-export {};

package/dist/types/integrations/agent_registry/agent_registry_mcp_toolset.d.ts

@@ -25,6 +25,19 @@ export declare class AgentRegistrySingleMCPToolset extends BaseToolset {
     readonly headerProvider?: (context?: ReadonlyContext) => Promise<Record<string, string>> | Record<string, string>;
     readonly authScheme?: AuthScheme;
     readonly authCredential?: AuthCredential;
+    /**
+     * @param options - Configuration for the MCP toolset.
+     * @param options.destinationResourceId - Telemetry identifier injected as
+     *   `gcp.mcp.server.destination.id` into each resolved tool's custom metadata.
+     * @param options.connectionParams - HTTP connection parameters for the MCP server.
+     * @param options.toolFilter - Optional predicate or list of tool names to include.
+     *   When omitted, all tools from the server are returned.
+     * @param options.prefix - Optional prefix prepended to each tool name (e.g. `myServer_toolName`).
+     * @param options.headerProvider - Optional async function called immediately before each
+     *   {@link getTools} invocation to supply or refresh request headers (e.g. GCP auth tokens).
+     * @param options.authScheme - Optional auth scheme forwarded to each resolved tool.
+     * @param options.authCredential - Optional credential forwarded to each resolved tool.
+     */
     constructor(options: {
         destinationResourceId?: string;
         connectionParams: StreamableHTTPConnectionParams;
@@ -35,8 +48,14 @@ export declare class AgentRegistrySingleMCPToolset extends BaseToolset {
         authCredential?: AuthCredential;
     });
     /**
-     * Connects to the underlying MCP server, retrieves tool definitions, prefixes tool names,
-     * and injects destination telemetry metadata.
+     * Connects to the underlying MCP server, retrieves tool definitions, prefixes
+     * tool names, and injects destination telemetry metadata into each tool.
+     *
+     * The `headerProvider`, if configured, is invoked immediately before the
+     * connection is established so that tokens are always fresh.
+     *
+     * @param context - Optional readonly agent context passed to the header provider.
+     * @returns The resolved and optionally filtered list of {@link MCPTool} instances.
      */
     getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
     close(): Promise<void>;

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

@@ -38,6 +38,16 @@ export interface BaseLlmConnection {
      * @param blob The blob to send to the model.
      */
     sendRealtime(blob: Blob): Promise<void>;
+    /**
+     * Optionally signals the start of user activity (e.g. user begins speaking)
+     * for models that support manual activity boundaries.
+     */
+    sendActivityStart?(): Promise<void>;
+    /**
+     * Optionally signals the end of user activity (e.g. user finishes speaking)
+     * for models that support manual activity boundaries.
+     */
+    sendActivityEnd?(): Promise<void>;
     /**
      * Receives the model response using the llm server connection.
      *

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

@@ -1,15 +1,17 @@
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Blob, Content, Session } from '@google/genai';
+import { Blob, Content, LiveServerMessage, Session } from '@google/genai';
 import { BaseLlmConnection } from './base_llm_connection.js';
 import { LlmResponse } from './llm_response.js';
 /** The Gemini model connection. */
 export declare class GeminiLlmConnection implements BaseLlmConnection {
     private readonly geminiSession;
-    constructor(geminiSession: Session);
+    private readonly modelVersion?;
+    private readonly messageQueue?;
+    constructor(geminiSession: Session, modelVersion?: string | undefined, messageQueue?: AsyncIterable<LiveServerMessage> | undefined);
     /**
      * Sends the conversation history to the gemini model.
      *
@@ -36,6 +38,14 @@ export declare class GeminiLlmConnection implements BaseLlmConnection {
      * @param blob The blob to send to the model.
      */
     sendRealtime(blob: Blob): Promise<void>;
+    /**
+     * Sends an activity start signal to the model.
+     */
+    sendActivityStart(): Promise<void>;
+    /**
+     * Sends an activity end signal to the model.
+     */
+    sendActivityEnd(): Promise<void>;
     /**
      * Builds a full text response.
      *
@@ -43,9 +53,10 @@ export declare class GeminiLlmConnection implements BaseLlmConnection {
      * partial.
      *
      * @param text The text to be included in the response.
+     * @param isThought Whether the text is a thought.
+     * @param groundingMetadata The grounding metadata to include.
      * @returns An LlmResponse containing the full text.
      */
-    private buildFullTextResponse;
     receive(): AsyncGenerator<LlmResponse, void, void>;
     /**
      * Closes the llm server connection.

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

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { CitationMetadata, Content, FinishReason, GenerateContentResponse, GenerateContentResponseUsageMetadata, GroundingMetadata, LiveServerSessionResumptionUpdate, Transcription } from '@google/genai';
+import { CitationMetadata, Content, FinishReason, GenerateContentResponse, GenerateContentResponseUsageMetadata, GroundingMetadata, LiveServerGoAway, 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.
@@ -64,6 +64,11 @@ export interface LlmResponse {
      * The session resumption update of the LlmResponse
      */
     liveSessionResumptionUpdate?: LiveServerSessionResumptionUpdate;
+    /**
+     * Server-side signal that the live connection will be closed soon. The
+     * caller should reconnect using the latest session resumption handle.
+     */
+    goAway?: LiveServerGoAway;
     /**
      * Audio transcription of user input.
      */
@@ -72,6 +77,10 @@ export interface LlmResponse {
      * Audio transcription of model output.
      */
     outputTranscription?: Transcription;
+    /** The model version used to generate the response. */
+    modelVersion?: string;
+    /** The session ID of the Live session. */
+    liveSessionId?: string;
 }
 /**
  * Creates an LlmResponse from a GenerateContentResponse.

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

@@ -17,18 +17,37 @@ export declare enum PolicyOutcome {
     CONFIRM = "CONFIRM",
     ALLOW = "ALLOW"
 }
+/** The result returned by a policy engine after evaluating a tool call. */
 export interface PolicyCheckResult {
+    /** The policy decision: `ALLOW`, `DENY`, or `CONFIRM`. */
     outcome: string;
+    /** Optional human-readable explanation of the decision. */
     reason?: string;
 }
+/** Context passed to a policy engine when evaluating a tool call. */
 export interface ToolCallPolicyContext {
+    /** The tool being invoked. */
     tool: BaseTool;
+    /** The arguments supplied to the tool call. */
     toolArgs: Record<string, unknown>;
 }
+/** Interface for policy engines that gate tool call execution. */
 export interface BasePolicyEngine {
+    /**
+     * Evaluates whether a tool call should be allowed, denied, or confirmed.
+     *
+     * @param context - The tool and its arguments to evaluate.
+     * @returns A promise resolving to the policy decision.
+     */
     evaluate(context: ToolCallPolicyContext): Promise<PolicyCheckResult>;
 }
+/** In-memory policy engine that permits all tool calls. Intended for prototyping. */
 export declare class InMemoryPolicyEngine implements BasePolicyEngine {
+    /**
+     * Always returns {@link PolicyOutcome.ALLOW} for every tool call.
+     *
+     * @returns A promise resolving to an ALLOW result.
+     */
     evaluate(): Promise<PolicyCheckResult>;
 }
 /**
@@ -36,9 +55,20 @@ export declare class InMemoryPolicyEngine implements BasePolicyEngine {
  */
 export declare class SecurityPlugin extends BasePlugin {
     private readonly policyEngine;
+    /**
+     * @param params - Optional configuration. Defaults to {@link InMemoryPolicyEngine}
+     *   when no policy engine is provided.
+     */
     constructor(params?: {
         policyEngine?: BasePolicyEngine;
     });
+    /**
+     * Intercepts tool calls, evaluating them against the policy engine before
+     * execution and handling confirmation flows for calls that require it.
+     *
+     * @returns A partial or error response object if the call is blocked or
+     *   awaiting confirmation, or `undefined` to allow execution to proceed.
+     */
     beforeToolCallback({ tool, toolArgs, toolContext, }: {
         tool: BaseTool;
         toolArgs: {

package/dist/types/sessions/base_session_service.d.ts

@@ -156,6 +156,10 @@ export declare abstract class BaseSessionService {
  * Removes temporary state delta keys from the event.
  */
 export declare function trimTempDeltaState(event: Event): Event;
+/**
+ * Removes temporary state keys from the state.
+ */
+export declare function trimTempState(state: Record<string, unknown>): Record<string, unknown>;
 /**
  * Merges app state, user state, and session state.
  *

package/dist/types/sessions/db/schema.d.ts

@@ -7,6 +7,7 @@ import { PrimaryKey } from '@mikro-orm/core';
 import { Event } from '../../events/event.js';
 export declare const SCHEMA_VERSION_KEY = "schema_version";
 export declare const SCHEMA_VERSION_1_JSON = "1";
+export declare const STORAGE_KEY_COLUMN_LENGTH = 191;
 export declare class StorageMetadata {
     key: string;
     value: string;

package/dist/types/skills/gcp_skill_registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client } from '@google-cloud/vertexai';
+import { Frontmatter, Skill } from './skill.js';
+import { SkillRegistry } from './skill_registry.js';
+export interface GCPSkillRegistryOptions {
+    projectId?: string;
+    location?: string;
+    client?: Client;
+}
+/**
+ * GCP implementation of SkillRegistry using GCP Skill Registry API.
+ */
+export declare class GCPSkillRegistry implements SkillRegistry {
+    private readonly projectId?;
+    private readonly location?;
+    private readonly client;
+    constructor(options?: GCPSkillRegistryOptions);
+    getSkill(name: string): Promise<Skill>;
+    searchSkills(query: string): Promise<Frontmatter[]>;
+}

package/dist/types/skills/loader.d.ts

@@ -36,3 +36,10 @@ export declare function validateSkillDir(skillDir: string): Promise<string[]>;
  * @returns A promise that resolves to a map of skill names to their corresponding Skill objects.
  */
 export declare function loadAllSkillsInDir(skillsBasePath: string): Promise<Record<string, Skill>>;
+/**
+ * Loads a complete skill directly from in-memory zip file buffer.
+ *
+ * @param zipBuffer - The raw Buffer of the zip file containing the skill.
+ * @returns A Skill object with all components loaded.
+ */
+export declare function loadSkillFromZipBuffer(zipBuffer: Buffer): Skill;

package/dist/types/skills/skill.d.ts

@@ -8,7 +8,7 @@ export declare const SNAKE_OR_KEBAB_NAME_PATTERN: RegExp;
 /**
  * Schema and Type for Skill Frontmatter metadata.
  */
-export declare const FrontmatterSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+export declare const FrontmatterSchema: z.ZodPreprocess<z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     license: z.ZodOptional<z.ZodString>;

package/dist/types/skills/skill_registry.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Frontmatter, Skill } from './skill.js';
+/**
+ * Interface for a skill registry.
+ */
+export interface SkillRegistry {
+    /**
+     * Fetches a skill from the registry.
+     *
+     * @param name The name of the skill.
+     * @returns A Promise resolving to a Skill object.
+     */
+    getSkill(name: string): Promise<Skill>;
+    /**
+     * Searches for skills in the registry.
+     *
+     * @param query The search query.
+     * @returns A Promise resolving to a list of Frontmatter objects for discovery.
+     */
+    searchSkills(query: string): Promise<Frontmatter[]>;
+    /**
+     * Returns the description for the search_skills tool.
+     */
+    searchToolDescription?(): string | undefined;
+}

package/dist/types/tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+import { ApiParameter } from './operation_parser.js';
+export interface OperationEndpoint {
+    baseUrl: string;
+    path: string;
+    method: string;
+}
+export interface ParsedOperation {
+    name: string;
+    description: string;
+    endpoint: OperationEndpoint;
+    operation: OpenAPIV3.OperationObject;
+    parameters: ApiParameter[];
+    returnValue?: ApiParameter;
+    authScheme?: OpenAPIV3.SecuritySchemeObject;
+}
+export declare class OpenApiSpecParser {
+    private preservePropertyNames;
+    constructor(options?: {
+        preservePropertyNames?: boolean;
+    });
+    /**
+     * Parses an OpenAPI specification document and extracts a list of operations.
+     *
+     * @param openapiSpec The OpenAPI V3 document to parse.
+     * @returns An array of parsed operations.
+     */
+    parse(openapiSpec: OpenAPIV3.Document): ParsedOperation[];
+}

package/dist/types/tools/openapi_tool/openapi_spec_parser/operation_parser.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+export interface ApiParameter {
+    originalName: string;
+    paramLocation: string;
+    paramSchema: OpenAPIV3.SchemaObject;
+    description?: string;
+    name: string;
+    required: boolean;
+}
+/**
+ * Parses an OpenAPI OperationObject and extracts its parameters, request body, and return value.
+ *
+ * It maps OpenAPI parameters and request bodies into a flat list of `ApiParameter` objects
+ * that are compatible with Gemini's tool function declarations.
+ */
+export declare class OperationParser {
+    private readonly operation;
+    private params;
+    private returnValue?;
+    private preservePropertyNames;
+    constructor(operation: OpenAPIV3.OperationObject, options?: {
+        preservePropertyNames?: boolean;
+    });
+    private getParamName;
+    private processOperationParameters;
+    private processRequestBody;
+    private processReturnValue;
+    private dedupeParamNames;
+    /**
+     * Gets the list of parsed parameters extracted from the OpenAPI operation.
+     *
+     * @returns An array of parsed parameters.
+     */
+    getParameters(): ApiParameter[];
+    /**
+     * Generates a JSON schema representing the arguments of the tool function call.
+     *
+     * @returns A JSON Schema object.
+     */
+    getJsonSchema(): Record<string, unknown>;
+    /**
+     * Gets a valid tool function name derived from the operation's operationId.
+     *
+     * @throws {Error} If the operation does not have an operationId.
+     * @returns A string representing the function name.
+     */
+    getFunctionName(): string;
+    /**
+     * Gets the description of the tool, derived from the operation's description or summary.
+     *
+     * @returns A string representing the description.
+     */
+    getDescription(): string;
+}

package/dist/types/tools/openapi_tool/openapi_spec_parser/tool_auth_handler.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+import { Context } from '../../../agents/context.js';
+import { AuthCredential } from '../../../auth/auth_credential.js';
+export interface AuthPreparationResult {
+    state: 'pending' | 'done';
+    authCredential?: AuthCredential;
+}
+export declare class ToolAuthHandler {
+    private readonly context;
+    private readonly authScheme?;
+    private readonly authCredential?;
+    private readonly credentialKey?;
+    constructor(context: Context, authScheme?: OpenAPIV3.SecuritySchemeObject | undefined, authCredential?: AuthCredential | undefined, credentialKey?: string | undefined);
+    static fromToolContext(context: Context, authScheme?: OpenAPIV3.SecuritySchemeObject, authCredential?: AuthCredential, options?: {
+        credentialKey?: string;
+    }): ToolAuthHandler;
+    prepareAuthCredentials(): Promise<AuthPreparationResult>;
+}

package/dist/types/tools/openapi_tool/openapi_toolset.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { AuthCredential } from '../../auth/auth_credential.js';
+import { BaseTool } from '../base_tool.js';
+import { BaseToolset, ToolPredicate } from '../base_toolset.js';
+export declare class OpenAPIToolset extends BaseToolset {
+    private tools;
+    constructor(options?: {
+        specDict?: OpenAPIV3.Document;
+        specStr?: string;
+        specType?: 'json' | 'yaml';
+        toolFilter?: ToolPredicate | string[];
+        prefix?: string;
+        preservePropertyNames?: boolean;
+        authScheme?: OpenAPIV3.SecuritySchemeObject;
+        authCredential?: AuthCredential;
+        credentialKey?: string;
+        headerProvider?: (context: ReadonlyContext) => Record<string, string>;
+    });
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    close(): Promise<void>;
+}