@google/adk 2.0.0 → 2.1.0

package/dist/types/errors/tool_execution_error.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * HTTP error types conforming to OpenTelemetry semantics.
+ *
+ * The string values populate the `error.type` span attribute, so they are
+ * observable outside the process and must stay identical to the adk-python
+ * `ToolErrorType` members.
+ */
+export declare enum ToolErrorType {
+    BAD_REQUEST = "BAD_REQUEST",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    FORBIDDEN = "FORBIDDEN",
+    NOT_FOUND = "NOT_FOUND",
+    REQUEST_TIMEOUT = "REQUEST_TIMEOUT",
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR",
+    BAD_GATEWAY = "BAD_GATEWAY",
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
+    GATEWAY_TIMEOUT = "GATEWAY_TIMEOUT"
+}
+/**
+ * Represents an error that occurs during the execution of a tool.
+ */
+export declare class ToolExecutionError extends Error {
+    readonly errorType?: (ToolErrorType | string) | undefined;
+    /**
+     * @param message A message describing the error.
+     * @param errorType The semantic error type (e.g.
+     *   {@link ToolErrorType.REQUEST_TIMEOUT} or `'500'`). Used to populate the
+     *   `error.type` span attribute in OpenTelemetry traces.
+     */
+    constructor(message: string, errorType?: (ToolErrorType | string) | undefined);
+}

package/dist/types/events/event_actions.d.ts

@@ -79,6 +79,19 @@ export interface EventActions {
  * @returns A fully populated {@link EventActions} object.
  */
 export declare function createEventActions(state?: Partial<EventActions>): EventActions;
+/**
+ * Returns whether the given {@link EventActions} still holds only its default
+ * values, i.e. the event carries no state, artifact, auth, confirmation,
+ * transfer, escalation or summarization signal.
+ *
+ * An actions object is considered non-default when any dictionary field has at
+ * least one entry, or when any scalar field has been explicitly set (including
+ * being set to `false`).
+ *
+ * @param actions - The actions to inspect.
+ * @returns `true` when every field is at its default value.
+ */
+export declare function isDefaultEventActions(actions: EventActions): boolean;
 /**
  * Merges a list of {@link EventActions} objects into a single
  * {@link EventActions} object.

package/dist/types/index.d.ts

@@ -11,17 +11,38 @@ 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 { 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 } from './tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js';
+export type { AuthPreparationResult } from './tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js';
+export { OpenAPIToolset } from './tools/openapi_tool/openapi_toolset.js';
+export { createRestApiTool, RestApiTool, } 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/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_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;
+}

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

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Content, FunctionDeclaration } from '@google/genai';
+import type { ChromeMessage } from './chrome_prompt_llm.js';
+import type { LlmRequest } from './llm_request.js';
+import type { LlmResponse } from './llm_response.js';
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Pulls function declarations out of a request's tool config. */
+export declare function collectFunctionDeclarations(llmRequest: LlmRequest): FunctionDeclaration[];
+/**
+ * Builds the constrained-decoding schema: a union of "final answer" and one
+ * branch per available tool, each carrying that tool's exact argument schema.
+ *
+ * A single-value `enum` is used rather than `const`, because it is semantically
+ * identical and more widely supported across constraint engines.
+ */
+export declare function buildToolChoiceSchema(declarations: FunctionDeclaration[]): Record<string, unknown>;
+/** Renders tool declarations into instructions the model can act on. */
+export declare function renderToolInstructions(declarations: FunctionDeclaration[]): string;
+/**
+ * Renders a tool result as text the model can actually read.
+ *
+ * ADK wraps a tool's string return value as `{result: "<the string>"}`. Naively
+ * JSON-stringifying that produces double-encoded output, in which every quote
+ * is escaped twice:
+ *
+ *     [tool_result] search -> {"result":"{\"matches\":[{\"id\":8, ...
+ *
+ * A large model shrugs at this. A small one has to spend attention unpicking
+ * the encoding before it can read the payload, and often just fails. Unwrapping
+ * the single `result` key and re-emitting plain JSON costs nothing and gives
+ * the model something legible:
+ *
+ *     [tool_result] search -> {"matches":[{"id":8, ...
+ */
+export declare function renderToolResult(response: unknown): string;
+/**
+ * Maps genai `Content[]` onto Prompt API messages.
+ *
+ * Function calls and responses have no native representation in a Prompt API
+ * message, so they are serialised to text. Without this the model loses the
+ * thread of a multi-step tool interaction.
+ */
+export declare function contentsToMessages(contents: Content[]): ChromeMessage[];
+/** Extracts the system instruction from a request as plain text. */
+export declare function extractSystemInstruction(llmRequest: LlmRequest): string;
+/**
+ * Removes ADK's per-agent identity preamble from a system prompt.
+ *
+ * Turns:
+ *
+ *     You are an agent. Your internal name is "rerank_11".
+ *     The description about you is "..."
+ *
+ *     <the actual instruction>
+ *
+ * into just the instruction, so that sibling agents sharing one instruction
+ * also share one cached session. See
+ * {@link ChromeBuiltInLlmParams.normalizeSystemPrompt}.
+ */
+export declare function stripAdkIdentityPreamble(systemPrompt: string): string;
+/** Whether an error is an aborted-operation error from a cancelled signal. */
+export declare function isAbortError(error: unknown): boolean;
+export declare function finalText(text: string): LlmResponse;
+export declare function errorResponse(error: unknown): LlmResponse;

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

@@ -81,9 +81,14 @@ export declare class Gemini extends BaseLlm {
     /**
      * Sends a request to the Gemini model.
      *
-     * @param llmRequest LlmRequest, the request to send to the Gemini model.
-     * @param stream bool = false, whether to do streaming call.
-     * @yields LlmResponse: The model response.
+     * @param llmRequest The request to send to the Gemini model.
+     * @param stream Whether to make a streaming call. Defaults to `false`.
+     * @yields Each {@link LlmResponse} produced by the model. A non-streaming
+     *     call yields exactly one; a streaming call yields the partial responses
+     *     as they arrive, then a final aggregated response whenever the stream
+     *     carried either content or usage/grounding/citation metadata. A
+     *     metadata-only stream therefore still ends with one, holding the
+     *     metadata and no `content`; only a stream with neither ends silently.
      */
     generateContentAsync(llmRequest: LlmRequest, stream?: boolean, abortSignal?: AbortSignal): AsyncGenerator<LlmResponse, void>;
     protected getHttpOptions(): HttpOptions;

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

@@ -5,8 +5,9 @@
  */
 import { BaseLlm } from './base_llm.js';
 /**
- * type[BaseLlm] equivalent in TypeScript, represents a class that can be new-ed
- * to create a BaseLlm instance.
+ * The constructor of a {@link BaseLlm} subclass, rather than an instance of
+ * one: a class that can be `new`-ed with a model name, and that also exposes
+ * the static `supportedModels` patterns the registry matches against.
  */
 export type BaseLlmType = (new (params: {
     model: string;