verifiable-thinking-mcp 0.4.0

package/src/lib/compute/confidence.ts

@@ -0,0 +1,79 @@
+/**
+ * Confidence scoring for local compute
+ * Returns probability (0-1) that local compute will solve the question
+ */
+
+import {
+  CONFIDENCE_NEGATIVE,
+  CONFIDENCE_POSITIVE,
+  LIKELY_COMPUTABLE_NEGATIVE,
+  LIKELY_COMPUTABLE_POSITIVE,
+} from "./patterns.ts";
+import type { ComputeConfidence } from "./types.ts";
+
+/**
+ * Check if a question is likely computable locally
+ * Use this for routing decisions before attempting compute
+ */
+export function isLikelyComputable(text: string): boolean {
+  const lower = text.toLowerCase();
+
+  const hasCompute = LIKELY_COMPUTABLE_POSITIVE.some((p) => p.test(text));
+  const hasReasoning = LIKELY_COMPUTABLE_NEGATIVE.some((p) => p.test(lower));
+
+  return hasCompute && !hasReasoning;
+}
+
+/**
+ * Calculate confidence that a question can be computed locally
+ * Returns a score from 0-1 with breakdown of matching signals
+ */
+export function computeConfidence(text: string): ComputeConfidence {
+  const lower = text.toLowerCase();
+
+  // Calculate positive score (max of matching signals)
+  const matchedPositive: string[] = [];
+  let positiveScore = 0;
+
+  for (const { pattern, weight, name } of CONFIDENCE_POSITIVE) {
+    if (pattern.test(text)) {
+      matchedPositive.push(name);
+      positiveScore = Math.max(positiveScore, weight);
+    }
+  }
+
+  // Calculate negative penalty (multiplicative)
+  const matchedNegative: string[] = [];
+  let negativePenalty = 1.0;
+
+  for (const { pattern, penalty, name } of CONFIDENCE_NEGATIVE) {
+    if (pattern.test(lower)) {
+      matchedNegative.push(name);
+      negativePenalty *= 1 - penalty;
+    }
+  }
+
+  // Final score
+  const score = Math.max(0, Math.min(1, positiveScore * (1 - (1 - negativePenalty))));
+
+  // Determine recommendation
+  let recommendation: ComputeConfidence["recommendation"];
+  if (score >= 0.85) {
+    recommendation = "local_only";
+  } else if (score >= 0.6) {
+    recommendation = "try_local_first";
+  } else if (score >= 0.3) {
+    recommendation = "try_local";
+  } else {
+    recommendation = "skip";
+  }
+
+  return {
+    score,
+    signals: {
+      positive: matchedPositive,
+      negative: matchedNegative,
+    },
+    recommendation,
+  };
+}

package/src/lib/compute/context.ts

@@ -0,0 +1,154 @@
+/**
+ * Context-Aware Compute
+ *
+ * Combines system prompt awareness with local compute.
+ * Filters computations by domain relevance before injection.
+ *
+ * Use case: A financial advisor system prompt shouldn't trigger
+ * calculus injections even if the user mentions derivatives.
+ */
+
+import { detectMetaDomain, getRelevantSolvers, type MetaDomain } from "../domain.ts";
+import { extractAndCompute } from "./extract.ts";
+import { filterByDomainRelevance, isMethodRelevant } from "./filter.ts";
+import type { AugmentedResult, ExtractedComputation } from "./types.ts";
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+export interface ContextAwareInput {
+  /** System prompt (defines domain context) */
+  systemPrompt?: string;
+  /** User query (secondary context) */
+  userQuery?: string;
+  /** Thought text to compute */
+  thought: string;
+}
+
+export interface ContextAwareResult extends AugmentedResult {
+  /** Detected meta-domain from context */
+  domain: MetaDomain;
+  /** How many computations were filtered out by domain */
+  filteredCount: number;
+  /** Computations that were removed (for debugging) */
+  filteredComputations: ExtractedComputation[];
+}
+
+// =============================================================================
+// MAIN FUNCTION
+// =============================================================================
+
+/**
+ * Extract and compute with domain-aware filtering.
+ *
+ * Algorithm:
+ * 1. Detect domain from context (systemPrompt > userQuery > thought)
+ * 2. Extract all computations from thought
+ * 3. Filter by domain relevance
+ * 4. Inject only relevant computations
+ *
+ * @param input - Thought text with optional system prompt context
+ * @returns Augmented thought with only domain-relevant computations
+ */
+export function contextAwareCompute(input: ContextAwareInput): ContextAwareResult {
+  const start = performance.now();
+
+  // Determine context for domain detection
+  // Priority: systemPrompt > userQuery > thought
+  const contextText = input.systemPrompt || input.userQuery || input.thought;
+
+  // Detect domain
+  const domain = detectMetaDomain(contextText);
+
+  // Extract all computations from thought
+  const extraction = extractAndCompute(input.thought);
+
+  // If no computations, fast path
+  if (!extraction.hasComputations) {
+    return {
+      ...extraction,
+      domain,
+      filteredCount: 0,
+      filteredComputations: [],
+    };
+  }
+
+  // Filter by domain relevance
+  const filterResult = filterByDomainRelevance(extraction.computations, contextText);
+
+  // If nothing filtered, return original
+  if (filterResult.stats.removed === 0) {
+    return {
+      ...extraction,
+      domain,
+      filteredCount: 0,
+      filteredComputations: [],
+    };
+  }
+
+  // Re-inject only relevant computations
+  const augmented = injectComputations(input.thought, filterResult.relevant);
+
+  return {
+    augmented,
+    computations: filterResult.relevant,
+    hasComputations: filterResult.relevant.length > 0,
+    time_ms: performance.now() - start,
+    domain,
+    filteredCount: filterResult.stats.removed,
+    filteredComputations: filterResult.filtered,
+  };
+}
+
+/**
+ * Inject computations into text.
+ * Used when we need to re-inject after filtering.
+ */
+function injectComputations(text: string, computations: ExtractedComputation[]): string {
+  if (computations.length === 0) return text;
+
+  // Sort by position descending to preserve indices
+  const sorted = [...computations].sort((a, b) => b.start - a.start);
+
+  let result = text;
+  for (const comp of sorted) {
+    const insertPos = comp.end;
+    // Check for existing injection
+    if (result.slice(insertPos, insertPos + 3) !== " [=") {
+      const injection = ` [=${comp.result}]`;
+      result = result.slice(0, insertPos) + injection + result.slice(insertPos);
+    }
+  }
+
+  return result;
+}
+
+// =============================================================================
+// CONVENIENCE FUNCTIONS
+// =============================================================================
+
+/**
+ * Simple interface: compute with system prompt context.
+ * Returns augmented text only.
+ *
+ * @param thought - Text to compute
+ * @param systemPrompt - Optional system prompt for context
+ * @returns Augmented text with domain-relevant computations
+ */
+export function computeWithContext(thought: string, systemPrompt?: string): string {
+  return contextAwareCompute({ thought, systemPrompt }).augmented;
+}
+
+/**
+ * Check if a computation would be filtered given a context.
+ * Useful for testing/debugging.
+ *
+ * @param method - Computation method string
+ * @param contextText - Context text for domain detection
+ * @returns True if the computation would be kept
+ */
+export function wouldKeepComputation(method: string, contextText: string): boolean {
+  const relevantMask = getRelevantSolvers(contextText);
+  return isMethodRelevant(method, relevantMask);
+}

package/src/lib/compute/extract.ts

@@ -0,0 +1,200 @@
+/**
+ * Multi-expression extractor
+ * Finds and computes ALL mathematical expressions in a text
+ *
+ * Performance: O(n) using combined regex with alternation
+ * V8 optimizes alternation patterns into efficient automata
+ */
+
+import { tryLocalCompute } from "./index.ts";
+import { buildCombinedSpanRegex, EXTRACT, WORD_PROBLEM_PATTERNS } from "./patterns.ts";
+import type { AugmentedResult, ExtractedComputation } from "./types.ts";
+
+/**
+ * Format a numeric result for display
+ */
+function formatResult(result: number | string): number | string {
+  if (typeof result === "string") return result;
+  return Number.isInteger(result) ? result : +result.toFixed(6);
+}
+
+/**
+ * Check if a position in text already has an injection marker immediately following
+ */
+function hasInjectionAt(text: string, pos: number): boolean {
+  // Check for " [=" immediately at position (the injection format we use)
+  return text.slice(pos, pos + 3) === " [=";
+}
+
+/**
+ * Remove overlapping computations, keeping the first (leftmost) match
+ */
+function dedupeOverlaps(computations: ExtractedComputation[]): ExtractedComputation[] {
+  if (computations.length <= 1) return computations;
+
+  // Sort by start position
+  const sorted = [...computations].sort((a, b) => a.start - b.start);
+  const result: ExtractedComputation[] = [];
+  let lastEnd = -1;
+
+  for (const comp of sorted) {
+    // Skip if this overlaps with previous
+    if (comp.start < lastEnd) continue;
+    result.push(comp);
+    lastEnd = comp.end;
+  }
+
+  return result;
+}
+
+/**
+ * Extract and compute all mathematical expressions in text
+ * Returns augmented text with computed values injected
+ *
+ * Algorithm:
+ * 1. Single O(n) pass with combined regex finds formula spans
+ * 2. Single O(n) pass finds binary arithmetic
+ * 3. Single O(n) pass finds word problems
+ * 4. Dedupe overlaps O(c log c)
+ * 5. Inject results in reverse order O(c)
+ *
+ * Total: O(n + c log c) where c = number of matches
+ */
+export function extractAndCompute(text: string): AugmentedResult {
+  const start = performance.now();
+  const computations: ExtractedComputation[] = [];
+
+  // Phase 1: Formula patterns (sqrt, factorial, power, etc.) - O(n)
+  // Use fresh regex instance to reset lastIndex
+  const spanRegex = buildCombinedSpanRegex();
+  let match: RegExpExecArray | null;
+
+  while ((match = spanRegex.exec(text)) !== null) {
+    const span = match[0];
+    const matchStart = match.index;
+
+    // Try to compute this span using the full solver pipeline
+    const result = tryLocalCompute(span);
+
+    if (result.solved && result.result !== undefined) {
+      computations.push({
+        original: span,
+        result: formatResult(result.result),
+        method: result.method || "formula",
+        start: matchStart,
+        end: matchStart + span.length,
+      });
+    }
+  }
+
+  // Phase 2: Simple binary operations (5 + 3, 12 * 4) - O(n)
+  const binaryPattern = new RegExp(EXTRACT.binaryOp.source, "g");
+
+  while ((match = binaryPattern.exec(text)) !== null) {
+    const [full, a, op, b] = match;
+    if (!a || !b || !op) continue;
+
+    const matchStart = match.index;
+
+    // Skip if already covered by a formula pattern
+    const alreadyCovered = computations.some(
+      (c) => c.start <= matchStart && c.end >= matchStart + full.length,
+    );
+    if (alreadyCovered) continue;
+
+    const numA = parseFloat(a);
+    const numB = parseFloat(b);
+    let result: number | null = null;
+
+    switch (op) {
+      case "+":
+        result = numA + numB;
+        break;
+      case "-":
+        result = numA - numB;
+        break;
+      case "*":
+        result = numA * numB;
+        break;
+      case "/":
+        result = numB !== 0 ? numA / numB : null;
+        break;
+    }
+
+    if (result !== null && Number.isFinite(result)) {
+      computations.push({
+        original: full,
+        result: formatResult(result),
+        method: "inline_arithmetic",
+        start: matchStart,
+        end: matchStart + full.length,
+      });
+    }
+  }
+
+  // Phase 3: Word problems - O(n * p) where p = word patterns (small constant)
+  for (const { pattern, compute, method } of WORD_PROBLEM_PATTERNS) {
+    const globalPattern = new RegExp(pattern.source, "gi");
+
+    while ((match = globalPattern.exec(text)) !== null) {
+      const result = compute(match);
+      if (result !== null && Number.isFinite(result)) {
+        const matchStart = match.index;
+        const matchLen = match[0].length;
+
+        // Skip if already covered
+        const alreadyCovered = computations.some(
+          (c) => c.start <= matchStart && c.end >= matchStart + matchLen,
+        );
+        if (alreadyCovered) continue;
+
+        computations.push({
+          original: match[0],
+          result: formatResult(result),
+          method,
+          start: matchStart,
+          end: matchStart + matchLen,
+        });
+      }
+    }
+  }
+
+  // Phase 4: Dedupe overlapping matches - O(c log c)
+  const deduped = dedupeOverlaps(computations);
+
+  // Phase 5: Inject results in reverse order to preserve positions - O(c)
+  // By processing from end to start, each injection doesn't affect earlier positions
+  let augmented = text;
+  const sortedByPosDesc = [...deduped].sort((a, b) => b.start - a.start);
+
+  for (const comp of sortedByPosDesc) {
+    const insertPos = comp.end;
+    // Only inject if not already present
+    if (!hasInjectionAt(augmented, insertPos)) {
+      const injection = ` [=${comp.result}]`;
+      augmented = augmented.slice(0, insertPos) + injection + augmented.slice(insertPos);
+    }
+  }
+
+  return {
+    augmented,
+    computations: deduped,
+    hasComputations: deduped.length > 0,
+    time_ms: performance.now() - start,
+  };
+}
+
+/**
+ * Convenience function: compute all expressions and return augmented text only.
+ * Use when you just need the result string without metadata.
+ *
+ * @param text - Input text with mathematical expressions
+ * @returns Text with computed values injected as [=result]
+ *
+ * @example
+ * computeAndReplace("The sqrt(16) is important")
+ * // => "The sqrt(16) [=4] is important"
+ */
+export function computeAndReplace(text: string): string {
+  return extractAndCompute(text).augmented;
+}

package/src/lib/compute/filter.ts

@@ -0,0 +1,224 @@
+/**
+ * Domain-Aware Computation Filtering
+ *
+ * Filters computations based on domain relevance.
+ * Financial context doesn't need calculus, coding context doesn't need probability.
+ *
+ * Architecture:
+ * 1. Map computation methods → SolverType bitmask
+ * 2. Get domain's relevant solvers from domain.ts
+ * 3. Filter computations that match both
+ */
+
+import { detectMetaDomain, getRelevantSolvers, type MetaDomain } from "../domain.ts";
+import { type SolverMask, SolverType } from "./classifier.ts";
+import type { ExtractedComputation } from "./types.ts";
+
+// =============================================================================
+// METHOD → SOLVER TYPE MAPPING
+// =============================================================================
+
+/**
+ * Maps computation method strings to their SolverType bitmask.
+ * Methods returned by solvers are mapped to the solver type that produced them.
+ */
+const METHOD_TO_SOLVER: Record<string, SolverMask> = {
+  // Arithmetic
+  arithmetic: SolverType.ARITHMETIC,
+  inline_arithmetic: SolverType.ARITHMETIC,
+
+  // Formula Tier 1 (percentage, factorial, modulo, prime, fibonacci)
+  percentage: SolverType.FORMULA_TIER1,
+  factorial: SolverType.FORMULA_TIER1,
+  modulo: SolverType.FORMULA_TIER1,
+  prime: SolverType.FORMULA_TIER1,
+  fibonacci: SolverType.FORMULA_TIER1,
+
+  // Formula Tier 2 (sqrt, power, gcd, lcm)
+  sqrt: SolverType.FORMULA_TIER2,
+  power: SolverType.FORMULA_TIER2,
+  gcd: SolverType.FORMULA_TIER2,
+  lcm: SolverType.FORMULA_TIER2,
+
+  // Formula Tier 3 (log, quadratic, combinations, permutations, last digit)
+  logarithm_base10: SolverType.FORMULA_TIER3,
+  natural_log: SolverType.FORMULA_TIER3,
+  quadratic: SolverType.FORMULA_TIER3,
+  quadratic_larger: SolverType.FORMULA_TIER3,
+  quadratic_smaller: SolverType.FORMULA_TIER3,
+  combinations: SolverType.FORMULA_TIER3,
+  permutations: SolverType.FORMULA_TIER3,
+  last_digit: SolverType.FORMULA_TIER3,
+
+  // Formula Tier 4 (pythagorean, trailing zeros, series, matrix, interest)
+  pythagorean: SolverType.FORMULA_TIER4,
+  trailing_zeros: SolverType.FORMULA_TIER4,
+  geometric_series: SolverType.FORMULA_TIER4,
+  matrix_determinant: SolverType.FORMULA_TIER4,
+  compound_interest: SolverType.FORMULA_TIER4,
+
+  // Word problems
+  word_twice: SolverType.WORD_PROBLEM,
+  word_times: SolverType.WORD_PROBLEM,
+  word_triple: SolverType.WORD_PROBLEM,
+  word_double: SolverType.WORD_PROBLEM,
+  word_half: SolverType.WORD_PROBLEM,
+  word_third: SolverType.WORD_PROBLEM,
+  word_quarter: SolverType.WORD_PROBLEM,
+  word_divide: SolverType.WORD_PROBLEM,
+  word_sum: SolverType.WORD_PROBLEM,
+  word_plus: SolverType.WORD_PROBLEM,
+  word_add: SolverType.WORD_PROBLEM,
+  word_total: SolverType.WORD_PROBLEM,
+  word_difference: SolverType.WORD_PROBLEM,
+  word_minus: SolverType.WORD_PROBLEM,
+  word_less_than: SolverType.WORD_PROBLEM,
+  word_subtract: SolverType.WORD_PROBLEM,
+  word_product: SolverType.WORD_PROBLEM,
+  word_quotient: SolverType.WORD_PROBLEM,
+  word_more_than: SolverType.WORD_PROBLEM,
+  word_squared: SolverType.WORD_PROBLEM,
+  word_cubed: SolverType.WORD_PROBLEM,
+  word_rate: SolverType.WORD_PROBLEM,
+  word_average: SolverType.WORD_PROBLEM,
+
+  // CRT word problems
+  crt_bat_ball: SolverType.WORD_PROBLEM,
+  crt_lily_pad: SolverType.WORD_PROBLEM,
+  crt_widget: SolverType.WORD_PROBLEM,
+  crt_harmonic: SolverType.WORD_PROBLEM,
+  crt_catchup: SolverType.WORD_PROBLEM,
+  crt_pigeonhole: SolverType.WORD_PROBLEM,
+
+  // Multi-step
+  multi_step_word: SolverType.MULTI_STEP,
+  multi_step_total: SolverType.MULTI_STEP,
+
+  // Calculus
+  derivative_eval: SolverType.CALCULUS,
+  derivative_symbolic: SolverType.CALCULUS,
+  definite_integral: SolverType.CALCULUS,
+  numerical_integral: SolverType.CALCULUS,
+
+  // Facts
+  math_fact_rationality: SolverType.FACTS,
+  math_fact_known_irrational: SolverType.FACTS,
+  math_fact_integer: SolverType.FACTS,
+  math_fact_fraction: SolverType.FACTS,
+
+  // Logic
+  modus_ponens: SolverType.LOGIC,
+  modus_tollens: SolverType.LOGIC,
+  syllogism: SolverType.LOGIC,
+  xor_violation: SolverType.LOGIC,
+
+  // Probability
+  fair_coin_independence: SolverType.PROBABILITY,
+  fair_coin_direct: SolverType.PROBABILITY,
+  independent_event: SolverType.PROBABILITY,
+  hot_hand_independence: SolverType.PROBABILITY,
+
+  // Generic formula (from tryLocalCompute pipeline)
+  formula: SolverType.FORMULA_TIER1 | SolverType.FORMULA_TIER2,
+};
+
+// =============================================================================
+// FILTER FUNCTIONS
+// =============================================================================
+
+/**
+ * Get the SolverType for a computation method.
+ * Returns ARITHMETIC as fallback for unknown methods.
+ */
+export function methodToSolverType(method: string): SolverMask {
+  return METHOD_TO_SOLVER[method] ?? SolverType.ARITHMETIC;
+}
+
+/**
+ * Check if a computation's method is relevant for a domain.
+ *
+ * @param method - Computation method string (e.g., "derivative_eval")
+ * @param relevantMask - Bitmask of relevant solver types
+ * @returns True if the method is relevant
+ */
+export function isMethodRelevant(method: string, relevantMask: SolverMask): boolean {
+  const methodMask = methodToSolverType(method);
+  return (methodMask & relevantMask) !== 0;
+}
+
+/**
+ * Filter computations by domain relevance.
+ * Keeps only computations whose methods match the domain's relevant solvers.
+ *
+ * @param computations - Array of extracted computations
+ * @param contextText - System prompt or combined context for domain detection
+ * @returns Filtered computations + metadata
+ */
+export function filterByDomainRelevance(
+  computations: ExtractedComputation[],
+  contextText: string,
+): FilterResult {
+  // Get domain's relevant solver mask
+  const relevantMask = getRelevantSolvers(contextText);
+  const meta = detectMetaDomain(contextText);
+
+  // Filter computations
+  const relevant: ExtractedComputation[] = [];
+  const filtered: ExtractedComputation[] = [];
+
+  for (const comp of computations) {
+    if (isMethodRelevant(comp.method, relevantMask)) {
+      relevant.push(comp);
+    } else {
+      filtered.push(comp);
+    }
+  }
+
+  return {
+    relevant,
+    filtered,
+    meta,
+    relevantMask,
+    stats: {
+      total: computations.length,
+      kept: relevant.length,
+      removed: filtered.length,
+    },
+  };
+}
+
+/**
+ * Filter computations by explicit solver mask (no domain detection).
+ * Useful when you already know the relevant solvers.
+ *
+ * @param computations - Array of extracted computations
+ * @param relevantMask - Bitmask of relevant solver types
+ * @returns Filtered computations
+ */
+export function filterByMask(
+  computations: ExtractedComputation[],
+  relevantMask: SolverMask,
+): ExtractedComputation[] {
+  return computations.filter((comp) => isMethodRelevant(comp.method, relevantMask));
+}
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+export interface FilterResult {
+  /** Computations that match the domain's relevant solvers */
+  relevant: ExtractedComputation[];
+  /** Computations that were filtered out */
+  filtered: ExtractedComputation[];
+  /** Detected meta-domain */
+  meta: MetaDomain;
+  /** Bitmask of relevant solver types */
+  relevantMask: SolverMask;
+  /** Statistics */
+  stats: {
+    total: number;
+    kept: number;
+    removed: number;
+  };
+}