@vellumai/assistant 0.4.53 → 0.4.54

package/src/__tests__/registry.test.ts

@@ -2,8 +2,6 @@ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
 import { RiskLevel } from "../permissions/types.js";
 import type { ToolDefinition } from "../providers/types.js";
-// We cannot import the private LazyTool class directly, so we test through
-// registerLazyTool + getTool which exercise the same code path.
 import {
   __clearRegistryForTesting,
   __resetRegistryForTesting,
@@ -13,16 +11,11 @@ import {
   getSkillToolNames,
   getTool,
   initializeTools,
-  registerLazyTool,
   registerSkillTools,
   registerTool,
   unregisterSkillTools,
 } from "../tools/registry.js";
-import {
-  eagerModuleToolNames,
-  explicitTools,
-  lazyTools,
-} from "../tools/tool-manifest.js";
+import { eagerModuleToolNames, explicitTools } from "../tools/tool-manifest.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
 
 // Clean up global registry after this file completes to prevent
@@ -61,48 +54,6 @@ function makeSkillTool(name: string, ownerSkillId: string): Tool {
   };
 }
 
-describe("LazyTool", () => {
-  test("clears cached promise on load failure so subsequent call can retry", async () => {
-    let callCount = 0;
-
-    registerLazyTool({
-      name: "test-retry-tool",
-      description: "A tool that fails on first load then succeeds",
-      category: "test",
-      defaultRiskLevel: RiskLevel.Low,
-      definition: {
-        name: "test-retry-tool",
-        description: "A tool that fails on first load then succeeds",
-        input_schema: { type: "object", properties: {}, required: [] },
-      },
-      loader: async () => {
-        callCount++;
-        if (callCount === 1) {
-          throw new Error("transient load failure");
-        }
-        return makeFakeTool("test-retry-tool");
-      },
-    });
-
-    const tool = getTool("test-retry-tool")!;
-    expect(tool).toBeDefined();
-
-    const dummyContext = {} as ToolContext;
-
-    // First call should throw the transient error
-    await expect(tool.execute({}, dummyContext)).rejects.toThrow(
-      "transient load failure",
-    );
-    expect(callCount).toBe(1);
-
-    // Second call should retry the loader and succeed
-    const result = await tool.execute({}, dummyContext);
-    expect(result.content).toBe("ok");
-    expect(result.isError).toBe(false);
-    expect(callCount).toBe(2);
-  });
-});
-
 describe("tool registry host tools", () => {
   test("registers host tools and exposes them in tool definitions", async () => {
     await initializeTools();
@@ -157,29 +108,6 @@ describe("tool registry dynamic-tools tools", () => {
 });
 
 describe("tool manifest", () => {
-  test("all manifest lazy tools are registered after init", async () => {
-    await initializeTools();
-    const registered = new Set(getAllTools().map((t) => t.name));
-
-    for (const descriptor of lazyTools) {
-      expect(registered.has(descriptor.name)).toBe(true);
-    }
-  });
-
-  test("manifest declares expected core lazy tools", () => {
-    // bash moved from lazy to eager registration
-    // swarm_delegate moved to the orchestration bundled skill
-    const lazyNames = new Set(lazyTools.map((t) => t.name));
-    expect(lazyNames.has("bash")).toBe(false);
-    expect(lazyNames.has("evaluate_typescript_code")).toBe(false);
-    expect(lazyNames.has("claude_code")).toBe(false);
-    expect(lazyNames.has("swarm_delegate")).toBe(false);
-    // bash is in eager tools; swarm_delegate is now a bundled skill tool
-    expect(eagerModuleToolNames).toContain("bash");
-    expect(eagerModuleToolNames).not.toContain("swarm_delegate");
-    expect(eagerModuleToolNames).not.toContain("version");
-  });
-
   test("eager module tool names list contains expected count", () => {
     expect(eagerModuleToolNames.length).toBe(11);
   });
@@ -193,12 +121,10 @@ describe("tool manifest", () => {
     expect(names).not.toContain("start_screen_watch");
   });
 
-  test("registered tool count is at least eager + lazy + host", async () => {
+  test("registered tool count is at least eager + host", async () => {
     await initializeTools();
     const tools = getAllTools();
-    expect(tools.length).toBeGreaterThanOrEqual(
-      eagerModuleToolNames.length + lazyTools.length,
-    );
+    expect(tools.length).toBeGreaterThanOrEqual(eagerModuleToolNames.length);
   });
 });
 
@@ -253,11 +179,6 @@ describe("baseline characterization: hardcoded tool loading", () => {
     const tool = getTool("claude_code");
     expect(tool).toBeUndefined();
   });
-
-  test("claude_code is NOT in lazyTools manifest", () => {
-    const lazyNames = lazyTools.map((t) => t.name);
-    expect(lazyNames).not.toContain("claude_code");
-  });
 });
 
 describe("baseline characterization: core app tool surface", () => {
@@ -505,24 +426,3 @@ describe("skill tool reference counting", () => {
     expect(getSkillRefCount("nonexistent-skill")).toBe(0);
   });
 });
-
-describe("computer-use registration split", () => {
-  // Start each test from a completely empty registry so assertions are
-  // non-vacuous — the split functions must actually register tools.
-
-  test("registerComputerUseActionTools registers all 11 CU action tools and nothing else", async () => {
-    const { registerComputerUseActionTools } =
-      await import("../tools/computer-use/registry.js");
-
-    __clearRegistryForTesting();
-    expect(getAllTools()).toHaveLength(0);
-
-    registerComputerUseActionTools();
-
-    const registered = getAllTools();
-    expect(registered).toHaveLength(11);
-    expect(registered.every((t) => t.name.startsWith("computer_use_"))).toBe(
-      true,
-    );
-  });
-});

package/src/__tests__/script-proxy-injection-runtime.test.ts

@@ -27,21 +27,16 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
   listCredentialMetadata: () => credentialMetadataList,
 }));
 
-// Track getSecureKey return values per storage key
+// Track getSecureKeyAsync return values per storage key
 let secureKeyValues = new Map<string, string | undefined>();
 
 mock.module("../security/secure-keys.js", () => ({
-  getSecureKey: (account: string) => secureKeyValues.get(account),
   getSecureKeyAsync: (account: string) =>
     Promise.resolve(secureKeyValues.get(account)),
-  setSecureKey: () => true,
   setSecureKeyAsync: () => Promise.resolve(true),
-  deleteSecureKey: () => "deleted",
   deleteSecureKeyAsync: () => Promise.resolve("deleted"),
-  listSecureKeys: () => [],
-  getBackendType: () => "encrypted",
+  listSecureKeysAsync: async () => [],
   _resetBackend: () => {},
-  _setBackend: () => {},
 }));
 
 // Stub ensureLocalCA / certs so tests never run openssl

package/src/__tests__/secret-onetime-send.test.ts

@@ -42,16 +42,11 @@ mock.module("../security/secure-keys.js", () => {
     return "not-found" as const;
   };
   return {
-    getSecureKey: (key: string) => storedKeys.get(key) ?? null,
     getSecureKeyAsync: async (key: string) => storedKeys.get(key) ?? undefined,
-    setSecureKey: syncSet,
     setSecureKeyAsync: async (key: string, value: string) =>
       syncSet(key, value),
-    deleteSecureKey: syncDelete,
     deleteSecureKeyAsync: async (key: string) => syncDelete(key),
-    listSecureKeys: () => [],
-    getBackendType: () => "encrypted",
-    isDowngradedFromKeychain: () => false,
+    listSecureKeysAsync: async () => [],
   };
 });
 

package/src/__tests__/secret-routes-managed-proxy.test.ts

@@ -9,13 +9,7 @@ const metadataDeletes: Array<{ service: string; field: string }> = [];
 
 const PLATFORM_BASE_URL = "https://platform.example.com";
 const ASSISTANT_API_KEY_PATH = credentialKey("vellum", "assistant_api_key");
-const MANAGED_PROVIDERS = [
-  "anthropic",
-  "openai",
-  "gemini",
-  "fireworks",
-  "openrouter",
-] as const;
+const MANAGED_PROVIDERS = ["anthropic", "gemini"] as const;
 
 const mockConfig = {
   provider: "anthropic",
@@ -66,7 +60,6 @@ mock.module("../logfire.js", () => ({
 }));
 
 mock.module("../security/secure-keys.js", () => ({
-  getSecureKey: (key: string) => secureKeyStore[key],
   getSecureKeyAsync: async (key: string) => secureKeyStore[key],
   setSecureKeyAsync: async (key: string, value: string) => {
     secureKeyStore[key] = value;
@@ -129,15 +122,15 @@ function makeDeleteCredentialRequest(name: string): Request {
 }
 
 describe("secret routes managed proxy registry sync", () => {
-  beforeEach(() => {
+  beforeEach(async () => {
     secureKeyStore = {};
     metadataUpserts.length = 0;
     metadataDeletes.length = 0;
     lastGeminiConstructorOpts = null;
-    initializeProviders(mockConfig);
+    await initializeProviders(mockConfig);
   });
 
-  test("adding vellum:assistant_api_key bootstraps managed providers immediately", async () => {
+  test("adding vellum:assistant_api_key bootstraps managed fallback providers immediately", async () => {
     expect(listProviders()).toEqual([]);
 
     const res = await handleAddSecret(
@@ -159,9 +152,9 @@ describe("secret routes managed proxy registry sync", () => {
     expect(lastGeminiConstructorOpts).toBeDefined();
   });
 
-  test("deleting vellum:assistant_api_key clears managed providers immediately", async () => {
+  test("deleting vellum:assistant_api_key clears managed fallback providers immediately", async () => {
     secureKeyStore[ASSISTANT_API_KEY_PATH] = "ast-managed-key";
-    initializeProviders(mockConfig);
+    await initializeProviders(mockConfig);
 
     for (const provider of MANAGED_PROVIDERS) {
       expect(listProviders()).toContain(provider);