@google/adk 0.1.0

package/dist/cjs/agents/content_processor_utils.js

@@ -0,0 +1,299 @@
+/**
+  * @license
+  * Copyright 2025 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 content_processor_utils_exports = {};
+__export(content_processor_utils_exports, {
+  getContents: () => getContents,
+  getCurrentTurnContents: () => getCurrentTurnContents
+});
+module.exports = __toCommonJS(content_processor_utils_exports);
+var import_event = require("../events/event.js");
+var import_deep_clone = require("../utils/deep_clone.js");
+var import_functions = require("./functions.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function getContents(events, agentName, currentBranch) {
+  var _a, _b, _c;
+  const filteredEvents = [];
+  for (const event of events) {
+    if (!((_a = event.content) == null ? void 0 : _a.role) || ((_c = (_b = event.content.parts) == null ? void 0 : _b[0]) == null ? void 0 : _c.text) === "") {
+      continue;
+    }
+    if (currentBranch && event.branch && !currentBranch.startsWith(event.branch)) {
+      continue;
+    }
+    if (isAuthEvent(event)) {
+      continue;
+    }
+    if (isToolConfirmationEvent(event)) {
+      continue;
+    }
+    filteredEvents.push(
+      isEventFromAnotherAgent(agentName, event) ? convertForeignEvent(event) : event
+    );
+  }
+  let resultEvents = rearrangeEventsForLatestFunctionResponse(filteredEvents);
+  resultEvents = rearrangeEventsForAsyncFunctionResponsesInHistory(resultEvents);
+  const contents = [];
+  for (const event of resultEvents) {
+    const content = (0, import_deep_clone.deepClone)(event.content);
+    (0, import_functions.removeClientFunctionCallId)(content);
+    contents.push(content);
+  }
+  return contents;
+}
+function getCurrentTurnContents(events, agentName, currentBranch) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.author === "user" || isEventFromAnotherAgent(agentName, event)) {
+      return getContents(events.slice(i), agentName, currentBranch);
+    }
+  }
+  return [];
+}
+function isAuthEvent(event) {
+  var _a, _b, _c;
+  if (!((_a = event.content) == null ? void 0 : _a.parts)) {
+    return false;
+  }
+  for (const part of event.content.parts) {
+    if (((_b = part.functionCall) == null ? void 0 : _b.name) === import_functions.REQUEST_EUC_FUNCTION_CALL_NAME || ((_c = part.functionResponse) == null ? void 0 : _c.name) === import_functions.REQUEST_EUC_FUNCTION_CALL_NAME) {
+      return true;
+    }
+  }
+  return false;
+}
+function isToolConfirmationEvent(event) {
+  var _a, _b, _c;
+  if (!((_a = event.content) == null ? void 0 : _a.parts)) {
+    return false;
+  }
+  for (const part of event.content.parts) {
+    if (((_b = part.functionCall) == null ? void 0 : _b.name) === import_functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME || ((_c = part.functionResponse) == null ? void 0 : _c.name) === import_functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+      return true;
+    }
+  }
+  return false;
+}
+function isEventFromAnotherAgent(agentName, event) {
+  return !!agentName && event.author !== agentName && event.author !== "user";
+}
+function convertForeignEvent(event) {
+  var _a, _b, _c, _d, _e;
+  if (!((_a = event.content) == null ? void 0 : _a.parts)) {
+    return event;
+  }
+  const content = {
+    role: "user",
+    parts: [{
+      text: "For context:"
+    }]
+  };
+  for (const part of event.content.parts) {
+    if (part.text && !part.thought) {
+      (_b = content.parts) == null ? void 0 : _b.push({
+        text: `[${event.author}] said: ${part.text}`
+      });
+    } else if (part.functionCall) {
+      (_c = content.parts) == null ? void 0 : _c.push({
+        text: `[${event.author}] called tool \`${part.functionCall.name}\` with parameters: ${part.functionCall.args}`
+      });
+    } else if (part.functionResponse) {
+      (_d = content.parts) == null ? void 0 : _d.push({
+        text: `[${event.author}] tool \`${part.functionResponse.name}\` returned result: ${part.functionResponse.response}`
+      });
+    } else {
+      (_e = content.parts) == null ? void 0 : _e.push(part);
+    }
+  }
+  return (0, import_event.createEvent)({
+    invocationId: event.invocationId,
+    author: "user",
+    content,
+    branch: event.branch,
+    timestamp: event.timestamp
+  });
+}
+function mergeFunctionResponseEvents(events) {
+  var _a;
+  if (events.length === 0) {
+    throw new Error("Cannot merge an empty list of events.");
+  }
+  const mergedEvent = (0, import_event.createEvent)(events[0]);
+  const partsInMergedEvent = ((_a = mergedEvent.content) == null ? void 0 : _a.parts) || [];
+  if (partsInMergedEvent.length === 0) {
+    throw new Error("There should be at least one function_response part.");
+  }
+  const partIndicesInMergedEvent = {};
+  for (let i = 0; i < partsInMergedEvent.length; i++) {
+    const part = partsInMergedEvent[i];
+    if (part.functionResponse && part.functionResponse.id) {
+      partIndicesInMergedEvent[part.functionResponse.id] = i;
+    }
+  }
+  for (const event of events.slice(1)) {
+    if (!event.content || !event.content.parts) {
+      throw new Error("There should be at least one function_response part.");
+    }
+    for (const part of event.content.parts) {
+      if (part.functionResponse && part.functionResponse.id) {
+        const functionCallId = part.functionResponse.id;
+        if (functionCallId in partIndicesInMergedEvent) {
+          partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = part;
+        } else {
+          partsInMergedEvent.push(part);
+          partIndicesInMergedEvent[functionCallId] = partsInMergedEvent.length - 1;
+        }
+      } else {
+        partsInMergedEvent.push(part);
+      }
+    }
+  }
+  return mergedEvent;
+}
+function rearrangeEventsForLatestFunctionResponse(events) {
+  if (events.length === 0) {
+    return events;
+  }
+  const latestEvent = events[events.length - 1];
+  const functionResponses = (0, import_event.getFunctionResponses)(latestEvent);
+  if (!(functionResponses == null ? void 0 : functionResponses.length)) {
+    return events;
+  }
+  let functionResponsesIds = new Set(
+    functionResponses.filter((response) => !!response.id).map((response) => response.id)
+  );
+  const secondLatestEvent = events.at(-2);
+  if (secondLatestEvent) {
+    const functionCallsFromSecondLatest = (0, import_event.getFunctionCalls)(secondLatestEvent);
+    if (functionCallsFromSecondLatest) {
+      for (const functionCall of functionCallsFromSecondLatest) {
+        if (functionCall.id && functionResponsesIds.has(functionCall.id)) {
+          return events;
+        }
+      }
+    }
+  }
+  let functionCallEventIdx = -1;
+  for (let idx = events.length - 2; idx >= 0; idx--) {
+    const event = events[idx];
+    const functionCalls = (0, import_event.getFunctionCalls)(event);
+    if (!(functionCalls == null ? void 0 : functionCalls.length)) {
+      continue;
+    }
+    for (const functionCall of functionCalls) {
+      if (functionCall.id && functionResponsesIds.has(functionCall.id)) {
+        functionCallEventIdx = idx;
+        const functionCallIds = new Set(
+          functionCalls.map((fc) => fc.id).filter((id) => !!id)
+        );
+        const isSubset = Array.from(functionResponsesIds).every((id) => functionCallIds.has(id));
+        if (!isSubset) {
+          throw new Error(
+            `Last response event should only contain the responses for the function calls in the same function call event. Function call ids found : ${Array.from(functionCallIds).join(", ")}, function response ids provided: ${Array.from(functionResponsesIds).join(", ")}`
+          );
+        }
+        functionResponsesIds = functionCallIds;
+        break;
+      }
+    }
+  }
+  if (functionCallEventIdx === -1) {
+    throw new Error(
+      `No function call event found for function responses ids: ${Array.from(
+        functionResponsesIds
+      ).join(", ")}`
+    );
+  }
+  const functionResponseEvents = [];
+  for (let idx = functionCallEventIdx + 1; idx < events.length - 1; idx++) {
+    const event = events[idx];
+    const responses = (0, import_event.getFunctionResponses)(event);
+    if (responses && responses.some(
+      (response) => response.id && functionResponsesIds.has(response.id)
+    )) {
+      functionResponseEvents.push(event);
+    }
+  }
+  functionResponseEvents.push(events[events.length - 1]);
+  const resultEvents = events.slice(0, functionCallEventIdx + 1);
+  resultEvents.push(mergeFunctionResponseEvents(functionResponseEvents));
+  return resultEvents;
+}
+function rearrangeEventsForAsyncFunctionResponsesInHistory(events) {
+  const functionCallIdToResponseEventIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i];
+    const functionResponses = (0, import_event.getFunctionResponses)(event);
+    if (functionResponses == null ? void 0 : functionResponses.length) {
+      for (const functionResponse of functionResponses) {
+        if (!functionResponse.id) {
+          continue;
+        }
+        functionCallIdToResponseEventIndex.set(functionResponse.id, i);
+      }
+    }
+  }
+  const resultEvents = [];
+  for (const event of events) {
+    if ((0, import_event.getFunctionResponses)(event).length > 0) {
+      continue;
+    }
+    const functionCalls = (0, import_event.getFunctionCalls)(event);
+    if (functionCalls == null ? void 0 : functionCalls.length) {
+      const functionResponseEventsIndices = /* @__PURE__ */ new Set();
+      for (const functionCall of functionCalls) {
+        const functionCallId = functionCall.id;
+        if (functionCallId && functionCallIdToResponseEventIndex.has(functionCallId)) {
+          functionResponseEventsIndices.add(
+            functionCallIdToResponseEventIndex.get(functionCallId)
+          );
+        }
+      }
+      resultEvents.push(event);
+      if (functionResponseEventsIndices.size === 0) {
+        continue;
+      }
+      if (functionResponseEventsIndices.size === 1) {
+        const [responseIndex] = [...functionResponseEventsIndices];
+        resultEvents.push(events[responseIndex]);
+      } else {
+        const indicesArray = Array.from(functionResponseEventsIndices).sort((a, b) => a - b);
+        const eventsToMerge = indicesArray.map((index) => events[index]);
+        resultEvents.push(mergeFunctionResponseEvents(eventsToMerge));
+      }
+    } else {
+      resultEvents.push(event);
+    }
+  }
+  return resultEvents;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getContents,
+  getCurrentTurnContents
+});

package/dist/cjs/agents/functions.js

@@ -0,0 +1,394 @@
+/**
+  * @license
+  * Copyright 2025 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 functions_exports = {};
+__export(functions_exports, {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME: () => REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_EUC_FUNCTION_CALL_NAME: () => REQUEST_EUC_FUNCTION_CALL_NAME,
+  functionsExportedForTestingOnly: () => functionsExportedForTestingOnly,
+  generateAuthEvent: () => generateAuthEvent,
+  generateClientFunctionCallId: () => generateClientFunctionCallId,
+  generateRequestConfirmationEvent: () => generateRequestConfirmationEvent,
+  getLongRunningFunctionCalls: () => getLongRunningFunctionCalls,
+  handleFunctionCallList: () => handleFunctionCallList,
+  handleFunctionCallsAsync: () => handleFunctionCallsAsync,
+  mergeParallelFunctionResponseEvents: () => mergeParallelFunctionResponseEvents,
+  populateClientFunctionCallId: () => populateClientFunctionCallId,
+  removeClientFunctionCallId: () => removeClientFunctionCallId
+});
+module.exports = __toCommonJS(functions_exports);
+var import_event = require("../events/event.js");
+var import_event_actions = require("../events/event_actions.js");
+var import_tool_context = require("../tools/tool_context.js");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_logger = require("../utils/logger.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
+const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
+const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+const functionsExportedForTestingOnly = {
+  handleFunctionCallList
+};
+function generateClientFunctionCallId() {
+  return `${AF_FUNCTION_CALL_ID_PREFIX}${(0, import_env_aware_utils.randomUUID)()}`;
+}
+function populateClientFunctionCallId(modelResponseEvent) {
+  const functionCalls = (0, import_event.getFunctionCalls)(modelResponseEvent);
+  if (!functionCalls) {
+    return;
+  }
+  for (const functionCall of functionCalls) {
+    if (!functionCall.id) {
+      functionCall.id = generateClientFunctionCallId();
+    }
+  }
+}
+function removeClientFunctionCallId(content) {
+  if (content && content.parts) {
+    for (const part of content.parts) {
+      if (part.functionCall && part.functionCall.id && part.functionCall.id.startsWith(AF_FUNCTION_CALL_ID_PREFIX)) {
+        part.functionCall.id = void 0;
+      }
+      if (part.functionResponse && part.functionResponse.id && part.functionResponse.id.startsWith(AF_FUNCTION_CALL_ID_PREFIX)) {
+        part.functionResponse.id = void 0;
+      }
+    }
+  }
+}
+function getLongRunningFunctionCalls(functionCalls, toolsDict) {
+  const longRunningToolIds = /* @__PURE__ */ new Set();
+  for (const functionCall of functionCalls) {
+    if (functionCall.name && functionCall.name in toolsDict && toolsDict[functionCall.name].isLongRunning && functionCall.id) {
+      longRunningToolIds.add(functionCall.id);
+    }
+  }
+  return longRunningToolIds;
+}
+function generateAuthEvent(invocationContext, functionResponseEvent) {
+  var _a;
+  if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedAuthConfigs)) {
+    return void 0;
+  }
+  const parts = [];
+  const longRunningToolIds = /* @__PURE__ */ new Set();
+  for (const [functionCallId, authConfig] of Object.entries(
+    functionResponseEvent.actions.requestedAuthConfigs
+  )) {
+    const requestEucFunctionCall = {
+      name: REQUEST_EUC_FUNCTION_CALL_NAME,
+      args: {
+        "function_call_id": functionCallId,
+        "auth_config": authConfig
+      },
+      id: generateClientFunctionCallId()
+    };
+    longRunningToolIds.add(requestEucFunctionCall.id);
+    parts.push({ functionCall: requestEucFunctionCall });
+  }
+  return (0, import_event.createEvent)({
+    invocationId: invocationContext.invocationId,
+    author: invocationContext.agent.name,
+    branch: invocationContext.branch,
+    content: {
+      parts,
+      role: functionResponseEvent.content.role
+    },
+    longRunningToolIds: Array.from(longRunningToolIds)
+  });
+}
+function generateRequestConfirmationEvent({
+  invocationContext,
+  functionCallEvent,
+  functionResponseEvent
+}) {
+  var _a, _b;
+  if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedToolConfirmations)) {
+    return;
+  }
+  const parts = [];
+  const longRunningToolIds = /* @__PURE__ */ new Set();
+  const functionCalls = (0, import_event.getFunctionCalls)(functionCallEvent);
+  for (const [functionCallId, toolConfirmation] of Object.entries(
+    functionResponseEvent.actions.requestedToolConfirmations
+  )) {
+    const originalFunctionCall = (_b = functionCalls.find((call) => call.id === functionCallId)) != null ? _b : void 0;
+    if (!originalFunctionCall) {
+      continue;
+    }
+    const requestConfirmationFunctionCall = {
+      name: REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+      args: {
+        "originalFunctionCall": originalFunctionCall,
+        "toolConfirmation": toolConfirmation
+      },
+      id: generateClientFunctionCallId()
+    };
+    longRunningToolIds.add(requestConfirmationFunctionCall.id);
+    parts.push({ functionCall: requestConfirmationFunctionCall });
+  }
+  return (0, import_event.createEvent)({
+    invocationId: invocationContext.invocationId,
+    author: invocationContext.agent.name,
+    branch: invocationContext.branch,
+    content: {
+      parts,
+      role: functionResponseEvent.content.role
+    },
+    longRunningToolIds: Array.from(longRunningToolIds)
+  });
+}
+async function callToolAsync(tool, args, toolContext) {
+  import_logger.logger.debug(`callToolAsync ${tool.name}`);
+  return await tool.runAsync({ args, toolContext });
+}
+function buildResponseEvent(tool, functionResult, toolContext, invocationContext) {
+  let responseResult = functionResult;
+  if (typeof functionResult !== "object" || functionResult == null) {
+    responseResult = { result: functionResult };
+  }
+  const partFunctionResponse = {
+    functionResponse: {
+      name: tool.name,
+      response: responseResult,
+      id: toolContext.functionCallId
+    }
+  };
+  const content = {
+    role: "user",
+    parts: [partFunctionResponse]
+  };
+  return (0, import_event.createEvent)({
+    invocationId: invocationContext.invocationId,
+    author: invocationContext.agent.name,
+    content,
+    actions: toolContext.actions,
+    branch: invocationContext.branch
+  });
+}
+async function handleFunctionCallsAsync({
+  invocationContext,
+  functionCallEvent,
+  toolsDict,
+  beforeToolCallbacks,
+  afterToolCallbacks,
+  filters,
+  toolConfirmationDict
+}) {
+  const functionCalls = (0, import_event.getFunctionCalls)(functionCallEvent);
+  return await handleFunctionCallList({
+    invocationContext,
+    functionCalls,
+    toolsDict,
+    beforeToolCallbacks,
+    afterToolCallbacks,
+    filters,
+    toolConfirmationDict
+  });
+}
+async function handleFunctionCallList({
+  invocationContext,
+  functionCalls,
+  toolsDict,
+  beforeToolCallbacks,
+  afterToolCallbacks,
+  filters,
+  toolConfirmationDict
+}) {
+  var _a;
+  const functionResponseEvents = [];
+  const filteredFunctionCalls = functionCalls.filter((functionCall) => {
+    return !filters || functionCall.id && filters.has(functionCall.id);
+  });
+  for (const functionCall of filteredFunctionCalls) {
+    let toolConfirmation = void 0;
+    if (toolConfirmationDict && functionCall.id) {
+      toolConfirmation = toolConfirmationDict[functionCall.id];
+    }
+    const { tool, toolContext } = getToolAndContext(
+      {
+        invocationContext,
+        functionCall,
+        toolsDict,
+        toolConfirmation
+      }
+    );
+    import_logger.logger.debug(`execute_tool ${tool.name}`);
+    const functionArgs = (_a = functionCall.args) != null ? _a : {};
+    let functionResponse = null;
+    functionResponse = await invocationContext.pluginManager.runBeforeToolCallback({
+      tool,
+      toolArgs: functionArgs,
+      toolContext
+    });
+    if (functionResponse == null) {
+      for (const callback of beforeToolCallbacks) {
+        functionResponse = await callback({
+          tool,
+          args: functionArgs,
+          context: toolContext
+        });
+        if (functionResponse) {
+          break;
+        }
+      }
+    }
+    if (functionResponse == null) {
+      try {
+        functionResponse = await callToolAsync(
+          tool,
+          functionArgs,
+          toolContext
+        );
+      } catch (e) {
+        if (e instanceof Error) {
+          const onToolErrorResponse = await invocationContext.pluginManager.runOnToolErrorCallback(
+            {
+              tool,
+              toolArgs: functionArgs,
+              toolContext,
+              error: e
+            }
+          );
+          if (onToolErrorResponse) {
+            functionResponse = onToolErrorResponse;
+          }
+        } else {
+          import_logger.logger.error("Unknown error on tool execution type", e);
+          throw e;
+        }
+      }
+    }
+    let alteredFunctionResponse = await invocationContext.pluginManager.runAfterToolCallback({
+      tool,
+      toolArgs: functionArgs,
+      toolContext,
+      result: functionResponse
+    });
+    if (alteredFunctionResponse == null) {
+      for (const callback of afterToolCallbacks) {
+        alteredFunctionResponse = await callback({
+          tool,
+          args: functionArgs,
+          context: toolContext,
+          response: functionResponse
+        });
+        if (alteredFunctionResponse) {
+          break;
+        }
+      }
+    }
+    if (alteredFunctionResponse != null) {
+      functionResponse = alteredFunctionResponse;
+    }
+    if (tool.isLongRunning && !functionResponse) {
+      continue;
+    }
+    const functionResponseEvent = buildResponseEvent(
+      tool,
+      functionResponse,
+      toolContext,
+      invocationContext
+    );
+    import_logger.logger.debug("traceToolCall", {
+      tool: tool.name,
+      args: functionArgs,
+      functionResponseEvent: functionResponseEvent.id
+    });
+    functionResponseEvents.push(functionResponseEvent);
+  }
+  if (!functionResponseEvents.length) {
+    return null;
+  }
+  const mergedEvent = mergeParallelFunctionResponseEvents(functionResponseEvents);
+  if (functionResponseEvents.length > 1) {
+    import_logger.logger.debug("execute_tool (merged)");
+    import_logger.logger.debug("traceMergedToolCalls", {
+      responseEventId: mergedEvent.id,
+      functionResponseEvent: mergedEvent.id
+    });
+  }
+  return mergedEvent;
+}
+function getToolAndContext({
+  invocationContext,
+  functionCall,
+  toolsDict,
+  toolConfirmation
+}) {
+  if (!functionCall.name || !(functionCall.name in toolsDict)) {
+    throw new Error(
+      `Function ${functionCall.name} is not found in the toolsDict.`
+    );
+  }
+  const toolContext = new import_tool_context.ToolContext({
+    invocationContext,
+    functionCallId: functionCall.id || void 0,
+    toolConfirmation
+  });
+  const tool = toolsDict[functionCall.name];
+  return { tool, toolContext };
+}
+function mergeParallelFunctionResponseEvents(functionResponseEvents) {
+  if (!functionResponseEvents.length) {
+    throw new Error("No function response events provided.");
+  }
+  if (functionResponseEvents.length === 1) {
+    return functionResponseEvents[0];
+  }
+  const mergedParts = [];
+  for (const event of functionResponseEvents) {
+    if (event.content && event.content.parts) {
+      mergedParts.push(...event.content.parts);
+    }
+  }
+  const baseEvent = functionResponseEvents[0];
+  const actionsList = functionResponseEvents.map((event) => event.actions || {});
+  const mergedActions = (0, import_event_actions.mergeEventActions)(actionsList);
+  return (0, import_event.createEvent)({
+    author: baseEvent.author,
+    branch: baseEvent.branch,
+    content: { role: "user", parts: mergedParts },
+    actions: mergedActions,
+    timestamp: baseEvent.timestamp
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_EUC_FUNCTION_CALL_NAME,
+  functionsExportedForTestingOnly,
+  generateAuthEvent,
+  generateClientFunctionCallId,
+  generateRequestConfirmationEvent,
+  getLongRunningFunctionCalls,
+  handleFunctionCallList,
+  handleFunctionCallsAsync,
+  mergeParallelFunctionResponseEvents,
+  populateClientFunctionCallId,
+  removeClientFunctionCallId
+});