Skip to content

Commit 095936b

Browse files
committed
fix(voice): invalidate stale Codex availability probes
- Clear cached availability when the connection or provider changes - Ignore late responses from older probes
1 parent dfec2c7 commit 095936b

2 files changed

Lines changed: 148 additions & 2 deletions

File tree

Lines changed: 140 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,140 @@
1+
import { EnvironmentId, ProviderInstanceId } from "@t3tools/contracts";
2+
import { act, useLayoutEffect } from "react";
3+
import { create, type ReactTestRenderer } from "react-test-renderer";
4+
import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test";
5+
6+
const mocks = vi.hoisted(() => ({
7+
prepared: {} as object | null,
8+
run: vi.fn<
9+
(input: unknown, options: { signal: AbortSignal }) => Promise<{ codexVoiceAvailable: boolean }>
10+
>(),
11+
}));
12+
vi.mock("../state/session", () => ({
13+
usePreparedConnection: () =>
14+
mocks.prepared ? { _tag: "Some", value: mocks.prepared } : { _tag: "None" },
15+
}));
16+
vi.mock("../lib/runtime", () => ({ runtime: { runPromise: mocks.run } }));
17+
vi.mock("@t3tools/client-runtime/voice-input", () => ({ voiceAvailability: vi.fn() }));
18+
19+
import { useCodexVoiceAvailability } from "./codexVoiceAvailability";
20+
21+
const environmentId = EnvironmentId.make("env");
22+
const instanceA = ProviderInstanceId.make("codex-a");
23+
const instanceB = ProviderInstanceId.make("codex-b");
24+
let renderer: ReactTestRenderer;
25+
let value: ReturnType<typeof useCodexVoiceAvailability>;
26+
let requests: ReturnType<typeof deferredAvailability>[];
27+
28+
function deferredAvailability() {
29+
let resolve!: (response: { codexVoiceAvailable: boolean }) => void;
30+
let reject!: (error: Error) => void;
31+
const promise = new Promise<{ codexVoiceAvailable: boolean }>((resolvePromise, rejectPromise) => {
32+
resolve = resolvePromise;
33+
reject = rejectPromise;
34+
});
35+
return { promise, resolve, reject };
36+
}
37+
38+
function Probe({ instanceId = instanceA, enabled = true }) {
39+
const availability = useCodexVoiceAvailability(environmentId, instanceId, enabled);
40+
useLayoutEffect(() => {
41+
value = availability;
42+
});
43+
return null;
44+
}
45+
46+
beforeEach(() => {
47+
vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
48+
vi.stubGlobal("window", new EventTarget());
49+
vi.stubGlobal("document", Object.assign(new EventTarget(), { visibilityState: "visible" }));
50+
vi.spyOn(Date, "now").mockReturnValue(30_000);
51+
mocks.prepared = {};
52+
requests = [];
53+
mocks.run.mockReset().mockImplementation(() => {
54+
const request = deferredAvailability();
55+
requests.push(request);
56+
return request.promise;
57+
});
58+
act(() => {
59+
renderer = create(<Probe />);
60+
});
61+
});
62+
63+
afterEach(() => {
64+
act(() => renderer.unmount());
65+
vi.restoreAllMocks();
66+
vi.unstubAllGlobals();
67+
});
68+
69+
it.each([true, false])(
70+
"discards cached availability %s when switching A → B → A",
71+
async (available) => {
72+
await act(async () => requests[0]!.resolve({ codexVoiceAvailable: available }));
73+
expect(value.available).toBe(available);
74+
act(() => renderer.update(<Probe instanceId={instanceB} />));
75+
expect(value.available).toBeNull();
76+
act(() => renderer.update(<Probe />));
77+
expect(value.available).toBeNull();
78+
79+
await act(async () => requests[1]!.resolve({ codexVoiceAvailable: available }));
80+
expect(value.available).toBeNull();
81+
await act(async () => requests[2]!.resolve({ codexVoiceAvailable: !available }));
82+
expect(value.available).toBe(!available);
83+
},
84+
);
85+
86+
it("invalidates availability while disabled or disconnected and on reconnect", async () => {
87+
await act(async () => requests[0]!.resolve({ codexVoiceAvailable: true }));
88+
act(() => renderer.update(<Probe enabled={false} />));
89+
expect(value.available).toBe(false);
90+
act(() => renderer.update(<Probe />));
91+
expect(value.available).toBeNull();
92+
await act(async () => requests[1]!.resolve({ codexVoiceAvailable: true }));
93+
94+
mocks.prepared = null;
95+
act(() => renderer.update(<Probe />));
96+
expect(value.available).toBeNull();
97+
mocks.prepared = {};
98+
act(() => renderer.update(<Probe />));
99+
expect(value.available).toBeNull();
100+
await act(async () => requests[2]!.reject(new Error("unavailable")));
101+
expect(value.available).toBe(false);
102+
});
103+
104+
it("clears cached availability for a focus probe and preserves throttling", async () => {
105+
await act(async () => requests[0]!.resolve({ codexVoiceAvailable: true }));
106+
act(() => value.prepare());
107+
expect(requests).toHaveLength(1);
108+
expect(value.available).toBe(true);
109+
110+
vi.mocked(Date.now).mockReturnValue(45_000);
111+
act(() => window.dispatchEvent(new Event("focus")));
112+
expect(value.available).toBeNull();
113+
await act(async () => requests[1]!.resolve({ codexVoiceAvailable: false }));
114+
expect(value.available).toBe(false);
115+
});
116+
117+
it.each(["success", "failure"])("ignores an older probe's late %s", async (outcome) => {
118+
vi.mocked(Date.now).mockReturnValue(45_000);
119+
act(() => value.prepare());
120+
expect(requests).toHaveLength(2);
121+
await act(async () => requests[1]!.resolve({ codexVoiceAvailable: true }));
122+
await act(async () => {
123+
if (outcome === "success") requests[0]!.resolve({ codexVoiceAvailable: false });
124+
else requests[0]!.reject(new Error("old failure"));
125+
});
126+
expect(value.available).toBe(true);
127+
});
128+
129+
it("keeps prepare bound to the current effect and ignores aborted responses", async () => {
130+
const prepare = value.prepare;
131+
act(() => renderer.update(<Probe instanceId={instanceB} />));
132+
expect(mocks.run.mock.calls[0]![1].signal.aborted).toBe(true);
133+
vi.mocked(Date.now).mockReturnValue(45_000);
134+
act(() => prepare());
135+
expect(requests).toHaveLength(3);
136+
expect(mocks.run.mock.calls[2]![1].signal.aborted).toBe(false);
137+
await act(async () => requests[2]!.resolve({ codexVoiceAvailable: true }));
138+
await act(async () => requests[0]!.reject(new Error("aborted")));
139+
expect(value.available).toBe(true);
140+
});

‎apps/web/src/voice/codexVoiceAvailability.ts‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16,22 +16,28 @@ export function useCodexVoiceAvailability(
1616
const key = `${environmentId}:${instanceId}`;
1717
const [result, setResult] = useState<{ key: string; available: boolean } | null>(null);
1818
useEffect(() => {
19+
// oxlint-disable-next-line react/set-state-in-effect -- A new connection or probe lifetime invalidates the previous server response.
20+
setResult(null);
1921
if (!enabled) return;
2022
if (!prepared) return;
2123
lastWarm.current = 0;
2224
const aborter = new AbortController();
25+
let generation = 0;
2326
const warm = () => {
2427
if (document.visibilityState === "hidden" || Date.now() - lastWarm.current < 15_000) return;
2528
lastWarm.current = Date.now();
29+
const requestGeneration = ++generation;
30+
setResult(null);
2631
void runtime
2732
.runPromise(voiceAvailability(prepared, instanceId), { signal: aborter.signal })
2833
.then(
2934
(response) => {
30-
if (!aborter.signal.aborted)
35+
if (!aborter.signal.aborted && requestGeneration === generation)
3136
setResult({ key, available: response.codexVoiceAvailable });
3237
},
3338
() => {
34-
if (!aborter.signal.aborted) setResult({ key, available: false });
39+
if (!aborter.signal.aborted && requestGeneration === generation)
40+
setResult({ key, available: false });
3541
},
3642
);
3743
};

0 commit comments

Comments
 (0)