@google/adk 2.4.0 → 2.5.0

package/dist/types/telemetry/api/internal/trace/inference.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Attributes, Span } from '@opentelemetry/api';
+import type { LlmRequest } from '../../../../models/llm_request.js';
+import type { LlmResponse } from '../../../../models/llm_response.js';
+import { type ResolvedTelemetryConfig } from '../common/config.js';
+import { type OperationDetails } from '../common/genai_messages.js';
+/** Parameters for {@link startInferenceSpan}. */
+export interface StartInferenceSpanParams {
+    readonly llmRequest: LlmRequest;
+    /** Attributes the span shares with the call's log record. */
+    readonly commonAttributes: Attributes;
+}
+/** Starts a `generate_content {model}` span under the active context. */
+export declare function startInferenceSpan({ llmRequest, commonAttributes, }: StartInferenceSpanParams): Span;
+/**
+ * Builds the attributes one model response contributes to both the span and
+ * the log record: its finish reason and its token usage.
+ */
+export declare function buildResponseAttributes(llmResponse: LlmResponse): Attributes;
+/** Records one model response on its `generate_content` span. */
+export declare function setInferenceResponseAttributes(span: Span, llmResponse: LlmResponse, config: ResolvedTelemetryConfig): void;
+/**
+ * Records the operation details of a model call on its span, as JSON: all of
+ * them when content capture includes spans, otherwise only the view without
+ * message content.
+ */
+export declare function setInferenceOperationDetails(span: Span, details: OperationDetails, config: ResolvedTelemetryConfig): void;

package/dist/types/telemetry/api/internal/trace/live.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+import type { Span } from '@opentelemetry/api';
+import type { InvocationContext } from '../../../../agents/invocation_context.js';
+/** Parameters for recording live history `send_data` attributes on a span. */
+export interface SetSendDataAttributesParams {
+    /** The invocation context for the current agent run. */
+    readonly invocationContext: InvocationContext;
+    /** The ID of the event. */
+    readonly eventId: string;
+    /** A list of content objects. */
+    readonly data: Content[];
+}
+/**
+ * Sets `send_data` attributes on the given span.
+ */
+export declare function setSendDataAttributes(span: Span, { invocationContext, eventId, data }: SetSendDataAttributesParams): void;

package/dist/types/telemetry/api/internal/trace/node.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Span } from '@opentelemetry/api';
+import type { BaseNode } from '../../../../workflow/base_node.js';
+/**
+ * Whether a node is traced by a span of its own kind rather than by
+ * `invoke_node`: an agent opens `invoke_agent` and a workflow
+ * `invoke_workflow`.
+ */
+export declare function hasOwnInvocationSpan(node: BaseNode): boolean;
+/** Parameters for {@link startNodeSpan}. */
+export interface StartNodeSpanParams {
+    readonly nodeName: string;
+    readonly sessionId: string;
+}
+/** Starts an `invoke_node {nodeName}` span under the active context. */
+export declare function startNodeSpan({ nodeName, sessionId, }: StartNodeSpanParams): Span;
+/** Records the ids of the events a node emitted on its span, if it emitted any. */
+export declare function setAssociatedEventIds(span: Span, eventIds: readonly string[]): void;

package/dist/types/telemetry/api/internal/trace/propagation.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { TextMapGetter } from '@opentelemetry/api';
+/** Incoming request headers, such as Node's `IncomingMessage.headers`. */
+export type IncomingHeaders = Readonly<Record<string, string | string[] | undefined>>;
+/**
+ * Reads incoming request headers for the propagator, matching names
+ * case-insensitively. An array value is returned as is; the W3C propagator
+ * reads its first element.
+ */
+export declare const INCOMING_HEADERS_GETTER: TextMapGetter<IncomingHeaders>;
+/**
+ * Returns the headers a `fetch(input, init)` call sends, with each injected
+ * header added unless the call already sets it.
+ *
+ * As in `fetch`, `init.headers` replaces the headers of a `Request` input
+ * when given, and the `Request` headers are kept otherwise.
+ */
+export declare function addMissingHeaders(input: Parameters<typeof globalThis.fetch>[0], init: Parameters<typeof globalThis.fetch>[1], injected: Readonly<Record<string, string>>): Headers;

package/dist/types/telemetry/api/internal/trace/tool.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Attributes, Span } from '@opentelemetry/api';
+import type { Event } from '../../../../events/event.js';
+import type { Skill } from '../../../../skills/skill.js';
+import type { BaseTool } from '../../../../tools/base_tool.js';
+import type { ResolvedTelemetryConfig } from '../common/config.js';
+/** The outcome of one tool call, as recorded on its `execute_tool` span. */
+export type ToolCallOutcome = {
+    readonly kind: 'response';
+    readonly functionResponseEvent?: Event;
+    /** An error type the tool reported in its response instead of throwing. */
+    readonly errorType?: string;
+} | {
+    readonly kind: 'error';
+    readonly errorType: string;
+};
+/** Parameters for {@link buildToolCallAttributes}. */
+export interface ToolCallAttributesParams {
+    readonly tool: BaseTool;
+    readonly args: Record<string, unknown>;
+    readonly agentName?: string;
+    readonly outcome: ToolCallOutcome;
+    readonly config: ResolvedTelemetryConfig;
+}
+/**
+ * Builds the attributes of an `execute_tool` span.
+ *
+ * The call arguments and result are message content, so they are recorded
+ * only when content capture includes spans, and the result has credential
+ * secrets removed.
+ */
+export declare function buildToolCallAttributes({ tool, args, agentName, outcome, config, }: ToolCallAttributesParams): Attributes;
+/** Builds the attributes of an `execute_tool (merged)` span. */
+export declare function buildMergedToolCallsAttributes(responseEventId: string): Attributes;
+/** What a skill tool reported about the skill it worked on. */
+export interface SkillReport {
+    /** The skill name the tool was asked for, which may not exist. */
+    readonly skillName: string;
+    /** The resource or script path, for a resource load or a script run. */
+    readonly resourceName?: string;
+    /** Whether the tool loaded the skill itself, as opposed to part of it. */
+    readonly isSkillLoad: boolean;
+    /** Whether the tool executed a skill script. */
+    readonly isSkillScript?: boolean;
+    /** The skill, once the tool has resolved it. */
+    readonly skill?: Skill;
+}
+/** Names an `execute_tool` span after the skill and resource it touched. */
+export declare function buildSkillSpanName(toolName: string, report: SkillReport): string;
+/** Builds the skill attributes of an `execute_tool` span. */
+export declare function buildSkillAttributes(report: SkillReport): Attributes;
+/** Records a skill on its `execute_tool` span: the span name and attributes. */
+export declare function setSkillSpanAttributes(span: Span, toolName: string, report: SkillReport): void;

package/dist/types/telemetry/api/internal/trace/tracer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Context, type Span, type Tracer } from '@opentelemetry/api';
+/**
+ * Returns the ADK tracer from the global `TracerProvider`.
+ *
+ * Resolved on every call rather than once at import, like the logger, so the
+ * tracer carries the schema URL whichever provider the application registers
+ * and whenever it registers it.
+ */
+export declare function getTracer(): Tracer;
+/**
+ * Binds an async generator to OpenTelemetry context for trace propagation.
+ *
+ * @param ctx The OpenTelemetry context to bind the generator to.
+ * @param generator The async generator to be bound to the context.
+ * @returns A new async generator that executes all operations within the provided context.
+ */
+export declare function bindOtelContextToAsyncGenerator<T>(ctx: Context, generator: AsyncGenerator<T, void, void>): AsyncGenerator<T, void, void>;
+/**
+ * Records a failure on a span: the exception and an ERROR status.
+ *
+ * The status message is the error type rather than the error message, which
+ * can carry user data that the content capture setting does not gate. Only an
+ * `Error` instance is recorded as an exception; any other thrown value is
+ * recorded by its type alone.
+ */
+export declare function setSpanError(span: Span, error: unknown): void;

package/dist/types/telemetry/api/internal/trace/workflow.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Context, type Span } from '@opentelemetry/api';
+/** Parameters for {@link startWorkflowSpan}. */
+export interface StartWorkflowSpanParams {
+    readonly workflowName: string;
+    readonly sessionId: string;
+    readonly nested: boolean;
+    readonly parentContext?: Context;
+}
+/**
+ * Starts an `invoke_workflow {workflowName}` span.
+ *
+ * A workflow started inside another workflow is marked
+ * `gen_ai.workflow.nested`; the outermost one carries no such attribute. The
+ * top span of a trace also carries `supportID` when the request supplied one.
+ */
+export declare function startWorkflowSpan({ workflowName, sessionId, nested, parentContext, }: StartWorkflowSpanParams): Span;

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Runs `fn` in a context that continues an Agent Engine request trace.
+ *
+ * When `Google-Agent-Engine-Traceparent` holds a valid W3C traceparent and no
+ * span is active, the Agent Engine span becomes the remote parent of the
+ * spans `fn` starts. An invalid value is ignored. The `traceparent` header is
+ * recorded as the `supportID` attribute of the invocation's top span.
+ *
+ * Without either header, `fn` runs in the active context unchanged.
+ *
+ * @experimental (Experimental, subject to change)
+ *
+ * @param headers The incoming request headers, such as Node's
+ *     `IncomingMessage.headers`.
+ * @param fn The request handler to run.
+ * @returns What `fn` returns.
+ */
+export declare function runWithAgentEngineContext<T>(headers: Readonly<Record<string, string | string[] | undefined>>, fn: () => T): T;

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

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { OTelHooks } from './setup.js';
+/**
+ * Hooks a server calls at the start and end of every request, so telemetry is
+ * exported while the request still holds the CPU.
+ *
+ * Neither hook throws, and {@link AgentRuntimeRequestHooks.onRequestEnd}
+ * never rejects: a telemetry failure never breaks the request.
+ *
+ * @experimental (Experimental, subject to change)
+ */
+export interface AgentRuntimeRequestHooks {
+    /** Call when a request arrives. */
+    onRequestStart(): void;
+    /**
+     * Call when the handler ends the response, before the response completes.
+     * Resolves once metrics are drained and spans and logs are flushed.
+     */
+    onRequestEnd(): Promise<void>;
+}
+/**
+ * Builds the request hooks that drive export for the given processors and
+ * readers on a runtime that throttles the CPU between requests.
+ *
+ * Each request start and end drives every request-driven metric reader in
+ * `otelHooks.metricReaders`. Each request end also force-flushes every span and
+ * log record processor in `otelHooks`. Other metric readers are left alone:
+ * flushing them would collect outside the request-driven reader's spacing
+ * rules.
+ *
+ * @experimental (Experimental, subject to change)
+ *
+ * @param otelHooks The processors and readers to drive, usually the result of
+ *     {@link getGcpExporters}.
+ */
+export declare function agentRuntimeRequestHooks(otelHooks: OTelHooks): AgentRuntimeRequestHooks;

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. */