@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/live-voice/protocol.ts

@@ -30,6 +30,7 @@ const _LIVE_VOICE_SERVER_FRAME_TYPES = [
   "tts_done",
   "turn_cancelled",
   "minimize_room",
+  "session_control",
   "metrics",
   "archived",
   "error",
@@ -152,6 +153,40 @@ export interface LiveVoiceClientStartFrame {
    * malformed value costs a chart facet and never the session.
    */
   readonly entry?: string;
+  /**
+   * The session controls this client can carry out when a reply asks for one
+   * (see {@link LiveVoiceSessionControlServerFrame}). The session teaches the
+   * model only the controls listed here, so a client that cannot hang up or
+   * mute is never told it can.
+   *
+   * Absent means none: a client that predates the field would ignore the
+   * frame, and a spoken "okay, ending the call" that ends nothing is worse
+   * than the model not offering. Values this daemon does not know are dropped
+   * rather than rejected, so a newer client can list controls an older daemon
+   * has never heard of.
+   */
+  readonly sessionControls?: readonly LiveVoiceSessionControl[];
+}
+
+const LIVE_VOICE_SESSION_CONTROLS = ["end", "mute"] as const;
+
+/** A session control a client can carry out on the assistant's behalf. */
+export type LiveVoiceSessionControl =
+  (typeof LIVE_VOICE_SESSION_CONTROLS)[number];
+
+/**
+ * A start frame's `sessionControls`, reduced to the known values with
+ * duplicates removed; empty when the field is absent or not an array.
+ */
+export function parseLiveVoiceSessionControls(
+  value: unknown,
+): LiveVoiceSessionControl[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return LIVE_VOICE_SESSION_CONTROLS.filter((control) =>
+    value.includes(control),
+  );
 }
 
 /**
@@ -586,6 +621,26 @@ export interface LiveVoiceMinimizeRoomServerFrame extends LiveVoiceServerFrameBa
   readonly turnId: string;
 }
 
+/**
+ * A session control the just-completed reply asked for with a terminal marker
+ * (`[END_CALL]`, `[MUTE]`, `[MUTE:<seconds>]`). Sent only after the turn's TTS
+ * has fully drained, so the spoken acknowledgement is heard first, never for a
+ * turn the user barged in on, at most once per turn, and only for a control
+ * the client listed in the start frame's `sessionControls`.
+ *
+ * - `end`: end the session the way the client's own end control does.
+ * - `mute`: mute the microphone. With `durationMs`, unmute again once it
+ *   elapses; without, stay muted until the user unmutes. The timer is the
+ *   client's: a muted microphone sends silence, so the daemon cannot hear an
+ *   "unmute".
+ */
+export interface LiveVoiceSessionControlServerFrame extends LiveVoiceServerFrameBase {
+  readonly type: "session_control";
+  readonly turnId: string;
+  readonly action: LiveVoiceSessionControl;
+  readonly durationMs?: number;
+}
+
 export interface LiveVoiceMetricsServerFrame extends LiveVoiceServerFrameBase {
   readonly type: "metrics";
   readonly event?: string;
@@ -627,8 +682,6 @@ export interface LiveVoiceMetricsServerFrame extends LiveVoiceServerFrameBase {
    * condition as the two fields above.
    */
   readonly endpointDecisionSource?: "front-door" | "provider";
-  /** Which floor-holding ack actually spoke during the turn, if any. */
-  readonly ackSpoken?: "first_delta" | "tool_use";
   /**
    * Spoken progress narrations during the turn. Present only when at least
    * one progress update spoke (otherwise the field is absent, keeping frames
@@ -709,6 +762,7 @@ export type LiveVoiceServerFrame =
   | LiveVoiceTtsDoneServerFrame
   | LiveVoiceTurnCancelledServerFrame
   | LiveVoiceMinimizeRoomServerFrame
+  | LiveVoiceSessionControlServerFrame
   | LiveVoiceMetricsServerFrame
   | LiveVoiceArchivedServerFrame
   | LiveVoiceErrorServerFrame;
@@ -730,6 +784,7 @@ export type LiveVoiceServerFramePayload =
   | WithoutSeq<LiveVoiceTtsDoneServerFrame>
   | WithoutSeq<LiveVoiceTurnCancelledServerFrame>
   | WithoutSeq<LiveVoiceMinimizeRoomServerFrame>
+  | WithoutSeq<LiveVoiceSessionControlServerFrame>
   | WithoutSeq<LiveVoiceMetricsServerFrame>
   | WithoutSeq<LiveVoiceArchivedServerFrame>
   | WithoutSeq<LiveVoiceErrorServerFrame>;
@@ -1220,6 +1275,8 @@ function validateStartFrame(
   const client = parseClientOs(value.client);
   // Same policy for the same reason: a dimension, not a capability.
   const entry = parseLiveVoiceEntry(value.entry);
+  // Same policy again: an unknown control is a newer client, not a bad frame.
+  const sessionControls = parseLiveVoiceSessionControls(value.sessionControls);
 
   return {
     ok: true,
@@ -1241,6 +1298,7 @@ function validateStartFrame(
         ? { bargeInMinSpeechMs: value.bargeInMinSpeechMs }
         : {}),
       ...(value.textInput === true ? { textInput: true } : {}),
+      ...(sessionControls.length > 0 ? { sessionControls } : {}),
     },
   };
 }

package/src/live-voice/session-controls.ts

@@ -0,0 +1,111 @@
+import {
+  END_CALL_MARKER,
+  FEWER_UPDATES_MARKER,
+  MUTE_MARKER,
+  NORMAL_UPDATES_MARKER,
+  parseTerminalSessionControl,
+  type SessionControlRequest,
+} from "../calls/voice-control-protocol.js";
+import type { VoiceProgressConfig } from "../config/schemas/voice.js";
+import type { LiveVoiceSessionControl } from "./protocol.js";
+
+/**
+ * Spoken session controls: the user asks out loud to end the call, mute their
+ * microphone, or hear fewer progress updates, the reply acknowledges it and
+ * ends with a marker, and the session carries it out once that
+ * acknowledgement has been spoken.
+ *
+ * A marker rather than a tool, because these are the turns a front-door leg
+ * answers on its own: "okay, I'm gonna go" should not wait on an escalation to
+ * a stronger model before the call can end. The marker is judged by the
+ * model, never by matching the user's words, so "I'm all done with that
+ * email" does not hang up.
+ */
+
+const CLIENT_CONTROL_LINES: Record<LiveVoiceSessionControl, string> = {
+  end: `- To end the call (for example "I'm all done" or "okay, I'm gonna go"), say a brief goodbye, then end your reply with ${END_CALL_MARKER}. Being done with a task is not the same as leaving the call; end only when they are leaving.`,
+  mute: `- To mute their microphone (for example "mute for 30 seconds" or "mute yourself, I need to take this"), confirm in a few words, then end your reply with [MUTE:<seconds>] when they gave a duration or ${MUTE_MARKER} when they did not. While muted you cannot hear them, so mention they can unmute from the call controls unless the mute is timed.`,
+};
+
+// Always taught: narration is the session's own, so no client has to be able
+// to carry it out.
+const UPDATES_LINE = `- To hear fewer spoken progress updates while you work (for example "don't give me updates so often"), confirm that you will only check in now and then and will tell them when it is done, then end your reply with ${FEWER_UPDATES_MARKER}. If they later want regular updates back, confirm and end with ${NORMAL_UPDATES_MARKER}.`;
+
+/**
+ * The control-prompt block that teaches the session controls: the ones the
+ * client declared plus the progress-update cadence. Every leg gets it,
+ * including the toolless front-door leg: these turns are its to answer.
+ *
+ * The no-other-markers rule is withheld from the front-door leg, whose
+ * routing rule teaches it leading verdict tokens and already confines
+ * everything else to speech.
+ */
+export function sessionControlTeaching(
+  controls: readonly LiveVoiceSessionControl[],
+  leg: { frontDoor?: boolean },
+): string {
+  return [
+    "The user can also control this call by asking you. Only when they clearly ask:",
+    ...controls.map((control) => CLIENT_CONTROL_LINES[control]),
+    UPDATES_LINE,
+    `The marker must be the very last thing in your reply. It is never spoken and does nothing anywhere else.${leg.frontDoor === true ? "" : " Never emit any other bracketed marker."}`,
+  ].join("\n");
+}
+
+/** A session control the client carries out, sent as a `session_control` frame. */
+export type ClientSessionControlRequest = Exclude<
+  SessionControlRequest,
+  { action: "updates" }
+>;
+
+/**
+ * The control a completed leg's raw text asks for; null when there is none or
+ * when it is a client control the client did not declare. An undeclared
+ * control is dropped rather than sent: the client said it cannot carry it out.
+ * The update cadence always passes, since the session carries it out itself.
+ */
+export function requestedSessionControl(
+  rawText: string,
+  controls: readonly LiveVoiceSessionControl[],
+): SessionControlRequest | null {
+  const request = parseTerminalSessionControl(rawText);
+  if (request === null) {
+    return null;
+  }
+  if (request.action === "updates") {
+    return request;
+  }
+  return controls.includes(request.action) ? request : null;
+}
+
+/**
+ * Silence (ms) a session that asked for fewer updates waits through before a
+ * progress update. Long enough that a minute-long task runs without a word;
+ * short enough that a really long one still proves the call is alive.
+ */
+export const FEWER_UPDATES_INTERVAL_MS = 60_000;
+
+/**
+ * The progress config a turn runs on under the session's update cadence.
+ *
+ * Fewer updates means no update for tool activity (a burst of ops or a long
+ * op finishing, each normally its own beat) and the silence tick stretched to
+ * {@link FEWER_UPDATES_INTERVAL_MS}, so the only thing that speaks is a long
+ * stretch of silence. Done is still said: the reply itself is the "it's done".
+ */
+export function progressConfigForCadence(
+  config: VoiceProgressConfig,
+  cadence: "fewer" | "normal",
+): VoiceProgressConfig {
+  if (cadence === "normal") {
+    return config;
+  }
+  const intervalMs = Math.max(FEWER_UPDATES_INTERVAL_MS, config.maxSilenceMs);
+  return {
+    ...config,
+    opsThreshold: Number.MAX_SAFE_INTEGER,
+    longOpMs: Number.MAX_SAFE_INTEGER,
+    idleIntervalMs: intervalMs,
+    maxSilenceMs: intervalMs,
+  };
+}

package/src/mcp/__tests__/effective-config.test.ts

@@ -4,8 +4,8 @@
  * The properties worth pinning are the ones a refactor could quietly
  * break, each of which fails silently rather than loudly:
  *
- * 1. Plugin servers reach the manager at all. Reading only `config.mcp`
- *    leaves a plugin's tools missing with nothing logged.
+ * 1. Plugin servers reach the manager at all. Reading only the workspace
+ *    `mcp.json` leaves a plugin's tools missing with nothing logged.
  * 2. A workspace entry of the same id wins, so a plugin cannot redirect a
  *    server the user configured by hand.
  * 3. Every server is attributed. `source` is what `McpClient` reads to

package/src/mcp/__tests__/workspace-mcp-config.test.ts

@@ -0,0 +1,135 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { AGENT_PLUGINS_MCP_SCHEMA_URL } from "../spec-schema.js";
+import {
+  loadWorkspaceMcpConfig,
+  overlayWorkspaceMcpForConfigRead,
+  readWorkspaceMcpFile,
+  saveWorkspaceMcpConfig,
+} from "../workspace-mcp-config.js";
+
+function mcpPath(): string {
+  return join(process.env.VELLUM_WORKSPACE_DIR!, "mcp.json");
+}
+
+describe("workspace mcp.json", () => {
+  beforeEach(() => {
+    mkdirSync(process.env.VELLUM_WORKSPACE_DIR!, { recursive: true });
+    rmSync(mcpPath(), { force: true });
+  });
+
+  test("missing file is an empty server map", () => {
+    expect(loadWorkspaceMcpConfig()).toEqual({ servers: {} });
+    expect(readWorkspaceMcpFile().fileState).toBe("missing");
+  });
+
+  test("round-trips a spec document without wrapping transport", () => {
+    saveWorkspaceMcpConfig({
+      servers: {
+        remote: {
+          transport: {
+            type: "streamable-http",
+            url: "https://example.com/mcp",
+          },
+        },
+        local: {
+          transport: {
+            type: "stdio",
+            command: "npx",
+            args: ["-y", "srv"],
+          },
+        },
+      },
+    });
+
+    expect(JSON.parse(readFileSync(mcpPath(), "utf8"))).toEqual({
+      $schema: AGENT_PLUGINS_MCP_SCHEMA_URL,
+      mcpServers: {
+        remote: {
+          type: "streamable-http",
+          url: "https://example.com/mcp",
+        },
+        local: {
+          type: "stdio",
+          command: "npx",
+          args: ["-y", "srv"],
+        },
+      },
+    });
+    expect(loadWorkspaceMcpConfig()).toEqual({
+      servers: {
+        remote: {
+          transport: {
+            type: "streamable-http",
+            url: "https://example.com/mcp",
+          },
+        },
+        local: {
+          transport: {
+            type: "stdio",
+            command: "npx",
+            args: ["-y", "srv"],
+          },
+        },
+      },
+    });
+  });
+
+  test("does not persist transport headers", () => {
+    saveWorkspaceMcpConfig({
+      servers: {
+        remote: {
+          transport: {
+            type: "streamable-http",
+            url: "https://example.com/mcp",
+            headers: { Authorization: "Bearer secret" },
+          },
+        },
+      },
+    });
+
+    const onDisk = readFileSync(mcpPath(), "utf8");
+    expect(onDisk).not.toContain("secret");
+    expect(loadWorkspaceMcpConfig().servers.remote?.transport).toEqual({
+      type: "streamable-http",
+      url: "https://example.com/mcp",
+    });
+  });
+
+  test("invalid file does not throw on read and refuses a later write", () => {
+    mkdirSync(process.env.VELLUM_WORKSPACE_DIR!, { recursive: true });
+    writeFileSync(mcpPath(), "{ not json");
+
+    expect(loadWorkspaceMcpConfig()).toEqual({ servers: {} });
+    expect(readWorkspaceMcpFile().fileState).toBe("invalid");
+    expect(() => saveWorkspaceMcpConfig({ servers: {} })).toThrow(/invalid JSON/);
+  });
+
+  test("overlay projects transport-only servers for config reads", () => {
+    saveWorkspaceMcpConfig({
+      servers: {
+        remote: {
+          transport: {
+            type: "streamable-http",
+            url: "https://example.com/mcp",
+          },
+        },
+      },
+    });
+
+    const config: Record<string, unknown> = { llm: { activeProfile: "balanced" } };
+    overlayWorkspaceMcpForConfigRead(config);
+    expect(config.mcp).toEqual({
+      servers: {
+        remote: {
+          transport: {
+            type: "streamable-http",
+            url: "https://example.com/mcp",
+          },
+        },
+      },
+    });
+  });
+});

package/src/mcp/effective-config.ts

@@ -1,11 +1,11 @@
 /**
  * The MCP configuration the daemon actually runs.
  *
- * Two sources contribute servers: the workspace `config.json`, which the
+ * Two sources contribute servers: the workspace `mcp.json`, which the
  * user owns, and each installed plugin's `mcp.json`, which its author
  * owns. Both must reach the MCP manager, so every consumer that starts
- * servers builds its config through here rather than reading
- * `config.mcp` directly — a path that only reads the workspace half
+ * servers builds its config through here rather than reading the
+ * workspace file directly — a path that only reads the workspace half
  * leaves a plugin's tools silently missing.
  *
  * Every server comes out attributed with its {@link McpServerSource}, so

package/src/mcp/mcp-header-store.ts

@@ -3,18 +3,21 @@
  *
  * Follows the same pattern as mcp-oauth-provider.ts: headers are stored in
  * the secure credential store (CES or encrypted file fallback) rather than
- * in plaintext config.json, keeping secrets out of workspace config files.
+ * in plaintext mcp.json, keeping secrets out of workspace config files.
  *
  * Key format: mcp:{serverId}:headers — stores JSON-serialized Record<string, string>.
  */
 
-import { loadRawConfig, saveRawConfig } from "../config/loader.js";
 import {
   deleteSecureKeyAsync,
   getSecureKeyAsync,
   setSecureKeyAsync,
 } from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
+import {
+  loadWorkspaceMcpConfig,
+  saveWorkspaceMcpConfig,
+} from "./workspace-mcp-config.js";
 
 const log = getLogger("mcp-header-store");
 
@@ -73,64 +76,45 @@ export async function deleteMcpHeaders(serverId: string): Promise<boolean> {
 }
 
 /**
- * One-time lazy migration: move any plaintext headers from config.json
- * transport entries into the credential store and strip them from config.
- * Safe to call on every MCP reload — no-ops when no legacy headers remain.
+ * Move leftover plaintext headers from mcp.json into the credential store
+ * and rewrite the file without them. Safe to call on every MCP reload.
  */
 export async function migrateLegacyMcpHeaders(): Promise<void> {
-  const raw = loadRawConfig();
-  const mcpConfig = raw.mcp as
-    | { servers?: Record<string, Record<string, unknown>> }
-    | undefined;
-  const servers = mcpConfig?.servers;
-  if (!servers) {
-    return;
-  }
+  const config = loadWorkspaceMcpConfig();
+  const servers = config.servers;
+  let dirty = false;
 
-  let configDirty = false;
   for (const [id, server] of Object.entries(servers)) {
-    const transport = server?.transport as Record<string, unknown> | undefined;
-    if (
-      !transport ||
-      (transport.type !== "sse" && transport.type !== "streamable-http")
-    ) {
+    const transport = server.transport;
+    if (transport.type !== "sse" && transport.type !== "streamable-http") {
       continue;
     }
-    const legacyHeaders = transport.headers as
-      | Record<string, string>
-      | undefined;
-    if (!legacyHeaders || Object.keys(legacyHeaders).length === 0) {
+    const leftoverHeaders = transport.headers;
+    if (!leftoverHeaders || Object.keys(leftoverHeaders).length === 0) {
       continue;
     }
 
-    // Only migrate if credential store doesn't already have headers for
-    // this server (idempotent — safe to re-run after partial failure).
     const existing = await getMcpHeaders(id);
-    if (existing) {
-      // Credential store already has headers; just strip the config copy.
-      delete transport.headers;
-      configDirty = true;
-      continue;
-    }
-
-    const ok = await setMcpHeaders(id, legacyHeaders);
-    if (ok) {
-      delete transport.headers;
-      configDirty = true;
+    if (!existing) {
+      const ok = await setMcpHeaders(id, leftoverHeaders);
+      if (!ok) {
+        log.warn(
+          { serverId: id },
+          "Skipping leftover header migration: credential store write failed; will retry on next reload",
+        );
+        continue;
+      }
       log.info(
         { serverId: id },
-        "Migrated legacy MCP headers to credential store",
-      );
-    } else {
-      log.warn(
-        { serverId: id },
-        "Skipping legacy header migration — credential store write failed; will retry on next reload",
+        "Moved leftover MCP headers to credential store",
       );
     }
+    delete transport.headers;
+    dirty = true;
   }
 
-  if (configDirty) {
-    saveRawConfig(raw);
-    log.info("Config updated: legacy MCP headers removed after migration");
+  if (dirty) {
+    saveWorkspaceMcpConfig(config);
+    log.info("mcp.json updated: leftover MCP headers removed after migration");
   }
 }

package/src/mcp/spec-schema.ts

@@ -0,0 +1,111 @@
+/**
+ * Agent Plugins 1.0.0 `mcp.json` wire schema and projections onto the
+ * assistant's in-memory `McpTransport` union.
+ *
+ * Workspace `/workspace/mcp.json` and each plugin's root `mcp.json` share
+ * this document shape. Origin (`workspace` vs `plugin`) is resolved from
+ * which file was read, never from a field in the file.
+ */
+
+import { z } from "zod";
+
+import type { McpTransport } from "../config/schemas/mcp.js";
+
+/** Canonical `$schema` value for an Agent Plugins 1.0.0 MCP document. */
+export const AGENT_PLUGINS_MCP_SCHEMA_URL =
+  "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+
+const SpecStdioServerSchema = z.object({
+  type: z.literal("stdio"),
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  cwd: z.string().optional(),
+});
+
+/**
+ * Remote MCP entry. Agent Plugins 1.0.0 requires `type` and names no
+ * default. MCP's current remote transport is Streamable HTTP, so this
+ * host fills omitted `type` and the Claude-style `http` alias as
+ * `streamable-http`. `sse` stays explicit.
+ */
+const SpecHttpServerSchema = z.object({
+  type: z
+    .union([
+      z.literal("streamable-http"),
+      z.literal("sse"),
+      z.literal("http").transform(() => "streamable-http" as const),
+    ])
+    .default("streamable-http"),
+  url: z.string().min(1),
+  headers: z.record(z.string(), z.string()).optional(),
+});
+
+export const SpecMcpServerSchema = z.union([
+  SpecStdioServerSchema,
+  SpecHttpServerSchema,
+]);
+
+export const SpecMcpDocumentSchema = z.object({
+  $schema: z.string().optional(),
+  mcpServers: z.record(z.string(), z.unknown()),
+});
+
+export type SpecMcpServer = z.infer<typeof SpecMcpServerSchema>;
+export type SpecMcpDocument = z.infer<typeof SpecMcpDocumentSchema>;
+
+/**
+ * Project one spec-shaped entry onto the assistant's transport union. The
+ * two vocabularies already agree on type names and required fields, so this
+ * is a field copy plus an optional expander for plugin path variables.
+ */
+export function projectSpecServerToTransport(
+  entry: SpecMcpServer,
+  expand?: (value: string) => string,
+): McpTransport {
+  if (entry.type === "stdio") {
+    const map = expand ?? ((value: string) => value);
+    return {
+      type: "stdio",
+      command: entry.command,
+      args: (entry.args ?? []).map(map),
+      ...(entry.env && {
+        env: Object.fromEntries(
+          Object.entries(entry.env).map(([key, value]) => [key, map(value)]),
+        ),
+      }),
+    };
+  }
+  return {
+    type: entry.type,
+    url: entry.url,
+    ...(entry.headers && { headers: entry.headers }),
+  };
+}
+
+/**
+ * Project an in-memory transport onto a spec server entry. Headers are
+ * omitted: workspace secrets live in the credential store, and a write
+ * must not copy them into `mcp.json`.
+ */
+export function projectTransportToSpecServer(
+  transport: McpTransport,
+): Record<string, unknown> {
+  if (transport.type === "stdio") {
+    const entry: Record<string, unknown> = {
+      type: "stdio",
+      command: transport.command,
+    };
+    if (transport.args && transport.args.length > 0) {
+      entry.args = transport.args;
+    }
+    if (transport.env) {
+      entry.env = transport.env;
+    }
+    return entry;
+  }
+  return {
+    type: transport.type,
+    url: transport.url,
+  };
+}

package/src/mcp/startup.ts

@@ -13,13 +13,14 @@
  * further process that starts hosting turns has one call to make.
  */
 
-import { getConfig, invalidateConfigCache } from "../config/loader.js";
+import { invalidateConfigCache } from "../config/loader.js";
 import type { McpConfig } from "../config/schemas/mcp.js";
 import { createMcpToolsFromServer } from "../tools/mcp/mcp-tool-factory.js";
 import { registerMcpTools, unregisterAllMcpTools } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
 import { buildEffectiveMcpConfig } from "./effective-config.js";
 import { getMcpServerManager, stopMcpServerManager } from "./manager.js";
+import { loadWorkspaceMcpConfig } from "./workspace-mcp-config.js";
 
 const log = getLogger("mcp-startup");
 
@@ -36,7 +37,8 @@ const log = getLogger("mcp-startup");
  * is a startup step in processes whose other work must not be held hostage to
  * a third-party server being up.
  *
- * @param workspaceMcpConfig The `mcp` block of the assistant config, if any.
+ * @param workspaceMcpConfig The projected workspace MCP config. Callers
+ * that omit it read `/workspace/mcp.json`.
  * @returns The number of tools registered across all servers.
  */
 export async function startConfiguredMcpServers(
@@ -44,7 +46,9 @@ export async function startConfiguredMcpServers(
 ): Promise<number> {
   let registered = 0;
   try {
-    const mcpConfig = buildEffectiveMcpConfig(workspaceMcpConfig);
+    const mcpConfig = buildEffectiveMcpConfig(
+      workspaceMcpConfig ?? loadWorkspaceMcpConfig(),
+    );
     if (Object.keys(mcpConfig.servers).length === 0) {
       return 0;
     }
@@ -97,5 +101,5 @@ export async function restartConfiguredMcpServers(): Promise<number> {
   }
   unregisterAllMcpTools();
   invalidateConfigCache();
-  return startConfiguredMcpServers(getConfig().mcp);
+  return startConfiguredMcpServers(loadWorkspaceMcpConfig());
 }