@google/adk 0.4.0 → 0.6.0

package/dist/esm/a2a/a2a_remote_agent.js

@@ -0,0 +1,148 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  AGENT_CARD_PATH
+} from "@a2a-js/sdk";
+import { ClientFactory } from "@a2a-js/sdk/client";
+import { BaseAgent } from "../agents/base_agent.js";
+import { createEvent } from "../events/event.js";
+import { randomUUID } from "../utils/env_aware_utils.js";
+import { logger } from "../utils/logger.js";
+import { MessageRole } from "./a2a_event.js";
+import { A2ARemoteAgentRunProcessor } from "./a2a_remote_agent_run_processor.js";
+import {
+  getUserFunctionCallAt,
+  toMissingRemoteSessionParts
+} from "./a2a_remote_agent_utils.js";
+import { resolveAgentCard } from "./agent_card.js";
+import { toAdkEvent } from "./event_converter_utils.js";
+import { getA2ASessionMetadata } from "./metadata_converter_utils.js";
+import { toA2AParts } from "./part_converter_utils.js";
+class RemoteA2AAgent extends BaseAgent {
+  constructor(a2aConfig) {
+    super(a2aConfig);
+    this.a2aConfig = a2aConfig;
+    this.isInitialized = false;
+    if (!a2aConfig.agentCard) {
+      throw new Error("AgentCard must be provided");
+    }
+  }
+  async init() {
+    if (this.isInitialized) {
+      return;
+    }
+    this.card = await resolveAgentCard(this.a2aConfig.agentCard);
+    const factory = this.a2aConfig.clientFactory || new ClientFactory();
+    this.client = await factory.createFromAgentCard(this.card);
+    this.isInitialized = true;
+  }
+  async *runAsyncImpl(context) {
+    var _a, _b;
+    await this.init();
+    try {
+      const events = context.session.events;
+      if (events.length === 0) {
+        throw new Error("No events in session to send");
+      }
+      const userFnCall = getUserFunctionCallAt(
+        context.session,
+        events.length - 1
+      );
+      let parts;
+      let taskId = void 0;
+      let contextId = void 0;
+      if (userFnCall) {
+        const event = userFnCall.response;
+        parts = toA2AParts(
+          ((_a = event.content) == null ? void 0 : _a.parts) || [],
+          event.longRunningToolIds
+        );
+        taskId = userFnCall.taskId;
+        contextId = userFnCall.contextId;
+      } else {
+        const missing = toMissingRemoteSessionParts(context, context.session);
+        parts = missing.parts;
+        contextId = missing.contextId;
+      }
+      const message = {
+        kind: "message",
+        messageId: randomUUID(),
+        role: MessageRole.USER,
+        parts,
+        metadata: {
+          ...getA2ASessionMetadata({
+            appName: context.session.appName,
+            userId: context.session.userId,
+            sessionId: context.session.id
+          })
+        }
+      };
+      if (taskId) message.taskId = taskId;
+      if (contextId) message.contextId = contextId;
+      const params = {
+        message,
+        configuration: this.a2aConfig.messageSendConfig
+      };
+      const processor = new A2ARemoteAgentRunProcessor(params);
+      if (this.a2aConfig.beforeRequestCallbacks) {
+        for (const callback of this.a2aConfig.beforeRequestCallbacks) {
+          await callback(context, params);
+        }
+      }
+      const useStreaming = ((_b = this.card.capabilities) == null ? void 0 : _b.streaming) !== false;
+      if (useStreaming) {
+        for await (const chunk of this.client.sendMessageStream(params)) {
+          if (this.a2aConfig.afterRequestCallbacks) {
+            for (const callback of this.a2aConfig.afterRequestCallbacks) {
+              await callback(context, chunk);
+            }
+          }
+          const adkEvent = toAdkEvent(chunk, context.invocationId, this.name);
+          if (!adkEvent) {
+            continue;
+          }
+          processor.updateCustomMetadata(adkEvent, chunk);
+          const eventsToEmit = processor.aggregatePartial(
+            context,
+            chunk,
+            adkEvent
+          );
+          for (const ev of eventsToEmit) {
+            yield ev;
+          }
+        }
+      } else {
+        const result = await this.client.sendMessage(params);
+        if (this.a2aConfig.afterRequestCallbacks) {
+          for (const callback of this.a2aConfig.afterRequestCallbacks) {
+            await callback(context, result);
+          }
+        }
+        const adkEvent = toAdkEvent(result, context.invocationId, this.name);
+        if (adkEvent) {
+          processor.updateCustomMetadata(adkEvent, result);
+          yield adkEvent;
+        }
+      }
+    } catch (e) {
+      const error = e;
+      logger.error(`A2ARemoteAgent ${this.name} failed:`, error);
+      yield createEvent({
+        author: this.name,
+        invocationId: context.invocationId,
+        errorMessage: error.message,
+        turnComplete: true
+      });
+    }
+  }
+  runLiveImpl(_context) {
+    throw new Error("Live mode is not supported in A2ARemoteAgent yet.");
+  }
+}
+export {
+  AGENT_CARD_PATH,
+  RemoteA2AAgent
+};

package/dist/esm/a2a/a2a_remote_agent_run_processor.js

@@ -0,0 +1,175 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  createModelContent
+} from "@google/genai";
+import { createEvent } from "../events/event.js";
+import {
+  getEventMetadata,
+  isTask,
+  isTaskArtifactUpdateEvent,
+  isTaskStatusUpdateEvent
+} from "./a2a_event.js";
+import { A2AMetadataKeys } from "./metadata_converter_utils.js";
+class A2ARemoteAgentRunProcessor {
+  constructor(request) {
+    this.request = request;
+    this.aggregations = /* @__PURE__ */ new Map();
+    this.aggregationOrder = [];
+  }
+  /**
+   * 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, a2aEvent, adkEvent) {
+    const metadata = getEventMetadata(a2aEvent);
+    if (metadata[A2AMetadataKeys.PARTIAL]) {
+      return [adkEvent];
+    }
+    if (isTaskStatusUpdateEvent(a2aEvent) && a2aEvent.final) {
+      const events = [];
+      for (const aid of this.aggregationOrder) {
+        const agg = this.aggregations.get(aid);
+        if (agg) {
+          events.push(this.buildNonPartialAggregation(context, agg));
+        }
+      }
+      this.aggregations.clear();
+      this.aggregationOrder = [];
+      return [...events, adkEvent];
+    }
+    if (isTask(a2aEvent)) {
+      this.aggregations.clear();
+      this.aggregationOrder = [];
+      return [adkEvent];
+    }
+    if (!isTaskArtifactUpdateEvent(a2aEvent)) {
+      return [adkEvent];
+    }
+    const artifactId = a2aEvent.artifact.artifactId;
+    if (!a2aEvent.append) {
+      this.removeAggregation(artifactId);
+      if (a2aEvent.lastChunk) {
+        adkEvent.partial = false;
+        return [adkEvent];
+      }
+    }
+    let aggregation = this.aggregations.get(artifactId);
+    if (!aggregation) {
+      aggregation = {
+        aggregatedText: "",
+        aggregatedThoughts: "",
+        parts: []
+      };
+      this.aggregations.set(artifactId, aggregation);
+      this.aggregationOrder.push(artifactId);
+    } else {
+      this.aggregationOrder = this.aggregationOrder.filter(
+        (id) => id !== artifactId
+      );
+      this.aggregationOrder.push(artifactId);
+    }
+    this.updateAggregation(aggregation, adkEvent);
+    if (!a2aEvent.lastChunk) {
+      return [adkEvent];
+    }
+    this.removeAggregation(artifactId);
+    return [adkEvent, this.buildNonPartialAggregation(context, aggregation)];
+  }
+  removeAggregation(artifactId) {
+    this.aggregations.delete(artifactId);
+    this.aggregationOrder = this.aggregationOrder.filter(
+      (id) => id !== artifactId
+    );
+  }
+  updateAggregation(agg, event) {
+    var _a;
+    const parts = ((_a = event.content) == null ? void 0 : _a.parts) || [];
+    for (const part of parts) {
+      if (part.text && part.text !== "") {
+        if (part.thought) {
+          agg.aggregatedThoughts += part.text;
+        } else {
+          agg.aggregatedText += part.text;
+        }
+      } else {
+        this.promoteTextBlocksToParts(agg);
+        agg.parts.push(part);
+      }
+    }
+    if (event.citationMetadata) {
+      if (!agg.citations) {
+        agg.citations = { citations: [] };
+      }
+      if (!agg.citations.citations) {
+        agg.citations.citations = [];
+      }
+      agg.citations.citations.push(...event.citationMetadata.citations || []);
+    }
+    if (event.customMetadata) {
+      if (!agg.customMeta) {
+        agg.customMeta = {};
+      }
+      Object.assign(agg.customMeta, event.customMetadata);
+    }
+    if (event.groundingMetadata) {
+      agg.grounding = event.groundingMetadata;
+    }
+    if (event.usageMetadata) {
+      agg.usage = event.usageMetadata;
+    }
+  }
+  buildNonPartialAggregation(context, agg) {
+    this.promoteTextBlocksToParts(agg);
+    const result = createEvent({
+      author: context.agent.name,
+      invocationId: context.invocationId,
+      content: agg.parts.length > 0 ? createModelContent([...agg.parts]) : void 0,
+      customMetadata: agg.customMeta,
+      groundingMetadata: agg.grounding,
+      citationMetadata: agg.citations,
+      usageMetadata: agg.usage,
+      turnComplete: false,
+      partial: false
+    });
+    return result;
+  }
+  promoteTextBlocksToParts(agg) {
+    if (agg.aggregatedThoughts !== "") {
+      agg.parts.push({ thought: true, text: agg.aggregatedThoughts });
+      agg.aggregatedThoughts = "";
+    }
+    if (agg.aggregatedText !== "") {
+      agg.parts.push({ text: agg.aggregatedText });
+      agg.aggregatedText = "";
+    }
+  }
+  /**
+   * Adds request and response metadata to the event.
+   */
+  updateCustomMetadata(event, response) {
+    const toAdd = {};
+    if (this.request && event.turnComplete) {
+      toAdd["request"] = this.request;
+    }
+    if (response) {
+      toAdd["response"] = response;
+    }
+    if (Object.keys(toAdd).length === 0) {
+      return;
+    }
+    if (!event.customMetadata) {
+      event.customMetadata = {};
+    }
+    for (const [k, v] of Object.entries(toAdd)) {
+      if (v === void 0 || v === null) continue;
+      event.customMetadata[`a2a:${k}`] = v;
+    }
+  }
+}
+export {
+  A2ARemoteAgentRunProcessor
+};

package/dist/esm/a2a/a2a_remote_agent_utils.js

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEvent } from "../events/event.js";
+import { AdkMetadataKeys } from "./metadata_converter_utils.js";
+import { toA2AParts } from "./part_converter_utils.js";
+function getUserFunctionCallAt(session, index) {
+  const events = session.events;
+  if (index < 0 || index >= events.length) {
+    return void 0;
+  }
+  const candidate = events[index];
+  if (candidate.author !== "user") {
+    return void 0;
+  }
+  const fnCallId = getFunctionResponseCallId(candidate);
+  if (!fnCallId) {
+    return void 0;
+  }
+  for (let i = index - 1; i >= 0; i--) {
+    const request = events[i];
+    if (!isFunctionCallEvent(request, fnCallId)) {
+      continue;
+    }
+    const metadata = request.customMetadata || {};
+    const taskId = metadata[AdkMetadataKeys.TASK_ID] || "";
+    const contextId = metadata[AdkMetadataKeys.CONTEXT_ID] || "";
+    return {
+      response: candidate,
+      taskId,
+      contextId
+    };
+  }
+  return void 0;
+}
+function isFunctionCallEvent(event, callId) {
+  if (!event || !event.content || !event.content.parts) {
+    return false;
+  }
+  return event.content.parts.some(
+    (part) => part.functionCall && part.functionCall.id === callId
+  );
+}
+function getFunctionResponseCallId(event) {
+  var _a;
+  if (!event || !event.content || !event.content.parts) {
+    return void 0;
+  }
+  const responsePart = event.content.parts.find(
+    (part) => part.functionResponse
+  );
+  return (_a = responsePart == null ? void 0 : responsePart.functionResponse) == null ? void 0 : _a.id;
+}
+function toMissingRemoteSessionParts(ctx, session) {
+  const events = session.events;
+  let contextId = void 0;
+  let lastRemoteResponseIndex = -1;
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.author === ctx.agent.name) {
+      lastRemoteResponseIndex = i;
+      const metadata = event.customMetadata || {};
+      contextId = metadata[AdkMetadataKeys.CONTEXT_ID];
+      break;
+    }
+  }
+  const missingParts = [];
+  for (let i = lastRemoteResponseIndex + 1; i < events.length; i++) {
+    let event = events[i];
+    if (event.author !== "user" && event.author !== ctx.agent.name) {
+      event = presentAsUserMessage(ctx, event);
+    }
+    if (!event.content || !event.content.parts || event.content.parts.length === 0) {
+      continue;
+    }
+    const parts = toA2AParts(event.content.parts, event.longRunningToolIds);
+    missingParts.push(...parts);
+  }
+  return {
+    parts: missingParts,
+    contextId
+  };
+}
+function presentAsUserMessage(ctx, agentEvent) {
+  const event = createEvent({
+    author: "user",
+    invocationId: ctx.invocationId
+  });
+  if (!agentEvent.content || !agentEvent.content.parts) {
+    return event;
+  }
+  const parts = [{ text: "For context:" }];
+  for (const part of agentEvent.content.parts) {
+    if (part.thought) {
+      continue;
+    }
+    if (part.text) {
+      parts.push({
+        text: `[${agentEvent.author}] said: ${part.text}`
+      });
+    } else if (part.functionCall) {
+      const call = part.functionCall;
+      parts.push({
+        text: `[${agentEvent.author}] called tool ${call.name} with parameters: ${JSON.stringify(call.args)}`
+      });
+    } else if (part.functionResponse) {
+      const resp = part.functionResponse;
+      parts.push({
+        text: `[${agentEvent.author}] ${resp.name} tool returned result: ${JSON.stringify(resp.response)}`
+      });
+    } else {
+      parts.push(part);
+    }
+  }
+  if (parts.length > 1) {
+    event.content = {
+      role: "user",
+      parts
+    };
+  }
+  return event;
+}
+export {
+  getFunctionResponseCallId,
+  getUserFunctionCallAt,
+  isFunctionCallEvent,
+  presentAsUserMessage,
+  toMissingRemoteSessionParts
+};