101 lines
6.0 KiB
JavaScript
101 lines
6.0 KiB
JavaScript
import test from 'node:test'
|
||
import assert from 'node:assert/strict'
|
||
import { VOICE_PRICING, VoiceUsage, estimateUsage, voiceLimits, usageLabel } from '../src/voice-usage.mjs'
|
||
import { VoiceSession } from '../src/voice.mjs'
|
||
|
||
const model = VOICE_PRICING.model
|
||
const report = { promptTokenCount: 2000, responseTokenCount: 1000, totalTokenCount: 3000,
|
||
promptTokensDetails: [{ modality: 'TEXT', tokenCount: 500 }, { modality: 'AUDIO', tokenCount: 1500 }],
|
||
responseTokensDetails: [{ modality: 'TEXT', tokenCount: 100 }, { modality: 'AUDIO', tokenCount: 900 }] }
|
||
const expected = (500 * VOICE_PRICING.input.TEXT + 1500 * VOICE_PRICING.input.AUDIO +
|
||
100 * VOICE_PRICING.output.TEXT + 900 * VOICE_PRICING.output.AUDIO) / 1e6
|
||
|
||
test('reported input history is billed again on each request, including identical reports', () => {
|
||
const usage = new VoiceUsage(model, { minutes: 10, usd: expected * 1.5 })
|
||
assert.equal(usage.add(report).reached, false)
|
||
const next = usage.add(report)
|
||
assert.equal(next.lowUsd, expected * 2); assert.equal(next.highUsd, expected * 2)
|
||
assert.equal(next.reports, 2); assert.equal(next.reached, true)
|
||
})
|
||
|
||
test('missing or unknown modality yields a finite range, not zero/free usage', () => {
|
||
for (const details of [undefined, [{ modality: 'toString', tokenCount: 3000 }]]) {
|
||
const cost = estimateUsage({ promptTokenCount: 3000, promptTokensDetails: details }, model)
|
||
assert.ok(cost.lowUsd > 0); assert.ok(cost.highUsd > cost.lowUsd); assert.equal(cost.uncertain, true)
|
||
}
|
||
const extra = estimateUsage({ ...report, thoughtsTokenCount: 100, toolUsePromptTokenCount: 100 }, model)
|
||
assert.ok(extra.highUsd > expected); assert.equal(extra.uncertain, true)
|
||
const noBreakdown = estimateUsage({ totalTokenCount: 1000 }, model)
|
||
assert.ok(noBreakdown.highUsd > 0); assert.equal(noBreakdown.uncertain, true)
|
||
})
|
||
|
||
test('invalid metadata cannot poison the running total or silently bypass the limit', () => {
|
||
const usage = new VoiceUsage(model)
|
||
usage.add(report); const before = usage.snapshot()
|
||
for (const metadata of [{}, { promptTokenCount: -1 }, { responseTokenCount: NaN },
|
||
{ promptTokenCount: '100' }, { ...report, totalTokenCount: 1 },
|
||
{ promptTokenCount: 1, promptTokensDetails: [{ modality: 'AUDIO', tokenCount: 2 }] }]) {
|
||
assert.throws(() => usage.add(metadata)); assert.deepEqual(usage.snapshot(), before)
|
||
}
|
||
assert.throws(() => estimateUsage(report, 'unknown-model'))
|
||
})
|
||
|
||
test('limits validate actual numeric bounds and usage label does not claim quota or invoice', () => {
|
||
assert.deepEqual(voiceLimits({ minutes: '3', usd: '0.05' }), { minutes: 3, usd: 0.05 })
|
||
for (const value of [{ minutes: 0, usd: 1 }, { minutes: 11, usd: 1 }, { minutes: 1, usd: 0 },
|
||
{ minutes: 1, usd: Infinity }, { minutes: 1.5, usd: 0.25 }, { minutes: 1, usd: 11 }]) assert.throws(() => voiceLimits(value))
|
||
assert.match(usageLabel(new VoiceUsage(model).snapshot(), 0), /henüz bilinmiyor/)
|
||
const usage = new VoiceUsage(model); usage.add(report)
|
||
assert.match(usageLabel(usage.snapshot(), 30), /IDE modeli dahil değildir/)
|
||
})
|
||
|
||
test('usage threshold closes voice before a co-delivered tool can submit IDE work', async () => {
|
||
let dispatched = 0, closed = 0, tracks = 0
|
||
const notices = []
|
||
const voice = new VoiceSession({ model, limits: { minutes: 10, usd: 0.01 }, onText: (_, text) => notices.push(text),
|
||
onState: text => notices.push(text), onSubmit: () => { dispatched++ } })
|
||
voice.startedAt = voice.now(); voice.lastUsageAt = voice.startedAt
|
||
voice.stream = { getTracks: () => [{ stop() { tracks++ } }] }
|
||
voice.socket = { readyState: 1, close() { closed++ }, send() { throw new Error('must not send after cap') } }
|
||
await voice.receive({ data: JSON.stringify({ usageMetadata: report,
|
||
toolCall: { functionCalls: [{ id: '1', name: 'submit_task', args: {} }] } }) })
|
||
voice.text = VoiceSession.prototype.text.bind(voice)
|
||
assert.throws(() => voice.text('Bunu yap'))
|
||
voice.result({ status: 'complete', text: 'Done' }); voice.stop()
|
||
assert.equal(voice.stopped, true); assert.deepEqual([dispatched, closed, tracks], [0, 1, 1])
|
||
assert.ok(notices.some(text => text.includes('maliyet sınırına')))
|
||
assert.ok(notices.some(text => text.includes('IDE işi devam edebilir')))
|
||
})
|
||
|
||
test('malformed usage closes an established session with a visible error', async () => {
|
||
const errors = []
|
||
const voice = new VoiceSession({ model, onError: text => errors.push(text) })
|
||
voice.ready = true
|
||
await voice.receive({ data: JSON.stringify({ usageMetadata: {} }) })
|
||
assert.equal(voice.stopped, true); assert.match(errors[0], /hesaplanamadı/)
|
||
})
|
||
|
||
for (const scenario of [
|
||
{ minutes: 1, elapsed: 60000, reason: /süresi doldu/ },
|
||
{ minutes: 10, elapsed: 120000, reason: /bildirimi alınamadı/ },
|
||
]) test(`real voice lifecycle timer stops without resuming: ${scenario.minutes} minute setting`, async t => {
|
||
t.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
|
||
let now = 0, connections = 0, closed = 0
|
||
const messages = [], usage = []
|
||
const originalContext = globalThis.AudioContext, originalSocket = globalThis.WebSocket
|
||
globalThis.AudioContext = class { async resume() {} async close() {} }
|
||
globalThis.WebSocket = class { constructor() { connections++ } close() { closed++ } }
|
||
t.after(() => { globalThis.AudioContext = originalContext; globalThis.WebSocket = originalSocket })
|
||
const voice = new VoiceSession({ token: 'test-only', model, now: () => now,
|
||
limits: { minutes: scenario.minutes, usd: 0.25 }, onText() {}, onError: text => messages.push(text),
|
||
onState: text => messages.push(text), onUsage: value => usage.push(value) })
|
||
t.after(() => voice.stop())
|
||
await voice.start(false)
|
||
await voice.receive({ data: JSON.stringify({ setupComplete: {} }) })
|
||
now = scenario.elapsed; t.mock.timers.tick(scenario.elapsed)
|
||
assert.equal(voice.stopped, true); assert.deepEqual([connections, closed], [1, 1])
|
||
assert.ok(messages.some(text => scenario.reason.test(text)))
|
||
assert.equal(usage.at(-1).seconds, scenario.elapsed / 1000)
|
||
t.mock.timers.tick(600000); assert.equal(connections, 1)
|
||
})
|