@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.3

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -11,6 +11,7 @@ import {
   clearFeatureFlagOverridesCache,
   initFeatureFlagOverrides,
   isAssistantFeatureFlagEnabled,
+  refreshOverridesFromGateway,
 } from "../config/assistant-feature-flags.js";
 import { mockGatewayIpc, resetMockGatewayIpc } from "./mock-gateway-ipc.js";
 
@@ -110,3 +111,51 @@ describe("initFeatureFlagOverrides", () => {
     expect(isAssistantFeatureFlagEnabled("second-call", config)).toBe(false);
   });
 });
+
+describe("refreshOverridesFromGateway", () => {
+  it("replaces the cache with the new gateway values", async () => {
+    mockGatewayIpc({ "moving-flag": true });
+    await initFeatureFlagOverrides();
+
+    resetMockGatewayIpc();
+    mockGatewayIpc({ "moving-flag": false });
+
+    expect(await refreshOverridesFromGateway()).toBe(true);
+
+    const config = {} as any;
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(false);
+  });
+
+  it("keeps the last known values when the refresh fails", async () => {
+    mockGatewayIpc({ "moving-flag": true });
+    await initFeatureFlagOverrides();
+
+    resetMockGatewayIpc();
+    mockGatewayIpc(null, { error: true });
+
+    expect(await refreshOverridesFromGateway()).toBe(false);
+
+    // A failed refresh must not drop the flag to its registry default: a
+    // value the assistant selects behavior from (an experiment arm, a kill
+    // switch) would otherwise flip on one timed-out IPC call.
+    const config = {} as any;
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(true);
+  });
+
+  it("keeps the cache readable for the whole call", async () => {
+    mockGatewayIpc({ "moving-flag": true });
+    await initFeatureFlagOverrides();
+
+    resetMockGatewayIpc();
+    mockGatewayIpc({ "moving-flag": false });
+
+    const config = {} as any;
+    const inFlight = refreshOverridesFromGateway();
+    // A sync read landing mid-refresh sees the previous values, never an
+    // empty cache.
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(true);
+
+    await inFlight;
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(false);
+  });
+});

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -47,6 +47,9 @@ import { skillLoadTool } from "../tools/skills/load.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
+/** scaffold_managed_skill requires activation hints; a fixed set for tests. */
+const HINTS = ["user asks to run the lifecycle test procedure"];
+
 function makeContext(): ToolContext {
   return {
     workingDir: "/tmp",
@@ -126,6 +129,7 @@ Run the custom lifecycle verification procedure.
         name: "Lifecycle Test",
         description: "Integration test skill.",
         body_markdown: "Run the lifecycle test procedure.",
+        activation_hints: HINTS,
         emoji: "🧪",
       },
       makeContext(),
@@ -185,6 +189,7 @@ Run the custom lifecycle verification procedure.
         name: "V1",
         description: "Version 1.",
         body_markdown: "Original body.",
+        activation_hints: HINTS,
       },
       ctx,
     );
@@ -196,6 +201,7 @@ Run the custom lifecycle verification procedure.
         name: "V2",
         description: "Version 2.",
         body_markdown: "Updated body.",
+        activation_hints: HINTS,
         overwrite: true,
       },
       ctx,
@@ -241,6 +247,7 @@ Run the custom lifecycle verification procedure.
         description: "Created from scaffold.",
         body_markdown:
           "This skill was dynamically created.\n\nRun: `echo chain-test-ok`",
+        activation_hints: HINTS,
       },
       ctx,
     );

package/src/__tests__/media-generate-image.test.ts

@@ -1,6 +1,14 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { readFileSync } from "fs";
+import {
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "fs";
+import { tmpdir } from "os";
 import { dirname, join } from "path";
 
 import { __resetRegistryForTesting, getTool } from "../tools/registry.js";
@@ -97,8 +105,23 @@ import { run } from "../config/bundled-skills/image-studio/tools/media-generate-
 // Clean up after this file to prevent contamination of later test files.
 afterAll(() => {
   __resetRegistryForTesting();
+  for (const dir of tempWorkingDirs) {
+    rmSync(dir, { recursive: true, force: true });
+  }
 });
 
+const tempWorkingDirs: string[] = [];
+
+/** Build a ToolContext with a fresh temp working directory. */
+function makeContext(): ToolContext {
+  const workingDir = mkdtempSync(join(tmpdir(), "media-gen-test-"));
+  tempWorkingDirs.push(workingDir);
+  return {
+    conversationId: "conv-123",
+    workingDir,
+  } as unknown as ToolContext;
+}
+
 const CONFIG_DIR = join(
   dirname(import.meta.dirname!),
   "config",
@@ -128,12 +151,10 @@ beforeEach(() => {
     platformBaseUrl: "",
     assistantApiKey: "",
   };
+  fakeContext = makeContext();
 });
 
-const fakeContext = {
-  conversationId: "conv-123",
-  workingDir: "/tmp",
-} as unknown as ToolContext;
+let fakeContext: ToolContext;
 
 describe("image-studio skill script wrapper", () => {
   test("exports a run function without registering media_generate_image in the tool registry", async () => {
@@ -431,28 +452,117 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("reads source images from file paths on disk", async () => {
-    // Write a temp image file inside the workspace (fakeContext.workingDir = /tmp)
-    const tmpPath = join("/tmp", "test-source-image.png");
+    // Write a temp image file inside the workspace
+    const tmpPath = join(fakeContext.workingDir, "test-source-image.png");
     const pngBytes = Buffer.from(
       "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==",
       "base64",
     );
     await Bun.write(tmpPath, pngBytes);
 
-    try {
-      const result = await run(
-        { prompt: "edit this", mode: "edit", source_paths: [tmpPath] },
-        fakeContext,
-      );
-
-      expect(result.isError).toBe(false);
-      expect(result.content).toContain("Generated 1 image");
-    } finally {
-      const { unlink } = await import("fs/promises");
-      if (await Bun.file(tmpPath).exists()) {
-        await unlink(tmpPath);
-      }
-    }
+    const result = await run(
+      { prompt: "edit this", mode: "edit", source_paths: [tmpPath] },
+      fakeContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Generated 1 image");
+  });
+
+  test("saves the image into media/generated and returns the embed instruction", async () => {
+    const result = await run({ prompt: "a sunset" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Saved to media/generated/a-sunset.png");
+    expect(result.content).toContain(
+      "![description](vellum://workspace/media/generated/a-sunset.png)",
+    );
+    const saved = Bun.file(
+      join(fakeContext.workingDir, "media/generated/a-sunset.png"),
+    );
+    expect(await saved.exists()).toBe(true);
+    const bytes = Buffer.from(await saved.arrayBuffer());
+    expect(bytes.equals(Buffer.from("generated-data", "base64"))).toBe(true);
+  });
+
+  test("uses the image title for the filename when present", async () => {
+    mockGenerateResult = {
+      images: [
+        {
+          mimeType: "image/png",
+          dataBase64: "img1",
+          title: "Twilight Gremlin!",
+        } as never,
+      ],
+      text: "",
+      resolvedModel: "gemini-3.1-flash-image-preview",
+    };
+
+    const result = await run({ prompt: "a pond creature" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain(
+      "Saved to media/generated/twilight-gremlin.png",
+    );
+  });
+
+  test("gives each variant a distinct filename", async () => {
+    mockGenerateResult = {
+      images: [
+        { mimeType: "image/png", dataBase64: "img1" },
+        { mimeType: "image/png", dataBase64: "img2" },
+      ],
+      text: undefined as unknown as string,
+      resolvedModel: "gemini-3.1-flash-image-preview",
+    };
+
+    const result = await run({ prompt: "a robot", variants: 2 }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("- media/generated/a-robot.png");
+    expect(result.content).toContain("- media/generated/a-robot-2.png");
+    expect(
+      await Bun.file(
+        join(fakeContext.workingDir, "media/generated/a-robot-2.png"),
+      ).exists(),
+    ).toBe(true);
+  });
+
+  test("suffixes the filename when a previous generation already used it", async () => {
+    const first = await run({ prompt: "a fox" }, fakeContext);
+    expect(first.content).toContain("Saved to media/generated/a-fox.png");
+
+    const second = await run({ prompt: "a fox" }, fakeContext);
+    expect(second.content).toContain("Saved to media/generated/a-fox-2.png");
+  });
+
+  test("refuses to write through a symlink that escapes the workspace", async () => {
+    const outside = mkdtempSync(join(tmpdir(), "media-gen-outside-"));
+    tempWorkingDirs.push(outside);
+    symlinkSync(outside, join(fakeContext.workingDir, "media"));
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Could not save to the workspace");
+    expect(result.content).not.toContain("vellum://workspace/");
+    expect(readdirSync(outside)).toEqual([]);
+  });
+
+  test("falls back to inline-only when the workspace write fails", async () => {
+    // Occupy the media path with a regular file so the directory creation
+    // under it fails.
+    writeFileSync(join(fakeContext.workingDir, "media"), "not a directory");
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Could not save to the workspace");
+    expect(result.content).toContain(
+      "will be attached to your reply automatically",
+    );
+    expect(result.content).not.toContain("vellum://workspace/");
+    expect(result.contentBlocks).toHaveLength(1);
   });
 
   test("returns error when all source_paths are invalid", async () => {

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -64,9 +64,13 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: broadcastMessageMock,
 }));
 
-import type { UserPromptSubmitContext } from "@vellumai/plugin-api";
+import {
+  type UserPromptSubmitContext,
+  VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+} from "@vellumai/plugin-api";
 
 import type { AssistantEvent } from "../api/index.js";
+import { ESCALATION_CONTINUATION_CONTENT } from "../calls/voice-triage-escalate.js";
 import type { AssistantConfig } from "../config/schema.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { QdrantSparseVector } from "../persistence/embeddings/qdrant-client.js";
@@ -74,6 +78,7 @@ import type { ConversationGraphMemory } from "../plugins/defaults/memory/graph/c
 import userPromptSubmitMemoryRetrieval from "../plugins/defaults/memory/hooks/user-prompt-submit.js";
 import type { Message } from "../providers/types.js";
 import { asConversation } from "./helpers/mock-conversation.js";
+import { setConfig } from "./helpers/set-config.js";
 
 /** Canonical metrics payload the graph retriever attaches to a real hit. */
 function makeMetrics() {
@@ -175,13 +180,14 @@ function installConversation(
     trusted?: boolean;
     abortController?: AbortController;
   },
-): void {
+): Conversation {
   currentTrustClass = opts?.trusted === false ? "unknown" : "guardian";
   currentConversation = asConversation({
     graphMemory,
     trustContext: undefined,
     abortController: opts?.abortController ?? new AbortController(),
   });
+  return currentConversation;
 }
 
 beforeEach(() => {
@@ -192,9 +198,95 @@ beforeEach(() => {
   broadcastMessageMock.mockReset();
   currentConversation = undefined;
   currentTrustClass = "guardian";
+  setConfig("memory", { enabled: true, v3: { live: false } });
 });
 
 describe("user-prompt-submit hook (memory retrieval)", () => {
+  test("voice front door skips serial legacy retrieval", async () => {
+    const { memory, prepareMemoryMock, recordPkbQueryVectorsMock } =
+      makeFakeGraphMemory();
+    const conversation = installConversation(memory, { trusted: true });
+    conversation.currentCallSite = "voiceFrontDoor";
+    const ctx = makeHookCtx({ conversationId: "conv-voice" });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).not.toHaveBeenCalled();
+    expect(recordPkbQueryVectorsMock).toHaveBeenCalledWith(
+      undefined,
+      undefined,
+    );
+    expect(applyRuntimeInjectionsMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("voice escalation continuation routes legacy retrieval on the preceding user message", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    installConversation(memory, { trusted: true });
+    const latestMessages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<info>\ncarried context\n</info>" },
+          {
+            type: "text",
+            text: "<turn_context>\nturn context\n</turn_context>",
+          },
+          { type: "text", text: "What is my preferred editor?" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Let me check that." }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "Continue the answer." }],
+      },
+    ];
+    const ctx = makeHookCtx({
+      latestMessages,
+      isHiddenPrompt: true,
+      prompt: ESCALATION_CONTINUATION_CONTENT,
+      messageKind: VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+    });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).toHaveBeenCalledTimes(1);
+    expect(prepareMemoryMock.mock.calls[0]?.[0]).toBe(latestMessages);
+    expect(prepareMemoryMock.mock.calls[0]?.[4]).toEqual([
+      {
+        role: "user",
+        content: [{ type: "text", text: "What is my preferred editor?" }],
+      },
+    ]);
+  });
+
+  test("generic hidden prompts route legacy retrieval on their own content", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    installConversation(memory, { trusted: true });
+    const latestMessages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "Visible caller message" }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "Hidden prompt content" }],
+      },
+    ];
+    const ctx = makeHookCtx({
+      latestMessages,
+      isHiddenPrompt: true,
+      prompt: "Hidden prompt content",
+    });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).toHaveBeenCalledTimes(1);
+    expect(prepareMemoryMock.mock.calls[0]?.[4]).toBe(latestMessages);
+  });
+
   test("adopts the injected run messages when the actor is trusted", async () => {
     const injected: Message[] = [
       { role: "user", content: [{ type: "text", text: "injected" }] },

package/src/__tests__/plugin-api-webhook-url.test.ts

@@ -26,7 +26,7 @@ describe("resolveWebhookUrl", () => {
     });
 
     expect(url).toBe(
-      "https://callbacks.vellum.ai/abc/webhooks/plugins/imessage/events-photon",
+      "https://callbacks.vellum.ai/abc/webhooks/plugins/imessage/events-photon/",
     );
     expect(spy.mock.calls[0]![1]).toBe(
       "webhooks/plugins/imessage/events-photon",
@@ -124,10 +124,10 @@ describe("resolveWebhookUrl", () => {
     }
   });
 
-  test("hands the vendor a URL with no trailing slash", async () => {
-    // The platform appends one, and a provider delivers to the URL it was
-    // given verbatim. The gateway matches the declared path, which never ends
-    // in a slash, so a registration carrying one 404s every delivery.
+  test("hands the vendor a URL with a trailing slash", async () => {
+    // Django in front of managed callbacks canonicalizes onto `/`. A vendor
+    // given the slashless spelling is 301'd, and clients that follow a 301
+    // on POST typically retry as GET and drop the body.
     const spy = spyOn(registration, "resolveCallbackUrl").mockResolvedValue(
       "https://callbacks.vellum.ai/abc/webhooks/plugins/imessage/events-comms/",
     );
@@ -135,13 +135,16 @@ describe("resolveWebhookUrl", () => {
     await expect(
       resolveWebhookUrl({ plugin: "imessage", path: "events-comms" }),
     ).resolves.toBe(
-      "https://callbacks.vellum.ai/abc/webhooks/plugins/imessage/events-comms",
+      "https://callbacks.vellum.ai/abc/webhooks/plugins/imessage/events-comms/",
+    );
+    expect(spy.mock.calls[0]![1]).toBe(
+      "webhooks/plugins/imessage/events-comms",
     );
     spy.mockRestore();
   });
 
   test("leaves a URL carrying a query string alone", async () => {
-    // Trimming there would cut into the query rather than the path.
+    // Appending there would cut into the query rather than the path.
     const spy = spyOn(registration, "resolveCallbackUrl").mockResolvedValue(
       "https://example.test/webhooks/plugins/imessage/events-comms?token=abc/",
     );

package/src/__tests__/plugin-import-boundary-reverse-guard.test.ts

@@ -22,6 +22,7 @@ import { Glob } from "bun";
  *     barrel. Bundled defaults are compiled into the daemon, so the barrel is
  *     their loading mechanism: the in-process analog of loading an external
  *     plugin from its manifest.
+ *   - `src/plugins/defaults/worker-entrypoints.ts`, the compiled sidecar loader.
  *   - Imports of modules directly under `defaults/` (e.g.
  *     `injector-order.js`) — those are host-level shared modules, not plugin
  *     internals.
@@ -47,8 +48,11 @@ import { Glob } from "bun";
 const DEFAULTS_REL = join("src", "plugins", "defaults");
 const DEFAULTS_ABS = join(process.cwd(), DEFAULTS_REL);
 
-/** The bundled-plugin registration barrel — the sanctioned host→plugin edge. */
-const COMPOSITION_ROOT = join(DEFAULTS_REL, "index.ts");
+/** Bundled-plugin composition roots allowed to load plugin internals. */
+const COMPOSITION_ROOTS = new Set([
+  join(DEFAULTS_REL, "index.ts"),
+  join(DEFAULTS_REL, "worker-entrypoints.ts"),
+]);
 
 /**
  * Allowed host→plugin reaches: plugin name → sorted list of host files (paths
@@ -151,7 +155,7 @@ function collectHostFiles(): HostFile[] {
       if (norm.split(sep).includes("__tests__")) {
         continue;
       }
-      if (norm === COMPOSITION_ROOT) {
+      if (COMPOSITION_ROOTS.has(norm)) {
         continue;
       }
       // A file at least two segments below defaults/ belongs to a plugin —

package/src/__tests__/proxy-approval-callback.test.ts

@@ -34,6 +34,7 @@ function makeContext(overrides?: Partial<Conversation>): Conversation {
     workingDir: "/tmp/test-project",
     abortController: null,
     sendToClient: () => {},
+    emit: () => {},
     surfacesByAppId: new Map(),
     ...overrides,
   } as unknown as Conversation;

package/src/__tests__/qdrant-manager.test.ts

@@ -20,7 +20,10 @@ import {
 
 const testDataDir = process.env.VELLUM_WORKSPACE_DIR!;
 
-import { QdrantManager } from "../persistence/embeddings/qdrant-manager.js";
+import {
+  QdrantManager,
+  resolveQdrantReleaseAsset,
+} from "../persistence/embeddings/qdrant-manager.js";
 
 /**
  * Short timeouts so tests complete fast but with enough headroom for CI and
@@ -96,6 +99,16 @@ describe("QdrantManager", () => {
     });
   });
 
+  test("selects the pinned Windows x64 zip release", () => {
+    expect(resolveQdrantReleaseAsset("win32", "x64")).toEqual({
+      binaryName: "qdrant.exe",
+      filename: "qdrant-x86_64-pc-windows-msvc.zip",
+      format: "zip",
+      sha256:
+        "9d3b1d1fa58566bc71709347c4c9b83a0111d23a550daa93c3ee48e3150c4470",
+    });
+  });
+
   // ── getUrl ───────────────────────────────────────────────────
 
   describe("getUrl", () => {

package/src/__tests__/run-due-schedules.test.ts

@@ -57,6 +57,7 @@ mock.module("../persistence/lifecycle-quiesce.js", () => ({
 
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { isPluginDirActivated } from "../plugins/mtime-cache.js";
 import {
   createSchedule,
   deferClaimedSchedule,
@@ -342,6 +343,26 @@ describe("fire-time source-availability gate", () => {
     expect(skipRunsFor(job.id)).toHaveLength(1);
   });
 
+  test("executes an armed sourced row even though no plugin is activated in this process", async () => {
+    const job = await seedDueSourcedScript();
+    // The tick runs in the schedule worker, which activates no plugins, so the
+    // activation ledger is empty here. The gate must therefore read the disk
+    // alone: reading activation would skip every plugin schedule. Arming is
+    // the daemon-side reconciler's call.
+    expect(isPluginDirActivated(pluginDir)).toBe(false);
+
+    const result = await runDueSchedulesOnce();
+
+    expect(result.completed).toBe(1);
+    expect(result.skipped).toBe(0);
+    expect(existsSync(marker)).toBe(true);
+    const runs = rawDb()
+      .query("SELECT status FROM cron_runs WHERE job_id = ?")
+      .all(job.id) as Array<{ status: string }>;
+    expect(runs).toHaveLength(1);
+    expect(runs[0].status).toBe("ok");
+  });
+
   test("does not execute a due sourced row while the feature flag is off", async () => {
     const job = await seedDueSourcedScript();
     setOverridesForTesting({ "plugin-schedules": false });