@softactivate/adk 1.1.0

package/dist/web/agents/processors/code_execution_request_processor.js

@@ -0,0 +1,370 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { cloneDeep } from "lodash-es";
+import { isBaseCodeExecutor } from "../../code_executors/base_code_executor.js";
+import { isBuiltInCodeExecutor } from "../../code_executors/built_in_code_executor.js";
+import {
+  buildCodeExecutionResultPart,
+  buildExecutableCodePart,
+  CodeExecutionLanguage,
+  convertCodeExecutionParts,
+  extractCodeAndTruncateContent
+} from "../../code_executors/code_execution_utils.js";
+import { CodeExecutorContext } from "../../code_executors/code_executor_context.js";
+import { createEvent } from "../../events/event.js";
+import { createEventActions } from "../../events/event_actions.js";
+import { State } from "../../sessions/state.js";
+import { base64Decode } from "../../utils/env_aware_utils.js";
+import { isLlmAgent } from "../llm_agent.js";
+import {
+  BaseLlmRequestProcessor
+} from "./base_llm_processor.js";
+class CodeExecutionRequestProcessor extends BaseLlmRequestProcessor {
+  runAsync(invocationContext, llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      if (!isLlmAgent(invocationContext.agent)) {
+        return;
+      }
+      if (!invocationContext.agent.codeExecutor) {
+        return;
+      }
+      try {
+        for (var iter = __forAwait(runPreProcessor(invocationContext, llmRequest)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const event = temp.value;
+          yield event;
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      if (!isBaseCodeExecutor(invocationContext.agent.codeExecutor)) {
+        return;
+      }
+      for (const content of llmRequest.contents) {
+        const delimeters = invocationContext.agent.codeExecutor.codeBlockDelimiters.length ? invocationContext.agent.codeExecutor.codeBlockDelimiters[0] : ["", ""];
+        convertCodeExecutionParts(
+          content,
+          delimeters,
+          invocationContext.agent.codeExecutor.executionResultDelimiters
+        );
+      }
+    });
+  }
+}
+const DATA_FILE_UTIL_MAP = {
+  "text/csv": {
+    extension: ".csv",
+    loaderCodeTemplate: "pd.read_csv('{filename}')"
+  }
+};
+const DATA_FILE_HELPER_LIB = "\nimport pandas as pd\n\ndef explore_df(df: pd.DataFrame) -> None:\n  \"\"\"Prints some information about a pandas DataFrame.\"\"\"\n\n  with pd.option_context(\n      'display.max_columns', None, 'display.expand_frame_repr', False\n  ):\n    # Print the column names to never encounter KeyError when selecting one.\n    df_dtypes = df.dtypes\n\n    # Obtain information about data types and missing values.\n    df_nulls = (len(df) - df.isnull().sum()).apply(\n        lambda x: f'{x} / {df.shape[0]} non-null'\n    )\n\n    # Explore unique total values in columns using `.unique()`.\n    df_unique_count = df.apply(lambda x: len(x.unique()))\n\n    # Explore unique values in columns using `.unique()`.\n    df_unique = df.apply(lambda x: crop(str(list(x.unique()))))\n\n    df_info = pd.concat(\n        (\n            df_dtypes.rename('Dtype'),\n            df_nulls.rename('Non-Null Count'),\n            df_unique_count.rename('Unique Values Count'),\n            df_unique.rename('Unique Values'),\n        ),\n        axis=1,\n    )\n    df_info.index.name = 'Columns'\n    print(f\"\"\"Total rows: {df.shape[0]}\nTotal columns: {df.shape[1]}\n\n{df_info}\"\"\")\n";
+class CodeExecutionResponseProcessor {
+  /**
+   * Processes the LLM response asynchronously.
+   *
+   * @param invocationContext The invocation context
+   * @param llmResponse The LLM response to process
+   * @returns An async generator yielding events
+   */
+  runAsync(invocationContext, llmResponse) {
+    return __asyncGenerator(this, null, function* () {
+      if (llmResponse.partial) {
+        return;
+      }
+      try {
+        for (var iter = __forAwait(runPostProcessor(
+          invocationContext,
+          llmResponse
+        )), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const event = temp.value;
+          yield event;
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+}
+const responseProcessor = new CodeExecutionResponseProcessor();
+function runPreProcessor(invocationContext, llmRequest) {
+  return __asyncGenerator(this, null, function* () {
+    const agent = invocationContext.agent;
+    if (!isLlmAgent(agent)) {
+      return;
+    }
+    const codeExecutor = agent.codeExecutor;
+    if (!codeExecutor || !isBaseCodeExecutor(codeExecutor)) {
+      return;
+    }
+    if (isBuiltInCodeExecutor(codeExecutor)) {
+      codeExecutor.processLlmRequest(llmRequest);
+      return;
+    }
+    if (!codeExecutor.optimizeDataFile) {
+      return;
+    }
+    const codeExecutorContext = new CodeExecutorContext(
+      new State(invocationContext.session.state)
+    );
+    if (codeExecutorContext.getErrorCount(invocationContext.invocationId) >= codeExecutor.errorRetryAttempts) {
+      return;
+    }
+    const allInputFiles = extractAndReplaceInlineFiles(
+      codeExecutorContext,
+      llmRequest
+    );
+    const processedFileNames = new Set(
+      codeExecutorContext.getProcessedFileNames()
+    );
+    const filesToProcess = allInputFiles.filter(
+      (f) => !processedFileNames.has(f.name)
+    );
+    for (const file of filesToProcess) {
+      const codeStr = getDataFilePreprocessingCode(file);
+      if (!codeStr) {
+        return;
+      }
+      const codeContent = {
+        role: "model",
+        parts: [
+          { text: "Processing input file: `".concat(file.name, "`") },
+          buildExecutableCodePart(codeStr)
+        ]
+      };
+      llmRequest.contents.push(cloneDeep(codeContent));
+      yield createEvent({
+        invocationId: invocationContext.invocationId,
+        author: agent.name,
+        branch: invocationContext.branch,
+        content: codeContent
+      });
+      const executionId = getOrSetExecutionId(
+        invocationContext,
+        codeExecutorContext
+      );
+      const codeExecutionResult = yield new __await(codeExecutor.executeCode({
+        invocationContext,
+        codeExecutionInput: {
+          code: codeStr,
+          language: CodeExecutionLanguage.PYTHON,
+          inputFiles: [file],
+          executionId
+        }
+      }));
+      codeExecutorContext.updateCodeExecutionResult({
+        invocationId: invocationContext.invocationId,
+        code: codeStr,
+        resultStdout: codeExecutionResult.stdout,
+        resultStderr: codeExecutionResult.stderr
+      });
+      codeExecutorContext.addProcessedFileNames([file.name]);
+      const executionResultEvent = yield new __await(postProcessCodeExecutionResult(
+        invocationContext,
+        codeExecutorContext,
+        codeExecutionResult
+      ));
+      yield executionResultEvent;
+      llmRequest.contents.push(cloneDeep(executionResultEvent.content));
+    }
+  });
+}
+function runPostProcessor(invocationContext, llmResponse) {
+  return __asyncGenerator(this, null, function* () {
+    const agent = invocationContext.agent;
+    if (!isLlmAgent(agent)) {
+      return;
+    }
+    const codeExecutor = agent.codeExecutor;
+    if (!codeExecutor || !isBaseCodeExecutor(codeExecutor)) {
+      return;
+    }
+    if (!llmResponse || !llmResponse.content) {
+      return;
+    }
+    if (isBuiltInCodeExecutor(codeExecutor)) {
+      return;
+    }
+    const codeExecutorContext = new CodeExecutorContext(
+      new State(invocationContext.session.state)
+    );
+    if (codeExecutorContext.getErrorCount(invocationContext.invocationId) >= codeExecutor.errorRetryAttempts) {
+      return;
+    }
+    const responseContent = llmResponse.content;
+    const codeStr = extractCodeAndTruncateContent(
+      responseContent,
+      codeExecutor.codeBlockDelimiters
+    );
+    if (!codeStr) {
+      return;
+    }
+    yield createEvent({
+      invocationId: invocationContext.invocationId,
+      author: agent.name,
+      branch: invocationContext.branch,
+      content: responseContent
+    });
+    const executionId = getOrSetExecutionId(
+      invocationContext,
+      codeExecutorContext
+    );
+    const codeExecutionResult = yield new __await(codeExecutor.executeCode({
+      invocationContext,
+      codeExecutionInput: {
+        code: codeStr,
+        language: CodeExecutionLanguage.PYTHON,
+        inputFiles: codeExecutorContext.getInputFiles(),
+        executionId
+      }
+    }));
+    codeExecutorContext.updateCodeExecutionResult({
+      invocationId: invocationContext.invocationId,
+      code: codeStr,
+      resultStdout: codeExecutionResult.stdout,
+      resultStderr: codeExecutionResult.stderr
+    });
+    yield yield new __await(postProcessCodeExecutionResult(
+      invocationContext,
+      codeExecutorContext,
+      codeExecutionResult
+    ));
+    llmResponse.content = void 0;
+  });
+}
+function extractAndReplaceInlineFiles(codeExecutorContext, llmRequest) {
+  var _a;
+  const allInputFiles = codeExecutorContext.getInputFiles();
+  const savedFileNames = new Set(allInputFiles.map((f) => f.name));
+  for (let i = 0; i < llmRequest.contents.length; i++) {
+    const content = llmRequest.contents[i];
+    if (content.role !== "user" || !content.parts) {
+      continue;
+    }
+    for (let j = 0; j < content.parts.length; j++) {
+      const part = content.parts[j];
+      const mimeType = (_a = part.inlineData) == null ? void 0 : _a.mimeType;
+      if (!mimeType || !part.inlineData || !DATA_FILE_UTIL_MAP[mimeType]) {
+        continue;
+      }
+      const fileName = "data_".concat(i + 1, "_").concat(j + 1).concat(DATA_FILE_UTIL_MAP[mimeType].extension);
+      part.text = "\nAvailable file: `".concat(fileName, "`\n");
+      const file = {
+        name: fileName,
+        content: base64Decode(part.inlineData.data),
+        mimeType
+      };
+      if (!savedFileNames.has(fileName)) {
+        codeExecutorContext.addInputFiles([file]);
+        allInputFiles.push(file);
+      }
+    }
+  }
+  return allInputFiles;
+}
+function getOrSetExecutionId(invocationContext, codeExecutorContext) {
+  var _a;
+  const agent = invocationContext.agent;
+  if (!isLlmAgent(agent) || !((_a = agent.codeExecutor) == null ? void 0 : _a.stateful)) {
+    return void 0;
+  }
+  let executionId = codeExecutorContext.getExecutionId();
+  if (!executionId) {
+    executionId = invocationContext.session.id;
+    codeExecutorContext.setExecutionId(executionId);
+  }
+  return executionId;
+}
+async function postProcessCodeExecutionResult(invocationContext, codeExecutorContext, codeExecutionResult) {
+  if (!invocationContext.artifactService) {
+    throw new Error("Artifact service is not initialized.");
+  }
+  const resultContent = {
+    role: "model",
+    parts: [buildCodeExecutionResultPart(codeExecutionResult)]
+  };
+  const eventActions = createEventActions({
+    stateDelta: codeExecutorContext.getStateDelta()
+  });
+  if (codeExecutionResult.stderr) {
+    codeExecutorContext.incrementErrorCount(invocationContext.invocationId);
+  } else {
+    codeExecutorContext.resetErrorCount(invocationContext.invocationId);
+  }
+  for (const outputFile of codeExecutionResult.outputFiles) {
+    const version = await invocationContext.artifactService.saveArtifact({
+      appName: invocationContext.appName || "",
+      userId: invocationContext.userId || "",
+      sessionId: invocationContext.session.id,
+      filename: outputFile.name,
+      artifact: {
+        inlineData: { data: outputFile.content, mimeType: outputFile.mimeType }
+      }
+    });
+    eventActions.artifactDelta[outputFile.name] = version;
+  }
+  return createEvent({
+    invocationId: invocationContext.invocationId,
+    author: invocationContext.agent.name,
+    branch: invocationContext.branch,
+    content: resultContent,
+    actions: eventActions
+  });
+}
+function getDataFilePreprocessingCode(file) {
+  function getNormalizedFileName(fileName) {
+    const [varName2] = fileName.split(".");
+    let normalizedName = varName2.replace(/[^a-zA-Z0-9_]/g, "_");
+    if (/^\d/.test(normalizedName)) {
+      normalizedName = "_" + normalizedName;
+    }
+    return normalizedName;
+  }
+  if (!DATA_FILE_UTIL_MAP[file.mimeType]) {
+    return void 0;
+  }
+  const varName = getNormalizedFileName(file.name);
+  const loaderCode = DATA_FILE_UTIL_MAP[file.mimeType].loaderCodeTemplate.replace("{filename}", file.name);
+  return "\n".concat(DATA_FILE_HELPER_LIB, "\n\n# Load the dataframe.\n").concat(varName, " = ").concat(loaderCode, "\n\n# Use `explore_df` to guide my analysis.\nexplore_df(").concat(varName, ")\n");
+}
+const CODE_EXECUTION_REQUEST_PROCESSOR = new CodeExecutionRequestProcessor();
+export {
+  CODE_EXECUTION_REQUEST_PROCESSOR,
+  CodeExecutionRequestProcessor,
+  CodeExecutionResponseProcessor,
+  responseProcessor
+};

package/dist/web/agents/processors/content_processor_utils.js

@@ -0,0 +1,318 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createUserContent } from "@google/genai";
+import { cloneDeep } from "lodash-es";
+import {
+  isCompactedEvent
+} from "../../events/compacted_event.js";
+import {
+  createEvent,
+  getFunctionCalls,
+  getFunctionResponses
+} from "../../events/event.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;
+  const filteredEvents = [];
+  for (const event of events) {
+    if (isCompactedEvent(event)) {
+      filteredEvents.push(convertCompactedEvent(event));
+      continue;
+    }
+    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 = cloneDeep(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);
+  }
+}
+function convertCompactedEvent(event) {
+  const content = createUserContent(
+    "[Previous Context Summary]:\n".concat(event.compactedContent)
+  );
+  return createEvent({
+    invocationId: event.invocationId,
+    author: "user",
+    content,
+    branch: event.branch,
+    timestamp: event.timestamp
+  });
+}
+export {
+  getContents,
+  getCurrentTurnContents
+};