@google/adk 1.2.0 → 1.4.0

package/dist/esm/utils/streaming_utils.js

@@ -12,6 +12,7 @@ import { JSONPath } from "jsonpath-plus";
 import { generateClientFunctionCallId } from "../agents/functions.js";
 import { FeatureName, isFeatureEnabled } from "../features/feature_registry.js";
 import { createLlmResponse } from "../models/llm_response.js";
+const UNSAFE_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 class ProgressiveStrategy {
   constructor() {
     this.partsSequence = [];
@@ -78,10 +79,13 @@ class ProgressiveStrategy {
     const pathParts = JSONPath.toPathArray(jsonPath).filter(
       (p) => p !== "$" && p !== "$["
     );
+    if (pathParts.some((part) => UNSAFE_PROPERTY_KEYS.has(String(part)))) {
+      return;
+    }
     let current = this.currentFcArgs;
     for (let i = 0; i < pathParts.length - 1; i++) {
       const part = pathParts[i];
-      if (!(part in current)) {
+      if (!Object.prototype.hasOwnProperty.call(current, part)) {
         current[part] = {};
       }
       current = current[part];
@@ -273,17 +277,13 @@ class StreamingResponseAggregator {
   )) {
     this.isProgressiveMode = isProgressiveMode;
     this.lastThoughtSignature = {};
-    this.sawFunctionCall = false;
     this.strategy = this.isProgressiveMode ? new ProgressiveStrategy() : new NonProgressiveStrategy();
   }
   async *processResponse(response) {
     var _a, _b;
     const llmResponse = createLlmResponse(response);
     const parts = (_b = (_a = llmResponse.content) == null ? void 0 : _a.parts) != null ? _b : [];
-    if (parts.some((part) => part.functionCall)) {
-      this.sawFunctionCall = true;
-    }
-    if (this.sawFunctionCall && llmResponse.finishReason === FinishReason.STOP && parts.length > 0 && parts.every(isEmptyContentPart)) {
+    if (parts.every(isEmptyContentPart) && (llmResponse.finishReason === void 0 || llmResponse.finishReason === FinishReason.STOP)) {
       if (llmResponse.usageMetadata) {
         this.usageMetadata = llmResponse.usageMetadata;
       }
@@ -323,16 +323,23 @@ class StreamingResponseAggregator {
   close() {
     var _a, _b, _c;
     const finalParts = this.strategy.close();
-    if (!finalParts) {
+    const hasMetadata = this.usageMetadata !== void 0 || this.groundingMetadata !== void 0 || this.citationMetadata !== void 0;
+    if (!finalParts && !hasMetadata) {
       return void 0;
     }
     const candidate = (_b = (_a = this.response) == null ? void 0 : _a.candidates) == null ? void 0 : _b[0];
     const finishReason = (_c = this.finishReason) != null ? _c : candidate == null ? void 0 : candidate.finishReason;
     return {
-      content: {
-        role: "model",
-        parts: finalParts
-      },
+      // Only attach a model `content` when there are actual parts to emit. When
+      // the turn accumulated no parts (e.g. a function call that was already
+      // flushed, followed by a trailing STOP chunk that carries only usage
+      // metadata) we still surface that trailing metadata, but MUST NOT emit
+      // `content: { parts: [] }`. An empty-parts model turn corrupts the session
+      // history: on the next request the Vertex AI backend rejects the whole
+      // call with HTTP 400 "Unable to submit request because it must include at
+      // least one parts field", which breaks multi-turn tool-using sessions
+      // right after the first tool call (google/adk-js#21, #22).
+      content: finalParts ? { role: "model", parts: finalParts } : void 0,
       groundingMetadata: this.groundingMetadata,
       citationMetadata: this.citationMetadata,
       errorCode: finishReason === FinishReason.STOP ? void 0 : finishReason,

package/dist/esm/utils/task.js

@@ -0,0 +1,34 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class Task {
+  constructor(executable) {
+    this.executable = executable;
+    this.isDone = false;
+    this.abortController = new AbortController();
+    const markDone = () => {
+      this.isDone = true;
+    };
+    this.promise = executable(this.abortController.signal);
+    this.promise.then(markDone).catch(markDone);
+  }
+  /**
+   * Cancels the task execution.
+   */
+  cancel() {
+    this.abortController.abort();
+  }
+  /**
+   * Returns true if the task has completed (either resolved or rejected).
+   */
+  done() {
+    return this.isDone;
+  }
+}
+export {
+  Task
+};

package/dist/esm/version.js

@@ -5,7 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "1.2.0";
+const version = "1.4.0";
 export {
   version
 };

package/dist/types/a2a/a2a_remote_agent_utils.d.ts

@@ -13,26 +13,51 @@ export interface UserFunctionCall {
     contextId: string;
 }
 /**
- * Returns a UserFunctionCall when the event at index has a FunctionResponse.
+ * Returns a UserFunctionCall when the event at `index` contains a
+ * FunctionResponse that can be traced back to a preceding FunctionCall event.
+ *
+ * @param session - The session whose event history to inspect.
+ * @param index - Index of the candidate event to examine.
+ * @returns The matching `UserFunctionCall`, or `undefined` if the event at
+ *   `index` is not a user function-response event or has no preceding call.
  */
 export declare function getUserFunctionCallAt(session: Session, index: number): UserFunctionCall | undefined;
 /**
  * Checks if an event contains a function call with the given ID.
+ *
+ * @param event - The event to inspect.
+ * @param callId - The function call ID to look for.
+ * @returns `true` if a part in the event has a matching `functionCall.id`.
  */
 export declare function isFunctionCallEvent(event: AdkEvent, callId: string): boolean;
 /**
  * Finds the first part with a FunctionResponse and returns the call ID.
+ *
+ * @param event - The event to inspect.
+ * @returns The `id` of the first FunctionResponse part, or `undefined` if
+ *   none is found.
  */
 export declare function getFunctionResponseCallId(event: AdkEvent): string | undefined;
 /**
- * Returns content parts for all events not present in the remote session
- * and a2a contextId if found in a remote agent event metadata.
+ * Returns A2A content parts for all events not yet seen by the remote agent,
+ * along with the A2A context ID found in the most recent remote agent event.
+ *
+ * @param ctx - The current invocation context, used to identify the remote
+ *   agent's authored events.
+ * @param session - The local session whose event history to diff.
+ * @returns An object with the missing `parts` and an optional `contextId`.
  */
 export declare function toMissingRemoteSessionParts(ctx: InvocationContext, session: Session): {
     parts: A2APart[];
     contextId?: string;
 };
 /**
- * Wraps an agent event as a user message for context.
+ * Wraps an agent event as a user message so it can be sent as context to a
+ * remote agent that only accepts user-role messages.
+ *
+ * @param ctx - The current invocation context.
+ * @param agentEvent - The agent-authored event to reframe as a user message.
+ * @returns A new event with `author: 'user'` whose parts summarise the
+ *   original agent event's text, function calls, and function responses.
  */
 export declare function presentAsUserMessage(ctx: InvocationContext, agentEvent: AdkEvent): AdkEvent;

package/dist/types/a2a/event_converter_utils.d.ts

@@ -8,6 +8,12 @@ import { Event as AdkEvent } from '../events/event.js';
 import { A2AEvent } from './a2a_event.js';
 /**
  * Converts a session Event to an A2A Message.
+ *
+ * @param event - The ADK event to convert.
+ * @param appName - The name of the ADK application.
+ * @param userId - The ID of the current user.
+ * @param sessionId - The ID of the current session.
+ * @returns An A2A message with the event's parts and metadata.
  */
 export declare function toA2AMessage(event: AdkEvent, { appName, userId, sessionId, }: {
     appName: string;
@@ -15,6 +21,13 @@ export declare function toA2AMessage(event: AdkEvent, { appName, userId, session
     sessionId: string;
 }): Message;
 /**
- * Converts an A2A Event to a Session Event.
+ * Converts an A2A Event to an ADK Session Event.
+ *
+ * @param event - The A2A event to convert (message, task, artifact update, or
+ *   status update).
+ * @param invocationId - The ADK invocation ID to attach to the resulting event.
+ * @param agentName - The name of the agent to use as the event author.
+ * @returns The converted ADK event, or `undefined` if the A2A event type
+ *   produces no content.
  */
 export declare function toAdkEvent(event: A2AEvent, invocationId: string, agentName: string): AdkEvent | undefined;

package/dist/types/a2a/metadata_converter_utils.d.ts

@@ -39,10 +39,19 @@ export declare enum AdkMetadataKeys {
 }
 /**
  * Creates ADK Event metadata from an A2A Event.
+ *
+ * @param a2aEvent - The A2A event to extract metadata from.
+ * @returns A record containing the ADK task ID and context ID keys.
  */
 export declare function getAdkEventMetadata(a2aEvent: A2AEvent): Record<string, unknown>;
 /**
  * Creates A2A Event metadata from an ADK Event.
+ *
+ * @param adkEvent - The ADK event to extract metadata from.
+ * @param appName - The name of the ADK application.
+ * @param userId - The ID of the current user.
+ * @param sessionId - The ID of the current session.
+ * @returns A record of A2A metadata keys populated from the ADK event.
  */
 export declare function getA2AEventMetadata(adkEvent: AdkEvent, { appName, userId, sessionId, }: {
     appName: string;
@@ -51,6 +60,11 @@ export declare function getA2AEventMetadata(adkEvent: AdkEvent, { appName, userI
 }): Record<string, unknown>;
 /**
  * Creates A2A Session metadata from ADK Event invocation metadata.
+ *
+ * @param appName - The name of the ADK application.
+ * @param userId - The ID of the current user.
+ * @param sessionId - The ID of the current session.
+ * @returns A record of A2A metadata keys for app name, user ID, and session ID.
  */
 export declare function getA2ASessionMetadata({ appName, userId, sessionId, }: {
     appName: string;
@@ -59,5 +73,9 @@ export declare function getA2ASessionMetadata({ appName, userId, sessionId, }: {
 }): Record<string, unknown>;
 /**
  * Creates A2A Event metadata from ADK Event actions.
+ *
+ * @param actions - The ADK event actions to extract escalation and transfer
+ *   metadata from.
+ * @returns A record with escalate and transfer-to-agent A2A metadata keys.
  */
 export declare function getA2AEventMetadataFromActions(actions: AdkEventActions): Record<string, unknown>;

package/dist/types/a2a/part_converter_utils.d.ts

@@ -6,43 +6,88 @@
 import { DataPart as A2ADataPart, FilePart as A2AFilePart, Part as A2APart, TextPart as A2ATextPart, Message } from '@a2a-js/sdk';
 import { Content as GenAIContent, Part as GenAIPart } from '@google/genai';
 /**
- * Converts GenAI Parts to A2A Parts.
+ * Converts an array of GenAI Parts to A2A Parts.
+ *
+ * @param parts - The GenAI parts to convert. Defaults to an empty array.
+ * @param longRunningToolIDs - IDs of function calls that are long-running.
+ * @returns An array of A2A parts.
  */
 export declare function toA2AParts(parts?: GenAIPart[], longRunningToolIDs?: string[]): A2APart[];
 /**
- * Converts a GenAI Part to an A2A Part.
+ * Converts a single GenAI Part to the appropriate A2A Part type.
+ *
+ * @param part - The GenAI part to convert.
+ * @param longRunningToolIDs - IDs of function calls that are long-running.
+ * @returns The corresponding A2A part (text, file, or data).
  */
 export declare function toA2APart(part: GenAIPart, longRunningToolIDs?: string[]): A2APart;
 /**
  * Converts a GenAI Text Part to an A2A Text Part.
+ *
+ * @param part - The GenAI part containing a text field.
+ * @returns An A2A text part, with thought metadata attached if applicable.
  */
 export declare function toA2ATextPart(part: GenAIPart): A2APart;
 /**
  * Converts a GenAI File Part to an A2A File Part.
+ *
+ * @param part - The GenAI part containing `fileData` or `inlineData`.
+ * @returns An A2A file part with URI or bytes depending on the source.
+ * @throws {Error} If the part contains neither `fileData` nor `inlineData`.
  */
 export declare function toA2AFilePart(part: GenAIPart): A2APart;
 /**
- * Converts a GenAI Data Part to an A2A Data Part.
+ * Converts a GenAI Data Part (function call/response or code) to an A2A Data Part.
+ *
+ * @param part - The GenAI part containing structured data.
+ * @param longRunningToolIDs - IDs of function calls that are long-running.
+ * @returns An A2A data part with the appropriate type metadata.
  */
 export declare function toA2ADataPart(part: GenAIPart, longRunningToolIDs?: string[]): A2APart;
+/**
+ * Converts an A2A Message to a GenAI Content object.
+ *
+ * @param a2aMessage - The A2A message to convert.
+ * @returns A GenAI user or model content object based on the message role.
+ */
 export declare function toGenAIContent(a2aMessage: Message): GenAIContent;
 /**
- * Converts an A2A Part to a GenAI Part.
+ * Converts an array of A2A Parts to GenAI Parts.
+ *
+ * @param a2aParts - The A2A parts to convert.
+ * @returns An array of GenAI parts.
  */
 export declare function toGenAIParts(a2aParts: A2APart[]): GenAIPart[];
 /**
- * Converts an A2A Part to a GenAI Part.
+ * Converts a single A2A Part to the appropriate GenAI Part type.
+ *
+ * @param a2aPart - The A2A part to convert.
+ * @returns The corresponding GenAI part.
+ * @throws {Error} If the A2A part has an unrecognized `kind`.
  */
 export declare function toGenAIPart(a2aPart: A2APart): GenAIPart;
 /**
  * Converts an A2A Text Part to a GenAI Part.
+ *
+ * @param a2aPart - The A2A text part to convert.
+ * @returns A GenAI part with `text` and optional `thought` flag.
  */
 export declare function toGenAIPartText(a2aPart: A2ATextPart): GenAIPart;
 /**
  * Converts an A2A File Part to a GenAI Part.
+ *
+ * @param a2aPart - The A2A file part containing bytes or a URI.
+ * @returns A GenAI part with `inlineData` or `fileData` depending on the
+ *   source, with optional video metadata attached.
+ * @throws {Error} If the file part contains neither bytes nor a URI.
  */
 export declare function toGenAIPartFile(a2aPart: A2AFilePart): GenAIPart;
 /**
- * Converts an A2A Data Part to a GenAI Part.
+ * Converts an A2A Data Part to the appropriate GenAI Part.
+ *
+ * @param a2aPart - The A2A data part containing structured data and type metadata.
+ * @returns A GenAI part with the appropriate function call, function response,
+ *   or code execution fields, falling back to a JSON text part if the type is
+ *   unrecognized.
  */
 export declare function toGenAIPartData(a2aPart: A2ADataPart): GenAIPart;

package/dist/types/agents/active_streaming_tool.d.ts

@@ -3,12 +3,13 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { Task } from '../utils/task.js';
 import { LiveRequestQueue } from './live_request_queue.js';
 /**
  * The parameters for creating an ActiveStreamingTool.
  */
 export interface ActiveStreamingToolParams {
-    task?: Promise<void>;
+    task?: Task<void> | Promise<void>;
     stream?: LiveRequestQueue;
 }
 /**
@@ -17,10 +18,8 @@ export interface ActiveStreamingToolParams {
 export declare class ActiveStreamingTool {
     /**
      * The active task of this streaming tool.
-     * TODO: Replace 'Promise<void>' with a proper Task type if available in this
-     * env.
      */
-    task?: Promise<void>;
+    task?: Task<void>;
     /**
      * The active (input) streams of this streaming tool.
      */

package/dist/types/agents/functions.d.ts

@@ -3,12 +3,13 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Content, FunctionCall } from '@google/genai';
+import { FunctionCall } from '@google/genai';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event } from '../events/event.js';
 import { BaseTool } from '../tools/base_tool.js';
 import { ToolConfirmation } from '../tools/tool_confirmation.js';
 import { SingleAfterToolCallback, SingleBeforeToolCallback } from './llm_agent.js';
+export declare const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
 export declare const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
 export declare const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
 export declare const functionsExportedForTestingOnly: {
@@ -24,14 +25,6 @@ export declare function generateClientFunctionCallId(): string;
  * unique client-side ID to each one that doesn't already have an ID.
  */
 export declare function populateClientFunctionCallId(modelResponseEvent: Event): void;
-/**
- * Removes the client-generated function call IDs from a given content object.
- *
- * When sending content back to the server, these IDs are
- * specific to the client-side and should not be included in requests to the
- * model.
- */
-export declare function removeClientFunctionCallId(content: Content): void;
 /**
  * Returns a set of function call ids of the long running tools.
  */
@@ -90,3 +83,13 @@ export declare function handleFunctionCallList({ invocationContext, functionCall
  * Merges a list of function response events into a single event.
  */
 export declare function mergeParallelFunctionResponseEvents(functionResponseEvents: Event[]): Event;
+/**
+ * Finds the function call event that matches the function call ID.
+ * Mirrors Python ADK's `find_event_by_function_call_id`.
+ */
+export declare function findEventByFunctionCallId(events: Event[], functionCallId: string, endIndex?: number): Event | undefined;
+/**
+ * Finds the function call event that matches the function response ID of the last event.
+ * Mirrors Python ADK's `find_matching_function_call`.
+ */
+export declare function findMatchingFunctionCall(events: Event[]): Event | undefined;

package/dist/types/agents/invocation_context.d.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Content } from '@google/genai';
-import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
+import { SessionArtifactService } from '../artifacts/session_artifact_service.js';
 import { BaseCredentialService } from '../auth/credential_service/base_credential_service.js';
 import { BaseMemoryService } from '../memory/base_memory_service.js';
 import { PluginManager } from '../plugins/plugin_manager.js';
@@ -12,14 +12,13 @@ import { BaseSessionService } from '../sessions/base_session_service.js';
 import { Session } from '../sessions/session.js';
 import { ActiveStreamingTool } from './active_streaming_tool.js';
 import { BaseAgent } from './base_agent.js';
-import { LiveRequestQueue } from './live_request_queue.js';
 import { RunConfig } from './run_config.js';
 import { TranscriptionEntry } from './transcription_entry.js';
 /**
  * The parameters for creating an invocation context.
  */
 export interface InvocationContextParams {
-    artifactService?: BaseArtifactService;
+    artifactService?: SessionArtifactService;
     sessionService?: BaseSessionService;
     memoryService?: BaseMemoryService;
     credentialService?: BaseCredentialService;
@@ -31,7 +30,6 @@ export interface InvocationContextParams {
     endInvocation?: boolean;
     transcriptionCache?: TranscriptionEntry[];
     runConfig?: RunConfig;
-    liveRequestQueue?: LiveRequestQueue;
     activeStreamingTools?: Record<string, ActiveStreamingTool>;
     pluginManager: PluginManager;
     abortSignal?: AbortSignal;
@@ -76,7 +74,7 @@ export interface InvocationContextParams {
  *  ```
  */
 export declare class InvocationContext {
-    readonly artifactService?: BaseArtifactService;
+    readonly artifactService?: SessionArtifactService;
     readonly sessionService?: BaseSessionService;
     readonly memoryService?: BaseMemoryService;
     readonly credentialService?: BaseCredentialService;
@@ -122,12 +120,12 @@ export declare class InvocationContext {
     /**
      * A container to keep track of different kinds of costs incurred as a part of
      * this invocation.
+     *
+     * This is shared across every agent context of the same invocation (see the
+     * constructor) so run-wide limits such as `maxLlmCalls` are enforced for the
+     * whole invocation rather than resetting for each agent/sub-agent.
      */
     private readonly invocationCostManager;
-    /**
-     * The queue to receive live requests.
-     */
-    liveRequestQueue?: LiveRequestQueue;
     /**
      * The running streaming tools of this invocation.
      */
@@ -136,9 +134,6 @@ export declare class InvocationContext {
      * The manager for keeping track of plugins in this invocation.
      */
     pluginManager: PluginManager;
-    /**
-     * The abort signal for the invocation.
-     */
     readonly abortSignal?: AbortSignal;
     /**
      * @param params The parameters for creating an invocation context.

package/dist/types/agents/llm_agent.d.ts

@@ -327,6 +327,20 @@ export declare class LlmAgent extends BaseAgent {
     private maybeSaveOutputToState;
     protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
     protected runLiveImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
+    /**
+     * Runs the bidirectional (live) flow for this agent.
+     *
+     * Establishes a live connection to the model, drains the invocation's
+     * `liveRequestQueue` into the connection on a parallel task, and yields
+     * events derived from server messages until the queue closes, the model
+     * finishes, or an agent transfer occurs.
+     *
+     * If the live connection drops (network failure, server `goAway`) and a
+     * session resumption handle has been observed, the flow transparently
+     * reconnects using that handle up to {@link MAX_LIVE_RECONNECT_ATTEMPTS}
+     * times. Subsequent reconnects skip `sendHistory` because the server
+     * already holds the conversation state associated with the handle.
+     */
     private runLiveFlow;
     private runOneStepAsync;
     private postprocess;

package/dist/types/agents/processors/agent_transfer_llm_request_processor.d.ts

@@ -7,9 +7,23 @@ import { Event } from '../../events/event.js';
 import { LlmRequest } from '../../models/llm_request.js';
 import { InvocationContext } from '../invocation_context.js';
 import { BaseLlmRequestProcessor } from './base_llm_processor.js';
+/**
+ * Augments the {@link LlmRequest} to support agent transfer. When the current
+ * agent has reachable transfer targets (sub-agents, peer agents, or a parent
+ * agent), this processor registers a `transfer_to_agent` function tool and
+ * appends instructions describing each candidate so the model can choose to
+ * hand off control.
+ */
 export declare class AgentTransferLlmRequestProcessor extends BaseLlmRequestProcessor {
     private readonly toolName;
     private readonly tool;
+    /**
+     * Appends transfer instructions and registers the `transfer_to_agent` tool
+     * when the agent has reachable transfer targets.
+     *
+     * @param invocationContext - The current invocation context.
+     * @param llmRequest - The request to augment with transfer instructions and the transfer tool.
+     */
     runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
     private buildTargetAgentsInfo;
     private buildTargetAgentsInstructions;

package/dist/types/agents/processors/basic_llm_request_processor.d.ts

@@ -13,6 +13,13 @@ import { BaseLlmRequestProcessor } from './base_llm_processor.js';
  * connect settings.
  */
 export declare class BasicLlmRequestProcessor extends BaseLlmRequestProcessor {
+    /**
+     * Populates model name, generation config, output schema, and live connect
+     * settings on the request from the agent and run config.
+     *
+     * @param invocationContext - The current invocation context.
+     * @param llmRequest - The request object to populate in place.
+     */
     runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
 }
 export declare const BASIC_LLM_REQUEST_PROCESSOR: BasicLlmRequestProcessor;

package/dist/types/agents/processors/content_processor_utils.d.ts

@@ -5,6 +5,14 @@
  */
 import { Content } from '@google/genai';
 import { Event } from '../../events/event.js';
+/**
+ * Removes the client-generated function call IDs from a given content object.
+ *
+ * When sending content back to the server, these IDs are
+ * specific to the client-side and should not be included in requests to the
+ * model.
+ */
+export declare function removeClientFunctionCallId(content: Content): void;
 /**
  * Get the contents for the LLM request.
  *
@@ -34,3 +42,29 @@ export declare function getContents(events: Event[], agentName: string, currentB
  *     needed for proper tool execution while excluding conversation history.
  */
 export declare function getCurrentTurnContents(events: Event[], agentName: string, currentBranch?: string): Content[];
+/**
+ * Merges a list of function_response events into one event.
+ *
+ * The key goal is to ensure:
+ *  1. function_call and function_response are always of the same number.
+ *  2. The function_call and function_response are consecutively in the content.
+ *
+ * @param events: A list of function_response events.
+ *
+ * NOTE:
+ * function_response_events must fulfill these requirements:
+ * 1. The list is in increasing order of timestamp;
+ * 2. the first event is the initial function_response event;
+ * 3. all later events should contain at least one function_response part that
+ * related to the function_call event. Caveat: This implementation doesn't
+ * support when a parallel function_call event contains async function_call of
+ * the same name.
+ *
+ * @returns
+ *    A merged event, that is
+ *      1. All later function_response will replace function_response part in
+ *          the initial function_response event.
+ *      2. All non-function_response parts will be appended to the part list of
+ *          the initial function_response event.
+ */
+export declare function mergeFunctionResponseEvents(events: Event[]): Event;

package/dist/types/agents/processors/content_request_processor.d.ts

@@ -7,7 +7,23 @@ import { Event } from '../../events/event.js';
 import { LlmRequest } from '../../models/llm_request.js';
 import { InvocationContext } from '../invocation_context.js';
 import { BaseLlmRequestProcessor } from './base_llm_processor.js';
+/**
+ * Populates {@link LlmRequest.contents} from the session event history.
+ *
+ * When a {@link CompactedEvent} exists in the session, only the most recent
+ * compacted event and the raw events that follow it are included, eliding
+ * earlier history. The extent of context included depends on the agent's
+ * `includeContents` setting: `'default'` sends the full visible history while
+ * any other value sends only the current-turn context.
+ */
 export declare class ContentRequestProcessor implements BaseLlmRequestProcessor {
+    /**
+     * Fills {@link LlmRequest.contents} based on the session event history and
+     * agent configuration.
+     *
+     * @param invocationContext - The current invocation context.
+     * @param llmRequest - The request whose contents field will be populated.
+     */
     runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
 }
 export declare const CONTENT_REQUEST_PROCESSOR: ContentRequestProcessor;

package/dist/types/agents/processors/context_compactor_request_processor.d.ts

@@ -17,6 +17,18 @@ import { BaseLlmRequestProcessor } from './base_llm_processor.js';
  */
 export declare class ContextCompactorRequestProcessor implements BaseLlmRequestProcessor {
     private compactors;
+    /**
+     * @param compactors - Ordered list of compactors to evaluate; the first one
+     *   that reports it should compact will perform the compaction.
+     */
     constructor(compactors: BaseContextCompactor[]);
+    /**
+     * Evaluates compactors in priority order. The first compactor that indicates
+     * it should compact will compact the session history, fire plugin hooks, and
+     * yield any newly generated events. Iteration stops after one compaction.
+     *
+     * @param invocationContext - The current invocation context.
+     * @param _llmRequest - Unused; present to satisfy the {@link BaseLlmRequestProcessor} interface.
+     */
     runAsync(invocationContext: InvocationContext, _llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
 }

package/dist/types/agents/processors/identity_llm_request_processor.d.ts

@@ -12,6 +12,13 @@ import { BaseLlmRequestProcessor } from './base_llm_processor.js';
  * informing the model of the agent's name and description.
  */
 export declare class IdentityLlmRequestProcessor extends BaseLlmRequestProcessor {
+    /**
+     * Appends agent name and description as identity instructions to the system
+     * prompt of the request.
+     *
+     * @param invocationContext - The current invocation context.
+     * @param llmRequest - The request object to append instructions to.
+     */
     runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, undefined>;
 }
 export declare const IDENTITY_LLM_REQUEST_PROCESSOR: IdentityLlmRequestProcessor;

package/dist/types/agents/processors/interactions_request_processor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../../events/event.js';
+import { LlmRequest } from '../../models/llm_request.js';
+import { InvocationContext } from '../invocation_context.js';
+import { BaseLlmRequestProcessor } from './base_llm_processor.js';
+/**
+ * Request processor for Gemini Interactions API.
+ * Resolves the previous interaction ID from the session history.
+ */
+export declare class InteractionsRequestProcessor implements BaseLlmRequestProcessor {
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
+}
+export declare const INTERACTIONS_REQUEST_PROCESSOR: InteractionsRequestProcessor;