@google/adk 2.0.0 → 2.2.0

package/dist/cjs/plugins/_reflect_retry_utils.js

@@ -0,0 +1,142 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reflect_retry_utils_exports = {};
+__export(reflect_retry_utils_exports, {
+  GLOBAL_SCOPE_KEY: () => GLOBAL_SCOPE_KEY,
+  REFLECT_AND_RETRY_RESPONSE_TYPE: () => REFLECT_AND_RETRY_RESPONSE_TYPE,
+  ScopedFailureTracker: () => ScopedFailureTracker,
+  TrackingScope: () => TrackingScope,
+  resolveScopeKey: () => resolveScopeKey
+});
+module.exports = __toCommonJS(reflect_retry_utils_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const REFLECT_AND_RETRY_RESPONSE_TYPE = "ERROR_HANDLED_BY_REFLECT_AND_RETRY_PLUGIN";
+const GLOBAL_SCOPE_KEY = "__global_reflect_and_retry_scope__";
+var TrackingScope = /* @__PURE__ */ ((TrackingScope2) => {
+  TrackingScope2["INVOCATION"] = "invocation";
+  TrackingScope2["GLOBAL"] = "global";
+  return TrackingScope2;
+})(TrackingScope || {});
+function resolveScopeKey(scope, invocationId) {
+  if (scope === "invocation" /* INVOCATION */) {
+    if (!invocationId) {
+      throw new Error("invocation_id must be provided for INVOCATION scope");
+    }
+    return invocationId;
+  } else if (scope === "global" /* GLOBAL */) {
+    return GLOBAL_SCOPE_KEY;
+  }
+  throw new Error(`Unknown scope: ${scope}`);
+}
+__name(resolveScopeKey, "resolveScopeKey");
+const _ScopedFailureTracker = class _ScopedFailureTracker {
+  constructor() {
+    this.scopedFailureCounters = /* @__PURE__ */ new Map();
+    this.lockPromise = Promise.resolve();
+  }
+  async acquireLock() {
+    let release;
+    const nextLock = new Promise((resolve) => {
+      release = resolve;
+    });
+    const currentLock = this.lockPromise;
+    this.lockPromise = this.lockPromise.then(() => nextLock);
+    await currentLock;
+    return release;
+  }
+  /**
+   * Atomically increments and returns the failure count for an item.
+   *
+   * @param scopeKey - The scope identifier (e.g. invocation ID or global key).
+   * @param itemName - The name of the tool or model.
+   * @returns The updated failure count.
+   */
+  async increment(scopeKey, itemName) {
+    var _a;
+    const release = await this.acquireLock();
+    try {
+      let counter = this.scopedFailureCounters.get(scopeKey);
+      if (!counter) {
+        counter = /* @__PURE__ */ new Map();
+        this.scopedFailureCounters.set(scopeKey, counter);
+      }
+      const current = ((_a = counter.get(itemName)) != null ? _a : 0) + 1;
+      counter.set(itemName, current);
+      return current;
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Atomically resets the failure count for an item and cleans up state.
+   *
+   * @param scopeKey - The scope identifier.
+   * @param itemName - The name of the tool or model.
+   */
+  async reset(scopeKey, itemName) {
+    const release = await this.acquireLock();
+    try {
+      const counter = this.scopedFailureCounters.get(scopeKey);
+      if (counter) {
+        counter.delete(itemName);
+        if (counter.size === 0) {
+          this.scopedFailureCounters.delete(scopeKey);
+        }
+      }
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Gets the current failure count for an item.
+   *
+   * @param scopeKey - The scope identifier.
+   * @param itemName - The name of the tool or model.
+   */
+  async getCount(scopeKey, itemName) {
+    var _a, _b;
+    const release = await this.acquireLock();
+    try {
+      return (_b = (_a = this.scopedFailureCounters.get(scopeKey)) == null ? void 0 : _a.get(itemName)) != null ? _b : 0;
+    } finally {
+      release();
+    }
+  }
+};
+__name(_ScopedFailureTracker, "ScopedFailureTracker");
+let ScopedFailureTracker = _ScopedFailureTracker;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLOBAL_SCOPE_KEY,
+  REFLECT_AND_RETRY_RESPONSE_TYPE,
+  ScopedFailureTracker,
+  TrackingScope,
+  resolveScopeKey
+});

package/dist/cjs/plugins/base_plugin.js

@@ -65,14 +65,13 @@ const _BasePlugin = class _BasePlugin {
    * This callback helps logging and modifying the user message before the
    * runner starts the invocation.
    *
-   * @param params.invocationContext The context for the entire invocation.
-   * @param params.userMessage The message content input by user.
+   * @param _params.invocationContext The context for the entire invocation.
+   * @param _params.userMessage The message content input by user.
    * @returns An optional `Content` to be returned to the ADK. Returning a
    *     value to replace the user message. Returning `undefined` to proceed
    *     normally.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async onUserMessageCallback(params) {
+  async onUserMessageCallback(_params) {
     return;
   }
   /**
@@ -81,14 +80,13 @@ const _BasePlugin = class _BasePlugin {
    * This is the first callback to be called in the lifecycle, ideal for global
    * setup or initialization tasks.
    *
-   * @param params.invocationContext The context for the entire invocation, containing
+   * @param _params.invocationContext The context for the entire invocation, containing
    *     session information, the root agent, etc.
    * @returns An optional `Event` to be returned to the ADK. Returning a value
    *     to halt execution of the runner and ends the runner with that event.
    *     Return `undefined` to proceed normally.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async beforeRunCallback(params) {
+  async beforeRunCallback(_params) {
     return;
   }
   /**
@@ -97,16 +95,15 @@ const _BasePlugin = class _BasePlugin {
    * This is the ideal place to make modification to the event before the event
    * is handled by the underlying agent app.
    *
-   * @param params.invocationContext The context for the entire invocation.
-   * @param params.event The event raised by the runner.
+   * @param _params.invocationContext The context for the entire invocation.
+   * @param _params.event The event raised by the runner.
    * @returns An optional value. A non-`undefined` return may be used by the
-   *     framework to modify or replace the response. Copy `params.event` when
-   *     constructing a replacement to preserve fields that are not being
-   *     modified, such as event actions. Returning `undefined` allows the
+   *     framework to modify or replace the response. Copy the incoming
+   *     `event` when constructing a replacement to preserve fields that are not
+   *     being modified, such as event actions. Returning `undefined` allows the
    *     original response to be used.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async onEventCallback(params) {
+  async onEventCallback(_params) {
     return;
   }
   /**
@@ -115,11 +112,10 @@ const _BasePlugin = class _BasePlugin {
    * This is the final callback in the ADK lifecycle, suitable for cleanup,
    * final logging, or reporting tasks.
    *
-   * @param params.invocationContext The context for the entire invocation.
+   * @param _params.invocationContext The context for the entire invocation.
    * @returns undefined
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async afterRunCallback(params) {
+  async afterRunCallback(_params) {
     return;
   }
   /**
@@ -128,14 +124,13 @@ const _BasePlugin = class _BasePlugin {
    * This callback can be used for logging, setup, or to short-circuit the
    * agent's execution by returning a value.
    *
-   * @param params.agent The agent that is about to run.
-   * @param params.callbackContext The context for the agent invocation.
+   * @param _params.agent The agent that is about to run.
+   * @param _params.callbackContext The context for the agent invocation.
    * @returns An optional `Content` object. If a value is returned, it will
    *     bypass the agent's callbacks and its execution, and return this value
    *     directly. Returning `undefined` allows the agent to proceed normally.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async beforeAgentCallback(params) {
+  async beforeAgentCallback(_params) {
     return;
   }
   /**
@@ -144,14 +139,13 @@ const _BasePlugin = class _BasePlugin {
    * This callback can be used to inspect, log, or modify the agent's final
    * result before it is returned.
    *
-   * @param params.agent The agent that has just run.
-   * @param params.callbackContext The context for the agent invocation.
+   * @param _params.agent The agent that has just run.
+   * @param _params.callbackContext The context for the agent invocation.
    * @returns An optional `Content` object. If a value is returned, it will
    *     replace the agent's original result. Returning `undefined` uses the
    *     original, unmodified result.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async afterAgentCallback(params) {
+  async afterAgentCallback(_params) {
     return;
   }
   /**
@@ -192,14 +186,13 @@ const _BasePlugin = class _BasePlugin {
    * object. It can also be used to implement caching by returning a cached
    * `LlmResponse`, which would skip the actual model call.
    *
-   * @param params.callbackContext The context for the current agent call.
-   * @param params.llmRequest The prepared request object to be sent to the model.
+   * @param _params.callbackContext The context for the current agent call.
+   * @param _params.llmRequest The prepared request object to be sent to the model.
    * @returns An optional value. The interpretation of a non-`undefined`
    *     trigger an early exit and returns the response immediately. Returning
    *     `undefined` allows the LLM request to proceed normally.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async beforeModelCallback(params) {
+  async beforeModelCallback(_params) {
     return;
   }
   /**
@@ -208,14 +201,13 @@ const _BasePlugin = class _BasePlugin {
    * This is the ideal place to log model responses, collect metrics on token
    * usage, or perform post-processing on the raw `LlmResponse`.
    *
-   * @param params.callbackContext The context for the current agent call.
-   * @param params.llmResponse The response object received from the model.
+   * @param _params.callbackContext The context for the current agent call.
+   * @param _params.llmResponse The response object received from the model.
    * @returns An optional value. A non-`undefined` return may be used by the
    *     framework to modify or replace the response. Returning `undefined`
    *     allows the original response to be used.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async afterModelCallback(params) {
+  async afterModelCallback(_params) {
     return;
   }
   /**
@@ -224,28 +216,24 @@ const _BasePlugin = class _BasePlugin {
    * This callback provides an opportunity to handle model errors gracefully,
    * potentially providing alternative responses or recovery mechanisms.
    *
-   * @param params.callbackContext The context for the current agent call.
-   * @param params.llmRequest The request that was sent to the model when the error
+   * @param _params.callbackContext The context for the current agent call.
+   * @param _params.llmRequest The request that was sent to the model when the error
    *     occurred.
-   * @param params.error The exception that was raised during model execution.
+   * @param _params.error The exception that was raised during model execution.
    * @returns An optional LlmResponse. If an LlmResponse is returned, it will be
    *     used instead of propagating the error. Returning `undefined` allows
    *     the original error to be raised.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async onModelErrorCallback(params) {
+  async onModelErrorCallback(_params) {
     return;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async beforeToolSelection(params) {
+  async beforeToolSelection(_params) {
     return;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async beforeContextCompaction(params) {
+  async beforeContextCompaction(_params) {
     return;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async afterContextCompaction(params) {
+  async afterContextCompaction(_params) {
     return;
   }
   /**
@@ -254,16 +242,15 @@ const _BasePlugin = class _BasePlugin {
    * This callback is useful for logging tool usage, input validation, or
    * modifying the arguments before they are passed to the tool.
    *
-   * @param params.tool The tool instance that is about to be executed.
-   * @param params.toolArgs The dictionary of arguments to be used for invoking the
+   * @param _params.tool The tool instance that is about to be executed.
+   * @param _params.toolArgs The dictionary of arguments to be used for invoking the
    *     tool.
-   * @param params.toolContext The context specific to the tool execution.
+   * @param _params.toolContext The context specific to the tool execution.
    * @returns An optional dictionary. If a dictionary is returned, it will stop
    *     the tool execution and return this response immediately. Returning
    *     `undefined` uses the original, unmodified arguments.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async beforeToolCallback(params) {
+  async beforeToolCallback(_params) {
     return;
   }
   /**
@@ -272,17 +259,16 @@ const _BasePlugin = class _BasePlugin {
    * This callback allows for inspecting, logging, or modifying the result
    * returned by a tool.
    *
-   * @param params.tool The tool instance that has just been executed.
-   * @param params.toolArgs The original arguments that were passed to the tool.
-   * @param params.toolContext The context specific to the tool execution.
-   * @param params.result The dictionary returned by the tool invocation.
+   * @param _params.tool The tool instance that has just been executed.
+   * @param _params.toolArgs The original arguments that were passed to the tool.
+   * @param _params.toolContext The context specific to the tool execution.
+   * @param _params.result The dictionary returned by the tool invocation.
    * @returns An optional dictionary. If a dictionary is returned, it will
    *     **replace** the original result from the tool. This allows for
    *     post-processing or altering tool outputs. Returning `undefined` uses
    *     the original, unmodified result.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async afterToolCallback(params) {
+  async afterToolCallback(_params) {
     return;
   }
   /**
@@ -301,16 +287,15 @@ const _BasePlugin = class _BasePlugin {
      * This callback provides an opportunity to handle tool errors gracefully,
      * potentially providing alternative responses or recovery mechanisms.
      *
-     * @param params.tool The tool instance that encountered an error.
-     * @param params.toolArgs The arguments that were passed to the tool.
-     * @param params.toolContext The context specific to the tool execution.
-     * @param params.error The exception that was raised during tool execution.
+     * @param _params.tool The tool instance that encountered an error.
+     * @param _params.toolArgs The arguments that were passed to the tool.
+     * @param _params.toolContext The context specific to the tool execution.
+     * @param _params.error The exception that was raised during tool execution.
      * @returns An optional dictionary. If a dictionary is returned, it will be
      *     used as the tool response instead of propagating the error. Returning
      *     `undefined` allows the original error to be raised.
      */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async onToolErrorCallback(params) {
+  async onToolErrorCallback(_params) {
     return;
   }
 };

package/dist/cjs/plugins/reflect_retry_model_plugin.js

@@ -0,0 +1,274 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reflect_retry_model_plugin_exports = {};
+__export(reflect_retry_model_plugin_exports, {
+  ADK_HANDLE_MODEL_ERROR_TOOL_NAME: () => ADK_HANDLE_MODEL_ERROR_TOOL_NAME,
+  RESERVED_TOOL_CALL_ERROR_TYPE: () => RESERVED_TOOL_CALL_ERROR_TYPE,
+  ReflectAndRetryModelPlugin: () => ReflectAndRetryModelPlugin
+});
+module.exports = __toCommonJS(reflect_retry_model_plugin_exports);
+var import_genai = require("@google/genai");
+var import_uuid = require("uuid");
+var import_function_tool = require("../tools/function_tool.js");
+var import_reflect_retry_utils = require("./_reflect_retry_utils.js");
+var import_base_plugin = require("./base_plugin.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 import_base_plugin.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 : import_reflect_retry_utils.TrackingScope.INVOCATION;
+    this.onModelErrors = (_e = options.onModelErrors) != null ? _e : [
+      import_genai.FinishReason.MALFORMED_FUNCTION_CALL
+    ];
+    this.tracker = new import_reflect_retry_utils.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 import_function_tool.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.`,
+      import_genai.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 : import_genai.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: import_reflect_retry_utils.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}_${(0, import_uuid.v4)()}`;
+  }
+  /**
+   * Returns the scope key for model failure tracking.
+   */
+  getModelScopeKey(callbackContext) {
+    return (0, import_reflect_retry_utils.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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADK_HANDLE_MODEL_ERROR_TOOL_NAME,
+  RESERVED_TOOL_CALL_ERROR_TYPE,
+  ReflectAndRetryModelPlugin
+});