The best way to control Claude Code, Codex and more from any computer or phone
| 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 | ); |