ccusage 15.1.0 → 15.3.0

package/dist/{logger-Cke8hliP.js → logger-DeTONwj8.js}

@@ -915,7 +915,7 @@ ${indent}`);
 		line = space > 0 && (opts.columns || 0) >= 80 ? left + " ".repeat(space) + right : (right ? `${colors.gray(`[${right}]`)} ` : "") + left;
 		line += characterFormat(additional.length > 0 ? "\n" + additional.join("\n") : "");
 		if (logObj.type === "trace") {
-			const _err = new Error("Trace: " + logObj.message);
+			const _err = /* @__PURE__ */ new Error("Trace: " + logObj.message);
 			line += this.formatStack(_err.stack || "", _err.message);
 		}
 		return isBadge ? "\n" + line + "\n" : line;
@@ -938,7 +938,7 @@ function createConsola$1(options = {}) {
 		defaults: { level },
 		stdout: process.stdout,
 		stderr: process.stderr,
-		prompt: (...args) => import("./prompt-j5YimnLx.js").then((m) => m.prompt(...args)),
+		prompt: (...args) => import("./prompt-DsUFNEY7.js").then((m) => m.prompt(...args)),
 		reporters: options.reporters || [options.fancy ?? !(T || R) ? new FancyReporter() : new BasicReporter()],
 		...options
 	});
@@ -951,7 +951,7 @@ function _getDefaultLogLevel() {
 }
 const consola = createConsola$1();
 var name = "ccusage";
-var version = "15.1.0";
+var version = "15.3.0";
 var description = "Usage analysis tool for Claude Code";
 /**
 * Application logger instance with package name tag

package/dist/logger.d.ts

@@ -10,6 +10,9 @@ declare const logger: ConsolaInstance;
  * Direct console.log function for cases where logger formatting is not desired
  */
 // eslint-disable-next-line no-console
-declare const log: (message?: any, ...optionalParams: any[]) => void;
+declare const log: {
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+};
 //#endregion
 export { log, logger };

package/dist/logger.js

@@ -1,2 +1,2 @@
-import { log, logger } from "./logger-Cke8hliP.js";
+import { log, logger } from "./logger-DeTONwj8.js";
 export { log, logger };

package/dist/{mcp-DKqp_F9c.js → mcp-Kff7A2dF.js}

@@ -1,7 +1,9 @@
-import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-Dm8hcn_h.js";
-import { ZodFirstPartyTypeKind, ZodOptional, ZodType, arrayType, booleanType, dateSchema, discriminatedUnionType, enumType, literalType, numberType, objectType, optionalType, recordType, stringType, unionType, unknownType } from "./_types-Cr2YEzKm.js";
-import { getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-BeaFK_sH.js";
-import { name, version } from "./logger-Cke8hliP.js";
+import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-DaK2jizg.js";
+import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
+import { ZodFirstPartyTypeKind, ZodOptional, ZodType, arrayType, booleanType, discriminatedUnionType, enumType, filterDateSchema, literalType, numberType, objectType, optionalType, recordType, stringType, unionType, unknownType } from "./_types-BHFM59hI.js";
+import { calculateTotals, createTotalsObject } from "./calculate-cost-BDqO4yWA.js";
+import { getClaudePaths, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-R9pMvoQp.js";
+import { name, version } from "./logger-DeTONwj8.js";
 import process from "node:process";
 const LATEST_PROTOCOL_VERSION = "2025-06-18";
 const SUPPORTED_PROTOCOL_VERSIONS = [
@@ -1322,7 +1324,7 @@ var StreamableHTTPTransport = class {
 							data: JSON.stringify(message)
 						});
 					} catch {
-						this.onerror?.(new Error("Failed replay events"));
+						this.onerror?.(/* @__PURE__ */ new Error("Failed replay events"));
 						throw new HTTPException(500, { message: "Failed replay events" });
 					}
 				} });
@@ -1650,18 +1652,25 @@ var Protocol = class {
 	* The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
 	*/
 	async connect(transport) {
+		var _a, _b, _c;
 		this._transport = transport;
+		const _onclose = (_a = this.transport) === null || _a === void 0 ? void 0 : _a.onclose;
 		this._transport.onclose = () => {
+			_onclose === null || _onclose === void 0 || _onclose();
 			this._onclose();
 		};
+		const _onerror = (_b = this.transport) === null || _b === void 0 ? void 0 : _b.onerror;
 		this._transport.onerror = (error) => {
+			_onerror === null || _onerror === void 0 || _onerror(error);
 			this._onerror(error);
 		};
+		const _onmessage = (_c = this._transport) === null || _c === void 0 ? void 0 : _c.onmessage;
 		this._transport.onmessage = (message, extra) => {
+			_onmessage === null || _onmessage === void 0 || _onmessage(message, extra);
 			if (isJSONRPCResponse(message) || isJSONRPCError(message)) this._onresponse(message);
 			else if (isJSONRPCRequest(message)) this._onrequest(message, extra);
 			else if (isJSONRPCNotification(message)) this._onnotification(message);
-			else this._onerror(new Error(`Unknown message type: ${JSON.stringify(message)}`));
+			else this._onerror(/* @__PURE__ */ new Error(`Unknown message type: ${JSON.stringify(message)}`));
 		};
 		await this._transport.start();
 	}
@@ -1683,7 +1692,7 @@ var Protocol = class {
 		var _a;
 		const handler = (_a = this._notificationHandlers.get(notification.method)) !== null && _a !== void 0 ? _a : this.fallbackNotificationHandler;
 		if (handler === void 0) return;
-		Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(new Error(`Uncaught error in notification handler: ${error}`)));
+		Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Uncaught error in notification handler: ${error}`)));
 	}
 	_onrequest(request, extra) {
 		var _a, _b, _c, _d;
@@ -1696,7 +1705,7 @@ var Protocol = class {
 					code: ErrorCode.MethodNotFound,
 					message: "Method not found"
 				}
-			}).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
+			}).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send an error response: ${error}`)));
 			return;
 		}
 		const abortController = new AbortController();
@@ -1711,7 +1720,8 @@ var Protocol = class {
 				relatedRequestId: request.id
 			}),
 			authInfo: extra === null || extra === void 0 ? void 0 : extra.authInfo,
-			requestId: request.id
+			requestId: request.id,
+			requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo
 		};
 		Promise.resolve().then(() => handler(request, fullExtra)).then((result) => {
 			var _a$1;
@@ -1732,7 +1742,7 @@ var Protocol = class {
 					message: (_b$1 = error.message) !== null && _b$1 !== void 0 ? _b$1 : "Internal error"
 				}
 			});
-		}).catch((error) => this._onerror(new Error(`Failed to send response: ${error}`))).finally(() => {
+		}).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send response: ${error}`))).finally(() => {
 			this._requestHandlerAbortControllers.delete(request.id);
 		});
 	}
@@ -1741,7 +1751,7 @@ var Protocol = class {
 		const messageId = Number(progressToken);
 		const handler = this._progressHandlers.get(messageId);
 		if (!handler) {
-			this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
+			this._onerror(/* @__PURE__ */ new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
 			return;
 		}
 		const responseHandler = this._responseHandlers.get(messageId);
@@ -1758,7 +1768,7 @@ var Protocol = class {
 		const messageId = Number(response.id);
 		const handler = this._responseHandlers.get(messageId);
 		if (handler === void 0) {
-			this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
+			this._onerror(/* @__PURE__ */ new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
 			return;
 		}
 		this._responseHandlers.delete(messageId);
@@ -1790,7 +1800,7 @@ var Protocol = class {
 		return new Promise((resolve$4, reject) => {
 			var _a, _b, _c, _d, _e, _f;
 			if (!this._transport) {
-				reject(new Error("Not connected"));
+				reject(/* @__PURE__ */ new Error("Not connected"));
 				return;
 			}
 			if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.enforceStrictCapabilities) === true) this.assertCapabilityForMethod(request.method);
@@ -1827,7 +1837,7 @@ var Protocol = class {
 					relatedRequestId,
 					resumptionToken,
 					onresumptiontoken
-				}).catch((error) => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
+				}).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error}`)));
 				reject(reason);
 			};
 			this._responseHandlers.set(messageId, (response) => {
@@ -1976,8 +1986,8 @@ var require_uri_all = __commonJSMin((exports, module) => {
 				UNRESERVED: new RegExp(UNRESERVED$$$1, "g"),
 				OTHER_CHARS: new RegExp(merge("[^\\%]", UNRESERVED$$$1, RESERVED$$), "g"),
 				PCT_ENCODED: new RegExp(PCT_ENCODED$$1, "g"),
-				IPV4ADDRESS: new RegExp("^(" + IPV4ADDRESS$ + ")$"),
-				IPV6ADDRESS: new RegExp("^\\[?(" + IPV6ADDRESS$ + ")" + subexp(subexp("\\%25|\\%(?!" + HEXDIG$$$1 + "{2})") + "(" + ZONEID$ + ")") + "?\\]?$")
+				IPV4ADDRESS: /* @__PURE__ */ new RegExp("^(" + IPV4ADDRESS$ + ")$"),
+				IPV6ADDRESS: /* @__PURE__ */ new RegExp("^\\[?(" + IPV6ADDRESS$ + ")" + subexp(subexp("\\%25|\\%(?!" + HEXDIG$$$1 + "{2})") + "(" + ZONEID$ + ")") + "?\\]?$")
 			};
 		}
 		var URI_PROTOCOL = buildExps(false);
@@ -7663,7 +7673,7 @@ function parseStringDef(def, refs) {
 function escapeLiteralCheckValue(literal, refs) {
 	return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
 }
-const ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+const ALPHA_NUMERIC = /* @__PURE__ */ new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
 function escapeNonAlphaNumeric(source) {
 	let result = "";
 	for (let i = 0; i < source.length; i++) {
@@ -8411,7 +8421,7 @@ var McpServer = class {
 					};
 				}
 			}
-			if (tool.outputSchema) {
+			if (tool.outputSchema && !result.isError) {
 				if (!result.structuredContent) throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} has an output schema but no structured content was provided`);
 				const parseResult = await tool.outputSchema.safeParseAsync(result.structuredContent);
 				if (!parseResult.success) throw new McpError(ErrorCode.InvalidParams, `Invalid structured content for tool ${request.params.name}: ${parseResult.error.message}`);
@@ -9121,7 +9131,7 @@ var PatternRouter = class {
 		});
 		try {
 			this.#routes.push([
-				new RegExp(`^${parts.join("")}${endsWithWildcard ? "" : "/?$"}`),
+				/* @__PURE__ */ new RegExp(`^${parts.join("")}${endsWithWildcard ? "" : "/?$"}`),
 				method,
 				handler
 			]);
@@ -9148,8 +9158,120 @@ var Hono = class extends Hono$1 {
 	}
 };
 var import_usingCtx = __toESM(require_usingCtx(), 1);
+const modelBreakdownSchema = objectType({
+	modelName: stringType(),
+	inputTokens: numberType(),
+	outputTokens: numberType(),
+	cacheCreationTokens: numberType().optional(),
+	cacheReadTokens: numberType().optional(),
+	cost: numberType()
+});
+const dailyUsageSchema = objectType({
+	date: stringType(),
+	inputTokens: numberType(),
+	outputTokens: numberType(),
+	cacheCreationTokens: numberType().optional(),
+	cacheReadTokens: numberType().optional(),
+	totalTokens: numberType(),
+	totalCost: numberType(),
+	modelsUsed: arrayType(stringType()),
+	modelBreakdowns: arrayType(modelBreakdownSchema)
+});
+const sessionUsageSchema = objectType({
+	sessionId: stringType(),
+	inputTokens: numberType(),
+	outputTokens: numberType(),
+	cacheCreationTokens: numberType().optional(),
+	cacheReadTokens: numberType().optional(),
+	totalTokens: numberType(),
+	totalCost: numberType(),
+	lastActivity: stringType(),
+	modelsUsed: arrayType(stringType()),
+	modelBreakdowns: arrayType(modelBreakdownSchema)
+});
+const monthlyUsageSchema = objectType({
+	month: stringType(),
+	inputTokens: numberType(),
+	outputTokens: numberType(),
+	cacheCreationTokens: numberType().optional(),
+	cacheReadTokens: numberType().optional(),
+	totalTokens: numberType(),
+	totalCost: numberType(),
+	modelsUsed: arrayType(stringType()),
+	modelBreakdowns: arrayType(modelBreakdownSchema)
+});
+const blockUsageSchema = objectType({
+	id: stringType(),
+	startTime: stringType(),
+	endTime: stringType().optional(),
+	actualEndTime: stringType().optional(),
+	isActive: booleanType(),
+	isGap: booleanType(),
+	entries: numberType(),
+	tokenCounts: objectType({
+		inputTokens: numberType(),
+		outputTokens: numberType(),
+		cacheCreationInputTokens: numberType(),
+		cacheReadInputTokens: numberType()
+	}),
+	totalTokens: numberType(),
+	costUSD: numberType(),
+	models: arrayType(stringType()),
+	burnRate: numberType().nullable(),
+	projection: unknownType().nullable()
+});
+const dailyResponseSchema = {
+	daily: arrayType(dailyUsageSchema),
+	totals: objectType({
+		totalInputTokens: numberType().optional(),
+		totalOutputTokens: numberType().optional(),
+		totalCacheCreationTokens: numberType().optional(),
+		totalCacheReadTokens: numberType().optional(),
+		totalTokens: numberType().optional(),
+		totalCost: numberType().optional(),
+		modelsUsed: arrayType(stringType()).optional()
+	})
+};
+const sessionResponseSchema = {
+	sessions: arrayType(sessionUsageSchema),
+	totals: objectType({
+		totalInputTokens: numberType().optional(),
+		totalOutputTokens: numberType().optional(),
+		totalCacheCreationTokens: numberType().optional(),
+		totalCacheReadTokens: numberType().optional(),
+		totalTokens: numberType().optional(),
+		totalCost: numberType().optional(),
+		modelsUsed: arrayType(stringType()).optional()
+	})
+};
+const monthlyResponseSchema = {
+	monthly: arrayType(monthlyUsageSchema),
+	totals: objectType({
+		totalInputTokens: numberType().optional(),
+		totalOutputTokens: numberType().optional(),
+		totalCacheCreationTokens: numberType().optional(),
+		totalCacheReadTokens: numberType().optional(),
+		totalTokens: numberType().optional(),
+		totalCost: numberType().optional(),
+		modelsUsed: arrayType(stringType()).optional()
+	})
+};
+const blocksResponseSchema = { blocks: arrayType(blockUsageSchema) };
+/**
+* Helper function to transform usage data with totals into JSON output format
+*/
+function transformUsageDataWithTotals(data, totals, mapper, key) {
+	return {
+		[key]: data.map(mapper),
+		totals: createTotalsObject(totals)
+	};
+}
 /** Default options for the MCP server */
-const defaultOptions = { claudePath: getDefaultClaudePath() };
+const defaultOptions = { claudePath: (() => {
+	const paths = getClaudePaths();
+	if (paths.length === 0) throw new Error("No valid Claude path found. Ensure getClaudePaths() returns at least one valid path.");
+	return paths[0];
+})() };
 /**
 * Creates an MCP server with tools for showing usage reports.
 * Registers tools for daily, session, monthly, and blocks usage data.
@@ -9164,8 +9286,8 @@ function createMcpServer({ claudePath } = defaultOptions) {
 		version
 	});
 	const parametersZodSchema = {
-		since: dateSchema.optional(),
-		until: dateSchema.optional(),
+		since: filterDateSchema.optional(),
+		until: filterDateSchema.optional(),
 		mode: enumType([
 			"auto",
 			"calculate",
@@ -9174,55 +9296,125 @@ function createMcpServer({ claudePath } = defaultOptions) {
 	};
 	server.registerTool("daily", {
 		description: "Show usage report grouped by date",
-		inputSchema: parametersZodSchema
+		inputSchema: parametersZodSchema,
+		outputSchema: dailyResponseSchema
 	}, async (args) => {
 		const dailyData = await loadDailyUsageData({
 			...args,
 			claudePath
 		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(dailyData, null, 2)
-		}] };
+		const totals = calculateTotals(dailyData);
+		const jsonOutput = transformUsageDataWithTotals(dailyData, totals, (data) => ({
+			date: data.date,
+			inputTokens: data.inputTokens,
+			outputTokens: data.outputTokens,
+			cacheCreationTokens: data.cacheCreationTokens,
+			cacheReadTokens: data.cacheReadTokens,
+			totalTokens: getTotalTokens(data),
+			totalCost: data.totalCost,
+			modelsUsed: data.modelsUsed,
+			modelBreakdowns: data.modelBreakdowns
+		}), "daily");
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(jsonOutput, null, 2)
+			}],
+			structuredContent: jsonOutput
+		};
 	});
 	server.registerTool("session", {
 		description: "Show usage report grouped by conversation session",
-		inputSchema: parametersZodSchema
+		inputSchema: parametersZodSchema,
+		outputSchema: sessionResponseSchema
 	}, async (args) => {
 		const sessionData = await loadSessionData({
 			...args,
 			claudePath
 		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(sessionData, null, 2)
-		}] };
+		const totals = calculateTotals(sessionData);
+		const jsonOutput = transformUsageDataWithTotals(sessionData, totals, (data) => ({
+			sessionId: data.sessionId,
+			inputTokens: data.inputTokens,
+			outputTokens: data.outputTokens,
+			cacheCreationTokens: data.cacheCreationTokens,
+			cacheReadTokens: data.cacheReadTokens,
+			totalTokens: getTotalTokens(data),
+			totalCost: data.totalCost,
+			lastActivity: data.lastActivity,
+			modelsUsed: data.modelsUsed,
+			modelBreakdowns: data.modelBreakdowns
+		}), "sessions");
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(jsonOutput, null, 2)
+			}],
+			structuredContent: jsonOutput
+		};
 	});
 	server.registerTool("monthly", {
 		description: "Show usage report grouped by month",
-		inputSchema: parametersZodSchema
+		inputSchema: parametersZodSchema,
+		outputSchema: monthlyResponseSchema
 	}, async (args) => {
 		const monthlyData = await loadMonthlyUsageData({
 			...args,
 			claudePath
 		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(monthlyData, null, 2)
-		}] };
+		const totals = calculateTotals(monthlyData);
+		const jsonOutput = transformUsageDataWithTotals(monthlyData, totals, (data) => ({
+			month: data.month,
+			inputTokens: data.inputTokens,
+			outputTokens: data.outputTokens,
+			cacheCreationTokens: data.cacheCreationTokens,
+			cacheReadTokens: data.cacheReadTokens,
+			totalTokens: getTotalTokens(data),
+			totalCost: data.totalCost,
+			modelsUsed: data.modelsUsed,
+			modelBreakdowns: data.modelBreakdowns
+		}), "monthly");
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(jsonOutput, null, 2)
+			}],
+			structuredContent: jsonOutput
+		};
 	});
 	server.registerTool("blocks", {
 		description: "Show usage report grouped by session billing blocks",
-		inputSchema: parametersZodSchema
+		inputSchema: parametersZodSchema,
+		outputSchema: blocksResponseSchema
 	}, async (args) => {
-		const blocksData = await loadSessionBlockData({
+		const blocks = await loadSessionBlockData({
 			...args,
 			claudePath
 		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(blocksData, null, 2)
-		}] };
+		const jsonOutput = { blocks: blocks.map((block) => {
+			return {
+				id: block.id,
+				startTime: block.startTime.toISOString(),
+				endTime: block.endTime.toISOString(),
+				actualEndTime: block.actualEndTime?.toISOString() ?? null,
+				isActive: block.isActive,
+				isGap: block.isGap ?? false,
+				entries: block.entries.length,
+				tokenCounts: block.tokenCounts,
+				totalTokens: block.tokenCounts.inputTokens + block.tokenCounts.outputTokens,
+				costUSD: block.costUSD,
+				models: block.models,
+				burnRate: null,
+				projection: null
+			};
+		}) };
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(jsonOutput, null, 2)
+			}],
+			structuredContent: jsonOutput
+		};
 	});
 	return server;
 }

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
-import { LoadOptions } from "./data-loader-DZczD-9E.js";
-import "./pricing-fetcher-BZe7AafW.js";
+import { LoadOptions } from "./data-loader-a9CiVyT5.js";
+import "./pricing-fetcher-B3SvKOod.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Hono } from "hono/tiny";
 

package/dist/mcp.js

@@ -1,6 +1,8 @@
-import "./pricing-fetcher-Dm8hcn_h.js";
-import "./_types-Cr2YEzKm.js";
-import "./data-loader-BeaFK_sH.js";
-import "./logger-Cke8hliP.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-DKqp_F9c.js";
+import "./pricing-fetcher-DaK2jizg.js";
+import "./_token-utils-WjkbrjKv.js";
+import "./_types-BHFM59hI.js";
+import "./calculate-cost-BDqO4yWA.js";
+import "./data-loader-R9pMvoQp.js";
+import "./logger-DeTONwj8.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-Kff7A2dF.js";
 export { createMcpHttpApp, createMcpServer, startMcpServerStdio };

package/dist/{pricing-fetcher-BZe7AafW.d.ts → pricing-fetcher-B3SvKOod.d.ts}

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { Result } from "@praha/byethrow";
 
 //#region node_modules/type-fest/source/observable-like.d.ts
 declare global {
@@ -139,19 +140,25 @@ declare class PricingFetcher implements Disposable {
    * Clears the cached pricing data
    */
   clearCache(): void;
+  /**
+   * Loads offline pricing data from pre-fetched cache
+   * @returns Map of model names to pricing information
+   */
+  private loadOfflinePricing;
+  private handleFallbackToCachedPricing;
   private ensurePricingLoaded;
   /**
    * Fetches all available model pricing data
    * @returns Map of model names to pricing information
    */
-  fetchModelPricing(): Promise<Map<string, ModelPricing>>;
+  fetchModelPricing(): Result.ResultAsync<Map<string, ModelPricing>, Error>;
   /**
    * 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>;
+  getModelPricing(modelName: string): Result.ResultAsync<ModelPricing | null, Error>;
   /**
    * Calculates the cost for given token usage and model
    * @param tokens - Token usage breakdown
@@ -167,7 +174,7 @@ declare class PricingFetcher implements Disposable {
     output_tokens: number;
     cache_creation_input_tokens?: number;
     cache_read_input_tokens?: number;
-  }, modelName: string): Promise<number>;
+  }, modelName: string): Result.ResultAsync<number, Error>;
   /**
    * Calculates cost from token usage and pricing information
    * @param tokens - Token usage breakdown