@vellumai/assistant 0.12.3 → 0.12.4-staging.2

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/cli/commands/channel-verification-sessions.help.ts

@@ -44,7 +44,11 @@ Examples:
           description:
             "Destination address for outbound verification (handle, phone number, user ID, or email address)",
         },
-        { flags: "--rebind", description: "Replace existing guardian binding" },
+        {
+          flags: "--rebind",
+          description:
+            "Create a code although the channel already has a guardian (see below)",
+        },
         {
           flags: "--conversation-id <conversationId>",
           description: "Conversation ID for inbound challenges",
@@ -74,7 +78,13 @@ Routes between three creation modes based on the provided options:
   2. Outbound: --channel <ch> --destination <dest>
      Sends a verification code to the given destination. Supports telegram
      (handle or chat ID), phone (E.164 number), slack and discord (user ID),
-     and email. Use --rebind to replace an existing guardian binding.
+     and email.
+
+--rebind creates a code although the channel already has a guardian. On
+telegram, slack, discord and email, only the account already bound can redeem
+that code, which is how the same guardian verifies again. A code never moves
+the guardian to a different account there: run "revoke" first, then create
+without --rebind. On phone, an outbound code replaces the bound number.
 
   3. Inbound: --channel <ch> (no --destination)
      Generates a challenge secret for the guardian to send back on the

package/src/cli/lib/bundled-marketplace.json

@@ -176,16 +176,16 @@
       "icon": "\ud83d\udcbb"
     },
     {
-      "name": "ecommerce-wismo-supporter",
+      "name": "ecommerce-order-supporter",
       "description": "Resolves ecommerce Where-Is-My-Order (WISMO) support inquiries, cross-checks real-time carrier tracking milestones, flags delivery exceptions, and stages customer update drafts without helpdesk seat taxes.",
       "category": "commerce",
       "icon": "📦",
       "license": "MIT",
-      "homepage": "https://github.com/ZeebBoyBlue/ecommerce-wismo-supporter",
+      "homepage": "https://github.com/ZeebBoyBlue/ecommerce-order-supporter",
       "source": {
         "source": "github",
-        "repo": "ZeebBoyBlue/ecommerce-wismo-supporter",
-        "ref": "9218c23d325c749500d59b6ae651f38264a43cd1"
+        "repo": "ZeebBoyBlue/ecommerce-order-supporter",
+        "ref": "35e2165a14447a897aee750a198c3f166458226b"
       }
     },
     {

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