@vellumai/assistant 0.7.1 → 0.7.2

package/src/__tests__/conversation-app-control-instantiation.test.ts

@@ -0,0 +1,392 @@
+/**
+ * Tests for HostAppControlProxy instantiation in `prepareConversationForMessage`
+ * (and the parallel block in `conversation-routes.ts`).
+ *
+ * Verifies that:
+ *  - A macOS client connection unconditionally attaches a HostAppControlProxy
+ *    and preactivates the `app-control` skill — regardless of whether the
+ *    `app-control` feature flag is on or off. The flag is read only by the
+ *    skill-projection layer, never gates the proxy.
+ *  - A non-macOS client connection (where
+ *    `supportsHostProxy(_, "host_app_control")` returns false) leaves the
+ *    proxy unattached.
+ *  - The skill-projection layer filters the `app-control` skill out of the
+ *    projected tool list when the feature flag is off, even when it is in
+ *    the preactivated set — proving that the gating point is the projection
+ *    layer rather than the proxy attachment site.
+ *
+ * The first set of tests mirrors the production gating logic from
+ * `prepareConversationForMessage` (in `assistant/src/daemon/process-message.ts`)
+ * and the parallel block in `assistant/src/runtime/routes/conversation-routes.ts`
+ * — both unconditionally instantiate `HostAppControlProxy` and preactivate
+ * `"app-control"` when `supportsHostProxy(interfaceId, "host_app_control")`
+ * returns true. Calling the real prepare/route helpers directly would require
+ * mocking the full processMessage/handleSendMessage stack (slash router, agent
+ * loop, persistence, secret scanner, …), so we test the logic against the
+ * real `supportsHostProxy` predicate plus a fake Conversation.
+ *
+ * The second set of tests calls the real `projectSkillTools` to confirm
+ * that the feature flag — not the proxy attachment — controls whether
+ * `app-control` tools end up in the LLM tool list.
+ */
+
+import * as realFs from "node:fs";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { InterfaceId } from "../channels/types.js";
+import { supportsHostProxy } from "../channels/types.js";
+import type { SkillSummary, SkillToolManifest } from "../config/skills.js";
+import { RiskLevel } from "../permissions/types.js";
+import type { Tool } from "../tools/types.js";
+
+// ---------------------------------------------------------------------------
+// Module mocks for the skill-projection layer
+// ---------------------------------------------------------------------------
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+let appControlFlagEnabled = false;
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) => {
+    if (key === "app-control") return appControlFlagEnabled;
+    return true;
+  },
+  loadDefaultsRegistry: () => ({}),
+}));
+
+mock.module("../config/skill-state.js", () => ({
+  skillFlagKey: (skill: { featureFlag?: string }) =>
+    skill.featureFlag ?? undefined,
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: { entries: {}, allowBundled: null },
+  }),
+  loadConfig: () => ({
+    skills: { entries: {}, allowBundled: null },
+  }),
+  invalidateConfigCache: () => {},
+}));
+
+let mockCatalog: SkillSummary[] = [];
+let mockManifests: Record<string, SkillToolManifest | null> = {};
+const mockRegisteredTools = new Map<string, Tool[]>();
+const mockSkillRefCount = new Map<string, number>();
+
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: () => mockCatalog,
+}));
+
+mock.module("../skills/active-skill-tools.js", () => ({
+  deriveActiveSkills: () => [],
+}));
+
+mock.module("../skills/tool-manifest.js", () => ({
+  parseToolManifestFile: (filePath: string) => {
+    const parts = filePath.split("/");
+    const skillId = parts[parts.length - 2];
+    const manifest = mockManifests[skillId];
+    if (!manifest) {
+      throw new Error(`Mock: no manifest for skill "${skillId}"`);
+    }
+    return manifest;
+  },
+}));
+
+mock.module("../tools/skills/skill-tool-factory.js", () => ({
+  createSkillToolsFromManifest: (
+    entries: SkillToolManifest["tools"],
+    skillId: string,
+    _skillDir: string,
+    versionHash: string,
+    bundled?: boolean,
+  ): Tool[] =>
+    entries.map((entry) => ({
+      name: entry.name,
+      description: entry.description,
+      category: entry.category,
+      defaultRiskLevel: RiskLevel.Medium,
+      origin: "skill" as const,
+      ownerSkillId: skillId,
+      ownerSkillVersionHash: versionHash,
+      ownerSkillBundled: bundled ?? undefined,
+      getDefinition: () => ({
+        name: entry.name,
+        description: entry.description,
+        input_schema: entry.input_schema as object,
+      }),
+      execute: async () => ({ content: "", isError: false }),
+    })),
+}));
+
+mock.module("../tools/registry.js", () => ({
+  registerSkillTools: (tools: Tool[]) => {
+    const skillIds = new Set<string>();
+    for (const tool of tools) {
+      const skillId = tool.ownerSkillId!;
+      skillIds.add(skillId);
+      const existing = mockRegisteredTools.get(skillId) ?? [];
+      existing.push(tool);
+      mockRegisteredTools.set(skillId, existing);
+    }
+    for (const id of skillIds) {
+      mockSkillRefCount.set(id, (mockSkillRefCount.get(id) ?? 0) + 1);
+    }
+    return tools;
+  },
+  unregisterSkillTools: (skillId: string) => {
+    const current = mockSkillRefCount.get(skillId) ?? 0;
+    if (current > 1) {
+      mockSkillRefCount.set(skillId, current - 1);
+      return;
+    }
+    mockSkillRefCount.delete(skillId);
+    mockRegisteredTools.delete(skillId);
+  },
+  getTool: (name: string) => {
+    let found: Tool | undefined;
+    for (const tools of mockRegisteredTools.values()) {
+      for (const tool of tools) {
+        if (tool.name === name) found = tool;
+      }
+    }
+    return found;
+  },
+  getSkillToolNames: () => {
+    const names: string[] = [];
+    for (const tools of mockRegisteredTools.values()) {
+      for (const tool of tools) {
+        names.push(tool.name);
+      }
+    }
+    return names;
+  },
+}));
+
+mock.module("node:fs", () => ({
+  ...realFs,
+  existsSync: (p: string) => {
+    if (typeof p === "string" && p.endsWith("TOOLS.json")) {
+      const parts = p.split("/");
+      const skillId = parts[parts.length - 2];
+      return skillId in mockManifests;
+    }
+    return realFs.existsSync(p);
+  },
+}));
+
+mock.module("../skills/version-hash.js", () => ({
+  computeSkillVersionHash: (skillDir: string) => {
+    const parts = skillDir.split("/");
+    return `v1:default-hash-${parts[parts.length - 1]}`;
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Imports under test (after mocks)
+// ---------------------------------------------------------------------------
+
+const { HostAppControlProxy } =
+  await import("../daemon/host-app-control-proxy.js");
+const { preactivateHostProxySkills } =
+  await import("../daemon/host-proxy-preactivation.js");
+const { projectSkillTools, resetSkillToolProjection } =
+  await import("../daemon/conversation-skill-tools.js");
+
+// ---------------------------------------------------------------------------
+// Conversation surface — captures proxy attachment + preactivations
+// ---------------------------------------------------------------------------
+
+interface FakeConversation {
+  conversationId: string;
+  hostAppControlProxy?: unknown;
+  preactivatedSkillIds: string[];
+  isProcessing(): boolean;
+  setHostAppControlProxy(proxy: unknown): void;
+  addPreactivatedSkillId(id: string): void;
+}
+
+function makeFakeConversation(): FakeConversation {
+  const conv: FakeConversation = {
+    conversationId: "conv-app-control-instantiation",
+    hostAppControlProxy: undefined,
+    preactivatedSkillIds: [],
+    isProcessing: () => false,
+    setHostAppControlProxy(proxy: unknown) {
+      this.hostAppControlProxy = proxy;
+    },
+    addPreactivatedSkillId(id: string) {
+      if (!this.preactivatedSkillIds.includes(id)) {
+        this.preactivatedSkillIds.push(id);
+      }
+    },
+  };
+  return conv;
+}
+
+/**
+ * Replica of the gating block from `prepareConversationForMessage`
+ * (process-message.ts) and `conversation-routes.ts`. The proxy-attachment
+ * step still lives inline at each call site (the proxy constructors take
+ * different argument shapes), but the preactivation step routes through the
+ * shared `preactivateHostProxySkills` helper exactly as the production code
+ * does.
+ */
+function applyAppControlInstantiation(
+  conv: FakeConversation,
+  interfaceId: InterfaceId,
+): void {
+  if (supportsHostProxy(interfaceId, "host_app_control")) {
+    if (!conv.isProcessing() || !conv.hostAppControlProxy) {
+      conv.setHostAppControlProxy(new HostAppControlProxy(conv.conversationId));
+    }
+  } else if (!conv.isProcessing()) {
+    conv.setHostAppControlProxy(undefined);
+  }
+  if (!conv.isProcessing()) {
+    preactivateHostProxySkills(conv, interfaceId);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Skill fixtures
+// ---------------------------------------------------------------------------
+
+function makeAppControlSkill(): SkillSummary {
+  return {
+    id: "app-control",
+    name: "app-control",
+    displayName: "App Control",
+    description: "Drive a specific named app via raw input",
+    directoryPath: "/skills/app-control",
+    skillFilePath: "/skills/app-control/SKILL.md",
+    bundled: true,
+    source: "bundled",
+    featureFlag: "app-control",
+  };
+}
+
+function makeAppControlManifest(): SkillToolManifest {
+  return {
+    version: 1,
+    tools: [
+      {
+        name: "app_control_start",
+        description: "Start a session against a named app",
+        category: "app-control",
+        risk: "medium" as const,
+        input_schema: { type: "object", properties: {} },
+        executor: "run.ts",
+        execution_target: "host" as const,
+      },
+      {
+        name: "app_control_observe",
+        description: "Observe the focused app's window",
+        category: "app-control",
+        risk: "low" as const,
+        input_schema: { type: "object", properties: {} },
+        executor: "run.ts",
+        execution_target: "host" as const,
+      },
+    ],
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests — proxy instantiation
+// ---------------------------------------------------------------------------
+
+describe("HostAppControlProxy instantiation gate", () => {
+  beforeEach(() => {
+    appControlFlagEnabled = false;
+  });
+
+  test("macOS client attaches HostAppControlProxy and preactivates app-control (flag off)", () => {
+    appControlFlagEnabled = false;
+    const conv = makeFakeConversation();
+
+    applyAppControlInstantiation(conv, "macos");
+
+    // Proxy is attached unconditionally — no flag check at instantiation.
+    expect(conv.hostAppControlProxy).toBeInstanceOf(HostAppControlProxy);
+    expect(conv.preactivatedSkillIds).toContain("app-control");
+  });
+
+  test("macOS client attaches HostAppControlProxy and preactivates app-control (flag on)", () => {
+    appControlFlagEnabled = true;
+    const conv = makeFakeConversation();
+
+    applyAppControlInstantiation(conv, "macos");
+
+    expect(conv.hostAppControlProxy).toBeInstanceOf(HostAppControlProxy);
+    expect(conv.preactivatedSkillIds).toContain("app-control");
+  });
+
+  test("non-macOS client (slack) does not attach HostAppControlProxy nor preactivate app-control", () => {
+    appControlFlagEnabled = true;
+    const conv = makeFakeConversation();
+
+    applyAppControlInstantiation(conv, "slack");
+
+    expect(conv.hostAppControlProxy).toBeUndefined();
+    expect(conv.preactivatedSkillIds).not.toContain("app-control");
+  });
+
+  test("chrome-extension client does not attach HostAppControlProxy (host_app_control unsupported)", () => {
+    appControlFlagEnabled = true;
+    const conv = makeFakeConversation();
+    // Sanity check: chrome-extension supports host_browser, NOT host_app_control.
+    expect(supportsHostProxy("chrome-extension", "host_app_control")).toBe(
+      false,
+    );
+
+    applyAppControlInstantiation(conv, "chrome-extension");
+
+    expect(conv.hostAppControlProxy).toBeUndefined();
+    expect(conv.preactivatedSkillIds).not.toContain("app-control");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests — skill-projection feature-flag gating
+// ---------------------------------------------------------------------------
+
+describe("Skill projection — app-control feature-flag gating", () => {
+  beforeEach(() => {
+    mockCatalog = [makeAppControlSkill()];
+    mockManifests = { "app-control": makeAppControlManifest() };
+    mockRegisteredTools.clear();
+    mockSkillRefCount.clear();
+    resetSkillToolProjection();
+  });
+
+  test("flag off: app-control is filtered out of projected tools even when preactivated", () => {
+    appControlFlagEnabled = false;
+
+    const sessionState = new Map<string, string>();
+    const result = projectSkillTools([], {
+      preactivatedSkillIds: ["app-control"],
+      previouslyActiveSkillIds: sessionState,
+    });
+
+    expect(result.allowedToolNames.has("app_control_start")).toBe(false);
+    expect(result.allowedToolNames.has("app_control_observe")).toBe(false);
+  });
+
+  test("flag on: app-control tools are projected when preactivated", () => {
+    appControlFlagEnabled = true;
+
+    const sessionState = new Map<string, string>();
+    const result = projectSkillTools([], {
+      preactivatedSkillIds: ["app-control"],
+      previouslyActiveSkillIds: sessionState,
+    });
+
+    expect(result.allowedToolNames.has("app_control_start")).toBe(true);
+    expect(result.allowedToolNames.has("app_control_observe")).toBe(true);
+  });
+});

package/src/__tests__/conversation-app-control-lifecycle.test.ts

@@ -0,0 +1,237 @@
+/**
+ * Lifecycle tests for HostAppControlProxy attachment to a Conversation.
+ *
+ * Verifies that:
+ *  - `setHostAppControlProxy` stores the proxy and disposes any prior proxy
+ *    when replaced with a different instance.
+ *  - `Conversation.dispose()` calls `dispose()` on the attached proxy and
+ *    nulls the field so a subsequent `setHostAppControlProxy(newProxy)`
+ *    cleanly attaches without double-disposing.
+ *
+ * Mirrors the dependency mocking pattern used by
+ * `conversation-lifecycle.test.ts` so we can construct a real Conversation
+ * without bringing up the full daemon stack.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: () => {},
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  updateConversationTitle: () => {},
+  updateConversationUsage: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => [],
+  getConversation: () => null,
+  createConversation: () => ({ id: "conv-app-control" }),
+  addMessage: async () => ({ id: "persisted-1" }),
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+}));
+
+mock.module("../memory/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+// Stub graph_extract / auto-analysis enqueue paths so dispose's best-effort
+// background work doesn't reach into real subsystems during the test.
+mock.module("../memory/jobs-store.js", () => ({
+  enqueueMemoryJob: () => {},
+}));
+
+mock.module("../memory/auto-analysis-enqueue.js", () => ({
+  enqueueAutoAnalysisIfEnabled: () => {},
+}));
+
+mock.module("../memory/auto-analysis-guard.js", () => ({
+  isAutoAnalysisConversation: () => false,
+}));
+
+import { Conversation } from "../daemon/conversation.js";
+import type { HostAppControlProxy } from "../daemon/host-app-control-proxy.js";
+
+/**
+ * Minimal stand-in for HostAppControlProxy that records dispose() calls.
+ * The Conversation only invokes `dispose()` on the proxy in the lifecycle
+ * paths under test, so we don't need the rest of the API.
+ */
+function makeFakeProxy(): {
+  proxy: HostAppControlProxy;
+  disposeCount: () => number;
+} {
+  let disposed = 0;
+  const fake = {
+    dispose() {
+      disposed++;
+    },
+  } as unknown as HostAppControlProxy;
+  return { proxy: fake, disposeCount: () => disposed };
+}
+
+function makeConversation(): Conversation {
+  const provider = {
+    name: "mock",
+    sendMessage: async () => ({
+      content: [],
+      model: "mock",
+      usage: { inputTokens: 0, outputTokens: 0 },
+      stopReason: "end_turn",
+    }),
+  };
+  const conv = new Conversation(
+    "conv-app-control",
+    provider,
+    "system prompt",
+    4096,
+    () => {},
+    "/tmp",
+  );
+  conv.setTrustContext({ trustClass: "guardian", sourceChannel: "vellum" });
+  return conv;
+}
+
+describe("Conversation — HostAppControlProxy lifecycle", () => {
+  test("setHostAppControlProxy stores the proxy", () => {
+    const conversation = makeConversation();
+    const { proxy, disposeCount } = makeFakeProxy();
+
+    conversation.setHostAppControlProxy(proxy);
+
+    expect(conversation.hostAppControlProxy).toBe(proxy);
+    expect(disposeCount()).toBe(0);
+  });
+
+  test("setHostAppControlProxy disposes prior proxy when replaced", () => {
+    const conversation = makeConversation();
+    const first = makeFakeProxy();
+    const second = makeFakeProxy();
+
+    conversation.setHostAppControlProxy(first.proxy);
+    conversation.setHostAppControlProxy(second.proxy);
+
+    expect(first.disposeCount()).toBe(1);
+    expect(second.disposeCount()).toBe(0);
+    expect(conversation.hostAppControlProxy).toBe(second.proxy);
+  });
+
+  test("setHostAppControlProxy with the same instance does not redispose", () => {
+    const conversation = makeConversation();
+    const { proxy, disposeCount } = makeFakeProxy();
+
+    conversation.setHostAppControlProxy(proxy);
+    conversation.setHostAppControlProxy(proxy);
+
+    expect(disposeCount()).toBe(0);
+    expect(conversation.hostAppControlProxy).toBe(proxy);
+  });
+
+  test("setHostAppControlProxy(undefined) disposes the existing proxy", () => {
+    const conversation = makeConversation();
+    const { proxy, disposeCount } = makeFakeProxy();
+
+    conversation.setHostAppControlProxy(proxy);
+    conversation.setHostAppControlProxy(undefined);
+
+    expect(disposeCount()).toBe(1);
+    expect(conversation.hostAppControlProxy).toBeUndefined();
+  });
+
+  test("Conversation.dispose() disposes the attached proxy and nulls the field", () => {
+    const conversation = makeConversation();
+    const { proxy, disposeCount } = makeFakeProxy();
+
+    conversation.setHostAppControlProxy(proxy);
+    conversation.dispose();
+
+    expect(disposeCount()).toBe(1);
+    expect(conversation.hostAppControlProxy).toBeUndefined();
+  });
+
+  test("Conversation.dispose() is a no-op when no proxy is attached", () => {
+    const conversation = makeConversation();
+
+    expect(() => conversation.dispose()).not.toThrow();
+    expect(conversation.hostAppControlProxy).toBeUndefined();
+  });
+
+  test("setHostAppControlProxy after dispose cleanly attaches without double-disposing the prior proxy", () => {
+    const conversation = makeConversation();
+    const first = makeFakeProxy();
+    const second = makeFakeProxy();
+
+    conversation.setHostAppControlProxy(first.proxy);
+    conversation.dispose();
+    // After dispose the field is nulled, so attaching a new proxy must NOT
+    // call dispose() on the (already-disposed) prior proxy a second time.
+    conversation.setHostAppControlProxy(second.proxy);
+
+    expect(first.disposeCount()).toBe(1);
+    expect(second.disposeCount()).toBe(0);
+    expect(conversation.hostAppControlProxy).toBe(second.proxy);
+  });
+});

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -140,14 +140,12 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   getConfigReadOnly: () => mockConfig,
   loadConfig: () => mockConfig,
-  saveConfig: () => {},
   invalidateConfigCache: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
   setNestedValue: () => {},
   applyNestedDefaults: (c: unknown) => c,
-  deepMergeMissing: () => {},
   deepMergeOverwrite: () => {},
   mergeDefaultWorkspaceConfig: () => {},
 }));

package/src/__tests__/conversation-lifecycle.test.ts

@@ -308,6 +308,42 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages[2].content).toEqual([{ type: "text", text: "Second" }]);
   });
 
+  test("historical wrapped memoryInjectedBlock rehydrates singly-wrapped", async () => {
+    // Historical v2 rows persisted `injectedBlockText` already wrapped in
+    // `<memory>...</memory>`. After unifying v2's storage with v1's
+    // unwrapped contract, the rehydrate path must defensively strip any
+    // pre-existing wrapper so old rows don't render double-wrapped.
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Hi" }]),
+        metadata: JSON.stringify({
+          memoryInjectedBlock: "<memory>\nremember: alice\n</memory>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Hello" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(2);
+    const firstBlock = messages[0].content[0];
+    expect(firstBlock).toEqual({
+      type: "text",
+      text: "<memory>\nremember: alice\n</memory>",
+    });
+    if (firstBlock.type !== "text") throw new Error("unexpected block type");
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
+  });
+
   test("malformed metadata is tolerated: load does not throw, content unchanged", async () => {
     mockConversation = defaultConv();
     mockDbMessages = [