@softactivate/adk 1.1.0

package/dist/cjs/a2a/agent_card.js

@@ -0,0 +1,380 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_card_exports = {};
+__export(agent_card_exports, {
+  buildAgentSkills: () => buildAgentSkills,
+  getA2AAgentCard: () => getA2AAgentCard,
+  resolveAgentCard: () => resolveAgentCard
+});
+module.exports = __toCommonJS(agent_card_exports);
+var import_client = require("@a2a-js/sdk/client");
+var fs = __toESM(require("node:fs/promises"), 1);
+var import_invocation_context = require("../agents/invocation_context.js");
+var import_llm_agent = require("../agents/llm_agent.js");
+var import_loop_agent = require("../agents/loop_agent.js");
+var import_parallel_agent = require("../agents/parallel_agent.js");
+var import_readonly_context = require("../agents/readonly_context.js");
+var import_sequential_agent = require("../agents/sequential_agent.js");
+var import_base_tool = require("../tools/base_tool.js");
+var import_base_toolset = require("../tools/base_toolset.js");
+var import_logger = require("../utils/logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+async function resolveAgentCard(agentCard) {
+  if (typeof agentCard === "object") {
+    return agentCard;
+  }
+  const source = agentCard;
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    const resolver = new import_client.DefaultAgentCardResolver();
+    return await resolver.resolve(source);
+  }
+  try {
+    const content = await fs.readFile(source, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    throw new Error(
+      `Failed to read agent card from file ${source}: ${err.message}`
+    );
+  }
+}
+async function getA2AAgentCard(agent, transports) {
+  return {
+    name: agent.name,
+    description: agent.description || "",
+    protocolVersion: "0.3.0",
+    version: "1.0.0",
+    skills: await buildAgentSkills(agent),
+    url: transports[0].url,
+    preferredTransport: transports[0].transport,
+    capabilities: {
+      extensions: [],
+      stateTransitionHistory: false,
+      pushNotifications: false,
+      streaming: true
+    },
+    defaultInputModes: ["text"],
+    defaultOutputModes: ["text"],
+    additionalInterfaces: transports
+  };
+}
+async function buildAgentSkills(agent) {
+  const [primarySkills, subAgentSkills] = await Promise.all([
+    buildPrimarySkills(agent),
+    buildSubAgentSkills(agent)
+  ]);
+  return [...primarySkills, ...subAgentSkills];
+}
+async function buildPrimarySkills(agent) {
+  if ((0, import_llm_agent.isLlmAgent)(agent)) {
+    return buildLLMAgentSkills(agent);
+  }
+  return buildNonLLMAgentSkills(agent);
+}
+async function buildSubAgentSkills(agent) {
+  const subAgents = agent.subAgents;
+  const result = [];
+  for (const sub of subAgents) {
+    const skills = await buildPrimarySkills(sub);
+    for (const subSkill of skills) {
+      const skill = {
+        id: `${sub.name}_${subSkill.id}`,
+        name: `${sub.name}: ${subSkill.name}`,
+        description: subSkill.description,
+        tags: [`sub_agent:${sub.name}`, ...subSkill.tags]
+      };
+      result.push(skill);
+    }
+  }
+  return result;
+}
+async function buildLLMAgentSkills(agent) {
+  const skills = [
+    {
+      id: agent.name,
+      name: "model",
+      description: await buildDescriptionFromInstructions(agent),
+      tags: ["llm"]
+    }
+  ];
+  if (agent.tools && agent.tools.length > 0) {
+    for (const toolUnion of agent.tools) {
+      if ((0, import_base_tool.isBaseTool)(toolUnion)) {
+        skills.push(toolToSkill(agent.name, toolUnion));
+      } else if ((0, import_base_toolset.isBaseToolset)(toolUnion)) {
+        const tools = await toolUnion.getTools();
+        for (const tool of tools) {
+          skills.push(toolToSkill(agent.name, tool));
+        }
+      }
+    }
+  }
+  return skills;
+}
+function toolToSkill(prefix, tool) {
+  let description = tool.description;
+  if (!description) {
+    description = `Tool: ${tool.name}`;
+  }
+  return {
+    id: `${prefix}-${tool.name}`,
+    name: tool.name,
+    description,
+    tags: ["llm", "tools"]
+  };
+}
+function buildNonLLMAgentSkills(agent) {
+  const skills = [
+    {
+      id: agent.name,
+      name: getAgentSkillName(agent),
+      description: buildAgentDescription(agent),
+      tags: [getAgentTypeTag(agent)]
+    }
+  ];
+  const subAgents = agent.subAgents;
+  if (subAgents.length > 0) {
+    const descriptions = subAgents.map(
+      (sub) => sub.description || "No description"
+    );
+    skills.push({
+      id: `${agent.name}-sub-agents`,
+      name: "sub-agents",
+      description: `Orchestrates: ${descriptions.join("; ")}`,
+      tags: [getAgentTypeTag(agent), "orchestration"]
+    });
+  }
+  return skills;
+}
+function buildAgentDescription(agent) {
+  const descriptionParts = [];
+  if (agent.description) {
+    descriptionParts.push(agent.description);
+  }
+  if (agent.subAgents.length > 0) {
+    if ((0, import_loop_agent.isLoopAgent)(agent)) {
+      descriptionParts.push(buildLoopAgentDescription(agent));
+    } else if ((0, import_parallel_agent.isParallelAgent)(agent)) {
+      descriptionParts.push(buildParallelAgentDescription(agent));
+    } else if ((0, import_sequential_agent.isSequentialAgent)(agent)) {
+      descriptionParts.push(buildSequentialAgentDescription(agent));
+    }
+  }
+  if (descriptionParts.length > 0) {
+    return descriptionParts.join(" ");
+  } else {
+    return getDefaultAgentDescription(agent);
+  }
+}
+function buildSequentialAgentDescription(agent) {
+  const subAgents = agent.subAgents;
+  const descriptions = [];
+  subAgents.forEach((sub, i) => {
+    let subDescription = sub.description;
+    if (!subDescription) {
+      subDescription = `execute the ${sub.name} agent`;
+    }
+    if (i === 0) {
+      descriptions.push(`First, this agent will ${subDescription}.`);
+    } else if (i === subAgents.length - 1) {
+      descriptions.push(`Finally, this agent will ${subDescription}.`);
+    } else {
+      descriptions.push(`Then, this agent will ${subDescription}.`);
+    }
+  });
+  return descriptions.join(" ");
+}
+function buildParallelAgentDescription(agent) {
+  const subAgents = agent.subAgents;
+  const descriptions = [];
+  subAgents.forEach((sub, i) => {
+    let subDescription = sub.description;
+    if (!subDescription) {
+      subDescription = `execute the ${sub.name} agent`;
+    }
+    if (i === 0) {
+      descriptions.push(`This agent will ${subDescription}`);
+    } else if (i === subAgents.length - 1) {
+      descriptions.push(`and ${subDescription}`);
+    } else {
+      descriptions.push(`, ${subDescription}`);
+    }
+  });
+  return `${descriptions.join(" ")} simultaneously.`;
+}
+function buildLoopAgentDescription(agent) {
+  const maxIterationsVal = agent.maxIterations;
+  let maxIterations = "unlimited";
+  if (typeof maxIterationsVal === "number" && maxIterationsVal < Number.MAX_SAFE_INTEGER) {
+    maxIterations = maxIterationsVal.toString();
+  }
+  const subAgents = agent.subAgents;
+  const descriptions = [];
+  subAgents.forEach((sub, i) => {
+    let subDescription = sub.description;
+    if (!subDescription) {
+      subDescription = `execute the ${sub.name} agent`;
+    }
+    if (i === 0) {
+      descriptions.push(`This agent will ${subDescription}`);
+    } else if (i === subAgents.length - 1) {
+      descriptions.push(`and ${subDescription}`);
+    } else {
+      descriptions.push(`, ${subDescription}`);
+    }
+  });
+  return `${descriptions.join(" ")} in a loop (max ${maxIterations} iterations).`;
+}
+async function buildDescriptionFromInstructions(agent) {
+  const descriptionParts = [];
+  if (agent.description) {
+    descriptionParts.push(agent.description);
+  }
+  if (agent.instruction) {
+    let instructionStr;
+    if (typeof agent.instruction === "function") {
+      const dummyContext = new import_readonly_context.ReadonlyContext(
+        new import_invocation_context.InvocationContext({
+          agent
+        })
+      );
+      try {
+        instructionStr = await agent.instruction(dummyContext);
+      } catch (e) {
+        import_logger.logger.warn("Failed to resolve dynamic instruction for AgentCard", e);
+        instructionStr = "";
+      }
+    } else {
+      instructionStr = agent.instruction;
+    }
+    if (instructionStr) {
+      descriptionParts.push(replacePronouns(instructionStr));
+    }
+  }
+  const root = agent.rootAgent;
+  if ((0, import_llm_agent.isLlmAgent)(root) && root.globalInstruction) {
+    let globalInstructionStr;
+    if (typeof root.globalInstruction === "function") {
+      const dummyContext = new import_readonly_context.ReadonlyContext(
+        new import_invocation_context.InvocationContext({
+          agent
+        })
+      );
+      try {
+        globalInstructionStr = await root.globalInstruction(dummyContext);
+      } catch (e) {
+        import_logger.logger.warn(
+          "Failed to resolve dynamic global instruction for AgentCard",
+          e
+        );
+        globalInstructionStr = "";
+      }
+    } else {
+      globalInstructionStr = root.globalInstruction;
+    }
+    if (globalInstructionStr) {
+      descriptionParts.push(replacePronouns(globalInstructionStr));
+    }
+  }
+  if (descriptionParts.length > 0) {
+    return descriptionParts.join(" ");
+  } else {
+    return getDefaultAgentDescription(agent);
+  }
+}
+function replacePronouns(instruction) {
+  const substitutions = [
+    { original: "you were", target: "I was" },
+    { original: "you are", target: "I am" },
+    { original: "you're", target: "I am" },
+    { original: "you've", target: "I have" },
+    { original: "yours", target: "mine" },
+    { original: "your", target: "my" },
+    { original: "you", target: "I" }
+  ];
+  let result = instruction;
+  for (const sub of substitutions) {
+    const pattern = new RegExp(`\\b${sub.original}\\b`, "gi");
+    result = result.replace(pattern, sub.target);
+  }
+  return result;
+}
+function getDefaultAgentDescription(agent) {
+  if ((0, import_loop_agent.isLoopAgent)(agent)) {
+    return "A loop workflow agent";
+  } else if ((0, import_sequential_agent.isSequentialAgent)(agent)) {
+    return "A sequential workflow agent";
+  } else if ((0, import_parallel_agent.isParallelAgent)(agent)) {
+    return "A parallel workflow agent";
+  } else if ((0, import_llm_agent.isLlmAgent)(agent)) {
+    return "An LLM-based agent";
+  } else {
+    return "A custom agent";
+  }
+}
+function getAgentTypeTag(agent) {
+  if ((0, import_loop_agent.isLoopAgent)(agent)) {
+    return "loop_workflow";
+  } else if ((0, import_sequential_agent.isSequentialAgent)(agent)) {
+    return "sequential_workflow";
+  } else if ((0, import_parallel_agent.isParallelAgent)(agent)) {
+    return "parallel_workflow";
+  } else if ((0, import_llm_agent.isLlmAgent)(agent)) {
+    return "llm_agent";
+  } else {
+    return "custom_agent";
+  }
+}
+function getAgentSkillName(agent) {
+  if ((0, import_llm_agent.isLlmAgent)(agent)) {
+    return "model";
+  }
+  if (isWorkflowAgent(agent)) {
+    return "workflow";
+  }
+  return "custom";
+}
+function isWorkflowAgent(agent) {
+  return (0, import_loop_agent.isLoopAgent)(agent) || (0, import_sequential_agent.isSequentialAgent)(agent) || (0, import_parallel_agent.isParallelAgent)(agent);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAgentSkills,
+  getA2AAgentCard,
+  resolveAgentCard
+});

package/dist/cjs/a2a/agent_executor.js

@@ -0,0 +1,221 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_executor_exports = {};
+__export(agent_executor_exports, {
+  A2AAgentExecutor: () => A2AAgentExecutor
+});
+module.exports = __toCommonJS(agent_executor_exports);
+var import_runner = require("../runner/runner.js");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_logger = require("../utils/logger.js");
+var import_a2a_event = require("./a2a_event.js");
+var import_event_processor_utils = require("./event_processor_utils.js");
+var import_executor_context = require("./executor_context.js");
+var import_metadata_converter_utils = require("./metadata_converter_utils.js");
+var import_part_converter_utils = require("./part_converter_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class A2AAgentExecutor {
+  constructor(config) {
+    this.config = config;
+    this.agentPartialArtifactIdsMap = {};
+  }
+  async execute(ctx, eventBus) {
+    var _a, _b;
+    const a2aUserMessage = ctx.userMessage;
+    if (!a2aUserMessage) {
+      throw new Error("message not provided");
+    }
+    const userId = `A2A_USER_${ctx.contextId}`;
+    const sessionId = ctx.contextId;
+    const genAIUserMessage = (0, import_part_converter_utils.toGenAIContent)(a2aUserMessage);
+    const adkRunner = await getAdkRunner(this.config.runner);
+    const session = await getAdkSession(
+      userId,
+      sessionId,
+      adkRunner.sessionService,
+      adkRunner.appName
+    );
+    const executorContext = (0, import_executor_context.createExecutorContext)({
+      session,
+      userContent: genAIUserMessage,
+      requestContext: ctx
+    });
+    try {
+      if (this.config.beforeExecuteCallback) {
+        await this.config.beforeExecuteCallback(ctx);
+      }
+      if (ctx.task) {
+        const inputRequiredEvent = (0, import_event_processor_utils.getTaskInputRequiredEvent)(
+          ctx.task,
+          genAIUserMessage
+        );
+        if (inputRequiredEvent) {
+          await this.publishFinalTaskStatus({
+            executorContext,
+            eventBus,
+            event: inputRequiredEvent
+          });
+          return;
+        }
+      }
+      if (!ctx.task) {
+        eventBus.publish(
+          (0, import_a2a_event.createTask)({
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            message: a2aUserMessage
+          })
+        );
+      }
+      eventBus.publish(
+        (0, import_a2a_event.createTaskWorkingEvent)({
+          taskId: ctx.taskId,
+          contextId: ctx.contextId
+        })
+      );
+      const adkEvents = [];
+      for await (const adkEvent of adkRunner.runAsync({
+        userId,
+        sessionId,
+        newMessage: genAIUserMessage,
+        runConfig: this.config.runConfig
+      })) {
+        adkEvents.push(adkEvent);
+        const a2aEvent = this.convertAdkEventToA2AEvent(
+          adkEvent,
+          executorContext
+        );
+        if (!a2aEvent) {
+          continue;
+        }
+        await ((_b = (_a = this.config).afterEventCallback) == null ? void 0 : _b.call(
+          _a,
+          executorContext,
+          adkEvent,
+          a2aEvent
+        ));
+        eventBus.publish(a2aEvent);
+      }
+      await this.publishFinalTaskStatus({
+        executorContext,
+        eventBus,
+        event: (0, import_event_processor_utils.getFinalTaskStatusUpdate)(adkEvents, executorContext)
+      });
+    } catch (e) {
+      const error = e;
+      await this.publishFinalTaskStatus({
+        executorContext,
+        eventBus,
+        error,
+        event: (0, import_a2a_event.createTaskFailedEvent)({
+          taskId: ctx.taskId,
+          contextId: ctx.contextId,
+          error: new Error(`Agent run failed: ${error.message}`),
+          metadata: (0, import_metadata_converter_utils.getA2ASessionMetadata)(executorContext)
+        })
+      });
+    }
+  }
+  // Task cancellation is not supported in this implementation yet.
+  async cancelTask(_taskId) {
+    throw new Error("Task cancellation is not supported yet.");
+  }
+  convertAdkEventToA2AEvent(adkEvent, executorContext) {
+    var _a;
+    const a2aParts = (0, import_part_converter_utils.toA2AParts)(
+      (_a = adkEvent.content) == null ? void 0 : _a.parts,
+      adkEvent.longRunningToolIds
+    );
+    if (a2aParts.length === 0) {
+      return void 0;
+    }
+    const artifactId = this.agentPartialArtifactIdsMap[adkEvent.author] || (0, import_env_aware_utils.randomUUID)();
+    const a2aEvent = (0, import_a2a_event.createTaskArtifactUpdateEvent)({
+      taskId: executorContext.requestContext.taskId,
+      contextId: executorContext.requestContext.contextId,
+      artifactId,
+      parts: a2aParts,
+      metadata: (0, import_metadata_converter_utils.getA2AEventMetadata)(adkEvent, executorContext),
+      append: adkEvent.partial,
+      lastChunk: !adkEvent.partial
+    });
+    if (adkEvent.partial) {
+      this.agentPartialArtifactIdsMap[adkEvent.author] = artifactId;
+    } else {
+      delete this.agentPartialArtifactIdsMap[adkEvent.author];
+    }
+    return a2aEvent;
+  }
+  /**
+   * Writes the final status event to the queue.
+   */
+  async publishFinalTaskStatus({
+    executorContext,
+    eventBus,
+    event,
+    error
+  }) {
+    var _a, _b;
+    try {
+      await ((_b = (_a = this.config).afterExecuteCallback) == null ? void 0 : _b.call(_a, executorContext, event, error));
+    } catch (e) {
+      import_logger.logger.error("Error in afterExecuteCallback:", e);
+    }
+    eventBus.publish(event);
+  }
+}
+async function getAdkSession(userId, sessionId, sessionService, appName) {
+  const session = await sessionService.getSession({
+    appName,
+    userId,
+    sessionId
+  });
+  if (session) {
+    return session;
+  }
+  return sessionService.createSession({
+    appName,
+    userId,
+    sessionId
+  });
+}
+async function getAdkRunner(runnerOrConfig) {
+  if (typeof runnerOrConfig === "function") {
+    const result = await runnerOrConfig();
+    return getAdkRunner(result);
+  }
+  if ((0, import_runner.isRunner)(runnerOrConfig)) {
+    return runnerOrConfig;
+  }
+  return new import_runner.Runner(runnerOrConfig);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2AAgentExecutor
+});