compute-cfo 0.1.0

package/dist/budget.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Budget policy enforcement.
+ */
+import { BudgetWindow, CostEvent, OnExceed } from './types';
+export interface BudgetPolicyOptions {
+    maxCost: number;
+    window?: BudgetWindow;
+    onExceed?: OnExceed;
+    onExceedCallback?: (event: CostEvent, projected: number) => void;
+    tags?: Record<string, string>;
+}
+export declare class BudgetPolicy {
+    readonly maxCost: number;
+    readonly window: BudgetWindow;
+    readonly onExceed: OnExceed;
+    readonly onExceedCallback?: (event: CostEvent, projected: number) => void;
+    readonly tags?: Record<string, string>;
+    constructor(options: BudgetPolicyOptions);
+    private getWindowStart;
+    private matchesTags;
+    currentSpend(events: CostEvent[]): number;
+    check(events: CostEvent[], pendingEvent: CostEvent): void;
+}

package/dist/budget.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Budget policy enforcement.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BudgetPolicy = void 0;
+const types_1 = require("./types");
+class BudgetPolicy {
+    constructor(options) {
+        this.maxCost = options.maxCost;
+        this.window = options.window ?? 'total';
+        this.onExceed = options.onExceed ?? 'throw';
+        this.onExceedCallback = options.onExceedCallback;
+        this.tags = options.tags;
+    }
+    getWindowStart(now) {
+        if (this.window === 'total')
+            return null;
+        const d = new Date(now);
+        if (this.window === 'hourly') {
+            d.setMinutes(0, 0, 0);
+            return d;
+        }
+        if (this.window === 'daily') {
+            d.setHours(0, 0, 0, 0);
+            return d;
+        }
+        if (this.window === 'monthly') {
+            d.setDate(1);
+            d.setHours(0, 0, 0, 0);
+            return d;
+        }
+        return null;
+    }
+    matchesTags(event) {
+        if (!this.tags)
+            return true;
+        return Object.entries(this.tags).every(([k, v]) => event.tags[k] === v);
+    }
+    currentSpend(events) {
+        const now = new Date();
+        const windowStart = this.getWindowStart(now);
+        let total = 0;
+        for (const e of events) {
+            if (windowStart && new Date(e.timestamp) < windowStart)
+                continue;
+            if (!this.matchesTags(e))
+                continue;
+            if (e.costUsd !== null)
+                total += e.costUsd;
+        }
+        return total;
+    }
+    check(events, pendingEvent) {
+        if (!this.matchesTags(pendingEvent))
+            return;
+        const current = this.currentSpend(events);
+        const pendingCost = pendingEvent.costUsd ?? 0;
+        const projected = current + pendingCost;
+        if (projected <= this.maxCost)
+            return;
+        if (this.onExceed === 'throw') {
+            throw new types_1.BudgetExceededError(this.maxCost, projected, this.window);
+        }
+        else if (this.onExceed === 'warn') {
+            console.warn(`[compute-cfo] Budget warning: $${projected.toFixed(4)} / $${this.maxCost.toFixed(4)} (${this.window} window)`);
+        }
+        else if (this.onExceed === 'callback' && this.onExceedCallback) {
+            this.onExceedCallback(pendingEvent, projected);
+        }
+    }
+}
+exports.BudgetPolicy = BudgetPolicy;

package/dist/exporters.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Cost event exporters.
+ */
+import { CostEvent } from './types';
+export type Exporter = (event: CostEvent) => void;
+export declare function consoleExporter(event: CostEvent): void;
+export declare function jsonlExporter(path?: string): Exporter;
+export declare function webhookExporter(url: string): Exporter;
+export declare function getExporter(spec: string): Exporter;

package/dist/exporters.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Cost event exporters.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleExporter = consoleExporter;
+exports.jsonlExporter = jsonlExporter;
+exports.webhookExporter = webhookExporter;
+exports.getExporter = getExporter;
+const fs = __importStar(require("fs"));
+const types_1 = require("./types");
+function consoleExporter(event) {
+    const costStr = event.costUsd !== null ? `$${event.costUsd.toFixed(6)}` : '$?.??????';
+    const totalTokens = event.inputTokens + event.outputTokens;
+    const parts = [
+        `[compute-cfo]`,
+        event.model,
+        `${totalTokens} tokens`,
+        costStr,
+    ];
+    if (Object.keys(event.tags).length > 0) {
+        const tagStr = Object.entries(event.tags)
+            .map(([k, v]) => `${k}:${v}`)
+            .join(' ');
+        parts.push(tagStr);
+    }
+    console.error(parts.join(' | '));
+}
+function jsonlExporter(path = 'compute_cfo_events.jsonl') {
+    return (event) => {
+        fs.appendFileSync(path, JSON.stringify((0, types_1.costEventToDict)(event)) + '\n');
+    };
+}
+function webhookExporter(url) {
+    return (event) => {
+        const data = JSON.stringify((0, types_1.costEventToDict)(event));
+        fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: data,
+        }).catch(() => { }); // fire-and-forget
+    };
+}
+function getExporter(spec) {
+    if (spec === 'console')
+        return consoleExporter;
+    if (spec === 'jsonl')
+        return jsonlExporter();
+    if (spec.startsWith('jsonl:'))
+        return jsonlExporter(spec.slice(6));
+    if (spec.startsWith('webhook:'))
+        return webhookExporter(spec.slice(8));
+    throw new Error(`Unknown exporter: "${spec}". Use 'console', 'jsonl', 'jsonl:/path', or 'webhook:URL'.`);
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * compute-cfo: Cost tracking, attribution, and budget enforcement for AI inference APIs.
+ */
+export { getCost, getPrice, resolveModel } from './pricing';
+export { CostTracker } from './tracker';
+export type { CostTrackerOptions } from './tracker';
+export { BudgetPolicy } from './budget';
+export type { BudgetPolicyOptions } from './budget';
+export { BudgetExceededError, costEventToDict, } from './types';
+export type { CostEvent, BudgetWindow, OnExceed } from './types';
+export { wrap } from './wrapper';
+export type { WrapOptions } from './wrapper';
+export { consoleExporter, jsonlExporter, webhookExporter, } from './exporters';
+export type { Exporter } from './exporters';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * compute-cfo: Cost tracking, attribution, and budget enforcement for AI inference APIs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhookExporter = exports.jsonlExporter = exports.consoleExporter = exports.wrap = exports.costEventToDict = exports.BudgetExceededError = exports.BudgetPolicy = exports.CostTracker = exports.resolveModel = exports.getPrice = exports.getCost = void 0;
+var pricing_1 = require("./pricing");
+Object.defineProperty(exports, "getCost", { enumerable: true, get: function () { return pricing_1.getCost; } });
+Object.defineProperty(exports, "getPrice", { enumerable: true, get: function () { return pricing_1.getPrice; } });
+Object.defineProperty(exports, "resolveModel", { enumerable: true, get: function () { return pricing_1.resolveModel; } });
+var tracker_1 = require("./tracker");
+Object.defineProperty(exports, "CostTracker", { enumerable: true, get: function () { return tracker_1.CostTracker; } });
+var budget_1 = require("./budget");
+Object.defineProperty(exports, "BudgetPolicy", { enumerable: true, get: function () { return budget_1.BudgetPolicy; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "BudgetExceededError", { enumerable: true, get: function () { return types_1.BudgetExceededError; } });
+Object.defineProperty(exports, "costEventToDict", { enumerable: true, get: function () { return types_1.costEventToDict; } });
+var wrapper_1 = require("./wrapper");
+Object.defineProperty(exports, "wrap", { enumerable: true, get: function () { return wrapper_1.wrap; } });
+var exporters_1 = require("./exporters");
+Object.defineProperty(exports, "consoleExporter", { enumerable: true, get: function () { return exporters_1.consoleExporter; } });
+Object.defineProperty(exports, "jsonlExporter", { enumerable: true, get: function () { return exporters_1.jsonlExporter; } });
+Object.defineProperty(exports, "webhookExporter", { enumerable: true, get: function () { return exporters_1.webhookExporter; } });

package/dist/pricing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Model pricing database for OpenAI and Anthropic.
+ * Prices are in USD per 1 million tokens. Updated March 2026.
+ */
+export interface ModelPrice {
+    inputPerMillion: number;
+    outputPerMillion: number;
+}
+export declare function resolveModel(model: string): string;
+export declare function getPrice(model: string): ModelPrice | null;
+export declare function getCost(model: string, inputTokens: number, outputTokens: number): number | null;

package/dist/pricing.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Model pricing database for OpenAI and Anthropic.
+ * Prices are in USD per 1 million tokens. Updated March 2026.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveModel = resolveModel;
+exports.getPrice = getPrice;
+exports.getCost = getCost;
+const MODEL_PRICES = {
+    // ── OpenAI ──────────────────────────────────────────────
+    // GPT-4.1 family
+    'gpt-4.1': { inputPerMillion: 2.0, outputPerMillion: 8.0 },
+    'gpt-4.1-mini': { inputPerMillion: 0.4, outputPerMillion: 1.6 },
+    'gpt-4.1-nano': { inputPerMillion: 0.1, outputPerMillion: 0.4 },
+    // GPT-4o family
+    'gpt-4o': { inputPerMillion: 2.5, outputPerMillion: 10.0 },
+    'gpt-4o-mini': { inputPerMillion: 0.15, outputPerMillion: 0.6 },
+    'gpt-4o-audio-preview': { inputPerMillion: 2.5, outputPerMillion: 10.0 },
+    // GPT-4 legacy
+    'gpt-4-turbo': { inputPerMillion: 10.0, outputPerMillion: 30.0 },
+    'gpt-4': { inputPerMillion: 30.0, outputPerMillion: 60.0 },
+    // GPT-3.5
+    'gpt-3.5-turbo': { inputPerMillion: 0.5, outputPerMillion: 1.5 },
+    // o-series reasoning
+    'o3': { inputPerMillion: 2.0, outputPerMillion: 8.0 },
+    'o3-mini': { inputPerMillion: 1.1, outputPerMillion: 4.4 },
+    'o4-mini': { inputPerMillion: 1.1, outputPerMillion: 4.4 },
+    'o1': { inputPerMillion: 15.0, outputPerMillion: 60.0 },
+    'o1-mini': { inputPerMillion: 1.1, outputPerMillion: 4.4 },
+    'o1-preview': { inputPerMillion: 15.0, outputPerMillion: 60.0 },
+    // Embeddings
+    'text-embedding-3-small': { inputPerMillion: 0.02, outputPerMillion: 0 },
+    'text-embedding-3-large': { inputPerMillion: 0.13, outputPerMillion: 0 },
+    'text-embedding-ada-002': { inputPerMillion: 0.1, outputPerMillion: 0 },
+    // ── Anthropic ───────────────────────────────────────────
+    'claude-opus-4-20250514': { inputPerMillion: 15.0, outputPerMillion: 75.0 },
+    'claude-sonnet-4-20250514': { inputPerMillion: 3.0, outputPerMillion: 15.0 },
+    'claude-3-7-sonnet-20250219': { inputPerMillion: 3.0, outputPerMillion: 15.0 },
+    'claude-3-5-sonnet-20241022': { inputPerMillion: 3.0, outputPerMillion: 15.0 },
+    'claude-3-5-sonnet-20240620': { inputPerMillion: 3.0, outputPerMillion: 15.0 },
+    'claude-3-5-haiku-20241022': { inputPerMillion: 0.8, outputPerMillion: 4.0 },
+    'claude-3-opus-20240229': { inputPerMillion: 15.0, outputPerMillion: 75.0 },
+    'claude-3-sonnet-20240229': { inputPerMillion: 3.0, outputPerMillion: 15.0 },
+    'claude-3-haiku-20240307': { inputPerMillion: 0.25, outputPerMillion: 1.25 },
+    // Aliases
+    'claude-opus-4-0': { inputPerMillion: 15.0, outputPerMillion: 75.0 },
+    'claude-sonnet-4-0': { inputPerMillion: 3.0, outputPerMillion: 15.0 },
+    'claude-3.7-sonnet': { inputPerMillion: 3.0, outputPerMillion: 15.0 },
+    'claude-3.5-sonnet': { inputPerMillion: 3.0, outputPerMillion: 15.0 },
+    'claude-3.5-haiku': { inputPerMillion: 0.8, outputPerMillion: 4.0 },
+    'claude-3-opus': { inputPerMillion: 15.0, outputPerMillion: 75.0 },
+    'claude-3-sonnet': { inputPerMillion: 3.0, outputPerMillion: 15.0 },
+    'claude-3-haiku': { inputPerMillion: 0.25, outputPerMillion: 1.25 },
+};
+const ALIASES = {
+    'gpt-4o-2024-11-20': 'gpt-4o',
+    'gpt-4o-2024-08-06': 'gpt-4o',
+    'gpt-4o-2024-05-13': 'gpt-4o',
+    'gpt-4o-mini-2024-07-18': 'gpt-4o-mini',
+    'gpt-4-turbo-2024-04-09': 'gpt-4-turbo',
+    'gpt-4-turbo-preview': 'gpt-4-turbo',
+    'gpt-4-0125-preview': 'gpt-4-turbo',
+    'gpt-4-1106-preview': 'gpt-4-turbo',
+    'gpt-3.5-turbo-0125': 'gpt-3.5-turbo',
+    'gpt-3.5-turbo-1106': 'gpt-3.5-turbo',
+    'o3-2025-04-16': 'o3',
+    'o4-mini-2025-04-16': 'o4-mini',
+};
+function resolveModel(model) {
+    return ALIASES[model] ?? model;
+}
+function getPrice(model) {
+    const canonical = resolveModel(model);
+    return MODEL_PRICES[canonical] ?? null;
+}
+function getCost(model, inputTokens, outputTokens) {
+    const price = getPrice(model);
+    if (!price)
+        return null;
+    return ((inputTokens * price.inputPerMillion +
+        outputTokens * price.outputPerMillion) /
+        1000000);
+}

package/dist/tracker.d.ts

@@ -0,0 +1,21 @@
+/**
+ * CostTracker — core cost accumulation and querying.
+ */
+import { BudgetPolicy } from './budget';
+import { CostEvent } from './types';
+export interface CostTrackerOptions {
+    budget?: BudgetPolicy;
+    export?: string | null;
+    quiet?: boolean;
+}
+export declare class CostTracker {
+    private _events;
+    private _budget?;
+    private _exporters;
+    constructor(options?: CostTrackerOptions);
+    record(event: CostEvent): void;
+    get events(): CostEvent[];
+    get totalCost(): number;
+    costBy(key: string): Record<string, number>;
+    reset(): void;
+}

package/dist/tracker.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * CostTracker — core cost accumulation and querying.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostTracker = void 0;
+const exporters_1 = require("./exporters");
+class CostTracker {
+    constructor(options = {}) {
+        this._events = [];
+        this._exporters = [];
+        this._budget = options.budget;
+        let exportSpec = options.export ?? 'console';
+        if (options.quiet)
+            exportSpec = null;
+        if (exportSpec) {
+            this._exporters.push((0, exporters_1.getExporter)(exportSpec));
+        }
+    }
+    record(event) {
+        if (this._budget) {
+            this._budget.check(this._events, event);
+        }
+        if (this._budget && event.costUsd !== null) {
+            const spent = this._budget.currentSpend(this._events) + event.costUsd;
+            event.budgetRemainingUsd = Math.max(0, this._budget.maxCost - spent);
+        }
+        this._events.push(event);
+        for (const exporter of this._exporters) {
+            exporter(event);
+        }
+    }
+    get events() {
+        return [...this._events];
+    }
+    get totalCost() {
+        return this._events.reduce((sum, e) => sum + (e.costUsd ?? 0), 0);
+    }
+    costBy(key) {
+        const result = {};
+        for (const e of this._events) {
+            if (e.costUsd === null)
+                continue;
+            let groupKey;
+            if (key === 'model')
+                groupKey = e.model;
+            else if (key === 'provider')
+                groupKey = e.provider;
+            else
+                groupKey = e.tags[key];
+            if (groupKey !== undefined) {
+                result[groupKey] = (result[groupKey] ?? 0) + e.costUsd;
+            }
+        }
+        return result;
+    }
+    reset() {
+        this._events = [];
+    }
+}
+exports.CostTracker = CostTracker;

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Core data types for compute-cfo.
+ */
+export interface CostEvent {
+    timestamp: string;
+    provider: string;
+    model: string;
+    operation: string;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number | null;
+    latencyMs?: number;
+    tags: Record<string, string>;
+    budgetRemainingUsd?: number;
+}
+export type BudgetWindow = 'hourly' | 'daily' | 'monthly' | 'total';
+export type OnExceed = 'throw' | 'warn' | 'callback';
+export declare class BudgetExceededError extends Error {
+    readonly limit: number;
+    readonly current: number;
+    readonly window: string;
+    constructor(limit: number, current: number, window: string);
+}
+export declare function costEventToDict(event: CostEvent): Record<string, unknown>;

package/dist/types.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Core data types for compute-cfo.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BudgetExceededError = void 0;
+exports.costEventToDict = costEventToDict;
+class BudgetExceededError extends Error {
+    constructor(limit, current, window) {
+        super(`Budget exceeded: $${current.toFixed(4)} / $${limit.toFixed(4)} (${window} window)`);
+        this.name = 'BudgetExceededError';
+        this.limit = limit;
+        this.current = current;
+        this.window = window;
+    }
+}
+exports.BudgetExceededError = BudgetExceededError;
+function costEventToDict(event) {
+    const d = {
+        timestamp: event.timestamp,
+        provider: event.provider,
+        model: event.model,
+        operation: event.operation,
+        input_tokens: event.inputTokens,
+        output_tokens: event.outputTokens,
+        cost_usd: event.costUsd,
+    };
+    if (event.latencyMs !== undefined)
+        d.latency_ms = event.latencyMs;
+    if (Object.keys(event.tags).length > 0)
+        d.tags = event.tags;
+    if (event.budgetRemainingUsd !== undefined)
+        d.budget_remaining_usd = event.budgetRemainingUsd;
+    return d;
+}

package/dist/wrapper.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Drop-in wrapper for OpenAI and Anthropic SDK clients.
+ */
+import { CostTracker } from './tracker';
+export interface WrapOptions {
+    tracker?: CostTracker;
+}
+/**
+ * Wrap an OpenAI or Anthropic client with cost tracking.
+ */
+export declare function wrap<T extends object>(client: T, options?: WrapOptions): T;

package/dist/wrapper.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Drop-in wrapper for OpenAI and Anthropic SDK clients.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrap = wrap;
+const pricing_1 = require("./pricing");
+const tracker_1 = require("./tracker");
+let defaultTracker = null;
+function getOrCreateDefaultTracker() {
+    if (!defaultTracker) {
+        defaultTracker = new tracker_1.CostTracker({ export: 'console' });
+    }
+    return defaultTracker;
+}
+/**
+ * Wrap an OpenAI or Anthropic client with cost tracking.
+ */
+function wrap(client, options) {
+    const tracker = options?.tracker ?? getOrCreateDefaultTracker();
+    // Detect client type by checking for characteristic properties
+    if ('chat' in client && typeof client.chat?.completions?.create === 'function') {
+        return wrapOpenAI(client, tracker);
+    }
+    if ('messages' in client && typeof client.messages?.create === 'function') {
+        return wrapAnthropic(client, tracker);
+    }
+    throw new TypeError(`Unsupported client type. Supported: OpenAI, Anthropic`);
+}
+function wrapOpenAI(client, tracker) {
+    const originalCreate = client.chat.completions.create.bind(client.chat.completions);
+    const trackedCreate = async (params) => {
+        const { metadata, ...rest } = params ?? {};
+        const tags = metadata && typeof metadata === 'object' ? { ...metadata } : {};
+        const model = rest.model ?? 'unknown';
+        const start = performance.now();
+        const response = await originalCreate(rest);
+        const latencyMs = Math.round((performance.now() - start) * 10) / 10;
+        const usage = response?.usage;
+        const inputTokens = usage?.prompt_tokens ?? 0;
+        const outputTokens = usage?.completion_tokens ?? 0;
+        const actualModel = response?.model ?? model;
+        const costUsd = (0, pricing_1.getCost)(actualModel, inputTokens, outputTokens);
+        const event = {
+            timestamp: new Date().toISOString(),
+            provider: 'openai',
+            model: actualModel,
+            operation: 'chat.completions',
+            inputTokens,
+            outputTokens,
+            costUsd,
+            latencyMs,
+            tags,
+        };
+        tracker.record(event);
+        return response;
+    };
+    // Create a proxy that intercepts chat.completions.create
+    return new Proxy(client, {
+        get(target, prop) {
+            if (prop === 'chat') {
+                return new Proxy(target.chat, {
+                    get(chatTarget, chatProp) {
+                        if (chatProp === 'completions') {
+                            return new Proxy(chatTarget.completions, {
+                                get(compTarget, compProp) {
+                                    if (compProp === 'create')
+                                        return trackedCreate;
+                                    return compTarget[compProp];
+                                },
+                            });
+                        }
+                        return chatTarget[chatProp];
+                    },
+                });
+            }
+            return target[prop];
+        },
+    });
+}
+function wrapAnthropic(client, tracker) {
+    const originalCreate = client.messages.create.bind(client.messages);
+    const trackedCreate = async (params) => {
+        const { compute_cfo_tags, ...rest } = params ?? {};
+        const tags = {};
+        // Extract from Anthropic metadata
+        if (rest.metadata && typeof rest.metadata === 'object') {
+            for (const [k, v] of Object.entries(rest.metadata)) {
+                if (k !== 'user_id')
+                    tags[k] = String(v);
+            }
+        }
+        // Merge explicit tags
+        if (compute_cfo_tags && typeof compute_cfo_tags === 'object') {
+            Object.assign(tags, compute_cfo_tags);
+        }
+        const model = rest.model ?? 'unknown';
+        const start = performance.now();
+        const response = await originalCreate(rest);
+        const latencyMs = Math.round((performance.now() - start) * 10) / 10;
+        const usage = response?.usage;
+        const inputTokens = usage?.input_tokens ?? 0;
+        const outputTokens = usage?.output_tokens ?? 0;
+        const actualModel = response?.model ?? model;
+        const costUsd = (0, pricing_1.getCost)(actualModel, inputTokens, outputTokens);
+        const event = {
+            timestamp: new Date().toISOString(),
+            provider: 'anthropic',
+            model: actualModel,
+            operation: 'messages',
+            inputTokens,
+            outputTokens,
+            costUsd,
+            latencyMs,
+            tags,
+        };
+        tracker.record(event);
+        return response;
+    };
+    return new Proxy(client, {
+        get(target, prop) {
+            if (prop === 'messages') {
+                return new Proxy(target.messages, {
+                    get(msgTarget, msgProp) {
+                        if (msgProp === 'create')
+                            return trackedCreate;
+                        return msgTarget[msgProp];
+                    },
+                });
+            }
+            return target[prop];
+        },
+    });
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "compute-cfo",
+  "version": "0.1.0",
+  "description": "Cost tracking, attribution, and budget enforcement for AI inference APIs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["llm", "cost", "tracking", "openai", "anthropic", "budget", "inference", "ai"],
+  "author": "Compute CFO <hello@computecfo.com>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/YanLukashin/compute-cfo"
+  },
+  "peerDependencies": {
+    "openai": ">=4.0.0",
+    "@anthropic-ai/sdk": ">=0.20.0"
+  },
+  "peerDependenciesMeta": {
+    "openai": { "optional": true },
+    "@anthropic-ai/sdk": { "optional": true }
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "@types/jest": "^29.0.0",
+    "openai": "^4.80.0",
+    "@anthropic-ai/sdk": "^0.39.0"
+  }
+}