@hazeljs/ai 0.2.0-alpha.1

package/dist/providers/openai.provider.test.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+    default: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const mockChatCreate = jest.fn();
+const mockEmbedCreate = jest.fn();
+const mockSpeechCreate = jest.fn();
+const mockModelsList = jest.fn();
+jest.mock('openai', () => ({
+    __esModule: true,
+    default: jest.fn().mockImplementation(() => ({
+        chat: { completions: { create: mockChatCreate } },
+        embeddings: { create: mockEmbedCreate },
+        audio: { speech: { create: mockSpeechCreate } },
+        models: { list: mockModelsList },
+    })),
+}));
+const openai_provider_1 = require("./openai.provider");
+const BASE_REQUEST = {
+    messages: [{ role: 'user', content: 'Hello OpenAI' }],
+    model: 'gpt-4',
+};
+const MOCK_COMPLETION = {
+    id: 'chatcmpl-001',
+    model: 'gpt-4',
+    choices: [
+        {
+            message: { content: 'OpenAI response', tool_calls: undefined },
+            finish_reason: 'stop',
+        },
+    ],
+    usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+};
+describe('OpenAIProvider', () => {
+    let provider;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        provider = new openai_provider_1.OpenAIProvider('test-api-key');
+    });
+    describe('constructor', () => {
+        it('sets name to openai', () => {
+            expect(provider.name).toBe('openai');
+        });
+        it('accepts custom config', () => {
+            const p = new openai_provider_1.OpenAIProvider('key', {
+                baseURL: 'http://custom',
+                defaultModel: 'gpt-3.5-turbo',
+            });
+            expect(p).toBeDefined();
+        });
+    });
+    describe('getSupportedModels()', () => {
+        it('returns list including gpt-4', () => {
+            const models = provider.getSupportedModels();
+            expect(models).toContain('gpt-4');
+        });
+    });
+    describe('getSupportedEmbeddingModels()', () => {
+        it('returns embedding models', () => {
+            const models = provider.getSupportedEmbeddingModels();
+            expect(models).toContain('text-embedding-3-small');
+        });
+    });
+    describe('complete()', () => {
+        it('returns a completion response', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.content).toBe('OpenAI response');
+            expect(result.role).toBe('assistant');
+            expect(result.usage?.promptTokens).toBe(10);
+            expect(result.usage?.completionTokens).toBe(20);
+            expect(result.usage?.totalTokens).toBe(30);
+            expect(result.finishReason).toBe('stop');
+        });
+        it('uses default model when not specified', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            await provider.complete({ messages: [{ role: 'user', content: 'hi' }] });
+            expect(mockChatCreate).toHaveBeenCalledWith(expect.objectContaining({ model: 'gpt-4-turbo-preview' }));
+        });
+        it('handles tool_calls in response', async () => {
+            mockChatCreate.mockResolvedValue({
+                ...MOCK_COMPLETION,
+                choices: [
+                    {
+                        message: {
+                            content: '',
+                            tool_calls: [
+                                {
+                                    id: 'call_1',
+                                    type: 'function',
+                                    function: { name: 'getWeather', arguments: '{"city":"NYC"}' },
+                                },
+                            ],
+                        },
+                        finish_reason: 'tool_calls',
+                    },
+                ],
+            });
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.functionCall?.name).toBe('getWeather');
+            expect(result.toolCalls).toHaveLength(1);
+        });
+        it('passes functions as tools', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            await provider.complete({
+                ...BASE_REQUEST,
+                functions: [
+                    {
+                        name: 'testFn',
+                        description: 'Test',
+                        parameters: { type: 'object', properties: {} },
+                    },
+                ],
+            });
+            expect(mockChatCreate).toHaveBeenCalledWith(expect.objectContaining({
+                tools: expect.arrayContaining([expect.objectContaining({ type: 'function' })]),
+            }));
+        });
+        it('sets tool_choice auto when functionCall is "auto"', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            await provider.complete({ ...BASE_REQUEST, functionCall: 'auto' });
+            expect(mockChatCreate).toHaveBeenCalledWith(expect.objectContaining({ tool_choice: 'auto' }));
+        });
+        it('sets tool_choice none when functionCall is "none"', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            await provider.complete({ ...BASE_REQUEST, functionCall: 'none' });
+            expect(mockChatCreate).toHaveBeenCalledWith(expect.objectContaining({ tool_choice: 'none' }));
+        });
+        it('handles missing usage in response', async () => {
+            mockChatCreate.mockResolvedValue({ ...MOCK_COMPLETION, usage: undefined });
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.usage).toBeUndefined();
+        });
+        it('throws when no choices returned', async () => {
+            mockChatCreate.mockResolvedValue({ ...MOCK_COMPLETION, choices: [] });
+            await expect(provider.complete(BASE_REQUEST)).rejects.toThrow();
+        });
+        it('wraps API errors with status code', async () => {
+            mockChatCreate.mockRejectedValue({ status: 429, message: 'Rate limit' });
+            await expect(provider.complete(BASE_REQUEST)).rejects.toThrow('OpenAI API Error (429)');
+        });
+        it('returns original Error when thrown', async () => {
+            mockChatCreate.mockRejectedValue(new Error('Direct error'));
+            await expect(provider.complete(BASE_REQUEST)).rejects.toThrow('Direct error');
+        });
+        it('wraps unknown thrown values', async () => {
+            mockChatCreate.mockRejectedValue(null);
+            await expect(provider.complete(BASE_REQUEST)).rejects.toThrow('Unknown OpenAI error');
+        });
+    });
+    describe('complete() – message transformation', () => {
+        it('transforms system messages', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            await provider.complete({
+                messages: [{ role: 'system', content: 'Be helpful' }],
+            });
+            const msgs = mockChatCreate.mock.calls[0][0].messages;
+            expect(msgs[0].role).toBe('system');
+        });
+        it('transforms user messages', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            await provider.complete({ messages: [{ role: 'user', content: 'Hello' }] });
+            const msgs = mockChatCreate.mock.calls[0][0].messages;
+            expect(msgs[0].role).toBe('user');
+        });
+        it('transforms assistant messages with functionCall to tool_calls', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            await provider.complete({
+                messages: [
+                    {
+                        role: 'assistant',
+                        content: '',
+                        functionCall: { name: 'fn', arguments: '{}' },
+                    },
+                ],
+            });
+            const msgs = mockChatCreate.mock.calls[0][0].messages;
+            expect(msgs[0].role).toBe('assistant');
+            expect(msgs[0].tool_calls).toBeDefined();
+        });
+        it('transforms function/tool role messages', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            await provider.complete({
+                messages: [{ role: 'tool', content: 'result', toolCallId: 'call_1' }],
+            });
+            const msgs = mockChatCreate.mock.calls[0][0].messages;
+            expect(msgs[0].role).toBe('tool');
+        });
+        it('transforms assistant messages with toolCalls', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            await provider.complete({
+                messages: [
+                    {
+                        role: 'assistant',
+                        content: '',
+                        toolCalls: [{ id: 'tc_1', type: 'function', function: { name: 'f', arguments: '{}' } }],
+                    },
+                ],
+            });
+            const msgs = mockChatCreate.mock.calls[0][0].messages;
+            expect(msgs[0].role).toBe('assistant');
+        });
+        it('defaults unknown role to assistant', async () => {
+            mockChatCreate.mockResolvedValue(MOCK_COMPLETION);
+            await provider.complete({
+                messages: [{ role: 'unknown', content: 'msg' }],
+            });
+            const msgs = mockChatCreate.mock.calls[0][0].messages;
+            expect(msgs[0].role).toBe('assistant');
+        });
+    });
+    describe('streamComplete()', () => {
+        it('yields content chunks', async () => {
+            async function* mockStream() {
+                yield {
+                    id: 's1',
+                    choices: [{ delta: { content: 'Hello ' }, finish_reason: null }],
+                    usage: undefined,
+                };
+                yield {
+                    id: 's1',
+                    choices: [{ delta: { content: 'world' }, finish_reason: null }],
+                    usage: undefined,
+                };
+                yield {
+                    id: 's1',
+                    choices: [{ delta: {}, finish_reason: 'stop' }],
+                    usage: { prompt_tokens: 5, completion_tokens: 3, total_tokens: 8 },
+                };
+            }
+            mockChatCreate.mockResolvedValue(mockStream());
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            expect(results.length).toBeGreaterThan(0);
+        });
+        it('includes usage in final chunk when finish_reason is set', async () => {
+            async function* mockStream() {
+                yield {
+                    id: 's2',
+                    choices: [{ delta: { content: 'end' }, finish_reason: 'stop' }],
+                    usage: { prompt_tokens: 3, completion_tokens: 2, total_tokens: 5 },
+                };
+            }
+            mockChatCreate.mockResolvedValue(mockStream());
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            const last = results[results.length - 1];
+            expect(last.done).toBe(true);
+        });
+        it('skips chunks with empty content', async () => {
+            async function* mockStream() {
+                yield {
+                    id: 's3',
+                    choices: [{ delta: { content: '' }, finish_reason: null }],
+                    usage: undefined,
+                };
+                yield { id: 's3', choices: [{ delta: {}, finish_reason: 'stop' }], usage: undefined };
+            }
+            mockChatCreate.mockResolvedValue(mockStream());
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            // Only done chunk, no content chunks
+            expect(results).toHaveLength(1);
+        });
+        it('throws on streaming error', async () => {
+            mockChatCreate.mockRejectedValue(new Error('Stream failed'));
+            await expect(async () => {
+                for await (const _chunk of provider.streamComplete(BASE_REQUEST)) {
+                    // consume
+                }
+            }).rejects.toThrow();
+        });
+    });
+    describe('embed()', () => {
+        it('returns embeddings for string input', async () => {
+            mockEmbedCreate.mockResolvedValue({
+                data: [{ embedding: [0.1, 0.2, 0.3] }],
+                model: 'text-embedding-3-small',
+                usage: { prompt_tokens: 5, total_tokens: 5 },
+            });
+            const result = await provider.embed({ input: 'hello' });
+            expect(result.embeddings).toHaveLength(1);
+            expect(result.embeddings[0]).toEqual([0.1, 0.2, 0.3]);
+        });
+        it('returns multiple embeddings for array input', async () => {
+            mockEmbedCreate.mockResolvedValue({
+                data: [{ embedding: [0.1] }, { embedding: [0.2] }],
+                model: 'text-embedding-3-small',
+                usage: { prompt_tokens: 10, total_tokens: 10 },
+            });
+            const result = await provider.embed({ input: ['first', 'second'] });
+            expect(result.embeddings).toHaveLength(2);
+        });
+        it('uses default model text-embedding-3-small', async () => {
+            mockEmbedCreate.mockResolvedValue({
+                data: [{ embedding: [0.1] }],
+                model: 'text-embedding-3-small',
+                usage: { prompt_tokens: 3, total_tokens: 3 },
+            });
+            const result = await provider.embed({ input: 'test' });
+            expect(mockEmbedCreate).toHaveBeenCalledWith(expect.objectContaining({ model: 'text-embedding-3-small' }));
+            expect(result.model).toBe('text-embedding-3-small');
+        });
+        it('throws on API failure', async () => {
+            mockEmbedCreate.mockRejectedValue({ status: 500, message: 'Server error' });
+            await expect(provider.embed({ input: 'test' })).rejects.toThrow();
+        });
+    });
+    describe('speech()', () => {
+        it('returns a Buffer from TTS', async () => {
+            const fakeAudioData = new Uint8Array([1, 2, 3]).buffer;
+            mockSpeechCreate.mockResolvedValue({
+                arrayBuffer: jest.fn().mockResolvedValue(fakeAudioData),
+            });
+            const result = await provider.speech('Hello world', { voice: 'alloy' });
+            expect(Buffer.isBuffer(result)).toBe(true);
+        });
+        it('uses default voice alloy', async () => {
+            const fakeAudioData = new Uint8Array([1]).buffer;
+            mockSpeechCreate.mockResolvedValue({
+                arrayBuffer: jest.fn().mockResolvedValue(fakeAudioData),
+            });
+            await provider.speech('test');
+            expect(mockSpeechCreate).toHaveBeenCalledWith(expect.objectContaining({ voice: 'alloy' }));
+        });
+        it('falls back to alloy for invalid voice', async () => {
+            const fakeAudioData = new Uint8Array([1]).buffer;
+            mockSpeechCreate.mockResolvedValue({
+                arrayBuffer: jest.fn().mockResolvedValue(fakeAudioData),
+            });
+            await provider.speech('test', { voice: 'invalid-voice' });
+            expect(mockSpeechCreate).toHaveBeenCalledWith(expect.objectContaining({ voice: 'alloy' }));
+        });
+        it('throws when input exceeds 4096 characters', async () => {
+            await expect(provider.speech('x'.repeat(4097))).rejects.toThrow('TTS input must be 4096 characters');
+        });
+        it('uses custom model and format', async () => {
+            const fakeAudioData = new Uint8Array([1]).buffer;
+            mockSpeechCreate.mockResolvedValue({
+                arrayBuffer: jest.fn().mockResolvedValue(fakeAudioData),
+            });
+            await provider.speech('hello', { model: 'tts-1-hd', format: 'opus' });
+            expect(mockSpeechCreate).toHaveBeenCalledWith(expect.objectContaining({ model: 'tts-1-hd', response_format: 'opus' }));
+        });
+    });
+    describe('isAvailable()', () => {
+        it('returns true when models.list() succeeds', async () => {
+            mockModelsList.mockResolvedValue({ data: [] });
+            expect(await provider.isAvailable()).toBe(true);
+        });
+        it('returns false when models.list() throws', async () => {
+            mockModelsList.mockRejectedValue(new Error('Unauthorized'));
+            expect(await provider.isAvailable()).toBe(false);
+        });
+    });
+});

package/dist/tracking/token.tracker.d.ts

@@ -0,0 +1,72 @@
+import { TokenUsage, TokenLimitConfig } from '../ai-enhanced.types';
+/**
+ * Token Usage Tracker
+ * Tracks and limits token usage per user/request
+ */
+export declare class TokenTracker {
+    private usageHistory;
+    private config;
+    private userUsage;
+    private readonly TOKEN_COSTS;
+    constructor(config?: TokenLimitConfig);
+    /**
+     * Track token usage
+     */
+    track(usage: TokenUsage, model?: string): void;
+    /**
+     * Check if request is within limits
+     */
+    checkLimits(userId?: string, requestTokens?: number): Promise<{
+        allowed: boolean;
+        reason?: string;
+        usage?: {
+            today: number;
+            month: number;
+            limit: {
+                daily: number;
+                monthly: number;
+            };
+        };
+    }>;
+    /**
+     * Calculate cost for token usage
+     */
+    calculateCost(usage: TokenUsage, model: string): number;
+    /**
+     * Get usage statistics for a user
+     */
+    getUserStats(userId: string, days?: number): {
+        totalTokens: number;
+        totalCost: number;
+        requestCount: number;
+        averageTokensPerRequest: number;
+        dailyAverage: number;
+    };
+    /**
+     * Get global statistics
+     */
+    getGlobalStats(days?: number): {
+        totalTokens: number;
+        totalCost: number;
+        requestCount: number;
+        uniqueUsers: number;
+        topUsers: Array<{
+            userId: string;
+            tokens: number;
+            cost: number;
+        }>;
+    };
+    /**
+     * Clear old usage data
+     */
+    cleanup(daysToKeep?: number): void;
+    /**
+     * Export usage data
+     */
+    exportData(userId?: string): TokenUsage[];
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<TokenLimitConfig>): void;
+}
+//# sourceMappingURL=token.tracker.d.ts.map

package/dist/tracking/token.tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.tracker.d.ts","sourceRoot":"","sources":["../../src/tracking/token.tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAIpE;;;GAGG;AACH,qBACa,YAAY;IACvB,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,SAAS,CAAwC;IAGzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAO1B;gBAEU,MAAM,CAAC,EAAE,gBAAgB;IAUrC;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAsB9C;;OAEG;IACG,WAAW,CACf,MAAM,CAAC,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE;YACN,KAAK,EAAE,MAAM,CAAC;YACd,KAAK,EAAE,MAAM,CAAC;YACd,KAAK,EAAE;gBACL,KAAK,EAAE,MAAM,CAAC;gBACd,OAAO,EAAE,MAAM,CAAC;aACjB,CAAC;SACH,CAAC;KACH,CAAC;IA2DF;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAavD;;OAEG;IACH,YAAY,CACV,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,MAAW,GAChB;QACD,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,uBAAuB,EAAE,MAAM,CAAC;QAChC,YAAY,EAAE,MAAM,CAAC;KACtB;IAiBD;;OAEG;IACH,cAAc,CAAC,IAAI,GAAE,MAAW,GAAG;QACjC,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,KAAK,CAAC;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACnE;IAsCD;;OAEG;IACH,OAAO,CAAC,UAAU,GAAE,MAAW,GAAG,IAAI;IAmBtC;;OAEG;IACH,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE;IAOzC;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI;CAItD"}

package/dist/tracking/token.tracker.js

@@ -0,0 +1,222 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTracker = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Token Usage Tracker
+ * Tracks and limits token usage per user/request
+ */
+let TokenTracker = class TokenTracker {
+    constructor(config) {
+        this.usageHistory = [];
+        this.userUsage = new Map();
+        // Token costs per 1K tokens (as of 2024)
+        this.TOKEN_COSTS = {
+            'gpt-4-turbo-preview': { prompt: 0.01, completion: 0.03 },
+            'gpt-4': { prompt: 0.03, completion: 0.06 },
+            'gpt-3.5-turbo': { prompt: 0.0005, completion: 0.0015 },
+            'claude-3-opus': { prompt: 0.015, completion: 0.075 },
+            'claude-3-sonnet': { prompt: 0.003, completion: 0.015 },
+            'claude-3-haiku': { prompt: 0.00025, completion: 0.00125 },
+        };
+        this.config = {
+            maxTokensPerRequest: config?.maxTokensPerRequest || 4096,
+            maxTokensPerDay: config?.maxTokensPerDay || 100000,
+            maxTokensPerMonth: config?.maxTokensPerMonth || 1000000,
+            costPerToken: config?.costPerToken,
+        };
+        core_2.default.info('Token Tracker initialized', this.config);
+    }
+    /**
+     * Track token usage
+     */
+    track(usage, model) {
+        // Calculate cost if not provided
+        if (!usage.cost && model) {
+            usage.cost = this.calculateCost(usage, model);
+        }
+        this.usageHistory.push(usage);
+        // Track per user if userId provided
+        if (usage.userId) {
+            const userHistory = this.userUsage.get(usage.userId) || [];
+            userHistory.push(usage);
+            this.userUsage.set(usage.userId, userHistory);
+        }
+        core_2.default.debug('Token usage tracked', {
+            userId: usage.userId,
+            totalTokens: usage.totalTokens,
+            cost: usage.cost,
+        });
+    }
+    /**
+     * Check if request is within limits
+     */
+    async checkLimits(userId, requestTokens) {
+        // Check request token limit
+        if (requestTokens && requestTokens > this.config.maxTokensPerRequest) {
+            return {
+                allowed: false,
+                reason: `Request exceeds token limit (${requestTokens} > ${this.config.maxTokensPerRequest})`,
+            };
+        }
+        if (!userId) {
+            return { allowed: true };
+        }
+        const now = Date.now();
+        const oneDayAgo = now - 24 * 60 * 60 * 1000;
+        const oneMonthAgo = now - 30 * 24 * 60 * 60 * 1000;
+        const userHistory = this.userUsage.get(userId) || [];
+        // Calculate daily usage
+        const dailyUsage = userHistory
+            .filter((u) => u.timestamp > oneDayAgo)
+            .reduce((sum, u) => sum + u.totalTokens, 0);
+        // Calculate monthly usage
+        const monthlyUsage = userHistory
+            .filter((u) => u.timestamp > oneMonthAgo)
+            .reduce((sum, u) => sum + u.totalTokens, 0);
+        const usage = {
+            today: dailyUsage,
+            month: monthlyUsage,
+            limit: {
+                daily: this.config.maxTokensPerDay,
+                monthly: this.config.maxTokensPerMonth,
+            },
+        };
+        // Check daily limit
+        if (dailyUsage >= this.config.maxTokensPerDay) {
+            return {
+                allowed: false,
+                reason: 'Daily token limit exceeded',
+                usage,
+            };
+        }
+        // Check monthly limit
+        if (monthlyUsage >= this.config.maxTokensPerMonth) {
+            return {
+                allowed: false,
+                reason: 'Monthly token limit exceeded',
+                usage,
+            };
+        }
+        return { allowed: true, usage };
+    }
+    /**
+     * Calculate cost for token usage
+     */
+    calculateCost(usage, model) {
+        const costs = this.TOKEN_COSTS[model];
+        if (!costs) {
+            core_2.default.warn(`Unknown model for cost calculation: ${model}`);
+            return 0;
+        }
+        const promptCost = (usage.promptTokens / 1000) * costs.prompt;
+        const completionCost = (usage.completionTokens / 1000) * costs.completion;
+        return promptCost + completionCost;
+    }
+    /**
+     * Get usage statistics for a user
+     */
+    getUserStats(userId, days = 30) {
+        const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+        const userHistory = (this.userUsage.get(userId) || []).filter((u) => u.timestamp > cutoff);
+        const totalTokens = userHistory.reduce((sum, u) => sum + u.totalTokens, 0);
+        const totalCost = userHistory.reduce((sum, u) => sum + (u.cost || 0), 0);
+        const requestCount = userHistory.length;
+        return {
+            totalTokens,
+            totalCost,
+            requestCount,
+            averageTokensPerRequest: requestCount > 0 ? Math.round(totalTokens / requestCount) : 0,
+            dailyAverage: Math.round(totalTokens / days),
+        };
+    }
+    /**
+     * Get global statistics
+     */
+    getGlobalStats(days = 30) {
+        const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+        const recentUsage = this.usageHistory.filter((u) => u.timestamp > cutoff);
+        const totalTokens = recentUsage.reduce((sum, u) => sum + u.totalTokens, 0);
+        const totalCost = recentUsage.reduce((sum, u) => sum + (u.cost || 0), 0);
+        const requestCount = recentUsage.length;
+        // Calculate per-user stats
+        const userStats = new Map();
+        recentUsage.forEach((u) => {
+            if (u.userId) {
+                const stats = userStats.get(u.userId) || { tokens: 0, cost: 0 };
+                stats.tokens += u.totalTokens;
+                stats.cost += u.cost || 0;
+                userStats.set(u.userId, stats);
+            }
+        });
+        // Get top users
+        const topUsers = Array.from(userStats.entries())
+            .map(([userId, stats]) => ({
+            userId,
+            tokens: stats.tokens,
+            cost: stats.cost,
+        }))
+            .sort((a, b) => b.tokens - a.tokens)
+            .slice(0, 10);
+        return {
+            totalTokens,
+            totalCost,
+            requestCount,
+            uniqueUsers: userStats.size,
+            topUsers,
+        };
+    }
+    /**
+     * Clear old usage data
+     */
+    cleanup(daysToKeep = 90) {
+        const cutoff = Date.now() - daysToKeep * 24 * 60 * 60 * 1000;
+        // Clean global history
+        this.usageHistory = this.usageHistory.filter((u) => u.timestamp > cutoff);
+        // Clean per-user history
+        for (const [userId, history] of this.userUsage.entries()) {
+            const filtered = history.filter((u) => u.timestamp > cutoff);
+            if (filtered.length === 0) {
+                this.userUsage.delete(userId);
+            }
+            else {
+                this.userUsage.set(userId, filtered);
+            }
+        }
+        core_2.default.info(`Cleaned up usage data older than ${daysToKeep} days`);
+    }
+    /**
+     * Export usage data
+     */
+    exportData(userId) {
+        if (userId) {
+            return this.userUsage.get(userId) || [];
+        }
+        return [...this.usageHistory];
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        core_2.default.info('Token tracker configuration updated', this.config);
+    }
+};
+exports.TokenTracker = TokenTracker;
+exports.TokenTracker = TokenTracker = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [Object])
+], TokenTracker);

package/dist/tracking/token.tracker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=token.tracker.test.d.ts.map

package/dist/tracking/token.tracker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.tracker.test.d.ts","sourceRoot":"","sources":["../../src/tracking/token.tracker.test.ts"],"names":[],"mappings":""}