Usage summary and cost breakdown
No cost recorded this period.
Detailed call logs and per-model breakdown {lastUpdated && ( @@ -140,12 +191,24 @@ export function UsagePage() { {POLL_OPTIONS.map(o => ( setPollInterval(o.value)} + className={`btn btn-sm ${!liveMode && pollInterval === o.value ? 'btn-primary' : 'btn-secondary'}`} + onClick={() => { setLiveMode(false); setPollInterval(o.value); }} + disabled={liveMode} > {o.label} ))} + + ● Live + - {filteredRecords.map((r, i) => { + {filteredRecords.map((r) => { const isRouting = (r.callType ?? 'completion') === 'routing'; + const isNew = liveMode && newRowIds.has(r.id); return ( navigate(`/dashboard/usage/${r.id}`, { state: { record: r } })} > @@ -353,7 +423,7 @@ export function UsagePage() { {r.inputTokens} {r.outputTokens} - ${r.cost.toFixed(8)} + ${r.cost.toFixed(8)} {r.latencyMs}ms {r.ttftMs != null ? `${r.ttftMs}ms` : '—'} {r.tokensPerSec != null ? `${r.tokensPerSec}` : '—'} diff --git a/packages/dashboard/src/utils/traceUtils.ts b/packages/dashboard/src/utils/traceUtils.ts index aa425736..8ef26344 100644 --- a/packages/dashboard/src/utils/traceUtils.ts +++ b/packages/dashboard/src/utils/traceUtils.ts @@ -25,6 +25,7 @@ export interface MessageStats { outputPerMillion: number | null; hasError: boolean; errorMessage?: string; + fallbackUsed: boolean; cacheHit: boolean; cacheMiss: boolean; cacheSimilarity: number | null; @@ -51,6 +52,7 @@ export function extractMessageStats(traces: TraceEntry[]): MessageStats { inputPerMillion: null, outputPerMillion: null, hasError: false, + fallbackUsed: false, cacheHit: false, cacheMiss: false, cacheSimilarity: null, @@ -82,11 +84,16 @@ export function extractMessageStats(traces: TraceEntry[]): MessageStats { stats.outputPerMillion = success.details.outputPerMillion ?? null; } - // Check for errors - const error = traces.find((e) => e.message === 'model:error'); - if (error) { - stats.hasError = true; - stats.errorMessage = error.details?.error ?? error.details?.message ?? 'Unknown error'; + // Check for errors — only fatal if there's no subsequent model:success (fallback) + const errorEntry = traces.find((e) => e.message === 'model:error'); + const hasSuccess = traces.some((e) => e.message === 'model:success'); + if (errorEntry) { + stats.errorMessage = errorEntry.details?.error ?? errorEntry.details?.message ?? 'Unknown error'; + if (hasSuccess) { + stats.fallbackUsed = true; + } else { + stats.hasError = true; + } } // Check for cache hit/miss diff --git a/packages/service/package.json b/packages/service/package.json index 78ca24b6..660fc2d3 100644 --- a/packages/service/package.json +++ b/packages/service/package.json @@ -32,6 +32,7 @@ "@types/nodemailer": "^7.0.11", "@types/proper-lockfile": "^4.1.4", "@types/uuid": "^9.0.8", + "@vitest/coverage-v8": "^4.1.8", "tsx": "^4.7.3", "typescript": "^5.4.5", "vitest": "^4.1.8" diff --git a/packages/service/src/embeddings/openai.test.ts b/packages/service/src/embeddings/openai.test.ts index 89a3f67c..e481ebd0 100644 --- a/packages/service/src/embeddings/openai.test.ts +++ b/packages/service/src/embeddings/openai.test.ts @@ -63,4 +63,15 @@ describe('OpenAIEmbeddingProvider', () => { const provider = new OpenAIEmbeddingProvider(); await expect(provider.embed(['test'], 'model')).rejects.toThrow('api error'); }); + + it('returns 0 inputTokens when response.usage is undefined (line 23 ?? 0 branch)', async () => { + getMockCreate().mockResolvedValue({ + data: [{ embedding: [0.1, 0.2] }], + usage: undefined, + }); + + const provider = new OpenAIEmbeddingProvider(); + const result = await provider.embed(['text'], 'model'); + expect(result.inputTokens).toBe(0); + }); }); diff --git a/packages/service/src/notifications/sender.ts b/packages/service/src/notifications/sender.ts index 87e91e3f..06f4793a 100644 --- a/packages/service/src/notifications/sender.ts +++ b/packages/service/src/notifications/sender.ts @@ -161,7 +161,8 @@ async function sendGoogle(cfg: GoogleChannelConfig, to: string): Promise { expect(deltas).toEqual([' Hi', ' there']); expect(chunks.at(-1)!.choices[0]!.finish_reason).toBe('stop'); }); + + it('handles message_stop SSE event type', async () => { + const encoder = new TextEncoder() + const stopStream = new ReadableStream({ + start(controller) { + const data = [ + `data: ${JSON.stringify({ type: 'completion', completion: 'Hello', model: 'claude' })}\n\n`, + `data: ${JSON.stringify({ type: 'message_stop' })}\n\n`, + 'data: [DONE]\n\n', + ].join('') + controller.enqueue(encoder.encode(data)) + controller.close() + }, + }) + + vi.stubGlobal('fetch', makeFetchMock(stopStream)) + const adapter = new AnthropicWebAdapter() + const chunks: import('@routerly/shared').StreamChunk[] = [] + for await (const chunk of adapter.streamCompletion(makeRequest(), makeModel())) { + chunks.push(chunk) + } + expect(chunks.length).toBeGreaterThan(0) + }); + + it('handles sendCompletion 404 (invalidates cachedConvId)', async () => { + let callCount = 0 + vi.stubGlobal('fetch', vi.fn((url: string) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }) + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }) + } + callCount++ + // First completion call returns 404, second succeeds + if (callCount === 1) { + return Promise.resolve({ ok: false, status: 404, statusText: 'Not Found', headers: { get: () => null }, text: async () => '' }) + } + return Promise.resolve({ ok: true, body: makeSSEStream([completionEvent('ok')]) }) + })) + + const adapter = new AnthropicWebAdapter() + await expect(adapter.chatCompletion(makeRequest(), makeModel())).rejects.toThrow('HTTP 404') + }); +}); + +describe('AnthropicWebAdapter conversation creation failure', () => { + it('throws when conversation creation endpoint returns non-ok', async () => { + vi.stubGlobal('fetch', vi.fn((url: string) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }) + } + // conversation creation fails + return Promise.resolve({ ok: false, status: 503, statusText: 'Service Unavailable', text: async () => '' }) + })) + + const adapter = new AnthropicWebAdapter() + await expect(adapter.chatCompletion(makeRequest(), makeModel())).rejects.toThrow('HTTP 503') + }) +}) + +describe('AnthropicWebAdapter invalid JSON in SSE stream', () => { + it('skips invalid JSON lines (continue branch in parseSSE)', async () => { + const encoder = new TextEncoder() + const stream = new ReadableStream({ + start(controller) { + const data = [ + `data: not-valid-json\n\n`, + `data: ${JSON.stringify({ type: 'completion', completion: 'Hello', model: 'claude' })}\n\n`, + 'data: [DONE]\n\n', + ].join('') + controller.enqueue(encoder.encode(data)) + controller.close() + }, + }) + + vi.stubGlobal('fetch', makeFetchMock(stream)) + const adapter = new AnthropicWebAdapter() + const result = await adapter.chatCompletion(makeRequest(), makeModel()) + // Should still get the valid completion text + expect(result.choices[0]!.message.content).toBe('Hello') + }) +}) + +describe('AnthropicWebAdapter system prompt with non-string content', () => { + it('JSON stringifies non-string system message content', async () => { + const stream = makeSSEStream([completionEvent('ok')]) + + let capturedBody: any = null + vi.stubGlobal('fetch', vi.fn((url: string, opts: any) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }) + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }) + } + capturedBody = JSON.parse(opts.body) + return Promise.resolve({ ok: true, body: stream }) + })) + + const adapter = new AnthropicWebAdapter() + const request: ChatCompletionRequest = { + model: 'claude', messages: [ + { role: 'system', content: [{ type: 'text', text: 'system' }] as any }, + { role: 'user', content: 'hi' }, + ], + } + await adapter.chatCompletion(request, makeModel()) + expect(typeof capturedBody?.system_prompt).toBe('string') + }); +}); + +describe('AnthropicWebAdapter getUpstreamModelId branches', () => { + it('returns upstreamModelId directly when configured', async () => { + vi.stubGlobal('fetch', makeFetchMock(makeSSEStream([completionEvent('ok', 'claude-opus-4-5')]))); + + const adapter = new AnthropicWebAdapter(); + const model = makeModel({ upstreamModelId: 'claude-opus-4-5' }); + const result = await adapter.chatCompletion(makeRequest(), model); + expect(result.model).toBe('claude-opus-4-5'); + }); + + it('strips the provider prefix when model id contains a slash but has no upstreamModelId', async () => { + // makeSSEStream returns model '' via completionEvent default, so finalModel stays as upstreamModelId + vi.stubGlobal('fetch', makeFetchMock(makeSSEStream([completionEvent('ok', '')]))); + + const adapter = new AnthropicWebAdapter(); + // id = 'anthropic-web/claude-3-opus' → split gives ['anthropic-web', 'claude-3-opus'] → slice(1) → 'claude-3-opus' + const model = makeModel({ id: 'anthropic-web/claude-3-opus' } as any); + const result = await adapter.chatCompletion(makeRequest(), model); + expect(result.model).toBe('claude-3-opus'); + }); + + it('uses model id as-is when there is no slash and no upstreamModelId', async () => { + vi.stubGlobal('fetch', makeFetchMock(makeSSEStream([completionEvent('ok', '')]))); + + const adapter = new AnthropicWebAdapter(); + const model = makeModel({ id: 'claude-haiku' } as any); + const result = await adapter.chatCompletion(makeRequest(), model); + expect(result.model).toBe('claude-haiku'); + }); +}); + +describe('AnthropicWebAdapter baseUrl fallback', () => { + it('defaults to https://claude.ai when endpoint is not set', async () => { + vi.stubGlobal('fetch', vi.fn((url: string) => { + // Verify all requests go to the default base URL + expect((url as string).startsWith('https://claude.ai')).toBe(true); + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }); + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }); + } + return Promise.resolve({ ok: true, body: makeSSEStream([completionEvent('ok')]) }); + })); + + const adapter = new AnthropicWebAdapter(); + // No endpoint set → should use 'https://claude.ai' + const result = await adapter.chatCompletion(makeRequest(), makeModel({ endpoint: undefined } as any)); + expect(result.object).toBe('chat.completion'); + }); + + it('strips trailing slash from endpoint', async () => { + vi.stubGlobal('fetch', vi.fn((url: string) => { + // Should not have double slashes + expect((url as string)).not.toMatch(/claude\.ai\/\//); + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }); + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }); + } + return Promise.resolve({ ok: true, body: makeSSEStream([completionEvent('ok')]) }); + })); + + const adapter = new AnthropicWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel({ endpoint: 'https://claude.ai/' })); + expect(result.object).toBe('chat.completion'); + }); +}); + +describe('AnthropicWebAdapter getOrgId error with detail body', () => { + it('includes detail text in error message when org fetch fails with body', async () => { + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: false, + status: 403, + statusText: 'Forbidden', + text: () => Promise.resolve('session expired'), + })); + + const adapter = new AnthropicWebAdapter(); + await expect(adapter.chatCompletion(makeRequest(), makeModel())) + .rejects.toThrow('session expired'); + }); + + it('throws when organizations response is an empty array', async () => { + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: true, + json: () => Promise.resolve([]), + })); + + const adapter = new AnthropicWebAdapter(); + await expect(adapter.chatCompletion(makeRequest(), makeModel())) + .rejects.toThrow('no organizations found'); + }); + + it('throws when organizations response is not an array', async () => { + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: true, + json: () => Promise.resolve({ error: 'not an array' }), + })); + + const adapter = new AnthropicWebAdapter(); + await expect(adapter.chatCompletion(makeRequest(), makeModel())) + .rejects.toThrow('no organizations found'); + }); +}); + +describe('AnthropicWebAdapter getConvId error with detail body', () => { + it('includes detail text in error message when conversation creation fails with body', async () => { + vi.stubGlobal('fetch', vi.fn((url: string) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }); + } + // conversation creation fails with detail body + return Promise.resolve({ + ok: false, + status: 429, + statusText: 'Too Many Requests', + text: () => Promise.resolve('rate limit exceeded'), + }); + })); + + const adapter = new AnthropicWebAdapter(); + await expect(adapter.chatCompletion(makeRequest(), makeModel())) + .rejects.toThrow('rate limit exceeded'); + }); +}); + +describe('AnthropicWebAdapter sendCompletion with Retry-After header', () => { + it('includes retry-after value in error message', async () => { + vi.stubGlobal('fetch', vi.fn((url: string) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }); + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }); + } + return Promise.resolve({ + ok: false, + status: 429, + statusText: 'Too Many Requests', + headers: { get: (h: string) => h === 'Retry-After' ? '30' : null }, + text: () => Promise.resolve(''), + }); + })); + + const adapter = new AnthropicWebAdapter(); + await expect(adapter.chatCompletion(makeRequest(), makeModel())) + .rejects.toThrow('retry after 30s'); + }); + + it('includes both retry-after and detail in error message', async () => { + vi.stubGlobal('fetch', vi.fn((url: string) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }); + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }); + } + return Promise.resolve({ + ok: false, + status: 503, + statusText: 'Service Unavailable', + headers: { get: (h: string) => h === 'Retry-After' ? '60' : null }, + text: () => Promise.resolve('server overloaded'), + }); + })); + + const adapter = new AnthropicWebAdapter(); + const err = await adapter.chatCompletion(makeRequest(), makeModel()).catch(e => e); + expect(err.message).toMatch(/retry after 60s/); + expect(err.message).toMatch(/server overloaded/); + }); +}); + +describe('AnthropicWebAdapter empty response body', () => { + it('throws when chatCompletion response has no body', async () => { + vi.stubGlobal('fetch', vi.fn((url: string) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }); + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }); + } + return Promise.resolve({ ok: true, body: null }); + })); + + const adapter = new AnthropicWebAdapter(); + await expect(adapter.chatCompletion(makeRequest(), makeModel())) + .rejects.toThrow('empty response body'); + }); + + it('throws when streamCompletion response has no body', async () => { + vi.stubGlobal('fetch', vi.fn((url: string) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }); + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }); + } + return Promise.resolve({ ok: true, body: null }); + })); + + const adapter = new AnthropicWebAdapter(); + const gen = adapter.streamCompletion(makeRequest(), makeModel()); + await expect((gen as AsyncGenerator).next()).rejects.toThrow('empty response body'); + }); +}); + +describe('AnthropicWebAdapter buildPrompt branches', () => { + it('prefixes assistant messages with "Assistant:"', async () => { + let capturedBody: any = null; + vi.stubGlobal('fetch', vi.fn((url: string, opts: any) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }); + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }); + } + capturedBody = JSON.parse(opts.body); + return Promise.resolve({ ok: true, body: makeSSEStream([completionEvent('ok')]) }); + })); + + const adapter = new AnthropicWebAdapter(); + const request: ChatCompletionRequest = { + model: 'claude', + messages: [ + { role: 'user', content: 'Hello' }, + { role: 'assistant', content: 'Hi there' }, + { role: 'user', content: 'Follow up' }, + ], + }; + await adapter.chatCompletion(request, makeModel()); + expect(capturedBody?.prompt).toContain('Assistant: Hi there'); + expect(capturedBody?.prompt).toContain('Human: Hello'); + }); + + it('handles non-string user message content in buildPrompt', async () => { + let capturedBody: any = null; + vi.stubGlobal('fetch', vi.fn((url: string, opts: any) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }); + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }); + } + capturedBody = JSON.parse(opts.body); + return Promise.resolve({ ok: true, body: makeSSEStream([completionEvent('ok')]) }); + })); + + const adapter = new AnthropicWebAdapter(); + const request: ChatCompletionRequest = { + model: 'claude', + messages: [ + { role: 'user', content: [{ type: 'text', text: 'array content' }] as any }, + ], + }; + await adapter.chatCompletion(request, makeModel()); + // Non-string content should be JSON-stringified and prefixed with "Human:" + expect(capturedBody?.prompt).toContain('Human:'); + }); + + it('includes system message as plain content (no prefix) in buildPrompt', async () => { + let capturedBody: any = null; + vi.stubGlobal('fetch', vi.fn((url: string, opts: any) => { + if ((url as string).includes('/api/organizations') && !(url as string).includes('chat_conversations')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(ORGS_RESPONSE) }); + } + if ((url as string).includes('chat_conversations') && !(url as string).includes('completion')) { + return Promise.resolve({ ok: true, json: () => Promise.resolve(CONV_RESPONSE) }); + } + capturedBody = JSON.parse(opts.body); + return Promise.resolve({ ok: true, body: makeSSEStream([completionEvent('ok')]) }); + })); + + const adapter = new AnthropicWebAdapter(); + // When messages only has a system + user message, the system is filtered out for the prompt + // and the system_prompt field captures the system content. + // But when there are multiple system-role messages that pass through buildPrompt (via nonSystemMessages), + // the system role branch returns just the content without prefix. + // We test it by passing a system role message as a non-system in a custom way. + // Instead, verify prompt does NOT start with "Human:" or "Assistant:" for system messages + // by including a system message and checking system_prompt field is set. + const request: ChatCompletionRequest = { + model: 'claude', + messages: [ + { role: 'system', content: 'You are helpful' }, + { role: 'user', content: 'hi' }, + ], + }; + await adapter.chatCompletion(request, makeModel()); + expect(capturedBody?.system_prompt).toBe('You are helpful'); + // The prompt should only have the user message (system is filtered out for prompt building) + expect(capturedBody?.prompt).toBe('Human: hi'); + }); +}); + +describe('AnthropicWebAdapter SSE parseSSE edge cases', () => { + it('ignores completion events with empty delta', async () => { + const encoder = new TextEncoder(); + const stream = new ReadableStream({ + start(controller) { + // delta is empty string — should not yield a chunk for that event + const data = [ + `data: ${JSON.stringify({ type: 'completion', completion: '', model: 'claude' })}\n\n`, + `data: ${JSON.stringify({ type: 'completion', completion: 'Hello', model: 'claude' })}\n\n`, + 'data: [DONE]\n\n', + ].join(''); + controller.enqueue(encoder.encode(data)); + controller.close(); + }, + }); + + vi.stubGlobal('fetch', makeFetchMock(stream)); + const adapter = new AnthropicWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + // Only the non-empty delta should be accumulated + expect(result.choices[0]!.message.content).toBe('Hello'); + }); + + it('handles stream that ends without [DONE] or message_stop', async () => { + const encoder = new TextEncoder(); + const stream = new ReadableStream({ + start(controller) { + const data = `data: ${JSON.stringify({ type: 'completion', completion: 'partial', model: 'claude' })}\n\n`; + controller.enqueue(encoder.encode(data)); + controller.close(); + // No [DONE] — reader.read() will return done:true, hitting the `if (done) break` branch + }, + }); + + vi.stubGlobal('fetch', makeFetchMock(stream)); + const adapter = new AnthropicWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + expect(result.choices[0]!.message.content).toBe('partial'); + }); + + it('updates finalModel from SSE chunk model field in chatCompletion', async () => { + vi.stubGlobal('fetch', makeFetchMock(makeSSEStream([ + completionEvent('text', 'claude-updated-model'), + ]))); + + const adapter = new AnthropicWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + expect(result.model).toBe('claude-updated-model'); + }); + + it('updates finalModel from SSE chunk model field in streamCompletion', async () => { + vi.stubGlobal('fetch', makeFetchMock(makeSSEStream([ + completionEvent('text', 'claude-stream-model'), + ]))); + + const adapter = new AnthropicWebAdapter(); + const chunks: import('@routerly/shared').StreamChunk[] = []; + for await (const chunk of adapter.streamCompletion(makeRequest(), makeModel())) { + chunks.push(chunk); + } + // The model should be updated in the yielded chunks + const contentChunk = chunks.find(c => c.choices[0]!.delta.content); + expect(contentChunk?.model).toBe('claude-stream-model'); + }); }); diff --git a/packages/service/src/providers/openai-web.test.ts b/packages/service/src/providers/openai-web.test.ts index 162540c3..9f63c719 100644 --- a/packages/service/src/providers/openai-web.test.ts +++ b/packages/service/src/providers/openai-web.test.ts @@ -241,4 +241,862 @@ describe('OpenAIWebAdapter.cleanAnnotations (via SSE parsing)', () => { const result = await adapter.chatCompletion(makeRequest(), makeModel()); expect(result.choices[0]!.message.content).toBe(raw); }); + + it('throws when chatCompletion response body is null', async () => { + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: true, + body: null, + })); + + const adapter = new OpenAIWebAdapter(); + await expect(adapter.chatCompletion(makeRequest(), makeModel())).rejects.toThrow('empty response body'); + }); +}); + +describe('OpenAIWebAdapter sentinel proof-of-work required', () => { + it('includes proof token when proofofwork.required is true', async () => { + const sentinelResponse = { + ok: true, + json: vi.fn().mockResolvedValue({ + token: 'sentinel-tok-pow', + proofofwork: { required: true, seed: 'seed-abc', difficulty: 'ffffffffffffffff' }, + }), + } + const conversationResponse = { + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + } + const fetchMock = vi.fn() + .mockResolvedValueOnce(sentinelResponse) + .mockResolvedValueOnce(conversationResponse) + vi.stubGlobal('fetch', fetchMock) + + const adapter = new OpenAIWebAdapter() + await adapter.chatCompletion(makeRequest(), makeModel()) + + const [, conversationInit] = fetchMock.mock.calls[1] as [string, RequestInit] + const headers = conversationInit.headers as Record + expect(headers['Openai-Sentinel-Chat-Requirements-Token']).toBe('sentinel-tok-pow') + // Proof token header should be present + expect(headers['Openai-Sentinel-Proof-Token']).toBeDefined() + }) +}) + +describe('OpenAIWebAdapter invalid JSON in SSE stream', () => { + it('skips invalid JSON lines (continue branch in parseSSE)', async () => { + const encoder = new TextEncoder() + const streamWithBadJSON = new ReadableStream({ + start(controller) { + const data = [ + `data: not-valid-json\n\n`, + `data: ${sseEvent('Valid part')}\n\n`, + 'data: [DONE]\n\n', + ].join('') + controller.enqueue(encoder.encode(data)) + controller.close() + }, + }) + + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, body: streamWithBadJSON })) + + const adapter = new OpenAIWebAdapter() + const result = await adapter.chatCompletion(makeRequest(), makeModel()) + // Should get the valid content + expect(result.choices[0]!.message.content).toBe('Valid part') + }) +}) + +describe('OpenAIWebAdapter.streamCompletion errors', () => { + it('throws on HTTP error during streamCompletion', async () => { + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: false, + status: 403, + statusText: 'Forbidden', + text: async () => 'Access denied', + body: null, + })); + + const adapter = new OpenAIWebAdapter(); + const gen = adapter.streamCompletion(makeRequest(), makeModel()) + await expect(async () => { for await (const _ of gen) { /* consume */ } }).rejects.toThrow('HTTP 403') + }); + + it('throws when streamCompletion response body is null', async () => { + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: true, + body: null, + })); + + const adapter = new OpenAIWebAdapter(); + const gen = adapter.streamCompletion(makeRequest(), makeModel()) + await expect(async () => { for await (const _ of gen) { /* consume */ } }).rejects.toThrow('empty response body') + }); +}); + +describe('OpenAIWebAdapter branch coverage: line 56 — cfClearance cookie', () => { + it('sets Cookie header when cfClearance is provided', async () => { + const fetchMock = vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }); + vi.stubGlobal('fetch', fetchMock); + + const adapter = new OpenAIWebAdapter(); + await adapter.chatCompletion(makeRequest(), makeModel({ cfClearance: 'cf-test-value-abc123' })); + + // calls[0] = sentinel (GET), calls[1] = conversation (POST) + const [, conversationInit] = fetchMock.mock.calls[1] as [string, RequestInit]; + const headers = conversationInit.headers as Record; + expect(headers['Cookie']).toBe('cf_clearance=cf-test-value-abc123'); + }); +}); + +describe('OpenAIWebAdapter branch coverage: line 64 — getUpstreamModelId without slash', () => { + it('returns model.id as-is when it contains no slash and upstreamModelId is absent', async () => { + const fetchMock = vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }); + vi.stubGlobal('fetch', fetchMock); + + // model.id without "/" — should hit `return model.id` at line 64 + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion( + makeRequest(), + makeModel({ id: 'gpt-4o' }), + ); + + // The model returned should be the model_slug from SSE, or fallback to model.id + expect(result.object).toBe('chat.completion'); + + // Also verify the upstream model id used in the request body is 'gpt-4o' + const [, conversationInit] = fetchMock.mock.calls[1] as [string, RequestInit]; + const body = JSON.parse((conversationInit.body) as string) as Record; + expect(body['model']).toBe('gpt-4o'); + }); +}); + +describe('OpenAIWebAdapter branch coverage: lines 111-112 — generateProofToken fallback', () => { + it('uses fallback token when no nonce satisfies an impossibly strict difficulty', async () => { + // A 128-character difficulty of zeros is impossible to satisfy within 100k iterations, + // so generateProofToken will hit the fallback path at lines 111-112. + const impossibleDifficulty = '0'.repeat(128); + const sentinelResponse = { + ok: true, + json: vi.fn().mockResolvedValue({ + token: 'sentinel-tok-fallback', + proofofwork: { + required: true, + seed: 'test-seed-for-fallback', + difficulty: impossibleDifficulty, + }, + }), + }; + const conversationResponse = { + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }; + const fetchMock = vi.fn() + .mockResolvedValueOnce(sentinelResponse) + .mockResolvedValueOnce(conversationResponse); + vi.stubGlobal('fetch', fetchMock); + + const adapter = new OpenAIWebAdapter(); + await adapter.chatCompletion(makeRequest(), makeModel()); + + const [, conversationInit] = fetchMock.mock.calls[1] as [string, RequestInit]; + const headers = conversationInit.headers as Record; + // The proof token should start with the fallback prefix + expect(headers['Openai-Sentinel-Proof-Token']).toMatch(/^gAAAAABwQ8Lk5FbGpA2NcR9dShT6gYjU7VxZ4D/); + }); +}); + +describe('OpenAIWebAdapter branch coverage: line 265 — parseSSE stream ends without [DONE]', () => { + it('handles a stream that closes without a [DONE] marker', async () => { + // Build a stream that sends SSE content but no [DONE] line. + // The reader.read() will return done=true, hitting the `if (done) break` path (line 255) + // and the generator returns normally without yielding the done sentinel. + const encoder = new TextEncoder(); + const streamNoDone = new ReadableStream({ + start(controller) { + controller.enqueue(encoder.encode(`data: ${sseEvent('No done marker')}\n\n`)); + controller.close(); + }, + }); + + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, body: streamNoDone })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + expect(result.choices[0]!.message.content).toBe('No done marker'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 62 — upstreamModelId explicitly set +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter branch coverage: line 62 — upstreamModelId explicitly set', () => { + it('uses model.upstreamModelId when provided', async () => { + const fetchMock = vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }); + vi.stubGlobal('fetch', fetchMock); + + const adapter = new OpenAIWebAdapter(); + await adapter.chatCompletion( + makeRequest(), + makeModel({ id: 'openai-web/gpt-4o', upstreamModelId: 'gpt-4o-upstream' }), + ); + + const [, conversationInit] = fetchMock.mock.calls[1] as [string, RequestInit]; + const body = JSON.parse((conversationInit.body) as string) as Record; + expect(body['model']).toBe('gpt-4o-upstream'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 140 — sentinel returns no token (data.token falsy) +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter branch coverage: line 140 — sentinel returns no token', () => { + it('proceeds without sentinel header when data.token is absent', async () => { + const sentinelResponse = { + ok: true, + json: vi.fn().mockResolvedValue({ proofofwork: { required: false } }), + }; + const conversationResponse = { + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }; + const fetchMock = vi.fn() + .mockResolvedValueOnce(sentinelResponse) + .mockResolvedValueOnce(conversationResponse); + vi.stubGlobal('fetch', fetchMock); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + + const [, conversationInit] = fetchMock.mock.calls[1] as [string, RequestInit]; + const headers = conversationInit.headers as Record; + expect(headers['Openai-Sentinel-Chat-Requirements-Token']).toBeUndefined(); + expect(result.object).toBe('chat.completion'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for lines 166 & 169 — assistant role and non-string content +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter branch coverage: line 166 — assistant role in buildMessages', () => { + it('maps assistant messages to role="assistant"', async () => { + const fetchMock = vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }); + vi.stubGlobal('fetch', fetchMock); + + const adapter = new OpenAIWebAdapter(); + await adapter.chatCompletion( + { + model: 'gpt-4o', + messages: [ + { role: 'user', content: 'Hello' }, + { role: 'assistant', content: 'World' }, + { role: 'user', content: 'Again' }, + ], + }, + makeModel(), + ); + + const [, conversationInit] = fetchMock.mock.calls[1] as [string, RequestInit]; + const body = JSON.parse((conversationInit.body) as string) as Record; + const messages = body['messages'] as Array<{ author: { role: string }; content: { parts: string[] } }>; + expect(messages[1]!.author.role).toBe('assistant'); + }); +}); + +describe('OpenAIWebAdapter branch coverage: line 169 — non-string message content', () => { + it('JSON.stringifies non-string message content', async () => { + const fetchMock = vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }); + vi.stubGlobal('fetch', fetchMock); + + const adapter = new OpenAIWebAdapter(); + // Pass content as an array (multimodal-style), which is non-string + await adapter.chatCompletion( + { + model: 'gpt-4o', + messages: [{ role: 'user', content: [{ type: 'text', text: 'Hi' }] as unknown as string }], + }, + makeModel(), + ); + + const [, conversationInit] = fetchMock.mock.calls[1] as [string, RequestInit]; + const body = JSON.parse((conversationInit.body) as string) as Record; + const messages = body['messages'] as Array<{ content: { parts: string[] } }>; + expect(typeof messages[0]!.content.parts[0]).toBe('string'); + // Should be JSON.stringify of the array + expect(messages[0]!.content.parts[0]).toContain('text'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 184 — non-string system message content +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter branch coverage: line 184 — non-string system message content', () => { + it('JSON.stringifies non-string systemMessage.content', async () => { + const fetchMock = vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }); + vi.stubGlobal('fetch', fetchMock); + + const adapter = new OpenAIWebAdapter(); + await adapter.chatCompletion( + { + model: 'gpt-4o', + messages: [ + { role: 'system', content: [{ type: 'text', text: 'system' }] as unknown as string }, + { role: 'user', content: 'Hello' }, + ], + }, + makeModel(), + ); + + const [, conversationInit] = fetchMock.mock.calls[1] as [string, RequestInit]; + const body = JSON.parse((conversationInit.body) as string) as Record; + expect(typeof body['system_prompt']).toBe('string'); + expect((body['system_prompt'] as string)).toContain('text'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 210 — MARKER followed by non-{ character +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter cleanAnnotations: MARKER not followed by {', () => { + it('skips annotation when MARKER is not followed by {', async () => { + const MARKER = '\u{1F523}'; + // Place MARKER followed by non-{ character — should be skipped + const raw = `Hello${MARKER}not-json world`; + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent(raw)]), + })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + // The MARKER and trailing text should remain (not cleaned), but no crash + expect(result.choices[0]!.message.content).toContain('Hello'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 219 — unclosed braces (depth !== 0) +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter cleanAnnotations: unclosed JSON braces', () => { + it('skips annotation when braces are not balanced', async () => { + const MARKER = '\u{1F523}'; + // MARKER + { unclosed — depth will be nonzero at end of string + const raw = `Hello${MARKER}{"key": {"nested": "open" world`; + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent(raw)]), + })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + expect(result.choices[0]!.message.content).toContain('Hello'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 221 — closing MARKER check fails (no trailing MARKER) +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter cleanAnnotations: closing MARKER absent', () => { + it('skips annotation when closing MARKER is absent after JSON', async () => { + const MARKER = '\u{1F523}'; + // MARKER + valid JSON but no closing MARKER + const raw = `Hello${MARKER}{"key": {"content": "x"}} world`; + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent(raw)]), + })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + expect(result.choices[0]!.message.content).toContain('Hello'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 227 — Object.keys(ann)[0] is undefined (empty object) +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter cleanAnnotations: empty annotation object', () => { + it('handles empty annotation object gracefully', async () => { + const MARKER = '\u{1F523}'; + // Valid JSON but empty object — Object.keys(ann)[0] === undefined, key = '' + const raw = `Hello${MARKER}{}${MARKER} world`; + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent(raw)]), + })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + // Empty object → empty key → no math prefix match → silently dropped + expect(result.choices[0]!.message.content).toBe('Hello world'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 229 — inner.content is undefined +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter cleanAnnotations: annotation with no content field', () => { + it('treats missing content as empty string', async () => { + const MARKER = '\u{1F523}'; + // Annotation with key but inner has no "content" field + const raw = `Before${MARKER}${JSON.stringify({ math_inline_widget_v1: { other: 'x' } })}${MARKER}After`; + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent(raw)]), + })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + // math_inline_widget with no content → replacement = '$$' + expect(result.choices[0]!.message.content).toBe('Before$$After'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 274 — SSE message field is undefined +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter parseSSE: no message field in SSE data', () => { + it('skips SSE events without a message field', async () => { + const encoder = new TextEncoder(); + const stream = new ReadableStream({ + start(controller) { + const lines = [ + `data: ${JSON.stringify({ other: 'data' })}\n\n`, + `data: ${sseEvent('Real content')}\n\n`, + 'data: [DONE]\n\n', + ].join(''); + controller.enqueue(encoder.encode(lines)); + controller.close(); + }, + }); + + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, body: stream })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + expect(result.choices[0]!.message.content).toBe('Real content'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for lines 276 & 279 — status not in_progress/finished_successfully +// and parts not an array +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter parseSSE: unrecognised status skipped', () => { + it('skips SSE events whose status is not in_progress or finished_successfully', async () => { + const encoder = new TextEncoder(); + const eventWithWrongStatus = JSON.stringify({ + message: { + status: 'created', + content: { content_type: 'text', parts: ['ignored'] }, + metadata: { model_slug: 'gpt-4o' }, + }, + }); + const stream = new ReadableStream({ + start(controller) { + const lines = [ + `data: ${eventWithWrongStatus}\n\n`, + `data: ${sseEvent('Good content')}\n\n`, + 'data: [DONE]\n\n', + ].join(''); + controller.enqueue(encoder.encode(lines)); + controller.close(); + }, + }); + + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, body: stream })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + expect(result.choices[0]!.message.content).toBe('Good content'); + }); +}); + +describe('OpenAIWebAdapter parseSSE: parts field missing or not array', () => { + it('skips SSE events when content.parts is not an array', async () => { + const encoder = new TextEncoder(); + const eventNoArray = JSON.stringify({ + message: { + status: 'in_progress', + content: { content_type: 'text', parts: 'not-an-array' }, + metadata: { model_slug: 'gpt-4o' }, + }, + }); + const stream = new ReadableStream({ + start(controller) { + const lines = [ + `data: ${eventNoArray}\n\n`, + `data: ${sseEvent('Real text')}\n\n`, + 'data: [DONE]\n\n', + ].join(''); + controller.enqueue(encoder.encode(lines)); + controller.close(); + }, + }); + + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, body: stream })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + expect(result.choices[0]!.message.content).toBe('Real text'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 284 — model_slug absent (metadata.model_slug undefined) +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter parseSSE: model_slug absent in metadata', () => { + it('yields empty model string when model_slug is missing', async () => { + const encoder = new TextEncoder(); + const eventNoSlug = JSON.stringify({ + message: { + status: 'in_progress', + content: { content_type: 'text', parts: ['text with no slug'] }, + metadata: {}, + }, + }); + const stream = new ReadableStream({ + start(controller) { + const lines = [ + `data: ${eventNoSlug}\n\n`, + 'data: [DONE]\n\n', + ].join(''); + controller.enqueue(encoder.encode(lines)); + controller.close(); + }, + }); + + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, body: stream })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel({ upstreamModelId: 'fallback-model' })); + // model_slug is '' so finalModel stays as upstreamModelId + expect(result.model).toBe('fallback-model'); + expect(result.choices[0]!.message.content).toBe('text with no slug'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 299 — model.endpoint falsy (uses default https://chatgpt.com) +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter branch coverage: line 299 — default endpoint', () => { + it('uses https://chatgpt.com when model.endpoint is undefined', async () => { + const fetchMock = vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }); + vi.stubGlobal('fetch', fetchMock); + + const adapter = new OpenAIWebAdapter(); + // makeModel without endpoint override — endpoint defaults to 'https://chatgpt.com' in makeModel, + // but we need it absent so we use an object spread omitting 'endpoint' + const modelNoEndpoint = { ...makeModel(), endpoint: 'https://chatgpt.com' }; + // Actually use a model that has no endpoint key — we can just use makeModel() since its default IS chatgpt.com + // For this test to hit the `|| 'https://chatgpt.com'` branch we need endpoint to be falsy (empty string) + await adapter.chatCompletion(makeRequest(), { ...makeModel(), endpoint: '' }); + + // sentinel call goes to default base URL (empty string → falls back to 'https://chatgpt.com') + const [sentinelUrl] = fetchMock.mock.calls[0] as [string, RequestInit]; + expect(sentinelUrl).toContain('https://chatgpt.com'); + const [conversationUrl] = fetchMock.mock.calls[1] as [string, RequestInit]; + expect(conversationUrl).toBe('https://chatgpt.com/backend-api/conversation'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 316 — chatCompletion HTTP error with empty detail +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter chatCompletion: HTTP error with empty response text', () => { + it('throws error without " — " suffix when response text is empty', async () => { + vi.stubGlobal('fetch', vi.fn() + .mockResolvedValueOnce({ + ok: true, + json: vi.fn().mockResolvedValue({}), + }) + .mockResolvedValueOnce({ + ok: false, + status: 429, + statusText: 'Too Many Requests', + text: () => Promise.resolve(''), + })); + + const adapter = new OpenAIWebAdapter(); + let caught: Error | undefined; + await adapter.chatCompletion(makeRequest(), makeModel()).catch((e: Error) => { caught = e; }); + expect(caught).toBeDefined(); + expect(caught!.message).toContain('HTTP 429 Too Many Requests'); + expect(caught!.message).not.toContain(' — '); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 328 — chunk.model falsy in chatCompletion +// (SSE events with empty model_slug don't update finalModel) +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter chatCompletion: chunk.model falsy keeps upstreamModelId', () => { + it('retains upstreamModelId when SSE chunks have no model_slug', async () => { + const encoder = new TextEncoder(); + const eventNoSlug = JSON.stringify({ + message: { + status: 'in_progress', + content: { content_type: 'text', parts: ['response text'] }, + metadata: {}, // no model_slug + }, + }); + const stream = new ReadableStream({ + start(controller) { + controller.enqueue(encoder.encode(`data: ${eventNoSlug}\n\ndata: [DONE]\n\n`)); + controller.close(); + }, + }); + + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, body: stream })); + + const adapter = new OpenAIWebAdapter(); + const result = await adapter.chatCompletion(makeRequest(), makeModel({ upstreamModelId: 'my-model' })); + expect(result.model).toBe('my-model'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 356 — streamCompletion default endpoint +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter streamCompletion: default endpoint when model.endpoint falsy', () => { + it('uses https://chatgpt.com as default endpoint in streamCompletion', async () => { + const fetchMock = vi.fn().mockResolvedValue({ + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }); + vi.stubGlobal('fetch', fetchMock); + + const adapter = new OpenAIWebAdapter(); + const chunks = []; + for await (const chunk of adapter.streamCompletion(makeRequest(), { ...makeModel(), endpoint: '' })) { + chunks.push(chunk); + } + + const [conversationUrl] = fetchMock.mock.calls[1] as [string, RequestInit]; + expect(conversationUrl).toBe('https://chatgpt.com/backend-api/conversation'); + expect(chunks.length).toBeGreaterThan(0); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 373 — streamCompletion HTTP error with empty detail +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter streamCompletion: HTTP error with empty response text', () => { + it('throws error without " — " suffix when response text is empty in streamCompletion', async () => { + vi.stubGlobal('fetch', vi.fn() + .mockResolvedValueOnce({ + ok: true, + json: vi.fn().mockResolvedValue({}), + }) + .mockResolvedValueOnce({ + ok: false, + status: 503, + statusText: 'Service Unavailable', + text: () => Promise.resolve(''), + })); + + const adapter = new OpenAIWebAdapter(); + let errorMessage = ''; + const gen = adapter.streamCompletion(makeRequest(), makeModel()); + await (async () => { + for await (const _ of gen) { /* consume */ } + })().catch((e: Error) => { errorMessage = e.message; }); + + expect(errorMessage).toContain('HTTP 503 Service Unavailable'); + expect(errorMessage).not.toContain(' — '); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 386 — chunk.model falsy in streamCompletion +// and line 390 — delta is empty (no new content) +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter streamCompletion: chunk.model falsy keeps upstreamModelId', () => { + it('retains upstreamModelId when SSE chunks have no model_slug in streamCompletion', async () => { + const encoder = new TextEncoder(); + const eventNoSlug = JSON.stringify({ + message: { + status: 'in_progress', + content: { content_type: 'text', parts: ['hello'] }, + metadata: {}, // no model_slug → chunk.model === '' + }, + }); + const stream = new ReadableStream({ + start(controller) { + controller.enqueue(encoder.encode(`data: ${eventNoSlug}\n\ndata: [DONE]\n\n`)); + controller.close(); + }, + }); + + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, body: stream })); + + const adapter = new OpenAIWebAdapter(); + const chunks = []; + for await (const chunk of adapter.streamCompletion(makeRequest(), makeModel({ upstreamModelId: 'kept-model' }))) { + chunks.push(chunk); + } + // All content chunks should use the kept model + const contentChunks = chunks.filter(c => c.choices[0]!.delta.content); + expect(contentChunks.every(c => c.model === 'kept-model')).toBe(true); + }); +}); + +describe('OpenAIWebAdapter streamCompletion: empty delta not emitted', () => { + it('does not emit a content chunk when delta is empty (same text repeated)', async () => { + const encoder = new TextEncoder(); + // Two events with identical text — second delta would be '' + const event1 = JSON.stringify({ + message: { + status: 'in_progress', + content: { content_type: 'text', parts: ['hello'] }, + metadata: { model_slug: 'gpt-4o' }, + }, + }); + // Same text again — delta would be '' + const event2 = JSON.stringify({ + message: { + status: 'in_progress', + content: { content_type: 'text', parts: ['hello'] }, + metadata: { model_slug: 'gpt-4o' }, + }, + }); + const stream = new ReadableStream({ + start(controller) { + controller.enqueue(encoder.encode(`data: ${event1}\n\ndata: ${event2}\n\ndata: [DONE]\n\n`)); + controller.close(); + }, + }); + + vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, body: stream })); + + const adapter = new OpenAIWebAdapter(); + const chunks = []; + for await (const chunk of adapter.streamCompletion(makeRequest(), makeModel())) { + chunks.push(chunk); + } + // Only 1 content chunk (for 'hello'), then 1 stop chunk — no duplicate empty delta + const contentChunks = chunks.filter(c => c.choices[0]!.delta.content); + expect(contentChunks.length).toBe(1); + expect(contentChunks[0]!.choices[0]!.delta.content).toBe('hello'); + }); +}); + +// --------------------------------------------------------------------------- +// Branch coverage for line 316 true branch — chatCompletion HTTP error with non-empty detail +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter chatCompletion: HTTP error with non-empty detail', () => { + it('includes " — detail" in error message when response body is non-empty', async () => { + vi.stubGlobal('fetch', vi.fn() + .mockResolvedValueOnce({ + ok: true, + json: vi.fn().mockResolvedValue({}), + }) + .mockResolvedValueOnce({ + ok: false, + status: 401, + statusText: 'Unauthorized', + text: () => Promise.resolve('invalid token provided'), + })); + + const adapter = new OpenAIWebAdapter(); + let caught: Error | undefined; + await adapter.chatCompletion(makeRequest(), makeModel()).catch((e: Error) => { caught = e; }); + expect(caught).toBeDefined(); + expect(caught!.message).toContain('HTTP 401 Unauthorized'); + expect(caught!.message).toContain(' — invalid token provided'); + }); +}); + +// --------------------------------------------------------------------------- +// Function coverage: .catch(() => '') callbacks on response.text() +// lines 132, 315, 372 — response.text() rejects +// --------------------------------------------------------------------------- +describe('OpenAIWebAdapter: response.text() rejects — catch(() => \'\') callbacks', () => { + it('chatCompletion uses empty detail when response.text() throws', async () => { + vi.stubGlobal('fetch', vi.fn() + .mockResolvedValueOnce({ + ok: true, + json: vi.fn().mockResolvedValue({}), + }) + .mockResolvedValueOnce({ + ok: false, + status: 500, + statusText: 'Internal Server Error', + text: () => Promise.reject(new Error('stream error')), + })); + + const adapter = new OpenAIWebAdapter(); + let caught: Error | undefined; + await adapter.chatCompletion(makeRequest(), makeModel()).catch((e: Error) => { caught = e; }); + expect(caught).toBeDefined(); + expect(caught!.message).toContain('HTTP 500 Internal Server Error'); + // detail is '' because text() threw — no " — " suffix + expect(caught!.message).not.toContain(' — '); + }); + + it('streamCompletion uses empty detail when response.text() throws', async () => { + vi.stubGlobal('fetch', vi.fn() + .mockResolvedValueOnce({ + ok: true, + json: vi.fn().mockResolvedValue({}), + }) + .mockResolvedValueOnce({ + ok: false, + status: 500, + statusText: 'Internal Server Error', + text: () => Promise.reject(new Error('stream error')), + })); + + const adapter = new OpenAIWebAdapter(); + let errorMessage = ''; + const gen = adapter.streamCompletion(makeRequest(), makeModel()); + await (async () => { + for await (const _ of gen) { /* consume */ } + })().catch((e: Error) => { errorMessage = e.message; }); + + expect(errorMessage).toContain('HTTP 500 Internal Server Error'); + expect(errorMessage).not.toContain(' — '); + }); + + it('sentinel getSentinelHeaders uses empty body when response.text() throws', async () => { + // Make sentinel response non-ok and text() throw + // This covers line 132: .catch(() => '') + const fetchMock = vi.fn() + .mockResolvedValueOnce({ + ok: false, + status: 403, + statusText: 'Forbidden', + text: () => Promise.reject(new Error('text error')), + }) + .mockResolvedValueOnce({ + ok: true, + body: makeSSEStream([sseEvent('Hi')]), + }); + vi.stubGlobal('fetch', fetchMock); + + const adapter = new OpenAIWebAdapter(); + // Should not throw — sentinel failure is graceful, returns {} + const result = await adapter.chatCompletion(makeRequest(), makeModel()); + expect(result.object).toBe('chat.completion'); + }); }); diff --git a/packages/service/src/providers/openai.test.ts b/packages/service/src/providers/openai.test.ts new file mode 100644 index 00000000..76065f5b --- /dev/null +++ b/packages/service/src/providers/openai.test.ts @@ -0,0 +1,205 @@ +import { describe, it, expect, vi, afterEach } from 'vitest'; +import { OpenAIAdapter } from './openai.js'; +import type { ChatCompletionRequest, ModelConfig } from '@routerly/shared'; + +const create = vi.hoisted(() => vi.fn()); + +vi.mock('openai', () => { + class OpenAIMock { + chat = { completions: { create } }; + } + return { default: OpenAIMock }; +}); + +afterEach(() => vi.clearAllMocks()); + +function makeModel(overrides: Partial = {}): ModelConfig { + return { + id: 'openai/gpt-4o', + name: 'GPT-4o', + provider: 'openai', + endpoint: 'https://api.openai.com/v1', + apiKey: 'sk-test', + cost: { inputPerMillion: 5, outputPerMillion: 15 }, + ...overrides, + }; +} + +function makeResponse() { + return { + id: 'chatcmpl-test', + object: 'chat.completion', + created: 1700000000, + model: 'gpt-4o', + choices: [{ index: 0, message: { role: 'assistant', content: 'Hi' }, finish_reason: 'stop' }], + usage: { prompt_tokens: 5, completion_tokens: 3, total_tokens: 8 }, + }; +} + +describe('OpenAIAdapter.chatCompletion', () => { + it('strips the `input` field before forwarding to Chat Completions API', async () => { + create.mockResolvedValue(makeResponse()); + + const adapter = new OpenAIAdapter(); + const request: ChatCompletionRequest = { + model: 'gpt-4o', + messages: [{ role: 'user', content: 'Hello' }], + input: [{ role: 'user', content: 'Hello' }], // simulate /v1/responses leak + }; + + await adapter.chatCompletion(request, makeModel()); + + const calledWith = create.mock.calls[0]?.[0] as Record; + expect(calledWith).not.toHaveProperty('input'); + expect(calledWith).toHaveProperty('messages'); + }); + + it('strips `stream` before forwarding (forces stream: false for non-streaming call)', async () => { + create.mockResolvedValue(makeResponse()); + + const adapter = new OpenAIAdapter(); + await adapter.chatCompletion( + { model: 'gpt-4o', messages: [{ role: 'user', content: 'Hi' }], stream: true }, + makeModel(), + ); + + const calledWith = create.mock.calls[0]?.[0] as Record; + expect(calledWith).toHaveProperty('stream', false); + }); + + it('normalises max_tokens → max_completion_tokens', async () => { + create.mockResolvedValue(makeResponse()); + + const adapter = new OpenAIAdapter(); + await adapter.chatCompletion( + { model: 'gpt-4o', messages: [{ role: 'user', content: 'Hi' }], max_tokens: 512 }, + makeModel(), + ); + + const calledWith = create.mock.calls[0]?.[0] as Record; + expect(calledWith).not.toHaveProperty('max_tokens'); + expect(calledWith).toHaveProperty('max_completion_tokens', 512); + }); + + it('strips reasoning params for non-o-series models', async () => { + create.mockResolvedValue(makeResponse()); + + const adapter = new OpenAIAdapter(); + await adapter.chatCompletion( + { + model: 'gpt-4o', + messages: [{ role: 'user', content: 'Hi' }], + reasoning_effort: 'high', + reasoning_summary: 'auto', + } as ChatCompletionRequest, + makeModel(), + ); + + const calledWith = create.mock.calls[0]?.[0] as Record; + expect(calledWith).not.toHaveProperty('reasoning_effort'); + expect(calledWith).not.toHaveProperty('reasoning_summary'); + }); + + it('keeps reasoning params for o-series models', async () => { + create.mockResolvedValue(makeResponse()); + const adapter = new OpenAIAdapter(); + await adapter.chatCompletion( + { model: 'o1-mini', messages: [{ role: 'user', content: 'Hi' }], reasoning_effort: 'high' } as any, + makeModel({ id: 'o1-mini' }), + ); + const calledWith = create.mock.calls[0]?.[0] as Record; + expect(calledWith).toHaveProperty('reasoning_effort', 'high') + expect(calledWith).toHaveProperty('model', 'o1-mini') + }); + + it('uses model.id as-is when no slash present', async () => { + create.mockResolvedValue(makeResponse()); + const adapter = new OpenAIAdapter(); + await adapter.chatCompletion( + { model: 'gpt-4o', messages: [{ role: 'user', content: 'Hi' }] }, + makeModel({ id: 'gpt-4o' }), + ); + const calledWith = create.mock.calls[0]?.[0] as Record; + expect(calledWith).toHaveProperty('model', 'gpt-4o') + }); + + it('passes through when neither max_tokens nor max_completion_tokens are set', async () => { + create.mockResolvedValue(makeResponse()); + const adapter = new OpenAIAdapter(); + await adapter.chatCompletion({ model: 'gpt-4o', messages: [] }, makeModel()) + const calledWith = create.mock.calls[0]?.[0] as Record; + expect(calledWith).not.toHaveProperty('max_tokens') + expect(calledWith).not.toHaveProperty('max_completion_tokens') + }); +}); + +describe('OpenAIAdapter.streamCompletion', () => { + it('yields chunks from the stream', async () => { + const chunks = [{ choices: [{ delta: { content: 'hello' } }] }] + create.mockReturnValue({ [Symbol.asyncIterator]: async function* () { for (const c of chunks) yield c } }) + const adapter = new OpenAIAdapter() + const received: any[] = [] + for await (const chunk of adapter.streamCompletion({ model: 'gpt-4o', messages: [] }, makeModel())) { + received.push(chunk) + } + expect(received).toHaveLength(1) + expect(received[0].choices[0].delta.content).toBe('hello') + }); +}); + +describe('OpenAIAdapter.messages', () => { + it('converts MessagesRequest to OpenAI format and returns response', async () => { + create.mockResolvedValue({ + id: 'cmpl-1', model: 'gpt-4o', + choices: [{ message: { content: 'Hi' }, finish_reason: 'stop' }], + usage: { prompt_tokens: 5, completion_tokens: 3 }, + }) + const adapter = new OpenAIAdapter() + const result = await adapter.messages({ + model: 'gpt-4o', max_tokens: 100, + messages: [{ role: 'user', content: 'Hello' }], + }, makeModel()) + expect(result.content[0]).toMatchObject({ type: 'text' }) + }); + + it('includes system message when provided', async () => { + create.mockResolvedValue({ + id: 'c2', model: 'gpt-4o', + choices: [{ message: { content: 'ok' }, finish_reason: 'stop' }], + usage: { prompt_tokens: 5, completion_tokens: 2 }, + }) + const adapter = new OpenAIAdapter() + await adapter.messages({ + model: 'gpt-4o', max_tokens: 50, + messages: [{ role: 'user', content: 'Hi' }], + system: 'You are helpful.', + }, makeModel()) + const msgs = (create.mock.calls[0]![0] as any).messages + expect(msgs[0].role).toBe('system') + expect(msgs[0].content).toBe('You are helpful.') + }); + + it('uses empty string for apiKey when model.apiKey is undefined (line 15 ?? branch)', async () => { + create.mockResolvedValueOnce({ + id: 'c-no-key', model: 'gpt-4o', + choices: [{ message: { content: 'ok' }, finish_reason: 'stop' }], + usage: { prompt_tokens: 1, completion_tokens: 1 }, + }) + const adapter = new OpenAIAdapter() + const modelNoKey: any = { ...makeModel(), apiKey: undefined } + await adapter.chatCompletion({ messages: [{ role: 'user', content: 'Hi' }] } as any, modelNoKey) + expect(create).toHaveBeenCalled() + }); + + it('uses default endpoint when model.endpoint is falsy (line 18 || branch)', async () => { + create.mockResolvedValueOnce({ + id: 'c-no-ep', model: 'gpt-4o', + choices: [{ message: { content: 'ok' }, finish_reason: 'stop' }], + usage: { prompt_tokens: 1, completion_tokens: 1 }, + }) + const adapter = new OpenAIAdapter() + const modelNoEp: any = { ...makeModel(), endpoint: '' } + await adapter.chatCompletion({ messages: [{ role: 'user', content: 'Hi' }] } as any, modelNoEp) + expect(create).toHaveBeenCalled() + }); +}); diff --git a/packages/service/src/providers/openai.ts b/packages/service/src/providers/openai.ts index a9644b68..a21ab30d 100644 --- a/packages/service/src/providers/openai.ts +++ b/packages/service/src/providers/openai.ts @@ -45,13 +45,13 @@ export class OpenAIAdapter implements ProviderAdapter { // Strip reasoning-model-only params when forwarding to non-o-series models. private normalizeForModel(req: ChatCompletionRequest, upstreamModel: string): Record { - const { stream: _stream, ...normalized } = this.normalizeTokenLimit(req); + const { stream: _stream, input: _input, ...normalized } = this.normalizeTokenLimit(req) as Record; if (!this.isReasoningModel(upstreamModel)) { // eslint-disable-next-line @typescript-eslint/no-unused-vars - const { reasoning_effort, reasoning_summary, ...safe } = normalized as Record; + const { reasoning_effort, reasoning_summary, ...safe } = normalized; return safe; } - return normalized as Record; + return normalized; } async chatCompletion( diff --git a/packages/service/src/routes/api.ts b/packages/service/src/routes/api.ts index e0a76c95..7b50f859 100644 --- a/packages/service/src/routes/api.ts +++ b/packages/service/src/routes/api.ts @@ -50,13 +50,6 @@ async function verifyPassword( return { ok: false }; } -function requireAdmin(authHeader: string | undefined): string | null { - if (!authHeader?.startsWith('Bearer ')) return null; - const token = authHeader.slice(7); - const payload = verifyToken(token); - if (!payload) return null; - return payload['sub'] as string; -} // ── Module augmentation ─────────────────────────────────────────────────────── declare module 'fastify' { @@ -787,11 +780,11 @@ export const apiRoutes: FastifyPluginAsync = async (fastify) => { const routingCost = filtered.filter(r => r.callType === 'routing' && r.outcome === 'success').reduce((s, r) => s + r.cost, 0); const completionCost = filtered.filter(r => r.callType !== 'routing' && r.outcome === 'success').reduce((s, r) => s + r.cost, 0); - // Daily timeline (last 30 days) + // Timeline for the selected period (hourly for daily, daily otherwise) const timeline: Record = {}; - for (const r of records.filter(r => r.outcome === 'success')) { - const day = r.timestamp.slice(0, 10); - timeline[day] = (timeline[day] ?? 0) + r.cost; + for (const r of filtered.filter(r => r.outcome === 'success')) { + const key = period === 'daily' ? r.timestamp.slice(0, 13) : r.timestamp.slice(0, 10); + timeline[key] = (timeline[key] ?? 0) + r.cost; } const totalCost = filtered.filter(r => r.outcome === 'success').reduce((s, r) => s + r.cost, 0); @@ -907,7 +900,13 @@ export const apiRoutes: FastifyPluginAsync = async (fastify) => { const wasEnabled = current.telemetry?.enabled === true; if (telemetryPatch.enabled) { const installId = current.telemetry?.installId || randomUUID(); - updated.telemetry = { enabled: true, installId }; + updated.telemetry = { + enabled: true, + installId, + ...(current.telemetry?.lastPingedVersion !== undefined + ? { lastPingedVersion: current.telemetry.lastPingedVersion } + : {}), + }; if (!wasEnabled) pingTelemetry(installId, 'install'); } else { updated.telemetry = { enabled: false, installId: current.telemetry?.installId ?? '' }; diff --git a/packages/service/src/routes/openai.ts b/packages/service/src/routes/openai.ts index 5ccae6bb..e3184a62 100644 --- a/packages/service/src/routes/openai.ts +++ b/packages/service/src/routes/openai.ts @@ -69,6 +69,7 @@ export const openaiRoutes: FastifyPluginAsync = async (fastify) => { if (body.input && !body.messages) { body.messages = body.input; } + delete body.input; if (body.max_tokens !== undefined) { body.max_output_tokens = body.max_tokens; delete body.max_tokens; @@ -105,7 +106,7 @@ export const openaiRoutes: FastifyPluginAsync = async (fastify) => { request.log.info( { messageCount: msgs.length, - roles: msgs.map((m: any) => m.role), + roles: msgs.map((m: any) => m?.role), payloadChars, stream: isStream, }, diff --git a/packages/service/src/routing/intent/similarity.test.ts b/packages/service/src/routing/intent/similarity.test.ts index 26f019fe..6700de64 100644 --- a/packages/service/src/routing/intent/similarity.test.ts +++ b/packages/service/src/routing/intent/similarity.test.ts @@ -26,6 +26,17 @@ describe('cosineSimilarity', () => { // [1,1] vs [1,0] → dot=1, |a|=√2, |b|=1 → 1/√2 ≈ 0.7071 expect(cosineSimilarity([1, 1], [1, 0])).toBeCloseTo(0.7071, 4); }); + + it('handles b shorter than a (b[i] is undefined → ?? 0)', () => { + // a=[1,0,1], b=[1,0] → b[2] is undefined → dot=1+0+0=1, normA=2, normB=1 → 1/√2 + expect(cosineSimilarity([1, 0, 1], [1, 0])).toBeCloseTo(0.7071, 4); + }); + + it('handles a shorter than b (a[i] is undefined → ?? 0)', () => { + // Iterates a.length=2 times, so a[i] is always defined, b[2] would require 3-elem + // Actually since loop goes up to a.length, a[i] is always valid; but b[i] may be undefined + expect(cosineSimilarity([1, 0], [1, 0, 1])).toBeCloseTo(1.0, 4); + }); }); describe('meanVector', () => { @@ -42,4 +53,38 @@ describe('meanVector', () => { expect(result[0]).toBeCloseTo(2); expect(result[1]).toBeCloseTo(3); }); + + it('handles vectors shorter than dim (v[i] undefined → ?? 0)', () => { + // dim = vectors[0].length = 3, second vector has only 2 elements → v[2] is undefined + const result = meanVector([[1, 2, 4], [1, 2]]); + expect(result[0]).toBeCloseTo(1); + expect(result[2]).toBeCloseTo(2); // (4 + 0) / 2 + }); + + it('sum[i] ?? 0 branch when sum has fewer elements than dim', () => { + // This is exercised naturally in the loop above when sum is pre-filled + const result = meanVector([[0, 0, 0], [0, 0, 0]]); + expect(result).toEqual([0, 0, 0]); + }); + + it('vectors[0]?.length ?? 0 fallback: first vector is undefined — returns empty', () => { + // Force dim to take the ?? 0 branch by casting to bypass the type check. + // When the first element is undefined, dim becomes 0 and sum stays empty. + const result = meanVector([undefined as unknown as number[]]); + expect(result).toEqual([]); + }); +}); + +describe('cosineSimilarity — a[i] ?? 0 nullish branch (line 10)', () => { + it('handles sparse arrays where a[i] is undefined', () => { + // Create a sparse array: arr[0] = 1, arr[2] = 1, arr[1] is a hole (undefined) + const sparse: number[] = []; + sparse[0] = 1; + sparse[2] = 1; + // b is a normal dense array of the same apparent length + const dense = [1, 0, 1]; + // a.length is 3, sparse[1] is undefined → ?? 0 branch is hit on line 10 & 11 + const sim = cosineSimilarity(sparse, dense); + expect(sim).toBeCloseTo(1.0); + }); }); diff --git a/packages/service/src/routing/policies/llm.ts b/packages/service/src/routing/policies/llm.ts index 0517fbae..f595cfc3 100644 --- a/packages/service/src/routing/policies/llm.ts +++ b/packages/service/src/routing/policies/llm.ts @@ -69,11 +69,11 @@ Respond with ONLY this JSON object and nothing else: } function buildUserMessage( - request: { messages: { role: string; content: unknown }[] }, + request: { messages?: { role: string; content: unknown }[] }, previousDecisions?: { model: string }[], maxChars?: number, ): string { - const msgs = request.messages as Array<{ role: string; content: unknown }>; + const msgs = (request.messages ?? []) as Array<{ role: string; content: unknown }>; const systemMsg = msgs.find(m => m.role === 'system'); const systemContent = systemMsg diff --git a/packages/service/src/routing/policies/semantic-intent.test.ts b/packages/service/src/routing/policies/semantic-intent.test.ts index 011cb3ae..c6364899 100644 --- a/packages/service/src/routing/policies/semantic-intent.test.ts +++ b/packages/service/src/routing/policies/semantic-intent.test.ts @@ -1,4 +1,4 @@ -import { describe, it, expect, vi, beforeEach } from 'vitest'; +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; import { clearIntentCache } from '../intent/cache.js'; // ── Helpers ─────────────────────────────────────────────────────────────────── @@ -18,6 +18,10 @@ vi.mock('../../embeddings/index.js', () => ({ getEmbeddingProvider: vi.fn(() => mockProvider), })); +vi.mock('../../cost/tracker.js', () => ({ + trackUsage: vi.fn().mockResolvedValue(undefined), +})); + import { semanticIntentPolicy } from './semantic-intent.js'; import type { PolicyInput } from './types.js'; import type { SemanticIntentConfig } from '@routerly/shared'; @@ -60,6 +64,8 @@ const baseConfig: SemanticIntentConfig = { }, }; +import { trackUsage } from '../../cost/tracker.js'; + // ── Tests ───────────────────────────────────────────────────────────────────── describe('semanticIntentPolicy', () => { @@ -68,6 +74,8 @@ describe('semanticIntentPolicy', () => { vi.clearAllMocks(); }); + afterEach(() => vi.clearAllMocks()); + it('passes all candidates when config is missing required fields', async () => { const emitMock = vi.fn(); const result = await semanticIntentPolicy({ @@ -210,4 +218,225 @@ describe('semanticIntentPolicy', () => { // Falls back to all candidates expect(result.routing.find(r => r.model === 'some-other-model')?.point).toBe(1.0); }); + + it('falls back to all concatenated content when user content is an array', async () => { + // User message has array content → no string user message found → fallback joins all messages + const requestVec = [0, 0, 0]; // zero → unknown status + mockProvider.embed.mockResolvedValue({ embeddings: [requestVec], inputTokens: 0 }); + + const result = await semanticIntentPolicy({ + request: { + model: 'auto', + messages: [{ role: 'user', content: [{ type: 'text', text: 'hello' }] as any }], + } as any, + candidates: [makeCandidate('coder-model')], + config: baseConfig, + }); + + expect(result.routing.every(r => r.point === 1.0)).toBe(true); + }); + + it('tracks usage when projectId is provided and classification succeeds', async () => { + const vec = [1, 0, 0]; + mockProvider.embed.mockImplementation(async (texts: string[]) => ({ + embeddings: texts.map(() => vec), + inputTokens: 10, + })); + + const log = { info: vi.fn(), warn: vi.fn() } as any; + + const result = await semanticIntentPolicy({ + request: makeRequest('some coding question'), + candidates: [makeCandidate('coder-model')], + config: { ...baseConfig, absolute_threshold: 0.0 }, + projectId: 'proj-test', + log, + traceId: 'trace-1', + }); + + expect(result.routing).toBeDefined(); + expect(log.info).toHaveBeenCalled(); + }); + + it('passes all candidates when no messages have string content', async () => { + const result = await semanticIntentPolicy({ + request: { + model: 'auto', + messages: [], + } as any, + candidates: [makeCandidate('coder-model')], + config: baseConfig, + }); + + expect(result.routing.every(r => r.point === 1.0)).toBe(true); + }); + + // ── Line 58: request.messages ?? [] when messages is absent ───────────────── + it('passes all candidates when request has no messages property (messages ?? [])', async () => { + const result = await semanticIntentPolicy({ + request: { model: 'auto' } as any, + candidates: [makeCandidate('coder-model')], + config: baseConfig, + }); + + // No messages → userText is '' → passes all through + expect(result.routing.every(r => r.point === 1.0)).toBe(true); + }); + + // ── Line 108: traceId === undefined inside projectId block ─────────────────── + it('tracks usage without traceId when projectId is set but traceId is omitted', async () => { + const vec = [1, 0, 0]; + mockProvider.embed.mockImplementation(async (texts: string[]) => ({ + embeddings: texts.map(() => vec), + inputTokens: 5, + })); + + await semanticIntentPolicy({ + request: makeRequest('write code'), + candidates: [makeCandidate('coder-model')], + config: { ...baseConfig, absolute_threshold: 0.0 }, + projectId: 'proj-no-trace', + // traceId intentionally omitted → hits the false branch of `traceId !== undefined` + }); + + expect(trackUsage).toHaveBeenCalledWith( + expect.not.objectContaining({ traceId: expect.anything() }), + ); + }); + + // ── Lines 113 & 117: catch block when err is NOT an Error instance ─────────── + it('degrades gracefully and stringifies non-Error thrown value', async () => { + // Throw a plain string (not an Error instance) → String(err) branch + mockProvider.embed.mockRejectedValue('plain string error'); + + const emit = vi.fn(); + const log = { warn: vi.fn(), info: vi.fn() } as any; + const result = await semanticIntentPolicy({ + request: makeRequest('some text'), + candidates: [makeCandidate('coder-model')], + config: baseConfig, + emit, + log, + }); + + expect(result.routing.every(r => r.point === 1.0)).toBe(true); + expect(emit).toHaveBeenCalledWith(expect.objectContaining({ + message: 'policy:semantic-intent:error', + details: expect.objectContaining({ error: 'plain string error' }), + })); + expect(log.warn).toHaveBeenCalledWith( + expect.objectContaining({ err: 'plain string error' }), + expect.any(String), + ); + }); + + // ── Line 148: resolvePool called with null intentName (ambiguous, secondIntent=null) ── + it('resolvePool returns all candidates when secondIntent is null (ambiguous status)', async () => { + // Use a config with only one intent so secondIntent is null when ambiguous + const singleIntentConfig: SemanticIntentConfig = { + ...baseConfig, + intents: { coding: baseConfig.intents['coding']! }, + absolute_threshold: 0.0, + ambiguity_threshold: 2.0, // very high → ambiguous + }; + + const vec = [1, 0, 0]; + mockProvider.embed.mockResolvedValue({ embeddings: [vec], inputTokens: 0 }); + + const result = await semanticIntentPolicy({ + request: makeRequest('write some code'), + candidates: [makeCandidate('coder-model'), makeCandidate('other-model')], + config: singleIntentConfig, + }); + + // secondIntent is null → resolvePool(null) returns all candidateIds + // pool1 ∪ pool2 (all) → all candidates allowed + expect(result.routing.every(r => r.point === 1.0)).toBe(true); + }); + + // ── Line 150: resolvePool when intentDef is missing from cfg.intents ───────── + it('resolvePool falls back to all candidates when intentName is not in cfg.intents', async () => { + // Build classification result where topIntent is a name not in the config's intents map. + // We can achieve this by having classifyIntent return a confident result for 'coding', + // but using a config that has no 'coding' key. + const noMatchConfig: SemanticIntentConfig = { + ...baseConfig, + intents: { + unknown_intent: { + examples: ['something else'], + candidate_models: ['never-model'], + }, + }, + absolute_threshold: 0.0, + ambiguity_threshold: 0.0, + }; + + const vec = [1, 0, 0]; + mockProvider.embed.mockResolvedValue({ embeddings: [vec], inputTokens: 0 }); + + // The classifier will return topIntent='unknown_intent' (confident) + // cfg.intents['unknown_intent'] exists but candidate_models=['never-model'] + // which is NOT in the candidates list → falls back to all candidates (pool.size === 0). + const result = await semanticIntentPolicy({ + request: makeRequest('some request'), + candidates: [makeCandidate('coder-model'), makeCandidate('chat-model')], + config: noMatchConfig, + }); + + // Since the intent's pool has no overlap with candidates, falls back to all candidates + expect(result.routing.every(r => r.point === 1.0)).toBe(true); + }); + + // ── Line 11 (getEmbeddingInputCost): modelConf.input is undefined (returns 0) ── + it('getEmbeddingInputCost returns 0 when the provider model has no input cost defined', async () => { + const vec = [1, 0, 0]; + mockProvider.embed.mockImplementation(async (texts: string[]) => ({ + embeddings: texts.map(() => vec), + inputTokens: 7, + })); + + // Use a provider/model combo that does not exist in providersConf → input cost = 0 + await semanticIntentPolicy({ + request: makeRequest('compute something'), + candidates: [makeCandidate('coder-model')], + config: { + ...baseConfig, + embedding_provider: 'nonexistent-provider', + embedding_model: 'nonexistent-model', + absolute_threshold: 0.0, + }, + projectId: 'proj-cost-zero', + }); + + // trackUsage should be called with inputPerMillion: 0 + expect(trackUsage).toHaveBeenCalledWith( + expect.objectContaining({ + model: expect.objectContaining({ cost: { inputPerMillion: 0, outputPerMillion: 0 } }), + }), + ); + }); +}); + +// ── Line 113: log?.warn with err instanceof Error → TRUE branch ─────────────── + +describe('semanticIntentPolicy — line 113 err instanceof Error TRUE branch', () => { + it('logs err.message when the thrown value is an Error instance and log is provided', async () => { + mockProvider.embed.mockRejectedValue(new Error('embedding network error')); + + const emit = vi.fn(); + const log = { warn: vi.fn(), info: vi.fn() } as any; + const result = await semanticIntentPolicy({ + request: makeRequest('some text'), + candidates: [makeCandidate('coder-model')], + config: baseConfig, + emit, + log, + }); + + expect(result.routing.every(r => r.point === 1.0)).toBe(true); + expect(log.warn).toHaveBeenCalledWith( + expect.objectContaining({ err: 'embedding network error' }), + expect.any(String), + ); + }); }); diff --git a/packages/service/src/server.telemetry.test.ts b/packages/service/src/server.telemetry.test.ts new file mode 100644 index 00000000..8e072007 --- /dev/null +++ b/packages/service/src/server.telemetry.test.ts @@ -0,0 +1,126 @@ +import { describe, it, expect, vi, afterEach } from 'vitest'; +import { readFileSync } from 'node:fs'; +import { join, dirname } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const _dir = dirname(fileURLToPath(import.meta.url)); +const { version: CURRENT_VERSION } = JSON.parse( + readFileSync(join(_dir, '../package.json'), 'utf-8'), +) as { version: string }; + +// ── Hoist mock factories before any import ─────────────────────────────────── + +const { mockPing, mockReadConfig, mockWriteConfig, mockInitConfigDirs, mockLoadSecret } = + vi.hoisted(() => ({ + mockPing: vi.fn(), + mockReadConfig: vi.fn(), + mockWriteConfig: vi.fn().mockResolvedValue(undefined), + mockInitConfigDirs: vi.fn().mockResolvedValue(undefined), + mockLoadSecret: vi.fn().mockResolvedValue(undefined), + })); + +vi.mock('./telemetry.js', () => ({ pingTelemetry: mockPing })); +vi.mock('./config/loader.js', () => ({ + initConfigDirs: mockInitConfigDirs, + readConfig: mockReadConfig, + writeConfig: mockWriteConfig, +})); +vi.mock('./plugins/jwt.js', () => ({ loadSecret: mockLoadSecret })); +vi.mock('./update-checker.js', () => ({ updateChecker: { start: vi.fn() } })); + +vi.mock('fastify', () => ({ + default: vi.fn(() => ({ + register: vi.fn().mockResolvedValue(undefined), + get: vi.fn(), + listen: vi.fn().mockResolvedValue(undefined), + log: { warn: vi.fn(), error: vi.fn() }, + setNotFoundHandler: vi.fn(), + })), +})); +vi.mock('@fastify/cors', () => ({ default: vi.fn() })); +vi.mock('@fastify/static', () => ({ default: vi.fn() })); +vi.mock('./plugins/auth.js', () => ({ default: vi.fn() })); +vi.mock('./routes/api.js', () => ({ apiRoutes: vi.fn() })); +vi.mock('./routes/openai.js', () => ({ openaiRoutes: vi.fn() })); +vi.mock('./routes/anthropic.js', () => ({ anthropicRoutes: vi.fn() })); + +import { startServer } from './server.js'; + +// ── Helpers ────────────────────────────────────────────────────────────────── + +function makeSettings(telemetry?: { enabled: boolean; installId: string; lastPingedVersion?: string }) { + return { + port: 3000, + host: '0.0.0.0', + dashboardEnabled: false, + defaultTimeoutMs: 30000, + logLevel: 'info' as const, + channel: 'latest', + ...(telemetry !== undefined ? { telemetry } : {}), + }; +} + +afterEach(() => vi.clearAllMocks()); + +// ── Tests ───────────────────────────────────────────────────────────────────── + +describe('startServer() startup telemetry', () => { + it('does not ping when telemetry is absent (user not yet asked)', async () => { + mockReadConfig.mockResolvedValue(makeSettings()); + + await startServer(); + + expect(mockPing).not.toHaveBeenCalled(); + expect(mockWriteConfig).not.toHaveBeenCalled(); + }); + + it('does not ping when telemetry is disabled', async () => { + mockReadConfig.mockResolvedValue(makeSettings({ enabled: false, installId: 'id-1' })); + + await startServer(); + + expect(mockPing).not.toHaveBeenCalled(); + expect(mockWriteConfig).not.toHaveBeenCalled(); + }); + + it('fires "install" when lastPingedVersion is absent', async () => { + mockReadConfig.mockResolvedValue(makeSettings({ enabled: true, installId: 'uuid-abc' })); + + await startServer(); + + expect(mockPing).toHaveBeenCalledWith('uuid-abc', 'install'); + expect(mockWriteConfig).toHaveBeenCalledWith( + 'settings', + expect.objectContaining({ + telemetry: expect.objectContaining({ lastPingedVersion: CURRENT_VERSION }), + }), + ); + }); + + it('fires "upgrade" when lastPingedVersion differs from current version', async () => { + mockReadConfig.mockResolvedValue( + makeSettings({ enabled: true, installId: 'uuid-def', lastPingedVersion: '0.0.1' }), + ); + + await startServer(); + + expect(mockPing).toHaveBeenCalledWith('uuid-def', 'upgrade'); + expect(mockWriteConfig).toHaveBeenCalledWith( + 'settings', + expect.objectContaining({ + telemetry: expect.objectContaining({ lastPingedVersion: CURRENT_VERSION }), + }), + ); + }); + + it('does not ping when lastPingedVersion already matches current version', async () => { + mockReadConfig.mockResolvedValue( + makeSettings({ enabled: true, installId: 'uuid-ghi', lastPingedVersion: CURRENT_VERSION }), + ); + + await startServer(); + + expect(mockPing).not.toHaveBeenCalled(); + expect(mockWriteConfig).not.toHaveBeenCalled(); + }); +}); diff --git a/packages/service/src/server.ts b/packages/service/src/server.ts index cd7dc40d..be9bc885 100644 --- a/packages/service/src/server.ts +++ b/packages/service/src/server.ts @@ -9,7 +9,8 @@ import { loadSecret } from './plugins/jwt.js'; import { openaiRoutes } from './routes/openai.js'; import { anthropicRoutes } from './routes/anthropic.js'; import { apiRoutes } from './routes/api.js'; -import { initConfigDirs, readConfig } from './config/loader.js'; +import { initConfigDirs, readConfig, writeConfig } from './config/loader.js'; +import { pingTelemetry } from './telemetry.js'; import { updateChecker } from './update-checker.js'; const __dirname = dirname(fileURLToPath(import.meta.url)); @@ -86,6 +87,23 @@ export async function startServer() { await initConfigDirs(); await loadSecret(); const settings = await readConfig('settings'); + + if (settings.telemetry?.enabled === true) { + const { installId, lastPingedVersion } = settings.telemetry; + const event: 'install' | 'upgrade' | null = + !lastPingedVersion ? 'install' : + lastPingedVersion !== pkgVersion ? 'upgrade' : + null; + + if (event !== null) { + pingTelemetry(installId, event); + await writeConfig('settings', { + ...settings, + telemetry: { ...settings.telemetry, lastPingedVersion: pkgVersion }, + }); + } + } + const server = await buildServer(); try { diff --git a/packages/service/src/telemetry.ts b/packages/service/src/telemetry.ts index 1508c37c..aaf1efa1 100644 --- a/packages/service/src/telemetry.ts +++ b/packages/service/src/telemetry.ts @@ -30,6 +30,8 @@ export function pingTelemetry(installId: string, event: TelemetryEvent): void { headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload), signal: AbortSignal.timeout(3000), - }).catch(() => { /* fire-and-forget: network errors, timeouts, server down */ }); + }) + .then(res => console.log(`[telemetry] ${event} sent → ${res.status}`)) + .catch(err => console.log(`[telemetry] ${event} failed → ${(err as Error).message}`)); } catch { /* never propagate to the caller */ } } diff --git a/packages/service/src/update-checker.test.ts b/packages/service/src/update-checker.test.ts index 5f56b496..8d348dd8 100644 --- a/packages/service/src/update-checker.test.ts +++ b/packages/service/src/update-checker.test.ts @@ -115,6 +115,48 @@ describe('UpdateChecker.check()', () => { expect(result.latestVersion).toBe('2.0.0'); }); + it('uses tag_name as-is when it has no leading "v"', async () => { + stubGithubOk({ tag_name: '2.0.0', html_url: 'https://example.com', prerelease: false }); + + checker.start('0.1.5', 'latest'); + const result = await checker.check(); + + expect(result.latestVersion).toBe('2.0.0'); + expect(result.available).toBe(true); + }); + + it('returns available=false when candidate has a lower major version (isNewer branch)', async () => { + stubGithubOk({ tag_name: 'v0.0.1', html_url: '', prerelease: false }); + + checker.start('1.0.0', 'stable'); + const result = await checker.check(); + + expect(result.available).toBe(false); + }); + + it('returns available=false for non-semver tag names (parseSemver returns null)', async () => { + stubGithubOk({ tag_name: 'not-a-version', html_url: '', prerelease: false }); + + checker.start('0.1.5', 'latest'); + const result = await checker.check(); + + expect(result.available).toBe(false); + }); + + it('keeps existing cached result when a subsequent check fails', async () => { + // First successful check populates the cache + stubGithubOk({ tag_name: 'v1.0.0', html_url: 'https://example.com', prerelease: false }); + checker.start('0.1.5', 'latest'); + const first = await checker.check(); + expect(first.latestVersion).toBe('1.0.0'); + + // Second check fails — cached result should be preserved (not overwritten by fallback) + stubGithubError(); + const second = await checker.check(); + expect(second.latestVersion).toBe('1.0.0'); + expect(checker.getLastResult()!.latestVersion).toBe('1.0.0'); + }); + it('swallows network errors and returns safe fallback', async () => { stubGithubError(); @@ -153,6 +195,15 @@ describe('UpdateChecker.getLastResult()', () => { }); }); +describe('UpdateChecker.start() with empty channel', () => { + it('defaults channel to "latest" when an empty string is passed', async () => { + stubGithubOk({ tag_name: 'v1.0.0', html_url: '', prerelease: false }); + checker.start('0.1.5', ''); + const result = await checker.check(); + expect(result.channel).toBe('latest'); + }); +}); + describe('UpdateChecker.updateChannel()', () => { it('changes the channel used for subsequent checks', async () => { // First check on "latest" @@ -181,6 +232,14 @@ describe('UpdateChecker.updateChannel()', () => { // Cached result channel is unchanged until next check expect(before?.channel).toBe(after?.channel); }); + + it('defaults to "latest" when empty string is passed to updateChannel', async () => { + stubGithubOk({ tag_name: 'v1.0.0', html_url: '', prerelease: false }); + checker.start('0.1.5', 'latest'); + checker.updateChannel(''); + const result = await checker.check(); + expect(result.channel).toBe('latest'); + }); }); describe('UpdateChecker.start() idempotency', () => { @@ -196,3 +255,168 @@ describe('UpdateChecker.start() idempotency', () => { setIntervalSpy.mockRestore(); }); }); + +describe('UpdateChecker.getAvailableReleases()', () => { + it('returns base channels when GitHub API fails', async () => { + stubGithubError(); + checker.start('0.1.5', 'latest'); + const result = await checker.getAvailableReleases(); + expect(result.channels).toContain('latest'); + expect(result.channels).toContain('stable'); + }); + + it('returns base channels plus extra non-semver tags from GitHub', async () => { + stubGithubOk([ + { tag_name: 'beta-2', draft: false, prerelease: true }, + { tag_name: 'v0.1.5', draft: false, prerelease: false }, + { tag_name: 'nightly', draft: false, prerelease: false }, + { tag_name: 'draft-only', draft: true, prerelease: false }, + ]); + + // Do NOT call start() — it fires check() which would consume the first mock call + const result = await checker.getAvailableReleases(); + expect(result.channels).toContain('nightly') + // v0.1.5 is a semver tag so not added as extra channel + expect(result.channels).not.toContain('v0.1.5') + // draft-only is skipped + expect(result.channels).not.toContain('draft-only') + }); + + it('falls back to base channels when fetchAllReleases returns invalid JSON', async () => { + mockRequest.mockImplementation((_opts: unknown, cb: (res: MockRes) => void) => { + const req = new EventEmitter() as ReqLike; + req.end = () => { + const res = new EventEmitter() as MockRes; + res.statusCode = 200; + cb(res); + res.emit('data', Buffer.from('{{{invalid-json')); + res.emit('end'); + }; + req.destroy = () => {}; + return req; + }); + + const result = await checker.getAvailableReleases(); + expect(result.channels).toEqual(['latest', 'stable', 'develop']); + }); +}); + +describe('UpdateChecker.check() JSON parse error', () => { + it('handles JSON parse error gracefully', async () => { + mockRequest.mockImplementation((_opts: unknown, cb: (res: MockRes) => void) => { + const req = new EventEmitter() as ReqLike; + req.end = () => { + const res = new EventEmitter() as MockRes; + res.statusCode = 200; + cb(res); + res.emit('data', Buffer.from('not-valid-json-{{{')); + res.emit('end'); + }; + req.destroy = () => {}; + return req; + }); + + checker.start('0.1.5', 'latest'); + const result = await checker.check(); + // Should return fallback on JSON parse error + expect(result.available).toBe(false); + }); +}); + +describe('UpdateChecker.stop()', () => { + it('clears the interval timer', () => { + const clearIntervalSpy = vi.spyOn(globalThis, 'clearInterval'); + stubGithubOk({ tag_name: 'v0.1.5', html_url: '', prerelease: false }); + checker.start('0.1.5', 'latest'); + checker.stop(); + expect(clearIntervalSpy).toHaveBeenCalled(); + clearIntervalSpy.mockRestore(); + }); + + it('is idempotent when called multiple times', () => { + checker.stop(); + checker.stop(); + // Should not throw + }); +}); + +describe('UpdateChecker — remaining uncovered branches', () => { + it('isNewer returns true when candidate has higher minor version (line 35 true branch)', async () => { + stubGithubOk({ tag_name: 'v0.2.0', html_url: 'http://x.com', prerelease: false }); + checker.start('0.1.5', 'latest'); + const result = await checker.check(); + expect(result.available).toBe(true); + expect(result.latestVersion).toBe('0.2.0'); + }); + + it('rejects when GitHub API returns non-200 status (line 65 false branch)', async () => { + mockRequest.mockImplementation((_opts: unknown, cb: (res: MockRes) => void) => { + const req = new EventEmitter() as ReqLike; + req.end = () => { + const res = new EventEmitter() as MockRes; + res.statusCode = 404; + cb(res); + res.emit('end'); + }; + req.destroy = () => {}; + return req; + }); + checker.start('0.1.5', 'latest'); + const result = await checker.check(); + // Error from non-200 → check returns false (not available) + expect(result.available).toBe(false); + }); + + it('does not create a second timer when start() is called twice (line 139 false branch)', () => { + stubGithubOk([{ tag_name: 'v0.1.5', html_url: '', prerelease: false, draft: false }]); + const setIntervalSpy = vi.spyOn(globalThis, 'setInterval'); + checker.start('0.1.5', 'latest'); + checker.start('0.1.5', 'latest'); + // Timer should only be created once + expect(setIntervalSpy).toHaveBeenCalledTimes(1); + setIntervalSpy.mockRestore(); + }); + + it('getAvailableReleases: non-200 response from fetchReleaseList → falls back to base channels (line 70)', async () => { + mockRequest.mockImplementation((_opts: unknown, cb: (res: MockRes) => void) => { + const req = new EventEmitter() as ReqLike; + req.end = () => { + const res = new EventEmitter() as MockRes; + res.statusCode = 403; + cb(res); + res.emit('data', Buffer.from('Forbidden')); + res.emit('end'); + }; + req.destroy = () => {}; + return req; + }); + checker.start('0.1.5', 'latest'); + const result = await checker.getAvailableReleases(); + expect(result.channels).toContain('latest'); + expect(result.channels).toContain('stable'); + }); + + it('setInterval callback fires and triggers a check (line 137 function)', async () => { + stubGithubOk({ tag_name: 'v0.2.0', html_url: '', prerelease: false }); + vi.useFakeTimers(); + checker.start('0.1.5', 'latest'); + // Advance past CHECK_INTERVAL_MS to trigger the setInterval callback + await vi.advanceTimersByTimeAsync(3_700_000); + vi.useRealTimers(); + // The setInterval callback called check() — verify the result was fetched + expect(checker.getLastResult()).not.toBeNull(); + }); + + it('fetchRelease timeout → rejects with timeout error (line 76 function)', async () => { + mockRequest.mockImplementation((_opts: unknown, _cb: unknown) => { + const req = new EventEmitter() as ReqLike; + req.end = () => { req.emit('timeout'); }; + req.destroy = vi.fn(); + return req; + }); + checker.start('0.1.5', 'latest'); + const result = await checker.check(); + // timeout → error caught → fallback result + expect(result.available).toBe(false); + }); +}); diff --git a/packages/service/vitest.config.ts b/packages/service/vitest.config.ts index 647f3936..0f868023 100644 --- a/packages/service/vitest.config.ts +++ b/packages/service/vitest.config.ts @@ -3,5 +3,12 @@ import { defineConfig } from 'vitest/config' export default defineConfig({ test: { include: ['src/**/*.test.ts'], + coverage: { + provider: 'v8', + reporter: ['text', 'lcov', 'json'], + include: ['src/**/*.ts'], + exclude: ['src/**/*.d.ts', 'src/index.ts'], + thresholds: { lines: 98, branches: 98, functions: 98, statements: 98 }, + }, }, }) diff --git a/packages/shared/src/types/config.ts b/packages/shared/src/types/config.ts index d0ed93e8..5f302698 100644 --- a/packages/shared/src/types/config.ts +++ b/packages/shared/src/types/config.ts @@ -309,6 +309,8 @@ export interface TelemetryConfig { enabled: boolean; /** Random UUID generated once at opt-in time, never changes */ installId: string; + /** Version that last fired a telemetry ping — absent means not yet tracked */ + lastPingedVersion?: string; } export interface Settings { diff --git a/website/docusaurus.config.ts b/website/docusaurus.config.ts index d32c6d87..fb80506f 100644 --- a/website/docusaurus.config.ts +++ b/website/docusaurus.config.ts @@ -45,16 +45,16 @@ const config: Config = { routeBasePath: '/', sidebarPath: './sidebars.ts', editUrl: 'https://github.com/Inebrio/Routerly/edit/main/', - lastVersion: '0.1.5', + lastVersion: 'current', versions: { - '0.1.5': { - label: '0.1.5 (current)', - badge: true, - }, current: { label: '0.2.0', badge: false, }, + '0.1.5': { + label: '0.1.5', + badge: true, + }, }, }, blog: false,