@vellumai/assistant 0.11.6 → 0.11.7-staging.2

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

@@ -665,13 +665,14 @@ describe("config mode flip → provider reinit", () => {
 });
 
 describe("managed proxy integration — constants integrity", () => {
-  test("anthropic, openai, gemini, fireworks, and together have metadata with managed=true and a proxyPath", () => {
+  test("anthropic, openai, gemini, fireworks, together, and vellum have metadata with managed=true and a proxyPath", () => {
     for (const provider of [
       "anthropic",
       "openai",
       "gemini",
       "fireworks",
       "together",
+      "vellum",
     ]) {
       const meta = PLATFORM_PROVIDER_META[provider];
       expect(meta).toBeDefined();
@@ -711,6 +712,12 @@ describe("managed proxy integration — constants integrity", () => {
     );
   });
 
+  test("vellum routes through the vellum runtime-proxy path", () => {
+    expect(PLATFORM_PROVIDER_META.vellum.proxyPath).toBe(
+      "/v1/runtime-proxy/vellum",
+    );
+  });
+
   test("openrouter is not managed proxy capable", () => {
     expect(PLATFORM_PROVIDER_META.openrouter.managed).toBe(false);
     expect(PLATFORM_PROVIDER_META.openrouter.proxyPath).toBeUndefined();

package/src/__tests__/provider-usage-tracking.test.ts

@@ -164,6 +164,62 @@ describe("UsageTrackingProvider", () => {
     });
   });
 
+  test("attributes a fallback-served response to the stamped backup profile", async () => {
+    // RetryProvider's fallback escalation stamps `actualProvider` and
+    // `actualInferenceProfile` on the response it serves from the backup
+    // route. The usage event must follow those stamps, not the original
+    // request options, which still carry the failed primary's resolution.
+    setLlmConfig({
+      profiles: {
+        balanced: {
+          provider: "openai",
+          model: "gpt-5.4-mini",
+        },
+        "backup-profile": {
+          provider: "anthropic",
+          model: "claude-sonnet-4-5",
+        },
+      },
+      activeProfile: "balanced",
+      callSites: {
+        conversationTitle: { profile: "balanced" },
+      },
+      pricingOverrides: [],
+    });
+
+    const provider = new UsageTrackingProvider(
+      makeProvider({
+        content: [{ type: "text", text: "Title" }],
+        model: "claude-sonnet-4-5",
+        actualProvider: "anthropic",
+        actualInferenceProfile: "backup-profile",
+        usage: {
+          inputTokens: 1_000,
+          outputTokens: 2_000,
+        },
+        stopReason: "end_turn",
+      }),
+    );
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Summarize" }] }],
+      {
+        config: {
+          callSite: "conversationTitle",
+        },
+      },
+    );
+
+    const events = listUsageEvents();
+    expect(events).toHaveLength(1);
+    expect(events[0]).toMatchObject({
+      provider: "anthropic",
+      model: "claude-sonnet-4-5",
+      callSite: "conversationTitle",
+      inferenceProfile: "backup-profile",
+    });
+  });
+
   test("does not record calls without a call site", async () => {
     const provider = new UsageTrackingProvider(
       makeProvider({

package/src/__tests__/require-fresh-approval.test.ts

@@ -34,14 +34,17 @@ const auditCalls = {
   denied: [] as any[],
   error: [] as any[],
   executed: [] as any[],
-  prompted: [] as string[],
+  prompted: [] as any[],
+  decided: [] as any[],
 };
 
 mock.module("../telemetry/tool-audit.js", () => ({
   recordToolDenied: (e: any) => auditCalls.denied.push(e),
   recordToolError: (e: any) => auditCalls.error.push(e),
   recordToolExecuted: (e: any) => auditCalls.executed.push(e),
-  recordToolPermissionPrompted: (n: string) => auditCalls.prompted.push(n),
+  recordToolPermissionPrompted: (e: any) => auditCalls.prompted.push(e),
+  recordToolPermissionDecided: (e: any, outcome: string) =>
+    auditCalls.decided.push({ entry: e, outcome }),
 }));
 
 // ---------------------------------------------------------------------------