@vellumai/assistant 0.12.4-staging.1 → 0.12.4-staging.2

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

@@ -15,12 +15,14 @@ import {
   type DefaultProfileKey,
   type DefaultProfileProvider,
   FALLBACK_PROFILE_BY_KEY,
-  isBackupProfileKey,
   isDefaultProfileKey,
   isDefaultProfileProvider,
+  isManagedOnlyProfileKey,
+  JEV_MANAGED_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 } from "./default-profile-names.js";
 import { resolveDefaultConnectionName } from "./default-provider-resolution.js";
+import { profileSupportsTextGeneration } from "./profile-text-generation.js";
 import {
   backupProfilesResolveUnderDefaultProvider,
   DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS,
@@ -385,18 +387,39 @@ export const PROFILE_IMPLS: Record<
   Record<DefaultProfileProvider, DefaultProfileTemplate>
 >;
 
+/**
+ * The managed Jev profile: TypeSafe's System One decision model through the
+ * platform proxy. Managed column only, because the platform is the only
+ * route the catalog offers for it here, and never a conversation profile,
+ * because `jev-latest` returns structured answers rather than chat text
+ * (`supportsText: false` on the `typesafe` catalog entry). Its budget is
+ * TypeSafe's published request limit rather than the default context window.
+ */
+export const JEV_MANAGED_PROFILE_TEMPLATE: DefaultProfileTemplate = {
+  model: "jev-latest",
+  provider: "vellum",
+  source: "managed",
+  label: "Jev",
+  description:
+    "TypeSafe decision model for yes/no verdicts, for the voice judges and memory selection",
+  maxTokens: 4096,
+  thinking: { enabled: false, streamThinking: false },
+  contextWindow: { maxInputTokens: 32_000 },
+};
+
 /**
  * Managed profiles, i.e. the `vellum` column keyed by profile name, plus the
- * managed backup profiles. Backups come after the primaries, which is what
- * places them after the primaries in the seeded `profileOrder`: the seeder
- * inserts missing managed keys in this record's order. Keyed by the
- * user-facing defaults only: an internal profile is code-resolved and never
- * listed or ordered.
+ * managed backup profiles and the managed Jev profile. Backups come after the
+ * primaries, which is what places them after the primaries in the seeded
+ * `profileOrder`: the seeder inserts missing managed keys in this record's
+ * order. Keyed by the user-facing defaults only: an internal profile is
+ * code-resolved and never listed or ordered.
  */
 export const MANAGED_PROFILE_TEMPLATES: Record<string, DefaultProfileTemplate> =
   Object.fromEntries([
     ...DEFAULT_PROFILE_KEYS.map((key) => [key, PROFILE_IMPLS[key].vellum]),
     ...BACKUP_PROFILE_KEYS.map((key) => [key, BACKUP_PROFILE_IMPLS[key]]),
+    [JEV_MANAGED_PROFILE_KEY, JEV_MANAGED_PROFILE_TEMPLATE],
   ]);
 
 /**
@@ -484,6 +507,9 @@ export const OS_BETA_PROFILE_TEMPLATE: DefaultProfileTemplate = {
 export const CODE_OWNED_PROFILE_NAMES = new Set<string>([
   "latency-optimized",
   ...BACKUP_PROFILE_KEYS,
+  // A shadow could repoint the judges at a chat model, which answers a
+  // yes/no question with prose the verdict parser cannot read.
+  JEV_MANAGED_PROFILE_KEY,
 ]);
 
 // All managed profiles, including the flag-gated os-beta, are invariant:
@@ -494,6 +520,7 @@ export const CODE_OWNED_PROFILE_NAMES = new Set<string>([
 export const INVARIANT_PROFILE_NAMES = new Set<string>([
   ...DEFAULT_PROFILE_KEYS,
   ...BACKUP_PROFILE_KEYS,
+  JEV_MANAGED_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 ]);
 
@@ -507,6 +534,7 @@ export const INVARIANT_PROFILE_NAMES = new Set<string>([
 export const MANAGED_PROFILE_NAMES = new Set<string>([
   ...DEFAULT_PROFILE_KEYS,
   ...BACKUP_PROFILE_KEYS,
+  JEV_MANAGED_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 ]);
 
@@ -590,6 +618,19 @@ for (const key of BACKUP_PROFILE_KEYS) {
   }
 }
 
+// The managed Jev profile pins a model the platform proxy must front, and the
+// judges depend on it being the non-text TypeSafe model rather than a chat
+// model that happens to share the id.
+if (
+  getManagedUpstream(JEV_MANAGED_PROFILE_TEMPLATE.model ?? "") !== "typesafe"
+) {
+  throw new Error(
+    `JEV_MANAGED_PROFILE_TEMPLATE references model "${JEV_MANAGED_PROFILE_TEMPLATE.model ?? ""}" ` +
+      `which the managed route does not serve through typesafe. ` +
+      `Update model-catalog.ts, platform-proxy/constants.ts, or default-profile-catalog.ts.`,
+  );
+}
+
 // Provider choices without a named column materialize from the shared BYOK
 // templates; verify each one's resolved model lands in the catalog.
 for (const provider of DEFAULT_PROVIDER_CHOICES) {
@@ -621,6 +662,10 @@ function buildDefaultProfileEntries(): Record<string, ProfileEntry> {
     const impl = BACKUP_PROFILE_IMPLS[key];
     entries[key] = materializeProfile(impl, impl.provider);
   }
+  entries[JEV_MANAGED_PROFILE_KEY] = materializeProfile(
+    JEV_MANAGED_PROFILE_TEMPLATE,
+    JEV_MANAGED_PROFILE_TEMPLATE.provider,
+  );
   entries[OS_BETA_PROFILE_KEY] = materializeProfile(
     OS_BETA_PROFILE_TEMPLATE,
     OS_BETA_PROFILE_TEMPLATE.provider,
@@ -697,12 +742,13 @@ function resolveAgainstBody(
   if (body == null) {
     // A managed stub is the workspace's slot for a code-owned profile, never
     // a profile of its own, so with no body behind it there is nothing to
-    // resolve. Only a backup name reaches this branch with a stub (the
-    // default keys always have a body), and it reaches it on the columns
-    // where the backups do not exist. Resolving to the stub would list a
-    // profile with no provider or model and let a reference to it look
-    // valid, which is precisely what `LLMSchema` rejects on those columns.
-    if (isBackupProfileKey(name) && workspace?.source === "managed") {
+    // resolve. Only a managed-only name (a backup, the Jev profile) reaches
+    // this branch with a stub (the default keys always have a body), and it
+    // reaches it on the columns where those profiles do not exist. Resolving
+    // to the stub would list a profile with no provider or model and let a
+    // reference to it look valid, which is precisely what `LLMSchema` rejects
+    // on those columns.
+    if (isManagedOnlyProfileKey(name) && workspace?.source === "managed") {
       return undefined;
     }
     return workspace;
@@ -787,14 +833,14 @@ function defaultProfileBodyForProvider(
   defaultProvider: DefaultProviderConfig | null,
 ): ProfileEntry | undefined {
   if (!isDefaultProfileKey(name)) {
-    // Backup profiles are companions of the managed (`vellum`) column only:
-    // under a BYOK or chatgpt default provider the primaries carry no
-    // `fallbackProfile` pointers, and the backups must not materialize
-    // either, since the install may hold no credential for the backup's
+    // Backup profiles and the managed Jev profile exist on the managed
+    // (`vellum`) column only: under a BYOK or chatgpt default provider the
+    // primaries carry no `fallbackProfile` pointers, and neither may
+    // materialize, since the install may hold no credential for their
     // provider. A null defaultProvider predates `llm.defaultProvider` and
-    // resolves to the managed column, so it keeps its backups.
+    // resolves to the managed column, so it keeps them.
     if (
-      isBackupProfileKey(name) &&
+      isManagedOnlyProfileKey(name) &&
       !backupProfilesResolveUnderDefaultProvider(defaultProvider)
     ) {
       return undefined;
@@ -923,3 +969,27 @@ export function getUserSelectableProfilesForProvider(
   }
   return selectable;
 }
+
+/**
+ * The profiles a conversation can run on: the user-selectable view minus any
+ * profile whose model returns structured answers rather than chat text (the
+ * managed Jev profile). Every surface that picks or validates a conversation
+ * profile (the `/model` command, a per-conversation pin, the plugin and
+ * workflow listings) reads this view; the call-site override pickers keep
+ * the wider selectable view, since the verdict sites are what Jev is for.
+ */
+export function getConversationProfilesForProvider(
+  workspaceProfiles: Record<string, ProfileEntry> | undefined,
+  defaultProvider: DefaultProviderConfig | null,
+): Record<string, ProfileEntry> {
+  const selectable = getUserSelectableProfilesForProvider(
+    workspaceProfiles,
+    defaultProvider,
+  );
+  for (const [name, entry] of Object.entries(selectable)) {
+    if (!profileSupportsTextGeneration(entry, selectable)) {
+      delete selectable[name];
+    }
+  }
+  return selectable;
+}

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

@@ -67,6 +67,41 @@ export function isBackupProfileKey(value: string): value is BackupProfileKey {
   return (BACKUP_PROFILE_KEYS as readonly string[]).includes(value);
 }
 
+/**
+ * Managed profile for the TypeSafe decision model (Jev). Deliberately NOT
+ * part of `DEFAULT_PROFILE_KEYS`: it has no BYOK column, because the
+ * platform serves Jev only through the managed route, and its model returns
+ * structured answers rather than chat text, so it can never be the active
+ * or conversation profile. It exists as a pin target for the call sites
+ * that consume a yes/no verdict (the voice judges, the memory selector).
+ */
+export const JEV_MANAGED_PROFILE_KEY = "jev-managed";
+
+/**
+ * The call sites that consume a structured verdict and so may be pinned to
+ * the Jev profile. Every other site expects chat text or a tool call, which
+ * the decision model never produces.
+ */
+export const JEV_MANAGED_PROFILE_CALL_SITES = [
+  "voiceEscalationJudge",
+  "voiceContinuationJudge",
+  "memoryV3SelectL2",
+] as const;
+
+/**
+ * Keys whose profile exists on the managed (`vellum`) column only: the
+ * backups and the Jev profile. Under a BYOK or ChatGPT default provider
+ * these names have no body to resolve to.
+ */
+export const MANAGED_ONLY_PROFILE_KEYS = [
+  ...BACKUP_PROFILE_KEYS,
+  JEV_MANAGED_PROFILE_KEY,
+] as const;
+
+export function isManagedOnlyProfileKey(value: string): boolean {
+  return (MANAGED_ONLY_PROFILE_KEYS as readonly string[]).includes(value);
+}
+
 /**
  * Flag-gated default profile: only available while the `os-beta` feature
  * flag has reconciled it into the workspace (see `sync-gated-profiles.ts`).

package/src/config/inference-profile-validation.ts

@@ -1,4 +1,4 @@
-import { getUserSelectableProfilesForProvider } from "./default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "./default-profile-catalog.js";
 import { getConfigReadOnly } from "./loader.js";
 
 /**
@@ -6,17 +6,18 @@ import { getConfigReadOnly } from "./loader.js";
  * (code-defined defaults + workspace `llm.profiles`). Returns a user-facing
  * error message when the key is empty or unknown, or `null` when valid.
  *
- * Resolved through the `llm.defaultProvider`-aware user-selectable view so
- * availability matches what a direct profile pin can choose. Managed backup
- * routes remain available to automatic fallback resolution but are not
- * reported as selectable profiles.
+ * Resolved through the `llm.defaultProvider`-aware conversation view, since
+ * every caller (schedules, subagent spawns, per-conversation pins) runs chat
+ * turns on the result. Managed backup routes remain available to automatic
+ * fallback resolution, and the managed Jev profile to the verdict call
+ * sites, but neither is reported as a selectable profile here.
  */
 export function validateInferenceProfileKey(profile: string): string | null {
   if (!profile.trim()) {
     return "inferenceProfile must be a non-empty string";
   }
   const llm = getConfigReadOnly().llm;
-  const profiles = getUserSelectableProfilesForProvider(
+  const profiles = getConversationProfilesForProvider(
     llm?.profiles,
     llm?.defaultProvider ?? null,
   );

package/src/config/llm-resolver.ts

@@ -627,6 +627,22 @@ export function resolveDefaultProfileKey(
   return selectWinningProfile(callSite, llm, {}).profileName ?? undefined;
 }
 
+/**
+ * Returns the code-owned profile tier for catalog display when that tier is
+ * available through the workspace's default provider. Workspace call-site
+ * pins do not affect this value. A managed-only tier on a BYOK install returns
+ * undefined so clients do not report a profile that cannot run there.
+ */
+export function resolveShippedDefaultProfileKey(
+  callSite: LLMCallSite,
+  llm: z.infer<typeof LLMSchema>,
+): string | undefined {
+  const intent = CALL_SITE_DEFAULTS[callSite]?.profile ?? "balanced";
+  return usableDefaultIntent(intent, llm, {}, () => undefined) == null
+    ? undefined
+    : intent;
+}
+
 /**
  * Returns the profile key that `resolveCallSiteConfig` treats as the winning
  * (highest-precedence) profile for a turn — the profile whose fragment supplies

package/src/config/profile-text-generation.test.ts

@@ -15,6 +15,15 @@ describe("profileSupportsTextGeneration", () => {
     ).toBe(false);
   });
 
+  test("false for the managed Jev profile shape", () => {
+    expect(
+      profileSupportsTextGeneration(
+        { provider: "vellum", model: "jev-latest" },
+        {},
+      ),
+    ).toBe(false);
+  });
+
   test("true for a chat model and for unlisted custom ids", () => {
     expect(
       profileSupportsTextGeneration(

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

@@ -307,7 +307,7 @@ const CATALOG_RECORD: CatalogRecord = {
     id: "voiceEscalationJudge",
     displayName: "Voice Escalation Judge",
     description:
-      "Second opinion on the voice front door's escalate decision. Runs only when pinned to a TypeSafe profile; a confident 'needs tools' verdict hands the turn to the escalated leg.",
+      "Second opinion on the voice front door's escalate decision. Uses managed Jev when Vellum-managed inference is available, or an explicitly configured TypeSafe profile; a confident 'needs tools' verdict hands the turn to the escalated leg.",
     domain: "agentLoop",
   },
   voiceContinuationJudge: {

package/src/config/schemas/llm.ts

@@ -14,12 +14,14 @@ import {
   parseVellumModel,
 } from "../../providers/vellum-model-routing.js";
 import {
-  BACKUP_PROFILE_KEYS,
   DEFAULT_PROFILE_KEYS,
   DEFAULT_PROFILE_PROVIDERS,
   FALLBACK_PROFILE_BY_KEY,
-  isBackupProfileKey,
   isDefaultProfileKey,
+  isManagedOnlyProfileKey,
+  JEV_MANAGED_PROFILE_CALL_SITES,
+  JEV_MANAGED_PROFILE_KEY,
+  MANAGED_ONLY_PROFILE_KEYS,
 } from "../default-profile-names.js";
 import { InputModalitiesSchema } from "../input-modalities.js";
 
@@ -766,10 +768,12 @@ function unresolvableProfileReason(
   name: string,
   backupsResolve: boolean,
 ): string {
-  return !backupsResolve &&
-    (BACKUP_PROFILE_KEYS as readonly string[]).includes(name)
-    ? "is a managed backup profile, which resolves only while llm.defaultProvider is the managed provider"
-    : "is not defined in llm.profiles";
+  if (backupsResolve || !isManagedOnlyProfileKey(name)) {
+    return "is not defined in llm.profiles";
+  }
+  return name === JEV_MANAGED_PROFILE_KEY
+    ? "is the managed Jev profile, which resolves only while llm.defaultProvider is the managed provider"
+    : "is a managed backup profile, which resolves only while llm.defaultProvider is the managed provider";
 }
 
 /**
@@ -800,7 +804,7 @@ function referenceableProfileKeys(
 ): string[] {
   return Object.entries(profiles ?? {})
     .filter(([name, value]) => {
-      if (backupsResolve || !isBackupProfileKey(name)) {
+      if (backupsResolve || !isManagedOnlyProfileKey(name)) {
         return true;
       }
       const entry =
@@ -854,7 +858,7 @@ export function collectFallbackProfileIssues(
   const profileNames = new Set([
     ...referenceableProfileKeys(profiles, backupsResolve),
     ...DEFAULT_PROFILE_KEYS,
-    ...(backupsResolve ? BACKUP_PROFILE_KEYS : []),
+    ...(backupsResolve ? MANAGED_ONLY_PROFILE_KEYS : []),
   ]);
   const mixProfileNames = new Set(
     entries
@@ -1004,6 +1008,8 @@ export const LLMSchema = z
     // they join the set only under a managed `llm.defaultProvider`: on a BYOK
     // or ChatGPT default provider they have no body to resolve to, and
     // keeping the reference would strand a selection the picker cannot show.
+    // The managed Jev profile (`JEV_MANAGED_PROFILE_KEY`) is scoped the same
+    // way, as a pin target for the judge call sites.
     // The flag-gated `os-beta` is excluded: it resolves only while a
     // workspace entry exists, so a reference to it is valid only when that
     // entry is present in `config.profiles`. A backup name materialized as a
@@ -1018,9 +1024,23 @@ export const LLMSchema = z
         backupsResolve,
       ),
       ...DEFAULT_PROFILE_KEYS,
-      ...(backupsResolve ? BACKUP_PROFILE_KEYS : []),
+      ...(backupsResolve ? MANAGED_ONLY_PROFILE_KEYS : []),
     ]);
     for (const [siteId, siteConfig] of Object.entries(config.callSites ?? {})) {
+      // The Jev profile answers with structured verdicts, so only the sites
+      // built to read one may pin it; a text-producing site would receive
+      // output it cannot use. (Mix arms are covered by the profile-level
+      // mix validation below, which bars the profile from any mix.)
+      if (
+        siteConfig?.profile === JEV_MANAGED_PROFILE_KEY &&
+        !(JEV_MANAGED_PROFILE_CALL_SITES as readonly string[]).includes(siteId)
+      ) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["callSites", siteId, "profile"],
+          message: `Profile "${JEV_MANAGED_PROFILE_KEY}" returns structured answers rather than chat text, so it can only be pinned to ${JEV_MANAGED_PROFILE_CALL_SITES.join(", ")}`,
+        });
+      }
       if (siteConfig?.profile == null) {
         continue;
       }
@@ -1052,6 +1072,20 @@ export const LLMSchema = z
         message: `Profile "${config.advisorProfile}" referenced by llm.advisorProfile ${unresolvableProfileReason(config.advisorProfile, backupsResolve)}`,
       });
     }
+    // The managed Jev profile is a valid reference target for call-site pins
+    // only. Its model returns structured verdicts rather than chat text, so
+    // the conversation positions reject it here as well as at the write
+    // routes, which keeps a raw config write from handing the main agent or
+    // the advisor a model that cannot answer in prose.
+    for (const field of ["activeProfile", "advisorProfile"] as const) {
+      if (config[field] === JEV_MANAGED_PROFILE_KEY) {
+        ctx.addIssue({
+          code: "custom",
+          path: [field],
+          message: `Profile "${JEV_MANAGED_PROFILE_KEY}" referenced by llm.${field} returns structured answers rather than chat text, so it cannot be the conversation or advisor profile`,
+        });
+      }
+    }
 
     // --- Mix profile validation --------------------------------------------
     // Config keys a mix profile must NOT also set (a mix only references other
@@ -1105,6 +1139,17 @@ export const LLMSchema = z
           });
           continue;
         }
+        // A mix is a conversation profile, so an arm that returns structured
+        // verdicts rather than text would hand a chat turn to the decision
+        // model whenever the seeded pick lands on it.
+        if (arm.profile === JEV_MANAGED_PROFILE_KEY) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["profiles", name, "mix", index, "profile"],
+            message: `Mix profile "${name}" references "${JEV_MANAGED_PROFILE_KEY}", which returns structured answers rather than chat text and cannot be a mix constituent.`,
+          });
+          continue;
+        }
         // (b) No nesting — a mix arm must be a standard (non-mix) profile.
         if (mixProfileNames.has(arm.profile)) {
           ctx.addIssue({

package/src/daemon/conversation-slash.ts

@@ -1,5 +1,5 @@
 import type { InterfaceId } from "../channels/types.js";
-import { getUserSelectableProfilesForProvider } from "../config/default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "../config/default-profile-catalog.js";
 import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import {
@@ -148,7 +148,7 @@ async function resolveModelCommand(
   parse: ModelCommandParse,
 ): Promise<SlashResolution> {
   const config = getConfig();
-  const profiles = getUserSelectableProfilesForProvider(
+  const profiles = getConversationProfilesForProvider(
     config.llm.profiles,
     config.llm.defaultProvider ?? null,
   );

package/src/daemon/dictation-text-processing.ts

@@ -1,8 +1,8 @@
 /**
  * Pure text-processing functions for dictation profiles.
  *
- * - expandSnippets: pre-LLM, dictation mode only
- * - applyDictionary: post-LLM, dictation + command modes (including fallback paths)
+ * - expandSnippets: dictation mode only
+ * - applyDictionary: dictation and selected-text edits (including fallback paths)
  */
 
 import type {
@@ -33,7 +33,7 @@ function wrapWordBoundary(
 }
 
 /**
- * Expand snippet triggers in text before sending to the LLM.
+ * Expand user-configured snippet triggers in dictated text.
  *
  * - Only enabled snippets are considered
  * - Sorted by trigger length descending (longest match wins)
@@ -80,7 +80,7 @@ export function expandSnippets(
 }
 
 /**
- * Apply dictionary normalization to text after LLM processing (or on raw fallback).
+ * Apply user-configured dictionary replacements to dictated or edited text.
  *
  * - Sorted by spoken length descending
  * - Respects wholeWord (default true) and caseSensitive (default false) per entry

package/src/plugin-api/model-profiles.ts

@@ -1,4 +1,4 @@
-import { getUserSelectableProfilesForProvider } from "../config/default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "../config/default-profile-catalog.js";
 import { getConfig } from "../config/loader.js";
 import { isDispatchableProfile } from "../config/profile-dispatchability.js";
 import { orderProfileKeys } from "../config/profile-order.js";
@@ -7,7 +7,9 @@ import type { ModelProfileInfo } from "./types.js";
 /**
  * List the workspace inference profiles a plugin can route to, in the order a
  * user-facing model picker presents them (`llm.profileOrder` first, then the
- * rest alphabetically). Managed backup routes are internal and omitted.
+ * rest alphabetically). Managed backup routes and the managed Jev profile
+ * are omitted with the rest of the conversation view: a plugin routes
+ * conversation turns, and a decision model cannot answer them.
  * Metadata-only entries without a provider, model, or mix are not routing
  * targets, so plugins never see them. Disabled profiles are included and flagged via
  * {@link ModelProfileInfo.isDisabled}; weighted "mix" profiles are included and
@@ -20,7 +22,7 @@ import type { ModelProfileInfo } from "./types.js";
 export function getModelProfiles(): ModelProfileInfo[] {
   const { llm } = getConfig();
   const { activeProfile } = llm;
-  const profiles = getUserSelectableProfilesForProvider(
+  const profiles = getConversationProfilesForProvider(
     llm.profiles,
     llm.defaultProvider ?? null,
   );

package/src/providers/model-catalog.ts

@@ -1,7 +1,9 @@
 import { PLATFORM_PROVIDER_META } from "./platform-proxy/constants.js";
 
 export type LongContextMode =
-  "native-model" | "provider-request-option" | "unsupported";
+  | "native-model"
+  | "provider-request-option"
+  | "unsupported";
 
 export interface CatalogModelPricingTier {
   /**
@@ -2602,6 +2604,16 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] =
     supportsPlatformAuth: PLATFORM_PROVIDER_META[entry.id]?.managed === true,
   }));
 
+/**
+ * Providers that are routing identities rather than catalog owners. Mirrors
+ * `ROUTING_IDENTITY_PROVIDERS` in `inference/auth.ts`, which cannot be
+ * imported here without a cycle.
+ */
+const ROUTING_IDENTITY_PROVIDER_IDS: ReadonlySet<string> = new Set([
+  "vellum",
+  "chatgpt",
+]);
+
 /**
  * Whether a catalog model produces free-form chat text. Unlisted providers
  * and model ids default to true so custom endpoints and unknown snapshots
@@ -2614,9 +2626,16 @@ export function catalogModelSupportsText(
   if (typeof provider !== "string" || typeof modelId !== "string") {
     return true;
   }
-  const model = PROVIDER_CATALOG.find((p) => p.id === provider)?.models.find(
-    (m) => m.id === modelId,
-  );
+  // A routing identity ("vellum", "chatgpt") owns no catalog models of the
+  // upstream it dispatches to, so judge the model by its catalog owner: a
+  // managed Jev profile is `vellum` + `jev-latest`, and `jev-latest` opts out
+  // of text under `typesafe`.
+  const catalogProvider = ROUTING_IDENTITY_PROVIDER_IDS.has(provider)
+    ? (getCatalogProviderForModel(modelId) ?? provider)
+    : provider;
+  const model = PROVIDER_CATALOG.find(
+    (p) => p.id === catalogProvider,
+  )?.models.find((m) => m.id === modelId);
   return model?.supportsText !== false;
 }