@vellumai/assistant 0.11.3 → 0.11.4-staging.2

package/src/config/default-profile-catalog.ts

@@ -4,6 +4,7 @@ import {
   isModelInCatalog,
 } from "../providers/model-catalog.js";
 import { resolveModelIntent } from "../providers/model-intents.js";
+import { isCodexSubscriptionModel } from "../providers/openai/codex-models.js";
 import type { ModelIntent } from "../providers/types.js";
 import { getManagedUpstream } from "../providers/vellum-model-routing.js";
 import {
@@ -31,7 +32,8 @@ import {
  * structured as an intent × provider matrix: each default profile is an
  * intent, and each provider that can serve default profiles has a concrete
  * implementation of that intent (model, token budget, effort, thinking).
- * The `vellum` column is the platform-managed implementation; the other
+ * The `vellum` column is the platform-managed implementation and the
+ * `chatgpt` column is the ChatGPT-subscription implementation; the other
  * columns are the BYOK implementations resolved through `llm.defaultProvider`
  * on off-platform installs.
  *
@@ -96,7 +98,7 @@ const VELLUM_PROFILE_IMPLS: ProfileImpls = {
     },
   },
   "cost-optimized": {
-    model: "accounts/fireworks/models/deepseek-v4-flash",
+    model: "accounts/fireworks/models/deepseek-v4-flash-0731",
     provider: "vellum",
     source: "managed",
     label: "Cost",
@@ -147,6 +149,69 @@ const VELLUM_PROFILE_IMPLS: ProfileImpls = {
   },
 };
 
+/**
+ * The `chatgpt` column: ChatGPT-subscription implementations, stamped
+ * `provider: "chatgpt"` so dispatch routes through the canonical
+ * `chatgpt-subscription` row via `resolveRoutingIdentity` with no pinned
+ * connection. Models are pinned (never intents): the intent tables are
+ * keyed by concrete dispatch providers, and the Codex endpoint serves only
+ * `CODEX_SUBSCRIPTION_MODEL_IDS`. Cost and Speed are identical
+ * implementations here: the subscription serves no tier cheaper or faster
+ * than luna, and both profiles advertise reasoning off.
+ */
+const CHATGPT_PROFILE_IMPLS: ProfileImpls = {
+  balanced: {
+    model: "gpt-5.6-luna",
+    provider: "chatgpt",
+    source: "managed",
+    label: "Balanced",
+    description: "Good balance of quality, cost, and speed",
+    // Matches the vellum column's Balanced (same model): the Codex path
+    // sends no max_output_tokens, so this only sizes internal budgeting.
+    maxTokens: 32000,
+    effort: "high",
+    thinking: { enabled: true, streamThinking: true },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+  },
+  "quality-optimized": {
+    model: "gpt-5.6-sol",
+    provider: "chatgpt",
+    source: "managed",
+    label: "Quality",
+    description: "Best results with the most capable model",
+    maxTokens: 32000,
+    effort: "high",
+    thinking: { enabled: true, streamThinking: true },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+  },
+  "cost-optimized": {
+    model: "gpt-5.6-luna",
+    provider: "chatgpt",
+    source: "managed",
+    label: "Cost",
+    description: "Cheapest responses, for high-volume work",
+    maxTokens: 8192,
+    effort: "none",
+    thinking: { enabled: false, streamThinking: false },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+  },
+  "latency-optimized": {
+    model: "gpt-5.6-luna",
+    provider: "chatgpt",
+    source: "managed",
+    label: "Speed",
+    description: "Fastest responses, with reasoning turned off",
+    maxTokens: 8192,
+    // Explicit reasoning opt-out, matching the other columns: this profile
+    // advertises reasoning as off, and OpenAI-compat APIs default reasoning
+    // to "medium" when the field is omitted, so the opt-out has to be stated
+    // rather than implied.
+    effort: "none",
+    thinking: { enabled: false, streamThinking: false },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+  },
+};
+
 /**
  * The BYOK implementation of each default profile intent, shared by every
  * non-vellum provider. The concrete model resolves per provider from the
@@ -219,7 +284,9 @@ export const PROFILE_IMPLS: Record<
         provider,
         provider === "vellum"
           ? VELLUM_PROFILE_IMPLS[key]
-          : { ...BYOK_PROFILE_IMPLS[key], provider },
+          : provider === "chatgpt"
+            ? CHATGPT_PROFILE_IMPLS[key]
+            : { ...BYOK_PROFILE_IMPLS[key], provider },
       ]),
     ) as Record<DefaultProfileProvider, DefaultProfileTemplate>,
   ]),
@@ -302,9 +369,9 @@ export const OS_BETA_PROFILE_TEMPLATE: DefaultProfileTemplate = {
 /**
  * Profiles whose body is code-owned outright: no workspace overlay, and no
  * user-owned shadow. The shadow rule below lets a user replace a default they
- * can select, but `latency-optimized` fronts every live-voice turn through
- * `voiceFrontDecision`/`voiceFrontDoor`, where a model outside the latency
- * envelope is audible dead air rather than a slow reply. A same-named
+ * can select, but `latency-optimized` serves `voiceFrontDoor` and
+ * `voiceProgressNarration`, where a model outside the latency envelope is
+ * audible dead air rather than a slow reply. A same-named
  * workspace entry stays on disk and stays listed; it just never governs what
  * this name resolves to.
  */
@@ -372,21 +439,23 @@ for (const key of DEFAULT_PROFILE_KEYS) {
         `PROFILE_IMPLS[${key}][${provider}] must set exactly one of \`intent\` or \`model\`.`,
       );
     }
-    if (impl.provider === "vellum" && impl.model == null) {
+    if (ROUTING_IDENTITY_PROVIDERS.has(impl.provider) && impl.model == null) {
       throw new Error(
-        `PROFILE_IMPLS[${key}][${provider}] must pin a \`model\`: the vellum ` +
-          `column has no intent table, and the model selects the upstream.`,
+        `PROFILE_IMPLS[${key}][${provider}] must pin a \`model\`: routing ` +
+          `identities have no intent table, and the model selects the route.`,
       );
     }
     if (impl.model != null) {
       const routable =
         impl.provider === "vellum"
           ? getManagedUpstream(impl.model) !== null
-          : isModelInCatalog(impl.provider, impl.model);
+          : impl.provider === "chatgpt"
+            ? isCodexSubscriptionModel(impl.model)
+            : isModelInCatalog(impl.provider, impl.model);
       if (!routable) {
         throw new Error(
           `PROFILE_IMPLS[${key}][${provider}] references model "${impl.model}" ` +
-            `which is not ${impl.provider === "vellum" ? "served by any managed upstream" : `in PROVIDER_CATALOG for provider "${impl.provider}"`}. ` +
+            `which is not ${impl.provider === "vellum" ? "served by any managed upstream" : impl.provider === "chatgpt" ? "in CODEX_SUBSCRIPTION_MODEL_IDS" : `in PROVIDER_CATALOG for provider "${impl.provider}"`}. ` +
             `Update model-catalog.ts or default-profile-catalog.ts.`,
         );
       }
@@ -517,7 +586,9 @@ function resolveAgainstBody(
  * Non-obvious rules:
  *
  * - The `vellum` column stamps `provider: "vellum"` with no connection —
- *   dispatch derives the upstream from the model per-request.
+ *   dispatch derives the upstream from the model per-request. The `chatgpt`
+ *   column likewise stamps its routing identity with no connection;
+ *   dispatch resolves the canonical subscription row per-request.
  * - A default provider without a named matrix column materializes from the
  *   shared `BYOK_PROFILE_IMPLS` templates, with `resolveModelIntent`
  *   falling back to the provider's catalog `defaultModel`.

package/src/config/default-profile-names.ts

@@ -38,7 +38,9 @@ export const OS_BETA_PROFILE_KEY = "os-beta";
 /**
  * The named columns of the intent × provider matrix. `vellum` is the
  * platform-managed column (routed through the single `vellum` connection to
- * an underlying provider per profile); the rest are BYOK columns whose
+ * an underlying provider per profile) and `chatgpt` is the
+ * ChatGPT-subscription column (routed through the `chatgpt-subscription`
+ * connection to the Codex endpoint); the rest are BYOK columns whose
  * models resolve per provider via `resolveModelIntent`. The full set of
  * providers that can back `llm.defaultProvider` is wider, see
  * `DEFAULT_PROVIDER_CHOICES` in `schemas/llm.ts`.
@@ -53,6 +55,7 @@ export const DEFAULT_PROFILE_PROVIDERS = [
   "gemini",
   "fireworks",
   "openrouter",
+  "chatgpt",
   "vellum",
 ] as const;
 export type DefaultProfileProvider = (typeof DEFAULT_PROFILE_PROVIDERS)[number];

package/src/config/default-provider-resolution.ts

@@ -6,6 +6,7 @@
  * conveniences (`getDefaultProvider()` without an argument,
  * `setDefaultProvider`) live in `default-provider.ts`.
  */
+import { CHATGPT_SUBSCRIPTION_CONNECTION_NAME } from "../providers/inference/auth.js";
 import { VELLUM_MANAGED_CONNECTION_NAME } from "../providers/vellum-model-routing.js";
 import type { DefaultProviderConfig } from "./schemas/llm.js";
 import type { AssistantConfig } from "./types.js";
@@ -29,5 +30,8 @@ export function resolveDefaultConnectionName(
   if (dp.provider === "vellum") {
     return VELLUM_MANAGED_CONNECTION_NAME;
   }
+  if (dp.provider === "chatgpt") {
+    return CHATGPT_SUBSCRIPTION_CONNECTION_NAME;
+  }
   return `${dp.provider}-personal`;
 }

package/src/config/llm-context-resolution.ts

@@ -1,3 +1,4 @@
+import { resolveEntryProviderKind } from "../providers/connection-resolution.js";
 import { ROUTING_IDENTITY_PROVIDERS } from "../providers/inference/auth.js";
 import {
   getCatalogProviderForModel,
@@ -54,11 +55,18 @@ export function resolveEffectiveContextWindow({
     forceOverrideProfile,
     selectionSeed,
   });
-  // Routing identities are not catalog providers; the model's catalog owner
-  // carries its context-window limits.
+  // Routing identities dispatch built-in catalog models, so the model's
+  // catalog owner carries their limits. An entry-name provider resolves
+  // through its row's kind instead: a custom-endpoint kind has no catalog
+  // models, so its models keep the conservative default even when a model
+  // id collides with a built-in one (the custom endpoint's "gpt-5.5" is not
+  // OpenAI's). Labels with no row fall back to the model's catalog owner.
   const catalogProviderId = ROUTING_IDENTITY_PROVIDERS.has(resolved.provider)
     ? getCatalogProviderForModel(resolved.model)
-    : resolved.provider;
+    : PROVIDER_CATALOG.some((p) => p.id === resolved.provider)
+      ? resolved.provider
+      : (resolveEntryProviderKind(resolved.provider, resolved.model) ??
+        getCatalogProviderForModel(resolved.model));
   const catalogModel = PROVIDER_CATALOG.find(
     (provider) => provider.id === catalogProviderId,
   )?.models.find((model) => model.id === resolved.model);

package/src/config/llm-resolver.ts

@@ -76,6 +76,15 @@ import {
  */
 export interface ResolveCallSiteOpts {
   overrideProfile?: string;
+  /**
+   * Whether a profile's provider value can actually dispatch: a known
+   * vendor, or a connection entry row. Selection is pure and DB-blind, so
+   * dispatch-side callers supply this (see `dispatchProviderResolvable` in
+   * `connection-resolution.ts`); a profile failing it is unusable and
+   * selection falls through to the next rung, keeping model and transport
+   * coherent. When absent, every provider is assumed resolvable.
+   */
+  isResolvableProvider?: (provider: string) => boolean;
   /**
    * Float `overrideProfile` above the call-site layers for non-main-agent call
    * sites. Retained for API compatibility; under single-winner selection the
@@ -112,7 +121,11 @@ export interface ResolveCallSiteOpts {
   }) => void;
 }
 
-export type ResolutionFallbackReason = "missing" | "disabled" | "incomplete";
+export type ResolutionFallbackReason =
+  | "missing"
+  | "disabled"
+  | "incomplete"
+  | "unresolvable";
 
 export interface ResolvedCallSiteConfig {
   config: z.infer<typeof LLMConfigBase>;
@@ -313,6 +326,20 @@ function usableEntry(
     report(name, "incomplete");
     return undefined;
   }
+  // A provider the caller cannot resolve (not a known vendor, not an entry
+  // row) makes the profile unusable, and selection falls through to the
+  // next rung the same way an incomplete profile does: the fallback keeps
+  // model and transport coherent, where a dispatch-time fallback would pair
+  // this profile's model with the default transport. Selection is DB-blind,
+  // so the predicate is supplied by dispatch-side callers; when absent,
+  // every provider is assumed resolvable.
+  if (
+    opts.isResolvableProvider != null &&
+    !opts.isResolvableProvider(entry.provider)
+  ) {
+    report(name, "unresolvable");
+    return undefined;
+  }
   return { name, entry };
 }
 

package/src/config/profile-materialization.ts

@@ -1,9 +1,12 @@
+import { getDb } from "../persistence/db-connection.js";
 import { ROUTING_IDENTITY_PROVIDERS } from "../providers/inference/auth.js";
+import { getConnection } from "../providers/inference/connections.js";
 import {
   getCatalogProviderForModel,
   isModelInCatalog,
 } from "../providers/model-catalog.js";
 import {
+  getManagedUpstream,
   MANAGED_ROUTABLE_PROVIDERS,
   VELLUM_MANAGED_CONNECTION_NAME,
 } from "../providers/vellum-model-routing.js";
@@ -97,35 +100,80 @@ export function completeCustomProfile(
     }
   }
 
-  // A provider-specific connection baked onto a different provider would pin
-  // a mismatch (dispatch auto-resolves an absent connection by provider
-  // instead). The Vellum managed connection must survive a provider change —
-  // dispatch routes it via `expectedProvider` — but only onto providers it
-  // can actually route; a non-managed-routable provider (openrouter, ollama)
-  // would hit the mismatch path instead of auto-resolution.
-  // Routing-identity providers resolve their connection per-request from
-  // the provider value; a stamped provider_connection would be dead weight
-  // at best and a misroute at worst.
+  // Completion never stamps a `provider_connection`; an inherited binding
+  // would only re-introduce the collapsed field on disk. The default's
+  // explicit binding is instead inherited IN the provider value, the
+  // entries-model representation: the vellum binding becomes the routing
+  // identity (only when it can serve the model, or the read-path schema
+  // would strip the profile), and a same-vendor binding becomes the entry
+  // name, so a completed profile keeps signing with the credential the
+  // workspace default names rather than whatever auto-resolution finds
+  // first.
   if (
     completed.provider !== undefined &&
-    ROUTING_IDENTITY_PROVIDERS.has(completed.provider)
+    !ROUTING_IDENTITY_PROVIDERS.has(completed.provider) &&
+    profile.provider_connection === undefined &&
+    dflt.provider_connection !== undefined
   ) {
-    return structuredClone(completed);
+    if (dflt.provider_connection === VELLUM_MANAGED_CONNECTION_NAME) {
+      // Only managed-servable pairs inherit the managed binding; anything
+      // else inherits nothing and lets dispatch auto-resolve by vendor,
+      // matching the pre-entries inheritance contract.
+      if (
+        MANAGED_ROUTABLE_PROVIDERS.has(completed.provider) &&
+        completed.model !== undefined &&
+        getManagedUpstream(completed.model) !== null
+      ) {
+        completed.provider = "vellum";
+      }
+    } else if (completed.provider === dflt.provider) {
+      // Folding to the entry name is only safe against a verified row; a
+      // dangling or kind-disagreeing binding stays in the legacy field,
+      // where the collapse migration's recovery can judge it.
+      if (bindingRowKind(dflt.provider_connection) === completed.provider) {
+        completed.provider = dflt.provider_connection;
+      } else {
+        completed.provider_connection = dflt.provider_connection;
+      }
+    }
   }
+  return structuredClone(completed);
+}
 
-  const vellumRoutable =
-    dflt.provider_connection === VELLUM_MANAGED_CONNECTION_NAME &&
-    completed.provider !== undefined &&
-    MANAGED_ROUTABLE_PROVIDERS.has(completed.provider);
-  if (
-    profile.provider_connection === undefined &&
-    dflt.provider_connection !== undefined &&
-    (completed.provider === dflt.provider || vellumRoutable)
-  ) {
-    completed.provider_connection = dflt.provider_connection;
+/**
+ * `{...raw, ...completed}` recursively: completed (schema-known) values win,
+ * raw keys the schema stripped survive at every depth. Used by boot
+ * materialization and the config write path so both preserve unknown keys
+ * the same way after `safeParse`.
+ */
+export function mergePreservingUnknownKeys(
+  raw: Record<string, unknown>,
+  completed: Record<string, unknown>,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = { ...raw, ...completed };
+  for (const [key, value] of Object.entries(completed)) {
+    const rawValue = raw[key];
+    if (isRecord(value) && isRecord(rawValue)) {
+      out[key] = mergePreservingUnknownKeys(rawValue, value);
+    }
   }
+  return out;
+}
 
-  return structuredClone(completed);
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * The provider kind stored on a connection row, or null when the row is
+ * missing or the DB is unavailable (both mean "unverifiable" to callers).
+ */
+function bindingRowKind(name: string): string | null {
+  try {
+    return getConnection(getDb(), name)?.provider ?? null;
+  } catch {
+    return null;
+  }
 }
 
 type PlainObject = Record<string, unknown>;

package/src/config/schemas/__tests__/live-voice.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   LiveVoiceConfigSchema,
+  LiveVoiceFluxConfigSchema,
   LiveVoiceFrontModelConfigSchema,
   LiveVoiceVadConfigSchema,
   VALID_LIVE_VOICE_MODES,
@@ -21,11 +22,18 @@ const FRONT_MODEL_DEFAULTS = {
   endpointDecisionTimeoutMs: 1200,
   endpointExtensionMs: 1500,
   endpointMaxExtensions: 2,
-  ackFirstDeltaTimeoutMs: 2500,
-  ackGenerationTimeoutMs: 600,
   progress: PROGRESS_DEFAULTS,
 };
 
+// `eagerEotThreshold` is deliberately absent: it has no default, and leaving it
+// unset is what keeps Deepgram from emitting speculative turn events.
+const FLUX_DEFAULTS = {
+  turnEnd: { enabled: false },
+  model: "flux-general-en",
+  eotThreshold: 0.7,
+  eotTimeoutMs: 5_000,
+};
+
 describe("LiveVoiceVadConfigSchema", () => {
   test("empty object parses to defaults", () => {
     const parsed = LiveVoiceVadConfigSchema.parse({});
@@ -124,8 +132,15 @@ describe("LiveVoiceFrontModelConfigSchema", () => {
     expect(parsed.endpointMaxExtensions).toBe(0);
     // Unspecified fields still get defaults
     expect(parsed.endpointExtensionMs).toBe(1500);
-    expect(parsed.ackFirstDeltaTimeoutMs).toBe(2500);
-    expect(parsed.ackGenerationTimeoutMs).toBe(600);
+  });
+
+  test("strips retired generated-ack settings", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({
+      ackFirstDeltaTimeoutMs: 2500,
+      ackGenerationTimeoutMs: 600,
+    });
+    expect(parsed).not.toHaveProperty("ackFirstDeltaTimeoutMs");
+    expect(parsed).not.toHaveProperty("ackGenerationTimeoutMs");
   });
 
   test("rejects non-positive endpointDecisionTimeoutMs", () => {
@@ -213,6 +228,87 @@ describe("LiveVoiceFrontModelConfigSchema", () => {
   });
 });
 
+describe("LiveVoiceFluxConfigSchema", () => {
+  test("empty object parses to defaults, with turn-end off", () => {
+    expect(LiveVoiceFluxConfigSchema.parse({})).toEqual(FLUX_DEFAULTS);
+  });
+
+  test("an unset eagerEotThreshold is absent, not zero", () => {
+    expect("eagerEotThreshold" in LiveVoiceFluxConfigSchema.parse({})).toBe(
+      false,
+    );
+  });
+
+  test("accepts overrides", () => {
+    const parsed = LiveVoiceFluxConfigSchema.parse({
+      turnEnd: { enabled: true },
+      model: "flux-general-multi",
+      eotThreshold: 0.85,
+      eagerEotThreshold: 0.45,
+      eotTimeoutMs: 12_000,
+    });
+    expect(parsed.turnEnd.enabled).toBe(true);
+    expect(parsed.model).toBe("flux-general-multi");
+    expect(parsed.eotThreshold).toBe(0.85);
+    expect(parsed.eagerEotThreshold).toBe(0.45);
+    expect(parsed.eotTimeoutMs).toBe(12_000);
+  });
+
+  test("partial overrides merge with defaults", () => {
+    const parsed = LiveVoiceFluxConfigSchema.parse({ eotThreshold: 0.6 });
+    expect(parsed.eotThreshold).toBe(0.6);
+    expect(parsed.turnEnd.enabled).toBe(false);
+    expect(parsed.model).toBe("flux-general-en");
+    expect(parsed.eotTimeoutMs).toBe(5_000);
+  });
+
+  test("rejects an eotThreshold outside 0.5..0.9", () => {
+    const above = LiveVoiceFluxConfigSchema.safeParse({ eotThreshold: 0.95 });
+    expect(above.success).toBe(false);
+    expect(above.error?.issues.map((i) => i.message)).toEqual([
+      "liveVoice.flux.eotThreshold must be <= 0.9",
+    ]);
+
+    const below = LiveVoiceFluxConfigSchema.safeParse({ eotThreshold: 0.4 });
+    expect(below.success).toBe(false);
+    expect(below.error?.issues.map((i) => i.message)).toEqual([
+      "liveVoice.flux.eotThreshold must be >= 0.5",
+    ]);
+  });
+
+  test("rejects an eagerEotThreshold outside 0.3..0.9", () => {
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eagerEotThreshold: 0.2 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eagerEotThreshold: 0.95 }).success,
+    ).toBe(false);
+  });
+
+  test("rejects an eotTimeoutMs outside 500..60000, and non-integers", () => {
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eotTimeoutMs: 499 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eotTimeoutMs: 60_001 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eotTimeoutMs: 1_500.5 }).success,
+    ).toBe(false);
+  });
+
+  test("rejects a non-boolean turnEnd.enabled", () => {
+    const result = LiveVoiceFluxConfigSchema.safeParse({
+      turnEnd: { enabled: "yes" },
+    });
+    expect(result.success).toBe(false);
+    const msgs = result.error?.issues.map((i) => i.message) ?? [];
+    expect(msgs.some((m) => m.includes("liveVoice.flux.turnEnd.enabled"))).toBe(
+      true,
+    );
+  });
+});
+
 describe("LiveVoiceConfigSchema", () => {
   test("empty object parses to defaults", () => {
     const parsed = LiveVoiceConfigSchema.parse({});
@@ -228,6 +324,9 @@ describe("LiveVoiceConfigSchema", () => {
         echoDrainSlackMs: 300,
       },
       frontModel: FRONT_MODEL_DEFAULTS,
+      // Off by default: Flux turn detection is opt-in, so the front-door hold
+      // verdict keeps committing turns until it is enabled.
+      flux: FLUX_DEFAULTS,
       maxSessionDurationSeconds: 1800,
       // Off by default: voice turns carry only their transcript, no audio
       // artifacts on the conversation messages (JARVIS-1283).
@@ -255,6 +354,7 @@ describe("LiveVoiceConfigSchema", () => {
       mode: "ptt",
       vad: { silenceThresholdMs: 900 },
       frontModel: { endpointDecisionTimeoutMs: 300 },
+      flux: { turnEnd: { enabled: true } },
       maxSessionDurationSeconds: 600,
     });
     expect(parsed.mode).toBe("ptt");
@@ -265,6 +365,9 @@ describe("LiveVoiceConfigSchema", () => {
     // Partial frontModel overrides merge with defaults
     expect(parsed.frontModel.endpointDecisionTimeoutMs).toBe(300);
     expect(parsed.frontModel.endpointExtensionMs).toBe(1500);
+    // Partial flux overrides merge with defaults
+    expect(parsed.flux.turnEnd.enabled).toBe(true);
+    expect(parsed.flux.eotThreshold).toBe(0.7);
     expect(parsed.maxSessionDurationSeconds).toBe(600);
   });
 

package/src/config/schemas/call-site-catalog.ts

@@ -289,11 +289,11 @@ const CATALOG_RECORD: CatalogRecord = {
       "Captions images via a vision-capable profile for text-only model fallback.",
     domain: "skills",
   },
-  voiceFrontDecision: {
-    id: "voiceFrontDecision",
-    displayName: "Voice Front Decision",
+  voiceProgressNarration: {
+    id: "voiceProgressNarration",
+    displayName: "Voice Progress Narration",
     description:
-      "Fast turn-taking and presence decisions during live voice (semantic endpointing, ack generation).",
+      "Phrases short spoken progress updates during long-running live voice turns.",
     domain: "agentLoop",
   },
   voiceFrontDoor: {

package/src/config/schemas/live-voice.ts

@@ -207,34 +207,64 @@ export const LiveVoiceFrontModelConfigSchema = z
       )
       .default(2)
       .describe("Cap on consecutive 'hold' extensions per utterance"),
-    ackFirstDeltaTimeoutMs: z
-      .number({
-        error: "liveVoice.frontModel.ackFirstDeltaTimeoutMs must be a number",
-      })
-      .int("liveVoice.frontModel.ackFirstDeltaTimeoutMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.ackFirstDeltaTimeoutMs must be a positive integer",
-      )
-      .default(2500)
-      .describe(
-        "Keyword-delay budget (ms): a spoken ack fires if no first assistant delta has arrived by then",
-      ),
-    ackGenerationTimeoutMs: z
-      .number({
-        error: "liveVoice.frontModel.ackGenerationTimeoutMs must be a number",
-      })
-      .int("liveVoice.frontModel.ackGenerationTimeoutMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.ackGenerationTimeoutMs must be a positive integer",
-      )
-      .default(600)
-      .describe("Budget (ms) for LLM-generated ack text"),
     progress: LiveVoiceProgressConfigSchema.default(
       LiveVoiceProgressConfigSchema.parse({}),
     ),
   })
   .describe(
-    "Front-model presence layer tuning for live voice sessions (semantic endpointing + spoken acks + progress narration)",
+    "Voice front-door endpointing and long-turn progress narration tuning",
+  );
+
+const LiveVoiceFluxTurnEndConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "liveVoice.flux.turnEnd.enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Commit the live-voice turn on Flux's EndOfTurn instead of the front-door [0] hold verdict. Requires services.stt.provider to be deepgram-flux; ignored otherwise.",
+      ),
+  })
+  .describe(
+    "Which signal commits a live voice turn when Deepgram Flux is the STT provider",
+  );
+
+export const LiveVoiceFluxConfigSchema = z
+  .object({
+    turnEnd: LiveVoiceFluxTurnEndConfigSchema.default(
+      LiveVoiceFluxTurnEndConfigSchema.parse({}),
+    ),
+    model: z
+      .string({ error: "liveVoice.flux.model must be a string" })
+      .default("flux-general-en")
+      .describe("Deepgram Flux model requested when opening the STT stream"),
+    eotThreshold: z
+      .number({ error: "liveVoice.flux.eotThreshold must be a number" })
+      .min(0.5, "liveVoice.flux.eotThreshold must be >= 0.5")
+      .max(0.9, "liveVoice.flux.eotThreshold must be <= 0.9")
+      .default(0.7)
+      .describe(
+        "End-of-turn confidence Flux must reach before it emits EndOfTurn. Lower values commit sooner and cut speakers off more often; higher values wait longer and add end-of-turn latency.",
+      ),
+    eagerEotThreshold: z
+      .number({ error: "liveVoice.flux.eagerEotThreshold must be a number" })
+      .min(0.3, "liveVoice.flux.eagerEotThreshold must be >= 0.3")
+      .max(0.9, "liveVoice.flux.eagerEotThreshold must be <= 0.9")
+      .optional()
+      .describe(
+        "Confidence at which Flux starts speculating that the turn has ended. Leaving it unset disables Deepgram's EagerEndOfTurn / TurnResumed events; enabling it raises LLM calls 50-70% because speculative turns that resume are thrown away.",
+      ),
+    eotTimeoutMs: z
+      .number({ error: "liveVoice.flux.eotTimeoutMs must be a number" })
+      .int("liveVoice.flux.eotTimeoutMs must be an integer")
+      .min(500, "liveVoice.flux.eotTimeoutMs must be >= 500")
+      .max(60_000, "liveVoice.flux.eotTimeoutMs must be <= 60000")
+      .default(5_000)
+      .describe(
+        "Silence (ms) after which Flux force-ends the turn even though its end-of-turn confidence never reached eotThreshold",
+      ),
+  })
+  .describe(
+    "Deepgram Flux turn-detection tuning for live voice sessions (model-integrated end-of-turn)",
   );
 
 export const LiveVoiceConfigSchema = z
@@ -251,6 +281,9 @@ export const LiveVoiceConfigSchema = z
     frontModel: LiveVoiceFrontModelConfigSchema.default(
       LiveVoiceFrontModelConfigSchema.parse({}),
     ),
+    flux: LiveVoiceFluxConfigSchema.default(
+      LiveVoiceFluxConfigSchema.parse({}),
+    ),
     maxSessionDurationSeconds: z
       .number({
         error: "liveVoice.maxSessionDurationSeconds must be a number",
@@ -280,3 +313,4 @@ export type LiveVoiceFrontModelConfig = z.infer<
 export type LiveVoiceProgressConfig = z.infer<
   typeof LiveVoiceProgressConfigSchema
 >;
+export type LiveVoiceFluxConfig = z.infer<typeof LiveVoiceFluxConfigSchema>;