@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/config/llm-resolver.ts

@@ -485,6 +485,7 @@ function winnerConfigFragment(entry: ProfileEntry): Mergeable {
     description: _description,
     status: _status,
     mix: _mix,
+    fallbackProfile: _fallbackProfile,
     ...config
   } = entry;
   return config as Mergeable;
@@ -642,6 +643,30 @@ export function resolveEffectiveProfileKey(
   return selectWinningProfile(callSite, llm, opts).profileName ?? undefined;
 }
 
+/**
+ * Returns the winning profile key only when it identifies a single provider
+ * route: one profile whose own provider/model fragment serves every call it
+ * wins. A mix winner returns `undefined` on purpose. Its arm is picked per
+ * conversation from a seed (or `Math.random()` unseeded), so a caller
+ * recomputing after the fact cannot know which arm actually ran, and arms can
+ * span providers, so the outer mix key would put one label on what are
+ * several provider routes. Use this where attribution must not claim a
+ * broader scope than the route that ran (e.g. failure-notification dedupe);
+ * `undefined` means "no single route can be named", and callers fall back to
+ * their narrower key.
+ */
+export function resolveSingleRouteProfileKey(
+  callSite: LLMCallSite,
+  llm: z.infer<typeof LLMSchema>,
+  opts: ResolveCallSiteOpts = {},
+): string | undefined {
+  const name = selectWinningProfile(callSite, llm, opts).profileName;
+  if (name == null) {
+    return undefined;
+  }
+  return providerAwareEntry(llm, name)?.mix == null ? name : undefined;
+}
+
 /**
  * Stable non-null identity for profileless configs. Callers should prefer real
  * profile keys first; when no named profile applies, the resolved model id is

package/src/config/loader.ts

@@ -179,6 +179,9 @@ export function getDeploymentContextDefaults(): Record<string, unknown> {
       "todoist-oauth": managed,
       "discord-oauth": managed,
       "hubspot-oauth": managed,
+      "monday-oauth": managed,
+      "eventbrite-oauth": managed,
+      "calendly-oauth": managed,
     },
   };
 }

package/src/config/managed-speech-defaults.ts

@@ -18,8 +18,23 @@
 
 import { ttsSecretResolves } from "../calls/telephony-tts-capability.js";
 import { managedSpeechAvailable } from "../platform/managed-speech.js";
-import { getProviderEntry } from "../providers/speech-to-text/provider-catalog.js";
+import { fluxModelForLanguage } from "../providers/speech-to-text/deepgram-flux-frames.js";
+import {
+  baseModelFamilyFor,
+  getProviderEntry,
+  isManagedSttProvider,
+  resolveSttCatalogKey,
+  sttConfigForCatalogKey,
+  supportsProviderTurnDetection,
+} from "../providers/speech-to-text/provider-catalog.js";
 import { sttProviderKeyResolves } from "../providers/speech-to-text/resolve.js";
+import {
+  STT_ROLES,
+  sttCatalogKeyForRole,
+  type SttRole,
+  sttRoleCapabilityGap,
+  sttSelectionForRole,
+} from "../stt/roles.js";
 import type { SttProviderId } from "../stt/types.js";
 import { getCatalogProvider } from "../tts/provider-catalog.js";
 import type { TtsProviderId } from "../tts/types.js";
@@ -60,6 +75,31 @@ async function ttsByokCredentialsResolve(provider: string): Promise<boolean> {
   return true;
 }
 
+/**
+ * The managed provider that stands in for a configured one whose credential
+ * did not resolve.
+ *
+ * Managed speech has two STT entries, and they are not interchangeable:
+ * `vellum-flux` decides end-of-turn itself, `vellum` leaves it to the
+ * session's silence timer. Substituting the plain one for a provider that had
+ * provider turn detection would keep live voice working while quietly
+ * changing how it takes turns, which reads as "Flux is no better" rather than
+ * as a missing credential. Match the capability instead.
+ */
+function managedStandInFor(
+  configured: SttProviderId,
+  language: string | undefined,
+): SttProviderId {
+  if (!supportsProviderTurnDetection(configured)) {
+    return "vellum";
+  }
+  // Flux has a model for ten languages. Outside them the relay rejects the
+  // dial outright, so standing in with it would hand the speaker a mic that
+  // does not work at all rather than one that detects turns less well. The
+  // language is the one the resolver will actually send.
+  return fluxModelForLanguage(language) === null ? "vellum" : "vellum-flux";
+}
+
 /** The speech providers a runtime path uses, after managed-speech defaulting. */
 export interface EffectiveSpeechProviders {
   stt: SttProviderId;
@@ -70,19 +110,23 @@ export interface EffectiveSpeechProviders {
  * Resolve the speech providers the runtime actually uses.
  *
  * A configured service whose BYOK credential does not resolve is reported as
- * `"vellum"` while managed speech is available; every other service keeps its
- * configured provider. Read-only — callers that hold no `settings.write`
+ * its managed stand-in while managed speech is available (see
+ * {@link managedStandInFor}, which preserves provider turn detection); every
+ * other service keeps its configured provider. Read-only: callers that hold no `settings.write`
  * scope (the live-voice WebSocket transport) resolve the same verdict the
  * preflight route does without persisting anything.
  *
  * `config` selects the configuration to read the configured providers from,
- * for callers already holding one (defaults to the loaded config).
+ * for callers already holding one (defaults to the loaded config). `role`
+ * selects which consumer's STT override applies; omitting it reads the global
+ * provider.
  */
 export async function resolveEffectiveSpeechProviders(
   config?: AssistantConfig,
+  options: { role?: SttRole } = {},
 ): Promise<EffectiveSpeechProviders> {
   const services = (config ?? getConfig()).services;
-  const configuredStt = services.stt.provider as SttProviderId;
+  const configuredStt = sttCatalogKeyForRole(services.stt, options.role);
   const configuredTts = services.tts.provider as TtsProviderId;
 
   if (!(await managedSpeechAvailable())) {
@@ -90,9 +134,9 @@ export async function resolveEffectiveSpeechProviders(
   }
 
   const stt =
-    configuredStt !== "vellum" &&
+    !isManagedSttProvider(configuredStt) &&
     !(await sttByokCredentialResolves(configuredStt))
-      ? "vellum"
+      ? managedStandInFor(configuredStt, services.stt.language)
       : configuredStt;
 
   const tts =
@@ -101,7 +145,85 @@ export async function resolveEffectiveSpeechProviders(
       ? "vellum"
       : configuredTts;
 
-  return { stt, tts };
+  return {
+    stt: managedLiveVoiceModelFamily(stt, options.role, services.stt),
+    tts,
+  };
+}
+
+/**
+ * Managed live voice runs Flux.
+ *
+ * Turn detection is the reason to reach for Flux at all, and managed users
+ * cannot ask for it: the provider picker offers no model family, so `vellum`
+ * is as specific as they can be. Deciding it here rather than persisting a
+ * `services.stt.roles.liveVoice` entry keeps managed opinionated without
+ * writing config on anyone's behalf, and reaches installs already on `vellum`
+ * that a substitution rule never sees.
+ *
+ * Two things still win over it. A family the user named is honoured, because
+ * `services.stt.providers.vellum.model` accepts `nova-3` and quietly ignoring
+ * a valid setting is the silent substitution roles exist to prevent. And a
+ * language outside Flux's roster stays on nova-3, since the relay refuses the
+ * dial rather than degrading (see `managedStandInFor`).
+ *
+ * Live voice only: Flux streams and nothing else, so every other consumer
+ * would lose its transcriber.
+ */
+function managedLiveVoiceModelFamily(
+  resolved: SttProviderId,
+  role: SttRole | undefined,
+  stt: AssistantConfig["services"]["stt"],
+): SttProviderId {
+  if (role !== "liveVoice" || resolved !== "vellum") {
+    return resolved;
+  }
+  if (sttSelectionForRole(stt, role).model !== undefined) {
+    return resolved;
+  }
+  return fluxModelForLanguage(stt.language) === null ? "vellum" : "vellum-flux";
+}
+
+/**
+ * Whether a provider can serve every consumer, or only the one that chose it.
+ *
+ * `vellum` covers every boundary, so substituting it is safe everywhere. A
+ * narrowing row like `vellum-flux` streams and nothing else, and the roles it
+ * fails are exactly the consumers that must not be moved onto it.
+ */
+function servesEveryRole(provider: SttProviderId): boolean {
+  const selection = sttConfigForCatalogKey(provider);
+  return STT_ROLES.every(
+    (role) => sttRoleCapabilityGap(role, selection) === null,
+  );
+}
+
+/**
+ * The writes that put `selection` in force as the global provider.
+ *
+ * The family is always written, including the base one. Substituting away
+ * from a variant leaves its `model` behind otherwise, and the next load
+ * resolves straight back to the variant this substitution just rejected: the
+ * provider would read as plain vellum while running Flux, with batch and
+ * telephony quietly unavailable. A provider with no families has no name to
+ * write, and no variant to have left a stale value behind either.
+ */
+function globalSttUpdates(selection: {
+  provider: string;
+  model?: string | undefined;
+}): { path: string; provider: string }[] {
+  const updates = [
+    { path: "services.stt.provider", provider: selection.provider },
+  ];
+  const family =
+    selection.model ?? baseModelFamilyFor(selection.provider as SttProviderId);
+  if (family !== undefined) {
+    updates.push({
+      path: `services.stt.providers.${selection.provider}.model`,
+      provider: family,
+    });
+  }
+  return updates;
 }
 
 /**
@@ -119,8 +241,36 @@ export async function maybeDefaultSpeechToManaged(): Promise<void> {
     const effective = await resolveEffectiveSpeechProviders();
 
     const updates: { path: string; provider: string }[] = [];
-    if (effective.stt !== services.stt.provider) {
-      updates.push({ path: "services.stt.provider", provider: effective.stt });
+    if (effective.stt !== resolveSttCatalogKey(services.stt)) {
+      // A variant row is not a valid services.stt.provider value, so persist
+      // the pair that selects it. Writing the key itself would put an id the
+      // schema rejects on disk, and an unparseable services block is how the
+      // loader's salvage ladder ends up resetting the whole section.
+      const standIn = sttConfigForCatalogKey(effective.stt);
+      if (servesEveryRole(effective.stt)) {
+        updates.push(...globalSttUpdates(standIn));
+      } else {
+        // A stand-in that cannot serve every consumer belongs to the one that
+        // chose it. Live voice is that consumer: provider turn detection is
+        // the only reason managedStandInFor reaches for a narrow row, and
+        // writing that row globally would take batch transcription and
+        // telephony from every other consumer in a single write.
+        updates.push({
+          path: "services.stt.roles.liveVoice.provider",
+          provider: standIn.provider,
+        });
+        if (standIn.model !== undefined) {
+          updates.push({
+            path: "services.stt.roles.liveVoice.model",
+            provider: standIn.model,
+          });
+        }
+        // The other consumers still need a provider that answers, and the
+        // narrow stand-in's own base is the managed row that serves them.
+        if (servesEveryRole(standIn.provider as SttProviderId)) {
+          updates.push(...globalSttUpdates({ provider: standIn.provider }));
+        }
+      }
     }
     if (effective.tts !== services.tts.provider) {
       updates.push({ path: "services.tts.provider", provider: effective.tts });

package/src/config/schema.ts

@@ -20,6 +20,7 @@ import { BackupConfigSchema } from "./schemas/backup.js";
 import { CallsConfigSchema } from "./schemas/calls.js";
 import {
   A2AConfigSchema,
+  DiscordConfigSchema,
   SlackConfigSchema,
   TelegramConfigSchema,
   TwilioConfigSchema,
@@ -120,6 +121,7 @@ export const AssistantConfigSchema = z.object({
   whatsapp: WhatsAppConfigSchema.default(WhatsAppConfigSchema.parse({})),
   telegram: TelegramConfigSchema.default(TelegramConfigSchema.parse({})),
   slack: SlackConfigSchema.default(SlackConfigSchema.parse({})),
+  discord: DiscordConfigSchema.default(DiscordConfigSchema.parse({})),
   a2a: A2AConfigSchema.default(A2AConfigSchema.parse({})),
   ingress: IngressConfigSchema,
   platform: PlatformConfigSchema.default(PlatformConfigSchema.parse({})),

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

@@ -26,10 +26,11 @@ const FRONT_MODEL_DEFAULTS = {
 };
 
 // `eagerEotThreshold` is deliberately absent: it has no default, and leaving it
-// unset is what keeps Deepgram from emitting speculative turn events.
+// unset is what keeps Deepgram from emitting speculative turn events. `model`
+// is absent for a related reason: unset means the spoken language selects the
+// model, and pinning one overrides that.
 const FLUX_DEFAULTS = {
-  turnEnd: { enabled: false },
-  model: "flux-general-en",
+  turnEnd: { enabled: true },
   eotThreshold: 0.7,
   eotTimeoutMs: 5_000,
 };
@@ -229,7 +230,7 @@ describe("LiveVoiceFrontModelConfigSchema", () => {
 });
 
 describe("LiveVoiceFluxConfigSchema", () => {
-  test("empty object parses to defaults, with turn-end off", () => {
+  test("empty object parses to defaults, with turn-end on", () => {
     expect(LiveVoiceFluxConfigSchema.parse({})).toEqual(FLUX_DEFAULTS);
   });
 
@@ -257,8 +258,8 @@ describe("LiveVoiceFluxConfigSchema", () => {
   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.turnEnd.enabled).toBe(true);
+    expect(parsed.model).toBeUndefined();
     expect(parsed.eotTimeoutMs).toBe(5_000);
   });
 

package/src/config/schemas/__tests__/stt.test.ts

@@ -122,6 +122,100 @@ describe("managed provider", () => {
       provider: "vellum",
       language: "multi",
       providers: {},
+      roles: {},
     });
   });
 });
+
+describe("services.stt.roles", () => {
+  test("defaults to empty so an untouched config is unchanged", () => {
+    expect(SttServiceSchema.parse({ provider: "deepgram" }).roles).toEqual({});
+  });
+
+  test("accepts a role whose selection covers what it needs", () => {
+    const parsed = SttServiceSchema.parse({
+      provider: "deepgram",
+      roles: { liveVoice: { provider: "deepgram", model: "flux" } },
+    });
+    expect(parsed.roles).toEqual({
+      liveVoice: { provider: "deepgram", model: "flux" },
+    });
+  });
+
+  test("a role can select a different family than the global default", () => {
+    // The point of the split: live voice on flux while everything else keeps
+    // the batch-capable family.
+    const parsed = SttServiceSchema.parse({
+      provider: "deepgram",
+      roles: { liveVoice: { provider: "deepgram", model: "flux" } },
+    });
+    expect(parsed.provider).toBe("deepgram");
+    expect(parsed.roles.liveVoice?.model).toBe("flux");
+  });
+
+  test("rejects a streaming-only family for a role that batches", () => {
+    // The whole point of the split: Flux has no batch endpoint, so it can
+    // serve live voice and cannot serve file transcription.
+    for (const role of ["batch", "dictation", "telephony"]) {
+      const result = SttServiceSchema.safeParse({
+        provider: "deepgram",
+        roles: { [role]: { provider: "deepgram", model: "flux" } },
+      });
+      expect(result.success).toBe(false);
+      expect(result.error?.issues[0]?.message).toContain(
+        `services.stt.roles.${role} cannot be "deepgram" running flux`,
+      );
+    }
+  });
+
+  test("names the first requirement a provider misses", () => {
+    // Telephony needs both boundaries AND call ingestion. Flux is missing a
+    // boundary, so that is what the message says: the reported reason is the
+    // one the user has to act on, not a generic incompatibility.
+    const result = SttServiceSchema.safeParse({
+      provider: "deepgram",
+      roles: { telephony: { provider: "deepgram", model: "flux" } },
+    });
+    expect(result.success).toBe(false);
+    expect(result.error?.issues[0]?.message).toContain(
+      "supports no daemon-batch transcription, which telephony needs",
+    );
+  });
+
+  test("rejects an unknown role key", () => {
+    expect(
+      SttServiceSchema.safeParse({
+        provider: "deepgram",
+        roles: { transcription: { provider: "deepgram" } },
+      }).success,
+    ).toBe(false);
+  });
+
+  test("normalizes provider aliases inside a role", () => {
+    expect(
+      SttServiceSchema.parse({
+        provider: "deepgram",
+        roles: { batch: { provider: "whisper" } },
+      }).roles,
+    ).toEqual({ batch: { provider: "openai-whisper" } });
+  });
+});
+
+describe("services.stt.roles model validation", () => {
+  test("rejects a family the role's provider cannot serve", () => {
+    const result = SttServiceSchema.safeParse({
+      provider: "deepgram",
+      roles: { liveVoice: { provider: "openai-whisper", model: "flux" } },
+    });
+    expect(result.success).toBe(false);
+    expect(result.error?.issues[0]?.message).toContain("single model");
+  });
+
+  test("a role with no model runs the provider's default family", () => {
+    const parsed = SttServiceSchema.parse({
+      provider: "deepgram",
+      roles: { batch: { provider: "deepgram" } },
+    });
+    expect(parsed.roles.batch).toEqual({ provider: "deepgram" });
+  });
+});

package/src/config/schemas/backup.ts

@@ -29,7 +29,7 @@ export const BackupOffsiteConfigSchema = z
       .nullable()
       .default(null)
       .describe(
-        "Offsite destinations. null means use the default iCloud Drive destination with encryption on; an explicit array (including []) overrides the default.",
+        "Offsite destinations. null uses encrypted iCloud Drive on macOS and no implicit destination on Windows or Linux; an explicit array (including []) overrides the default.",
       ),
   })
   .describe("Offsite backup configuration");

package/src/config/schemas/channels.ts

@@ -121,6 +121,38 @@ export const A2AConfigSchema = z
   })
   .describe("Agent-to-Agent protocol channel configuration");
 
+/**
+ * Discord channel settings.
+ *
+ * All three are read back from Discord when a bot token validates and written
+ * here so a connected panel can name the bot and build an install link
+ * without another round trip. The bot user and the application are separate
+ * ids: they coincide today, and a link built on that assumption would break
+ * silently if they stopped.
+ */
+export const DiscordConfigSchema = z
+  .object({
+    botUserId: z
+      .string({ error: "discord.botUserId must be a string" })
+      .default("")
+      .describe("Discord bot user ID"),
+    botUsername: z
+      .string({ error: "discord.botUsername must be a string" })
+      .default("")
+      .describe("Discord bot display name"),
+    applicationId: z
+      .string({ error: "discord.applicationId must be a string" })
+      .default("")
+      .describe("Discord application ID the bot belongs to"),
+    inviteUrl: z
+      .string({ error: "discord.inviteUrl must be a string" })
+      .default("")
+      .describe(
+        "Install link for the bot's application, computed when a token validates",
+      ),
+  })
+  .describe("Discord channel configuration");
+
 export const SlackConfigSchema = z
   .object({
     deliverAuthBypass: z

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

@@ -219,9 +219,16 @@ const LiveVoiceFluxTurnEndConfigSchema = z
   .object({
     enabled: z
       .boolean({ error: "liveVoice.flux.turnEnd.enabled must be a boolean" })
-      .default(false)
+      // On by default because it is the only reason to select Flux, and
+      // because off is not a neutral setting on this provider: managed Flux
+      // exposes no `finalizeUtterance` (Flux commits turns itself), so the
+      // session's persistence check falls through and it opens a socket per
+      // utterance, putting a full Deepgram handshake on every turn. Ignored
+      // by any provider that does not own its turn boundary, so the default
+      // reaches only the sessions it is about.
+      .default(true)
       .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.",
+        "Commit the live-voice turn on Flux's EndOfTurn instead of the front-door [0] hold verdict. Requires the active STT provider to be running the flux model family (services.stt.providers.<provider>.model); ignored otherwise.",
       ),
   })
   .describe(
@@ -235,8 +242,10 @@ export const LiveVoiceFluxConfigSchema = z
     ),
     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"),
+      .optional()
+      .describe(
+        "Deepgram Flux model to pin when opening the STT stream. Unset (the default) selects the model from services.stt.language: English and unset use the English model, everything else uses the multilingual one",
+      ),
     eotThreshold: z
       .number({ error: "liveVoice.flux.eotThreshold must be a number" })
       .min(0.5, "liveVoice.flux.eotThreshold must be >= 0.5")