@vellumai/assistant 0.12.2 → 0.12.3-staging.1

package/src/cli/lib/inspect-plugin.ts

@@ -27,7 +27,10 @@ import {
   type InstalledPluginInfo,
   readInstalledPlugin,
 } from "./list-installed-plugins.js";
-import { readBundledLocalPluginCatalog } from "./plugin-catalog-local.js";
+import {
+  arePlatformFeaturesEnabled,
+  readBundledLocalPluginCatalog,
+} from "./plugin-catalog-local.js";
 import { DEFAULT_PLUGIN_REF } from "./plugin-constants.js";
 import {
   compareFingerprint,
@@ -338,17 +341,21 @@ export async function inspectPlugin(
   let remote: PluginRemoteInfo | null = null;
   let remoteError: string | null = null;
   const installedLocalSource = local?.source?.kind === "local";
+  const useBundledLocalCatalog =
+    installedLocalSource || (!installed && !arePlatformFeaturesEnabled());
   try {
-    if (installedLocalSource) {
+    if (useBundledLocalCatalog) {
       const catalog = deps.localCatalog ?? readBundledLocalPluginCatalog();
       const match = catalog.matches.find(
         (candidate) =>
           candidate.name === name &&
           candidate.source.kind === "local" &&
-          candidate.source.path === local.source?.path,
+          (!installedLocalSource ||
+            candidate.source.path === local.source?.path),
       );
       remote = match ? readLocalPackageRemote(match, catalog.ref) : null;
-    } else {
+    }
+    if (!remote && !installedLocalSource) {
       const entries = await fetchMarketplaceEntries(
         { fetch: deps.fetch },
         { ref: marketplaceRef },

package/src/cli/lib/upgrade-plugin.ts

@@ -412,6 +412,24 @@ export async function upgradePlugin(
     };
   }
 
+  const usesMergeStrategy =
+    strategy === "ours" || strategy === "theirs" || strategy === "assistant";
+  const canOverwriteCleanBundledInstall =
+    remote.kind === "local" &&
+    strategy === "theirs" &&
+    local.localChanges?.clean === true;
+
+  if (
+    remote.kind === "local" &&
+    usesMergeStrategy &&
+    !canOverwriteCleanBundledInstall
+  ) {
+    throw new PluginMergeBaselineError(
+      name,
+      "bundled packages do not retain the previous package version needed for a three-way merge",
+    );
+  }
+
   if (dryRun) {
     return {
       name,
@@ -433,17 +451,7 @@ export async function upgradePlugin(
   // `ours`/`theirs`/`assistant` carry local edits forward via a three-way
   // merge; the default `overwrite` discards them and re-installs the pin
   // wholesale.
-  if (
-    strategy === "ours" ||
-    strategy === "theirs" ||
-    strategy === "assistant"
-  ) {
-    if (remote.kind === "local") {
-      throw new PluginMergeBaselineError(
-        name,
-        "bundled packages do not retain the previous package version needed for a three-way merge",
-      );
-    }
+  if (usesMergeStrategy && remote.kind !== "local") {
     const [remoteOwner, remoteRepo] = remote.repo.split("/");
     return mergeUpgrade(
       {

package/src/cli/output.ts

@@ -11,20 +11,34 @@ export function shouldOutputJson(cmd: Command): boolean {
   return false;
 }
 
-export function writeOutput(cmd: Command, payload: unknown): void {
+/**
+ * Write a JSON payload to stdout. `onFlushed` runs once the bytes have left
+ * the process, for a command that must exit itself and would otherwise cut
+ * a piped payload short.
+ */
+export function writeOutput(
+  cmd: Command,
+  payload: unknown,
+  onFlushed?: () => void,
+): void {
   const compact = shouldOutputJson(cmd);
   process.stdout.write(
     compact
       ? JSON.stringify(payload) + "\n"
       : JSON.stringify(payload, null, 2) + "\n",
+    onFlushed,
   );
 }
 
 /** Format-aware error output: JSON envelope with --json, stderr otherwise. */
-export function writeError(cmd: Command, message: string): void {
+export function writeError(
+  cmd: Command,
+  message: string,
+  onFlushed?: () => void,
+): void {
   if (shouldOutputJson(cmd)) {
-    writeOutput(cmd, { ok: false, error: message });
+    writeOutput(cmd, { ok: false, error: message }, onFlushed);
   } else {
-    process.stderr.write(`Error: ${message}\n`);
+    process.stderr.write(`Error: ${message}\n`, onFlushed);
   }
 }

package/src/config/__tests__/default-provider.test.ts

@@ -72,6 +72,10 @@ describe("LLMSchema.defaultProvider", () => {
     ).toThrow();
   });
 
+  test("rejects a structured-decision catalog provider", () => {
+    expect(() => DefaultProviderSchema.parse({ provider: "jev" })).toThrow();
+  });
+
   test("rejects an empty connectionName", () => {
     expect(() =>
       DefaultProviderSchema.parse({

package/src/config/bundled-skills/schedule/SKILL.md

@@ -249,18 +249,18 @@ If any required capability is missing:
 
 Scheduled messages run without user interaction, in a conversation nobody has open. If the task produces output the user should see (a digest, summary, report, or a check whose answer is "nothing changed"), the scheduled message **must** end with an explicit instruction to deliver it. Without one, the output lives in a conversation log the user never opens.
 
-Write the delivery step into the `message` when you create the schedule — not as a vague "let me know", but as the actual call, with a real title:
+Write the delivery step into the `message` when you create the schedule, not as a vague "let me know", but as the actual call, with a real title:
 
-> "…then send the summary with `assistant notifications send --title \"Inbox digest\" --message \"<the summary>\"`."
+> "…then send the summary with `assistant notifications send --source-channel scheduler --title \"Inbox digest\" --message \"<the summary>\"`."
 
 A schedule whose message has no delivery step is not finished. Before calling `schedule_create` in `execute` mode, read your own message back and check that it says where the output goes.
 
-There is a safety net, and it is not a substitute for the above. When an execute-mode run finishes with user-facing output and nothing delivered it, the assistant sends a notification carrying the run's final reply, so a schedule can no longer run and leave no trace. `messaging_send` counts as a delivery only when the call reported success, and `assistant notifications send` once the notification pipeline has taken it: a send the channel refused, or one that never reported at all, leaves the run eligible for the net, so the failure reaches you instead of vanishing into a conversation nobody has open. A Slack `chat.postMessage` never counts, because Slack refuses a call with a successful HTTP status and `ok: false` in the body, so the command succeeding proves nothing; a run that posts Block Kit that way also gets the net's notification. It fires on the raw reply, whatever the run happened to end on, at whatever length. An authored delivery step gets a title and body you chose, sent at the moment you chose. Rely on the net and you get the machine's guess instead.
+There is a safety net, and it is not a substitute for the above. When an execute-mode run finishes with user-facing output and nothing delivered it, the assistant sends a notification carrying the run's final reply, so a schedule can no longer run and leave no trace. `messaging_send` counts as a delivery only when the call reported success, and `assistant notifications send` once the notification pipeline has taken it: a send the channel refused, or one that never reported at all, leaves the run eligible for the net, so the failure reaches you instead of vanishing into a conversation nobody has open. A Slack `chat.postMessage` never counts, because the net recognizes only the recorded routes; a run that posts Block Kit that way also gets the net's notification. It fires on the raw reply, whatever the run happened to end on, at whatever length. An authored delivery step gets a title and body you chose, sent at the moment you chose. Rely on the net and you get the machine's guess instead.
 
-Choose the right delivery tool based on the content:
+Choose the right delivery tool based on the destination:
 
-- **Rich content** (digests, summaries, reports): Use `messaging_send` with the target platform and conversation ID. It reaches Gmail or Outlook as a draft, and posts to a Slack, Telegram, or Discord chat through that channel's own transport, where the post is recorded and can be found again afterwards. Reach for `chat.postMessage` through `assistant oauth request` only for a Block Kit shape `messaging_send` cannot carry, with the provider the **slack** skill says to pass for posting on this workspace (`slack_channel` when the bot is set up; where only the `slack` integration exists, the skill says to tell the user before posting as them), never through `curl` or a revealed token. Either way the full content posts directly.
-- **Short alerts** (status updates, completion notices): Use `assistant notifications send` via `bash` to let the notification router pick the best channel. Note: the router's decision engine rewrites content into short alerts, so it is not suitable for rich content.
+- **A specific chat or mailbox** (a named Slack, Telegram, or Discord conversation, or an email draft): Use `messaging_send` with the target platform and conversation ID. It reaches Gmail or Outlook as a draft, and posts to a Slack, Telegram, or Discord chat through that channel's own transport, where the post is recorded and can be found again afterwards. Reach for `chat.postMessage` through `assistant oauth request` only for a Block Kit shape `messaging_send` cannot carry, with the provider the **slack** skill says to pass for posting on this workspace (`slack_channel` when the bot is set up; where only the `slack` integration exists, the skill says to tell the user before posting as them), never through `curl` or a revealed token. Either way the full content posts directly.
+- **The user's notification surfaces** (Vellum inbox, Telegram, platform push): Use `assistant notifications send` via `bash`. Pass `--source-channel scheduler` and the complete authored body as `--message`. The pipeline keeps that body. Do not summarize the report before sending.
 
 Example schedule message for a Slack digest:
 

package/src/config/loader.ts

@@ -58,14 +58,6 @@ type ConfigFileSignature =
       exists: false;
     };
 
-function getConfigPath(): string {
-  return getWorkspaceConfigPath();
-}
-
-function ensureMigratedDataDir(): void {
-  ensureDataDir();
-}
-
 function readConfigFileSignature(configPath: string): ConfigFileSignature {
   const stats = safeStatSync(configPath);
   if (!stats) {
@@ -104,7 +96,7 @@ function getCachedConfigIfFresh(): AssistantConfig | null {
     return null;
   }
 
-  const currentSignature = readConfigFileSignature(getConfigPath());
+  const currentSignature = readConfigFileSignature(getWorkspaceConfigPath());
   if (configFileSignaturesEqual(cachedFileSignature, currentSignature)) {
     return cached;
   }
@@ -1002,7 +994,7 @@ export function mergeDefaultWorkspaceConfig(): DefaultWorkspaceConfigMergeResult
       Object.prototype.hasOwnProperty.call(llmDefaults, "activeProfile"),
   };
 
-  const configPath = getConfigPath();
+  const configPath = getWorkspaceConfigPath();
   let existing: Record<string, unknown> = {};
   if (existsSync(configPath)) {
     try {
@@ -1070,8 +1062,8 @@ export function loadConfig(): AssistantConfig {
   loading = true;
 
   try {
-    ensureMigratedDataDir();
-    const configPath = getConfigPath();
+    ensureDataDir();
+    const configPath = getWorkspaceConfigPath();
 
     let fileConfig: Record<string, unknown> = {};
     let configFileExisted = true;
@@ -1259,7 +1251,7 @@ export function getConfigReadOnly(): AssistantConfig {
     return freshCached;
   }
 
-  const configPath = getConfigPath();
+  const configPath = getWorkspaceConfigPath();
   let fileConfig: Record<string, unknown> = {};
   if (existsSync(configPath)) {
     try {
@@ -1312,8 +1304,8 @@ export function withSuppressedConfigDiskWritesSync<T>(fn: () => T): T {
  * type without runtime shape-checking — the boundary check happens here.
  */
 export function loadRawConfig(): Record<string, unknown> {
-  ensureMigratedDataDir();
-  const configPath = getConfigPath();
+  ensureDataDir();
+  const configPath = getWorkspaceConfigPath();
   if (!existsSync(configPath)) {
     return {};
   }
@@ -1372,8 +1364,8 @@ function describeJsonShape(value: unknown): string {
 }
 
 export function saveRawConfig(config: Record<string, unknown>): void {
-  ensureMigratedDataDir();
-  const configPath = getConfigPath();
+  ensureDataDir();
+  const configPath = getWorkspaceConfigPath();
 
   // Strip legacy apiKeys — provider keys belong in secure storage, not plaintext config
   delete config.apiKeys;

package/src/config/platform-identity.ts

@@ -136,7 +136,7 @@ export function _resetPlatformIdentityEnsureForTests(): void {
  * Concurrent callers share one in-flight request.
  */
 export async function ensurePlatformIdentityIds(): Promise<void> {
-  if (getPlatformAssistantId().trim()) {
+  if (getPlatformAssistantId()?.trim()) {
     return;
   }
   if (Date.now() < nextEnsureAttemptAt) {
@@ -146,7 +146,7 @@ export async function ensurePlatformIdentityIds(): Promise<void> {
     ensureInFlight = (async () => {
       try {
         const apiKey = await readAssistantApiKey();
-        const baseUrl = getPlatformBaseUrl();
+        const baseUrl = (getPlatformBaseUrl() ?? "").replace(/\/+$/, "");
         if (!apiKey || !baseUrl) {
           return;
         }
@@ -167,12 +167,12 @@ export async function ensurePlatformIdentityIds(): Promise<void> {
 }
 
 export async function resolvePlatformAssistantId(): Promise<string> {
-  const existing = getPlatformAssistantId().trim();
+  const existing = getPlatformAssistantId()?.trim() ?? "";
   if (existing) {
     return existing;
   }
   await ensurePlatformIdentityIds();
-  return getPlatformAssistantId().trim();
+  return getPlatformAssistantId()?.trim() ?? "";
 }
 
 export async function resolvePlatformAssistantIdOrNull(): Promise<
@@ -183,19 +183,19 @@ export async function resolvePlatformAssistantIdOrNull(): Promise<
 }
 
 export async function resolvePlatformOrganizationId(): Promise<string> {
-  const existing = getPlatformOrganizationId().trim();
+  const existing = getPlatformOrganizationId()?.trim() ?? "";
   if (existing) {
     return existing;
   }
   await ensurePlatformIdentityIds();
-  return getPlatformOrganizationId().trim();
+  return getPlatformOrganizationId()?.trim() ?? "";
 }
 
 export async function resolvePlatformUserId(): Promise<string> {
-  const existing = getPlatformUserId().trim();
+  const existing = getPlatformUserId()?.trim() ?? "";
   if (existing) {
     return existing;
   }
   await ensurePlatformIdentityIds();
-  return getPlatformUserId().trim();
+  return getPlatformUserId()?.trim() ?? "";
 }

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

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  nonTextConversationProfileMessage,
+  profileSupportsTextGeneration,
+} from "./profile-text-generation.js";
+
+describe("profileSupportsTextGeneration", () => {
+  test("false for a structured-decision catalog model", () => {
+    expect(
+      profileSupportsTextGeneration(
+        { provider: "jev", model: "jev-latest" },
+        {},
+      ),
+    ).toBe(false);
+  });
+
+  test("true for a chat model and for unlisted custom ids", () => {
+    expect(
+      profileSupportsTextGeneration(
+        { provider: "anthropic", model: "claude-opus-4-8" },
+        {},
+      ),
+    ).toBe(true);
+    expect(
+      profileSupportsTextGeneration(
+        { provider: "openai-compatible", model: "local-mixtral" },
+        {},
+      ),
+    ).toBe(true);
+  });
+
+  test("a mix is false when any arm is non-text", () => {
+    expect(
+      profileSupportsTextGeneration(
+        { mix: [{ profile: "jev" }, { profile: "balanced" }] },
+        {
+          jev: { provider: "jev", model: "jev-latest" },
+          balanced: { provider: "anthropic", model: "claude-opus-4-8" },
+        },
+      ),
+    ).toBe(false);
+  });
+
+  test("names the profile in the conversation-model error", () => {
+    expect(nonTextConversationProfileMessage("jev")).toContain("jev");
+    expect(nonTextConversationProfileMessage("jev")).toContain(
+      "structured answers rather than chat text",
+    );
+  });
+});

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

@@ -0,0 +1,51 @@
+import { catalogModelSupportsText } from "../providers/model-catalog.js";
+
+/**
+ * Whether a profile can back the conversation model (active profile or a
+ * per-conversation pin). Mix arms are judged individually: a mix that can
+ * land on a non-text model is not a conversation profile.
+ *
+ * Missing arms and unlisted models default to true so other validators
+ * (existence, availability) own those failures.
+ */
+export function profileSupportsTextGeneration(
+  entry: {
+    provider?: unknown;
+    model?: unknown;
+    mix?: unknown;
+  },
+  siblings: Record<string, unknown>,
+): boolean {
+  const mix = entry.mix;
+  if (Array.isArray(mix) && mix.length > 0) {
+    return mix.every((arm) => {
+      const name =
+        arm !== null &&
+        typeof arm === "object" &&
+        "profile" in arm &&
+        typeof arm.profile === "string"
+          ? arm.profile
+          : undefined;
+      if (name === undefined) {
+        return true;
+      }
+      const target = siblings[name];
+      if (target === null || typeof target !== "object") {
+        return true;
+      }
+      const nested = target as { provider?: unknown; model?: unknown };
+      return catalogModelSupportsText(
+        typeof nested.provider === "string" ? nested.provider : undefined,
+        typeof nested.model === "string" ? nested.model : undefined,
+      );
+    });
+  }
+  return catalogModelSupportsText(
+    typeof entry.provider === "string" ? entry.provider : undefined,
+    typeof entry.model === "string" ? entry.model : undefined,
+  );
+}
+
+export function nonTextConversationProfileMessage(profileName: string): string {
+  return `Profile "${profileName}" uses a model that returns structured answers rather than chat text, so it cannot be the conversation model.`;
+}

package/src/config/schemas/__tests__/memory-v3.test.ts

@@ -45,6 +45,7 @@ describe("MemoryV3ConfigSchema", () => {
         bm25NormK: null,
         bypassForCore: false,
       },
+      poolLog: { captureInput: false },
     });
   });
 
@@ -204,6 +205,17 @@ describe("MemoryV3ConfigSchema", () => {
     ).toThrow();
   });
 
+  test("poolLog.captureInput defaults false, accepts true, rejects non-booleans", () => {
+    expect(MemoryV3ConfigSchema.parse({}).poolLog.captureInput).toBe(false);
+    expect(
+      MemoryV3ConfigSchema.parse({ poolLog: { captureInput: true } }).poolLog
+        .captureInput,
+    ).toBe(true);
+    expect(() =>
+      MemoryV3ConfigSchema.parse({ poolLog: { captureInput: "yes" } }),
+    ).toThrow();
+  });
+
   test("gate.topK rejects zero and non-integers", () => {
     expect(() => MemoryV3ConfigSchema.parse({ gate: { topK: 0 } })).toThrow();
     expect(() => MemoryV3ConfigSchema.parse({ gate: { topK: 2.5 } })).toThrow();

package/src/config/schemas/llm.ts

@@ -4,7 +4,10 @@ import {
   PROVIDERS_REQUIRING_BASE_URL_AND_MODELS,
   ROUTING_IDENTITY_PROVIDERS,
 } from "../../providers/inference/auth.js";
-import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
+import {
+  catalogModelSupportsText,
+  PROVIDER_CATALOG,
+} from "../../providers/model-catalog.js";
 import { isCodexSubscriptionModel } from "../../providers/openai/codex-models.js";
 import {
   getManagedUpstream,
@@ -59,6 +62,7 @@ export const KNOWN_LLM_PROVIDERS = [
   "opencode",
   "baseten",
   "poolside",
+  "jev",
   // Routing identities: "vellum" = the platform-managed route (upstream
   // derived from the model at dispatch) and the catalog owner of
   // Vellum-hosted GPU models; "chatgpt" = the subscription route to OpenAI.
@@ -99,7 +103,8 @@ export const DEFAULT_PROVIDER_CHOICES: readonly LLMProvider[] = [
       (entry) =>
         entry.setupMode === "api-key" &&
         !PROVIDERS_REQUIRING_BASE_URL_AND_MODELS.has(entry.id) &&
-        entry.defaultModel !== "",
+        entry.defaultModel !== "" &&
+        catalogModelSupportsText(entry.id, entry.defaultModel),
     )
       .map((entry) => entry.id)
       // A catalog provider outside the known provider set cannot be

package/src/config/schemas/mcp.ts

@@ -17,7 +17,11 @@ export const PLUGIN_MCP_RISK_LEVEL = "low" as const;
 /** Per-server cap on tools registered from one MCP server. */
 export const MCP_MAX_TOOLS_PER_SERVER = 20;
 
-/** Cap on tools registered across every MCP server. */
+/**
+ * Cap on tools registered across every MCP server. Selection is a
+ * deterministic round-robin by server id (see `mcp/tool-caps.ts`), so a
+ * later server is not emptied just because earlier ones filled the budget.
+ */
 export const MCP_GLOBAL_MAX_TOOLS = 50;
 
 export type McpRiskLevel =

package/src/config/schemas/memory-v3.ts

@@ -352,6 +352,17 @@ export const MemoryV3GateSchema = z
     "Memory v3 per-turn injection gate tuning (thresholds; the gate runs when `enabled` is on).",
   );
 
+const MemoryV3PoolLogSchema = z
+  .object({
+    captureInput: z
+      .boolean({ error: "memory.v3.poolLog.captureInput must be a boolean" })
+      .default(false)
+      .describe(
+        "Persist the selector's exact input beside each turn's pool audit: the rendered text of every pooled candidate, content-addressed in `memory_v3_pool_texts`, and the turn's context strings in `memory_v3_pool_inputs`, for offline selector evaluation and training data. Off by default; the pool audit itself (`memory_v3_pools`) is always written.",
+      ),
+  })
+  .describe("Memory v3 selector pool audit options.");
+
 // Persisted config files can carry unsupported tuning keys this object does
 // not declare; zod's default unknown-key stripping accepts and drops them, so
 // such a config keeps parsing. Do not make this object `.strict()`.
@@ -434,6 +445,7 @@ export const MemoryV3ConfigSchema = z
     entity: MemoryV3EntitySchema.default(MemoryV3EntitySchema.parse({})),
     rareTerm: MemoryV3RareTermSchema.default(MemoryV3RareTermSchema.parse({})),
     gate: MemoryV3GateSchema.default(MemoryV3GateSchema.parse({})),
+    poolLog: MemoryV3PoolLogSchema.default(MemoryV3PoolLogSchema.parse({})),
   })
   .describe("Memory v3 — section-grain lane retrieval");
 

package/src/credential-execution/ces-runtime.ts

@@ -49,8 +49,8 @@ interface CesStartupResult {
  * handles to the in-flight initialization — callers don't need to await this
  * for startup to continue.
  *
- * The managed sidecar accepts exactly one bootstrap connection, so this must be
- * called at the process level (not per-conversation).
+ * CES serves a multi-connection Unix socket, so this is called at the
+ * process level and child processes may open their own connections.
  */
 function startCesProcess(config: AssistantConfig): CesStartupResult {
   const pm = createCesProcessManager({ assistantConfig: config });