@google/adk 1.6.0 → 2.1.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/plugins/security_plugin.js

@@ -1,12 +1,14 @@
 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 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { REQUEST_CONFIRMATION_FUNCTION_CALL_NAME } from "../agents/functions.js";
 import { BasePlugin } from "../plugins/base_plugin.js";
-const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
 const TOOL_CALL_SECURITY_CHECK_STATES = "orcas_tool_call_security_check_states";
 const INTERMEDIATE_REQUIRE_TOOL_CALL_CONFIRMATION_ERROR = "This tool call needs external confirmation before completion.";
 var PolicyOutcome = /* @__PURE__ */ ((PolicyOutcome2) => {
@@ -15,20 +17,23 @@ var PolicyOutcome = /* @__PURE__ */ ((PolicyOutcome2) => {
   PolicyOutcome2["ALLOW"] = "ALLOW";
   return PolicyOutcome2;
 })(PolicyOutcome || {});
-class InMemoryPolicyEngine {
+const _InMemoryPolicyEngine = class _InMemoryPolicyEngine {
   /**
    * Always returns {@link PolicyOutcome.ALLOW} for every tool call.
    *
+   * @param _context - The tool and its arguments; ignored.
    * @returns A promise resolving to an ALLOW result.
    */
-  async evaluate() {
+  async evaluate(_context) {
     return Promise.resolve({
       outcome: "ALLOW" /* ALLOW */,
       reason: "For prototyping purpose, all tool calls are allowed."
     });
   }
-}
-class SecurityPlugin extends BasePlugin {
+};
+__name(_InMemoryPolicyEngine, "InMemoryPolicyEngine");
+let InMemoryPolicyEngine = _InMemoryPolicyEngine;
+const _SecurityPlugin = class _SecurityPlugin extends BasePlugin {
   /**
    * @param params - Optional configuration. Defaults to {@link InMemoryPolicyEngine}
    *   when no policy engine is provided.
@@ -118,7 +123,9 @@ class SecurityPlugin extends BasePlugin {
         return;
     }
   }
-}
+};
+__name(_SecurityPlugin, "SecurityPlugin");
+let SecurityPlugin = _SecurityPlugin;
 function getAskUserConfirmationFunctionCalls(event) {
   if (!event.content || !event.content.parts) {
     return [];
@@ -131,6 +138,7 @@ function getAskUserConfirmationFunctionCalls(event) {
   }
   return results;
 }
+__name(getAskUserConfirmationFunctionCalls, "getAskUserConfirmationFunctionCalls");
 export {
   InMemoryPolicyEngine,
   PolicyOutcome,

package/dist/esm/runner/in_memory_runner.js

@@ -1,5 +1,7 @@
 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 2025 Google LLC
@@ -9,7 +11,7 @@ import { InMemoryArtifactService } from "../artifacts/in_memory_artifact_service
 import { InMemoryMemoryService } from "../memory/in_memory_memory_service.js";
 import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
 import { Runner } from "./runner.js";
-class InMemoryRunner extends Runner {
+const _InMemoryRunner = class _InMemoryRunner extends Runner {
   /**
    * Creates a new InMemoryRunner instance.
    *
@@ -40,7 +42,9 @@ class InMemoryRunner extends Runner {
       resumabilityConfig: (_a = app == null ? void 0 : app.resumabilityConfig) != null ? _a : resumabilityConfig
     });
   }
-}
+};
+__name(_InMemoryRunner, "InMemoryRunner");
+let InMemoryRunner = _InMemoryRunner;
 export {
   InMemoryRunner
 };