mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-04 10:24:02 +00:00
manjunath22466
0343b4495e
keep analyst counts, speech, cards, cancellation, pointer capture, tool schema boundaries, and session lifetime consistent add the exact Alps fallback and focused regression coverage
3783 lines
142 KiB
JavaScript
3783 lines
142 KiB
JavaScript
// Pure-logic unit tests for the voice-lifecycle size guards (Batch 11, M13).
|
||
// These helpers are DOM/WebRTC-free so they pin the screenshot down-scaling and
|
||
// payload-byte estimation that keep an oversized dc.send from stranding a turn.
|
||
import { test } from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import { DataLayerManager } from '../data/manager.js';
|
||
import { controlRadio as runControlRadio, createGevActionRunner as createActionRunner } from './gevActions.js';
|
||
import { createStandalonePlaceSearch } from '../standalone/placeSearch.js';
|
||
import {
|
||
computeDownscale,
|
||
renderFreshCesiumFrame,
|
||
estimateDataUrlBytes,
|
||
GevRealtimeController,
|
||
gateVoiceVisualizerLevel,
|
||
isBenignViewportDeleteError,
|
||
isEditingSpaceTarget,
|
||
isInteractiveSpaceTarget,
|
||
isPushToTalkKey,
|
||
isPushToTalkSurface,
|
||
PUSH_TO_TALK_HOLD_DELAY_MS,
|
||
resolveVoiceControlHint,
|
||
resolveVoiceVisualizerSpeaker,
|
||
selectVoiceVisualizerSignal,
|
||
silenceRadioForVoice,
|
||
startPreparedRadioAfterPlaybackReady,
|
||
shouldPauseRadioForVoice,
|
||
shouldHandlePushToTalkKeyDown,
|
||
shouldIgnoreVoiceButtonClick,
|
||
shouldStopVoiceAfterRadioTool,
|
||
readStoredVoiceTier,
|
||
readStoredVoiceLimits,
|
||
writeStoredVoiceTier,
|
||
writeStoredVoiceLimits,
|
||
withToolCatalog,
|
||
} from './gevRealtime.js';
|
||
import { createVoiceCostTracker } from './voiceCost.js';
|
||
|
||
test('push-to-talk recognizes Space by code or key', () => {
|
||
assert.equal(PUSH_TO_TALK_HOLD_DELAY_MS, 500);
|
||
assert.equal(isPushToTalkKey({ code: 'Space', key: 'Unidentified' }), true);
|
||
assert.equal(isPushToTalkKey({ code: '', key: ' ' }), true);
|
||
assert.equal(isPushToTalkKey({ code: 'KeyM', key: 'm' }), false);
|
||
});
|
||
|
||
test('push-to-talk protects text entry but arbitrates non-editing controls', () => {
|
||
const plainTarget = { isContentEditable: false, closest: () => null };
|
||
assert.equal(shouldHandlePushToTalkKeyDown({ code: 'Space', target: plainTarget }), true);
|
||
assert.equal(shouldHandlePushToTalkKeyDown({ code: 'Space', target: plainTarget, metaKey: true }), false);
|
||
assert.equal(shouldHandlePushToTalkKeyDown({
|
||
code: 'Space',
|
||
target: pushToTalkTarget({ tagName: 'INPUT', type: 'text' }),
|
||
}), false);
|
||
assert.equal(shouldHandlePushToTalkKeyDown({
|
||
code: 'Space',
|
||
target: { isContentEditable: true, closest: () => null },
|
||
}), false);
|
||
assert.equal(shouldHandlePushToTalkKeyDown({
|
||
code: 'Space',
|
||
target: pushToTalkTarget({ tagName: 'BUTTON' }),
|
||
}), true);
|
||
assert.equal(isEditingSpaceTarget(pushToTalkTarget({ tagName: 'INPUT', type: 'range' })), false);
|
||
});
|
||
|
||
// Dispatch through the installed document/window listeners, keeping WebRTC at
|
||
// the start boundary. Native button activation itself belongs to browser QA.
|
||
function createPushToTalkFixture(t) {
|
||
const savedGlobals = new Map(['document', 'window', 'setTimeout', 'clearTimeout'].map((name) => (
|
||
[name, Object.getOwnPropertyDescriptor(globalThis, name)]
|
||
)));
|
||
const eventHub = () => {
|
||
const listeners = new Map();
|
||
return {
|
||
addEventListener(type, listener) {
|
||
if (!listeners.has(type)) listeners.set(type, new Set());
|
||
listeners.get(type).add(listener);
|
||
},
|
||
removeEventListener(type, listener) { listeners.get(type)?.delete(listener); },
|
||
dispatch(type, event = {}) {
|
||
for (const listener of listeners.get(type) || []) listener(event);
|
||
return event;
|
||
},
|
||
count(type) { return listeners.get(type)?.size || 0; },
|
||
};
|
||
};
|
||
let clock = 0;
|
||
let nextTimerId = 1;
|
||
const timers = new Map();
|
||
const setTimeout = (callback, delay = 0) => {
|
||
const id = nextTimerId++;
|
||
timers.set(id, { callback, due: clock + Number(delay || 0) });
|
||
return id;
|
||
};
|
||
const clearTimeout = (id) => timers.delete(id);
|
||
const advance = (milliseconds) => {
|
||
const end = clock + milliseconds;
|
||
while (true) {
|
||
const due = [...timers.entries()]
|
||
.filter(([, timer]) => timer.due <= end)
|
||
.sort((a, b) => a[1].due - b[1].due || a[0] - b[0])[0];
|
||
if (!due) break;
|
||
const [id, timer] = due;
|
||
timers.delete(id);
|
||
clock = timer.due;
|
||
timer.callback();
|
||
}
|
||
clock = end;
|
||
};
|
||
const document = { ...eventHub(), visibilityState: 'visible', activeElement: null };
|
||
const window = eventHub();
|
||
Object.assign(globalThis, { document, window, setTimeout, clearTimeout });
|
||
const starts = [];
|
||
const radio = [];
|
||
const controllers = [];
|
||
const makeController = () => {
|
||
const microphone = { enabled: false, stopped: false, stop() { this.stopped = true; } };
|
||
const controller = new GevRealtimeController({
|
||
ui: {
|
||
root: { dataset: {}, querySelectorAll: () => [], remove() {} },
|
||
status: {}, detail: {},
|
||
},
|
||
runner: async () => ({}),
|
||
radioLayer: {
|
||
pause: () => radio.push('pause'),
|
||
setVoiceDucked: (ducked) => radio.push(ducked ? 'duck' : 'unduck'),
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.start = ({ pushToTalk }) => {
|
||
starts.push({ pushToTalk });
|
||
controller.pushToTalkMode = pushToTalk;
|
||
controller.status = 'listening';
|
||
controller.stream = {
|
||
getAudioTracks: () => [microphone],
|
||
getTracks: () => [microphone],
|
||
};
|
||
controller.setMicrophoneEnabled(true);
|
||
};
|
||
controllers.push(controller);
|
||
controller.bindPushToTalkShortcut();
|
||
return { controller, microphone };
|
||
};
|
||
t.after(() => {
|
||
for (const controller of controllers) controller.stop({ removeUi: true });
|
||
for (const [name, descriptor] of savedGlobals) {
|
||
if (descriptor) Object.defineProperty(globalThis, name, descriptor);
|
||
else delete globalThis[name];
|
||
}
|
||
});
|
||
const key = (type, target, options = {}) => {
|
||
document.activeElement = options.activeElement === undefined ? target : options.activeElement;
|
||
return document.dispatch(type, {
|
||
code: 'Space', key: ' ', target, defaultPrevented: false,
|
||
preventDefault() { this.defaultPrevented = true; },
|
||
...options,
|
||
});
|
||
};
|
||
return { advance, document, window, starts, radio, key, makeController, timers, ...makeController() };
|
||
}
|
||
|
||
function pushToTalkTarget({
|
||
tagName = null,
|
||
id = null,
|
||
style = null,
|
||
parentElement = null,
|
||
role = null,
|
||
tabIndex = null,
|
||
href = null,
|
||
controls = false,
|
||
type = null,
|
||
contentEditable = false,
|
||
mapSurface = false,
|
||
} = {}) {
|
||
const resolvedTagName = (tagName || (style ? 'BUTTON' : 'DIV')).toUpperCase();
|
||
return {
|
||
tagName: resolvedTagName,
|
||
id,
|
||
style,
|
||
parentElement,
|
||
role,
|
||
tabIndex,
|
||
href,
|
||
controls,
|
||
type,
|
||
blurred: 0,
|
||
blur() { this.blurred += 1; },
|
||
isContentEditable: contentEditable,
|
||
closest(selector) {
|
||
for (let node = this; node; node = node.parentElement) {
|
||
if (selector === '#cesiumContainer' && (node.id === 'cesiumContainer' || node.mapSurface)) {
|
||
return node;
|
||
}
|
||
for (const part of selector.split(/,\s*/)) {
|
||
if (part.toUpperCase() === node.tagName) return node;
|
||
if (part === 'a[href]' && node.tagName === 'A' && node.href !== null) return node;
|
||
if (part === 'audio[controls]' && node.tagName === 'AUDIO' && node.controls) return node;
|
||
if (part === 'video[controls]' && node.tagName === 'VIDEO' && node.controls) return node;
|
||
if (part === '[contenteditable]' && node.isContentEditable) return node;
|
||
if (part === '[tabindex]' && node.tabIndex !== null) return node;
|
||
const roleMatch = part.match(/^\[role="([^"]+)"\]$/);
|
||
if (roleMatch && node.role === roleMatch[1]) return node;
|
||
}
|
||
}
|
||
return null;
|
||
},
|
||
mapSurface,
|
||
};
|
||
}
|
||
|
||
test('push-to-talk starts from Cesium canvases and the document background', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const cesiumContainer = pushToTalkTarget({ tagName: 'DIV', id: 'cesiumContainer' });
|
||
const cesiumCanvas = pushToTalkTarget({
|
||
tagName: 'CANVAS',
|
||
tabIndex: 0,
|
||
parentElement: cesiumContainer,
|
||
});
|
||
const overlayCanvas = pushToTalkTarget({
|
||
tagName: 'CANVAS',
|
||
id: 'world-overlay-canvas',
|
||
tabIndex: 0,
|
||
});
|
||
|
||
for (const [index, canvas] of [cesiumCanvas, overlayCanvas].entries()) {
|
||
assert.equal(isPushToTalkSurface(canvas), true);
|
||
assert.equal(isInteractiveSpaceTarget(canvas), false);
|
||
assert.equal(f.key('keydown', canvas).defaultPrevented, true);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.equal(f.starts.length, 1, 'the first map hold opens one reusable voice session');
|
||
assert.equal(f.controller.pushToTalkKeyHeld, true);
|
||
assert.equal(f.microphone.enabled, true, `map hold ${index + 1} enables the microphone`);
|
||
assert.equal(f.key('keyup', canvas).defaultPrevented, true);
|
||
assert.equal(f.microphone.enabled, false, `map release ${index + 1} mutes the microphone`);
|
||
}
|
||
const background = pushToTalkTarget();
|
||
assert.equal(f.key('keydown', background).defaultPrevented, true);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.equal(f.controller.pushToTalkKeyHeld, true);
|
||
assert.equal(f.key('keyup', background).defaultPrevented, true);
|
||
});
|
||
|
||
test('short Space on a focused control preserves release activation', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const button = pushToTalkTarget({ tagName: 'BUTTON' });
|
||
let activations = 0;
|
||
assert.equal(f.key('keydown', button).defaultPrevented, false);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS - 1);
|
||
const release = f.key('keyup', button);
|
||
if (!release.defaultPrevented) activations += 1;
|
||
assert.equal(release.defaultPrevented, false);
|
||
assert.equal(activations, 1);
|
||
assert.equal(button.blurred, 0);
|
||
assert.deepEqual(f.starts, []);
|
||
});
|
||
|
||
test('long Space blurs a focused control before voice and consumes release', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const button = pushToTalkTarget({ tagName: 'BUTTON' });
|
||
const order = [];
|
||
button.blur = () => {
|
||
button.blurred += 1;
|
||
order.push('blur');
|
||
f.document.activeElement = null;
|
||
};
|
||
f.controller.pauseRadioForVoice = () => order.push('voice');
|
||
assert.equal(f.key('keydown', button).defaultPrevented, false);
|
||
assert.equal(f.key('keydown', button, { repeat: true }).defaultPrevented, false);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.deepEqual(order, ['blur', 'voice']);
|
||
assert.equal(button.blurred, 1);
|
||
assert.equal(f.controller.pushToTalkKeyHeld, true);
|
||
assert.equal(f.key('keydown', button, { repeat: true, activeElement: null }).defaultPrevented, true);
|
||
let activations = 0;
|
||
const release = f.key('keyup', button, { activeElement: null });
|
||
if (!release.defaultPrevented) activations += 1;
|
||
assert.equal(release.defaultPrevented, true);
|
||
assert.equal(activations, 0);
|
||
assert.equal(f.microphone.enabled, false);
|
||
});
|
||
|
||
test('push-to-talk still ignores modified, already-handled and typing keydowns', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const target = pushToTalkTarget();
|
||
for (const modifier of ['altKey', 'ctrlKey', 'metaKey', 'shiftKey']) {
|
||
assert.equal(f.key('keydown', target, { [modifier]: true }).defaultPrevented, false);
|
||
}
|
||
f.key('keydown', target, { defaultPrevented: true });
|
||
f.key('keydown', target, { code: 'Enter', key: 'Enter' });
|
||
for (const tagName of ['INPUT', 'TEXTAREA']) f.key('keydown', pushToTalkTarget({ tagName }));
|
||
f.key('keydown', pushToTalkTarget({ role: 'textbox' }));
|
||
f.key('keydown', { isContentEditable: true });
|
||
assert.deepEqual(f.starts, []);
|
||
assert.deepEqual(f.radio, []);
|
||
assert.equal(f.controller.spaceKeyHeld, false);
|
||
});
|
||
|
||
test('push-to-talk starts once at 500ms and repeat does not reset the threshold', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const background = pushToTalkTarget();
|
||
assert.equal(f.key('keydown', background).defaultPrevented, true);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS - 1);
|
||
assert.deepEqual(f.starts, []);
|
||
assert.deepEqual(f.radio, []);
|
||
assert.equal(f.key('keydown', background, { repeat: true }).defaultPrevented, true);
|
||
f.advance(1);
|
||
assert.deepEqual(f.starts, [{ pushToTalk: true }]);
|
||
assert.equal(f.controller.pushToTalkKeyHeld, true);
|
||
assert.equal(f.microphone.enabled, true);
|
||
const radioAfterStart = f.radio.slice();
|
||
assert.equal(f.key('keydown', background, { repeat: true }).defaultPrevented, true);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS * 2);
|
||
assert.deepEqual(f.radio, radioAfterStart);
|
||
assert.equal(f.starts.length, 1);
|
||
assert.equal(
|
||
f.key('keyup', pushToTalkTarget({ tagName: 'BUTTON' })).defaultPrevented,
|
||
true,
|
||
'release follows a voice-owned hold after focus moves',
|
||
);
|
||
assert.equal(f.controller.spaceKeyHeld, false);
|
||
assert.equal(f.controller.pushToTalkKeyHeld, false);
|
||
assert.equal(f.microphone.enabled, false);
|
||
assert.equal(f.controller.ui.root.dataset.pushToTalk, undefined);
|
||
assert.equal(f.controller.ui.detail.textContent, 'Hold Space to talk');
|
||
});
|
||
|
||
test('push-to-talk treats a Space release before 500ms as a background tap', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const background = pushToTalkTarget();
|
||
assert.equal(f.key('keydown', background).defaultPrevented, true);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS - 1);
|
||
assert.equal(f.key('keyup', background).defaultPrevented, true);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS + 1);
|
||
assert.deepEqual(f.starts, []);
|
||
assert.deepEqual(f.radio, []);
|
||
assert.equal(f.controller.spaceKeyHeld, false);
|
||
assert.equal(f.controller.pushToTalkKeyHeld, false);
|
||
assert.equal(f.timers.size, 0);
|
||
});
|
||
|
||
test('push-to-talk rechecks focus before the hold threshold claims voice', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const background = pushToTalkTarget();
|
||
const control = pushToTalkTarget({ tagName: 'BUTTON' });
|
||
assert.equal(f.key('keydown', background).defaultPrevented, true);
|
||
f.document.activeElement = control;
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.deepEqual(f.starts, []);
|
||
assert.deepEqual(f.radio, []);
|
||
assert.equal(f.key('keyup', control).defaultPrevented, true, 'release follows the background gesture owner');
|
||
assert.equal(f.controller.spaceKeyHeld, false);
|
||
});
|
||
|
||
test('push-to-talk never claims a control-started hold after focus moves outside', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const control = pushToTalkTarget({ tagName: 'BUTTON' });
|
||
const background = pushToTalkTarget();
|
||
assert.equal(f.key('keydown', control).defaultPrevented, false);
|
||
assert.equal(f.key('keydown', background, { repeat: true }).defaultPrevented, false);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS + 1);
|
||
assert.equal(f.key('keyup', background).defaultPrevented, false);
|
||
assert.deepEqual(f.starts, []);
|
||
assert.deepEqual(f.radio, []);
|
||
});
|
||
|
||
test('push-to-talk cancels pending and active holds on blur or hidden document', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const background = pushToTalkTarget();
|
||
for (const exit of ['blur', 'hidden']) {
|
||
const startsBeforePending = f.starts.length;
|
||
const radioBeforePending = f.radio.length;
|
||
f.key('keydown', background);
|
||
const staleCallback = [...f.timers.values()][0].callback;
|
||
if (exit === 'blur') f.window.dispatch('blur');
|
||
else {
|
||
f.document.visibilityState = 'hidden';
|
||
f.document.dispatch('visibilitychange');
|
||
}
|
||
staleCallback();
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.equal(f.starts.length, startsBeforePending);
|
||
assert.equal(f.radio.length, radioBeforePending);
|
||
assert.equal(f.controller.spaceKeyHeld, false);
|
||
f.document.visibilityState = 'visible';
|
||
|
||
f.key('keydown', background);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.equal(f.microphone.enabled, true);
|
||
if (exit === 'blur') f.window.dispatch('blur');
|
||
else {
|
||
f.document.visibilityState = 'hidden';
|
||
f.document.dispatch('visibilitychange');
|
||
}
|
||
assert.equal(f.controller.spaceKeyHeld, false);
|
||
assert.equal(f.controller.pushToTalkKeyHeld, false);
|
||
assert.equal(f.microphone.enabled, false);
|
||
assert.equal(f.controller.ui.root.dataset.pushToTalk, undefined);
|
||
assert.equal(f.key('keyup', background).defaultPrevented, false);
|
||
f.document.visibilityState = 'visible';
|
||
}
|
||
});
|
||
|
||
test('push-to-talk timer refuses hidden or unfocused documents before lifecycle events arrive', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const background = pushToTalkTarget();
|
||
for (const state of ['hidden', 'unfocused']) {
|
||
f.key('keydown', background);
|
||
if (state === 'hidden') f.document.visibilityState = 'hidden';
|
||
else f.document.hasFocus = () => false;
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.deepEqual(f.starts, []);
|
||
assert.deepEqual(f.radio, []);
|
||
assert.equal(f.key('keyup', background).defaultPrevented, true);
|
||
f.document.visibilityState = 'visible';
|
||
delete f.document.hasFocus;
|
||
}
|
||
});
|
||
|
||
test('focused controls and background Space preserve a click-started open mic', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
f.controller.start({ pushToTalk: false });
|
||
f.starts.length = 0;
|
||
const style = pushToTalkTarget({ style: 'retro' });
|
||
f.key('keydown', style);
|
||
f.key('keydown', style, { repeat: true });
|
||
assert.equal(f.key('keyup', style).defaultPrevented, false);
|
||
assert.deepEqual(f.radio, []);
|
||
assert.equal(f.microphone.enabled, true);
|
||
assert.equal(f.controller.pushToTalkMode, false);
|
||
assert.equal(f.key('keydown', pushToTalkTarget()).defaultPrevented, true);
|
||
assert.equal(f.controller.spaceKeyHeld, true);
|
||
assert.equal(f.controller.pushToTalkKeyHeld, false);
|
||
assert.equal(f.timers.size, 0);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS + 1);
|
||
assert.equal(f.key('keyup', style).defaultPrevented, true);
|
||
assert.equal(f.controller.spaceKeyHeld, false);
|
||
assert.equal(f.microphone.enabled, true, 'an outside Space gesture must not claim or mute an open-mic session');
|
||
assert.deepEqual(f.starts, []);
|
||
});
|
||
|
||
test('push-to-talk teardown removes installed listeners and replacement binds once', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const outside = pushToTalkTarget();
|
||
f.controller.bindPushToTalkShortcut();
|
||
assert.equal(f.document.count('keydown'), 1);
|
||
f.key('keydown', outside);
|
||
const staleCallback = [...f.timers.values()][0].callback;
|
||
f.controller.stop({ removeUi: true });
|
||
staleCallback();
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.equal(f.microphone.stopped, false);
|
||
assert.equal(f.controller.spaceKeyHeld, false);
|
||
assert.equal(f.controller.pushToTalkKeyHeld, false);
|
||
assert.equal(f.controller.pushToTalkMode, false);
|
||
assert.equal(f.document.count('keydown'), 0);
|
||
assert.equal(f.document.count('keyup'), 0);
|
||
assert.equal(f.document.count('visibilitychange'), 0);
|
||
assert.equal(f.window.count('blur'), 0);
|
||
f.key('keydown', outside);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.equal(f.starts.length, 0, 'the removed controller must not respond');
|
||
const replacement = f.makeController();
|
||
replacement.controller.bindPushToTalkShortcut();
|
||
assert.equal(f.document.count('keydown'), 1);
|
||
assert.equal(f.document.count('keyup'), 1);
|
||
assert.equal(f.document.count('visibilitychange'), 1);
|
||
assert.equal(f.window.count('blur'), 1);
|
||
f.key('keydown', pushToTalkTarget({ tagName: 'INPUT', type: 'text' }));
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.equal(f.starts.length, 0);
|
||
f.key('keydown', outside);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.equal(f.starts.length, 1);
|
||
assert.equal(replacement.microphone.enabled, true);
|
||
f.key('keyup', outside);
|
||
assert.equal(replacement.microphone.enabled, false);
|
||
});
|
||
|
||
test('mic clicks are ignored while Space is physically held', () => {
|
||
assert.equal(shouldIgnoreVoiceButtonClick(true), true);
|
||
assert.equal(shouldIgnoreVoiceButtonClick(false), false);
|
||
});
|
||
|
||
test('voice control help tray reflects the push-to-talk key state', () => {
|
||
assert.equal(
|
||
resolveVoiceControlHint(false, false),
|
||
'Hold Space to speak · tap Space to activate focused controls',
|
||
);
|
||
assert.equal(resolveVoiceControlHint(true, true), 'Release Space to send');
|
||
assert.equal(
|
||
resolveVoiceControlHint(true, false),
|
||
'Hold Space to speak · tap Space to activate focused controls',
|
||
);
|
||
});
|
||
|
||
test('voice visualizer reads assistant output while the assistant is speaking', () => {
|
||
const input = { analyser: { id: 'mic' }, data: new Uint8Array([1]) };
|
||
const output = { analyser: { id: 'speaker' }, data: new Uint8Array([2]) };
|
||
assert.equal(selectVoiceVisualizerSignal('user', input, output), input);
|
||
assert.equal(selectVoiceVisualizerSignal('ai', input, output), output);
|
||
assert.equal(selectVoiceVisualizerSignal('ai', input, { analyser: null, data: null }), null);
|
||
});
|
||
|
||
test('voice visualizer keeps assistant audio selected after response.done', () => {
|
||
assert.equal(resolveVoiceVisualizerSpeaker('ai', 'idle', true), 'ai');
|
||
assert.equal(resolveVoiceVisualizerSpeaker('ai', 'user', false), 'user');
|
||
assert.equal(resolveVoiceVisualizerSpeaker('user', 'idle', true), 'idle');
|
||
});
|
||
|
||
test('voice visualizer noise gate holds room tone at the baseline', () => {
|
||
assert.equal(gateVoiceVisualizerLevel(0.12, 0.12), 0);
|
||
assert.equal(gateVoiceVisualizerLevel(0.06, 0.12), 0);
|
||
assert.ok(gateVoiceVisualizerLevel(0.5, 0.12) > 0);
|
||
assert.equal(gateVoiceVisualizerLevel(1, 0.12), 1);
|
||
assert.equal(gateVoiceVisualizerLevel(NaN, 0.12), 0);
|
||
});
|
||
|
||
test('voice activation, speech, and push-to-talk pause Radio without an idle auto-resume', () => {
|
||
assert.equal(shouldPauseRadioForVoice({ status: 'connecting' }), true);
|
||
assert.equal(shouldPauseRadioForVoice({ status: 'executing' }), true);
|
||
assert.equal(shouldPauseRadioForVoice({ status: 'listening', speaker: 'user' }), true);
|
||
assert.equal(shouldPauseRadioForVoice({ status: 'listening', speaker: 'ai' }), true);
|
||
assert.equal(shouldPauseRadioForVoice({ status: 'listening', pushToTalkKeyHeld: true }), true);
|
||
assert.equal(shouldPauseRadioForVoice({ status: 'listening' }), false);
|
||
assert.equal(shouldPauseRadioForVoice({ status: 'idle' }), false);
|
||
assert.equal(shouldPauseRadioForVoice({ status: 'error' }), false);
|
||
});
|
||
|
||
test('successful Radio activation tools close voice after handing control to Radio', () => {
|
||
for (const radioAction of ['play', 'resume', 'select', 'next', 'previous']) {
|
||
assert.equal(shouldStopVoiceAfterRadioTool({ ok: true, action: 'control_radio', radioAction }), true);
|
||
}
|
||
assert.equal(shouldStopVoiceAfterRadioTool({ ok: true, action: 'control_radio', radioAction: 'enable' }), false);
|
||
assert.equal(shouldStopVoiceAfterRadioTool({ ok: true, action: 'control_radio', radioAction: 'volume' }), false);
|
||
assert.equal(shouldStopVoiceAfterRadioTool({ ok: false, action: 'control_radio', radioAction: 'play' }), false);
|
||
assert.equal(shouldStopVoiceAfterRadioTool({ ok: true, action: 'control_cctv', radioAction: 'play' }), false);
|
||
});
|
||
|
||
test('prepared Radio playback is verified under mute before voice closes', async () => {
|
||
const order = [];
|
||
const handoff = await startPreparedRadioAfterPlaybackReady({
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'select',
|
||
radioPlaybackRequested: true,
|
||
}, {
|
||
prepareRadio: async () => {
|
||
order.push('radio-play-muted');
|
||
return true;
|
||
},
|
||
stopVoice: () => order.push('voice-stop'),
|
||
});
|
||
assert.deepEqual(order, ['radio-play-muted', 'voice-stop']);
|
||
assert.equal(handoff.handled, true);
|
||
assert.equal(handoff.result.ok, true);
|
||
assert.equal(handoff.result.audioState, 'playing');
|
||
});
|
||
|
||
test('failed or superseded Radio preflight keeps voice open and cancels audio', async () => {
|
||
for (const scenario of [
|
||
{ started: false, current: true, cancelled: false },
|
||
{ started: true, current: false, cancelled: true },
|
||
]) {
|
||
const order = [];
|
||
const handoff = await startPreparedRadioAfterPlaybackReady({
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioPlaybackRequested: true,
|
||
}, {
|
||
prepareRadio: async () => scenario.started,
|
||
isCurrent: () => scenario.current,
|
||
cancelRadio: () => order.push('radio-cancel'),
|
||
stopVoice: () => order.push('voice-stop'),
|
||
});
|
||
assert.deepEqual(order, ['radio-cancel']);
|
||
assert.equal(handoff.result.ok, false);
|
||
assert.equal(Boolean(handoff.cancelled), scenario.cancelled);
|
||
}
|
||
});
|
||
|
||
test('replacement input invalidates an in-flight Radio preflight immediately', () => {
|
||
const order = [];
|
||
const controller = new GevRealtimeController({
|
||
ui: {},
|
||
runner: async () => ({}),
|
||
radioLayer: { stopPlayback: () => order.push('radio-stop') },
|
||
});
|
||
controller.pendingRadioPlaybackResult = { ok: true };
|
||
controller.radioHandoffInFlight = true;
|
||
const priorEpoch = controller.radioHandoffEpoch;
|
||
controller.cancelRadioHandoff();
|
||
assert.deepEqual(order, ['radio-stop']);
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
assert.equal(controller.radioHandoffInFlight, false);
|
||
assert.equal(controller.radioHandoffEpoch, priorEpoch + 1);
|
||
});
|
||
|
||
test('direct Radio pause or stop cancels a pending voice handoff', async () => {
|
||
const order = [];
|
||
let playbackControl = null;
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async () => ({ ok: true }),
|
||
radioLayer: {
|
||
subscribePlaybackControls(listener) {
|
||
playbackControl = listener;
|
||
return () => { playbackControl = null; };
|
||
},
|
||
playForVoice: async () => {
|
||
order.push('radio-play');
|
||
return true;
|
||
},
|
||
stopPlayback: () => order.push('radio-stop'),
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send() {},
|
||
close() { order.push('voice-stop'); },
|
||
};
|
||
controller.pendingRadioPlaybackResult = { ok: true, radioPlaybackRequested: true };
|
||
|
||
playbackControl('stop');
|
||
await controller.handleRealtimeEvent({
|
||
data: JSON.stringify({ type: 'response.done', response: { status: 'completed' } }),
|
||
});
|
||
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
assert.deepEqual(order, [], 'the explicit stop remains authoritative');
|
||
});
|
||
|
||
test('confirmed manual Radio playback closes active voice without stopping Radio', () => {
|
||
const order = [];
|
||
let playbackControl = null;
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async () => ({ ok: true }),
|
||
radioLayer: {
|
||
subscribePlaybackControls(listener) {
|
||
playbackControl = listener;
|
||
return () => { playbackControl = null; };
|
||
},
|
||
setVoiceDucked(ducked) { order.push(ducked ? 'radio-muted' : 'radio-fade-in'); },
|
||
stopPlayback() { order.push('radio-stop'); },
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.status = 'listening';
|
||
controller.radioVoiceDucked = true;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
close() { order.push('voice-stop'); },
|
||
};
|
||
|
||
playbackControl('play');
|
||
|
||
assert.deepEqual(order, ['voice-stop', 'radio-fade-in']);
|
||
assert.equal(controller.status, 'idle');
|
||
assert.equal(controller.dc, null);
|
||
});
|
||
|
||
test('manual playback takeover survives stale voice preflight cleanup', async () => {
|
||
let playbackControl = null;
|
||
let resolvePreflight;
|
||
let activeAttemptId = null;
|
||
const stopRequests = [];
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const radioLayer = {
|
||
subscribePlaybackControls(listener) {
|
||
playbackControl = listener;
|
||
return () => { playbackControl = null; };
|
||
},
|
||
setVoiceDucked() {},
|
||
async playForVoice({ attemptId }) {
|
||
activeAttemptId = attemptId;
|
||
return new Promise((resolve) => { resolvePreflight = resolve; });
|
||
},
|
||
stopPlayback({ attemptId, origin }) {
|
||
const owned = activeAttemptId === attemptId;
|
||
stopRequests.push({ attemptId, origin, owned });
|
||
if (owned) activeAttemptId = null;
|
||
return owned;
|
||
},
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async () => ({ ok: true }),
|
||
radioLayer,
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.status = 'listening';
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
controller.pendingRadioPlaybackResult = { ok: true, radioPlaybackRequested: true };
|
||
|
||
const pending = controller.handleRealtimeEvent({
|
||
data: JSON.stringify({ type: 'response.done', response: { status: 'completed' } }),
|
||
});
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
const voiceAttemptId = activeAttemptId;
|
||
assert.match(voiceAttemptId, /^voice-radio-/);
|
||
|
||
activeAttemptId = 'manual-attempt';
|
||
playbackControl({ action: 'play', origin: 'user', attemptId: activeAttemptId });
|
||
resolvePreflight(true);
|
||
await pending;
|
||
|
||
assert.equal(activeAttemptId, 'manual-attempt');
|
||
assert.deepEqual(stopRequests, [{
|
||
attemptId: voiceAttemptId,
|
||
origin: 'voice-cleanup',
|
||
owned: false,
|
||
}]);
|
||
assert.equal(controller.status, 'idle');
|
||
});
|
||
|
||
test('internal Radio cleanup controls do not masquerade as newer user input', () => {
|
||
let playbackControl = null;
|
||
const controller = new GevRealtimeController({
|
||
ui: {},
|
||
runner: async () => ({}),
|
||
radioLayer: {
|
||
subscribePlaybackControls(listener) {
|
||
playbackControl = listener;
|
||
return () => {};
|
||
},
|
||
stopPlayback() {},
|
||
},
|
||
});
|
||
controller.pendingRadioPlaybackResult = { ok: true };
|
||
controller.radioHandoffInFlight = true;
|
||
controller.radioHandoffAttemptId = 'voice-attempt';
|
||
|
||
playbackControl({ action: 'stop', origin: 'voice-cleanup', attemptId: 'voice-attempt' });
|
||
|
||
assert.ok(controller.pendingRadioPlaybackResult);
|
||
assert.equal(controller.radioHandoffInFlight, true);
|
||
assert.equal(controller.radioHandoffAttemptId, 'voice-attempt');
|
||
});
|
||
|
||
test('manual Radio playback does not close voice when voice is already idle', () => {
|
||
let playbackControl = null;
|
||
let voiceStops = 0;
|
||
const controller = new GevRealtimeController({
|
||
ui: {},
|
||
runner: async () => ({}),
|
||
radioLayer: {
|
||
subscribePlaybackControls(listener) {
|
||
playbackControl = listener;
|
||
return () => { playbackControl = null; };
|
||
},
|
||
},
|
||
});
|
||
controller.dc = { readyState: 'open', close() { voiceStops += 1; } };
|
||
|
||
playbackControl('play');
|
||
|
||
assert.equal(voiceStops, 0);
|
||
assert.equal(controller.dc?.readyState, 'open');
|
||
});
|
||
|
||
test('active-response Realtime errors invalidate pending and in-flight Radio handoffs', async () => {
|
||
const order = [];
|
||
let playbackControl = null;
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async () => ({ ok: true }),
|
||
radioLayer: {
|
||
subscribePlaybackControls(listener) {
|
||
playbackControl = listener;
|
||
return () => { playbackControl = null; };
|
||
},
|
||
stopPlayback() {
|
||
order.push('radio-stop');
|
||
playbackControl?.('stop');
|
||
},
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.dc = { readyState: 'open', send() {}, close() { order.push('voice-stop'); } };
|
||
controller.pendingRadioPlaybackResult = { ok: true, radioPlaybackRequested: true };
|
||
controller.radioHandoffInFlight = true;
|
||
|
||
await controller.handleRealtimeEvent({
|
||
data: JSON.stringify({
|
||
type: 'error',
|
||
error: { code: 'conversation_already_has_active_response', message: 'response active' },
|
||
}),
|
||
});
|
||
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
assert.equal(controller.radioHandoffInFlight, false);
|
||
assert.deepEqual(order, ['radio-stop']);
|
||
});
|
||
|
||
test('voice ownership ducks tuner static before pausing broadcaster audio', () => {
|
||
const order = [];
|
||
const paused = silenceRadioForVoice({
|
||
duckRadio: () => order.push('duck-static'),
|
||
pauseRadio: () => {
|
||
order.push('pause-stream');
|
||
return false;
|
||
},
|
||
});
|
||
assert.deepEqual(order, ['duck-static', 'pause-stream']);
|
||
assert.equal(paused, false, 'a stopped stream can remain stopped while static is still silenced');
|
||
});
|
||
|
||
test('Radio handoff waits for response.done so later multi-intent tools execute before voice closes', async () => {
|
||
const order = [];
|
||
const confirmationInstructions = [];
|
||
const ui = {
|
||
root: {
|
||
dataset: {},
|
||
classList: { remove() {} },
|
||
querySelectorAll: () => [],
|
||
},
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const runner = async (name) => {
|
||
order.push(`tool:${name}`);
|
||
if (name === 'control_radio') {
|
||
return {
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'select',
|
||
radioPlaybackRequested: true,
|
||
};
|
||
}
|
||
return { ok: true, action: name };
|
||
};
|
||
const radioLayer = {
|
||
setVoiceDucked() {},
|
||
pause: () => false,
|
||
playForVoice: async () => {
|
||
order.push('radio-play');
|
||
return true;
|
||
},
|
||
stopPlayback() { order.push('radio-stop'); },
|
||
};
|
||
const controller = new GevRealtimeController({ runner, ui, radioLayer });
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) {
|
||
const payload = JSON.parse(message);
|
||
if (payload.type === 'response.create') {
|
||
order.push('assistant-confirmation-requested');
|
||
confirmationInstructions.push(payload.response?.instructions || '');
|
||
}
|
||
},
|
||
close() { order.push('voice-stop'); },
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
await controller.handleRealtimeEvent(event({ type: 'response.created', response: { id: 'response-1' } }));
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'response-1',
|
||
call_id: 'radio-call',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select"}',
|
||
}));
|
||
assert.deepEqual(order, ['tool:control_radio'], 'prepared playback keeps the response channel open');
|
||
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'response-1',
|
||
call_id: 'style-call',
|
||
name: 'set_visual_style',
|
||
arguments: '{"style":"night-vision"}',
|
||
}));
|
||
assert.deepEqual(order, ['tool:control_radio', 'tool:set_visual_style']);
|
||
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.done',
|
||
response: { id: 'response-1', status: 'completed' },
|
||
}));
|
||
assert.deepEqual(order, [
|
||
'tool:control_radio',
|
||
'tool:set_visual_style',
|
||
'assistant-confirmation-requested',
|
||
]);
|
||
assert.match(confirmationInstructions[0], /Turning on the radio/);
|
||
|
||
await controller.handleRealtimeEvent(event({ type: 'response.created', response: { id: 'response-confirm' } }));
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.done',
|
||
response: { id: 'response-confirm', status: 'completed' },
|
||
}));
|
||
assert.deepEqual(order, [
|
||
'tool:control_radio',
|
||
'tool:set_visual_style',
|
||
'assistant-confirmation-requested',
|
||
'radio-play',
|
||
'voice-stop',
|
||
]);
|
||
});
|
||
|
||
test('Radio playback failure leaves voice connected and speaks a correction', async () => {
|
||
const sent = [];
|
||
const order = [];
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async () => ({
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'play',
|
||
radioPlaybackRequested: true,
|
||
}),
|
||
radioLayer: {
|
||
setVoiceDucked() {},
|
||
pause: () => false,
|
||
playForVoice: async () => false,
|
||
stopPlayback: () => order.push('radio-stop'),
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() { order.push('voice-stop'); },
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
await controller.handleRealtimeEvent(event({ type: 'response.created', response: { id: 'response-fail' } }));
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'response-fail',
|
||
call_id: 'radio-fail',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"play"}',
|
||
}));
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.done',
|
||
response: { id: 'response-fail', status: 'completed' },
|
||
}));
|
||
await controller.handleRealtimeEvent(event({ type: 'response.created', response: { id: 'response-fail-confirm' } }));
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.done',
|
||
response: { id: 'response-fail-confirm', status: 'completed' },
|
||
}));
|
||
|
||
assert.deepEqual(order, ['radio-stop']);
|
||
assert.equal(controller.dc?.readyState, 'open');
|
||
assert.ok(sent.some((message) => (
|
||
message.type === 'response.create'
|
||
&& message.response?.instructions?.includes('Voice is still on')
|
||
)));
|
||
});
|
||
|
||
test('detected speech cancels a prepared Radio handoff before a cancelled response completes', async () => {
|
||
const order = [];
|
||
const ui = {
|
||
root: {
|
||
dataset: {},
|
||
classList: { remove() {} },
|
||
querySelectorAll: () => [],
|
||
},
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async () => ({
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'select',
|
||
radioPlaybackRequested: true,
|
||
}),
|
||
radioLayer: {
|
||
setVoiceDucked() {},
|
||
pause: () => false,
|
||
playForVoice: async () => {
|
||
order.push('radio-play');
|
||
return true;
|
||
},
|
||
stopPlayback: () => order.push('radio-stop'),
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send() {},
|
||
close() { order.push('voice-stop'); },
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
await controller.handleRealtimeEvent(event({ type: 'response.created', response: { id: 'response-2' } }));
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'response-2',
|
||
call_id: 'radio-call-2',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select"}',
|
||
}));
|
||
assert.ok(controller.pendingRadioPlaybackResult);
|
||
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.done',
|
||
response: { id: 'response-2', status: 'completed' },
|
||
}));
|
||
await controller.handleRealtimeEvent(event({ type: 'response.created', response: { id: 'response-2-confirm' } }));
|
||
|
||
await controller.handleRealtimeEvent(event({ type: 'input_audio_buffer.speech_started' }));
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.done',
|
||
response: { id: 'response-2-confirm', status: 'cancelled' },
|
||
}));
|
||
|
||
assert.deepEqual(order, [], 'the new user turn keeps voice open and Radio silent');
|
||
assert.equal(controller.dc?.readyState, 'open');
|
||
});
|
||
|
||
test('a Radio tool result that resolves after speech interruption cannot re-arm playback', async () => {
|
||
let resolveRunner;
|
||
const runnerResult = new Promise((resolve) => { resolveRunner = resolve; });
|
||
let receivedSignal = null;
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async (_name, _args, options) => {
|
||
receivedSignal = options.signal;
|
||
return runnerResult;
|
||
},
|
||
radioLayer: {
|
||
setVoiceDucked() {},
|
||
pause: () => false,
|
||
stopPlayback() {},
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
const sent = [];
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
const pendingTool = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'response-stale-radio',
|
||
call_id: 'radio-stale-call',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select"}',
|
||
}));
|
||
await Promise.resolve();
|
||
assert.equal(receivedSignal?.aborted, false);
|
||
await controller.handleRealtimeEvent(event({ type: 'input_audio_buffer.speech_started' }));
|
||
assert.equal(receivedSignal.aborted, true, 'barge-in aborts the underlying tool work');
|
||
resolveRunner({
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'select',
|
||
radioPlaybackRequested: true,
|
||
});
|
||
await pendingTool;
|
||
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
const output = sent.find((message) => message.type === 'conversation.item.create');
|
||
const result = JSON.parse(output.item.output);
|
||
assert.equal(result.ok, false);
|
||
assert.equal(result.cancelled, true);
|
||
assert.equal(result.radioPlaybackRequested, false);
|
||
assert.equal(sent.some((message) => message.type === 'response.create'), false);
|
||
});
|
||
|
||
test('sibling tool calls in one response do not abort an in-flight Radio action', async () => {
|
||
let resolveRadio;
|
||
let radioSignal = null;
|
||
const radioResult = new Promise((resolve) => { resolveRadio = resolve; });
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async (name, _args, options) => {
|
||
if (name === 'control_radio') {
|
||
radioSignal = options.signal;
|
||
return radioResult;
|
||
}
|
||
return { ok: true, action: name };
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
const pendingRadio = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'response-multi-tool',
|
||
call_id: 'radio-sibling',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select","locationId":"austin"}',
|
||
}));
|
||
await Promise.resolve();
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'response-multi-tool',
|
||
call_id: 'style-sibling',
|
||
name: 'set_visual_style',
|
||
arguments: '{"style":"normal"}',
|
||
}));
|
||
assert.equal(radioSignal?.aborted, false);
|
||
resolveRadio({ ok: true, action: 'control_radio', radioAction: 'status' });
|
||
await pendingRadio;
|
||
assert.equal(radioSignal.aborted, false);
|
||
});
|
||
|
||
test('Radio stop does not abort an unrelated sibling tool from the same response', async () => {
|
||
let releaseStyle;
|
||
let styleSignal = null;
|
||
const styleResult = new Promise((resolve) => { releaseStyle = resolve; });
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async (name, _args, options) => {
|
||
if (name === 'set_visual_style') {
|
||
styleSignal = options.signal;
|
||
return styleResult;
|
||
}
|
||
return { ok: true, action: 'control_radio', radioAction: 'stop' };
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
const pendingStyle = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'response-multi-tool-stop',
|
||
call_id: 'style-sibling-stop',
|
||
name: 'set_visual_style',
|
||
arguments: '{"style":"normal"}',
|
||
}));
|
||
await Promise.resolve();
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'response-multi-tool-stop',
|
||
call_id: 'radio-stop-sibling',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"stop"}',
|
||
}));
|
||
assert.equal(styleSignal?.aborted, false);
|
||
releaseStyle({ ok: true, action: 'set_visual_style' });
|
||
await pendingStyle;
|
||
assert.equal(styleSignal.aborted, false);
|
||
});
|
||
|
||
test('real Radio Select cannot enable or play after a same-response Disable completes', async () => {
|
||
const originalWindow = globalThis.window;
|
||
const originalFetch = globalThis.fetch;
|
||
let releaseLookup;
|
||
let announceLookupStarted;
|
||
const lookupGate = new Promise((resolve) => { releaseLookup = resolve; });
|
||
const lookupStarted = new Promise((resolve) => { announceLookupStarted = resolve; });
|
||
const sent = [];
|
||
const managerCalls = [];
|
||
const selectionCalls = [];
|
||
let voiceClosed = false;
|
||
let enabled = true;
|
||
const state = {
|
||
stationCount: 1,
|
||
selected: null,
|
||
audioState: 'playing',
|
||
volume: 0.8,
|
||
voiceDucked: true,
|
||
};
|
||
const radioLayer = {
|
||
getUIState: () => ({ ...state, enabled }),
|
||
selectRequestedStation(criteria) {
|
||
selectionCalls.push(criteria);
|
||
state.selected = { id: 'late-austin', name: 'Late Austin' };
|
||
return state.selected;
|
||
},
|
||
};
|
||
const dataManager = {
|
||
layers: new Map([['radio', { module: radioLayer }]]),
|
||
isEnabled: () => enabled,
|
||
async setEnabled(_layerId, nextEnabled) {
|
||
managerCalls.push(nextEnabled);
|
||
enabled = nextEnabled;
|
||
if (!nextEnabled) state.audioState = 'stopped';
|
||
return true;
|
||
},
|
||
};
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
globalThis.window = { __GOOGLE_MAPS_API_KEY__: 'test-key' };
|
||
globalThis.fetch = async () => {
|
||
announceLookupStarted();
|
||
await lookupGate;
|
||
return {
|
||
json: async () => ({
|
||
status: 'OK',
|
||
results: [{
|
||
formatted_address: 'Austin, TX',
|
||
geometry: { location: { lat: 30.2672, lng: -97.7431 } },
|
||
}],
|
||
}),
|
||
};
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
dataManager,
|
||
radioLayer,
|
||
runner: (_name, args, options) => controlRadio({}, dataManager, args, options),
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() { voiceClosed = true; },
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
try {
|
||
const pendingSelect = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'same-radio-response',
|
||
call_id: 'radio-select-sibling',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select","locationQuery":"Delayed place"}',
|
||
}));
|
||
await lookupStarted;
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'same-radio-response',
|
||
call_id: 'radio-disable-sibling',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"disable"}',
|
||
}));
|
||
|
||
assert.equal(enabled, false);
|
||
releaseLookup();
|
||
await pendingSelect;
|
||
const selectOutput = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse)
|
||
.find((result) => result.radioAction === 'select');
|
||
assert.equal(selectOutput?.ok, false, JSON.stringify({ selectOutput, epoch: controller.radioHandoffEpoch }));
|
||
assert.equal(selectOutput?.cancelled, true);
|
||
assert.equal(selectOutput?.enabled, false);
|
||
assert.equal(selectOutput?.audioState, 'stopped');
|
||
assert.equal(selectOutput?.radioPlaybackRequested, undefined);
|
||
assert.deepEqual(managerCalls, [false]);
|
||
assert.deepEqual(selectionCalls, []);
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
assert.equal(voiceClosed, false);
|
||
assert.equal(sent.some((message) => (
|
||
message.type === 'response.create'
|
||
&& message.response?.instructions?.includes('Turning on the radio')
|
||
)), false);
|
||
} finally {
|
||
globalThis.window = originalWindow;
|
||
globalThis.fetch = originalFetch;
|
||
}
|
||
});
|
||
|
||
test('generic same-response Radio visibility disable supersedes delayed Select', async () => {
|
||
const originalWindow = globalThis.window;
|
||
const originalFetch = globalThis.fetch;
|
||
let releaseLookup;
|
||
let announceLookupStarted;
|
||
const lookupGate = new Promise((resolve) => { releaseLookup = resolve; });
|
||
const lookupStarted = new Promise((resolve) => { announceLookupStarted = resolve; });
|
||
const sent = [];
|
||
const visibilityEvents = [];
|
||
const selectionCalls = [];
|
||
let dataManager = null;
|
||
const state = {
|
||
stationCount: 1,
|
||
selected: null,
|
||
audioState: 'playing',
|
||
volume: 0.8,
|
||
voiceDucked: true,
|
||
};
|
||
const radioLayer = {
|
||
id: 'radio',
|
||
name: 'Radio',
|
||
updateInterval: -1,
|
||
init: async () => true,
|
||
enable: async () => true,
|
||
disable: async () => {
|
||
state.audioState = 'stopped';
|
||
return true;
|
||
},
|
||
update: async () => true,
|
||
destroy: async () => true,
|
||
getStats: () => ({}),
|
||
getUIState: () => ({ ...state, enabled: dataManager?.isEnabled('radio') || false }),
|
||
selectRequestedStation(criteria) {
|
||
selectionCalls.push(criteria);
|
||
state.selected = { id: 'late-generic', name: 'Late generic station' };
|
||
return state.selected;
|
||
},
|
||
};
|
||
dataManager = new DataLayerManager({});
|
||
dataManager.register(radioLayer);
|
||
await dataManager.setEnabled('radio', true);
|
||
dataManager.subscribe((change) => {
|
||
if (change.type === 'visibility') {
|
||
visibilityEvents.push({ enabled: change.enabled, origin: change.origin });
|
||
}
|
||
});
|
||
const viewer = {
|
||
clock: { onTick: { addEventListener: () => () => {} } },
|
||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||
camera: { moveEnd: { addEventListener() {} } },
|
||
};
|
||
const genericRunner = createGevActionRunner({ viewer, styleManager: {}, dataManager });
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
globalThis.window = { __GOOGLE_MAPS_API_KEY__: 'test-key' };
|
||
globalThis.fetch = async () => {
|
||
announceLookupStarted();
|
||
await lookupGate;
|
||
return {
|
||
json: async () => ({
|
||
status: 'OK',
|
||
results: [{
|
||
formatted_address: 'Austin, TX',
|
||
geometry: { location: { lat: 30.2672, lng: -97.7431 } },
|
||
}],
|
||
}),
|
||
};
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
radioLayer,
|
||
runner: (name, args, options) => (
|
||
name === 'control_radio'
|
||
? controlRadio({}, dataManager, args, options)
|
||
: genericRunner(name, args, options)
|
||
),
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
try {
|
||
const pendingSelect = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'same-radio-generic-response',
|
||
call_id: 'radio-select-before-generic-disable',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select","locationQuery":"Delayed place"}',
|
||
}));
|
||
await lookupStarted;
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'same-radio-generic-response',
|
||
call_id: 'generic-radio-disable',
|
||
name: 'set_layer_visibility',
|
||
arguments: '{"layerId":"radio","enabled":false}',
|
||
}));
|
||
assert.equal(dataManager.isEnabled('radio'), false);
|
||
releaseLookup();
|
||
await pendingSelect;
|
||
|
||
const outputs = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse);
|
||
const visibilityOutput = outputs.find((result) => result.action === 'set_layer_visibility');
|
||
const selectOutput = outputs.find((result) => result.radioAction === 'select');
|
||
assert.equal(visibilityOutput?.ok, true);
|
||
assert.equal(visibilityOutput?.enabled, false);
|
||
assert.equal(visibilityOutput?.lifecycleState, 'disabled');
|
||
assert.equal(visibilityOutput?.lifecycleUncertain, false);
|
||
assert.equal(selectOutput?.cancelled, true);
|
||
assert.equal(selectOutput?.enabled, false);
|
||
assert.equal(selectOutput?.lifecycleState, 'disabled');
|
||
assert.equal(selectOutput?.lifecycleUncertain, false);
|
||
assert.equal(selectOutput?.radioPlaybackRequested, undefined);
|
||
assert.deepEqual(visibilityEvents, [{ enabled: false, origin: 'voice' }]);
|
||
assert.deepEqual(selectionCalls, []);
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
} finally {
|
||
globalThis.window = originalWindow;
|
||
globalThis.fetch = originalFetch;
|
||
}
|
||
});
|
||
|
||
test('same-response Pause aborts a real manager enable already in flight', async () => {
|
||
let releaseEnable;
|
||
let announceEnableStarted;
|
||
const enableGate = new Promise((resolve) => { releaseEnable = resolve; });
|
||
const enableStarted = new Promise((resolve) => { announceEnableStarted = resolve; });
|
||
const trace = [];
|
||
const sent = [];
|
||
const state = {
|
||
stationCount: 1,
|
||
selected: null,
|
||
audioState: 'stopped',
|
||
volume: 0.8,
|
||
};
|
||
const radioLayer = {
|
||
id: 'radio',
|
||
name: 'Radio',
|
||
updateInterval: -1,
|
||
init: async () => true,
|
||
enable: async () => {
|
||
trace.push('enable:start');
|
||
announceEnableStarted();
|
||
await enableGate;
|
||
trace.push('enable:finish');
|
||
return true;
|
||
},
|
||
disable: async () => {
|
||
trace.push('disable');
|
||
state.audioState = 'stopped';
|
||
return true;
|
||
},
|
||
update: async () => {
|
||
trace.push('update');
|
||
return true;
|
||
},
|
||
destroy: async () => true,
|
||
getStats: () => ({}),
|
||
getUIState: () => ({ ...state }),
|
||
pause: ({ origin } = {}) => {
|
||
trace.push(`pause:${origin || 'unknown'}`);
|
||
if (origin === 'voice') state.audioState = 'paused';
|
||
return true;
|
||
},
|
||
selectRequestedStation: () => {
|
||
trace.push('select');
|
||
state.selected = { id: 'late', name: 'Late station' };
|
||
return state.selected;
|
||
},
|
||
};
|
||
const dataManager = new DataLayerManager({});
|
||
dataManager.register(radioLayer);
|
||
dataManager.subscribe((change) => {
|
||
if (change.type === 'visibility') trace.push(`visibility:${change.enabled}`);
|
||
});
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
dataManager,
|
||
radioLayer,
|
||
runner: (_name, args, options) => controlRadio({}, dataManager, args, options),
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
const responseId = 'same-response-real-manager-pause';
|
||
|
||
const pendingSelect = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: 'select-enabling',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select"}',
|
||
}));
|
||
await enableStarted;
|
||
const pendingPause = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: 'pause-owner',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"pause"}',
|
||
}));
|
||
await pendingPause;
|
||
trace.push('pause:return');
|
||
releaseEnable();
|
||
await pendingSelect;
|
||
|
||
const outputs = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse);
|
||
const selectOutput = outputs.find((result) => result.radioAction === 'select');
|
||
const pauseOutput = outputs.find((result) => result.radioAction === 'pause');
|
||
assert.equal(dataManager.isEnabled('radio'), false);
|
||
assert.equal(selectOutput?.cancelled, true);
|
||
assert.equal(selectOutput?.enabled, false);
|
||
assert.equal(pauseOutput?.ok, true);
|
||
assert.equal(pauseOutput?.changed, false);
|
||
assert.equal(pauseOutput?.enabled, false);
|
||
assert.equal(pauseOutput?.audioState, 'stopped');
|
||
// The successful Pause may touch the current player before its reservation
|
||
// commits. Its commit then aborts the pending auto-enable synchronously, and
|
||
// the reconciled tool output reports the authoritative stopped/OFF result.
|
||
assert.equal(trace.includes('pause:voice'), true, trace.join(' → '));
|
||
assert.equal(trace.includes('select'), false, trace.join(' → '));
|
||
assert.equal(trace.includes('update'), false, trace.join(' → '));
|
||
assert.equal(trace.includes('visibility:true'), false, trace.join(' → '));
|
||
assert.ok(trace.indexOf('disable') < trace.indexOf('enable:finish'), trace.join(' → '));
|
||
});
|
||
|
||
test('Pause and Stop preserve independent dedicated and generic Radio ON across manager phases', async (t) => {
|
||
for (const onRoute of ['dedicated', 'generic']) {
|
||
for (const controlAction of ['pause', 'stop']) {
|
||
for (const heldPhase of ['init', 'enable', 'update']) {
|
||
for (const controlSucceeds of [true, false]) {
|
||
await t.test(
|
||
`${onRoute} ON + ${controlAction} ${controlSucceeds ? 'success' : 'failure'} during ${heldPhase}`,
|
||
async () => {
|
||
let releasePhase;
|
||
let markPhaseStarted;
|
||
const phaseGate = new Promise((resolve) => { releasePhase = resolve; });
|
||
const phaseStarted = new Promise((resolve) => { markPhaseStarted = resolve; });
|
||
const sent = [];
|
||
const visibility = [];
|
||
const trace = [];
|
||
let dataManager;
|
||
const runPhase = (phase) => async () => {
|
||
trace.push(`${phase}:start`);
|
||
if (phase === heldPhase) {
|
||
markPhaseStarted();
|
||
await phaseGate;
|
||
}
|
||
trace.push(`${phase}:finish`);
|
||
return true;
|
||
};
|
||
const state = { audioState: 'playing', volume: 0.8 };
|
||
const radioLayer = {
|
||
id: 'radio',
|
||
name: 'Radio',
|
||
updateInterval: -1,
|
||
init: runPhase('init'),
|
||
enable: runPhase('enable'),
|
||
update: runPhase('update'),
|
||
disable: async () => true,
|
||
destroy: async () => true,
|
||
getStats: () => ({}),
|
||
getUIState: () => ({
|
||
...state,
|
||
enabled: dataManager?.isEnabled('radio') || false,
|
||
}),
|
||
pause: () => {
|
||
trace.push(`pause:${controlSucceeds}`);
|
||
if (controlSucceeds) state.audioState = 'paused';
|
||
return controlSucceeds;
|
||
},
|
||
stopPlayback: () => {
|
||
trace.push(`stop:${controlSucceeds}`);
|
||
if (controlSucceeds) state.audioState = 'stopped';
|
||
return controlSucceeds;
|
||
},
|
||
};
|
||
dataManager = new DataLayerManager({});
|
||
dataManager.register(radioLayer);
|
||
dataManager.subscribe((change) => {
|
||
if (change.type === 'visibility') visibility.push(change.enabled);
|
||
});
|
||
const viewer = {
|
||
clock: { onTick: { addEventListener: () => () => {} } },
|
||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||
camera: { moveEnd: { addEventListener() {} } },
|
||
};
|
||
const genericRunner = createGevActionRunner({
|
||
viewer,
|
||
styleManager: {},
|
||
dataManager,
|
||
});
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
dataManager,
|
||
radioLayer,
|
||
runner: (name, args, options) => (
|
||
name === 'control_radio'
|
||
? controlRadio({}, dataManager, args, options)
|
||
: genericRunner(name, args, options)
|
||
),
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
const responseId = `${onRoute}-${controlAction}-${heldPhase}-${controlSucceeds}`;
|
||
|
||
const pendingOn = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: `${responseId}-on`,
|
||
name: onRoute === 'dedicated' ? 'control_radio' : 'set_layer_visibility',
|
||
arguments: onRoute === 'dedicated'
|
||
? '{"action":"enable"}'
|
||
: '{"layerId":"radio","enabled":true}',
|
||
}));
|
||
await phaseStarted;
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: `${responseId}-${controlAction}`,
|
||
name: 'control_radio',
|
||
arguments: JSON.stringify({ action: controlAction }),
|
||
}));
|
||
releasePhase();
|
||
await pendingOn;
|
||
|
||
const outputs = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse);
|
||
const onOutput = outputs.find((result) => onRoute === 'dedicated'
|
||
? result.radioAction === 'enable'
|
||
: result.action === 'set_layer_visibility');
|
||
const controlOutput = outputs.find((result) => result.radioAction === controlAction);
|
||
assert.equal(onOutput?.ok, true, trace.join(' → '));
|
||
assert.notEqual(onOutput?.cancelled, true, trace.join(' → '));
|
||
assert.equal(controlOutput?.ok, controlSucceeds, trace.join(' → '));
|
||
assert.equal(dataManager.isEnabled('radio'), true, trace.join(' → '));
|
||
assert.deepEqual(visibility, [true], trace.join(' → '));
|
||
assert.equal(visibility.includes(false), false, trace.join(' → '));
|
||
assert.equal(
|
||
state.audioState,
|
||
controlSucceeds ? (controlAction === 'pause' ? 'paused' : 'stopped') : 'playing',
|
||
);
|
||
await dataManager.destroyAll();
|
||
},
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
});
|
||
|
||
test('successful same- or newer-response Stop aborts Select across real manager lifecycle phases', async (t) => {
|
||
for (const responseMode of ['same-response', 'newer-response']) {
|
||
for (const heldPhase of ['init', 'enable', 'update']) {
|
||
await t.test(`${responseMode} ${heldPhase}`, async () => {
|
||
let releasePhase;
|
||
let announcePhaseStarted;
|
||
const phaseGate = new Promise((resolve) => { releasePhase = resolve; });
|
||
const phaseStarted = new Promise((resolve) => { announcePhaseStarted = resolve; });
|
||
const trace = [];
|
||
const sent = [];
|
||
const persistenceWrites = [];
|
||
const state = {
|
||
stationCount: 1,
|
||
selected: null,
|
||
audioState: 'stopped',
|
||
volume: 0.8,
|
||
};
|
||
let dataManager = null;
|
||
const runPhase = async (phase) => {
|
||
trace.push(`${phase}:start`);
|
||
if (heldPhase === phase) {
|
||
announcePhaseStarted();
|
||
await phaseGate;
|
||
}
|
||
trace.push(`${phase}:finish`);
|
||
return true;
|
||
};
|
||
const radioLayer = {
|
||
id: 'radio',
|
||
name: 'Radio',
|
||
updateInterval: -1,
|
||
init: () => runPhase('init'),
|
||
enable: () => runPhase('enable'),
|
||
update: () => runPhase('update'),
|
||
disable: async () => {
|
||
trace.push('disable');
|
||
state.audioState = 'stopped';
|
||
return true;
|
||
},
|
||
destroy: async () => true,
|
||
getStats: () => ({}),
|
||
getUIState: () => ({ ...state, enabled: dataManager?.isEnabled('radio') || false }),
|
||
stopPlayback: ({ origin } = {}) => {
|
||
trace.push(`stop:${origin || 'unknown'}`);
|
||
state.audioState = 'stopped';
|
||
return true;
|
||
},
|
||
selectRequestedStation: () => {
|
||
trace.push('select');
|
||
state.selected = { id: 'late-stop', name: 'Late stop station' };
|
||
return state.selected;
|
||
},
|
||
};
|
||
dataManager = new DataLayerManager({});
|
||
dataManager.register(radioLayer);
|
||
dataManager.subscribe((change) => {
|
||
if (change.type === 'visibility') {
|
||
trace.push(`visibility:${change.enabled}`);
|
||
if (change.origin === 'voice') persistenceWrites.push(change.enabled);
|
||
}
|
||
});
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
radioLayer,
|
||
runner: (_name, args, options) => controlRadio({}, dataManager, args, options),
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
const selectResponseId = `${responseMode}-real-manager-select-${heldPhase}`;
|
||
const stopResponseId = responseMode === 'same-response'
|
||
? selectResponseId
|
||
: `${responseMode}-real-manager-stop-${heldPhase}`;
|
||
|
||
const pendingSelect = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: selectResponseId,
|
||
call_id: `select-${heldPhase}`,
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select"}',
|
||
}));
|
||
await phaseStarted;
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: stopResponseId,
|
||
call_id: `stop-${heldPhase}`,
|
||
name: 'control_radio',
|
||
arguments: '{"action":"stop"}',
|
||
}));
|
||
trace.push('stop:return');
|
||
assert.equal(dataManager.isEnabled('radio'), false, trace.join(' → '));
|
||
releasePhase();
|
||
await pendingSelect;
|
||
|
||
const outputs = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse);
|
||
const selectOutput = outputs.find((result) => result.radioAction === 'select');
|
||
const stopOutput = outputs.find((result) => result.radioAction === 'stop');
|
||
assert.equal(stopOutput?.ok, true);
|
||
assert.equal(stopOutput?.audioState, 'stopped');
|
||
assert.equal(selectOutput?.cancelled, true);
|
||
assert.equal(selectOutput?.enabled, false);
|
||
assert.equal(dataManager.isEnabled('radio'), false);
|
||
assert.deepEqual(persistenceWrites, []);
|
||
assert.equal(trace.includes('select'), false, trace.join(' → '));
|
||
assert.equal(trace.includes('visibility:true'), false, trace.join(' → '));
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
});
|
||
}
|
||
}
|
||
});
|
||
|
||
test('same-response pause and disable suppress play/select handoffs without cancelling results', async (t) => {
|
||
for (const [playbackAction, stopAction] of [['play', 'pause'], ['select', 'disable']]) {
|
||
await t.test(`${playbackAction} + ${stopAction}`, async () => {
|
||
let releasePlayback;
|
||
const playbackGate = new Promise((resolve) => { releasePlayback = resolve; });
|
||
const sent = [];
|
||
const radioState = { enabled: true, audioState: 'playing' };
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
radioLayer: { getUIState: () => ({ ...radioState }) },
|
||
runner: async (_name, args) => {
|
||
if (args.action === playbackAction) {
|
||
await playbackGate;
|
||
return {
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: playbackAction,
|
||
radioPlaybackRequested: true,
|
||
};
|
||
}
|
||
if (stopAction === 'pause') radioState.audioState = 'paused';
|
||
else {
|
||
radioState.enabled = false;
|
||
radioState.audioState = 'stopped';
|
||
}
|
||
return { ok: true, action: 'control_radio', radioAction: stopAction };
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
const responseId = `same-response-${playbackAction}-${stopAction}`;
|
||
|
||
const pendingPlayback = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: `${playbackAction}-call`,
|
||
name: 'control_radio',
|
||
arguments: JSON.stringify({ action: playbackAction }),
|
||
}));
|
||
await Promise.resolve();
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: `${stopAction}-call`,
|
||
name: 'control_radio',
|
||
arguments: JSON.stringify({ action: stopAction }),
|
||
}));
|
||
releasePlayback();
|
||
await pendingPlayback;
|
||
|
||
const playbackOutput = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse)
|
||
.find((result) => result.radioAction === playbackAction);
|
||
assert.equal(playbackOutput?.ok, true);
|
||
assert.equal(playbackOutput?.cancelled, undefined);
|
||
assert.equal(playbackOutput?.radioPlaybackRequested, false);
|
||
assert.equal(playbackOutput?.radioPlaybackSuppressed, true);
|
||
assert.equal(playbackOutput?.audioState, stopAction === 'pause' ? 'paused' : 'stopped');
|
||
assert.equal(playbackOutput?.enabled, stopAction !== 'disable');
|
||
assert.equal(playbackOutput?.lifecycleState, stopAction === 'disable' ? 'disabled' : 'enabled');
|
||
assert.equal(playbackOutput?.lifecycleUncertain, false);
|
||
assert.match(
|
||
controller.pendingResponseInstructions,
|
||
stopAction === 'pause' ? /remains paused/ : /remains disabled/,
|
||
);
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
});
|
||
}
|
||
});
|
||
|
||
test('Realtime Radio route exceptions preserve the authoritative lifecycle summary', async () => {
|
||
for (const route of ['dedicated', 'generic']) {
|
||
const sent = [];
|
||
const lifecycle = { enabled: true, lifecycleState: 'disabling', uncertain: true };
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
dataManager: {
|
||
getLayerLifecycleState: () => ({ ...lifecycle }),
|
||
isEnabled: () => false,
|
||
},
|
||
radioLayer: { getUIState: () => ({ enabled: false, audioState: 'stopped' }) },
|
||
runner: async () => { throw new Error('route failed'); },
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
|
||
await controller.handleRealtimeEvent({
|
||
data: JSON.stringify({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: `exception-${route}`,
|
||
call_id: `exception-${route}-call`,
|
||
name: route === 'dedicated' ? 'control_radio' : 'set_layer_visibility',
|
||
arguments: route === 'dedicated'
|
||
? '{"action":"disable"}'
|
||
: '{"layerId":"radio","enabled":false}',
|
||
}),
|
||
});
|
||
|
||
const output = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse)
|
||
.find((result) => result.tool);
|
||
assert.equal(output?.ok, false);
|
||
assert.equal(output?.error, 'route failed');
|
||
assert.equal(output?.enabled, true);
|
||
assert.equal(output?.lifecycleState, 'disabling');
|
||
assert.equal(output?.lifecycleUncertain, true);
|
||
}
|
||
});
|
||
|
||
test('different-response Radio stop remains a cancellation authority for an older playback tool', async () => {
|
||
let releaseSelect;
|
||
const selectGate = new Promise((resolve) => { releaseSelect = resolve; });
|
||
const sent = [];
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async (_name, args) => {
|
||
if (args.action === 'select') {
|
||
await selectGate;
|
||
return {
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'select',
|
||
radioPlaybackRequested: true,
|
||
};
|
||
}
|
||
return { ok: true, action: 'control_radio', radioAction: 'stop' };
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
const pendingSelect = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'older-response',
|
||
call_id: 'older-select',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select"}',
|
||
}));
|
||
await Promise.resolve();
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'newer-response',
|
||
call_id: 'newer-stop',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"stop"}',
|
||
}));
|
||
releaseSelect();
|
||
await pendingSelect;
|
||
|
||
const selectOutput = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse)
|
||
.find((result) => result.radioAction === 'select');
|
||
assert.equal(selectOutput?.ok, false);
|
||
assert.equal(selectOutput?.cancelled, true);
|
||
assert.equal(selectOutput?.radioPlaybackRequested, false);
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
});
|
||
|
||
test('failed same-response stop does not suppress a successful playback request', async () => {
|
||
let releasePlay;
|
||
const playGate = new Promise((resolve) => { releasePlay = resolve; });
|
||
const sent = [];
|
||
const state = {
|
||
stationCount: 1,
|
||
selected: { id: 'station-1', name: 'Station 1' },
|
||
audioState: 'playing',
|
||
volume: 0.8,
|
||
};
|
||
const dataManager = {
|
||
layers: new Map([['radio', {
|
||
module: {
|
||
getUIState: () => ({ ...state }),
|
||
stopPlayback: () => false,
|
||
},
|
||
}]]),
|
||
isEnabled: () => true,
|
||
};
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async (_name, args) => {
|
||
const result = await controlRadio({}, dataManager, args);
|
||
if (args.action === 'play') await playGate;
|
||
return result;
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
const pendingPlay = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'failed-stop-response',
|
||
call_id: 'play-before-failed-stop',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"play"}',
|
||
}));
|
||
await Promise.resolve();
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'failed-stop-response',
|
||
call_id: 'failed-stop',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"stop"}',
|
||
}));
|
||
releasePlay();
|
||
await pendingPlay;
|
||
|
||
const playOutput = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse)
|
||
.find((result) => result.radioAction === 'play');
|
||
const stopOutput = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse)
|
||
.find((result) => result.radioAction === 'stop');
|
||
assert.equal(stopOutput?.ok, false);
|
||
assert.equal(stopOutput?.audioState, 'playing');
|
||
assert.equal(playOutput?.ok, true);
|
||
assert.equal(playOutput?.radioPlaybackRequested, true);
|
||
assert.equal(playOutput?.radioPlaybackSuppressed, undefined);
|
||
assert.equal(controller.pendingRadioPlaybackResult?.radioAction, 'play');
|
||
});
|
||
|
||
test('failed same-response Stop preserves Select auto-enable held inside real manager init', async () => {
|
||
let releaseInit;
|
||
let markInitStarted;
|
||
const initGate = new Promise((resolve) => { releaseInit = resolve; });
|
||
const initStarted = new Promise((resolve) => { markInitStarted = resolve; });
|
||
const sent = [];
|
||
const trace = [];
|
||
const state = {
|
||
selected: null,
|
||
audioState: 'playing',
|
||
volume: 0.8,
|
||
};
|
||
let dataManager;
|
||
const radioLayer = {
|
||
id: 'radio',
|
||
name: 'Radio',
|
||
updateInterval: -1,
|
||
init: async () => {
|
||
trace.push('init:start');
|
||
markInitStarted();
|
||
await initGate;
|
||
trace.push('init:finish');
|
||
return true;
|
||
},
|
||
enable: async () => true,
|
||
update: async () => true,
|
||
disable: async () => {
|
||
trace.push('disable');
|
||
return true;
|
||
},
|
||
destroy: async () => true,
|
||
getStats: () => ({}),
|
||
getUIState: () => ({
|
||
...state,
|
||
enabled: dataManager?.isEnabled('radio') || false,
|
||
stationCount: 1,
|
||
}),
|
||
stopPlayback: () => {
|
||
trace.push('stop:false');
|
||
return false;
|
||
},
|
||
selectRequestedStation: () => {
|
||
trace.push('select');
|
||
state.selected = { id: 'station-1', name: 'Station 1' };
|
||
return state.selected;
|
||
},
|
||
};
|
||
dataManager = new DataLayerManager({});
|
||
dataManager.register(radioLayer);
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
dataManager,
|
||
radioLayer,
|
||
runner: (_name, args, options) => controlRadio({}, dataManager, args, options),
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
const responseId = 'failed-stop-during-select-init';
|
||
|
||
const pendingSelect = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: 'select-held-in-init',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select","category":"all"}',
|
||
}));
|
||
await initStarted;
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: 'failed-stop-during-init',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"stop"}',
|
||
}));
|
||
releaseInit();
|
||
await pendingSelect;
|
||
|
||
const outputs = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse);
|
||
const selectOutput = outputs.find((result) => result.radioAction === 'select');
|
||
const stopOutput = outputs.find((result) => result.radioAction === 'stop');
|
||
assert.equal(stopOutput?.ok, false, trace.join(' → '));
|
||
assert.equal(selectOutput?.ok, true, trace.join(' → '));
|
||
assert.notEqual(selectOutput?.cancelled, true, trace.join(' → '));
|
||
assert.equal(dataManager.isEnabled('radio'), true, trace.join(' → '));
|
||
assert.equal(state.selected?.id, 'station-1', trace.join(' → '));
|
||
assert.equal(controller.pendingRadioPlaybackResult?.radioAction, 'select');
|
||
assert.equal(trace.includes('disable'), false, trace.join(' → '));
|
||
await dataManager.destroyAll();
|
||
});
|
||
|
||
test('failed same-response Pause and Disable do not suppress valid older playback', async (t) => {
|
||
for (const action of ['pause', 'disable']) {
|
||
await t.test(action, async () => {
|
||
let releasePlay;
|
||
const playGate = new Promise((resolve) => { releasePlay = resolve; });
|
||
const sent = [];
|
||
const state = {
|
||
stationCount: 1,
|
||
selected: { id: 'station-1', name: 'Station 1' },
|
||
audioState: 'playing',
|
||
volume: 0.8,
|
||
};
|
||
const requestListeners = new Set();
|
||
const visibilityListeners = new Set();
|
||
const dataManager = {
|
||
layers: new Map([['radio', {
|
||
module: {
|
||
getUIState: () => ({ ...state }),
|
||
pause: () => false,
|
||
},
|
||
}]]),
|
||
isEnabled: () => true,
|
||
setEnabled: async () => false,
|
||
subscribeVisibilityRequests(listener) {
|
||
requestListeners.add(listener);
|
||
return () => requestListeners.delete(listener);
|
||
},
|
||
subscribe(listener) {
|
||
visibilityListeners.add(listener);
|
||
return () => visibilityListeners.delete(listener);
|
||
},
|
||
};
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
dataManager,
|
||
radioLayer: dataManager.layers.get('radio').module,
|
||
runner: async (_name, args) => {
|
||
const result = await controlRadio({}, dataManager, args);
|
||
if (args.action === 'play') await playGate;
|
||
return result;
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
const responseId = `failed-${action}-response`;
|
||
|
||
const pendingPlay = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: `play-before-${action}`,
|
||
name: 'control_radio',
|
||
arguments: '{"action":"play"}',
|
||
}));
|
||
await Promise.resolve();
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: `failed-${action}`,
|
||
name: 'control_radio',
|
||
arguments: JSON.stringify({ action }),
|
||
}));
|
||
releasePlay();
|
||
await pendingPlay;
|
||
|
||
const outputs = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse);
|
||
const strongerOutput = outputs.find((result) => result.radioAction === action);
|
||
const playOutput = outputs.find((result) => result.radioAction === 'play');
|
||
assert.equal(strongerOutput?.ok, false);
|
||
assert.equal(playOutput?.ok, true);
|
||
assert.equal(playOutput?.radioPlaybackRequested, true);
|
||
assert.equal(playOutput?.radioPlaybackSuppressed, undefined);
|
||
assert.equal(controller.pendingRadioPlaybackResult?.radioAction, 'play');
|
||
});
|
||
}
|
||
});
|
||
|
||
test('failed generic same-response Radio OFF does not suppress valid older playback', async () => {
|
||
let releaseSelect;
|
||
const selectGate = new Promise((resolve) => { releaseSelect = resolve; });
|
||
const sent = [];
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async (name, args) => {
|
||
if (name === 'set_layer_visibility') {
|
||
return { ok: false, action: 'set_layer_visibility', layerId: 'radio', enabled: true };
|
||
}
|
||
await selectGate;
|
||
return {
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: args.action,
|
||
radioPlaybackRequested: true,
|
||
};
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
const pendingSelect = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'failed-generic-off',
|
||
call_id: 'select-before-generic-off',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select"}',
|
||
}));
|
||
await Promise.resolve();
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'failed-generic-off',
|
||
call_id: 'generic-off-fails',
|
||
name: 'set_layer_visibility',
|
||
arguments: '{"layerId":"radio","enabled":false}',
|
||
}));
|
||
releaseSelect();
|
||
await pendingSelect;
|
||
|
||
const selectOutput = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse)
|
||
.find((result) => result.radioAction === 'select');
|
||
assert.equal(selectOutput?.ok, true);
|
||
assert.equal(selectOutput?.radioPlaybackRequested, true);
|
||
assert.equal(selectOutput?.radioPlaybackSuppressed, undefined);
|
||
});
|
||
|
||
test('direct user Radio OFF aborts an in-flight voice enable before settled publication', async () => {
|
||
let releaseInit;
|
||
let markInitStarted;
|
||
const initGate = new Promise((resolve) => { releaseInit = resolve; });
|
||
const initStarted = new Promise((resolve) => { markInitStarted = resolve; });
|
||
const sent = [];
|
||
const visibility = [];
|
||
let dataManager;
|
||
const state = { selected: null, audioState: 'stopped', volume: 0.8 };
|
||
const radioLayer = {
|
||
id: 'radio',
|
||
name: 'Radio',
|
||
icon: '',
|
||
source: 'test',
|
||
updateInterval: 0,
|
||
init: async () => {
|
||
markInitStarted();
|
||
await initGate;
|
||
return true;
|
||
},
|
||
enable: async () => true,
|
||
update: async () => true,
|
||
disable: async () => true,
|
||
destroy: async () => true,
|
||
getStats: () => ({}),
|
||
getUIState: () => ({ ...state, enabled: dataManager?.isEnabled('radio') || false }),
|
||
selectRequestedStation: () => {
|
||
state.selected = { id: 'late', name: 'Late station' };
|
||
return state.selected;
|
||
},
|
||
};
|
||
dataManager = new DataLayerManager({});
|
||
dataManager.register(radioLayer);
|
||
dataManager.subscribe((change) => {
|
||
if (change.type === 'visibility') visibility.push(`${change.origin}:${change.enabled}`);
|
||
});
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
dataManager,
|
||
radioLayer,
|
||
runner: (_name, args, options) => controlRadio({}, dataManager, args, options),
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) { sent.push(JSON.parse(message)); },
|
||
close() {},
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
const pendingSelect = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'voice-select-before-ui-off',
|
||
call_id: 'voice-select',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select"}',
|
||
}));
|
||
await initStarted;
|
||
const userOff = dataManager.setEnabled('radio', false, { origin: 'user' });
|
||
releaseInit();
|
||
await Promise.all([pendingSelect, userOff]);
|
||
|
||
const selectOutput = sent
|
||
.map((message) => message.item?.output)
|
||
.filter(Boolean)
|
||
.map(JSON.parse)
|
||
.find((result) => result.radioAction === 'select');
|
||
assert.equal(selectOutput?.cancelled, true);
|
||
assert.equal(dataManager.isEnabled('radio'), false);
|
||
assert.deepEqual(
|
||
visibility,
|
||
['user:false'],
|
||
'voice ON never settles and the latest direct OFF alone owns publication',
|
||
);
|
||
assert.equal(state.selected, null);
|
||
await dataManager.destroyAll();
|
||
});
|
||
|
||
test('direct user Radio OFF freezes a prepared handoff until disable success or failure settles', async (t) => {
|
||
for (const disableSucceeds of [true, false]) {
|
||
await t.test(disableSucceeds ? 'success commits cancellation' : 'failure resumes prepared playback', async () => {
|
||
let releaseDisable;
|
||
let markDisableStarted;
|
||
const disableGate = new Promise((resolve) => { releaseDisable = resolve; });
|
||
const disableStarted = new Promise((resolve) => { markDisableStarted = resolve; });
|
||
const trace = [];
|
||
let dataManager;
|
||
const radioLayer = {
|
||
id: 'radio',
|
||
name: 'Radio',
|
||
updateInterval: -1,
|
||
init: async () => true,
|
||
enable: async () => true,
|
||
update: async () => true,
|
||
disable: async () => {
|
||
trace.push('disable:start');
|
||
markDisableStarted();
|
||
await disableGate;
|
||
trace.push(`disable:${disableSucceeds}`);
|
||
return disableSucceeds;
|
||
},
|
||
destroy: async () => true,
|
||
getStats: () => ({}),
|
||
getUIState: () => ({
|
||
enabled: dataManager?.isEnabled('radio') || false,
|
||
audioState: 'stopped',
|
||
}),
|
||
setVoiceDucked: () => trace.push('duck'),
|
||
playForVoice: async () => {
|
||
trace.push('playForVoice');
|
||
return true;
|
||
},
|
||
stopPlayback: () => {
|
||
trace.push('stopPlayback');
|
||
return true;
|
||
},
|
||
};
|
||
dataManager = new DataLayerManager({});
|
||
dataManager.register(radioLayer);
|
||
await dataManager.setEnabled('radio', true);
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
dataManager,
|
||
radioLayer,
|
||
runner: async () => ({ ok: true }),
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.pendingRadioPlaybackResult = {
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'select',
|
||
radioPlaybackRequested: true,
|
||
};
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send() {},
|
||
close() { trace.push('voice:close'); },
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
const userOff = dataManager.setEnabled('radio', false, { origin: 'user' });
|
||
await disableStarted;
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.done',
|
||
response: { id: `prepared-off-${disableSucceeds}`, status: 'completed' },
|
||
}));
|
||
assert.equal(trace.includes('playForVoice'), false, trace.join(' → '));
|
||
assert.equal(trace.includes('voice:close'), false, trace.join(' → '));
|
||
assert.equal(controller.pendingRadioPlaybackResult?.radioAction, 'select');
|
||
|
||
releaseDisable();
|
||
const disabled = await userOff;
|
||
await new Promise((resolve) => setImmediate(resolve));
|
||
assert.equal(disabled, disableSucceeds ? true : false);
|
||
assert.equal(trace.includes('playForVoice'), !disableSucceeds, trace.join(' → '));
|
||
assert.equal(trace.includes('voice:close'), !disableSucceeds, trace.join(' → '));
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
});
|
||
}
|
||
});
|
||
|
||
test('dedicated and generic Radio OFF reservations freeze an in-flight playback handoff', async (t) => {
|
||
for (const route of ['dedicated-disable', 'dedicated-stop', 'generic-off']) {
|
||
for (const controlSucceeds of [true, false]) {
|
||
await t.test(`${route} ${controlSucceeds ? 'success commits' : 'failure resumes'}`, async () => {
|
||
let releaseFirstPlay;
|
||
let markFirstPlayStarted;
|
||
let releaseControl;
|
||
let markControlStarted;
|
||
const firstPlayGate = new Promise((resolve) => { releaseFirstPlay = resolve; });
|
||
const firstPlayStarted = new Promise((resolve) => { markFirstPlayStarted = resolve; });
|
||
const controlGate = new Promise((resolve) => { releaseControl = resolve; });
|
||
const controlStarted = new Promise((resolve) => { markControlStarted = resolve; });
|
||
const trace = [];
|
||
let playCalls = 0;
|
||
const radioLayer = {
|
||
setVoiceDucked: () => trace.push('duck'),
|
||
playForVoice: async () => {
|
||
playCalls++;
|
||
trace.push(`play:${playCalls}:start`);
|
||
if (playCalls === 1) {
|
||
markFirstPlayStarted();
|
||
await firstPlayGate;
|
||
}
|
||
trace.push(`play:${playCalls}:finish`);
|
||
return true;
|
||
},
|
||
stopPlayback: () => {
|
||
trace.push('stopPlayback');
|
||
return true;
|
||
},
|
||
getUIState: () => ({ enabled: true, audioState: 'stopped' }),
|
||
};
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
radioLayer,
|
||
dataManager: { isEnabled: () => true },
|
||
runner: async (name, args) => {
|
||
const isDedicatedControl = route.startsWith('dedicated-');
|
||
const radioAction = route.replace('dedicated-', '');
|
||
const isStrongerControl = isDedicatedControl
|
||
? name === 'control_radio' && args.action === radioAction
|
||
: name === 'set_layer_visibility' && args.enabled === false;
|
||
if (!isStrongerControl) return { ok: false, error: 'unexpected route' };
|
||
trace.push('control:start');
|
||
markControlStarted();
|
||
await controlGate;
|
||
trace.push(`control:${controlSucceeds}`);
|
||
return isDedicatedControl
|
||
? {
|
||
ok: controlSucceeds,
|
||
action: 'control_radio',
|
||
radioAction,
|
||
}
|
||
: {
|
||
ok: controlSucceeds,
|
||
action: 'set_layer_visibility',
|
||
enabled: !controlSucceeds,
|
||
};
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.pendingRadioPlaybackResult = {
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'select',
|
||
radioPlaybackRequested: true,
|
||
};
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send() {},
|
||
close() { trace.push('voice:close'); },
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
const pendingHandoff = controller.handleRealtimeEvent(event({
|
||
type: 'response.done',
|
||
response: { id: `${route}-handoff`, status: 'completed' },
|
||
}));
|
||
await firstPlayStarted;
|
||
const pendingControl = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: `${route}-control`,
|
||
call_id: `${route}-call`,
|
||
name: route.startsWith('dedicated-') ? 'control_radio' : 'set_layer_visibility',
|
||
arguments: route.startsWith('dedicated-')
|
||
? JSON.stringify({ action: route.replace('dedicated-', '') })
|
||
: '{"layerId":"radio","enabled":false}',
|
||
}));
|
||
await controlStarted;
|
||
assert.equal(trace.includes('stopPlayback'), true, trace.join(' → '));
|
||
|
||
releaseFirstPlay();
|
||
await pendingHandoff;
|
||
assert.equal(trace.includes('voice:close'), false, trace.join(' → '));
|
||
assert.equal(controller.pendingRadioPlaybackResult?.radioAction, 'select');
|
||
|
||
releaseControl();
|
||
await pendingControl;
|
||
await new Promise((resolve) => setImmediate(resolve));
|
||
assert.equal(playCalls, controlSucceeds ? 1 : 2, trace.join(' → '));
|
||
assert.equal(trace.includes('voice:close'), !controlSucceeds, trace.join(' → '));
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
});
|
||
}
|
||
}
|
||
});
|
||
|
||
test('delayed Stop reports its result before committing or resuming a prepared handoff', async (t) => {
|
||
for (const outcome of ['success', 'false', 'reject']) {
|
||
await t.test(outcome, async () => {
|
||
let releaseStop;
|
||
let markStopStarted;
|
||
const stopGate = new Promise((resolve) => { releaseStop = resolve; });
|
||
const stopStarted = new Promise((resolve) => { markStopStarted = resolve; });
|
||
const trace = [];
|
||
const radioLayer = {
|
||
setVoiceDucked: () => trace.push('duck'),
|
||
playForVoice: async () => {
|
||
trace.push('play:start');
|
||
return true;
|
||
},
|
||
stopPlayback: () => {
|
||
trace.push('stopPlayback');
|
||
return true;
|
||
},
|
||
getUIState: () => ({ enabled: true, audioState: 'stopped' }),
|
||
};
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
radioLayer,
|
||
dataManager: { isEnabled: () => true },
|
||
runner: async () => {
|
||
trace.push('stop:start');
|
||
markStopStarted();
|
||
await stopGate;
|
||
if (outcome === 'reject') throw new Error('Stop rejected');
|
||
return {
|
||
ok: outcome === 'success',
|
||
action: 'control_radio',
|
||
radioAction: 'stop',
|
||
};
|
||
},
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.pendingRadioPlaybackResult = {
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'select',
|
||
radioPlaybackRequested: true,
|
||
};
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send(message) {
|
||
const payload = JSON.parse(message);
|
||
if (payload.item?.call_id === `delayed-stop-${outcome}`) trace.push('output:stop');
|
||
},
|
||
close() { trace.push('voice:close'); },
|
||
};
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
const pendingStop = controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: `delayed-stop-response-${outcome}`,
|
||
call_id: `delayed-stop-${outcome}`,
|
||
name: 'control_radio',
|
||
arguments: '{"action":"stop"}',
|
||
}));
|
||
await stopStarted;
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.done',
|
||
response: { id: `delayed-stop-response-${outcome}`, status: 'completed' },
|
||
}));
|
||
assert.equal(trace.includes('play:start'), false, trace.join(' → '));
|
||
|
||
releaseStop();
|
||
await pendingStop;
|
||
await new Promise((resolve) => setImmediate(resolve));
|
||
assert.equal(trace.includes('output:stop'), true, trace.join(' → '));
|
||
assert.equal(trace.includes('play:start'), outcome !== 'success', trace.join(' → '));
|
||
if (outcome !== 'success') {
|
||
assert.ok(
|
||
trace.indexOf('output:stop') < trace.indexOf('play:start'),
|
||
trace.join(' → '),
|
||
);
|
||
}
|
||
});
|
||
}
|
||
});
|
||
|
||
test('stale handoff cleanup cannot erase a resumed successor across repeated failed reservations', async () => {
|
||
const playbackAttempts = [];
|
||
const trace = [];
|
||
const radioLayer = {
|
||
setVoiceDucked: () => trace.push('duck'),
|
||
playForVoice: ({ attemptId }) => new Promise((resolve) => {
|
||
playbackAttempts.push({ attemptId, resolve });
|
||
trace.push(`play:${attemptId}`);
|
||
}),
|
||
stopPlayback: ({ attemptId }) => {
|
||
trace.push(`stop:${attemptId}`);
|
||
return true;
|
||
},
|
||
};
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
radioLayer,
|
||
runner: async () => ({ ok: false }),
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.queueResponseCreate = () => {};
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
const preparedResult = {
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'select',
|
||
radioPlaybackRequested: true,
|
||
};
|
||
controller.pendingRadioPlaybackResult = preparedResult;
|
||
|
||
const handoffA = controller.startPendingRadioHandoff();
|
||
await new Promise((resolve) => setImmediate(resolve));
|
||
assert.equal(playbackAttempts.length, 1);
|
||
|
||
const reservationA = controller.reserveRadioToolHandoff();
|
||
controller.settleRadioToolHandoffReservation(reservationA, { commit: false });
|
||
await new Promise((resolve) => setImmediate(resolve));
|
||
assert.equal(playbackAttempts.length, 2, trace.join(' → '));
|
||
const resumedAttemptId = playbackAttempts[1].attemptId;
|
||
|
||
playbackAttempts[0].resolve(true);
|
||
await handoffA;
|
||
assert.equal(controller.radioHandoffInFlight, true);
|
||
assert.equal(controller.radioHandoffAttemptId, resumedAttemptId);
|
||
assert.equal(controller.radioHandoffInFlightResult, preparedResult);
|
||
|
||
const reservationB = controller.reserveRadioToolHandoff();
|
||
controller.settleRadioToolHandoffReservation(reservationB, { commit: false });
|
||
await new Promise((resolve) => setImmediate(resolve));
|
||
assert.equal(playbackAttempts.length, 3, trace.join(' → '));
|
||
assert.equal(controller.radioHandoffInFlight, true);
|
||
assert.notEqual(controller.radioHandoffAttemptId, resumedAttemptId);
|
||
assert.equal(controller.radioHandoffInFlightResult, preparedResult);
|
||
|
||
playbackAttempts[1].resolve(true);
|
||
playbackAttempts[2].resolve(true);
|
||
await new Promise((resolve) => setImmediate(resolve));
|
||
});
|
||
|
||
test('a later same-response stop clears an already prepared playback result', async () => {
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: async (_name, args) => args.action === 'select'
|
||
? {
|
||
ok: true,
|
||
action: 'control_radio',
|
||
radioAction: 'select',
|
||
radioPlaybackRequested: true,
|
||
}
|
||
: { ok: true, action: 'control_radio', radioAction: 'stop' },
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.sendVisualContextIfUseful = async () => false;
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
const event = (payload) => ({ data: JSON.stringify(payload) });
|
||
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'prepared-then-stop',
|
||
call_id: 'prepared-select',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"select"}',
|
||
}));
|
||
assert.equal(controller.pendingRadioPlaybackResult?.radioAction, 'select');
|
||
await controller.handleRealtimeEvent(event({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: 'prepared-then-stop',
|
||
call_id: 'stop-prepared',
|
||
name: 'control_radio',
|
||
arguments: '{"action":"stop"}',
|
||
}));
|
||
assert.equal(controller.pendingRadioPlaybackResult, null);
|
||
});
|
||
|
||
test('computeDownscale leaves an already-small frame untouched', () => {
|
||
assert.deepEqual(computeDownscale(800, 600, 1200 * 900), { width: 800, height: 600 });
|
||
});
|
||
|
||
test('computeDownscale clamps a huge landscape frame under the pixel budget', () => {
|
||
const maxPx = 1200 * 900; // 1,080,000
|
||
const out = computeDownscale(3840, 2160, maxPx); // 4K, 8.29 MP
|
||
assert.ok(out.width * out.height <= maxPx, `pixels ${out.width * out.height} <= ${maxPx}`);
|
||
// aspect ratio preserved (16:9) within rounding
|
||
assert.ok(Math.abs(out.width / out.height - 3840 / 2160) < 0.01);
|
||
});
|
||
|
||
test('computeDownscale clamps a TALL PORTRAIT frame too (the width-only bug)', () => {
|
||
const maxPx = 1200 * 900;
|
||
// A narrow-but-very-tall portrait window: width alone (1080) would have
|
||
// passed the old 1200px width clamp untouched, but its 1080*3000 = 3.24 MP
|
||
// total blows the budget and must be scaled down.
|
||
const out = computeDownscale(1080, 3000, maxPx);
|
||
assert.ok(out.width * out.height <= maxPx, `portrait pixels ${out.width * out.height} <= ${maxPx}`);
|
||
assert.ok(out.height < 3000, 'height was reduced');
|
||
assert.ok(out.width < 1080, 'width was reduced');
|
||
assert.ok(Math.abs(out.width / out.height - 1080 / 3000) < 0.01, 'aspect preserved');
|
||
});
|
||
|
||
test('computeDownscale never upscales and never returns a zero dimension', () => {
|
||
assert.deepEqual(computeDownscale(10, 10, 1_000_000), { width: 10, height: 10 });
|
||
const tiny = computeDownscale(1, 1, 1);
|
||
assert.ok(tiny.width >= 1 && tiny.height >= 1);
|
||
});
|
||
|
||
test('computeDownscale is defensive against garbage input', () => {
|
||
const out = computeDownscale(0, 0, 0);
|
||
assert.ok(out.width >= 1 && out.height >= 1);
|
||
const nan = computeDownscale(NaN, NaN, NaN);
|
||
assert.ok(nan.width >= 1 && nan.height >= 1);
|
||
});
|
||
|
||
test('estimateDataUrlBytes decodes base64 length minus the data-URL prefix', () => {
|
||
// "AAAA" (4 base64 chars, no padding) = 3 bytes.
|
||
assert.equal(estimateDataUrlBytes('data:image/jpeg;base64,AAAA'), 3);
|
||
// one '=' pad => 2 bytes; two '==' pads => 1 byte
|
||
assert.equal(estimateDataUrlBytes('data:image/jpeg;base64,AAA='), 2);
|
||
assert.equal(estimateDataUrlBytes('data:image/jpeg;base64,AA=='), 1);
|
||
});
|
||
|
||
test('estimateDataUrlBytes handles a raw base64 string with no comma prefix', () => {
|
||
assert.equal(estimateDataUrlBytes('AAAA'), 3);
|
||
});
|
||
|
||
test('estimateDataUrlBytes is safe on non-strings', () => {
|
||
assert.equal(estimateDataUrlBytes(null), 0);
|
||
assert.equal(estimateDataUrlBytes(undefined), 0);
|
||
assert.equal(estimateDataUrlBytes(12345), 0);
|
||
});
|
||
|
||
test('estimateDataUrlBytes flags a payload over the 200KB ceiling', () => {
|
||
const LIMIT = 200 * 1024;
|
||
// ~300 KB of base64 (each char ~0.75 bytes) decodes well over the ceiling.
|
||
const big = 'data:image/jpeg;base64,' + 'A'.repeat(300 * 1024);
|
||
assert.ok(estimateDataUrlBytes(big) > LIMIT);
|
||
// A small one stays under.
|
||
const small = 'data:image/jpeg;base64,' + 'A'.repeat(1024);
|
||
assert.ok(estimateDataUrlBytes(small) < LIMIT);
|
||
});
|
||
|
||
// --- M14: item_not_found from a stale viewport-delete must be non-fatal ---
|
||
|
||
test('isBenignViewportDeleteError matches an item_not_found by code', () => {
|
||
const payload = { type: 'error', error: { code: 'item_not_found' } };
|
||
assert.equal(isBenignViewportDeleteError(payload, new Set()), true);
|
||
});
|
||
|
||
test('isBenignViewportDeleteError matches an echoed delete event_id even without the code', () => {
|
||
const pending = new Set(['evt_del_abc']);
|
||
const payload = { type: 'error', event_id: 'evt_del_abc', error: { code: 'server_error' } };
|
||
assert.equal(isBenignViewportDeleteError(payload, pending), true);
|
||
});
|
||
|
||
test('isBenignViewportDeleteError does NOT swallow unrelated errors', () => {
|
||
const pending = new Set(['evt_del_abc']);
|
||
// Different code, event_id we never issued → must stay fatal.
|
||
const payload = { type: 'error', event_id: 'evt_other', error: { code: 'invalid_request_error' } };
|
||
assert.equal(isBenignViewportDeleteError(payload, pending), false);
|
||
});
|
||
|
||
test('isBenignViewportDeleteError is false for non-error payloads and junk', () => {
|
||
assert.equal(isBenignViewportDeleteError({ type: 'response.done' }, new Set()), false);
|
||
assert.equal(isBenignViewportDeleteError(null, new Set()), false);
|
||
assert.equal(isBenignViewportDeleteError(undefined), false);
|
||
assert.equal(isBenignViewportDeleteError({ type: 'error' }, new Set()), false);
|
||
});
|
||
|
||
|
||
test('hidden document yields no fresh frame — capture must not label a stale canvas Current', async () => {
|
||
const originalDocument = globalThis.document;
|
||
let requested = 0;
|
||
const scene = {
|
||
postRender: { addEventListener() { return () => {}; } },
|
||
requestRender() { requested += 1; },
|
||
};
|
||
try {
|
||
globalThis.document = { hidden: true };
|
||
const fresh = await renderFreshCesiumFrame({ scene });
|
||
assert.equal(fresh, false, 'hidden capture reports non-fresh');
|
||
assert.equal(requested, 0, 'no secret render restart while hidden');
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
}
|
||
});
|
||
|
||
test('visible document with a rendering scene reports a fresh frame', async () => {
|
||
const originalDocument = globalThis.document;
|
||
try {
|
||
globalThis.document = { hidden: false };
|
||
let fire = null;
|
||
const scene = {
|
||
postRender: { addEventListener(listener) { fire = listener; return () => { fire = null; }; } },
|
||
requestRender() { queueMicrotask(() => fire?.()); },
|
||
};
|
||
const fresh = await renderFreshCesiumFrame({ scene });
|
||
assert.equal(fresh, true);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
}
|
||
});
|
||
|
||
test('a tab switch during the bounded render wait invalidates freshness', async () => {
|
||
const originalDocument = globalThis.document;
|
||
try {
|
||
const doc = { hidden: false };
|
||
globalThis.document = doc;
|
||
let fire = null;
|
||
const scene = {
|
||
postRender: { addEventListener(listener) { fire = listener; return () => { fire = null; }; } },
|
||
requestRender() { doc.hidden = true; queueMicrotask(() => fire?.()); },
|
||
};
|
||
const fresh = await renderFreshCesiumFrame({ scene });
|
||
assert.equal(fresh, false, 'freshness rechecked after the await');
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
}
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Voice cost control — persistence.
|
||
// The stored tier picks the OpenAI model id for the next session and the stored
|
||
// limits arm the spend cap, so both must survive corruption without either
|
||
// throwing or silently disarming the guard.
|
||
// ---------------------------------------------------------------------------
|
||
|
||
/** Minimal in-memory localStorage stand-in. */
|
||
function fakeVoiceStorage(seed = {}) {
|
||
const map = new Map(Object.entries(seed));
|
||
return {
|
||
getItem: (key) => (map.has(key) ? map.get(key) : null),
|
||
setItem: (key, value) => map.set(key, String(value)),
|
||
dump: () => Object.fromEntries(map),
|
||
};
|
||
}
|
||
|
||
test('voice tier round-trips through storage', () => {
|
||
const storage = fakeVoiceStorage();
|
||
assert.equal(writeStoredVoiceTier('mini', storage), 'mini');
|
||
assert.equal(readStoredVoiceTier(storage), 'mini');
|
||
assert.equal(writeStoredVoiceTier('standard', storage), 'standard');
|
||
assert.equal(readStoredVoiceTier(storage), 'standard');
|
||
});
|
||
|
||
test('an unset or hand-edited tier reads back as standard', () => {
|
||
assert.equal(readStoredVoiceTier(fakeVoiceStorage()), 'standard');
|
||
assert.equal(
|
||
readStoredVoiceTier(fakeVoiceStorage({ 'godsEyeView.voiceCost.tier': 'gpt-4o' })),
|
||
'standard'
|
||
);
|
||
assert.equal(
|
||
readStoredVoiceTier(fakeVoiceStorage({ 'godsEyeView.voiceCost.tier': '__proto__' })),
|
||
'standard'
|
||
);
|
||
});
|
||
|
||
test('writing a bogus tier persists the safe fallback, not the bogus value', () => {
|
||
const storage = fakeVoiceStorage();
|
||
assert.equal(writeStoredVoiceTier('turbo', storage), 'standard');
|
||
assert.equal(storage.dump()['godsEyeView.voiceCost.tier'], 'standard');
|
||
});
|
||
|
||
test('a storage that throws never breaks the mic', () => {
|
||
const hostile = {
|
||
getItem() {
|
||
throw new Error('SecurityError');
|
||
},
|
||
setItem() {
|
||
throw new Error('SecurityError');
|
||
},
|
||
};
|
||
assert.equal(readStoredVoiceTier(hostile), 'standard');
|
||
assert.equal(writeStoredVoiceTier('mini', hostile), 'mini');
|
||
assert.deepEqual(readStoredVoiceLimits(hostile), { warnUsd: 2, capUsd: 5 });
|
||
});
|
||
|
||
test('spend limits round-trip as one object', () => {
|
||
const storage = fakeVoiceStorage();
|
||
writeStoredVoiceLimits({ warnUsd: 1, capUsd: 3 }, storage);
|
||
assert.deepEqual(readStoredVoiceLimits(storage), { warnUsd: 1, capUsd: 3 });
|
||
});
|
||
|
||
test('corrupt stored limits fall back to defaults rather than disarming the cap', () => {
|
||
// A disarmed cap is the dangerous failure — assert we land on the default,
|
||
// not on Infinity.
|
||
const limits = readStoredVoiceLimits(
|
||
fakeVoiceStorage({ 'godsEyeView.voiceCost.limits': '{oops' })
|
||
);
|
||
assert.deepEqual(limits, { warnUsd: 2, capUsd: 5 });
|
||
});
|
||
|
||
test('partially stored limits keep the default for the missing threshold', () => {
|
||
const limits = readStoredVoiceLimits(
|
||
fakeVoiceStorage({ 'godsEyeView.voiceCost.limits': '{"warnUsd":0.5}' })
|
||
);
|
||
assert.deepEqual(limits, { warnUsd: 0.5, capUsd: 5 });
|
||
});
|
||
|
||
test('a disabled threshold survives the storage round-trip', () => {
|
||
// Infinity JSON-serializes to null, which reads back as "absent" and restores
|
||
// the DEFAULT — silently re-arming a cap the user turned off. The 'off'
|
||
// sentinel is what makes disabling persist.
|
||
const storage = fakeVoiceStorage();
|
||
writeStoredVoiceLimits({ warnUsd: 0, capUsd: 0 }, storage);
|
||
const raw = storage.dump()['godsEyeView.voiceCost.limits'];
|
||
assert.ok(!raw.includes('null'), `must not persist null: ${raw}`);
|
||
const restored = readStoredVoiceLimits(storage);
|
||
assert.equal(restored.warnUsd, Infinity);
|
||
assert.equal(restored.capUsd, Infinity);
|
||
});
|
||
|
||
test('one disabled and one live threshold both round-trip', () => {
|
||
const storage = fakeVoiceStorage();
|
||
writeStoredVoiceLimits({ warnUsd: 0, capUsd: 7 }, storage);
|
||
const restored = readStoredVoiceLimits(storage);
|
||
assert.equal(restored.warnUsd, Infinity);
|
||
assert.equal(restored.capUsd, 7);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Voice cost control — REAL handlers driven by a mocked Realtime event stream.
|
||
// These exercise updateResponseState / handleRealtimeEvent / stop() rather than
|
||
// the pure module, because the bugs they pin were all in the wiring.
|
||
// ---------------------------------------------------------------------------
|
||
|
||
/** Usage worth exactly $`usd` on STANDARD rates (audio out is $64/1M). */
|
||
const usdUsage = (usd) => ({
|
||
input_tokens: 0,
|
||
output_tokens: 15625 * usd,
|
||
output_token_details: { text_tokens: 0, audio_tokens: 15625 * usd },
|
||
});
|
||
|
||
/** A controller wired to inert UI stubs, with the cost surface present. */
|
||
function costControllerHarness({ runner } = {}) {
|
||
const toolCalls = [];
|
||
const ui = {
|
||
root: { dataset: {}, classList: { remove() {}, add() {} }, querySelectorAll: () => [] },
|
||
status: { textContent: '' },
|
||
detail: { textContent: '', title: '' },
|
||
errorDetail: { textContent: '' },
|
||
button: { dataset: {} },
|
||
buttonLabel: { textContent: '' },
|
||
tierButton: {
|
||
textContent: '',
|
||
title: '',
|
||
attrs: {},
|
||
setAttribute(key, value) { this.attrs[key] = value; },
|
||
getAttribute(key) { return this.attrs[key] ?? null; },
|
||
},
|
||
costValue: { textContent: '', title: '', dataset: {} },
|
||
};
|
||
const controller = new GevRealtimeController({
|
||
ui,
|
||
runner: runner || (async (name) => { toolCalls.push(name); return { ok: true }; }),
|
||
});
|
||
controller.debugLog = () => {};
|
||
controller.updateVoiceButtonLabel = () => {};
|
||
return { controller, ui, toolCalls };
|
||
}
|
||
|
||
const doneEvent = (usage) => ({
|
||
data: JSON.stringify({
|
||
type: 'response.done',
|
||
response: { id: 'r1', status: 'completed', usage },
|
||
}),
|
||
});
|
||
|
||
const fnCallEvent = (name, itemId, callId) => ({
|
||
data: JSON.stringify({
|
||
type: 'response.function_call_arguments.done',
|
||
item_id: itemId,
|
||
call_id: callId,
|
||
name,
|
||
arguments: '{}',
|
||
}),
|
||
});
|
||
|
||
test('F1: toggling tier mid-session does not erase accrued spend', () => {
|
||
const { controller } = costControllerHarness();
|
||
controller.status = 'listening'; // live session
|
||
controller.costTracker = createVoiceCostTracker({
|
||
modelId: 'gpt-realtime-2',
|
||
limits: { warnUsd: 2, capUsd: 5 },
|
||
});
|
||
controller.recordUsage(usdUsage(3));
|
||
assert.ok(Math.abs(controller.costTracker.state().totalUsd - 3) < 1e-9);
|
||
|
||
controller.setVoiceTier('mini');
|
||
|
||
const after = controller.costTracker.state();
|
||
assert.ok(Math.abs(after.totalUsd - 3) < 1e-9, `accrued spend survived: ${after.totalUsd}`);
|
||
assert.equal(after.modelId, 'gpt-realtime-2', 'session keeps its original model binding');
|
||
});
|
||
|
||
test('F1: the cap still fires after a mid-session toggle, at the original rates', () => {
|
||
// The bug this pins: rebuilding the tracker on toggle reset the meter, so
|
||
// repeated toggles could hold a session under the cap forever.
|
||
const { controller } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
controller.costTracker = createVoiceCostTracker({
|
||
modelId: 'gpt-realtime-2',
|
||
limits: { warnUsd: 2, capUsd: 5 },
|
||
});
|
||
for (let i = 0; i < 4; i += 1) {
|
||
controller.recordUsage(usdUsage(1));
|
||
controller.setVoiceTier(i % 2 === 0 ? 'mini' : 'standard'); // toggle spam
|
||
}
|
||
assert.equal(controller.costTracker.state().capReached, false, '$4 is under the cap');
|
||
controller.recordUsage(usdUsage(1)); // $5 — crosses
|
||
assert.equal(controller.costTracker.state().capReached, true);
|
||
assert.equal(controller.isSessionEnding(), true);
|
||
});
|
||
|
||
test('F1: the toggle still records the next-session preference while live', () => {
|
||
const { controller, ui } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
controller.setVoiceTier('mini');
|
||
assert.equal(controller.voiceTier, 'mini');
|
||
assert.equal(ui.tierButton.textContent, 'MINI');
|
||
// ...and says so, rather than implying the live session switched.
|
||
assert.match(ui.tierButton.title, /this session stays on/i);
|
||
});
|
||
|
||
test('F1: when idle, toggling does re-price the preview meter', () => {
|
||
const { controller } = costControllerHarness();
|
||
controller.status = 'idle';
|
||
controller.setVoiceTier('mini');
|
||
assert.equal(controller.costTracker.state().modelId, 'gpt-realtime-2.1-mini');
|
||
});
|
||
|
||
test('F4: once the cap latches, queued function calls do not execute', async () => {
|
||
const { controller, toolCalls } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
controller.costCapStopped = true; // latched by a prior cap
|
||
await controller.handleRealtimeEvent({
|
||
data: JSON.stringify({
|
||
type: 'response.function_call_arguments.done',
|
||
item_id: 'i1',
|
||
call_id: 'c1',
|
||
name: 'fly_to_location',
|
||
arguments: '{"query":"London"}',
|
||
}),
|
||
});
|
||
assert.deepEqual(toolCalls, [], 'no map mutation after the session ended');
|
||
});
|
||
|
||
test('F4: a cap between tool events stops every later tool', async () => {
|
||
// The real sequence this guards. Function-call events arrive BEFORE the
|
||
// response.done that carries usage, so tool N runs, the cap then trips, and
|
||
// tool N+1 must not dispatch. extractFunctionCalls yields at most one call
|
||
// per event, so this across-events path is the only reachable one — the
|
||
// single pre-loop gate covers it, and there is no per-iteration check.
|
||
const executed = [];
|
||
const { controller } = costControllerHarness({
|
||
runner: async (name) => { executed.push(name); return { ok: true }; },
|
||
});
|
||
controller.status = 'listening';
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
controller.costTracker = createVoiceCostTracker({
|
||
modelId: 'gpt-realtime-2',
|
||
limits: { warnUsd: 2, capUsd: 5 },
|
||
});
|
||
|
||
await controller.handleRealtimeEvent(fnCallEvent('set_hud', 'i1', 'c1'));
|
||
assert.deepEqual(executed, ['set_hud'], 'healthy session executes normally');
|
||
|
||
await controller.handleRealtimeEvent(doneEvent(usdUsage(9))); // trips the cap
|
||
assert.equal(controller.isSessionEnding(), true);
|
||
|
||
await controller.handleRealtimeEvent(fnCallEvent('fly_to_location', 'i2', 'c2'));
|
||
assert.deepEqual(executed, ['set_hud'], 'no map mutation dispatched after the cap');
|
||
});
|
||
|
||
test('F4: tools DO execute normally while the session is healthy', async () => {
|
||
// Guards the gate against being trivially always-on.
|
||
const { controller, toolCalls } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
await controller.handleRealtimeEvent({
|
||
data: JSON.stringify({
|
||
type: 'response.function_call_arguments.done',
|
||
item_id: 'i2',
|
||
call_id: 'c2',
|
||
name: 'fly_to_location',
|
||
arguments: '{"query":"London"}',
|
||
}),
|
||
});
|
||
assert.deepEqual(toolCalls, ['fly_to_location']);
|
||
});
|
||
|
||
test('F4: an output_item.done arriving after the cap does not execute either', async () => {
|
||
// The other extractor path (response.output_item.done), same guarantee.
|
||
const { controller, toolCalls } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
controller.costCapStopped = true;
|
||
await controller.handleRealtimeEvent({
|
||
data: JSON.stringify({
|
||
type: 'response.output_item.done',
|
||
item: {
|
||
type: 'function_call',
|
||
id: 'i4',
|
||
call_id: 'c4',
|
||
name: 'set_layer_visibility',
|
||
arguments: '{"layerId":"flights","enabled":true}',
|
||
},
|
||
}),
|
||
});
|
||
assert.deepEqual(toolCalls, []);
|
||
});
|
||
|
||
test('F5: teardown always closes the channel, in one step', () => {
|
||
// The drain that used to live here could not work: stop() closes the peer
|
||
// connection immediately after, which closes the data channels a drain would
|
||
// listen on. Teardown is now unconditional and single-step.
|
||
const { controller } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
let closed = false;
|
||
let pcClosed = false;
|
||
controller.responseActive = true;
|
||
controller.dc = { readyState: 'open', send() {}, close() { closed = true; } };
|
||
controller.pc = { close() { pcClosed = true; } };
|
||
controller.stop();
|
||
assert.equal(closed, true, 'data channel closed');
|
||
assert.equal(pcClosed, true, 'peer connection closed');
|
||
assert.equal(controller.dc, null);
|
||
assert.equal(controller.pc, null);
|
||
});
|
||
|
||
test('F5: a response in flight at teardown marks the accounting INCOMPLETE', () => {
|
||
// We have no token telemetry for an unfinished response, so we flag the
|
||
// accounting as partial rather than inventing a number for it. Deliberately
|
||
// not framed as a floor — the estimate can also run high.
|
||
const { controller } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
controller.costTracker = createVoiceCostTracker({
|
||
modelId: 'gpt-realtime-2',
|
||
limits: { warnUsd: 2, capUsd: 5 },
|
||
});
|
||
controller.recordUsage(usdUsage(1));
|
||
controller.responseActive = true;
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
controller.stop();
|
||
const state = controller.costTracker.state();
|
||
assert.equal(state.incomplete, true);
|
||
assert.equal(state.display, '~$1.00*', 'see-note mark, not a direction claim');
|
||
assert.match(state.note, /incomplete/i, 'the tooltip explains why');
|
||
assert.doesNotMatch(state.note, /at least|lower bound|floor/i, 'no floor claim');
|
||
});
|
||
|
||
test('F5: a clean teardown does not mark the total incomplete', () => {
|
||
const { controller } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
controller.costTracker = createVoiceCostTracker({ modelId: 'gpt-realtime-2' });
|
||
controller.recordUsage(usdUsage(1));
|
||
controller.responseActive = false;
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
controller.stop();
|
||
assert.equal(controller.costTracker.state().incomplete, false);
|
||
assert.equal(controller.costTracker.state().display, '~$1.00');
|
||
assert.equal(controller.costTracker.state().note, null, 'no note when complete');
|
||
});
|
||
|
||
test('F2/F5: no stray message listener survives teardown to double-meter', () => {
|
||
// The removed drain attached a SECOND 'message' listener while the normal
|
||
// handler stayed attached, so a late response.done was metered twice.
|
||
const { controller } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
const added = [];
|
||
controller.responseActive = true;
|
||
controller.dc = {
|
||
readyState: 'open',
|
||
send() {},
|
||
close() {},
|
||
addEventListener(type) { added.push(type); },
|
||
removeEventListener() {},
|
||
};
|
||
controller.stop();
|
||
assert.deepEqual(added, [], 'teardown attaches no new listeners');
|
||
});
|
||
|
||
test('F3: setVoiceTier does NOT rebuild the tracker while transport is live', () => {
|
||
// 'error' reports !isActive() but can still hold an open channel delivering a
|
||
// late response.done — rebuilding there sends that usage to a preview tracker.
|
||
const { controller } = costControllerHarness();
|
||
controller.costTracker = createVoiceCostTracker({
|
||
modelId: 'gpt-realtime-2',
|
||
limits: { warnUsd: 2, capUsd: 5 },
|
||
});
|
||
controller.recordUsage(usdUsage(3));
|
||
controller.status = 'error';
|
||
controller.dc = { readyState: 'open', send() {}, close() {} };
|
||
assert.equal(controller.isVoiceSessionSettled(), false);
|
||
|
||
controller.setVoiceTier('mini');
|
||
|
||
const state = controller.costTracker.state();
|
||
assert.ok(Math.abs(state.totalUsd - 3) < 1e-9, `spend survived: ${state.totalUsd}`);
|
||
assert.equal(state.modelId, 'gpt-realtime-2');
|
||
});
|
||
|
||
test('F3: once fully settled, setVoiceTier does rebuild the preview tracker', () => {
|
||
const { controller } = costControllerHarness();
|
||
controller.status = 'idle';
|
||
controller.dc = null;
|
||
controller.pc = null;
|
||
assert.equal(controller.isVoiceSessionSettled(), true);
|
||
controller.setVoiceTier('mini');
|
||
assert.equal(controller.costTracker.state().modelId, 'gpt-realtime-2.1-mini');
|
||
});
|
||
|
||
test('F4: two clicks during a live session return to the original preference', () => {
|
||
// The bug: toggleVoiceTier() derived the next tier from the immutable live
|
||
// TRACKER, so every click during a standard session selected 'mini' again.
|
||
const { controller, ui } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
controller.costTracker = createVoiceCostTracker({ modelId: 'gpt-realtime-2' });
|
||
controller.voiceTier = 'standard';
|
||
|
||
controller.toggleVoiceTier();
|
||
assert.equal(controller.voiceTier, 'mini', 'first click switches to mini');
|
||
|
||
controller.toggleVoiceTier();
|
||
assert.equal(controller.voiceTier, 'standard', 'second click switches back');
|
||
assert.equal(ui.tierButton.textContent, 'STD');
|
||
});
|
||
|
||
test('F4: the toggle alternates across many clicks mid-session', () => {
|
||
const { controller } = costControllerHarness();
|
||
controller.status = 'listening';
|
||
controller.costTracker = createVoiceCostTracker({ modelId: 'gpt-realtime-2' });
|
||
controller.voiceTier = 'standard';
|
||
const seen = [];
|
||
for (let i = 0; i < 4; i += 1) seen.push(controller.toggleVoiceTier());
|
||
assert.deepEqual(seen, ['mini', 'standard', 'mini', 'standard']);
|
||
});
|
||
|
||
test('F3: an unrecognised session model bills at the most expensive known rates', () => {
|
||
// An env override can point a tier at any model id; pricing it cheap (or
|
||
// free) is what lets a cap be overrun.
|
||
const tracker = createVoiceCostTracker({
|
||
modelId: 'gpt-realtime-9-experimental',
|
||
limits: { warnUsd: 2, capUsd: 5 },
|
||
});
|
||
assert.equal(tracker.state().ratesRecognized, false);
|
||
const standard = createVoiceCostTracker({ modelId: 'gpt-realtime-2' });
|
||
const unknownCost = tracker.record(usdUsage(1)).totalUsd;
|
||
const standardCost = standard.record(usdUsage(1)).totalUsd;
|
||
assert.ok(unknownCost >= standardCost, 'never cheaper than the priciest known model');
|
||
});
|
||
|
||
/**
|
||
* The Realtime API rejects a second concurrent `response.create`
|
||
* (`conversation_already_has_active_response`) and the rejected turn is lost.
|
||
* Every client trigger goes through the in-flight guard except the typed-command
|
||
* path, which fired straight out — so a typed command landing mid-answer was
|
||
* silently dropped instead of answered.
|
||
*/
|
||
function textCommandController() {
|
||
const sent = [];
|
||
const controller = new GevRealtimeController({
|
||
ui: {},
|
||
runner: async () => ({}),
|
||
});
|
||
controller.dc = { readyState: 'open' };
|
||
controller.sendRealtimeEvent = (event, label) => {
|
||
sent.push(label || event?.type);
|
||
return true;
|
||
};
|
||
controller.debugLog = () => {};
|
||
controller.cancelRadioHandoff = () => {};
|
||
return { controller, sent };
|
||
}
|
||
|
||
test('a typed command mid-response defers its turn instead of colliding', () => {
|
||
const { controller, sent } = textCommandController();
|
||
controller.responseActive = true;
|
||
controller.sendTextCommand('zoom to the globe');
|
||
assert.deepEqual(sent, ['client.user_text'], 'no second response.create while one is active');
|
||
assert.equal(controller.pendingUserTextResponse, true);
|
||
});
|
||
|
||
test('the deferred typed turn is answered once when the active response finishes', () => {
|
||
const { controller, sent } = textCommandController();
|
||
controller.responseActive = true;
|
||
controller.sendTextCommand('zoom to the globe');
|
||
controller.setVoiceSpeaker = () => {};
|
||
controller.recordUsage = () => {};
|
||
controller.updateResponseState({ type: 'response.done', response: { status: 'completed' } });
|
||
assert.deepEqual(sent, ['client.user_text', 'client.response_create.user_text']);
|
||
assert.equal(controller.pendingUserTextResponse, false);
|
||
// A second completion must not produce a second answer to the same command.
|
||
controller.updateResponseState({ type: 'response.done', response: { status: 'completed' } });
|
||
assert.deepEqual(sent, ['client.user_text', 'client.response_create.user_text']);
|
||
});
|
||
|
||
test('a typed command with nothing in flight is answered immediately', () => {
|
||
const { controller, sent } = textCommandController();
|
||
controller.sendTextCommand('zoom to the globe');
|
||
assert.deepEqual(sent, ['client.user_text', 'client.response_create.user_text']);
|
||
assert.equal(controller.responseCreatePending, true);
|
||
});
|
||
|
||
test('an overlapping-response rejection is dropped, never replayed', () => {
|
||
const { controller, sent } = textCommandController();
|
||
controller.responseActive = true;
|
||
controller.sendTextCommand('zoom to the globe');
|
||
controller.setStatus = () => {};
|
||
controller.handleRealtimeEvent({
|
||
data: JSON.stringify({
|
||
type: 'error',
|
||
error: { type: 'invalid_request_error', code: 'conversation_already_has_active_response' },
|
||
}),
|
||
});
|
||
assert.equal(controller.pendingUserTextResponse, false, 'a rejected turn must not re-arm itself');
|
||
controller.setVoiceSpeaker = () => {};
|
||
controller.recordUsage = () => {};
|
||
controller.updateResponseState({ type: 'response.done', response: { status: 'completed' } });
|
||
assert.deepEqual(sent, ['client.user_text'], 'and must not speak the same turn again');
|
||
});
|
||
|
||
/** A late function call from response `responseId`, as the server sends it. */
|
||
function lateToolEvent(responseId, callId) {
|
||
return {
|
||
data: JSON.stringify({
|
||
type: 'response.function_call_arguments.done',
|
||
response_id: responseId,
|
||
call_id: callId,
|
||
name: 'fly_to_location',
|
||
arguments: '{"query":"Paris"}',
|
||
}),
|
||
};
|
||
}
|
||
|
||
/** Wire the dispatch collaborators a bare controller does not have in a unit test. */
|
||
function toolDispatchController() {
|
||
const { controller, sent } = textCommandController();
|
||
const dispatched = [];
|
||
controller.runner = async (name) => { dispatched.push(name); return { ok: true }; };
|
||
controller.setStatus = () => {};
|
||
controller.setVoiceSpeaker = () => {};
|
||
controller.recordUsage = () => {};
|
||
controller.captureViewportScreenshot = async () => null;
|
||
return { controller, sent, dispatched };
|
||
}
|
||
|
||
test('CONTROL: a live response’s function call is dispatched normally', async () => {
|
||
const { controller, dispatched } = toolDispatchController();
|
||
controller.updateResponseState({ type: 'response.created', response: { id: 'resp_live' } });
|
||
await controller.handleRealtimeEvent(lateToolEvent('resp_live', 'call_live'));
|
||
assert.deepEqual(dispatched, ['fly_to_location'], 'the guard must not block ordinary tool calls');
|
||
});
|
||
|
||
test('a typed command supersedes the old response, so its late tools never fire', async () => {
|
||
const { controller, sent, dispatched } = toolDispatchController();
|
||
controller.updateResponseState({ type: 'response.created', response: { id: 'resp_old' } });
|
||
assert.equal(controller.activeResponseId, 'resp_old');
|
||
|
||
controller.sendTextCommand('stop');
|
||
assert.equal(controller.isSupersededResponse('resp_old'), true);
|
||
|
||
// The same event the control case dispatched, now belonging to a turn the
|
||
// operator has replaced.
|
||
await controller.handleRealtimeEvent(lateToolEvent('resp_old', 'call_stale'));
|
||
assert.deepEqual(dispatched, [], 'a stale turn must not mutate the map after a newer command');
|
||
// The call is REFUSED, not ignored: it is still answered (see the terminal
|
||
// output pin below), but nothing about it creates a response.
|
||
assert.deepEqual(sent, ['client.user_text', 'client.function_call_output']);
|
||
assert.equal(
|
||
sent.filter((label) => label.startsWith('client.response_create')).length,
|
||
0,
|
||
'the refusal must not produce an answer of its own',
|
||
);
|
||
});
|
||
|
||
test('a typed command drops the old response’s queued follow-up confirmation', () => {
|
||
const { controller, sent } = textCommandController();
|
||
controller.setVoiceSpeaker = () => {};
|
||
controller.recordUsage = () => {};
|
||
controller.updateResponseState({ type: 'response.created', response: { id: 'resp_old' } });
|
||
controller.queueResponseCreate('Briefly confirm the completed GEV action once.');
|
||
assert.ok(controller.pendingResponseInstructions, 'a follow-up is queued behind the active response');
|
||
|
||
controller.sendTextCommand('stop');
|
||
assert.equal(
|
||
controller.pendingResponseInstructions,
|
||
null,
|
||
'the stale confirmation is dropped — the typed turn is the single answer now',
|
||
);
|
||
|
||
controller.updateResponseState({ type: 'response.done', response: { status: 'completed' } });
|
||
assert.deepEqual(
|
||
sent,
|
||
['client.user_text', 'client.response_create.user_text'],
|
||
'exactly one response follows, and it answers the newest command',
|
||
);
|
||
});
|
||
|
||
test('a burst of typed commands coalesces into one answer, keeping both items', () => {
|
||
// Deliberate policy, pinned so it cannot drift: both commands stay in the
|
||
// conversation so the model sees the full intent, but they share one
|
||
// response rather than racing two.
|
||
const { controller, sent } = textCommandController();
|
||
controller.setVoiceSpeaker = () => {};
|
||
controller.recordUsage = () => {};
|
||
controller.responseActive = true;
|
||
controller.sendTextCommand('zoom to the globe');
|
||
controller.sendTextCommand('actually, show me Texas');
|
||
assert.deepEqual(sent, ['client.user_text', 'client.user_text'], 'both items are kept');
|
||
|
||
controller.updateResponseState({ type: 'response.done', response: { status: 'completed' } });
|
||
assert.deepEqual(sent, [
|
||
'client.user_text',
|
||
'client.user_text',
|
||
'client.response_create.user_text',
|
||
], 'and exactly one response covers the burst');
|
||
});
|
||
|
||
test('a live response is untouched when no typed command superseded it', () => {
|
||
const { controller } = textCommandController();
|
||
controller.setVoiceSpeaker = () => {};
|
||
controller.recordUsage = () => {};
|
||
controller.updateResponseState({ type: 'response.created', response: { id: 'resp_live' } });
|
||
assert.equal(controller.isSupersededResponse('resp_live'), false);
|
||
assert.equal(controller.isSupersededResponse(null), false, 'an unattributed call is not stale');
|
||
});
|
||
|
||
/** Observe the actual protocol output rather than replacing its implementation. */
|
||
function observeToolOutputs(controller, record) {
|
||
const send = controller.sendRealtimeEvent;
|
||
controller.sendRealtimeEvent = (message, label) => {
|
||
if (message.type === 'conversation.item.create' && message.item?.type === 'function_call_output') {
|
||
record(message.item.call_id, JSON.parse(message.item.output));
|
||
}
|
||
return send.call(controller, message, label);
|
||
};
|
||
}
|
||
|
||
test('a refused superseded call is still answered with a terminal output', async () => {
|
||
// Every function call must be answered. Leaving one unanswered strands a
|
||
// pending call in the conversation and deadlocks the model — the same hazard
|
||
// callDedupeKeys is written to avoid. Refusing is not ignoring.
|
||
const { controller, sent, dispatched } = toolDispatchController();
|
||
const outputs = [];
|
||
observeToolOutputs(controller, (callId, result) => outputs.push({ callId, result }));
|
||
controller.updateResponseState({ type: 'response.created', response: { id: 'resp_old' } });
|
||
controller.sendTextCommand('stop');
|
||
await controller.handleRealtimeEvent(lateToolEvent('resp_old', 'call_stale'));
|
||
|
||
assert.deepEqual(dispatched, [], 'the stale tool still must not run');
|
||
assert.equal(outputs.length, 1, 'exactly one terminal output for the refused call');
|
||
assert.equal(outputs[0].callId, 'call_stale');
|
||
assert.equal(outputs[0].result.ok, false);
|
||
assert.equal(outputs[0].result.superseded, true);
|
||
assert.equal(outputs[0].result.action, 'fly_to_location');
|
||
assert.ok(/superseded/i.test(outputs[0].result.error), 'and it says plainly why');
|
||
assert.equal(
|
||
sent.filter((label) => label === 'client.response_create.tool_followup').length,
|
||
0,
|
||
'a refused call must not create a response of its own',
|
||
);
|
||
});
|
||
|
||
/** The OTHER server surface for the same call: response.output_item.done. */
|
||
function lateToolItemEvent(responseId, callId, itemId = 'item_stale') {
|
||
return {
|
||
data: JSON.stringify({
|
||
type: 'response.output_item.done',
|
||
response_id: responseId,
|
||
item: {
|
||
type: 'function_call',
|
||
id: itemId,
|
||
call_id: callId,
|
||
name: 'fly_to_location',
|
||
arguments: '{"query":"Paris"}',
|
||
},
|
||
}),
|
||
};
|
||
}
|
||
|
||
test('the two server surfaces of one refused call collapse to a single output', async () => {
|
||
// The same call arrives as BOTH response.function_call_arguments.done and
|
||
// response.output_item.done. Replaying one type twice would only prove the
|
||
// event is idempotent; the collapse that matters is across surfaces, since
|
||
// two outputs for one call_id is its own protocol error.
|
||
const { controller } = toolDispatchController();
|
||
const outputs = [];
|
||
observeToolOutputs(controller, (callId) => outputs.push(callId));
|
||
controller.updateResponseState({ type: 'response.created', response: { id: 'resp_old' } });
|
||
controller.sendTextCommand('stop');
|
||
await controller.handleRealtimeEvent(lateToolEvent('resp_old', 'call_stale'));
|
||
await controller.handleRealtimeEvent(lateToolItemEvent('resp_old', 'call_stale'));
|
||
assert.deepEqual(outputs, ['call_stale'], 'exactly one output across both surfaces');
|
||
});
|
||
|
||
test('a genuinely different refused call still gets its own output', async () => {
|
||
// The collapse must key on call identity, not on "we already refused one".
|
||
const { controller } = toolDispatchController();
|
||
const outputs = [];
|
||
observeToolOutputs(controller, (callId) => outputs.push(callId));
|
||
controller.updateResponseState({ type: 'response.created', response: { id: 'resp_old' } });
|
||
controller.sendTextCommand('stop');
|
||
await controller.handleRealtimeEvent(lateToolEvent('resp_old', 'call_one'));
|
||
await controller.handleRealtimeEvent(lateToolItemEvent('resp_old', 'call_two', 'item_two'));
|
||
assert.deepEqual(outputs, ['call_one', 'call_two'], 'each distinct call is answered');
|
||
});
|
||
|
||
test('a claimed Space hold barges in on the assistant; a short tap never does', (t) => {
|
||
const f = createPushToTalkFixture(t);
|
||
const canvas = pushToTalkTarget({ tagName: 'CANVAS', id: 'world-overlay-canvas', tabIndex: 0 });
|
||
let bargeIns = 0;
|
||
f.controller._turns.bargeIn = () => {
|
||
bargeIns += 1;
|
||
return true;
|
||
};
|
||
// First hold starts the push-to-talk session; nothing to interrupt yet.
|
||
f.key('keydown', canvas);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
f.key('keyup', canvas);
|
||
assert.equal(bargeIns, 0);
|
||
// A short tap during the reply stays a tap.
|
||
f.key('keydown', canvas);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS - 1);
|
||
f.key('keyup', canvas);
|
||
assert.equal(bargeIns, 0);
|
||
// Only the 500 ms claim interrupts, and the microphone opens as before.
|
||
f.key('keydown', canvas);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.equal(bargeIns, 1);
|
||
assert.equal(f.microphone.enabled, true);
|
||
f.key('keyup', canvas);
|
||
// Radio's claim is read before Radio is paused, and a held handoff is
|
||
// never interrupted.
|
||
const order = [];
|
||
const input = f.controller._input;
|
||
input.mayClaimSpeaker = () => {
|
||
order.push('claim');
|
||
return false;
|
||
};
|
||
const pause = input.pauseRadioForVoice;
|
||
input.pauseRadioForVoice = (...args) => {
|
||
order.push('pause');
|
||
return pause(...args);
|
||
};
|
||
f.key('keydown', canvas);
|
||
f.advance(PUSH_TO_TALK_HOLD_DELAY_MS);
|
||
assert.deepEqual(order.slice(0, 2), ['claim', 'pause']);
|
||
assert.equal(bargeIns, 1, 'no barge-in while Radio holds the speaker');
|
||
f.key('keyup', canvas);
|
||
});
|
||
|
||
const testPlaceSearch = () => createStandalonePlaceSearch({ resolveApiKey: () => globalThis.window?.__GOOGLE_MAPS_API_KEY__ });
|
||
function createGevActionRunner(options) { return createActionRunner({ placeSearch: testPlaceSearch(), ...options }); }
|
||
function controlRadio(viewer, manager, args, options) { return runControlRadio(viewer, manager, args, { placeSearch: testPlaceSearch(), ...options }); }
|
||
|
||
test('voice runs app actions itself and other tools through the catalog', async () => {
|
||
const actions = [];
|
||
const runner = async (name, args) => {
|
||
actions.push([name, args]);
|
||
return { ok: true, action: name };
|
||
};
|
||
const resets = [];
|
||
const disposals = [];
|
||
runner.resetConversation = (...args) => {
|
||
resets.push(args);
|
||
return 'reset';
|
||
};
|
||
runner.dispose = (...args) => {
|
||
disposals.push(args);
|
||
return 'disposed';
|
||
};
|
||
const calls = [];
|
||
let loads = 0;
|
||
const catalog = {
|
||
get: (name) => (name === 'get_wind' ? { name } : undefined),
|
||
async call(name, args, options) {
|
||
calls.push([name, args, options.signal]);
|
||
return { summary: 'Calm.', data: { calm: true } };
|
||
},
|
||
};
|
||
const run = withToolCatalog(runner, async () => {
|
||
loads += 1;
|
||
return catalog;
|
||
});
|
||
const signal = new AbortController().signal;
|
||
assert.deepEqual(await run('zoom_to_globe', {}), {
|
||
ok: true,
|
||
action: 'zoom_to_globe',
|
||
});
|
||
assert.equal(loads, 0);
|
||
assert.deepEqual(
|
||
await run('get_wind', { location: { place: 'Oslo' } }, { signal }),
|
||
{ ok: true, tool: 'get_wind', summary: 'Calm.', data: { calm: true } },
|
||
);
|
||
assert.deepEqual(calls, [
|
||
['get_wind', { location: { place: 'Oslo' } }, signal],
|
||
]);
|
||
await run('not_a_tool', {});
|
||
assert.deepEqual(
|
||
actions.map(([name]) => name),
|
||
['zoom_to_globe', 'not_a_tool'],
|
||
);
|
||
assert.equal(run.resetConversation('stopped'), 'reset');
|
||
assert.equal(run.dispose('removed'), 'disposed');
|
||
assert.deepEqual(resets, [['stopped']]);
|
||
assert.deepEqual(disposals, [['removed']]);
|
||
assert.equal(withToolCatalog(runner, undefined), runner);
|
||
});
|