@google/adk 1.2.0 → 1.4.0

package/dist/web/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 ".concat(fileName, " not found."));
-      }
-      return String(artifact);
+      throw new Error("Artifact ".concat(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: `".concat(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: ".concat(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: `".concat(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/web/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/web/agents/llm_agent.js

@@ -71,10 +71,12 @@ var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")])
  */
 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";
@@ -96,6 +98,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";
@@ -103,6 +106,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";
@@ -142,10 +146,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
     ];
@@ -368,9 +374,10 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
   }
   runAsyncImpl(context2) {
     return __asyncGenerator(this, null, function* () {
-      var _a2;
+      var _a2, _b2;
       while (true) {
         let lastEvent = void 0;
+        let stepHadToolCalls = false;
         try {
           for (var iter = __forAwait(this.runOneStepAsync(context2)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
             const event = temp.value;
@@ -378,6 +385,9 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
               return;
             }
             lastEvent = event;
+            if (getFunctionCalls(event).length > 0 || getFunctionResponses(event).length > 0) {
+              stepHadToolCalls = true;
+            }
             this.maybeSaveOutputToState(event);
             yield event;
           }
@@ -391,7 +401,11 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
               throw error[0];
           }
         }
-        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) {
@@ -431,6 +445,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
   runLiveFlow(_invocationContext) {
     return __asyncGenerator(this, null, function* () {
@@ -469,13 +497,28 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
           }
         }
       }
-      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 = (yield new __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) {
           yield new __await(tool.processLlmRequest({ toolContext, llmRequest }));
@@ -564,7 +607,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
   }
   postprocess(invocationContext, llmRequest, llmResponse, modelResponseEvent) {
     return __asyncGenerator(this, null, function* () {
-      var _a2, _b2, _c, _d, _e;
+      var _a2, _b2, _c, _d, _e, _f;
       for (const processor of this.responseProcessors) {
         try {
           for (var iter = __forAwait(processor.runAsync(
@@ -588,13 +631,20 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
           }
         }
       }
-      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(__spreadValues(__spreadValues({}, modelResponseEvent), llmResponse));
       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)
@@ -602,10 +652,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;
       }
@@ -616,7 +666,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(
@@ -643,7 +693,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
         try {
           for (var iter2 = __forAwait(nextAgent.runAsync(invocationContext)), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
             const event = temp2.value;
-            if ((_e = invocationContext.abortSignal) == null ? void 0 : _e.aborted) {
+            if ((_f = invocationContext.abortSignal) == null ? void 0 : _f.aborted) {
               return;
             }
             yield event;

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

@@ -46,6 +46,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
   runAsync(invocationContext, llmRequest) {
     return __asyncGenerator(this, null, function* () {

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

@@ -41,6 +41,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
   runAsync(invocationContext, llmRequest) {
     return __asyncGenerator(this, null, function* () {
@@ -51,7 +58,7 @@ class BasicLlmRequestProcessor extends BaseLlmRequestProcessor {
       }
       llmRequest.model = agent.canonicalModel.model;
       llmRequest.config = __spreadValues({}, (_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/web/agents/processors/code_execution_request_processor.js

@@ -327,9 +327,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/web/agents/processors/content_processor_utils.js

@@ -1,5 +1,24 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -16,10 +35,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 +139,19 @@ function convertForeignEvent(event) {
         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)
+        text: "[".concat(event.author, "] called tool `").concat(part.functionCall.name, "` with parameters: ").concat(safeStringify(
+          part.functionCall.args
+        ))
       });
     } 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)
+        text: "[".concat(event.author, "] tool `").concat(part.functionResponse.name, "` returned result: ").concat(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 +167,11 @@ 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(__spreadProps(__spreadValues({}, 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 +186,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 +211,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 +225,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 +248,16 @@ function rearrangeEventsForLatestFunctionResponse(events) {
             ), ", function response") + " ids provided: ".concat(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: ".concat(Array.from(
         functionResponsesIds
@@ -226,17 +265,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 +315,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(
@@ -314,5 +354,7 @@ function convertCompactedEvent(event) {
 }
 export {
   getContents,
-  getCurrentTurnContents
+  getCurrentTurnContents,
+  mergeFunctionResponseEvents,
+  removeClientFunctionCallId
 };

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

@@ -28,6 +28,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
   runAsync(invocationContext, llmRequest) {
     return __asyncGenerator(this, null, function* () {

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

@@ -23,25 +23,39 @@ var __asyncGenerator = (__this, __arguments, generator) => {
  */
 import { ContextCompactionTrigger } from "../../plugins/base_plugin.js";
 class ContextCompactorRequestProcessor {
+  /**
+   * @param compactors - Ordered list of compactors to evaluate; the first one
+   *   that reports it should compact will perform the compaction.
+   */
   constructor(compactors) {
     this.compactors = compactors;
   }
+  /**
+   * Evaluates compactors in priority order. The first compactor that indicates
+   * it should compact will compact the session history, fire plugin hooks, and
+   * yield any newly generated events. Iteration stops after one compaction.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param _llmRequest - Unused; present to satisfy the {@link BaseLlmRequestProcessor} interface.
+   */
   runAsync(invocationContext, _llmRequest) {
     return __asyncGenerator(this, null, function* () {
+      var _a;
       for (const compactor of this.compactors) {
         const shouldCompact = yield new __await(Promise.resolve(
           compactor.shouldCompact(invocationContext)
         ));
         if (shouldCompact) {
+          const trigger = (_a = compactor.trigger) != null ? _a : ContextCompactionTrigger.Auto;
           yield new __await(invocationContext.pluginManager.runBeforeContextCompaction({
             invocationContext,
-            trigger: ContextCompactionTrigger.Auto
+            trigger
           }));
           const oldEvents = new Set(invocationContext.session.events);
           yield new __await(Promise.resolve(compactor.compact(invocationContext)));
           yield new __await(invocationContext.pluginManager.runAfterContextCompaction({
             invocationContext,
-            trigger: ContextCompactionTrigger.Auto
+            trigger
           }));
           const newEvents = invocationContext.session.events.filter(
             (e) => !oldEvents.has(e)