@google/adk 2.0.0 → 2.2.0

package/dist/types/examples/example.d.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Content } from '@google/genai';
+import { BaseExampleProvider } from './base_example_provider.js';
 /**
  * A few-shot example.
  */
@@ -17,3 +18,77 @@ export interface Example {
      */
     output: Content[];
 }
+/**
+ * Request payload for searching examples in Vertex AI Example Store.
+ */
+export interface SearchExamplesRequest {
+    storedContentsExampleParameters: {
+        contentSearchKey: {
+            contents: Content[];
+            searchKeyGenerationMethod: {
+                lastEntry: Record<string, never>;
+            };
+        };
+    };
+    topK: number;
+    exampleStore: string;
+}
+/**
+ * A stored example returned inside a {@link SearchExamplesResult}.
+ */
+export interface StoredContentsExample {
+    searchKey?: string;
+    contentsExample?: {
+        expectedContents?: Array<{
+            content?: Content;
+        }>;
+    };
+}
+/**
+ * Single result item returned by {@link ExampleStoreApiClient.searchExamples}.
+ */
+export interface SearchExamplesResult {
+    similarityScore?: number;
+    example?: {
+        storedContentsExample?: StoredContentsExample;
+    };
+}
+/**
+ * Response returned by {@link ExampleStoreApiClient.searchExamples}.
+ */
+export interface SearchExamplesResponse {
+    results?: SearchExamplesResult[];
+}
+/**
+ * API client interface for the Vertex AI Example Store.
+ *
+ * The Python SDK obtains this client from its bundled `vertexai` dependency.
+ * adk-js does not bundle that dependency, so the caller injects a client that
+ * reaches the Vertex AI Example Store API.
+ */
+export interface ExampleStoreApiClient {
+    searchExamples(request: SearchExamplesRequest): Promise<SearchExamplesResponse>;
+}
+/**
+ * Provides examples from a Vertex AI Example Store.
+ */
+export declare class VertexAiExampleStore extends BaseExampleProvider {
+    readonly examplesStoreName: string;
+    private readonly apiClient;
+    /**
+     * Initializes the VertexAiExampleStore.
+     *
+     * @param examplesStoreName The resource name of the vertex example store, in
+     *   the format of
+     *   `projects/{project}/locations/{location}/exampleStores/{example_store}`.
+     * @param apiClient A client that reaches the Vertex AI Example Store API.
+     *   adk-js does not bundle the `vertexai` dependency the Python SDK relies
+     *   on, so the caller supplies this client.
+     */
+    constructor(examplesStoreName: string, apiClient: ExampleStoreApiClient);
+    /**
+     * Retrieves relevant examples from the Vertex AI Example Store for the given
+     * query.
+     */
+    getExamples(query: string): Promise<Example[]>;
+}

package/dist/types/examples/example_util.d.ts

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { Session } from '../sessions/session.js';
 import { BaseExampleProvider } from './base_example_provider.js';
 import { Example } from './example.js';
 /**
@@ -20,6 +21,15 @@ import { Example } from './example.js';
  *   suitable for inclusion in a system instruction.
  */
 export declare function convertExamplesToText(examples: Example[], model?: string): string;
+/**
+ * Gets the latest message from the user.
+ *
+ * @param session - The session to inspect.
+ * @returns The latest message from the user. If not found, returns an empty
+ *   string.
+ */
+export declare function getLatestMessageFromUser(session: Session): string;
+export declare const _getLatestMessageFromUser: typeof getLatestMessageFromUser;
 /**
  * Builds the few-shot portion of a system instruction from a list of examples
  * or a {@link BaseExampleProvider}.
@@ -31,8 +41,9 @@ export declare function convertExamplesToText(examples: Example[], model?: strin
  *   when `examples` is a provider. Ignored when `examples` is an array.
  * @param model - Optional model name forwarded to
  *   {@link convertExamplesToText} to select the function-call fence style.
- * @returns A formatted string ready to be appended to a system instruction.
+ * @returns A promise resolving to a formatted string ready to be appended to a
+ *   system instruction.
  * @throws {Error} When `examples` is neither an array nor a
  *   {@link BaseExampleProvider}.
  */
-export declare function buildExampleSi(examples: Example[] | BaseExampleProvider, query: string, model?: string): string;
+export declare function buildExampleSi(examples: Example[] | BaseExampleProvider, query: string, model?: string): Promise<string>;

package/dist/types/examples/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Examples subsystem barrel export.
+ *
+ * Re-exports all `examples` modules (`Example`, `BaseExampleProvider`,
+ * `VertexAiExampleStore`, `example_util`) alongside compatibility references
+ * for `BaseCodeExecutor`, `BuiltInCodeExecutor`, `CodeExecutorContext`,
+ * `ContainerCodeExecutor`, `UnsafeLocalCodeExecutor`, `VertexAiCodeExecutor`,
+ * and `code_execution_utils`.
+ */
+export * from './base_example_provider.js';
+export * from './example.js';
+export * from './example_util.js';
+export * from './vertex_ai_example_store.js';

package/dist/types/examples/vertex_ai_example_store.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export { VertexAiExampleStore } from './example.js';
+export type { ExampleStoreApiClient, SearchExamplesRequest, SearchExamplesResponse, SearchExamplesResult, StoredContentsExample, } from './example.js';

package/dist/types/index.d.ts

@@ -11,17 +11,47 @@ export { GcsArtifactService } from './artifacts/gcs_artifact_service.js';
 export { getArtifactServiceFromUri } from './artifacts/registry.js';
 export { AgentEngineSandboxCodeExecutor, type AgentEngineSandboxCodeExecutorOptions, } from './code_executors/agent_engine_sandbox_code_executor.js';
 export { CodeExecutionLanguage } from './code_executors/code_execution_utils.js';
+export { ContainerCodeExecutor, type ContainerCodeExecutorOptions, } from './code_executors/container_code_executor.js';
 export { UnsafeLocalCodeExecutor, type UnsafeLocalCodeExecutorOptions, } from './code_executors/unsafe_local_code_executor.js';
 export * from './common.js';
 export { LocalEnvironment } from './environment/local_environment.js';
 export type { LocalEnvironmentOptions } from './environment/local_environment.js';
+export { VertexAiMemoryBankService } from './memory/vertex_ai_memory_bank_service.js';
+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 { DatabaseSessionService } from './sessions/database_session_service.js';
 export { getSessionServiceFromUri } from './sessions/registry.js';
 export { VertexAiSessionService } from './sessions/vertex_ai_session_service.js';
 export type { VertexAiCreateSessionRequest, VertexAiSessionServiceOptions, } from './sessions/vertex_ai_session_service.js';
-export { loadAllSkillsInDir, loadSkillFromDir, validateSkillDir, } from './skills/loader.js';
+export { GCPSkillRegistry } from './skills/gcp_skill_registry.js';
+export type { GCPSkillRegistryOptions } from './skills/gcp_skill_registry.js';
+export { loadAllSkillsInDir, loadSkillFromDir, loadSkillFromZipBuffer, validateSkillDir, } from './skills/loader.js';
+export { 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 { 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 { 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';
+export { OpenApiSpecParser } from './tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js';
+export type { OperationEndpoint, ParsedOperation, } from './tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js';
+export { OperationParser } from './tools/openapi_tool/openapi_spec_parser/operation_parser.js';
+export type { ApiParameter } from './tools/openapi_tool/openapi_spec_parser/operation_parser.js';
+export { ToolAuthHandler, ToolContextCredentialStore, } from './tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js';
+export type { AuthPreparationResult, ToolAuthHandlerOptions, } from './tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js';
+export { OpenAPIToolset } from './tools/openapi_tool/openapi_toolset.js';
+export { createRestApiTool, createRestApiToolFromJson, RestApiTool, } from './tools/openapi_tool/rest_api_tool.js';
+export type { ParsedOperationInput } from './tools/openapi_tool/rest_api_tool.js';
+export { FilesRetrieval } from './tools/retrieval/files_retrieval.js';
+export type { FilesRetrievalConstructorParams, FilesRetrievalParams, } from './tools/retrieval/files_retrieval.js';
+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 * from './integrations/agent_registry/agent_registry.js';
 export * from './telemetry/google_cloud.js';
 export * from './telemetry/setup.js';

package/dist/types/memory/memory_entry.d.ts

@@ -15,6 +15,21 @@ export interface MemoryEntry {
      * The content of the memory entry, as originally produced during a session.
      */
     content: Content;
+    /**
+     * The unique identifier of the memory.
+     *
+     * When set on an entry passed to `addMemory`, a service that supports
+     * caller-chosen identifiers uses it as the last component of the created
+     * memory's resource name instead of generating one.
+     */
+    id?: string;
+    /**
+     * Optional custom metadata associated with the memory.
+     *
+     * A service that also accepts request-level metadata merges this on top of
+     * it, so a key declared here wins over the same key on the request.
+     */
+    customMetadata?: Record<string, unknown>;
     /**
      * The author of the memory. Common values are `'user'` and `'model'`, but
      * this can also be the name of an agent when the content was produced by a

package/dist/types/memory/rag_memory_transcript.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Session } from '../sessions/session.js';
+/** The RAG file a chunk came from, identified by its display name. */
+export interface SourceIdentity {
+    appName: string;
+    userId: string;
+    sessionId: string;
+}
+/** One line of a stored transcript. */
+export interface TranscriptEvent {
+    author: string;
+    /** Epoch milliseconds. The transcript itself stores seconds. */
+    timestamp: number;
+    text: string;
+}
+/**
+ * Builds the `displayName` under which a session's transcript is stored.
+ *
+ * The identifiers are encoded because they may contain dots, which the legacy
+ * dot-delimited form cannot represent unambiguously.
+ */
+export declare function buildSourceDisplayName(appName: string, userId: string, sessionId: string): string;
+/**
+ * Recovers the identifiers from a `displayName`, or returns `undefined` when
+ * the name is malformed or ambiguous.
+ *
+ * Two forms are read. The prefixed form is the one both this service and
+ * adk-python write, so a corpus either writes stays readable by the other. The
+ * unprefixed `{app}.{user}.{session}` form is read only: adk-python wrote it
+ * before it adopted the prefix, and no writer here emits it.
+ *
+ * A dot-delimited name with four or more parts is ambiguous:
+ * `demo.alice.smith.s1` names either user `alice` or user `alice.smith`.
+ * Accepting it would hand one user another user's memories, so it is rejected.
+ */
+export declare function parseSourceDisplayName(displayName: string): SourceIdentity | undefined;
+/**
+ * Renders a session as the newline-delimited JSON transcript that both ADK
+ * implementations read, one object per text-bearing event.
+ *
+ * The timestamp is written in seconds because adk-python writes seconds; a
+ * corpus is shared between the two.
+ */
+export declare function serializeSessionTranscript(session: Session): string;
+/**
+ * Reads the events out of a retrieved transcript chunk.
+ *
+ * A line that is not JSON is skipped: a corpus may hold files this service
+ * never wrote.
+ */
+export declare function parseTranscriptEvents(text: string): TranscriptEvent[];

package/dist/types/memory/vertex_ai_memory_bank_service.d.ts

@@ -38,6 +38,15 @@ export declare class VertexAiMemoryBankService implements BaseMemoryService {
     }): Promise<void>;
     /**
      * Adds explicit memory items using Vertex Memory Bank.
+     *
+     * When a `MemoryEntry.id` is set, it is forwarded as the `memoryId` of the
+     * created memory, so the caller picks the last component of the memory
+     * resource name instead of letting the service generate one. An explicit
+     * `customMetadata['memoryId']` takes precedence over `MemoryEntry.id`.
+     *
+     * The id is forwarded unvalidated, so an id the API rejects fails the create
+     * call. Vertex accepts up to 63 characters from `[a-z0-9-]`, starting with a
+     * letter and ending with a letter or number.
      */
     addMemory(request: {
         appName: string;

package/dist/types/memory/vertex_ai_rag_api.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { RagRetrievalConfig, VertexRagStore } from '@google/genai';
+/** One file in a RAG corpus. */
+export interface RagFile {
+    /**
+     * Full resource name,
+     * `projects/{project}/locations/{location}/ragCorpora/{corpus}/ragFiles/{file}`.
+     */
+    name?: string;
+    /** Caller-supplied label for the file. */
+    displayName?: string;
+}
+/** One page of a `ragFiles` listing. */
+export interface ListRagFilesResponse {
+    ragFiles?: RagFile[];
+    nextPageToken?: string;
+}
+/** One chunk returned by a retrieval query. */
+export interface RagContext {
+    /** The `displayName` of the RAG file this chunk came from. */
+    sourceDisplayName?: string;
+    text?: string;
+}
+/** The response of a retrieval query. */
+export interface RetrieveContextsResponse {
+    contexts?: {
+        contexts?: RagContext[];
+    };
+}
+/** Parameters of {@link RagApiClient.listRagFiles}. */
+export interface ListRagFilesParams {
+    ragCorpus: string;
+    pageSize: number;
+    pageToken?: string;
+}
+/** Parameters of {@link RagApiClient.uploadRagFile}. */
+export interface UploadRagFileParams {
+    ragCorpus: string;
+    displayName: string;
+    content: string;
+}
+/** Parameters of {@link RagApiClient.retrieveContexts}. */
+export interface RetrieveContextsParams {
+    /** `projects/{project}/locations/{location}`. */
+    parent: string;
+    vertexRagStore: VertexRagStore;
+    /** `@google/genai` models the store and the config, but not the query. */
+    query: {
+        text: string;
+        ragRetrievalConfig?: RagRetrievalConfig;
+    };
+}
+/**
+ * The file and retrieval calls of the Vertex AI RAG Engine.
+ *
+ * `VertexRagApiClient` is the implementation; the interface is the seam
+ * a test substitutes.
+ */
+export interface RagApiClient {
+    listRagFiles(params: ListRagFilesParams): Promise<ListRagFilesResponse>;
+    uploadRagFile(params: UploadRagFileParams): Promise<void>;
+    retrieveContexts(params: RetrieveContextsParams): Promise<RetrieveContextsResponse>;
+}
+/**
+ * A {@link RagApiClient} over the Vertex AI RAG Engine REST API.
+ *
+ * The calls go to the REST API directly because neither
+ * `@google-cloud/vertexai` nor `@google/genai` ships a RAG client. Requests
+ * carry Application Default Credentials.
+ */
+export declare class VertexRagApiClient implements RagApiClient {
+    private readonly host;
+    private readonly auth;
+    constructor(options: {
+        location: string;
+    });
+    /** Lists one page of the files in a corpus. */
+    listRagFiles(params: ListRagFilesParams): Promise<ListRagFilesResponse>;
+    /** Uploads `content` into a corpus as one RAG file. */
+    uploadRagFile(params: UploadRagFileParams): Promise<void>;
+    /** Runs a retrieval query over a corpus. */
+    retrieveContexts(params: RetrieveContextsParams): Promise<RetrieveContextsResponse>;
+    private authHeaders;
+    private send;
+}

package/dist/types/memory/vertex_ai_rag_memory_service.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Session } from '../sessions/session.js';
+import { BaseMemoryService, SearchMemoryRequest, SearchMemoryResponse } from './base_memory_service.js';
+import { RagApiClient } from './vertex_ai_rag_api.js';
+/** Options for {@link VertexAiRagMemoryService}. */
+export interface VertexAiRagMemoryServiceOptions {
+    /**
+     * `projects/{project}/locations/{location}/ragCorpora/{ragCorpusId}`, or a
+     * bare `{ragCorpusId}` when the project and the location are resolvable.
+     */
+    ragCorpus: string;
+    /** Number of contexts to retrieve. Sent as `ragRetrievalConfig.topK`. */
+    similarityTopK?: number;
+    /** Only return contexts below this vector distance. Defaults to 10. */
+    vectorDistanceThreshold?: number;
+    /** Defaults to `process.env.GOOGLE_CLOUD_PROJECT`. */
+    projectId?: string;
+    /** Defaults to `process.env.GOOGLE_CLOUD_LOCATION`. */
+    location?: string;
+}
+/**
+ * A {@link BaseMemoryService} backed by a Vertex AI RAG Engine corpus.
+ *
+ * A finished session is uploaded as one RAG file holding its transcript, and a
+ * search retrieves the chunks of those transcripts that match the query. Only
+ * `addSessionToMemory` and `searchMemory` are supported, matching adk-python.
+ *
+ * @example
+ * ```ts
+ * const memoryService = new VertexAiRagMemoryService({
+ *   ragCorpus: 'projects/my-project/locations/us-central1/ragCorpora/12345',
+ *   similarityTopK: 5,
+ * });
+ * await memoryService.addSessionToMemory(session);
+ * ```
+ */
+export declare class VertexAiRagMemoryService implements BaseMemoryService {
+    private readonly ragCorpus;
+    private readonly projectId;
+    private readonly location;
+    private readonly similarityTopK?;
+    private readonly vectorDistanceThreshold;
+    private readonly ragApiClient;
+    /**
+     * @param ragApiClient An internal seam for tests to substitute a fake REST
+     *     client. Production callers omit it and get a client for the resolved
+     *     location.
+     * @internal
+     */
+    constructor(options: VertexAiRagMemoryServiceOptions, ragApiClient?: RagApiClient);
+    /** Uploads the session's transcript into the corpus as one RAG file. */
+    addSessionToMemory(session: Session): Promise<void>;
+    searchMemory(request: SearchMemoryRequest): Promise<SearchMemoryResponse>;
+    /**
+     * Returns the ids of the corpus files owned by the requesting app and user,
+     * or `undefined` when the corpus could not be listed within the page budget.
+     *
+     * An `undefined` result retrieves over the whole corpus. Narrowing only
+     * improves ranking and transfer size, and every returned context is filtered
+     * by tenant anyway. Scoping to a partial listing would instead hide the
+     * caller's own memories.
+     */
+    private listTenantRagFileIds;
+}

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

@@ -0,0 +1,210 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseLlm } from './base_llm.js';
+import type { BaseLlmConnection } from './base_llm_connection.js';
+import type { LlmRequest } from './llm_request.js';
+import type { LlmResponse } from './llm_response.js';
+export { stripAdkIdentityPreamble } from './chrome_prompt_utils.js';
+/**
+ * An ADK `BaseLlm` backed by Chrome's built-in on-device model, reached through
+ * the Prompt API (`globalThis.LanguageModel`).
+ *
+ * ## What this adapter is for
+ *
+ * ADK's agent loop is built around a model that emits *function calls*: the
+ * Runner inspects them, applies before/after-tool callbacks, executes the tool,
+ * appends a function response and loops. Chrome's Prompt API offers `prompt()`
+ * and `promptStreaming()`, which return a plain string.
+ *
+ * Chrome does expose a `tools` option on `LanguageModel.create()`, but its
+ * contract differs in a way that matters here: each tool carries an `execute()`
+ * callback and *the browser runs the tool itself*, feeding the result back into
+ * the model internally. The caller receives only the final text. That takes ADK
+ * out of its own loop — no tool callbacks, no per-call events, no confirmation
+ * hooks, no session state updates and nothing to trace.
+ *
+ * So this adapter synthesises function calling out of constrained decoding
+ * instead. Tools are described in the system prompt, and the reply is forced to
+ * match a JSON Schema whose branches are "final answer" or "call this exact
+ * tool with these exact arguments" (via `responseConstraint`). The reply is
+ * parsed back into genai `functionCall` parts, and ADK stays in control.
+ *
+ * ## Session strategy
+ *
+ * ADK is stateless per request: it re-sends the whole conversation every time.
+ * Chrome sessions are stateful, and `create()` is far more expensive than
+ * `prompt()`. This adapter therefore keeps one warm "base" session holding only
+ * the system prompt and `clone()`s it per request, destroying the clone after
+ * the turn. The conversation history rides in the prompt input.
+ *
+ * ## Availability
+ *
+ * The Prompt API is exposed to documents, not to workers, and it is desktop
+ * only with a substantial hardware floor. Call {@link availability} before
+ * relying on it. `create()` also requires a user gesture while the model is
+ * still downloading, so build the session in response to a user action.
+ *
+ * @example
+ * ```ts
+ * const llm = new ChromeBuiltInLlm();
+ * if ((await llm.availability()) === 'unavailable') {
+ *   // Fall back to a hosted model.
+ * }
+ * const agent = new LlmAgent({name: 'search', model: llm, tools: [...]});
+ * ```
+ */
+/** Whether the on-device model can serve a request right now. */
+export type ChromeModelAvailability = 'unavailable' | 'downloadable' | 'downloading' | 'available';
+/** A modality declared at session creation. */
+export interface ChromeExpectedModality {
+    type: 'text' | 'image' | 'audio';
+    languages?: string[];
+}
+/** One piece of a multimodal message. */
+export interface ChromeMessageContent {
+    type: 'text' | 'image' | 'audio';
+    value: string;
+}
+/** A single turn handed to `prompt()`. */
+export interface ChromeMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string | ChromeMessageContent[];
+}
+/** Emits `downloadprogress` while the model is fetched on first use. */
+export interface ChromeCreateMonitor {
+    addEventListener(type: 'downloadprogress', listener: (event: {
+        loaded: number;
+    }) => void): void;
+}
+/** Options accepted by `LanguageModel.availability()`. */
+export interface ChromeCreateCoreOptions {
+    expectedInputs?: ChromeExpectedModality[];
+    expectedOutputs?: ChromeExpectedModality[];
+}
+/** Options accepted by `LanguageModel.create()`. */
+export interface ChromeCreateOptions extends ChromeCreateCoreOptions {
+    signal?: AbortSignal;
+    initialPrompts?: ChromeMessage[];
+    monitor?: (monitor: ChromeCreateMonitor) => void;
+    temperature?: number;
+    topK?: number;
+}
+/** Options accepted by `prompt()` and `promptStreaming()`. */
+export interface ChromePromptOptions {
+    signal?: AbortSignal;
+    responseConstraint?: Record<string, unknown>;
+    omitResponseConstraintInput?: boolean;
+}
+/** A live Prompt API session. */
+export interface ChromeLanguageModelSession {
+    prompt(input: string | ChromeMessage[], options?: ChromePromptOptions): Promise<string>;
+    promptStreaming(input: string | ChromeMessage[], options?: ChromePromptOptions): ReadableStream<string>;
+    clone(options?: {
+        signal?: AbortSignal;
+    }): Promise<ChromeLanguageModelSession>;
+    destroy?(): void;
+    addEventListener?(type: 'contextoverflow', listener: () => void): void;
+    readonly contextUsage?: number;
+    readonly contextWindow?: number;
+}
+/** The `LanguageModel` global itself. */
+export interface ChromeLanguageModelFactory {
+    availability(options?: ChromeCreateCoreOptions): Promise<ChromeModelAvailability>;
+    create(options?: ChromeCreateOptions): Promise<ChromeLanguageModelSession>;
+}
+/** Timing and context signals emitted while the adapter runs. */
+export interface ChromeBuiltInDiagnostic {
+    phase: 'create' | 'prompt' | 'parse-fallback' | 'context-overflow';
+    ms?: number;
+    contextUsage?: number;
+    contextWindow?: number;
+    note?: string;
+}
+/** Constructor options for {@link ChromeBuiltInLlm}. */
+export interface ChromeBuiltInLlmParams {
+    /** Model id used for registry matching. Defaults to `chrome-on-device`. */
+    model?: string;
+    /**
+     * Injects an alternative implementation of the `LanguageModel` global, for
+     * tests and for embedding a stand-in. Defaults to
+     * `globalThis.LanguageModel`.
+     */
+    languageModel?: ChromeLanguageModelFactory;
+    /**
+     * Sampling temperature. Accepted only in extension contexts; on a plain web
+     * page `create()` rejects it and the adapter retries without it.
+     */
+    temperature?: number;
+    /** Sampling top-K. Subject to the same restriction as `temperature`. */
+    topK?: number;
+    /** Modalities to declare at session creation. */
+    expectedInputs?: ChromeExpectedModality[];
+    expectedOutputs?: ChromeExpectedModality[];
+    /** Receives bytes-loaded progress while the model downloads on first use. */
+    onDownloadProgress?: (loaded: number) => void;
+    /**
+     * Rewrites the system prompt before a session is created.
+     *
+     * This exists because of a specific and costly interaction with ADK. Every
+     * request is prefixed by ADK's identity processor with:
+     *
+     *     You are an agent. Your internal name is "<agent name>".
+     *
+     * Under a `ParallelAgent` fan-out each child has a different name, so every
+     * child produces a *different* system prompt, so the warm base session never
+     * hits and each child pays a full `create()` — the most expensive call
+     * available — precisely when the most calls are in flight.
+     *
+     * Pass {@link stripAdkIdentityPreamble} to drop it. That is safe whenever
+     * agent transfer is disabled, because the identity line exists to support
+     * transfer. Leave it unset for multi-agent setups that route by name.
+     */
+    normalizeSystemPrompt?: (systemPrompt: string) => string;
+    /** Receives timing and context diagnostics. */
+    onDiagnostic?: (diagnostic: ChromeBuiltInDiagnostic) => void;
+}
+/** Thrown when the browser has no usable on-device model. */
+export declare class ChromeModelUnavailableError extends Error {
+    readonly availability: ChromeModelAvailability | 'missing-api';
+    constructor(availability: ChromeModelAvailability | 'missing-api');
+}
+/** See the file overview for the design rationale. */
+export declare class ChromeBuiltInLlm extends BaseLlm {
+    static readonly supportedModels: Array<string | RegExp>;
+    private readonly params;
+    /**
+     * A warm session holding only the system prompt, cloned per request.
+     *
+     * The *promise* is memoised, not the resolved session. Under a
+     * `ParallelAgent` fan-out every child reaches this at the same instant, and
+     * caching only the resolved value means they all observe an empty cache and
+     * each create their own session — turning the optimisation into a no-op
+     * precisely when it matters most. Sharing the in-flight promise collapses
+     * them onto one `create()`.
+     */
+    private baseSessionPromise?;
+    private baseSession?;
+    private baseSessionKey?;
+    constructor(params?: ChromeBuiltInLlmParams);
+    private get api();
+    /** Reports whether this browser can actually run the model. */
+    availability(): Promise<ChromeModelAvailability>;
+    private diagnostic;
+    /**
+     * Returns a session cloned from a warm base carrying `systemPrompt`, and
+     * rebuilds that base only when the system prompt or sampling changes.
+     */
+    private acquireSession;
+    private createBaseSession;
+    generateContentAsync(llmRequest: LlmRequest, stream?: boolean, abortSignal?: AbortSignal): AsyncGenerator<LlmResponse, void>;
+    private promptOnce;
+    private streamText;
+    /** Turns the constrained JSON reply into an ADK response. */
+    private parseToolChoice;
+    connect(_llmRequest: LlmRequest): Promise<BaseLlmConnection>;
+    /** Releases the warm base session. */
+    destroy(): void;
+}