@vellumai/assistant 0.8.2 → 0.8.3

package/src/__tests__/system-prompt.test.ts

@@ -675,10 +675,7 @@ describe("buildSystemPrompt", () => {
       // so the bundled body must not leak into the rendered output.  This is
       // the explicit "user silenced this section" path.
       mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-      writeFileSync(
-        PARALLEL_FILE,
-        "---\nenabled: false\n---\nIgnored body.\n",
-      );
+      writeFileSync(PARALLEL_FILE, "---\nenabled: false\n---\nIgnored body.\n");
       const result = buildSystemPrompt();
       expect(result).not.toContain("<use_parallel_tool_calls>");
       expect(result).not.toContain("Batch independent tool calls");
@@ -713,7 +710,10 @@ describe("buildSystemPrompt", () => {
     });
 
     describe("containerized section (slot 02)", () => {
-      const CONTAINERIZED_FILE = join(SYSTEM_PROMPTS_DIR, "02-containerized.md");
+      const CONTAINERIZED_FILE = join(
+        SYSTEM_PROMPTS_DIR,
+        "02-containerized.md",
+      );
 
       // The runtime gate is `isContainerized` on the render context, sourced
       // from `getIsContainerized()` which reads `process.env.IS_CONTAINERIZED`.
@@ -1093,10 +1093,7 @@ describe("buildSystemPrompt", () => {
     });
 
     describe("external-content section (slot 07)", () => {
-      const EXTERNAL_FILE = join(
-        SYSTEM_PROMPTS_DIR,
-        "07-external-content.md",
-      );
+      const EXTERNAL_FILE = join(SYSTEM_PROMPTS_DIR, "07-external-content.md");
 
       test("workspace external-content file is rendered into the static block", () => {
         mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
@@ -1139,69 +1136,6 @@ describe("buildSystemPrompt", () => {
       });
     });
 
-    describe("background-conversation section (slot 08)", () => {
-      const BACKGROUND_FILE = join(
-        SYSTEM_PROMPTS_DIR,
-        "08-background-conversation.md",
-      );
-
-      test("bundled default renders when isBackgroundConversation is true", () => {
-        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-        const result = buildSystemPrompt({ isBackgroundConversation: true });
-        expect(result).toContain("## Background Conversation");
-        expect(result).toContain("non-interactive background job");
-        expect(result).toContain("`notifications` skill");
-      });
-
-      test("bundled default is gated out when isBackgroundConversation is false", () => {
-        // Mustache `{{#isBackgroundConversation}}...{{/isBackgroundConversation}}`
-        // wraps the entire heading + body so the slot interpolates to empty
-        // in foreground conversations and the renderer drops it.
-        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-        const result = buildSystemPrompt({ isBackgroundConversation: false });
-        expect(result).not.toContain("## Background Conversation");
-      });
-
-      test("bundled default is gated out when isBackgroundConversation is omitted", () => {
-        // `ctx.isBackgroundConversation` is normalized to `false` when the
-        // caller omits the flag, so the gated section drops out cleanly.
-        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-        const result = buildSystemPrompt();
-        expect(result).not.toContain("## Background Conversation");
-      });
-
-      test("workspace override is also gated by isBackgroundConversation", () => {
-        // Workspace overrides flow through the same mustache interpolation,
-        // so authors can rely on the same `{{#isBackgroundConversation}}`
-        // gate in their custom body.
-        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-        writeFileSync(
-          BACKGROUND_FILE,
-          "{{#isBackgroundConversation}}## Background Conversation\n\nWorkspace override marker COMET_3K.\n{{/isBackgroundConversation}}\n",
-        );
-
-        const offResult = buildSystemPrompt({ isBackgroundConversation: false });
-        expect(offResult).not.toContain("## Background Conversation");
-        expect(offResult).not.toContain("Workspace override marker COMET_3K.");
-
-        const onResult = buildSystemPrompt({ isBackgroundConversation: true });
-        expect(onResult).toContain("## Background Conversation");
-        expect(onResult).toContain("Workspace override marker COMET_3K.");
-      });
-
-      test("renders after the external-content section when both render", () => {
-        // Numeric prefix `08-` > `07-` so the background-conversation
-        // section trails the external-content section in the static block.
-        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-        const result = buildSystemPrompt({ isBackgroundConversation: true });
-        const externalIdx = result.indexOf("## External Content");
-        const backgroundIdx = result.indexOf("## Background Conversation");
-        expect(externalIdx).toBeGreaterThan(-1);
-        expect(backgroundIdx).toBeGreaterThan(-1);
-        expect(externalIdx).toBeLessThan(backgroundIdx);
-      });
-    });
-
     test("unresolved {{variable}} is left as a literal in the body", () => {
       mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
       writeFileSync(
@@ -1211,7 +1145,6 @@ describe("buildSystemPrompt", () => {
       const result = buildSystemPrompt();
       expect(result).toContain("Has {{somethingMissing}} in body.");
     });
-
   });
 });
 

package/src/__tests__/workspace-migration-087-memory-router-balanced-profile.test.ts

@@ -0,0 +1,228 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { memoryRouterBalancedProfileMigration } from "../workspace/migrations/087-memory-router-balanced-profile.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-087-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("087-memory-router-balanced-profile migration", () => {
+  test("has correct migration id", () => {
+    expect(memoryRouterBalancedProfileMigration.id).toBe(
+      "087-memory-router-balanced-profile",
+    );
+  });
+
+  test("replaces seeded Sonnet 4.6 + 1M context with balanced profile", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: {
+            model: "claude-sonnet-4-6",
+            contextWindow: { maxInputTokens: 1_000_000 },
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("creates the call site when missing", () => {
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("writes a fresh starter config when config.json is absent", () => {
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    expect(existsSync(configPath())).toBe(true);
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("skips BYOK / non-Anthropic workspaces to avoid breaking memoryRouter", () => {
+    // `balanced` resolves to the managed Anthropic connection, which BYOK
+    // installs disable. Rewriting to `balanced` there would silently disable
+    // memory injection (getConfiguredProvider returns null). Preserve whatever
+    // memoryRouter config the workspace already has — including absence.
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+        callSites: {
+          memoryRouter: { model: "gpt-5.4" },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ model: "gpt-5.4" });
+  });
+
+  test("skips BYOK workspaces with no existing memoryRouter entry", () => {
+    writeConfig({
+      llm: { default: { provider: "gemini" } },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites?.memoryRouter).toBeUndefined();
+  });
+
+  test("preserves user customizations on memoryRouter (non-077-seeded shape)", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: {
+            model: "claude-haiku-4-5-20251001",
+            effort: "low",
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+    });
+  });
+
+  test("is idempotent — second run does not change the call site", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: {
+            model: "claude-sonnet-4-6",
+            contextWindow: { maxInputTokens: 1_000_000 },
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+    const afterFirst = readFileSync(configPath(), "utf-8");
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+    const afterSecond = readFileSync(configPath(), "utf-8");
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("skips when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: { model: "claude-sonnet-4-6" },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      model: "claude-sonnet-4-6",
+    });
+  });
+
+  test("preserves sibling call-site entries", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          mainAgent: { model: "claude-opus-4-7", maxTokens: 32000 },
+          memoryRouter: {
+            model: "claude-sonnet-4-6",
+            contextWindow: { maxInputTokens: 1_000_000 },
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.mainAgent).toEqual({
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    });
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+});

package/src/a2a/__tests__/agent-card.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+
+import { buildAgentCard } from "../agent-card.js";
+
+describe("buildAgentCard", () => {
+  const BASE_PARAMS = {
+    assistantName: "Alice",
+    baseUrl: "https://example.com",
+  };
+
+  test("includes all required top-level fields", () => {
+    const card = buildAgentCard(BASE_PARAMS);
+
+    expect(card.name).toBe("Alice");
+    expect(card.description).toBeDefined();
+    expect(card.version).toBe("1.0.0");
+    expect(card.supported_interfaces).toBeDefined();
+    expect(card.capabilities).toBeDefined();
+    expect(card.default_input_modes).toBeDefined();
+    expect(card.default_output_modes).toBeDefined();
+    expect(card.skills).toBeDefined();
+  });
+
+  test("interface URL is baseUrl + /a2a/message:send", () => {
+    const card = buildAgentCard(BASE_PARAMS);
+
+    expect(card.supported_interfaces).toHaveLength(1);
+    expect(card.supported_interfaces[0].url).toBe(
+      "https://example.com/a2a/message:send",
+    );
+    expect(card.supported_interfaces[0].protocol_binding).toBe("JSONRPC");
+    expect(card.supported_interfaces[0].protocol_version).toBe("1.0");
+  });
+
+  test("push_notifications capability is true", () => {
+    const card = buildAgentCard(BASE_PARAMS);
+
+    expect(card.capabilities.push_notifications).toBe(true);
+  });
+
+  test("streaming capability is false", () => {
+    const card = buildAgentCard(BASE_PARAMS);
+
+    expect(card.capabilities.streaming).toBe(false);
+  });
+
+  test("extended_agent_card capability is false", () => {
+    const card = buildAgentCard(BASE_PARAMS);
+
+    expect(card.capabilities.extended_agent_card).toBe(false);
+  });
+
+  test("defaults description when omitted", () => {
+    const card = buildAgentCard(BASE_PARAMS);
+
+    expect(card.description).toBe("Alice — a Vellum AI assistant");
+  });
+
+  test("uses explicit description when provided", () => {
+    const card = buildAgentCard({
+      ...BASE_PARAMS,
+      assistantDescription: "A specialized research assistant",
+    });
+
+    expect(card.description).toBe("A specialized research assistant");
+  });
+
+  test("advertises text/plain as default input and output mode", () => {
+    const card = buildAgentCard(BASE_PARAMS);
+
+    expect(card.default_input_modes).toEqual(["text/plain"]);
+    expect(card.default_output_modes).toEqual(["text/plain"]);
+  });
+
+  test("includes a conversation skill", () => {
+    const card = buildAgentCard(BASE_PARAMS);
+
+    expect(card.skills).toHaveLength(1);
+    expect(card.skills[0]).toEqual({
+      id: "conversation",
+      name: "General conversation",
+      description: "Send a message and receive a response",
+      tags: ["chat"],
+    });
+  });
+
+  test("constructs correct interface URL with trailing-slash base", () => {
+    const card = buildAgentCard({
+      ...BASE_PARAMS,
+      baseUrl: "https://example.com/",
+    });
+
+    // The URL is constructed by simple concatenation; callers normalize the base.
+    expect(card.supported_interfaces[0].url).toBe(
+      "https://example.com//a2a/message:send",
+    );
+  });
+});