@google/gemini-cli-a2a-server 0.15.0-preview.3 → 0.16.0-nightly.20251113.ad1f0d99

package/dist/a2a-server.mjs

@@ -293122,16 +293122,14 @@ var CodeAssistServer = class {
       });
       let bufferedLines = [];
       for await (const line of rl) {
-        if (line === "") {
+        if (line.startsWith("data: ")) {
+          bufferedLines.push(line.slice(6).trim());
+        } else if (line === "") {
           if (bufferedLines.length === 0) {
             continue;
           }
           yield JSON.parse(bufferedLines.join("\n"));
           bufferedLines = [];
-        } else if (line.startsWith("data: ")) {
-          bufferedLines.push(line.slice(6).trim());
-        } else {
-          throw new Error(`Unexpected line format in response: ${line}`);
         }
       }
     }();
@@ -293643,7 +293641,7 @@ function hasCycleInSchema(schema) {
     }
     if ("$ref" in node && typeof node.$ref === "string") {
       const ref = node.$ref;
-      if (ref === "#/" || pathRefs.has(ref)) {
+      if (ref === "#" || ref === "#/" || pathRefs.has(ref)) {
         return true;
       }
       if (visitedRefs.has(ref)) {
@@ -295263,23 +295261,29 @@ var LoopDetectedEvent = class {
   "event.timestamp";
   loop_type;
   prompt_id;
-  constructor(loop_type, prompt_id) {
+  confirmed_by_model;
+  constructor(loop_type, prompt_id, confirmed_by_model) {
     this["event.name"] = "loop_detected";
     this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
     this.loop_type = loop_type;
     this.prompt_id = prompt_id;
+    this.confirmed_by_model = confirmed_by_model;
   }
   toOpenTelemetryAttributes(config2) {
-    return {
+    const attributes = {
       ...getCommonAttributes(config2),
       "event.name": this["event.name"],
       "event.timestamp": this["event.timestamp"],
       loop_type: this.loop_type,
       prompt_id: this.prompt_id
     };
+    if (this.confirmed_by_model) {
+      attributes["confirmed_by_model"] = this.confirmed_by_model;
+    }
+    return attributes;
   }
   toLogBody() {
-    return `Loop detected. Type: ${this.loop_type}.`;
+    return `Loop detected. Type: ${this.loop_type}.${this.confirmed_by_model ? ` Confirmed by: ${this.confirmed_by_model}` : ""}`;
   }
 };
 var LoopDetectionDisabledEvent = class {
@@ -295569,6 +295573,37 @@ var ToolOutputTruncatedEvent = class {
     return `Tool output truncated for ${this.tool_name}.`;
   }
 };
+var EVENT_LLM_LOOP_CHECK = "gemini_cli.llm_loop_check";
+var LlmLoopCheckEvent = class {
+  "event.name";
+  "event.timestamp";
+  prompt_id;
+  flash_confidence;
+  main_model;
+  main_model_confidence;
+  constructor(prompt_id, flash_confidence, main_model, main_model_confidence) {
+    this["event.name"] = "llm_loop_check";
+    this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
+    this.prompt_id = prompt_id;
+    this.flash_confidence = flash_confidence;
+    this.main_model = main_model;
+    this.main_model_confidence = main_model_confidence;
+  }
+  toOpenTelemetryAttributes(config2) {
+    return {
+      ...getCommonAttributes(config2),
+      "event.name": EVENT_LLM_LOOP_CHECK,
+      "event.timestamp": this["event.timestamp"],
+      prompt_id: this.prompt_id,
+      flash_confidence: this.flash_confidence,
+      main_model: this.main_model,
+      main_model_confidence: this.main_model_confidence
+    };
+  }
+  toLogBody() {
+    return this.main_model_confidence === -1 ? `LLM loop check. Flash confidence: ${this.flash_confidence.toFixed(2)}. Main model (${this.main_model}) check skipped` : `LLM loop check. Flash confidence: ${this.flash_confidence.toFixed(2)}. Main model (${this.main_model}) confidence: ${this.main_model_confidence.toFixed(2)}`;
+  }
+};
 var EVENT_SMART_EDIT_STRATEGY = "gemini_cli.smart_edit_strategy";
 var SmartEditStrategyEvent = class {
   "event.name";
@@ -295874,6 +295909,10 @@ var EventMetadataKey;
   EventMetadataKey2[EventMetadataKey2["GEMINI_CLI_AGENT_RECOVERY_DURATION_MS"] = 123] = "GEMINI_CLI_AGENT_RECOVERY_DURATION_MS";
   EventMetadataKey2[EventMetadataKey2["GEMINI_CLI_AGENT_RECOVERY_SUCCESS"] = 124] = "GEMINI_CLI_AGENT_RECOVERY_SUCCESS";
   EventMetadataKey2[EventMetadataKey2["GEMINI_CLI_INTERACTIVE"] = 125] = "GEMINI_CLI_INTERACTIVE";
+  EventMetadataKey2[EventMetadataKey2["GEMINI_CLI_LLM_LOOP_CHECK_FLASH_CONFIDENCE"] = 126] = "GEMINI_CLI_LLM_LOOP_CHECK_FLASH_CONFIDENCE";
+  EventMetadataKey2[EventMetadataKey2["GEMINI_CLI_LLM_LOOP_CHECK_MAIN_MODEL"] = 127] = "GEMINI_CLI_LLM_LOOP_CHECK_MAIN_MODEL";
+  EventMetadataKey2[EventMetadataKey2["GEMINI_CLI_LLM_LOOP_CHECK_MAIN_MODEL_CONFIDENCE"] = 128] = "GEMINI_CLI_LLM_LOOP_CHECK_MAIN_MODEL_CONFIDENCE";
+  EventMetadataKey2[EventMetadataKey2["GEMINI_CLI_LOOP_DETECTED_CONFIRMED_BY_MODEL"] = 129] = "GEMINI_CLI_LOOP_DETECTED_CONFIRMED_BY_MODEL";
 })(EventMetadataKey || (EventMetadataKey = {}));
 
 // node_modules/mnemonist/index.mjs
@@ -295899,8 +295938,8 @@ var Float64Vector = import_vector.default.Float64Vector;
 var PointerVector = import_vector.default.PointerVector;
 
 // packages/core/dist/src/generated/git-commit.js
-var GIT_COMMIT_INFO = "605d9167";
-var CLI_VERSION = "0.15.0-preview.3";
+var GIT_COMMIT_INFO = "ad1f0d99";
+var CLI_VERSION = "0.16.0-nightly.20251113.ad1f0d99";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {
@@ -296003,6 +296042,7 @@ var EventNames;
   EventNames2["AGENT_FINISH"] = "agent_finish";
   EventNames2["RECOVERY_ATTEMPT"] = "recovery_attempt";
   EventNames2["WEB_FETCH_FALLBACK_ATTEMPT"] = "web_fetch_fallback_attempt";
+  EventNames2["LLM_LOOP_CHECK"] = "llm_loop_check";
 })(EventNames || (EventNames = {}));
 function determineSurface() {
   if (process.env["SURFACE"]) {
@@ -296494,6 +296534,12 @@ var ClearcutLogger = class _ClearcutLogger {
         value: JSON.stringify(event.loop_type)
       }
     ];
+    if (event.confirmed_by_model) {
+      data.push({
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_LOOP_DETECTED_CONFIRMED_BY_MODEL,
+        value: event.confirmed_by_model
+      });
+    }
     this.enqueueLogEvent(this.createLogEvent(EventNames.LOOP_DETECTED, data));
     this.flushIfNeeded();
   }
@@ -296929,6 +296975,28 @@ var ClearcutLogger = class _ClearcutLogger {
     this.enqueueLogEvent(this.createLogEvent(EventNames.WEB_FETCH_FALLBACK_ATTEMPT, data));
     this.flushIfNeeded();
   }
+  logLlmLoopCheckEvent(event) {
+    const data = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
+        value: event.prompt_id
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_LLM_LOOP_CHECK_FLASH_CONFIDENCE,
+        value: event.flash_confidence.toString()
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_LLM_LOOP_CHECK_MAIN_MODEL,
+        value: event.main_model
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_LLM_LOOP_CHECK_MAIN_MODEL_CONFIDENCE,
+        value: event.main_model_confidence.toString()
+      }
+    ];
+    this.enqueueLogEvent(this.createLogEvent(EventNames.LLM_LOOP_CHECK, data));
+    this.flushIfNeeded();
+  }
   /**
    * Adds default fields to data, and returns a new data array.  This fields
    * should exist on all log events.
@@ -298363,6 +298431,17 @@ function logWebFetchFallbackAttempt(config2, event) {
   };
   logger6.emit(logRecord);
 }
+function logLlmLoopCheck(config2, event) {
+  ClearcutLogger.getInstance(config2)?.logLlmLoopCheckEvent(event);
+  if (!isTelemetrySdkInitialized())
+    return;
+  const logger6 = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logRecord = {
+    body: event.toLogBody(),
+    attributes: event.toOpenTelemetryAttributes(config2)
+  };
+  logger6.emit(logRecord);
+}
 
 // packages/core/dist/src/utils/quotaErrorDetection.js
 function isApiError(error) {
@@ -298705,7 +298784,7 @@ async function createContentGenerator(config2, gcConfig, sessionId2) {
     if (gcConfig.fakeResponses) {
       return FakeContentGenerator.fromFile(gcConfig.fakeResponses);
     }
-    const version3 = "0.15.0-preview.3";
+    const version3 = "0.16.0-nightly.20251113.ad1f0d99";
     const userAgent = `GeminiCLI/${version3} (${process.platform}; ${process.arch})`;
     const baseHeaders = {
       "User-Agent": userAgent
@@ -300911,7 +300990,7 @@ var MemoryToolInvocation = class _MemoryToolInvocation extends BaseToolInvocatio
 var MemoryTool = class _MemoryTool extends BaseDeclarativeTool {
   static Name = MEMORY_TOOL_NAME;
   constructor(messageBus) {
-    super(_MemoryTool.Name, "Save Memory", memoryToolDescription, Kind.Think, memoryToolSchemaData.parametersJsonSchema, true, false, messageBus);
+    super(_MemoryTool.Name, "SaveMemory", memoryToolDescription, Kind.Think, memoryToolSchemaData.parametersJsonSchema, true, false, messageBus);
   }
   validateToolParamValues(params) {
     if (params.fact.trim() === "") {
@@ -320614,83 +320693,61 @@ async function ensureRgPath() {
   }
   throw new Error("Cannot use ripgrep.");
 }
+function resolveAndValidatePath(config2, relativePath) {
+  if (!relativePath) {
+    return null;
+  }
+  const targetDir = config2.getTargetDir();
+  const targetPath = path33.resolve(targetDir, relativePath);
+  const workspaceContext = config2.getWorkspaceContext();
+  if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
+    const directories = workspaceContext.getDirectories();
+    throw new Error(`Path validation failed: Attempted path "${relativePath}" resolves outside the allowed workspace directories: ${directories.join(", ")}`);
+  }
+  try {
+    const stats = fs31.statSync(targetPath);
+    if (!stats.isDirectory() && !stats.isFile()) {
+      throw new Error(`Path is not a valid directory or file: ${targetPath} (CWD: ${targetDir})`);
+    }
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      throw new Error(`Path does not exist: ${targetPath} (CWD: ${targetDir})`);
+    }
+    throw new Error(`Failed to access path stats for ${targetPath}: ${error}`);
+  }
+  return targetPath;
+}
 var GrepToolInvocation2 = class extends BaseToolInvocation {
   config;
   constructor(config2, params, messageBus, _toolName, _toolDisplayName) {
     super(params, messageBus, _toolName, _toolDisplayName);
     this.config = config2;
   }
-  /**
-   * Checks if a path is within the root directory and resolves it.
-   * @param relativePath Path relative to the root directory (or undefined for root).
-   * @returns The absolute path if valid and exists, or null if no path specified (to search all directories).
-   * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
-   */
-  resolveAndValidatePath(relativePath) {
-    if (!relativePath) {
-      return null;
-    }
-    const targetPath = path33.resolve(this.config.getTargetDir(), relativePath);
-    const workspaceContext = this.config.getWorkspaceContext();
-    if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
-      const directories = workspaceContext.getDirectories();
-      throw new Error(`Path validation failed: Attempted path "${relativePath}" resolves outside the allowed workspace directories: ${directories.join(", ")}`);
-    }
-    try {
-      const stats = fs31.statSync(targetPath);
-      if (!stats.isDirectory()) {
-        throw new Error(`Path is not a directory: ${targetPath}`);
-      }
-    } catch (error) {
-      if (isNodeError(error) && error.code !== "ENOENT") {
-        throw new Error(`Path does not exist: ${targetPath}`);
-      }
-      throw new Error(`Failed to access path stats for ${targetPath}: ${error}`);
-    }
-    return targetPath;
-  }
   async execute(signal) {
     try {
-      const workspaceContext = this.config.getWorkspaceContext();
-      const searchDirAbs = this.resolveAndValidatePath(this.params.dir_path);
-      const searchDirDisplay = this.params.dir_path || ".";
-      let searchDirectories;
-      if (searchDirAbs === null) {
-        searchDirectories = workspaceContext.getDirectories();
-      } else {
-        searchDirectories = [searchDirAbs];
-      }
-      let allMatches = [];
+      const pathParam = this.params.dir_path || ".";
+      const searchDirAbs = resolveAndValidatePath(this.config, pathParam);
+      const searchDirDisplay = pathParam;
       const totalMaxMatches = DEFAULT_TOTAL_MAX_MATCHES;
       if (this.config.getDebugMode()) {
         debugLogger.log(`[GrepTool] Total result limit: ${totalMaxMatches}`);
       }
-      for (const searchDir of searchDirectories) {
-        const searchResult = await this.performRipgrepSearch({
-          pattern: this.params.pattern,
-          path: searchDir,
-          include: this.params.include,
-          signal
-        });
-        if (searchDirectories.length > 1) {
-          const dirName = path33.basename(searchDir);
-          searchResult.forEach((match2) => {
-            match2.filePath = path33.join(dirName, match2.filePath);
-          });
-        }
-        allMatches = allMatches.concat(searchResult);
-        if (allMatches.length >= totalMaxMatches) {
-          allMatches = allMatches.slice(0, totalMaxMatches);
-          break;
-        }
-      }
-      let searchLocationDescription;
-      if (searchDirAbs === null) {
-        const numDirs = workspaceContext.getDirectories().length;
-        searchLocationDescription = numDirs > 1 ? `across ${numDirs} workspace directories` : `in the workspace directory`;
-      } else {
-        searchLocationDescription = `in path "${searchDirDisplay}"`;
+      let allMatches = await this.performRipgrepSearch({
+        pattern: this.params.pattern,
+        path: searchDirAbs,
+        include: this.params.include,
+        case_sensitive: this.params.case_sensitive,
+        fixed_strings: this.params.fixed_strings,
+        context: this.params.context,
+        after: this.params.after,
+        before: this.params.before,
+        no_ignore: this.params.no_ignore,
+        signal
+      });
+      if (allMatches.length >= totalMaxMatches) {
+        allMatches = allMatches.slice(0, totalMaxMatches);
       }
+      const searchLocationDescription = `in path "${searchDirDisplay}"`;
       if (allMatches.length === 0) {
         const noMatchMsg = `No matches found for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ""}.`;
         return { llmContent: noMatchMsg, returnDisplay: `No matches found` };
@@ -320770,24 +320827,43 @@ var GrepToolInvocation2 = class extends BaseToolInvocation {
     return results;
   }
   async performRipgrepSearch(options2) {
-    const { pattern, path: absolutePath, include } = options2;
-    const rgArgs = ["--json", "--ignore-case", "--regexp", pattern];
+    const { pattern, path: absolutePath, include, case_sensitive, fixed_strings, context: context2, after, before, no_ignore } = options2;
+    const rgArgs = ["--json"];
+    if (!case_sensitive) {
+      rgArgs.push("--ignore-case");
+    }
+    if (fixed_strings) {
+      rgArgs.push("--fixed-strings");
+      rgArgs.push(pattern);
+    } else {
+      rgArgs.push("--regexp", pattern);
+    }
+    if (context2) {
+      rgArgs.push("--context", context2.toString());
+    }
+    if (after) {
+      rgArgs.push("--after-context", after.toString());
+    }
+    if (before) {
+      rgArgs.push("--before-context", before.toString());
+    }
+    if (no_ignore) {
+      rgArgs.push("--no-ignore");
+    }
     if (include) {
       rgArgs.push("--glob", include);
     }
-    const excludes = [
-      ".git",
-      "node_modules",
-      "bower_components",
-      "*.log",
-      "*.tmp",
-      "build",
-      "dist",
-      "coverage"
-    ];
-    excludes.forEach((exclude) => {
-      rgArgs.push("--glob", `!${exclude}`);
-    });
+    if (!no_ignore) {
+      const fileExclusions = new FileExclusions(this.config);
+      const excludes = fileExclusions.getGlobExcludes([
+        ...COMMON_DIRECTORY_EXCLUDES,
+        "*.log",
+        "*.tmp"
+      ]);
+      excludes.forEach((exclude) => {
+        rgArgs.push("--glob", `!${exclude}`);
+      });
+    }
     rgArgs.push("--threads", "4");
     rgArgs.push(absolutePath);
     try {
@@ -320839,20 +320915,13 @@ var GrepToolInvocation2 = class extends BaseToolInvocation {
     if (this.params.include) {
       description += ` in ${this.params.include}`;
     }
-    if (this.params.dir_path) {
-      const resolvedPath = path33.resolve(this.config.getTargetDir(), this.params.dir_path);
-      if (resolvedPath === this.config.getTargetDir() || this.params.dir_path === ".") {
-        description += ` within ./`;
-      } else {
-        const relativePath = makeRelative(resolvedPath, this.config.getTargetDir());
-        description += ` within ${shortenPath(relativePath)}`;
-      }
+    const pathParam = this.params.dir_path || ".";
+    const resolvedPath = path33.resolve(this.config.getTargetDir(), pathParam);
+    if (resolvedPath === this.config.getTargetDir() || pathParam === ".") {
+      description += ` within ./`;
     } else {
-      const workspaceContext = this.config.getWorkspaceContext();
-      const directories = workspaceContext.getDirectories();
-      if (directories.length > 1) {
-        description += ` across all workspace directories`;
-      }
+      const relativePath = makeRelative(resolvedPath, this.config.getTargetDir());
+      description += ` within ${shortenPath(relativePath)}`;
     }
     return description;
   }
@@ -320864,21 +320933,45 @@ var RipGrepTool = class _RipGrepTool extends BaseDeclarativeTool {
     super(
       _RipGrepTool.Name,
       "SearchText",
-      "Searches for a regular expression pattern within the content of files in a specified directory (or current working directory). Can filter files by a glob pattern. Returns the lines containing matches, along with their file paths and line numbers. Total results limited to 20,000 matches like VSCode.",
+      'FAST, optimized search powered by `ripgrep`. PREFERRED over standard `run_shell_command("grep ...")` due to better performance and automatic output limiting (max 20k matches).',
       Kind.Search,
       {
         properties: {
           pattern: {
-            description: "The regular expression (regex) pattern to search for within file contents (e.g., 'function\\s+myFunction', 'import\\s+\\{.*\\}\\s+from\\s+.*').",
+            description: "The pattern to search for. By default, treated as a Rust-flavored regular expression. Use '\\b' for precise symbol matching (e.g., '\\bMatchMe\\b').",
             type: "string"
           },
           dir_path: {
-            description: "Optional: The absolute path to the directory to search within. If omitted, searches the current working directory.",
+            description: "Directory or file to search. Directories are searched recursively. Relative paths are resolved against current working directory. Defaults to current working directory ('.') if omitted.",
             type: "string"
           },
           include: {
-            description: "Optional: A glob pattern to filter which files are searched (e.g., '*.js', '*.{ts,tsx}', 'src/**'). If omitted, searches all files (respecting potential global ignores).",
+            description: "Glob pattern to filter files (e.g., '*.ts', 'src/**'). Recommended for large repositories to reduce noise. Defaults to all files if omitted.",
             type: "string"
+          },
+          case_sensitive: {
+            description: "If true, search is case-sensitive. Defaults to false (ignore case) if omitted.",
+            type: "boolean"
+          },
+          fixed_strings: {
+            description: "If true, treats the `pattern` as a literal string instead of a regular expression. Defaults to false (basic regex) if omitted.",
+            type: "boolean"
+          },
+          context: {
+            description: "Show this many lines of context around each match (equivalent to grep -C). Defaults to 0 if omitted.",
+            type: "integer"
+          },
+          after: {
+            description: "Show this many lines after each match (equivalent to grep -A). Defaults to 0 if omitted.",
+            type: "integer"
+          },
+          before: {
+            description: "Show this many lines before each match (equivalent to grep -B). Defaults to 0 if omitted.",
+            type: "integer"
+          },
+          no_ignore: {
+            description: "If true, searches all files including those usually ignored (like in .gitignore, build/, dist/, etc). Defaults to false if omitted.",
+            type: "boolean"
           }
         },
         required: ["pattern"],
@@ -320892,35 +320985,6 @@ var RipGrepTool = class _RipGrepTool extends BaseDeclarativeTool {
     );
     this.config = config2;
   }
-  /**
-   * Checks if a path is within the root directory and resolves it.
-   * @param relativePath Path relative to the root directory (or undefined for root).
-   * @returns The absolute path if valid and exists, or null if no path specified (to search all directories).
-   * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
-   */
-  resolveAndValidatePath(relativePath) {
-    if (!relativePath) {
-      return null;
-    }
-    const targetPath = path33.resolve(this.config.getTargetDir(), relativePath);
-    const workspaceContext = this.config.getWorkspaceContext();
-    if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
-      const directories = workspaceContext.getDirectories();
-      throw new Error(`Path validation failed: Attempted path "${relativePath}" resolves outside the allowed workspace directories: ${directories.join(", ")}`);
-    }
-    try {
-      const stats = fs31.statSync(targetPath);
-      if (!stats.isDirectory()) {
-        throw new Error(`Path is not a directory: ${targetPath}`);
-      }
-    } catch (error) {
-      if (isNodeError(error) && error.code !== "ENOENT") {
-        throw new Error(`Path does not exist: ${targetPath}`);
-      }
-      throw new Error(`Failed to access path stats for ${targetPath}: ${error}`);
-    }
-    return targetPath;
-  }
   /**
    * Validates the parameters for the tool
    * @param params Parameters to validate
@@ -320933,7 +320997,7 @@ var RipGrepTool = class _RipGrepTool extends BaseDeclarativeTool {
     }
     if (params.dir_path) {
       try {
-        this.resolveAndValidatePath(params.dir_path);
+        resolveAndValidatePath(this.config, params.dir_path);
       } catch (error) {
         return getErrorMessage(error);
       }
@@ -321163,6 +321227,10 @@ var ApprovalMode;
   ApprovalMode2["AUTO_EDIT"] = "autoEdit";
   ApprovalMode2["YOLO"] = "yolo";
 })(ApprovalMode || (ApprovalMode = {}));
+var InProcessCheckerType;
+(function(InProcessCheckerType2) {
+  InProcessCheckerType2["ALLOWED_PATH"] = "allowed-path";
+})(InProcessCheckerType || (InProcessCheckerType = {}));
 
 // packages/core/dist/src/utils/LruCache.js
 var LruCache = class {
@@ -345309,7 +345377,7 @@ ${todoListString}` : "Successfully cleared the todo list.";
 var WriteTodosTool = class _WriteTodosTool extends BaseDeclarativeTool {
   static Name = WRITE_TODOS_TOOL_NAME;
   constructor() {
-    super(_WriteTodosTool.Name, "Write Todos", WRITE_TODOS_DESCRIPTION, Kind.Other, {
+    super(_WriteTodosTool.Name, "WriteTodos", WRITE_TODOS_DESCRIPTION, Kind.Other, {
       type: "object",
       properties: {
         todos: {
@@ -345810,6 +345878,8 @@ var LLM_CHECK_AFTER_TURNS = 30;
 var DEFAULT_LLM_CHECK_INTERVAL = 3;
 var MIN_LLM_CHECK_INTERVAL = 5;
 var MAX_LLM_CHECK_INTERVAL = 15;
+var LLM_CONFIDENCE_THRESHOLD = 0.9;
+var DOUBLE_CHECK_MODEL_ALIAS = "loop-detection-double-check";
 var LOOP_DETECTION_SYSTEM_PROMPT = `You are a sophisticated AI diagnostic agent specializing in identifying when a conversational AI is stuck in an unproductive state. Your task is to analyze the provided conversation history and determine if the assistant has ceased to make meaningful progress.
 
 An unproductive state is characterized by one or more of the following patterns over the last 5 or more assistant turns:
@@ -345820,6 +345890,20 @@ Cognitive Loop: The assistant seems unable to determine the next logical step. I
 
 Crucially, differentiate between a true unproductive state and legitimate, incremental progress.
 For example, a series of 'tool_A' or 'tool_B' tool calls that make small, distinct changes to the same file (like adding docstrings to functions one by one) is considered forward progress and is NOT a loop. A loop would be repeatedly replacing the same text with the same content, or cycling between a small set of files with no net change.`;
+var LOOP_DETECTION_SCHEMA = {
+  type: "object",
+  properties: {
+    unproductive_state_analysis: {
+      type: "string",
+      description: "Your reasoning on if the conversation is looping without forward progress."
+    },
+    unproductive_state_confidence: {
+      type: "number",
+      description: "A number between 0.0 and 1.0 representing your confidence that the conversation is in an unproductive state."
+    }
+  },
+  required: ["unproductive_state_analysis", "unproductive_state_confidence"]
+};
 var LoopDetectionService = class {
   config;
   promptId = "";
@@ -346047,49 +346131,67 @@ var LoopDetectionService = class {
         parts: [{ text: "Recent conversation history:" }]
       });
     }
-    const schema = {
-      type: "object",
-      properties: {
-        unproductive_state_analysis: {
-          type: "string",
-          description: "Your reasoning on if the conversation is looping without forward progress."
-        },
-        unproductive_state_confidence: {
-          type: "number",
-          description: "A number between 0.0 and 1.0 representing your confidence that the conversation is in an unproductive state."
-        }
-      },
-      required: [
-        "unproductive_state_analysis",
-        "unproductive_state_confidence"
-      ]
-    };
-    let result;
+    const flashResult = await this.queryLoopDetectionModel("loop-detection", contents, signal);
+    if (!flashResult) {
+      return false;
+    }
+    const flashConfidence = flashResult["unproductive_state_confidence"];
+    const doubleCheckModelName = this.config.modelConfigService.getResolvedConfig({
+      model: DOUBLE_CHECK_MODEL_ALIAS
+    }).model;
+    if (flashConfidence < LLM_CONFIDENCE_THRESHOLD) {
+      logLlmLoopCheck(this.config, new LlmLoopCheckEvent(this.promptId, flashConfidence, doubleCheckModelName, -1));
+      this.updateCheckInterval(flashConfidence);
+      return false;
+    }
+    if (this.config.isInFallbackMode()) {
+      const flashModelName = this.config.modelConfigService.getResolvedConfig({
+        model: "loop-detection"
+      }).model;
+      this.handleConfirmedLoop(flashResult, flashModelName);
+      return true;
+    }
+    const mainModelResult = await this.queryLoopDetectionModel(DOUBLE_CHECK_MODEL_ALIAS, contents, signal);
+    const mainModelConfidence = mainModelResult ? mainModelResult["unproductive_state_confidence"] : 0;
+    logLlmLoopCheck(this.config, new LlmLoopCheckEvent(this.promptId, flashConfidence, doubleCheckModelName, mainModelConfidence));
+    if (mainModelResult) {
+      if (mainModelConfidence >= LLM_CONFIDENCE_THRESHOLD) {
+        this.handleConfirmedLoop(mainModelResult, doubleCheckModelName);
+        return true;
+      } else {
+        this.updateCheckInterval(mainModelConfidence);
+      }
+    }
+    return false;
+  }
+  async queryLoopDetectionModel(model, contents, signal) {
     try {
-      result = await this.config.getBaseLlmClient().generateJson({
-        modelConfigKey: { model: "loop-detection" },
+      const result = await this.config.getBaseLlmClient().generateJson({
+        modelConfigKey: { model },
         contents,
-        schema,
+        schema: LOOP_DETECTION_SCHEMA,
         systemInstruction: LOOP_DETECTION_SYSTEM_PROMPT,
         abortSignal: signal,
-        promptId: this.promptId
+        promptId: this.promptId,
+        maxAttempts: 2
       });
+      if (result && typeof result["unproductive_state_confidence"] === "number") {
+        return result;
+      }
+      return null;
     } catch (e2) {
       this.config.getDebugMode() ? debugLogger.warn(e2) : debugLogger.debug(e2);
-      return false;
+      return null;
     }
-    if (typeof result["unproductive_state_confidence"] === "number") {
-      if (result["unproductive_state_confidence"] > 0.9) {
-        if (typeof result["unproductive_state_analysis"] === "string" && result["unproductive_state_analysis"]) {
-          debugLogger.warn(result["unproductive_state_analysis"]);
-        }
-        logLoopDetected(this.config, new LoopDetectedEvent(LoopType.LLM_DETECTED_LOOP, this.promptId));
-        return true;
-      } else {
-        this.llmCheckInterval = Math.round(MIN_LLM_CHECK_INTERVAL + (MAX_LLM_CHECK_INTERVAL - MIN_LLM_CHECK_INTERVAL) * (1 - result["unproductive_state_confidence"]));
-      }
+  }
+  handleConfirmedLoop(result, modelName) {
+    if (typeof result["unproductive_state_analysis"] === "string" && result["unproductive_state_analysis"]) {
+      debugLogger.warn(result["unproductive_state_analysis"]);
     }
-    return false;
+    logLoopDetected(this.config, new LoopDetectedEvent(LoopType.LLM_DETECTED_LOOP, this.promptId, modelName));
+  }
+  updateCheckInterval(unproductive_state_confidence) {
+    this.llmCheckInterval = Math.round(MIN_LLM_CHECK_INTERVAL + (MAX_LLM_CHECK_INTERVAL - MIN_LLM_CHECK_INTERVAL) * (1 - unproductive_state_confidence));
   }
   /**
    * Resets all loop detection state.
@@ -352154,6 +352256,12 @@ var DEFAULT_MODEL_CONFIGS = {
       extends: "gemini-2.5-flash-base",
       modelConfig: {}
     },
+    "loop-detection-double-check": {
+      extends: "base",
+      modelConfig: {
+        model: "gemini-2.5-pro"
+      }
+    },
     "llm-edit-fixer": {
       extends: "gemini-2.5-flash-base",
       modelConfig: {}
@@ -352334,7 +352442,7 @@ var MessageBus = class extends EventEmitter10 {
   emitMessage(message) {
     this.emit(message.type, message);
   }
-  publish(message) {
+  async publish(message) {
     if (this.debug) {
       console.debug(`[MESSAGE_BUS] publish: ${safeJsonStringify(message)}`);
     }
@@ -352343,7 +352451,7 @@ var MessageBus = class extends EventEmitter10 {
         throw new Error(`Invalid message structure: ${safeJsonStringify(message)}`);
       }
       if (message.type === MessageBusType.TOOL_CONFIRMATION_REQUEST) {
-        const decision = this.policyEngine.check(message.toolCall, message.serverName);
+        const { decision } = await this.policyEngine.check(message.toolCall, message.serverName);
         switch (decision) {
           case PolicyDecision.ALLOW:
             this.emitMessage({
@@ -352440,6 +352548,14 @@ function stableStringify(obj) {
   return stringify5(obj, /* @__PURE__ */ new Set());
 }
 
+// packages/core/dist/src/safety/protocol.js
+var SafetyCheckDecision;
+(function(SafetyCheckDecision2) {
+  SafetyCheckDecision2["ALLOW"] = "allow";
+  SafetyCheckDecision2["DENY"] = "deny";
+  SafetyCheckDecision2["ASK_USER"] = "ask_user";
+})(SafetyCheckDecision || (SafetyCheckDecision = {}));
+
 // packages/core/dist/src/policy/policy-engine.js
 function ruleMatches(rule, toolCall, stringifiedArgs, serverName) {
   if (rule.toolName) {
@@ -352469,30 +352585,71 @@ function ruleMatches(rule, toolCall, stringifiedArgs, serverName) {
 }
 var PolicyEngine = class {
   rules;
+  checkers;
   defaultDecision;
   nonInteractive;
-  constructor(config2 = {}) {
+  checkerRunner;
+  constructor(config2 = {}, checkerRunner) {
     this.rules = (config2.rules ?? []).sort((a2, b) => (b.priority ?? 0) - (a2.priority ?? 0));
+    this.checkers = (config2.checkers ?? []).sort((a2, b) => (b.priority ?? 0) - (a2.priority ?? 0));
     this.defaultDecision = config2.defaultDecision ?? PolicyDecision.ASK_USER;
     this.nonInteractive = config2.nonInteractive ?? false;
+    this.checkerRunner = checkerRunner;
   }
   /**
    * Check if a tool call is allowed based on the configured policies.
+   * Returns the decision and the matching rule (if any).
    */
-  check(toolCall, serverName) {
+  async check(toolCall, serverName) {
     let stringifiedArgs;
-    if (toolCall.args && this.rules.some((rule) => rule.argsPattern)) {
+    if (toolCall.args && (this.rules.some((rule) => rule.argsPattern) || this.checkers.some((checker) => checker.argsPattern))) {
       stringifiedArgs = stableStringify(toolCall.args);
     }
     debugLogger.debug(`[PolicyEngine.check] toolCall.name: ${toolCall.name}, stringifiedArgs: ${stringifiedArgs}`);
+    let matchedRule;
+    let decision;
     for (const rule of this.rules) {
       if (ruleMatches(rule, toolCall, stringifiedArgs, serverName)) {
         debugLogger.debug(`[PolicyEngine.check] MATCHED rule: toolName=${rule.toolName}, decision=${rule.decision}, priority=${rule.priority}, argsPattern=${rule.argsPattern?.source || "none"}`);
-        return this.applyNonInteractiveMode(rule.decision);
+        matchedRule = rule;
+        decision = this.applyNonInteractiveMode(rule.decision);
+        break;
       }
     }
-    debugLogger.debug(`[PolicyEngine.check] NO MATCH - using default decision: ${this.defaultDecision}`);
-    return this.applyNonInteractiveMode(this.defaultDecision);
+    if (!decision) {
+      debugLogger.debug(`[PolicyEngine.check] NO MATCH - using default decision: ${this.defaultDecision}`);
+      decision = this.applyNonInteractiveMode(this.defaultDecision);
+    }
+    if (decision !== PolicyDecision.DENY && this.checkerRunner) {
+      for (const checkerRule of this.checkers) {
+        if (ruleMatches(checkerRule, toolCall, stringifiedArgs, serverName)) {
+          debugLogger.debug(`[PolicyEngine.check] Running safety checker: ${checkerRule.checker.name}`);
+          try {
+            const result = await this.checkerRunner.runChecker(toolCall, checkerRule.checker);
+            if (result.decision === SafetyCheckDecision.DENY) {
+              debugLogger.debug(`[PolicyEngine.check] Safety checker denied: ${result.reason}`);
+              return {
+                decision: PolicyDecision.DENY,
+                rule: matchedRule
+              };
+            } else if (result.decision === SafetyCheckDecision.ASK_USER) {
+              debugLogger.debug(`[PolicyEngine.check] Safety checker requested ASK_USER: ${result.reason}`);
+              decision = PolicyDecision.ASK_USER;
+            }
+          } catch (error) {
+            debugLogger.debug(`[PolicyEngine.check] Safety checker failed: ${error}`);
+            return {
+              decision: PolicyDecision.DENY,
+              rule: matchedRule
+            };
+          }
+        }
+      }
+    }
+    return {
+      decision: this.applyNonInteractiveMode(decision),
+      rule: matchedRule
+    };
   }
   /**
    * Add a new rule to the policy engine.
@@ -352501,6 +352658,10 @@ var PolicyEngine = class {
     this.rules.push(rule);
     this.rules.sort((a2, b) => (b.priority ?? 0) - (a2.priority ?? 0));
   }
+  addChecker(checker) {
+    this.checkers.push(checker);
+    this.checkers.sort((a2, b) => (b.priority ?? 0) - (a2.priority ?? 0));
+  }
   /**
    * Remove rules for a specific tool.
    */
@@ -352513,6 +352674,9 @@ var PolicyEngine = class {
   getRules() {
     return this.rules;
   }
+  getCheckers() {
+    return this.checkers;
+  }
   applyNonInteractiveMode(decision) {
     if (this.nonInteractive && decision === PolicyDecision.ASK_USER) {
       return PolicyDecision.DENY;
@@ -355005,8 +355169,9 @@ function getPlatform() {
 async function getClientMetadata() {
   if (!clientMetadataPromise) {
     clientMetadataPromise = (async () => ({
-      ideName: "GEMINI_CLI",
-      ideVersion: "0.15.0-preview.3",
+      ideName: "IDE_UNSPECIFIED",
+      pluginType: "GEMINI",
+      ideVersion: "0.16.0-nightly.20251113.ad1f0d99",
       platform: getPlatform(),
       updateChannel: await getReleaseChannel(__dirname5)
     }))();
@@ -361345,8 +361510,32 @@ var PolicyRuleSchema = external_exports.object({
   }),
   modes: external_exports.array(external_exports.string()).optional()
 });
+var SafetyCheckerRuleSchema = external_exports.object({
+  toolName: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional(),
+  mcpName: external_exports.string().optional(),
+  argsPattern: external_exports.string().optional(),
+  commandPrefix: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional(),
+  commandRegex: external_exports.string().optional(),
+  priority: external_exports.number().int().default(0),
+  modes: external_exports.array(external_exports.string()).optional(),
+  checker: external_exports.discriminatedUnion("type", [
+    external_exports.object({
+      type: external_exports.literal("in-process"),
+      name: external_exports.nativeEnum(InProcessCheckerType),
+      required_context: external_exports.array(external_exports.string()).optional(),
+      config: external_exports.record(external_exports.unknown()).optional()
+    }),
+    external_exports.object({
+      type: external_exports.literal("external"),
+      name: external_exports.string(),
+      required_context: external_exports.array(external_exports.string()).optional(),
+      config: external_exports.record(external_exports.unknown()).optional()
+    })
+  ])
+});
 var PolicyFileSchema = external_exports.object({
-  rule: external_exports.array(PolicyRuleSchema)
+  rule: external_exports.array(PolicyRuleSchema).optional(),
+  safety_checker: external_exports.array(SafetyCheckerRuleSchema).optional()
 });
 
 // packages/core/dist/src/policy/config.js