@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/__tests__/empty-response-hook.test.ts

@@ -0,0 +1,304 @@
+/**
+ * Tests for the default `empty-response` plugin's `stop` hook.
+ *
+ * Covers:
+ * - The default hook's binary decision for the canonical cases: empty turn
+ *   after a prior tool-use turn → continue (with the canonical nudge text);
+ *   visible text → stop; prior turn already delivered visible text → stop;
+ *   first model call with no prior turn → stop; provider refusal → continue
+ *   (with the refusal-specific nudge text); refusal-but-recovered → stop.
+ * - The hook scopes its prior-turn signals to the current response cycle (the
+ *   messages after the last genuine user prompt), so visible text from the
+ *   inbound conversation does not suppress the nudge.
+ * - When the hook continues, it appends the nudge as a `user` message to
+ *   `messages`.
+ * - End-to-end through `runHook` + the registry: registering the default
+ *   plugin makes the hook fire, and a later-registered user hook chains after
+ *   it and can read/override the decision.
+ *
+ * The loop's actual side-effects (retry-budget cap, history splice, log
+ * emission) live in `agent/loop.ts` and are covered by integration tests in
+ * `conversation-agent-loop.test.ts` / `agent-loop.test.ts`. This file isolates
+ * the hook.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { HOOKS } from "../plugin-api/constants.js";
+import type { PluginLogger, StopContext } from "../plugin-api/types.js";
+import {
+  NUDGE_TEXT,
+  REFUSAL_NUDGE_TEXT,
+} from "../plugins/defaults/empty-response/hooks/stop.js";
+import stop from "../plugins/defaults/empty-response/hooks/stop.js";
+import { defaultEmptyResponsePlugin } from "../plugins/defaults/empty-response/register.js";
+import { runHook } from "../plugins/pipeline.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type { ContentBlock, Message } from "../providers/types.js";
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+const noopLogger: PluginLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  debug: () => {},
+};
+
+const emptyTextBlock: ContentBlock = { type: "text", text: "   " };
+
+/** A prior assistant turn that issued a tool call but no visible text. */
+const priorToolUseTurn: Message = {
+  role: "assistant",
+  content: [{ type: "tool_use", id: "tu_1", name: "read_file", input: {} }],
+};
+
+/** A prior assistant turn that delivered visible text to the user. */
+const priorVisibleTextTurn: Message = {
+  role: "assistant",
+  content: [{ type: "text", text: "here is what I found earlier" }],
+};
+
+/** A genuine user prompt — the boundary that opens a new response cycle. */
+function userPrompt(text: string): Message {
+  return { role: "user", content: [{ type: "text", text }] };
+}
+
+function makeCtx(overrides: Partial<StopContext> = {}): StopContext {
+  return {
+    conversationId: "conv-stop",
+    messages: [],
+    responseContent: [],
+    stopReason: null,
+    decision: "stop",
+    logger: noopLogger,
+    ...overrides,
+  };
+}
+
+// ─── Default decisions ───────────────────────────────────────────────────────
+
+describe("empty-response stop hook — default decisions", () => {
+  test("empty turn after a prior tool-use turn → continue with canonical nudge", async () => {
+    // GIVEN a run that already issued a tool call, then returned an empty
+    // (whitespace-only) assistant turn with no visible text.
+    const ctx = makeCtx({
+      messages: [priorToolUseTurn],
+      responseContent: [emptyTextBlock],
+    });
+
+    // WHEN the default stop hook runs.
+    await stop(ctx);
+
+    // THEN it asks the loop to continue and appends the canonical nudge.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: NUDGE_TEXT }],
+    });
+  });
+
+  test("turn contains visible text → stop", async () => {
+    // GIVEN a turn that delivered visible text.
+    const ctx = makeCtx({
+      messages: [priorToolUseTurn],
+      responseContent: [{ type: "text", text: "here is a summary" }],
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN the decision stays at stop and nothing is appended.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toEqual([priorToolUseTurn]);
+  });
+
+  test("prior turn already delivered visible text → stop", async () => {
+    // GIVEN the model said its piece in an earlier turn this run, then ended
+    // with a side-effect tool and returned empty. Nudging would force a
+    // verbatim re-send of text the user already saw.
+    const ctx = makeCtx({
+      messages: [userPrompt("do X"), priorVisibleTextTurn, priorToolUseTurn],
+      responseContent: [],
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN the decision stays at stop.
+    expect(ctx.decision).toBe("stop");
+  });
+
+  test("visible text before the last user prompt is ignored → continue", async () => {
+    // GIVEN the inbound conversation already contains an assistant turn with
+    // visible text, but it precedes this run's user prompt. The current cycle
+    // (after that prompt) holds only a tool-use turn, so the earlier text
+    // belongs to the prior conversation and must not suppress the nudge.
+    const ctx = makeCtx({
+      messages: [
+        priorVisibleTextTurn,
+        userPrompt("do the next thing"),
+        priorToolUseTurn,
+      ],
+      responseContent: [],
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN it continues — the cycle scope sees only the tool-use turn, not the
+    // inbound conversation's visible text.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: NUDGE_TEXT }],
+    });
+  });
+
+  test("first model call with no prior turn → stop", async () => {
+    // GIVEN an empty first assistant response with no prior turn this run and
+    // no refusal — not the pattern the organic-empty-turn nudge guards against.
+    const ctx = makeCtx({ messages: [], responseContent: [] });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN the decision stays at stop.
+    expect(ctx.decision).toBe("stop");
+  });
+
+  // ─── Refusal stop ──────────────────────────────────────────────────────────
+
+  test("refusal on the first call with no content → continue with refusal nudge", async () => {
+    // GIVEN the canonical failure mode: the provider's safety classifier zeros
+    // the response on the very first model call, returning `stopReason:
+    // "refusal"` and no visible text.
+    const ctx = makeCtx({
+      messages: [],
+      responseContent: [],
+      stopReason: "refusal",
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN it continues with the refusal-specific nudge, even with no prior turn.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: REFUSAL_NUDGE_TEXT }],
+    });
+  });
+
+  test("refusal with a thinking-only block still continues", async () => {
+    // GIVEN a refusal whose only content is a thinking block — the user sees
+    // nothing.
+    const ctx = makeCtx({
+      messages: [],
+      responseContent: [
+        { type: "thinking", thinking: "...", signature: "sig" },
+      ],
+      stopReason: "refusal",
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN it continues with the refusal-specific nudge.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: REFUSAL_NUDGE_TEXT }],
+    });
+  });
+
+  test("refusal but visible text present → stop (model recovered)", async () => {
+    // GIVEN a refusal that still delivered some visible text before refusing —
+    // the user has something to see.
+    const ctx = makeCtx({
+      responseContent: [{ type: "text", text: "partial answer" }],
+      stopReason: "refusal",
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN the decision stays at stop.
+    expect(ctx.decision).toBe("stop");
+  });
+
+  test("refusal beats the post-tool-empty nudge wording", async () => {
+    // GIVEN conditions that would trip both the refusal branch and the
+    // post-tool-empty branch.
+    const ctx = makeCtx({
+      messages: [priorToolUseTurn],
+      responseContent: [],
+      stopReason: "refusal",
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN refusal wins because its wording is more accurate.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: REFUSAL_NUDGE_TEXT }],
+    });
+  });
+});
+
+// ─── Via runHook + registry ──────────────────────────────────────────────────
+
+describe("empty-response stop hook — via runHook", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+  });
+
+  test("registering the default plugin makes the hook continue on empty-after-tools", async () => {
+    // GIVEN the default empty-response plugin is registered.
+    registerPlugin(defaultEmptyResponsePlugin);
+
+    // WHEN the stop chain runs over an empty-after-tools context.
+    const result = await runHook<StopContext>(
+      HOOKS.STOP,
+      makeCtx({ messages: [priorToolUseTurn], responseContent: [] }),
+    );
+
+    // THEN the chain settles on continue with the canonical nudge appended.
+    expect(result.decision).toBe("continue");
+    expect(result.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: NUDGE_TEXT }],
+    });
+  });
+
+  test("a later-registered user hook can override the default decision", async () => {
+    // GIVEN the default plugin registers first, then a user plugin whose hook
+    // observes the default's decision and forces a stop.
+    let observedDecision: string | null = null;
+    registerPlugin(defaultEmptyResponsePlugin);
+    registerPlugin({
+      manifest: { name: "force-stop", version: "0.0.1" },
+      hooks: {
+        stop: async (ctx: StopContext) => {
+          observedDecision = ctx.decision;
+          ctx.decision = "stop";
+        },
+      },
+    });
+
+    // WHEN the chain runs over an empty-after-tools context.
+    const result = await runHook<StopContext>(
+      HOOKS.STOP,
+      makeCtx({ messages: [priorToolUseTurn], responseContent: [] }),
+    );
+
+    // THEN the user hook saw the default's continue, and its override wins.
+    expect(observedDecision as string | null).toBe("continue");
+    expect(result.decision).toBe("stop");
+  });
+});

package/src/__tests__/feature-flag-test-helpers.ts

@@ -19,7 +19,7 @@
 // Mirrors `src/config/feature-flag-cache.ts`. Duplicated by design — see
 // the "No source-module imports" section above.
 type FlagSlot = {
-  overrides: Record<string, boolean> | null;
+  overrides: Record<string, boolean | string> | null;
   fromGateway: boolean;
 };
 
@@ -45,7 +45,7 @@ function flagSlot(): FlagSlot {
  * `clearFeatureFlagOverridesCache()` from `assistant-feature-flags.ts`.
  */
 export function setOverridesForTesting(
-  overrides: Record<string, boolean>,
+  overrides: Record<string, boolean | string>,
 ): void {
   const s = flagSlot();
   s.overrides = { ...overrides };

package/src/__tests__/file-write-tool.test.ts

@@ -260,3 +260,66 @@ describe("file_write tool PKB re-index hook", () => {
     expect(existsSync(join(workingDir, "pkb", "oops.md"))).toBe(true);
   });
 });
+
+describe("file_write artifact-HTML guard", () => {
+  test("rejects a self-contained interactive HTML visualization", async () => {
+    const dir = makeTempDir();
+    const html =
+      "<!doctype html><html><head><title>Food Market</title></head>" +
+      "<body><canvas id='c'></canvas><script>" +
+      ("const data=[{x:1,y:2}];").padEnd(4000, "/") +
+      "new Chart(document.getElementById('c'), {data});</script></body></html>";
+
+    const result = await fileWriteTool.execute(
+      { path: "food-market-stats.html", content: html },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('skill: "app-builder"');
+    expect(existsSync(join(dir, "food-market-stats.html"))).toBe(false);
+  });
+
+  test("allows app-builder's thin shell index.html (external module script)", async () => {
+    const dir = makeTempDir();
+    const shell =
+      "<!doctype html><html><head>" +
+      "<link rel='stylesheet' href='/src/styles.css'>".padEnd(3200, " ") +
+      "</head><body><div id='app'></div>" +
+      "<script type='module' src='/src/main.tsx'></script></body></html>";
+
+    const result = await fileWriteTool.execute(
+      { path: "src/index.html", content: shell },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "src", "index.html"))).toBe(true);
+  });
+
+  test("allows a small/static HTML snippet", async () => {
+    const dir = makeTempDir();
+    const result = await fileWriteTool.execute(
+      { path: "note.html", content: "<html><body><h1>Hi</h1></body></html>" },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "note.html"))).toBe(true);
+  });
+
+  test("allows a non-HTML file even with inline script-like content", async () => {
+    const dir = makeTempDir();
+    const result = await fileWriteTool.execute(
+      {
+        path: "notes.md",
+        content:
+          "<script>" + "x".padEnd(2000, "x") + "</script>" + "\n# notes\n",
+      },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "notes.md"))).toBe(true);
+  });
+});

package/src/__tests__/gateway-only-guard.test.ts

@@ -27,6 +27,7 @@ const ALLOWLIST = new Set([
   "clients/shared/App/Auth/PlatformOAuthService.swift", // comment explaining runtimeUrl vs platformUrl
   "clients/macos/vellum-assistant/App/AppDelegate.swift",
   "clients/macos/vellum-assistant/Features/Settings/SettingsConnectTab.swift",
+  "apps/macos/src/main/bundle-flow.ts", // Electron main calls the local gateway (gatewayPort) with a Guardian token to scan bundles
   ".claude/skills/update/SKILL.md", // daemon health check script
 
   // --- Test fixtures that poll the daemon directly (gateway may require auth) ---
@@ -84,12 +85,21 @@ function isGatewayInternal(filePath: string): boolean {
   return filePath.startsWith("gateway/");
 }
 
+/** Additional files allowed for the interpolated-port check only (use gateway port, not runtime). */
+const INTERPOLATED_PORT_ALLOWLIST = new Set([
+  "apps/macos/src/main/bundle-flow.ts",
+]);
+
 /** Shared violation filter: exempt test files, gateway internals, and allowlisted paths. */
-function filterViolations(files: string[]): string[] {
+function filterViolations(
+  files: string[],
+  extraAllowlist?: Set<string>,
+): string[] {
   return files.filter((f) => {
     if (isTestFile(f)) return false;
     if (isGatewayInternal(f)) return false;
     if (ALLOWLIST.has(f)) return false;
+    if (extraAllowlist?.has(f)) return false;
     return true;
   });
 }
@@ -181,7 +191,7 @@ describe("gateway-only API consumption guard", () => {
     }
 
     const files = grepOutput.split("\n").filter((f) => f.length > 0);
-    const violations = filterViolations(files);
+    const violations = filterViolations(files, INTERPOLATED_PORT_ALLOWLIST);
 
     if (violations.length > 0) {
       const message = [

package/src/__tests__/gemini-image-service.test.ts

@@ -287,6 +287,19 @@ describe("mapGeminiError", () => {
     expect(msg).toContain("Rate limit");
   });
 
+  test("maps 402 status to a non-retryable out-of-credits message", () => {
+    const msg = mapGeminiError(new FakeApiError(402, "payment required"));
+    expect(msg).toContain("out of credits");
+    expect(msg).not.toContain("Please try again");
+  });
+
+  test("maps a managed-proxy 402 failure (plain Error) to out-of-credits message", () => {
+    const msg = mapGeminiError(
+      new Error("Managed proxy request failed (402): insufficient credits"),
+    );
+    expect(msg).toContain("out of credits");
+  });
+
   test("maps 500 status to server error message", () => {
     const msg = mapGeminiError(new FakeApiError(500, "internal"));
     expect(msg).toContain("temporarily unavailable");

package/src/__tests__/guardian-grant-minting.test.ts

@@ -20,7 +20,7 @@ mock.module("../util/logger.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__/guardian-routing-invariants.test.ts

@@ -21,7 +21,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 
@@ -51,9 +51,7 @@ import {
   routeGuardianReply,
 } from "../runtime/guardian-reply-router.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
-import {
-  listGuardianDecisionPrompts,
-} from "../runtime/routes/guardian-action-routes.js";
+import { listGuardianDecisionPrompts } from "../runtime/routes/guardian-action-routes.js";
 
 initializeDb();
 

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -143,7 +143,7 @@ mock.module("../util/logger.js", () => ({
 import {
   clearConversations,
   setConversation,
-} from "../daemon/conversation-store.js";
+} from "../daemon/conversation-registry.js";
 import { handleConfirmationResponse } from "../daemon/handlers/conversations.js";
 
 describe("handleConfirmationResponse canonical status sync", () => {

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -56,6 +56,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   markStaleRunsAsMissed: mockMarkStaleRunsAsMissed,
   markStaleRunningAsError: mockMarkStaleRunningAsError,
   countCompletedHeartbeatRuns: mock(() => 10),
+  countCompletedRunsToday: mock(() => 0),
   countRecentConsecutiveRuns: mock(() => 0),
 }));
 

package/src/__tests__/heartbeat-service.test.ts

@@ -32,6 +32,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   markStaleRunningAsError: mockMarkStaleRunningAsError,
   listHeartbeatRuns: mockListHeartbeatRuns,
   countCompletedHeartbeatRuns: mockCountCompletedHeartbeatRuns,
+  countCompletedRunsToday: mock(() => 0),
   countRecentConsecutiveRuns: mock(() => 0),
 }));
 

package/src/__tests__/helpers/mock-provider.ts

@@ -0,0 +1,110 @@
+// Type-only import: this binds the mock to the real `Provider` contract so it
+// can be passed to a live `AgentLoop` without casts. It must stay `import type`
+// — a value import would pull `providers/types.ts`'s runtime exports into this
+// shared helper, which the test-machinery isolation rule forbids.
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+  ToolDefinition,
+} from "../../providers/types.js";
+
+/**
+ * Records the arguments of a single `provider.sendMessage` invocation so tests
+ * can assert on what the agent loop sent (messages, tools, system prompt, the
+ * resolved options bag).
+ */
+export interface RecordedProviderCall {
+  messages: Message[];
+  tools?: ToolDefinition[];
+  systemPrompt?: string;
+  options?: SendMessageOptions;
+}
+
+/**
+ * One scripted provider turn. A `ProviderResponse` is returned normally; an
+ * `Error` is thrown to simulate a provider HTTP rejection (e.g. a
+ * context-too-large error the orchestrator must recover from).
+ */
+export type ScriptedResponse = ProviderResponse | Error;
+
+/**
+ * A mock provider that returns pre-configured responses in sequence.
+ *
+ * Drives the real {@link import("../../agent/loop.js").AgentLoop} by mocking
+ * only the provider HTTP boundary: each call returns the next scripted
+ * `ProviderResponse` (the last response repeats once the script is exhausted)
+ * and replays its text blocks as `text_delta` events so the loop streams
+ * exactly as it would against a live provider. A scripted `Error` entry is
+ * thrown instead of returned, so a rejection can be sequenced before a
+ * recovery response.
+ */
+export function createMockProvider(
+  responses: ScriptedResponse[],
+  name = "mock",
+): {
+  provider: Provider;
+  calls: RecordedProviderCall[];
+} {
+  const calls: RecordedProviderCall[] = [];
+  let callIndex = 0;
+
+  const provider: Provider = {
+    name,
+    async sendMessage(
+      messages: Message[],
+      options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      calls.push({
+        messages: [...messages],
+        tools: options?.tools,
+        systemPrompt: options?.systemPrompt,
+        options,
+      });
+      const scripted = responses[callIndex] ?? responses[responses.length - 1];
+      callIndex++;
+
+      if (scripted instanceof Error) {
+        throw scripted;
+      }
+
+      // Replay streaming deltas for text blocks, mirroring a live provider.
+      if (options?.onEvent) {
+        for (const block of scripted.content) {
+          if (block.type === "text") {
+            options.onEvent({ type: "text_delta", text: block.text });
+          }
+        }
+      }
+
+      return scripted;
+    },
+  };
+
+  return { provider, calls };
+}
+
+/** A scripted assistant turn that ends with a plain text response. */
+export function textResponse(text: string): ProviderResponse {
+  return {
+    content: [{ type: "text", text }],
+    model: "mock-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "end_turn",
+  };
+}
+
+/** A scripted assistant turn that invokes a single tool. */
+export function toolUseResponse(
+  id: string,
+  name: string,
+  input: Record<string, unknown>,
+): ProviderResponse {
+  return {
+    content: [{ type: "tool_use", id, name, input }],
+    model: "mock-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "tool_use",
+  };
+}