@google/adk 0.5.0 → 0.6.1

package/dist/cjs/a2a/a2a_remote_agent_utils.js

@@ -0,0 +1,165 @@
+/**
+  * @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 a2a_remote_agent_utils_exports = {};
+__export(a2a_remote_agent_utils_exports, {
+  getFunctionResponseCallId: () => getFunctionResponseCallId,
+  getUserFunctionCallAt: () => getUserFunctionCallAt,
+  isFunctionCallEvent: () => isFunctionCallEvent,
+  presentAsUserMessage: () => presentAsUserMessage,
+  toMissingRemoteSessionParts: () => toMissingRemoteSessionParts
+});
+module.exports = __toCommonJS(a2a_remote_agent_utils_exports);
+var import_event = require("../events/event.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
+ */
+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[import_metadata_converter_utils.AdkMetadataKeys.TASK_ID] || "";
+    const contextId = metadata[import_metadata_converter_utils.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[import_metadata_converter_utils.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 = (0, import_part_converter_utils.toA2AParts)(event.content.parts, event.longRunningToolIds);
+    missingParts.push(...parts);
+  }
+  return {
+    parts: missingParts,
+    contextId
+  };
+}
+function presentAsUserMessage(ctx, agentEvent) {
+  const event = (0, import_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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFunctionResponseCallId,
+  getUserFunctionCallAt,
+  isFunctionCallEvent,
+  presentAsUserMessage,
+  toMissingRemoteSessionParts
+});

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
+});