🤖 fix: respect direct OpenAI voice routing (#3090)

## Summary

Voice transcription now follows the same routing preference as OpenAI
models, so putting Direct ahead of Mux Gateway in Settings keeps voice
input on the direct OpenAI transcription endpoint.

## Background

`VoiceService` hardcoded a gateway-first choice whenever both a Mux
Gateway token and an OpenAI API key were present. That ignored Provider
settings, where users can prefer direct routing for OpenAI, and made
voice input unexpectedly go through Mux Gateway.

## Implementation

- route `openai:whisper-1` through the shared routing resolver using the
saved `routePriority` / `routeOverrides`
- keep voice transcription scoped to the backends it actually supports
today: direct OpenAI and Mux Gateway
- add a regression test covering the direct-before-gateway provider
ordering

## Validation

- `bun test src/node/services/voiceService.test.ts`
- `make typecheck`
- `make static-check`

## Risks

Low and localized to voice transcription backend selection. The change
only affects whether voice requests use direct OpenAI or Mux Gateway
when both are configured.

---

_Generated with `mux` • Model: `openai:gpt-5.4` • Thinking: `xhigh` •
Cost: `$unknown`_

<!-- mux-attribution: model=openai:gpt-5.4 thinking=xhigh costs=unknown
-->

Author: ammar-agent

src/node/services/voiceService.test.ts

@@ -192,6 +192,41 @@ describe("VoiceService.transcribe", () => {
     });
   });
 
+  it("respects direct-before-gateway route priority when both are configured", async () => {
+    await withTempConfig(async (config, service) => {
+      config.saveProvidersConfig({
+        "mux-gateway": {
+          couponCode: "gateway-token",
+        },
+        openai: {
+          apiKey: "sk-test",
+        },
+      });
+      await config.editConfig((cfg) => {
+        cfg.routePriority = ["direct", "mux-gateway"];
+        return cfg;
+      });
+
+      const fetchSpy = spyOn(globalThis, "fetch");
+      fetchSpy.mockResolvedValue(new Response("transcribed text"));
+
+      try {
+        const result = await service.transcribe("Zm9v");
+
+        expect(result).toEqual({ success: true, data: "transcribed text" });
+        expect(fetchSpy).toHaveBeenCalledTimes(1);
+
+        const [url, init] = fetchSpy.mock.calls[0] as [string, RequestInit | undefined];
+        expect(url).toBe("https://api.openai.com/v1/audio/transcriptions");
+        expect(init?.headers).toEqual({
+          Authorization: "Bearer sk-test",
+        });
+      } finally {
+        fetchSpy.mockRestore();
+      }
+    });
+  });
+
   it("falls back to OpenAI when gateway is disabled", async () => {
     await withTempConfig(async (config, service) => {
       config.saveProvidersConfig({

src/node/services/voiceService.ts

@@ -1,3 +1,4 @@
+import { resolveRoute } from "@/common/routing";
 import { MUX_GATEWAY_ORIGIN } from "@/common/constants/muxGatewayOAuth";
 import type { ExternalSecretResolver } from "@/common/types/secrets";
 import type { Result } from "@/common/types/result";
@@ -11,6 +12,8 @@ import { log } from "./log";
 
 const OPENAI_TRANSCRIPTION_URL = "https://api.openai.com/v1/audio/transcriptions";
 const MUX_GATEWAY_TRANSCRIPTION_PATH = "/api/v1/openai/v1/audio/transcriptions";
+const OPENAI_TRANSCRIPTION_MODEL = "openai:whisper-1";
+const DEFAULT_TRANSCRIPTION_ROUTE_PRIORITY = ["mux-gateway", "direct"];
 
 interface OpenAITranscriptionConfig {
   apiKey?: string;
@@ -63,12 +66,18 @@ export class VoiceService {
         !isProviderDisabledInConfig(openaiConfig ?? {}) &&
         !!openaiApiKey &&
         (this.policyService?.isProviderAllowed("openai") ?? true);
+      const transcriptionRoute = this.resolveTranscriptionRoute({
+        routePriority: mainConfig.routePriority,
+        routeOverrides: mainConfig.routeOverrides,
+        gatewayAvailable,
+        openaiAvailable,
+      });
 
-      if (gatewayAvailable) {
+      if (transcriptionRoute === "mux-gateway" && gatewayToken) {
         return await this.transcribeWithGateway(audioBase64, gatewayToken, gatewayConfig);
       }
 
-      if (openaiAvailable) {
+      if (transcriptionRoute === "openai" && openaiApiKey) {
         return await this.transcribeWithOpenAI(audioBase64, openaiApiKey, openaiConfig);
       }
 
@@ -91,6 +100,42 @@ export class VoiceService {
     }
   }
 
+  private resolveTranscriptionRoute(options: {
+    routePriority?: string[];
+    routeOverrides?: Record<string, string>;
+    gatewayAvailable: boolean;
+    openaiAvailable: boolean;
+  }): "mux-gateway" | "openai" | null {
+    // User rationale: when Settings routes OpenAI directly, voice transcription should use
+    // the same direct path instead of silently detouring through Mux Gateway.
+    const route = resolveRoute(
+      OPENAI_TRANSCRIPTION_MODEL,
+      options.routePriority ?? DEFAULT_TRANSCRIPTION_ROUTE_PRIORITY,
+      options.routeOverrides ?? {},
+      (provider) => {
+        if (provider === "mux-gateway") {
+          return options.gatewayAvailable;
+        }
+
+        if (provider === "openai") {
+          return options.openaiAvailable;
+        }
+
+        return false;
+      }
+    );
+
+    if (route.routeProvider === "mux-gateway" && options.gatewayAvailable) {
+      return "mux-gateway";
+    }
+
+    if (route.routeProvider === "openai" && options.openaiAvailable) {
+      return "openai";
+    }
+
+    return null;
+  }
+
   private async transcribeWithGateway(
     audioBase64: string,
     couponCode: string,