Wear OS: "Transcription failed" on Pixel Watch (tethered, OpenAI gpt-4o-mini-transcribe) — Try-it and keyboard

[DevEmperor]

Wear OS: "Transcription failed" on Pixel Watch — both the app's "Try it" and the Dictate keyboard

Forwarded from a user (Kseniya) 🙏 — she loves the new Wear OS integration but transcription fails on her Pixel Watch, both in the Dictate watch app's "Try it" test and in the Dictate keyboard when dictating a new note in Keep Notes on the watch. She gets a generic "Transcription failed" with no logs to go on.

When I try to create a new note in Keep Notes and dictate text, it gives me a "transcription failed" message. I also tried the "Try it" button in the Dictate app, but I get the same error without any logs to help me understand what's going wrong.

Screen recording (watch): https://drive.google.com/file/d/1WToGW5LzmuDV-wK-cG_u-gER40uJMn5S/view

Environment (read off the video)

• Pixel Watch, Wear OS · v5.0.0-w2 (build 100126) (round display).
• Dictate watch app main screen: "Phone connected · Transcribes via phone" → i.e. tethered mode.
• Provider shown: OpenAI · gpt-4o-mini-transcribe.
• Advanced: "Key on watch · Can dictate solo" toggle is ON; "Auto-reword" is off (Raw text).
• Setup checklist all green: Microphone ✓, Keyboard enabled ✓, Keyboard selected ✓.

What the video shows (step by step)

1. Opens the Dictate app on the watch → main screen already shows "Transcription failed" in red at the bottom.
2. Taps "Try it" → "Stop & transcribe" → "Transcribing…" → back to "Transcription failed".
3. Walks through Setup (all permissions ✓) and Advanced (Key on watch ON, Auto-reword off, "Re-sync from phone").
4. Opens Keep Notes → Create note, picks the Dictate keyboard, sees "Tap to dictate".
5. Records fine — waveform animates, timer runs (up to 0:09) — then taps stop.
6. Result: "Transcription failed" (red) under the mic. Repeats several times, always the same.

Key takeaways

• Recording itself works (mic permission ✓, waveform + timer are live). The failure is at the transcription step, after audio capture.
• It fails identically in the app test and the keyboard, and the watch is set to transcribe via the phone — so the failure is most likely on the phone-side transcription of the watch's audio, or the watch↔phone transport, not the mic.
• The only feedback is a generic "Transcription failed" — no HTTP status, no provider error. The reporter explicitly can't diagnose it, and neither can we from here.

Likely causes (ranked)

1. Phone-side transcription is failing and the watch just surfaces it. Most common root: the OpenAI account/key can't run gpt-4o-mini-transcribe — invalid key, no credit/quota (429), org not verified, or no access to that specific model. Would explain why every attempt fails instantly.
2. Tethered transport / audio-format issue (watch → phone). Since recording was switched to WAV (Proposal: Support single-call audio transcription + formatting using multimodal models (Chat Completions with input_audio) #130), if the phone's handling of watch-originated audio chokes on the format/size, watch dictation fails while phone dictation still works.
3. Standalone fallback despite the "via phone" label (watch has no working network/key of its own). Less likely given the explicit "Transcribes via phone".

The real blocker: no error detail on the watch

Regardless of root cause, the watch should propagate the phone-side error (HTTP status / provider message) instead of a blanket "Transcription failed". This is the DX gap the reporter is hitting — worth fixing so users can self-diagnose (e.g. "Invalid API key", "Quota exceeded", "Model not available").

Questions for the reporter (to narrow it down)

• Does dictation work directly on the phone (open Dictate on the phone and dictate) with the same OpenAI account? → distinguishes an account/key problem from a watch-transport bug.
• Does the OpenAI account have credit and access to gpt-4o-mini-transcribe? Try a different provider/model (e.g. Groq Whisper) to isolate.
• Does toggling "Key on watch / Can dictate solo" (standalone) change anything, given the watch is on Wi-Fi?

Next steps (dev)

• Surface the actual transcription error on the watch (propagate phone-side status/message).
• Verify the tethered watch→phone→provider path with the current WAV recording format.
• Confirm with the reporter whether phone-side dictation works with the same account.

[grapefruit89]

Hey! I took a look at this issue and wanted to help take some of the debugging workload off your shoulders.

Note

Workflow Transparency: I don't have deep Android development expertise myself, so I used the Google Antigravity desktop version. I cloned the repository locally, fed it the issue description, and had the AI assistant thoroughly analyze the codebase to trace where this is coming from. I've manually reviewed the findings to make sure this isn't just "AI slop" but an actual, accurate analysis that genuinely helps you fix the app! 🚀

Here is what we found and how to solve it:

🔍 The Root Cause Analysis

• The Audio Transport is fine: At first glance, one might suspect that the uncompressed WAV files (introduced in Proposal: Support single-call audio transcription + formatting using multimodal models (Chat Completions with input_audio) #130) are too large for Wear OS to transfer. However, looking at WearTranscription.kt and DictateWearService.kt, you are correctly using the ChannelClient (streaming) to send the audio to the phone, rather than the MessageClient. So the audio upload is perfectly intact.
• The User's Model Configuration: The reporter mentioned they are using "OpenAI · gpt-4o-mini-transcribe". OpenAI does not have an audio transcription model by this name (theirs is whisper-1; gpt-4o-mini is a chat model). Because of this, the OpenAI API is almost certainly returning an HTTP 404 (Not Found) or HTTP 400 (Bad Request).
• The Missing Error Propagation (The Bottleneck):
  1. When the API returns a 404 or 400, DictateApiException.fromHttp() doesn't explicitly catch it (it mostly looks for 401, 403, 429, etc.), so it falls back to Kind.UNKNOWN.
  2. On the phone, DictateWearService.kt maps Kind.UNKNOWN to DictateWearProtocol.RESP_ERROR.
  3. The phone then sends only the RESP_ERROR status byte to the watch, silently discarding the actual error message from the API.
  4. The watch (WearTranscription.kt) reads RESP_ERROR and throws the hardcoded Android string resource: "Transcription failed".

Important

Summary: The transcription correctly fails because the user configured an invalid model name, but the watch swallows the detailed error message, leaving the user guessing.

---

💡 The Solution (Code Snippets)

The great news is that your DictateWearProtocol architecture is already perfectly designed to handle this! The function encodeTranscribeResponse(status, text) already supports appending text to the payload, and the watch already parses it into TranscribeResponse.text. We just need to utilize it for errors.

Here are the specific lines that need to be changed:

1. On the Phone (DictateWearService.kt around line 104)

We just need to temporarily store the exception message in the transcript variable and pass it to the encoder.

         } catch (e: DictateApiException) {
             Log.e(TAG, "tether: phone transcription failed (${e.kind})", e)
             status = when (e.kind) {
                 DictateApiException.Kind.INVALID_API_KEY -> DictateWearProtocol.RESP_BAD_KEY
                 DictateApiException.Kind.QUOTA_EXCEEDED -> DictateWearProtocol.RESP_QUOTA
                 DictateApiException.Kind.NETWORK,
                 DictateApiException.Kind.TIMEOUT,
                 DictateApiException.Kind.SERVER_ERROR -> DictateWearProtocol.RESP_OFFLINE
                 else -> DictateWearProtocol.RESP_ERROR
             }
-            transcript = ""
+            transcript = e.message ?: ""
         } catch (e: Exception) {
             Log.e(TAG, "tether: phone transcription failed", e)
             status = DictateWearProtocol.RESP_ERROR
-            transcript = ""
+            transcript = e.message ?: ""
         } finally {
             audio.delete()
             channelClient.close(channel)
             
             val payload = if (status == DictateWearProtocol.RESP_OK) {
                 transcript.toByteArray(Charsets.UTF_8)
             } else {
-                DictateWearProtocol.encodeTranscribeResponse(status)
+                DictateWearProtocol.encodeTranscribeResponse(status, transcript)
             }
             
             Wearable.getMessageClient(applicationContext).sendMessage(

2. On the Watch (WearTranscription.kt around line 162)

In the toTranscriptOrThrow mapper function, instead of blindly falling back to the Android string, we can use the transmitted error text if it isn't blank:

     private fun DictateWearProtocol.TranscribeResponse.toTranscriptOrThrow(context: Context): String = when (status) {
         DictateWearProtocol.RESP_OK -> text.trim()
         DictateWearProtocol.RESP_NO_SPEECH -> throw TetherResultError(context.getString(R.string.wear_err_no_speech))
         DictateWearProtocol.RESP_BAD_KEY -> throw TetherResultError(context.getString(R.string.wear_err_bad_key))
         DictateWearProtocol.RESP_OFFLINE -> throw TetherResultError(context.getString(R.string.wear_err_offline))
         DictateWearProtocol.RESP_QUOTA -> throw TetherResultError(context.getString(R.string.wear_err_quota))
-        else -> throw TetherResultError(context.getString(R.string.wear_err_transcribe_failed))
+        else -> throw TetherResultError(text.ifBlank { context.getString(R.string.wear_err_transcribe_failed) })
     }

Tip

With these tiny changes, the watch app will now instantly display the actual API error (e.g., "Model gpt-4o-mini-transcribe does not exist") on the screen, allowing users to troubleshoot their own setup without getting stuck.

I hope this legwork saves you some valuable debugging time! Happy coding! ✨