@zyycn/claudex 1.0.3-fork.3767904

package/dist/chunk-xx6h50zt.js

@@ -0,0 +1,338 @@
+// @bun
+import {
+  BROWSER_TOOLS,
+  init_src
+} from "./chunk-gyj242zr.js";
+import {
+  getChromeSystemPrompt,
+  init_prompt
+} from "./chunk-k2qkkhf9.js";
+import {
+  CLAUDE_IN_CHROME_MCP_SERVER_NAME,
+  getAllBrowserDataPaths,
+  getAllNativeMessagingHostsDirs,
+  getAllWindowsRegistryKeys,
+  init_common,
+  openInChrome
+} from "./chunk-j5hc27hv.js";
+import {
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getGlobalConfig,
+  init_config1 as init_config,
+  init_growthbook,
+  saveGlobalConfig
+} from "./chunk-z06751ss.js";
+import {
+  getPlatform,
+  init_platform
+} from "./chunk-nj17bhkh.js";
+import {
+  init_bundledMode,
+  isInBundledMode
+} from "./chunk-wn2268qd.js";
+import {
+  execFileNoThrowWithCwd,
+  init_execFileNoThrow
+} from "./chunk-gzzfhtdv.js";
+import {
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  isFsInaccessible,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils,
+  isEnvDefinedFalsy,
+  isEnvTruthy
+} from "./chunk-raqgs410.js";
+import {
+  getIsInteractive,
+  getIsNonInteractiveSession,
+  getSessionBypassPermissionsMode,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/claudeInChrome/setupPortable.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+function getExtensionIds() {
+  return process.env.USER_TYPE === "ant" ? [PROD_EXTENSION_ID, DEV_EXTENSION_ID, ANT_EXTENSION_ID] : [PROD_EXTENSION_ID];
+}
+async function detectExtensionInstallationPortable(browserPaths, log) {
+  if (browserPaths.length === 0) {
+    log?.(`[Claude in Chrome] No browser paths to check`);
+    return { isInstalled: false, browser: null };
+  }
+  const extensionIds = getExtensionIds();
+  for (const { browser, path: browserBasePath } of browserPaths) {
+    let browserProfileEntries = [];
+    try {
+      browserProfileEntries = await readdir(browserBasePath, {
+        withFileTypes: true
+      });
+    } catch (e) {
+      if (isFsInaccessible(e))
+        continue;
+      throw e;
+    }
+    const profileDirs = browserProfileEntries.filter((entry) => entry.isDirectory()).filter((entry) => entry.name === "Default" || entry.name.startsWith("Profile ")).map((entry) => entry.name);
+    if (profileDirs.length > 0) {
+      log?.(`[Claude in Chrome] Found ${browser} profiles: ${profileDirs.join(", ")}`);
+    }
+    for (const profile of profileDirs) {
+      for (const extensionId of extensionIds) {
+        const extensionPath = join(browserBasePath, profile, "Extensions", extensionId);
+        try {
+          await readdir(extensionPath);
+          log?.(`[Claude in Chrome] Extension ${extensionId} found in ${browser} ${profile}`);
+          return { isInstalled: true, browser };
+        } catch {}
+      }
+    }
+  }
+  log?.(`[Claude in Chrome] Extension not found in any browser`);
+  return { isInstalled: false, browser: null };
+}
+async function isChromeExtensionInstalledPortable(browserPaths, log) {
+  const result = await detectExtensionInstallationPortable(browserPaths, log);
+  return result.isInstalled;
+}
+var PROD_EXTENSION_ID = "fcoeoabgfenejglbffodgkkbkcdhcgfn", DEV_EXTENSION_ID = "dihbgbndebgnbjfmelmegjepbnkhlgni", ANT_EXTENSION_ID = "dngcpimnedloihjnnfngkgjoidhnaolf";
+var init_setupPortable = __esm(() => {
+  init_errors();
+});
+
+// src/utils/claudeInChrome/setup.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { fileURLToPath } from "url";
+function shouldEnableClaudeInChrome(chromeFlag) {
+  if (getIsNonInteractiveSession() && chromeFlag !== true) {
+    return false;
+  }
+  if (chromeFlag === true) {
+    return true;
+  }
+  if (chromeFlag === false) {
+    return false;
+  }
+  if (isEnvTruthy(process.env.CLAUDE_CODE_ENABLE_CFC)) {
+    return true;
+  }
+  if (isEnvDefinedFalsy(process.env.CLAUDE_CODE_ENABLE_CFC)) {
+    return false;
+  }
+  const config = getGlobalConfig();
+  if (config.claudeInChromeDefaultEnabled !== undefined) {
+    return config.claudeInChromeDefaultEnabled;
+  }
+  return false;
+}
+function shouldAutoEnableClaudeInChrome() {
+  if (shouldAutoEnable !== undefined) {
+    return shouldAutoEnable;
+  }
+  shouldAutoEnable = getIsInteractive() && isChromeExtensionInstalled_CACHED_MAY_BE_STALE() && (process.env.USER_TYPE === "ant" || getFeatureValue_CACHED_MAY_BE_STALE("tengu_chrome_auto_enable", false));
+  return shouldAutoEnable;
+}
+function setupClaudeInChrome() {
+  const isNativeBuild = isInBundledMode();
+  const allowedTools = BROWSER_TOOLS.map((tool) => `mcp__claude-in-chrome__${tool.name}`);
+  const env = {};
+  if (getSessionBypassPermissionsMode()) {
+    env.CLAUDE_CHROME_PERMISSION_MODE = "skip_all_permission_checks";
+  }
+  const hasEnv = Object.keys(env).length > 0;
+  if (isNativeBuild) {
+    const execCommand = `"${process.execPath}" --chrome-native-host`;
+    createWrapperScript(execCommand).then((manifestBinaryPath) => installChromeNativeHostManifest(manifestBinaryPath)).catch((e) => logForDebugging(`[Claude in Chrome] Failed to install native host: ${e}`, { level: "error" }));
+    return {
+      mcpConfig: {
+        [CLAUDE_IN_CHROME_MCP_SERVER_NAME]: {
+          type: "stdio",
+          command: process.execPath,
+          args: ["--claude-in-chrome-mcp"],
+          scope: "dynamic",
+          ...hasEnv && { env }
+        }
+      },
+      allowedTools,
+      systemPrompt: getChromeSystemPrompt()
+    };
+  } else {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = join2(__filename2, "..");
+    const cliPath = join2(__dirname2, "cli.js");
+    createWrapperScript(`"${process.execPath}" "${cliPath}" --chrome-native-host`).then((manifestBinaryPath) => installChromeNativeHostManifest(manifestBinaryPath)).catch((e) => logForDebugging(`[Claude in Chrome] Failed to install native host: ${e}`, { level: "error" }));
+    const mcpConfig = {
+      [CLAUDE_IN_CHROME_MCP_SERVER_NAME]: {
+        type: "stdio",
+        command: process.execPath,
+        args: [`${cliPath}`, "--claude-in-chrome-mcp"],
+        scope: "dynamic",
+        ...hasEnv && { env }
+      }
+    };
+    return {
+      mcpConfig,
+      allowedTools,
+      systemPrompt: getChromeSystemPrompt()
+    };
+  }
+}
+function getNativeMessagingHostsDirs() {
+  const platform = getPlatform();
+  if (platform === "windows") {
+    const home = homedir();
+    const appData = process.env.APPDATA || join2(home, "AppData", "Local");
+    return [join2(appData, "Claude Code", "ChromeNativeHost")];
+  }
+  return getAllNativeMessagingHostsDirs().map(({ path }) => path);
+}
+async function installChromeNativeHostManifest(manifestBinaryPath) {
+  const manifestDirs = getNativeMessagingHostsDirs();
+  if (manifestDirs.length === 0) {
+    throw Error("Claude in Chrome Native Host not supported on this platform");
+  }
+  const manifest = {
+    name: NATIVE_HOST_IDENTIFIER,
+    description: "Claude Code Browser Extension Native Host",
+    path: manifestBinaryPath,
+    type: "stdio",
+    allowed_origins: [
+      `chrome-extension://fcoeoabgfenejglbffodgkkbkcdhcgfn/`,
+      ...process.env.USER_TYPE === "ant" ? [
+        "chrome-extension://dihbgbndebgnbjfmelmegjepbnkhlgni/",
+        "chrome-extension://dngcpimnedloihjnnfngkgjoidhnaolf/"
+      ] : []
+    ]
+  };
+  const manifestContent = jsonStringify(manifest, null, 2);
+  let anyManifestUpdated = false;
+  for (const manifestDir of manifestDirs) {
+    const manifestPath = join2(manifestDir, NATIVE_HOST_MANIFEST_NAME);
+    const existingContent = await readFile(manifestPath, "utf-8").catch(() => null);
+    if (existingContent === manifestContent) {
+      continue;
+    }
+    try {
+      await mkdir(manifestDir, { recursive: true });
+      await writeFile(manifestPath, manifestContent);
+      logForDebugging(`[Claude in Chrome] Installed native host manifest at: ${manifestPath}`);
+      anyManifestUpdated = true;
+    } catch (error) {
+      logForDebugging(`[Claude in Chrome] Failed to install manifest at ${manifestPath}: ${error}`);
+    }
+  }
+  if (getPlatform() === "windows") {
+    const manifestPath = join2(manifestDirs[0], NATIVE_HOST_MANIFEST_NAME);
+    registerWindowsNativeHosts(manifestPath);
+  }
+  if (anyManifestUpdated) {
+    isChromeExtensionInstalled().then((isInstalled) => {
+      if (isInstalled) {
+        logForDebugging(`[Claude in Chrome] First-time install detected, opening reconnect page in browser`);
+        openInChrome(CHROME_EXTENSION_RECONNECT_URL);
+      } else {
+        logForDebugging(`[Claude in Chrome] First-time install detected, but extension not installed, skipping reconnect`);
+      }
+    });
+  }
+}
+function registerWindowsNativeHosts(manifestPath) {
+  const registryKeys = getAllWindowsRegistryKeys();
+  for (const { browser, key } of registryKeys) {
+    const fullKey = `${key}\\${NATIVE_HOST_IDENTIFIER}`;
+    execFileNoThrowWithCwd("reg", [
+      "add",
+      fullKey,
+      "/ve",
+      "/t",
+      "REG_SZ",
+      "/d",
+      manifestPath,
+      "/f"
+    ]).then((result) => {
+      if (result.code === 0) {
+        logForDebugging(`[Claude in Chrome] Registered native host for ${browser} in Windows registry: ${fullKey}`);
+      } else {
+        logForDebugging(`[Claude in Chrome] Failed to register native host for ${browser} in Windows registry: ${result.stderr}`);
+      }
+    });
+  }
+}
+async function createWrapperScript(command) {
+  const platform = getPlatform();
+  const chromeDir = join2(getClaudeConfigHomeDir(), "chrome");
+  const wrapperPath = platform === "windows" ? join2(chromeDir, "chrome-native-host.bat") : join2(chromeDir, "chrome-native-host");
+  const scriptContent = platform === "windows" ? `@echo off
+REM Chrome native host wrapper script
+REM Generated by Claude Code - do not edit manually
+${command}
+` : `#!/bin/sh
+# Chrome native host wrapper script
+# Generated by Claude Code - do not edit manually
+exec ${command}
+`;
+  const existingContent = await readFile(wrapperPath, "utf-8").catch(() => null);
+  if (existingContent === scriptContent) {
+    return wrapperPath;
+  }
+  await mkdir(chromeDir, { recursive: true });
+  await writeFile(wrapperPath, scriptContent);
+  if (platform !== "windows") {
+    await chmod(wrapperPath, 493);
+  }
+  logForDebugging(`[Claude in Chrome] Created Chrome native host wrapper script: ${wrapperPath}`);
+  return wrapperPath;
+}
+function isChromeExtensionInstalled_CACHED_MAY_BE_STALE() {
+  isChromeExtensionInstalled().then((isInstalled) => {
+    if (!isInstalled) {
+      return;
+    }
+    const config = getGlobalConfig();
+    if (config.cachedChromeExtensionInstalled !== isInstalled) {
+      saveGlobalConfig((prev) => ({
+        ...prev,
+        cachedChromeExtensionInstalled: isInstalled
+      }));
+    }
+  });
+  const cached = getGlobalConfig().cachedChromeExtensionInstalled;
+  return cached ?? false;
+}
+async function isChromeExtensionInstalled() {
+  const browserPaths = getAllBrowserDataPaths();
+  if (browserPaths.length === 0) {
+    logForDebugging(`[Claude in Chrome] Unsupported platform for extension detection: ${getPlatform()}`);
+    return false;
+  }
+  return isChromeExtensionInstalledPortable(browserPaths, logForDebugging);
+}
+var CHROME_EXTENSION_RECONNECT_URL = "https://clau.de/chrome/reconnect", NATIVE_HOST_IDENTIFIER = "com.anthropic.claude_code_browser_extension", NATIVE_HOST_MANIFEST_NAME, shouldAutoEnable = undefined;
+var init_setup = __esm(() => {
+  init_src();
+  init_state();
+  init_growthbook();
+  init_bundledMode();
+  init_config();
+  init_debug();
+  init_envUtils();
+  init_execFileNoThrow();
+  init_platform();
+  init_slowOperations();
+  init_common();
+  init_prompt();
+  init_setupPortable();
+  NATIVE_HOST_MANIFEST_NAME = `${NATIVE_HOST_IDENTIFIER}.json`;
+});
+
+export { shouldEnableClaudeInChrome, shouldAutoEnableClaudeInChrome, setupClaudeInChrome, isChromeExtensionInstalled, init_setup };

package/dist/chunk-y1784krc.js

@@ -0,0 +1,19 @@
+// @bun
+import {
+  exitWithError,
+  init_process,
+  peekForStdinData,
+  registerProcessOutputErrorHandlers,
+  writeToStderr,
+  writeToStdout
+} from "./chunk-fbv4apne.js";
+import"./chunk-qp2qdcda.js";
+init_process();
+
+export {
+  writeToStdout,
+  writeToStderr,
+  registerProcessOutputErrorHandlers,
+  peekForStdinData,
+  exitWithError
+};

package/dist/chunk-yfcsc3s4.js

@@ -0,0 +1,153 @@
+// @bun
+import {
+  AGENT_COLORS,
+  getTranscriptPath,
+  init_agentColorManager,
+  init_sessionStorage,
+  saveAgentColor
+} from "./chunk-njmw3yt4.js";
+import"./chunk-j0xd989k.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-a8fvd2bk.js";
+import"./chunk-pkcx8qa3.js";
+import"./chunk-er596fa7.js";
+import"./chunk-ddk0ak7r.js";
+import"./chunk-k2qkkhf9.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-1ed0q5rg.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-khs0jvy0.js";
+import"./chunk-p4qrpz5a.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-pxy618ae.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-tnd5xbeh.js";
+import"./chunk-8aww16wk.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-f2xj33w0.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-tssr3fyd.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-pkb4qnmq.js";
+import"./chunk-z06751ss.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-9nta4x35.js";
+import {
+  init_teammate,
+  isTeammate
+} from "./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-w8yw30sd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/color/color.ts
+async function call(onDone, context, args) {
+  if (isTeammate()) {
+    onDone("Cannot set color: This session is a swarm teammate. Teammate colors are assigned by the team leader.", { display: "system" });
+    return null;
+  }
+  if (!args || args.trim() === "") {
+    const colorList = AGENT_COLORS.join(", ");
+    onDone(`Please provide a color. Available colors: ${colorList}, default`, {
+      display: "system"
+    });
+    return null;
+  }
+  const colorArg = args.trim().toLowerCase();
+  if (RESET_ALIASES.includes(colorArg)) {
+    const sessionId2 = getSessionId();
+    const fullPath2 = getTranscriptPath();
+    await saveAgentColor(sessionId2, "default", fullPath2);
+    context.setAppState((prev) => ({
+      ...prev,
+      standaloneAgentContext: {
+        ...prev.standaloneAgentContext,
+        name: prev.standaloneAgentContext?.name ?? "",
+        color: undefined
+      }
+    }));
+    onDone("Session color reset to default", { display: "system" });
+    return null;
+  }
+  if (!AGENT_COLORS.includes(colorArg)) {
+    const colorList = AGENT_COLORS.join(", ");
+    onDone(`Invalid color "${colorArg}". Available colors: ${colorList}, default`, { display: "system" });
+    return null;
+  }
+  const sessionId = getSessionId();
+  const fullPath = getTranscriptPath();
+  await saveAgentColor(sessionId, colorArg, fullPath);
+  context.setAppState((prev) => ({
+    ...prev,
+    standaloneAgentContext: {
+      ...prev.standaloneAgentContext,
+      name: prev.standaloneAgentContext?.name ?? "",
+      color: colorArg
+    }
+  }));
+  onDone(`Session color set to: ${colorArg}`, { display: "system" });
+  return null;
+}
+var RESET_ALIASES;
+var init_color = __esm(() => {
+  init_state();
+  init_agentColorManager();
+  init_sessionStorage();
+  init_teammate();
+  RESET_ALIASES = ["default", "reset", "none", "gray", "grey"];
+});
+init_color();
+
+export {
+  call
+};

package/dist/chunk-yngvgvqm.js

@@ -0,0 +1,103 @@
+// @bun
+import {
+  extractDiscoveredToolNames,
+  getAutoToolSearchCharThreshold,
+  getDeferredToolsDelta,
+  getToolSearchMode,
+  init_toolSearch,
+  isDeferredToolsDeltaEnabled,
+  isToolReferenceBlock,
+  isToolSearchEnabled,
+  isToolSearchEnabledOptimistic,
+  isToolSearchToolAvailable,
+  modelSupportsToolReference
+} from "./chunk-njmw3yt4.js";
+import"./chunk-j0xd989k.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-a8fvd2bk.js";
+import"./chunk-pkcx8qa3.js";
+import"./chunk-er596fa7.js";
+import"./chunk-ddk0ak7r.js";
+import"./chunk-k2qkkhf9.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-1ed0q5rg.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-khs0jvy0.js";
+import"./chunk-p4qrpz5a.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-pxy618ae.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-tnd5xbeh.js";
+import"./chunk-8aww16wk.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-f2xj33w0.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-tssr3fyd.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-pkb4qnmq.js";
+import"./chunk-z06751ss.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-9nta4x35.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-w8yw30sd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_toolSearch();
+
+export {
+  modelSupportsToolReference,
+  isToolSearchToolAvailable,
+  isToolSearchEnabledOptimistic,
+  isToolSearchEnabled,
+  isToolReferenceBlock,
+  isDeferredToolsDeltaEnabled,
+  getToolSearchMode,
+  getDeferredToolsDelta,
+  getAutoToolSearchCharThreshold,
+  extractDiscoveredToolNames
+};