@google/adk 0.5.0 → 0.6.0

package/dist/esm/memory/in_memory_memory_service.js

@@ -58,7 +58,7 @@ function getUserKey(appName, userId) {
 }
 function extractWordsLower(text) {
   return new Set(
-    [...text.matchAll(/[A-Za-z]+/)].map((match) => match[0].toLowerCase())
+    [...text.matchAll(/[A-Za-z]+/g)].map((match) => match[0].toLowerCase())
   );
 }
 function formatTimestamp(timestamp) {

package/dist/esm/runner/runner.js

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
 import { createPartFromText } from "@google/genai";
 import { context, trace } from "@opentelemetry/api";
 import {
@@ -24,12 +25,18 @@ import {
 } from "../telemetry/tracing.js";
 import { logger } from "../utils/logger.js";
 import { isGemini2OrAbove } from "../utils/model_name.js";
+const RUNNER_SIGNATURE_SYMBOL = Symbol.for("google.adk.runner");
+function isRunner(obj) {
+  return typeof obj === "object" && obj !== null && RUNNER_SIGNATURE_SYMBOL in obj && obj[RUNNER_SIGNATURE_SYMBOL] === true;
+}
+_a = RUNNER_SIGNATURE_SYMBOL;
 class Runner {
   constructor(input) {
-    var _a;
+    this[_a] = true;
+    var _a2;
     this.appName = input.appName;
     this.agent = input.agent;
-    this.pluginManager = new PluginManager((_a = input.plugins) != null ? _a : []);
+    this.pluginManager = new PluginManager((_a2 = input.plugins) != null ? _a2 : []);
     this.artifactService = input.artifactService;
     this.sessionService = input.sessionService;
     this.memoryService = input.memoryService;
@@ -89,7 +96,7 @@ class Runner {
         ctx,
         this,
         async function* () {
-          var _a;
+          var _a2;
           const session = await this.sessionService.getSession({
             appName: this.appName,
             userId,
@@ -134,7 +141,7 @@ class Runner {
             newMessage = pluginUserMessage;
           }
           if (newMessage) {
-            if (!((_a = newMessage.parts) == null ? void 0 : _a.length)) {
+            if (!((_a2 = newMessage.parts) == null ? void 0 : _a2.length)) {
               throw new Error("No parts in the newMessage.");
             }
             if (runConfig.saveInputBlobsAsArtifacts) {
@@ -210,8 +217,8 @@ class Runner {
    * @param message The message containing parts to process.
    */
   async saveArtifacts(invocationId, userId, sessionId, message) {
-    var _a;
-    if (!this.artifactService || !((_a = message.parts) == null ? void 0 : _a.length)) {
+    var _a2;
+    if (!this.artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
       return;
     }
     for (let i = 0; i < message.parts.length; i++) {
@@ -292,12 +299,12 @@ class Runner {
   // TODO - b/425992518: Implement runLive and related methods.
 }
 function findEventByLastFunctionResponseId(events) {
-  var _a, _b, _c, _d;
+  var _a2, _b, _c, _d;
   if (!events.length) {
     return null;
   }
   const lastEvent = events[events.length - 1];
-  const functionCallId = (_d = (_c = (_b = (_a = lastEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.find(
+  const functionCallId = (_d = (_c = (_b = (_a2 = lastEvent.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b.find(
     (part) => part.functionResponse
   )) == null ? void 0 : _c.functionResponse) == null ? void 0 : _d.id;
   if (!functionCallId) {
@@ -318,5 +325,6 @@ function findEventByLastFunctionResponseId(events) {
   return null;
 }
 export {
-  Runner
+  Runner,
+  isRunner
 };

package/dist/esm/sessions/db/operations.js

@@ -25,7 +25,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { MikroORM } from "@mikro-orm/core";
 import {
   ENTITIES,
   SCHEMA_VERSION_1_JSON,
@@ -61,9 +60,10 @@ async function getConnectionOptionsFromUri(uri) {
   }
   const { host, port, username, password, pathname } = new URL(uri);
   const hostName = host.split(":")[0];
+  const dbName = uri.startsWith("sqlite://") ? uri.substring("sqlite://".length) : pathname.slice(1);
   return {
     entities: ENTITIES,
-    dbName: pathname.slice(1),
+    dbName,
     host: hostName,
     port: port ? parseInt(port) : void 0,
     user: username,
@@ -71,19 +71,9 @@ async function getConnectionOptionsFromUri(uri) {
     driver
   };
 }
-async function ensureDatabaseCreated(ormOrUrlOrOptions) {
-  let orm;
-  if (ormOrUrlOrOptions instanceof MikroORM) {
-    orm = ormOrUrlOrOptions;
-  } else if (typeof ormOrUrlOrOptions === "string") {
-    orm = await MikroORM.init(
-      await getConnectionOptionsFromUri(ormOrUrlOrOptions)
-    );
-  } else {
-    orm = await MikroORM.init(ormOrUrlOrOptions);
-  }
+async function ensureDatabaseCreated(orm) {
   await orm.schema.ensureDatabase();
-  await orm.schema.updateSchema();
+  await orm.schema.updateSchema({ safe: true });
 }
 async function validateDatabaseSchemaVersion(orm) {
   const em = orm.em.fork();

package/dist/esm/sessions/state.js

@@ -53,8 +53,8 @@ class State {
    * @param delta The delta to update the state with.
    */
   update(delta) {
-    this.delta = { ...this.delta, ...delta };
-    this.value = { ...this.value, ...delta };
+    Object.assign(this.delta, delta);
+    Object.assign(this.value, delta);
   }
   /**
    * Returns the state as a plain JSON object.

package/dist/esm/tools/agent_tool.js

@@ -63,7 +63,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
     args,
     toolContext
   }) {
-    var _a2, _b2;
+    var _a2, _b2, _c, _d;
     if (this.skipSummarization) {
       toolContext.actions.skipSummarization = true;
     }
@@ -82,13 +82,14 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
       appName: this.agent.name,
       agent: this.agent,
       artifactService: new ForwardingArtifactService(toolContext),
-      sessionService: new InMemorySessionService(),
-      memoryService: new InMemoryMemoryService(),
+      sessionService: (_a2 = toolContext.invocationContext.sessionService) != null ? _a2 : new InMemorySessionService(),
+      memoryService: (_b2 = toolContext.invocationContext.memoryService) != null ? _b2 : new InMemoryMemoryService(),
       credentialService: toolContext.invocationContext.credentialService
     });
     const session = await runner.sessionService.createSession({
       appName: this.agent.name,
-      userId: "tmp_user",
+      userId: toolContext.invocationContext.userId,
+      sessionId: toolContext.invocationContext.session.id,
       state: toolContext.state.toRecord()
     });
     let lastEvent;
@@ -102,7 +103,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
       }
       lastEvent = event;
     }
-    if (!((_b2 = (_a2 = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b2.length)) {
+    if (!((_d = (_c = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _c.parts) == null ? void 0 : _d.length)) {
       return "";
     }
     const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;

package/dist/esm/tools/load_artifacts_tool.js

@@ -0,0 +1,159 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { appendInstructions } from "../models/llm_request.js";
+import { getLogger } from "../utils/logger.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+const logger = getLogger();
+const GEMINI_SUPPORTED_INLINE_MIME_PREFIXES = ["image/", "audio/", "video/"];
+const GEMINI_SUPPORTED_INLINE_MIME_TYPES = /* @__PURE__ */ new Set(["application/pdf"]);
+const TEXT_LIKE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "application/csv",
+  "application/json",
+  "application/xml"
+]);
+function normalizeMimeType(mimeType) {
+  if (!mimeType) {
+    return void 0;
+  }
+  return mimeType.split(";")[0].trim();
+}
+function isInlineMimeTypeSupported(mimeType) {
+  const normalized = normalizeMimeType(mimeType);
+  if (!normalized) {
+    return false;
+  }
+  return GEMINI_SUPPORTED_INLINE_MIME_PREFIXES.some(
+    (prefix) => normalized.startsWith(prefix)
+  ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
+}
+function asSafePartForLlm(artifact, artifactName) {
+  const inlineData = artifact.inlineData;
+  if (!inlineData) {
+    return artifact;
+  }
+  if (isInlineMimeTypeSupported(inlineData.mimeType)) {
+    return artifact;
+  }
+  const mimeType = normalizeMimeType(inlineData.mimeType) || "application/octet-stream";
+  const data = inlineData.data;
+  if (!data) {
+    return {
+      text: `[Artifact: ${artifactName}, type: ${mimeType}. No inline data was provided.]`
+    };
+  }
+  const isTextLike = mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
+  const decodedBuffer = Buffer.from(data, "base64");
+  if (isTextLike) {
+    try {
+      const decoded = decodedBuffer.toString("utf8");
+      return { text: decoded };
+    } catch {
+    }
+  }
+  const sizeKb = decodedBuffer.length / 1024;
+  return {
+    text: `[Binary artifact: ${artifactName}, type: ${mimeType}, size: ${sizeKb.toFixed(1)} KB. Content cannot be displayed inline.]`
+  };
+}
+class LoadArtifactsTool extends BaseTool {
+  constructor() {
+    super({
+      name: "load_artifacts",
+      description: `Loads artifacts into the session for this request.
+
+NOTE: Call when you need access to artifacts (for example, uploads saved by the web UI).`
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          artifact_names: {
+            type: Type.ARRAY,
+            items: {
+              type: Type.STRING
+            },
+            description: "The names of the artifacts to load."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const artifactNames = args["artifact_names"] || [];
+    return {
+      artifact_names: artifactNames,
+      status: "artifact contents temporarily inserted and removed. to access these artifacts, call load_artifacts tool again."
+    };
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    await this.appendArtifactsToLlmRequest(
+      request.toolContext,
+      request.llmRequest
+    );
+  }
+  async appendArtifactsToLlmRequest(toolContext, llmRequest) {
+    if (!toolContext.invocationContext.artifactService) {
+      return;
+    }
+    const artifactNames = await toolContext.listArtifacts();
+    if (!artifactNames || artifactNames.length === 0) {
+      return;
+    }
+    appendInstructions(llmRequest, [
+      `You have a list of artifacts:
+  ${JSON.stringify(
+        artifactNames
+      )}
+
+  When the user asks questions about any of the artifacts, you should call the
+  \`load_artifacts\` function to load the artifact. Always call load_artifacts
+  before answering questions related to the artifacts, regardless of whether the
+  artifacts have been loaded before. Do not depend on prior answers about the
+  artifacts.`
+    ]);
+    const contents = llmRequest.contents;
+    if (contents && contents.length > 0) {
+      const lastContent = contents[contents.length - 1];
+      if (lastContent.role === "user" && lastContent.parts && lastContent.parts.length > 0) {
+        const functionResponsePart = lastContent.parts[0];
+        const functionResponse = functionResponsePart.functionResponse;
+        if (functionResponse && functionResponse.name === "load_artifacts") {
+          const response = functionResponse.response || {};
+          const namesToLoad = response["artifact_names"] || [];
+          for (const artifactName of namesToLoad) {
+            let artifact = await toolContext.loadArtifact(artifactName);
+            if (!artifact && !artifactName.startsWith("user:")) {
+              const prefixedName = `user:${artifactName}`;
+              artifact = await toolContext.loadArtifact(prefixedName);
+            }
+            if (!artifact) {
+              logger.warn(`Artifact "${artifactName}" not found, skipping`);
+              continue;
+            }
+            const artifactPart = asSafePartForLlm(artifact, artifactName);
+            llmRequest.contents.push({
+              role: "user",
+              parts: [{ text: `Artifact ${artifactName} is:` }, artifactPart]
+            });
+          }
+        }
+      }
+    }
+  }
+}
+const LOAD_ARTIFACTS = new LoadArtifactsTool();
+export {
+  LOAD_ARTIFACTS,
+  LoadArtifactsTool
+};

package/dist/esm/tools/load_memory_tool.js

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { appendInstructions } from "../models/llm_request.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+class LoadMemoryTool extends BaseTool {
+  constructor() {
+    super({
+      name: "load_memory",
+      description: "Loads the memory for the current user.\n\nNOTE: Currently this tool only uses text part from the memory."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          query: {
+            type: Type.STRING,
+            description: "The query to load the memory for."
+          }
+        },
+        required: ["query"]
+      }
+    };
+  }
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    try {
+      const query = args["query"];
+      if (!toolContext.invocationContext.memoryService) {
+        throw new Error("Memory service is not initialized.");
+      }
+      const searchMemoryResponse = await toolContext.searchMemory(query);
+      return {
+        memories: searchMemoryResponse.memories.map((m) => {
+          var _a, _b;
+          return {
+            // Join all text parts by a space, or empty string if no text parts
+            content: (_b = (_a = m.content.parts) == null ? void 0 : _a.map((p) => {
+              var _a2;
+              return (_a2 = p.text) != null ? _a2 : "";
+            }).join(" ")) != null ? _b : "",
+            author: m.author,
+            timestamp: m.timestamp
+          };
+        })
+      };
+    } catch (e) {
+      console.error("ERROR in LoadMemoryTool runAsync:", e);
+      throw e;
+    }
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    if (!request.toolContext.invocationContext.memoryService) {
+      return;
+    }
+    appendInstructions(request.llmRequest, [
+      `You have memory. You can use it to answer questions. If any questions need
+you to look up the memory, you should call load_memory function with a query.`
+    ]);
+  }
+}
+const LOAD_MEMORY = new LoadMemoryTool();
+export {
+  LOAD_MEMORY,
+  LoadMemoryTool
+};

package/dist/esm/tools/preload_memory_tool.js

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { appendInstructions } from "../models/llm_request.js";
+import { logger } from "../utils/logger.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+class PreloadMemoryTool extends BaseTool {
+  constructor() {
+    super({
+      // Name and description are not used because this tool only
+      // changes llm_request.
+      name: "preload_memory",
+      description: "preload_memory"
+    });
+  }
+  async runAsync({
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    args,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    toolContext
+  }) {
+    throw new Error("PreloadMemoryTool should not be called by model");
+  }
+  async processLlmRequest(request) {
+    var _a, _b, _c;
+    await super.processLlmRequest(request);
+    const userContent = request.toolContext.userContent;
+    if (!userContent || !userContent.parts || !((_a = userContent.parts[0]) == null ? void 0 : _a.text)) {
+      return;
+    }
+    const userQuery = userContent.parts[0].text;
+    let response;
+    try {
+      if (!request.toolContext.invocationContext.memoryService) {
+        return;
+      }
+      response = await request.toolContext.searchMemory(userQuery);
+    } catch (_) {
+      logger.warn(`Failed to preload memory for query: ${userQuery}`);
+      return;
+    }
+    if (!response.memories || response.memories.length === 0) {
+      return;
+    }
+    const memoryTextLines = [];
+    for (const memory of response.memories) {
+      const timeStr = memory.timestamp ? `Time: ${memory.timestamp}` : "";
+      if (timeStr) memoryTextLines.push(timeStr);
+      const memoryText = (_c = (_b = memory.content.parts) == null ? void 0 : _b.map((p) => {
+        var _a2;
+        return (_a2 = p.text) != null ? _a2 : "";
+      }).join(" ")) != null ? _c : "";
+      if (memoryText) {
+        memoryTextLines.push(
+          memory.author ? `${memory.author}: ${memoryText}` : memoryText
+        );
+      }
+    }
+    if (memoryTextLines.length === 0) {
+      return;
+    }
+    const fullMemoryText = memoryTextLines.join("\n");
+    const si = `The following content is from your previous conversations with the user.
+They may be useful for answering the user's current query.
+<PAST_CONVERSATIONS>
+${fullMemoryText}
+</PAST_CONVERSATIONS>
+`;
+    appendInstructions(request.llmRequest, [si]);
+  }
+}
+const PRELOAD_MEMORY = new PreloadMemoryTool();
+export {
+  PRELOAD_MEMORY,
+  PreloadMemoryTool
+};

package/dist/esm/utils/logger.js

@@ -21,6 +21,7 @@ class SimpleLogger {
         "warn": 2 /* WARN */,
         "error": 3 /* ERROR */
       },
+      level: "error",
       format: winston.format.combine(
         winston.format.label({ label: "ADK" }),
         winston.format((info) => {

package/dist/esm/version.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "0.5.0";
+const version = "0.6.0";
 export {
   version
 };

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

@@ -11,6 +11,18 @@ export declare enum MessageRole {
     USER = "user",
     AGENT = "agent"
 }
+/**
+ * Task states.
+ */
+export declare enum TaskState {
+    SUBMITTED = "submitted",
+    WORKING = "working",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELED = "canceled",
+    REJECTED = "rejected",
+    INPUT_REQUIRED = "input-required"
+}
 /**
  * A2A event.
  */
@@ -54,26 +66,29 @@ export declare function getFailedTaskStatusUpdateEventError(event: TaskStatusUpd
 /**
  * Creates a task submitted event.
  */
-export declare function createTaskSubmittedEvent({ taskId, contextId, message, }: {
+export declare function createTaskSubmittedEvent({ taskId, contextId, message, metadata, }: {
     taskId: string;
     contextId: string;
     message: Message;
+    metadata?: Record<string, unknown>;
 }): TaskStatusUpdateEvent;
 /**
  * Creates a task with submitted status.
  */
-export declare function createTask({ contextId, message, taskId, }: {
+export declare function createTask({ contextId, message, taskId, metadata, }: {
     taskId: string;
     contextId: string;
     message: Message;
+    metadata?: Record<string, unknown>;
 }): Task;
 /**
  * Creates a task working event.
  */
-export declare function createTaskWorkingEvent({ taskId, contextId, message, }: {
+export declare function createTaskWorkingEvent({ taskId, contextId, message, metadata, }: {
     taskId: string;
     contextId: string;
-    message: Message;
+    message?: Message;
+    metadata?: Record<string, unknown>;
 }): TaskStatusUpdateEvent;
 /**
  * Creates a task completed event.
@@ -107,16 +122,18 @@ export declare function createTaskFailedEvent({ taskId, contextId, error, metada
 /**
  * Creates an input required event.
  */
-export declare function createTaskInputRequiredEvent({ taskId, contextId, parts, }: {
+export declare function createTaskInputRequiredEvent({ taskId, contextId, parts, metadata, }: {
     taskId: string;
     contextId: string;
     parts: A2APart[];
+    metadata?: Record<string, unknown>;
 }): TaskStatusUpdateEvent;
 /**
  * Creates an error message for missing input for a function call.
  */
-export declare function createInputMissingErrorEvent({ taskId, contextId, parts, }: {
+export declare function createInputMissingErrorEvent({ taskId, contextId, parts, metadata, }: {
     parts: A2APart[];
     taskId: string;
     contextId: string;
+    metadata?: Record<string, unknown>;
 }): TaskStatusUpdateEvent;

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

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AGENT_CARD_PATH, AgentCard, Message, MessageSendConfiguration, MessageSendParams, Task, TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+import { ClientFactory } from '@a2a-js/sdk/client';
+import { BaseAgent, BaseAgentConfig } from '../agents/base_agent.js';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event as AdkEvent } from '../events/event.js';
+export { AGENT_CARD_PATH };
+/**
+ * Type alias for A2A stream event data.
+ */
+export type A2AStreamEventData = Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent;
+/**
+ * Callback called before sending a request to the remote agent.
+ * Allows modifying the request parameters.
+ */
+export type BeforeA2ARequestCallback = (ctx: InvocationContext, params: MessageSendParams) => Promise<void> | void;
+/**
+ * Callback called after receiving a response from the remote agent.
+ * Allows inspecting or modifying the response.
+ */
+export type AfterA2ARequestCallback = (ctx: InvocationContext, resp: A2AStreamEventData) => Promise<void> | void;
+/**
+ * Configuration for the A2ARemoteAgent.
+ */
+export interface RemoteA2AAgentConfig extends BaseAgentConfig {
+    /**
+     * Loaded AgentCard or URL to AgentCard
+     */
+    agentCard: AgentCard | string;
+    /**
+     * Optional ClientFactory for creating the A2A Client.
+     */
+    clientFactory?: ClientFactory;
+    /**
+     * Optional default configuration for sending messages.
+     */
+    messageSendConfig?: MessageSendConfiguration;
+    /**
+     * Callbacks run before the remote request is sent.
+     */
+    beforeRequestCallbacks?: BeforeA2ARequestCallback[];
+    /**
+     * Callbacks run after receiving a response chunk or event, before conversion.
+     */
+    afterRequestCallbacks?: AfterA2ARequestCallback[];
+}
+/**
+ * RemoteA2AAgent delegates execution to a remote agent using the A2A protocol.
+ */
+export declare class RemoteA2AAgent extends BaseAgent {
+    private readonly a2aConfig;
+    private client?;
+    private card?;
+    private isInitialized;
+    constructor(a2aConfig: RemoteA2AAgentConfig);
+    private init;
+    protected runAsyncImpl(context: InvocationContext): AsyncGenerator<AdkEvent, void, void>;
+    protected runLiveImpl(_context: InvocationContext): AsyncGenerator<AdkEvent, void, void>;
+}

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

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MessageSendParams } from '@a2a-js/sdk';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event as AdkEvent } from '../events/event.js';
+import { A2AEvent } from './a2a_event.js';
+/**
+ * Processes streams of A2A events and aggregates partials for emissions.
+ */
+export declare class A2ARemoteAgentRunProcessor {
+    private readonly request?;
+    private aggregations;
+    private aggregationOrder;
+    constructor(request?: MessageSendParams | undefined);
+    /**
+     * aggregatePartial stores contents of partial events to emit them with the terminal event.
+     * It can return multiple events to emit instead of just the provided one.
+     */
+    aggregatePartial(context: InvocationContext, a2aEvent: A2AEvent, adkEvent: AdkEvent): AdkEvent[];
+    private removeAggregation;
+    private updateAggregation;
+    private buildNonPartialAggregation;
+    private promoteTextBlocksToParts;
+    /**
+     * Adds request and response metadata to the event.
+     */
+    updateCustomMetadata(event: AdkEvent, response?: A2AEvent): void;
+}