@vellumai/assistant 0.5.7 → 0.5.8

package/src/__tests__/provider-fail-open-selection.test.ts

@@ -1,271 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-
-import { credentialKey } from "../security/credential-key.js";
-
-// ---------------------------------------------------------------------------
-// Mock the underlying dependencies of managed-proxy/context.js rather than
-// the context module itself. This avoids global mock bleed: other test files
-// that import context.js will still get the real implementation with their
-// own dependency mocks.
-// ---------------------------------------------------------------------------
-let mockPlatformBaseUrl = "";
-let mockAssistantApiKey = "";
-let mockProviderKeys: Record<string, string> = {};
-
-const actualEnv = await import("../config/env.js");
-mock.module("../config/env.js", () => ({
-  ...actualEnv,
-  getPlatformBaseUrl: () => mockPlatformBaseUrl,
-}));
-
-const actualSecureKeys = await import("../security/secure-keys.js");
-mock.module("../security/secure-keys.js", () => ({
-  ...actualSecureKeys,
-  getSecureKeyAsync: async (key: string) => {
-    if (key === credentialKey("vellum", "assistant_api_key")) {
-      return mockAssistantApiKey || null;
-    }
-    return mockProviderKeys[key] ?? null;
-  },
-}));
-
-import type { ProvidersConfig } from "../providers/registry.js";
-import {
-  getFailoverProvider,
-  getProviderRoutingSource,
-  initializeProviders,
-  listProviders,
-  resolveProviderSelection,
-} from "../providers/registry.js";
-import { ProviderNotConfiguredError } from "../util/errors.js";
-
-/**
- * Tests for fail-open provider selection: when the configured primary provider
- * is unavailable, the system should automatically fall back to the first
- * available provider in the provider order.
- */
-
-function makeProvidersConfig(provider: string, model: string): ProvidersConfig {
-  return {
-    services: {
-      inference: { mode: "your-own", provider, model },
-      "image-generation": {
-        mode: "your-own",
-        provider: "gemini",
-        model: "gemini-3.1-flash-image-preview",
-      },
-      "web-search": { mode: "your-own", provider: "inference-provider-native" },
-    },
-  };
-}
-
-/** Initialize registry with anthropic + openai for most tests. */
-async function setupTwoProviders() {
-  mockProviderKeys = { anthropic: "test-key", openai: "test-key" };
-  await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
-}
-
-/** Initialize registry with no providers (empty keys, non-registerable primary). */
-async function setupNoProviders() {
-  mockProviderKeys = {};
-  await initializeProviders(makeProvidersConfig("gemini", "test-model"));
-}
-
-describe("resolveProviderSelection", () => {
-  test("configured primary available → selected as primary", async () => {
-    await setupTwoProviders();
-    const result = resolveProviderSelection("anthropic", ["openai"]);
-    expect(result.selectedPrimary).toBe("anthropic");
-    expect(result.usedFallbackPrimary).toBe(false);
-    expect(result.availableProviders).toEqual(["anthropic", "openai"]);
-  });
-
-  test("configured primary unavailable + alternate available → alternate selected", async () => {
-    await setupTwoProviders();
-    const result = resolveProviderSelection("gemini", ["anthropic", "openai"]);
-    expect(result.selectedPrimary).toBe("anthropic");
-    expect(result.usedFallbackPrimary).toBe(true);
-    expect(result.availableProviders).toEqual(["anthropic", "openai"]);
-  });
-
-  test("configured primary unavailable + first alternate also unavailable → second alternate selected", async () => {
-    await setupTwoProviders();
-    const result = resolveProviderSelection("gemini", ["fireworks", "openai"]);
-    expect(result.selectedPrimary).toBe("openai");
-    expect(result.usedFallbackPrimary).toBe(true);
-    expect(result.availableProviders).toEqual(["openai"]);
-  });
-
-  test("deduplicates entries in providerOrder", async () => {
-    await setupTwoProviders();
-    const result = resolveProviderSelection("anthropic", [
-      "anthropic",
-      "openai",
-      "openai",
-    ]);
-    expect(result.availableProviders).toEqual(["anthropic", "openai"]);
-  });
-
-  test("unknown entries in providerOrder are filtered out", async () => {
-    await setupTwoProviders();
-    const result = resolveProviderSelection("anthropic", [
-      "nonexistent",
-      "openai",
-    ]);
-    expect(result.availableProviders).toEqual(["anthropic", "openai"]);
-  });
-
-  test("no available providers → null selectedPrimary", async () => {
-    await setupTwoProviders();
-    const result = resolveProviderSelection("gemini", ["fireworks", "ollama"]);
-    expect(result.selectedPrimary).toBeNull();
-    expect(result.usedFallbackPrimary).toBe(false);
-    expect(result.availableProviders).toEqual([]);
-  });
-
-  test("empty providerOrder with available primary → primary only", async () => {
-    await setupTwoProviders();
-    const result = resolveProviderSelection("anthropic", []);
-    expect(result.selectedPrimary).toBe("anthropic");
-    expect(result.usedFallbackPrimary).toBe(false);
-    expect(result.availableProviders).toEqual(["anthropic"]);
-  });
-
-  test("empty providerOrder with unavailable primary → null", async () => {
-    await setupTwoProviders();
-    const result = resolveProviderSelection("gemini", []);
-    expect(result.selectedPrimary).toBeNull();
-    expect(result.availableProviders).toEqual([]);
-  });
-});
-
-describe("getFailoverProvider (fail-open)", () => {
-  test("returns provider when primary is available", async () => {
-    await setupTwoProviders();
-    const provider = getFailoverProvider("anthropic", ["openai"]);
-    expect(provider).toBeDefined();
-  });
-
-  test("returns provider when primary is unavailable but alternate exists", async () => {
-    await setupTwoProviders();
-    const provider = getFailoverProvider("gemini", ["anthropic", "openai"]);
-    expect(provider).toBeDefined();
-  });
-
-  test("throws ProviderNotConfiguredError when no providers are available", async () => {
-    await setupNoProviders();
-    expect(() => getFailoverProvider("gemini", ["fireworks"])).toThrow(
-      ProviderNotConfiguredError,
-    );
-    try {
-      getFailoverProvider("gemini", ["fireworks"]);
-    } catch (err) {
-      expect(err).toBeInstanceOf(ProviderNotConfiguredError);
-      const typed = err as ProviderNotConfiguredError;
-      expect(typed.requestedProvider).toBe("gemini");
-      expect(typed.registeredProviders).toEqual([]);
-      expect(typed.message).toMatch(/No providers available/);
-    }
-  });
-
-  test("single available provider returns it directly (no failover wrapper)", async () => {
-    await setupTwoProviders();
-    const provider = getFailoverProvider("gemini", ["anthropic"]);
-    // Should be a RetryProvider wrapping AnthropicProvider, not a FailoverProvider
-    expect(provider.name).not.toBe("failover");
-  });
-});
-
-// -------------------------------------------------------------------------
-// Managed proxy fallback
-// -------------------------------------------------------------------------
-
-describe("managed proxy fallback", () => {
-  function enableManagedProxy() {
-    mockPlatformBaseUrl = "https://platform.example.com";
-    mockAssistantApiKey = "ast-key-123";
-  }
-
-  function disableManagedProxy() {
-    mockPlatformBaseUrl = "";
-    mockAssistantApiKey = "";
-  }
-
-  test("anthropic and gemini are registered via managed fallback when no user key but proxy context is valid", async () => {
-    enableManagedProxy();
-    try {
-      mockProviderKeys = { anthropic: "test-key" };
-      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
-      const registered = listProviders();
-      expect(registered).toEqual(["anthropic", "gemini"]);
-    } finally {
-      disableManagedProxy();
-    }
-  });
-
-  test("user key takes precedence and managed fallback only fills anthropic and gemini", async () => {
-    enableManagedProxy();
-    try {
-      mockProviderKeys = { anthropic: "test-key", openai: "user-openai-key" };
-      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
-      const registered = listProviders();
-      expect(registered).toContain("openai");
-      expect(registered).toContain("anthropic");
-      expect(registered).toContain("gemini");
-      expect(registered).not.toContain("fireworks");
-      expect(registered).not.toContain("openrouter");
-    } finally {
-      disableManagedProxy();
-    }
-  });
-
-  test("managed fallback not activated when proxy context is disabled", async () => {
-    disableManagedProxy();
-    mockProviderKeys = { anthropic: "test-key" };
-    await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
-    const registered = listProviders();
-    // Anthropic is registered via user-key, not managed proxy.
-    expect(registered).toContain("anthropic");
-    expect(getProviderRoutingSource("anthropic")).toBe("user-key");
-    // No other providers are registered — managed fallback is off.
-    expect(registered).not.toContain("gemini");
-    expect(registered).not.toContain("openai");
-    expect(registered).not.toContain("fireworks");
-    expect(registered).not.toContain("openrouter");
-  });
-
-  test("managed anthropic and gemini participate in failover selection", async () => {
-    enableManagedProxy();
-    try {
-      mockProviderKeys = { anthropic: "test-key" };
-      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
-      const selection = resolveProviderSelection("anthropic", [
-        "openai",
-        "gemini",
-        "fireworks",
-      ]);
-      expect(selection.availableProviders).toEqual(["anthropic", "gemini"]);
-      expect(selection.selectedPrimary).toBe("anthropic");
-      expect(selection.usedFallbackPrimary).toBe(false);
-    } finally {
-      disableManagedProxy();
-    }
-  });
-
-  test("managed gemini can be selected as fallback primary when configured primary is unavailable", async () => {
-    enableManagedProxy();
-    try {
-      // No anthropic key, no gemini key — only managed providers available
-      mockProviderKeys = {};
-      await initializeProviders(makeProvidersConfig("openai", "test-model"));
-      const selection = resolveProviderSelection("openai", [
-        "gemini",
-        "anthropic",
-      ]);
-      expect(selection.selectedPrimary).toBe("gemini");
-      expect(selection.usedFallbackPrimary).toBe(true);
-    } finally {
-      disableManagedProxy();
-    }
-  });
-});

package/src/__tests__/provider-failover-actual-provider.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
-import { FailoverProvider } from "../providers/failover.js";
-import type {
-  Message,
-  Provider,
-  ProviderResponse,
-} from "../providers/types.js";
-import { ProviderError } from "../util/errors.js";
-
-const MESSAGES: Message[] = [
-  { role: "user", content: [{ type: "text", text: "Hello" }] },
-];
-
-function successResponse(
-  overrides?: Partial<ProviderResponse>,
-): ProviderResponse {
-  return {
-    content: [{ type: "text", text: "ok" }],
-    model: "test-model",
-    usage: { inputTokens: 10, outputTokens: 5 },
-    stopReason: "end_turn",
-    ...overrides,
-  };
-}
-
-describe("FailoverProvider actual provider propagation", () => {
-  test("stamps the winning provider when failover uses a fallback", async () => {
-    const primary: Provider = {
-      name: "openrouter",
-      async sendMessage() {
-        throw new ProviderError("down", "openrouter", 500);
-      },
-    };
-    const secondary: Provider = {
-      name: "fireworks",
-      async sendMessage() {
-        return successResponse();
-      },
-    };
-
-    const provider = new FailoverProvider([primary, secondary]);
-    const response = await provider.sendMessage(MESSAGES);
-
-    expect(response.actualProvider).toBe("fireworks");
-  });
-
-  test("preserves an inner provider's actual provider when already set", async () => {
-    const inner: Provider = {
-      name: "retry-wrapper",
-      async sendMessage() {
-        return successResponse({ actualProvider: "anthropic" });
-      },
-    };
-
-    const provider = new FailoverProvider([inner]);
-    const response = await provider.sendMessage(MESSAGES);
-
-    expect(response.actualProvider).toBe("anthropic");
-  });
-});

package/src/memory/search/lexical.ts

@@ -1,48 +0,0 @@
-import { and, desc, eq, inArray, notInArray } from "drizzle-orm";
-
-import { getDb } from "../db.js";
-import { memorySegments } from "../schema.js";
-import { computeRecencyScore } from "./ranking.js";
-import type { Candidate, CandidateType } from "./types.js";
-
-export function recencySearch(
-  conversationId: string,
-  limit: number,
-  excludedMessageIds: string[] = [],
-  scopeIds?: string[],
-): Candidate[] {
-  if (!conversationId || limit <= 0) return [];
-  const db = getDb();
-  const conditions = [eq(memorySegments.conversationId, conversationId)];
-  if (excludedMessageIds.length > 0) {
-    conditions.push(notInArray(memorySegments.messageId, excludedMessageIds));
-  }
-  if (scopeIds && scopeIds.length > 0) {
-    conditions.push(inArray(memorySegments.scopeId, scopeIds));
-  }
-  const whereClause =
-    conditions.length > 1 ? and(...conditions) : conditions[0];
-  const rows = db
-    .select()
-    .from(memorySegments)
-    .where(whereClause)
-    .orderBy(desc(memorySegments.createdAt))
-    .limit(limit)
-    .all();
-  return rows.map((row) => ({
-    key: `segment:${row.id}`,
-    type: "segment" as CandidateType,
-    id: row.id,
-    source: "recency",
-    text: row.text,
-    kind: "segment",
-    conversationId: row.conversationId,
-    messageId: row.messageId,
-    confidence: 0.55,
-    importance: 0.5,
-    createdAt: row.createdAt,
-    semantic: 0,
-    recency: computeRecencyScore(row.createdAt),
-    finalScore: 0,
-  }));
-}

package/src/providers/failover.ts

@@ -1,186 +0,0 @@
-import { ProviderError } from "../util/errors.js";
-import { getLogger } from "../util/logger.js";
-import type {
-  Message,
-  Provider,
-  ProviderResponse,
-  SendMessageOptions,
-  ToolDefinition,
-} from "./types.js";
-
-const log = getLogger("failover");
-
-const DEFAULT_COOLDOWN_MS = 60_000;
-
-interface ProviderHealth {
-  unhealthySince: number | null;
-}
-
-/**
- * Determine whether an error should trigger failover to the next provider.
- * Connection errors, auth errors, and 5xx server errors trigger failover.
- * 4xx client errors do NOT trigger failover (except 429 rate limit).
- */
-function isFailoverError(error: unknown): boolean {
-  if (error instanceof ProviderError && error.statusCode !== undefined) {
-    // 429 rate limit — try next provider
-    if (error.statusCode === 429) return true;
-    // 5xx server errors — try next provider
-    if (error.statusCode >= 500) return true;
-    // Other 4xx — don't failover (bad request, auth with wrong format, etc.)
-    return false;
-  }
-
-  // Network errors — try next provider
-  if (error instanceof Error) {
-    const code = (error as NodeJS.ErrnoException).code;
-    if (
-      code === "ECONNRESET" ||
-      code === "ECONNREFUSED" ||
-      code === "ETIMEDOUT" ||
-      code === "EPIPE"
-    ) {
-      return true;
-    }
-    if (error.cause instanceof Error) {
-      const causeCode = (error.cause as NodeJS.ErrnoException).code;
-      if (
-        causeCode === "ECONNRESET" ||
-        causeCode === "ECONNREFUSED" ||
-        causeCode === "ETIMEDOUT" ||
-        causeCode === "EPIPE"
-      ) {
-        return true;
-      }
-    }
-  }
-
-  // ProviderError without a status code = connection/unknown failure
-  if (error instanceof ProviderError && error.statusCode === undefined) {
-    return true;
-  }
-
-  return false;
-}
-
-export interface ProviderHealthStatus {
-  name: string;
-  healthy: boolean;
-  unhealthySince: string | null;
-}
-
-export class FailoverProvider implements Provider {
-  public readonly name: string;
-  private readonly healthMap = new Map<string, ProviderHealth>();
-
-  constructor(
-    private readonly providers: Provider[],
-    private readonly cooldownMs: number = DEFAULT_COOLDOWN_MS,
-  ) {
-    if (providers.length === 0) {
-      throw new Error("FailoverProvider requires at least one provider");
-    }
-    this.name = providers[0].name;
-    for (const p of providers) {
-      this.healthMap.set(p.name, { unhealthySince: null });
-    }
-  }
-
-  async sendMessage(
-    messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
-    options?: SendMessageOptions,
-  ): Promise<ProviderResponse> {
-    let lastError: unknown;
-
-    for (const provider of this.providers) {
-      const health = this.healthMap.get(provider.name)!;
-      const now = Date.now();
-
-      // Skip providers that are still in cooldown
-      if (health.unhealthySince != null) {
-        const elapsed = now - health.unhealthySince;
-        if (elapsed < this.cooldownMs) {
-          log.debug(
-            {
-              provider: provider.name,
-              cooldownRemainingMs: this.cooldownMs - elapsed,
-            },
-            "Skipping unhealthy provider (in cooldown)",
-          );
-          continue;
-        }
-        // Cooldown expired — give it another chance
-        log.info(
-          { provider: provider.name },
-          "Provider cooldown expired, retrying",
-        );
-      }
-
-      try {
-        const response = await provider.sendMessage(
-          messages,
-          tools,
-          systemPrompt,
-          options,
-        );
-        // Success — mark healthy
-        if (health.unhealthySince != null) {
-          log.info(
-            { provider: provider.name },
-            "Provider recovered, marking healthy",
-          );
-          health.unhealthySince = null;
-        }
-        return {
-          ...response,
-          actualProvider: response.actualProvider ?? provider.name,
-        };
-      } catch (error) {
-        lastError = error;
-
-        if (isFailoverError(error)) {
-          health.unhealthySince = Date.now();
-          log.warn(
-            {
-              provider: provider.name,
-              error: error instanceof Error ? error.message : String(error),
-              statusCode:
-                error instanceof ProviderError ? error.statusCode : undefined,
-            },
-            "Provider failed, marked unhealthy",
-          );
-          continue;
-        }
-
-        // Non-failover error (e.g. 400 bad request) — don't try other providers
-        throw error;
-      }
-    }
-
-    // All providers exhausted
-    throw (
-      lastError ??
-      new ProviderError(
-        "All configured providers are unavailable",
-        this.name,
-        undefined,
-      )
-    );
-  }
-
-  getHealthStatus(): ProviderHealthStatus[] {
-    return this.providers.map((p) => {
-      const health = this.healthMap.get(p.name)!;
-      return {
-        name: p.name,
-        healthy: health.unhealthySince == null,
-        unhealthySince:
-          health.unhealthySince != null
-            ? new Date(health.unhealthySince).toISOString()
-            : null,
-      };
-    });
-  }
-}