@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/usage-grouped-buckets.test.ts

@@ -0,0 +1,155 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  bucketGroupedUsageEvents,
+  displayUsageGroup,
+  stableUsageSeriesGroupKey,
+} from "../memory/usage-grouped-buckets.js";
+
+describe("usage grouped buckets", () => {
+  test("uses canonical labels for call-site groups and fallbacks", () => {
+    expect(displayUsageGroup("call_site", "mainAgent")).toBe("Main Agent");
+    expect(displayUsageGroup("call_site", "unknownCallSite")).toBe(
+      "unknownCallSite",
+    );
+    expect(displayUsageGroup("call_site", null)).toBe("Unknown Task");
+    expect(displayUsageGroup("inference_profile", null)).toBe(
+      "Default / Unset",
+    );
+  });
+
+  test("uses stable collision-proof keys for grouped series values", () => {
+    expect(stableUsageSeriesGroupKey("call_site", "mainAgent")).toBe(
+      "value:mainAgent",
+    );
+    expect(stableUsageSeriesGroupKey("call_site", null)).toBe("null:call_site");
+    expect(stableUsageSeriesGroupKey("inference_profile", null)).toBe(
+      "null:inference_profile",
+    );
+    expect(
+      stableUsageSeriesGroupKey("inference_profile", "null:inference_profile"),
+    ).toBe("value:null:inference_profile");
+  });
+
+  test("does not double-count bucket totals when empty buckets are disabled", () => {
+    const buckets = bucketGroupedUsageEvents(
+      [
+        {
+          created_at: Date.UTC(2026, 3, 10, 10),
+          input_tokens: 100,
+          output_tokens: 10,
+          estimated_cost_usd: 0.01,
+          llm_call_count: 1,
+          group_key: "mainAgent",
+        },
+        {
+          created_at: Date.UTC(2026, 3, 10, 11),
+          input_tokens: 200,
+          output_tokens: 20,
+          estimated_cost_usd: 0.02,
+          llm_call_count: 1,
+          group_key: "conversationTitle",
+        },
+      ],
+      {
+        from: Date.UTC(2026, 3, 10, 0),
+        to: Date.UTC(2026, 3, 10, 23),
+      },
+      "UTC",
+      { granularity: "daily", groupBy: "call_site", fillEmpty: false },
+    );
+
+    expect(buckets).toHaveLength(1);
+    expect(buckets[0].totalInputTokens).toBe(300);
+    expect(buckets[0].totalOutputTokens).toBe(30);
+    expect(buckets[0].totalEstimatedCostUsd).toBe(0.03);
+    expect(buckets[0].eventCount).toBe(2);
+    expect(buckets[0].groups["value:mainAgent"].totalInputTokens).toBe(100);
+    expect(buckets[0].groups["value:conversationTitle"].totalInputTokens).toBe(
+      200,
+    );
+  });
+
+  test("keeps unset inference profiles separate from matching profile names", () => {
+    const buckets = bucketGroupedUsageEvents(
+      [
+        {
+          created_at: Date.UTC(2026, 3, 10, 10),
+          input_tokens: 100,
+          output_tokens: 10,
+          estimated_cost_usd: 0.01,
+          llm_call_count: 1,
+          group_key: null,
+        },
+        {
+          created_at: Date.UTC(2026, 3, 10, 11),
+          input_tokens: 200,
+          output_tokens: 20,
+          estimated_cost_usd: 0.02,
+          llm_call_count: 1,
+          group_key: "null:inference_profile",
+        },
+      ],
+      {
+        from: Date.UTC(2026, 3, 10, 0),
+        to: Date.UTC(2026, 3, 10, 23),
+      },
+      "UTC",
+      {
+        granularity: "daily",
+        groupBy: "inference_profile",
+        fillEmpty: true,
+      },
+    );
+
+    expect(buckets).toHaveLength(1);
+    expect(buckets[0].groups["null:inference_profile"]).toMatchObject({
+      group: "Default / Unset",
+      groupKey: null,
+      totalInputTokens: 100,
+    });
+    expect(buckets[0].groups["value:null:inference_profile"]).toMatchObject({
+      group: "null:inference_profile",
+      groupKey: "null:inference_profile",
+      totalInputTokens: 200,
+    });
+  });
+
+  test("buckets grouped events without dropping null call-site rows", () => {
+    const buckets = bucketGroupedUsageEvents(
+      [
+        {
+          created_at: Date.UTC(2026, 3, 10, 10),
+          input_tokens: 100,
+          output_tokens: 10,
+          estimated_cost_usd: 0.01,
+          llm_call_count: 1,
+          group_key: "mainAgent",
+        },
+        {
+          created_at: Date.UTC(2026, 3, 10, 11),
+          input_tokens: 200,
+          output_tokens: 20,
+          estimated_cost_usd: 0.02,
+          llm_call_count: 1,
+          group_key: null,
+        },
+      ],
+      {
+        from: Date.UTC(2026, 3, 10, 0),
+        to: Date.UTC(2026, 3, 10, 23),
+      },
+      "UTC",
+      { granularity: "daily", groupBy: "call_site", fillEmpty: true },
+    );
+
+    expect(buckets).toHaveLength(1);
+    expect(buckets[0].totalInputTokens).toBe(300);
+    expect(buckets[0].groups["value:mainAgent"].group).toBe("Main Agent");
+    expect(buckets[0].groups["null:call_site"]).toMatchObject({
+      group: "Unknown Task",
+      groupKey: null,
+      totalInputTokens: 200,
+    });
+  });
+});

package/src/__tests__/usage-routes.test.ts

@@ -51,6 +51,8 @@ function seedEvents() {
       runId: "run-1",
       requestId: "req-1",
       actor: "main_agent",
+      callSite: "mainAgent",
+      inferenceProfile: "balanced",
       provider: "anthropic",
       model: "claude-sonnet-4-20250514",
       inputTokens: 850,
@@ -72,6 +74,8 @@ function seedEvents() {
       runId: "run-1",
       requestId: "req-2",
       actor: "context_compactor",
+      callSite: "compactionAgent",
+      inferenceProfile: "fast",
       provider: "anthropic",
       model: "claude-haiku-3",
       inputTokens: 500,
@@ -92,6 +96,8 @@ function seedEvents() {
       runId: "run-2",
       requestId: "req-3",
       actor: "main_agent",
+      callSite: null,
+      inferenceProfile: null,
       provider: "openai",
       model: "gpt-4o",
       inputTokens: 2000,
@@ -331,5 +337,149 @@ describe("usage routes", () => {
       };
       expect(body.breakdown).toHaveLength(3);
     });
+
+    test("groups by call site with friendly labels and raw keys", () => {
+      const { day1, day2 } = seedEvents();
+      const from = day1 - 1000;
+      const to = day2 + 1000;
+
+      const body = dispatch(
+        "GET",
+        `usage/breakdown?from=${from}&to=${to}&groupBy=call_site`,
+      ) as {
+        breakdown: Array<{
+          group: string;
+          groupKey: string | null;
+          totalInputTokens: number;
+          eventCount: number;
+        }>;
+      };
+
+      expect(body.breakdown.map((row) => row.group)).toEqual([
+        "Main Agent",
+        "Compaction Agent",
+        "Unknown Task",
+      ]);
+      expect(body.breakdown.map((row) => row.groupKey)).toEqual([
+        "mainAgent",
+        "compactionAgent",
+        null,
+      ]);
+      expect(
+        body.breakdown.find((row) => row.groupKey === null)?.totalInputTokens,
+      ).toBe(2000);
+    });
+
+    test("groups by inference profile with unset rows", () => {
+      const { day1, day2 } = seedEvents();
+      const from = day1 - 1000;
+      const to = day2 + 1000;
+
+      const body = dispatch(
+        "GET",
+        `usage/breakdown?from=${from}&to=${to}&groupBy=inference_profile`,
+      ) as {
+        breakdown: Array<{ group: string; groupKey: string | null }>;
+      };
+
+      expect(body.breakdown.map((row) => row.group)).toEqual([
+        "balanced",
+        "fast",
+        "Default / Unset",
+      ]);
+      expect(body.breakdown.map((row) => row.groupKey)).toEqual([
+        "balanced",
+        "fast",
+        null,
+      ]);
+    });
+  });
+
+  describe("GET /v1/usage/series", () => {
+    test("throws BadRequestError when groupBy is missing", () => {
+      expect(() =>
+        dispatch("GET", "usage/series?from=0&to=999999999999"),
+      ).toThrow(BadRequestError);
+    });
+
+    test("throws BadRequestError for invalid groupBy value", () => {
+      expect(() =>
+        dispatch(
+          "GET",
+          "usage/series?from=0&to=999999999999&groupBy=conversation",
+        ),
+      ).toThrow(BadRequestError);
+    });
+
+    test("returns grouped call-site series buckets", () => {
+      const { day1, day2 } = seedEvents();
+      const from = day1 - 1000;
+      const to = day2 + 1000;
+
+      const body = dispatch(
+        "GET",
+        `usage/series?from=${from}&to=${to}&groupBy=call_site&granularity=daily`,
+      ) as {
+        buckets: Array<{
+          date: string;
+          totalInputTokens: number;
+          groups: Record<
+            string,
+            { group: string; groupKey: string | null; totalInputTokens: number }
+          >;
+        }>;
+      };
+
+      expect(body.buckets).toHaveLength(2);
+      expect(body.buckets[0].groups["value:mainAgent"]).toMatchObject({
+        group: "Main Agent",
+        groupKey: "mainAgent",
+        totalInputTokens: 850,
+      });
+      expect(body.buckets[0].groups["value:compactionAgent"]).toMatchObject({
+        group: "Compaction Agent",
+        groupKey: "compactionAgent",
+        totalInputTokens: 500,
+      });
+      expect(body.buckets[1].groups["null:call_site"]).toMatchObject({
+        group: "Unknown Task",
+        groupKey: null,
+        totalInputTokens: 2000,
+      });
+    });
+
+    test("returns grouped inference-profile series buckets", () => {
+      const { day1, day2 } = seedEvents();
+      const from = day1 - 1000;
+      const to = day2 + 1000;
+
+      const body = dispatch(
+        "GET",
+        `usage/series?from=${from}&to=${to}&groupBy=inference_profile&granularity=daily`,
+      ) as {
+        buckets: Array<{
+          groups: Record<
+            string,
+            { group: string; groupKey: string | null; totalInputTokens: number }
+          >;
+        }>;
+      };
+
+      expect(body.buckets[0].groups["value:balanced"]).toMatchObject({
+        group: "balanced",
+        groupKey: "balanced",
+        totalInputTokens: 850,
+      });
+      expect(body.buckets[0].groups["value:fast"]).toMatchObject({
+        group: "fast",
+        groupKey: "fast",
+        totalInputTokens: 500,
+      });
+      expect(body.buckets[1].groups["null:inference_profile"]).toMatchObject({
+        group: "Default / Unset",
+        groupKey: null,
+        totalInputTokens: 2000,
+      });
+    });
   });
 });

package/src/__tests__/validation-results-screen.test.ts

@@ -156,15 +156,26 @@ function makeValidateSuccess(): ValidateResponse {
     is_valid: true,
     errors: [],
     manifest: {
-      schema_version: "1.0",
-      created_at: "2025-01-01T00:00:00Z",
-      source: "test",
-      description: "Test bundle",
-      files: [
-        { path: "config.json", sha256: "abc123", size: 1024 },
-        { path: "skills/test.md", sha256: "def456", size: 2048 },
+      schema_version: 1,
+      bundle_id: "00000000-0000-4000-8000-000000000000",
+      created_at: "2026-03-01T00:00:00Z",
+      assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
+      origin: { mode: "self-hosted-local" },
+      compatibility: {
+        min_runtime_version: "0.0.0-test",
+        max_runtime_version: null,
+      },
+      contents: [
+        { path: "config.json", sha256: "abc123", size_bytes: 1024 },
+        { path: "skills/test.md", sha256: "def456", size_bytes: 2048 },
       ],
-      manifest_sha256: "manifest-hash",
+      checksum: "manifest-hash",
+      secrets_redacted: false,
+      export_options: {
+        include_logs: false,
+        include_browser_state: false,
+        include_memory_vectors: false,
+      },
     },
   };
 }
@@ -246,14 +257,26 @@ function makePreflightSuccess(): ImportPreflightResponse {
       },
     ],
     manifest: {
-      schema_version: "1.0",
-      created_at: "2025-01-01T00:00:00Z",
-      source: "test",
-      files: [
-        { path: "config.json", sha256: "abc123", size: 1024 },
-        { path: "skills/new-skill.md", sha256: "ghi789", size: 512 },
+      schema_version: 1,
+      bundle_id: "00000000-0000-4000-8000-000000000000",
+      created_at: "2026-03-01T00:00:00Z",
+      assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
+      origin: { mode: "self-hosted-local" },
+      compatibility: {
+        min_runtime_version: "0.0.0-test",
+        max_runtime_version: null,
+      },
+      contents: [
+        { path: "config.json", sha256: "abc123", size_bytes: 1024 },
+        { path: "skills/new-skill.md", sha256: "ghi789", size_bytes: 512 },
       ],
-      manifest_sha256: "manifest-hash",
+      checksum: "manifest-hash",
+      secrets_redacted: false,
+      export_options: {
+        include_logs: false,
+        include_browser_state: false,
+        include_memory_vectors: false,
+      },
     },
   };
 }
@@ -539,7 +562,7 @@ describe("deriveValidationScreenState — success", () => {
     expect(screen.phase).toBe("success");
     if (screen.phase === "success") {
       expect(screen.validation.isValid).toBe(true);
-      expect(screen.validation.manifest.schema_version).toBe("1.0");
+      expect(screen.validation.manifest.schema_version).toBe(1);
     }
   });
 

package/src/__tests__/vbundle-pax-and-symlink.test.ts

@@ -42,12 +42,12 @@ mock.module("../config/env.js", () => ({
   setIngressPublicBaseUrl: () => {},
 }));
 
+import { defaultV1Options } from "../runtime/migrations/__tests__/v1-test-helpers.js";
 import {
   buildExportVBundle,
   buildVBundle,
 } from "../runtime/migrations/vbundle-builder.js";
 import { validateVBundle } from "../runtime/migrations/vbundle-validator.js";
-
 // ---------------------------------------------------------------------------
 // PAX header round-trip
 // ---------------------------------------------------------------------------
@@ -71,6 +71,7 @@ describe("PAX extended header round-trip", () => {
         { path: "data/db/assistant.db", data: dbData },
         { path: longPath, data: fileData },
       ],
+      ...defaultV1Options(),
     });
 
     // Validate: should succeed — validator must parse the PAX header
@@ -99,6 +100,7 @@ describe("PAX extended header round-trip", () => {
         { path: "data/db/assistant.db", data: dbData },
         { path: longPath, data: fileData },
       ],
+      ...defaultV1Options(),
     });
 
     const result = validateVBundle(archive);
@@ -117,6 +119,7 @@ describe("PAX extended header round-trip", () => {
         { path: "data/db/assistant.db", data: dbData },
         { path: shortPath, data: fileData },
       ],
+      ...defaultV1Options(),
     });
 
     const result = validateVBundle(archive);
@@ -143,8 +146,14 @@ describe("buildExportVBundle with symlinked skills directory", () => {
     writeFileSync(join(wsDir, "skills", "real-skill.md"), "# Real");
     symlinkSync(realSkillsDir, join(wsDir, "linked-skills"));
 
+    // Add a DB so the v1 manifest schema's `data/db/assistant.db` refine
+    // accepts the bundle.
+    mkdirSync(join(wsDir, "data", "db"), { recursive: true });
+    writeFileSync(join(wsDir, "data", "db", "assistant.db"), "fake-db");
+
     const { archive, manifest } = buildExportVBundle({
       workspaceDir: wsDir,
+      ...defaultV1Options(),
     });
 
     // Validate archive
@@ -152,13 +161,13 @@ describe("buildExportVBundle with symlinked skills directory", () => {
     expect(result.is_valid).toBe(true);
 
     // Real skill file is in the manifest under workspace/ prefix
-    const realSkill = manifest.files.find(
+    const realSkill = manifest.contents.find(
       (f) => f.path === "workspace/skills/real-skill.md",
     );
     expect(realSkill).toBeDefined();
 
     // Symlinked directory is skipped
-    const linkedSkill = manifest.files.find(
+    const linkedSkill = manifest.contents.find(
       (f) => f.path === "workspace/linked-skills/my-skill.md",
     );
     expect(linkedSkill).toBeUndefined();