@usewhisper/mcp-server 0.3.0 → 0.5.0

package/dist/cost-optimization-F3L5BS5F.js

@@ -1,303 +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
-};
+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

@@ -1,16 +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
-};
+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-7T5FAZNC.js

@@ -1,15 +1,15 @@
-import {
-  ingestChunk,
-  ingestChunksBatch,
-  ingestSession,
-  updateMemory
-} from "./chunk-EI5CE3EY.js";
-import "./chunk-5KBZQHDL.js";
-import "./chunk-3WGYBAYR.js";
-import "./chunk-QGM4M3NI.js";
-export {
-  ingestChunk,
-  ingestChunksBatch,
-  ingestSession,
-  updateMemory
-};
+import {
+  ingestChunk,
+  ingestChunksBatch,
+  ingestSession,
+  updateMemory
+} from "./chunk-EI5CE3EY.js";
+import "./chunk-5KBZQHDL.js";
+import "./chunk-3WGYBAYR.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  ingestChunk,
+  ingestChunksBatch,
+  ingestSession,
+  updateMemory
+};