@vellumai/assistant 0.5.1 → 0.5.2

package/src/__tests__/turn-boundary-resolution.test.ts

@@ -0,0 +1,243 @@
+import { mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const testDir = realpathSync(
+  mkdtempSync(join(tmpdir(), "turn-boundary-resolution-test-")),
+);
+const workspaceDir = join(testDir, ".vellum", "workspace");
+const conversationsDir = join(workspaceDir, "conversations");
+
+mock.module("../util/platform.js", () => ({
+  getRootDir: () => join(testDir, ".vellum"),
+  getDataDir: () => join(workspaceDir, "data"),
+  getWorkspaceDir: () => workspaceDir,
+  getConversationsDir: () => conversationsDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import {
+  addMessage,
+  createConversation,
+  getAssistantMessageIdsInTurn,
+} from "../memory/conversation-crud.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { llmRequestLogs, toolInvocations } from "../memory/schema.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.delete(llmRequestLogs).run();
+  db.delete(toolInvocations).run();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+function toolResultContent(toolUseIds: string[]): string {
+  return JSON.stringify(
+    toolUseIds.map((id) => ({
+      type: "tool_result",
+      tool_use_id: id,
+      content: "ok",
+      is_error: false,
+    })),
+  );
+}
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: true, force: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+describe("getAssistantMessageIdsInTurn", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("single-step turn: returns only the one assistant message", async () => {
+    const conv = createConversation("single-step");
+    await addMessage(conv.id, "user", "Hello", undefined, {
+      skipIndexing: true,
+    });
+    const a1 = await addMessage(conv.id, "assistant", "Hi there!", undefined, {
+      skipIndexing: true,
+    });
+
+    const result = getAssistantMessageIdsInTurn(a1.id);
+    expect(result).toEqual([a1.id]);
+  });
+
+  test("multi-step turn: user → A1 → tool_result → A2 → query A2 → returns [A1, A2]", async () => {
+    const conv = createConversation("multi-step");
+    await addMessage(conv.id, "user", "Do the thing", undefined, {
+      skipIndexing: true,
+    });
+    const a1 = await addMessage(
+      conv.id,
+      "assistant",
+      "Using tool...",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      toolResultContent(["tool-1"]),
+      undefined,
+      { skipIndexing: true },
+    );
+    const a2 = await addMessage(conv.id, "assistant", "Done!", undefined, {
+      skipIndexing: true,
+    });
+
+    const result = getAssistantMessageIdsInTurn(a2.id);
+    expect(result).toEqual([a1.id, a2.id]);
+  });
+
+  test("3-step turn: user → A1 → tool_result → A2 → tool_result → A3 → query A3 → returns [A1, A2, A3]", async () => {
+    const conv = createConversation("three-step");
+    await addMessage(conv.id, "user", "Complex task", undefined, {
+      skipIndexing: true,
+    });
+    const a1 = await addMessage(conv.id, "assistant", "Step 1...", undefined, {
+      skipIndexing: true,
+    });
+    await addMessage(
+      conv.id,
+      "user",
+      toolResultContent(["tool-1"]),
+      undefined,
+      { skipIndexing: true },
+    );
+    const a2 = await addMessage(conv.id, "assistant", "Step 2...", undefined, {
+      skipIndexing: true,
+    });
+    await addMessage(
+      conv.id,
+      "user",
+      toolResultContent(["tool-2"]),
+      undefined,
+      { skipIndexing: true },
+    );
+    const a3 = await addMessage(conv.id, "assistant", "All done!", undefined, {
+      skipIndexing: true,
+    });
+
+    const result = getAssistantMessageIdsInTurn(a3.id);
+    expect(result).toEqual([a1.id, a2.id, a3.id]);
+  });
+
+  test("query intermediate message: query A1 in a 2-step turn → returns [A1, A2]", async () => {
+    const conv = createConversation("intermediate");
+    await addMessage(conv.id, "user", "Start task", undefined, {
+      skipIndexing: true,
+    });
+    const a1 = await addMessage(
+      conv.id,
+      "assistant",
+      "Using tool...",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      toolResultContent(["tool-1"]),
+      undefined,
+      { skipIndexing: true },
+    );
+    const a2 = await addMessage(conv.id, "assistant", "Done!", undefined, {
+      skipIndexing: true,
+    });
+
+    const result = getAssistantMessageIdsInTurn(a1.id);
+    expect(result).toEqual([a1.id, a2.id]);
+  });
+
+  test("message not found: returns [messageId]", () => {
+    const result = getAssistantMessageIdsInTurn("nonexistent-id");
+    expect(result).toEqual(["nonexistent-id"]);
+  });
+
+  test("consecutive turns: query message in second turn → returns only that turn's messages", async () => {
+    const conv = createConversation("consecutive");
+
+    // First turn
+    await addMessage(conv.id, "user", "First question", undefined, {
+      skipIndexing: true,
+    });
+    const a1 = await addMessage(
+      conv.id,
+      "assistant",
+      "First answer",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    // Second turn
+    await addMessage(conv.id, "user", "Second question", undefined, {
+      skipIndexing: true,
+    });
+    const a2 = await addMessage(
+      conv.id,
+      "assistant",
+      "Using tool...",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      toolResultContent(["tool-1"]),
+      undefined,
+      { skipIndexing: true },
+    );
+    const a3 = await addMessage(
+      conv.id,
+      "assistant",
+      "Done with second",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    // Query second turn → should NOT include a1
+    const result = getAssistantMessageIdsInTurn(a3.id);
+    expect(result).toEqual([a2.id, a3.id]);
+
+    // Query first turn → should only include a1
+    const firstTurnResult = getAssistantMessageIdsInTurn(a1.id);
+    expect(firstTurnResult).toEqual([a1.id]);
+  });
+});

package/src/__tests__/web-fetch.test.ts

@@ -1641,7 +1641,9 @@ describe("web_fetch tool", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(result.content).not.toContain("Extracted text content is very short");
+    expect(result.content).not.toContain(
+      "Extracted text content is very short",
+    );
   });
 
   test("does not suggest JS rendering notice in raw mode even for sparse HTML", async () => {
@@ -1660,6 +1662,8 @@ describe("web_fetch tool", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(result.content).not.toContain("Extracted text content is very short");
+    expect(result.content).not.toContain(
+      "Extracted text content is very short",
+    );
   });
 });

package/src/__tests__/workspace-migration-006-services-config.test.ts

@@ -0,0 +1,335 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must precede the migration import
+// ---------------------------------------------------------------------------
+
+mock.module("../security/secure-keys.js", () => ({
+  getProviderKeyAsync: async () => null,
+  getSecureKeyAsync: async () => null,
+}));
+
+import { servicesConfigMigration } from "../workspace/migrations/006-services-config.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-006-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"));
+}
+
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("006-services-config migration", () => {
+  test("migrates all legacy fields into services object", async () => {
+    writeConfig({
+      provider: "openai",
+      model: "gpt-4o",
+      imageGenModel: "dall-e-3",
+      webSearchProvider: "brave",
+      otherSetting: true,
+    });
+
+    await servicesConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+
+    // Legacy fields removed
+    expect(config.provider).toBeUndefined();
+    expect(config.model).toBeUndefined();
+    expect(config.imageGenModel).toBeUndefined();
+    expect(config.webSearchProvider).toBeUndefined();
+
+    // Non-legacy fields preserved
+    expect(config.otherSetting).toBe(true);
+
+    // Services populated correctly
+    const services = config.services as Record<string, Record<string, unknown>>;
+    expect(services.inference).toEqual({
+      mode: "your-own",
+      provider: "openai",
+      model: "gpt-4o",
+    });
+    expect(services["image-generation"]).toEqual({
+      mode: "your-own",
+      provider: "openai",
+      model: "dall-e-3",
+    });
+    expect(services["web-search"]).toEqual({
+      mode: "your-own",
+      provider: "brave",
+    });
+  });
+
+  test("uses anthropic defaults when legacy fields are non-string", async () => {
+    // Legacy fields present but not strings (e.g. null or number) — fall
+    // through to defaults
+    writeConfig({
+      provider: null,
+      model: 123,
+    });
+
+    await servicesConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, Record<string, unknown>>;
+    expect(services.inference.provider).toBe("anthropic");
+    expect(services.inference.model).toBe("claude-opus-4-6");
+  });
+
+  test("no-op when config.json does not exist", async () => {
+    // No config file — should return without error
+    await servicesConfigMigration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
+  });
+
+  test("no-op when no legacy fields are present (fresh install)", async () => {
+    const original = {
+      services: {
+        inference: {
+          mode: "your-own",
+          provider: "anthropic",
+          model: "claude-opus-4-6",
+        },
+      },
+    };
+    writeConfig(original);
+
+    await servicesConfigMigration.run(workspaceDir);
+
+    // Config should be unchanged — migration skipped entirely
+    const config = readConfig();
+    expect(config).toEqual(original);
+  });
+
+  test("no-op when no legacy fields are present (already migrated)", async () => {
+    const alreadyMigrated = {
+      services: {
+        inference: { mode: "your-own", provider: "openai", model: "gpt-4o" },
+        "image-generation": {
+          mode: "your-own",
+          provider: "gemini",
+          model: "gemini-2.5-flash-image",
+        },
+        "web-search": { mode: "your-own", provider: "anthropic-native" },
+      },
+    };
+    writeConfig(alreadyMigrated);
+
+    await servicesConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config).toEqual(alreadyMigrated);
+  });
+
+  test("idempotency: running migration twice produces same result", async () => {
+    writeConfig({
+      provider: "openai",
+      model: "gpt-4o",
+      imageGenModel: "dall-e-3",
+      webSearchProvider: "brave",
+    });
+
+    await servicesConfigMigration.run(workspaceDir);
+    const afterFirst = readConfig();
+
+    await servicesConfigMigration.run(workspaceDir);
+    const afterSecond = readConfig();
+
+    expect(afterSecond).toEqual(afterFirst);
+  });
+
+  test("merges with existing backfilled services object", async () => {
+    // Simulates the scenario where backfillConfigDefaults wrote a default
+    // services object before migrations run, and legacy fields coexist.
+    writeConfig({
+      provider: "openai",
+      model: "gpt-4o",
+      services: {
+        inference: {
+          mode: "your-own",
+          provider: "anthropic",
+          model: "claude-opus-4-6",
+        },
+        "image-generation": {
+          mode: "your-own",
+          provider: "gemini",
+          model: "gemini-2.5-flash-image",
+        },
+        "web-search": {
+          mode: "your-own",
+          provider: "anthropic-native",
+        },
+      },
+    });
+
+    await servicesConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, Record<string, unknown>>;
+
+    // Legacy fields should win over backfilled defaults
+    expect(services.inference.provider).toBe("openai");
+    expect(services.inference.model).toBe("gpt-4o");
+
+    // Legacy fields removed
+    expect(config.provider).toBeUndefined();
+    expect(config.model).toBeUndefined();
+  });
+
+  test("preserves extra keys from existing services during merge", async () => {
+    // If backfill or future code added extra keys in services, the spread
+    // operator should preserve them.
+    writeConfig({
+      provider: "openai",
+      services: {
+        inference: {
+          mode: "your-own",
+          provider: "anthropic",
+          model: "claude-opus-4-6",
+          extraKey: "should-survive",
+        },
+        "custom-service": {
+          foo: "bar",
+        },
+      },
+    });
+
+    await servicesConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, Record<string, unknown>>;
+
+    // Extra key preserved from spread
+    expect(services.inference.extraKey).toBe("should-survive");
+
+    // Custom service section preserved from top-level spread
+    expect(services["custom-service"]).toEqual({ foo: "bar" });
+  });
+
+  test("gemini image model sets provider to gemini", async () => {
+    writeConfig({
+      imageGenModel: "gemini-2.5-flash-image",
+    });
+
+    await servicesConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, Record<string, unknown>>;
+    expect(services["image-generation"].provider).toBe("gemini");
+    expect(services["image-generation"].model).toBe("gemini-2.5-flash-image");
+  });
+
+  test("dall-e image model sets provider to openai", async () => {
+    writeConfig({
+      imageGenModel: "dall-e-3",
+    });
+
+    await servicesConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, Record<string, unknown>>;
+    expect(services["image-generation"].provider).toBe("openai");
+    expect(services["image-generation"].model).toBe("dall-e-3");
+  });
+
+  test("gracefully handles invalid JSON in config file", async () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+
+    // Should return without error
+    await servicesConfigMigration.run(workspaceDir);
+
+    // File should be unchanged
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("gracefully handles array config", async () => {
+    writeFileSync(join(workspaceDir, "config.json"), JSON.stringify([1, 2, 3]));
+
+    // Should return without error
+    await servicesConfigMigration.run(workspaceDir);
+
+    // File should be unchanged
+    const raw = JSON.parse(
+      readFileSync(join(workspaceDir, "config.json"), "utf-8"),
+    );
+    expect(raw).toEqual([1, 2, 3]);
+  });
+
+  test("falls back to existing services values when legacy fields are absent for that service", async () => {
+    // Only provider legacy field present; imageGenModel and webSearchProvider
+    // are missing. Existing services should be used for image-generation and
+    // web-search.
+    writeConfig({
+      provider: "openai",
+      services: {
+        "image-generation": {
+          mode: "your-own",
+          provider: "openai",
+          model: "dall-e-2",
+        },
+        "web-search": {
+          mode: "your-own",
+          provider: "brave",
+        },
+      },
+    });
+
+    await servicesConfigMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, Record<string, unknown>>;
+
+    // image-generation: falls back to existing services model value
+    expect(services["image-generation"].model).toBe("dall-e-2");
+    expect(services["image-generation"].provider).toBe("openai");
+
+    // web-search: falls back to existing services provider value
+    expect(services["web-search"].provider).toBe("brave");
+  });
+});