@vellumai/assistant 0.11.2-dev.202608072144.9eaee43 → 0.11.2-dev.202608080025.b2695c7

package/docs/flux-turn-detection-spike.md

@@ -22,10 +22,10 @@ It is also the only endpoint number that the Flux socket teardown stays out of:
 
 | Path                                   | What `endpointDecisionMaxLatencyMs` actually spans                                                                                                                                                                                     |
 | -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `endpointDecisionSource: "flux"`       | Local VAD speech-stop mark to the `turn-end` event. This is the **whole** end-of-turn latency.                                                                                                                                         |
+| `endpointDecisionSource: "provider"`   | Local VAD speech-stop mark to the `turn-end` event. This is the **whole** end-of-turn latency.                                                                                                                                         |
 | `endpointDecisionSource: "front-door"` | Speculative dispatch to the hold verdict, i.e. the endpoint-decider LLM roundtrip **only**. The trailing-silence wait that had to elapse before that dispatch is not in the number, and neither is the hold extension that follows it. |
 
-Source: `handleFluxTurnEnd` passes `this.msSinceLocalSpeechStop()` (`live-voice-session.ts`), while `holdSpeculativeTurn` passes `Date.now() - turn.speculativeDispatchedAtMs`, and the dispatch happens at the silence boundary.
+Source: `handleProviderTurnEnd` passes `this.msSinceLocalSpeechStop()` (`live-voice-session.ts`), while `holdSpeculativeTurn` passes `Date.now() - turn.speculativeDispatchedAtMs`, and the dispatch happens at the silence boundary.
 
 **It samples different populations.** `markEndpointDecision` is called from exactly two places: the Flux commit, and the hold verdict. A front-door turn that committed straight through the boundary emits **no** `endpoint_decision` at all, and its metrics frame carries none of the three endpoint fields. So the front-door sample is "turns the model judged mid-thought", the slow tail by construction, while the Flux sample is every turn. Two denominators that cannot be reconciled after the fact is exactly why `endpointCommitLatencyMs` exists.
 
@@ -129,7 +129,7 @@ The daemon sends a `metrics` frame over the live-voice WebSocket on `turn_comple
 | Field                          | Meaning                                                                                                                                |
 | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
 | `endpointCommitLatencyMs`      | **The headline.** Local VAD speech-stop mark to the commit. Present on every committed turn on both arms. Compare medians across arms. |
-| `endpointDecisionSource`       | `"flux"` or `"front-door"`. Present only when an endpoint decision was recorded.                                                       |
+| `endpointDecisionSource`       | `"provider"` or `"front-door"`. Present only when an endpoint decision was recorded.                                                   |
 | `endpointDecisionMaxLatencyMs` | Worst single decision latency in the turn. A breakdown of the headline, never a cross-arm comparison. See the first section.           |
 | `endpointHoldCount`            | Hold verdicts in the turn. Always 0 on a Flux-committed turn.                                                                          |
 
@@ -141,21 +141,21 @@ The last three are **absent** unless a decision was recorded, which is deliberat
 
 | What you see                           | What happened                                                                                                                                 |
 | -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
-| `endpointDecisionSource: "flux"`       | Flux committed the turn. This is the measurement you came for.                                                                                |
+| `endpointDecisionSource: "provider"`   | Flux committed the turn. This is the measurement you came for.                                                                                |
 | No endpoint fields at all              | The fail-open deadline fired, the utterance fell back to the silence path, and the front door released it without holding. Not a Flux sample. |
 | `endpointDecisionSource: "front-door"` | Same fallback, but the front door then held. Not a Flux sample either.                                                                        |
 
 Fallbacks are logged at `warn`, so they are visible at the default log level:
 
 ```
-No Flux end-of-turn is coming; falling back to the silence boundary for this utterance
+No provider end-of-turn is coming; falling back to the silence boundary for this utterance
 ```
 
-The deadline is `liveVoice.flux.eotTimeoutMs` plus a 1000ms margin (`FLUX_TURN_END_FALLBACK_MARGIN_MS`), measured from the local speech-stop mark. If you see these routinely, you are measuring the fallback path, not Flux.
+The deadline is `liveVoice.flux.eotTimeoutMs` plus a 1000ms margin (`PROVIDER_TURN_END_FALLBACK_MARGIN_MS`), measured from the local speech-stop mark. If you see these routinely, you are measuring the fallback path, not Flux.
 
 #### Lower `eotTimeoutMs` for the run
 
-With the shipped defaults the fail-open budget is `eotTimeoutMs` (**5000**) plus `FLUX_TURN_END_FALLBACK_MARGIN_MS` (**1000**), so **6000ms from the local speech-stop mark**. The local silence boundary fires at ~1200ms and then hands the turn to Flux, so a stalled turn is roughly **4.8 seconds of dead air** before the utterance replays onto the hold path and anyone answers.
+With the shipped defaults the fail-open budget is `eotTimeoutMs` (**5000**) plus `PROVIDER_TURN_END_FALLBACK_MARGIN_MS` (**1000**), so **6000ms from the local speech-stop mark**. The local silence boundary fires at ~1200ms and then hands the turn to Flux, so a stalled turn is roughly **4.8 seconds of dead air** before the utterance replays onto the hold path and anyone answers.
 
 That is the worst case by design (the budget has to clear Flux's own force-end), but it is a bad property to carry through a measurement run. It makes a stall expensive to sit through, which biases you toward not reproducing one, and it means arm B's slow turns are dominated by a timeout rather than by turn detection.
 
@@ -163,14 +163,14 @@ Set `liveVoice.flux.eotTimeoutMs` to **1500 to 2000** for the duration of the ru
 
 ### Prefer medians, and do not chase a single bad sample
 
-`isStaleFluxTurnEnd` decides on Flux's own `turn_index`, which `parseFluxFrame` carries onto `turn-start` and `turn-end`. The cycle records the newest turn Flux opened, so a delayed end-of-turn for an older index is recognized as stale and dropped, even though the caller has resumed speaking since. An end-of-turn for the turn still in progress is never stale: the mid-thought pause is what Flux's turn model exists to judge, its verdict covers the resumed speech, and the newest speech-stop mark is the right anchor for it.
+`isStaleProviderTurnEnd` decides on Flux's own `turn_index`, which `parseFluxFrame` carries onto `turn-start` and `turn-end`. The cycle records the newest turn Flux opened, so a delayed end-of-turn for an older index is recognized as stale and dropped, even though the caller has resumed speaking since. An end-of-turn for the turn still in progress is never stale: the mid-thought pause is what Flux's turn model exists to judge, its verdict covers the resumed speech, and the newest speech-stop mark is the right anchor for it.
 
-The local VAD generation counter is only the fallback, for an event that carries no turn number. There the outlier mode survives: if the caller resumes and stops again before a delayed `turn-end` lands, the second boundary re-stamps `fluxBoundaryGeneration` to the current generation, the event stops looking stale, and it is accepted against the newer speech-stop mark. The **commit is still correct**, but the recorded latency is understated for that turn, in `endpointCommitLatencyMs` and `endpointDecisionMaxLatencyMs` alike, since they share the anchor.
+The local VAD generation counter is only the fallback, for an event that carries no turn number. There the outlier mode survives: if the caller resumes and stops again before a delayed `turn-end` lands, the second boundary re-stamps `turnBoundaryGeneration` to the current generation, the event stops looking stale, and it is accepted against the newer speech-stop mark. The **commit is still correct**, but the recorded latency is understated for that turn, in `endpointCommitLatencyMs` and `endpointDecisionMaxLatencyMs` alike, since they share the anchor.
 
 Drops log at `info` and so are visible at the default log level, carrying `turnIndex`, `openTurnIndex`, `boundaryGeneration`, and `speechGeneration`:
 
 ```
-Dropping a stale Flux end-of-turn: the caller resumed speaking past the boundary it closed
+Dropping a stale provider end-of-turn: the caller resumed speaking past the boundary it closed
 ```
 
 A drop is not itself an error: the cycle stays open and still commits, on the end-of-turn for the resumed speech or on the fail-open deadline. Read the line's fields. A drop with both `turnIndex` and `openTurnIndex` present is the turn-index path working, and it also drops the silent variant of the same race. A drop with `turnIndex` absent means Deepgram is sending unnumbered events and the run is on the generation fallback, where individual samples can be skewed and legitimate fast end-of-turns are dropped conservatively. Either way, report medians over a run of turns and ignore individual extremes.

package/docs/stt-provider-onboarding.md

@@ -13,6 +13,7 @@ Add a new entry to the `CATALOG` map with:
 - `supportedBoundaries` — the set of `SttBoundaryId` values the provider supports. Valid values are `"daemon-batch"` (post-recording transcription) and `"daemon-streaming"` (real-time streaming transcription during conversation).
 - `conversationStreamingMode` — how the provider handles streaming transcription in conversation mode: `"realtime-ws"` (provider supports real-time streaming natively via WebSocket), `"incremental-batch"` (streaming emulated via throttled polling), or `"none"` (no streaming support). Required for all providers.
 - `telephonyMode` — how the provider participates in real-time telephony STT: `"realtime-ws"`, `"batch-only"`, or `"none"`. The telephony capability resolver (`resolveTelephonySttCapability()` in `src/providers/speech-to-text/resolve.ts`) reads this field plus credential availability to decide whether phone calls can run with the provider.
+- `turnDetection`: whether the provider decides end-of-turn itself, `"provider"` or `"none"`. Use `"provider"` only when the adapter emits `turn-start` / `turn-end` on its transcript stream; a live-voice session reads this via `supportsProviderTurnDetection()` to decide whether to arm its provider turn-end path. Default to `"none"`: a provider that declares `"provider"` but never emits the events makes every turn wait out the fail-open deadline before falling back to the silence boundary. A provider declaring `"provider"` should also number its turns, because the staleness check prefers the turn index on the event and degrades to the session's VAD generation counter without one.
 
 ## 2. Type-system registration
 

package/openapi.yaml

@@ -4354,6 +4354,7 @@ paths:
                             - platform
                             - a2a
                             - discord
+                            - plugin
                         ready:
                           type: boolean
                         setupStatus:
@@ -4444,6 +4445,7 @@ paths:
                     - platform
                     - a2a
                     - discord
+                    - plugin
                 includeRemote:
                   description: Include remote checks (default true)
                   type: boolean
@@ -4474,6 +4476,7 @@ paths:
                             - platform
                             - a2a
                             - discord
+                            - plugin
                         ready:
                           type: boolean
                         setupStatus:
@@ -6578,6 +6581,7 @@ paths:
               - platform
               - a2a
               - discord
+              - plugin
           description:
             Filter by origin channel. When provided, only conversations with this exact origin_channel value are
             returned. Omit to include all channels.
@@ -6714,6 +6718,7 @@ paths:
                                 - platform
                                 - a2a
                                 - discord
+                                - plugin
                             - type: "null"
                         assistantAttention:
                           type: object
@@ -7077,6 +7082,7 @@ paths:
                               - platform
                               - a2a
                               - discord
+                              - plugin
                           - type: "null"
                       assistantAttention:
                         type: object
@@ -8290,6 +8296,7 @@ paths:
                               - platform
                               - a2a
                               - discord
+                              - plugin
                           - type: "null"
                       assistantAttention:
                         type: object
@@ -21958,6 +21965,7 @@ paths:
                     - platform
                     - a2a
                     - discord
+                    - plugin
                     - scheduler
                     - watcher
                 sourceContextId:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.2-dev.202608072144.9eaee43",
+  "version": "0.11.2-dev.202608080025.b2695c7",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/live-voice/__tests__/live-voice-flux-turn-end.test.ts

@@ -377,7 +377,7 @@ describe("LiveVoiceSession Flux end-of-turn", () => {
     await waitFor(() => turnCalls.length === 1);
 
     const metricsFrame = await waitForTurnMetrics(frames);
-    expect(metricsFrame.endpointDecisionSource).toBe("flux");
+    expect(metricsFrame.endpointDecisionSource).toBe("provider");
     expect(metricsFrame.endpointHoldCount).toBe(0);
 
     await session.close("client_end");
@@ -606,7 +606,7 @@ describe("LiveVoiceSession Flux end-of-turn", () => {
     expect(frames.some((frame) => frame.type === "utterance_end")).toBe(true);
 
     const metricsFrame = await waitForTurnMetrics(frames);
-    expect(metricsFrame.endpointDecisionSource).toBe("flux");
+    expect(metricsFrame.endpointDecisionSource).toBe("provider");
 
     await session.close("client_end");
   });

package/src/live-voice/__tests__/live-voice-metrics.test.ts

@@ -376,19 +376,19 @@ describe("LiveVoiceMetricsCollector", () => {
     collector.markEndpointDecision("turn-src-flux", {
       action: "hold",
       latencyMs: 40,
-      source: "flux",
+      source: "provider",
     });
     collector.markEndpointDecision("turn-src-flux", {
       action: "release",
       latencyMs: 120,
-      source: "flux",
+      source: "provider",
     });
     const completed = collector.completeTurn();
 
     expect(completed).toMatchObject({
       endpointHoldCount: 1,
       endpointDecisionMaxLatencyMs: 120,
-      endpointDecisionSource: "flux",
+      endpointDecisionSource: "provider",
     });
     expect(
       getLiveVoiceMetricsAggregateFields(
@@ -398,7 +398,7 @@ describe("LiveVoiceMetricsCollector", () => {
     ).toMatchObject({
       endpointHoldCount: 1,
       endpointDecisionMaxLatencyMs: 120,
-      endpointDecisionSource: "flux",
+      endpointDecisionSource: "provider",
     });
   });
 

package/src/live-voice/live-voice-metrics.ts

@@ -31,8 +31,8 @@ export type LiveVoiceMetricsEvent =
 export type VoiceEndpointAction = "release" | "hold";
 
 // Which decider produced the endpoint outcome: the speculative front-door
-// leg, or the Flux turn-detection stream.
-export type VoiceEndpointSource = "front-door" | "flux";
+// leg, or the STT provider's own turn-detection stream.
+export type VoiceEndpointSource = "front-door" | "provider";
 
 const DEFAULT_ENDPOINT_SOURCE: VoiceEndpointSource = "front-door";
 

package/src/live-voice/live-voice-session.ts

@@ -50,6 +50,7 @@ import {
   listProviderIds,
   pinnedListeningLanguage,
   supportsBoundary,
+  supportsProviderTurnDetection,
 } from "../providers/speech-to-text/provider-catalog.js";
 import type { ResolveStreamingTranscriberOptions } from "../providers/speech-to-text/resolve.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
@@ -213,12 +214,12 @@ const BARGE_IN_GAP_TOLERANCE_MS = 200;
 // (1 / (1 + ratio) ≈ 20%): once the run is mostly silence it resets, so genuine
 // choppy speech still lands but periodic noise cannot accumulate into one.
 const BARGE_IN_MAX_TOLERATED_SILENCE_RATIO = 4;
-// Slack added to `liveVoice.flux.eotTimeoutMs` before the session stops
-// waiting for an end-of-turn event that is not coming and falls the utterance
-// back onto the silence-boundary path. Flux force-ends its own turn at
-// `eotTimeoutMs` of silence, so anything past that plus a frame's network and
-// parse hop means the stream is gone, not slow.
-const FLUX_TURN_END_FALLBACK_MARGIN_MS = 1_000;
+// Slack added to the configured end-of-turn timeout before the session stops
+// waiting for an event that is not coming and falls the utterance back onto
+// the silence-boundary path. A turn-detecting provider force-ends its own turn
+// at that timeout, so anything past it plus a frame's network and parse hop
+// means the stream is gone, not slow.
+const PROVIDER_TURN_END_FALLBACK_MARGIN_MS = 1_000;
 // At most this many TTS segment jobs are open (provider stream started,
 // frames not yet fully emitted) per turn: the emitting job plus one
 // prefetching job. The prefetch buffers its chunks in memory until promoted;
@@ -443,18 +444,19 @@ interface UtteranceCycle {
   // The provider's end-of-turn never arrived for this cycle, so it fell back
   // to the silence-boundary path and stays there: a late event must not
   // commit a boundary the fallback already owns.
-  fluxTurnEndTimedOut: boolean;
+  providerTurnEndTimedOut: boolean;
   // `vadSpeechGeneration` as of the local silence boundary that handed this
-  // cycle to Flux, or null while no boundary has fired yet (Flux routinely
-  // beats the trailing-silence countdown, and that fast commit is the point).
+  // cycle to the provider, or null while no boundary has fired yet (a turn
+  // model routinely beats the trailing-silence countdown, and that fast commit
+  // is the point).
   // The staleness signal of last resort: it stands in for the provider's own
-  // turn numbering when the provider sends none (see isStaleFluxTurnEnd).
-  fluxBoundaryGeneration: number | null;
+  // turn numbering when the provider sends none (see isStaleProviderTurnEnd).
+  turnBoundaryGeneration: number | null;
   // Index of the newest provider turn opened in this cycle, from the turn
   // model's own numbering, or null when the provider does not number its
   // turns. An end-of-turn closing an older index describes a turn the
-  // provider has already superseded (see isStaleFluxTurnEnd).
-  fluxOpenTurnIndex: number | null;
+  // provider has already superseded (see isStaleProviderTurnEnd).
+  openProviderTurnIndex: number | null;
   // The transcript the most recent hold verdict judged (unified front-door).
   // A final segment arriving during the extension window that extends this
   // text replays the boundary immediately — the hold was judged on stale
@@ -955,9 +957,9 @@ function createUtteranceCycle(): UtteranceCycle {
     finalTranscriptSegments: [],
     latestPartialText: null,
     endpointExtensionCount: 0,
-    fluxTurnEndTimedOut: false,
-    fluxBoundaryGeneration: null,
-    fluxOpenTurnIndex: null,
+    providerTurnEndTimedOut: false,
+    turnBoundaryGeneration: null,
+    openProviderTurnIndex: null,
     heldSpeculativeContent: null,
     languageTally: new Map(),
     latestPartialLanguages: null,
@@ -1267,24 +1269,25 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   /**
    * Per-session latch: the provider's committed end-of-turn owns the turn
    * boundary instead of the silence boundary's front-door hold verdict. Set
-   * when the config flag is on AND the resolved streaming provider is
-   * `deepgram-flux` AND the session runs server VAD. Push-to-talk is excluded
-   * deliberately: there the client's release IS the boundary, and answering
-   * while the caller still holds the button is not turn detection, it is a
-   * bug. False leaves every other code path exactly as it is with no Flux in
-   * the picture.
+   * when the config flag is on AND the resolved streaming provider declares
+   * `turnDetection: "provider"` in the STT catalog AND the session runs server
+   * VAD. Push-to-talk is excluded deliberately: there the client's release IS
+   * the boundary, and answering while the caller still holds the button is not
+   * turn detection, it is a bug. False leaves every other code path exactly as
+   * it is, with no provider turn detection in the picture.
    */
-  private fluxTurnEndActive = false;
+  private providerTurnEndActive = false;
   // Wall-clock of the newest above-gate audio chunk, tracked in every
   // server-VAD session. It is the local VAD's speech-stop mark: the one anchor
   // the reported end-of-turn latency is measured from whichever decider
-  // commits the turn, and the anchor for the Flux fallback deadline. Null in
-  // push-to-talk, where no local VAD runs.
+  // commits the turn, and the anchor for the provider fallback deadline. Null
+  // in push-to-talk, where no local VAD runs.
   private localSpeechStopAtMs: number | null = null;
-  // Fail-open deadline for a Flux end-of-turn that never arrives. On expiry
-  // the utterance falls back to the silence-boundary path, so a dead Flux
-  // stream degrades to today's behavior instead of a hung turn.
-  private fluxTurnEndTimer: ReturnType<typeof setTimeout> | null = null;
+  // Fail-open deadline for a provider end-of-turn that never arrives. On
+  // expiry the utterance falls back to the silence-boundary path, so a dead
+  // provider stream degrades to the silence-path behavior instead of a hung
+  // turn.
+  private providerTurnEndTimer: ReturnType<typeof setTimeout> | null = null;
   // Effective trailing-silence threshold, mirroring the detector's private
   // copy (constructor seed + update_config), reported to the endpoint decider.
   private silenceThresholdMs: number;
@@ -1534,7 +1537,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.liveActivityReporter.end();
     this.turnDetector?.dispose();
     this.clearEndpointExtensionTimer();
-    this.clearFluxTurnEndTimer();
+    this.clearProviderTurnEndTimer();
     // There is no longer anyone on the call to speak to, so a queued
     // announcement cannot be spoken — but the answer behind it is finished
     // work the user asked for, so it takes the same conversation route a
@@ -1598,13 +1601,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // waiting on this resolve, so the caller can speak and close an entire
       // silence boundary while the provider handshake is still in flight. A
       // latch still on its default `false` at that boundary hands the first
-      // turn of the session to the old silence path and then ignores the
-      // Flux end-of-turn that follows, which is invisible from the outside:
-      // the session looks like a Flux session while its opening turn is not
-      // one. The resolved provider reconciles this guess below.
-      this.setFluxTurnEndActive(
+      // turn of the session to the silence path and then ignores the
+      // provider end-of-turn that follows, which is invisible from the
+      // outside: the session looks like a turn-detecting session while its
+      // opening turn is not one. The resolved provider reconciles this guess
+      // below.
+      this.setProviderTurnEndActive(
         this.fluxConfig.turnEnd.enabled &&
-          stt.provider === "deepgram-flux" &&
+          supportsProviderTurnDetection(stt.provider as SttProviderId) &&
           this.turnDetector !== null,
       );
       const transcriber = await this.resolveTranscriber({
@@ -1620,7 +1624,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       if (!transcriber) {
         // No stream answered, so no end-of-turn ever will: the guess above
         // must not outlive the dial that disproved it.
-        this.setFluxTurnEndActive(false);
+        this.setProviderTurnEndActive(false);
         return {
           status: "unavailable",
           message: unavailableTranscriberMessage(),
@@ -1634,9 +1638,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // change under a live session, so this normally confirms the guess; it
       // clears it when the dial fell back to another provider or resolved
       // one the config did not name.
-      this.setFluxTurnEndActive(
+      this.setProviderTurnEndActive(
         this.fluxConfig.turnEnd.enabled &&
-          transcriber.providerId === "deepgram-flux" &&
+          supportsProviderTurnDetection(transcriber.providerId) &&
           this.turnDetector !== null,
       );
       if (
@@ -1674,7 +1678,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       }
       // The dial threw, so the pre-dial guess is disproved the same way the
       // unavailable case disproves it: nothing will send an end-of-turn.
-      this.setFluxTurnEndActive(false);
+      this.setProviderTurnEndActive(false);
       return {
         status: "error",
         message: `Live voice transcription could not be started: ${errorMessage(
@@ -1802,7 +1806,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
 
     this.state = "failed";
     this.clearEndpointExtensionTimer();
-    this.clearFluxTurnEndTimer();
+    this.clearProviderTurnEndTimer();
     await this.sendFrame({
       type: "error",
       code:
@@ -2281,7 +2285,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.clearEndpointExtensionTimer();
     // ...and so is a fallback deadline armed for the boundary the caller just
     // spoke through. The next silence boundary arms a fresh one.
-    this.clearFluxTurnEndTimer();
+    this.clearProviderTurnEndTimer();
 
     // Speech resumed while a speculative leg was awaiting its verdict: the
     // pause was mid-thought after all. Discard silently (no frames were ever
@@ -3191,10 +3195,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       this.pendingBargeIn = null;
       if (reason === "max-duration") {
         // A max-duration boundary always releases: drop any pending hold
-        // replay (or Flux fallback deadline) so it cannot re-fire a boundary
-        // this one already owns.
+        // replay (or provider fallback deadline) so it cannot re-fire a
+        // boundary this one already owns.
         this.clearEndpointExtensionTimer();
-        this.clearFluxTurnEndTimer();
+        this.clearProviderTurnEndTimer();
       }
       const utterance = this.currentUtterance;
       if (!utterance || utterance.released || utterance.completed) {
@@ -3216,17 +3220,18 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // release (ptt_release forced the boundary) is the user saying "answer
       // now" — never second-guess it.
       if (reason === "silence" && !manualRelease) {
-        // Flux owns this boundary: its end-of-turn commits the utterance, so
-        // the silence timer only arms the fail-open deadline. An utterance
-        // whose deadline already elapsed falls through to the hold path
-        // below, which is the whole point of the fallback.
-        if (this.fluxTurnEndActive && !utterance.fluxTurnEndTimedOut) {
+        // The provider owns this boundary: its end-of-turn commits the
+        // utterance, so the silence timer only arms the fail-open deadline. An
+        // utterance whose deadline already elapsed falls through to the hold
+        // path below, which is the whole point of the fallback.
+        if (this.providerTurnEndActive && !utterance.providerTurnEndTimedOut) {
           // Stamp the speech run this boundary closed. This is the staleness
           // signal of last resort, used only for a provider that does not
-          // number its turns: where Flux's own turn index is on the wire it
-          // answers the question directly (see isStaleFluxTurnEnd).
-          utterance.fluxBoundaryGeneration = this.vadSpeechGeneration;
-          this.armFluxTurnEndFallbackTimer(utterance);
+          // number its turns: where the provider's own turn index is on the
+          // wire it answers the question directly (see
+          // isStaleProviderTurnEnd).
+          utterance.turnBoundaryGeneration = this.vadSpeechGeneration;
+          this.armProviderTurnEndFallbackTimer(utterance);
           return;
         }
         if (await this.launchSpeculativeAssistantTurn(utterance)) {
@@ -3259,23 +3264,24 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }, this.frontModelConfig.endpointExtensionMs);
   }
 
-  // Arms the fail-open deadline for a Flux end-of-turn. Flux force-ends its
-  // own turn after `eotTimeoutMs` of silence, so once that budget plus a
-  // margin has passed since the caller stopped speaking, no end-of-turn is
-  // coming and the utterance replays this boundary on the silence path.
+  // Arms the fail-open deadline for a provider end-of-turn. A turn-detecting
+  // provider force-ends its own turn after `eotTimeoutMs` of silence, so once
+  // that budget plus a margin has passed since the caller stopped speaking, no
+  // end-of-turn is coming and the utterance replays this boundary on the
+  // silence path.
   // `waitMsOverride` collapses that wait when the caller already knows no
-  // end-of-turn is coming (see setFluxTurnEndActive).
-  private armFluxTurnEndFallbackTimer(
+  // end-of-turn is coming (see setProviderTurnEndActive).
+  private armProviderTurnEndFallbackTimer(
     utterance: UtteranceCycle,
     waitMsOverride?: number,
   ): void {
-    this.clearFluxTurnEndTimer();
+    this.clearProviderTurnEndTimer();
     const budgetMs =
-      this.fluxConfig.eotTimeoutMs + FLUX_TURN_END_FALLBACK_MARGIN_MS;
+      this.fluxConfig.eotTimeoutMs + PROVIDER_TURN_END_FALLBACK_MARGIN_MS;
     const waitMs =
       waitMsOverride ?? Math.max(0, budgetMs - this.msSinceLocalSpeechStop());
-    this.fluxTurnEndTimer = setTimeout(() => {
-      this.fluxTurnEndTimer = null;
+    this.providerTurnEndTimer = setTimeout(() => {
+      this.providerTurnEndTimer = null;
       if (
         this.currentUtterance !== utterance ||
         utterance.released ||
@@ -3287,23 +3293,23 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       ) {
         return;
       }
-      utterance.fluxTurnEndTimedOut = true;
+      utterance.providerTurnEndTimedOut = true;
       log.warn(
         { budgetMs, waitMs },
-        "No Flux end-of-turn is coming; falling back to the silence boundary for this utterance",
+        "No provider end-of-turn is coming; falling back to the silence boundary for this utterance",
       );
       this.handleVadUtteranceEnd("silence");
     }, waitMs);
   }
 
   /**
-   * Flips the Flux end-of-turn latch, unwinding an optimistic arm.
+   * Flips the provider end-of-turn latch, unwinding an optimistic arm.
    *
    * `beginUtterance` arms the latch from the configured provider before the
-   * dial resolves, so a silence boundary can already have deferred to Flux by
-   * the time the resolved provider says otherwise. That deferred boundary is
-   * parked on the fail-open deadline, a whole Flux end-of-turn budget away,
-   * waiting for an event that will now never arrive. Collapse the wait to
+   * dial resolves, so a silence boundary can already have deferred to the
+   * provider by the time the resolved one says otherwise. That deferred
+   * boundary is parked on the fail-open deadline, a whole end-of-turn budget
+   * away, waiting for an event that will now never arrive. Collapse the wait to
    * zero rather than burn the budget: the deadline body re-checks the cycle
    * and replays the silence boundary, which with the latch down takes the
    * ordinary hold path. Replaying through the deadline instead of calling
@@ -3313,38 +3319,38 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * A cleared latch with no deadline armed needs no unwind: either no
    * boundary ever deferred, or the caller resumed speaking and
    * `handleVadSpeechStart` already dropped the deadline, leaving the detector
-   * owning the next boundary. The cycle's `fluxBoundaryGeneration` stamp is
-   * left as it is: `isStaleFluxTurnEnd` is only ever consulted from
-   * `handleFluxTurnEnd`, which returns immediately once the latch is down.
+   * owning the next boundary. The cycle's `turnBoundaryGeneration` stamp is
+   * left as it is: `isStaleProviderTurnEnd` is only ever consulted from
+   * `handleProviderTurnEnd`, which returns immediately once the latch is down.
    */
-  private setFluxTurnEndActive(active: boolean): void {
-    if (active === this.fluxTurnEndActive) {
+  private setProviderTurnEndActive(active: boolean): void {
+    if (active === this.providerTurnEndActive) {
       return;
     }
-    this.fluxTurnEndActive = active;
-    if (active || this.fluxTurnEndTimer === null) {
+    this.providerTurnEndActive = active;
+    if (active || this.providerTurnEndTimer === null) {
       return;
     }
     const utterance = this.currentUtterance;
-    this.clearFluxTurnEndTimer();
+    this.clearProviderTurnEndTimer();
     if (utterance && !utterance.released && !utterance.completed) {
-      this.armFluxTurnEndFallbackTimer(utterance, 0);
+      this.armProviderTurnEndFallbackTimer(utterance, 0);
     }
   }
 
   /**
    * Record the provider turn a cycle is currently inside. Providers without
    * turn numbering send no index, which leaves the cycle on the local speech
-   * generation as its only staleness signal (see isStaleFluxTurnEnd).
+   * generation as its only staleness signal (see isStaleProviderTurnEnd).
    */
-  private recordFluxTurnStart(
+  private recordProviderTurnStart(
     utterance: UtteranceCycle,
     turnIndex: number | undefined,
   ): void {
     if (turnIndex === undefined) {
       return;
     }
-    utterance.fluxOpenTurnIndex = turnIndex;
+    utterance.openProviderTurnIndex = turnIndex;
   }
 
   /**
@@ -3354,13 +3360,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * still routing the resumed speech into this same cycle, cutting off the
    * next words or folding them into the wrong turn.
    *
-   * Flux's own turn numbering answers this directly and is preferred
-   * wherever it is available: the cycle records the newest turn Flux has
-   * opened, so an end-of-turn for an older index closes a turn Flux itself
-   * has already superseded. An end-of-turn for the turn still in progress is
-   * never stale, however many times the caller drew breath inside it: the
-   * mid-thought pause is exactly the case Flux's turn model exists to judge,
-   * and its verdict covers the resumed speech too.
+   * The provider's own turn numbering answers this directly and is preferred
+   * wherever it is available: the cycle records the newest turn the provider
+   * has opened, so an end-of-turn for an older index closes a turn the
+   * provider itself has already superseded. An end-of-turn for the turn still
+   * in progress is never stale, however many times the caller drew breath
+   * inside it: the mid-thought pause is exactly the case a provider's turn
+   * model exists to judge, and its verdict covers the resumed speech too.
    *
    * With no turn numbering the local speech generation is the only signal
    * left. The silence boundary stamps the cycle with the generation it
@@ -3370,23 +3376,23 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * feature exists for, which the turn index would have committed. Before
    * any boundary has fired the stamp is null and nothing is stale.
    */
-  private isStaleFluxTurnEnd(
+  private isStaleProviderTurnEnd(
     utterance: UtteranceCycle,
     turnIndex: number | undefined,
   ): boolean {
-    if (turnIndex !== undefined && utterance.fluxOpenTurnIndex !== null) {
-      return turnIndex < utterance.fluxOpenTurnIndex;
+    if (turnIndex !== undefined && utterance.openProviderTurnIndex !== null) {
+      return turnIndex < utterance.openProviderTurnIndex;
     }
     return (
-      utterance.fluxBoundaryGeneration !== null &&
-      utterance.fluxBoundaryGeneration !== this.vadSpeechGeneration
+      utterance.turnBoundaryGeneration !== null &&
+      utterance.turnBoundaryGeneration !== this.vadSpeechGeneration
     );
   }
 
-  private clearFluxTurnEndTimer(): void {
-    if (this.fluxTurnEndTimer !== null) {
-      clearTimeout(this.fluxTurnEndTimer);
-      this.fluxTurnEndTimer = null;
+  private clearProviderTurnEndTimer(): void {
+    if (this.providerTurnEndTimer !== null) {
+      clearTimeout(this.providerTurnEndTimer);
+      this.providerTurnEndTimer = null;
     }
   }
 
@@ -3401,7 +3407,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   /**
-   * Flux committed an end of turn: the caller has finished, so the utterance
+   * The provider committed an end of turn: the caller has finished, so the utterance
    * commits now instead of waiting out the trailing-silence timer and asking
    * the front door whether the pause was mid-thought. This runs the ordinary
    * post-release path (utterance_end, then release), so the front-door leg it
@@ -3410,33 +3416,33 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * the caller has finished. The escalate verdict and the spoken ack /
    * progress phrasing are untouched; only the hold verdict is bypassed.
    */
-  private async handleFluxTurnEnd(
+  private async handleProviderTurnEnd(
     utterance: UtteranceCycle,
     turnIndex: number | undefined,
   ): Promise<void> {
     if (
-      !this.fluxTurnEndActive ||
+      !this.providerTurnEndActive ||
       this.currentUtterance !== utterance ||
       utterance.released ||
       utterance.completed ||
       utterance.assistantTurnStarted ||
       // The fallback already took this utterance back to the silence path.
-      utterance.fluxTurnEndTimedOut
+      utterance.providerTurnEndTimedOut
     ) {
       return;
     }
-    if (this.isStaleFluxTurnEnd(utterance, turnIndex)) {
+    if (this.isStaleProviderTurnEnd(utterance, turnIndex)) {
       // At `info`, not `debug`: a drop is rare and is the only signal of the
       // one known latency-outlier mode, so an operator measuring the two
       // paths has to be able to see it at the default log level.
       log.info(
         {
           turnIndex,
-          openTurnIndex: utterance.fluxOpenTurnIndex,
-          boundaryGeneration: utterance.fluxBoundaryGeneration,
+          openTurnIndex: utterance.openProviderTurnIndex,
+          boundaryGeneration: utterance.turnBoundaryGeneration,
           speechGeneration: this.vadSpeechGeneration,
         },
-        "Dropping a stale Flux end-of-turn: the caller resumed speaking past the boundary it closed",
+        "Dropping a stale provider end-of-turn: the caller resumed speaking past the boundary it closed",
       );
       // The cycle stays open and local VAD keeps routing the resumed speech
       // into it. The detector's next silence boundary re-stamps the
@@ -3446,23 +3452,23 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // idle, so the deadline handleVadSpeechStart cleared can never strand
       // the cycle with nothing left to close it.
       if (this.turnDetector?.isActive !== true) {
-        utterance.fluxBoundaryGeneration = this.vadSpeechGeneration;
-        this.armFluxTurnEndFallbackTimer(utterance);
+        utterance.turnBoundaryGeneration = this.vadSpeechGeneration;
+        this.armProviderTurnEndFallbackTimer(utterance);
       }
       return;
     }
-    this.clearFluxTurnEndTimer();
+    this.clearProviderTurnEndTimer();
     this.markEndpointDecision(
       utterance,
       "release",
       this.msSinceLocalSpeechStop(),
-      "flux",
+      "provider",
     );
     await this.sendFrame({ type: "utterance_end", reason: "silence" });
     await this.releaseUtterance();
     // Leave the local detector idle, which is where every other commit path
-    // leaves it. Flux can close a turn while the trailing-silence countdown
-    // is still running, and barge-in fires from the detector's next speech
+    // leaves it. A provider can close a turn while the trailing-silence
+    // countdown is still running, and barge-in fires from the detector's speech
     // ONSET: a detector left mid-turn reports no onset, so the caller could
     // not interrupt the reply they just triggered. The forced boundary
     // reaches an already-released utterance and returns.
@@ -3688,7 +3694,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       !utterance.completed
     ) {
       this.clearEndpointExtensionTimer();
-      this.clearFluxTurnEndTimer();
+      this.clearProviderTurnEndTimer();
       await this.sendFrame({ type: "utterance_end", reason: "silence" });
     }
     await this.releaseUtterance();
@@ -3898,8 +3904,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         // because a provider roundtrip cannot beat a local energy gate on an
         // interrupt during playback (see DEFAULT_BARGE_IN_MIN_SPEECH_MS). The
         // index is recorded so a later end-of-turn can be told apart from one
-        // this turn superseded (see isStaleFluxTurnEnd).
-        this.recordFluxTurnStart(utterance, event.turnIndex);
+        // this turn superseded (see isStaleProviderTurnEnd).
+        this.recordProviderTurnStart(utterance, event.turnIndex);
         return;
       case "eager-turn-end":
       case "turn-resumed":
@@ -3909,7 +3915,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         // follow-up.
         return;
       case "turn-end":
-        await this.handleFluxTurnEnd(utterance, event.turnIndex);
+        await this.handleProviderTurnEnd(utterance, event.turnIndex);
         return;
       case "error":
         await this.sendTranscriberErrorFrame(event);
@@ -4044,10 +4050,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         // because a provider roundtrip cannot beat a local energy gate on an
         // interrupt during playback (see DEFAULT_BARGE_IN_MIN_SPEECH_MS). The
         // index is recorded so a later end-of-turn can be told apart from one
-        // this turn superseded (see isStaleFluxTurnEnd).
+        // this turn superseded (see isStaleProviderTurnEnd).
         const target = this.pendingTranscriptCycle();
         if (target) {
-          this.recordFluxTurnStart(target, event.turnIndex);
+          this.recordProviderTurnStart(target, event.turnIndex);
         }
         return;
       }
@@ -4063,7 +4069,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         // transcript owns the turn the provider just closed.
         const target = this.pendingTranscriptCycle();
         if (target) {
-          await this.handleFluxTurnEnd(target, event.turnIndex);
+          await this.handleProviderTurnEnd(target, event.turnIndex);
         }
         return;
       }
@@ -4246,9 +4252,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.takeVadPreRoll();
     this.vadPendingTurnEnd = null;
     // ...and abandons any semantic-endpointing hold still awaiting replay,
-    // along with any Flux end-of-turn the session was still waiting on.
+    // along with any provider end-of-turn the session was still waiting on.
     this.clearEndpointExtensionTimer();
-    this.clearFluxTurnEndTimer();
+    this.clearProviderTurnEndTimer();
     // A client interrupt is a hard reset: any barge-in merge context waiting for
     // the next turn is now stale (the interrupted utterance may be discarded
     // without ever reaching finalizePendingUtterance).
@@ -6128,7 +6134,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     action: VoiceEndpointAction,
     latencyMs: number,
     // Absent means the front door decided, which is what the collector
-    // defaults to; the Flux path names itself so one metrics frame can
+    // defaults to; the provider path names itself so one metrics frame can
     // compare the two.
     source?: VoiceEndpointSource,
   ): void {
@@ -6146,7 +6152,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   /**
    * The turn's end-of-turn latency, stamped at the moment it commits. Called
    * from `releaseUtterance`, which every committed turn passes through
-   * whichever decider released it, so the front-door and Flux samples span
+   * whichever decider released it, so the front-door and provider samples span
    * the same thing from the same anchor over the same population. That is
    * what `endpointDecisionMaxLatencyMs` cannot offer, and why this exists
    * alongside it.
@@ -6563,7 +6569,7 @@ export function createLiveVoiceSession(
       options.echoEmaHalfLifeMs ?? vadConfig?.echoEmaHalfLifeMs,
     echoDrainSlackMs: options.echoDrainSlackMs ?? vadConfig?.echoDrainSlackMs,
     frontModelConfig,
-    // Absent config leaves the schema defaults, which keep Flux turn
+    // Absent config leaves the schema defaults, which keep provider turn
     // detection off.
     fluxConfig: options.fluxConfig ?? liveVoiceConfig?.flux,
     // Eager construction is safe even when the `liveVoice.frontModel` config

package/src/live-voice/protocol.ts

@@ -368,7 +368,7 @@ export interface LiveVoiceMetricsServerFrame extends LiveVoiceServerFrameBase {
    * the STT provider's model-integrated end-of-turn. Present under the same
    * condition as the two fields above.
    */
-  readonly endpointDecisionSource?: "front-door" | "flux";
+  readonly endpointDecisionSource?: "front-door" | "provider";
   /** Which floor-holding ack actually spoke during the turn, if any. */
   readonly ackSpoken?: "first_delta" | "tool_use";
   /**

package/src/providers/speech-to-text/provider-catalog.ts

@@ -14,6 +14,7 @@ import type {
   ConversationStreamingMode,
   SttBoundaryId,
   SttProviderId,
+  SttTurnDetectionMode,
   TelephonySttMode,
 } from "../../stt/types.js";
 import { baseLanguageSubtag } from "../../util/language-subtag.js";
@@ -87,6 +88,14 @@ interface SttProviderEntry {
    */
   readonly conversationStreamingMode: ConversationStreamingMode;
 
+  /**
+   * Whether the provider decides end-of-turn itself, in-band with the audio
+   * it transcribes, or leaves the boundary to the session's local silence
+   * timer. A live-voice session reads this to decide whether to arm its
+   * provider turn-end path; it never names a provider directly.
+   */
+  readonly turnDetection: SttTurnDetectionMode;
+
   /**
    * Whether the provider can attribute transcribed speech to distinct
    * speakers (speaker diarization). When `true`, callers may opt in to
@@ -159,6 +168,7 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
       ]),
       telephonyMode: "realtime-ws",
       conversationStreamingMode: "realtime-ws",
+      turnDetection: "none",
       supportsDiarization: true,
       languageSelection: "manual",
       credentialsGuide: DEEPGRAM_CREDENTIALS_GUIDE,
@@ -184,6 +194,9 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
       // calls at all.
       telephonyMode: "none",
       conversationStreamingMode: "realtime-ws",
+      // Flux emits turn lifecycle events on its transcript stream and numbers
+      // them, so a live-voice session may let them commit the turn.
+      turnDetection: "provider",
       supportsDiarization: false,
       // "no picker", not native detection: the Flux model is English-only and
       // takes no language parameter, so audio in another language transcribes
@@ -209,6 +222,7 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
       ]),
       telephonyMode: "batch-only",
       conversationStreamingMode: "realtime-ws",
+      turnDetection: "none",
       supportsDiarization: false,
       languageSelection: "auto",
       credentialsGuide: {
@@ -235,6 +249,7 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
       ]),
       telephonyMode: "batch-only",
       conversationStreamingMode: "incremental-batch",
+      turnDetection: "none",
       supportsDiarization: false,
       languageSelection: "auto",
       credentialsGuide: {
@@ -261,6 +276,7 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
       ]),
       telephonyMode: "realtime-ws",
       conversationStreamingMode: "realtime-ws",
+      turnDetection: "none",
       supportsDiarization: false,
       // The relay dials Deepgram nova-3 server-side, which takes an explicit
       // language parameter.
@@ -283,6 +299,7 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
       ]),
       telephonyMode: "batch-only",
       conversationStreamingMode: "realtime-ws",
+      turnDetection: "none",
       supportsDiarization: true,
       languageSelection: "manual",
       credentialsGuide: {
@@ -414,6 +431,19 @@ export function supportsDiarization(id: SttProviderId): boolean {
   return CATALOG.get(id)?.supportsDiarization ?? false;
 }
 
+/**
+ * Check whether a provider decides end-of-turn itself.
+ *
+ * Returns `false` for unknown provider IDs, which keeps an unrecognized
+ * provider on the local silence boundary rather than waiting for turn events
+ * that will never arrive. A live-voice session reads this instead of naming a
+ * provider, so a new turn-detecting provider is a catalog entry rather than a
+ * session change.
+ */
+export function supportsProviderTurnDetection(id: SttProviderId): boolean {
+  return CATALOG.get(id)?.turnDetection === "provider";
+}
+
 /**
  * Return all canonical provider IDs in deterministic (insertion) order.
  */

package/src/stt/types.ts

@@ -70,6 +70,26 @@ export type ConversationStreamingMode =
   | "incremental-batch"
   | "none";
 
+/**
+ * Turn-detection support mode.
+ *
+ * Describes whether a provider decides end-of-turn itself, in-band with the
+ * audio it is already transcribing, rather than leaving the boundary to the
+ * session's local silence timer and front-door hold verdict.
+ *
+ * - `"provider"`: the provider emits turn lifecycle events (`turn-start`,
+ *   `turn-end`) on its transcript stream, and a live-voice session may let
+ *   those events commit the turn.
+ * - `"none"`: the provider transcribes only; the local silence boundary owns
+ *   end-of-turn.
+ *
+ * A provider declaring `"provider"` should number its turns: the staleness
+ * check prefers the turn index carried on the event, and degrades to the
+ * session's local VAD generation counter when one is absent, which understates
+ * the recorded latency for a turn the caller resumed and stopped again.
+ */
+export type SttTurnDetectionMode = "provider" | "none";
+
 // ---------------------------------------------------------------------------
 // Boundary identifier
 // ---------------------------------------------------------------------------