@google/adk 2.0.0 → 2.1.0

package/dist/esm/models/google_llm.js

@@ -21,7 +21,7 @@ import { BaseLlm } from "./base_llm.js";
 import { GeminiLlmConnection } from "./gemini_llm_connection.js";
 import { generateContentViaInteractions } from "./interactions_utils.js";
 import { createLlmResponse } from "./llm_response.js";
-const GEMINI_MODEL_SYMBOL = Symbol.for("google.adk.geminiModel");
+const GEMINI_MODEL_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.geminiModel");
 function isGemini(obj) {
   return typeof obj === "object" && obj !== null && GEMINI_MODEL_SYMBOL in obj && obj[GEMINI_MODEL_SYMBOL] === true;
 }
@@ -66,9 +66,14 @@ const _Gemini = class _Gemini extends (_b = BaseLlm, _a = GEMINI_MODEL_SYMBOL, _
   /**
    * Sends a request to the Gemini model.
    *
-   * @param llmRequest LlmRequest, the request to send to the Gemini model.
-   * @param stream bool = false, whether to do streaming call.
-   * @yields LlmResponse: The model response.
+   * @param llmRequest The request to send to the Gemini model.
+   * @param stream Whether to make a streaming call. Defaults to `false`.
+   * @yields Each {@link LlmResponse} produced by the model. A non-streaming
+   *     call yields exactly one; a streaming call yields the partial responses
+   *     as they arrive, then a final aggregated response whenever the stream
+   *     carried either content or usage/grounding/citation metadata. A
+   *     metadata-only stream therefore still ends with one, holding the
+   *     metadata and no `content`; only a stream with neither ends silently.
    */
   async *generateContentAsync(llmRequest, stream = false, abortSignal) {
     var _a2, _b2, _c;

package/dist/esm/models/interactions_utils.js

@@ -662,13 +662,12 @@ async function* generateContentViaInteractions(apiClient, llmRequest, stream) {
     });
     const aggregatedParts = [];
     for await (const event of responses) {
-      const sseEvent = event;
-      const interactionId = extractStreamInteractionId(sseEvent);
+      const interactionId = extractStreamInteractionId(event);
       if (interactionId) {
         currentInteractionId = interactionId;
       }
       const llmResponse = convertInteractionEventToLlmResponse(
-        sseEvent,
+        event,
         aggregatedParts,
         currentInteractionId
       );

package/dist/esm/models/registry.js

@@ -9,6 +9,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { logger } from "../utils/logger.js";
 import { ApigeeLlm } from "./apigee_llm.js";
+import { ChromeBuiltInLlm } from "./chrome_prompt_llm.js";
 import { Gemini } from "./google_llm.js";
 const _LRUCache = class _LRUCache {
   constructor(maxSize) {
@@ -95,6 +96,7 @@ _LLMRegistry.resolveCache = new LRUCache(32);
 let LLMRegistry = _LLMRegistry;
 LLMRegistry.register(Gemini);
 LLMRegistry.register(ApigeeLlm);
+LLMRegistry.register(ChromeBuiltInLlm);
 export {
   LLMRegistry
 };

package/dist/esm/plugins/_reflect_retry_utils.js

@@ -0,0 +1,111 @@
+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
+ */
+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;
+export {
+  GLOBAL_SCOPE_KEY,
+  REFLECT_AND_RETRY_RESPONSE_TYPE,
+  ScopedFailureTracker,
+  TrackingScope,
+  resolveScopeKey
+};

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
+};