prompt-pricer 0.1.0

package/dist/index.cjs

@@ -0,0 +1,494 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  InvalidCalculateInputError: () => InvalidCalculateInputError,
+  InvalidTokenCountError: () => InvalidTokenCountError,
+  UnknownModelError: () => UnknownModelError,
+  calculate: () => calculate,
+  calculateBatch: () => calculateBatch,
+  compare: () => compare,
+  createStreamTracker: () => createStreamTracker,
+  estimateStreamCost: () => estimateStreamCost,
+  models: () => models
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+function createModelId(id) {
+  return id;
+}
+var UnknownModelError = class extends Error {
+  constructor(modelId) {
+    super(`Unknown model: "${modelId}"`);
+    this.name = "UnknownModelError";
+  }
+};
+var InvalidTokenCountError = class extends Error {
+  constructor(field, value) {
+    super(`Invalid token count for "${field}": ${value} (must be >= 0)`);
+    this.name = "InvalidTokenCountError";
+  }
+};
+var InvalidCalculateInputError = class extends Error {
+  constructor(message) {
+    super(`Invalid input: ${message}`);
+    this.name = "InvalidCalculateInputError";
+  }
+};
+
+// src/models/anthropic.ts
+var anthropicModels = [
+  {
+    id: createModelId("claude-3-5-sonnet"),
+    name: "Claude 3.5 Sonnet",
+    provider: "anthropic",
+    contextWindow: 2e5,
+    lastUpdated: "2026-03-01",
+    pricing: {
+      inputPer1M: 3,
+      outputPer1M: 15,
+      cachedInputPer1M: 3.75,
+      // 25% of standard
+      cachedReadPer1M: 0.3
+      // 2% of standard
+    },
+    notes: "Latest Claude 3.5 model, optimized for speed/cost balance. Supports prompt caching."
+  },
+  {
+    id: createModelId("claude-3-opus"),
+    name: "Claude 3 Opus",
+    provider: "anthropic",
+    contextWindow: 2e5,
+    lastUpdated: "2026-03-01",
+    pricing: {
+      inputPer1M: 15,
+      outputPer1M: 75,
+      cachedInputPer1M: 18.75,
+      cachedReadPer1M: 1.5
+    },
+    notes: "Most capable Claude 3 variant. Higher cost but best performance."
+  },
+  {
+    id: createModelId("claude-3-sonnet"),
+    name: "Claude 3 Sonnet",
+    provider: "anthropic",
+    contextWindow: 2e5,
+    lastUpdated: "2026-03-01",
+    pricing: {
+      inputPer1M: 3,
+      outputPer1M: 15,
+      cachedInputPer1M: 3.75,
+      cachedReadPer1M: 0.3
+    },
+    notes: "Balanced Claude 3 model. Use Claude 3.5 Sonnet for better speed/cost."
+  },
+  {
+    id: createModelId("claude-3-haiku"),
+    name: "Claude 3 Haiku",
+    provider: "anthropic",
+    contextWindow: 2e5,
+    lastUpdated: "2026-03-01",
+    pricing: {
+      inputPer1M: 0.25,
+      outputPer1M: 1.25,
+      cachedInputPer1M: 0.3125,
+      cachedReadPer1M: 0.025
+    },
+    notes: "Fastest and most compact Claude model. Best for simple tasks."
+  }
+];
+
+// src/models/openai.ts
+var openaiModels = [
+  {
+    id: createModelId("gpt-4o"),
+    name: "GPT-4o",
+    provider: "openai",
+    contextWindow: 128e3,
+    lastUpdated: "2026-03-15",
+    pricing: {
+      inputPer1M: 5,
+      outputPer1M: 15,
+      batchInputPer1M: 2.5,
+      batchOutputPer1M: 7.5
+    },
+    notes: "Latest flagship model. Supports batch API for cost reduction."
+  },
+  {
+    id: createModelId("gpt-4o-mini"),
+    name: "GPT-4o Mini",
+    provider: "openai",
+    contextWindow: 128e3,
+    lastUpdated: "2026-03-15",
+    pricing: {
+      inputPer1M: 0.15,
+      outputPer1M: 0.6,
+      batchInputPer1M: 0.075,
+      batchOutputPer1M: 0.3
+    },
+    notes: "Lightweight, cost-effective model. Great for simple tasks and high volume."
+  },
+  {
+    id: createModelId("gpt-4-turbo"),
+    name: "GPT-4 Turbo",
+    provider: "openai",
+    contextWindow: 128e3,
+    lastUpdated: "2026-03-15",
+    pricing: {
+      inputPer1M: 10,
+      outputPer1M: 30,
+      batchInputPer1M: 5,
+      batchOutputPer1M: 15
+    },
+    notes: "Previous generation flagship. Maintained for compatibility."
+  },
+  {
+    id: createModelId("o1"),
+    name: "o1",
+    provider: "openai",
+    contextWindow: 128e3,
+    lastUpdated: "2026-03-15",
+    pricing: {
+      inputPer1M: 15,
+      outputPer1M: 60
+    },
+    notes: "Reasoning model for complex problem-solving. Premium pricing."
+  },
+  {
+    id: createModelId("o1-mini"),
+    name: "o1 Mini",
+    provider: "openai",
+    contextWindow: 128e3,
+    lastUpdated: "2026-03-15",
+    pricing: {
+      inputPer1M: 3,
+      outputPer1M: 12
+    },
+    notes: "Lightweight reasoning model. Better cost/performance than o1."
+  }
+];
+
+// src/models/google.ts
+var googleModels = [
+  {
+    id: createModelId("gemini-1.5-pro"),
+    name: "Gemini 1.5 Pro",
+    provider: "google",
+    contextWindow: 2e6,
+    lastUpdated: "2026-02-01",
+    pricing: {
+      inputPer1M: 7.5,
+      outputPer1M: 30
+    },
+    notes: "Latest flagship model. Massive 2M token context window."
+  },
+  {
+    id: createModelId("gemini-1.5-flash"),
+    name: "Gemini 1.5 Flash",
+    provider: "google",
+    contextWindow: 1e6,
+    lastUpdated: "2026-02-01",
+    pricing: {
+      inputPer1M: 0.075,
+      outputPer1M: 0.3
+    },
+    notes: "Fast, cost-effective model. Excellent for high-volume applications."
+  },
+  {
+    id: createModelId("gemini-1-pro"),
+    name: "Gemini 1 Pro",
+    provider: "google",
+    contextWindow: 32e3,
+    lastUpdated: "2026-02-01",
+    pricing: {
+      inputPer1M: 0.5,
+      outputPer1M: 1.5
+    },
+    notes: "Previous generation. Maintained for compatibility."
+  }
+];
+
+// src/models/catalog.ts
+var ALL_MODELS = [
+  ...anthropicModels,
+  ...openaiModels,
+  ...googleModels
+];
+var ALIASES = {
+  // Claude aliases
+  "claude-sonnet": "claude-3-5-sonnet",
+  "claude-haiku": "claude-3-haiku",
+  "claude-opus": "claude-3-opus",
+  // GPT aliases
+  "gpt4": "gpt-4o",
+  "gpt4o": "gpt-4o",
+  "gpt-4": "gpt-4o",
+  "gpt4o-mini": "gpt-4o-mini",
+  "gpt-4-mini": "gpt-4o-mini",
+  // Gemini aliases
+  "gemini": "gemini-1.5-pro",
+  "gemini-pro": "gemini-1.5-pro",
+  "gemini-flash": "gemini-1.5-flash"
+};
+function getModel(modelId) {
+  const normalized = modelId.toLowerCase().trim();
+  let model = ALL_MODELS.find((m) => m.id === normalized);
+  if (model) return model;
+  const canonical = ALIASES[normalized];
+  if (canonical) {
+    model = ALL_MODELS.find((m) => m.id === canonical);
+    if (model) return model;
+  }
+  throw new UnknownModelError(modelId);
+}
+function listModels() {
+  return ALL_MODELS;
+}
+function getModelsByProvider(provider) {
+  return ALL_MODELS.filter((m) => m.provider === provider);
+}
+function searchModels(query) {
+  const q = query.toLowerCase();
+  return ALL_MODELS.filter(
+    (m) => m.id.toLowerCase().includes(q) || m.name.toLowerCase().includes(q) || m.provider.toLowerCase().includes(q)
+  );
+}
+function getModelsByCost() {
+  const sorted = [...ALL_MODELS].sort(
+    (a, b) => a.pricing.inputPer1M - b.pricing.inputPer1M
+  );
+  return sorted;
+}
+function getCatalogStats() {
+  const providers = {
+    anthropic: 0,
+    openai: 0,
+    google: 0
+  };
+  for (const model of ALL_MODELS) {
+    providers[model.provider]++;
+  }
+  return {
+    totalModels: ALL_MODELS.length,
+    providers,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var models = {
+  get: getModel,
+  list: listModels,
+  byProvider: getModelsByProvider,
+  search: searchModels,
+  byCost: getModelsByCost,
+  stats: getCatalogStats
+};
+
+// src/utils.ts
+function roundCost(value) {
+  return Math.round(value * 1e8) / 1e8;
+}
+
+// src/calculate.ts
+function validateTokenCount(field, value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new InvalidTokenCountError(field, value);
+  }
+}
+function calculate(input) {
+  if (!input.model || typeof input.model !== "string") {
+    throw new InvalidCalculateInputError("model must be a non-empty string");
+  }
+  validateTokenCount("inputTokens", input.inputTokens);
+  validateTokenCount("outputTokens", input.outputTokens);
+  if (input.cachedTokens !== void 0) {
+    validateTokenCount("cachedTokens", input.cachedTokens);
+    if (input.cachedTokens > input.inputTokens) {
+      throw new InvalidCalculateInputError(
+        "cachedTokens cannot exceed inputTokens"
+      );
+    }
+  }
+  let modelInfo;
+  try {
+    modelInfo = getModel(input.model);
+  } catch (error) {
+    if (error instanceof UnknownModelError) {
+      throw error;
+    }
+    throw new InvalidCalculateInputError(`Invalid model: ${input.model}`);
+  }
+  const { pricing } = modelInfo;
+  const standardInputTokens = input.inputTokens - (input.cachedTokens ?? 0);
+  const standardInputCost = roundCost(
+    standardInputTokens / 1e6 * pricing.inputPer1M
+  );
+  let cachedInputCost = 0;
+  if (input.cachedTokens && input.cachedTokens > 0 && pricing.cachedInputPer1M) {
+    cachedInputCost = roundCost(
+      input.cachedTokens / 1e6 * pricing.cachedInputPer1M
+    );
+  }
+  const inputCost = roundCost(standardInputCost + cachedInputCost);
+  const outputCost = roundCost(
+    input.outputTokens / 1e6 * pricing.outputPer1M
+  );
+  const total = roundCost(inputCost + outputCost);
+  const result = {
+    model: modelInfo.id,
+    provider: modelInfo.provider,
+    inputTokens: input.inputTokens,
+    outputTokens: input.outputTokens,
+    input: inputCost,
+    output: outputCost,
+    total,
+    currency: "USD",
+    pricing: modelInfo.pricing
+  };
+  if (input.cachedTokens !== void 0) {
+    result.cachedTokens = input.cachedTokens;
+  }
+  if (cachedInputCost > 0) {
+    result.cached = cachedInputCost;
+  }
+  return result;
+}
+
+// src/compare.ts
+function compare(input) {
+  if (!input.models || input.models.length === 0) {
+    throw new InvalidCalculateInputError("models array must not be empty");
+  }
+  const results = input.models.map(
+    (model) => calculate({
+      model,
+      inputTokens: input.inputTokens,
+      outputTokens: input.outputTokens,
+      ...input.cachedTokens !== void 0 && { cachedTokens: input.cachedTokens }
+    })
+  );
+  results.sort((a, b) => a.total - b.total);
+  const cheapest = results[0].total;
+  return results.map((result, index) => ({
+    ...result,
+    rank: index + 1,
+    relativeCost: cheapest === 0 ? 1 : roundCost(result.total / cheapest)
+  }));
+}
+
+// src/batch.ts
+function calculateBatch(inputs) {
+  if (!inputs || inputs.length === 0) {
+    throw new InvalidCalculateInputError("inputs array must not be empty");
+  }
+  const results = inputs.map((input) => calculate(input));
+  const totalCost = roundCost(results.reduce((sum, r) => sum + r.total, 0));
+  return {
+    results,
+    totalCost,
+    currency: "USD",
+    itemCount: results.length
+  };
+}
+
+// src/streaming.ts
+var CHARS_PER_TOKEN = 4;
+function estimateStreamCost(input) {
+  if (!Number.isFinite(input.inputTokens) || input.inputTokens < 0) {
+    throw new InvalidTokenCountError("inputTokens", input.inputTokens);
+  }
+  if (!Number.isFinite(input.expectedOutputTokens) || input.expectedOutputTokens < 0) {
+    throw new InvalidTokenCountError("expectedOutputTokens", input.expectedOutputTokens);
+  }
+  const modelInfo = getModel(input.model);
+  const { pricing } = modelInfo;
+  const inputCost = roundCost(input.inputTokens / 1e6 * pricing.inputPer1M);
+  const outputCost = roundCost(input.expectedOutputTokens / 1e6 * pricing.outputPer1M);
+  const estimatedTotal = roundCost(inputCost + outputCost);
+  return {
+    model: modelInfo.id,
+    inputTokens: input.inputTokens,
+    estimatedOutputTokens: input.expectedOutputTokens,
+    estimatedTotal,
+    confidence: "medium",
+    range: {
+      min: roundCost(inputCost + outputCost * 0.9),
+      max: roundCost(inputCost + outputCost * 1.1)
+    }
+  };
+}
+function createStreamTracker(input) {
+  if (!Number.isFinite(input.inputTokens) || input.inputTokens < 0) {
+    throw new InvalidTokenCountError("inputTokens", input.inputTokens);
+  }
+  const modelInfo = getModel(input.model);
+  const { pricing } = modelInfo;
+  const inputCost = roundCost(input.inputTokens / 1e6 * pricing.inputPer1M);
+  let totalChars = 0;
+  return {
+    addChunk(text) {
+      totalChars += text.length;
+    },
+    getCurrent() {
+      const estimatedTokens = Math.round(totalChars / CHARS_PER_TOKEN);
+      const outputCost = roundCost(estimatedTokens / 1e6 * pricing.outputPer1M);
+      const estimatedTotal = roundCost(inputCost + outputCost);
+      return {
+        model: modelInfo.id,
+        inputTokens: input.inputTokens,
+        estimatedOutputTokens: estimatedTokens,
+        estimatedTotal,
+        confidence: "low",
+        range: {
+          min: roundCost(estimatedTotal * 0.75),
+          max: roundCost(estimatedTotal * 1.25)
+        }
+      };
+    },
+    finalize() {
+      const outputTokens = Math.round(totalChars / CHARS_PER_TOKEN);
+      const outputCost = roundCost(outputTokens / 1e6 * pricing.outputPer1M);
+      return {
+        model: modelInfo.id,
+        provider: modelInfo.provider,
+        inputTokens: input.inputTokens,
+        outputTokens,
+        input: inputCost,
+        output: outputCost,
+        total: roundCost(inputCost + outputCost),
+        currency: "USD",
+        pricing: modelInfo.pricing
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InvalidCalculateInputError,
+  InvalidTokenCountError,
+  UnknownModelError,
+  calculate,
+  calculateBatch,
+  compare,
+  createStreamTracker,
+  estimateStreamCost,
+  models
+});

package/dist/index.js

@@ -0,0 +1,459 @@
+// src/types.ts
+function createModelId(id) {
+  return id;
+}
+var UnknownModelError = class extends Error {
+  constructor(modelId) {
+    super(`Unknown model: "${modelId}"`);
+    this.name = "UnknownModelError";
+  }
+};
+var InvalidTokenCountError = class extends Error {
+  constructor(field, value) {
+    super(`Invalid token count for "${field}": ${value} (must be >= 0)`);
+    this.name = "InvalidTokenCountError";
+  }
+};
+var InvalidCalculateInputError = class extends Error {
+  constructor(message) {
+    super(`Invalid input: ${message}`);
+    this.name = "InvalidCalculateInputError";
+  }
+};
+
+// src/models/anthropic.ts
+var anthropicModels = [
+  {
+    id: createModelId("claude-3-5-sonnet"),
+    name: "Claude 3.5 Sonnet",
+    provider: "anthropic",
+    contextWindow: 2e5,
+    lastUpdated: "2026-03-01",
+    pricing: {
+      inputPer1M: 3,
+      outputPer1M: 15,
+      cachedInputPer1M: 3.75,
+      // 25% of standard
+      cachedReadPer1M: 0.3
+      // 2% of standard
+    },
+    notes: "Latest Claude 3.5 model, optimized for speed/cost balance. Supports prompt caching."
+  },
+  {
+    id: createModelId("claude-3-opus"),
+    name: "Claude 3 Opus",
+    provider: "anthropic",
+    contextWindow: 2e5,
+    lastUpdated: "2026-03-01",
+    pricing: {
+      inputPer1M: 15,
+      outputPer1M: 75,
+      cachedInputPer1M: 18.75,
+      cachedReadPer1M: 1.5
+    },
+    notes: "Most capable Claude 3 variant. Higher cost but best performance."
+  },
+  {
+    id: createModelId("claude-3-sonnet"),
+    name: "Claude 3 Sonnet",
+    provider: "anthropic",
+    contextWindow: 2e5,
+    lastUpdated: "2026-03-01",
+    pricing: {
+      inputPer1M: 3,
+      outputPer1M: 15,
+      cachedInputPer1M: 3.75,
+      cachedReadPer1M: 0.3
+    },
+    notes: "Balanced Claude 3 model. Use Claude 3.5 Sonnet for better speed/cost."
+  },
+  {
+    id: createModelId("claude-3-haiku"),
+    name: "Claude 3 Haiku",
+    provider: "anthropic",
+    contextWindow: 2e5,
+    lastUpdated: "2026-03-01",
+    pricing: {
+      inputPer1M: 0.25,
+      outputPer1M: 1.25,
+      cachedInputPer1M: 0.3125,
+      cachedReadPer1M: 0.025
+    },
+    notes: "Fastest and most compact Claude model. Best for simple tasks."
+  }
+];
+
+// src/models/openai.ts
+var openaiModels = [
+  {
+    id: createModelId("gpt-4o"),
+    name: "GPT-4o",
+    provider: "openai",
+    contextWindow: 128e3,
+    lastUpdated: "2026-03-15",
+    pricing: {
+      inputPer1M: 5,
+      outputPer1M: 15,
+      batchInputPer1M: 2.5,
+      batchOutputPer1M: 7.5
+    },
+    notes: "Latest flagship model. Supports batch API for cost reduction."
+  },
+  {
+    id: createModelId("gpt-4o-mini"),
+    name: "GPT-4o Mini",
+    provider: "openai",
+    contextWindow: 128e3,
+    lastUpdated: "2026-03-15",
+    pricing: {
+      inputPer1M: 0.15,
+      outputPer1M: 0.6,
+      batchInputPer1M: 0.075,
+      batchOutputPer1M: 0.3
+    },
+    notes: "Lightweight, cost-effective model. Great for simple tasks and high volume."
+  },
+  {
+    id: createModelId("gpt-4-turbo"),
+    name: "GPT-4 Turbo",
+    provider: "openai",
+    contextWindow: 128e3,
+    lastUpdated: "2026-03-15",
+    pricing: {
+      inputPer1M: 10,
+      outputPer1M: 30,
+      batchInputPer1M: 5,
+      batchOutputPer1M: 15
+    },
+    notes: "Previous generation flagship. Maintained for compatibility."
+  },
+  {
+    id: createModelId("o1"),
+    name: "o1",
+    provider: "openai",
+    contextWindow: 128e3,
+    lastUpdated: "2026-03-15",
+    pricing: {
+      inputPer1M: 15,
+      outputPer1M: 60
+    },
+    notes: "Reasoning model for complex problem-solving. Premium pricing."
+  },
+  {
+    id: createModelId("o1-mini"),
+    name: "o1 Mini",
+    provider: "openai",
+    contextWindow: 128e3,
+    lastUpdated: "2026-03-15",
+    pricing: {
+      inputPer1M: 3,
+      outputPer1M: 12
+    },
+    notes: "Lightweight reasoning model. Better cost/performance than o1."
+  }
+];
+
+// src/models/google.ts
+var googleModels = [
+  {
+    id: createModelId("gemini-1.5-pro"),
+    name: "Gemini 1.5 Pro",
+    provider: "google",
+    contextWindow: 2e6,
+    lastUpdated: "2026-02-01",
+    pricing: {
+      inputPer1M: 7.5,
+      outputPer1M: 30
+    },
+    notes: "Latest flagship model. Massive 2M token context window."
+  },
+  {
+    id: createModelId("gemini-1.5-flash"),
+    name: "Gemini 1.5 Flash",
+    provider: "google",
+    contextWindow: 1e6,
+    lastUpdated: "2026-02-01",
+    pricing: {
+      inputPer1M: 0.075,
+      outputPer1M: 0.3
+    },
+    notes: "Fast, cost-effective model. Excellent for high-volume applications."
+  },
+  {
+    id: createModelId("gemini-1-pro"),
+    name: "Gemini 1 Pro",
+    provider: "google",
+    contextWindow: 32e3,
+    lastUpdated: "2026-02-01",
+    pricing: {
+      inputPer1M: 0.5,
+      outputPer1M: 1.5
+    },
+    notes: "Previous generation. Maintained for compatibility."
+  }
+];
+
+// src/models/catalog.ts
+var ALL_MODELS = [
+  ...anthropicModels,
+  ...openaiModels,
+  ...googleModels
+];
+var ALIASES = {
+  // Claude aliases
+  "claude-sonnet": "claude-3-5-sonnet",
+  "claude-haiku": "claude-3-haiku",
+  "claude-opus": "claude-3-opus",
+  // GPT aliases
+  "gpt4": "gpt-4o",
+  "gpt4o": "gpt-4o",
+  "gpt-4": "gpt-4o",
+  "gpt4o-mini": "gpt-4o-mini",
+  "gpt-4-mini": "gpt-4o-mini",
+  // Gemini aliases
+  "gemini": "gemini-1.5-pro",
+  "gemini-pro": "gemini-1.5-pro",
+  "gemini-flash": "gemini-1.5-flash"
+};
+function getModel(modelId) {
+  const normalized = modelId.toLowerCase().trim();
+  let model = ALL_MODELS.find((m) => m.id === normalized);
+  if (model) return model;
+  const canonical = ALIASES[normalized];
+  if (canonical) {
+    model = ALL_MODELS.find((m) => m.id === canonical);
+    if (model) return model;
+  }
+  throw new UnknownModelError(modelId);
+}
+function listModels() {
+  return ALL_MODELS;
+}
+function getModelsByProvider(provider) {
+  return ALL_MODELS.filter((m) => m.provider === provider);
+}
+function searchModels(query) {
+  const q = query.toLowerCase();
+  return ALL_MODELS.filter(
+    (m) => m.id.toLowerCase().includes(q) || m.name.toLowerCase().includes(q) || m.provider.toLowerCase().includes(q)
+  );
+}
+function getModelsByCost() {
+  const sorted = [...ALL_MODELS].sort(
+    (a, b) => a.pricing.inputPer1M - b.pricing.inputPer1M
+  );
+  return sorted;
+}
+function getCatalogStats() {
+  const providers = {
+    anthropic: 0,
+    openai: 0,
+    google: 0
+  };
+  for (const model of ALL_MODELS) {
+    providers[model.provider]++;
+  }
+  return {
+    totalModels: ALL_MODELS.length,
+    providers,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var models = {
+  get: getModel,
+  list: listModels,
+  byProvider: getModelsByProvider,
+  search: searchModels,
+  byCost: getModelsByCost,
+  stats: getCatalogStats
+};
+
+// src/utils.ts
+function roundCost(value) {
+  return Math.round(value * 1e8) / 1e8;
+}
+
+// src/calculate.ts
+function validateTokenCount(field, value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new InvalidTokenCountError(field, value);
+  }
+}
+function calculate(input) {
+  if (!input.model || typeof input.model !== "string") {
+    throw new InvalidCalculateInputError("model must be a non-empty string");
+  }
+  validateTokenCount("inputTokens", input.inputTokens);
+  validateTokenCount("outputTokens", input.outputTokens);
+  if (input.cachedTokens !== void 0) {
+    validateTokenCount("cachedTokens", input.cachedTokens);
+    if (input.cachedTokens > input.inputTokens) {
+      throw new InvalidCalculateInputError(
+        "cachedTokens cannot exceed inputTokens"
+      );
+    }
+  }
+  let modelInfo;
+  try {
+    modelInfo = getModel(input.model);
+  } catch (error) {
+    if (error instanceof UnknownModelError) {
+      throw error;
+    }
+    throw new InvalidCalculateInputError(`Invalid model: ${input.model}`);
+  }
+  const { pricing } = modelInfo;
+  const standardInputTokens = input.inputTokens - (input.cachedTokens ?? 0);
+  const standardInputCost = roundCost(
+    standardInputTokens / 1e6 * pricing.inputPer1M
+  );
+  let cachedInputCost = 0;
+  if (input.cachedTokens && input.cachedTokens > 0 && pricing.cachedInputPer1M) {
+    cachedInputCost = roundCost(
+      input.cachedTokens / 1e6 * pricing.cachedInputPer1M
+    );
+  }
+  const inputCost = roundCost(standardInputCost + cachedInputCost);
+  const outputCost = roundCost(
+    input.outputTokens / 1e6 * pricing.outputPer1M
+  );
+  const total = roundCost(inputCost + outputCost);
+  const result = {
+    model: modelInfo.id,
+    provider: modelInfo.provider,
+    inputTokens: input.inputTokens,
+    outputTokens: input.outputTokens,
+    input: inputCost,
+    output: outputCost,
+    total,
+    currency: "USD",
+    pricing: modelInfo.pricing
+  };
+  if (input.cachedTokens !== void 0) {
+    result.cachedTokens = input.cachedTokens;
+  }
+  if (cachedInputCost > 0) {
+    result.cached = cachedInputCost;
+  }
+  return result;
+}
+
+// src/compare.ts
+function compare(input) {
+  if (!input.models || input.models.length === 0) {
+    throw new InvalidCalculateInputError("models array must not be empty");
+  }
+  const results = input.models.map(
+    (model) => calculate({
+      model,
+      inputTokens: input.inputTokens,
+      outputTokens: input.outputTokens,
+      ...input.cachedTokens !== void 0 && { cachedTokens: input.cachedTokens }
+    })
+  );
+  results.sort((a, b) => a.total - b.total);
+  const cheapest = results[0].total;
+  return results.map((result, index) => ({
+    ...result,
+    rank: index + 1,
+    relativeCost: cheapest === 0 ? 1 : roundCost(result.total / cheapest)
+  }));
+}
+
+// src/batch.ts
+function calculateBatch(inputs) {
+  if (!inputs || inputs.length === 0) {
+    throw new InvalidCalculateInputError("inputs array must not be empty");
+  }
+  const results = inputs.map((input) => calculate(input));
+  const totalCost = roundCost(results.reduce((sum, r) => sum + r.total, 0));
+  return {
+    results,
+    totalCost,
+    currency: "USD",
+    itemCount: results.length
+  };
+}
+
+// src/streaming.ts
+var CHARS_PER_TOKEN = 4;
+function estimateStreamCost(input) {
+  if (!Number.isFinite(input.inputTokens) || input.inputTokens < 0) {
+    throw new InvalidTokenCountError("inputTokens", input.inputTokens);
+  }
+  if (!Number.isFinite(input.expectedOutputTokens) || input.expectedOutputTokens < 0) {
+    throw new InvalidTokenCountError("expectedOutputTokens", input.expectedOutputTokens);
+  }
+  const modelInfo = getModel(input.model);
+  const { pricing } = modelInfo;
+  const inputCost = roundCost(input.inputTokens / 1e6 * pricing.inputPer1M);
+  const outputCost = roundCost(input.expectedOutputTokens / 1e6 * pricing.outputPer1M);
+  const estimatedTotal = roundCost(inputCost + outputCost);
+  return {
+    model: modelInfo.id,
+    inputTokens: input.inputTokens,
+    estimatedOutputTokens: input.expectedOutputTokens,
+    estimatedTotal,
+    confidence: "medium",
+    range: {
+      min: roundCost(inputCost + outputCost * 0.9),
+      max: roundCost(inputCost + outputCost * 1.1)
+    }
+  };
+}
+function createStreamTracker(input) {
+  if (!Number.isFinite(input.inputTokens) || input.inputTokens < 0) {
+    throw new InvalidTokenCountError("inputTokens", input.inputTokens);
+  }
+  const modelInfo = getModel(input.model);
+  const { pricing } = modelInfo;
+  const inputCost = roundCost(input.inputTokens / 1e6 * pricing.inputPer1M);
+  let totalChars = 0;
+  return {
+    addChunk(text) {
+      totalChars += text.length;
+    },
+    getCurrent() {
+      const estimatedTokens = Math.round(totalChars / CHARS_PER_TOKEN);
+      const outputCost = roundCost(estimatedTokens / 1e6 * pricing.outputPer1M);
+      const estimatedTotal = roundCost(inputCost + outputCost);
+      return {
+        model: modelInfo.id,
+        inputTokens: input.inputTokens,
+        estimatedOutputTokens: estimatedTokens,
+        estimatedTotal,
+        confidence: "low",
+        range: {
+          min: roundCost(estimatedTotal * 0.75),
+          max: roundCost(estimatedTotal * 1.25)
+        }
+      };
+    },
+    finalize() {
+      const outputTokens = Math.round(totalChars / CHARS_PER_TOKEN);
+      const outputCost = roundCost(outputTokens / 1e6 * pricing.outputPer1M);
+      return {
+        model: modelInfo.id,
+        provider: modelInfo.provider,
+        inputTokens: input.inputTokens,
+        outputTokens,
+        input: inputCost,
+        output: outputCost,
+        total: roundCost(inputCost + outputCost),
+        currency: "USD",
+        pricing: modelInfo.pricing
+      };
+    }
+  };
+}
+export {
+  InvalidCalculateInputError,
+  InvalidTokenCountError,
+  UnknownModelError,
+  calculate,
+  calculateBatch,
+  compare,
+  createStreamTracker,
+  estimateStreamCost,
+  models
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "prompt-pricer",
+  "version": "0.1.0",
+  "description": "Calculate LLM API costs before you get the bill. TypeScript-first, zero dependencies.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "bun build.ts",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage",
+    "typecheck": "tsc --noEmit",
+    "smoke": "bun smoke.ts"
+  },
+  "keywords": [
+    "llm",
+    "ai",
+    "cost",
+    "calculator",
+    "claude",
+    "openai",
+    "gemini",
+    "tokens",
+    "pricing",
+    "typescript"
+  ],
+  "author": "JD",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jd/prompt-pricer.git"
+  },
+  "homepage": "https://promptpricer.dev",
+  "bugs": {
+    "url": "https://github.com/jd/prompt-pricer/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}