@google/adk 1.3.0 → 1.5.0

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

@@ -77,6 +77,10 @@ export interface LlmResponse {
      * Audio transcription of model output.
      */
     outputTranscription?: Transcription;
+    /**
+     * The interaction ID returned by the model, if any.
+     */
+    interactionId?: string;
     /** The model version used to generate the response. */
     modelVersion?: string;
     /** The session ID of the Live session. */

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

@@ -16,7 +16,8 @@ import { BaseTool } from '../tools/base_tool.js';
  */
 export declare enum ContextCompactionTrigger {
     Manual = "Manual",
-    Auto = "Auto"
+    Auto = "Auto",
+    AgentControlled = "AgentControlled"
 }
 /**
  * Base class for creating plugins.

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

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Context } from '../agents/context.js';
+import { InstructionProvider } from '../agents/llm_agent.js';
+import { LlmRequest } from '../models/llm_request.js';
+import { LlmResponse } from '../models/llm_response.js';
+import { BasePlugin } from './base_plugin.js';
+/**
+ * Plugin that provides global instructions functionality at the App level.
+ *
+ * This plugin replaces the deprecated globalInstruction field on LlmAgent.
+ * Global instructions are applied to all agents in the application, providing
+ * a consistent way to set application-wide instructions, identity, or
+ * personality.
+ *
+ * The plugin operates through the beforeModelCallback, allowing it to modify
+ * LLM requests before they are sent to the model.
+ */
+export declare class GlobalInstructionPlugin extends BasePlugin {
+    private readonly globalInstruction?;
+    /**
+     * Initializes the GlobalInstructionPlugin.
+     *
+     * @param globalInstruction The instruction to apply globally. Can be a string
+     *     or an InstructionProvider function that takes ReadonlyContext and
+     *     returns a string (sync or async).
+     * @param name The name of the plugin (defaults to 'global_instruction').
+     */
+    constructor(globalInstruction?: string | InstructionProvider, name?: string);
+    beforeModelCallback(params: {
+        callbackContext: Context;
+        llmRequest: LlmRequest;
+    }): Promise<LlmResponse | undefined>;
+    private resolveGlobalInstruction;
+}

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

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { BaseAgent } from '../agents/base_agent.js';
+import { App } from '../apps/app.js';
+import { ResumabilityConfig } from '../apps/resumability_config.js';
 import { BasePlugin } from '../plugins/base_plugin.js';
 import { Runner } from './runner.js';
 /**
@@ -30,13 +32,17 @@ export declare class InMemoryRunner extends Runner {
      * Creates a new InMemoryRunner instance.
      *
      * @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.plugins An optional list of plugins.
+     * @param params.resumabilityConfig An optional resumability configuration.
      */
     constructor(params: {
-        agent: BaseAgent;
+        app?: App;
+        agent?: BaseAgent;
         appName?: string;
         plugins?: BasePlugin[];
+        resumabilityConfig?: ResumabilityConfig;
     });
 }

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

@@ -6,6 +6,8 @@
 import { Content } from '@google/genai';
 import { BaseAgent } from '../agents/base_agent.js';
 import { RunConfig } from '../agents/run_config.js';
+import { App } from '../apps/app.js';
+import { ResumabilityConfig } from '../apps/resumability_config.js';
 import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
 import { BaseCredentialService } from '../auth/credential_service/base_credential_service.js';
 import { Event } from '../events/event.js';
@@ -13,18 +15,23 @@ import { BaseMemoryService } from '../memory/base_memory_service.js';
 import { BasePlugin } from '../plugins/base_plugin.js';
 import { PluginManager } from '../plugins/plugin_manager.js';
 import { BaseSessionService } from '../sessions/base_session_service.js';
+import { Session } from '../sessions/session.js';
 /**
  * The configuration parameters for the Runner.
  */
 export interface RunnerConfig {
     /**
-     * The application name.
+     * The application object. If provided, `appName`, `agent`, and `plugins` will default from this app.
      */
-    appName: string;
+    app?: App;
     /**
-     * The agent to run.
+     * The application name. Required if `app` is not provided.
      */
-    agent: BaseAgent;
+    appName?: string;
+    /**
+     * The agent to run. Required if `app` is not provided.
+     */
+    agent?: BaseAgent;
     /**
      * An optional list of plugins to apply globally across all agents.
      */
@@ -45,6 +52,10 @@ export interface RunnerConfig {
      * An optional service for managing authentication credentials.
      */
     credentialService?: BaseCredentialService;
+    /**
+     * An optional resumability configuration applied to the runner.
+     */
+    resumabilityConfig?: ResumabilityConfig;
 }
 /**
  * A unique symbol to identify ADK agent classes.
@@ -91,6 +102,7 @@ export declare class Runner {
     readonly sessionService: BaseSessionService;
     readonly memoryService?: BaseMemoryService;
     readonly credentialService?: BaseCredentialService;
+    readonly resumabilityConfig?: ResumabilityConfig;
     /**
      * Creates a new Runner instance.
      *
@@ -135,7 +147,7 @@ export declare class Runner {
     }): AsyncGenerator<Event, void, undefined>;
     /**
      * Saves artifacts from the message parts and replaces the inline data with
-     * a file name placeholder.
+     * a file name placeholder and optional file reference.
      *
      * @param invocationId The current invocation ID.
      * @param userId The user ID of the session.
@@ -147,18 +159,40 @@ export declare class Runner {
      * Determines the next agent to run to continue the session. This is primarily
      * used for session resumption.
      */
+    /**
+     * Determines the next agent to run to continue the session. This is primarily
+     * used for session resumption across tool and LRO boundaries.
+     */
     private determineAgentForResumption;
     /**
      * Whether the agent to run can transfer to any other agent in the agent tree.
      *
-     * An agent is transferable if:
-     *  - It is an instance of `LlmAgent`.
-     *  - All its ancestors are also transferable (i.e., they have
-     *    `disallowTransferToParent` set to false).
-     *
      * @param agentToRun The agent to check for transferability.
      * @returns True if the agent can transfer, False otherwise.
      */
     private isRoutableLlmAgent;
 }
+/**
+ * Determines the next agent to run to continue the session. This is primarily
+ * used for session resumption across tool and LRO boundaries.
+ */
+export declare function determineAgentForResumption(session: Session, rootAgent: BaseAgent, resumabilityConfig?: ResumabilityConfig): BaseAgent;
+/**
+ * Whether the agent to run can transfer to any other agent in the agent tree.
+ *
+ * An agent is transferable if:
+ *  - It is an instance of `LlmAgent`.
+ *  - All its ancestors are also transferable (i.e., they have
+ *    `disallowTransferToParent` set to false).
+ *
+ * @param agentToRun The agent to check for transferability.
+ * @returns True if the agent can transfer, False otherwise.
+ */
+export declare function isRoutableLlmAgent(agentToRun: BaseAgent): boolean;
+/**
+ * It iterates through the events in reverse order, and returns the event
+ * containing a function call with a functionCall.id matching the
+ * functionResponse.id from the last event in the session.
+ */
+export declare function findEventByLastFunctionResponseId(events: Event[]): Event | null;
 export {};

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Event } from '../events/event.js';
-import { Session } from './session.js';
+import { CompositeSessionKey, Session } from './session.js';
 /**
  * The configuration of getting a session.
  */
@@ -30,13 +30,7 @@ export interface CreateSessionRequest {
 /**
  * The parameters for `getSession`.
  */
-export interface GetSessionRequest {
-    /** The name of the application. */
-    appName: string;
-    /** The ID of the user. */
-    userId: string;
-    /** The ID of the session. */
-    sessionId: string;
+export interface GetSessionRequest extends CompositeSessionKey {
     /** The configurations for getting the session. */
     config?: GetSessionConfig;
 }
@@ -60,14 +54,7 @@ export interface ListSessionsRequest {
 /**
  * The parameters for `deleteSession`.
  */
-export interface DeleteSessionRequest {
-    /** The name of the application. */
-    appName: string;
-    /** The ID of the user. */
-    userId: string;
-    /** The ID of the session. */
-    sessionId: string;
-}
+export type DeleteSessionRequest = CompositeSessionKey;
 /**
  * The parameters for `appendEvent`.
  */

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

@@ -4,6 +4,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Event } from '../events/event.js';
+/**
+ * Represents a unified composite session key grouping application, user, and session identifiers.
+ */
+export interface CompositeSessionKey {
+    /** The name of the application. */
+    appName: string;
+    /** The ID of the user. */
+    userId: string;
+    /** The ID of the session. */
+    sessionId: string;
+}
 /**
  * Represents a session in a conversation between agents and users.
  */

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

@@ -11,6 +11,14 @@ import { Session } from './session.js';
  * Checks if the given URI is a Vertex AI session service URI.
  */
 export declare function isVertexAiConnectionString(uri?: string): boolean;
+/**
+ * Quotes a value for safe use as a Google AIP-160 filter string literal.
+ *
+ * Backslashes are escaped first, then double quotes, so that caller-controlled
+ * input stays inside the quoted value and cannot break out to inject additional
+ * filter predicates. See https://google.aip.dev/160.
+ */
+export declare function quoteFilterLiteral(value: string): string;
 export interface VertexAiSessionServiceOptions {
     projectId?: string;
     location?: string;
@@ -32,6 +40,6 @@ export declare class VertexAiSessionService extends BaseSessionService {
     createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
     getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
     listSessions({ appName, userId, limit, offset, page, order, }: ListSessionsRequest): Promise<ListSessionsResponse>;
-    deleteSession({ appName, userId: _userId, sessionId, }: DeleteSessionRequest): Promise<void>;
+    deleteSession({ appName, userId, sessionId, }: DeleteSessionRequest): Promise<void>;
     appendEvent({ session, event, }: AppendEventRequest): Promise<Event>;
 }

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

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
+/**
+ * Tool for requesting context consolidation (compaction).
+ *
+ * When called by an LLM agent, this tool sets the state flags
+ * `temp:consolidate_context` and optionally `temp:consolidate_context_detail`,
+ * signalling the context compactor to trigger compaction.
+ */
+export declare class ConsolidateContextTool extends BaseTool {
+    constructor();
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+}

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

@@ -0,0 +1,26 @@
+import { LlmRequest } from '../models/llm_request.js';
+import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * Appends the Enterprise Web Search built-in tool to the LLM request when the
+ * target model supports it.
+ *
+ * NOTE: This is NOT Vertex AI Search (formerly "Enterprise Search"). See
+ * https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/web-grounding-enterprise
+ */
+export declare function applyEnterpriseWebSearch(llmRequest: LlmRequest): void;
+/**
+ * A Gemini 2+ built-in tool that grounds responses on public web data via
+ * Vertex AI Search with Enterprise (Sec4) compliance.
+ *
+ * This tool operates internally within the model and does not require or
+ * perform local code execution.
+ */
+export declare class EnterpriseWebSearchTool extends BaseTool {
+    constructor();
+    runAsync(): Promise<unknown>;
+    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link EnterpriseWebSearchTool}.
+ */
+export declare const ENTERPRISE_WEB_SEARCH: EnterpriseWebSearchTool;

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

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseExampleProvider } from '../examples/base_example_provider.js';
+import { Example } from '../examples/example.js';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that adds (few-shot) examples to the LLM request.
+ *
+ * This tool is executed for each LLM request and is never called by the model;
+ * it only mutates the outgoing request by appending few-shot instructions built
+ * from the latest user query.
+ */
+export declare class ExampleTool extends BaseTool {
+    readonly examples: Example[] | BaseExampleProvider;
+    constructor(examples: Example[] | BaseExampleProvider);
+    runAsync(_request: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest({ toolContext, llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+}

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Part } from '@google/genai';
-import { ArtifactVersion, BaseArtifactService, DeleteArtifactRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from '../artifacts/base_artifact_service.js';
+import { ArtifactVersion, BaseArtifactService, DeleteArtifactRequest, ListArtifactKeysRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from '../artifacts/base_artifact_service.js';
 import { Context } from '../agents/context.js';
 /**
  * Artifact service that forwards to the parent tool context.
@@ -15,7 +15,8 @@ export declare class ForwardingArtifactService implements BaseArtifactService {
     constructor(toolContext: Context);
     saveArtifact(request: SaveArtifactRequest): Promise<number>;
     loadArtifact(request: LoadArtifactRequest): Promise<Part | undefined>;
-    listArtifactKeys(): Promise<string[]>;
+    listArtifactKeys(_request: ListArtifactKeysRequest): Promise<string[]>;
+    private getArtifactService;
     deleteArtifact(request: DeleteArtifactRequest): Promise<void>;
     listVersions(request: ListVersionsRequest): Promise<number[]>;
     listArtifactVersions(request: ListVersionsRequest): Promise<ArtifactVersion[]>;

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

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import { FunctionTool } from './function_tool.js';
+/** Options for {@link loadWebPage}. */
+export interface LoadWebPageOptions {
+    /** Request timeout in milliseconds. Defaults to 30_000 (30s). */
+    timeoutMs?: number;
+}
+/**
+ * Fetches the content at `url` and returns its extracted, readable text.
+ *
+ * Hardened against SSRF: only `http`/`https` URLs are fetched, the host is
+ * resolved and rejected up front if it is `localhost`-style or resolves to a
+ * private / loopback / link-local / shared / reserved / multicast address, and
+ * redirects are never followed. Never throws for expected failures (bad scheme,
+ * blocked host, non-200, timeout, network error); returns
+ * `Failed to fetch url: <url>` instead.
+ *
+ * Known limitation: global `fetch` performs its own DNS resolution at connect
+ * time, so a residual time-of-check/time-of-use (DNS-rebinding) window exists
+ * between this pre-flight lookup and fetch's own lookup. Full connection
+ * IP-pinning (e.g. an `undici` Agent with a custom `lookup`) is a possible
+ * future hardening.
+ */
+export declare function loadWebPage(url: string, options?: LoadWebPageOptions): Promise<string>;
+/** A global {@link FunctionTool} exposing {@link loadWebPage} to the model. */
+export declare const LOAD_WEB_PAGE: FunctionTool<z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>>;

package/dist/types/tools/mcp/load_mcp_resource_tool.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from '../base_tool.js';
+import { MCPToolset } from './mcp_toolset.js';
+/**
+ * A tool that loads MCP server resources and adds them to the session.
+ *
+ * This mirrors the in-repo `LoadArtifactsTool` idiom: the model calls
+ * `load_mcp_resource` with the names of the resources it wants, and on the next
+ * turn {@link processLlmRequest} reads those resources over the MCP session and
+ * appends their contents (text and base64-encoded binary) to the request
+ * context.
+ */
+export declare class LoadMcpResourceTool extends BaseTool {
+    private readonly mcpToolset;
+    constructor(mcpToolset: MCPToolset);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+    private appendResourcesToLlmRequest;
+    private mcpContentToPart;
+}

package/dist/types/tools/mcp/mcp_toolset.d.ts

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { BlobResourceContents, Resource, TextResourceContents } from '@modelcontextprotocol/sdk/types.js';
 import { ReadonlyContext } from '../../agents/readonly_context.js';
 import { BaseTool } from '../base_tool.js';
 import { BaseToolset, ToolPredicate } from '../base_toolset.js';
@@ -40,5 +41,31 @@ export declare class MCPToolset extends BaseToolset {
     private readonly mcpSessionManager;
     constructor(connectionParams: MCPConnectionParams, toolFilter?: ToolPredicate | string[], prefix?: string);
     getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    /**
+     * Lists the names of the resources advertised by the MCP server.
+     *
+     * @return The resource names available on the server.
+     */
+    listResources(): Promise<string[]>;
+    /**
+     * Returns metadata for the resource whose name matches `name`.
+     *
+     * @param name The advertised name of the resource.
+     * @return The matching MCP `Resource`.
+     * @throws If no resource with the given name is advertised by the server.
+     */
+    getResourceInfo(name: string): Promise<Resource>;
+    /**
+     * Reads the contents of the named resource from the MCP server.
+     *
+     * The resource name is resolved to a URI via {@link getResourceInfo} before
+     * reading. Binary contents are returned base64-encoded, exactly as provided
+     * by the server (never decoded and re-encoded).
+     *
+     * @param name The advertised name of the resource to read.
+     * @return The resource contents (text and/or base64-encoded binary).
+     * @throws If the resource is unknown or has no URI.
+     */
+    readResource(name: string): Promise<Array<TextResourceContents | BlobResourceContents>>;
     close(): Promise<void>;
 }

package/dist/types/tools/skill/run_skill_inline_script_tool.d.ts

@@ -6,9 +6,34 @@
 import { FunctionDeclaration } from '@google/genai';
 import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
 import { SkillToolset } from './skill_toolset.js';
+/**
+ * Error codes returned by {@link RunSkillInlineScriptTool} when a call cannot
+ * be completed. The string values are part of the tool's response contract and
+ * must remain stable.
+ */
+export declare enum RunSkillInlineScriptErrorCode {
+    MISSING_SCRIPT_CONTENT = "MISSING_SCRIPT_CONTENT",
+    MISSING_LANGUAGE = "MISSING_LANGUAGE",
+    NO_CODE_EXECUTOR = "NO_CODE_EXECUTOR",
+    EXECUTION_ERROR = "EXECUTION_ERROR",
+    CONFIRMATION_REJECTED = "CONFIRMATION_REJECTED"
+}
 export declare class RunSkillInlineScriptTool extends BaseTool {
     private toolset;
     constructor(toolset: SkillToolset);
     _getDeclaration(): FunctionDeclaration;
     runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    /**
+     * Enforces a human-in-the-loop confirmation gate before executing an inline
+     * script, using the repo's standard tool-confirmation mechanism.
+     *
+     * - When no confirmation has been provided yet, a confirmation is requested
+     *   (surfacing the language and script that would run) and an intermediate
+     *   result is returned so the tool call pauses until the client responds.
+     * - When a confirmation exists but was not confirmed, a rejection error is
+     *   returned and execution is refused.
+     * - When the confirmation is confirmed, `undefined` is returned to allow the
+     *   caller to proceed with execution.
+     */
+    private enforceConfirmation;
 }

package/dist/types/tools/skill/skill_toolset.d.ts

@@ -23,6 +23,15 @@ export declare class SkillToolset extends BaseToolset {
         codeExecutor?: BaseCodeExecutor;
         additionalTools?: Array<BaseTool | BaseToolset>;
         registry?: SkillRegistry;
+        /**
+         * Whether to expose the `run_skill_inline_script` tool, which executes
+         * model-provided script content in the configured code executor. This is
+         * disabled by default because arbitrary inline-script execution is a
+         * sensitive capability; opt in explicitly by setting this to `true`.
+         * Execution additionally remains gated behind a human-in-the-loop
+         * confirmation.
+         */
+        allowInlineScripts?: boolean;
     });
     getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
     close(): Promise<void>;

package/dist/types/utils/async_hooks_shim.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare class AsyncLocalStorage<T> {
+    private store;
+    run<R>(store: T, callback: () => R): R;
+    getStore(): T | undefined;
+}

package/dist/types/utils/branch_trie.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Checks whether targetBranch is equal to or an ancestor of currentBranch
+ * by verifying segment-by-segment matching without substring false positives.
+ *
+ * @param currentBranch The branch being evaluated.
+ * @param targetBranch The candidate prefix or ancestor branch.
+ * @returns true if targetBranch equals currentBranch or is an ancestor of currentBranch.
+ */
+export declare function isSegmentPrefix(currentBranch: string, targetBranch: string): boolean;

package/dist/types/utils/client_labels.d.ts

@@ -3,6 +3,16 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+export declare function parseUserAgent(userAgent: string): string;
+/**
+ * Runs the given callback within a context that has the specified client label.
+ * All LLM calls made within this callback will include the client label in their tracking headers.
+ *
+ * @param clientLabel The custom client label to apply.
+ * @param callback The callback function to execute.
+ * @return The result of the callback.
+ */
+export declare function runWithClientLabel<R>(clientLabel: string, callback: () => R): R;
 /**
  * Returns the current list of client labels that can be added to HTTP Headers.
  */

package/dist/types/utils/env_aware_utils.d.ts

@@ -9,12 +9,12 @@
 export declare function isBrowser(): boolean;
 export declare function randomUUID(): string;
 /**
- * Encodes the given string to base64.
+ * Encodes the given string or Uint8Array to base64.
  *
- * @param data The string to encode.
+ * @param data The data to encode.
  * @return The base64-encoded string.
  */
-export declare function base64Encode(data: string): string;
+export declare function base64Encode(data: string | Uint8Array): string;
 /**
  * Decodes the given base64 string to a string.
  *

package/dist/types/utils/task.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export type TaskExecutable<T = void> = (abortSignal: AbortSignal) => Promise<T>;
+/**
+ * Represents a runtime task wrapping a promise, allowing status check and cancellation.
+ */
+export declare class Task<T = void> {
+    executable: TaskExecutable<T>;
+    private isDone;
+    private abortController;
+    promise: Promise<T>;
+    constructor(executable: TaskExecutable<T>);
+    /**
+     * Cancels the task execution.
+     */
+    cancel(): void;
+    /**
+     * Returns true if the task has completed (either resolved or rejected).
+     */
+    done(): boolean;
+}

package/dist/types/version.d.ts

@@ -3,4 +3,4 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export declare const version = "1.3.0";
+export declare const version = "1.5.0";