@google/adk 2.2.0 → 2.3.0

package/dist/types/flows/llm_flows/audio_transcriber.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+import { InvocationContext } from '../../agents/invocation_context.js';
+/**
+ * Audio encoding values matching Google Cloud Speech-to-Text `AudioEncoding`.
+ */
+export declare enum AudioEncoding {
+    ENCODING_UNSPECIFIED = 0,
+    LINEAR16 = 1
+}
+/**
+ * Configuration passed to a Speech-to-Text client `recognize` call.
+ */
+export interface RecognitionConfig {
+    encoding: AudioEncoding | keyof typeof AudioEncoding | number;
+    sampleRateHertz: number;
+    languageCode: string;
+}
+/**
+ * Audio payload passed to a Speech-to-Text client `recognize` call.
+ */
+export interface RecognitionAudio {
+    content: Uint8Array | string;
+}
+/**
+ * A single alternative hypothesis from a Speech-to-Text recognition result.
+ */
+export interface SpeechRecognitionAlternative {
+    transcript?: string | null;
+    confidence?: number | null;
+}
+/**
+ * A single Speech-to-Text recognition result segment.
+ */
+export interface SpeechRecognitionResult {
+    alternatives?: SpeechRecognitionAlternative[] | null;
+}
+/**
+ * Response returned by a Speech-to-Text client `recognize` call.
+ */
+export interface RecognizeResponse {
+    results?: SpeechRecognitionResult[] | null;
+}
+/**
+ * Duck-typed interface compatible with `@google-cloud/speech`'s `SpeechClient`
+ * as well as lightweight test or browser speech recognition clients.
+ */
+export interface SpeechClientLike {
+    recognize(request: {
+        config: RecognitionConfig;
+        audio: RecognitionAudio;
+    }): Promise<RecognizeResponse | [RecognizeResponse, ...unknown[]]> | RecognizeResponse | [RecognizeResponse, ...unknown[]];
+}
+/**
+ * Options for constructing an {@link AudioTranscriber}.
+ */
+export interface AudioTranscriberOptions {
+    /**
+     * Pre-configured Speech-to-Text client used to transcribe bundled user audio.
+     */
+    client?: SpeechClientLike;
+}
+/**
+ * Transcribes cached audio entries in an {@link InvocationContext} into
+ * conversation `Content` objects.
+ */
+export declare class AudioTranscriber {
+    client: SpeechClientLike;
+    constructor(optionsOrClient?: AudioTranscriberOptions | SpeechClientLike);
+    /**
+     * Bundles consecutive audio blobs from the same speaker in
+     * `invocationContext.transcriptionCache`, transcribes user audio bundles into
+     * text `Content` entries, preserves already-transcribed `Content`
+     * entries in order, clears `invocationContext.transcriptionCache`, and
+     * returns the resulting content list.
+     *
+     * @param invocationContext The invocation context holding `transcriptionCache`.
+     * @returns Ordered list of transcribed `Content` objects.
+     */
+    transcribeFile(invocationContext: InvocationContext): Promise<Content[]>;
+}

package/dist/types/index.d.ts

@@ -20,6 +20,7 @@ export { VertexAiMemoryBankService } from './memory/vertex_ai_memory_bank_servic
 export type { VertexAiMemoryBankServiceOptions } from './memory/vertex_ai_memory_bank_service.js';
 export { VertexAiRagMemoryService } from './memory/vertex_ai_rag_memory_service.js';
 export type { VertexAiRagMemoryServiceOptions } from './memory/vertex_ai_rag_memory_service.js';
+export { DebugLoggingPlugin, isDebugLoggingPlugin, } from './plugins/debug_logging_plugin.js';
 export { DatabaseSessionService } from './sessions/database_session_service.js';
 export { getSessionServiceFromUri } from './sessions/registry.js';
 export { VertexAiSessionService } from './sessions/vertex_ai_session_service.js';
@@ -27,13 +28,20 @@ export type { VertexAiCreateSessionRequest, VertexAiSessionServiceOptions, } fro
 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 { APIHubToolset, type APIHubToolsetOptions, } from './tools/apihub_tool/apihub_toolset.js';
+export { APIHubClient, type APIHubApi, type APIHubApiVersion, type APIHubClientOptions, type BaseAPIHubClient, } from './tools/apihub_tool/clients/apihub_client.js';
+export { SecretManagerClient, type SecretManagerClientOptions, } from './tools/apihub_tool/clients/secret_client.js';
+export { ApplicationIntegrationToolset, type ApplicationIntegrationToolsetOptions, } from './tools/application_integration_tool/application_integration_toolset.js';
+export { actionRequest, actionResponse, ConnectionsClient, CONNECTOR_BASE_SPEC, connectorPayload, createOperation, createOperationRequest, deleteOperation, deleteOperationRequest, executeCustomQueryRequest, getActionOperation, getOperation, getOperationRequest, listOperation, listOperationRequest, updateOperation, updateOperationRequest, type ActionSchema, type ConnectionDetails, type ConnectionsClientOptions, type ConnectorSpec, type EntityOperationOptions, type EntitySchemaAndOperations, type EntitySchemaOperationOptions, type GetActionOperationOptions, } from './tools/application_integration_tool/clients/connections_client.js';
+export { IntegrationClient, type IntegrationClientOptions, } from './tools/application_integration_tool/clients/integration_client.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 type { OpenIdConfig } 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 { exchangeCredential, generateAuthToken, 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';
@@ -52,7 +60,14 @@ export { LoadSkillResourceTool } from './tools/skill/load_skill_resource_tool.js
 export { RunSkillInlineScriptErrorCode, RunSkillInlineScriptTool, } from './tools/skill/run_skill_inline_script_tool.js';
 export { RunSkillScriptTool } from './tools/skill/run_skill_script_tool.js';
 export { SkillToolset } from './tools/skill/skill_toolset.js';
+export type { JsonObject } from './utils/json_utils.js';
 export * from './integrations/agent_registry/agent_registry.js';
 export * from './telemetry/google_cloud.js';
 export * from './telemetry/setup.js';
+export * from './tools/google_api_tool/index.js';
+export { DEFAULT_CRITERIA, EVAL_SESSION_ID_PREFIX, EvalStatus, getEvaluationCriteriaOrDefault, getRootAgent, MISSING_EVAL_DEPENDENCIES_MESSAGE, parseAndGetEvalsToRun, RESPONSE_EVALUATION_SCORE_KEY, RESPONSE_MATCH_SCORE_KEY, runEvals, TOOL_TRAJECTORY_SCORE_KEY, tryGetResetFunc, } from './cli/cli_eval.js';
+export type { AddSessionToEvalSetRequest, EvalEntry, EvalInitialSession, EvalMetric, EvalMetricResult, EvalResult, EvalSetItem, InvocationEvalMetricResult, RunEvalRequest, RunEvalResult, RunEvalsOptions, } from './cli/cli_eval.js';
+export { loadDotenvForAgent, walkToRootUntilFound } from './cli/utils/envs.js';
+export { LOGGING_FORMAT, logToStderr, logToTmpFolder } from './cli/utils/logs.js';
+export type { LogToTmpFolderOptions } from './cli/utils/logs.js';
 export * from './tools/mcp/index.js';

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

@@ -11,6 +11,7 @@ export declare class GeminiLlmConnection implements BaseLlmConnection {
     private readonly geminiSession;
     private readonly modelVersion?;
     private readonly messageQueue?;
+    private messageIterator?;
     constructor(geminiSession: Session, modelVersion?: string | undefined, messageQueue?: AsyncIterable<LiveServerMessage> | undefined);
     /**
      * Sends the conversation history to the gemini model.
@@ -47,15 +48,13 @@ export declare class GeminiLlmConnection implements BaseLlmConnection {
      */
     sendActivityEnd(): Promise<void>;
     /**
-     * Builds a full text response.
+     * Receives the model responses for one model turn.
      *
-     * The text should not be partial and the returned LlmResponse is not be
-     * partial.
+     * The generator ends after the message that completes the turn has been
+     * processed, or when the server closes the connection. Call `receive()`
+     * again to read the next turn; it continues from the next server message.
      *
-     * @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.
+     * @returns A generator of the LlmResponses of one model turn.
      */
     receive(): AsyncGenerator<LlmResponse, void, void>;
     /**

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

@@ -28,7 +28,7 @@ export declare class RoutedLlm extends BaseLlm {
     /**
      * Generates content by delegating to the selected model.
      */
-    generateContentAsync(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void>;
+    generateContentAsync(llmRequest: LlmRequest, stream?: boolean, abortSignal?: AbortSignal): AsyncGenerator<LlmResponse, void>;
     /**
      * Creates a live connection to the LLM by delegating to the selected model.
      * This live connection cannot be switched mid-stream, it is tied to the model

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

@@ -0,0 +1,157 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+import { BaseAgent } from '../agents/base_agent.js';
+import { Context } from '../agents/context.js';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event } from '../events/event.js';
+import { LlmRequest } from '../models/llm_request.js';
+import { LlmResponse } from '../models/llm_response.js';
+import { BaseTool } from '../tools/base_tool.js';
+import { BasePlugin } from './base_plugin.js';
+declare const DEBUG_LOGGING_PLUGIN_SYMBOL: unique symbol;
+/**
+ * Options for configuring {@link DebugLoggingPlugin}.
+ */
+export interface DebugLoggingPluginOptions {
+    /**
+     * The name of the plugin instance.
+     * @defaultValue 'debug_logging_plugin'
+     */
+    name?: string;
+    /**
+     * Path to the output YAML debug file.
+     * @defaultValue 'adk_debug.yaml'
+     */
+    outputPath?: string;
+    /**
+     * Whether to include a session state snapshot at the end of each invocation.
+     * @defaultValue true
+     */
+    includeSessionState?: boolean;
+    /**
+     * Whether to include full system instructions in LLM request logs.
+     * @defaultValue true
+     */
+    includeSystemInstruction?: boolean;
+}
+/**
+ * A single debug log entry recorded during an invocation.
+ */
+export interface DebugEntry {
+    timestamp: string;
+    entry_type: string;
+    invocation_id?: string;
+    agent_name?: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Per-invocation debug state written as a YAML document.
+ */
+export interface InvocationDebugState {
+    invocation_id: string;
+    session_id: string;
+    app_name: string;
+    user_id?: string;
+    start_time: string;
+    entries: DebugEntry[];
+}
+/**
+ * Type guard to check if an object is an instance of {@link DebugLoggingPlugin}.
+ */
+export declare function isDebugLoggingPlugin(obj: unknown): obj is DebugLoggingPlugin;
+/**
+ * A plugin that captures complete debug information to a YAML file.
+ *
+ * This plugin records detailed interaction data including:
+ * - LLM requests (model, system instruction, contents, tools)
+ * - LLM responses (content, usage metadata, errors)
+ * - Function calls with arguments
+ * - Function responses with results
+ * - Events yielded from the runner
+ * - Session state at the end of each invocation
+ *
+ * Each invocation is appended to the output file as a separate YAML document
+ * (separated by `---`). Credentials, sensitive keys, `temp:`-scoped state keys,
+ * and armored private key blocks are automatically redacted to `[REDACTED]`.
+ */
+export declare class DebugLoggingPlugin extends BasePlugin {
+    readonly [DEBUG_LOGGING_PLUGIN_SYMBOL] = true;
+    readonly outputPath: string;
+    readonly includeSessionState: boolean;
+    readonly includeSystemInstruction: boolean;
+    private readonly invocationStates;
+    private warnedAboutOutputMode;
+    constructor(options?: DebugLoggingPluginOptions);
+    /**
+     * Exposes active invocation states for testing and inspection.
+     */
+    getInvocationState(invocationId: string): InvocationDebugState | undefined;
+    private getTimestamp;
+    /**
+     * Serializes a Gemini `Content` object to a dictionary for YAML output.
+     */
+    serializeContent(content: Content | null | undefined): Record<string, unknown> | null;
+    /**
+     * Safely serializes an arbitrary value to a YAML/JSON-compatible format with
+     * credential, sensitive key, and private key redaction.
+     */
+    safeSerialize(obj: unknown, depth?: number): unknown;
+    private addEntry;
+    onUserMessageCallback({ invocationContext, userMessage, }: {
+        invocationContext: InvocationContext;
+        userMessage: Content;
+    }): Promise<Content | undefined>;
+    beforeRunCallback({ invocationContext, }: {
+        invocationContext: InvocationContext;
+    }): Promise<Content | undefined>;
+    onEventCallback({ invocationContext, event, }: {
+        invocationContext: InvocationContext;
+        event: Event;
+    }): Promise<Event | undefined>;
+    afterRunCallback({ invocationContext, }: {
+        invocationContext: InvocationContext;
+    }): Promise<void>;
+    beforeAgentCallback({ callbackContext, }: {
+        agent: BaseAgent;
+        callbackContext: Context;
+    }): Promise<Content | undefined>;
+    afterAgentCallback({ callbackContext, }: {
+        agent: BaseAgent;
+        callbackContext: Context;
+    }): Promise<Content | undefined>;
+    beforeModelCallback({ callbackContext, llmRequest, }: {
+        callbackContext: Context;
+        llmRequest: LlmRequest;
+    }): Promise<LlmResponse | undefined>;
+    afterModelCallback({ callbackContext, llmResponse, }: {
+        callbackContext: Context;
+        llmResponse: LlmResponse;
+    }): Promise<LlmResponse | undefined>;
+    onModelErrorCallback({ callbackContext, llmRequest, error, }: {
+        callbackContext: Context;
+        llmRequest: LlmRequest;
+        error: Error;
+    }): Promise<LlmResponse | undefined>;
+    beforeToolCallback({ tool, toolArgs, toolContext, }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: Context;
+    }): Promise<Record<string, unknown> | undefined>;
+    afterToolCallback({ tool, toolContext, result, }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: Context;
+        result: Record<string, unknown>;
+    }): Promise<Record<string, unknown> | undefined>;
+    onToolErrorCallback({ tool, toolArgs, toolContext, error, }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: Context;
+        error: Error;
+    }): Promise<Record<string, unknown> | undefined>;
+}
+export {};

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

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Optional HMAC integrity check for function calls stored in the session.
+ *
+ * Mirrors adk-python's `google.adk.plugins._tool_call_integrity_plugin`.
+ */
+import { Content } from '@google/genai';
+import { Context } from '../agents/context.js';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event } from '../events/event.js';
+import { BaseTool } from '../tools/base_tool.js';
+import { BasePlugin } from './base_plugin.js';
+/** `customMetadata` key holding `{functionCallId: stamp}`. */
+export declare const TOOL_CALL_HMAC_METADATA_KEY = "__adk_internal_fc_hmac";
+/** A function call in the session failed its integrity check. */
+export declare class ToolCallIntegrityError extends Error {
+    constructor(message: string);
+}
+/** Options for {@link ToolCallIntegrityPlugin}. */
+export interface ToolCallIntegrityPluginOptions {
+    /**
+     * The HMAC key, or a list of keys during rotation. The first key stamps new
+     * calls; every key is accepted when verifying.
+     */
+    secretKey: Uint8Array | readonly Uint8Array[];
+    /**
+     * Log a warning instead of throwing for function calls that have no stamp,
+     * such as calls stored before the plugin was installed. Such calls also run,
+     * so this reports tampering that removes a stamp but does not prevent it. A
+     * stamp that is present but wrong is always rejected. Defaults to `false`.
+     */
+    allowUnstampedCalls?: boolean;
+    /** The plugin name. Defaults to `'tool_call_integrity'`. */
+    name?: string;
+}
+/**
+ * Stamps function calls and verifies them before runs and tool calls.
+ *
+ * `onEventCallback` adds `"v1:" + HMAC-SHA256(key, payload)` for each function
+ * call to `event.customMetadata["__adk_internal_fc_hmac"]`, and throws
+ * {@link ToolCallIntegrityError} for a response that repeats a call ID before
+ * it is stored. `beforeRunCallback` recomputes the HMAC for every function call
+ * with an ID in the session history, answered or not, and throws when a stamp
+ * is wrong, malformed, repeated or left over from a call that no longer
+ * matches. `beforeToolCallback` lets a tool run only when every stored copy of
+ * its call verifies and the tool's name and arguments match one of them; it
+ * always refuses a call with no ID. Unstamped calls are rejected unless
+ * `allowUnstampedCalls` is set, in which case they are logged.
+ *
+ * Events without function calls are ignored. Events marked as restored are not
+ * verified, and their function calls are never executed. ADK marks events
+ * restored by `adk run --replay`, and {@link prepareRestoredEvent} marks events
+ * that your code copies. Anyone who can write to the session store can also
+ * set the marker, but `beforeToolCallback` still refuses those events' calls.
+ *
+ * `PluginManager` re-throws plugin errors as a generic `Error`; the
+ * {@link ToolCallIntegrityError} is its `cause`.
+ *
+ * Register this plugin before other plugins. `PluginManager` stops at the first
+ * `onEventCallback` that returns an event, and a later plugin must not change
+ * function calls or replace `customMetadata`.
+ *
+ * Requires the Web Crypto API (`globalThis.crypto.subtle`), available in
+ * browsers and in Node.js 19 and later.
+ *
+ * Example:
+ * ```typescript
+ * const plugin = new ToolCallIntegrityPlugin({secretKey: keyBytes});
+ * const app = {name: 'my_app', rootAgent: agent, plugins: [plugin]};
+ *
+ * // Key rotation: stamp with the new key, accept both.
+ * new ToolCallIntegrityPlugin({secretKey: [newKeyBytes, oldKeyBytes]});
+ * ```
+ */
+export declare class ToolCallIntegrityPlugin extends BasePlugin {
+    private readonly keys;
+    private readonly allowUnstampedCalls;
+    private cryptoKeys?;
+    /**
+     * @throws {Error} If `secretKey` is empty or contains a key that is not
+     *     non-empty bytes.
+     */
+    constructor(options: ToolCallIntegrityPluginOptions);
+    /**
+     * Returns a copy with internal metadata removed and marked as restored.
+     *
+     * Use it on events that your code copies into another session, so that the
+     * history passes the integrity check. The copy only keeps the history: its
+     * function calls are never executed.
+     *
+     * @param event The event to copy. It is not modified.
+     * @returns The marked copy, ready to append to the new session.
+     */
+    static prepareRestoredEvent(event: Event): Event;
+    private getCryptoKeys;
+    private sign;
+    /** `subtle.verify` compares in constant time. */
+    private verify;
+    private unstamped;
+    onEventCallback({ invocationContext, event, }: {
+        invocationContext: InvocationContext;
+        event: Event;
+    }): Promise<Event | undefined>;
+    beforeRunCallback({ invocationContext, }: {
+        invocationContext: InvocationContext;
+    }): Promise<Content | undefined>;
+    beforeToolCallback({ tool, toolArgs, toolContext, }: {
+        tool: BaseTool;
+        toolArgs: Record<string, unknown>;
+        toolContext: Context;
+    }): Promise<Record<string, unknown> | undefined>;
+}

package/dist/types/runner/in_memory_runner.d.ts

@@ -34,7 +34,8 @@ export declare class InMemoryRunner extends Runner {
      * @param params The configuration for the runner.
      * @param params.app An optional application instance to run.
      * @param params.agent The root agent to run.
-     * @param params.appName The application name. Defaults to `'InMemoryRunner'`.
+     * @param params.appName The application name. Defaults to `app.name` when
+     *     `app` is provided, or `'InMemoryRunner'` otherwise.
      * @param params.plugins An optional list of plugins.
      * @param params.resumabilityConfig An optional resumability configuration.
      */

package/dist/types/runner/runner.d.ts

@@ -65,6 +65,17 @@ export interface RunnerConfig {
      * An optional resumability configuration applied to the runner.
      */
     resumabilityConfig?: ResumabilityConfig;
+    /**
+     * Whether to create the session when `runAsync` is given a session id that
+     * does not exist. Defaults to `false`, which reports the missing session as
+     * an error instead.
+     *
+     * Enabling this trades a loud failure for a silent one: a caller that
+     * mistypes a session id gets a new empty conversation rather than an error.
+     * Turn it on only where the session id is a key the caller owns and a first
+     * use is expected to create it.
+     */
+    autoCreateSession?: boolean;
 }
 /**
  * A unique symbol to identify ADK agent classes.
@@ -116,12 +127,20 @@ export declare class Runner {
     readonly memoryService?: BaseMemoryService;
     readonly credentialService?: BaseCredentialService;
     readonly resumabilityConfig?: ResumabilityConfig;
+    readonly autoCreateSession: boolean;
     /**
      * Creates a new Runner instance.
      *
      * @param input The configuration for the runner.
      */
     constructor(input: RunnerConfig);
+    /**
+     * Looks the session up, creating it first when `autoCreateSession` is set.
+     *
+     * A runner with no `appName` cannot address a session, so it falls through to
+     * the plain lookup rather than creating one under an undefined app name.
+     */
+    private resolveSession;
     /**
      * Runs the agent with a new, ephemeral session.
      *
@@ -171,6 +190,21 @@ export declare class Runner {
      * plugins; there is nothing to lack if there is only one loop.
      */
     private runRoot;
+    /**
+     * Runs the on_event plugin callbacks on an event and appends the result to
+     * the session unless it is partial.
+     *
+     * @returns The event as streamed to the caller.
+     */
+    private processAndAppendEvent;
+    /**
+     * Seals an aborted invocation in session history: answers its dangling
+     * function calls with error responses, or records a plain abort event when
+     * there is nothing to answer.
+     *
+     * @returns The synthetic events after plugin processing and persistence.
+     */
+    private synthesizeAbortEvents;
     /**
      * Saves artifacts from the message parts and replaces the inline data with
      * a file name placeholder and optional file reference.

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

@@ -56,6 +56,9 @@ export declare class State {
     /**
      * Returns the value of the state dict for the given key.
      *
+     * Only keys the state holds itself are found. Names inherited from
+     * `Object.prototype`, such as `toString`, are treated as missing.
+     *
      * @param key The key to get the value for.
      * @param defaultValue The default value to return if the key is not found.
      * @return The value of the state for the given key, or the default value if
@@ -70,7 +73,8 @@ export declare class State {
      */
     set(key: string, value: unknown): void;
     /**
-     * Whether the state has pending delta.
+     * Whether the state holds the given key, either as a stored value or as a
+     * pending delta. Names inherited from `Object.prototype` are not keys.
      */
     has(key: string): boolean;
     /**

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

@@ -20,7 +20,15 @@ export declare function isVertexAiConnectionString(uri?: string): boolean;
  */
 export declare function quoteFilterLiteral(value: string): string;
 export interface VertexAiSessionServiceOptions {
+    /**
+     * Google Cloud project ID. Defaults to `process.env.GOOGLE_CLOUD_PROJECT`
+     * unless `expressModeApiKey` is passed.
+     */
     projectId?: string;
+    /**
+     * Google Cloud location. Defaults to `process.env.GOOGLE_CLOUD_LOCATION`
+     * unless `expressModeApiKey` is passed.
+     */
     location?: string;
     agentEngineId?: string;
     expressModeApiKey?: string;

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

@@ -15,7 +15,7 @@ export declare const FrontmatterSchema: z.ZodPreprocess<z.ZodObject<{
     compatibility: z.ZodOptional<z.ZodString>;
     'allowed-tools': z.ZodOptional<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
-}, z.core.$loose>>;
+}, z.core.$loose>, unknown>;
 export interface Frontmatter {
     name: string;
     description: string;

package/dist/types/telemetry/tracing.d.ts

@@ -63,16 +63,18 @@ export interface TraceToolCallParams {
     tool: BaseTool;
     args: Record<string, unknown>;
     functionResponseEvent: Event;
+    invocationContext: InvocationContext;
 }
 /**
  * Traces tool call.
  *
  * @param params The parameters object containing tool, args, and function response event.
  */
-export declare function traceToolCall({ tool, args, functionResponseEvent, }: TraceToolCallParams): void;
+export declare function traceToolCall({ tool, args, functionResponseEvent, invocationContext, }: TraceToolCallParams): void;
 export interface TraceMergedToolCallsParams {
     responseEventId: string;
     functionResponseEvent: Event;
+    invocationContext: InvocationContext;
 }
 /**
  * Traces merged tool call events.
@@ -82,7 +84,7 @@ export interface TraceMergedToolCallsParams {
  *
  * @param params The parameters object containing response event ID and function response event.
  */
-export declare function traceMergedToolCalls({ responseEventId, functionResponseEvent, }: TraceMergedToolCallsParams): void;
+export declare function traceMergedToolCalls({ responseEventId, functionResponseEvent, invocationContext, }: TraceMergedToolCallsParams): void;
 export interface TraceCallLlmParams {
     invocationContext: InvocationContext;
     eventId: string;