@vellumai/assistant 0.4.44 → 0.4.45

package/src/__tests__/session-surfaces-task-progress.test.ts

@@ -145,6 +145,40 @@ describe("task_progress surface compatibility", () => {
     });
   });
 
+  test("ui_show supports file_upload surfaces directly", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "file_upload",
+      title: "Upload a receipt",
+      data: {
+        prompt: "Share the receipt PDF",
+        acceptedTypes: ["application/pdf"],
+        maxFiles: 1,
+      },
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.yieldToUser).toBe(true);
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    );
+    expect(showMessage).toBeDefined();
+    if (!showMessage || showMessage.surfaceType !== "file_upload") return;
+
+    expect(showMessage.title).toBe("Upload a receipt");
+    expect(showMessage.data).toEqual({
+      prompt: "Share the receipt PDF",
+      acceptedTypes: ["application/pdf"],
+      maxFiles: 1,
+    });
+    expect(ctx.pendingSurfaceActions.get(showMessage.surfaceId)).toEqual({
+      surfaceType: "file_upload",
+    });
+  });
+
   test("ui_show dynamic_page uses data.html when properly nested", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);

package/src/__tests__/session-usage.test.ts

@@ -17,7 +17,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/session-workspace-cache-state.test.ts

@@ -13,7 +13,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 
@@ -32,11 +31,8 @@ mock.module("../config/loader.js", () => ({
     contextWindow: {
       enabled: true,
       maxInputTokens: 100000,
-      targetInputTokens: 80000,
-      compactThreshold: 0.8,
-      preserveRecentUserTurns: 8,
-      summaryMaxTokens: 512,
-      chunkTokens: 12000,
+      targetBudgetRatio: 0.30,
+      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
     },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     apiKeys: {},

package/src/__tests__/session-workspace-injection.test.ts

@@ -21,7 +21,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 
@@ -46,11 +45,8 @@ mock.module("../config/loader.js", () => ({
     contextWindow: {
       enabled: true,
       maxInputTokens: 100000,
-      targetInputTokens: 80000,
-      compactThreshold: 0.8,
-      preserveRecentUserTurns: 8,
-      summaryMaxTokens: 512,
-      chunkTokens: 12000,
+      targetBudgetRatio: 0.30,
+      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
       overflowRecovery: {
         enabled: true,
         safetyMarginRatio: 0.05,

package/src/__tests__/session-workspace-tool-tracking.test.ts

@@ -19,7 +19,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 
@@ -44,11 +43,8 @@ mock.module("../config/loader.js", () => ({
     contextWindow: {
       enabled: true,
       maxInputTokens: 100000,
-      targetInputTokens: 80000,
-      compactThreshold: 0.8,
-      preserveRecentUserTurns: 8,
-      summaryMaxTokens: 512,
-      chunkTokens: 12000,
+      targetBudgetRatio: 0.30,
+      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
       overflowRecovery: {
         enabled: true,
         safetyMarginRatio: 0.05,

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

@@ -1,218 +1,214 @@
 /**
- * Integration tests for skill feature flag enforcement at system prompt,
- * skill_load, and session-skill-tools projection layers.
+ * Integration test: end-to-end frontmatter parsing → feature flag resolution.
+ *
+ * Creates a SKILL.md with a `feature-flag` field in its YAML metadata,
+ * parses it via the real frontmatter parser, and verifies that `skillFlagKey()`
+ * returns the correct key and `resolveSkillStates()` correctly gates the skill.
  */
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 
-// ---------------------------------------------------------------------------
-// Test-scoped temp directory and config state
-// ---------------------------------------------------------------------------
-
-const TEST_DIR = join(
-  tmpdir(),
-  `vellum-skill-flags-test-${crypto.randomUUID()}`,
-);
-
-let currentConfig: Record<string, unknown> = {
-  sandbox: { enabled: false, backend: "native" },
-};
-
-const DECLARED_SKILL_ID = "hatch-new-assistant";
-const DECLARED_FLAG_KEY = "feature_flags.hatch-new-assistant.enabled";
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realPlatform = require("../util/platform.js");
-mock.module("../util/platform.js", () => ({
-  ...realPlatform,
-  getRootDir: () => TEST_DIR,
-  getDataDir: () => TEST_DIR,
-  getWorkspaceDir: () => TEST_DIR,
-  getWorkspaceConfigPath: () => join(TEST_DIR, "config.json"),
-  getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
-  getWorkspaceHooksDir: () => join(TEST_DIR, "hooks"),
-  getWorkspacePromptPath: (file: string) => join(TEST_DIR, file),
-  ensureDataDir: () => {},
-  getSocketPath: () => join(TEST_DIR, "vellum.sock"),
-  getPidPath: () => join(TEST_DIR, "vellum.pid"),
-  getDbPath: () => join(TEST_DIR, "data", "assistant.db"),
-  getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
-  getHistoryPath: () => join(TEST_DIR, "history"),
-  getHooksDir: () => join(TEST_DIR, "hooks"),
-
-  getSandboxRootDir: () => join(TEST_DIR, "sandbox"),
-  getSandboxWorkingDir: () => TEST_DIR,
-  getInterfacesDir: () => join(TEST_DIR, "interfaces"),
-  isMacOS: () => false,
-  isLinux: () => false,
-  isWindows: () => false,
-  getPlatformName: () => "linux",
-  getClipboardCommand: () => null,
-  readSessionToken: () => null,
-}));
-
-const noopLogger = new Proxy({} as Record<string, unknown>, {
-  get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
-});
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realLogger = require("../util/logger.js");
-mock.module("../util/logger.js", () => ({
-  ...realLogger,
-  getLogger: () => noopLogger,
-  getCliLogger: () => noopLogger,
-  isDebug: () => false,
-  truncateForLog: (v: string) => v,
-  initLogger: () => {},
-  pruneOldLogFiles: () => 0,
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => currentConfig,
-  loadConfig: () => currentConfig,
-  loadRawConfig: () => ({}),
-  saveConfig: () => {},
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  syncConfigToLockfile: () => {},
-}));
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realUserReference = require("../prompts/user-reference.js");
-mock.module("../prompts/user-reference.js", () => ({
-  ...realUserReference,
-  resolveUserReference: () => "TestUser",
-  resolveUserPronouns: () => null,
-}));
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realCredentialMetadataStore = require("../tools/credentials/metadata-store.js");
-mock.module("../tools/credentials/metadata-store.js", () => ({
-  ...realCredentialMetadataStore,
-  listCredentialMetadata: () => [],
-}));
-
-const { buildSystemPrompt } = await import("../prompts/system-prompt.js");
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import type { AssistantConfig } from "../config/schema.js";
+import { resolveSkillStates, skillFlagKey } from "../config/skill-state.js";
+import type { SkillSummary } from "../config/skills.js";
+import { parseFrontmatterFields } from "../skills/frontmatter.js";
 
 // ---------------------------------------------------------------------------
-// Setup / Teardown
+// Fixtures
 // ---------------------------------------------------------------------------
 
-beforeEach(() => {
-  mkdirSync(TEST_DIR, { recursive: true });
-  // Reset config to defaults before each test
-  currentConfig = {
-    sandbox: { enabled: false, backend: "native" },
-  };
-});
-
-afterEach(() => {
-  if (existsSync(TEST_DIR)) {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  }
-});
+/** A SKILL.md with `feature-flag: contacts` declared in its vellum metadata. */
+const SKILL_MD_WITH_FLAG = `---
+name: "Contacts"
+description: "View and manage contacts"
+metadata:
+  vellum:
+    feature-flag: contacts
+---
+
+Instructions for the contacts skill.
+`;
+
+/** A SKILL.md with no feature-flag field at all. */
+const SKILL_MD_WITHOUT_FLAG = `---
+name: "Plain Skill"
+description: "A skill with no feature flag"
+metadata:
+  vellum: {}
+---
+
+Instructions for the plain skill.
+`;
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function createSkillOnDisk(
+/** Create a minimal AssistantConfig with optional feature flag values. */
+function makeConfig(overrides: Partial<AssistantConfig> = {}): AssistantConfig {
+  return {
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+    ...overrides,
+  } as AssistantConfig;
+}
+
+/**
+ * Build a SkillSummary from parsed frontmatter, mimicking what the real
+ * skill catalog loader does.
+ */
+function buildSkillSummary(
   id: string,
-  name: string,
-  description: string,
-): void {
-  const skillsDir = join(TEST_DIR, "skills");
-  mkdirSync(join(skillsDir, id), { recursive: true });
-  writeFileSync(
-    join(skillsDir, id, "SKILL.md"),
-    `---\nname: "${name}"\ndescription: "${description}"\n---\n\nInstructions for ${id}.\n`,
-  );
-  // Ensure SKILLS.md index references the skill
-  const indexPath = join(skillsDir, "SKILLS.md");
-  const existing = existsSync(indexPath)
-    ? readFileSync(indexPath, "utf-8")
-    : "";
-  writeFileSync(indexPath, existing + `- ${id}\n`);
+  skillMd: string,
+  source: "bundled" | "managed" = "bundled",
+): SkillSummary | null {
+  const parsed = parseFrontmatterFields(skillMd);
+  if (!parsed) return null;
+
+  let featureFlag: string | undefined;
+  const metadataObj = parsed.fields.metadata;
+  if (metadataObj != null && typeof metadataObj === "object") {
+    const vellum = (metadataObj as Record<string, unknown>).vellum as
+      | Record<string, unknown>
+      | undefined;
+    featureFlag =
+      typeof vellum?.["feature-flag"] === "string"
+        ? vellum["feature-flag"]
+        : undefined;
+  }
+
+  return {
+    id,
+    name: (parsed.fields.name as string) ?? id,
+    displayName: (parsed.fields.name as string) ?? id,
+    description: (parsed.fields.description as string) ?? "",
+    directoryPath: `/fake/skills/${id}`,
+    skillFilePath: `/fake/skills/${id}/SKILL.md`,
+    bundled: source === "bundled",
+    userInvocable: true,
+    disableModelInvocation: false,
+    source,
+    featureFlag,
+  };
 }
 
 // ---------------------------------------------------------------------------
-// System prompt — feature flag filtering
+// Tests
 // ---------------------------------------------------------------------------
 
-describe("buildSystemPrompt feature flag filtering", () => {
-  test("flag OFF skill does not appear in <available_skills> section", () => {
-    createSkillOnDisk(
-      DECLARED_SKILL_ID,
-      "Hatch New Assistant",
-      "Toggle hatch new assistant behavior",
-    );
-    createSkillOnDisk("twitter", "Twitter", "Post to X/Twitter");
-
-    currentConfig = {
-      sandbox: { enabled: false, backend: "native" },
-      assistantFeatureFlagValues: {
-        [DECLARED_FLAG_KEY]: false,
-        "feature_flags.twitter.enabled": true,
-      },
-    };
+describe("frontmatter feature-flag integration", () => {
+  test("parses feature-flag from frontmatter YAML metadata", () => {
+    const parsed = parseFrontmatterFields(SKILL_MD_WITH_FLAG);
+    expect(parsed).not.toBeNull();
 
-    const result = buildSystemPrompt();
+    const metadataObj = parsed!.fields.metadata as Record<string, unknown>;
+    expect(metadataObj).toBeTruthy();
 
-    // twitter is explicitly enabled, declared flagged skill is explicitly off
-    expect(result).toContain('id="twitter"');
-    expect(result).not.toContain(`id="${DECLARED_SKILL_ID}"`);
+    const vellum = metadataObj.vellum as Record<string, unknown>;
+    expect(vellum["feature-flag"]).toBe("contacts");
   });
 
-  test("declared skills hidden when no overrides set (registry defaults to false)", () => {
-    createSkillOnDisk(
-      DECLARED_SKILL_ID,
-      "Hatch New Assistant",
-      "Toggle hatch new assistant behavior",
-    );
-    createSkillOnDisk("twitter", "Twitter", "Post to X/Twitter");
+  test("skillFlagKey returns correct key for parsed skill", () => {
+    const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG);
+    expect(skill).not.toBeNull();
+    expect(skill!.featureFlag).toBe("contacts");
 
-    currentConfig = {
-      sandbox: { enabled: false, backend: "native" },
-      assistantFeatureFlagValues: {},
-    };
+    const key = skillFlagKey(skill!);
+    expect(key).toBe("feature_flags.contacts.enabled");
+  });
 
-    const result = buildSystemPrompt();
+  test("skillFlagKey returns undefined for skill without feature-flag", () => {
+    const skill = buildSkillSummary("plain-skill", SKILL_MD_WITHOUT_FLAG);
+    expect(skill).not.toBeNull();
+    expect(skill!.featureFlag).toBeUndefined();
 
-    // Both skills are declared in the registry with defaultEnabled: false
-    expect(result).not.toContain(`id="${DECLARED_SKILL_ID}"`);
-    expect(result).not.toContain('id="twitter"');
+    const key = skillFlagKey(skill!);
+    expect(key).toBeUndefined();
   });
 
-  test("flagged-off skills hidden even when all workspace skill flags are OFF", () => {
-    createSkillOnDisk(
-      DECLARED_SKILL_ID,
-      "Hatch New Assistant",
-      "Toggle hatch new assistant behavior",
-    );
-    createSkillOnDisk("twitter", "Twitter", "Post to X/Twitter");
+  test("resolveSkillStates gates skill with featureFlag when flag is OFF", () => {
+    const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG)!;
+    // "contacts" is in the registry with defaultEnabled: false
+    const config = makeConfig();
 
-    currentConfig = {
-      sandbox: { enabled: false, backend: "native" },
+    const resolved = resolveSkillStates([skill], config);
+    // Flag defaults to false → skill is filtered out
+    expect(resolved.length).toBe(0);
+  });
+
+  test("resolveSkillStates includes skill with featureFlag when flag is ON", () => {
+    const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG)!;
+    const config = makeConfig({
       assistantFeatureFlagValues: {
-        [DECLARED_FLAG_KEY]: false,
-        "feature_flags.twitter.enabled": false,
+        "feature_flags.contacts.enabled": true,
       },
-    };
+    });
+
+    const resolved = resolveSkillStates([skill], config);
+    expect(resolved.length).toBe(1);
+    expect(resolved[0].summary.id).toBe("contacts");
+  });
 
-    const result = buildSystemPrompt();
+  test("resolveSkillStates never gates skill without featureFlag", () => {
+    const skill = buildSkillSummary("plain-skill", SKILL_MD_WITHOUT_FLAG)!;
+    // Even with an explicit false override for this skill ID, it should pass through
+    const config = makeConfig({
+      assistantFeatureFlagValues: {
+        "feature_flags.plain-skill.enabled": false,
+      },
+    });
+
+    const resolved = resolveSkillStates([skill], config);
+    expect(resolved.length).toBe(1);
+    expect(resolved[0].summary.id).toBe("plain-skill");
+  });
 
-    // Both are hidden: declared skill via registry, undeclared via persisted override.
-    expect(result).not.toContain(`id="${DECLARED_SKILL_ID}"`);
-    expect(result).not.toContain('id="twitter"');
+  test("end-to-end: parse frontmatter → skillFlagKey → flag check → resolveSkillStates", () => {
+    // Step 1: Parse SKILL.md with feature-flag in metadata
+    const parsed = parseFrontmatterFields(SKILL_MD_WITH_FLAG);
+    expect(parsed).not.toBeNull();
+    const metadataObj = parsed!.fields.metadata as Record<string, unknown>;
+    const vellum = metadataObj.vellum as Record<string, unknown>;
+    const flagId = vellum["feature-flag"];
+    expect(flagId).toBe("contacts");
+
+    // Step 2: Build SkillSummary (as the catalog loader would)
+    const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG)!;
+    expect(skill.featureFlag).toBe("contacts");
+
+    // Step 3: Derive the flag key
+    const key = skillFlagKey(skill);
+    expect(key).toBe("feature_flags.contacts.enabled");
+
+    // Step 4: Check flag state — "contacts" has defaultEnabled: false in registry
+    const configOff = makeConfig();
+    expect(isAssistantFeatureFlagEnabled(key!, configOff)).toBe(false);
+
+    // Step 5: resolveSkillStates correctly filters it out
+    const resolvedOff = resolveSkillStates([skill], configOff);
+    expect(resolvedOff.length).toBe(0);
+
+    // Step 6: With override enabled, skill passes through
+    const configOn = makeConfig({
+      assistantFeatureFlagValues: { [key!]: true },
+    });
+    expect(isAssistantFeatureFlagEnabled(key!, configOn)).toBe(true);
+
+    const resolvedOn = resolveSkillStates([skill], configOn);
+    expect(resolvedOn.length).toBe(1);
+    expect(resolvedOn[0].summary.id).toBe("contacts");
   });
 });