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

package/openapi.yaml

@@ -12060,7 +12060,9 @@ paths:
     post:
       operationId: dictation_post
       summary: Process dictation
-      description: Classify voice input as dictation or action, clean up text, and apply user style preferences.
+      description:
+        Preserve dictated words with explicit dictionary and snippet replacements, classify actions, or edit
+        selected text when instructed.
       tags:
         - diagnostics
       requestBody:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.4-staging.1",
+  "version": "0.12.4-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/config-loader-backfill.test.ts

@@ -1869,6 +1869,7 @@ describe("seedInferenceProfiles BYOK-mode default profiles", () => {
       "quality-optimized-backup",
       "cost-optimized-backup",
       "latency-optimized-backup",
+      "jev-managed",
       "my-custom",
     ]);
   });

package/src/__tests__/default-profile-catalog-fallback.test.ts

@@ -116,6 +116,7 @@ describe("managed-column-only scoping", () => {
     expect(Object.keys(MANAGED_PROFILE_TEMPLATES)).toEqual([
       ...DEFAULT_PROFILE_KEYS,
       ...BACKUP_PROFILE_KEYS,
+      "jev-managed",
     ]);
   });
 

package/src/__tests__/inference-profile-validation-jev.test.ts

@@ -0,0 +1,17 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { validateInferenceProfileKey } from "../config/inference-profile-validation.js";
+import { setConfig } from "./helpers/set-config.js";
+
+describe("validateInferenceProfileKey and the managed Jev profile", () => {
+  beforeEach(() => {
+    setConfig("llm", { profiles: {} });
+  });
+
+  test("a schedule or subagent turn cannot run on the verdict model", () => {
+    expect(validateInferenceProfileKey("balanced")).toBeNull();
+    expect(validateInferenceProfileKey("jev-managed")).toContain(
+      "is not defined in llm.profiles",
+    );
+  });
+});

package/src/__tests__/llm-catalog-parity.test.ts

@@ -235,6 +235,10 @@ describe("LLM catalog parity: daemon vs client", () => {
 
   test("jev-latest opts out of chat text generation", () => {
     expect(catalogModelSupportsText("typesafe", "jev-latest")).toBe(false);
+    // A managed Jev profile is configured as `vellum`; the routing identity
+    // owns no catalog models, so the lookup must judge by the catalog owner.
+    expect(catalogModelSupportsText("vellum", "jev-latest")).toBe(false);
+    expect(catalogModelSupportsText("vellum", "claude-opus-5")).toBe(true);
     expect(catalogModelSupportsText("anthropic", "claude-opus-4-8")).toBe(true);
     expect(catalogModelSupportsText("openai-compatible", "local-model")).toBe(
       true,

package/src/__tests__/llm-resolver-override-or-default.test.ts

@@ -225,6 +225,49 @@ describe("composeCallSiteTweak", () => {
 });
 
 describe("shipped call-site tuning", () => {
+  test("the escalation judge uses managed Jev by default", () => {
+    const resolved = resolveCallSiteConfig(
+      "voiceEscalationJudge",
+      LLMSchema.parse({}),
+    );
+
+    expect(resolved.provider).toBe("vellum");
+    expect(resolved.provider_connection).toBeUndefined();
+    expect(resolved.model).toBe("jev-latest");
+  });
+
+  test("the escalation judge falls through on a BYOK default provider", () => {
+    const resolved = resolveCallSiteConfig(
+      "voiceEscalationJudge",
+      LLMSchema.parse(anthropicDp),
+    );
+
+    expect(resolved.provider).toBe("anthropic");
+    expect(resolved.model).not.toBe("jev-latest");
+  });
+
+  test("a BYOK Jev call-site override replaces the managed default", () => {
+    const llm = LLMSchema.parse({
+      ...anthropicDp,
+      profiles: {
+        jev: {
+          ...completeCustom,
+          provider: "typesafe",
+          provider_connection: "typesafe-personal",
+          model: "jev-latest",
+        },
+      },
+      callSites: {
+        voiceEscalationJudge: { profile: "jev" },
+      },
+    });
+    const resolved = resolveCallSiteConfig("voiceEscalationJudge", llm);
+
+    expect(resolved.provider).toBe("typesafe");
+    expect(resolved.provider_connection).toBe("typesafe-personal");
+    expect(resolved.model).toBe("jev-latest");
+  });
+
   // A workspace entry that only repoints the profile must not cost the call
   // site the tuning it ships with. `recall` carries a full set: a token
   // budget, effort, sampling, thinking, and cache posture.

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

@@ -40,6 +40,13 @@ describe("getModelProfiles", () => {
     writeFixtureConfig({});
   });
 
+  test("omits the managed Jev profile, whose model returns verdicts rather than text", () => {
+    writeFixtureConfig({});
+    const keys = getModelProfiles().map((p) => p.key);
+    expect(keys).toContain("balanced");
+    expect(keys).not.toContain("jev-managed");
+  });
+
   test("orders profiles by profileOrder then the remaining keys alphabetically", () => {
     // GIVEN a workspace whose profileOrder names some keys, with a duplicate
     // ("balanced") and a key that resolves to no profile ("ghost").

package/src/__tests__/workspace-migration-159-rename-colliding-jev-profile-name.test.ts

@@ -0,0 +1,197 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+const migration = WORKSPACE_MIGRATIONS.find(
+  (entry) => entry.id === "159-rename-colliding-jev-profile-name",
+)!;
+
+let workspaceDir: string;
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, any> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function seedProfilePinTables(rows: {
+  conversations: string[];
+  cronJobs: string[];
+}): void {
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  db.run(
+    `CREATE TABLE conversations (id TEXT PRIMARY KEY, inference_profile TEXT)`,
+  );
+  db.run(
+    `CREATE TABLE cron_jobs (id TEXT PRIMARY KEY, inference_profile TEXT)`,
+  );
+  rows.conversations.forEach((profile, index) => {
+    db.query(
+      `INSERT INTO conversations (id, inference_profile) VALUES (?, ?)`,
+    ).run(`conv-${index}`, profile);
+  });
+  rows.cronJobs.forEach((profile, index) => {
+    db.query(`INSERT INTO cron_jobs (id, inference_profile) VALUES (?, ?)`).run(
+      `job-${index}`,
+      profile,
+    );
+  });
+  db.close();
+}
+
+function readPins(table: string): string[] {
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  try {
+    return (
+      db
+        .query(`SELECT inference_profile AS p FROM ${table} ORDER BY id`)
+        .all() as Array<{ p: string }>
+    ).map((row) => row.p);
+  } finally {
+    db.close();
+  }
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-159-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    assertNotLiveDb(workspaceDir);
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("159-rename-colliding-jev-profile-name migration", () => {
+  test("is registered under its id with checkpoint retry", () => {
+    expect(migration).toBeDefined();
+    expect(migration.retryFailedCheckpoint).toBe(true);
+  });
+
+  test("renames a colliding user profile and rewrites every reference", async () => {
+    writeConfig({
+      llm: {
+        defaultProvider: { provider: "vellum" },
+        profiles: {
+          "jev-managed": {
+            source: "user",
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+            label: "Mine",
+          },
+          scratch: { source: "user", fallbackProfile: "jev-managed" },
+          armA: { source: "user", speed: "fast" },
+          blend: {
+            source: "user",
+            mix: [
+              { profile: "jev-managed", weight: 1 },
+              { profile: "armA", weight: 1 },
+            ],
+          },
+        },
+        profileOrder: ["balanced", "jev-managed", "blend"],
+        activeProfile: "jev-managed",
+        advisorProfile: "jev-managed",
+        callSites: { recall: { profile: "jev-managed", maxTokens: 4096 } },
+      },
+    });
+    seedProfilePinTables({
+      conversations: ["jev-managed", "balanced"],
+      cronJobs: ["jev-managed"],
+    });
+
+    await migration.run(workspaceDir);
+
+    const llm = readConfig().llm;
+    expect(llm.profiles["jev-managed"]).toBeUndefined();
+    expect(llm.profiles["jev-managed-custom"]).toEqual({
+      source: "user",
+      provider: "anthropic",
+      model: "claude-opus-4-7",
+      label: "Mine",
+    });
+    expect(Object.keys(llm.profiles)).toEqual([
+      "jev-managed-custom",
+      "scratch",
+      "armA",
+      "blend",
+    ]);
+    expect(llm.activeProfile).toBe("jev-managed-custom");
+    expect(llm.advisorProfile).toBe("jev-managed-custom");
+    expect(llm.profileOrder).toEqual([
+      "balanced",
+      "jev-managed-custom",
+      "blend",
+    ]);
+    expect(llm.callSites.recall.profile).toBe("jev-managed-custom");
+    expect(llm.profiles.scratch.fallbackProfile).toBe("jev-managed-custom");
+    expect(llm.profiles.blend.mix[0].profile).toBe("jev-managed-custom");
+    expect(readPins("conversations")).toEqual([
+      "jev-managed-custom",
+      "balanced",
+    ]);
+    expect(readPins("cron_jobs")).toEqual(["jev-managed-custom"]);
+  });
+
+  test("keeps suffixing past taken and reserved names", async () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "jev-managed": {
+            source: "user",
+            provider: "openai",
+            model: "gpt-5.5",
+          },
+          "jev-managed-custom": { source: "user", provider: "openai" },
+        },
+      },
+    });
+
+    await migration.run(workspaceDir);
+
+    const keys = Object.keys(readConfig().llm.profiles);
+    expect(keys).toEqual(["jev-managed-custom-2", "jev-managed-custom"]);
+  });
+
+  test("leaves a managed stub alone and is idempotent", async () => {
+    const original = {
+      llm: {
+        profiles: {
+          "jev-managed": { source: "managed", status: "disabled" },
+          balanced: { source: "managed" },
+        },
+      },
+    };
+    writeConfig(original);
+
+    await migration.run(workspaceDir);
+    await migration.run(workspaceDir);
+
+    expect(readConfig()).toEqual(original);
+    expect(existsSync(join(workspaceDir, "data", "db", "assistant.db"))).toBe(
+      false,
+    );
+  });
+});

package/src/api/requests/dictation.ts

@@ -1,8 +1,8 @@
 /**
  * Wire contract for the dictation REST endpoint (`POST /dictation`).
  *
- * The body web/macOS sends when asking the daemon to clean up a raw voice
- * transcript and classify it as dictation vs. action. `context` is its own
+ * The body web/macOS sends to apply explicit dictation replacements, classify
+ * voice input, or edit selected text. `context` is its own
  * named schema/type so consumers (web client) can import `DictationContext`
  * directly instead of inferring it from the generated client.
  *

package/src/calls/__tests__/typesafe-noul.test.ts

@@ -0,0 +1,66 @@
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+import type { Provider } from "../../providers/types.js";
+
+let configured: {
+  provider: Provider;
+  configuredProviderName: string;
+  entryRouted: boolean;
+} | null = null;
+
+const actual = await import("../../providers/provider-send-message.js");
+mock.module("../../providers/provider-send-message.js", () => ({
+  ...actual,
+  resolveConfiguredProvider: async () => configured,
+}));
+
+const { resolveTypesafeProvider } = await import("../typesafe-noul.js");
+
+afterAll(() => {
+  mock.restore();
+});
+
+function stub(name: string): Provider {
+  return {
+    name,
+    defaultModel: "jev-latest",
+    sendMessage: async () => {
+      throw new Error("not dispatched in this test");
+    },
+  } as unknown as Provider;
+}
+
+describe("resolveTypesafeProvider", () => {
+  test("a BYOK TypeSafe profile resolves", async () => {
+    configured = {
+      provider: stub("typesafe"),
+      configuredProviderName: "typesafe",
+      entryRouted: false,
+    };
+    expect((await resolveTypesafeProvider("voiceEscalationJudge"))?.name).toBe(
+      "typesafe",
+    );
+  });
+
+  test("a managed Jev profile resolves although it is configured as vellum", async () => {
+    configured = {
+      provider: stub("typesafe"),
+      configuredProviderName: "vellum",
+      entryRouted: false,
+    };
+    expect((await resolveTypesafeProvider("voiceEscalationJudge"))?.name).toBe(
+      "typesafe",
+    );
+  });
+
+  test("any other dispatched provider is unavailable", async () => {
+    configured = {
+      provider: stub("anthropic"),
+      configuredProviderName: "vellum",
+      entryRouted: false,
+    };
+    expect(await resolveTypesafeProvider("voiceEscalationJudge")).toBeNull();
+    configured = null;
+    expect(await resolveTypesafeProvider("voiceEscalationJudge")).toBeNull();
+  });
+});

package/src/calls/typesafe-noul.ts

@@ -28,12 +28,18 @@ export interface TypesafeNoulResult {
   latencyMs: number;
 }
 
-/** The call site's provider when it resolves to TypeSafe, else null. */
+/**
+ * The call site's provider when it resolves to TypeSafe, else null. Judged
+ * on the dispatched adapter's name rather than the configured provider: a
+ * managed profile is configured as `vellum` and only substitutes the
+ * TypeSafe upstream at dispatch, so the configured name alone would report
+ * the managed Jev profile as unavailable.
+ */
 export async function resolveTypesafeProvider(
   callSite: LLMCallSite,
 ): Promise<Provider | null> {
   const resolved = await resolveConfiguredProvider(callSite);
-  return resolved?.configuredProviderName === TYPESAFE_PROVIDER_NAME
+  return resolved?.provider.name === TYPESAFE_PROVIDER_NAME
     ? resolved.provider
     : null;
 }

package/src/calls/voice-escalation-judge.ts

@@ -9,10 +9,11 @@
  * correct reply need something the front door cannot do from here? A
  * confident yes overrules a front-door answer and hands the turn off.
  *
- * The judge runs only when the `voiceEscalationJudge` call site resolves to
- * the TypeSafe provider. Every other outcome (no such profile, provider
- * error, timeout, unparseable answer) is a "clear" verdict, so the front
- * door's own decision stands exactly as it would without the judge.
+ * The judge uses managed Jev by default when Vellum-managed inference is
+ * available. An explicit TypeSafe call-site override can use a user-owned
+ * connection. Every other outcome (unavailable route, provider error,
+ * timeout, unparseable answer) is a "clear" verdict, so the front door's own
+ * decision stands exactly as it would without the judge.
  */
 
 import type { Message, Provider } from "../providers/types.js";

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

@@ -5,6 +5,7 @@ import { resolveModelIntent } from "../../providers/model-intents.js";
 import { CALL_SITE_DEFAULTS } from "../call-site-defaults.js";
 import {
   CODE_DEFAULT_PROFILE_ENTRIES,
+  getConversationProfilesForProvider,
   getEffectiveProfile,
   getEffectiveProfiles,
   getEffectiveProfilesForProvider,
@@ -59,6 +60,37 @@ describe("getEffectiveProfiles", () => {
     }
   });
 
+  test("the managed Jev profile routes jev-latest through TypeSafe and is managed-only", () => {
+    const jev = CODE_DEFAULT_PROFILE_ENTRIES["jev-managed"];
+    expect(jev.model).toBe("jev-latest");
+    expect(jev.provider_connection).toBeUndefined();
+    expect(resolveRoutingIdentity(jev.provider, jev.model)).toEqual({
+      connectionName: "vellum",
+      expectedProvider: "typesafe",
+    });
+    expect(
+      resolveDefaultProfileForProvider(undefined, "jev-managed", null),
+    ).toBeDefined();
+    expect(
+      resolveDefaultProfileForProvider(undefined, "jev-managed", {
+        provider: "anthropic",
+        connectionName: "anthropic-personal",
+      }),
+    ).toBeUndefined();
+  });
+
+  test("the conversation view drops the managed Jev profile but keeps it selectable for call sites", () => {
+    expect(
+      Object.keys(getConversationProfilesForProvider(undefined, null)),
+    ).not.toContain("jev-managed");
+    expect(
+      Object.keys(getUserSelectableProfilesForProvider(undefined, null)),
+    ).toContain("jev-managed");
+    expect(
+      Object.keys(getConversationProfilesForProvider(undefined, null)),
+    ).toContain("balanced");
+  });
+
   test("the managed Balanced profile routes GLM 5.3 Flash through Fireworks", () => {
     const balanced = CODE_DEFAULT_PROFILE_ENTRIES.balanced;
     expect(balanced.model).toBe("accounts/fireworks/models/glm-5p3-flash");
@@ -80,7 +112,7 @@ describe("getEffectiveProfiles", () => {
   test("defaults absent from the workspace resolve from the catalog; os-beta stays flag-gated", () => {
     const effective = getEffectiveProfiles(undefined);
     expect(Object.keys(effective).sort()).toEqual(
-      [...DEFAULT_PROFILE_KEYS, ...BACKUP_PROFILE_KEYS].sort(),
+      [...DEFAULT_PROFILE_KEYS, ...BACKUP_PROFILE_KEYS, "jev-managed"].sort(),
     );
     expect(getEffectiveProfile({}, "balanced")?.model).toBe(
       CODE_DEFAULT_PROFILE_ENTRIES.balanced.model as string,

package/src/config/__tests__/jev-managed-profile.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+
+import { LLMSchema } from "../schemas/llm.js";
+
+const PIN = { callSites: { voiceEscalationJudge: { profile: "jev-managed" } } };
+
+describe("jev-managed as a call-site pin target", () => {
+  test("resolves under the managed default provider", () => {
+    expect(LLMSchema.safeParse(PIN).success).toBe(true);
+    expect(
+      LLMSchema.safeParse({
+        ...PIN,
+        defaultProvider: { provider: "vellum" },
+      }).success,
+    ).toBe(true);
+  });
+
+  test("can be pinned only to the verdict-consuming call sites", () => {
+    for (const site of [
+      "voiceEscalationJudge",
+      "voiceContinuationJudge",
+      "memoryV3SelectL2",
+    ]) {
+      expect(
+        LLMSchema.safeParse({
+          callSites: { [site]: { profile: "jev-managed" } },
+        }).success,
+      ).toBe(true);
+    }
+    const result = LLMSchema.safeParse({
+      callSites: { conversationTitle: { profile: "jev-managed" } },
+    });
+    expect(result.success).toBe(false);
+    expect(JSON.stringify(result.error?.issues)).toContain(
+      "can only be pinned to",
+    );
+  });
+
+  test("cannot be a mix constituent", () => {
+    const result = LLMSchema.safeParse({
+      profiles: {
+        blend: {
+          mix: [
+            { profile: "jev-managed", weight: 1 },
+            { profile: "balanced", weight: 1 },
+          ],
+        },
+      },
+    });
+    expect(result.success).toBe(false);
+    expect(JSON.stringify(result.error?.issues)).toContain(
+      "cannot be a mix constituent",
+    );
+  });
+
+  test("is rejected as the active or advisor profile even on the managed column", () => {
+    for (const field of ["activeProfile", "advisorProfile"] as const) {
+      const result = LLMSchema.safeParse({ [field]: "jev-managed" });
+      expect(result.success).toBe(false);
+      expect(JSON.stringify(result.error?.issues)).toContain(
+        "structured answers rather than chat text",
+      );
+    }
+    expect(LLMSchema.safeParse({ activeProfile: "balanced" }).success).toBe(
+      true,
+    );
+  });
+
+  test("is rejected under a BYOK default provider, where it has no body", () => {
+    const result = LLMSchema.safeParse({
+      ...PIN,
+      defaultProvider: {
+        provider: "anthropic",
+        connectionName: "anthropic-personal",
+      },
+    });
+    expect(result.success).toBe(false);
+    expect(JSON.stringify(result.error?.issues)).toContain(
+      "managed Jev profile",
+    );
+  });
+});

package/src/config/call-site-defaults.ts

@@ -1,3 +1,4 @@
+import { JEV_MANAGED_PROFILE_KEY } from "./default-profile-names.js";
 import { type LLMCallSite } from "./schemas/llm.js";
 
 type CallSiteDefaultConfig = {
@@ -123,9 +124,8 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     effort: "low",
     thinking: { enabled: false },
   },
-  // The dictation cleanup pass, and nothing else runs on this site. The
-  // caller has already stopped speaking and has nothing on screen until this
-  // answers, so it is priced as a latency call.
+  // Voice intent classification and explicit selected-text edits are
+  // latency-sensitive: the caller is waiting for insertion or dispatch.
   interactionClassifier: {
     profile: "latency-optimized",
     effort: "low",
@@ -153,14 +153,14 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     effort: "low",
     thinking: { enabled: false },
   },
-  // The escalation judge only runs when this site resolves to the TypeSafe
-  // provider (see calls/voice-escalation-judge.ts), so the shipped default is
-  // any ordinary profile: the judge stays off until a user pins a TypeSafe
-  // profile here.
-  voiceEscalationJudge: { profile: "cost-optimized" },
-  // Same arrangement for the barge-in continuation judge
-  // (live-voice/continuation-judge.ts): off until a TypeSafe profile is
-  // pinned here.
+  // The managed-only profile resolves through the Vellum connection. On a
+  // BYOK install it has no body, so the judge is unavailable and the front
+  // door's own decision stands.
+  voiceEscalationJudge: {
+    profile: JEV_MANAGED_PROFILE_KEY,
+  },
+  // The barge-in continuation judge remains off until a TypeSafe profile is
+  // pinned here (see live-voice/continuation-judge.ts).
   voiceContinuationJudge: { profile: "cost-optimized" },
   // Names the background continuation a barge-in spawns, from the interrupted
   // transcript. The label is fixed at spawn, so the call runs under a short