@vellumai/assistant 0.8.2 → 0.8.4

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

@@ -2,8 +2,8 @@ import { describe, expect, test } from "bun:test";
 
 import { z } from "zod";
 
-import { resolveCallSiteConfig } from "../config/llm-resolver.js";
-import { LLMSchema } from "../config/schemas/llm.js";
+import { resolveCallSiteConfig, resolveDefaultProfileKey } from "../config/llm-resolver.js";
+import { type LLMCallSite, LLMSchema } from "../config/schemas/llm.js";
 
 const fullDefault = {
   provider: "anthropic" as const,
@@ -369,7 +369,8 @@ describe("resolveCallSiteConfig", () => {
     const resolved = resolveCallSiteConfig("mainAgent", llm, {
       overrideProfile: "nonexistent",
     });
-    // Falls through to default — the missing override contributes nothing.
+    // overrideProfile is set so the shipped default's profile is stripped.
+    // The nonexistent overrideProfile also adds nothing. Falls through to default.
     expect(resolved.effort).toBe("max");
     expect(resolved.model).toBe("claude-opus-4-7");
   });
@@ -536,4 +537,340 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.maxTokens).toBe(65536);
     expect(resolved.contextWindow.maxInputTokens).toBe(1048576);
   });
+
+  test("call site with no explicit config falls back to CALL_SITE_DEFAULTS", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "cost-optimized": {
+          model: "claude-haiku-4-5-20251001",
+          effort: "low",
+        },
+      },
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+    expect(resolved.model).toBe("claude-haiku-4-5-20251001");
+    expect(resolved.effort).toBe("low");
+  });
+
+  test("explicit callSites config overrides CALL_SITE_DEFAULTS", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "cost-optimized": {
+          model: "claude-haiku-4-5-20251001",
+          effort: "low",
+        },
+        "quality-optimized": { model: "claude-opus-4-7", effort: "max" },
+      },
+      callSites: {
+        memoryExtraction: { profile: "quality-optimized" },
+      },
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+    expect(resolved.model).toBe("claude-opus-4-7");
+    expect(resolved.effort).toBe("max");
+  });
+
+  test("BYOK: disabled managed profile falls back to custom-* user profile", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        ...fullDefault,
+        provider: "openai",
+        model: "gpt-5.5",
+        provider_connection: "openai-personal",
+      },
+      profiles: {
+        "cost-optimized": {
+          status: "disabled",
+          model: "claude-haiku-4-5-20251001",
+          provider: "anthropic",
+          provider_connection: "anthropic-managed",
+        },
+        "custom-cost-optimized": {
+          source: "user",
+          model: "gpt-5.4-nano",
+          provider: "openai",
+          provider_connection: "openai-personal",
+        },
+        "custom-balanced": {
+          source: "user",
+          model: "gpt-5.5",
+          provider: "openai",
+          provider_connection: "openai-personal",
+        },
+      },
+      activeProfile: "custom-balanced",
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+    expect(resolved.provider).toBe("openai");
+    expect(resolved.model).toBe("gpt-5.4-nano");
+    expect(resolved.provider_connection).toBe("openai-personal");
+  });
+
+  test("BYOK: strips profile when neither managed nor custom-* is available", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        ...fullDefault,
+        provider: "openai",
+        model: "gpt-5.5",
+        provider_connection: "openai-personal",
+      },
+      profiles: {
+        "cost-optimized": {
+          status: "disabled",
+          model: "claude-haiku-4-5-20251001",
+          provider: "anthropic",
+          provider_connection: "anthropic-managed",
+        },
+        "custom-balanced": {
+          model: "gpt-5.5",
+          provider: "openai",
+          provider_connection: "openai-personal",
+        },
+      },
+      activeProfile: "custom-balanced",
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+    expect(resolved.provider).toBe("openai");
+    expect(resolved.model).toBe("gpt-5.5");
+    expect(resolved.provider_connection).toBe("openai-personal");
+  });
+
+  test("BYOK full-workspace: cost-optimized call sites use custom-cost-optimized, balanced use custom-balanced", () => {
+    const byokConfig = LLMSchema.parse({
+      default: {
+        ...fullDefault,
+        provider: "openai",
+        model: "gpt-5.5",
+        provider_connection: "openai-personal",
+      },
+      profiles: {
+        balanced: {
+          status: "disabled",
+          source: "managed",
+          provider: "anthropic",
+          model: "claude-sonnet-4-6",
+          provider_connection: "anthropic-managed",
+        },
+        "cost-optimized": {
+          status: "disabled",
+          source: "managed",
+          provider: "anthropic",
+          model: "claude-haiku-4-5-20251001",
+          provider_connection: "anthropic-managed",
+        },
+        "quality-optimized": {
+          status: "disabled",
+          source: "managed",
+          provider: "anthropic",
+          model: "claude-opus-4-7",
+          provider_connection: "anthropic-managed",
+        },
+        "custom-balanced": {
+          source: "user",
+          provider: "openai",
+          model: "gpt-5.5",
+          provider_connection: "openai-personal",
+        },
+        "custom-cost-optimized": {
+          source: "user",
+          provider: "openai",
+          model: "gpt-5.4-nano",
+          provider_connection: "openai-personal",
+        },
+        "custom-quality-optimized": {
+          source: "user",
+          provider: "openai",
+          model: "gpt-5.5-pro",
+          provider_connection: "openai-personal",
+        },
+      },
+      activeProfile: "custom-balanced",
+    });
+
+    const callSites: LLMCallSite[] = [
+      "mainAgent", "subagentSpawn", "heartbeatAgent", "filingAgent",
+      "compactionAgent", "analyzeConversation", "callAgent",
+      "memoryExtraction", "memoryConsolidation", "memoryRetrieval",
+      "memoryRouter", "recall", "conversationSummarization",
+      "commitMessage", "conversationStarters", "replySuggestion",
+      "conversationTitle", "identityIntro", "emptyStateGreeting",
+      "notificationDecision", "interactionClassifier", "inference",
+    ];
+
+    for (const cs of callSites) {
+      const resolved = resolveCallSiteConfig(cs, byokConfig);
+      expect(resolved.provider_connection).not.toBe("anthropic-managed");
+      expect(resolved.provider).toBe("openai");
+    }
+
+    // Cost-optimized call sites should use the user's nano model
+    const costSite = resolveCallSiteConfig("heartbeatAgent", byokConfig);
+    expect(costSite.model).toBe("gpt-5.4-nano");
+
+    // Balanced call sites should use the user's balanced model
+    const balancedSite = resolveCallSiteConfig("mainAgent", byokConfig);
+    expect(balancedSite.model).toBe("gpt-5.5");
+  });
+
+  test("BYOK: tuning overrides from defaults apply on top of custom-* fallback profile", () => {
+    const byokConfig = LLMSchema.parse({
+      default: {
+        ...fullDefault,
+        provider: "openai",
+        model: "gpt-5.5",
+        provider_connection: "openai-personal",
+      },
+      profiles: {
+        "cost-optimized": {
+          status: "disabled",
+          provider: "anthropic",
+          model: "claude-haiku-4-5-20251001",
+          provider_connection: "anthropic-managed",
+        },
+        "custom-cost-optimized": {
+          source: "user",
+          provider: "openai",
+          model: "gpt-5.4-nano",
+          provider_connection: "openai-personal",
+        },
+        "custom-balanced": {
+          provider: "openai",
+          model: "gpt-5.5",
+          provider_connection: "openai-personal",
+        },
+      },
+      activeProfile: "custom-balanced",
+    });
+
+    const resolved = resolveCallSiteConfig("commitMessage", byokConfig);
+    expect(resolved.provider).toBe("openai");
+    expect(resolved.model).toBe("gpt-5.4-nano");
+    expect(resolved.maxTokens).toBe(120);
+    expect(resolved.effort).toBe("low");
+    expect(resolved.thinking.enabled).toBe(false);
+  });
+
+  test("overrideProfile wins over CALL_SITE_DEFAULTS profile for non-main call sites", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "cost-optimized": { model: "claude-haiku-4-5-20251001", effort: "low" },
+        "quality-optimized": { model: "claude-opus-4-7", effort: "max" },
+      },
+    });
+    const resolved = resolveCallSiteConfig("inference", llm, {
+      overrideProfile: "quality-optimized",
+    });
+    expect(resolved.model).toBe("claude-opus-4-7");
+    expect(resolved.effort).toBe("max");
+  });
+
+  test("profile with provider but no provider_connection inherits stale default connection (JARVIS-861)", () => {
+    // This test documents the merge behavior that causes JARVIS-861: a profile
+    // overrides `provider` but not `provider_connection`, so the deep merge
+    // inherits a stale connection from the default layer. The fix is in the
+    // dispatch layer (connection-resolution auto-resolves the mismatch).
+    const llm = LLMSchema.parse({
+      default: {
+        ...fullDefault,
+        provider_connection: "anthropic-managed",
+      },
+      profiles: {
+        fireworks: { provider: "fireworks", model: "accounts/fireworks/models/kimi-k2p5" },
+      },
+      activeProfile: "fireworks",
+    });
+
+    const resolved = resolveCallSiteConfig("mainAgent", llm);
+
+    expect(resolved.provider).toBe("fireworks");
+    // The merge inherits the stale connection — the dispatch layer handles this.
+    expect(resolved.provider_connection).toBe("anthropic-managed");
+  });
+});
+
+describe("resolveDefaultProfileKey", () => {
+  test("mainAgent returns activeProfile when set and enabled", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+        gemini: { provider: "gemini", model: "gemini-2.5-pro" },
+      },
+      activeProfile: "gemini",
+    });
+    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("gemini");
+  });
+
+  test("mainAgent falls back to catalog default when activeProfile is unset", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      },
+    });
+    // mainAgent's CALL_SITE_DEFAULTS profile is `balanced`.
+    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("balanced");
+  });
+
+  test("mainAgent falls back to catalog default when activeProfile points to a missing profile", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      },
+    });
+    // `LLMSchema.superRefine` rejects unknown `activeProfile` references at
+    // config-load time, so this branch is unreachable for a parsed config.
+    // Mutate after parse to exercise the resolver's defensive fall-through.
+    const mutated = { ...llm, activeProfile: "does-not-exist" };
+    expect(resolveDefaultProfileKey("mainAgent", mutated)).toBe("balanced");
+  });
+
+  test("mainAgent falls back to catalog default when activeProfile is disabled", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+        gemini: {
+          provider: "gemini",
+          model: "gemini-2.5-pro",
+          status: "disabled",
+        },
+      },
+      activeProfile: "gemini",
+    });
+    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("balanced");
+  });
+
+  test("non-mainAgent ignores activeProfile and returns catalog default", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+        "cost-optimized": { provider: "openai", model: "gpt-5-mini" },
+        gemini: { provider: "gemini", model: "gemini-2.5-pro" },
+      },
+      activeProfile: "gemini",
+    });
+    // filingAgent's CALL_SITE_DEFAULTS profile is `cost-optimized` — not gemini.
+    expect(resolveDefaultProfileKey("filingAgent", llm)).toBe("cost-optimized");
+  });
+
+  test("non-mainAgent falls back to custom-* when catalog profile is missing", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "custom-cost-optimized": {
+          provider: "openai",
+          model: "gpt-5-mini",
+        },
+      },
+    });
+    expect(resolveDefaultProfileKey("filingAgent", llm)).toBe(
+      "custom-cost-optimized",
+    );
+  });
 });

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

@@ -1,8 +1,14 @@
 import { spawnSync } from "node:child_process";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -18,12 +24,23 @@ mock.module("../util/secure-keys.js", () => ({
 import { getDb } from "../memory/db-connection.js";
 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";
 
 initializeDb();
 
 const exportRoute = ROUTES.find((r) => r.endpoint === "export")!;
 
+function clearConnectedClients(): void {
+  for (const client of assistantEventHub.listClients()) {
+    assistantEventHub.disposeClient(client.clientId);
+  }
+}
+
+beforeEach(() => {
+  clearConnectedClients();
+});
+
 async function extractArchive(bytes: Uint8Array): Promise<string> {
   const extractDir = mkdtempSync(join(tmpdir(), "log-export-routes-"));
   const archivePath = join(extractDir, "archive.tar.gz");
@@ -39,6 +56,86 @@ async function extractArchive(bytes: Uint8Array): Promise<string> {
   return extractDir;
 }
 
+describe("POST /v1/export - connected clients", () => {
+  test("includes current `assistant clients list --json` output", async () => {
+    const subscription = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "client-list-export-test",
+      interfaceId: "macos",
+      capabilities: ["host_bash", "host_file"],
+      machineName: "test-macbook",
+      callback: () => {},
+    });
+
+    try {
+      const result = await exportRoute.handler({ body: {} });
+      expect(result).toBeInstanceOf(Uint8Array);
+
+      const dir = await extractArchive(result as Uint8Array);
+      try {
+        const clientsList = JSON.parse(
+          readFileSync(join(dir, "clients-list.json"), "utf-8"),
+        ) as {
+          clients: Array<{
+            clientId: string;
+            interfaceId: string;
+            capabilities: string[];
+            machineName?: string;
+            connectedAt: string;
+            lastActiveAt: string;
+          }>;
+        };
+
+        expect(clientsList.clients).toHaveLength(1);
+        expect(clientsList.clients[0]).toMatchObject({
+          clientId: "client-list-export-test",
+          interfaceId: "macos",
+          capabilities: ["host_bash", "host_file"],
+          machineName: "test-macbook",
+        });
+        expect(new Date(clientsList.clients[0].connectedAt).toISOString()).toBe(
+          clientsList.clients[0].connectedAt,
+        );
+        expect(
+          new Date(clientsList.clients[0].lastActiveAt).toISOString(),
+        ).toBe(clientsList.clients[0].lastActiveAt);
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("writes a non-blocking error artifact when client listing fails", async () => {
+    const originalListClients = assistantEventHub.listClients;
+    assistantEventHub.listClients = () => {
+      throw new Error("client list unavailable");
+    };
+
+    try {
+      const result = await exportRoute.handler({ body: {} });
+      expect(result).toBeInstanceOf(Uint8Array);
+
+      const dir = await extractArchive(result as Uint8Array);
+      try {
+        expect(existsSync(join(dir, "clients-list.json"))).toBe(false);
+        const errorArtifact = JSON.parse(
+          readFileSync(join(dir, "clients-list-error.json"), "utf-8"),
+        ) as { error: string; collectedAt: string };
+        expect(errorArtifact.error).toBe("client list unavailable");
+        expect(new Date(errorArtifact.collectedAt).toISOString()).toBe(
+          errorArtifact.collectedAt,
+        );
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    } finally {
+      assistantEventHub.listClients = originalListClients;
+    }
+  });
+});
+
 describe("POST /v1/export - LLM usage events", () => {
   test("full export includes usage attribution columns", async () => {
     const db = getDb();

package/src/__tests__/managed-profile-guard.test.ts

@@ -79,6 +79,16 @@ mock.module("../memory/embedding-backend.js", () => ({
   clearEmbeddingBackendCache: () => {},
 }));
 
+// The replace-profile handler auto-derives `provider_connection` from the
+// first active connection matching the requested provider when the body
+// omits it. That path queries the `provider_connections` table, which the
+// test doesn't migrate — stub it out so the guard logic stays the focus.
+mock.module("../providers/inference/connections.js", () => ({
+  listConnections: () => [],
+  createConnection: () => ({ ok: false, error: { code: "already_exists" } }),
+  PROVIDERS_REQUIRING_BASE_URL_AND_MODELS: new Set(["openai-compatible"]),
+}));
+
 import { ROUTES } from "../runtime/routes/conversation-query-routes.js";
 import { BadRequestError } from "../runtime/routes/errors.js";
 

package/src/__tests__/message-queue-steer.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  MessageQueue,
+  type QueuedMessage,
+} from "../daemon/conversation-queue-manager.js";
+
+function makeItem(content: string, requestId: string): QueuedMessage {
+  return {
+    content,
+    attachments: [],
+    requestId,
+    onEvent: () => {},
+    sentAt: Date.now(),
+  };
+}
+
+describe("MessageQueue.promoteToHead", () => {
+  test("returns undefined when queue is empty", () => {
+    const q = new MessageQueue();
+    expect(q.promoteToHead("nonexistent")).toBeUndefined();
+  });
+
+  test("returns undefined when requestId is not found", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    expect(q.promoteToHead("r99")).toBeUndefined();
+    // Queue unchanged
+    expect(q.peek(0)?.requestId).toBe("r1");
+    expect(q.peek(1)?.requestId).toBe("r2");
+  });
+
+  test("no-op when the message is already at head", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+
+    const bytesBefore = q.totalBytes;
+    const result = q.promoteToHead("r1");
+
+    expect(result).toBeDefined();
+    expect(result?.requestId).toBe("r1");
+    expect(q.peek(0)?.requestId).toBe("r1");
+    expect(q.peek(1)?.requestId).toBe("r2");
+    expect(q.length).toBe(2);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("moves a middle item to head", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    const bytesBefore = q.totalBytes;
+    const result = q.promoteToHead("r2");
+
+    expect(result).toBeDefined();
+    expect(result?.requestId).toBe("r2");
+    expect(q.peek(0)?.requestId).toBe("r2");
+    expect(q.peek(1)?.requestId).toBe("r1");
+    expect(q.peek(2)?.requestId).toBe("r3");
+    expect(q.length).toBe(3);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("moves the last item to head", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    const bytesBefore = q.totalBytes;
+    const result = q.promoteToHead("r3");
+
+    expect(result).toBeDefined();
+    expect(result?.requestId).toBe("r3");
+    expect(q.peek(0)?.requestId).toBe("r3");
+    expect(q.peek(1)?.requestId).toBe("r1");
+    expect(q.peek(2)?.requestId).toBe("r2");
+    expect(q.length).toBe(3);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("byte accounting unchanged after promote (item is reordered, not added/removed)", () => {
+    const q = new MessageQueue(10_000);
+    q.push(makeItem("short", "r1"));
+    q.push(makeItem("a".repeat(200), "r2"));
+    q.push(makeItem("medium text", "r3"));
+
+    const bytesBefore = q.totalBytes;
+    q.promoteToHead("r2");
+    expect(q.totalBytes).toBe(bytesBefore);
+
+    // shift all and verify bytes go to 0
+    q.shift();
+    q.shift();
+    q.shift();
+    expect(q.totalBytes).toBe(0);
+  });
+
+  test("promoted item is returned by shift()", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    q.promoteToHead("r3");
+    const head = q.shift();
+    expect(head?.requestId).toBe("r3");
+    expect(head?.content).toBe("c");
+  });
+});