@paean-ai/adk 0.2.19 → 0.2.20

package/dist/esm/agents/content_processor_utils.js

@@ -0,0 +1,280 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEvent, getFunctionCalls, getFunctionResponses } from "../events/event.js";
+import { deepClone } from "../utils/deep_clone.js";
+import { removeClientFunctionCallId, REQUEST_CONFIRMATION_FUNCTION_CALL_NAME, REQUEST_EUC_FUNCTION_CALL_NAME } from "./functions.js";
+function getContents(events, agentName, currentBranch) {
+  var _a, _b;
+  const filteredEvents = [];
+  for (const event of events) {
+    if (!((_a = event.content) == null ? void 0 : _a.role) || !((_b = event.content.parts) == null ? void 0 : _b.length)) {
+      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 = deepClone(event.content);
+    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) === REQUEST_EUC_FUNCTION_CALL_NAME || ((_c = part.functionResponse) == null ? void 0 : _c.name) === 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) === REQUEST_CONFIRMATION_FUNCTION_CALL_NAME || ((_c = part.functionResponse) == null ? void 0 : _c.name) === 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, _f;
+  if (!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
+    return event;
+  }
+  const content = {
+    role: "user",
+    parts: [{
+      text: "For context:"
+    }]
+  };
+  for (const part of event.content.parts) {
+    if (part.text && !part.thought) {
+      (_c = content.parts) == null ? void 0 : _c.push({
+        text: `[${event.author}] said: ${part.text}`
+      });
+    } else if (part.functionCall) {
+      const argsText = safeStringify(part.functionCall.args);
+      (_d = content.parts) == null ? void 0 : _d.push({
+        text: `[${event.author}] called tool \`${part.functionCall.name}\` with parameters: ${argsText}`
+      });
+    } else if (part.functionResponse) {
+      const responseText = safeStringify(part.functionResponse.response);
+      (_e = content.parts) == null ? void 0 : _e.push({
+        text: `[${event.author}] tool \`${part.functionResponse.name}\` returned result: ${responseText}`
+      });
+    } else {
+      (_f = content.parts) == null ? void 0 : _f.push(part);
+    }
+  }
+  return 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 = 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 = 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 = 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 = 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 = 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 = 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 (getFunctionResponses(event).length > 0) {
+      continue;
+    }
+    const functionCalls = 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;
+}
+function safeStringify(obj) {
+  if (typeof obj === "string") {
+    return obj;
+  }
+  try {
+    return JSON.stringify(obj);
+  } catch (e) {
+    return String(obj);
+  }
+}
+export {
+  getContents,
+  getCurrentTurnContents
+};

package/dist/esm/agents/functions.js

@@ -0,0 +1,384 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createUserContent } from "@google/genai";
+import { createEvent, getFunctionCalls } from "../events/event.js";
+import { mergeEventActions } from "../events/event_actions.js";
+import { ToolContext } from "../tools/tool_context.js";
+import { randomUUID } from "../utils/env_aware_utils.js";
+import { logger } from "../utils/logger.js";
+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}${randomUUID()}`;
+}
+function populateClientFunctionCallId(modelResponseEvent) {
+  const functionCalls = 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 resolveToolName(name, toolsDict) {
+  if (name in toolsDict) {
+    return name;
+  }
+  const colonIndex = name.indexOf(":");
+  if (colonIndex > 0) {
+    const baseName = name.substring(0, colonIndex);
+    if (baseName in toolsDict) {
+      logger.info(
+        `Resolved Gemini 3 function name "${name}" to tool "${baseName}"`
+      );
+      return baseName;
+    }
+  }
+  return void 0;
+}
+function getLongRunningFunctionCalls(functionCalls, toolsDict) {
+  const longRunningToolIds = /* @__PURE__ */ new Set();
+  for (const functionCall of functionCalls) {
+    if (!functionCall.name || !functionCall.id) continue;
+    const resolvedName = resolveToolName(functionCall.name, toolsDict);
+    if (resolvedName && toolsDict[resolvedName].isLongRunning) {
+      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 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 = 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 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) {
+  logger.debug(`callToolAsync ${tool.name}`);
+  return await tool.runAsync({ args, toolContext });
+}
+async function handleFunctionCallsAsync({
+  invocationContext,
+  functionCallEvent,
+  toolsDict,
+  beforeToolCallbacks,
+  afterToolCallbacks,
+  filters,
+  toolConfirmationDict
+}) {
+  const functionCalls = getFunctionCalls(functionCallEvent);
+  return await handleFunctionCallList({
+    invocationContext,
+    functionCalls,
+    toolsDict,
+    beforeToolCallbacks,
+    afterToolCallbacks,
+    filters,
+    toolConfirmationDict
+  });
+}
+async function handleFunctionCallList({
+  invocationContext,
+  functionCalls,
+  toolsDict,
+  beforeToolCallbacks,
+  afterToolCallbacks,
+  filters,
+  toolConfirmationDict
+}) {
+  var _a, _b, _c;
+  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 toolAndContext = getToolAndContext(
+      {
+        invocationContext,
+        functionCall,
+        toolsDict,
+        toolConfirmation
+      }
+    );
+    if (!toolAndContext) {
+      const availableTools = Object.keys(toolsDict).join(", ");
+      logger.warn(
+        `Function ${functionCall.name} is not found in the toolsDict. Available tools: [${availableTools}]. Returning error response to LLM.`
+      );
+      const errorResponseEvent = createEvent({
+        invocationId: invocationContext.invocationId,
+        author: invocationContext.agent.name,
+        content: createUserContent({
+          functionResponse: {
+            id: functionCall.id || void 0,
+            name: (_a = functionCall.name) != null ? _a : "unknown",
+            response: {
+              error: `Function '${functionCall.name}' is not available. Available tools: [${availableTools}]. Please use one of the available tools instead.`
+            }
+          }
+        }),
+        branch: invocationContext.branch
+      });
+      functionResponseEvents.push(errorResponseEvent);
+      continue;
+    }
+    const { tool, toolContext } = toolAndContext;
+    logger.debug(`execute_tool ${tool.name}`);
+    const functionArgs = (_b = functionCall.args) != null ? _b : {};
+    let functionResponse = null;
+    let functionResponseError;
+    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 {
+            functionResponseError = e.message;
+          }
+        } else {
+          functionResponseError = 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;
+    }
+    if (functionResponseError) {
+      functionResponse = { error: functionResponseError };
+    } else if (typeof functionResponse !== "object" || functionResponse == null) {
+      functionResponse = { result: functionResponse };
+    }
+    const functionResponseEvent = createEvent({
+      invocationId: invocationContext.invocationId,
+      author: invocationContext.agent.name,
+      content: createUserContent({
+        functionResponse: {
+          id: toolContext.functionCallId,
+          name: (_c = functionCall.name) != null ? _c : tool.name,
+          response: functionResponse
+        }
+      }),
+      actions: toolContext.actions,
+      branch: invocationContext.branch
+    });
+    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) {
+    logger.debug("execute_tool (merged)");
+    logger.debug("traceMergedToolCalls", {
+      responseEventId: mergedEvent.id,
+      functionResponseEvent: mergedEvent.id
+    });
+  }
+  return mergedEvent;
+}
+function getToolAndContext({
+  invocationContext,
+  functionCall,
+  toolsDict,
+  toolConfirmation
+}) {
+  const resolvedName = functionCall.name ? resolveToolName(functionCall.name, toolsDict) : void 0;
+  if (!resolvedName) {
+    return null;
+  }
+  const toolContext = new ToolContext({
+    invocationContext,
+    functionCallId: functionCall.id || void 0,
+    toolConfirmation
+  });
+  const tool = toolsDict[resolvedName];
+  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 = mergeEventActions(actionsList);
+  return createEvent({
+    author: baseEvent.author,
+    branch: baseEvent.branch,
+    content: { role: "user", parts: mergedParts },
+    actions: mergedActions,
+    timestamp: baseEvent.timestamp
+  });
+}
+export {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_EUC_FUNCTION_CALL_NAME,
+  functionsExportedForTestingOnly,
+  generateAuthEvent,
+  generateClientFunctionCallId,
+  generateRequestConfirmationEvent,
+  getLongRunningFunctionCalls,
+  handleFunctionCallList,
+  handleFunctionCallsAsync,
+  mergeParallelFunctionResponseEvents,
+  populateClientFunctionCallId,
+  removeClientFunctionCallId
+};