@paean-ai/adk 0.2.19 → 0.2.20

package/dist/web/agents/callback_context.js

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEventActions } from "../events/event_actions.js";
+import { State } from "../sessions/state.js";
+import { ReadonlyContext } from "./readonly_context.js";
+class CallbackContext extends ReadonlyContext {
+  constructor({ invocationContext, eventActions }) {
+    super(invocationContext);
+    this.eventActions = eventActions || createEventActions();
+    this._state = new State(
+      invocationContext.session.state,
+      this.eventActions.stateDelta
+    );
+  }
+  /**
+   * The delta-aware state of the current session.
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Loads an artifact attached to the current session.
+   *
+   * @param filename The filename of the artifact.
+   * @param version The version of the artifact. If not provided, the latest
+   *     version will be used.
+   * @return A promise that resolves to the loaded artifact.
+   */
+  loadArtifact(filename, version) {
+    if (!this.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.invocationContext.artifactService.loadArtifact({
+      appName: this.invocationContext.appName,
+      userId: this.invocationContext.userId,
+      sessionId: this.invocationContext.session.id,
+      filename,
+      version
+    });
+  }
+  /**
+   * Saves an artifact attached to the current session.
+   *
+   * @param filename The filename of the artifact.
+   * @param artifact The artifact to save.
+   * @return A promise that resolves to the version of the saved artifact.
+   */
+  async saveArtifact(filename, artifact) {
+    if (!this.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    const version = await this.invocationContext.artifactService.saveArtifact({
+      appName: this.invocationContext.appName,
+      userId: this.invocationContext.userId,
+      sessionId: this.invocationContext.session.id,
+      filename,
+      artifact
+    });
+    this.eventActions.artifactDelta[filename] = version;
+    return version;
+  }
+}
+export {
+  CallbackContext
+};

package/dist/web/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: "[".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
+};