@vellumai/assistant 0.4.52 → 0.4.54

package/src/__tests__/provider-managed-proxy-integration.test.ts

@@ -39,17 +39,18 @@ mock.module("@google/genai", () => ({
 // ---------------------------------------------------------------------------
 let mockPlatformBaseUrl = "";
 let mockAssistantApiKey: string | null = null;
+let mockProviderKeys: Record<string, string> = {};
 
 mock.module("../config/env.js", () => ({
   getPlatformBaseUrl: () => mockPlatformBaseUrl,
 }));
 
 mock.module("../security/secure-keys.js", () => ({
-  getSecureKey: (key: string) => {
+  getSecureKeyAsync: async (key: string) => {
     if (key === credentialKey("vellum", "assistant_api_key")) {
       return mockAssistantApiKey;
     }
-    return null;
+    return mockProviderKeys[key] ?? null;
   },
 }));
 
@@ -67,13 +68,14 @@ import {
 const PLATFORM_BASE = "https://platform.example.com";
 const MANAGED_API_KEY = "ast-managed-key-123";
 
-const MANAGED_PROVIDERS: string[] = [
+const DIRECT_OR_MANAGED_PROVIDER_KEYS: string[] = [
   "openai",
   "anthropic",
   "gemini",
   "fireworks",
   "openrouter",
 ];
+const MANAGED_FALLBACK_PROVIDERS: string[] = ["anthropic", "gemini"];
 
 function enableManagedProxy() {
   mockPlatformBaseUrl = PLATFORM_BASE;
@@ -86,14 +88,13 @@ function disableManagedProxy() {
 }
 
 /**
- * Build an apiKeys record with a user key for every provider in `names`.
+ * Set mock secure keys with a user key for every provider in `names`.
  */
-function userKeysFor(...names: string[]): Record<string, string> {
-  const keys: Record<string, string> = {};
+function setUserKeysFor(...names: string[]): void {
+  mockProviderKeys = {};
   for (const n of names) {
-    keys[n] = `user-key-${n}`;
+    mockProviderKeys[n] = `user-key-${n}`;
   }
-  return keys;
 }
 
 // ---------------------------------------------------------------------------
@@ -102,17 +103,18 @@ function userKeysFor(...names: string[]): Record<string, string> {
 
 beforeEach(() => {
   disableManagedProxy();
+  mockProviderKeys = {};
   lastGeminiConstructorOpts = null;
 });
 
 describe("managed proxy integration — credential precedence", () => {
   describe("user keys present → providers use direct connections (not proxy)", () => {
-    test.each(MANAGED_PROVIDERS)(
+    test.each(DIRECT_OR_MANAGED_PROVIDER_KEYS)(
       "%s routes via user-key when user key is provided regardless of managed context",
-      (provider: string) => {
+      async (provider: string) => {
         enableManagedProxy();
-        initializeProviders({
-          apiKeys: userKeysFor(provider),
+        setUserKeysFor(provider);
+        await initializeProviders({
           provider,
           model: "test-model",
         });
@@ -121,29 +123,29 @@ describe("managed proxy integration — credential precedence", () => {
       },
     );
 
-    test("all five managed providers route via user-key with user keys", () => {
+    test("all five configured providers route via user-key when user keys exist", async () => {
       enableManagedProxy();
-      initializeProviders({
-        apiKeys: userKeysFor(...MANAGED_PROVIDERS),
+      setUserKeysFor(...DIRECT_OR_MANAGED_PROVIDER_KEYS);
+      await initializeProviders({
         provider: "anthropic",
         model: "test-model",
       });
       const registered = listProviders();
-      for (const p of MANAGED_PROVIDERS) {
+      for (const p of DIRECT_OR_MANAGED_PROVIDER_KEYS) {
         expect(registered).toContain(p);
         expect(getProviderRoutingSource(p)).toBe("user-key");
       }
     });
 
-    test("user keys still route via user-key when managed context is disabled", () => {
+    test("user keys still route via user-key when managed context is disabled", async () => {
       disableManagedProxy();
-      initializeProviders({
-        apiKeys: userKeysFor(...MANAGED_PROVIDERS),
+      setUserKeysFor(...DIRECT_OR_MANAGED_PROVIDER_KEYS);
+      await initializeProviders({
         provider: "anthropic",
         model: "test-model",
       });
       const registered = listProviders();
-      for (const p of MANAGED_PROVIDERS) {
+      for (const p of DIRECT_OR_MANAGED_PROVIDER_KEYS) {
         expect(registered).toContain(p);
         expect(getProviderRoutingSource(p)).toBe("user-key");
       }
@@ -151,14 +153,13 @@ describe("managed proxy integration — credential precedence", () => {
   });
 
   describe("user keys absent + managed context available → providers use managed proxy", () => {
-    test.each(MANAGED_PROVIDERS)(
+    test.each(MANAGED_FALLBACK_PROVIDERS)(
       "%s routes via managed-proxy when no user key",
-      (provider: string) => {
+      async (provider: string) => {
         enableManagedProxy();
-        initializeProviders({
-          apiKeys: {},
-          // For ollama, provider selection does not trigger managed proxy
-          provider: provider === "openai" ? "openai" : "anthropic",
+        mockProviderKeys = {};
+        await initializeProviders({
+          provider: "anthropic",
           model: "test-model",
         });
         expect(listProviders()).toContain(provider);
@@ -166,24 +167,25 @@ describe("managed proxy integration — credential precedence", () => {
       },
     );
 
-    test("all five managed providers route via managed-proxy simultaneously", () => {
+    test("managed bootstrap registers anthropic and gemini only", async () => {
       enableManagedProxy();
-      initializeProviders({
-        apiKeys: {},
+      mockProviderKeys = {};
+      await initializeProviders({
         provider: "anthropic",
         model: "test-model",
       });
-      const registered = listProviders();
-      for (const p of MANAGED_PROVIDERS) {
-        expect(registered).toContain(p);
-        expect(getProviderRoutingSource(p)).toBe("managed-proxy");
+      expect(listProviders()).toEqual(["anthropic", "gemini"]);
+      expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+      for (const p of ["openai", "fireworks", "openrouter"]) {
+        expect(getProviderRoutingSource(p)).toBeUndefined();
       }
     });
 
-    test("managed anthropic uses vertex proxy path instead of anthropic proxy path", () => {
+    test("managed anthropic uses anthropic proxy path", async () => {
       enableManagedProxy();
-      initializeProviders({
-        apiKeys: {},
+      mockProviderKeys = {};
+      await initializeProviders({
         provider: "anthropic",
         model: "claude-opus-4-6",
       });
@@ -200,20 +202,17 @@ describe("managed proxy integration — credential precedence", () => {
 
       expect(anthropicClient).toBeDefined();
       const baseURL: string = anthropicClient.baseURL;
-      expect(baseURL).toContain("/v1/runtime-proxy/vertex");
-      expect(baseURL).not.toContain("/v1/runtime-proxy/anthropic");
+      expect(baseURL).toContain("/v1/runtime-proxy/anthropic");
     });
 
-    test("managed gemini uses vertex proxy path instead of gemini proxy path", () => {
+    test("managed gemini uses vertex proxy path", async () => {
       enableManagedProxy();
-      initializeProviders({
-        apiKeys: {},
+      mockProviderKeys = {};
+      await initializeProviders({
         provider: "anthropic",
         model: "test-model",
       });
 
-      // The GoogleGenAI constructor was captured by the mock — verify it
-      // received httpOptions.baseUrl pointing at the vertex proxy path.
       expect(lastGeminiConstructorOpts).toBeDefined();
       const httpOptions = lastGeminiConstructorOpts!.httpOptions as
         | { baseUrl?: string }
@@ -225,12 +224,12 @@ describe("managed proxy integration — credential precedence", () => {
   });
 
   describe("neither user keys nor managed context → providers not initialized", () => {
-    test.each(MANAGED_PROVIDERS)(
+    test.each(DIRECT_OR_MANAGED_PROVIDER_KEYS)(
       "%s is NOT registered when no user key and no managed context",
-      (provider: string) => {
+      async (provider: string) => {
         disableManagedProxy();
-        initializeProviders({
-          apiKeys: {},
+        mockProviderKeys = {};
+        await initializeProviders({
           provider: "anthropic",
           model: "test-model",
         });
@@ -239,10 +238,10 @@ describe("managed proxy integration — credential precedence", () => {
       },
     );
 
-    test("registry is empty when no keys and no managed context (non-ollama primary)", () => {
+    test("registry is empty when no keys and no managed context (non-ollama primary)", async () => {
       disableManagedProxy();
-      initializeProviders({
-        apiKeys: {},
+      mockProviderKeys = {};
+      await initializeProviders({
         provider: "anthropic",
         model: "test-model",
       });
@@ -251,65 +250,71 @@ describe("managed proxy integration — credential precedence", () => {
   });
 
   describe("mixed: some user keys + managed fallback fills gaps", () => {
-    test("user key for anthropic routes direct, managed fallback fills remaining four via proxy", () => {
+    test("user key for anthropic routes direct and managed fallback only fills gemini", async () => {
       enableManagedProxy();
-      initializeProviders({
-        apiKeys: userKeysFor("anthropic"),
+      setUserKeysFor("anthropic");
+      await initializeProviders({
         provider: "anthropic",
         model: "test-model",
       });
       const registered = listProviders();
       expect(registered).toContain("anthropic");
       expect(getProviderRoutingSource("anthropic")).toBe("user-key");
-      for (const p of ["openai", "gemini", "fireworks", "openrouter"]) {
-        expect(registered).toContain(p);
-        expect(getProviderRoutingSource(p)).toBe("managed-proxy");
+      expect(registered).toContain("gemini");
+      expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+      for (const p of ["openai", "fireworks", "openrouter"]) {
+        expect(registered).not.toContain(p);
+        expect(getProviderRoutingSource(p)).toBeUndefined();
       }
     });
 
-    test("user key for openai routes direct, managed fallback fills remaining four via proxy", () => {
+    test("user key for openai routes direct while anthropic and gemini still bootstrap via managed proxy", async () => {
       enableManagedProxy();
-      initializeProviders({
-        apiKeys: userKeysFor("openai"),
+      setUserKeysFor("openai");
+      await initializeProviders({
         provider: "openai",
         model: "test-model",
       });
       const registered = listProviders();
       expect(registered).toContain("openai");
       expect(getProviderRoutingSource("openai")).toBe("user-key");
-      for (const p of ["anthropic", "gemini", "fireworks", "openrouter"]) {
-        expect(registered).toContain(p);
-        expect(getProviderRoutingSource(p)).toBe("managed-proxy");
+      expect(registered).toContain("anthropic");
+      expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
+      expect(registered).toContain("gemini");
+      expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+      for (const p of ["fireworks", "openrouter"]) {
+        expect(registered).not.toContain(p);
+        expect(getProviderRoutingSource(p)).toBeUndefined();
       }
     });
   });
 });
 
 describe("managed proxy integration — ollama exclusion", () => {
-  test("ollama is never registered via managed proxy fallback", () => {
+  test("ollama is never registered via managed proxy fallback", async () => {
     enableManagedProxy();
-    initializeProviders({
-      apiKeys: {},
+    mockProviderKeys = {};
+    await initializeProviders({
       provider: "anthropic",
       model: "test-model",
     });
     expect(listProviders()).not.toContain("ollama");
   });
 
-  test("ollama registers only when explicitly configured as provider", () => {
+  test("ollama registers only when explicitly configured as provider", async () => {
     enableManagedProxy();
-    initializeProviders({
-      apiKeys: {},
+    mockProviderKeys = {};
+    await initializeProviders({
       provider: "ollama",
       model: "test-model",
     });
     expect(listProviders()).toContain("ollama");
   });
 
-  test("ollama registers with explicit API key", () => {
+  test("ollama registers with explicit API key", async () => {
     enableManagedProxy();
-    initializeProviders({
-      apiKeys: { ollama: "ollama-key" },
+    mockProviderKeys = { ollama: "ollama-key" };
+    await initializeProviders({
       provider: "anthropic",
       model: "test-model",
     });
@@ -325,8 +330,8 @@ describe("managed proxy integration — ollama exclusion", () => {
 });
 
 describe("managed proxy integration — constants integrity", () => {
-  test("all five managed providers have metadata with managed=true and a proxyPath", () => {
-    for (const provider of MANAGED_PROVIDERS) {
+  test("anthropic, gemini, and vertex have metadata with managed=true and a proxyPath", () => {
+    for (const provider of ["anthropic", "gemini", "vertex"]) {
       const meta = MANAGED_PROVIDER_META[provider];
       expect(meta).toBeDefined();
       expect(meta.managed).toBe(true);
@@ -335,24 +340,22 @@ describe("managed proxy integration — constants integrity", () => {
     }
   });
 
-  test("anthropic and gemini route through vertex proxy path", () => {
+  test("anthropic routes through anthropic proxy path", () => {
     expect(MANAGED_PROVIDER_META.anthropic.proxyPath).toBe(
-      "/v1/runtime-proxy/vertex",
+      "/v1/runtime-proxy/anthropic",
     );
+  });
+
+  test("gemini routes through vertex proxy path", () => {
     expect(MANAGED_PROVIDER_META.gemini.proxyPath).toBe(
       "/v1/runtime-proxy/vertex",
     );
   });
 
-  test("other providers use their own proxy paths", () => {
-    expect(MANAGED_PROVIDER_META.openai.proxyPath).toBe(
-      "/v1/runtime-proxy/openai",
-    );
-    expect(MANAGED_PROVIDER_META.fireworks.proxyPath).toBe(
-      "/v1/runtime-proxy/fireworks",
-    );
-    expect(MANAGED_PROVIDER_META.openrouter.proxyPath).toBe(
-      "/v1/runtime-proxy/openrouter",
-    );
+  test("openai-compatible providers are not managed proxy capable", () => {
+    for (const provider of ["openai", "fireworks", "openrouter"]) {
+      expect(MANAGED_PROVIDER_META[provider].managed).toBe(false);
+      expect(MANAGED_PROVIDER_META[provider].proxyPath).toBeUndefined();
+    }
   });
 });

package/src/__tests__/provider-registry-ollama.test.ts

@@ -1,4 +1,11 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+// Mock secure-keys so tests don't depend on the developer's local secure storage.
+const actualSecureKeys = await import("../security/secure-keys.js");
+mock.module("../security/secure-keys.js", () => ({
+  ...actualSecureKeys,
+  getSecureKeyAsync: async () => undefined,
+}));
 
 import {
   getProvider,
@@ -7,9 +14,8 @@ import {
 } from "../providers/registry.js";
 
 describe("provider registry (ollama)", () => {
-  test("registers ollama when selected provider has no API key", () => {
-    initializeProviders({
-      apiKeys: {},
+  test("registers ollama when selected provider has no API key", async () => {
+    await initializeProviders({
       provider: "ollama",
       model: "claude-opus-4-6",
     });

package/src/__tests__/public-ingress-urls.test.ts

@@ -98,7 +98,7 @@ describe("getPublicBaseUrl", () => {
     ).toThrow(/Public ingress is disabled/);
   });
 
-  test("returns URL when enabled is undefined (backward compat)", () => {
+  test("returns URL when enabled is undefined", () => {
     const result = getPublicBaseUrl({
       ingress: { enabled: undefined, publicBaseUrl: "https://example.com" },
     });

package/src/__tests__/recording-handler.test.ts

@@ -24,7 +24,6 @@ mock.module("../config/loader.js", () => ({
     daemon: { standaloneRecording: true },
     provider: "mock-provider",
     permissions: { mode: "workspace" },
-    apiKeys: {},
     sandbox: { enabled: false },
     timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },
     skills: { load: { extraDirs: [] } },

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__/relay-server.test.ts

@@ -88,7 +88,6 @@ mock.module("../prompts/user-reference.js", () => ({
 const mockConfig = {
   provider: "anthropic",
   providerOrder: ["anthropic"],
-  apiKeys: { anthropic: "test-key" },
   secretDetection: { enabled: false },
   calls: {
     enabled: true,

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -42,7 +42,6 @@ mock.module("../config/loader.js", () => ({
 
     model: "test",
     provider: "test",
-    apiKeys: {},
     memory: { enabled: false },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
   }),

package/src/__tests__/runtime-events-sse-parity.test.ts

@@ -49,7 +49,6 @@ mock.module("../config/loader.js", () => ({
 
     model: "test",
     provider: "test",
-    apiKeys: {},
     memory: { enabled: false },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     secretDetection: { enabled: false },

package/src/__tests__/runtime-events-sse.test.ts

@@ -41,7 +41,6 @@ mock.module("../config/loader.js", () => ({
 
     model: "test",
     provider: "test",
-    apiKeys: {},
     memory: { enabled: false },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     secretDetection: { enabled: false },

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 () => [],
   };
 });