@google/adk 1.2.0 → 1.4.0

package/dist/esm/agents/functions.js

@@ -7,7 +7,11 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { createUserContent } from "@google/genai";
 import { isEmpty } from "lodash-es";
-import { createEvent, getFunctionCalls } from "../events/event.js";
+import {
+  createEvent,
+  getFunctionCalls,
+  getFunctionResponses
+} from "../events/event.js";
 import { mergeEventActions } from "../events/event_actions.js";
 import { randomUUID } from "../utils/env_aware_utils.js";
 import { logger } from "../utils/logger.js";
@@ -39,18 +43,6 @@ function populateClientFunctionCallId(modelResponseEvent) {
     }
   }
 }
-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) {
@@ -393,9 +385,39 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
     timestamp: baseEvent.timestamp
   });
 }
+function findEventByFunctionCallId(events, functionCallId, endIndex = events.length) {
+  for (let i = endIndex - 1; i >= 0; i--) {
+    const event = events[i];
+    const functionCalls = getFunctionCalls(event);
+    for (const functionCall of functionCalls) {
+      if (functionCall.id === functionCallId) {
+        return event;
+      }
+    }
+  }
+  return void 0;
+}
+function findMatchingFunctionCall(events) {
+  if (!events.length) {
+    return void 0;
+  }
+  const lastEvent = events[events.length - 1];
+  const functionResponses = getFunctionResponses(lastEvent);
+  if (!functionResponses.length || !functionResponses[0].id) {
+    return void 0;
+  }
+  return findEventByFunctionCallId(
+    events,
+    functionResponses[0].id,
+    events.length - 1
+  );
+}
 export {
+  AF_FUNCTION_CALL_ID_PREFIX,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   REQUEST_EUC_FUNCTION_CALL_NAME,
+  findEventByFunctionCallId,
+  findMatchingFunctionCall,
   functionsExportedForTestingOnly,
   generateAuthEvent,
   generateClientFunctionCallId,
@@ -404,6 +426,5 @@ export {
   handleFunctionCallList,
   handleFunctionCallsAsync,
   mergeParallelFunctionResponseEvents,
-  populateClientFunctionCallId,
-  removeClientFunctionCallId
+  populateClientFunctionCallId
 };

package/dist/esm/agents/instructions.js

@@ -6,50 +6,116 @@ const require = topLevelCreateRequire(import.meta.url);
  * SPDX-License-Identifier: Apache-2.0
  */
 import { State } from "../sessions/state.js";
-async function injectSessionState(template, readonlyContext) {
+const ARTIFACT_PREFIX = "artifact.";
+async function resolveKey(key, isOptional, rawMatch, readonlyContext) {
   const invocationContext = readonlyContext.invocationContext;
-  async function replaceMatchedKeyWithItsValue(match) {
-    let key = match[0].replace(/^\{+/, "").replace(/\}+$/, "").trim();
-    const isOptional = key.endsWith("?");
-    if (isOptional) {
-      key = key.slice(0, -1);
+  if (key.startsWith(ARTIFACT_PREFIX)) {
+    const fileName = key.substring(ARTIFACT_PREFIX.length);
+    if (invocationContext.artifactService === void 0) {
+      throw new Error("Artifact service is not initialized.");
     }
-    if (key.startsWith("artifact.")) {
-      const fileName = key.substring("artifact.".length);
-      if (invocationContext.artifactService === void 0) {
-        throw new Error("Artifact service is not initialized.");
+    const artifact = await invocationContext.artifactService.loadArtifact({
+      filename: fileName
+    });
+    if (!artifact) {
+      if (isOptional) {
+        return "";
       }
-      const artifact = await invocationContext.artifactService.loadArtifact({
-        appName: invocationContext.session.appName,
-        userId: invocationContext.session.userId,
-        sessionId: invocationContext.session.id,
-        filename: fileName
-      });
-      if (!artifact) {
-        throw new Error(`Artifact ${fileName} not found.`);
-      }
-      return String(artifact);
+      throw new Error(`Artifact ${fileName} not found.`);
     }
-    if (!isValidStateName(key)) {
-      return match[0];
+    return formatValue(artifact, true);
+  }
+  if (!isValidStateName(key)) {
+    return rawMatch;
+  }
+  if (key in invocationContext.session.state) {
+    return formatValue(invocationContext.session.state[key], false);
+  }
+  if (isOptional) {
+    return "";
+  }
+  throw new Error(`Context variable not found: \`${key}\`.`);
+}
+function formatValue(value, isArtifact = false) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "object" && value !== null) {
+    if (isArtifact && "text" in value && typeof value.text === "string") {
+      return value.text;
     }
-    if (key in invocationContext.session.state) {
-      return String(invocationContext.session.state[key]);
+    try {
+      const json = JSON.stringify(value);
+      if (json !== void 0) {
+        return json;
+      }
+    } catch (e) {
+      throw new Error(
+        `Failed to serialize value for instruction template: ${e instanceof Error ? e.message : String(e)}`
+      );
     }
+  }
+  return String(value);
+}
+async function injectSessionState(template, readonlyContext) {
+  const pattern = /\{+[^{}]*}+/g;
+  const matches = Array.from(template.matchAll(pattern));
+  if (matches.length === 0) {
+    return template;
+  }
+  const parsedMatches = matches.map((match) => {
+    const raw = match[0];
+    let key = raw.replace(/^\{+/, "").replace(/\}+$/, "").trim();
+    const isOptional = key.endsWith("?");
     if (isOptional) {
-      return "";
+      key = key.slice(0, -1);
+    }
+    const isValid = key.startsWith(ARTIFACT_PREFIX) || isValidStateName(key);
+    return {
+      raw,
+      key,
+      isOptional,
+      isValid,
+      index: match.index
+    };
+  });
+  const uniqueKeys = /* @__PURE__ */ new Map();
+  for (const pm of parsedMatches) {
+    if (!pm.isValid) {
+      continue;
+    }
+    const existing = uniqueKeys.get(pm.key);
+    if (existing) {
+      if (existing.isOptional && !pm.isOptional) {
+        existing.isOptional = false;
+      }
+    } else {
+      uniqueKeys.set(pm.key, {
+        key: pm.key,
+        isOptional: pm.isOptional,
+        raw: pm.raw
+      });
     }
-    throw new Error(`Context variable not found: \`${key}\`.`);
   }
-  const pattern = /\{+[^{}]*}+/g;
+  const resolutions = /* @__PURE__ */ new Map();
+  for (const info of uniqueKeys.values()) {
+    resolutions.set(
+      info.key,
+      resolveKey(info.key, info.isOptional, info.raw, readonlyContext)
+    );
+  }
+  await Promise.all(resolutions.values());
   const result = [];
   let lastEnd = 0;
-  const matches = template.matchAll(pattern);
-  for (const match of matches) {
-    result.push(template.slice(lastEnd, match.index));
-    const replacement = await replaceMatchedKeyWithItsValue(match);
-    result.push(replacement);
-    lastEnd = match.index + match[0].length;
+  for (const pm of parsedMatches) {
+    result.push(template.slice(lastEnd, pm.index));
+    if (pm.isValid) {
+      const replacement = await resolutions.get(pm.key);
+      result.push(replacement);
+    } else {
+      result.push(pm.raw);
+    }
+    lastEnd = pm.index + pm.raw.length;
   }
   result.push(template.slice(lastEnd));
   return result.join("");

package/dist/esm/agents/invocation_context.js

@@ -30,11 +30,7 @@ class InvocationContext {
    * @param params The parameters for creating an invocation context.
    */
   constructor(params) {
-    /**
-     * A container to keep track of different kinds of costs incurred as a part of
-     * this invocation.
-     */
-    this.invocationCostManager = new InvocationCostManager();
+    var _a;
     this.artifactService = params.artifactService;
     this.sessionService = params.sessionService;
     this.memoryService = params.memoryService;
@@ -46,10 +42,10 @@ class InvocationContext {
     this.endInvocation = params.endInvocation || false;
     this.transcriptionCache = params.transcriptionCache;
     this.runConfig = params.runConfig;
-    this.liveRequestQueue = params.liveRequestQueue;
     this.activeStreamingTools = params.activeStreamingTools;
     this.pluginManager = params.pluginManager;
     this.abortSignal = params.abortSignal;
+    this.invocationCostManager = (_a = params.invocationCostManager) != null ? _a : new InvocationCostManager();
   }
   /**
    * The app name of the current session.

package/dist/esm/agents/llm_agent.js

@@ -7,10 +7,12 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 var _a, _b;
 import { context, trace } from "@opentelemetry/api";
+import { FunctionTool } from "../tools/function_tool.js";
 import {
   createEvent,
   createNewEventId,
   getFunctionCalls,
+  getFunctionResponses,
   isFinalResponse
 } from "../events/event.js";
 import { isBaseLlm } from "../models/base_llm.js";
@@ -32,6 +34,7 @@ import {
   handleFunctionCallsAsync,
   populateClientFunctionCallId
 } from "./functions.js";
+import { AUTH_PREPROCESSOR } from "../auth/auth_preprocessor.js";
 import { AGENT_TRANSFER_LLM_REQUEST_PROCESSOR } from "./processors/agent_transfer_llm_request_processor.js";
 import { BASIC_LLM_REQUEST_PROCESSOR } from "./processors/basic_llm_request_processor.js";
 import { CODE_EXECUTION_REQUEST_PROCESSOR } from "./processors/code_execution_request_processor.js";
@@ -39,6 +42,7 @@ import { CONTENT_REQUEST_PROCESSOR } from "./processors/content_request_processo
 import { ContextCompactorRequestProcessor } from "./processors/context_compactor_request_processor.js";
 import { IDENTITY_LLM_REQUEST_PROCESSOR } from "./processors/identity_llm_request_processor.js";
 import { INSTRUCTIONS_LLM_REQUEST_PROCESSOR } from "./processors/instructions_llm_request_processor.js";
+import { INTERACTIONS_REQUEST_PROCESSOR } from "./processors/interactions_request_processor.js";
 import { REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR } from "./processors/request_confirmation_llm_request_processor.js";
 import { TOOL_FILTER_REQUEST_PROCESSOR } from "./processors/tool_filter_request_processor.js";
 import { ReadonlyContext } from "./readonly_context.js";
@@ -78,10 +82,12 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
     this.codeExecutor = config.codeExecutor;
     this.requestProcessors = (_g = config.requestProcessors) != null ? _g : [
       BASIC_LLM_REQUEST_PROCESSOR,
+      AUTH_PREPROCESSOR,
       IDENTITY_LLM_REQUEST_PROCESSOR,
       INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
       REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
       CONTENT_REQUEST_PROCESSOR,
+      INTERACTIONS_REQUEST_PROCESSOR,
       CODE_EXECUTION_REQUEST_PROCESSOR,
       TOOL_FILTER_REQUEST_PROCESSOR
     ];
@@ -303,18 +309,26 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
     event.actions.stateDelta[this.outputKey] = result;
   }
   async *runAsyncImpl(context2) {
-    var _a2;
+    var _a2, _b2;
     while (true) {
       let lastEvent = void 0;
+      let stepHadToolCalls = false;
       for await (const event of this.runOneStepAsync(context2)) {
         if ((_a2 = context2.abortSignal) == null ? void 0 : _a2.aborted) {
           return;
         }
         lastEvent = event;
+        if (getFunctionCalls(event).length > 0 || getFunctionResponses(event).length > 0) {
+          stepHadToolCalls = true;
+        }
         this.maybeSaveOutputToState(event);
         yield event;
       }
-      if (!lastEvent || isFinalResponse(lastEvent)) {
+      if (!lastEvent) {
+        break;
+      }
+      const isEmptyMetadataEvent = lastEvent.author === this.name && !lastEvent.partial && (!((_b2 = lastEvent.content) == null ? void 0 : _b2.parts) || lastEvent.content.parts.length === 0);
+      if (isFinalResponse(lastEvent) && !(isEmptyMetadataEvent && stepHadToolCalls)) {
         break;
       }
       if (lastEvent.partial) {
@@ -339,6 +353,20 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
   // --------------------------------------------------------------------------
   // #START LlmFlow Logic
   // --------------------------------------------------------------------------
+  /**
+   * Runs the bidirectional (live) flow for this agent.
+   *
+   * Establishes a live connection to the model, drains the invocation's
+   * `liveRequestQueue` into the connection on a parallel task, and yields
+   * events derived from server messages until the queue closes, the model
+   * finishes, or an agent transfer occurs.
+   *
+   * If the live connection drops (network failure, server `goAway`) and a
+   * session resumption handle has been observed, the flow transparently
+   * reconnects using that handle up to {@link MAX_LIVE_RECONNECT_ATTEMPTS}
+   * times. Subsequent reconnects skip `sendHistory` because the server
+   * already holds the conversation state associated with the handle.
+   */
   // eslint-disable-next-line require-yield
   async *runLiveFlow(_invocationContext) {
     await Promise.resolve();
@@ -362,13 +390,28 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
         yield event;
       }
     }
-    for (const toolUnion of this.tools) {
+    const allTools = [...this.tools];
+    if (this.outputSchema && allTools.length > 0) {
+      const setModelResponseTool = new FunctionTool({
+        name: "set_model_response",
+        description: "Call this tool to submit your final response conforming to the output schema. Use this tool only when you have collected all the information and are ready to return the final answer.",
+        parameters: this.outputSchema,
+        execute: async (args, toolContext) => {
+          if (toolContext) {
+            toolContext.actions.skipSummarization = true;
+          }
+          return JSON.stringify(args);
+        }
+      });
+      allTools.push(setModelResponseTool);
+    }
+    for (const toolUnion of allTools) {
       const toolContext = new Context({ invocationContext });
       const tools = (await convertToolUnionToTools(
         toolUnion,
         new ReadonlyContext(invocationContext)
       )).filter((tool) => {
-        return !llmRequest.allowedTools || llmRequest.allowedTools.includes(tool.name);
+        return !llmRequest.allowedTools || llmRequest.allowedTools.includes(tool.name) || tool.name === "set_model_response";
       });
       for (const tool of tools) {
         await tool.processLlmRequest({ toolContext, llmRequest });
@@ -427,7 +470,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
     span.end();
   }
   async *postprocess(invocationContext, llmRequest, llmResponse, modelResponseEvent) {
-    var _a2, _b2, _c, _d, _e;
+    var _a2, _b2, _c, _d, _e, _f;
     for (const processor of this.responseProcessors) {
       for await (const event of processor.runAsync(
         invocationContext,
@@ -439,7 +482,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
         yield event;
       }
     }
-    if (!llmResponse.content && !llmResponse.errorCode && !llmResponse.interrupted) {
+    if ((!llmResponse.content || ((_b2 = llmResponse.content.parts) == null ? void 0 : _b2.length) === 0) && !llmResponse.errorCode && !llmResponse.interrupted) {
       return;
     }
     const mergedEvent = createEvent({
@@ -448,7 +491,14 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
     });
     if (mergedEvent.content) {
       const functionCalls = getFunctionCalls(mergedEvent);
-      if (functionCalls == null ? void 0 : functionCalls.length) {
+      const setModelResponseCall = functionCalls.find(
+        (call) => call.name === "set_model_response"
+      );
+      if (setModelResponseCall) {
+        const args = setModelResponseCall.args;
+        mergedEvent.content.parts = [{ text: JSON.stringify(args) }];
+        mergedEvent.actions.skipSummarization = true;
+      } else if (functionCalls && functionCalls.length) {
         populateClientFunctionCallId(mergedEvent);
         mergedEvent.longRunningToolIds = Array.from(
           getLongRunningFunctionCalls(functionCalls, llmRequest.toolsDict)
@@ -456,10 +506,10 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
       }
     }
     yield mergedEvent;
-    if (!((_b2 = getFunctionCalls(mergedEvent)) == null ? void 0 : _b2.length)) {
+    if (!((_c = getFunctionCalls(mergedEvent)) == null ? void 0 : _c.length)) {
       return;
     }
-    if ((_c = invocationContext.runConfig) == null ? void 0 : _c.pauseOnToolCalls) {
+    if ((_d = invocationContext.runConfig) == null ? void 0 : _d.pauseOnToolCalls) {
       invocationContext.endInvocation = true;
       return;
     }
@@ -470,7 +520,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
       beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
       afterToolCallbacks: this.canonicalAfterToolCallbacks
     });
-    if (!functionResponseEvent || ((_d = invocationContext.abortSignal) == null ? void 0 : _d.aborted)) {
+    if (!functionResponseEvent || ((_e = invocationContext.abortSignal) == null ? void 0 : _e.aborted)) {
       return;
     }
     const authEvent = generateAuthEvent(
@@ -495,7 +545,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
     if (nextAgentName) {
       const nextAgent = this.getAgentByName(invocationContext, nextAgentName);
       for await (const event of nextAgent.runAsync(invocationContext)) {
-        if ((_e = invocationContext.abortSignal) == null ? void 0 : _e.aborted) {
+        if ((_f = invocationContext.abortSignal) == null ? void 0 : _f.aborted) {
           return;
         }
         yield event;

package/dist/esm/agents/processors/agent_transfer_llm_request_processor.js

@@ -30,6 +30,13 @@ class AgentTransferLlmRequestProcessor extends BaseLlmRequestProcessor {
       }
     });
   }
+  /**
+   * Appends transfer instructions and registers the `transfer_to_agent` tool
+   * when the agent has reachable transfer targets.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request to augment with transfer instructions and the transfer tool.
+   */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     if (!isLlmAgent(invocationContext.agent)) {

package/dist/esm/agents/processors/basic_llm_request_processor.js

@@ -9,6 +9,13 @@ import { setOutputSchema } from "../../models/llm_request.js";
 import { isLlmAgent } from "../llm_agent.js";
 import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
 class BasicLlmRequestProcessor extends BaseLlmRequestProcessor {
+  /**
+   * Populates model name, generation config, output schema, and live connect
+   * settings on the request from the agent and run config.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request object to populate in place.
+   */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     var _a;
@@ -18,7 +25,7 @@ class BasicLlmRequestProcessor extends BaseLlmRequestProcessor {
     }
     llmRequest.model = agent.canonicalModel.model;
     llmRequest.config = { ...(_a = agent.generateContentConfig) != null ? _a : {} };
-    if (agent.outputSchema) {
+    if (agent.outputSchema && (!agent.tools || agent.tools.length === 0)) {
       setOutputSchema(llmRequest, agent.outputSchema);
     }
     if (invocationContext.runConfig) {

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

@@ -317,9 +317,6 @@ async function postProcessCodeExecutionResult(invocationContext, codeExecutorCon
   }
   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 }

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

@@ -16,10 +16,21 @@ import {
   getFunctionResponses
 } from "../../events/event.js";
 import {
-  removeClientFunctionCallId,
+  AF_FUNCTION_CALL_ID_PREFIX,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   REQUEST_EUC_FUNCTION_CALL_NAME
 } from "../functions.js";
+function removeClientFunctionCallId(content) {
+  var _a, _b, _c, _d, _e;
+  for (const part of (_a = content == null ? void 0 : content.parts) != null ? _a : []) {
+    if ((_c = (_b = part.functionCall) == null ? void 0 : _b.id) == null ? void 0 : _c.startsWith(AF_FUNCTION_CALL_ID_PREFIX)) {
+      part.functionCall.id = void 0;
+    }
+    if ((_e = (_d = part.functionResponse) == null ? void 0 : _d.id) == null ? void 0 : _e.startsWith(AF_FUNCTION_CALL_ID_PREFIX)) {
+      part.functionResponse.id = void 0;
+    }
+  }
+}
 function getContents(events, agentName, currentBranch) {
   var _a, _b, _c;
   const filteredEvents = [];
@@ -109,17 +120,19 @@ function convertForeignEvent(event) {
         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}`
+        text: `[${event.author}] called tool \`${part.functionCall.name}\` with parameters: ${safeStringify(
+          part.functionCall.args
+        )}`
       });
     } 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}`
+        text: `[${event.author}] tool \`${part.functionResponse.name}\` returned result: ${safeStringify(
+          part.functionResponse.response
+        )}`
       });
     } else {
-      (_f = content.parts) == null ? void 0 : _f.push(part);
+      (_f = content.parts) == null ? void 0 : _f.push(cloneDeep(part));
     }
   }
   return createEvent({
@@ -135,9 +148,12 @@ function mergeFunctionResponseEvents(events) {
   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) {
+  const mergedEvent = createEvent({
+    ...events[0],
+    content: events[0].content ? cloneDeep(events[0].content) : void 0
+  });
+  const partsInMergedEvent = (_a = mergedEvent.content) == null ? void 0 : _a.parts;
+  if (!partsInMergedEvent || partsInMergedEvent.length === 0) {
     throw new Error("There should be at least one function_response part.");
   }
   const partIndicesInMergedEvent = {};
@@ -152,16 +168,17 @@ function mergeFunctionResponseEvents(events) {
       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;
+      const clonedPart = cloneDeep(part);
+      if (clonedPart.functionResponse && clonedPart.functionResponse.id) {
+        const functionCallId = clonedPart.functionResponse.id;
         if (functionCallId in partIndicesInMergedEvent) {
-          partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = part;
+          partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = clonedPart;
         } else {
-          partsInMergedEvent.push(part);
+          partsInMergedEvent.push(clonedPart);
           partIndicesInMergedEvent[functionCallId] = partsInMergedEvent.length - 1;
         }
       } else {
-        partsInMergedEvent.push(part);
+        partsInMergedEvent.push(clonedPart);
       }
     }
   }
@@ -176,7 +193,7 @@ function rearrangeEventsForLatestFunctionResponse(events) {
   if (!(functionResponses == null ? void 0 : functionResponses.length)) {
     return events;
   }
-  let functionResponsesIds = new Set(
+  const functionResponsesIds = new Set(
     functionResponses.filter((response) => !!response.id).map((response) => response.id)
   );
   const secondLatestEvent = events.at(-2);
@@ -190,16 +207,16 @@ function rearrangeEventsForLatestFunctionResponse(events) {
       }
     }
   }
-  let functionCallEventIdx = -1;
+  let match;
   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;
     }
+    let matchedInEvent = false;
     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)
         );
@@ -213,12 +230,16 @@ function rearrangeEventsForLatestFunctionResponse(events) {
             )}, function response ids provided: ${Array.from(functionResponsesIds).join(", ")}`
           );
         }
-        functionResponsesIds = functionCallIds;
+        match = { eventIdx: idx, responseIds: functionCallIds };
+        matchedInEvent = true;
         break;
       }
     }
+    if (matchedInEvent) {
+      break;
+    }
   }
-  if (functionCallEventIdx === -1) {
+  if (!match) {
     throw new Error(
       `No function call event found for function responses ids: ${Array.from(
         functionResponsesIds
@@ -226,17 +247,18 @@ function rearrangeEventsForLatestFunctionResponse(events) {
     );
   }
   const functionResponseEvents = [];
-  for (let idx = functionCallEventIdx + 1; idx < events.length - 1; idx++) {
+  const activeResponses = match.responseIds;
+  for (let idx = match.eventIdx + 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)
+      (response) => response.id && activeResponses.has(response.id)
     )) {
       functionResponseEvents.push(event);
     }
   }
   functionResponseEvents.push(events[events.length - 1]);
-  const resultEvents = events.slice(0, functionCallEventIdx + 1);
+  const resultEvents = events.slice(0, match.eventIdx + 1);
   resultEvents.push(mergeFunctionResponseEvents(functionResponseEvents));
   return resultEvents;
 }
@@ -275,7 +297,7 @@ function rearrangeEventsForAsyncFunctionResponsesInHistory(events) {
         continue;
       }
       if (functionResponseEventsIndices.size === 1) {
-        const [responseIndex] = [...functionResponseEventsIndices];
+        const [responseIndex] = Array.from(functionResponseEventsIndices);
         resultEvents.push(events[responseIndex]);
       } else {
         const indicesArray = Array.from(functionResponseEventsIndices).sort(
@@ -315,5 +337,7 @@ ${event.compactedContent}`
 }
 export {
   getContents,
-  getCurrentTurnContents
+  getCurrentTurnContents,
+  mergeFunctionResponseEvents,
+  removeClientFunctionCallId
 };

package/dist/esm/agents/processors/content_request_processor.js

@@ -12,6 +12,13 @@ import {
   getCurrentTurnContents
 } from "./content_processor_utils.js";
 class ContentRequestProcessor {
+  /**
+   * Fills {@link LlmRequest.contents} based on the session event history and
+   * agent configuration.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request whose contents field will be populated.
+   */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;