observability-toolkit 2.0.0 → 2.1.1

package/dist/tools/query-llm-events.test.js

@@ -1,23 +1,37 @@
 /**
  * Tests for query-llm-events tool
  */
-import { describe, it, beforeEach, afterEach, mock } from 'node:test';
+import { describe, it, vi } from 'vitest';
 import assert from 'node:assert';
 import { queryLLMEvents, queryLLMEventsSchema, queryLLMEventsTool } from './query-llm-events.js';
-import { LocalJsonlBackend } from '../backends/local-jsonl.js';
+import { MAX_PROVIDER_LENGTH } from '../lib/core/shared-schemas.js';
 import { validateToolDefinition } from '../test-helpers/tool-validators.js';
 import { validateLimitSchema, validateDateRangeSchema } from '../test-helpers/schema-validators.js';
 import { TEST_TIMESTAMP_ISO } from '../test-helpers/test-data-builders.js';
-describe('queryLLMEvents', () => {
+// ---------- test constants ----------
+// schema defaults
+const LLM_EVENTS_DEFAULT_LIMIT = 50;
+// expected counts
+const EXPECTED_PAIR_COUNT = 2;
+const EXPECTED_MULTI_PROVIDER_COUNT = 4;
+// token/duration fixture values
+const INPUT_TOKENS_500 = 500;
+const OUTPUT_TOKENS_250 = 250;
+const DURATION_1500_MS = 1500;
+const INPUT_TOKENS_1K = 1000;
+// GenAI config fixtures
+const TEMPERATURE_0_7 = 0.7;
+const TEMPERATURE_0_5 = 0.5;
+const MAX_TOKENS_4K = 4096;
+const MAX_TOKENS_8K = 8192;
+// invalid fixture value (non-string in finish_reasons array)
+const NON_STRING_FINISH_REASON = 123;
+void describe('queryLLMEvents', () => {
     // Use shared schema validators
-    validateLimitSchema(queryLLMEventsSchema, 'queryLLMEventsSchema', 50);
+    validateLimitSchema(queryLLMEventsSchema, 'queryLLMEventsSchema', LLM_EVENTS_DEFAULT_LIMIT);
     validateDateRangeSchema(queryLLMEventsSchema, 'queryLLMEventsSchema');
-    describe('schema validation', () => {
-        it('should accept empty input with defaults', () => {
-            const result = queryLLMEventsSchema.parse({});
-            assert.strictEqual(result.limit, 50);
-        });
-        it('should accept all optional parameters', () => {
+    void describe('schema validation', () => {
+        void it('should accept all optional parameters', () => {
             const input = {
                 eventName: 'llm.completion',
                 model: 'claude-3-opus',
@@ -32,92 +46,40 @@ describe('queryLLMEvents', () => {
             assert.strictEqual(result.model, 'claude-3-opus');
             assert.strictEqual(result.provider, 'anthropic');
         });
-        describe('provider validation', () => {
-            it('should accept valid provider with alphanumeric characters', () => {
-                const result = queryLLMEventsSchema.parse({ provider: 'anthropic' });
-                assert.strictEqual(result.provider, 'anthropic');
-            });
-            it('should accept provider with dots', () => {
-                const result = queryLLMEventsSchema.parse({ provider: 'azure.openai' });
-                assert.strictEqual(result.provider, 'azure.openai');
-            });
-            it('should accept provider with underscores', () => {
-                const result = queryLLMEventsSchema.parse({ provider: 'my_custom_provider' });
-                assert.strictEqual(result.provider, 'my_custom_provider');
-            });
-            it('should accept provider with hyphens', () => {
-                const result = queryLLMEventsSchema.parse({ provider: 'together-ai' });
-                assert.strictEqual(result.provider, 'together-ai');
-            });
-            it('should accept provider with mixed valid characters', () => {
-                const result = queryLLMEventsSchema.parse({ provider: 'my_custom.provider-v2' });
-                assert.strictEqual(result.provider, 'my_custom.provider-v2');
-            });
-            it('should reject provider with spaces', () => {
-                assert.throws(() => queryLLMEventsSchema.parse({ provider: 'my provider' }), /Provider must contain only alphanumeric/);
-            });
-            it('should reject provider with special characters', () => {
-                assert.throws(() => queryLLMEventsSchema.parse({ provider: 'provider@domain' }), /Provider must contain only alphanumeric/);
-            });
-            it('should reject provider with SQL injection attempt', () => {
-                assert.throws(() => queryLLMEventsSchema.parse({ provider: "anthropic'; DROP TABLE--" }), /Provider must contain only alphanumeric/);
-            });
-            it('should reject provider exceeding max length', () => {
-                const longProvider = 'a'.repeat(101);
-                assert.throws(() => queryLLMEventsSchema.parse({ provider: longProvider }), /Provider name too long/);
-            });
-            it('should accept provider at max length (100)', () => {
-                const maxProvider = 'a'.repeat(100);
-                const result = queryLLMEventsSchema.parse({ provider: maxProvider });
-                assert.strictEqual(result.provider, maxProvider);
-            });
-            describe('path traversal prevention (security regression)', () => {
-                it('should reject provider starting with dot', () => {
-                    assert.throws(() => queryLLMEventsSchema.parse({ provider: '.hidden' }), /Provider must contain only alphanumeric/);
-                });
-                it('should reject provider ending with dot', () => {
-                    assert.throws(() => queryLLMEventsSchema.parse({ provider: 'provider.' }), /Provider must contain only alphanumeric/);
-                });
-                it('should reject provider with consecutive dots (..)', () => {
-                    assert.throws(() => queryLLMEventsSchema.parse({ provider: 'a..b' }), /Provider must contain only alphanumeric/);
-                });
-                it('should reject path traversal attempt', () => {
-                    assert.throws(() => queryLLMEventsSchema.parse({ provider: '../etc/passwd' }), /Provider must contain only alphanumeric/);
-                });
-                it('should accept valid provider with single dots', () => {
-                    const result = queryLLMEventsSchema.parse({ provider: 'azure.ai.openai' });
-                    assert.strictEqual(result.provider, 'azure.ai.openai');
-                });
-                it('should accept valid provider with dot-hyphen-underscore mix', () => {
-                    const result = queryLLMEventsSchema.parse({ provider: 'my_provider.v2-beta' });
-                    assert.strictEqual(result.provider, 'my_provider.v2-beta');
-                });
-                it('should reject provider starting with hyphen', () => {
-                    assert.throws(() => queryLLMEventsSchema.parse({ provider: '-invalid' }), /Provider must contain only alphanumeric/);
-                });
-                it('should reject provider starting with underscore', () => {
-                    assert.throws(() => queryLLMEventsSchema.parse({ provider: '_invalid' }), /Provider must contain only alphanumeric/);
-                });
+        void describe('provider validation', () => {
+            void it('should accept valid provider strings and reject invalid ones', () => {
+                const valid = 'my_custom.provider-v2';
+                assert.strictEqual(queryLLMEventsSchema.parse({ provider: valid }).provider, valid);
+                const atMaxLength = 'a'.repeat(MAX_PROVIDER_LENGTH);
+                assert.strictEqual(queryLLMEventsSchema.parse({ provider: atMaxLength }).provider, atMaxLength);
+                const invalidProviders = [
+                    'provider@domain', // special chars
+                    "anthropic'; DROP TABLE--", // SQL injection
+                    '.hidden', // leading dot (path traversal)
+                    'a..b', // consecutive dots (path traversal)
+                    '../etc/passwd', // path traversal
+                    '-invalid', // leading hyphen
+                    '_invalid', // leading underscore
+                    'a'.repeat(MAX_PROVIDER_LENGTH + 1), // exceeds max length
+                ];
+                for (const provider of invalidProviders) {
+                    assert.throws(() => queryLLMEventsSchema.parse({ provider }), Error, `expected rejection for provider: ${provider}`);
+                }
             });
         });
     });
-    describe('handler with mocked backend', () => {
-        let originalQueryLLMEvents;
-        beforeEach(() => {
-            originalQueryLLMEvents = LocalJsonlBackend.prototype.queryLLMEvents;
-        });
-        afterEach(() => {
-            LocalJsonlBackend.prototype.queryLLMEvents = originalQueryLLMEvents;
-        });
-        it('should return empty results when no events found', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => []);
-            const result = await queryLLMEvents({});
+    void describe('handler with mocked backend', () => {
+        function createMockBackend(queryFn) {
+            return { queryLLMEvents: queryFn };
+        }
+        void it('should return empty results when no events found', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => []));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.strictEqual(result.count, 0);
             assert.deepStrictEqual(result.events, []);
         });
-        it('should summarize events by name and model', async () => {
-            // Use TEST_TIMESTAMP_ISO for consistent timestamps
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should summarize events by name and model', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: TEST_TIMESTAMP_ISO,
                     name: 'llm.completion',
@@ -138,15 +100,14 @@ describe('queryLLMEvents', () => {
                         'gen_ai.usage.output_tokens': 100,
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
-            assert.strictEqual(result.count, 2);
-            assert.strictEqual(result.summary.byEventName['llm.completion'], 2);
-            assert.strictEqual(result.summary.byModel['claude-3-opus'], 2);
-        });
-        it('should include token usage in event details', async () => {
-            // Use TEST_TIMESTAMP_ISO for consistent timestamps
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
+            assert.strictEqual(result.count, EXPECTED_PAIR_COUNT);
+            assert.strictEqual(result.summary.byEventName['llm.completion'], EXPECTED_PAIR_COUNT);
+            assert.strictEqual(result.summary.byModel['claude-3-opus'], EXPECTED_PAIR_COUNT);
+        });
+        void it('should include token usage in event details', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: TEST_TIMESTAMP_ISO,
                     name: 'llm.completion',
@@ -159,45 +120,33 @@ describe('queryLLMEvents', () => {
                         'success': true,
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.strictEqual(result.events[0].model, 'gpt-4');
             assert.strictEqual(result.events[0].provider, 'openai');
-            assert.strictEqual(result.events[0].inputTokens, 500);
-            assert.strictEqual(result.events[0].outputTokens, 250);
-            assert.strictEqual(result.events[0].durationMs, 1500);
+            assert.strictEqual(result.events[0].inputTokens, INPUT_TOKENS_500);
+            assert.strictEqual(result.events[0].outputTokens, OUTPUT_TOKENS_250);
+            assert.strictEqual(result.events[0].durationMs, DURATION_1500_MS);
             assert.strictEqual(result.events[0].success, true);
         });
     });
-    describe('OTel GenAI compliance', () => {
-        let originalQueryLLMEvents;
-        beforeEach(() => {
-            originalQueryLLMEvents = LocalJsonlBackend.prototype.queryLLMEvents;
-        });
-        afterEach(() => {
-            LocalJsonlBackend.prototype.queryLLMEvents = originalQueryLLMEvents;
-        });
-        it('should accept operationName filter in schema', () => {
-            const input = {
-                operationName: 'chat',
-                limit: 10,
-            };
-            const result = queryLLMEventsSchema.parse(input);
-            assert.strictEqual(result.operationName, 'chat');
-        });
-        it('should validate operationName enum values', () => {
-            const validOps = ['chat', 'embeddings', 'invoke_agent', 'execute_tool'];
+    void describe('OTel GenAI compliance', () => {
+        function createMockBackend(queryFn) {
+            return { queryLLMEvents: queryFn };
+        }
+        void it('should validate operationName enum values', () => {
+            const validOps = ['chat', 'embeddings', 'invoke_agent', 'execute_tool', 'text_completion', 'generate_content', 'retrieval', 'create_agent', 'invoke_workflow'];
             for (const op of validOps) {
                 const result = queryLLMEventsSchema.parse({ operationName: op });
                 assert.strictEqual(result.operationName, op);
             }
         });
-        it('should reject invalid operationName', () => {
+        void it('should reject invalid operationName', () => {
             assert.throws(() => {
                 queryLLMEventsSchema.parse({ operationName: 'invalid' });
             });
         });
-        it('should accept conversationId filter in schema', () => {
+        void it('should accept conversationId filter in schema', () => {
             const input = {
                 conversationId: 'conv-12345',
                 limit: 10,
@@ -205,8 +154,8 @@ describe('queryLLMEvents', () => {
             const result = queryLLMEventsSchema.parse(input);
             assert.strictEqual(result.conversationId, 'conv-12345');
         });
-        it('should use provider fallback chain: gen_ai.provider.name -> gen_ai.system -> provider', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should use provider fallback chain: gen_ai.provider.name -> gen_ai.system -> provider', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -216,13 +165,12 @@ describe('queryLLMEvents', () => {
                         'provider': 'legacy-provider',
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
-            // Should use gen_ai.provider.name first
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.strictEqual(result.events[0].provider, 'anthropic-new');
         });
-        it('should fall back to gen_ai.system when gen_ai.provider.name is missing', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should fall back to gen_ai.system when gen_ai.provider.name is missing', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -231,12 +179,12 @@ describe('queryLLMEvents', () => {
                         'provider': 'legacy-provider',
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.strictEqual(result.events[0].provider, 'anthropic');
         });
-        it('should fall back to provider when OTel fields are missing', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should fall back to provider when OTel fields are missing', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -244,12 +192,12 @@ describe('queryLLMEvents', () => {
                         'provider': 'legacy-provider',
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.strictEqual(result.events[0].provider, 'legacy-provider');
         });
-        it('should include operationName in response when present', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should include operationName in response when present', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -258,12 +206,12 @@ describe('queryLLMEvents', () => {
                         'gen_ai.request.model': 'claude-3',
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.strictEqual(result.events[0].operationName, 'chat');
         });
-        it('should include conversationId in response when present', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should include conversationId in response when present', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -272,12 +220,12 @@ describe('queryLLMEvents', () => {
                         'gen_ai.request.model': 'claude-3',
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.strictEqual(result.events[0].conversationId, 'conv-abc123');
         });
-        it('should include gen_ai.response.model in response when present', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should include gen_ai.response.model in response when present', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -286,13 +234,13 @@ describe('queryLLMEvents', () => {
                         'gen_ai.response.model': 'claude-3-opus-20240229',
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.strictEqual(result.events[0].model, 'claude-3-opus');
             assert.strictEqual(result.events[0].responseModel, 'claude-3-opus-20240229');
         });
-        it('should include gen_ai.response.finish_reasons in response when present', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should include gen_ai.response.finish_reasons in response when present', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -301,12 +249,12 @@ describe('queryLLMEvents', () => {
                         'gen_ai.response.finish_reasons': ['stop'],
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.deepStrictEqual(result.events[0].finishReasons, ['stop']);
         });
-        it('should coerce single string finish_reason to array', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should coerce single string finish_reason to array', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -315,12 +263,12 @@ describe('queryLLMEvents', () => {
                         'gen_ai.response.finish_reasons': 'stop', // Single string, not array
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.deepStrictEqual(result.events[0].finishReasons, ['stop']);
         });
-        it('should return undefined for empty finish_reasons array', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should return undefined for empty finish_reasons array', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -329,26 +277,26 @@ describe('queryLLMEvents', () => {
                         'gen_ai.response.finish_reasons': [],
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.strictEqual(result.events[0].finishReasons, undefined);
         });
-        it('should filter out non-string values from finish_reasons array', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should filter out non-string values from finish_reasons array', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
                     attributes: {
                         'gen_ai.request.model': 'gpt-4',
-                        'gen_ai.response.finish_reasons': ['stop', 123, null, 'length'],
+                        'gen_ai.response.finish_reasons': ['stop', NON_STRING_FINISH_REASON, null, 'length'],
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.deepStrictEqual(result.events[0].finishReasons, ['stop', 'length']);
         });
-        it('should return undefined for invalid finish_reasons type', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should return undefined for invalid finish_reasons type', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -357,40 +305,40 @@ describe('queryLLMEvents', () => {
                         'gen_ai.response.finish_reasons': 123, // Invalid type
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             assert.strictEqual(result.events[0].finishReasons, undefined);
         });
-        it('should include gen_ai.request.temperature in response when present', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should include gen_ai.request.temperature in response when present', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
                     attributes: {
                         'gen_ai.request.model': 'claude-3',
-                        'gen_ai.request.temperature': 0.7,
+                        'gen_ai.request.temperature': TEMPERATURE_0_7,
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
-            assert.strictEqual(result.events[0].temperature, 0.7);
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
+            assert.strictEqual(result.events[0].temperature, TEMPERATURE_0_7);
         });
-        it('should include gen_ai.request.max_tokens in response when present', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should include gen_ai.request.max_tokens in response when present', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
                     attributes: {
                         'gen_ai.request.model': 'claude-3',
-                        'gen_ai.request.max_tokens': 4096,
+                        'gen_ai.request.max_tokens': MAX_TOKENS_4K,
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
-            assert.strictEqual(result.events[0].maxTokens, 4096);
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
+            assert.strictEqual(result.events[0].maxTokens, MAX_TOKENS_4K);
         });
-        it('should include all OTel GenAI recommended attributes together', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should include all OTel GenAI recommended attributes together', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -398,176 +346,65 @@ describe('queryLLMEvents', () => {
                         'gen_ai.request.model': 'claude-3-opus',
                         'gen_ai.response.model': 'claude-3-opus-20240229',
                         'gen_ai.response.finish_reasons': ['end_turn', 'tool_use'],
-                        'gen_ai.request.temperature': 0.5,
-                        'gen_ai.request.max_tokens': 8192,
+                        'gen_ai.request.temperature': TEMPERATURE_0_5,
+                        'gen_ai.request.max_tokens': MAX_TOKENS_8K,
                         'gen_ai.provider.name': 'anthropic',
                         'gen_ai.operation.name': 'chat',
                         'gen_ai.conversation.id': 'conv-xyz',
-                        'gen_ai.usage.input_tokens': 1000,
-                        'gen_ai.usage.output_tokens': 500,
+                        'gen_ai.usage.input_tokens': INPUT_TOKENS_1K,
+                        'gen_ai.usage.output_tokens': INPUT_TOKENS_500,
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
             const event = result.events[0];
             assert.strictEqual(event.model, 'claude-3-opus');
             assert.strictEqual(event.responseModel, 'claude-3-opus-20240229');
             assert.deepStrictEqual(event.finishReasons, ['end_turn', 'tool_use']);
-            assert.strictEqual(event.temperature, 0.5);
-            assert.strictEqual(event.maxTokens, 8192);
+            assert.strictEqual(event.temperature, TEMPERATURE_0_5);
+            assert.strictEqual(event.maxTokens, MAX_TOKENS_8K);
             assert.strictEqual(event.provider, 'anthropic');
             assert.strictEqual(event.operationName, 'chat');
             assert.strictEqual(event.conversationId, 'conv-xyz');
-            assert.strictEqual(event.inputTokens, 1000);
-            assert.strictEqual(event.outputTokens, 500);
+            assert.strictEqual(event.inputTokens, INPUT_TOKENS_1K);
+            assert.strictEqual(event.outputTokens, INPUT_TOKENS_500);
         });
     });
-    describe('multi-provider support', () => {
-        let originalQueryLLMEvents;
-        beforeEach(() => {
-            originalQueryLLMEvents = LocalJsonlBackend.prototype.queryLLMEvents;
-        });
-        afterEach(() => {
-            LocalJsonlBackend.prototype.queryLLMEvents = originalQueryLLMEvents;
-        });
-        it('should accept OpenAI provider and models', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: {
-                        'gen_ai.provider.name': 'openai',
-                        'gen_ai.request.model': 'gpt-4o',
-                        'gen_ai.usage.input_tokens': 500,
-                        'gen_ai.usage.output_tokens': 200,
-                        'gen_ai.response.finish_reasons': ['stop'],
-                    },
-                },
-            ]);
-            const result = await queryLLMEvents({ provider: 'openai' });
-            assert.strictEqual(result.events[0].provider, 'openai');
-            assert.strictEqual(result.events[0].model, 'gpt-4o');
-            assert.deepStrictEqual(result.events[0].finishReasons, ['stop']);
-        });
-        it('should accept Google Gemini provider and models', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: {
-                        'gen_ai.provider.name': 'gcp.gemini',
-                        'gen_ai.request.model': 'gemini-1.5-pro',
-                        'gen_ai.usage.input_tokens': 1000,
-                        'gen_ai.usage.output_tokens': 500,
-                    },
-                },
-            ]);
-            const result = await queryLLMEvents({ provider: 'gcp.gemini' });
-            assert.strictEqual(result.events[0].provider, 'gcp.gemini');
-            assert.strictEqual(result.events[0].model, 'gemini-1.5-pro');
-        });
-        it('should accept Mistral AI provider and models', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: {
-                        'gen_ai.provider.name': 'mistral_ai',
-                        'gen_ai.request.model': 'mistral-large',
-                        'gen_ai.usage.input_tokens': 800,
-                        'gen_ai.usage.output_tokens': 400,
-                    },
-                },
-            ]);
-            const result = await queryLLMEvents({ provider: 'mistral_ai' });
-            assert.strictEqual(result.events[0].provider, 'mistral_ai');
-            assert.strictEqual(result.events[0].model, 'mistral-large');
-        });
-        it('should accept Cohere provider and models', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: {
-                        'gen_ai.provider.name': 'cohere',
-                        'gen_ai.request.model': 'command-r-plus',
-                        'gen_ai.usage.input_tokens': 600,
-                        'gen_ai.usage.output_tokens': 300,
+    void describe('multi-provider support', () => {
+        function createMockBackend(queryFn) {
+            return { queryLLMEvents: queryFn };
+        }
+        const providerCases = [
+            { provider: 'openai', model: 'gpt-4o' },
+            { provider: 'gcp.gemini', model: 'gemini-1.5-pro' },
+            { provider: 'mistral_ai', model: 'mistral-large' },
+            { provider: 'cohere', model: 'command-r-plus' },
+            { provider: 'aws.bedrock', model: 'anthropic.claude-3-sonnet-20240229-v1:0' },
+            { provider: 'azure.ai.openai', model: 'gpt-4-deployment' },
+            { provider: 'groq', model: 'llama-3.3-70b' },
+            { provider: 'ollama', model: 'llama3:8b' },
+        ];
+        providerCases.forEach(({ provider, model }) => {
+            void it(`should pass through ${provider} provider and model`, async () => {
+                const mockBackend = createMockBackend(vi.fn(async () => [
+                    {
+                        timestamp: '2026-01-28T10:00:00Z',
+                        name: 'llm.completion',
+                        attributes: {
+                            'gen_ai.provider.name': provider,
+                            'gen_ai.request.model': model,
+                            'gen_ai.usage.input_tokens': 500,
+                            'gen_ai.usage.output_tokens': 200,
+                        },
                     },
-                },
-            ]);
-            const result = await queryLLMEvents({ provider: 'cohere' });
-            assert.strictEqual(result.events[0].provider, 'cohere');
-            assert.strictEqual(result.events[0].model, 'command-r-plus');
-        });
-        it('should accept AWS Bedrock provider', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: {
-                        'gen_ai.provider.name': 'aws.bedrock',
-                        'gen_ai.request.model': 'anthropic.claude-3-sonnet-20240229-v1:0',
-                        'gen_ai.usage.input_tokens': 1200,
-                        'gen_ai.usage.output_tokens': 600,
-                    },
-                },
-            ]);
-            const result = await queryLLMEvents({ provider: 'aws.bedrock' });
-            assert.strictEqual(result.events[0].provider, 'aws.bedrock');
-        });
-        it('should accept Azure OpenAI provider', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: {
-                        'gen_ai.provider.name': 'azure.ai.openai',
-                        'gen_ai.request.model': 'gpt-4-deployment',
-                        'gen_ai.usage.input_tokens': 700,
-                        'gen_ai.usage.output_tokens': 350,
-                    },
-                },
-            ]);
-            const result = await queryLLMEvents({ provider: 'azure.ai.openai' });
-            assert.strictEqual(result.events[0].provider, 'azure.ai.openai');
-        });
-        it('should accept Groq provider and models', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: {
-                        'gen_ai.provider.name': 'groq',
-                        'gen_ai.request.model': 'llama-3.3-70b',
-                        'gen_ai.usage.input_tokens': 400,
-                        'gen_ai.usage.output_tokens': 200,
-                    },
-                },
-            ]);
-            const result = await queryLLMEvents({ provider: 'groq' });
-            assert.strictEqual(result.events[0].provider, 'groq');
-            assert.strictEqual(result.events[0].model, 'llama-3.3-70b');
-        });
-        it('should accept Ollama provider for local models', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
-                {
-                    timestamp: '2026-01-28T10:00:00Z',
-                    name: 'llm.completion',
-                    attributes: {
-                        'gen_ai.provider.name': 'ollama',
-                        'gen_ai.request.model': 'llama3:8b',
-                        'gen_ai.usage.input_tokens': 300,
-                        'gen_ai.usage.output_tokens': 150,
-                    },
-                },
-            ]);
-            const result = await queryLLMEvents({ provider: 'ollama' });
-            assert.strictEqual(result.events[0].provider, 'ollama');
-            assert.strictEqual(result.events[0].model, 'llama3:8b');
+                ]));
+                const result = await queryLLMEvents({ backend: 'local', provider }, { localBackend: mockBackend });
+                assert.strictEqual(result.events[0].provider, provider);
+                assert.strictEqual(result.events[0].model, model);
+            });
         });
-        it('should summarize events by model across providers', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should summarize events by model across providers', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -600,15 +437,15 @@ describe('queryLLMEvents', () => {
                         'gen_ai.request.model': 'gpt-4o',
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({});
-            assert.strictEqual(result.count, 4);
+            ]));
+            const result = await queryLLMEvents({ backend: 'local' }, { localBackend: mockBackend });
+            assert.strictEqual(result.count, EXPECTED_MULTI_PROVIDER_COUNT);
             assert.strictEqual(result.summary.byModel['claude-3-opus'], 1);
-            assert.strictEqual(result.summary.byModel['gpt-4o'], 2);
+            assert.strictEqual(result.summary.byModel['gpt-4o'], EXPECTED_PAIR_COUNT);
             assert.strictEqual(result.summary.byModel['gemini-1.5-pro'], 1);
         });
-        it('should handle custom/unknown providers gracefully', async () => {
-            LocalJsonlBackend.prototype.queryLLMEvents = mock.fn(async () => [
+        void it('should handle custom/unknown providers gracefully', async () => {
+            const mockBackend = createMockBackend(vi.fn(async () => [
                 {
                     timestamp: '2026-01-28T10:00:00Z',
                     name: 'llm.completion',
@@ -617,8 +454,8 @@ describe('queryLLMEvents', () => {
                         'gen_ai.request.model': 'internal-model-v1',
                     },
                 },
-            ]);
-            const result = await queryLLMEvents({ provider: 'custom-internal-llm' });
+            ]));
+            const result = await queryLLMEvents({ backend: 'local', provider: 'custom-internal-llm' }, { localBackend: mockBackend });
             assert.strictEqual(result.events[0].provider, 'custom-internal-llm');
             assert.strictEqual(result.events[0].model, 'internal-model-v1');
         });