@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/__tests__/pre-model-call-sanitize.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "bun:test";
+
+import { preModelCallSanitize } from "../agent/loop.js";
+import type { Message } from "../providers/types.js";
+
+/**
+ * `preModelCallSanitize` is the loop's single pre-send transform: it converts
+ * historical `web_search_tool_result` blocks to text alongside the media and
+ * AX-tree strips, so every provider call — first call, post-compaction, and
+ * recovery reruns — is sanitized in one place. These tests guard that the
+ * helper actually performs the web-search conversion and is idempotent.
+ */
+describe("preModelCallSanitize", () => {
+  test("passes through history with nothing to sanitize", () => {
+    // GIVEN a plain conversation with no media, AX trees, or web-search blocks
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Hello" }] },
+      { role: "assistant", content: [{ type: "text", text: "Hi" }] },
+    ];
+
+    // WHEN the loop sanitizes the outbound history
+    const result = preModelCallSanitize(messages);
+
+    // THEN the history is returned unchanged
+    expect(result).toEqual(messages);
+  });
+
+  test("converts historical web_search_tool_result blocks to text summaries", () => {
+    // GIVEN an assistant turn whose web_search_tool_result carries an opaque
+    // encrypted_content token that would be rejected if replayed
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Search cats" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "server_tool_use",
+            id: "stu_1",
+            name: "web_search",
+            input: { query: "cats" },
+          },
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "stu_1",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://cats.com",
+                title: "Cats!",
+                encrypted_content: "expired_token_1",
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    // WHEN the loop sanitizes the outbound history
+    const result = preModelCallSanitize(messages);
+
+    // THEN the opaque block is replaced with a plaintext title+URL summary and
+    // the paired server_tool_use is dropped, so no expired token is replayed
+    const assistantMsg = result[1];
+    expect(assistantMsg.content.map((b) => b.type)).toEqual(["text"]);
+    const summary = assistantMsg.content[0];
+    expect(summary.type).toBe("text");
+    if (summary.type === "text") {
+      expect(summary.text).toContain("Cats!");
+      expect(summary.text).toContain("https://cats.com");
+      expect(summary.text).not.toContain("expired_token_1");
+    }
+  });
+
+  test("is idempotent — re-sanitizing already-sanitized history is a no-op", () => {
+    // GIVEN history that has already been sanitized once
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "server_tool_use",
+            id: "stu_A",
+            name: "web_search",
+            input: { query: "alpha" },
+          },
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "stu_A",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://a.example",
+                title: "A",
+                encrypted_content: "tok_A",
+              },
+            ],
+          },
+        ],
+      },
+    ];
+    const once = preModelCallSanitize(messages);
+
+    // WHEN it is sanitized a second time (every outbound call re-runs the helper)
+    const twice = preModelCallSanitize(once);
+
+    // THEN the second pass changes nothing
+    expect(twice).toEqual(once);
+  });
+});

package/src/__tests__/published-app-updater.test.ts

@@ -0,0 +1,138 @@
+/**
+ * Tests that the auto-redeploy path deploys the app's *effective* HTML
+ * (dist/index.html for multifile apps) rather than the empty `htmlDefinition`.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { AppDefinition } from "../memory/app-store.js";
+
+// ── Mocks ───────────────────────────────────────────────────────────────
+
+let mockApp: AppDefinition | null = null;
+let mockIsMultifile = false;
+let mockEffectiveHtml = "";
+// A directory that does not exist on disk, so the multifile dist-existence
+// guard reads `false` from the real fs without mocking node:fs (which would
+// leak across test files).
+let mockAppDir = "/tmp/__vellum_test_nonexistent__/app-1";
+
+mock.module("../memory/app-store.js", () => ({
+  getApp: () => mockApp,
+  getAppDirPath: () => mockAppDir,
+  isMultifileApp: () => mockIsMultifile,
+  resolveEffectiveAppHtml: () => mockEffectiveHtml,
+}));
+
+let mockPublishedPage: {
+  id: string;
+  projectSlug?: string;
+  htmlHash: string;
+} | null = null;
+const updatePublishedPageSpy = mock(() => {});
+
+mock.module("../memory/published-pages-store.js", () => ({
+  getActivePublishedPageByAppId: () => mockPublishedPage,
+  updatePublishedPage: updatePublishedPageSpy,
+}));
+
+const deploySpy = mock(async (_args: { html: string; name: string }) => ({
+  deploymentId: "dep-1",
+  url: "https://example.vercel.app",
+}));
+
+mock.module("../services/vercel-deploy.js", () => ({
+  deployHtmlToVercel: deploySpy,
+}));
+
+// credentialBroker.serverUse invokes execute(token) and reports success.
+mock.module("../tools/credentials/broker.js", () => ({
+  credentialBroker: {
+    serverUse: async ({
+      execute,
+    }: {
+      execute: (token: string) => Promise<unknown>;
+    }) => {
+      await execute("test-token");
+      return { success: true };
+    },
+  },
+}));
+
+const { updatePublishedAppDeployment } =
+  await import("../services/published-app-updater.js");
+
+function makeApp(overrides: Partial<AppDefinition> = {}): AppDefinition {
+  return {
+    id: "app-1",
+    name: "App",
+    schemaJson: "{}",
+    htmlDefinition: "",
+    createdAt: 1,
+    updatedAt: 2,
+    ...overrides,
+  };
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────
+
+describe("updatePublishedAppDeployment", () => {
+  beforeEach(() => {
+    mockApp = makeApp();
+    mockIsMultifile = false;
+    mockEffectiveHtml = "";
+    mockPublishedPage = { id: "pp-1", projectSlug: "slug", htmlHash: "old" };
+    mockAppDir = "/tmp/__vellum_test_nonexistent__/app-1";
+    deploySpy.mockClear();
+    updatePublishedPageSpy.mockClear();
+  });
+
+  test("deploys the resolved effective HTML, not the empty htmlDefinition", async () => {
+    // htmlDefinition is "" (as it is for every multifile app); the real
+    // content comes from resolveEffectiveAppHtml. isMultifile=false here keeps
+    // the dist guard out of the way so the assertion targets the html source.
+    mockApp = makeApp({ htmlDefinition: "" });
+    mockEffectiveHtml = "<html><body>real app</body></html>";
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).toHaveBeenCalledTimes(1);
+    expect(deploySpy.mock.calls[0][0].html).toBe(
+      "<html><body>real app</body></html>",
+    );
+  });
+
+  test("skips deploy when a multifile app has no compiled output", async () => {
+    mockIsMultifile = true;
+    mockApp = makeApp({ formatVersion: 2 });
+    mockEffectiveHtml = "<p>App compilation failed.</p>";
+    // mockAppDir does not exist → dist/index.html is absent.
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).not.toHaveBeenCalled();
+  });
+
+  test("skips deploy when content hash is unchanged", async () => {
+    const html = "<html>same</html>";
+    mockEffectiveHtml = html;
+    const { createHash } = await import("node:crypto");
+    mockPublishedPage = {
+      id: "pp-1",
+      htmlHash: createHash("sha256").update(html).digest("hex"),
+    };
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).not.toHaveBeenCalled();
+  });
+
+  test("skips deploy when the app has no active published page", async () => {
+    mockPublishedPage = null;
+    mockEffectiveHtml = "<html>x</html>";
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/reaction-persistence.test.ts

@@ -27,7 +27,7 @@ mock.module("../config/env.js", () => ({
 }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 

package/src/__tests__/retry-thinking-adaptive-only.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Verifies that `RetryProvider.normalizeSendMessageOptions` drops a disabled
+ * thinking config for adaptive-thinking-only models (Claude Fable), preventing
+ * an Anthropic 400: Fable always reasons with always-on adaptive thinking and
+ * rejects `thinking: { type: "disabled" }`.
+ *
+ * Effort and other parameters are unaffected, and models that genuinely support
+ * disabling thinking (e.g. Opus) keep their disabled config.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+let mockLlmConfig: Record<string, unknown> = {};
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({ llm: mockLlmConfig }),
+}));
+
+import { LLMSchema } from "../config/schemas/llm.js";
+import { RetryProvider } from "../providers/retry.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../providers/types.js";
+
+function setLlmConfig(raw: unknown): void {
+  mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;
+}
+
+beforeEach(() => {
+  mockLlmConfig = LLMSchema.parse({}) as Record<string, unknown>;
+});
+
+function makePipeline(providerName: string): {
+  provider: Provider;
+  lastConfig: () => Record<string, unknown> | undefined;
+} {
+  let captured: Record<string, unknown> | undefined;
+  const inner: Provider = {
+    name: providerName,
+    async sendMessage(
+      _messages: Message[],
+      options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      captured = options?.config as Record<string, unknown> | undefined;
+      return {
+        content: [],
+        model: "test",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "stop",
+      };
+    },
+  };
+  return {
+    provider: new RetryProvider(inner),
+    lastConfig: () => captured,
+  };
+}
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "hi" }],
+};
+
+describe("retry normalization: adaptive-only thinking models", () => {
+  test("drops resolved thinking: disabled for Claude Fable", async () => {
+    // GIVEN a profile that disables thinking for an adaptive-only Fable model
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-fable-5",
+        thinking: { enabled: false },
+        effort: "high",
+      },
+    });
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN the disabled thinking config is dropped so Fable falls back to its
+    // always-on adaptive thinking instead of 400-ing
+    expect(lastConfig()?.thinking).toBeUndefined();
+    // AND effort is still forwarded
+    expect(lastConfig()?.effort).toBe("high");
+  });
+
+  test("drops explicit thinking: disabled from pass-through callers for Fable", async () => {
+    // GIVEN a pass-through caller supplying the wire-shape disabled config
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN sending against a Fable model
+    await provider.sendMessage([userMessage], {
+      config: {
+        model: "claude-fable-5",
+        thinking: { type: "disabled" },
+      },
+    });
+
+    // THEN the disabled thinking config is dropped
+    expect(lastConfig()?.thinking).toBeUndefined();
+  });
+
+  test("drops disabled thinking for OpenRouter-proxied Fable", async () => {
+    // GIVEN a profile disabling thinking on the OpenRouter-proxied Fable id
+    setLlmConfig({
+      default: {
+        provider: "openrouter",
+        model: "anthropic/claude-fable-5",
+        thinking: { enabled: false },
+      },
+    });
+    const { provider, lastConfig } = makePipeline("openrouter");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN the disabled thinking config is dropped
+    expect(lastConfig()?.thinking).toBeUndefined();
+  });
+
+  test("preserves adaptive thinking for Fable", async () => {
+    // GIVEN a profile that enables thinking for a Fable model
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-fable-5",
+        thinking: { enabled: true },
+      },
+    });
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN adaptive thinking is preserved (only disabled is dropped)
+    expect(lastConfig()?.thinking).toEqual({ type: "adaptive" });
+  });
+
+  test("preserves disabled thinking for models that support disabling it", async () => {
+    // GIVEN a profile disabling thinking for a non-adaptive-only model
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: false },
+      },
+    });
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN the disabled thinking config is preserved for Opus
+    expect(lastConfig()?.thinking).toEqual({ type: "disabled" });
+  });
+
+  test("drops non-1 temperature for Fable when thinking is disabled", async () => {
+    // GIVEN a Fable profile that disables thinking and sets a non-1 temperature
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-fable-5",
+        thinking: { enabled: false },
+        temperature: 0.7,
+      },
+    });
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN the disabled thinking is dropped (Fable falls back to adaptive) AND
+    // the non-1 temperature is dropped, since adaptive mode requires
+    // temperature: 1 — leaving it would 400 the request
+    expect(lastConfig()?.thinking).toBeUndefined();
+    expect(lastConfig()?.temperature).toBeUndefined();
+  });
+
+  test("drops non-1 temperature for Fable with no explicit thinking config", async () => {
+    // GIVEN a pass-through caller that sets a non-1 temperature and no thinking
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN sending against a Fable model
+    await provider.sendMessage([userMessage], {
+      config: {
+        model: "claude-fable-5",
+        temperature: 0.5,
+      },
+    });
+
+    // THEN the temperature is dropped: Fable is always in adaptive mode, so the
+    // temperature: 1 constraint applies even without an explicit thinking config
+    expect(lastConfig()?.temperature).toBeUndefined();
+  });
+
+  test("drops non-1 temperature for OpenRouter-proxied Fable", async () => {
+    // GIVEN a pass-through caller on the OpenRouter-proxied Fable id
+    const { provider, lastConfig } = makePipeline("openrouter");
+
+    // WHEN sending with a non-1 temperature and no explicit thinking config
+    await provider.sendMessage([userMessage], {
+      config: {
+        model: "anthropic/claude-fable-5",
+        temperature: 0.2,
+      },
+    });
+
+    // THEN the temperature is dropped for the Anthropic-fronted Fable model
+    expect(lastConfig()?.temperature).toBeUndefined();
+  });
+
+  test("preserves temperature: 1 for Fable", async () => {
+    // GIVEN a Fable profile with the only adaptive-mode-valid temperature
+    const { provider, lastConfig } = makePipeline("anthropic");
+
+    // WHEN sending against a Fable model
+    await provider.sendMessage([userMessage], {
+      config: {
+        model: "claude-fable-5",
+        temperature: 1,
+      },
+    });
+
+    // THEN temperature: 1 is preserved (it is valid in adaptive mode)
+    expect(lastConfig()?.temperature).toBe(1);
+  });
+});

package/src/__tests__/send-endpoint-busy.test.ts

@@ -91,11 +91,14 @@ mock.module("../config/loader.js", () => ({
 let _conversationFactory: (() => Conversation) | undefined;
 let _approvalGenerator: unknown;
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: () => {
     if (!_conversationFactory) return undefined;
     return _conversationFactory();
   },
+}));
+
+mock.module("../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async (..._args: unknown[]) => {
     if (!_conversationFactory)
       throw new Error("_conversationFactory not set in test");

package/src/__tests__/server-history-render.test.ts

@@ -808,6 +808,45 @@ describe("renderHistoryContent contentBlocks", () => {
     );
   });
 
+  test("surfaces persisted thinking timing onto the thinking block", () => {
+    // GIVEN a thinking block the daemon stamped with internal `_startedAt` /
+    // `_completedAt` timing at message_complete
+    const output = renderHistoryContent([
+      {
+        type: "thinking",
+        thinking: "reasoning",
+        signature: "sig",
+        _startedAt: 1000,
+        _completedAt: 1500,
+      },
+    ]);
+
+    // THEN the rendered block exposes them as the wire schema's
+    // startedAt/completedAt so the client can show the duration + hover state
+    expect(output.contentBlocks).toEqual([
+      {
+        type: "thinking",
+        thinking: "reasoning",
+        startedAt: 1000,
+        completedAt: 1500,
+      },
+    ]);
+  });
+
+  test("omits thinking timing when the block carries none", () => {
+    // GIVEN a thinking block with no persisted timing (older daemon / thinking
+    // streaming disabled)
+    const output = renderHistoryContent([
+      { type: "thinking", thinking: "reasoning", signature: "sig" },
+    ]);
+
+    // THEN the rendered block has no startedAt/completedAt and the client hides
+    // the duration, exactly as a tool call with no timing
+    expect(output.contentBlocks).toEqual([
+      { type: "thinking", thinking: "reasoning" },
+    ]);
+  });
+
   const pdfBlock = {
     type: "file",
     source: {

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -5,6 +5,8 @@
  * parses it via the real frontmatter parser, and verifies that `skillFlagKey()`
  * returns the correct key and `resolveSkillStates()` correctly gates the skill.
  */
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
@@ -225,3 +227,32 @@ describe("frontmatter feature-flag integration", () => {
     expect(resolvedOff.length).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Bundled ACP skill: discoverability when ACP is disabled
+// ---------------------------------------------------------------------------
+
+describe("bundled acp skill discoverability", () => {
+  test("acp skill resolves with no frontmatter flag gate", () => {
+    // The ACP skill carries its own first-time-setup instructions and is
+    // always discoverable: it has no frontmatter feature-flag gate.
+    const skillMdPath = fileURLToPath(
+      new URL("../config/bundled-skills/acp/SKILL.md", import.meta.url),
+    );
+    const skillMd = readFileSync(skillMdPath, "utf8");
+
+    const skill = buildSkillSummary("acp", skillMd);
+    expect(skill).not.toBeNull();
+    expect(skill!.featureFlag).toBeUndefined();
+    expect(skillFlagKey(skill!)).toBeUndefined();
+
+    const config = makeConfig({
+      acp: { maxConcurrentSessions: 4, agents: {} },
+    });
+
+    const resolved = resolveSkillStates([skill!], config);
+    expect(resolved.length).toBe(1);
+    expect(resolved[0].summary.id).toBe("acp");
+    expect(resolved[0].state).toBe("enabled");
+  });
+});

package/src/__tests__/steer-tool-repair.test.ts

@@ -14,7 +14,7 @@ import type { Message } from "../providers/types.js";
 /**
  * Minimal reproduction of repairPendingToolUseBlocks logic for direct
  * unit testing. The real implementation lives in conversation-process.ts.
- * This mirrors it exactly to avoid needing the full ProcessConversationContext.
+ * This mirrors it exactly to avoid needing the full Conversation.
  */
 function repairPendingToolUseBlocks(messages: Message[]): Message[] {
   if (messages.length === 0) return messages;

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -174,7 +174,7 @@ import { LLMSchema } from "../config/schemas/llm.js";
 import {
   clearConversations,
   setConversation,
-} from "../daemon/conversation-store.js";
+} from "../daemon/conversation-registry.js";
 import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
 import { SubagentManager } from "../subagent/manager.js";
 

package/src/__tests__/subagent-detail.test.ts

@@ -18,6 +18,7 @@ function msg(role: string, content: unknown[]): MessageRow {
     content: JSON.stringify(content),
     createdAt: Date.now(),
     metadata: null,
+    clientMessageId: null,
   };
 }
 
@@ -26,10 +27,19 @@ describe("parseSubagentMessages", () => {
     const messages = [
       msg("user", [{ type: "text", text: "Do something" }]),
       msg("assistant", [
-        { type: "tool_use", id: "t1", name: "web_search", input: { query: "test" } },
+        {
+          type: "tool_use",
+          id: "t1",
+          name: "web_search",
+          input: { query: "test" },
+        },
       ]),
       msg("user", [
-        { type: "tool_result", tool_use_id: "t1", content: "Search results here" },
+        {
+          type: "tool_result",
+          tool_use_id: "t1",
+          content: "Search results here",
+        },
       ]),
     ];
 
@@ -44,7 +54,12 @@ describe("parseSubagentMessages", () => {
     const messages = [
       msg("user", [{ type: "text", text: "Do something" }]),
       msg("assistant", [
-        { type: "tool_use", id: "t2", name: "file_read", input: { file_path: "/tmp/test.txt" } },
+        {
+          type: "tool_use",
+          id: "t2",
+          name: "file_read",
+          input: { file_path: "/tmp/test.txt" },
+        },
       ]),
       msg("user", [
         {
@@ -69,11 +84,14 @@ describe("parseSubagentMessages", () => {
     const messages = [
       msg("user", [{ type: "text", text: "Do something" }]),
       msg("assistant", [
-        { type: "tool_use", id: "t3", name: "bash", input: { command: "echo hi" } },
-      ]),
-      msg("user", [
-        { type: "tool_result", tool_use_id: "t3", content: null },
+        {
+          type: "tool_use",
+          id: "t3",
+          name: "bash",
+          input: { command: "echo hi" },
+        },
       ]),
+      msg("user", [{ type: "tool_result", tool_use_id: "t3", content: null }]),
     ];
 
     const result = parseSubagentMessages("sub-1", messages);