@google/adk 2.0.0 → 2.2.0

package/dist/esm/plugins/reflect_retry_model_plugin.js

@@ -0,0 +1,250 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FinishReason } from "@google/genai";
+import { v4 as uuidv4 } from "uuid";
+import { FunctionTool } from "../tools/function_tool.js";
+import {
+  REFLECT_AND_RETRY_RESPONSE_TYPE,
+  resolveScopeKey,
+  ScopedFailureTracker,
+  TrackingScope
+} from "./_reflect_retry_utils.js";
+import { BasePlugin } from "./base_plugin.js";
+const RESERVED_TOOL_CALL_ERROR_TYPE = "RESERVED_TOOL_CALL";
+const ADK_HANDLE_MODEL_ERROR_TOOL_NAME = "adk_handle_model_error";
+const _ReflectAndRetryModelPlugin = class _ReflectAndRetryModelPlugin extends BasePlugin {
+  /**
+   * Initializes the {@link ReflectAndRetryModelPlugin}.
+   *
+   * @param options - Configuration options for the plugin.
+   */
+  constructor(options = {}) {
+    var _a, _b, _c, _d, _e;
+    super((_a = options.name) != null ? _a : "reflect_retry_model_plugin");
+    const retries = (_b = options.maxRetries) != null ? _b : 3;
+    if (retries < 0) {
+      throw new Error("maxRetries must be a non-negative integer.");
+    }
+    this.maxRetries = retries;
+    this.throwExceptionIfRetryExceeded = (_c = options.throwExceptionIfRetryExceeded) != null ? _c : true;
+    this.scope = (_d = options.trackingScope) != null ? _d : TrackingScope.INVOCATION;
+    this.onModelErrors = (_e = options.onModelErrors) != null ? _e : [
+      FinishReason.MALFORMED_FUNCTION_CALL
+    ];
+    this.tracker = new ScopedFailureTracker();
+  }
+  /**
+   * Internal framework reflection tool handler.
+   */
+  adkHandleModelError({
+    retryCount
+  }) {
+    const attempt = retryCount != null ? retryCount : 1;
+    return {
+      reflection_guidance: `
+The call to the model failed.
+
+**Reflection Guidance:**
+- This is retry attempt **${attempt}** of **${this.maxRetries}**
+- Analyze the error and the arguments you provided. Do not repeat the exact same call.
+
+Formulate a new plan based on your analysis and try a corrected or different approach.
+`.trim()
+    };
+  }
+  /**
+   * Checks if the model response contains an error matching `onModelErrors`.
+   */
+  checkForModelError(llmResponse) {
+    if (!llmResponse.errorCode && !llmResponse.finishReason) {
+      return false;
+    }
+    if (llmResponse.finishReason && this.onModelErrors.includes(llmResponse.finishReason)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Retrieves the model name from context.
+   */
+  getModelNameFromContext(callbackContext) {
+    return callbackContext.agentName || "default_model";
+  }
+  /**
+   * Prepares the LLM request by attaching the reflection tool.
+   */
+  async beforeModelCallback({
+    llmRequest
+  }) {
+    this.provideReflectionTool(llmRequest);
+    return void 0;
+  }
+  /**
+   * Inspects LLM responses, intercepts model errors or reserved tool calls, and handles retries.
+   */
+  async afterModelCallback({
+    callbackContext,
+    llmResponse
+  }) {
+    if (this.hasReservedToolCall(llmResponse)) {
+      return await this.handleReservedToolCall(callbackContext, llmResponse);
+    }
+    if (this.checkForModelError(llmResponse)) {
+      return await this.handleModelError(callbackContext, llmResponse);
+    }
+    const scopeKey = this.getModelScopeKey(callbackContext);
+    const modelName = this.getModelNameFromContext(callbackContext);
+    await this.resetModelFailureCount(scopeKey, modelName);
+    return void 0;
+  }
+  /**
+   * Provides the adk_handle_model_error tool for reflection and retries.
+   */
+  provideReflectionTool(llmRequest) {
+    if (!llmRequest.toolsDict) {
+      llmRequest.toolsDict = {};
+    }
+    llmRequest.toolsDict[ADK_HANDLE_MODEL_ERROR_TOOL_NAME] = new FunctionTool({
+      name: ADK_HANDLE_MODEL_ERROR_TOOL_NAME,
+      description: "A tool that triggers reflection. Reserved for internal framework use only. Do not call directly.",
+      execute: /* @__PURE__ */ __name((args) => this.adkHandleModelError(
+        args
+      ), "execute")
+    });
+  }
+  /**
+   * Checks if the model response calls the reserved reflection tool.
+   */
+  hasReservedToolCall(llmResponse) {
+    var _a;
+    if (!((_a = llmResponse.content) == null ? void 0 : _a.parts)) return false;
+    for (const part of llmResponse.content.parts) {
+      if (part.functionCall && part.functionCall.name === ADK_HANDLE_MODEL_ERROR_TOOL_NAME) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Handles direct calls to the reserved reflection tool.
+   */
+  async handleReservedToolCall(callbackContext, _llmResponse) {
+    const retryResponse = await this.handleModelRetry(
+      callbackContext,
+      RESERVED_TOOL_CALL_ERROR_TYPE,
+      `Model attempted to call reserved tool ${ADK_HANDLE_MODEL_ERROR_TOOL_NAME} directly. This tool is reserved for framework use only. Do not call it.`,
+      FinishReason.OTHER
+    );
+    if (retryResponse !== void 0) {
+      return retryResponse;
+    }
+    return {
+      errorCode: RESERVED_TOOL_CALL_ERROR_TYPE,
+      errorMessage: "Model attempted to call reserved tool and retry limit was exceeded."
+    };
+  }
+  /**
+   * Handles detected model errors by initiating retry logic.
+   */
+  async handleModelError(callbackContext, llmResponse) {
+    var _a, _b, _c;
+    const retryResponse = await this.handleModelRetry(
+      callbackContext,
+      (_a = llmResponse.errorCode) != null ? _a : "MODEL_ERROR",
+      (_b = llmResponse.errorMessage) != null ? _b : "Model error encountered.",
+      (_c = llmResponse.finishReason) != null ? _c : FinishReason.OTHER
+    );
+    if (retryResponse !== void 0) {
+      return retryResponse;
+    }
+    return llmResponse;
+  }
+  /**
+   * Tracks retry count, generates retry response, and checks against limits.
+   */
+  async handleModelRetry(callbackContext, errorType, errorDetails, finishReason) {
+    const scopeKey = this.getModelScopeKey(callbackContext);
+    const modelName = this.getModelNameFromContext(callbackContext);
+    const currentRetries = await this.incrementModelFailureCount(
+      scopeKey,
+      modelName
+    );
+    if (currentRetries <= this.maxRetries) {
+      return {
+        content: {
+          role: "model",
+          parts: [
+            this.generateModelRetryPart(
+              currentRetries,
+              errorType,
+              errorDetails,
+              finishReason
+            )
+          ]
+        }
+      };
+    }
+    if (this.throwExceptionIfRetryExceeded) {
+      throw new Error(
+        `The model has failed consecutively ${this.maxRetries} times and the retry limit has been exceeded.`
+      );
+    }
+    return void 0;
+  }
+  /**
+   * Generates a function call part for the model retry tool.
+   */
+  generateModelRetryPart(retryCount, errorType, errorDetails, finishReason) {
+    return {
+      functionCall: {
+        id: this.getModelRetryUuid(),
+        name: ADK_HANDLE_MODEL_ERROR_TOOL_NAME,
+        args: {
+          response_type: REFLECT_AND_RETRY_RESPONSE_TYPE,
+          error_type: errorType,
+          error_details: errorDetails,
+          finish_reason: finishReason,
+          retry_count: retryCount
+        }
+      }
+    };
+  }
+  /**
+   * Generates a unique ID for the model retry tool call.
+   */
+  getModelRetryUuid() {
+    return `${ADK_HANDLE_MODEL_ERROR_TOOL_NAME}_${uuidv4()}`;
+  }
+  /**
+   * Returns the scope key for model failure tracking.
+   */
+  getModelScopeKey(callbackContext) {
+    return resolveScopeKey(this.scope, callbackContext.invocationId);
+  }
+  /**
+   * Increment the failure count for a model within a scope.
+   */
+  async incrementModelFailureCount(scopeKey, itemName) {
+    return await this.tracker.increment(scopeKey, itemName);
+  }
+  /**
+   * Reset the failure count for a model within a scope.
+   */
+  async resetModelFailureCount(scopeKey, itemName) {
+    await this.tracker.reset(scopeKey, itemName);
+  }
+};
+__name(_ReflectAndRetryModelPlugin, "ReflectAndRetryModelPlugin");
+let ReflectAndRetryModelPlugin = _ReflectAndRetryModelPlugin;
+export {
+  ADK_HANDLE_MODEL_ERROR_TOOL_NAME,
+  RESERVED_TOOL_CALL_ERROR_TYPE,
+  ReflectAndRetryModelPlugin
+};

package/dist/esm/plugins/reflect_retry_tool_plugin.js

@@ -0,0 +1,254 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  REFLECT_AND_RETRY_RESPONSE_TYPE,
+  resolveScopeKey,
+  ScopedFailureTracker,
+  TrackingScope
+} from "./_reflect_retry_utils.js";
+import { BasePlugin } from "./base_plugin.js";
+const _ReflectAndRetryToolPlugin = class _ReflectAndRetryToolPlugin extends BasePlugin {
+  /**
+   * Initializes the {@link ReflectAndRetryToolPlugin}.
+   *
+   * @param options - Configuration options for the plugin.
+   */
+  constructor(options = {}) {
+    var _a, _b, _c, _d;
+    super((_a = options.name) != null ? _a : "reflect_retry_tool_plugin");
+    const retries = (_b = options.maxRetries) != null ? _b : 3;
+    if (retries < 0) {
+      throw new Error("maxRetries must be a non-negative integer.");
+    }
+    this.maxRetries = retries;
+    this.throwExceptionIfRetryExceeded = (_c = options.throwExceptionIfRetryExceeded) != null ? _c : true;
+    this.scope = (_d = options.trackingScope) != null ? _d : TrackingScope.INVOCATION;
+    this.tracker = new ScopedFailureTracker();
+  }
+  /**
+   * Handles successful tool calls or extracts and processes errors.
+   *
+   * @param params - The tool callback parameters.
+   * @returns An optional record containing reflection guidance if an error is
+   *   detected, or undefined if the tool call was successful or the response is
+   *   already a reflection message.
+   */
+  async afterToolCallback({
+    tool,
+    toolArgs,
+    toolContext,
+    result
+  }) {
+    if (result && typeof result === "object" && result["response_type"] === REFLECT_AND_RETRY_RESPONSE_TYPE) {
+      return void 0;
+    }
+    const error = await this.extractErrorFromResult({
+      tool,
+      toolArgs,
+      toolContext,
+      result
+    });
+    if (error != null) {
+      return await this.handleToolError(tool, toolArgs, toolContext, error);
+    }
+    await this.resetFailuresForTool(toolContext, tool.name);
+    return void 0;
+  }
+  /**
+   * Extracts an error from a successful tool result and triggers retry logic.
+   *
+   * This is useful when a tool call finishes without throwing an exception but
+   * the result contains an error payload like `{status: 'error', message: '...'}`
+   * that should be handled by the plugin.
+   *
+   * @param params - Tool execution context and result.
+   * @returns The extracted error if any, or undefined if no error was detected.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async extractErrorFromResult(params) {
+    return void 0;
+  }
+  /**
+   * Handles tool exceptions by providing reflection guidance.
+   *
+   * @param params - The error callback parameters.
+   * @returns An optional record containing reflection guidance for the error.
+   */
+  async onToolErrorCallback({
+    tool,
+    toolArgs,
+    toolContext,
+    error
+  }) {
+    return await this.handleToolError(tool, toolArgs, toolContext, error);
+  }
+  /**
+   * Central, thread-safe logic for processing tool errors.
+   *
+   * @param tool - The tool that was called.
+   * @param toolArgs - The arguments passed to the tool.
+   * @param toolContext - The context of the tool call.
+   * @param error - The error to be handled.
+   * @returns An optional record containing reflection guidance for the error.
+   */
+  async handleToolError(tool, toolArgs, toolContext, error) {
+    if (this.maxRetries === 0) {
+      if (this.throwExceptionIfRetryExceeded) {
+        throw this.ensureException(error);
+      }
+      return this.getToolRetryExceedMsg(tool, toolArgs, error);
+    }
+    const scopeKey = this.getScopeKey(toolContext);
+    const currentRetries = await this.tracker.increment(scopeKey, tool.name);
+    if (currentRetries <= this.maxRetries) {
+      return this.createToolReflectionResponse(
+        tool,
+        toolArgs,
+        error,
+        currentRetries
+      );
+    }
+    if (this.throwExceptionIfRetryExceeded) {
+      throw this.ensureException(error);
+    } else {
+      return this.getToolRetryExceedMsg(tool, toolArgs, error);
+    }
+  }
+  /**
+   * Returns a unique key for the state tracker based on the configured scope.
+   *
+   * This method can be overridden in a subclass to implement custom scoping
+   * logic, for example tracking failures on a per-user or per-session basis.
+   *
+   * @param toolContext - The tool context.
+   * @returns The resolved scope key.
+   */
+  getScopeKey(toolContext) {
+    return resolveScopeKey(this.scope, toolContext.invocationId);
+  }
+  /**
+   * Atomically resets the failure count for a tool and cleans up state.
+   *
+   * @param toolContext - The tool context.
+   * @param toolName - The name of the tool.
+   */
+  async resetFailuresForTool(toolContext, toolName) {
+    const scopeKey = this.getScopeKey(toolContext);
+    await this.tracker.reset(scopeKey, toolName);
+  }
+  /**
+   * Ensures the given error is an Error instance, wrapping if not.
+   *
+   * @param error - The error object.
+   * @returns An Error instance.
+   */
+  ensureException(error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+  /**
+   * Formats error details for inclusion in the reflection message.
+   *
+   * @param error - The error object.
+   * @returns Formatted error string.
+   */
+  formatErrorDetails(error) {
+    if (error instanceof Error) {
+      const name = error.name || "Error";
+      return `${name}: ${error.message}`;
+    }
+    return String(error);
+  }
+  /**
+   * Generates structured reflection guidance for tool failures.
+   *
+   * @param tool - The tool that failed.
+   * @param toolArgs - The arguments supplied to the tool.
+   * @param error - The error encountered.
+   * @param retryCount - The current retry count.
+   * @returns The structured tool failure response record.
+   */
+  createToolReflectionResponse(tool, toolArgs, error, retryCount) {
+    const argsSummary = JSON.stringify(toolArgs != null ? toolArgs : {}, null, 2);
+    const errorDetails = this.formatErrorDetails(error);
+    const reflectionMessage = `
+The call to tool \`${tool.name}\` failed.
+
+**Error Details:**
+\`\`\`
+${errorDetails}
+\`\`\`
+
+**Tool Arguments Used:**
+\`\`\`json
+${argsSummary}
+\`\`\`
+
+**Reflection Guidance:**
+This is retry attempt **${retryCount} of ${this.maxRetries}**. Analyze the error and the arguments you provided. Do not repeat the exact same call. Consider the following before your next attempt:
+
+1.  **Invalid Parameters**: Does the error suggest that one or more arguments are incorrect, badly formatted, or missing? Review the tool's schema and your arguments.
+2.  **State or Preconditions**: Did a previous step fail or not produce the necessary state/resource for this tool to succeed?
+3.  **Alternative Approach**: Is this the right tool for the job? Could another tool or a different sequence of steps achieve the goal?
+4.  **Simplify the Task**: Can you break the problem down into smaller, simpler steps?
+5.  **Wrong Function Name**: Does the error indicates the tool is not found? Please check again and only use available tools.
+
+Formulate a new plan based on your analysis and try a corrected or different approach.
+`.trim();
+    const response = {
+      response_type: REFLECT_AND_RETRY_RESPONSE_TYPE,
+      error_type: error instanceof Error ? error.name || "Error" : "ToolError",
+      error_details: error instanceof Error ? error.message : String(error),
+      retry_count: retryCount,
+      reflection_guidance: reflectionMessage
+    };
+    return response;
+  }
+  /**
+   * Generates guidance when the maximum retry limit is exceeded.
+   *
+   * @param tool - The tool that failed.
+   * @param toolArgs - The arguments supplied to the tool.
+   * @param error - The error encountered.
+   * @returns The structured retry-exceeded failure response record.
+   */
+  getToolRetryExceedMsg(tool, toolArgs, error) {
+    const errorDetails = this.formatErrorDetails(error);
+    const argsSummary = JSON.stringify(toolArgs != null ? toolArgs : {}, null, 2);
+    const reflectionMessage = `
+The tool \`${tool.name}\` has failed consecutively ${this.maxRetries} times and the retry limit has been exceeded.
+
+**Last Error:**
+\`\`\`
+${errorDetails}
+\`\`\`
+
+**Last Arguments Used:**
+\`\`\`json
+${argsSummary}
+\`\`\`
+
+**Final Instruction:**
+**Do not attempt to use the \`${tool.name}\` tool again for this task.** You must now try a different approach. Acknowledge the failure and devise a new strategy, potentially using other available tools or informing the user that the task cannot be completed.
+`.trim();
+    const response = {
+      response_type: REFLECT_AND_RETRY_RESPONSE_TYPE,
+      error_type: error instanceof Error ? error.name || "Error" : "ToolError",
+      error_details: error instanceof Error ? error.message : String(error),
+      retry_count: this.maxRetries,
+      reflection_guidance: reflectionMessage
+    };
+    return response;
+  }
+};
+__name(_ReflectAndRetryToolPlugin, "ReflectAndRetryToolPlugin");
+let ReflectAndRetryToolPlugin = _ReflectAndRetryToolPlugin;
+export {
+  ReflectAndRetryToolPlugin
+};

package/dist/esm/runner/runner.js

@@ -12,7 +12,10 @@ import { createPartFromText, Modality } from "@google/genai";
 import { context, trace } from "@opentelemetry/api";
 import { isBaseAgent } from "../agents/base_agent.js";
 import { reservedFunctionCallName } from "../agents/framework_function_calls.js";
-import { findMatchingFunctionCall } from "../agents/functions.js";
+import {
+  findMatchingFunctionCall,
+  getConflictingFunctionResponseAuthors
+} from "../agents/functions.js";
 import {
   InvocationContext,
   newInvocationContextId,
@@ -21,6 +24,9 @@ import {
 import { isLlmAgent } from "../agents/llm_agent.js";
 import { createRunConfig } from "../agents/run_config.js";
 import { ScopedArtifactService } from "../artifacts/scoped_artifact_service.js";
+import {
+  isSessionArtifactService
+} from "../artifacts/session_artifact_service.js";
 import {
   BuiltInCodeExecutor,
   isBuiltInCodeExecutor
@@ -35,11 +41,12 @@ import {
 import { isBaseToolset } from "../tools/base_toolset.js";
 import { logger } from "../utils/logger.js";
 import { isGemini2OrAbove } from "../utils/model_name.js";
+import { stringifyWithRedactedInlineData } from "../utils/redact_inline_data.js";
 import {
   asRunnableRoot,
   runNodeAsInvocation
 } from "../workflow/run_node_as_invocation.js";
-const RUNNER_SIGNATURE_SYMBOL = Symbol.for("google.adk.runner");
+const RUNNER_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.runner");
 function isRunner(obj) {
   return typeof obj === "object" && obj !== null && RUNNER_SIGNATURE_SYMBOL in obj && obj[RUNNER_SIGNATURE_SYMBOL] === true;
 }
@@ -146,7 +153,9 @@ const _Runner = class _Runner {
                 `Session lookup failed: appName must be provided in runner constructor (or via app.name)`
               );
             }
-            throw new Error(`Session not found: ${sessionId}`);
+            throw new Error(
+              `Session not found: ${sessionId} (appName=${this.appName}, userId=${userId})`
+            );
           }
           if (runConfig.supportCfc && isLlmAgent(this.agent)) {
             const modelName = this.agent.canonicalModel.model;
@@ -160,7 +169,7 @@ const _Runner = class _Runner {
             }
           }
           const invocationContext = new InvocationContext({
-            artifactService: this.artifactService ? new ScopedArtifactService(
+            artifactService: this.artifactService ? isSessionArtifactService(this.artifactService) ? this.artifactService : new ScopedArtifactService(
               this.artifactService,
               this.appName,
               userId,
@@ -174,6 +183,7 @@ const _Runner = class _Runner {
             session,
             userContent: newMessage,
             runConfig,
+            a2aMetadata: runConfig.a2aMetadata,
             pluginManager: this.pluginManager,
             abortSignal: params.abortSignal
           });
@@ -193,9 +203,8 @@ const _Runner = class _Runner {
             }
             if (runConfig.saveInputBlobsAsArtifacts) {
               newMessage = await this.saveArtifacts(
+                invocationContext.artifactService,
                 invocationContext.invocationId,
-                session.userId,
-                session.id,
                 newMessage
               );
               if ((_d = params.abortSignal) == null ? void 0 : _d.aborted) {
@@ -308,21 +317,15 @@ const _Runner = class _Runner {
    * Saves artifacts from the message parts and replaces the inline data with
    * a file name placeholder and optional file reference.
    *
+   * @param artifactService The session-scoped artifact service to save to.
    * @param invocationId The current invocation ID.
-   * @param userId The user ID of the session.
-   * @param sessionId The session ID of the session.
    * @param message The message containing parts to process.
    */
-  async saveArtifacts(invocationId, userId, sessionId, message) {
+  async saveArtifacts(artifactService, invocationId, message) {
     var _a2;
-    if (!this.artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
+    if (!artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
       return message;
     }
-    const sessionKey = {
-      appName: this.appName,
-      userId,
-      sessionId
-    };
     const newParts = [];
     let modified = false;
     for (let i = 0; i < message.parts.length; i++) {
@@ -334,20 +337,16 @@ const _Runner = class _Runner {
       try {
         const inlineData = part.inlineData;
         const fileName = inlineData.displayName || `artifact_${invocationId}_${i}`;
-        const version = await this.artifactService.saveArtifact({
-          ...sessionKey,
+        const version = await artifactService.saveArtifact({
           filename: fileName,
           artifact: part
         });
         newParts.push(createPartFromText(`[Uploaded Artifact: "${fileName}"]`));
         try {
-          const artifactVersion = await this.artifactService.getArtifactVersion(
-            {
-              ...sessionKey,
-              filename: fileName,
-              version
-            }
-          );
+          const artifactVersion = await artifactService.getArtifactVersion({
+            filename: fileName,
+            version
+          });
           if ((artifactVersion == null ? void 0 : artifactVersion.canonicalUri) && /^(gs|https?):/i.test(artifactVersion.canonicalUri)) {
             newParts.push({
               fileData: {
@@ -397,7 +396,7 @@ const _Runner = class _Runner {
    * Whether the agent to run can transfer to any other agent in the agent tree.
    *
    * @param agentToRun The agent to check for transferability.
-   * @returns True if the agent can transfer, False otherwise.
+   * @returns True if the agent can transfer, false otherwise.
    */
   isRoutableLlmAgent(agentToRun) {
     return isRoutableLlmAgent(agentToRun);
@@ -460,7 +459,7 @@ const _Runner = class _Runner {
             return;
           }
           const invocationContext = new InvocationContext({
-            artifactService: this.artifactService ? new ScopedArtifactService(
+            artifactService: this.artifactService ? isSessionArtifactService(this.artifactService) ? this.artifactService : new ScopedArtifactService(
               this.artifactService,
               this.appName,
               params.userId,
@@ -473,6 +472,7 @@ const _Runner = class _Runner {
             agent,
             session,
             runConfig,
+            a2aMetadata: runConfig.a2aMetadata,
             pluginManager: this.pluginManager,
             liveRequestQueue: params.liveRequestQueue,
             abortSignal: params.abortSignal,
@@ -550,6 +550,14 @@ function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
   const event = findEventByLastFunctionResponseId(session.events);
   const isResumable = Boolean(resumabilityConfig == null ? void 0 : resumabilityConfig.isResumable);
   if (event && event.author && isResumable) {
+    const conflictingAuthors = getConflictingFunctionResponseAuthors(
+      session.events
+    );
+    if (conflictingAuthors) {
+      throw new Error(
+        `Function responses in the last event resolve to function calls from more than one agent (at least "${conflictingAuthors[0]}" and "${conflictingAuthors[1]}"); cannot determine a single agent to resume.`
+      );
+    }
     const resumedAgent = rootAgent.findAgent(event.author);
     if (resumedAgent) {
       return resumedAgent;
@@ -561,7 +569,7 @@ function determineAgentForResumption(session, rootAgent, resumabilityConfig) {
     }
   }
   for (let i = session.events.length - 1; i >= 0; i--) {
-    logger.debug("event:", JSON.stringify(session.events[i]));
+    logger.debug("event:", stringifyWithRedactedInlineData(session.events[i]));
     const event2 = session.events[i];
     if (event2.author === "user" || !event2.author) {
       continue;