@vellumai/assistant 0.12.1 → 0.12.2-staging.1

package/src/workspace/migrations/156-extract-workspace-mcp-json.ts

@@ -0,0 +1,214 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const WORKSPACE_MCP_FILENAME = "mcp.json";
+
+// Inlined Agent Plugins 1.0.0 schema URL so this migration stays
+// self-contained if the production constant later changes or moves.
+const AGENT_PLUGINS_MCP_SCHEMA_URL =
+  "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+
+const log = getLogger("workspace-migration-156");
+
+/**
+ * Move user-owned MCP servers from `config.json` into a spec-pure
+ * `/workspace/mcp.json`. Presence of a server is what starts it. Headers
+ * that were still on a transport are copied onto the spec entry so the
+ * credential-store migration can lift them on the next MCP reload.
+ */
+export const extractWorkspaceMcpJsonMigration: WorkspaceMigration = {
+  id: "156-extract-workspace-mcp-json",
+  description:
+    "Extract workspace MCP servers from config.json into a spec-pure mcp.json",
+  run(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) {
+      return;
+    }
+
+    const config = readJsonObject(configPath);
+    if (config === null) {
+      return;
+    }
+
+    if (!Object.hasOwn(config, "mcp")) {
+      return;
+    }
+
+    const extracted = extractSpecServers(config.mcp);
+    const mcpPath = join(workspaceDir, WORKSPACE_MCP_FILENAME);
+    const existing = readExistingMcpServers(mcpPath);
+    const merged: Record<string, unknown> = {
+      ...extracted,
+      ...existing.servers,
+    };
+
+    if (Object.keys(merged).length > 0 || existing.present) {
+      const document = {
+        $schema: existing.schema ?? AGENT_PLUGINS_MCP_SCHEMA_URL,
+        mcpServers: merged,
+      };
+      atomicWrite(mcpPath, document);
+    }
+
+    delete config.mcp;
+    atomicWrite(configPath, config);
+    log.info("Extracted workspace MCP servers into mcp.json");
+  },
+  retryFailedCheckpoint: true,
+  down(_workspaceDir: string): void {
+    // Forward-only: mcp.json is the store. Putting servers back under
+    // config.json would just be extracted again on the next load.
+  },
+};
+
+function extractSpecServers(mcp: unknown): Record<string, unknown> {
+  const block = readObject(mcp);
+  if (block === null) {
+    return {};
+  }
+
+  const servers: Record<string, unknown> = {};
+  const rawServers = block.servers;
+  if (Array.isArray(rawServers)) {
+    for (const entry of rawServers) {
+      const object = readObject(entry);
+      if (object === null) {
+        continue;
+      }
+      const name = object.name;
+      if (typeof name !== "string" || name.trim().length === 0) {
+        continue;
+      }
+      const spec = toSpecServer(object);
+      if (spec !== null) {
+        servers[name] = spec;
+      }
+    }
+    return servers;
+  }
+
+  const serverMap = readObject(rawServers);
+  if (serverMap === null) {
+    return {};
+  }
+  for (const [id, entry] of Object.entries(serverMap)) {
+    if (id.trim().length === 0) {
+      continue;
+    }
+    const object = readObject(entry);
+    if (object === null) {
+      continue;
+    }
+    const spec = toSpecServer(object);
+    if (spec !== null) {
+      servers[id] = spec;
+    }
+  }
+  return servers;
+}
+
+function toSpecServer(entry: Record<string, unknown>): Record<string, unknown> | null {
+  const transport = readObject(entry.transport);
+  if (transport === null) {
+    return null;
+  }
+  const type = transport.type;
+  if (type === "stdio") {
+    if (typeof transport.command !== "string" || transport.command.length === 0) {
+      return null;
+    }
+    const spec: Record<string, unknown> = {
+      type: "stdio",
+      command: transport.command,
+    };
+    if (
+      Array.isArray(transport.args) &&
+      transport.args.length > 0 &&
+      transport.args.every((arg) => typeof arg === "string")
+    ) {
+      spec.args = transport.args;
+    }
+    const env = readStringRecord(transport.env);
+    if (env !== null) {
+      spec.env = env;
+    }
+    return spec;
+  }
+  if (type === "sse" || type === "streamable-http" || type === "http") {
+    if (typeof transport.url !== "string" || transport.url.length === 0) {
+      return null;
+    }
+    const spec: Record<string, unknown> = {
+      type: type === "http" ? "streamable-http" : type,
+      url: transport.url,
+    };
+    const headers = readStringRecord(transport.headers);
+    if (headers !== null) {
+      spec.headers = headers;
+    }
+    return spec;
+  }
+  return null;
+}
+
+function readExistingMcpServers(path: string): {
+  present: boolean;
+  schema?: string;
+  servers: Record<string, unknown>;
+} {
+  if (!existsSync(path)) {
+    return { present: false, servers: {} };
+  }
+  const document = readJsonObject(path);
+  if (document === null) {
+    return { present: true, servers: {} };
+  }
+  const servers = readObject(document.mcpServers);
+  return {
+    present: true,
+    schema:
+      typeof document.$schema === "string" ? document.$schema : undefined,
+    servers: servers ?? {},
+  };
+}
+
+function readJsonObject(path: string): Record<string, unknown> | null {
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf-8"));
+    return readObject(raw);
+  } catch {
+    return null;
+  }
+}
+
+function atomicWrite(path: string, value: unknown): void {
+  const tmpPath = `${path}.migration-156.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(value, null, 2) + "\n");
+  renameSync(tmpPath, path);
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function readStringRecord(value: unknown): Record<string, string> | null {
+  const object = readObject(value);
+  if (object === null) {
+    return null;
+  }
+  const result: Record<string, string> = {};
+  for (const [key, entry] of Object.entries(object)) {
+    if (typeof entry !== "string") {
+      return null;
+    }
+    result[key] = entry;
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}

package/src/workspace/migrations/__tests__/155-move-front-model-config-to-voice.test.ts

@@ -0,0 +1,102 @@
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { moveFrontModelConfigToVoiceMigration } from "../155-move-front-model-config-to-voice.js";
+
+function workspaceWith(config: unknown): string {
+  const dir = mkdtempSync(join(tmpdir(), "move-front-model-"));
+  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2));
+  return dir;
+}
+
+function readConfig(dir: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(dir, "config.json"), "utf8")) as Record<
+    string,
+    unknown
+  >;
+}
+
+describe("155-move-front-model-config-to-voice", () => {
+  test("moves liveVoice.frontModel under voice and leaves the rest of liveVoice", () => {
+    const dir = workspaceWith({
+      liveVoice: {
+        vad: { silenceThresholdMs: 900 },
+        frontModel: {
+          endpointDecisionTimeoutMs: 300,
+          progress: { idleIntervalMs: 4_000 },
+        },
+      },
+    });
+
+    moveFrontModelConfigToVoiceMigration.run(dir);
+
+    expect(readConfig(dir)).toEqual({
+      liveVoice: { vad: { silenceThresholdMs: 900 } },
+      voice: {
+        frontModel: {
+          endpointDecisionTimeoutMs: 300,
+          progress: { idleIntervalMs: 4_000 },
+        },
+      },
+    });
+  });
+
+  test("an existing voice.frontModel wins field by field", () => {
+    const dir = workspaceWith({
+      liveVoice: {
+        frontModel: {
+          endpointDecisionTimeoutMs: 300,
+          endpointMaxExtensions: 1,
+          progress: { idleIntervalMs: 4_000, minGapMs: 2_000 },
+        },
+      },
+      voice: {
+        frontModel: {
+          endpointDecisionTimeoutMs: 800,
+          progress: { idleIntervalMs: 7_000 },
+        },
+      },
+    });
+
+    moveFrontModelConfigToVoiceMigration.run(dir);
+
+    expect(readConfig(dir)).toEqual({
+      liveVoice: {},
+      voice: {
+        frontModel: {
+          endpointDecisionTimeoutMs: 800,
+          endpointMaxExtensions: 1,
+          progress: { idleIntervalMs: 7_000, minGapMs: 2_000 },
+        },
+      },
+    });
+  });
+
+  test("a config without the old key is left untouched", () => {
+    const dir = workspaceWith({ liveVoice: { archiveAudio: true } });
+    const before = readFileSync(join(dir, "config.json"), "utf8");
+
+    moveFrontModelConfigToVoiceMigration.run(dir);
+
+    expect(readFileSync(join(dir, "config.json"), "utf8")).toBe(before);
+  });
+
+  test("is idempotent", () => {
+    const dir = workspaceWith({
+      liveVoice: { frontModel: { endpointExtensionMs: 2_000 } },
+    });
+
+    moveFrontModelConfigToVoiceMigration.run(dir);
+    const once = readConfig(dir);
+    moveFrontModelConfigToVoiceMigration.run(dir);
+
+    expect(readConfig(dir)).toEqual(once);
+  });
+
+  test("a missing config file is a no-op", () => {
+    const dir = mkdtempSync(join(tmpdir(), "move-front-model-empty-"));
+    expect(() => moveFrontModelConfigToVoiceMigration.run(dir)).not.toThrow();
+  });
+});

package/src/workspace/migrations/__tests__/156-extract-workspace-mcp-json.test.ts

@@ -0,0 +1,199 @@
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { extractWorkspaceMcpJsonMigration } from "../156-extract-workspace-mcp-json.js";
+import { WORKSPACE_MIGRATIONS } from "../registry.js";
+
+const MIGRATION_156_SCHEMA_URL =
+  "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+
+function workspaceWith(config: unknown): string {
+  const dir = mkdtempSync(join(tmpdir(), "extract-workspace-mcp-"));
+  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2));
+  return dir;
+}
+
+function readJson(dir: string, name: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(dir, name), "utf8")) as Record<
+    string,
+    unknown
+  >;
+}
+
+describe("156-extract-workspace-mcp-json", () => {
+  test("has the next migration id and is registered last", () => {
+    expect(extractWorkspaceMcpJsonMigration.id).toBe(
+      "156-extract-workspace-mcp-json",
+    );
+    expect(WORKSPACE_MIGRATIONS.at(-1)?.id).toBe(
+      "156-extract-workspace-mcp-json",
+    );
+  });
+
+  test("moves servers into a spec-pure mcp.json and drops mcp from config", () => {
+    const dir = workspaceWith({
+      llm: { activeProfile: "balanced" },
+      mcp: {
+        servers: {
+          remote: {
+            transport: {
+              type: "streamable-http",
+              url: "https://example.com/mcp",
+            },
+          },
+          local: {
+            transport: {
+              type: "stdio",
+              command: "npx",
+              args: ["-y", "srv"],
+              env: { DATA_DIR: "/tmp" },
+            },
+          },
+        },
+      },
+    });
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readJson(dir, "config.json")).toEqual({
+      llm: { activeProfile: "balanced" },
+    });
+    expect(readJson(dir, "mcp.json")).toEqual({
+      $schema: MIGRATION_156_SCHEMA_URL,
+      mcpServers: {
+        remote: {
+          type: "streamable-http",
+          url: "https://example.com/mcp",
+        },
+        local: {
+          type: "stdio",
+          command: "npx",
+          args: ["-y", "srv"],
+          env: { DATA_DIR: "/tmp" },
+        },
+      },
+    });
+  });
+
+  test("copies leftover transport headers onto the spec entry", () => {
+    const dir = workspaceWith({
+      mcp: {
+        servers: {
+          remote: {
+            transport: {
+              type: "sse",
+              url: "https://example.com/sse",
+              headers: { Authorization: "Bearer leftover" },
+            },
+          },
+        },
+      },
+    });
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readJson(dir, "mcp.json")).toEqual({
+      $schema: MIGRATION_156_SCHEMA_URL,
+      mcpServers: {
+        remote: {
+          type: "sse",
+          url: "https://example.com/sse",
+          headers: { Authorization: "Bearer leftover" },
+        },
+      },
+    });
+  });
+
+  test("keeps existing mcp.json ids and fills only the missing ones", () => {
+    const dir = workspaceWith({
+      mcp: {
+        servers: {
+          fromConfig: {
+            transport: {
+              type: "streamable-http",
+              url: "https://config.example/mcp",
+            },
+          },
+          shared: {
+            transport: {
+              type: "streamable-http",
+              url: "https://config-loses.example/mcp",
+            },
+          },
+        },
+      },
+    });
+    writeFileSync(
+      join(dir, "mcp.json"),
+      JSON.stringify({
+        $schema: MIGRATION_156_SCHEMA_URL,
+        mcpServers: {
+          shared: {
+            type: "streamable-http",
+            url: "https://file-wins.example/mcp",
+          },
+        },
+      }),
+    );
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readJson(dir, "mcp.json")).toEqual({
+      $schema: MIGRATION_156_SCHEMA_URL,
+      mcpServers: {
+        fromConfig: {
+          type: "streamable-http",
+          url: "https://config.example/mcp",
+        },
+        shared: {
+          type: "streamable-http",
+          url: "https://file-wins.example/mcp",
+        },
+      },
+    });
+    expect(readJson(dir, "config.json")).toEqual({});
+  });
+
+  test("extracts a leftover array of servers", () => {
+    const dir = workspaceWith({
+      mcp: {
+        servers: [
+          {
+            name: "legacy",
+            transport: { type: "sse", url: "https://example.com/sse" },
+          },
+        ],
+      },
+    });
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readJson(dir, "mcp.json")).toEqual({
+      $schema: MIGRATION_156_SCHEMA_URL,
+      mcpServers: {
+        legacy: { type: "sse", url: "https://example.com/sse" },
+      },
+    });
+  });
+
+  test("is a no-op when mcp is already gone", () => {
+    const dir = workspaceWith({ llm: {} });
+    const before = readFileSync(join(dir, "config.json"), "utf8");
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readFileSync(join(dir, "config.json"), "utf8")).toBe(before);
+    expect(existsSync(join(dir, "mcp.json"))).toBe(false);
+  });
+
+  test("drops an empty mcp key without creating mcp.json", () => {
+    const dir = workspaceWith({ mcp: { servers: {} } });
+
+    extractWorkspaceMcpJsonMigration.run(dir);
+
+    expect(readJson(dir, "config.json")).toEqual({});
+    expect(existsSync(join(dir, "mcp.json"))).toBe(false);
+  });
+});

package/src/workspace/migrations/registry.ts

@@ -151,6 +151,9 @@ import { sttFluxProviderToModelFamilyMigration } from "./150-stt-flux-provider-t
 import { repairRenamedFireworksDeepseekProModelIdMigration } from "./151-repair-renamed-fireworks-deepseek-pro-model-id.js";
 import { repairRetiredFireworksMinimaxM2p7ModelIdMigration } from "./152-repair-retired-fireworks-minimax-m2p7-model-id.js";
 import { stripMcpPolicyFieldsMigration } from "./153-strip-mcp-policy-fields.js";
+import { repairRetiredCodexGpt54ModelIdsMigration } from "./154-repair-retired-codex-gpt-5-4-model-ids.js";
+import { moveFrontModelConfigToVoiceMigration } from "./155-move-front-model-config-to-voice.js";
+import { extractWorkspaceMcpJsonMigration } from "./156-extract-workspace-mcp-json.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -317,4 +320,7 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   repairRenamedFireworksDeepseekProModelIdMigration,
   repairRetiredFireworksMinimaxM2p7ModelIdMigration,
   stripMcpPolicyFieldsMigration,
+  repairRetiredCodexGpt54ModelIdsMigration,
+  moveFrontModelConfigToVoiceMigration,
+  extractWorkspaceMcpJsonMigration,
 ];