@usewhisper/mcp-server 0.1.0 → 0.2.3

package/dist/cost-optimization-F3L5BS5F.js

@@ -0,0 +1,303 @@
+import {
+  Anthropic
+} from "./chunk-H3HSKH2P.js";
+import "./chunk-QGM4M3NI.js";
+
+// ../src/engine/cost-optimization.ts
+var MODELS = {
+  haiku: {
+    model: "claude-haiku-4.5",
+    maxTokens: 4096,
+    temperature: 0,
+    costPerMillion: 0.25
+    // $0.25 per million input tokens
+  },
+  sonnet: {
+    model: "claude-sonnet-4.5",
+    maxTokens: 8192,
+    temperature: 0,
+    costPerMillion: 3
+    // $3.00 per million input tokens
+  },
+  opus: {
+    model: "claude-opus-4.5",
+    maxTokens: 16384,
+    temperature: 0,
+    costPerMillion: 15
+    // $15.00 per million input tokens
+  }
+};
+var TASK_MODEL_MAP = {
+  temporal_parsing: "haiku",
+  // Fast, simple parsing
+  simple_classification: "haiku",
+  // Fast classification
+  memory_extraction: "sonnet",
+  // Needs accuracy for disambiguation
+  relation_detection: "sonnet",
+  // Needs reasoning
+  consolidation: "sonnet",
+  // Needs to merge intelligently
+  summarization: "haiku",
+  // Fast summarization
+  complex_reasoning: "opus"
+  // Deep reasoning tasks
+};
+function getOptimalModel(taskType, options = {}) {
+  if (options.forceModel) {
+    return MODELS[options.forceModel];
+  }
+  let tier = TASK_MODEL_MAP[taskType];
+  if (options.minQuality && tier === "haiku") {
+    tier = "sonnet";
+  }
+  return MODELS[tier];
+}
+function estimateCost(params) {
+  const modelConfig = getOptimalModel(params.taskType, { forceModel: params.model });
+  const inputCost = params.inputTokens / 1e6 * modelConfig.costPerMillion;
+  const outputCostPerMillion = modelConfig.costPerMillion * 5;
+  const outputCost = params.outputTokens / 1e6 * outputCostPerMillion;
+  return {
+    model: modelConfig.model,
+    inputCost,
+    outputCost,
+    totalCost: inputCost + outputCost
+  };
+}
+async function smartLLMCall(params) {
+  const { taskType, prompt, systemPrompt, maxTokens, temperature, forceModel } = params;
+  const modelConfig = getOptimalModel(taskType, { forceModel });
+  const anthropic = new Anthropic({
+    apiKey: process.env.ANTHROPIC_API_KEY || ""
+  });
+  const messages = [{ role: "user", content: prompt }];
+  if (systemPrompt) {
+  }
+  const response = await anthropic.messages.create({
+    model: modelConfig.model,
+    max_tokens: maxTokens || modelConfig.maxTokens,
+    temperature: temperature !== void 0 ? temperature : modelConfig.temperature,
+    messages
+  });
+  const textContent = response.content.find((c) => c.type === "text");
+  const responseText = textContent && textContent.type === "text" ? textContent.text : "";
+  const tokensUsed = {
+    input: response.usage.input_tokens,
+    output: response.usage.output_tokens
+  };
+  const cost = estimateCost({
+    taskType,
+    inputTokens: tokensUsed.input,
+    outputTokens: tokensUsed.output,
+    model: forceModel
+  });
+  return {
+    response: responseText,
+    model: modelConfig.model,
+    tokensUsed,
+    cost: cost.totalCost
+  };
+}
+async function batchOptimize(params) {
+  const { items, processFn, batchSize = 10, delayMs = 100 } = params;
+  const results = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize);
+    const batchResults = await Promise.all(batch.map(processFn));
+    results.push(...batchResults);
+    if (i + batchSize < items.length) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return results;
+}
+var costRecords = [];
+function trackCost(record) {
+  costRecords.push({
+    ...record,
+    timestamp: /* @__PURE__ */ new Date()
+  });
+}
+async function getCostSummary(params) {
+  const { startDate, endDate } = params;
+  let filtered = [...costRecords];
+  if (startDate) {
+    filtered = filtered.filter((r) => r.timestamp >= startDate);
+  }
+  if (endDate) {
+    filtered = filtered.filter((r) => r.timestamp <= endDate);
+  }
+  const period = {
+    start: filtered.length > 0 ? filtered[0].timestamp : /* @__PURE__ */ new Date(),
+    end: filtered.length > 0 ? filtered[filtered.length - 1].timestamp : /* @__PURE__ */ new Date()
+  };
+  const totalCost = filtered.reduce((sum, r) => sum + r.cost, 0);
+  const totalRequests = filtered.length;
+  const costByModel = {};
+  const costByTask = {};
+  for (const record of filtered) {
+    costByModel[record.model] = (costByModel[record.model] || 0) + record.cost;
+    costByTask[record.taskType] = (costByTask[record.taskType] || 0) + record.cost;
+  }
+  const avgCostPerRequest = totalRequests > 0 ? totalCost / totalRequests : 0;
+  const daysDiff = period.end.getTime() - period.start.getTime();
+  const days = daysDiff > 0 ? daysDiff / (1e3 * 60 * 60 * 24) : 1;
+  const estimatedMonthlyCost = totalCost / days * 30;
+  return {
+    period,
+    totalCost,
+    totalRequests,
+    costByModel,
+    costByTask,
+    avgCostPerRequest,
+    estimatedMonthlyCost
+  };
+}
+function calculateSavings(params) {
+  const { since } = params;
+  const filtered = since ? costRecords.filter((r) => r.timestamp >= since) : costRecords;
+  const actualCost = filtered.reduce((sum, r) => sum + r.cost, 0);
+  const opusCost = filtered.reduce((sum, r) => {
+    const cost = estimateCost({
+      taskType: r.taskType,
+      inputTokens: r.inputTokens,
+      outputTokens: r.outputTokens,
+      model: "opus"
+    });
+    return sum + cost.totalCost;
+  }, 0);
+  const savings = opusCost - actualCost;
+  const savingsPercent = opusCost > 0 ? savings / opusCost * 100 : 0;
+  return {
+    actualCost,
+    opusCost,
+    savings,
+    savingsPercent
+  };
+}
+function recommendModelUpgrades(params) {
+  const { errorRates, threshold = 0.05 } = params;
+  const recommendations = [];
+  for (const [taskType, errorRate] of Object.entries(errorRates)) {
+    if (errorRate > threshold) {
+      const currentModel = TASK_MODEL_MAP[taskType];
+      let recommendedModel;
+      if (currentModel === "haiku") {
+        recommendedModel = "sonnet";
+      } else if (currentModel === "sonnet") {
+        recommendedModel = "opus";
+      } else {
+        continue;
+      }
+      recommendations.push({
+        taskType,
+        currentModel,
+        recommendedModel
+      });
+    }
+  }
+  return recommendations;
+}
+async function getCostBreakdown(params) {
+  const { groupBy, startDate, endDate } = params;
+  let filtered = [...costRecords];
+  if (startDate) {
+    filtered = filtered.filter((r) => r.timestamp >= startDate);
+  }
+  if (endDate) {
+    filtered = filtered.filter((r) => r.timestamp <= endDate);
+  }
+  const groups = {};
+  for (const record of filtered) {
+    let key;
+    switch (groupBy) {
+      case "model":
+        key = record.model;
+        break;
+      case "task":
+        key = record.taskType;
+        break;
+      case "day":
+        key = record.timestamp.toISOString().split("T")[0];
+        break;
+      case "hour":
+        key = record.timestamp.toISOString().slice(0, 13) + ":00";
+        break;
+      default:
+        key = record.taskType;
+    }
+    if (!groups[key]) {
+      groups[key] = { cost: 0, requests: 0 };
+    }
+    groups[key].cost += record.cost;
+    groups[key].requests += 1;
+  }
+  const totalCost = filtered.reduce((sum, r) => sum + r.cost, 0);
+  const totalRequests = filtered.length;
+  return { groups, totalCost, totalRequests };
+}
+async function getSavingsReport(params) {
+  const { startDate, endDate } = params;
+  let filtered = [...costRecords];
+  if (startDate) {
+    filtered = filtered.filter((r) => r.timestamp >= startDate);
+  }
+  if (endDate) {
+    filtered = filtered.filter((r) => r.timestamp <= endDate);
+  }
+  const period = {
+    start: filtered.length > 0 ? filtered[0].timestamp : /* @__PURE__ */ new Date(),
+    end: filtered.length > 0 ? filtered[filtered.length - 1].timestamp : /* @__PURE__ */ new Date()
+  };
+  const actualCost = filtered.reduce((sum, r) => sum + r.cost, 0);
+  let opusOnlyCost = 0;
+  const requests = { total: filtered.length, haiku: 0, sonnet: 0, opus: 0 };
+  for (const record of filtered) {
+    opusOnlyCost += estimateCost({
+      taskType: record.taskType,
+      inputTokens: record.inputTokens,
+      outputTokens: record.outputTokens,
+      model: "opus"
+    }).totalCost;
+    if (record.model.includes("haiku")) {
+      requests.haiku++;
+    } else if (record.model.includes("sonnet")) {
+      requests.sonnet++;
+    } else if (record.model.includes("opus")) {
+      requests.opus++;
+    }
+  }
+  const savings = opusOnlyCost - actualCost;
+  const savingsPercentage = opusOnlyCost > 0 ? savings / opusOnlyCost * 100 : 0;
+  let recommendation = "";
+  if (savingsPercentage > 50) {
+    recommendation = "Excellent! Your model selection is highly optimized.";
+  } else if (savingsPercentage > 30) {
+    recommendation = "Good savings. Consider using Haiku for simpler tasks.";
+  } else {
+    recommendation = "Consider reviewing task complexity to better match models.";
+  }
+  return {
+    period,
+    actualCost,
+    opusOnlyCost,
+    savings,
+    savingsPercentage,
+    requests,
+    recommendation
+  };
+}
+export {
+  MODELS,
+  batchOptimize,
+  calculateSavings,
+  estimateCost,
+  getCostBreakdown,
+  getCostSummary,
+  getOptimalModel,
+  getSavingsReport,
+  recommendModelUpgrades,
+  smartLLMCall,
+  trackCost
+};

package/dist/ingest-2LPTWUUM.js

@@ -0,0 +1,16 @@
+import {
+  ingestChunk,
+  ingestChunksBatch,
+  ingestSession,
+  updateMemory
+} from "./chunk-C57DHKTL.js";
+import "./chunk-5KIJNY6Z.js";
+import "./chunk-3WGYBAYR.js";
+import "./chunk-H3HSKH2P.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  ingestChunk,
+  ingestChunksBatch,
+  ingestSession,
+  updateMemory
+};

package/dist/ingest-QE2BTV72.js

@@ -0,0 +1,15 @@
+import {
+  ingestChunk,
+  ingestChunksBatch,
+  ingestSession,
+  updateMemory
+} from "./chunk-L6DXSM2U.js";
+import "./chunk-UYWE7HSU.js";
+import "./chunk-X2DL2GWT.js";
+export {
+  ingestChunk,
+  ingestChunksBatch,
+  ingestSession,
+  updateMemory
+};
+//# sourceMappingURL=ingest-QE2BTV72.js.map

package/dist/ingest-QE2BTV72.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/oracle-J47QCSEW.js

@@ -0,0 +1,263 @@
+import {
+  db,
+  embedSingle
+} from "./chunk-3WGYBAYR.js";
+import {
+  Anthropic
+} from "./chunk-H3HSKH2P.js";
+import "./chunk-QGM4M3NI.js";
+
+// ../src/engine/oracle.ts
+var anthropic = new Anthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY || ""
+});
+var MAX_DOCUMENT_CHUNKS = 500;
+async function buildDocumentTree(documentId) {
+  const document = await db.document.findUnique({
+    where: { id: documentId },
+    include: {
+      chunks: {
+        orderBy: { chunkOrder: "asc" },
+        take: MAX_DOCUMENT_CHUNKS
+      }
+    }
+  });
+  if (!document) {
+    throw new Error("Document not found");
+  }
+  const root = {
+    id: document.id,
+    content: document.title,
+    type: "document",
+    children: [],
+    metadata: document.metadata
+  };
+  const sectionMap = /* @__PURE__ */ new Map();
+  for (const chunk of document.chunks) {
+    const sectionPath = chunk.metadata?.sectionPath || chunk.sectionPath || "root";
+    if (!sectionMap.has(sectionPath)) {
+      const sectionNode = {
+        id: `${documentId}::${sectionPath}`,
+        content: sectionPath,
+        type: "section",
+        children: [],
+        metadata: { path: sectionPath }
+      };
+      sectionMap.set(sectionPath, sectionNode);
+      root.children.push(sectionNode);
+    }
+    const section = sectionMap.get(sectionPath);
+    section.children.push({
+      id: chunk.id,
+      content: chunk.content,
+      type: "chunk",
+      children: [],
+      metadata: chunk.metadata,
+      embedding: chunk.embedding
+    });
+  }
+  return {
+    root,
+    depth: calculateDepth(root),
+    nodeCount: countNodes(root)
+  };
+}
+function calculateDepth(node) {
+  if (node.children.length === 0) return 1;
+  return 1 + Math.max(...node.children.map(calculateDepth));
+}
+function countNodes(node) {
+  return 1 + node.children.reduce((sum, child) => sum + countNodes(child), 0);
+}
+async function oracleSearch(params) {
+  const { query, projectId, topK = 5, maxDepth = 3 } = params;
+  console.log(`\u{1F52E} Oracle search: "${query}"`);
+  const queryEmbedding = await embedSingle(query);
+  const documents = await db.document.findMany({
+    where: { projectId },
+    take: 10
+  });
+  const results = [];
+  for (const doc of documents) {
+    const tree = await buildDocumentTree(doc.id);
+    const traversalResults = await guidedTraversal({
+      tree,
+      query,
+      queryEmbedding,
+      maxDepth,
+      topK
+    });
+    results.push(...traversalResults);
+  }
+  results.sort((a, b) => b.relevance - a.relevance);
+  return results.slice(0, topK);
+}
+async function guidedTraversal(params) {
+  const {
+    tree,
+    query,
+    queryEmbedding,
+    maxDepth,
+    topK,
+    currentNode = tree.root,
+    currentDepth = 0,
+    path = ""
+  } = params;
+  const results = [];
+  if (currentDepth >= maxDepth) {
+    return results;
+  }
+  if (currentNode.type === "chunk") {
+    const relevance = currentNode.embedding ? cosineSimilarity(queryEmbedding, currentNode.embedding) : 0;
+    if (relevance > 0.3) {
+      results.push({
+        content: currentNode.content,
+        path,
+        relevance
+      });
+    }
+    return results;
+  }
+  const childScores = await Promise.all(
+    currentNode.children.map(async (child) => {
+      const score = await scoreNode(child, query, queryEmbedding);
+      return { child, score };
+    })
+  );
+  childScores.sort((a, b) => b.score - a.score);
+  const topChildren = childScores.slice(0, Math.min(3, childScores.length));
+  for (const { child, score } of topChildren) {
+    if (score > 0.2) {
+      const childPath = path ? `${path} > ${child.content.substring(0, 30)}` : child.content;
+      const childResults = await guidedTraversal({
+        tree,
+        query,
+        queryEmbedding,
+        maxDepth,
+        topK,
+        currentNode: child,
+        currentDepth: currentDepth + 1,
+        path: childPath
+      });
+      results.push(...childResults);
+    }
+  }
+  return results;
+}
+async function scoreNode(node, query, queryEmbedding) {
+  if (node.embedding) {
+    return cosineSimilarity(queryEmbedding, node.embedding);
+  }
+  const queryWords = query.toLowerCase().split(/\s+/);
+  const nodeWords = node.content.toLowerCase().split(/\s+/);
+  const overlap = queryWords.filter((w) => nodeWords.includes(w)).length;
+  return overlap / queryWords.length;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+async function oracleResearch(params) {
+  const { question, projectId, maxSteps = 5 } = params;
+  const steps = [];
+  let currentQuery = question;
+  for (let step = 1; step <= maxSteps; step++) {
+    console.log(`\u{1F52E} Oracle step ${step}: ${currentQuery}`);
+    const results = await oracleSearch({
+      query: currentQuery,
+      projectId,
+      topK: 5
+    });
+    const reasoning = await reasonAboutResults(currentQuery, results, question);
+    steps.push({
+      step,
+      query: currentQuery,
+      results,
+      reasoning: reasoning.thought
+    });
+    if (reasoning.hasAnswer) {
+      return {
+        answer: reasoning.answer,
+        steps
+      };
+    }
+    currentQuery = reasoning.nextQuery || question;
+  }
+  const finalAnswer = await synthesizeAnswer(question, steps);
+  return {
+    answer: finalAnswer,
+    steps
+  };
+}
+async function reasonAboutResults(query, results, originalQuestion) {
+  const prompt = `You are analyzing search results to answer a question.
+
+**Original question:** ${originalQuestion}
+**Current query:** ${query}
+
+**Search results:**
+${results.map((r, i) => `${i + 1}. ${r.content} (relevance: ${r.relevance.toFixed(2)})`).join("\n")}
+
+Analyze these results:
+1. Do they answer the original question?
+2. What information is still missing?
+3. What should be the next search query?
+
+Return JSON:
+{
+  "thought": "your analysis",
+  "hasAnswer": true or false,
+  "answer": "the answer if you have it" or null,
+  "nextQuery": "next search query" or null
+}`;
+  const response = await anthropic.messages.create({
+    model: "claude-sonnet-4-5-20250929",
+    // Fixed: was "claude-sonnet-4.5" (wrong format)
+    max_tokens: 1024,
+    temperature: 0,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const text = response.content.find((c) => c.type === "text");
+  if (!text || text.type !== "text") {
+    return {
+      thought: "Analysis failed",
+      hasAnswer: false
+    };
+  }
+  const jsonMatch = text.text.match(/```json\n?([\s\S]*?)\n?```/) || text.text.match(/\{[\s\S]*\}/);
+  const jsonStr = jsonMatch ? jsonMatch[1] || jsonMatch[0] : text.text;
+  return JSON.parse(jsonStr);
+}
+async function synthesizeAnswer(question, steps) {
+  const prompt = `Synthesize a final answer from multiple research steps.
+
+**Question:** ${question}
+
+**Research steps:**
+${steps.map((s) => `Step ${s.step}: ${s.query}
+  ${s.reasoning}`).join("\n\n")}
+
+Provide a comprehensive answer based on all the information gathered.`;
+  const response = await anthropic.messages.create({
+    model: "claude-sonnet-4-5-20250929",
+    // Fixed: was "claude-sonnet-4.5" (wrong format)
+    max_tokens: 2048,
+    temperature: 0,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const text = response.content.find((c) => c.type === "text");
+  return text && text.type === "text" ? text.text : "Unable to synthesize answer";
+}
+export {
+  buildDocumentTree,
+  oracleResearch,
+  oracleSearch
+};