ccusage 11.0.1 → 12.0.0

package/dist/mcp.d.ts

@@ -1,13 +1,37 @@
-import "./pricing-fetcher-DHaTs-k2.js";
-import { LoadOptions } from "./data-loader-dbZm5kOW.js";
-import { FastMCP } from "fastmcp";
+import "./pricing-fetcher-BkOpRIdx.js";
+import { LoadOptions } from "./data-loader-CBwn9vk0.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Hono } from "hono";
 
 //#region src/mcp.d.ts
+
 /**
- * Creates a FastMCP server with tools for showing usage reports.
+ * Creates an MCP server with tools for showing usage reports.
+ * Registers tools for daily, session, monthly, and blocks usage data.
+ *
+ * @param options - Configuration options for the MCP server
+ * @param options.claudePath - Path to Claude's data directory
+ * @returns Configured MCP server instance with registered tools
  */
 declare function createMcpServer({
   claudePath
-}?: LoadOptions): FastMCP;
+}?: LoadOptions): McpServer;
+/**
+ * Start the MCP server with stdio transport.
+ * Used for traditional MCP client connections via standard input/output.
+ *
+ * @param server - The MCP server instance to start
+ */
+declare function startMcpServerStdio(server: McpServer): Promise<void>;
+/**
+ * Create Hono app for MCP HTTP server.
+ * Provides HTTP transport support for MCP protocol using Hono framework.
+ * Handles POST requests for MCP communication and returns appropriate errors for other methods.
+ *
+ * @param options - Configuration options for the MCP server
+ * @param options.claudePath - Path to Claude's data directory
+ * @returns Configured Hono application for HTTP MCP transport
+ */
+declare function createMcpHttpApp(options?: LoadOptions): Hono;
 //#endregion
-export { createMcpServer };
+export { createMcpHttpApp, createMcpServer, startMcpServerStdio };

package/dist/mcp.js

@@ -1,9 +1,5 @@
-import "./pricing-fetcher-BtW4MVG7.js";
-import "./data-loader-BzOeJe6y.js";
-import "./dist-DCvt9hEv.js";
-import "./logger-E_Utl_fr.js";
-import "./types-5-VF7WcO.js";
-import { createMcpServer } from "./mcp-SPAE-cNK.js";
-import "./index-CISmcbXk-DpuCarFe.js";
-
-export { createMcpServer };
+import "./pricing-fetcher-3m6_Ejp8.js";
+import "./data-loader-rsgRy-no.js";
+import "./logger-CTFDCX5W.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-Cg5potQX.js";
+export { createMcpHttpApp, createMcpServer, startMcpServerStdio };

package/dist/{types-5-VF7WcO.js → pricing-fetcher-3m6_Ejp8.js}

@@ -1,4 +1,27 @@
-//#region node_modules/zod/dist/esm/v3/helpers/util.js
+import { logger } from "./logger-CTFDCX5W.js";
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 var util;
 (function(util$1) {
 	util$1.assertEqual = (_) => {};
@@ -95,9 +118,6 @@ const getParsedType = (data) => {
 		default: return ZodParsedType.unknown;
 	}
 };
-
-//#endregion
-//#region node_modules/zod/dist/esm/v3/ZodError.js
 const ZodIssueCode = util.arrayToEnum([
 	"invalid_type",
 	"invalid_literal",
@@ -196,9 +216,6 @@ ZodError.create = (issues) => {
 	const error = new ZodError(issues);
 	return error;
 };
-
-//#endregion
-//#region node_modules/zod/dist/esm/v3/locales/en.js
 const errorMap = (issue, _ctx) => {
 	let message;
 	switch (issue.code) {
@@ -274,16 +291,10 @@ const errorMap = (issue, _ctx) => {
 	return { message };
 };
 var en_default = errorMap;
-
-//#endregion
-//#region node_modules/zod/dist/esm/v3/errors.js
 let overrideErrorMap = en_default;
 function getErrorMap() {
 	return overrideErrorMap;
 }
-
-//#endregion
-//#region node_modules/zod/dist/esm/v3/helpers/parseUtil.js
 const makeIssue = (params) => {
 	const { data, path, errorMaps, issueData } = params;
 	const fullPath = [...path, ...issueData.path || []];
@@ -386,17 +397,11 @@ const isAborted = (x) => x.status === "aborted";
 const isDirty = (x) => x.status === "dirty";
 const isValid = (x) => x.status === "valid";
 const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
-
-//#endregion
-//#region node_modules/zod/dist/esm/v3/helpers/errorUtil.js
 var errorUtil;
 (function(errorUtil$1) {
 	errorUtil$1.errToObj = (message) => typeof message === "string" ? { message } : message || {};
 	errorUtil$1.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
-
-//#endregion
-//#region node_modules/zod/dist/esm/v3/types.js
 var ParseInputLazyPath = class {
 	constructor(parent, value, path, key) {
 		this._cachedPath = [];
@@ -3581,6 +3586,320 @@ const optionalType = ZodOptional.create;
 const nullableType = ZodNullable.create;
 const preprocessType = ZodEffects.createWithPreprocess;
 const pipelineType = ZodPipeline.create;
-
-//#endregion
-export { ZodFirstPartyTypeKind, ZodOptional, anyType, arrayType, booleanType, discriminatedUnionType, enumType, literalType, numberType, objectType, optionalType, recordType, stringType, unionType, unknownType };
+/**
+* URL for LiteLLM's model pricing and context window data
+*/
+const LITELLM_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+/**
+* Zod schema for validating date strings in YYYYMMDD format
+*/
+const dateSchema = stringType().regex(/^\d{8}$/, "Date must be in YYYYMMDD format");
+/**
+* Available cost calculation modes
+* - auto: Use pre-calculated costs when available, otherwise calculate from tokens
+* - calculate: Always calculate costs from token counts using model pricing
+* - display: Always use pre-calculated costs, show 0 for missing costs
+*/
+const CostModes = [
+	"auto",
+	"calculate",
+	"display"
+];
+/**
+* Available sort orders for data presentation
+*/
+const SortOrders = ["desc", "asc"];
+/**
+* Zod schema for model pricing information from LiteLLM
+*/
+const modelPricingSchema = objectType({
+	input_cost_per_token: numberType().optional(),
+	output_cost_per_token: numberType().optional(),
+	cache_creation_input_token_cost: numberType().optional(),
+	cache_read_input_token_cost: numberType().optional()
+});
+var require_usingCtx = __commonJSMin((exports, module) => {
+	function _usingCtx() {
+		var r = "function" == typeof SuppressedError ? SuppressedError : function(r$1, e$1) {
+			var n$1 = Error();
+			return n$1.name = "SuppressedError", n$1.error = r$1, n$1.suppressed = e$1, n$1;
+		}, e = {}, n = [];
+		function using(r$1, e$1) {
+			if (null != e$1) {
+				if (Object(e$1) !== e$1) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+				if (r$1) var o = e$1[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+				if (void 0 === o && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1)) var t = o;
+				if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+				t && (o = function o$1() {
+					try {
+						t.call(e$1);
+					} catch (r$2) {
+						return Promise.reject(r$2);
+					}
+				}), n.push({
+					v: e$1,
+					d: o,
+					a: r$1
+				});
+			} else r$1 && n.push({
+				d: e$1,
+				a: r$1
+			});
+			return e$1;
+		}
+		return {
+			e,
+			u: using.bind(null, !1),
+			a: using.bind(null, !0),
+			d: function d() {
+				var o, t = this.e, s = 0;
+				function next() {
+					for (; o = n.pop();) try {
+						if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+						if (o.d) {
+							var r$1 = o.d.call(o.v);
+							if (o.a) return s |= 2, Promise.resolve(r$1).then(next, err);
+						} else s |= 1;
+					} catch (r$2) {
+						return err(r$2);
+					}
+					if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+					if (t !== e) throw t;
+				}
+				function err(n$1) {
+					return t = t !== e ? new r(n$1, t) : n$1, next();
+				}
+				return next();
+			}
+		};
+	}
+	module.exports = _usingCtx, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+var import_usingCtx = __toESM(require_usingCtx(), 1);
+/**
+* Fetches and caches model pricing information from LiteLLM
+* Implements Disposable pattern for automatic resource cleanup
+*/
+var PricingFetcher = class {
+	cachedPricing = null;
+	offline;
+	/**
+	* Creates a new PricingFetcher instance
+	* @param offline - Whether to use pre-fetched pricing data instead of fetching from API
+	*/
+	constructor(offline = false) {
+		this.offline = offline;
+	}
+	/**
+	* Implements Disposable interface for automatic cleanup
+	*/
+	[Symbol.dispose]() {
+		this.clearCache();
+	}
+	/**
+	* Clears the cached pricing data
+	*/
+	clearCache() {
+		this.cachedPricing = null;
+	}
+	/**
+	* Ensures pricing data is loaded, either from cache or by fetching
+	* @returns Map of model names to pricing information
+	*/
+	async ensurePricingLoaded() {
+		if (this.cachedPricing != null) return this.cachedPricing;
+		if (this.offline) {
+			const pricing = new Map(Object.entries({
+				"claude-instant-1": {
+					"input_cost_per_token": 163e-8,
+					"output_cost_per_token": 551e-8
+				},
+				"claude-instant-1.2": {
+					"input_cost_per_token": 163e-9,
+					"output_cost_per_token": 551e-9
+				},
+				"claude-2": {
+					"input_cost_per_token": 8e-6,
+					"output_cost_per_token": 24e-6
+				},
+				"claude-2.1": {
+					"input_cost_per_token": 8e-6,
+					"output_cost_per_token": 24e-6
+				},
+				"claude-3-haiku-20240307": {
+					"input_cost_per_token": 25e-8,
+					"output_cost_per_token": 125e-8,
+					"cache_creation_input_token_cost": 3e-7,
+					"cache_read_input_token_cost": 3e-8
+				},
+				"claude-3-5-haiku-20241022": {
+					"input_cost_per_token": 8e-7,
+					"output_cost_per_token": 4e-6,
+					"cache_creation_input_token_cost": 1e-6,
+					"cache_read_input_token_cost": 8e-8
+				},
+				"claude-3-5-haiku-latest": {
+					"input_cost_per_token": 1e-6,
+					"output_cost_per_token": 5e-6,
+					"cache_creation_input_token_cost": 125e-8,
+					"cache_read_input_token_cost": 1e-7
+				},
+				"claude-3-opus-latest": {
+					"input_cost_per_token": 15e-6,
+					"output_cost_per_token": 75e-6,
+					"cache_creation_input_token_cost": 1875e-8,
+					"cache_read_input_token_cost": 15e-7
+				},
+				"claude-3-opus-20240229": {
+					"input_cost_per_token": 15e-6,
+					"output_cost_per_token": 75e-6,
+					"cache_creation_input_token_cost": 1875e-8,
+					"cache_read_input_token_cost": 15e-7
+				},
+				"claude-3-sonnet-20240229": {
+					"input_cost_per_token": 3e-6,
+					"output_cost_per_token": 15e-6
+				},
+				"claude-3-5-sonnet-latest": {
+					"input_cost_per_token": 3e-6,
+					"output_cost_per_token": 15e-6,
+					"cache_creation_input_token_cost": 375e-8,
+					"cache_read_input_token_cost": 3e-7
+				},
+				"claude-3-5-sonnet-20240620": {
+					"input_cost_per_token": 3e-6,
+					"output_cost_per_token": 15e-6,
+					"cache_creation_input_token_cost": 375e-8,
+					"cache_read_input_token_cost": 3e-7
+				},
+				"claude-opus-4-20250514": {
+					"input_cost_per_token": 15e-6,
+					"output_cost_per_token": 75e-6,
+					"cache_creation_input_token_cost": 1875e-8,
+					"cache_read_input_token_cost": 15e-7
+				},
+				"claude-sonnet-4-20250514": {
+					"input_cost_per_token": 3e-6,
+					"output_cost_per_token": 15e-6,
+					"cache_creation_input_token_cost": 375e-8,
+					"cache_read_input_token_cost": 3e-7
+				},
+				"claude-4-opus-20250514": {
+					"input_cost_per_token": 15e-6,
+					"output_cost_per_token": 75e-6,
+					"cache_creation_input_token_cost": 1875e-8,
+					"cache_read_input_token_cost": 15e-7
+				},
+				"claude-4-sonnet-20250514": {
+					"input_cost_per_token": 3e-6,
+					"output_cost_per_token": 15e-6,
+					"cache_creation_input_token_cost": 375e-8,
+					"cache_read_input_token_cost": 3e-7
+				},
+				"claude-3-7-sonnet-latest": {
+					"input_cost_per_token": 3e-6,
+					"output_cost_per_token": 15e-6,
+					"cache_creation_input_token_cost": 375e-8,
+					"cache_read_input_token_cost": 3e-7
+				},
+				"claude-3-7-sonnet-20250219": {
+					"input_cost_per_token": 3e-6,
+					"output_cost_per_token": 15e-6,
+					"cache_creation_input_token_cost": 375e-8,
+					"cache_read_input_token_cost": 3e-7
+				},
+				"claude-3-5-sonnet-20241022": {
+					"input_cost_per_token": 3e-6,
+					"output_cost_per_token": 15e-6,
+					"cache_creation_input_token_cost": 375e-8,
+					"cache_read_input_token_cost": 3e-7
+				}
+			}));
+			this.cachedPricing = pricing;
+			return pricing;
+		}
+		try {
+			logger.warn("Fetching latest model pricing from LiteLLM...");
+			const response = await fetch(LITELLM_PRICING_URL);
+			if (!response.ok) throw new Error(`Failed to fetch pricing data: ${response.statusText}`);
+			const data = await response.json();
+			const pricing = /* @__PURE__ */ new Map();
+			for (const [modelName, modelData] of Object.entries(data)) if (typeof modelData === "object" && modelData !== null) {
+				const parsed = modelPricingSchema.safeParse(modelData);
+				if (parsed.success) pricing.set(modelName, parsed.data);
+			}
+			this.cachedPricing = pricing;
+			logger.info(`Loaded pricing for ${pricing.size} models`);
+			return pricing;
+		} catch (error) {
+			logger.error("Failed to fetch model pricing:", error);
+			throw new Error("Could not fetch model pricing data");
+		}
+	}
+	/**
+	* Fetches all available model pricing data
+	* @returns Map of model names to pricing information
+	*/
+	async fetchModelPricing() {
+		return this.ensurePricingLoaded();
+	}
+	/**
+	* Gets pricing information for a specific model with fallback matching
+	* Tries exact match first, then provider prefixes, then partial matches
+	* @param modelName - Name of the model to get pricing for
+	* @returns Model pricing information or null if not found
+	*/
+	async getModelPricing(modelName) {
+		const pricing = await this.ensurePricingLoaded();
+		const directMatch = pricing.get(modelName);
+		if (directMatch != null) return directMatch;
+		const variations = [
+			modelName,
+			`anthropic/${modelName}`,
+			`claude-3-5-${modelName}`,
+			`claude-3-${modelName}`,
+			`claude-${modelName}`
+		];
+		for (const variant of variations) {
+			const match = pricing.get(variant);
+			if (match != null) return match;
+		}
+		const lowerModel = modelName.toLowerCase();
+		for (const [key, value] of pricing) if (key.toLowerCase().includes(lowerModel) || lowerModel.includes(key.toLowerCase())) return value;
+		return null;
+	}
+	/**
+	* Calculates the cost for given token usage and model
+	* @param tokens - Token usage breakdown
+	* @param tokens.input_tokens - Number of input tokens
+	* @param tokens.output_tokens - Number of output tokens
+	* @param tokens.cache_creation_input_tokens - Number of cache creation tokens
+	* @param tokens.cache_read_input_tokens - Number of cache read tokens
+	* @param modelName - Name of the model used
+	* @returns Total cost in USD
+	*/
+	async calculateCostFromTokens(tokens, modelName) {
+		const pricing = await this.getModelPricing(modelName);
+		if (pricing == null) return 0;
+		return this.calculateCostFromPricing(tokens, pricing);
+	}
+	/**
+	* Calculates cost from token usage and pricing information
+	* @param tokens - Token usage breakdown
+	* @param tokens.input_tokens - Number of input tokens
+	* @param tokens.output_tokens - Number of output tokens
+	* @param tokens.cache_creation_input_tokens - Number of cache creation tokens
+	* @param tokens.cache_read_input_tokens - Number of cache read tokens
+	* @param pricing - Model pricing rates
+	* @returns Total cost in USD
+	*/
+	calculateCostFromPricing(tokens, pricing) {
+		let cost = 0;
+		if (pricing.input_cost_per_token != null) cost += tokens.input_tokens * pricing.input_cost_per_token;
+		if (pricing.output_cost_per_token != null) cost += tokens.output_tokens * pricing.output_cost_per_token;
+		if (tokens.cache_creation_input_tokens != null && pricing.cache_creation_input_token_cost != null) cost += tokens.cache_creation_input_tokens * pricing.cache_creation_input_token_cost;
+		if (tokens.cache_read_input_tokens != null && pricing.cache_read_input_token_cost != null) cost += tokens.cache_read_input_tokens * pricing.cache_read_input_token_cost;
+		return cost;
+	}
+};
+export { CostModes, PricingFetcher, SortOrders, ZodFirstPartyTypeKind, ZodOptional, ZodType, __commonJSMin, __require, __toESM, arrayType, booleanType, dateSchema, discriminatedUnionType, enumType, literalType, numberType, objectType, optionalType, recordType, require_usingCtx, stringType, unionType, unknownType };

package/dist/pricing-fetcher-BkOpRIdx.d.ts

@@ -0,0 +1,188 @@
+import { z } from "zod";
+
+//#region node_modules/type-fest/source/observable-like.d.ts
+declare global {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+
+/**
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guidance on making an `Observable` to not include `closed` property.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
+
+@category Observable
+*/
+
+//#endregion
+//#region node_modules/type-fest/source/tuple-to-union.d.ts
+/**
+Convert a tuple/array into a union type of its elements.
+
+This can be useful when you have a fixed set of allowed values and want a type defining only the allowed values, but do not want to repeat yourself.
+
+@example
+```
+import type {TupleToUnion} from 'type-fest';
+
+const destinations = ['a', 'b', 'c'] as const;
+
+type Destination = TupleToUnion<typeof destinations>;
+//=> 'a' | 'b' | 'c'
+
+function verifyDestination(destination: unknown): destination is Destination {
+	return destinations.includes(destination as any);
+}
+
+type RequestBody = {
+	deliverTo: Destination;
+};
+
+function verifyRequestBody(body: unknown): body is RequestBody {
+	const deliverTo = (body as any).deliverTo;
+	return typeof body === 'object' && body !== null && verifyDestination(deliverTo);
+}
+```
+
+Alternatively, you may use `typeof destinations[number]`. If `destinations` is a tuple, there is no difference. However if `destinations` is a string, the resulting type will the union of the characters in the string. Other types of `destinations` may result in a compile error. In comparison, TupleToUnion will return `never` if a tuple is not provided.
+
+@example
+```
+const destinations = ['a', 'b', 'c'] as const;
+
+type Destination = typeof destinations[number];
+//=> 'a' | 'b' | 'c'
+
+const erroringType = new Set(['a', 'b', 'c']);
+
+type ErroringType = typeof erroringType[number];
+//=> Type 'Set<string>' has no matching index signature for type 'number'. ts(2537)
+
+const numberBool: { [n: number]: boolean } = { 1: true };
+
+type NumberBool = typeof numberBool[number];
+//=> boolean
+```
+
+@category Array
+*/
+type TupleToUnion<ArrayType> = ArrayType extends readonly unknown[] ? ArrayType[number] : never;
+//#endregion
+//#region src/types.internal.d.ts
+/**
+ * Available cost calculation modes
+ * - auto: Use pre-calculated costs when available, otherwise calculate from tokens
+ * - calculate: Always calculate costs from token counts using model pricing
+ * - display: Always use pre-calculated costs, show 0 for missing costs
+ */
+declare const CostModes: readonly ["auto", "calculate", "display"];
+/**
+ * Union type for cost calculation modes
+ */
+type CostMode = TupleToUnion<typeof CostModes>;
+/**
+ * Available sort orders for data presentation
+ */
+declare const SortOrders: readonly ["desc", "asc"];
+/**
+ * Union type for sort order options
+ */
+type SortOrder = TupleToUnion<typeof SortOrders>;
+/**
+ * Zod schema for model pricing information from LiteLLM
+ */
+declare const modelPricingSchema: z.ZodObject<{
+  input_cost_per_token: z.ZodOptional<z.ZodNumber>;
+  output_cost_per_token: z.ZodOptional<z.ZodNumber>;
+  cache_creation_input_token_cost: z.ZodOptional<z.ZodNumber>;
+  cache_read_input_token_cost: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+  input_cost_per_token?: number | undefined;
+  output_cost_per_token?: number | undefined;
+  cache_creation_input_token_cost?: number | undefined;
+  cache_read_input_token_cost?: number | undefined;
+}, {
+  input_cost_per_token?: number | undefined;
+  output_cost_per_token?: number | undefined;
+  cache_creation_input_token_cost?: number | undefined;
+  cache_read_input_token_cost?: number | undefined;
+}>;
+/**
+ * Type definition for model pricing information
+ */
+type ModelPricing = z.infer<typeof modelPricingSchema>;
+//#endregion
+//#region src/pricing-fetcher.d.ts
+/**
+ * Fetches and caches model pricing information from LiteLLM
+ * Implements Disposable pattern for automatic resource cleanup
+ */
+declare class PricingFetcher implements Disposable {
+  private cachedPricing;
+  private readonly offline;
+  /**
+   * Creates a new PricingFetcher instance
+   * @param offline - Whether to use pre-fetched pricing data instead of fetching from API
+   */
+  constructor(offline?: boolean);
+  /**
+   * Implements Disposable interface for automatic cleanup
+   */
+  [Symbol.dispose](): void;
+  /**
+   * Clears the cached pricing data
+   */
+  clearCache(): void;
+  private ensurePricingLoaded;
+  /**
+   * Fetches all available model pricing data
+   * @returns Map of model names to pricing information
+   */
+  fetchModelPricing(): Promise<Map<string, ModelPricing>>;
+  /**
+   * Gets pricing information for a specific model with fallback matching
+   * Tries exact match first, then provider prefixes, then partial matches
+   * @param modelName - Name of the model to get pricing for
+   * @returns Model pricing information or null if not found
+   */
+  getModelPricing(modelName: string): Promise<ModelPricing | null>;
+  /**
+   * Calculates the cost for given token usage and model
+   * @param tokens - Token usage breakdown
+   * @param tokens.input_tokens - Number of input tokens
+   * @param tokens.output_tokens - Number of output tokens
+   * @param tokens.cache_creation_input_tokens - Number of cache creation tokens
+   * @param tokens.cache_read_input_tokens - Number of cache read tokens
+   * @param modelName - Name of the model used
+   * @returns Total cost in USD
+   */
+  calculateCostFromTokens(tokens: {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+  }, modelName: string): Promise<number>;
+  /**
+   * Calculates cost from token usage and pricing information
+   * @param tokens - Token usage breakdown
+   * @param tokens.input_tokens - Number of input tokens
+   * @param tokens.output_tokens - Number of output tokens
+   * @param tokens.cache_creation_input_tokens - Number of cache creation tokens
+   * @param tokens.cache_read_input_tokens - Number of cache read tokens
+   * @param pricing - Model pricing rates
+   * @returns Total cost in USD
+   */
+  calculateCostFromPricing(tokens: {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+  }, pricing: ModelPricing): number;
+}
+//#endregion
+export { CostMode, PricingFetcher, SortOrder };

package/dist/pricing-fetcher.d.ts

@@ -1,2 +1,2 @@
-import { PricingFetcher } from "./pricing-fetcher-DHaTs-k2.js";
+import { PricingFetcher } from "./pricing-fetcher-BkOpRIdx.js";
 export { PricingFetcher };

package/dist/pricing-fetcher.js

@@ -1,5 +1,3 @@
-import { PricingFetcher } from "./pricing-fetcher-BtW4MVG7.js";
-import "./dist-DCvt9hEv.js";
-import "./logger-E_Utl_fr.js";
-
-export { PricingFetcher };
+import { PricingFetcher } from "./pricing-fetcher-3m6_Ejp8.js";
+import "./logger-CTFDCX5W.js";
+export { PricingFetcher };

package/dist/{prompt-CUbwSrjo.js → prompt-E8j7mEMw.js}

@@ -1,8 +1,6 @@
 import process$1, { stdin, stdout } from "node:process";
 import { WriteStream } from "node:tty";
 import f from "node:readline";
-
-//#region node_modules/consola/dist/chunks/prompt.mjs
 function getDefaultExportFromCjs(x$1) {
 	return x$1 && x$1.__esModule && Object.prototype.hasOwnProperty.call(x$1, "default") ? x$1["default"] : x$1;
 }
@@ -847,6 +845,4 @@ async function prompt(message, opts = {}) {
 	}).then(handleCancel);
 	throw new Error(`Unknown prompt type: ${opts.type}`);
 }
-
-//#endregion
-export { prompt };
+export { prompt };