@softactivate/adk 1.1.0

package/dist/web/a2a/a2a_remote_agent.js

@@ -0,0 +1,186 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @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 && !a2aConfig.client) {
+      throw new Error("Either AgentCard or Client must be provided");
+    }
+  }
+  async init() {
+    if (this.isInitialized) {
+      return;
+    }
+    if (this.a2aConfig.client) {
+      this.client = this.a2aConfig.client;
+    }
+    if (this.a2aConfig.agentCard) {
+      this.card = await resolveAgentCard(this.a2aConfig.agentCard);
+      if (!this.client) {
+        const factory = this.a2aConfig.clientFactory || new ClientFactory();
+        this.client = await factory.createFromAgentCard(this.card);
+      }
+    }
+    this.isInitialized = true;
+  }
+  runAsyncImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      var _a, _b;
+      yield new __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) {
+            yield new __await(callback(context, params));
+          }
+        }
+        const useStreaming = this.card ? ((_b = this.card.capabilities) == null ? void 0 : _b.streaming) !== false : true;
+        if (useStreaming) {
+          try {
+            for (var iter = __forAwait(this.client.sendMessageStream(params)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+              const chunk = temp.value;
+              if (this.a2aConfig.afterRequestCallbacks) {
+                for (const callback of this.a2aConfig.afterRequestCallbacks) {
+                  yield new __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;
+              }
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+            } finally {
+              if (error)
+                throw error[0];
+            }
+          }
+        } else {
+          const result = yield new __await(this.client.sendMessage(params));
+          if (this.a2aConfig.afterRequestCallbacks) {
+            for (const callback of this.a2aConfig.afterRequestCallbacks) {
+              yield new __await(callback(context, result));
+            }
+          }
+          const adkEvent = toAdkEvent(result, context.invocationId, this.name);
+          if (adkEvent) {
+            processor.updateCustomMetadata(adkEvent, result);
+            yield adkEvent;
+          }
+        }
+      } catch (e) {
+        const error2 = e;
+        logger.error("A2ARemoteAgent ".concat(this.name, " failed:"), error2);
+        yield createEvent({
+          author: this.name,
+          invocationId: context.invocationId,
+          errorMessage: error2.message,
+          turnComplete: true
+        });
+      }
+    });
+  }
+  runLiveImpl(_context) {
+    throw new Error("Live mode is not supported in A2ARemoteAgent yet.");
+  }
+}
+export {
+  AGENT_CARD_PATH,
+  RemoteA2AAgent
+};

package/dist/web/a2a/a2a_remote_agent_run_processor.js

@@ -0,0 +1,184 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @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 (isTask(response)) {
+        if (response.id) toAdd["task_id"] = response.id;
+        if (response.contextId) toAdd["context_id"] = response.contextId;
+      } else if (response.taskId) {
+        toAdd["task_id"] = response.taskId;
+        if (response.contextId) toAdd["context_id"] = response.contextId;
+      }
+    }
+    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:".concat(k)] = v;
+    }
+  }
+}
+export {
+  A2ARemoteAgentRunProcessor
+};

package/dist/web/a2a/a2a_remote_agent_utils.js

@@ -0,0 +1,133 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @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: "[".concat(agentEvent.author, "] said: ").concat(part.text)
+      });
+    } else if (part.functionCall) {
+      const call = part.functionCall;
+      parts.push({
+        text: "[".concat(agentEvent.author, "] called tool ").concat(call.name, " with parameters: ").concat(JSON.stringify(call.args))
+      });
+    } else if (part.functionResponse) {
+      const resp = part.functionResponse;
+      parts.push({
+        text: "[".concat(agentEvent.author, "] ").concat(resp.name, " tool returned result: ").concat(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
+};