@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/workspace-migration-090-memory-router-cost-optimized-profile.test.ts

@@ -0,0 +1,326 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { memoryRouterCostOptimizedProfileMigration } from "../workspace/migrations/090-memory-router-cost-optimized-profile.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-090-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("090-memory-router-cost-optimized-profile migration", () => {
+  test("has correct migration id", () => {
+    expect(memoryRouterCostOptimizedProfileMigration.id).toBe(
+      "090-memory-router-cost-optimized-profile",
+    );
+  });
+
+  test("flips the 087-seeded balanced profile to cost-optimized with 1M context", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: { profile: "balanced" },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    // Must mirror the shipped default in call-site-defaults.ts: dropping the
+    // contextWindow would regress migrated users to the profile's ~200k window
+    // because the resolver prefers an explicit callSites entry.
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      profile: "cost-optimized",
+      contextWindow: { maxInputTokens: 1_000_000 },
+    });
+  });
+
+  test("flips when default provider is absent (treated as Anthropic)", () => {
+    writeConfig({
+      llm: {
+        callSites: {
+          memoryRouter: { profile: "balanced" },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      profile: "cost-optimized",
+      contextWindow: { maxInputTokens: 1_000_000 },
+    });
+  });
+
+  test("upgrades a bare cost-optimized entry left by a pre-fix run to add 1M context", () => {
+    // An earlier (pre-fix) run of this migration wrote a bare
+    // { profile: "cost-optimized" } with no contextWindow. Re-running must
+    // recover the 1M window for those users.
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: { profile: "cost-optimized" },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      profile: "cost-optimized",
+      contextWindow: { maxInputTokens: 1_000_000 },
+    });
+  });
+
+  test("does not create the call site when missing — shipped default handles it", () => {
+    // Fresh installs and BYOK-skipped-by-087 workspaces have no memoryRouter
+    // entry. The shipped default in call-site-defaults.ts already supplies
+    // cost-optimized + 1M context, so this migration should not write anything.
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    const before = readFileSync(configPath(), "utf-8");
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+    const after = readFileSync(configPath(), "utf-8");
+
+    expect(after).toBe(before);
+  });
+
+  test("does nothing when config.json is absent", () => {
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+    expect(existsSync(configPath())).toBe(false);
+  });
+
+  test("skips BYOK / non-Anthropic workspaces to avoid breaking memoryRouter", () => {
+    // `cost-optimized` resolves to a managed connection that BYOK installs
+    // disable. Rewriting there would silently disable memory injection.
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+        callSites: {
+          memoryRouter: { profile: "balanced" },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("skips BYOK workspaces with no existing memoryRouter entry", () => {
+    writeConfig({
+      llm: { default: { provider: "gemini" } },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites?.memoryRouter).toBeUndefined();
+  });
+
+  test("preserves user customizations (model pin)", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: { model: "claude-sonnet-4-6" },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      model: "claude-sonnet-4-6",
+    });
+  });
+
+  test("preserves user customizations (profile + tuning fields)", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: { profile: "balanced", effort: "low" },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      profile: "balanced",
+      effort: "low",
+    });
+  });
+
+  test("preserves the original 077-seeded shape if still present", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: {
+            model: "claude-sonnet-4-6",
+            contextWindow: { maxInputTokens: 1_000_000 },
+          },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      model: "claude-sonnet-4-6",
+      contextWindow: { maxInputTokens: 1_000_000 },
+    });
+  });
+
+  test("preserves quality-optimized override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: { profile: "quality-optimized" },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      profile: "quality-optimized",
+    });
+  });
+
+  test("is idempotent — second run does not change the call site", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: { profile: "balanced" },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+    const afterFirst = readFileSync(configPath(), "utf-8");
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+    const afterSecond = readFileSync(configPath(), "utf-8");
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("skips when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: { profile: "balanced" },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("preserves sibling call-site entries", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          mainAgent: { model: "claude-opus-4-7", maxTokens: 32000 },
+          memoryRouter: { profile: "balanced" },
+        },
+      },
+    });
+
+    memoryRouterCostOptimizedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.mainAgent).toEqual({
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    });
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      profile: "cost-optimized",
+      contextWindow: { maxInputTokens: 1_000_000 },
+    });
+  });
+});

package/src/__tests__/workspace-migration-091-retighten-migration-onboarding-thread.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Tests for workspace migration `091-retighten-migration-onboarding-thread`.
+ *
+ * The migration rewrites the assistant-migration onboarding bullet in
+ * `memory/threads.md` (seeded by 069) only for newly-created workspaces
+ * (`ctx.isNewWorkspace === true`) when the exact old bullet is present. It is a
+ * no-op on upgrade, when the old bullet is absent, and when the file is
+ * missing. It must be idempotent and compose with 069 (069 seeds the old
+ * bullets, then 091 retightens bullet 3).
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { seedOnboardingThreadsMigration } from "../workspace/migrations/069-seed-onboarding-threads.js";
+import { retightenMigrationOnboardingThreadMigration } from "../workspace/migrations/091-retighten-migration-onboarding-thread.js";
+import type { MigrationRunContext } from "../workspace/migrations/types.js";
+
+const NEW_WORKSPACE_CTX: MigrationRunContext = { isNewWorkspace: true };
+const UPGRADE_CTX: MigrationRunContext = { isNewWorkspace: false };
+
+// Literal copy of the 4-bullet block 069 seeds into memory/threads.md. The
+// third bullet is the one 091 retightens.
+const ONBOARDING_THREADS = `- Figure out what kind of personality would best mesh with your user. Figure out who you are and what your voice should be. Your choice should be DISTINCT and have CHARACTER. Once you've figured this out, rewrite SOUL.md and IDENTITY.md in your own voice to define who you are.
+- Work with your user to set a custom avatar for yourself. This task is done once data/avatar/avatar-image.png exists.
+- Ask your user if they use ChatGPT, Claude or another AI tool and offer to help them import memories from there.
+- Suggest connecting to available messaging services like Slack or Telegram
+`;
+
+const OLD_BULLET =
+  "- Ask your user if they use ChatGPT, Claude or another AI tool and offer to help them import memories from there.";
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-091-test-"));
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function seedThreads(content: string): void {
+  mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+  writeFileSync(join(workspaceDir, "memory", "threads.md"), content, "utf-8");
+}
+
+function readThreads(): string {
+  return readFileSync(join(workspaceDir, "memory", "threads.md"), "utf-8");
+}
+
+describe("091-retighten-migration-onboarding-thread migration", () => {
+  test("has correct id and description", () => {
+    expect(retightenMigrationOnboardingThreadMigration.id).toBe(
+      "091-retighten-migration-onboarding-thread",
+    );
+    expect(retightenMigrationOnboardingThreadMigration.description).toContain(
+      "threads.md",
+    );
+  });
+
+  test("replaces the old bullet on a new workspace, preserving the others", () => {
+    seedThreads(ONBOARDING_THREADS);
+
+    retightenMigrationOnboardingThreadMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+
+    const content = readThreads();
+    expect(content).not.toContain(OLD_BULLET);
+    expect(content).toContain("first real task");
+    expect(content).toContain("ChatGPT, Claude");
+    // The other three onboarding bullets are preserved verbatim.
+    expect(content).toContain("Figure out what kind of personality");
+    expect(content).toContain("data/avatar/avatar-image.png");
+    expect(content).toContain("Slack or Telegram");
+  });
+
+  test("no-op on upgrade even when the old bullet is present", () => {
+    seedThreads(ONBOARDING_THREADS);
+
+    retightenMigrationOnboardingThreadMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readThreads()).toBe(ONBOARDING_THREADS);
+  });
+
+  test("no-op when the old bullet is absent (user-edited content)", () => {
+    const edited = "- A bullet the user wrote themselves.\n";
+    seedThreads(edited);
+
+    retightenMigrationOnboardingThreadMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+
+    expect(readThreads()).toBe(edited);
+  });
+
+  test("no-op when memory/threads.md does not exist", () => {
+    retightenMigrationOnboardingThreadMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+    expect(existsSync(join(workspaceDir, "memory", "threads.md"))).toBe(false);
+  });
+
+  test("idempotent — second run produces identical content", () => {
+    seedThreads(ONBOARDING_THREADS);
+
+    retightenMigrationOnboardingThreadMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+    const afterFirst = readThreads();
+
+    retightenMigrationOnboardingThreadMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+    const afterSecond = readThreads();
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("composes 069 -> 091: fresh empty workspace ends with the new bullet", () => {
+    // Mirror how the 069 test sets up: create an empty threads.md first.
+    seedThreads("");
+
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+    retightenMigrationOnboardingThreadMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+
+    const content = readThreads();
+    expect(content).not.toContain(OLD_BULLET);
+    expect(content).toContain("first real task");
+    expect(content).toContain("ChatGPT, Claude");
+  });
+
+  test("down() is a no-op — rewritten content remains", () => {
+    seedThreads(ONBOARDING_THREADS);
+
+    retightenMigrationOnboardingThreadMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+    const rewritten = readThreads();
+
+    retightenMigrationOnboardingThreadMigration.down(workspaceDir);
+
+    expect(readThreads()).toBe(rewritten);
+  });
+});

package/src/acp/session-manager.ts

@@ -460,14 +460,13 @@ export class AcpSessionManager {
             current.parentConversationId,
           );
           if (parentConversation) {
-            const enqueueResult = parentConversation.enqueueMessage(
-              notifyMessage,
-              [],
-            );
+            const enqueueResult = parentConversation.enqueueMessage({
+              content: notifyMessage,
+            });
             if (!enqueueResult.queued && !enqueueResult.rejected) {
               parentConversation
-                .persistUserMessage(notifyMessage, [])
-                .then((messageId) =>
+                .persistUserMessage({ content: notifyMessage })
+                .then(({ id: messageId }) =>
                   parentConversation.runAgentLoop(notifyMessage, messageId),
                 )
                 .catch((err) => {

package/src/agent/loop.ts

@@ -111,6 +111,8 @@ export type AgentLoopExitReason =
    * leaving `agent_loop_exit_reason` NULL.
    */
   | "budget_yield_unrecovered"
+  /** Provider stopped because the configured output-token limit was reached. */
+  | "max_tokens_reached"
   /** User cancellation landed after a non-terminal checkpoint yield. */
   | "aborted_after_checkpoint"
   /** Signal aborted while the catch handler was synthesizing an error turn. */
@@ -119,9 +121,19 @@ export type AgentLoopExitReason =
   | "error";
 
 export type AgentEvent =
+  /**
+   * Emitted once per LLM call inside the loop, immediately before the
+   * `provider.sendMessage` invocation. Carries the optional `callSite` tag so
+   * downstream handlers (the daemon's persistence pipeline) can decide
+   * whether to reserve a row for this call. One `llm_call_started` precedes
+   * every `message_complete` for the same call; multi-call agent turns emit
+   * one pair per call.
+   */
+  | { type: "llm_call_started"; callSite?: LLMCallSite }
   | { type: "text_delta"; text: string }
   | { type: "thinking_delta"; thinking: string }
   | { type: "message_complete"; message: Message }
+  | { type: "max_tokens_reached"; stopReason: string }
   | {
       type: "tool_use";
       id: string;
@@ -256,6 +268,18 @@ const DEFAULT_CONFIG: AgentLoopConfig = {
 
 const MAX_CONSECUTIVE_ERROR_NUDGES = 3;
 const MAX_EMPTY_RESPONSE_RETRIES = 1;
+const MAX_TOKENS_STOP_REASONS = new Set([
+  "length",
+  "max_output_tokens",
+  "max_tokens",
+]);
+
+export function isMaxTokensStopReason(
+  stopReason: string | null | undefined,
+): boolean {
+  if (!stopReason) return false;
+  return MAX_TOKENS_STOP_REASONS.has(stopReason.trim().toLowerCase());
+}
 
 /**
  * Build a minimal {@link TurnContext} for pipeline invocations inside the
@@ -603,6 +627,16 @@ export class AgentLoop {
         if (callSite) {
           providerConfig.callSite = callSite;
           providerConfig.usageTracking = "manual";
+          // Per-conversation seed for deterministic `mix`-profile expansion.
+          // Sourced from the orchestrator-supplied turn context's
+          // conversationId so every LLM call in a conversation resolves the
+          // same mix arm (stable across turns and retries, and across daemon
+          // restarts since the seed is the durable conversation id). Absent
+          // for standalone `AgentLoop` instances (unit tests / no turnContext)
+          // — those fall back to per-call random mix selection.
+          if (turnContext?.conversationId) {
+            providerConfig.selectionSeed = turnContext.conversationId;
+          }
         }
 
         // Per-call inference-profile override. The resolver layers
@@ -751,6 +785,18 @@ export class AgentLoop {
           toolUseTurns,
         );
 
+        // Announce the LLM-call boundary so downstream handlers (the
+        // daemon's persistence pipeline) can reserve an empty assistant row
+        // and stamp the resulting `messageId` onto every streaming event the
+        // call emits. Emit as late as possible — after history stripping,
+        // arg construction, and turn-context resolution — so the gap
+        // between "we said the call started" and the actual provider HTTP
+        // call is minimized. Awaited so the row is created and the
+        // `assistant_turn_start` wire event reaches the client BEFORE the
+        // provider starts streaming deltas — the deltas downstream will
+        // carry the freshly-reserved id.
+        await onEvent({ type: "llm_call_started", callSite });
+
         // Inner try/catch narrows error-recording scope to the provider
         // call itself. The outer agent-loop catch (below) wraps the entire
         // turn body (tool execution, plugin pipelines, checkpoints), so
@@ -862,6 +908,40 @@ export class AgentLoop {
           "LLM call complete",
         );
 
+        if (isMaxTokensStopReason(response.stopReason)) {
+          const safeContent = response.content.filter(
+            (block) =>
+              block.type !== "tool_use" &&
+              block.type !== "server_tool_use" &&
+              block.type !== "web_search_tool_result",
+          );
+          const safeAssistantMessage: Message = {
+            role: "assistant",
+            content: safeContent,
+          };
+          rlog.warn(
+            {
+              turn: toolUseTurns,
+              stopReason: response.stopReason,
+              contentBlocks: response.content.length,
+              safeContentBlocks: safeContent.length,
+              toolUseCount: toolUseBlocks.length,
+            },
+            "LLM response reached output token limit",
+          );
+          history.push(safeAssistantMessage);
+          await onEvent({
+            type: "max_tokens_reached",
+            stopReason: response.stopReason,
+          });
+          await onEvent({
+            type: "message_complete",
+            message: safeAssistantMessage,
+          });
+          await emitExit("max_tokens_reached");
+          break;
+        }
+
         // Detect empty responses: no user-visible text and no tool calls.
         // This can happen when the model fails to produce output after
         // receiving a large tool result. Retry once with a nudge before