The best way to control Claude Code, Codex and more from any computer or phone

main
ts 207 lines 8.81 KB
Raw
1 import { it } from "@effect/vitest";
2 import { DEFAULT_SPEECH_TRANSCRIPTION_OPTIONS, SecretProviderId } from "@t3tools/contracts";
3 import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver";
4 import * as Effect from "effect/Effect";
5 import * as Fiber from "effect/Fiber";
6 import * as Layer from "effect/Layer";
7 import * as Redacted from "effect/Redacted";
8 import * as FetchHttpClient from "effect/http/FetchHttpClient";
9 import { expect, vi } from "vite-plus/test";
10 import * as ServerSettings from "../serverSettings.ts";
11 import * as CloudSpeech from "./CloudSpeech.ts";
12
13 it.effect.each(["openai", "xai"] as const)("sends only to %s using its own saved key", (provider) =>
14 Effect.gen(function* () {
15 const reference = {
16 provider: SecretProviderId.make("work"),
17 reference: "op://Work/Voice/key",
18 };
19 let resolved: string | undefined;
20 let cached: string | undefined;
21 const read = vi.fn(() => Effect.sync(() => [(cached ??= resolved)]));
22 const upstream = vi.fn<typeof fetch>(async () => Response.json({ text: "hello" }));
23 const service = yield* CloudSpeech.CloudSpeech.pipe(
24 Effect.provide(
25 CloudSpeech.layer.pipe(
26 Layer.provide(FetchHttpClient.layer),
27 Layer.provide(ServerSettings.ServerSettingsService.layerTest()),
28 Layer.provide(
29 Layer.mock(SecretResolver.SecretResolver)({
30 read,
31 label: () => Effect.succeed("Work"),
32 invalidate: () =>
33 Effect.sync(() => {
34 cached = undefined;
35 }),
36 }),
37 ),
38 ),
39 ),
40 );
41 // A full dictionary plus a hint still stays within xAI's 100-term limit.
42 const words = Array.from({ length: 99 }, (_, index) => `word${index}`);
43 const transcribe = (pcm = new Uint8Array(new Float32Array([0, 0.5]).buffer)) =>
44 service
45 .transcribe(provider, pcm, {
46 ...DEFAULT_SPEECH_TRANSCRIPTION_OPTIONS,
47 speechLanguage: "en",
48 speechCustomWords: ["T3 Code", ...words].map((term) => ({ term, aliases: [] })),
49 speechHints: ["Server"],
50 })
51 .pipe(Effect.provideService(FetchHttpClient.Fetch, upstream));
52 yield* service.setKey(provider === "openai" ? "xai" : "openai", Redacted.make("other"));
53 expect((yield* Effect.flip(transcribe()))._tag).toBe("CloudSpeechError");
54 yield* service.setKey(provider, Redacted.make("chosen"));
55 expect(yield* service.configured).toEqual({ openai: true, xai: true, openrouter: false });
56 yield* Effect.flip(transcribe(new Uint8Array(3)));
57 expect(upstream).not.toHaveBeenCalled();
58 expect(yield* transcribe()).toBe("hello");
59 const [url, init] = upstream.mock.calls[0]!;
60 expect(String(url)).toBe(
61 {
62 openai: "https://api.openai.com/v1/audio/transcriptions",
63 xai: "https://api.x.ai/v1/stt",
64 }[provider],
65 );
66 expect(init?.redirect).toBe("error");
67 expect(new Headers(init?.headers).get("authorization")).toBe("Bearer chosen");
68 const form = init?.body as FormData;
69 expect(form.get("model")).toBe(
70 provider === "openai" ? "gpt-transcribe" : "grok-voice-transcribe-2.0",
71 );
72 expect(form.getAll(provider === "openai" ? "keywords[]" : "keyterm")).toEqual([
73 "Server",
74 "T3 Code",
75 ...words.slice(0, 98),
76 ]);
77 expect(form.get(provider === "openai" ? "languages[]" : "language")).toBe("en");
78 expect([...form.keys()].at(-1)).toBe("file");
79 const wav = new DataView(yield* Effect.promise(() => (form.get("file") as Blob).arrayBuffer()));
80 expect(wav.getUint32(24, true)).toBe(16_000);
81 expect(wav.getInt16(46, true)).toBe(16384);
82 upstream.mockResolvedValueOnce(new Response("sensitive upstream diagnostic", { status: 401 }));
83 expect(yield* Effect.flip(transcribe())).toMatchObject({ provider, reason: "rejected-key" });
84 yield* service.setKey(provider, null);
85 expect((yield* service.configured)[provider]).toBe(false);
86 yield* Effect.flip(transcribe());
87 expect(upstream).toHaveBeenCalledTimes(2);
88 yield* service.setKey(provider, reference);
89 expect((yield* service.configured)[provider]).toBe(true);
90 expect(read).not.toHaveBeenCalled();
91 resolved = "resolved-fixture";
92 expect(yield* transcribe()).toBe("hello");
93 expect(read).toHaveBeenCalledWith([reference]);
94 expect(new Headers(upstream.mock.calls[2]?.[1]?.headers).get("authorization")).toBe(
95 "Bearer resolved-fixture",
96 );
97 resolved = undefined;
98 expect(yield* Effect.flip(transcribe())).toMatchObject({
99 provider,
100 reason: "unreadable-key",
101 });
102 expect(upstream).toHaveBeenCalledTimes(3);
103 }),
104 );
105
106 it.effect("uploads to OpenRouter only for a listed exact model, as zero-retention JSON WAV", () =>
107 Effect.gen(function* () {
108 const upstream = vi.fn<typeof fetch>(async (input) =>
109 new URL(String(input)).pathname.endsWith("/models")
110 ? Response.json({ data: [{ id: "acme/transcribe-1" }, { id: "acme/transcribe-2" }] })
111 : Response.json({ text: "hello" }),
112 );
113 const service = yield* CloudSpeech.CloudSpeech.pipe(
114 Effect.provide(
115 CloudSpeech.layer.pipe(
116 Layer.provide(FetchHttpClient.layer),
117 Layer.provide(ServerSettings.ServerSettingsService.layerTest()),
118 Layer.provide(Layer.mock(SecretResolver.SecretResolver)({})),
119 ),
120 ),
121 );
122 const uploads = () =>
123 upstream.mock.calls.filter(([url]) => String(url).endsWith("/audio/transcriptions"));
124 const transcribe = (model: string | undefined) =>
125 service
126 .transcribe(
127 "openrouter",
128 new Uint8Array(new Float32Array([0, 0.5]).buffer),
129 { ...DEFAULT_SPEECH_TRANSCRIPTION_OPTIONS, speechLanguage: "en" },
130 model,
131 )
132 .pipe(Effect.provideService(FetchHttpClient.Fetch, upstream));
133 yield* service.setKey("openrouter", Redacted.make("router-key"));
134 expect(yield* Effect.flip(transcribe(undefined))).toMatchObject({ provider: "openrouter" });
135 upstream.mockResolvedValueOnce(new Response(null, { status: 503 }));
136 expect(yield* Effect.flip(transcribe("acme/transcribe-2"))).toMatchObject({
137 reason: "unavailable",
138 });
139 expect(yield* Effect.flip(transcribe("acme/delisted"))).toMatchObject({
140 provider: "openrouter",
141 });
142 expect(uploads()).toEqual([]);
143 expect(yield* transcribe("acme/transcribe-2")).toBe("hello");
144 const [[url, init]] = uploads() as [[URL, RequestInit]];
145 expect(new URL(String(upstream.mock.calls[0]![0])).searchParams.get("zdr")).toBe("true");
146 expect(String(url)).toBe("https://openrouter.ai/api/v1/audio/transcriptions");
147 expect(init.redirect).toBe("error");
148 const headers = new Headers(init.headers);
149 expect(headers.get("authorization")).toBe("Bearer router-key");
150 expect(headers.get("content-type")).toContain("application/json");
151 const body = JSON.parse(yield* Effect.promise(() => new Response(init.body).text())) as {
152 model: string;
153 models?: unknown;
154 provider: { zdr: boolean };
155 input_audio: { format: string; data: string };
156 };
157 expect(body).toMatchObject({
158 model: "acme/transcribe-2",
159 provider: { zdr: true },
160 input_audio: { format: "wav" },
161 });
162 expect(body.models).toBeUndefined();
163 const wav = Buffer.from(body.input_audio.data, "base64");
164 expect(wav.toString("ascii", 0, 4)).toBe("RIFF");
165 expect(wav.readInt16LE(46)).toBe(16384);
166 }),
167 );
168
169 it.effect("removing a key while a catalog read is pending prevents the upload", () =>
170 Effect.gen(function* () {
171 const service = yield* CloudSpeech.CloudSpeech.pipe(
172 Effect.provide(
173 CloudSpeech.layer.pipe(
174 Layer.provide(FetchHttpClient.layer),
175 Layer.provide(ServerSettings.ServerSettingsService.layerTest()),
176 Layer.provide(Layer.mock(SecretResolver.SecretResolver)({})),
177 ),
178 ),
179 );
180 const catalogStarted = Promise.withResolvers<void>();
181 const catalog = Promise.withResolvers<Response>();
182 const uploads: string[] = [];
183 const upstream: typeof fetch = async (input) => {
184 if (new URL(String(input)).pathname.endsWith("/models")) {
185 catalogStarted.resolve();
186 return catalog.promise;
187 }
188 uploads.push(String(input));
189 return Response.json({ text: "unexpected" });
190 };
191 yield* service.setKey("openrouter", Redacted.make("old-key"));
192 const job = yield* service
193 .transcribe(
194 "openrouter",
195 new Uint8Array(4),
196 DEFAULT_SPEECH_TRANSCRIPTION_OPTIONS,
197 "acme/voice",
198 )
199 .pipe(Effect.provideService(FetchHttpClient.Fetch, upstream), Effect.forkChild);
200 yield* Effect.promise(() => catalogStarted.promise);
201 yield* service.setKey("openrouter", null);
202 catalog.resolve(Response.json({ data: [{ id: "acme/voice" }] }));
203 const exit = yield* Fiber.await(job);
204 expect(uploads).toEqual([]);
205 expect(exit._tag).toBe("Failure");
206 }),
207 );