@vellumai/assistant 0.4.29 → 0.4.30

package/src/__tests__/session-media-retry.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+
+import { createContextSummaryMessage } from "../context/window-manager.js";
+import { stripMediaPayloadsForRetry } from "../daemon/session-media-retry.js";
+import type { ContentBlock, Message } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeImageBlock(
+  data = "AAAA",
+  mediaType = "image/png",
+): Extract<ContentBlock, { type: "image" }> {
+  return {
+    type: "image",
+    source: { type: "base64", media_type: mediaType, data },
+  };
+}
+
+function makeUserMessage(...blocks: ContentBlock[]): Message {
+  return { role: "user", content: blocks };
+}
+
+function makeAssistantMessage(...blocks: ContentBlock[]): Message {
+  return { role: "assistant", content: blocks };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("stripMediaPayloadsForRetry", () => {
+  test("keeps images in the latest user message", () => {
+    const img = makeImageBlock();
+    const messages: Message[] = [
+      makeUserMessage({ type: "text", text: "hello" }, img),
+    ];
+
+    const result = stripMediaPayloadsForRetry(messages);
+    expect(result.modified).toBe(false);
+    expect(result.replacedBlocks).toBe(0);
+  });
+
+  test("strips images from older user messages", () => {
+    const messages: Message[] = [
+      makeUserMessage({ type: "text", text: "old" }, makeImageBlock()),
+      makeAssistantMessage({ type: "text", text: "response" }),
+      makeUserMessage({ type: "text", text: "new" }),
+    ];
+
+    const result = stripMediaPayloadsForRetry(messages);
+    expect(result.modified).toBe(true);
+    expect(result.replacedBlocks).toBe(1);
+    // The image in the first message should be replaced with a text stub
+    const firstMsg = result.messages[0];
+    expect(firstMsg.content[1].type).toBe("text");
+    expect(
+      (firstMsg.content[1] as { type: "text"; text: string }).text,
+    ).toContain("Image omitted");
+  });
+
+  test("keeps images in summary message when it is the only user message", () => {
+    // This is the bug scenario: forced compaction with minKeepRecentUserTurns: 0
+    // compacts everything, preserving images into the summary message. Media
+    // stubbing should NOT strip those images since there's no other user message.
+    const img = makeImageBlock();
+    const summaryMsg = createContextSummaryMessage(
+      "Prior conversation summary",
+    );
+    summaryMsg.content.push(
+      {
+        type: "text",
+        text: "[The following images were uploaded by the user in earlier messages and are preserved for reference.]",
+      },
+      img,
+    );
+
+    const messages: Message[] = [summaryMsg];
+
+    const result = stripMediaPayloadsForRetry(messages);
+    expect(result.modified).toBe(false);
+    expect(result.replacedBlocks).toBe(0);
+    // The image should still be present
+    const imageBlocks = result.messages[0].content.filter(
+      (b) => b.type === "image",
+    );
+    expect(imageBlocks.length).toBe(1);
+  });
+
+  test("keeps images in summary message when only other user messages are tool-result-only", () => {
+    const img = makeImageBlock();
+    const summaryMsg = createContextSummaryMessage("Summary");
+    summaryMsg.content.push(img);
+
+    const toolResultMsg: Message = {
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: "tool-1",
+          content: "result text",
+        },
+      ],
+    };
+
+    const messages: Message[] = [
+      summaryMsg,
+      makeAssistantMessage({ type: "text", text: "ok" }),
+      toolResultMsg,
+    ];
+
+    const result = stripMediaPayloadsForRetry(messages);
+    expect(result.modified).toBe(false);
+    expect(result.replacedBlocks).toBe(0);
+  });
+
+  test("prefers non-summary user message over summary when both exist", () => {
+    const summaryImg = makeImageBlock("BBBB");
+    const summaryMsg = createContextSummaryMessage("Summary");
+    summaryMsg.content.push(summaryImg);
+
+    const userImg = makeImageBlock("CCCC");
+    const userMsg = makeUserMessage({ type: "text", text: "latest" }, userImg);
+
+    const messages: Message[] = [
+      summaryMsg,
+      makeAssistantMessage({ type: "text", text: "response" }),
+      userMsg,
+    ];
+
+    const result = stripMediaPayloadsForRetry(messages);
+    // Summary image should be stripped, user image should be kept
+    expect(result.modified).toBe(true);
+    expect(result.replacedBlocks).toBe(1);
+
+    // Summary message image → stubbed
+    const summaryBlocks = result.messages[0].content;
+    const summaryImageBlocks = summaryBlocks.filter((b) => b.type === "image");
+    expect(summaryImageBlocks.length).toBe(0);
+
+    // Latest user message image → kept
+    const userBlocks = result.messages[2].content;
+    const userImageBlocks = userBlocks.filter((b) => b.type === "image");
+    expect(userImageBlocks.length).toBe(1);
+  });
+});

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

@@ -141,17 +141,20 @@ describe("buildSystemPrompt feature flag filtering", () => {
 
     currentConfig = {
       sandbox: { enabled: false, backend: "native" },
-      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: false },
+      assistantFeatureFlagValues: {
+        [DECLARED_FLAG_KEY]: false,
+        "feature_flags.twitter.enabled": true,
+      },
     };
 
     const result = buildSystemPrompt();
 
-    // twitter should be visible, declared flagged skill should not
+    // twitter is explicitly enabled, declared flagged skill is explicitly off
     expect(result).toContain('id="twitter"');
     expect(result).not.toContain(`id="${DECLARED_SKILL_ID}"`);
   });
 
-  test("all skills visible when featureFlags is empty", () => {
+  test("declared skills hidden when featureFlags is empty (registry defaults to false)", () => {
     createSkillOnDisk(
       DECLARED_SKILL_ID,
       "Hatch New Assistant",
@@ -166,8 +169,9 @@ describe("buildSystemPrompt feature flag filtering", () => {
 
     const result = buildSystemPrompt();
 
-    expect(result).toContain(`id="${DECLARED_SKILL_ID}"`);
-    expect(result).toContain('id="twitter"');
+    // Both skills are declared in the registry with defaultEnabled: false
+    expect(result).not.toContain(`id="${DECLARED_SKILL_ID}"`);
+    expect(result).not.toContain('id="twitter"');
   });
 
   test("flagged-off skills hidden even when all workspace skill flags are OFF", () => {

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

@@ -59,9 +59,9 @@ function makeSkill(
 // ---------------------------------------------------------------------------
 
 describe("isSkillFeatureEnabled", () => {
-  test("returns true when no flag overrides", () => {
+  test("returns false when no flag overrides (registry default is false)", () => {
     const config = makeConfig();
-    expect(isSkillFeatureEnabled(DECLARED_SKILL_ID, config)).toBe(true);
+    expect(isSkillFeatureEnabled(DECLARED_SKILL_ID, config)).toBe(false);
   });
 
   test("returns true when skill key is explicitly true", () => {
@@ -103,8 +103,10 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
   test("falls back to registry default when no override", () => {
     const config = makeConfig();
-    // hatch-new-assistant defaults to true in the registry
-    expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(true);
+    // hatch-new-assistant defaults to false in the registry
+    expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
+      false,
+    );
   });
 
   test("respects persisted overrides for undeclared keys", () => {
@@ -116,11 +118,12 @@ describe("isAssistantFeatureFlagEnabled", () => {
     ).toBe(false);
   });
 
-  test("undeclared keys with no persisted override default to enabled", () => {
+  test("declared keys with no persisted override use registry default", () => {
     const config = makeConfig();
+    // browser is declared in the registry with defaultEnabled: false
     expect(
       isAssistantFeatureFlagEnabled("feature_flags.browser.enabled", config),
-    ).toBe(true);
+    ).toBe(false);
   });
 });
 
@@ -132,7 +135,10 @@ describe("resolveSkillStates with feature flags", () => {
   test("flag OFF skill does not appear in resolved list", () => {
     const catalog = [makeSkill(DECLARED_SKILL_ID), makeSkill("twitter")];
     const config = makeConfig({
-      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: false },
+      assistantFeatureFlagValues: {
+        [DECLARED_FLAG_KEY]: false,
+        "feature_flags.twitter.enabled": true,
+      },
     });
 
     const resolved = resolveSkillStates(catalog, config);
@@ -158,13 +164,13 @@ describe("resolveSkillStates with feature flags", () => {
     expect(ids).toContain("twitter");
   });
 
-  test("missing flag key defaults to enabled", () => {
+  test("declared flag key defaults to registry value (false)", () => {
     const catalog = [makeSkill(DECLARED_SKILL_ID)];
     const config = makeConfig();
 
     const resolved = resolveSkillStates(catalog, config);
-    expect(resolved.length).toBe(1);
-    expect(resolved[0].summary.id).toBe(DECLARED_SKILL_ID);
+    // hatch-new-assistant registry default is false, so it's filtered out
+    expect(resolved.length).toBe(0);
   });
 
   test("feature flag OFF takes precedence over user-enabled config entry", () => {
@@ -202,6 +208,7 @@ describe("resolveSkillStates with feature flags", () => {
     const config = makeConfig({
       assistantFeatureFlagValues: {
         [DECLARED_FLAG_KEY]: false,
+        "feature_flags.twitter.enabled": true,
         "feature_flags.deploy.enabled": false,
       },
     });
@@ -209,8 +216,7 @@ describe("resolveSkillStates with feature flags", () => {
     const resolved = resolveSkillStates(catalog, config);
     const ids = resolved.map((r) => r.summary.id);
 
-    // Both declared (hatch-new-assistant) and undeclared (deploy) skills with
-    // persisted false overrides are filtered out; only twitter remains.
+    // hatch-new-assistant and deploy explicitly false; twitter explicitly true
     expect(ids).toEqual(["twitter"]);
   });
 });

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -154,7 +154,7 @@ describe("skill_load feature flag enforcement", () => {
     expect(result.content).toContain("Skill: Hatch New Assistant");
   });
 
-  test("loads skill normally when flag key is absent (defaults to enabled)", async () => {
+  test("rejects skill when flag key is absent (registry defaults to disabled)", async () => {
     writeSkill(
       DECLARED_SKILL_ID,
       "Hatch New Assistant",
@@ -172,7 +172,8 @@ describe("skill_load feature flag enforcement", () => {
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Skill: Hatch New Assistant");
+    // hatch-new-assistant is declared in the registry with defaultEnabled: false
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("disabled by feature flag");
   });
 });

package/src/__tests__/slack-block-formatting.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  isSlackCallbackUrl,
+  textToSlackBlocks,
+} from "../runtime/slack-block-formatting.js";
+
+describe("textToSlackBlocks", () => {
+  test("returns undefined for empty text", () => {
+    expect(textToSlackBlocks("")).toBeUndefined();
+    expect(textToSlackBlocks("   ")).toBeUndefined();
+  });
+
+  test("converts plain text to a single section block", () => {
+    const blocks = textToSlackBlocks("Hello, world!");
+    expect(blocks).toEqual([
+      { type: "section", text: { type: "mrkdwn", text: "Hello, world!" } },
+    ]);
+  });
+
+  test("converts heading to header block", () => {
+    const blocks = textToSlackBlocks("# Title\n\nBody text.");
+    expect(blocks).toBeDefined();
+    expect(blocks![0]).toEqual({
+      type: "header",
+      text: { type: "plain_text", text: "Title" },
+    });
+  });
+
+  test("wraps fenced code in triple backticks", () => {
+    const blocks = textToSlackBlocks("```ts\nconst x = 1;\n```");
+    expect(blocks).toBeDefined();
+    expect(blocks![0]).toEqual({
+      type: "section",
+      text: { type: "mrkdwn", text: "```ts\nconst x = 1;\n```" },
+    });
+  });
+
+  test("converts markdown links to Slack format", () => {
+    const blocks = textToSlackBlocks("See [docs](https://example.com).");
+    expect(blocks).toBeDefined();
+    expect(blocks![0].type).toBe("section");
+    const sectionBlock = blocks![0] as {
+      type: "section";
+      text: { type: string; text: string };
+    };
+    expect(sectionBlock.text.text).toBe("See <https://example.com|docs>.");
+  });
+
+  test("converts **bold** to *bold*", () => {
+    const blocks = textToSlackBlocks("**important**");
+    expect(blocks).toBeDefined();
+    const sectionBlock = blocks![0] as {
+      type: "section";
+      text: { type: string; text: string };
+    };
+    expect(sectionBlock.text.text).toBe("*important*");
+  });
+
+  test("inserts dividers between segments", () => {
+    const blocks = textToSlackBlocks("# Heading\n\nParagraph.");
+    expect(blocks).toBeDefined();
+    const types = blocks!.map((b) => b.type);
+    expect(types).toContain("divider");
+  });
+});
+
+describe("isSlackCallbackUrl", () => {
+  test("returns true for Slack deliver URLs", () => {
+    expect(
+      isSlackCallbackUrl(
+        "http://127.0.0.1:7830/deliver/slack?threadTs=123&channel=C456",
+      ),
+    ).toBe(true);
+  });
+
+  test("returns true for bare Slack deliver path", () => {
+    expect(isSlackCallbackUrl("http://localhost:7830/deliver/slack")).toBe(
+      true,
+    );
+  });
+
+  test("returns false for non-Slack URLs", () => {
+    expect(isSlackCallbackUrl("http://localhost:7830/deliver/telegram")).toBe(
+      false,
+    );
+  });
+
+  test("returns false for invalid URLs", () => {
+    expect(isSlackCallbackUrl("not-a-url")).toBe(false);
+  });
+
+  test("returns false for managed outbound URLs", () => {
+    expect(
+      isSlackCallbackUrl(
+        "http://localhost:7830/v1/internal/managed-gateway/outbound-send/?route_id=r1&assistant_id=a1&source_channel=sms",
+      ),
+    ).toBe(false);
+  });
+});