@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/llm-resolver.test.ts

@@ -556,6 +556,29 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.effort).toBe("low");
   });
 
+  test("empty-state greeting defaults to the balanced profile", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: {
+          model: "claude-sonnet-4-7",
+          effort: "medium",
+        },
+        "cost-optimized": {
+          model: "claude-haiku-4-5-20251001",
+          effort: "low",
+        },
+      },
+    });
+
+    expect(resolveDefaultProfileKey("emptyStateGreeting", llm)).toBe(
+      "balanced",
+    );
+    const resolved = resolveCallSiteConfig("emptyStateGreeting", llm);
+    expect(resolved.model).toBe("claude-sonnet-4-7");
+    expect(resolved.effort).toBe("medium");
+  });
+
   test("explicit callSites config overrides CALL_SITE_DEFAULTS", () => {
     const llm = LLMSchema.parse({
       default: fullDefault,
@@ -812,6 +835,299 @@ describe("resolveCallSiteConfig", () => {
   });
 });
 
+describe("mix profiles", () => {
+  // A mix that routes 80% to `a` (model-a) and 20% to `b` (model-b).
+  const mixLlm = LLMSchema.parse({
+    default: fullDefault,
+    profiles: {
+      a: { model: "model-a", effort: "low" },
+      b: { model: "model-b", effort: "high" },
+      ab: {
+        mix: [
+          { profile: "a", weight: 80 },
+          { profile: "b", weight: 20 },
+        ],
+      },
+    },
+    activeProfile: "ab",
+  });
+
+  test("same seed resolves to the same arm (stable across calls)", () => {
+    const first = resolveCallSiteConfig("mainAgent", mixLlm, {
+      selectionSeed: "conv-1",
+    });
+    const second = resolveCallSiteConfig("mainAgent", mixLlm, {
+      selectionSeed: "conv-1",
+    });
+    expect(first.model).toBe(second.model);
+    expect(["model-a", "model-b"]).toContain(first.model);
+    // The chosen arm's other fields flow through; the other arm's don't.
+    if (first.model === "model-a") expect(first.effort).toBe("low");
+    else expect(first.effort).toBe("high");
+  });
+
+  test("all dereference spots in a turn agree for the same seed", () => {
+    // mainAgent (mix layered as activeProfile) and a non-main call site
+    // resolving the same mix as activeProfile must pick the same arm when
+    // given the same conversation seed — guards the invariant that every
+    // resolver call within a conversation lands on one arm.
+    const main = resolveCallSiteConfig("mainAgent", mixLlm, {
+      selectionSeed: "conv-xyz",
+    });
+    const other = resolveCallSiteConfig("memoryExtraction", mixLlm, {
+      selectionSeed: "conv-xyz",
+    });
+    expect(other.model).toBe(main.model);
+  });
+
+  test("different seeds split across both arms by weight", () => {
+    let aCount = 0;
+    let bCount = 0;
+    for (let i = 0; i < 400; i++) {
+      const resolved = resolveCallSiteConfig("mainAgent", mixLlm, {
+        selectionSeed: `conv-${i}`,
+      });
+      if (resolved.model === "model-a") aCount++;
+      else if (resolved.model === "model-b") bCount++;
+    }
+    // Both arms must be reachable, and the 80/20 weighting must skew toward
+    // `a`. Wide band so the assertion locks weighting without coupling to the
+    // exact hash output (deterministic, so never flaky).
+    expect(aCount).toBeGreaterThan(bCount);
+    expect(bCount).toBeGreaterThan(0);
+    expect(aCount).toBeGreaterThan(240); // ~80% of 400 = 320
+    expect(aCount).toBeLessThan(390);
+  });
+
+  test("relative weights are normalized by their sum ([80,20] ≡ [4,1])", () => {
+    const llm2 = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        a: { model: "model-a" },
+        b: { model: "model-b" },
+        ab: {
+          mix: [
+            { profile: "a", weight: 4 },
+            { profile: "b", weight: 1 },
+          ],
+        },
+      },
+      activeProfile: "ab",
+    });
+    for (let i = 0; i < 200; i++) {
+      const seed = `conv-${i}`;
+      expect(
+        resolveCallSiteConfig("mainAgent", llm2, { selectionSeed: seed }).model,
+      ).toBe(
+        resolveCallSiteConfig("mainAgent", mixLlm, { selectionSeed: seed })
+          .model,
+      );
+    }
+  });
+
+  test("mix works as overrideProfile", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        a: { model: "model-a" },
+        b: { model: "model-b" },
+        ab: {
+          mix: [
+            { profile: "a", weight: 50 },
+            { profile: "b", weight: 50 },
+          ],
+        },
+      },
+    });
+    const resolved = resolveCallSiteConfig("mainAgent", llm, {
+      overrideProfile: "ab",
+      selectionSeed: "conv-1",
+    });
+    expect(["model-a", "model-b"]).toContain(resolved.model);
+  });
+
+  test("mix works as a call-site profile (non-mainAgent and mainAgent)", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        a: { model: "model-a" },
+        b: { model: "model-b" },
+        ab: {
+          mix: [
+            { profile: "a", weight: 50 },
+            { profile: "b", weight: 50 },
+          ],
+        },
+      },
+      callSites: {
+        memoryExtraction: { profile: "ab" },
+        mainAgent: { profile: "ab" },
+      },
+    });
+    expect(["model-a", "model-b"]).toContain(
+      resolveCallSiteConfig("memoryExtraction", llm, { selectionSeed: "c1" })
+        .model,
+    );
+    expect(["model-a", "model-b"]).toContain(
+      resolveCallSiteConfig("mainAgent", llm, { selectionSeed: "c1" }).model,
+    );
+  });
+
+  test("onMixSelected reports the mix name and the chosen arm matching the resolved model", () => {
+    const calls: Array<{ mixProfile: string; chosenProfile: string }> = [];
+    const resolved = resolveCallSiteConfig("mainAgent", mixLlm, {
+      selectionSeed: "conv-1",
+      onMixSelected: (info) => calls.push(info),
+    });
+    expect(calls).toHaveLength(1);
+    expect(calls[0].mixProfile).toBe("ab");
+    expect(["a", "b"]).toContain(calls[0].chosenProfile);
+    expect(resolved.model).toBe(
+      calls[0].chosenProfile === "a" ? "model-a" : "model-b",
+    );
+  });
+
+  test("no seed falls back to random selection without throwing (both arms reachable)", () => {
+    const seen = new Set<string>();
+    for (let i = 0; i < 200; i++) {
+      seen.add(resolveCallSiteConfig("mainAgent", mixLlm).model);
+    }
+    expect(seen.has("model-a")).toBe(true);
+    expect(seen.has("model-b")).toBe(true);
+  });
+});
+
+describe("mix validation (LLMSchema.superRefine)", () => {
+  const base = {
+    default: fullDefault,
+    profiles: {
+      a: { model: "model-a" },
+      b: { model: "model-b" },
+    },
+  };
+
+  test("valid mix parses cleanly", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            mix: [
+              { profile: "a", weight: 80 },
+              { profile: "b", weight: 20 },
+            ],
+          },
+        },
+      }),
+    ).not.toThrow();
+  });
+
+  test("rejects a mix referencing an undefined profile", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            mix: [
+              { profile: "a", weight: 1 },
+              { profile: "ghost", weight: 1 },
+            ],
+          },
+        },
+      }),
+    ).toThrow(/not defined in llm\.profiles/);
+  });
+
+  test("rejects a nested mix (arm references another mix)", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            mix: [
+              { profile: "a", weight: 1 },
+              { profile: "b", weight: 1 },
+            ],
+          },
+          outer: {
+            mix: [
+              { profile: "ab", weight: 1 },
+              { profile: "a", weight: 1 },
+            ],
+          },
+        },
+      }),
+    ).toThrow(/cannot be nested/);
+  });
+
+  test("rejects a self-referencing mix", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            mix: [
+              { profile: "ab", weight: 1 },
+              { profile: "a", weight: 1 },
+            ],
+          },
+        },
+      }),
+    ).toThrow(/cannot reference itself/);
+  });
+
+  test("rejects a mix that also sets a config field", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            model: "model-c",
+            mix: [
+              { profile: "a", weight: 1 },
+              { profile: "b", weight: 1 },
+            ],
+          },
+        },
+      }),
+    ).toThrow(/cannot also set/);
+  });
+
+  test("rejects a mix with fewer than two arms", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: { mix: [{ profile: "a", weight: 1 }] },
+        },
+      }),
+    ).toThrow();
+  });
+
+  test("rejects a non-positive arm weight", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            mix: [
+              { profile: "a", weight: 0 },
+              { profile: "b", weight: 1 },
+            ],
+          },
+        },
+      }),
+    ).toThrow();
+  });
+});
+
 describe("resolveDefaultProfileKey", () => {
   test("mainAgent returns activeProfile when set and enabled", () => {
     const llm = LLMSchema.parse({
@@ -894,51 +1210,42 @@ describe("resolveDefaultProfileKey", () => {
       "custom-cost-optimized",
     );
   });
-});
 
-describe("memory v3 call sites resolve through the standard resolver", () => {
-  const llm = LLMSchema.parse({
-    default: fullDefault,
-    profiles: {
-      balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
-      "cost-optimized": {
-        provider: "anthropic",
-        model: "claude-haiku-4-5-20251001",
+  test("mainAgent returns the mix key (not an arm) when activeProfile is a mix", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        a: { model: "model-a" },
+        b: { model: "model-b" },
+        ab: {
+          mix: [
+            { profile: "a", weight: 1 },
+            { profile: "b", weight: 1 },
+          ],
+        },
       },
-    },
-  });
-
-  test("memoryV3Filter and memoryV3Descent resolve to the cost-optimized profile", () => {
-    expect(resolveDefaultProfileKey("memoryV3Filter", llm)).toBe(
-      "cost-optimized",
-    );
-    expect(resolveDefaultProfileKey("memoryV3Descent", llm)).toBe(
-      "cost-optimized",
-    );
-    expect(resolveCallSiteConfig("memoryV3Filter", llm).model).toBe(
-      "claude-haiku-4-5-20251001",
-    );
-    expect(resolveCallSiteConfig("memoryV3Descent", llm).model).toBe(
-      "claude-haiku-4-5-20251001",
-    );
-  });
-
-  test("memoryV3Gate resolves to the balanced (capable) profile", () => {
-    expect(resolveDefaultProfileKey("memoryV3Gate", llm)).toBe("balanced");
-    expect(resolveCallSiteConfig("memoryV3Gate", llm).model).toBe(
-      "claude-sonnet-4-7",
-    );
+      activeProfile: "ab",
+    });
+    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("ab");
   });
 
-  test("v3 call sites are addressable as call-site override keys", () => {
-    const overridden = LLMSchema.parse({
+  test("mainAgent falls back to catalog default when the mix activeProfile is disabled", () => {
+    const llm = LLMSchema.parse({
       default: fullDefault,
-      callSites: {
-        memoryV3Gate: { model: "claude-opus-4-7" },
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+        a: { model: "model-a" },
+        b: { model: "model-b" },
+        ab: {
+          status: "disabled",
+          mix: [
+            { profile: "a", weight: 1 },
+            { profile: "b", weight: 1 },
+          ],
+        },
       },
+      activeProfile: "ab",
     });
-    expect(resolveCallSiteConfig("memoryV3Gate", overridden).model).toBe(
-      "claude-opus-4-7",
-    );
+    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("balanced");
   });
 });

package/src/__tests__/llm-schema.test.ts

@@ -72,7 +72,7 @@ describe("LLMSchema", () => {
     const parsed = LLMSchema.parse({});
     expect(parsed.default).toEqual({
       provider: "anthropic",
-      model: "claude-opus-4-7",
+      model: "claude-opus-4-8",
       maxTokens: 64000,
       effort: "max",
       speed: "standard",

package/src/__tests__/llm-usage-store.test.ts

@@ -1458,3 +1458,48 @@ describe("queryUnreportedUsageEvents", () => {
     expect(events[0].rawUsage).toEqual(rawUsage);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Record-time assistantVersion stamping (May 2026 telemetry honesty fix)
+//
+// Events buffered while the assistant is offline must remember the binary
+// that was running when they were recorded, not the one that finally
+// uploads them. recordUsageEvent stamps APP_VERSION at insert time and the
+// query must return it so the reporter can put it on the wire.
+// ---------------------------------------------------------------------------
+
+describe("recordUsageEvent — assistantVersion stamping", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM llm_usage_events`);
+  });
+
+  test("stamps APP_VERSION on the returned event", async () => {
+    const { APP_VERSION } = await import("../version.js");
+    const event = recordUsageEvent(makeInput(), pricedResult);
+    expect(event.assistantVersion).toBe(APP_VERSION);
+  });
+
+  test("persists assistantVersion and queryUnreportedUsageEvents returns it", async () => {
+    const { APP_VERSION } = await import("../version.js");
+    insertEventAt(1000);
+    const [event] = queryUnreportedUsageEvents(0, undefined, 100);
+    expect(event).toBeDefined();
+    expect(event.assistantVersion).toBe(APP_VERSION);
+  });
+
+  test("legacy rows (null assistant_version column) round-trip as null", () => {
+    // Simulate a row that was persisted before migration 267 ran by
+    // inserting one through recordUsageEvent and then nulling the
+    // column out. This mirrors what production rows look like before
+    // the migration backfills `null`s; the reporter must accept them
+    // and let the platform fall back to the envelope's version.
+    insertEventAt(1000);
+    const db = getDb();
+    db.run(`UPDATE llm_usage_events SET assistant_version = NULL`);
+
+    const [event] = queryUnreportedUsageEvents(0, undefined, 100);
+    expect(event).toBeDefined();
+    expect(event.assistantVersion).toBeNull();
+  });
+});

package/src/__tests__/log-export-routes.test.ts

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import {
   existsSync,
+  mkdirSync,
   mkdtempSync,
   readFileSync,
   rmSync,
@@ -26,6 +27,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { llmUsageEvents } from "../memory/schema.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/log-export-routes.js";
+import { getLogsDir } from "../util/platform.js";
 
 initializeDb();
 
@@ -136,6 +138,63 @@ describe("POST /v1/export - connected clients", () => {
   });
 });
 
+describe("POST /v1/export - conversation-scoped daemon logs", () => {
+  test("retains the full daily assistant log even when lines are not tagged with the conversationId", async () => {
+    /**
+     * Tests that a conversation-scoped export keeps the full daily assistant
+     * log so agent-loop failures logged without the conversationId stay
+     * visible, while still emitting the conversation-filtered index.
+     */
+
+    // GIVEN a daily assistant log with a line that mentions the conversation
+    // AND an agent-loop failure line that does NOT — the kind that
+    // conversationId grepping would drop
+    const conversationId = "conv-export-log-retention";
+    const today = new Date().toISOString().slice(0, 10);
+    const logsDir = getLogsDir();
+    mkdirSync(logsDir, { recursive: true });
+    const logFileName = `assistant-${today}.log`;
+    const logPath = join(logsDir, logFileName);
+    const taggedLine = `[agent] processing turn for ${conversationId}`;
+    const untaggedErrorLine =
+      "[agent] ERROR agent loop failed: stream aborted before first token";
+    writeFileSync(logPath, `${taggedLine}\n${untaggedErrorLine}\n`, "utf-8");
+
+    try {
+      // WHEN we run a conversation-scoped export
+      const result = await exportRoute.handler({ body: { conversationId } });
+
+      // THEN the archive is produced
+      expect(result).toBeInstanceOf(Uint8Array);
+
+      const dir = await extractArchive(result as Uint8Array);
+      try {
+        // AND the full daily log is retained, including the untagged failure
+        const exportedLogPath = join(dir, "daemon-logs", logFileName);
+        expect(existsSync(exportedLogPath)).toBe(true);
+        const exportedLog = readFileSync(exportedLogPath, "utf-8");
+        expect(exportedLog).toContain(untaggedErrorLine);
+        expect(exportedLog).toContain(taggedLine);
+
+        // AND the conversation-filtered slice still exists as a quick index
+        const filteredPath = join(
+          dir,
+          "daemon-logs",
+          "conversation-filtered.jsonl",
+        );
+        expect(existsSync(filteredPath)).toBe(true);
+        const filtered = readFileSync(filteredPath, "utf-8");
+        expect(filtered).toContain(taggedLine);
+        expect(filtered).not.toContain(untaggedErrorLine);
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    } finally {
+      rmSync(logPath, { force: true });
+    }
+  });
+});
+
 describe("POST /v1/export - LLM usage events", () => {
   test("full export includes usage attribution columns", async () => {
     const db = getDb();

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -87,7 +87,7 @@ import {
   seedV2SkillEntries,
 } from "../memory/v2/skill-store.js";
 import { executeDeleteManagedSkill } from "../tools/skills/delete-managed.js";
-import { SkillLoadTool } from "../tools/skills/load.js";
+import { skillLoadTool } from "../tools/skills/load.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
@@ -136,9 +136,6 @@ Run the custom lifecycle verification procedure.
     expect(catalogSkill!.source).toBe("managed");
     expect(catalogSkill!.displayName).toBe("E2E Custom Skill");
 
-    const skillLoadTool = new (SkillLoadTool as any)() as InstanceType<
-      typeof SkillLoadTool
-    >;
     const loadResult = await skillLoadTool.execute(
       { skill: skillId },
       makeContext(),
@@ -280,10 +277,6 @@ Run the custom lifecycle verification procedure.
   test("scaffold → skill_load chain: literal tool execution", async () => {
     const ctx = makeContext();
 
-    const skillLoadTool = new (SkillLoadTool as any)() as InstanceType<
-      typeof SkillLoadTool
-    >;
-
     // Step 1: Scaffold a skill directly
     const scaffoldResult = await executeScaffoldManagedSkill(
       {

package/src/__tests__/manual-token-reconciliation.test.ts

@@ -13,6 +13,8 @@ let connectionStore: Record<
 > = {};
 let deletedConnectionIds: string[] = [];
 let createdConnections: Array<{ provider: string; accountInfo?: string }> = [];
+let updatedConnections: Array<{ id: string; accountInfo?: string | null }> = [];
+let telegramBotUsername: string | undefined;
 const warnings: string[] = [];
 
 // ---------------------------------------------------------------------------
@@ -41,6 +43,10 @@ mock.module("../security/secure-keys.js", () => ({
   },
 }));
 
+mock.module("../telegram/bot-username.js", () => ({
+  getTelegramBotUsername: () => telegramBotUsername,
+}));
+
 mock.module("../oauth/oauth-store.js", () => ({
   getConnectionByProvider: (provider: string) =>
     connectionStore[provider] ?? undefined,
@@ -72,7 +78,16 @@ mock.module("../oauth/oauth-store.js", () => ({
     };
     return { id: `conn-${params.provider}` };
   },
-  updateConnection: () => {},
+  updateConnection: (id: string, updates: { accountInfo?: string | null }) => {
+    updatedConnections.push({ id, accountInfo: updates.accountInfo });
+    for (const conn of Object.values(connectionStore)) {
+      if (conn.id === id) {
+        conn.accountInfo = updates.accountInfo;
+        return true;
+      }
+    }
+    return false;
+  },
   upsertApp: async (_provider: string, _clientId: string) => ({
     id: "app-1",
   }),
@@ -119,6 +134,8 @@ describe("syncManualTokenConnection", () => {
     connectionStore = {};
     deletedConnectionIds = [];
     createdConnections = [];
+    updatedConnections = [];
+    telegramBotUsername = undefined;
     warnings.length = 0;
   });
 
@@ -291,6 +308,62 @@ describe("syncManualTokenConnection", () => {
       { provider: "telegram", accountInfo: undefined },
     ]);
   });
+
+  test("creates telegram connection with configured bot username when account is omitted", async () => {
+    telegramBotUsername = "example_bot";
+    setCredentialResult("telegram", "bot_token", {
+      value: "bot-token",
+      unreachable: false,
+    });
+    setCredentialResult("telegram", "webhook_secret", {
+      value: "webhook-secret",
+      unreachable: false,
+    });
+
+    await syncManualTokenConnection("telegram");
+
+    expect(createdConnections).toEqual([
+      { provider: "telegram", accountInfo: "@example_bot" },
+    ]);
+  });
+
+  test("updates existing telegram connection with configured bot username when account is omitted", async () => {
+    telegramBotUsername = "@example_bot";
+    seedConnection("telegram");
+    setCredentialResult("telegram", "bot_token", {
+      value: "bot-token",
+      unreachable: false,
+    });
+    setCredentialResult("telegram", "webhook_secret", {
+      value: "webhook-secret",
+      unreachable: false,
+    });
+
+    await syncManualTokenConnection("telegram");
+
+    expect(updatedConnections).toEqual([
+      { id: "conn-telegram", accountInfo: "@example_bot" },
+    ]);
+    expect(connectionStore["telegram"]?.accountInfo).toBe("@example_bot");
+  });
+
+  test("preserves existing telegram account label when deriving bot username lazily", async () => {
+    telegramBotUsername = "@example_bot";
+    seedConnection("telegram", { accountInfo: "@existing_bot" });
+    setCredentialResult("telegram", "bot_token", {
+      value: "bot-token",
+      unreachable: false,
+    });
+    setCredentialResult("telegram", "webhook_secret", {
+      value: "webhook-secret",
+      unreachable: false,
+    });
+
+    await syncManualTokenConnection("telegram");
+
+    expect(updatedConnections).toEqual([]);
+    expect(connectionStore["telegram"]?.accountInfo).toBe("@existing_bot");
+  });
 });
 
 describe("backfillManualTokenConnections", () => {
@@ -299,6 +372,8 @@ describe("backfillManualTokenConnections", () => {
     connectionStore = {};
     deletedConnectionIds = [];
     createdConnections = [];
+    updatedConnections = [];
+    telegramBotUsername = undefined;
     warnings.length = 0;
   });