token-goat 2.9.26 → 2.9.29

package/dist/token-goat-chunk-E5TK5DNO.mjs

@@ -0,0 +1,718 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  COPILOT_CLI_TOOL_NAME_MAP,
+  foldToolName,
+  readCopilotMcpTools
+} from "./token-goat-chunk-EUSDXRXU.mjs";
+import {
+  countRedactionPlaceholders,
+  recordStat,
+  savedTokensFromBytes
+} from "./token-goat-chunk-CIQ2FTY3.mjs";
+import {
+  detectHarness,
+  loadConfig,
+  ownGet
+} from "./token-goat-chunk-TGOXNAHW.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  escapesOntoNetworkThroughLinks,
+  foldPathForContainment,
+  isInsideRoot
+} from "./token-goat-chunk-TCQANXYC.mjs";
+import {
+  displaySafeText,
+  isUncOrDevicePath,
+  neutralizeOutsideFences
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/hooks_cli.ts
+init_define_import_meta_env();
+
+// src/copilot_mcp_names.ts
+init_define_import_meta_env();
+var _cached = null;
+function copilotMcpToolNameMap() {
+  if (_cached) return _cached;
+  const map = /* @__PURE__ */ new Map();
+  try {
+    for (const server of readCopilotMcpTools().servers) {
+      for (const toolName of server.toolNames) {
+        map.set(`${server.serverName}-${toolName}`, `mcp__${server.serverName}__${toolName}`);
+      }
+    }
+  } catch {
+  }
+  _cached = map;
+  return map;
+}
+function canonicalizeCopilotMcpToolName(toolName) {
+  return copilotMcpToolNameMap().get(toolName) ?? toolName;
+}
+function resetCopilotMcpToolNameCache() {
+  _cached = null;
+}
+registerReset(resetCopilotMcpToolNameCache, { perRequest: true });
+
+// src/hooks_cli.ts
+var _LOG = {
+  warn: (msg, ...args) => console.warn(`[hooks_cli] ${msg}`, ...args),
+  debug: (msg, ...args) => console.error(`[hooks_cli] ${msg}`, ...args),
+  error: (msg, err, ...args) => console.error(`[hooks_cli] ${msg}`, ...err ? [err] : [], ...args)
+};
+var CANONICAL_TG_TOOLS = [
+  "Bash",
+  "BashOutput",
+  "Read",
+  "Write",
+  "Edit",
+  "WebFetch",
+  "WebSearch",
+  "Grep",
+  "Glob",
+  "Skill",
+  "NotebookEdit",
+  "ExitPlanMode"
+];
+function normalizeToolNameWithMap(toolName, nameMap) {
+  if (!toolName || typeof toolName !== "string") return toolName;
+  const stripped = toolName.includes(":") ? toolName.split(":").pop() : toolName;
+  if (nameMap) {
+    const exact = ownGet(nameMap, toolName) ?? ownGet(nameMap, stripped);
+    if (exact !== void 0) return exact;
+  }
+  const lower = toolName.toLowerCase();
+  const lowerStripped = stripped.toLowerCase();
+  const folded = foldToolName(toolName);
+  const foldedStripped = foldToolName(stripped);
+  if (nameMap) {
+    for (const [k, v] of Object.entries(nameMap)) {
+      const kLower = k.toLowerCase();
+      const kFolded = foldToolName(k);
+      if (kLower === lower || kLower === lowerStripped || kFolded === folded || kFolded === foldedStripped) {
+        return v;
+      }
+    }
+    for (const v of Object.values(nameMap)) {
+      const vLower = v.toLowerCase();
+      const vFolded = foldToolName(v);
+      if (vLower === lower || vLower === lowerStripped || vFolded === folded || vFolded === foldedStripped) {
+        return v;
+      }
+    }
+  }
+  for (const canonical of CANONICAL_TG_TOOLS) {
+    const cLower = canonical.toLowerCase();
+    const cFolded = foldToolName(canonical);
+    if (cLower === lower || cLower === lowerStripped || cFolded === folded || cFolded === foldedStripped) {
+      return canonical;
+    }
+  }
+  return toolName;
+}
+var COPILOT_CLI_INPUT_KEY_MAP = {
+  Read: { path: "file_path" },
+  Write: { path: "file_path" },
+  Edit: { path: "file_path", old_str: "old_string", new_str: "new_string" },
+  BashOutput: { shellId: "bash_id" }
+};
+var CODEX_TOOL_NAME_MAP = {
+  bash: "Bash",
+  // CAPTURE, codex-cli 0.155.0, 2026-09-22: a shell call reaches the hook wire already named 'Bash', and its internal spelling is 'exec'. 'shell' and 'bash' are kept for an older Codex or a fork; neither has been seen on a real payload, both came from this repo's own guidance text, and that text was wrong. See CODEX_MATCHERS in bridges/codex_install.ts.
+  exec: "Bash",
+  shell: "Bash",
+  edit_file: "Edit",
+  edit: "Edit",
+  apply_patch: "Edit",
+  write_file: "Write",
+  search_files: "Grep",
+  grep: "Grep",
+  list_files: "Glob",
+  glob: "Glob",
+  web_search: "WebFetch",
+  // Codex's only wired image-viewing tool (CODEX_MATCHERS in codex_install.ts wires it alongside the shell spellings, in one matcher that covers image reads and shell execution together, mirroring Claude Code's Read handling) -- without this entry, tool_name stayed the literal 'view_image', which matches neither preReadHandler's nor image_shrink.ts's preReadImageHandler's toolName: 'Read' filter, so every Codex image view silently skipped image shrinking and read-session tracking entirely.
+  view_image: "Read"
+};
+var GEMINI_TOOL_NAME_MAP = {
+  run_shell_command: "Bash",
+  read_file: "Read",
+  read_many_files: "Read",
+  // Deliberately 'Read', not 'Glob', even though list_directory enumerates a directory the way a Glob call does: Grok's equivalent list_dir maps to 'Glob' instead, but Grok's GROK_INPUT_KEY_MAP never remaps a 'pattern' key for it either, so on Grok this call is inert (preGlobHandler/globSignature require a non-empty toolInput['pattern'], which a plain directory listing never sends). Gemini's Read mapping, by contrast, is confirmed live: preReadHandler's node_modules deny fires on a list_directory call targeting node_modules (dogfooded in commit f1fc02de), which Glob's handler has no equivalent check for. Read was the considered choice, not an oversight; kept even though the two harnesses disagree.
+  list_directory: "Read",
+  write_file: "Write",
+  replace: "Edit",
+  glob: "Glob",
+  grep_search: "Grep",
+  // 'search_file_content' was GREP_TOOL_NAME's value before gemini-cli renamed it to 'grep_search' (confirmed against gemini-cli's current base-declarations.ts, which now defines GREP_TOOL_NAME = 'grep_search'; some of gemini-cli's own docs pages still lag the rename). Kept as a backward-compat entry for older installed gemini-cli versions that still emit the pre-rename name -- not dead/hallucinated, just legacy.
+  search_file_content: "Grep",
+  // Gemini's real web-search tool is registered as 'google_web_search' (WEB_SEARCH_TOOL_NAME in gemini-cli's tool-names.ts) -- 'web_search' is not a tool name Gemini CLI ever emits, so the old entry here silently never matched a real invocation.
+  // Previously mapped to 'WebFetch' as a workaround for GEMINI_PRE_TOOLS/POST_TOOLS (gemini_install.ts) excluding 'WebSearch' -- that made the hook fire under the installer's matcher, but hooks_fetch.ts's preFetchHandler/postFetchHandler require a `url` tool-input key, which a search call never sends (it sends `query`), so every google_web_search call silently no-op'd through WebFetch's handler: no URL policy check ever applied to it (it has no URL to check) and no search-result dedup ever ran. Now mapped to the dedicated 'WebSearch' handler (hooks_websearch.ts), which reads `query` directly; the installer gate above was extended to include 'WebSearch' so the hook stays wired.
+  google_web_search: "WebSearch",
+  web_fetch: "WebFetch"
+};
+var GEMINI_INPUT_KEY_MAP = {
+  // Gemini's real write_file/replace tool schemas already use 'file_path' (and replace's 'old_string'/'new_string') verbatim -- identical to token-goat's own canonical keys (see getFilePath() in hooks_common.ts, which reads event.toolInput['file_path']) -- confirmed against gemini-cli's own EditToolParams/WriteFileToolParams interfaces. No remap is needed for Write/Edit; the previous entries here actively renamed a key that was already correct (file_path -> path), which would have silently corrupted the path argument on every real Gemini Write/Edit call.
+  // 'Read' covers THREE distinct raw Gemini tools (see GEMINI_TOOL_NAME_MAP above), and they do NOT share one schema: read_file already uses 'file_path' verbatim, no remap needed; list_directory uses 'dir_path' (confirmed against gemini-cli's LSToolParams) -- remapped to 'file_path' below, exactly mirroring Grep's existing dir_path->path fix; read_many_files uses 'include' (confirmed against gemini-cli's ReadManyFilesParams), an ARRAY of glob patterns, not a single file path -- there is no single string to remap it to, so it is deliberately left unmapped. getFilePath() (hooks_common.ts) will return undefined for this call, and preReadHandler/postReadHandler already fall back to passOutput() on an undefined path (see preReadHandler's `if (filePath === undefined) return passOutput()`), so a real read_many_files call still succeeds normally; it just doesn't get session-dedup tracking or read-count hints. Accepted limitation, not a bug to force-fit.
+  Read: { dir_path: "file_path" },
+  // Grep's real tool (grep_search) calls its target-directory argument 'dir_path', which preReadHandler's Grep fallback (event.toolInput['path']) doesn't recognize, so that one remains remapped.
+  Grep: { dir_path: "path" }
+};
+var GROK_TOOL_NAME_MAP = {
+  read_file: "Read",
+  write: "Write",
+  search_replace: "Edit",
+  run_terminal_command: "Bash",
+  // The grok 0.2.93 binary registers its shell tool as `tool.run_terminal_cmd` (tracing-id table in ~/.grok/bin/agent.exe) and its newer embedded hooks doc's PreToolUse example sends `"toolName": "run_terminal_cmd"`, while the older embedded doc revision and a 2026-07-09 live capture on the same version both show `run_terminal_command`. Which spelling arrives is profile/version dependent, so BOTH are mapped: an unmatched extra entry is a harmless no-op, a missing one silently kills every Bash hook (compression, wrap, hints) on that profile.
+  run_terminal_cmd: "Bash",
+  grep: "Grep",
+  list_dir: "Glob",
+  // `glob` is a distinct registered grok tool (tool.glob in the 0.2.93 binary's tracing-id table), separate from list_dir; unmapped it arrived as lowercase 'glob' and matched no handler.
+  glob: "Glob",
+  // web_fetch/web_search were entirely absent from this map, so grok's URL fetches bypassed token-goat's WebFetch pipeline (URL-policy deny included) and its searches bypassed the WebSearch dedup/compression. Verified against the 0.2.93 binary: tool.web_fetch / tool.web_search registered ids, grok_build WebFetchInput's field described as "The URL to fetch content from" (i.e. `url`), grok_build WebSearchInput's fields query/citations/allowed_domains -- all matching the keys hooks_fetch.ts / hooks_websearch.ts already read, so a name map alone revives both.
+  web_fetch: "WebFetch",
+  web_search: "WebSearch",
+  // The Hashline prompt profile registers hashline_read/hashline_edit/hashline_grep (tool.hashline_* in the binary; grok's own hook alias table pairs them with Read/Edit/Grep). Their input key shapes were not individually verified: if one differs, the mapped handler degrades to the same no-op as an unmapped name, never a wrong rewrite. The *_concise twins are the GrokBuildConcise profile's registrations of the same three core tools.
+  hashline_read: "Read",
+  hashline_edit: "Edit",
+  hashline_grep: "Grep",
+  read_file_concise: "Read",
+  search_replace_concise: "Edit",
+  run_terminal_cmd_concise: "Bash"
+};
+var GROK_INPUT_KEY_MAP = {
+  Read: { target_file: "file_path" }
+};
+var KIMI_TOOL_NAME_MAP = {
+  FetchURL: "WebFetch",
+  ReadMediaFile: "Read"
+};
+var KIMI_INPUT_KEY_MAP = {
+  // line_offset/n_lines are Kimi's Read paging arguments (ReadInputSchema in MoonshotAI/kimi-code packages/agent-core-v2/src/agent/tools/os/read/read.ts: `path`, `line_offset` "the line number to start reading from", `n_lines` "the number of lines to read"). Unmapped, every ranged Kimi read looked unbounded to hooks_read.ts's estimateRequestedSlice and was gated on the whole file's size -- a small slice of a big file could draw the large-file deny meant for full reads. line_offset's 1-indexed positive form matches Read's own offset semantics exactly; its negative tail-read form has no token-goat equivalent and is clamped to 1 by estimateRequestedSlice's `offset >= 1` guard, degrading to a window of the right SIZE (which is all the gate consumes). ReadMediaFile shares this map via its Read rename and carries only `path`, so the extra entries never touch it.
+  Read: { path: "file_path", line_offset: "offset", n_lines: "limit" },
+  Write: { path: "file_path" },
+  Edit: { path: "file_path" }
+};
+var QWEN_TOOL_NAME_MAP = {
+  read_file: "Read",
+  write_file: "Write",
+  edit: "Edit",
+  replace: "Edit",
+  notebook_edit: "NotebookEdit",
+  run_shell_command: "Bash",
+  grep_search: "Grep",
+  search_file_content: "Grep",
+  glob: "Glob",
+  web_fetch: "WebFetch",
+  web_search: "WebSearch",
+  // Same deliberate 'Read' choice as Gemini's list_directory entry above (see its comment): node_modules deny fires, Grok's rival 'Glob' mapping is inert for the equivalent tool anyway.
+  list_directory: "Read"
+};
+var QWEN_INPUT_KEY_MAP = {
+  Read: { path: "file_path" }
+};
+var VSCODE_TOOL_NAME_MAP = {
+  read_file: "Read",
+  view_image: "Read",
+  list_dir: "Read",
+  grep_search: "Grep",
+  file_search: "Glob",
+  create_file: "Write",
+  replace_string_in_file: "Edit",
+  insert_edit_into_file: "Edit",
+  edit_notebook_file: "NotebookEdit",
+  run_in_terminal: "Bash"
+};
+var VSCODE_INPUT_KEY_MAP = {
+  read_file: { filePath: "file_path" },
+  view_image: { filePath: "file_path" },
+  list_dir: { path: "file_path" },
+  grep_search: { query: "pattern", includePattern: "glob" },
+  file_search: { query: "pattern" },
+  create_file: { filePath: "file_path" },
+  replace_string_in_file: { filePath: "file_path", oldString: "old_string", newString: "new_string" },
+  insert_edit_into_file: { filePath: "file_path" },
+  edit_notebook_file: { filePath: "notebook_path" },
+  run_in_terminal: {}
+};
+var VSCODE_TOOL_NAME_KEY = "_tg_vscode_tool_name";
+function vscodeNativeToolInput(vscodeToolName, canonicalInput) {
+  const inverse = {};
+  for (const [nativeKey, canonicalKey] of Object.entries(ownGet(VSCODE_INPUT_KEY_MAP, vscodeToolName) ?? {})) {
+    inverse[canonicalKey] = nativeKey;
+  }
+  return remapInputKeys(canonicalInput, inverse);
+}
+function remapInputKeys(input, keyMap) {
+  const newInput = {};
+  for (const [k, v] of Object.entries(input)) {
+    newInput[ownGet(keyMap, k) || k] = v;
+  }
+  return newInput;
+}
+function remapToolName(obj, toolName, nameMap, inputKeyMap) {
+  const mapped = normalizeToolNameWithMap(toolName, nameMap);
+  const result = { ...obj };
+  result["tool_name"] = mapped;
+  const rawInput = obj["tool_input"];
+  const keyMap = ownGet(inputKeyMap, mapped) ?? ownGet(inputKeyMap, toolName);
+  if (keyMap && typeof rawInput === "object" && rawInput !== null && !Array.isArray(rawInput)) {
+    result["tool_input"] = remapInputKeys(rawInput, keyMap);
+  }
+  return result;
+}
+function grokToCanonicalWire(obj) {
+  const wire = { ...obj };
+  if (typeof wire["toolName"] === "string" && wire["tool_name"] === void 0) {
+    wire["tool_name"] = wire["toolName"];
+  }
+  if (typeof wire["toolInput"] === "object" && wire["toolInput"] !== null && !Array.isArray(wire["toolInput"]) && wire["tool_input"] === void 0) {
+    wire["tool_input"] = wire["toolInput"];
+  }
+  if (typeof wire["sessionId"] === "string" && wire["session_id"] === void 0) {
+    wire["session_id"] = wire["sessionId"];
+  }
+  const toolResult = wire["toolResult"];
+  if (toolResult !== null && typeof toolResult === "object" && !Array.isArray(toolResult)) {
+    const tr = toolResult;
+    if (typeof tr["output_for_prompt"] === "string") {
+      wire["tool_response"] = { content: tr["output_for_prompt"], exit_code: tr["exit_code"] };
+    } else {
+      const firstString = Object.entries(tr).find(([k, v]) => k !== "type" && typeof v === "string");
+      if (firstString) {
+        wire["tool_response"] = { content: firstString[1] };
+      }
+    }
+  }
+  return wire;
+}
+function aliasLlmContentToOutput(result) {
+  const toolResponse = result["tool_response"];
+  if (toolResponse === null || typeof toolResponse !== "object" || Array.isArray(toolResponse)) return;
+  const responseRecord = toolResponse;
+  if (typeof responseRecord["llmContent"] === "string" && responseRecord["output"] === void 0) {
+    result["tool_response"] = { ...responseRecord, output: responseRecord["llmContent"] };
+  }
+}
+function normalizePayload(payload, harness = "claude") {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    _LOG.warn("normalizePayload: payload is not a dict; received %s", typeof payload);
+    return {};
+  }
+  const rawObj = payload;
+  const obj = harness === "grok" ? grokToCanonicalWire(rawObj) : rawObj;
+  const toolName = obj["tool_name"];
+  if (typeof toolName !== "string" || !toolName.trim()) {
+    _LOG.debug("normalizePayload: tool_name missing or invalid; received %s", toolName);
+    return {};
+  }
+  if (harness === "grok") {
+    const result2 = remapToolName(obj, toolName, GROK_TOOL_NAME_MAP, GROK_INPUT_KEY_MAP);
+    result2["_tg_harness"] = harness;
+    return result2;
+  }
+  if (harness === "codex") {
+    const mapped = normalizeToolNameWithMap(toolName, CODEX_TOOL_NAME_MAP);
+    const result2 = { ...obj };
+    if (mapped) {
+      result2["tool_name"] = mapped;
+    }
+    result2["_tg_harness"] = harness;
+    return result2;
+  }
+  if (harness === "copilot_cli") {
+    const result2 = remapToolName(obj, toolName, COPILOT_CLI_TOOL_NAME_MAP, COPILOT_CLI_INPUT_KEY_MAP);
+    result2["tool_name"] = canonicalizeCopilotMcpToolName(result2["tool_name"]);
+    result2["_tg_harness"] = harness;
+    return result2;
+  }
+  if (harness === "vscode") {
+    const mapped = normalizeToolNameWithMap(toolName, VSCODE_TOOL_NAME_MAP);
+    const result2 = { ...obj };
+    result2["tool_name"] = mapped;
+    const keyMap = ownGet(VSCODE_INPUT_KEY_MAP, toolName) ?? ownGet(VSCODE_INPUT_KEY_MAP, mapped);
+    const rawInput = obj["tool_input"];
+    if (keyMap && typeof rawInput === "object" && rawInput !== null && !Array.isArray(rawInput)) {
+      result2["tool_input"] = remapInputKeys(rawInput, keyMap);
+    }
+    result2[VSCODE_TOOL_NAME_KEY] = toolName;
+    result2["_tg_harness"] = harness;
+    return result2;
+  }
+  if (harness === "kimi") {
+    const result2 = remapToolName(obj, toolName, KIMI_TOOL_NAME_MAP, KIMI_INPUT_KEY_MAP);
+    result2["_tg_harness"] = harness;
+    return result2;
+  }
+  if (harness === "qwen") {
+    const result2 = remapToolName(obj, toolName, QWEN_TOOL_NAME_MAP, QWEN_INPUT_KEY_MAP);
+    aliasLlmContentToOutput(result2);
+    result2["_tg_harness"] = harness;
+    return result2;
+  }
+  if (harness === "gemini") {
+    const result2 = remapToolName(obj, toolName, GEMINI_TOOL_NAME_MAP, GEMINI_INPUT_KEY_MAP);
+    if ("functionCallId" in result2 && !("toolUseId" in result2)) {
+      result2["toolUseId"] = result2["functionCallId"];
+      delete result2["functionCallId"];
+    }
+    aliasLlmContentToOutput(result2);
+    result2["_tg_harness"] = harness;
+    return result2;
+  }
+  const result = { ...obj };
+  const normalizedCanonical = normalizeToolNameWithMap(toolName);
+  if (normalizedCanonical !== toolName) {
+    result["tool_name"] = normalizedCanonical;
+  }
+  result["_tg_harness"] = harness;
+  return result;
+}
+
+// src/hint_suggestion_guard.ts
+init_define_import_meta_env();
+function looksLikeSuggestion(slice) {
+  return slice.includes('"');
+}
+var SAFE_OUTSIDE_QUOTES = /^[A-Za-z0-9 \t_./=:,@+-]*$/;
+var CONTROL_OR_BIDI = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F\u200E\u200F\u202A-\u202E\u2066-\u2069\u061C\u200B-\u200D\u2028\u2029\uFE00-\uFE0F]|[\u{E0000}-\u{E007F}]/u;
+function suggestionIsUnsafe(slice) {
+  if (slice.includes("$") || slice.includes("\n") || slice.includes("\r") || slice.includes("`")) return true;
+  if (CONTROL_OR_BIDI.test(slice)) return true;
+  const regions = slice.split('"');
+  if (regions.length % 2 === 0) return true;
+  for (let i = 2; i < regions.length; i += 2) {
+    if (!SAFE_OUTSIDE_QUOTES.test(regions[i] ?? "")) return true;
+  }
+  return false;
+}
+var OMITTED = "token-goat (command omitted: the path contains shell metacharacters)";
+function stripUnsafeSuggestions(text) {
+  if (!text.includes("token-goat ")) return text;
+  let out = "";
+  let at = 0;
+  for (; ; ) {
+    const start = text.indexOf("token-goat ", at);
+    if (start === -1) return out + text.slice(at);
+    const lineBreak = text.slice(start).search(/[\r\n]/);
+    const line = lineBreak === -1 ? text.slice(start) : text.slice(start, start + lineBreak);
+    const firstTick = line.indexOf("`");
+    const narrow = firstTick === -1 ? line : line.slice(0, firstTick);
+    out += text.slice(at, start);
+    if (!looksLikeSuggestion(narrow) || !suggestionIsUnsafe(narrow)) {
+      out += narrow;
+      at = start + narrow.length;
+      continue;
+    }
+    const lastTick = line.lastIndexOf("`");
+    const wide = lastTick === -1 ? line : line.slice(0, lastTick);
+    out += OMITTED;
+    at = start + wide.length;
+  }
+}
+function leadWithCommand(command, purpose = "", reason = "") {
+  const tail = reason.trim();
+  return "Run `" + command + "`" + (purpose === "" ? "" : " " + purpose) + "." + (tail === "" ? "" : (tail.includes("`") ? "\n" : " ") + tail);
+}
+
+// src/hooks_common.ts
+init_define_import_meta_env();
+function getToolName(event) {
+  return event.toolName;
+}
+function getToolInput(event) {
+  return event.toolInput;
+}
+function getFilePath(event) {
+  const value = event.toolInput["file_path"];
+  if (typeof value === "string" && value !== "") return value;
+  const notebookValue = event.toolInput["notebook_path"];
+  return typeof notebookValue === "string" && notebookValue !== "" ? notebookValue : void 0;
+}
+function getCwd(event) {
+  const value = event.raw && typeof event.raw === "object" ? event.raw["cwd"] : void 0;
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function getTranscriptPath(event) {
+  const value = event.raw && typeof event.raw === "object" ? event.raw["transcript_path"] : void 0;
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function extractToolResponseField(raw, keys) {
+  const resp = raw["tool_response"];
+  if (typeof resp === "string") return resp;
+  if (resp !== null && typeof resp === "object") {
+    const r = resp;
+    const path2 = resolveToolResponseFieldPath(r, keys);
+    if (path2 !== null) return readAtPath(r, path2);
+  }
+  return "";
+}
+var NESTED_TOOL_RESPONSE_PATHS = [["file", "content"]];
+function readAtPath(resp, path2) {
+  let cur = resp;
+  for (const seg of path2) {
+    if (cur === null || typeof cur !== "object") return "";
+    cur = cur[seg];
+  }
+  return typeof cur === "string" ? cur : "";
+}
+function resolveToolResponseFieldPath(resp, keys) {
+  for (const key of keys) {
+    if (typeof resp[key] === "string" && resp[key] !== "") return [key];
+  }
+  for (const path2 of NESTED_TOOL_RESPONSE_PATHS) {
+    if (readAtPath(resp, path2) !== "") return path2;
+  }
+  return null;
+}
+function replaceToolResponseField(resp, keys, newText) {
+  const path2 = resolveToolResponseFieldPath(resp, keys);
+  if (path2 === null) return null;
+  const root = { ...resp };
+  let cur = root;
+  for (let i = 0; i < path2.length - 1; i++) {
+    const seg = path2[i];
+    const child = cur[seg];
+    if (child === null || typeof child !== "object") return null;
+    const cloned = { ...child };
+    cur[seg] = cloned;
+    cur = cloned;
+  }
+  cur[path2[path2.length - 1]] = newText;
+  return root;
+}
+var OUTPUT_FIRST_TOOL_RESPONSE_KEYS = ["output", "content", "text", "body", "stdout", "stderr"];
+var BODY_FIRST_TOOL_RESPONSE_KEYS = ["output", "body", "text", "content", "result"];
+function isMcpErrorResponse(raw) {
+  const tr = raw["tool_response"];
+  if (!tr || typeof tr !== "object") return false;
+  return tr["isError"] === true;
+}
+var MCP_CONTENT_BLOCK_TYPES = /* @__PURE__ */ new Set(["text", "image", "audio", "resource", "resource_link"]);
+function blocksToText(blocks) {
+  if (!Array.isArray(blocks)) return null;
+  const parts = [];
+  let recognised = false;
+  for (const block of blocks) {
+    if (!block || typeof block !== "object") continue;
+    const rec = block;
+    const type = rec["type"];
+    if (typeof type === "string" && MCP_CONTENT_BLOCK_TYPES.has(type)) recognised = true;
+    if (typeof rec["text"] === "string") {
+      parts.push(rec["text"]);
+      continue;
+    }
+    const resource = rec["resource"];
+    if (resource !== null && typeof resource === "object") {
+      const nested = resource["text"];
+      if (typeof nested === "string") parts.push(nested);
+      continue;
+    }
+    if (rec["type"] === "resource_link") {
+      const link = ["name", "uri", "description"].map((k) => rec[k]).filter((v) => typeof v === "string" && v !== "");
+      if (link.length > 0) parts.push(link.join(" "));
+    }
+  }
+  if (parts.length > 0) return parts.join("\n");
+  return recognised ? "" : null;
+}
+function extractToolResultText(raw) {
+  const tr = raw["tool_response"];
+  if (typeof tr === "string") return tr;
+  if (!tr || typeof tr !== "object") return "";
+  const bare = blocksToText(tr);
+  if (bare !== null) return bare;
+  const resp = tr;
+  const content = resp["content"];
+  const joined = blocksToText(content);
+  if (joined !== null) return joined;
+  for (const key of ["output", "text", "body"]) {
+    if (typeof resp[key] === "string") return resp[key];
+  }
+  if (typeof content === "string") return content;
+  try {
+    return JSON.stringify(resp);
+  } catch {
+    return "";
+  }
+}
+function asContentBlocks(value) {
+  if (!Array.isArray(value)) return null;
+  const blocks = value.filter((b) => b !== null && typeof b === "object");
+  const typed = blocks.some((b) => typeof b["type"] === "string" && MCP_CONTENT_BLOCK_TYPES.has(b["type"]));
+  return typed ? blocks : null;
+}
+function mcpContentBlocks(raw) {
+  const tr = raw["tool_response"];
+  if (tr === null || typeof tr !== "object") return null;
+  return asContentBlocks(tr) ?? asContentBlocks(tr["content"]);
+}
+function isTextualContentBlock(block) {
+  if (block === null || typeof block !== "object") return false;
+  const rec = block;
+  if (typeof rec["text"] === "string") return true;
+  if (rec["type"] === "resource_link") return true;
+  const resource = rec["resource"];
+  return resource !== null && typeof resource === "object" && typeof resource["text"] === "string";
+}
+function withPreservedBlocks(output, blocks) {
+  if (output.hookType !== "rewriteOutput" || blocks.length === 0) return output;
+  return { ...output, updatedBlocks: [{ type: "text", text: output.updatedOutput }, ...blocks] };
+}
+function passOutput() {
+  return { hookType: "pass" };
+}
+function denyOutput(message) {
+  return { hookType: "deny", message: `[tg] ${neutralizeOutsideFences(message)}` };
+}
+function contextOutput(context, correlators) {
+  return correlators === void 0 ? { hookType: "context", context } : { hookType: "context", context, correlators };
+}
+function emitRewrite(updatedOutput, detail, savings, redaction = "count-here") {
+  if (detectHarness() === "vscode") return passOutput();
+  if (redaction === "count-here") {
+    const count = countRedactionPlaceholders(updatedOutput);
+    if (count > 0) recordStat("secret_redacted", 0, count, void 0, detail);
+  }
+  if (savings !== void 0) {
+    const bytesSaved = savings.originalBytes - Buffer.byteLength(updatedOutput, "utf-8");
+    const credited = Math.max(0, bytesSaved);
+    recordStat(savings.kind, credited, savedTokensFromBytes(credited), void 0, savings.detail);
+  }
+  return { hookType: "rewriteOutput", updatedOutput };
+}
+function emitRewriteIfChanged(original, emitted, detail) {
+  if (emitted === original) return passOutput();
+  return emitRewrite(emitted, detail);
+}
+function countNonEmptyLines(text) {
+  return text.split(/\r\n|\r|\n/).filter((line) => line.length > 0).length;
+}
+function estimateResultCount(text) {
+  const firstLine = text.split(/\r\n|\r|\n/).find((line) => line.trim().length > 0);
+  if (firstLine !== void 0) {
+    const trimmed = firstLine.trim();
+    if (/^No (?:files|matches) found\.?$/i.test(trimmed)) return 0;
+    const found = /^Found (\d+) (?:files?|matches?)\.?$/i.exec(trimmed);
+    if (found) return Number.parseInt(found[1], 10);
+  }
+  return countNonEmptyLines(text);
+}
+var RESULT_COUNT_KEYS = ["numFiles", "numLines", "numMatches"];
+function structuredResultCount(raw) {
+  const response = raw["tool_response"];
+  if (response === null || typeof response !== "object") return null;
+  const counts = RESULT_COUNT_KEYS.map((k) => response[k]).filter((v) => typeof v === "number");
+  return counts.length > 0 ? Math.max(...counts) : null;
+}
+function makeDedupHintHandlers(opts) {
+  const post = (event) => {
+    try {
+      if (getToolName(event) !== opts.toolName) return passOutput();
+      const signature = opts.buildSignature(getToolInput(event));
+      if (signature === null) return passOutput();
+      opts.recordQuery(signature, structuredResultCount(event.raw) ?? estimateResultCount(extractToolResponseField(event.raw, OUTPUT_FIRST_TOOL_RESPONSE_KEYS)));
+      return passOutput();
+    } catch {
+      return passOutput();
+    }
+  };
+  const pre = (event) => {
+    try {
+      if (getToolName(event) !== opts.toolName) return passOutput();
+      const toolInput = getToolInput(event);
+      const signature = opts.buildSignature(toolInput);
+      if (signature === null) return passOutput();
+      const priorCount = opts.getMatchCount(signature);
+      if (priorCount === null) return passOutput();
+      if (priorCount < loadConfig().hints[opts.minMatchesConfigKey]) return passOutput();
+      recordStat(opts.statName, 0, 0);
+      const pattern = displaySafeText(typeof toolInput["pattern"] === "string" ? toolInput["pattern"] : "");
+      return contextOutput(
+        "Note: an identical " + opts.toolName + ' for "' + pattern + '" already ran this session and returned ' + priorCount + (priorCount === 1 ? " match" : " matches") + ". If that result already answers this, you can skip re-running it."
+      );
+    } catch {
+      return passOutput();
+    }
+  };
+  return { post, pre };
+}
+
+// src/vscode_path_gate.ts
+init_define_import_meta_env();
+import * as path from "node:path";
+function resolvesToUncPath(target, cwd) {
+  try {
+    return isUncOrDevicePath(path.resolve(cwd ?? process.cwd(), target));
+  } catch {
+    return false;
+  }
+}
+function vscodePathAllowed(filePath, workspace) {
+  if (isUncOrDevicePath(filePath)) return false;
+  if (workspace === void 0 || isUncOrDevicePath(workspace)) return false;
+  const resolvedRoot = path.resolve(workspace);
+  const resolvedTarget = path.resolve(workspace, filePath);
+  const root = foldPathForContainment(resolvedRoot.replace(/\\/g, "/"));
+  const target = foldPathForContainment(resolvedTarget.replace(/\\/g, "/"));
+  if (target !== root && !target.startsWith(root.endsWith("/") ? root : root + "/")) return false;
+  return isInsideRoot(resolvedTarget, resolvedRoot);
+}
+function isVscodeEvent(event) {
+  return event.raw["_tg_harness"] === "vscode" || event.raw[VSCODE_TOOL_NAME_KEY] !== void 0;
+}
+function preToolPathDeclined(event, target) {
+  if (target === void 0) return false;
+  const cwd = getCwd(event);
+  if (isUncOrDevicePath(target) || resolvesToUncPath(target, cwd)) return true;
+  if (isVscodeEvent(event)) return !vscodePathAllowed(target, cwd);
+  return escapesOntoNetworkThroughLinks(target, cwd);
+}
+function commandPathIsTouchable(filePath, event) {
+  if (event === void 0) return !escapesOntoNetworkThroughLinks(filePath);
+  return !preToolPathDeclined(event, filePath);
+}
+
+// src/delivering_deny.ts
+init_define_import_meta_env();
+var DELIVERS_CONTENT_RE = /is inlined below instead of the full body|headings below instead of the full body|in place of the full file/;
+
+export {
+  getToolName,
+  getToolInput,
+  getFilePath,
+  getCwd,
+  getTranscriptPath,
+  extractToolResponseField,
+  replaceToolResponseField,
+  OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
+  BODY_FIRST_TOOL_RESPONSE_KEYS,
+  isMcpErrorResponse,
+  extractToolResultText,
+  mcpContentBlocks,
+  isTextualContentBlock,
+  withPreservedBlocks,
+  passOutput,
+  denyOutput,
+  contextOutput,
+  emitRewrite,
+  emitRewriteIfChanged,
+  estimateResultCount,
+  structuredResultCount,
+  makeDedupHintHandlers,
+  GEMINI_TOOL_NAME_MAP,
+  VSCODE_TOOL_NAME_KEY,
+  vscodeNativeToolInput,
+  normalizePayload,
+  vscodePathAllowed,
+  preToolPathDeclined,
+  commandPathIsTouchable,
+  stripUnsafeSuggestions,
+  leadWithCommand,
+  DELIVERS_CONTENT_RE
+};