gsd-pi 2.27.0 → 2.28.0-dev.346ee62

package/dist/resources/extensions/gsd/worktree-command.ts

@@ -12,9 +12,9 @@
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 import { loadPrompt } from "./prompt-loader.js";
-import { autoCommitCurrentBranch } from "./worktree.js";
+import { autoCommitCurrentBranch, getMainBranch, resolveGitHeadPath, nudgeGitBranchCache } from "./worktree.js";
 import { runWorktreePostCreateHook } from "./auto-worktree.js";
-import { showConfirm } from "../shared/confirm-ui.js";
+import { showConfirm } from "../shared/mod.js";
 import { gsdRoot, milestonesDir } from "./paths.js";
 import {
   createWorktree,
@@ -23,7 +23,6 @@ import {
   mergeWorktreeToMain,
   diffWorktreeAll,
   diffWorktreeNumstat,
-  getMainBranch,
   getWorktreeGSDDiff,
   getWorktreeCodeDiff,
   getWorktreeLog,
@@ -32,9 +31,9 @@ import {
 } from "./worktree-manager.js";
 import { inferCommitType } from "./git-service.js";
 import type { FileLineStat } from "./worktree-manager.js";
-import { existsSync, realpathSync, readFileSync, readdirSync, rmSync, unlinkSync, utimesSync } from "node:fs";
+import { existsSync, realpathSync, readdirSync, rmSync, unlinkSync } from "node:fs";
 import { nativeMergeAbort } from "./native-git-bridge.js";
-import { join, resolve, sep } from "node:path";
+import { join, sep } from "node:path";
 
 /**
  * Tracks the original project root so we can switch back.
@@ -47,52 +46,6 @@ export function getWorktreeOriginalCwd(): string | null {
   return originalCwd;
 }
 
-/**
- * Resolve the git HEAD file path for a given directory.
- * Handles both normal repos (.git is a directory) and worktrees (.git is a file).
- */
-function resolveGitHeadPath(dir: string): string | null {
-  const gitPath = join(dir, ".git");
-  if (!existsSync(gitPath)) return null;
-
-  try {
-    const content = readFileSync(gitPath, "utf8").trim();
-    if (content.startsWith("gitdir: ")) {
-      // Worktree — .git is a file pointing to the real gitdir
-      const gitDir = resolve(dir, content.slice(8));
-      const headPath = join(gitDir, "HEAD");
-      return existsSync(headPath) ? headPath : null;
-    }
-    // Normal repo — .git is a directory
-    const headPath = join(dir, ".git", "HEAD");
-    return existsSync(headPath) ? headPath : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Nudge pi's FooterDataProvider to re-read the git branch.
- *
- * The footer caches the branch and watches a single .git dir for changes.
- * After process.chdir() into a worktree (or back), the watcher is stale —
- * it's still watching the old git dir. We touch HEAD in both the old and
- * new git dirs to ensure the watcher fires regardless of which one it's
- * monitoring. This clears cachedBranch; the next getGitBranch() call uses
- * the new process.cwd() and picks up the correct branch.
- */
-function nudgeGitBranchCache(previousCwd: string): void {
-  const now = new Date();
-  for (const dir of [previousCwd, process.cwd()]) {
-    try {
-      const headPath = resolveGitHeadPath(dir);
-      if (headPath) utimesSync(headPath, now, now);
-    } catch {
-      // Best-effort — branch display may be stale
-    }
-  }
-}
-
 /** Get the name of the active worktree, or null if not in one. */
 export function getActiveWorktreeName(): string | null {
   if (!originalCwd) return null;

package/dist/resources/extensions/gsd/worktree-manager.ts

@@ -17,6 +17,7 @@
 
 import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
+import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERROR, GSD_MERGE_CONFLICT } from "./errors.js";
 import {
   nativeBranchDelete,
   nativeBranchExists,
@@ -70,10 +71,6 @@ function normalizePathForComparison(path: string): string {
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 
-export function getMainBranch(basePath: string): string {
-  return nativeDetectMainBranch(basePath);
-}
-
 // ─── resolveGitDir ─────────────────────────────────────────────────────────
 
 /**
@@ -125,14 +122,14 @@ export function worktreeBranchName(name: string): string {
 export function createWorktree(basePath: string, name: string, opts: { branch?: string; startPoint?: string; reuseExistingBranch?: boolean } = {}): WorktreeInfo {
   // Validate name: alphanumeric, hyphens, underscores only
   if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
-    throw new Error(`Invalid worktree name "${name}". Use only letters, numbers, hyphens, and underscores.`);
+    throw new GSDError(GSD_PARSE_ERROR, `Invalid worktree name "${name}". Use only letters, numbers, hyphens, and underscores.`);
   }
 
   const wtPath = worktreePath(basePath, name);
   const branch = opts.branch ?? worktreeBranchName(name);
 
   if (existsSync(wtPath)) {
-    throw new Error(`Worktree "${name}" already exists at ${wtPath}`);
+    throw new GSDError(GSD_STALE_STATE, `Worktree "${name}" already exists at ${wtPath}`);
   }
 
   // Ensure the .gsd/worktrees/ directory exists
@@ -155,7 +152,8 @@ export function createWorktree(basePath: string, name: string, opts: { branch?:
     const branchInUse = worktreeEntries.some(entry => entry.branch === branch);
 
     if (branchInUse) {
-      throw new Error(
+      throw new GSDError(
+        GSD_LOCK_HELD,
         `Branch "${branch}" is already in use by another worktree. ` +
         `Remove the existing worktree first with /worktree remove ${name}.`,
       );
@@ -436,12 +434,12 @@ export function mergeWorktreeToMain(basePath: string, name: string, commitMessag
   const current = nativeGetCurrentBranch(basePath);
 
   if (current !== mainBranch) {
-    throw new Error(`Must be on ${mainBranch} to merge. Currently on ${current}.`);
+    throw new GSDError(GSD_GIT_ERROR, `Must be on ${mainBranch} to merge. Currently on ${current}.`);
   }
 
   const result = nativeMergeSquash(basePath, branch);
   if (!result.success) {
-    throw new Error(`Merge conflicts detected in: ${result.conflicts.join(", ")}`);
+    throw new GSDError(GSD_MERGE_CONFLICT, `Merge conflicts detected in: ${result.conflicts.join(", ")}`);
   }
 
   nativeCommit(basePath, commitMessage);

package/dist/resources/extensions/gsd/worktree.ts

@@ -12,7 +12,8 @@
  * SLICE_BRANCH_RE) remain for backwards compatibility with legacy branches.
  */
 
-import { sep } from "node:path";
+import { existsSync, readFileSync, utimesSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
 
 import { GitServiceImpl, writeIntegrationBranch, type TaskCommitContext } from "./git-service.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -177,4 +178,43 @@ export function autoCommitCurrentBranch(
   return getService(basePath).autoCommit(unitType, unitId, [], taskContext);
 }
 
+// ─── Git HEAD Resolution ────────────────────────────────────────────────────
 
+/**
+ * Resolve the git HEAD file path for a given directory.
+ * Handles both normal repos (.git is a directory) and worktrees (.git is a file
+ * containing a `gitdir:` pointer to the real gitdir).
+ */
+export function resolveGitHeadPath(dir: string): string | null {
+  const gitPath = join(dir, ".git");
+  if (!existsSync(gitPath)) return null;
+
+  try {
+    const content = readFileSync(gitPath, "utf8").trim();
+    if (content.startsWith("gitdir: ")) {
+      const gitDir = resolve(dir, content.slice(8));
+      const headPath = join(gitDir, "HEAD");
+      return existsSync(headPath) ? headPath : null;
+    }
+    const headPath = join(dir, ".git", "HEAD");
+    return existsSync(headPath) ? headPath : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Nudge pi's FooterDataProvider to re-read the git branch after chdir.
+ * Touches HEAD in both old and new cwd to fire the fs watcher.
+ */
+export function nudgeGitBranchCache(previousCwd: string): void {
+  const now = new Date();
+  for (const dir of [previousCwd, process.cwd()]) {
+    try {
+      const headPath = resolveGitHeadPath(dir);
+      if (headPath) utimesSync(headPath, now, now);
+    } catch {
+      // Best-effort
+    }
+  }
+}

package/dist/resources/extensions/mcporter/index.ts

@@ -102,22 +102,34 @@ async function runMcporter(
 }
 
 /**
- * Read .mcp.json from the project root (cwd) and return servers not already
- * discovered by mcporter. This bridges the gap where mcporter doesn't scan
- * the standard .mcp.json config used by Claude Code, Cursor, etc.
+ * Read MCP server configs from project-level files (.mcp.json and .gsd/mcp.json)
+ * and return servers not already discovered by mcporter.
+ *
+ * Search order:
+ *   1. .mcp.json (Claude Code / Cursor standard)
+ *   2. .gsd/mcp.json (GSD-specific per-project config, #716)
+ *
+ * Project config overrides global — servers found here take precedence over
+ * identically-named servers from mcporter's global discovery.
  */
 function readProjectMcpJson(knownNames: Set<string>): McpServer[] {
 	const servers: McpServer[] = [];
-	try {
-		const mcpJsonPath = join(process.cwd(), ".mcp.json");
-		if (!existsSync(mcpJsonPath)) return servers;
-		const raw = readFileSync(mcpJsonPath, "utf-8");
-		const data = JSON.parse(raw) as Record<string, unknown>;
-		const mcpServers = (data.mcpServers ?? data.servers) as Record<string, Record<string, unknown>> | undefined;
-		if (!mcpServers || typeof mcpServers !== "object") return servers;
+	const configPaths = [
+		join(process.cwd(), ".mcp.json"),
+		join(process.cwd(), ".gsd", "mcp.json"),
+	];
 
-		for (const [name, config] of Object.entries(mcpServers)) {
-			if (knownNames.has(name)) continue; // Already discovered by mcporter
+	for (const mcpJsonPath of configPaths) {
+		try {
+			if (!existsSync(mcpJsonPath)) continue;
+			const raw = readFileSync(mcpJsonPath, "utf-8");
+			const data = JSON.parse(raw) as Record<string, unknown>;
+			const mcpServers = (data.mcpServers ?? data.servers) as Record<string, Record<string, unknown>> | undefined;
+			if (!mcpServers || typeof mcpServers !== "object") continue;
+
+			for (const [name, config] of Object.entries(mcpServers)) {
+				if (knownNames.has(name)) continue; // Already discovered
+				knownNames.add(name); // Prevent duplicates across config files
 			const transport = (config.type as string) ?? (config.command ? "stdio" : config.url ? "http" : "unknown");
 			servers.push({
 				name,
@@ -126,8 +138,9 @@ function readProjectMcpJson(knownNames: Set<string>): McpServer[] {
 				tools: [], // Tools unknown until mcp_discover is called
 			});
 		}
-	} catch {
-		// Non-fatal — .mcp.json may not exist or be malformed
+		} catch {
+			// Non-fatal — config file may not exist or be malformed
+		}
 	}
 	return servers;
 }

package/dist/resources/extensions/remote-questions/manager.ts

@@ -9,6 +9,7 @@ import { DiscordAdapter } from "./discord-adapter.js";
 import { SlackAdapter } from "./slack-adapter.js";
 import { TelegramAdapter } from "./telegram-adapter.js";
 import { createPromptRecord, writePromptRecord, markPromptAnswered, markPromptDispatched, markPromptStatus, updatePromptRecord } from "./store.js";
+import { sanitizeError } from "../shared/sanitize.js";
 
 interface ToolResult {
   content: Array<{ type: "text"; text: string }>;
@@ -70,7 +71,7 @@ export async function tryRemoteQuestions(
         channel: config.channel,
         timed_out: true,
         promptId: prompt.id,
-        threadUrl: dispatch.ref.threadUrl,
+        threadUrl: dispatch.ref.threadUrl ?? null,
         status: signal?.aborted ? "cancelled" : "timed_out",
       },
     };
@@ -79,11 +80,9 @@ export async function tryRemoteQuestions(
   markPromptAnswered(prompt.id, answer);
 
   // Best-effort acknowledgement gives remote users a visible receipt signal.
-  if (dispatch.ref) {
-    try {
-      await adapter.acknowledgeAnswer?.(dispatch.ref);
-    } catch { /* best-effort */ }
-  }
+  try {
+    await adapter.acknowledgeAnswer?.(dispatch.ref);
+  } catch { /* best-effort */ }
 
   return {
     content: [{ type: "text", text: JSON.stringify({ answers: formatForTool(answer) }) }],
@@ -92,7 +91,7 @@ export async function tryRemoteQuestions(
       channel: config.channel,
       timed_out: false,
       promptId: prompt.id,
-      threadUrl: dispatch.ref.threadUrl,
+      threadUrl: dispatch.ref.threadUrl ?? null,
       questions,
       response: answer,
       status: "answered",
@@ -177,23 +176,6 @@ function formatForTool(answer: RemoteAnswer): Record<string, { answers: string[]
   return out;
 }
 
-// Strip token-like strings from error messages before surfacing
-const TOKEN_PATTERNS = [
-  /xoxb-[A-Za-z0-9\-]+/g,    // Slack bot tokens
-  /xoxp-[A-Za-z0-9\-]+/g,    // Slack user tokens
-  /xoxa-[A-Za-z0-9\-]+/g,    // Slack app tokens
-  /\d{8,10}:[A-Za-z0-9_-]{35}/g, // Telegram bot tokens
-  /[A-Za-z0-9_\-.]{20,}/g,   // Long opaque secrets (Discord tokens, etc.)
-];
-
-export function sanitizeError(msg: string): string {
-  let sanitized = msg;
-  for (const pattern of TOKEN_PATTERNS) {
-    sanitized = sanitized.replace(pattern, "[REDACTED]");
-  }
-  return sanitized;
-}
-
 function errorResult(message: string, channel: string): ToolResult {
   return {
     content: [{ type: "text", text: sanitizeError(message) }],

package/dist/resources/extensions/remote-questions/mod.ts

@@ -0,0 +1,16 @@
+// Barrel file — re-exports consumed by external modules
+
+export { handleRemote } from "./remote-command.js";
+export { createPromptRecord, writePromptRecord } from "./store.js";
+export { getLatestPromptSummary } from "./status.js";
+export {
+	parseSlackReply,
+	parseDiscordResponse,
+	formatForDiscord,
+	formatForSlack,
+	parseSlackReactionResponse,
+	formatForTelegram,
+	parseTelegramResponse,
+} from "./format.js";
+export { resolveRemoteConfig, isValidChannelId } from "./config.js";
+export { sendRemoteNotification } from "./notify.js";

package/dist/resources/extensions/remote-questions/notify.ts

@@ -0,0 +1,91 @@
+/**
+ * Remote Notifications — one-way alert delivery to configured channels.
+ *
+ * Sends informational messages to Slack/Discord/Telegram without expecting
+ * a reply. Used for auto-mode events like secrets-required pauses where
+ * the user needs to be notified but should NOT send sensitive data back
+ * through the channel.
+ */
+
+import { resolveRemoteConfig } from "./config.js";
+import type { ResolvedConfig } from "./config.js";
+
+const PER_REQUEST_TIMEOUT_MS = 15_000;
+
+/**
+ * Send a one-way notification to the configured remote channel.
+ * Non-blocking, non-fatal — failures are silently ignored.
+ *
+ * SECURITY: This is intentionally one-way. Never use remote channels
+ * to collect secrets or sensitive values.
+ */
+export async function sendRemoteNotification(title: string, message: string): Promise<void> {
+  let config: ResolvedConfig | null;
+  try {
+    config = resolveRemoteConfig();
+  } catch {
+    return; // Remote not configured — skip silently
+  }
+  if (!config) return;
+
+  try {
+    switch (config.channel) {
+      case "slack":
+        await sendSlackNotification(config, title, message);
+        break;
+      case "discord":
+        await sendDiscordNotification(config, title, message);
+        break;
+      case "telegram":
+        await sendTelegramNotification(config, title, message);
+        break;
+    }
+  } catch {
+    // Non-fatal — remote notifications are best-effort
+  }
+}
+
+async function sendSlackNotification(config: ResolvedConfig, title: string, message: string): Promise<void> {
+  const response = await fetch(`https://slack.com/api/chat.postMessage`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.token}`,
+      "Content-Type": "application/json; charset=utf-8",
+    },
+    body: JSON.stringify({
+      channel: config.channelId,
+      text: `⚠️ *${title}*\n${message}`,
+    }),
+    signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+  });
+  if (!response.ok) throw new Error(`Slack HTTP ${response.status}`);
+}
+
+async function sendDiscordNotification(config: ResolvedConfig, title: string, message: string): Promise<void> {
+  const response = await fetch(`https://discord.com/api/v10/channels/${config.channelId}/messages`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bot ${config.token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      content: `⚠️ **${title}**\n${message}`,
+    }),
+    signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+  });
+  if (!response.ok) throw new Error(`Discord HTTP ${response.status}`);
+}
+
+async function sendTelegramNotification(config: ResolvedConfig, title: string, message: string): Promise<void> {
+  const response = await fetch(`https://api.telegram.org/bot${config.token}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      chat_id: config.channelId,
+      text: `⚠️ *${title}*\n${message}`,
+      parse_mode: "Markdown",
+    }),
+    signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+  });
+  if (!response.ok) throw new Error(`Telegram HTTP ${response.status}`);
+}

package/dist/resources/extensions/remote-questions/remote-command.ts

@@ -9,7 +9,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getGlobalGSDPreferencesPath, loadEffectiveGSDPreferences } from "../gsd/preferences.js";
 import { getRemoteConfigStatus, isValidChannelId, resolveRemoteConfig } from "./config.js";
-import { sanitizeError } from "./manager.js";
+import { sanitizeError } from "../shared/sanitize.js";
 import { getLatestPromptSummary } from "./status.js";
 
 export async function handleRemote(

package/dist/resources/extensions/remote-questions/store.ts

@@ -51,11 +51,15 @@ export function updatePromptRecord(
 ): RemotePromptRecord | null {
   const current = readPromptRecord(id);
   if (!current) return null;
-  const next: RemotePromptRecord = {
+  const merged = {
     ...current,
     ...updates,
     updatedAt: Date.now(),
   };
+  // After spreading, the merged object satisfies one of the union members
+  // but TypeScript can't prove it statically. The invariant is maintained
+  // by callers: once `ref` is set via markPromptDispatched it is never removed.
+  const next = merged as RemotePromptRecord;
   writePromptRecord(next);
   return next;
 }

package/dist/resources/extensions/remote-questions/types.ts

@@ -44,17 +44,16 @@ export interface RemoteAnswer {
 
 export type RemotePromptStatus = "pending" | "answered" | "timed_out" | "failed" | "cancelled";
 
-export interface RemotePromptRecord {
+/** Shared fields present on every prompt record regardless of dispatch state. */
+interface RemotePromptRecordBase {
   version: 1;
   id: string;
   createdAt: number;
   updatedAt: number;
-  status: RemotePromptStatus;
   channel: RemoteChannel;
   timeoutAt: number;
   pollIntervalMs: number;
   questions: RemoteQuestion[];
-  ref?: RemotePromptRef;
   response?: RemoteAnswer;
   lastPollAt?: number;
   lastError?: string;
@@ -63,6 +62,30 @@ export interface RemotePromptRecord {
   };
 }
 
+/** Record before the prompt has been dispatched to a channel. */
+export interface PendingPromptRecord extends RemotePromptRecordBase {
+  status: "pending";
+  ref?: undefined;
+}
+
+/** Record after the prompt has been dispatched (ref is always present). */
+export interface DispatchedPromptRecord extends RemotePromptRecordBase {
+  status: RemotePromptStatus;
+  ref: RemotePromptRef;
+}
+
+/**
+ * A prompt record is either pre-dispatch (no ref) or post-dispatch (ref required).
+ *
+ * Narrow via `record.ref`:
+ * ```ts
+ * if (record.ref) {
+ *   // DispatchedPromptRecord — ref is RemotePromptRef
+ * }
+ * ```
+ */
+export type RemotePromptRecord = PendingPromptRecord | DispatchedPromptRecord;
+
 export interface RemoteDispatchResult {
   ref: RemotePromptRef;
 }

package/dist/resources/extensions/search-the-web/native-search.ts

@@ -5,6 +5,8 @@
  * the heavy tool-registration modules.
  */
 
+import { resolveSearchProviderFromPreferences } from "../gsd/preferences.js";
+
 /** Tool names for the Brave-backed custom search tools */
 export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
 
@@ -16,6 +18,11 @@ const THINKING_TYPES = new Set(["thinking", "redacted_thinking"]);
 
 /** When true, skip native web search injection and keep Brave/custom tools active on Anthropic. */
 export function preferBraveSearch(): boolean {
+  // preferences.md takes priority over env var
+  const prefsPref = resolveSearchProviderFromPreferences();
+  if (prefsPref === "brave" || prefsPref === "tavily" || prefsPref === "ollama") return true;
+  if (prefsPref === "native") return false;
+  // Fall back to env var
   return process.env.PREFER_BRAVE_SEARCH === "1" || process.env.PREFER_BRAVE_SEARCH === "true";
 }
 

package/dist/resources/extensions/search-the-web/provider.ts

@@ -12,6 +12,7 @@
 import { AuthStorage } from '@gsd/pi-coding-agent'
 import { homedir } from 'os'
 import { join } from 'path'
+import { resolveSearchProviderFromPreferences } from '../gsd/preferences.js'
 
 // Compute authFilePath locally instead of importing from app-paths.ts,
 // because extensions are copied to ~/.gsd/agent/extensions/ at runtime
@@ -34,6 +35,15 @@ export function getBraveApiKey(): string {
   return process.env.BRAVE_API_KEY || ''
 }
 
+/** Standard headers for Brave Search API requests. */
+export function braveHeaders(): Record<string, string> {
+  return {
+    "Accept": "application/json",
+    "Accept-Encoding": "gzip",
+    "X-Subscription-Token": getBraveApiKey(),
+  }
+}
+
 /** Returns the Ollama API key from the environment, or empty string if not set. */
 export function getOllamaApiKey(): string {
   return process.env.OLLAMA_API_KEY || ''
@@ -94,9 +104,11 @@ export function resolveSearchProvider(overridePreference?: string): SearchProvid
   if (overridePreference && VALID_PREFERENCES.has(overridePreference)) {
     pref = overridePreference as SearchProviderPreference
   } else {
-    // Invalid override or no override — read stored preference
-    // If overridePreference is provided but invalid, treat as 'auto'
-    if (overridePreference !== undefined && !VALID_PREFERENCES.has(overridePreference)) {
+    // preferences.md takes priority over auth.json
+    const mdPref = resolveSearchProviderFromPreferences()
+    if (mdPref && mdPref !== 'auto' && mdPref !== 'native') {
+      pref = mdPref as SearchProviderPreference
+    } else if (overridePreference !== undefined && !VALID_PREFERENCES.has(overridePreference)) {
       pref = 'auto'
     } else {
       pref = getSearchProviderPreference()

package/dist/resources/extensions/search-the-web/tool-llm-context.ts

@@ -27,7 +27,7 @@ import { normalizeQuery, extractDomain } from "./url-utils.js";
 import { formatLLMContext, type LLMContextSnippet, type LLMContextSource } from "./format.js";
 import type { TavilyResult, TavilySearchResponse } from "./tavily.js";
 import { publishedDateToAge } from "./tavily.js";
-import { getTavilyApiKey, getOllamaApiKey, resolveSearchProvider } from "./provider.js";
+import { getTavilyApiKey, getOllamaApiKey, getBraveApiKey, braveHeaders, resolveSearchProvider } from "./provider.js";
 
 // =============================================================================
 // Types
@@ -94,18 +94,6 @@ contextCache.startPurgeInterval(60_000);
 // Helpers
 // =============================================================================
 
-function getBraveApiKey(): string {
-  return process.env.BRAVE_API_KEY || "";
-}
-
-function braveHeaders(): Record<string, string> {
-  return {
-    "Accept": "application/json",
-    "Accept-Encoding": "gzip",
-    "X-Subscription-Token": getBraveApiKey(),
-  };
-}
-
 /** Rough token estimate: ~4 chars per token for English text. */
 function estimateTokens(text: string): number {
   return Math.ceil(text.length / 4);

package/dist/resources/extensions/search-the-web/tool-search.ts

@@ -20,7 +20,7 @@ import { LRUTTLCache } from "./cache.js";
 import { fetchWithRetryTimed, fetchWithRetry, classifyError, type RateLimitInfo } from "./http.js";
 import { normalizeQuery, toDedupeKey, detectFreshness } from "./url-utils.js";
 import { formatSearchResults, type SearchResultFormatted, type FormatSearchOptions } from "./format.js";
-import { getTavilyApiKey, getOllamaApiKey, resolveSearchProvider } from "./provider.js";
+import { getTavilyApiKey, getOllamaApiKey, getBraveApiKey, braveHeaders, resolveSearchProvider } from "./provider.js";
 import { normalizeTavilyResult, mapFreshnessToTavily, type TavilySearchResponse } from "./tavily.js";
 
 // =============================================================================
@@ -117,18 +117,6 @@ const summarizerCache = new LRUTTLCache<string>({ max: 50, ttlMs: 900_000 });
 // Brave API helpers
 // =============================================================================
 
-function getBraveApiKey(): string {
-  return process.env.BRAVE_API_KEY || "";
-}
-
-function braveHeaders(): Record<string, string> {
-  return {
-    "Accept": "application/json",
-    "Accept-Encoding": "gzip",
-    "X-Subscription-Token": getBraveApiKey(),
-  };
-}
-
 /**
  * Normalize a Brave result into our formatted result type.
  */