mcp-researchpowerpack 7.0.11 → 7.0.13

package/dist/src/schemas/web-search.js

@@ -1,31 +1,32 @@
+// src/schemas/web-search.ts
 import { z } from "zod";
-const QUERY_REWRITE_PAIR_EXAMPLES = [
+var QUERY_REWRITE_PAIR_EXAMPLES = [
   'Bad: `<feature> support` \u2192 Better: `site:<official-docs-domain> "<feature>" "<platform-or-version>"`',
   'Bad: `<product> pricing` \u2192 Better: `site:<vendor-domain> "<product>" pricing "enterprise" OR "free tier"`',
   'Bad: `<library> bug fix` \u2192 Better: `"<exact error text>" "<library-or-package>" "<version>" site:github.com`',
   'Bad: `<tool> reviews` \u2192 Better: `site:reddit.com/r/<community>/comments "<tool>" "migration" OR "regression"`'
 ];
-const QUERY_REWRITE_PAIR_GUIDANCE = [
+var QUERY_REWRITE_PAIR_GUIDANCE = [
   "Write Google retrieval probes, not topic labels.",
   "For each broad idea, rewrite it into a query that names the evidence source class, discriminating anchor terms, and one useful operator when possible.",
   "Use rewrite-pair thinking before searching:",
   ...QUERY_REWRITE_PAIR_EXAMPLES,
   "Do not repeat the same noun phrase with adjectives changed; fan out by source type and evidence need."
 ];
-const QUERY_REWRITE_PAIR_GUIDANCE_TEXT = QUERY_REWRITE_PAIR_GUIDANCE.join(" ");
-const keywordSchema = z.string().min(1, { message: "search: Keyword cannot be empty" }).describe(
+var QUERY_REWRITE_PAIR_GUIDANCE_TEXT = QUERY_REWRITE_PAIR_GUIDANCE.join(" ");
+var keywordSchema = z.string().min(1, { message: "search: Keyword cannot be empty" }).describe(
   `A single search keyword/query. Each item runs as a separate parallel search. ${QUERY_REWRITE_PAIR_GUIDANCE_TEXT}`
 );
-const keywordsSchema = z.array(keywordSchema).min(1, { message: "search: At least 1 keyword required" }).max(50, { message: "search: At most 50 keywords allowed per call" }).describe(
+var keywordsSchema = z.array(keywordSchema).min(1, { message: "search: At least 1 keyword required" }).max(50, { message: "search: At most 50 keywords allowed per call" }).describe(
   `Search keywords to run in parallel. Serper is primary when configured; Jina Search is fallback when Serper is missing, fails, or yields empty query results. ${QUERY_REWRITE_PAIR_GUIDANCE_TEXT} Think of keywords as retrieval probes, not topic labels. Pack distinct facets in one call: official docs, implementation, failures, comparisons, sentiment, changelog, CVE, pricing, or other source classes.`
 );
-const rawWebSearchParamsSchema = z.object({
+var rawWebSearchParamsSchema = z.object({
   keywords: keywordsSchema,
   extract: z.never().optional(),
   scope: z.never().optional(),
   verbose: z.never().optional()
 }).strict();
-const smartWebSearchParamsSchema = z.object({
+var smartWebSearchParamsSchema = z.object({
   keywords: keywordsSchema,
   extract: z.string().min(1, { message: "smart-web-search: extract cannot be empty" }).describe(
     'Semantic instruction for the relevance classifier \u2014 what "relevant" means for THIS goal. This is the post-sort target, so name the evidence you need and the source-of-truth expectation: e.g. official docs/release notes for specs, issue/PR/error text for bugs, Reddit/HN/blogs for lived experience, vendor pricing pages for pricing, CVE databases for security. Drives tiering (HIGHLY_RELEVANT / MAYBE_RELEVANT / OTHER), synthesis, gap analysis, and refine-query suggestions. Be specific: "OAuth 2.1 support in TypeScript MCP frameworks \u2014 runnable code, not marketing", not "MCP OAuth".'
@@ -37,7 +38,7 @@ const smartWebSearchParamsSchema = z.object({
     "Include per-row scoring/coverage metadata, the trailing Signals block, and CONSENSUS labels even when they carry little signal. Default false."
   )
 }).strict();
-const webSearchParamsSchema = smartWebSearchParamsSchema;
+var webSearchParamsSchema = smartWebSearchParamsSchema;
 export {
   QUERY_REWRITE_PAIR_EXAMPLES,
   QUERY_REWRITE_PAIR_GUIDANCE,

package/dist/src/schemas/web-search.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../../src/schemas/web-search.ts"],
   "sourcesContent": ["import { z } from 'zod';\n\nexport const QUERY_REWRITE_PAIR_EXAMPLES = [\n  'Bad: `<feature> support` \u2192 Better: `site:<official-docs-domain> \"<feature>\" \"<platform-or-version>\"`',\n  'Bad: `<product> pricing` \u2192 Better: `site:<vendor-domain> \"<product>\" pricing \"enterprise\" OR \"free tier\"`',\n  'Bad: `<library> bug fix` \u2192 Better: `\"<exact error text>\" \"<library-or-package>\" \"<version>\" site:github.com`',\n  'Bad: `<tool> reviews` \u2192 Better: `site:reddit.com/r/<community>/comments \"<tool>\" \"migration\" OR \"regression\"`',\n] as const;\n\nexport const QUERY_REWRITE_PAIR_GUIDANCE = [\n  'Write Google retrieval probes, not topic labels.',\n  'For each broad idea, rewrite it into a query that names the evidence source class, discriminating anchor terms, and one useful operator when possible.',\n  'Use rewrite-pair thinking before searching:',\n  ...QUERY_REWRITE_PAIR_EXAMPLES,\n  'Do not repeat the same noun phrase with adjectives changed; fan out by source type and evidence need.',\n] as const;\n\nexport const QUERY_REWRITE_PAIR_GUIDANCE_TEXT = QUERY_REWRITE_PAIR_GUIDANCE.join(' ');\n\nconst keywordSchema = z\n  .string()\n  .min(1, { message: 'search: Keyword cannot be empty' })\n  .describe(\n    `A single search keyword/query. Each item runs as a separate parallel search. ${QUERY_REWRITE_PAIR_GUIDANCE_TEXT}`,\n  );\n\nconst keywordsSchema = z\n  .array(keywordSchema)\n  .min(1, { message: 'search: At least 1 keyword required' })\n  .max(50, { message: 'search: At most 50 keywords allowed per call' })\n  .describe(\n    `Search keywords to run in parallel. Serper is primary when configured; Jina Search is fallback when Serper is missing, fails, or yields empty query results. ${QUERY_REWRITE_PAIR_GUIDANCE_TEXT} Think of keywords as retrieval probes, not topic labels. Pack distinct facets in one call: official docs, implementation, failures, comparisons, sentiment, changelog, CVE, pricing, or other source classes.`,\n  );\n\nexport const rawWebSearchParamsSchema = z.object({\n  keywords: keywordsSchema,\n  extract: z.never().optional(),\n  scope: z.never().optional(),\n  verbose: z.never().optional(),\n}).strict();\n\nexport const smartWebSearchParamsSchema = z.object({\n  keywords: keywordsSchema,\n  extract: z\n    .string()\n    .min(1, { message: 'smart-web-search: extract cannot be empty' })\n    .describe(\n      'Semantic instruction for the relevance classifier \u2014 what \"relevant\" means for THIS goal. This is the post-sort target, so name the evidence you need and the source-of-truth expectation: e.g. official docs/release notes for specs, issue/PR/error text for bugs, Reddit/HN/blogs for lived experience, vendor pricing pages for pricing, CVE databases for security. Drives tiering (HIGHLY_RELEVANT / MAYBE_RELEVANT / OTHER), synthesis, gap analysis, and refine-query suggestions. Be specific: \"OAuth 2.1 support in TypeScript MCP frameworks \u2014 runnable code, not marketing\", not \"MCP OAuth\".',\n    ),\n  scope: z\n    .enum(['web', 'reddit', 'both'])\n    .default('web')\n    .describe(\n      'Search scope. \"web\" (default) = open web, no augmentation. \"reddit\" = server appends `site:reddit.com` to every keyword and filters results to post permalinks (`/r/.+/comments/[a-z0-9]+/`); subreddit homepages are dropped. \"both\" = runs every keyword twice (open web + reddit-scoped), merges the result set, and tags each row with its source. Use \"reddit\" for sentiment/migration/lived-experience research; use \"both\" when opinion-heavy AND official sources also matter.',\n    ),\n  verbose: z\n    .boolean()\n    .default(false)\n    .describe(\n      'Include per-row scoring/coverage metadata, the trailing Signals block, and CONSENSUS labels even when they carry little signal. Default false.',\n    ),\n}).strict();\n\nexport type RawWebSearchParams = z.infer<typeof rawWebSearchParamsSchema>;\nexport type SmartWebSearchParams = z.infer<typeof smartWebSearchParamsSchema>;\n\n// Internal alias retained for shared tests/helpers. Public tools register the\n// raw/smart schemas above, not this alias.\nexport const webSearchParamsSchema = smartWebSearchParamsSchema;\nexport type WebSearchParams = SmartWebSearchParams;\n\n// Search tools are markdown-only at the MCP boundary.\nexport type WebSearchOutput = Record<string, never>;\n"],
-  "mappings": "AAAA,SAAS,SAAS;AAEX,MAAM,8BAA8B;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,MAAM,8BAA8B;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AAAA,EACH;AACF;AAEO,MAAM,mCAAmC,4BAA4B,KAAK,GAAG;AAEpF,MAAM,gBAAgB,EACnB,OAAO,EACP,IAAI,GAAG,EAAE,SAAS,kCAAkC,CAAC,EACrD;AAAA,EACC,gFAAgF,gCAAgC;AAClH;AAEF,MAAM,iBAAiB,EACpB,MAAM,aAAa,EACnB,IAAI,GAAG,EAAE,SAAS,sCAAsC,CAAC,EACzD,IAAI,IAAI,EAAE,SAAS,+CAA+C,CAAC,EACnE;AAAA,EACC,gKAAgK,gCAAgC;AAClM;AAEK,MAAM,2BAA2B,EAAE,OAAO;AAAA,EAC/C,UAAU;AAAA,EACV,SAAS,EAAE,MAAM,EAAE,SAAS;AAAA,EAC5B,OAAO,EAAE,MAAM,EAAE,SAAS;AAAA,EAC1B,SAAS,EAAE,MAAM,EAAE,SAAS;AAC9B,CAAC,EAAE,OAAO;AAEH,MAAM,6BAA6B,EAAE,OAAO;AAAA,EACjD,UAAU;AAAA,EACV,SAAS,EACN,OAAO,EACP,IAAI,GAAG,EAAE,SAAS,4CAA4C,CAAC,EAC/D;AAAA,IACC;AAAA,EACF;AAAA,EACF,OAAO,EACJ,KAAK,CAAC,OAAO,UAAU,MAAM,CAAC,EAC9B,QAAQ,KAAK,EACb;AAAA,IACC;AAAA,EACF;AAAA,EACF,SAAS,EACN,QAAQ,EACR,QAAQ,KAAK,EACb;AAAA,IACC;AAAA,EACF;AACJ,CAAC,EAAE,OAAO;AAOH,MAAM,wBAAwB;",
+  "mappings": ";AAAA,SAAS,SAAS;AAEX,IAAM,8BAA8B;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,8BAA8B;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AAAA,EACH;AACF;AAEO,IAAM,mCAAmC,4BAA4B,KAAK,GAAG;AAEpF,IAAM,gBAAgB,EACnB,OAAO,EACP,IAAI,GAAG,EAAE,SAAS,kCAAkC,CAAC,EACrD;AAAA,EACC,gFAAgF,gCAAgC;AAClH;AAEF,IAAM,iBAAiB,EACpB,MAAM,aAAa,EACnB,IAAI,GAAG,EAAE,SAAS,sCAAsC,CAAC,EACzD,IAAI,IAAI,EAAE,SAAS,+CAA+C,CAAC,EACnE;AAAA,EACC,gKAAgK,gCAAgC;AAClM;AAEK,IAAM,2BAA2B,EAAE,OAAO;AAAA,EAC/C,UAAU;AAAA,EACV,SAAS,EAAE,MAAM,EAAE,SAAS;AAAA,EAC5B,OAAO,EAAE,MAAM,EAAE,SAAS;AAAA,EAC1B,SAAS,EAAE,MAAM,EAAE,SAAS;AAC9B,CAAC,EAAE,OAAO;AAEH,IAAM,6BAA6B,EAAE,OAAO;AAAA,EACjD,UAAU;AAAA,EACV,SAAS,EACN,OAAO,EACP,IAAI,GAAG,EAAE,SAAS,4CAA4C,CAAC,EAC/D;AAAA,IACC;AAAA,EACF;AAAA,EACF,OAAO,EACJ,KAAK,CAAC,OAAO,UAAU,MAAM,CAAC,EAC9B,QAAQ,KAAK,EACb;AAAA,IACC;AAAA,EACF;AAAA,EACF,SAAS,EACN,QAAQ,EACR,QAAQ,KAAK,EACb;AAAA,IACC;AAAA,EACF;AACJ,CAAC,EAAE,OAAO;AAOH,IAAM,wBAAwB;",
   "names": []
 }

package/dist/src/services/llm-processor.js

@@ -1,20 +1,401 @@
+// src/services/llm-processor.ts
 import OpenAI from "openai";
-import { LLM_EXTRACTION, getCapabilities } from "../config/index.js";
-import { QUERY_REWRITE_PAIR_GUIDANCE_TEXT } from "../schemas/web-search.js";
-import {
-  classifyError,
-  sleep,
-  ErrorCode,
-  withStallProtection
-} from "../utils/errors.js";
-import { mcpLog } from "../utils/logger.js";
-const MAX_LLM_INPUT_CHARS = 5e5;
-const MAX_PRIMARY_MODEL_INPUT_CHARS = 1e5;
-const LLM_CLIENT_TIMEOUT_MS = 6e5;
-const BACKOFF_JITTER_FACTOR = 0.3;
-const LLM_STALL_TIMEOUT_MS = 75e3;
-const LLM_REQUEST_DEADLINE_MS = 15e4;
-const llmHealth = {
+
+// src/config/index.ts
+import { Logger } from "mcp-use";
+
+// src/version.ts
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var DEFAULT_PACKAGE_INFO = {
+  version: "3.9.5",
+  name: "mcp-researchpowerpack-http",
+  description: "Research Powerpack MCP Server"
+};
+var packageJson = { ...DEFAULT_PACKAGE_INFO };
+try {
+  if (typeof import.meta.url === "string" && import.meta.url.startsWith("file:")) {
+    const _require = createRequire(import.meta.url);
+    const _dirname = dirname(fileURLToPath(import.meta.url));
+    try {
+      packageJson = _require(join(_dirname, "..", "package.json"));
+    } catch {
+      packageJson = _require(join(_dirname, "..", "..", "package.json"));
+    }
+  }
+} catch {
+}
+var VERSION = packageJson.version;
+var PACKAGE_NAME = packageJson.name;
+var PACKAGE_DESCRIPTION = packageJson.description;
+var USER_AGENT_VERSION = `${PACKAGE_NAME}/${VERSION}`;
+
+// src/config/index.ts
+function safeParseInt(value, defaultVal, min, max) {
+  const logger = Logger.get("config");
+  if (!value) {
+    return defaultVal;
+  }
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    logger.warn(`Invalid number "${value}", using default ${defaultVal}`);
+    return defaultVal;
+  }
+  if (parsed < min) {
+    logger.warn(`Value ${parsed} below minimum ${min}, clamping to ${min}`);
+    return min;
+  }
+  if (parsed > max) {
+    logger.warn(`Value ${parsed} above maximum ${max}, clamping to ${max}`);
+    return max;
+  }
+  return parsed;
+}
+var cachedEnv = null;
+function parseEnv() {
+  if (cachedEnv) return cachedEnv;
+  cachedEnv = {
+    SCRAPER_API_KEY: process.env.SCRAPEDO_API_KEY || "",
+    SEARCH_API_KEY: process.env.SERPER_API_KEY || void 0,
+    REDDIT_CLIENT_ID: process.env.REDDIT_CLIENT_ID || void 0,
+    REDDIT_CLIENT_SECRET: process.env.REDDIT_CLIENT_SECRET || void 0,
+    JINA_API_KEY: process.env.JINA_API_KEY || void 0,
+    KERNEL_API_KEY: process.env.KERNEL_API_KEY || void 0,
+    KERNEL_PROJECT: process.env.KERNEL_PROJECT || void 0
+  };
+  return cachedEnv;
+}
+function getCapabilities() {
+  const env = parseEnv();
+  return {
+    reddit: !!(env.REDDIT_CLIENT_ID && env.REDDIT_CLIENT_SECRET),
+    search: !!(env.SEARCH_API_KEY || env.JINA_API_KEY),
+    serperSearch: !!env.SEARCH_API_KEY,
+    jina: !!env.JINA_API_KEY,
+    scraping: !!env.SCRAPER_API_KEY,
+    kernel: !!env.KERNEL_API_KEY,
+    llmExtraction: getLLMConfigStatus().configured
+  };
+}
+var CONCURRENCY = {
+  SEARCH: safeParseInt(process.env.CONCURRENCY_SEARCH, 50, 1, 200),
+  SCRAPER: safeParseInt(process.env.CONCURRENCY_SCRAPER, 50, 1, 200),
+  JINA_READER: safeParseInt(process.env.CONCURRENCY_JINA_READER, 50, 1, 200),
+  REDDIT: safeParseInt(process.env.CONCURRENCY_REDDIT, 50, 1, 200),
+  LLM_EXTRACTION: safeParseInt(process.env.LLM_CONCURRENCY, 50, 1, 200),
+  KERNEL: safeParseInt(process.env.CONCURRENCY_KERNEL, 3, 1, 20)
+};
+var cachedLlmConfigStatus = null;
+function getLLMConfigStatus() {
+  if (cachedLlmConfigStatus) return cachedLlmConfigStatus;
+  const apiKeyPresent = !!process.env.LLM_API_KEY?.trim();
+  const baseUrlPresent = !!process.env.LLM_BASE_URL?.trim();
+  const modelPresent = !!process.env.LLM_MODEL?.trim();
+  const missingVars = [];
+  if (!apiKeyPresent) missingVars.push("LLM_API_KEY");
+  if (!baseUrlPresent) missingVars.push("LLM_BASE_URL");
+  if (!modelPresent) missingVars.push("LLM_MODEL");
+  const configured = missingVars.length === 0;
+  cachedLlmConfigStatus = {
+    configured,
+    apiKeyPresent,
+    baseUrlPresent,
+    modelPresent,
+    missingVars,
+    error: configured ? null : `LLM disabled: missing ${missingVars.join(", ")}`
+  };
+  return cachedLlmConfigStatus;
+}
+var cachedLlmExtraction = null;
+function getLlmExtraction() {
+  if (cachedLlmExtraction) return cachedLlmExtraction;
+  const apiKey = process.env.LLM_API_KEY?.trim() || "";
+  const baseUrl = process.env.LLM_BASE_URL?.trim();
+  const model = process.env.LLM_MODEL?.trim();
+  const fallbackModel = process.env.LLM_FALLBACK_MODEL?.trim() || "";
+  if (apiKey && !baseUrl) {
+    throw new Error(
+      "LLM_BASE_URL is required when LLM_API_KEY is set. Set LLM_BASE_URL to your OpenAI-compatible endpoint."
+    );
+  }
+  if (apiKey && !model) {
+    throw new Error(
+      "LLM_MODEL is required when LLM_API_KEY is set."
+    );
+  }
+  cachedLlmExtraction = {
+    API_KEY: apiKey,
+    BASE_URL: baseUrl || "",
+    MODEL: model || "",
+    FALLBACK_MODEL: fallbackModel
+  };
+  return cachedLlmExtraction;
+}
+var LLM_EXTRACTION = new Proxy({}, {
+  get(_target, prop) {
+    return getLlmExtraction()[prop];
+  }
+});
+
+// src/schemas/web-search.ts
+import { z } from "zod";
+var QUERY_REWRITE_PAIR_EXAMPLES = [
+  'Bad: `<feature> support` \u2192 Better: `site:<official-docs-domain> "<feature>" "<platform-or-version>"`',
+  'Bad: `<product> pricing` \u2192 Better: `site:<vendor-domain> "<product>" pricing "enterprise" OR "free tier"`',
+  'Bad: `<library> bug fix` \u2192 Better: `"<exact error text>" "<library-or-package>" "<version>" site:github.com`',
+  'Bad: `<tool> reviews` \u2192 Better: `site:reddit.com/r/<community>/comments "<tool>" "migration" OR "regression"`'
+];
+var QUERY_REWRITE_PAIR_GUIDANCE = [
+  "Write Google retrieval probes, not topic labels.",
+  "For each broad idea, rewrite it into a query that names the evidence source class, discriminating anchor terms, and one useful operator when possible.",
+  "Use rewrite-pair thinking before searching:",
+  ...QUERY_REWRITE_PAIR_EXAMPLES,
+  "Do not repeat the same noun phrase with adjectives changed; fan out by source type and evidence need."
+];
+var QUERY_REWRITE_PAIR_GUIDANCE_TEXT = QUERY_REWRITE_PAIR_GUIDANCE.join(" ");
+var keywordSchema = z.string().min(1, { message: "search: Keyword cannot be empty" }).describe(
+  `A single search keyword/query. Each item runs as a separate parallel search. ${QUERY_REWRITE_PAIR_GUIDANCE_TEXT}`
+);
+var keywordsSchema = z.array(keywordSchema).min(1, { message: "search: At least 1 keyword required" }).max(50, { message: "search: At most 50 keywords allowed per call" }).describe(
+  `Search keywords to run in parallel. Serper is primary when configured; Jina Search is fallback when Serper is missing, fails, or yields empty query results. ${QUERY_REWRITE_PAIR_GUIDANCE_TEXT} Think of keywords as retrieval probes, not topic labels. Pack distinct facets in one call: official docs, implementation, failures, comparisons, sentiment, changelog, CVE, pricing, or other source classes.`
+);
+var rawWebSearchParamsSchema = z.object({
+  keywords: keywordsSchema,
+  extract: z.never().optional(),
+  scope: z.never().optional(),
+  verbose: z.never().optional()
+}).strict();
+var smartWebSearchParamsSchema = z.object({
+  keywords: keywordsSchema,
+  extract: z.string().min(1, { message: "smart-web-search: extract cannot be empty" }).describe(
+    'Semantic instruction for the relevance classifier \u2014 what "relevant" means for THIS goal. This is the post-sort target, so name the evidence you need and the source-of-truth expectation: e.g. official docs/release notes for specs, issue/PR/error text for bugs, Reddit/HN/blogs for lived experience, vendor pricing pages for pricing, CVE databases for security. Drives tiering (HIGHLY_RELEVANT / MAYBE_RELEVANT / OTHER), synthesis, gap analysis, and refine-query suggestions. Be specific: "OAuth 2.1 support in TypeScript MCP frameworks \u2014 runnable code, not marketing", not "MCP OAuth".'
+  ),
+  scope: z.enum(["web", "reddit", "both"]).default("web").describe(
+    'Search scope. "web" (default) = open web, no augmentation. "reddit" = server appends `site:reddit.com` to every keyword and filters results to post permalinks (`/r/.+/comments/[a-z0-9]+/`); subreddit homepages are dropped. "both" = runs every keyword twice (open web + reddit-scoped), merges the result set, and tags each row with its source. Use "reddit" for sentiment/migration/lived-experience research; use "both" when opinion-heavy AND official sources also matter.'
+  ),
+  verbose: z.boolean().default(false).describe(
+    "Include per-row scoring/coverage metadata, the trailing Signals block, and CONSENSUS labels even when they carry little signal. Default false."
+  )
+}).strict();
+
+// src/utils/logger.ts
+import { Logger as Logger2 } from "mcp-use";
+function getLogger(name) {
+  return Logger2.get(name);
+}
+function mcpLog(level, message, loggerName) {
+  const logger = getLogger(loggerName ?? "research-powerpack");
+  switch (level) {
+    case "debug":
+      logger.debug(message);
+      break;
+    case "info":
+      logger.info(message);
+      break;
+    case "warning":
+      logger.warn(message);
+      break;
+    case "error":
+      logger.error(message);
+      break;
+  }
+}
+
+// src/utils/errors.ts
+var ErrorCode = {
+  // Retryable errors
+  RATE_LIMITED: "RATE_LIMITED",
+  TIMEOUT: "TIMEOUT",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  // Non-retryable errors
+  AUTH_ERROR: "AUTH_ERROR",
+  INVALID_INPUT: "INVALID_INPUT",
+  NOT_FOUND: "NOT_FOUND",
+  QUOTA_EXCEEDED: "QUOTA_EXCEEDED",
+  UNSUPPORTED_BINARY_CONTENT: "UNSUPPORTED_BINARY_CONTENT",
+  // Internal errors
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  PARSE_ERROR: "PARSE_ERROR",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  retryableStatuses: [408, 429, 500, 502, 503, 504, 510]
+};
+function classifyDomException(error) {
+  if (error.name === "AbortError") {
+    return { code: ErrorCode.TIMEOUT, message: "Request timed out", retryable: true };
+  }
+  return { code: ErrorCode.UNKNOWN_ERROR, message: error.message, retryable: false };
+}
+function classifyByErrorCode(error) {
+  const errCode = error.code;
+  if (!errCode) return null;
+  const networkErrorMessages = {
+    ECONNREFUSED: "Connection refused \u2014 service may be down",
+    ECONNRESET: "Connection was reset \u2014 please retry",
+    ECONNABORTED: "Connection aborted \u2014 please retry",
+    ENOTFOUND: "Service not reachable \u2014 check your network",
+    EPIPE: "Connection lost \u2014 please retry",
+    EAI_AGAIN: "DNS lookup failed \u2014 check your network"
+  };
+  if (errCode === "ECONNREFUSED" || errCode === "ENOTFOUND" || errCode === "ECONNRESET") {
+    return { code: ErrorCode.NETWORK_ERROR, message: networkErrorMessages[errCode] || "Network connection failed", retryable: true, cause: error.message };
+  }
+  if (errCode === "ECONNABORTED" || errCode === "ETIMEDOUT") {
+    return { code: ErrorCode.TIMEOUT, message: networkErrorMessages[errCode] || "Request timed out", retryable: true, cause: error.message };
+  }
+  return null;
+}
+function classifyByStatusCode(error) {
+  const status = error.response?.status || error.status || error.statusCode;
+  if (!status) return null;
+  return classifyHttpError(status, error.message || String(error));
+}
+function classifyByMessage(message) {
+  const lower = message.toLowerCase();
+  if (lower.includes("timeout") || lower.includes("timed out") || lower.includes("aborterror")) {
+    return { code: ErrorCode.TIMEOUT, message: "Request timed out", retryable: true, cause: message };
+  }
+  if (lower.includes("rate limit") || lower.includes("too many requests")) {
+    return { code: ErrorCode.RATE_LIMITED, message: "Rate limit exceeded", retryable: true, cause: message };
+  }
+  if (message.includes("API_KEY") || message.includes("api_key") || message.includes("Invalid API")) {
+    return { code: ErrorCode.AUTH_ERROR, message: "API key missing or invalid", retryable: false, cause: message };
+  }
+  if (message.includes("JSON") || message.includes("parse") || message.includes("Unexpected token")) {
+    return { code: ErrorCode.PARSE_ERROR, message: "Failed to parse response", retryable: false, cause: message };
+  }
+  return null;
+}
+function classifyFallback(message, cause) {
+  return {
+    code: ErrorCode.UNKNOWN_ERROR,
+    message,
+    retryable: false,
+    cause: cause ? String(cause) : void 0
+  };
+}
+function classifyError(error) {
+  if (error == null) {
+    return { code: ErrorCode.UNKNOWN_ERROR, message: "An unknown error occurred", retryable: false };
+  }
+  if (error instanceof DOMException) return classifyDomException(error);
+  if (!isErrorLike(error)) {
+    return { code: ErrorCode.UNKNOWN_ERROR, message: String(error), retryable: false };
+  }
+  return classifyByErrorCode(error) ?? classifyByStatusCode(error) ?? classifyByMessage(error.message ?? String(error)) ?? classifyFallback(error.message ?? String(error), error.cause);
+}
+function isErrorLike(value) {
+  return typeof value === "object" && value !== null;
+}
+function classifyHttpError(status, message) {
+  switch (status) {
+    case 400:
+      return { code: ErrorCode.INVALID_INPUT, message: "Bad request", retryable: false, statusCode: status };
+    case 401:
+      return { code: ErrorCode.AUTH_ERROR, message: "Invalid API key", retryable: false, statusCode: status };
+    case 403:
+      return { code: ErrorCode.QUOTA_EXCEEDED, message: "Access forbidden or quota exceeded", retryable: false, statusCode: status };
+    case 404:
+      return { code: ErrorCode.NOT_FOUND, message: "Resource not found", retryable: false, statusCode: status };
+    case 408:
+      return { code: ErrorCode.TIMEOUT, message: "Request timeout", retryable: true, statusCode: status };
+    case 429:
+      return { code: ErrorCode.RATE_LIMITED, message: "Rate limit exceeded", retryable: true, statusCode: status };
+    case 500:
+      return { code: ErrorCode.INTERNAL_ERROR, message: "Server error", retryable: true, statusCode: status };
+    case 502:
+      return { code: ErrorCode.SERVICE_UNAVAILABLE, message: "Bad gateway", retryable: true, statusCode: status };
+    case 503:
+      return { code: ErrorCode.SERVICE_UNAVAILABLE, message: "Service unavailable", retryable: true, statusCode: status };
+    case 504:
+      return { code: ErrorCode.TIMEOUT, message: "Gateway timeout", retryable: true, statusCode: status };
+    case 510:
+      return { code: ErrorCode.SERVICE_UNAVAILABLE, message: "Request canceled", retryable: true, statusCode: status };
+    default:
+      if (status >= 500) {
+        return { code: ErrorCode.SERVICE_UNAVAILABLE, message: `Server error: ${status}`, retryable: true, statusCode: status };
+      }
+      if (status >= 400) {
+        return { code: ErrorCode.INVALID_INPUT, message: `Client error: ${status}`, retryable: false, statusCode: status };
+      }
+      return { code: ErrorCode.UNKNOWN_ERROR, message: `HTTP ${status}: ${message}`, retryable: false, statusCode: status };
+  }
+}
+function calculateBackoff(attempt, options) {
+  const exponentialDelay = options.baseDelayMs * Math.pow(2, attempt);
+  const jitter = Math.random() * 0.3 * exponentialDelay;
+  return Math.min(exponentialDelay + jitter, options.maxDelayMs);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    function onAbort() {
+      clearTimeout(timeout);
+      reject(new DOMException("Aborted", "AbortError"));
+    }
+    const timeout = setTimeout(() => {
+      if (signal) signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) {
+      onAbort();
+    }
+  });
+}
+async function withStallProtection(fn, stallMs, maxAttempts = 2, label = "request") {
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const controller = new AbortController();
+    let stallTimer;
+    const stallPromise = new Promise((_, reject) => {
+      stallTimer = setTimeout(() => {
+        controller.abort();
+        reject(Object.assign(new Error(`Service temporarily unavailable \u2014 no response received (attempt ${attempt + 1}/${maxAttempts})`), {
+          code: "ESTALLED",
+          retryable: attempt < maxAttempts - 1
+        }));
+      }, stallMs);
+    });
+    let fnPromise;
+    try {
+      fnPromise = fn(controller.signal);
+      const result = await Promise.race([fnPromise, stallPromise]);
+      clearTimeout(stallTimer);
+      return result;
+    } catch (err) {
+      fnPromise?.catch(() => {
+      });
+      clearTimeout(stallTimer);
+      const isStall = err instanceof Error && err.code === "ESTALLED";
+      if (isStall && attempt < maxAttempts - 1) {
+        const backoff = calculateBackoff(attempt, DEFAULT_RETRY_OPTIONS);
+        mcpLog("warning", `${label} stalled, retrying in ${backoff}ms (attempt ${attempt + 1})`, "stability");
+        await sleep(backoff);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`${label} failed after ${maxAttempts} stall-protection attempts`);
+}
+
+// src/services/llm-processor.ts
+var MAX_LLM_INPUT_CHARS = 5e5;
+var MAX_PRIMARY_MODEL_INPUT_CHARS = 1e5;
+var LLM_CLIENT_TIMEOUT_MS = 6e5;
+var BACKOFF_JITTER_FACTOR = 0.3;
+var LLM_STALL_TIMEOUT_MS = 75e3;
+var LLM_REQUEST_DEADLINE_MS = 15e4;
+var llmHealth = {
   lastPlannerOk: false,
   lastExtractorOk: false,
   lastPlannerCheckedAt: null,
@@ -80,13 +461,13 @@ function _resetLLMHealthForTests() {
   llmHealth.consecutivePlannerFailures = 0;
   llmHealth.consecutiveExtractorFailures = 0;
 }
-const LLM_RETRY_CONFIG = {
+var LLM_RETRY_CONFIG = {
   maxRetries: 2,
   baseDelayMs: 1e3,
   maxDelayMs: 5e3
 };
-const FALLBACK_RETRY_COUNT = 3;
-const RETRYABLE_LLM_ERROR_CODES = /* @__PURE__ */ new Set([
+var FALLBACK_RETRY_COUNT = 3;
+var RETRYABLE_LLM_ERROR_CODES = /* @__PURE__ */ new Set([
   "rate_limit_exceeded",
   "server_error",
   "timeout",
@@ -95,7 +476,7 @@ const RETRYABLE_LLM_ERROR_CODES = /* @__PURE__ */ new Set([
 function hasStatus(error) {
   return typeof error === "object" && error !== null && "status" in error && typeof error.status === "number";
 }
-let llmClient = null;
+var llmClient = null;
 function createLLMProcessor() {
   if (!getCapabilities().llmExtraction) return null;
   if (!llmClient) {
@@ -427,7 +808,7 @@ ${truncatedContent}`;
     }
   };
 }
-const MAX_CLASSIFICATION_URLS = 50;
+var MAX_CLASSIFICATION_URLS = 50;
 async function classifySearchResults(rankedUrls, objective, totalQueries, processor, previousQueries = []) {
   const urlsToClassify = rankedUrls.slice(0, MAX_CLASSIFICATION_URLS);
   const STATIC_WEIGHTS = [30, 20, 15, 10, 8, 6, 5, 4, 3, 2];
@@ -595,7 +976,7 @@ RULES:
     return { result: [], error: message };
   }
 }
-const VALID_GOAL_CLASSES = /* @__PURE__ */ new Set([
+var VALID_GOAL_CLASSES = /* @__PURE__ */ new Set([
   "spec",
   "bug",
   "migration",
@@ -606,9 +987,9 @@ const VALID_GOAL_CLASSES = /* @__PURE__ */ new Set([
   "product_launch",
   "other"
 ]);
-const VALID_FRESHNESS = /* @__PURE__ */ new Set(["days", "weeks", "months", "years"]);
-const VALID_BRANCHES = /* @__PURE__ */ new Set(["reddit", "web", "both"]);
-const VALID_STEP_TOOLS = /* @__PURE__ */ new Set(["raw-web-search", "smart-web-search", "raw-scrape-links", "smart-scrape-links"]);
+var VALID_FRESHNESS = /* @__PURE__ */ new Set(["days", "weeks", "months", "years"]);
+var VALID_BRANCHES = /* @__PURE__ */ new Set(["reddit", "web", "both"]);
+var VALID_STEP_TOOLS = /* @__PURE__ */ new Set(["raw-web-search", "smart-web-search", "raw-scrape-links", "smart-scrape-links"]);
 function isStringArray(value) {
   return Array.isArray(value) && value.every((v) => typeof v === "string");
 }