@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/__tests__/llm-resolver.test.ts

@@ -1,10 +1,20 @@
-import { describe, expect, test } from "bun:test";
+import { beforeAll, describe, expect, test } from "bun:test";
+
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
+
+// This suite pins the LEGACY merge-cascade semantics — the kill-switch
+// (flag-off) path. The override-or-default (flag-on, shipped default)
+// semantics are pinned by llm-resolver-override-or-default.test.ts.
+beforeAll(() => {
+  setOverridesForTesting({ "override-or-default-resolution": false });
+});
 
 import { z } from "zod";
 
 import {
   resolveCallSiteConfig,
   resolveDefaultProfileKey,
+  resolveEffectiveProfileKey,
 } from "../config/llm-resolver.js";
 import { type LLMCallSite, LLMSchema } from "../config/schemas/llm.js";
 
@@ -36,8 +46,14 @@ const fullDefault = {
 };
 
 describe("resolveCallSiteConfig", () => {
-  test("returns default when call site is absent and no profile", () => {
-    const llm = LLMSchema.parse({ default: fullDefault });
+  test("returns default when the call-site default profile is disabled and no custom fallback exists", () => {
+    // mainAgent's catalog default (`balanced`) always resolves from the code
+    // catalog, so the pure fall-through-to-default path requires a disabled
+    // stub (the BYOK hatch state) with no `custom-balanced` present.
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: { balanced: { source: "managed", status: "disabled" } },
+    });
     const resolved = resolveCallSiteConfig("mainAgent", llm);
     expect(resolved).toEqual(fullDefault);
   });
@@ -82,6 +98,76 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.effort).toBe("low");
   });
 
+  test("model-only override of a shared gateway model keeps a vercel-ai-gateway default provider", () => {
+    // `anthropic/claude-opus-4.8` is listed by both openrouter and
+    // vercel-ai-gateway; the applicable default provider serves it, so no
+    // provider is implied and the default wins.
+    const llm = LLMSchema.parse({
+      default: {
+        ...fullDefault,
+        provider: "vercel-ai-gateway",
+        model: "anthropic/claude-sonnet-4.6",
+      },
+      callSites: {
+        memoryExtraction: { model: "anthropic/claude-opus-4.8" },
+      },
+    });
+
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+
+    expect(resolved.provider).toBe("vercel-ai-gateway");
+    expect(resolved.model).toBe("anthropic/claude-opus-4.8");
+  });
+
+  test("model-only override of a shared gateway model keeps an openrouter default provider", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        ...fullDefault,
+        provider: "openrouter",
+        model: "anthropic/claude-sonnet-4.6",
+      },
+      callSites: {
+        memoryExtraction: { model: "anthropic/claude-opus-4.8" },
+      },
+    });
+
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+
+    expect(resolved.provider).toBe("openrouter");
+    expect(resolved.model).toBe("anthropic/claude-opus-4.8");
+  });
+
+  test("model-only override of a gateway model with a non-serving default implies the catalog owner", () => {
+    // Anthropic's own catalog uses bare slugs, so it does not serve
+    // `anthropic/claude-sonnet-4.6` — the catalog owner (openrouter, the
+    // earliest entry listing it) is implied.
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      callSites: {
+        memoryExtraction: { model: "anthropic/claude-sonnet-4.6" },
+      },
+    });
+
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+
+    expect(resolved.provider).toBe("openrouter");
+    expect(resolved.model).toBe("anthropic/claude-sonnet-4.6");
+  });
+
+  test("model unique to vercel-ai-gateway implies vercel-ai-gateway", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      callSites: {
+        memoryExtraction: { model: "openai/gpt-5.5-pro" },
+      },
+    });
+
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+
+    expect(resolved.provider).toBe("vercel-ai-gateway");
+    expect(resolved.model).toBe("openai/gpt-5.5-pro");
+  });
+
   test("unknown model-only override preserves inherited provider", () => {
     const llm = LLMSchema.parse({
       default: {
@@ -496,7 +582,9 @@ describe("resolveCallSiteConfig", () => {
     // resolver itself must not throw (parity with `overrideProfile`).
     const llm: z.infer<typeof LLMSchema> = {
       default: fullDefault,
-      profiles: {},
+      // Disable the catalog default so the missing activeProfile's silent
+      // fall-through lands on `llm.default` rather than catalog `balanced`.
+      profiles: { balanced: { source: "managed", status: "disabled" } },
       profileOrder: [],
       callSites: {},
       activeProfile: "nonexistent",
@@ -840,7 +928,6 @@ describe("resolveCallSiteConfig", () => {
       "heartbeatAgent",
       "filingAgent",
       "compactionAgent",
-      "analyzeConversation",
       "callAgent",
       "memoryExtraction",
       "memoryConsolidation",
@@ -938,6 +1025,9 @@ describe("resolveCallSiteConfig", () => {
         provider_connection: "anthropic-managed",
       },
       profiles: {
+        // Disable the catalog default so the stale connection under test
+        // comes from `llm.default`, not the catalog `balanced` layer.
+        balanced: { source: "managed", status: "disabled" },
         fireworks: {
           provider: "fireworks",
           model: "accounts/fireworks/models/kimi-k2p5",
@@ -969,6 +1059,9 @@ describe("mix profiles", () => {
       },
     },
     activeProfile: "ab",
+    // Dereference the same mix from a non-main call site so the
+    // cross-call-site agreement test below exercises both deref spots.
+    callSites: { memoryExtraction: { profile: "ab" } },
   });
 
   test("same seed resolves to the same arm (stable across calls)", () => {
@@ -1315,10 +1408,11 @@ describe("resolveDefaultProfileKey", () => {
     expect(resolveDefaultProfileKey("filingAgent", llm)).toBe("cost-optimized");
   });
 
-  test("non-mainAgent falls back to custom-* when catalog profile is missing", () => {
+  test("non-mainAgent falls back to custom-* when the catalog profile is disabled", () => {
     const llm = LLMSchema.parse({
       default: fullDefault,
       profiles: {
+        "cost-optimized": { source: "managed", status: "disabled" },
         "custom-cost-optimized": {
           provider: "openai",
           model: "gpt-5-mini",
@@ -1369,6 +1463,73 @@ describe("resolveDefaultProfileKey", () => {
   });
 });
 
+describe("resolveEffectiveProfileKey", () => {
+  const llm = LLMSchema.parse({
+    default: fullDefault,
+    profiles: {
+      balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      "cost-optimized": { provider: "openai", model: "gpt-5-mini" },
+      pinned: { provider: "gemini", model: "gemini-2.5-pro" },
+    },
+    activeProfile: "balanced",
+  });
+
+  test("mainAgent: override wins over active", () => {
+    expect(
+      resolveEffectiveProfileKey("mainAgent", llm, {
+        overrideProfile: "pinned",
+      }),
+    ).toBe("pinned");
+  });
+
+  test("mainAgent: active wins when no override", () => {
+    expect(resolveEffectiveProfileKey("mainAgent", llm)).toBe("balanced");
+  });
+
+  // Codex P2: a pinned override on a bare non-mainAgent site must attribute to
+  // the override — `effectiveDefault` strips the catalog default when an
+  // override is present, so the override is the profile that supplies the config.
+  test("non-mainAgent: pinned override wins over stripped catalog default", () => {
+    expect(
+      resolveEffectiveProfileKey("filingAgent", llm, {
+        overrideProfile: "pinned",
+      }),
+    ).toBe("pinned");
+  });
+
+  test("non-mainAgent: catalog default when no override", () => {
+    // filingAgent's CALL_SITE_DEFAULTS profile is `cost-optimized`.
+    expect(resolveEffectiveProfileKey("filingAgent", llm)).toBe(
+      "cost-optimized",
+    );
+  });
+
+  test("non-mainAgent: explicit call-site profile is authoritative over override", () => {
+    const withSite = LLMSchema.parse({
+      ...llm,
+      callSites: { filingAgent: { profile: "cost-optimized" } },
+    });
+    expect(
+      resolveEffectiveProfileKey("filingAgent", withSite, {
+        overrideProfile: "pinned",
+      }),
+    ).toBe("cost-optimized");
+  });
+
+  test("non-mainAgent: forced override floats above the call-site profile", () => {
+    const withSite = LLMSchema.parse({
+      ...llm,
+      callSites: { filingAgent: { profile: "cost-optimized" } },
+    });
+    expect(
+      resolveEffectiveProfileKey("filingAgent", withSite, {
+        overrideProfile: "pinned",
+        forceOverrideProfile: true,
+      }),
+    ).toBe("pinned");
+  });
+});
+
 describe("resolveCallSiteConfig logitBias provenance", () => {
   const kimi = "accounts/fireworks/models/kimi-k2p6";
 

package/src/__tests__/llm-usage-store.test.ts

@@ -1,10 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { makeMockLogger } from "./helpers/mock-logger.js";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { getDb, getSqlite } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";

package/src/__tests__/log-export-routes.test.ts

@@ -11,13 +11,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../util/secure-keys.js", () => ({
   getSecureKeyAsync: async () => undefined,
 }));

package/src/__tests__/log-export-workspace.test.ts

@@ -26,13 +26,6 @@ import { describe, expect, mock, test } from "bun:test";
 const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 mkdirSync(testWorkspaceDir, { recursive: true });
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // Mock getSecureKeyAsync to avoid credential store access during tests
 mock.module("../util/secure-keys.js", () => ({
   getSecureKeyAsync: async () => undefined,

package/src/__tests__/managed-profile-guard.test.ts

@@ -20,12 +20,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // Imported before the `mock.module` below so the mock can pass the real
 // implementation through instead of hand-copying it.
 import { setNestedValue } from "../config/loader.js";
-import { makeMockLogger } from "./helpers/mock-logger.js";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 let savedRaw: Record<string, unknown> | null = null;
 let rawConfig: Record<string, unknown>;
 // Counters so tests can assert whether `commitConfigWrite` ran its post-write
@@ -1032,3 +1026,243 @@ describe("wire-only profile keys are stripped from writes", () => {
     expect(profile.maxTokens).toBe(2048);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Code-owned default profiles: wire round-trip and shadowing guards
+// ---------------------------------------------------------------------------
+
+const getRoute = ROUTES.find((r) => r.operationId === "config_get")!;
+
+describe("code-owned default profiles — wire view and write normalization", () => {
+  test("GET materializes catalog bodies over thin stubs (wire-only)", async () => {
+    rawConfig = {
+      llm: {
+        profiles: { balanced: { source: "managed", status: "disabled" } },
+      },
+    };
+    const response = (await getRoute.handler({})) as Record<string, any>;
+    const wireBalanced = response.llm.profiles.balanced;
+    expect(wireBalanced.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(wireBalanced.provider_connection).toBe("vellum");
+    expect(wireBalanced.status).toBe("disabled");
+    expect(wireBalanced.invariant).toBe(true);
+    // Absent defaults are materialized too — the catalog owns their content.
+    expect(response.llm.profiles["quality-optimized"].model).toBeDefined();
+  });
+
+  test("GET → PATCH round-trip of the wire view is accepted and keeps disk stubs thin", async () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          balanced: { source: "managed", status: "disabled" },
+          "my-custom": { provider: "openai", model: "gpt-4o", source: "user" },
+        },
+      },
+    };
+    const response = (await getRoute.handler({})) as Record<string, any>;
+    const result = await patchRoute.handler({
+      body: { llm: { profiles: response.llm.profiles } },
+    });
+    expect(result).toHaveProperty("llm");
+    expectOneCommitCycle();
+    expect(savedProfile("balanced")).toEqual({
+      source: "managed",
+      status: "disabled",
+    });
+    // Echoes of absent defaults reduce to a no-op managed stub.
+    expect(savedProfile("quality-optimized")).toEqual({ source: "managed" });
+    expect(savedProfile("my-custom")).toEqual({
+      provider: "openai",
+      model: "gpt-4o",
+      source: "user",
+    });
+  });
+
+  test("creating a new profile under a default name is rejected", async () => {
+    rawConfig = { llm: { profiles: {} } };
+    await expect(
+      patchRoute.handler({
+        body: {
+          llm: {
+            profiles: {
+              balanced: { source: "user", provider: "openai", model: "gpt-4o" },
+            },
+          },
+        },
+      }),
+    ).rejects.toThrow(
+      'Cannot create profile "balanced" — the name is reserved for a code-defined default profile.',
+    );
+    expectNothingCommitted();
+  });
+
+  test("writing content to an absent default name is rejected", async () => {
+    rawConfig = { llm: { profiles: {} } };
+    await expect(
+      patchRoute.handler({
+        body: {
+          llm: {
+            profiles: {
+              "cost-optimized": { source: "managed", model: "gpt-4o" },
+            },
+          },
+        },
+      }),
+    ).rejects.toThrow(
+      'Cannot edit managed profile "cost-optimized" fields [model].',
+    );
+    expectNothingCommitted();
+  });
+
+  test("disabling an absent default via a generic write is rejected", async () => {
+    rawConfig = { llm: { profiles: {} } };
+    await expect(
+      patchRoute.handler({
+        body: {
+          llm: {
+            profiles: { balanced: { source: "managed", status: "disabled" } },
+          },
+        },
+      }),
+    ).rejects.toThrow('Cannot disable managed profile "balanced".');
+    expectNothingCommitted();
+  });
+
+  test("PUT status re-enable on an absent always-available default creates a thin managed stub", async () => {
+    rawConfig = { llm: { profiles: {} } };
+    const result = await replaceRoute.handler({
+      pathParams: { name: "balanced" },
+      body: { status: "active" },
+    });
+    expect(result).toEqual({ ok: true });
+    expect(savedProfile("balanced")).toEqual({
+      source: "managed",
+      status: "active",
+    });
+  });
+
+  test("PUT on absent flag-gated os-beta is still rejected", async () => {
+    rawConfig = { llm: { profiles: {} } };
+    await expect(
+      replaceRoute.handler({
+        pathParams: { name: "os-beta" },
+        body: { status: "active" },
+      }),
+    ).rejects.toThrow(
+      'Profile "os-beta" is not currently available and cannot be edited.',
+    );
+    expectNothingCommitted();
+  });
+
+  test("an existing user-source shadow of a default name stays editable", async () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          balanced: { source: "user", provider: "openai", model: "gpt-4o" },
+        },
+      },
+    };
+    const result = await patchRoute.handler({
+      body: { llm: { profiles: { balanced: { model: "gpt-5.4" } } } },
+    });
+    expect(result).toHaveProperty("llm");
+    expectOneCommitCycle();
+    expect(savedProfile("balanced").model).toBe("gpt-5.4");
+  });
+});
+
+describe("code-owned default profiles — leaf SET source stamping", () => {
+  test("a leaf SET creating a managed entry stamps the managed marker", async () => {
+    rawConfig = { llm: { profiles: {} } };
+    const result = await setRoute.handler({
+      body: { path: "llm.profiles.balanced.status", value: "active" },
+    });
+    expect(result).toEqual({ ok: true });
+    expect(savedProfile("balanced")).toEqual({
+      source: "managed",
+      status: "active",
+    });
+  });
+
+  test("a leaf SET on an existing user shadow does not stamp it managed", async () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          balanced: { source: "user", provider: "openai", model: "gpt-4o" },
+        },
+      },
+    };
+    const result = await setRoute.handler({
+      body: { path: "llm.profiles.balanced.model", value: "gpt-5.4" },
+    });
+    expect(result).toEqual({ ok: true });
+    // Write normalization completes the changed user entry; the guard's
+    // concern is only that `source` stays user-owned.
+    expect(savedProfile("balanced")).toMatchObject({
+      source: "user",
+      provider: "openai",
+      model: "gpt-5.4",
+    });
+    expect(savedProfile("balanced").source).toBe("user");
+  });
+
+  test("a leaf SET writing content to an absent default is rejected", async () => {
+    rawConfig = { llm: { profiles: {} } };
+    await expect(
+      setRoute.handler({
+        body: { path: "llm.profiles.balanced.model", value: "gpt-4o" },
+      }),
+    ).rejects.toThrow(BadRequestError);
+    expectNothingCommitted();
+  });
+});
+
+describe("code-owned default profiles — echoes over stale on-disk bodies", () => {
+  // An overlay can persist a managed entry whose content differs from the
+  // catalog; GET serves catalog content, so a client echo carries values
+  // that match neither nothing — they match the wire view. The round-trip
+  // must still be a no-op.
+  const staleBody = {
+    source: "managed",
+    provider: "anthropic",
+    model: "claude-sonnet",
+    maxTokens: 16000,
+  };
+
+  test("GET → PATCH round-trip over a stale managed body is accepted and changes nothing", async () => {
+    rawConfig = { llm: { profiles: { balanced: structuredClone(staleBody) } } };
+    const response = (await getRoute.handler({})) as Record<string, any>;
+    // The wire view serves catalog content, not the stale body.
+    expect(response.llm.profiles.balanced.model).toBe(
+      "accounts/fireworks/models/glm-5p2",
+    );
+    const result = await patchRoute.handler({
+      body: { llm: { profiles: response.llm.profiles } },
+    });
+    expect(result).toHaveProperty("llm");
+    expectOneCommitCycle();
+    expect(savedProfile("balanced")).toEqual(staleBody);
+  });
+
+  test("GET → SET llm round-trip over a stale managed body is accepted and changes nothing", async () => {
+    rawConfig = { llm: { profiles: { balanced: structuredClone(staleBody) } } };
+    const response = (await getRoute.handler({})) as Record<string, any>;
+    const result = await setRoute.handler({
+      body: { path: "llm.profiles", value: response.llm.profiles },
+    });
+    expect(result).toEqual({ ok: true });
+    expect(savedProfile("balanced")).toEqual(staleBody);
+  });
+
+  test("a genuine content edit over a stale managed body is still rejected", async () => {
+    rawConfig = { llm: { profiles: { balanced: structuredClone(staleBody) } } };
+    await expect(
+      patchRoute.handler({
+        body: {
+          llm: { profiles: { balanced: { model: "some-other-model" } } },
+        },
+      }),
+    ).rejects.toThrow(BadRequestError);
+    expectNothingCommitted();
+  });
+});

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -39,13 +39,6 @@ const mockConfig = {
   },
 };
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,

package/src/__tests__/managed-store.test.ts

@@ -8,27 +8,12 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  spyOn,
-  test,
-} from "bun:test";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 
 import { parse as parseYaml } from "yaml";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 import { loadSkillCatalog } from "../config/skills.js";
 import {
   buildSkillMarkdown,

package/src/__tests__/mcp-auth-routes.test.ts

@@ -44,13 +44,6 @@ mock.module("../config/loader.js", () => ({
   getConfigReadOnly: () => mockConfig,
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // ── Import SUT after mocks ─────────────────────────────────────────────────────
 
 const { ROUTES } = await import("../runtime/routes/mcp-auth-routes.js");
@@ -70,7 +63,7 @@ describe("mcp-auth-routes", () => {
     mockOrchestrateConnect.mockClear();
     mockGetMcpAuthState.mockClear();
     mockGetMcpAuthState.mockImplementation(() => null);
-    mockReloadMcpServers.mockClear();  // ← add this line
+    mockReloadMcpServers.mockClear(); // ← add this line
   });
 
   describe("POST internal/mcp/auth/start", () => {

package/src/__tests__/mcp-config-secret-boundary.test.ts

@@ -158,6 +158,18 @@ const configGetRoute = findRoute("config_get");
 const configPatchRoute = findRoute("config_patch");
 const configSetRoute = findRoute("config_set");
 
+/**
+ * Config responses inject the code-catalog default profiles into
+ * `llm.profiles` (the effective wire view). These tests pin the MCP secret
+ * boundary, so drop the injected block before whole-response comparisons.
+ */
+function withoutWireProfiles(
+  result: Record<string, unknown>,
+): Record<string, unknown> {
+  const { llm: _llm, ...rest } = result;
+  return rest;
+}
+
 describe("MCP config secret boundary", () => {
   beforeEach(() => {
     rawConfig = {};
@@ -211,7 +223,7 @@ describe("MCP config secret boundary", () => {
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
     expect(JSON.stringify(result)).not.toContain("malformed-secret");
-    expect(result).toEqual({
+    expect(withoutWireProfiles(result)).toEqual({
       mcp: {
         servers: [
           {
@@ -238,7 +250,7 @@ describe("MCP config secret boundary", () => {
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(result).toEqual(rawConfig);
+    expect(withoutWireProfiles(result)).toEqual(rawConfig);
   });
 
   test("config_get preserves non-credential headers env vars", () => {
@@ -260,7 +272,7 @@ describe("MCP config secret boundary", () => {
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(result).toEqual(rawConfig);
+    expect(withoutWireProfiles(result)).toEqual(rawConfig);
   });
 
   test("config_patch rejects MCP transport headers so generic writes cannot reintroduce plaintext credentials", async () => {
@@ -300,7 +312,7 @@ describe("MCP config secret boundary", () => {
       },
     });
 
-    expect(result).toEqual({
+    expect(withoutWireProfiles(result as Record<string, unknown>)).toEqual({
       mcp: {
         servers: {
           headers: {
@@ -333,7 +345,7 @@ describe("MCP config secret boundary", () => {
       },
     });
 
-    expect(result).toEqual({
+    expect(withoutWireProfiles(result as Record<string, unknown>)).toEqual({
       mcp: {
         servers: {
           local: {