@paean-ai/adk 0.2.14 → 0.2.15

package/dist/web/agents/content_processor_utils.js

@@ -1,315 +0,0 @@
-/**
- * @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 { logger } from "../utils/logger.js";
-import { removeClientFunctionCallId, REQUEST_CONFIRMATION_FUNCTION_CALL_NAME, REQUEST_EUC_FUNCTION_CALL_NAME } from "./functions.js";
-function getContents(events, agentName, currentBranch) {
-  var _a, _b, _c, _d, _e, _f;
-  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);
-  }
-  let hasFunctionCallWithoutSignature = false;
-  let problematicBlockIndex = -1;
-  for (let i = 0; i < contents.length; i++) {
-    const content = contents[i];
-    const hasFunctionCalls = (_c = content.parts) == null ? void 0 : _c.some((p) => p.functionCall);
-    const hasThoughtSignature = (_d = content.parts) == null ? void 0 : _d.some((p) => p.thoughtSignature);
-    const hasThought = (_e = content.parts) == null ? void 0 : _e.some((p) => p.thought);
-    if (hasFunctionCalls) {
-      logger.info(
-        "[getContents] Content block ".concat(i + 1, "/").concat(contents.length, ": role=").concat(content.role, ", ") + "hasFunctionCalls=true, hasThought=".concat(hasThought, ", hasSignature=").concat(hasThoughtSignature)
-      );
-      if (!hasThoughtSignature && content.role === "model") {
-        hasFunctionCallWithoutSignature = true;
-        problematicBlockIndex = i + 1;
-      }
-      for (let j = 0; j < (((_f = content.parts) == null ? void 0 : _f.length) || 0); j++) {
-        const part = content.parts[j];
-        if (part.functionCall) {
-          logger.info(
-            "[getContents]   Part ".concat(j, ": functionCall=").concat(part.functionCall.name, ", ") + "hasSignature=".concat(!!part.thoughtSignature)
-          );
-        } else if (part.thought) {
-          logger.info(
-            "[getContents]   Part ".concat(j, ": thought=true, hasSignature=").concat(!!part.thoughtSignature)
-          );
-        }
-      }
-    }
-  }
-  if (hasFunctionCallWithoutSignature) {
-    logger.warn(
-      "[getContents] WARNING: Content block ".concat(problematicBlockIndex, " has model function calls but NO thoughtSignature! ") + "This will likely cause a 400 error from Gemini 3 API."
-    );
-  }
-  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: "[".concat(event.author, "] said: ").concat(part.text)
-      });
-    } else if (part.functionCall) {
-      const argsText = safeStringify(part.functionCall.args);
-      (_d = content.parts) == null ? void 0 : _d.push({
-        text: "[".concat(event.author, "] called tool `").concat(part.functionCall.name, "` with parameters: ").concat(argsText)
-      });
-    } else if (part.functionResponse) {
-      const responseText = safeStringify(part.functionResponse.response);
-      (_e = content.parts) == null ? void 0 : _e.push({
-        text: "[".concat(event.author, "] tool `").concat(part.functionResponse.name, "` returned result: ").concat(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 : ".concat(Array.from(functionCallIds).join(", "), ", function response") + " ids provided: ".concat(Array.from(functionResponsesIds).join(", "))
-          );
-        }
-        functionResponsesIds = functionCallIds;
-        break;
-      }
-    }
-  }
-  if (functionCallEventIdx === -1) {
-    throw new Error(
-      "No function call event found for function responses ids: ".concat(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/web/agents/functions.js

@@ -1,344 +0,0 @@
-/**
- * @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 "".concat(AF_FUNCTION_CALL_ID_PREFIX).concat(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 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 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 ".concat(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;
-  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
-      }
-    );
-    logger.debug("execute_tool ".concat(tool.name));
-    const functionArgs = (_a = functionCall.args) != null ? _a : {};
-    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: 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
-}) {
-  if (!functionCall.name || !(functionCall.name in toolsDict)) {
-    throw new Error(
-      "Function ".concat(functionCall.name, " is not found in the toolsDict.")
-    );
-  }
-  const toolContext = new 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 = 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
-};