@vellumai/assistant 0.12.2 → 0.12.3-staging.2

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: "typesafe", 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: "typesafe", 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/__tests__/tools.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+
+import { MCP_GLOBAL_MAX_TOOLS } from "../mcp.js";
+import { ToolsConfigSchema } from "../tools.js";
+
+describe("ToolsConfigSchema.mcpGlobalMaxTools", () => {
+  test("omits the override so the shipped MCP cap remains in force", () => {
+    const parsed = ToolsConfigSchema.parse({});
+    expect(parsed.mcpGlobalMaxTools).toBeUndefined();
+    expect(parsed.exclude).toEqual([]);
+  });
+
+  test("accepts a workspace override", () => {
+    expect(
+      ToolsConfigSchema.parse({ mcpGlobalMaxTools: 80 }).mcpGlobalMaxTools,
+    ).toBe(80);
+    expect(
+      ToolsConfigSchema.parse({
+        mcpGlobalMaxTools: MCP_GLOBAL_MAX_TOOLS,
+      }).mcpGlobalMaxTools,
+    ).toBe(MCP_GLOBAL_MAX_TOOLS);
+    expect(
+      ToolsConfigSchema.parse({ mcpGlobalMaxTools: 1000 }).mcpGlobalMaxTools,
+    ).toBe(1000);
+  });
+
+  test("rejects zero and fractions", () => {
+    expect(() => ToolsConfigSchema.parse({ mcpGlobalMaxTools: 0 })).toThrow();
+    expect(() => ToolsConfigSchema.parse({ mcpGlobalMaxTools: 1.5 })).toThrow();
+  });
+});

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

@@ -303,6 +303,20 @@ const CATALOG_RECORD: CatalogRecord = {
       "Fast front-door leg fronting live-voice turns under triage-and-escalate: leading-token verdict, holding phrase, or the direct answer.",
     domain: "agentLoop",
   },
+  voiceEscalationJudge: {
+    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.",
+    domain: "agentLoop",
+  },
+  voiceContinuationJudge: {
+    id: "voiceContinuationJudge",
+    displayName: "Voice Continuation Judge",
+    description:
+      "Decides from the caller's interruption whether a barged-in request should keep running in the background. Runs only when pinned to a TypeSafe profile.",
+    domain: "agentLoop",
+  },
   voiceContinuationLabel: {
     id: "voiceContinuationLabel",
     displayName: "Voice Continuation Label",

package/src/config/schemas/channels.ts

@@ -23,12 +23,6 @@ export const WhatsAppConfigSchema = z
       .string({ error: "whatsapp.phoneNumber must be a string" })
       .default("")
       .describe("WhatsApp Business phone number"),
-    deliverAuthBypass: z
-      .boolean({ error: "whatsapp.deliverAuthBypass must be a boolean" })
-      .default(false)
-      .describe(
-        "Whether to bypass authentication when delivering WhatsApp messages",
-      ),
     timeoutMs: z
       .number({ error: "whatsapp.timeoutMs must be a number" })
       .int("whatsapp.timeoutMs must be an integer")
@@ -81,12 +75,6 @@ export const TelegramConfigSchema = z
       .describe(
         "Webhook URL this deployment last registered with Telegram (managed by the gateway)",
       ),
-    deliverAuthBypass: z
-      .boolean({ error: "telegram.deliverAuthBypass must be a boolean" })
-      .default(false)
-      .describe(
-        "Whether to bypass authentication when delivering Telegram messages",
-      ),
     timeoutMs: z
       .number({ error: "telegram.timeoutMs must be a number" })
       .int("telegram.timeoutMs must be an integer")
@@ -155,12 +143,6 @@ export const DiscordConfigSchema = z
 
 export const SlackConfigSchema = z
   .object({
-    deliverAuthBypass: z
-      .boolean({ error: "slack.deliverAuthBypass must be a boolean" })
-      .default(false)
-      .describe(
-        "Whether to bypass authentication when delivering Slack messages",
-      ),
     teamId: z
       .string({ error: "slack.teamId must be a string" })
       .default("")

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",
+  "typesafe",
   // 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
@@ -224,6 +229,8 @@ export const LLMCallSiteEnum = z.enum([
   "vision",
   "voiceProgressNarration",
   "voiceFrontDoor",
+  "voiceEscalationJudge",
+  "voiceContinuationJudge",
   "voiceContinuationLabel",
   "trustRuleSuggestion",
   "homeGreeting",

package/src/config/schemas/mcp.ts

@@ -17,7 +17,12 @@ 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 when the workspace
+ * does not set `tools.mcpGlobalMaxTools` in config.json. 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-retrospective.ts

@@ -11,14 +11,23 @@ export const MemoryRetrospectiveConfigSchema = z
 
     skillImprovement: z
       .boolean({
-        error:
-          "memory.retrospective.skillImprovement must be a boolean",
+        error: "memory.retrospective.skillImprovement must be a boolean",
       })
       .default(true)
       .describe(
         "Whether retrospectives may discover, refine, and create managed skills from observed procedures. When false, retrospectives still capture ordinary memories through `remember`, but cannot load skill management, search for similar skills, or scaffold managed skills.",
       ),
 
+    skillImprovementMonitoring: z
+      .boolean({
+        error:
+          "memory.retrospective.skillImprovementMonitoring must be a boolean",
+      })
+      .default(false)
+      .describe(
+        "Reserved opt-in for monitoring retrospective skill-improvement decisions. This setting currently has no effect.",
+      ),
+
     timeThresholdMs: z
       .number({
         error: "memory.retrospective.timeThresholdMs must be a number",

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/config/schemas/services.ts

@@ -22,7 +22,12 @@ export const VALID_INFERENCE_PROVIDERS = [
 
 // `vellum` generates through the platform runtime proxy; the backend
 // (gemini/openai) derives from the selected model's prefix at request time.
-const VALID_IMAGE_GEN_PROVIDERS = ["vellum", "gemini", "openai"] as const;
+const VALID_IMAGE_GEN_PROVIDERS = [
+  "vellum",
+  "gemini",
+  "openai",
+  "openrouter",
+] as const;
 
 /**
  * Derived from `SEARCH_PROVIDER_CATALOG`. Adding a new web-search provider
@@ -56,8 +61,9 @@ const InferenceServiceSchema = z.object({});
 /**
  * Image generation carries no `mode`: `provider` is the only axis. `"vellum"`
  * generates through the platform runtime proxy for the model-appropriate
- * backend, billed to Vellum credits; `"gemini"`/`"openai"` use the user's
- * key. A `mode` key sent by an older client is stripped at parse.
+ * backend, billed to Vellum credits; `"gemini"`/`"openai"`/`"openrouter"`
+ * use the user's key. A `mode` key sent by an older client is stripped at
+ * parse.
  */
 const ImageGenerationServiceSchema = z.object({
   provider: z.enum(VALID_IMAGE_GEN_PROVIDERS).default("gemini"),
@@ -76,8 +82,10 @@ const WebSearchServiceSchema = z.object({
   provider: z
     .enum(VALID_WEB_SEARCH_PROVIDERS)
     .default("inference-provider-native"),
-  // Origin for providers that support a custom API base (e.g. fastCRW).
-  // Empty / omitted uses the provider's cloud default.
+  // Origin for providers that support a custom API base (e.g. fastCRW,
+  // SearXNG, TinyFish). Empty / omitted uses the provider's cloud default
+  // when one exists. SearXNG has no cloud default and requires a user-supplied
+  // URL.
   apiBase: z.string().optional(),
 });
 
@@ -91,7 +99,8 @@ const WebFetchServiceSchema = z.object({
   // `firecrawl`) scrape via their hosted API and reuse the same stored key as
   // their web-search counterpart.
   provider: z.enum(VALID_WEB_FETCH_PROVIDERS).default("default"),
-  // Origin for providers that support a custom API base (e.g. fastCRW).
+  // Origin for providers that support a custom API base (e.g. fastCRW,
+  // TinyFish).
   // Empty / omitted uses the provider's cloud default.
   apiBase: z.string().optional(),
 });

package/src/config/schemas/tools.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 
+import { MCP_GLOBAL_MAX_TOOLS } from "./mcp.js";
+
 export const ToolsConfigSchema = z
   .object({
     exclude: z
@@ -8,6 +10,14 @@ export const ToolsConfigSchema = z
       .describe(
         "Tool names to suppress. Excluded tools are not sent to the LLM. Names match `ToolDefinition.name` exactly (e.g. `bash`, `mcp__server__tool`).",
       ),
+    mcpGlobalMaxTools: z
+      .number({ error: "tools.mcpGlobalMaxTools must be a number" })
+      .int("tools.mcpGlobalMaxTools must be an integer")
+      .min(1, "tools.mcpGlobalMaxTools must be >= 1")
+      .optional()
+      .describe(
+        `Override the code-owned cap on MCP tools registered across every server. Omit to use the shipped default of ${MCP_GLOBAL_MAX_TOOLS}. Selection is a fair round-robin by server id.`,
+      ),
   })
   .describe("Tool visibility configuration");
 

package/src/config/session-groups-gate.ts

@@ -0,0 +1,21 @@
+import { isAssistantFeatureFlagEnabled } from "./assistant-feature-flags.js";
+
+export const SESSION_GROUPS_FLAG_KEY = "session-groups";
+
+let recoveryHealthy = true;
+
+/** Recovery is a process prerequisite, independent of rollout targeting. */
+export function setModeSessionRecoveryHealthy(healthy: boolean): void {
+  recoveryHealthy = healthy;
+}
+
+export function isModeSessionRecoveryHealthy(): boolean {
+  return recoveryHealthy;
+}
+
+/** Whether this assistant may admit new transcript mode-session tracking. */
+export function isSessionGroupsEnabled(): boolean {
+  return (
+    recoveryHealthy && isAssistantFeatureFlagEnabled(SESSION_GROUPS_FLAG_KEY)
+  );
+}

package/src/config/skills.ts

@@ -225,10 +225,6 @@ export interface SkillToolManifestMeta {
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
-function getSkillsDir(): string {
-  return getWorkspaceSkillsDir();
-}
-
 export function getBundledSkillsDir(): string {
   const dir = import.meta.dir;
 
@@ -1114,7 +1110,7 @@ export function loadSkillCatalog(
   }
 
   // Load managed (user) skills, which take precedence over bundled skills with the same ID
-  const skillsDir = getSkillsDir();
+  const skillsDir = getWorkspaceSkillsDir();
   const directories = discoverSkillDirectories(skillsDir);
 
   for (const directory of directories) {
@@ -1354,7 +1350,7 @@ function loadSkillDefinition(skill: SkillSummary): SkillLookupResult {
   } else {
     loaded = readSkillFromDirectory(
       skill.directoryPath,
-      getSkillsDir(),
+      getWorkspaceSkillsDir(),
       skill.source,
     );
   }