@google/adk 2.3.0 → 2.5.0

package/dist/types/telemetry/export/google_cloud.d.ts

@@ -0,0 +1,189 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Resource } from '@opentelemetry/resources';
+import { BatchLogRecordProcessor, BatchLogRecordProcessorOptions, LogRecordExporter, ReadWriteLogRecord } from '@opentelemetry/sdk-logs';
+import { AggregationTemporality, InstrumentType, PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
+import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { GoogleAuth } from 'google-auth-library';
+import { agentRuntimeRequestHooks, type AgentRuntimeRequestHooks } from './agent_runtime.js';
+import { OtelExportersConfig, OTelHooks } from './setup.js';
+export { agentRuntimeRequestHooks, type AgentRuntimeRequestHooks };
+/**
+ * Resolved project identifiers from the Cloud Resource Manager API.
+ */
+export interface ProjectInfo {
+    readonly id: string;
+    readonly number: string;
+}
+/**
+ * Clears the cached project identifiers.
+ */
+export declare function clearProjectCache(): void;
+/**
+ * Selects standard or mTLS endpoint based on environment settings.
+ */
+export declare function getTelemetryEndpoint(defaultEndpoint: string, mtlsEndpoint: string): string;
+/**
+ * Returns the Vertex Agent Engine User-Agent header when telemetry is enabled.
+ */
+export declare function getAgentEngineUserAgentHeader(): Record<string, string>;
+/**
+ * Authenticated OTLP trace exporter wrapper sending spans to Google Cloud.
+ */
+export declare class AuthenticatedTraceExporter implements SpanExporter {
+    private readonly auth;
+    private readonly endpoint;
+    private readonly userAgentHeaders;
+    private readonly delegate;
+    private currentHeaders;
+    private warnedAuthFailure;
+    constructor(auth: GoogleAuth, endpoint: string, userAgentHeaders?: Record<string, string>);
+    /**
+     * Exports spans to Google Cloud.
+     *
+     * @param spans Spans to export.
+     * @param resultCallback Callback called with the export result.
+     */
+    export(spans: ReadableSpan[], resultCallback: (result: {
+        code: number;
+        error?: Error;
+    }) => void): void;
+    private exportAsync;
+    /**
+     * Shuts down the trace exporter.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Flushes pending traces.
+     */
+    forceFlush(): Promise<void>;
+}
+/**
+ * Authenticated OTLP metric exporter wrapper sending metrics to Google Cloud.
+ */
+export declare class AuthenticatedMetricExporter implements PushMetricExporter {
+    private readonly auth;
+    private readonly endpoint;
+    private readonly userAgentHeaders;
+    private readonly delegate;
+    private currentHeaders;
+    private warnedAuthFailure;
+    constructor(auth: GoogleAuth, endpoint: string, userAgentHeaders?: Record<string, string>);
+    /**
+     * Exports metrics to Google Cloud.
+     *
+     * @param metrics Metrics to export.
+     * @param resultCallback Callback called with the export result.
+     */
+    export(metrics: ResourceMetrics, resultCallback: (result: {
+        code: number;
+        error?: Error;
+    }) => void): void;
+    private exportAsync;
+    /**
+     * Shuts down the metric exporter.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Flushes pending metrics.
+     */
+    forceFlush(): Promise<void>;
+    /**
+     * Selects aggregation temporality for instrument type.
+     *
+     * @param instrumentType Instrument type.
+     */
+    selectAggregationTemporality(instrumentType: InstrumentType): AggregationTemporality;
+}
+/**
+ * Authenticated OTLP log exporter wrapper sending logs to Google Cloud.
+ */
+export declare class AuthenticatedLogExporter implements LogRecordExporter {
+    private readonly auth;
+    private readonly endpoint;
+    private readonly userAgentHeaders;
+    private readonly delegate;
+    private currentHeaders;
+    private warnedAuthFailure;
+    constructor(auth: GoogleAuth, endpoint: string, userAgentHeaders?: Record<string, string>);
+    /**
+     * Exports log records to Google Cloud.
+     *
+     * @param logs Log records to export.
+     * @param resultCallback Callback called with the export result.
+     */
+    export(logs: ReadWriteLogRecord[], resultCallback: (result: {
+        code: number;
+        error?: Error;
+    }) => void): void;
+    private exportAsync;
+    /**
+     * Shuts down the log exporter.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Flushes pending log records.
+     */
+    forceFlush(): Promise<void>;
+}
+/**
+ * Options for configuring {@link GCPBatchLogRecordProcessor}.
+ */
+export interface GCPBatchLogRecordProcessorOptions extends Partial<BatchLogRecordProcessorOptions> {
+    readonly exporter: LogRecordExporter;
+    readonly projectId?: string;
+}
+/**
+ * Batching log processor keeping Cloud Logging log names and labels stable.
+ */
+export declare class GCPBatchLogRecordProcessor extends BatchLogRecordProcessor {
+    private readonly defaultLogName;
+    private readonly logResource;
+    constructor(exporterOrOptions: LogRecordExporter | GCPBatchLogRecordProcessorOptions, projectId?: string);
+    onEmit(logRecord: ReadWriteLogRecord): void;
+}
+/**
+ * Looks up project number and ID via Cloud Resource Manager API with in-memory caching.
+ *
+ * Successful lookups require the `resourcemanager.projects.get` permission.
+ *
+ * @param project The project ID or number to query.
+ * @param auth Optional GoogleAuth instance to use.
+ * @returns Resolved project identifiers, or empty strings if resolution fails.
+ */
+export declare function fetchProject(project?: string, auth?: GoogleAuth): Promise<ProjectInfo>;
+/**
+ * Resolves the GCP project ID from parameter, environment, or Application Default Credentials.
+ *
+ * @param auth Optional GoogleAuth instance to use for resolution.
+ * @returns The resolved project ID, or undefined if it cannot be determined.
+ */
+export declare function getGcpProjectId(auth?: GoogleAuth): Promise<string | undefined>;
+/**
+ * Builds the OTel resource describing a Google Cloud deployment.
+ *
+ * Applies layered precedence: common resource, Agent Runtime resource,
+ * OTel environment detector, GCP detector, and Agent Registry URN enrichment.
+ *
+ * @param projectId Optional project ID. Falls back to GOOGLE_CLOUD_PROJECT or ADC.
+ * @returns Detected Resource object.
+ */
+export declare function getGcpResource(projectId?: string): Promise<Resource>;
+/**
+ * Returns OTel processors and readers configured for export to Google Cloud.
+ *
+ * Sends traces, metrics, and logs via OTLP over HTTP to telemetry.googleapis.com.
+ * On Agent Runtime (`GOOGLE_CLOUD_AGENT_ENGINE_ID` set) the metric reader is
+ * request-driven and starts no background timer. Custom servers calling
+ * `getGcpExporters` with {@link maybeSetOtelProviders} on Agent Runtime must
+ * wrap each request with {@link agentRuntimeRequestHooks} to drive the metric
+ * reader and flush the span and log processors; without those hooks, the reader
+ * never collects except on `forceFlush()` or `shutdown()`.
+ *
+ * @param config Configuration options for enabled signals and project.
+ * @returns OTelHooks containing configured processors and readers.
+ */
+export declare function getGcpExporters(config?: OtelExportersConfig): Promise<OTelHooks>;

package/dist/types/telemetry/export/request_driven_metric_reader.d.ts

@@ -0,0 +1,144 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MetricReader, type PushMetricExporter } from '@opentelemetry/sdk-metrics';
+/**
+ * The minimum spacing, in milliseconds, between two metric exports to
+ * telemetry.googleapis.com.
+ *
+ * Every ADK metric reader that exports there stays at or above it: it is the
+ * default floor of {@link RequestDrivenMetricReader} and the export interval of
+ * the periodic reader. The backend tolerates slightly faster points to absorb
+ * drift, but that is not a supported rate.
+ */
+export declare const MIN_EXPORT_INTERVAL_MS = 5000;
+declare const REQUEST_DRIVEN_METRIC_READER_SIGNATURE_SYMBOL: unique symbol;
+/** Options for {@link RequestDrivenMetricReader}. */
+export interface RequestDrivenMetricReaderOptions {
+    /** The exporter each collect is sent to. */
+    readonly exporter: PushMetricExporter;
+    /**
+     * The spacing of the guidepost grid, in milliseconds. Defaults to
+     * `OTEL_METRIC_EXPORT_INTERVAL`, or 60000.
+     */
+    readonly exportIntervalMillis?: number;
+    /**
+     * The timeout of one collect and one export, in milliseconds. Defaults to
+     * `OTEL_METRIC_EXPORT_TIMEOUT`, or 30000.
+     */
+    readonly exportTimeoutMillis?: number;
+    /**
+     * The minimum spacing between two collects, in milliseconds. Defaults to
+     * `GOOGLE_CLOUD_AGENT_ENGINE_METRICS_COLLECTION_INTERVAL_FLOOR_MS`, or
+     * `MIN_EXPORT_INTERVAL_MS`.
+     */
+    readonly floorMillis?: number;
+    /** A monotonic millisecond clock. Defaults to `performance.now`. */
+    readonly now?: () => number;
+}
+/**
+ * Returns whether `obj` is a {@link RequestDrivenMetricReader}, including one
+ * from another copy of this package.
+ */
+export declare function isRequestDrivenMetricReader(obj: unknown): obj is RequestDrivenMetricReader;
+/**
+ * A metric reader that collects and exports only from the request path, with
+ * no background timer.
+ *
+ * On a runtime that bills per request, such as Agent Runtime, the CPU is
+ * throttled as soon as a request ends. A periodic reader's timer gets no CPU
+ * between requests, so its exports are delayed or dropped. This reader keeps
+ * three invariants instead:
+ *
+ * - I1, export only while serving: every collect runs while a request is in
+ *   flight, the only time the CPU is guaranteed.
+ * - I2, a floor: two collects are never closer than `floorMillis`.
+ * - I3, a guidepost: the export period is a grid of hint times, not a
+ *   schedule. Under sustained load a passed guidepost forces a collect, so
+ *   points cannot pile up.
+ *
+ * Collects are triggered by:
+ *
+ * - {@link onRequestEnd}, when the last request in flight ends and the floor
+ *   allows it (the drain).
+ * - {@link onRequestStart}, when the request overlaps another one and a
+ *   guidepost has passed. A guidepost that lands within the floor of the last
+ *   collect is muted, and the grid moves one period on.
+ * - The start of a model call, when 1.5 periods have passed since the later
+ *   of the start of the busy period and the last collect. The model-call
+ *   instrumentation calls this through a hook the reader installs when a
+ *   `MeterProvider` registers it. Because that hook uses a single
+ *   process-global slot where the last registered reader wins, only a single
+ *   active reader is supported.
+ *
+ * Residual loss case: a request shorter than the floor that ends right after
+ * a collect has its drain muted by the floor. If it is the last request
+ * before the process goes idle, no later collect comes and its points are
+ * lost.
+ *
+ * The defaults come from `OTEL_METRIC_EXPORT_INTERVAL` (60000),
+ * `OTEL_METRIC_EXPORT_TIMEOUT` (30000) and
+ * `GOOGLE_CLOUD_AGENT_ENGINE_METRICS_COLLECTION_INTERVAL_FLOOR_MS` (5000). An
+ * explicit option wins over its variable. A value that is not a valid number
+ * logs a warning and uses the default.
+ *
+ * None of the request methods throws or rejects.
+ */
+export declare class RequestDrivenMetricReader extends MetricReader {
+    readonly [REQUEST_DRIVEN_METRIC_READER_SIGNATURE_SYMBOL] = true;
+    private readonly exporter;
+    private readonly now;
+    private readonly periodMillis;
+    private readonly exportTimeoutMillis;
+    private readonly floorMillis;
+    private readonly inferenceStartHook;
+    private inFlight;
+    private lastCollect?;
+    /** When in-flight last went from zero to one. */
+    private busyStart?;
+    private nextDue;
+    /** The collect now running; set while one runs, so collects never overlap. */
+    private runningCollect?;
+    private isShutdown;
+    private warnedNoRequest;
+    constructor({ exporter, exportIntervalMillis, exportTimeoutMillis, floorMillis, now, }: RequestDrivenMetricReaderOptions);
+    /** Marks a request as started, and collects if a guidepost has passed. */
+    onRequestStart(): void;
+    /**
+     * Marks a request as ended. Collects when no request is left in flight and
+     * the floor allows it, and resolves once any running collect has exported.
+     */
+    onRequestEnd(): Promise<void>;
+    /** Collects at a model-call start if the busy period is overdue. */
+    onInferenceStart(): void;
+    /**
+     * Registers the model-call start hook when a provider initializes this
+     * reader.
+     *
+     * Because the hook uses a single process-global slot where the last
+     * registered reader wins, only a single active reader is supported.
+     */
+    protected onInitialized(): void;
+    /** Shuts down the reader, exports remaining metrics, and cleans up hooks. */
+    protected onShutdown(): Promise<void>;
+    /** Flushes any in-flight and pending metric exports. */
+    protected onForceFlush(): Promise<void>;
+    private canCollect;
+    private floorAllows;
+    /**
+     * Returns whether the current busy period has gone 1.5 periods without a
+     * collect. A collect from an earlier busy period does not count, so a short
+     * request after an idle gap is never overdue: collecting at its model call
+     * would set the floor and mute the drain that carries its points.
+     */
+    private isOverdue;
+    /** Starts a collect, and moves the guidepost grid past `now`. */
+    private startCollect;
+    /** Runs one collect and export as the running collect. Never rejects. */
+    private runExclusive;
+    private collectAndExport;
+    private export;
+}
+export {};

package/dist/types/telemetry/{setup.d.ts → export/setup.d.ts}

@@ -7,10 +7,13 @@ import { Resource } from '@opentelemetry/resources';
 import { LogRecordProcessor } from '@opentelemetry/sdk-logs';
 import { MetricReader } from '@opentelemetry/sdk-metrics';
 import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import type { GoogleAuth } from 'google-auth-library';
 export interface OtelExportersConfig {
     enableTracing?: boolean;
     enableMetrics?: boolean;
     enableLogging?: boolean;
+    projectId?: string;
+    auth?: GoogleAuth;
 }
 /**
  * Configuration hooks for OpenTelemetry setup.

package/dist/types/tools/agent_tool.d.ts

@@ -37,7 +37,7 @@ export declare function isAgentTool(obj: unknown): obj is AgentTool;
  * application. The agent's input schema is used to define the tool's input
  * parameters, and the agent's output is returned as the tool's result.
  *
- *  @param config: The configuration of the agent tool.
+ * @param config The configuration of the agent tool.
  */
 export declare class AgentTool extends BaseTool {
     /** A unique symbol to identify ADK agent tool class. */

package/dist/types/tools/apihub_tool/apihub_toolset.d.ts

@@ -7,8 +7,7 @@ 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 } from '../base_toolset.js';
-import { RestApiTool } from '../openapi_tool/rest_api_tool.js';
+import { BaseToolset, ToolPredicate } from '../base_toolset.js';
 import { BaseAPIHubClient } from './clients/apihub_client.js';
 /** Options for {@link APIHubToolset}. */
 export interface APIHubToolsetOptions {
@@ -44,8 +43,8 @@ export interface APIHubToolsetOptions {
      */
     description?: string;
     /**
-     * When true, the spec is fetched on the first call to `getTools` or
-     * `getTool` instead of when the toolset is constructed.
+     * When true, the spec is fetched on the first call to `getTools`
+     * instead of when the toolset is constructed.
      */
     lazyLoadSpec?: boolean;
     /** Auth scheme applied to every tool the spec produces. */
@@ -57,13 +56,18 @@ export interface APIHubToolsetOptions {
      * built from `accessToken` and `serviceAccountJson`.
      */
     apihubClient?: BaseAPIHubClient;
+    /**
+     * Filter selecting which tools from the spec are exposed by `getTools`.
+     * Accepts a list of tool names or a {@link ToolPredicate} function.
+     */
+    toolFilter?: ToolPredicate | string[];
 }
 /**
  * Builds one tool per operation of an API registered in API Hub.
  *
  * The toolset fetches an OpenAPI spec from API Hub, parses it as YAML or JSON,
  * and hands it to an {@link OpenAPIToolset}, which produces a
- * {@link RestApiTool} for each operation.
+ * `RestApiTool` for each operation.
  *
  * ```ts
  * const toolset = new APIHubToolset({
@@ -79,11 +83,11 @@ export interface APIHubToolsetOptions {
  *
  * By default the spec is fetched when the toolset is constructed. A
  * constructor cannot wait for the request, so a failure is reported by the
- * first call to `getTools` or `getTool`, and every later call reports the same
+ * first call to `getTools`, and every later call reports the same
  * failure.
  *
- * With `lazyLoadSpec`, the spec is fetched on the first call to `getTools` or
- * `getTool`. A successful result is kept, including a spec that produced no
+ * With `lazyLoadSpec`, the spec is fetched on the first call to `getTools`.
+ * A successful result is kept, including a spec that produced no
  * tools. A failed fetch is not kept, so the next call fetches again.
  */
 export declare class APIHubToolset extends BaseToolset {
@@ -91,8 +95,8 @@ export declare class APIHubToolset extends BaseToolset {
     name: string;
     /** The toolset description, filled in from the spec when empty. */
     description: string;
-    readonly apihubResourceName: string;
-    readonly lazyLoadSpec: boolean;
+    private readonly apihubResourceName;
+    private readonly lazyLoadSpec;
     private readonly apihubClient;
     private readonly authScheme?;
     private readonly authCredential?;
@@ -105,17 +109,6 @@ export declare class APIHubToolset extends BaseToolset {
      * @throws When the spec cannot be fetched or is not valid YAML or JSON.
      */
     getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
-    /**
-     * Returns the tool with the given name, or `undefined` when the spec
-     * produced no such tool.
-     *
-     * Unlike `OpenAPIToolset.getTool`, the result is a Promise, because the spec
-     * may still be loading.
-     *
-     * @param name The tool name, which is the operation ID in snake_case.
-     * @throws When the spec cannot be fetched or is not valid YAML or JSON.
-     */
-    getTool(name: string): Promise<RestApiTool | undefined>;
     close(): Promise<void>;
     private loadToolset;
     private prepareTools;

package/dist/types/tools/application_integration_tool/application_integration_toolset.d.ts

@@ -3,18 +3,26 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { AuthCredential } from '../../auth/auth_credential.js';
+import { AuthScheme } from '../../auth/auth_schemes.js';
 import { BaseTool } from '../base_tool.js';
-import { BaseToolset } from '../base_toolset.js';
+import { BaseToolset, ToolPredicate } from '../base_toolset.js';
+import { IntegrationConnectorTool, type IntegrationConnectorToolOptions } from './integration_connector_tool.js';
+export { IntegrationConnectorTool, type IntegrationConnectorToolOptions };
 /** Options of {@link ApplicationIntegrationToolset}. */
 export interface ApplicationIntegrationToolsetOptions {
     /** The Google Cloud project ID. */
     project: string;
     /** The Google Cloud location, such as `us-central1`. */
     location: string;
-    /** The integration name. Set it together with `trigger`. */
+    /** The integration name. Set it together with `triggers` or alone for all triggers. */
     integration?: string;
-    /** The API trigger ID of the integration, such as `api_trigger/my_trigger`. */
-    trigger?: string;
+    /**
+     * The API trigger IDs of the integration, such as
+     * `['api_trigger/my_trigger']`.
+     */
+    triggers?: string[];
     /**
      * The Integration Connectors connection name. Set it together with
      * `entityOperations`, `actions`, or both.
@@ -29,7 +37,7 @@ export interface ApplicationIntegrationToolsetOptions {
     /** Connection actions to expose, such as `['ExecuteCustomQuery']`. */
     actions?: string[];
     /** Prefix of every generated tool name. Defaults to `''`. */
-    toolName?: string;
+    toolNamePrefix?: string;
     /** Text appended to every generated tool description. Defaults to `''`. */
     toolInstructions?: string;
     /**
@@ -38,6 +46,20 @@ export interface ApplicationIntegrationToolsetOptions {
      * Default Credentials.
      */
     serviceAccountJson?: string;
+    /**
+     * Authentication scheme for dynamic end-user credentials on connection tools,
+     * when `authOverrideEnabled` is enabled on the connection.
+     */
+    authScheme?: AuthScheme;
+    /**
+     * Authentication credential for dynamic end-user credentials on connection
+     * tools, when `authOverrideEnabled` is enabled on the connection.
+     */
+    authCredential?: AuthCredential;
+    /**
+     * Filter used to select which generated tools are exposed by `getTools`.
+     */
+    toolFilter?: ToolPredicate | string[];
 }
 /**
  * A toolset generated from a Google Cloud Application Integration API trigger,
@@ -53,7 +75,7 @@ export interface ApplicationIntegrationToolsetOptions {
  *   project: 'my-project',
  *   location: 'us-central1',
  *   integration: 'my-integration',
- *   trigger: 'api_trigger/my_trigger',
+ *   triggers: ['api_trigger/my_trigger'],
  * });
  *
  * @example
@@ -69,9 +91,10 @@ export interface ApplicationIntegrationToolsetOptions {
 export declare class ApplicationIntegrationToolset extends BaseToolset {
     private readonly options;
     private toolsPromise?;
+    private openApiToolsets;
     /**
-     * @throws Error Unless the options name either an integration and a trigger,
-     *   or a connection with at least one entity operation or action.
+     * @throws Error Unless the options name either an integration, or a
+     *   connection with at least one entity operation or action.
      */
     constructor(options: ApplicationIntegrationToolsetOptions);
     /**
@@ -80,7 +103,7 @@ export declare class ApplicationIntegrationToolset extends BaseToolset {
      * The first call fetches the spec and builds the tools. Concurrent calls
      * share that load. When it fails, the next call tries again.
      */
-    getTools(): Promise<BaseTool[]>;
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
     close(): Promise<void>;
     private loadTools;
 }

package/dist/types/tools/application_integration_tool/clients/connections_client.d.ts

@@ -21,6 +21,8 @@ export interface ConnectionsClientOptions {
 }
 /** Service details of an Integration Connectors connection. */
 export interface ConnectionDetails {
+    /** The resource name of the connection, or `''` when not reported. */
+    name?: string;
     /**
      * The Service Directory name of the connection. For a connection with a
      * `host`, the TLS Service Directory name.
@@ -159,21 +161,35 @@ export declare function updateOperation(options: EntityOperationOptions): JsonOb
  */
 export declare function deleteOperation(options: EntityOperationOptions): JsonObject;
 /** Builds the request schema of the create operation of an entity. */
-export declare function createOperationRequest(entity: string): JsonObject;
+export declare function createOperationRequest(entity: string, options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
 /** Builds the request schema of the update operation of an entity. */
-export declare function updateOperationRequest(entity: string): JsonObject;
+export declare function updateOperationRequest(entity: string, options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
 /** Builds the request schema of the get operation. */
-export declare function getOperationRequest(): JsonObject;
+export declare function getOperationRequest(options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
 /** Builds the request schema of the delete operation. */
-export declare function deleteOperationRequest(): JsonObject;
+export declare function deleteOperationRequest(options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
 /** Builds the request schema of the list operation. */
-export declare function listOperationRequest(): JsonObject;
+export declare function listOperationRequest(options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
 /** Builds the request schema of an action. */
-export declare function actionRequest(action: string): JsonObject;
+export declare function actionRequest(action: string, options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
 /** Builds the response schema of an action. */
 export declare function actionResponse(action: string): JsonObject;
 /** Builds the request schema of the `ExecuteCustomQuery` action. */
-export declare function executeCustomQueryRequest(): JsonObject;
+export declare function executeCustomQueryRequest(options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
 /**
  * A client for the Integration Connectors API.
  *
@@ -186,22 +202,24 @@ export declare class ConnectionsClient {
     private readonly tokenSource;
     constructor(options: ConnectionsClientOptions);
     /**
-     * Reads the service name and host of the connection, and whether it allows
-     * an authentication override.
+     * Reads the resource name, service name and host of the connection, and
+     * whether it allows an authentication override.
      */
     getConnectionDetails(): Promise<ConnectionDetails>;
     /**
      * Reads the JSON schema of an entity and the operations it supports.
      *
      * @param entity The entity name.
-     * @throws Error When the API starts no operation for the entity.
+     * @throws Error When the API starts no operation for the entity, or the
+     *   operation fails or times out.
      */
     getEntitySchemaAndOperations(entity: string): Promise<EntitySchemaAndOperations>;
     /**
      * Reads the input and output JSON schemas of an action.
      *
      * @param action The action name.
-     * @throws Error When the API starts no operation for the action.
+     * @throws Error When the API starts no operation for the action, or the
+     *   operation fails or times out.
      */
     getActionSchema(action: string): Promise<ActionSchema>;
     /**
@@ -210,6 +228,11 @@ export declare class ConnectionsClient {
      */
     connectorPayload(jsonSchema: JsonObject): JsonObject;
     private executeApiCall;
-    /** Polls a long-running operation until it reports `done`. */
+    /**
+     * Polls a long-running operation until it reports `done`.
+     *
+     * @throws Error When the operation reports an `error` or does not finish
+     *   within `MAX_OPERATION_POLL_ATTEMPTS` polls.
+     */
     private pollOperation;
 }

package/dist/types/tools/application_integration_tool/clients/integration_client.d.ts

@@ -13,8 +13,8 @@ export interface IntegrationClientOptions {
     location: string;
     /** The integration name. */
     integration?: string;
-    /** The API trigger ID of the integration. */
-    trigger?: string;
+    /** The API trigger IDs of the integration. */
+    triggers?: string[];
     /** The connection name. */
     connection?: string;
     /**
@@ -41,7 +41,7 @@ export declare class IntegrationClient {
     private readonly project;
     private readonly location;
     private readonly integration?;
-    private readonly trigger?;
+    private readonly triggers?;
     private readonly connection?;
     private readonly entityOperations;
     private readonly actions;