@vellumai/assistant 0.4.31 → 0.4.32

package/src/__tests__/ipc-snapshot.test.ts

@@ -101,10 +101,6 @@ const clientMessages: Record<ClientMessageType, ClientMessage> = {
     type: "usage_request",
     sessionId: "sess-001",
   },
-  sandbox_set: {
-    type: "sandbox_set",
-    enabled: true,
-  },
   cu_session_create: {
     type: "cu_session_create",
     sessionId: "cu-sess-001",

package/src/__tests__/managed-proxy-context.test.ts

@@ -0,0 +1,163 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Mock logger to suppress output
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Mutable state for env and secure key stubs
+let mockPlatformBaseUrl = "";
+let mockAssistantApiKey: string | null = null;
+
+mock.module("../config/env.js", () => ({
+  getPlatformBaseUrl: () => mockPlatformBaseUrl,
+}));
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKey: (key: string) => {
+    if (key === "credential:vellum:assistant_api_key") {
+      return mockAssistantApiKey;
+    }
+    return null;
+  },
+}));
+
+import {
+  buildManagedBaseUrl,
+  hasManagedProxyPrereqs,
+  managedFallbackEnabledFor,
+  resolveManagedProxyContext,
+} from "../providers/managed-proxy/context.js";
+
+describe("resolveManagedProxyContext", () => {
+  beforeEach(() => {
+    mockPlatformBaseUrl = "";
+    mockAssistantApiKey = null;
+  });
+
+  test("returns disabled when platform URL is empty", () => {
+    mockPlatformBaseUrl = "";
+    mockAssistantApiKey = "sk-test-key";
+
+    const ctx = resolveManagedProxyContext();
+    expect(ctx.enabled).toBe(false);
+    expect(ctx.platformBaseUrl).toBe("");
+  });
+
+  test("returns disabled when assistant API key is missing", () => {
+    mockPlatformBaseUrl = "https://platform.example.com";
+    mockAssistantApiKey = null;
+
+    const ctx = resolveManagedProxyContext();
+    expect(ctx.enabled).toBe(false);
+    expect(ctx.assistantApiKey).toBe("");
+  });
+
+  test("returns disabled when both are missing", () => {
+    const ctx = resolveManagedProxyContext();
+    expect(ctx.enabled).toBe(false);
+  });
+
+  test("returns enabled when both platform URL and API key are present", () => {
+    mockPlatformBaseUrl = "https://platform.example.com/";
+    mockAssistantApiKey = "sk-test-key";
+
+    const ctx = resolveManagedProxyContext();
+    expect(ctx.enabled).toBe(true);
+    expect(ctx.platformBaseUrl).toBe("https://platform.example.com");
+    expect(ctx.assistantApiKey).toBe("sk-test-key");
+  });
+
+  test("strips trailing slashes from platform URL", () => {
+    mockPlatformBaseUrl = "https://platform.example.com///";
+    mockAssistantApiKey = "sk-test-key";
+
+    const ctx = resolveManagedProxyContext();
+    expect(ctx.platformBaseUrl).toBe("https://platform.example.com");
+  });
+});
+
+describe("hasManagedProxyPrereqs", () => {
+  beforeEach(() => {
+    mockPlatformBaseUrl = "";
+    mockAssistantApiKey = null;
+  });
+
+  test("returns false when prerequisites are missing", () => {
+    expect(hasManagedProxyPrereqs()).toBe(false);
+  });
+
+  test("returns true when prerequisites are satisfied", () => {
+    mockPlatformBaseUrl = "https://platform.example.com";
+    mockAssistantApiKey = "sk-test-key";
+    expect(hasManagedProxyPrereqs()).toBe(true);
+  });
+});
+
+describe("buildManagedBaseUrl", () => {
+  beforeEach(() => {
+    mockPlatformBaseUrl = "https://platform.example.com";
+    mockAssistantApiKey = "sk-test-key";
+  });
+
+  test("builds correct URL for managed providers", () => {
+    expect(buildManagedBaseUrl("openai")).toBe(
+      "https://platform.example.com/v1/runtime-proxy/openai",
+    );
+    expect(buildManagedBaseUrl("anthropic")).toBe(
+      "https://platform.example.com/v1/runtime-proxy/anthropic",
+    );
+    expect(buildManagedBaseUrl("gemini")).toBe(
+      "https://platform.example.com/v1/runtime-proxy/gemini",
+    );
+    expect(buildManagedBaseUrl("fireworks")).toBe(
+      "https://platform.example.com/v1/runtime-proxy/fireworks",
+    );
+    expect(buildManagedBaseUrl("openrouter")).toBe(
+      "https://platform.example.com/v1/runtime-proxy/openrouter",
+    );
+  });
+
+  test("returns undefined for non-managed provider (ollama)", () => {
+    expect(buildManagedBaseUrl("ollama")).toBeUndefined();
+  });
+
+  test("returns undefined for unknown provider", () => {
+    expect(buildManagedBaseUrl("unknown-provider")).toBeUndefined();
+  });
+
+  test("returns undefined when prerequisites are missing", () => {
+    mockPlatformBaseUrl = "";
+    mockAssistantApiKey = null;
+    expect(buildManagedBaseUrl("openai")).toBeUndefined();
+  });
+});
+
+describe("managedFallbackEnabledFor", () => {
+  beforeEach(() => {
+    mockPlatformBaseUrl = "https://platform.example.com";
+    mockAssistantApiKey = "sk-test-key";
+  });
+
+  test("returns true for managed providers with prerequisites", () => {
+    expect(managedFallbackEnabledFor("openai")).toBe(true);
+    expect(managedFallbackEnabledFor("anthropic")).toBe(true);
+  });
+
+  test("returns false for non-managed provider", () => {
+    expect(managedFallbackEnabledFor("ollama")).toBe(false);
+  });
+
+  test("returns false for unknown provider", () => {
+    expect(managedFallbackEnabledFor("unknown")).toBe(false);
+  });
+
+  test("returns false when prerequisites are missing", () => {
+    mockPlatformBaseUrl = "";
+    mockAssistantApiKey = null;
+    expect(managedFallbackEnabledFor("openai")).toBe(false);
+  });
+});

package/src/__tests__/memory-lifecycle-e2e.test.ts

@@ -478,7 +478,7 @@ describe("Memory lifecycle E2E regression", () => {
           confidence: 0.83,
           importance: 0.7,
           fingerprint: "fp-item-runtime-existing",
-          verificationState: "assistant_inferred",
+          verificationState: "user_reported",
           scopeId: "default",
           firstSeenAt: now + 200,
           lastSeenAt: now + 200,
@@ -494,7 +494,7 @@ describe("Memory lifecycle E2E regression", () => {
           confidence: 0.81,
           importance: 0.7,
           fingerprint: "fp-item-runtime-candidate",
-          verificationState: "assistant_inferred",
+          verificationState: "user_reported",
           scopeId: "default",
           firstSeenAt: now + 201,
           lastSeenAt: now + 201,

package/src/__tests__/memory-regressions.test.ts

@@ -1201,7 +1201,7 @@ describe("Memory regressions", () => {
             status: "active",
             confidence: 0.8,
             fingerprint: "fp-conflict-existing",
-            verificationState: "assistant_inferred",
+            verificationState: "user_reported",
             scopeId: "scope-conflicts",
             firstSeenAt: now - 10_000,
             lastSeenAt: now - 5_000,
@@ -1216,7 +1216,7 @@ describe("Memory regressions", () => {
             status: "pending_clarification",
             confidence: 0.8,
             fingerprint: "fp-conflict-candidate",
-            verificationState: "assistant_inferred",
+            verificationState: "user_reported",
             scopeId: "scope-conflicts",
             firstSeenAt: now - 9_000,
             lastSeenAt: now - 4_000,
@@ -1312,7 +1312,7 @@ describe("Memory regressions", () => {
             status: "active",
             confidence: 0.8,
             fingerprint: "fp-conflict-existing-age",
-            verificationState: "assistant_inferred",
+            verificationState: "user_reported",
             scopeId: "scope-conflicts-age",
             firstSeenAt: now - 10_000,
             lastSeenAt: now - 5_000,
@@ -1327,7 +1327,7 @@ describe("Memory regressions", () => {
             status: "pending_clarification",
             confidence: 0.8,
             fingerprint: "fp-conflict-candidate-age",
-            verificationState: "assistant_inferred",
+            verificationState: "user_reported",
             scopeId: "scope-conflicts-age",
             firstSeenAt: now - 9_000,
             lastSeenAt: now - 4_000,
@@ -1418,7 +1418,7 @@ describe("Memory regressions", () => {
             status: "active",
             confidence: 0.8,
             fingerprint: "fp-conflict-existing-unrelated",
-            verificationState: "assistant_inferred",
+            verificationState: "user_reported",
             scopeId: "scope-conflicts-unrelated",
             firstSeenAt: now - 10_000,
             lastSeenAt: now - 5_000,
@@ -1433,7 +1433,7 @@ describe("Memory regressions", () => {
             status: "pending_clarification",
             confidence: 0.8,
             fingerprint: "fp-conflict-candidate-unrelated",
-            verificationState: "assistant_inferred",
+            verificationState: "user_reported",
             scopeId: "scope-conflicts-unrelated",
             firstSeenAt: now - 9_000,
             lastSeenAt: now - 4_000,

package/src/__tests__/openai-provider.test.ts

@@ -78,8 +78,10 @@ mock.module("openai", () => ({
 }));
 
 // Import after mocking
+import { FireworksProvider } from "../providers/fireworks/client.js";
 import { OllamaProvider } from "../providers/ollama/client.js";
 import { OpenAIProvider } from "../providers/openai/client.js";
+import { OpenRouterProvider } from "../providers/openrouter/client.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -844,3 +846,83 @@ describe("OpenAIProvider", () => {
     });
   });
 });
+
+// ---------------------------------------------------------------------------
+// Managed proxy initialization
+// ---------------------------------------------------------------------------
+
+describe("managed proxy initialization", () => {
+  beforeEach(() => {
+    lastConstructorOptions = null;
+  });
+
+  test("OpenAIProvider initializes with managed proxy base URL", () => {
+    const managed = new OpenAIProvider("ast-key-123", "gpt-4o", {
+      baseURL: "https://platform.example.com/v1/runtime-proxy/openai",
+    });
+
+    expect(managed.name).toBe("openai");
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "ast-key-123",
+      baseURL: "https://platform.example.com/v1/runtime-proxy/openai",
+    });
+  });
+
+  test("OpenAIProvider without baseURL calls provider directly", () => {
+    new OpenAIProvider("sk-user-key", "gpt-4o");
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "sk-user-key",
+      baseURL: undefined,
+    });
+  });
+
+  test("FireworksProvider initializes with managed proxy base URL", () => {
+    const managed = new FireworksProvider(
+      "ast-key-123",
+      "accounts/fireworks/models/llama-v3p1-70b-instruct",
+      {
+        baseURL: "https://platform.example.com/v1/runtime-proxy/fireworks",
+      },
+    );
+
+    expect(managed.name).toBe("fireworks");
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "ast-key-123",
+      baseURL: "https://platform.example.com/v1/runtime-proxy/fireworks",
+    });
+  });
+
+  test("FireworksProvider without managed baseURL uses default Fireworks URL", () => {
+    new FireworksProvider(
+      "fw-user-key",
+      "accounts/fireworks/models/llama-v3p1-70b-instruct",
+    );
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "fw-user-key",
+      baseURL: "https://api.fireworks.ai/inference/v1",
+    });
+  });
+
+  test("OpenRouterProvider initializes with managed proxy base URL", () => {
+    const managed = new OpenRouterProvider("ast-key-123", "openai/gpt-4o", {
+      baseURL: "https://platform.example.com/v1/runtime-proxy/openrouter",
+    });
+
+    expect(managed.name).toBe("openrouter");
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "ast-key-123",
+      baseURL: "https://platform.example.com/v1/runtime-proxy/openrouter",
+    });
+  });
+
+  test("OpenRouterProvider without managed baseURL uses default OpenRouter URL", () => {
+    new OpenRouterProvider("or-user-key", "openai/gpt-4o");
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "or-user-key",
+      baseURL: "https://openrouter.ai/api/v1",
+    });
+  });
+});

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

@@ -1,8 +1,35 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// 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 = "";
+
+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,
+  getSecureKey: (key: string) => {
+    if (key === "credential:vellum:assistant_api_key") {
+      return mockAssistantApiKey || null;
+    }
+    return null;
+  },
+}));
 
 import {
   getFailoverProvider,
   initializeProviders,
+  listProviders,
   resolveProviderSelection,
 } from "../providers/registry.js";
 
@@ -125,3 +152,109 @@ describe("getFailoverProvider (fail-open)", () => {
     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("openai registered via managed fallback when no user key but proxy context is valid", () => {
+    enableManagedProxy();
+    try {
+      initializeProviders({
+        apiKeys: { anthropic: "test-key" },
+        provider: "anthropic",
+        model: "test-model",
+      });
+      const registered = listProviders();
+      expect(registered).toContain("openai");
+      expect(registered).toContain("fireworks");
+      expect(registered).toContain("openrouter");
+    } finally {
+      disableManagedProxy();
+    }
+  });
+
+  test("user key takes precedence over managed fallback", () => {
+    enableManagedProxy();
+    try {
+      initializeProviders({
+        apiKeys: { anthropic: "test-key", openai: "user-openai-key" },
+        provider: "anthropic",
+        model: "test-model",
+      });
+      // openai should be registered (via user key, not managed)
+      const registered = listProviders();
+      expect(registered).toContain("openai");
+      // fireworks/openrouter should also be registered via managed fallback
+      expect(registered).toContain("fireworks");
+      expect(registered).toContain("openrouter");
+    } finally {
+      disableManagedProxy();
+    }
+  });
+
+  test("managed fallback not activated when proxy context is disabled", () => {
+    disableManagedProxy();
+    initializeProviders({
+      apiKeys: { anthropic: "test-key" },
+      provider: "anthropic",
+      model: "test-model",
+    });
+    const registered = listProviders();
+    expect(registered).not.toContain("openai");
+    expect(registered).not.toContain("fireworks");
+    expect(registered).not.toContain("openrouter");
+  });
+
+  test("managed providers participate in failover selection", () => {
+    enableManagedProxy();
+    try {
+      initializeProviders({
+        apiKeys: { anthropic: "test-key" },
+        provider: "anthropic",
+        model: "test-model",
+      });
+      const selection = resolveProviderSelection("anthropic", [
+        "openai",
+        "fireworks",
+      ]);
+      expect(selection.availableProviders).toEqual([
+        "anthropic",
+        "openai",
+        "fireworks",
+      ]);
+      expect(selection.selectedPrimary).toBe("anthropic");
+      expect(selection.usedFallbackPrimary).toBe(false);
+    } finally {
+      disableManagedProxy();
+    }
+  });
+
+  test("managed provider selected as primary when configured primary unavailable", () => {
+    enableManagedProxy();
+    try {
+      // No anthropic key, no gemini key — only managed providers available
+      initializeProviders({
+        apiKeys: {},
+        provider: "openai",
+        model: "test-model",
+      });
+      const selection = resolveProviderSelection("openai", ["fireworks"]);
+      expect(selection.selectedPrimary).toBe("openai");
+      expect(selection.usedFallbackPrimary).toBe(false);
+    } finally {
+      disableManagedProxy();
+    }
+  });
+});