@vellumai/assistant 0.5.7 → 0.5.8

package/src/__tests__/memory-retrieval.benchmark.test.ts

@@ -197,7 +197,6 @@ describe("Memory retrieval benchmark", () => {
     expect(recall.enabled).toBe(true);
     expect(recall.degraded).toBe(false);
     // Recency search finds conversation-scoped segments
-    expect(recall.recencyHits).toBeGreaterThan(0);
     // Relaxed threshold — guards against severe regressions, not precise benchmarking
     expect(recall.latencyMs).toBeLessThan(500);
   });
@@ -216,7 +215,6 @@ describe("Memory retrieval benchmark", () => {
 
     expect(recall.enabled).toBe(true);
     expect(recall.degraded).toBe(false);
-    expect(recall.recencyHits).toBeGreaterThan(0);
     expect(recall.latencyMs).toBeLessThan(1000);
   });
 
@@ -234,7 +232,6 @@ describe("Memory retrieval benchmark", () => {
 
     expect(recall.enabled).toBe(true);
     expect(recall.degraded).toBe(false);
-    expect(recall.recencyHits).toBeGreaterThan(0);
     expect(recall.latencyMs).toBeLessThan(2000);
   });
 

package/src/__tests__/non-member-access-request.test.ts

@@ -186,7 +186,7 @@ describe("non-member access request notification", () => {
     expect(deliverReplyCalls.length).toBe(1);
     expect(
       (deliverReplyCalls[0].payload as Record<string, unknown>).text,
-    ).toContain("let them know");
+    ).toContain("know you tried talking to me");
   });
 
   test("guardian is notified when a non-member messages and a guardian binding exists", async () => {
@@ -285,7 +285,7 @@ describe("non-member access request notification", () => {
     expect(deliverReplyCalls.length).toBe(1);
     expect(
       (deliverReplyCalls[0].payload as Record<string, unknown>).text,
-    ).toContain("let them know");
+    ).toContain("know you tried talking to me");
 
     // Notification signal was emitted
     expect(emitSignalCalls.length).toBe(1);

package/src/__tests__/notification-decision-strategy.test.ts

@@ -18,6 +18,7 @@ import {
   hasInviteFlowDirective,
   normalizeForDirectiveMatching,
   sanitizeIdentityField,
+  sanitizeMessagePreview,
 } from "../notifications/copy-composer.js";
 import {
   enforceGuardianCallConversationAffinity,
@@ -596,6 +597,31 @@ describe("notification decision strategy", () => {
     });
   });
 
+  describe("access-request message preview sanitization", () => {
+    test("strips control characters from message previews", () => {
+      expect(sanitizeMessagePreview("Hello\nWorld")).toBe("Hello World");
+      expect(sanitizeMessagePreview("Test\r\nMessage")).toBe("Test Message");
+    });
+
+    test("clamps to 200 characters (not 120)", () => {
+      const longMessage = "A".repeat(250);
+      const result = sanitizeMessagePreview(longMessage);
+      expect(result.length).toBeLessThanOrEqual(201); // 200 + '…'
+      expect(result).toEndWith("…");
+
+      // Verify it allows messages longer than the identity field limit (120)
+      const midMessage = "B".repeat(150);
+      const midResult = sanitizeMessagePreview(midMessage);
+      expect(midResult).toBe(midMessage); // no truncation at 150 chars
+    });
+
+    test("preserves normal messages", () => {
+      expect(sanitizeMessagePreview("Hello, can you help me?")).toBe(
+        "Hello, can you help me?",
+      );
+    });
+  });
+
   describe("access-request identity line builder", () => {
     test("builds voice identity line with caller name and phone", () => {
       const line = buildAccessRequestIdentityLine({
@@ -627,6 +653,51 @@ describe("notification decision strategy", () => {
       expect(line).toContain("requesting access");
     });
 
+    test("uses <@U...> mention format for Slack external IDs", () => {
+      const line = buildAccessRequestIdentityLine({
+        senderIdentifier: "Alice",
+        actorExternalId: "U04BTP01B2S",
+        sourceChannel: "slack",
+      });
+      expect(line).toContain("<@U04BTP01B2S>");
+      expect(line).not.toContain("[U04BTP01B2S]");
+      expect(line).toContain("via slack");
+    });
+
+    test("does not use <@U...> format for non-Slack channels", () => {
+      const line = buildAccessRequestIdentityLine({
+        senderIdentifier: "Alice",
+        actorExternalId: "U04BTP01B2S",
+        sourceChannel: "telegram",
+      });
+      expect(line).toContain("[U04BTP01B2S]");
+      expect(line).not.toContain("<@U04BTP01B2S>");
+    });
+
+    test("does not duplicate Slack mention when senderIdentifier equals raw external ID", () => {
+      // When actorDisplayName and actorUsername are missing, senderIdentifier
+      // falls back to the raw actorExternalId. The identity line should produce
+      // exactly one <@U...> mention, not two.
+      const line = buildAccessRequestIdentityLine({
+        senderIdentifier: "U04BTP01B2S",
+        actorExternalId: "U04BTP01B2S",
+        sourceChannel: "slack",
+      });
+      const mentionCount = (line.match(/<@U04BTP01B2S>/g) || []).length;
+      expect(mentionCount).toBe(1);
+      expect(line).toContain("via slack");
+    });
+
+    test("does not use <@U...> format for non-user-ID external IDs on Slack", () => {
+      const line = buildAccessRequestIdentityLine({
+        senderIdentifier: "Alice",
+        actorExternalId: "someone@example.com",
+        sourceChannel: "slack",
+      });
+      expect(line).not.toContain("<@someone@example.com>");
+      expect(line).toContain("[someone@example.com]");
+    });
+
     test("sanitizes adversarial display names", () => {
       const line = buildAccessRequestIdentityLine({
         senderIdentifier: "Alice",

package/src/__tests__/oauth-cli.test.ts

@@ -155,6 +155,10 @@ mock.module("../oauth/oauth-store.js", () => ({
 // Stub out transitive dependencies that token-manager would normally pull in
 mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (account: string) => mockGetSecureKey(account),
+  getSecureKeyResultAsync: async (account: string) => ({
+    value: mockGetSecureKey(account),
+    unreachable: false,
+  }),
   setSecureKeyAsync: async () => true,
   deleteSecureKeyAsync: async (account: string) => {
     if (secureKeyStore.has(account)) {
@@ -163,7 +167,7 @@ mock.module("../security/secure-keys.js", () => ({
     }
     return "not-found" as const;
   },
-  listSecureKeysAsync: async () => [...secureKeyStore.keys()],
+  listSecureKeysAsync: async () => ({ accounts: [...secureKeyStore.keys()], unreachable: false }),
   _resetBackend: () => {},
 }));
 

package/src/__tests__/provider-commit-message-generator.test.ts

@@ -69,13 +69,9 @@ const mockProvider: Provider = {
 let resolvedProvider: {
   provider: Provider;
   configuredProviderName: string;
-  selectedProviderName: string;
-  usedFallbackPrimary: boolean;
 } | null = {
   provider: mockProvider,
   configuredProviderName: "anthropic",
-  selectedProviderName: "anthropic",
-  usedFallbackPrimary: false,
 };
 
 mock.module("../providers/provider-send-message.js", () => ({
@@ -130,8 +126,6 @@ describe("ProviderCommitMessageGenerator", () => {
     resolvedProvider = {
       provider: mockProvider,
       configuredProviderName: "anthropic",
-      selectedProviderName: "anthropic",
-      usedFallbackPrimary: false,
     };
   });
 
@@ -343,8 +337,6 @@ describe("ProviderCommitMessageGenerator", () => {
     resolvedProvider = {
       provider: mockProvider,
       configuredProviderName: "ollama",
-      selectedProviderName: "ollama",
-      usedFallbackPrimary: false,
     };
     const gen = getCommitMessageGenerator();
     const result = await gen.generateCommitMessage(baseContext, {
@@ -364,8 +356,6 @@ describe("ProviderCommitMessageGenerator", () => {
     resolvedProvider = {
       provider: mockProvider,
       configuredProviderName: "exotic-provider",
-      selectedProviderName: "exotic-provider",
-      usedFallbackPrimary: false,
     };
     const gen = getCommitMessageGenerator();
     const result = await gen.generateCommitMessage(baseContext, {
@@ -383,8 +373,6 @@ describe("ProviderCommitMessageGenerator", () => {
     resolvedProvider = {
       provider: mockProvider,
       configuredProviderName: "ollama",
-      selectedProviderName: "ollama",
-      usedFallbackPrimary: false,
     };
     currentConfig.workspaceGit.commitMessageLLM.providerFastModelOverrides = {
       ollama: "llama3.2:3b",
@@ -404,29 +392,4 @@ describe("ProviderCommitMessageGenerator", () => {
     expect(options.config.model).toBe("llama3.2:3b");
   });
 
-  // 15. Fail-open fallback provider uses fallback provider's fast-model mapping
-  test("configured provider unavailable -> selected fallback provider model mapping is used", async () => {
-    currentConfig.services.inference.provider = "anthropic";
-    currentConfig.providerOrder = ["openai"];
-    mockSecureKeys = { openai: "sk-openai" };
-    resolvedProvider = {
-      provider: mockProvider,
-      configuredProviderName: "anthropic",
-      selectedProviderName: "openai",
-      usedFallbackPrimary: true,
-    };
-    mockSendMessage.mockResolvedValueOnce(
-      makeSuccessResponse("fix: fail-open commit"),
-    );
-
-    const gen = getCommitMessageGenerator();
-    const result = await gen.generateCommitMessage(baseContext, {
-      changedFiles: baseContext.changedFiles,
-    });
-
-    expect(result.source).toBe("llm");
-    const callArgs = mockSendMessage.mock.calls[0];
-    const options = callArgs[3] as { config: { model: string } };
-    expect(options.config.model).toBe("gpt-4o-mini");
-  });
 });

package/src/__tests__/provider-error-scenarios.test.ts

@@ -107,7 +107,6 @@ mock.module("../util/retry.js", () => {
   };
 });
 
-import { FailoverProvider } from "../providers/failover.js";
 import { RetryProvider } from "../providers/retry.js";
 import { createStreamTimeout } from "../providers/stream-timeout.js";
 import type {
@@ -139,18 +138,6 @@ function successResponse(
   };
 }
 
-function makeProvider(name = "mock"): Provider & { calls: number } {
-  const p = {
-    name,
-    calls: 0,
-    async sendMessage(): Promise<ProviderResponse> {
-      p.calls++;
-      return successResponse();
-    },
-  };
-  return p;
-}
-
 /** Provider that fails N times then succeeds. */
 function makeFlaky(
   failCount: number,
@@ -646,220 +633,6 @@ describe("RetryProvider — streaming response handling", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// FailoverProvider — model unavailability fallback
-// ---------------------------------------------------------------------------
-
-describe("FailoverProvider — model unavailability fallback", () => {
-  test("falls back to secondary when primary returns 500", async () => {
-    const primary = makeFailing(
-      new ProviderError("down", "primary", 500),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    const result = await provider.sendMessage(MESSAGES);
-
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(1);
-    expect(result.stopReason).toBe("end_turn");
-  });
-
-  test("falls back to secondary when primary returns 429", async () => {
-    const primary = makeFailing(
-      new ProviderError("rate limited", "primary", 429),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    const result = await provider.sendMessage(MESSAGES);
-
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(1);
-    expect(result.model).toBe("test-model");
-  });
-
-  test("falls back on ECONNREFUSED network error", async () => {
-    const err = new Error("connection refused");
-    (err as NodeJS.ErrnoException).code = "ECONNREFUSED";
-    const primary = makeFailing(err, "primary");
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    const result = await provider.sendMessage(MESSAGES);
-
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(1);
-    expect(result.content[0]).toMatchObject({ type: "text", text: "ok" });
-  });
-
-  test("falls back on ProviderError without status code (connection failure)", async () => {
-    const primary = makeFailing(
-      new ProviderError("connection failed", "primary"),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    const _result = await provider.sendMessage(MESSAGES);
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(1);
-  });
-
-  test("does NOT fall back on 400 Bad Request", async () => {
-    const primary = makeFailing(
-      new ProviderError("bad request", "primary", 400),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow("bad request");
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(0);
-  });
-
-  test("does NOT fall back on 401 Unauthorized", async () => {
-    const primary = makeFailing(
-      new ProviderError("unauthorized", "primary", 401),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
-      "unauthorized",
-    );
-    expect(secondary.calls).toBe(0);
-  });
-
-  test("throws last error when all providers fail", async () => {
-    const p1 = makeFailing(new ProviderError("p1 down", "p1", 500), "p1");
-    const p2 = makeFailing(new ProviderError("p2 down", "p2", 503), "p2");
-    const p3 = makeFailing(new ProviderError("p3 down", "p3", 502), "p3");
-    const provider = new FailoverProvider([p1, p2, p3]);
-
-    try {
-      await provider.sendMessage(MESSAGES);
-      expect(true).toBe(false);
-    } catch (err) {
-      expect(err).toBeInstanceOf(ProviderError);
-      // Last provider's error is thrown
-      expect((err as ProviderError).message).toBe("p3 down");
-    }
-    expect(p1.calls).toBe(1);
-    expect(p2.calls).toBe(1);
-    expect(p3.calls).toBe(1);
-  });
-
-  test("chains through three providers when first two fail", async () => {
-    const p1 = makeFailing(new ProviderError("p1 error", "p1", 500), "p1");
-    const p2 = makeFailing(new ProviderError("p2 error", "p2", 502), "p2");
-    const p3 = makeProvider("p3");
-    const provider = new FailoverProvider([p1, p2, p3]);
-
-    const result = await provider.sendMessage(MESSAGES);
-
-    expect(p1.calls).toBe(1);
-    expect(p2.calls).toBe(1);
-    expect(p3.calls).toBe(1);
-    expect(result.stopReason).toBe("end_turn");
-  });
-
-  test("requires at least one provider", () => {
-    expect(() => new FailoverProvider([])).toThrow(
-      "FailoverProvider requires at least one provider",
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// FailoverProvider — cooldown and recovery
-// ---------------------------------------------------------------------------
-
-describe("FailoverProvider — cooldown and recovery", () => {
-  test("skips provider in cooldown period", async () => {
-    const primary = makeFailing(
-      new ProviderError("down", "primary", 500),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    // Use a long cooldown so primary stays unhealthy
-    const provider = new FailoverProvider([primary, secondary], 60_000);
-
-    // First call: primary fails, secondary succeeds
-    await provider.sendMessage(MESSAGES);
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(1);
-
-    // Second call: primary is in cooldown, skipped — goes straight to secondary
-    await provider.sendMessage(MESSAGES);
-    expect(primary.calls).toBe(1); // not called again
-    expect(secondary.calls).toBe(2);
-  });
-
-  test("retries provider after cooldown expires", async () => {
-    let primaryCallCount = 0;
-    const primary: Provider = {
-      name: "primary",
-      async sendMessage() {
-        primaryCallCount++;
-        if (primaryCallCount === 1) {
-          throw new ProviderError("temporarily down", "primary", 500);
-        }
-        return successResponse();
-      },
-    };
-    const secondary = makeProvider("secondary");
-    // Very short cooldown
-    const provider = new FailoverProvider([primary, secondary], 1);
-
-    // First call: primary fails, marked unhealthy, secondary succeeds
-    await provider.sendMessage(MESSAGES);
-    expect(primaryCallCount).toBe(1);
-
-    // Wait for cooldown to expire
-    await new Promise((r) => setTimeout(r, 10));
-
-    // Second call: primary should be retried after cooldown expired
-    await provider.sendMessage(MESSAGES);
-    expect(primaryCallCount).toBe(2);
-  });
-
-  test("marks provider healthy after successful recovery", async () => {
-    let primaryCallCount = 0;
-    const primary: Provider = {
-      name: "primary",
-      async sendMessage() {
-        primaryCallCount++;
-        if (primaryCallCount === 1) {
-          throw new ProviderError("blip", "primary", 500);
-        }
-        return successResponse();
-      },
-    };
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary], 1);
-
-    // First call: primary fails
-    await provider.sendMessage(MESSAGES);
-    expect(primaryCallCount).toBe(1);
-
-    // Wait for cooldown
-    await new Promise((r) => setTimeout(r, 10));
-
-    // Second call: primary recovers
-    await provider.sendMessage(MESSAGES);
-    expect(primaryCallCount).toBe(2);
-
-    // Third call: primary is healthy, used directly
-    await provider.sendMessage(MESSAGES);
-    expect(primaryCallCount).toBe(3);
-    expect(secondary.calls).toBe(1); // only called once during initial failover
-  });
-});
 
 // ---------------------------------------------------------------------------
 // createStreamTimeout — edge cases
@@ -910,43 +683,3 @@ describe("createStreamTimeout — edge cases", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// RetryProvider + FailoverProvider — combined scenarios
-// ---------------------------------------------------------------------------
-
-describe("RetryProvider + FailoverProvider — combined", () => {
-  test("failover wrapping retry: each provider in the chain retries independently", async () => {
-    // Primary always fails with 500, secondary succeeds
-    const primary = makeFailing(
-      new ProviderError("primary down", "primary", 500),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-
-    // Wrap each in RetryProvider, then combine with FailoverProvider
-    const retryPrimary = new RetryProvider(primary);
-    const retrySecondary = new RetryProvider(secondary);
-    const failover = new FailoverProvider([retryPrimary, retrySecondary]);
-
-    const result = await failover.sendMessage(MESSAGES);
-    expect(result.stopReason).toBe("end_turn");
-    // Primary should have been retried MAX_RETRIES + 1 times before failover
-    expect(primary.calls).toBe(DEFAULT_MAX_RETRIES + 1);
-    expect(secondary.calls).toBe(1);
-  });
-
-  test("single provider: retry exhaustion produces the original error", async () => {
-    const inner = makeFailing(new ProviderError("always fail", "solo", 500));
-    const retrying = new RetryProvider(inner);
-
-    try {
-      await retrying.sendMessage(MESSAGES);
-      expect(true).toBe(false);
-    } catch (err) {
-      expect(err).toBeInstanceOf(ProviderError);
-      expect((err as ProviderError).message).toBe("always fail");
-      expect((err as ProviderError).statusCode).toBe(500);
-    }
-    expect(inner.calls).toBe(DEFAULT_MAX_RETRIES + 1);
-  });
-});

package/src/__tests__/provider-streaming.benchmark.test.ts

@@ -1,8 +1,8 @@
 /**
  * Provider Streaming Benchmark
  *
- * Measures overhead introduced by the provider adapter layers (retry, failover,
- * stream timeout) on top of a simulated streaming source.
+ * Measures overhead introduced by the provider adapter layers (retry, stream
+ * timeout) on top of a simulated streaming source.
  *
  * Baseline targets:
  * - TTFT overhead < 50ms beyond source latency
@@ -17,7 +17,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-import { FailoverProvider } from "../providers/failover.js";
 import { RetryProvider } from "../providers/retry.js";
 import { createStreamTimeout } from "../providers/stream-timeout.js";
 import type {
@@ -28,8 +27,6 @@ import type {
   SendMessageOptions,
   ToolDefinition,
 } from "../providers/types.js";
-import { ProviderError } from "../util/errors.js";
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -83,16 +80,6 @@ function makeStreamingProvider(
   };
 }
 
-/** Build a provider that always fails with a given error. */
-function makeFailingProvider(name: string, statusCode?: number): Provider {
-  return {
-    name,
-    async sendMessage(): Promise<ProviderResponse> {
-      throw new ProviderError(`${name} failed`, name, statusCode);
-    },
-  };
-}
-
 // ---------------------------------------------------------------------------
 // Benchmarks
 // ---------------------------------------------------------------------------
@@ -122,36 +109,6 @@ describe("Provider streaming benchmark", () => {
     expect(overhead).toBeLessThan(50);
   });
 
-  test("TTFT overhead through FailoverProvider is < 50ms", async () => {
-    const sourceTtftMs = 20;
-    const inner = makeStreamingProvider(10, 100, {
-      ttftMs: sourceTtftMs,
-      name: "primary",
-    });
-    const fallback = makeStreamingProvider(10, 100, {
-      ttftMs: sourceTtftMs,
-      name: "fallback",
-    });
-    const wrapped = new FailoverProvider([inner, fallback]);
-
-    let firstEventTime: number | undefined;
-    const start = performance.now();
-
-    await wrapped.sendMessage(SIMPLE_MESSAGES, undefined, undefined, {
-      onEvent: () => {
-        if (firstEventTime === undefined) {
-          firstEventTime = performance.now();
-        }
-      },
-    });
-
-    expect(firstEventTime).toBeDefined();
-    const observedTtft = firstEventTime! - start;
-    const overhead = observedTtft - sourceTtftMs;
-
-    expect(overhead).toBeLessThan(50);
-  });
-
   test("event throughput through provider wrappers is within 20% of source rate", async () => {
     const tokenCount = 50;
     const sourceRate = 200; // tokens/sec
@@ -196,42 +153,6 @@ describe("Provider streaming benchmark", () => {
     expect(observedRate).toBeGreaterThanOrEqual(minAcceptableRate);
   });
 
-  test("failover adds < 100ms overhead when primary provider fails", async () => {
-    const failing = makeFailingProvider("failing-primary", 500);
-    const healthy = makeStreamingProvider(5, 100, { name: "healthy-fallback" });
-
-    // Measure the fallback provider's baseline execution time directly so we
-    // can isolate the failover overhead from the stream's own runtime.
-    const baselineEvents: ProviderEvent[] = [];
-    const baselineStart = performance.now();
-
-    await healthy.sendMessage(SIMPLE_MESSAGES, undefined, undefined, {
-      onEvent: (e) => baselineEvents.push(e),
-    });
-
-    const baselineElapsed = performance.now() - baselineStart;
-
-    // Now measure through the FailoverProvider (primary fails, falls back)
-    const healthy2 = makeStreamingProvider(5, 100, {
-      name: "healthy-fallback",
-    });
-    const wrapped = new FailoverProvider([failing, healthy2]);
-
-    const events: ProviderEvent[] = [];
-    const start = performance.now();
-
-    await wrapped.sendMessage(SIMPLE_MESSAGES, undefined, undefined, {
-      onEvent: (e) => events.push(e),
-    });
-
-    const elapsed = performance.now() - start;
-    expect(events.length).toBe(5);
-
-    // Isolate the failover overhead by subtracting the fallback stream's baseline
-    const failoverOverhead = elapsed - baselineElapsed;
-    expect(failoverOverhead).toBeLessThan(100);
-  });
-
   test("createStreamTimeout fires within 50ms of configured deadline", async () => {
     const timeoutMs = 100;
     const { signal, cleanup } = createStreamTimeout(timeoutMs);

package/src/__tests__/relay-server.test.ts

@@ -87,7 +87,6 @@ mock.module("../prompts/user-reference.js", () => ({
 
 const mockConfig = {
   provider: "anthropic",
-  providerOrder: ["anthropic"],
   secretDetection: { enabled: false },
   calls: {
     enabled: true,
@@ -152,7 +151,7 @@ mock.module("../providers/registry.js", () => {
   mockSendMessage = mock(createMockProviderResponse(["Hello"]));
   return {
     listProviders: () => ["anthropic"],
-    getFailoverProvider: () => ({
+    getProvider: () => ({
       name: "anthropic",
       sendMessage: (...args: unknown[]) => mockSendMessage(...args),
     }),

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

@@ -35,7 +35,7 @@ mock.module("../security/secure-keys.js", () => ({
     Promise.resolve(secureKeyValues.get(account)),
   setSecureKeyAsync: () => Promise.resolve(true),
   deleteSecureKeyAsync: () => Promise.resolve("deleted"),
-  listSecureKeysAsync: async () => [],
+  listSecureKeysAsync: async () => ({ accounts: [], unreachable: false }),
   _resetBackend: () => {},
 }));
 

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

@@ -66,7 +66,7 @@ mock.module("../security/secure-keys.js", () => {
     setSecureKeyAsync: async (key: string, value: string) =>
       syncSet(key, value),
     deleteSecureKeyAsync: async (key: string) => syncDelete(key),
-    listSecureKeysAsync: async () => [],
+    listSecureKeysAsync: async () => ({ accounts: [], unreachable: false }),
   };
 });