@vellumai/assistant 0.5.6 → 0.5.8

package/src/__tests__/claude-code-skill-regression.test.ts

@@ -1,206 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { describe, expect, mock, spyOn, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mocks — must be set up before importing modules that use them
-// ---------------------------------------------------------------------------
-
-mock.module("@anthropic-ai/claude-agent-sdk", () => ({
-  query: () => ({
-    async *[Symbol.asyncIterator]() {
-      yield {
-        type: "result" as const,
-        session_id: "s",
-        subtype: "success" as const,
-        result: "ok",
-      };
-    },
-  }),
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    services: {
-      inference: {
-        mode: "your-own",
-        provider: "anthropic",
-        model: "claude-opus-4-6",
-      },
-      "image-generation": {
-        mode: "your-own",
-        provider: "gemini",
-        model: "gemini-3.1-flash-image-preview",
-      },
-      "web-search": { mode: "your-own", provider: "inference-provider-native" },
-    },
-  }),
-  loadConfig: () => ({}),
-  loadRawConfig: () => ({}),
-  saveConfig: () => {},
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  syncConfigToLockfile: () => {},
-}));
-
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKeyAsync: async (name: string) =>
-    name === "anthropic" ? "fake-anthropic-key" : null,
-  getProviderKeyAsync: async (provider: string) =>
-    provider === "anthropic" ? "fake-anthropic-key" : undefined,
-}));
-
-// ---------------------------------------------------------------------------
-// Imports (after mocks)
-// ---------------------------------------------------------------------------
-
-import { claudeCodeTool } from "../tools/claude-code/claude-code.js";
-
-// ---------------------------------------------------------------------------
-// Locate the bundled skill directory relative to the test file
-// ---------------------------------------------------------------------------
-
-const SKILL_DIR = path.resolve(
-  import.meta.dirname ?? __dirname,
-  "../config/bundled-skills/claude-code",
-);
-
-const SHARED_DIR = path.resolve(
-  import.meta.dirname ?? __dirname,
-  "../config/bundled-skills/_shared",
-);
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("Claude Code skill migration regression", () => {
-  test("skill script wrapper exports a `run` function", async () => {
-    const wrapperPath = path.join(SKILL_DIR, "tools/claude-code.ts");
-    // The wrapper module must exist and export `run`
-    const mod = await import(wrapperPath);
-    expect(typeof mod.run).toBe("function");
-  });
-
-  test("TOOLS.json manifest lists claude_code as the tool name", () => {
-    const manifestPath = path.join(SKILL_DIR, "TOOLS.json");
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-
-    expect(manifest.version).toBe(1);
-    expect(Array.isArray(manifest.tools)).toBe(true);
-
-    const toolNames = manifest.tools.map((t: { name: string }) => t.name);
-    expect(toolNames).toContain("claude_code");
-  });
-
-  test("TOOLS.json input_schema matches claudeCodeTool.getDefinition()", () => {
-    const manifestPath = path.join(SKILL_DIR, "TOOLS.json");
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-
-    const manifestTool = manifest.tools.find(
-      (t: { name: string }) => t.name === "claude_code",
-    );
-    expect(manifestTool).toBeDefined();
-
-    const runtimeDef = claudeCodeTool.getDefinition();
-
-    // The input_schema declared in the static manifest must match the
-    // runtime definition. Drift here would mean the model sees a different
-    // schema than the executor actually supports.
-    expect(manifestTool.input_schema).toEqual(runtimeDef.input_schema);
-  });
-
-  test("TOOLS.json description matches claudeCodeTool.getDefinition()", () => {
-    const manifestPath = path.join(SKILL_DIR, "TOOLS.json");
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-
-    const manifestTool = manifest.tools.find(
-      (t: { name: string }) => t.name === "claude_code",
-    );
-    expect(manifestTool).toBeDefined();
-
-    const runtimeDef = claudeCodeTool.getDefinition();
-
-    // Description parity guards against a manifest edit that diverges from
-    // the canonical tool description.
-    expect(manifestTool.description).toBe(runtimeDef.description);
-  });
-
-  test("wrapper run() delegates to claudeCodeTool.execute()", async () => {
-    // Verifies the wrapper is not a stale stub but actually calls through
-    // to the canonical execute method with the exact input and context.
-    const spy = spyOn(claudeCodeTool, "execute");
-
-    const wrapperPath = path.join(SKILL_DIR, "tools/claude-code.ts");
-    const mod = await import(wrapperPath);
-
-    const input = { prompt: "hello" };
-    const ctx = {
-      conversationId: "test",
-      workingDir: "/tmp",
-      onOutput: () => {},
-    };
-
-    const result = await mod.run(input, ctx);
-    expect(result.isError).toBeFalsy();
-
-    // The wrapper must delegate to the canonical execute method
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy).toHaveBeenCalledWith(input, ctx);
-
-    spy.mockRestore();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Bundled skill shared guidance — CES tools instead of token-reveal
-// ---------------------------------------------------------------------------
-
-describe("CLI_RETRIEVAL_PATTERN.md CES guidance", () => {
-  const patternPath = path.join(SHARED_DIR, "CLI_RETRIEVAL_PATTERN.md");
-  const content = fs.readFileSync(patternPath, "utf-8");
-
-  test("teaches handle discovery via assistant credentials list", () => {
-    expect(content).toContain("assistant credentials list");
-  });
-
-  test("teaches handle discovery via assistant oauth connections list", () => {
-    expect(content).toContain("assistant oauth connections list");
-  });
-
-  test("teaches make_authenticated_request CES tool", () => {
-    expect(content).toContain("make_authenticated_request");
-  });
-
-  test("teaches run_authenticated_command CES tool", () => {
-    expect(content).toContain("run_authenticated_command");
-  });
-
-  test("warns that host_bash is outside CES secrecy boundary", () => {
-    expect(content).toContain("outside the CES secrecy boundary");
-  });
-
-  // -- Deprecated patterns must NOT appear --
-
-  test("does not teach proxied bash with credential_ids", () => {
-    expect(content).not.toContain("credential_ids");
-    expect(content).not.toContain("network_mode: proxied");
-  });
-
-  test("does not teach oauth connections token for raw token extraction", () => {
-    expect(content).not.toContain("oauth connections token");
-  });
-});

package/src/__tests__/claude-code-tool-profiles.test.ts

@@ -1,99 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mock the Agent SDK — prevents real subprocess spawning
-// ---------------------------------------------------------------------------
-const queryMock = mock(() => {
-  // Returns an async iterable that yields a success result
-  return {
-    async *[Symbol.asyncIterator]() {
-      yield {
-        type: "result" as const,
-        session_id: "test-session",
-        subtype: "success" as const,
-        result: "Done.",
-      };
-    },
-  };
-});
-
-mock.module("@anthropic-ai/claude-agent-sdk", () => ({
-  query: queryMock,
-}));
-
-// Mock logger
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-// Mock config
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-  }),
-}));
-
-// Mock secure-keys — provide a fake Anthropic API key
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKeyAsync: async (name: string) =>
-    name === "anthropic" ? "fake-anthropic-key" : null,
-  getProviderKeyAsync: async (provider: string) =>
-    provider === "anthropic" ? "fake-anthropic-key" : undefined,
-}));
-
-import { claudeCodeTool } from "../tools/claude-code/claude-code.js";
-import type { ToolContext } from "../tools/types.js";
-
-function makeContext(overrides?: Partial<ToolContext>): ToolContext {
-  return {
-    conversationId: "test-session",
-    workingDir: "/tmp/test",
-    trustClass: "guardian",
-    onOutput: () => {},
-    ...overrides,
-  } as ToolContext;
-}
-
-describe("claude_code tool profile support", () => {
-  beforeEach(() => {
-    queryMock.mockClear();
-  });
-
-  test("getDefinition includes profile parameter", () => {
-    const def = claudeCodeTool.getDefinition();
-    const props = (def.input_schema as Record<string, unknown>)
-      .properties as Record<string, unknown>;
-    expect(props.profile).toBeDefined();
-  });
-
-  test("rejects invalid profile", async () => {
-    const result = await claudeCodeTool.execute(
-      { prompt: "test", profile: "hacker" },
-      makeContext(),
-    );
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("Invalid profile");
-  });
-
-  test("accepts valid profiles without error", async () => {
-    for (const profile of ["general", "researcher", "coder", "reviewer"]) {
-      queryMock.mockClear();
-      const result = await claudeCodeTool.execute(
-        { prompt: "test", profile },
-        makeContext(),
-      );
-      expect(result.isError).toBeFalsy();
-    }
-  });
-
-  test("omitted profile defaults to general", async () => {
-    const result = await claudeCodeTool.execute(
-      { prompt: "test" },
-      makeContext(),
-    );
-    expect(result.isError).toBeFalsy();
-  });
-});

package/src/__tests__/diagnostics-export.test.ts

@@ -1,288 +0,0 @@
-/**
- * Tests for the diagnostics export route handler.
- *
- * Validates anchor message resolution, including the fallback chain
- * (specific ID → most recent assistant → any message → empty conversation).
- */
-
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import JSZip from "jszip";
-
-const testDir = mkdtempSync(join(tmpdir(), "diagnostics-export-test-"));
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  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: () => () => {},
-    }),
-}));
-
-import { getSqlite, initializeDb, resetDb } from "../memory/db.js";
-import { diagnosticsRouteDefinitions } from "../runtime/routes/diagnostics-routes.js";
-
-initializeDb();
-
-afterAll(() => {
-  resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const routes = diagnosticsRouteDefinitions();
-const exportRoute = routes.find((r) => r.endpoint === "diagnostics/export")!;
-
-async function callExport(body: Record<string, unknown>): Promise<Response> {
-  const req = new Request("http://localhost/v1/diagnostics/export", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body),
-  });
-  const url = new URL(req.url);
-  return exportRoute.handler({
-    req,
-    url,
-    server: null as never,
-    authContext: {} as never,
-    params: {},
-  });
-}
-
-const db = () => getSqlite();
-
-function seedConversation(id: string): void {
-  const now = Date.now();
-  db().run(
-    "INSERT INTO conversations (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)",
-    [id, "Test", now, now],
-  );
-}
-
-function seedMessage(
-  id: string,
-  conversationId: string,
-  role: string,
-  content: string,
-  createdAt: number,
-): void {
-  db().run(
-    "INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)",
-    [id, conversationId, role, content, createdAt],
-  );
-}
-
-function seedLlmRequestLog(
-  id: string,
-  conversationId: string,
-  provider: string | null,
-  requestPayload: unknown,
-  responsePayload: unknown,
-  createdAt: number,
-): void {
-  db().run(
-    "INSERT INTO llm_request_logs (id, conversation_id, provider, request_payload, response_payload, created_at) VALUES (?, ?, ?, ?, ?, ?)",
-    [
-      id,
-      conversationId,
-      provider,
-      JSON.stringify(requestPayload),
-      JSON.stringify(responsePayload),
-      createdAt,
-    ],
-  );
-}
-
-function seedConversationKey(
-  conversationKey: string,
-  conversationId: string,
-): void {
-  db().run(
-    "INSERT INTO conversation_keys (id, conversation_key, conversation_id, created_at) VALUES (?, ?, ?, ?)",
-    [crypto.randomUUID(), conversationKey, conversationId, Date.now()],
-  );
-}
-
-function cleanDb(): void {
-  db().run("DELETE FROM messages");
-  db().run("DELETE FROM llm_request_logs");
-  db().run("DELETE FROM conversation_keys");
-  db().run("DELETE FROM conversations");
-}
-
-beforeEach(() => {
-  cleanDb();
-});
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("diagnostics export", () => {
-  test("returns 400 when conversationId is missing", async () => {
-    const res = await callExport({});
-    expect(res.status).toBe(400);
-  });
-
-  test("succeeds with specific anchorMessageId", async () => {
-    const convId = "conv-1";
-    const msgId = "msg-assistant-1";
-    const now = Date.now();
-
-    seedConversation(convId);
-    seedMessage("msg-user-1", convId, "user", "hello", now - 1000);
-    seedMessage(msgId, convId, "assistant", "world", now);
-
-    const res = await callExport({
-      conversationId: convId,
-      anchorMessageId: msgId,
-    });
-    expect(res.status).toBe(200);
-    const json = (await res.json()) as { success: boolean; filePath: string };
-    expect(json.success).toBe(true);
-    expect(json.filePath).toContain("diagnostics-");
-  });
-
-  test("falls back to most recent assistant message when anchorMessageId is omitted", async () => {
-    const convId = "conv-2";
-    const now = Date.now();
-
-    seedConversation(convId);
-    seedMessage("msg-user-1", convId, "user", "hello", now - 1000);
-    seedMessage("msg-assistant-1", convId, "assistant", "world", now);
-
-    const res = await callExport({ conversationId: convId });
-    expect(res.status).toBe(200);
-    const json = (await res.json()) as { success: boolean };
-    expect(json.success).toBe(true);
-  });
-
-  test("falls back to any message when no assistant messages exist (race condition fix)", async () => {
-    const convId = "conv-3";
-    const now = Date.now();
-
-    seedConversation(convId);
-    // Only a user message — assistant response hasn't been persisted yet
-    seedMessage("msg-user-1", convId, "user", "hello", now);
-
-    const res = await callExport({ conversationId: convId });
-    expect(res.status).toBe(200);
-    const json = (await res.json()) as { success: boolean; filePath: string };
-    expect(json.success).toBe(true);
-    expect(json.filePath).toContain("diagnostics-");
-  });
-
-  test("succeeds with empty conversation (no messages at all)", async () => {
-    const convId = "conv-4";
-
-    seedConversation(convId);
-    // No messages at all — conversation was just created
-
-    const res = await callExport({ conversationId: convId });
-    expect(res.status).toBe(200);
-    const json = (await res.json()) as { success: boolean; filePath: string };
-    expect(json.success).toBe(true);
-    expect(json.filePath).toContain("diagnostics-");
-  });
-
-  test("resolves conversation key to daemon conversation ID", async () => {
-    const daemonConvId = "conv-6-daemon";
-    const clientKey = "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE";
-    const now = Date.now();
-
-    seedConversation(daemonConvId);
-    seedConversationKey(clientKey, daemonConvId);
-    seedMessage("msg-user-6", daemonConvId, "user", "hello", now - 1000);
-    seedMessage("msg-assistant-6", daemonConvId, "assistant", "world", now);
-
-    // Client sends the conversation key (client-side UUID), not the daemon ID
-    const res = await callExport({ conversationId: clientKey });
-    expect(res.status).toBe(200);
-    const json = (await res.json()) as { success: boolean; filePath: string };
-    expect(json.success).toBe(true);
-    // The export should find the messages via the resolved daemon ID
-    expect(json.filePath).toContain("diagnostics-");
-  });
-
-  test("falls back to any-message when anchorMessageId is provided but not found", async () => {
-    const convId = "conv-5";
-    const now = Date.now();
-
-    seedConversation(convId);
-    seedMessage("msg-user-1", convId, "user", "hello", now);
-
-    // anchorMessageId doesn't exist — should fall through all the way
-    const res = await callExport({
-      conversationId: convId,
-      anchorMessageId: "nonexistent-msg-id",
-    });
-    expect(res.status).toBe(200);
-    const json = (await res.json()) as { success: boolean };
-    expect(json.success).toBe(true);
-  });
-
-  test("preserves llm request provider identity in the exported JSONL", async () => {
-    const convId = "conv-7";
-    const now = Date.now();
-
-    seedConversation(convId);
-    seedMessage("msg-user-7", convId, "user", "hello", now - 1000);
-    seedMessage("msg-assistant-7", convId, "assistant", "world", now);
-    seedLlmRequestLog(
-      "log-7",
-      convId,
-      "openrouter",
-      { model: "openai/gpt-4.1-mini", input: "hello" },
-      { output: "world" },
-      now,
-    );
-
-    const res = await callExport({ conversationId: convId });
-    expect(res.status).toBe(200);
-    const json = (await res.json()) as { success: boolean; filePath: string };
-    expect(json.success).toBe(true);
-
-    const zip = await JSZip.loadAsync(readFileSync(json.filePath));
-    const llmRequests = zip.file("llm_requests.jsonl");
-    expect(llmRequests).not.toBeNull();
-
-    const lines = (await llmRequests!.async("string")).trim().split("\n");
-    expect(lines).toHaveLength(1);
-
-    const row = JSON.parse(lines[0]) as {
-      id: string;
-      conversationId: string;
-      provider?: string | null;
-      request: unknown;
-      response: unknown;
-    };
-
-    expect(row).toMatchObject({
-      id: "log-7",
-      conversationId: convId,
-      provider: "openrouter",
-    });
-
-    rmSync(json.filePath, { force: true });
-  });
-});