@vellumai/assistant 0.8.0 → 0.8.1

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -1879,7 +1879,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
     },
   ];
 
-  const FLAT_REMINDER = buildPkbReminder([]);
+  const FLAT_REMINDER = buildPkbReminder([], false);
 
   // Use a platform-agnostic absolute workspace root so the tests work on
   // macOS and Linux runners alike. `pkbRoot` sits under `pkbWorkingDir` to
@@ -2135,7 +2135,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
       role: "user",
       content: [
         { type: "text", text: "hello" },
-        { type: "text", text: buildPkbReminder([]) },
+        { type: "text", text: buildPkbReminder([], false) },
       ],
     };
     const hintedMessage: Message = {
@@ -2144,7 +2144,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
         { type: "text", text: "hello" },
         {
           type: "text",
-          text: buildPkbReminder(["topics/alpha.md", "topics/beta.md"]),
+          text: buildPkbReminder(["topics/alpha.md", "topics/beta.md"], false),
         },
       ],
     };
@@ -4760,7 +4760,7 @@ describe("applyRuntimeInjections blocks.pkbSystemReminder", () => {
       mode: "full",
     });
 
-    const expected = buildPkbReminder([]);
+    const expected = buildPkbReminder([], false);
     expect(blocks.pkbSystemReminder).toBe(expected);
   });
 

package/src/__tests__/conversation-slash-commands.test.ts

@@ -1,10 +1,16 @@
-import { describe, expect, test } from "bun:test";
+import { writeFileSync } from "node:fs";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
+import {
+  invalidateConfigCache,
+  loadRawConfig,
+} from "../config/loader.js";
 import {
   classifySlash,
   resolveSlash,
   type SlashContext,
 } from "../daemon/conversation-slash.js";
+import { getWorkspaceConfigPath } from "../util/platform.js";
 
 function makeSlashContext(overrides: Partial<SlashContext> = {}): SlashContext {
   return {
@@ -37,12 +43,12 @@ describe("resolveSlash /commands interface-aware help", () => {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
       "/fork — Fork the current conversation into a new branch",
     ]);
-    expect(lines).not.toContain("/model — Switch the active model");
   });
 
   test("renders iOS command help with /fork", async () => {
@@ -53,6 +59,7 @@ describe("resolveSlash /commands interface-aware help", () => {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -68,6 +75,7 @@ describe("resolveSlash /commands interface-aware help", () => {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -80,6 +88,7 @@ describe("resolveSlash /commands interface-aware help", () => {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
     ]);
@@ -90,6 +99,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/model — List or switch inference profile",
       "/models — List all available models",
     ]);
   });
@@ -128,6 +138,55 @@ describe("resolveSlash command contract", () => {
   });
 });
 
+describe("resolveSlash /compact target override", () => {
+  test("plain /compact returns no override", async () => {
+    const result = await resolveSlash("/compact");
+    expect(result).toEqual({ kind: "compact" });
+  });
+
+  test("/compact <integer> sets explicit token target", async () => {
+    const result = await resolveSlash("/compact 30000");
+    expect(result).toEqual({
+      kind: "compact",
+      targetInputTokensOverride: 30000,
+    });
+  });
+
+  test("/compact <n>k expands to thousands", async () => {
+    const result = await resolveSlash("/compact 30k");
+    expect(result).toEqual({
+      kind: "compact",
+      targetInputTokensOverride: 30_000,
+    });
+  });
+
+  test("/compact <n>m expands to millions", async () => {
+    const result = await resolveSlash("/compact 1.5M");
+    expect(result).toEqual({
+      kind: "compact",
+      targetInputTokensOverride: 1_500_000,
+    });
+  });
+
+  test("/compact rejects malformed args with usage hint", async () => {
+    const result = await resolveSlash("/compact bogus");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown");
+    expect(result.message).toContain("`bogus`");
+    expect(result.message).toContain("/compact");
+  });
+
+  test("/compact rejects zero", async () => {
+    const result = await resolveSlash("/compact 0");
+    expect(result.kind).toBe("unknown");
+  });
+
+  test("/compact rejects negative numbers", async () => {
+    const result = await resolveSlash("/compact -50");
+    expect(result.kind).toBe("unknown");
+  });
+});
+
 describe("classifySlash is a pure classifier matching resolveSlash kinds", () => {
   // Lookahead in `buildPassthroughBatch` must not run `resolveSlash`'s side
   // effects. The pure classifier is synchronous, takes no side-effecting
@@ -141,11 +200,16 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/status", kind: "unknown" },
     { input: "/commands", kind: "unknown" },
     { input: "/compact", kind: "compact" },
+    { input: "/compact 30000", kind: "compact" },
+    { input: "/compact 30k", kind: "compact" },
+    { input: "/compact 1.5M", kind: "compact" },
+    { input: "/compact bogus", kind: "unknown" },
     { input: "/model", kind: "unknown" },
     { input: "/model foo", kind: "unknown" },
     { input: "/opus", kind: "unknown" },
     { input: "hello", kind: "passthrough" },
     { input: "  /compact  ", kind: "compact" },
+    { input: "  /compact 50k  ", kind: "compact" },
     { input: "/models foo", kind: "passthrough" },
   ];
 
@@ -160,3 +224,131 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     });
   }
 });
+
+// ── /model — inference profile switcher ────────────────────────────
+
+function writeFixtureConfig(config: Record<string, unknown>): void {
+  writeFileSync(getWorkspaceConfigPath(), JSON.stringify(config), "utf-8");
+  invalidateConfigCache();
+}
+
+describe("resolveSlash /model — inference profile switcher", () => {
+  beforeEach(() => {
+    writeFixtureConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            label: "Balanced",
+            description: "Default mix of speed and quality",
+          },
+          "cost-optimized": {
+            label: "Cost-optimized",
+            description: "Cheaper models, slower",
+          },
+          "short-context": {
+            label: "Short context",
+            status: "disabled",
+          },
+        },
+        profileOrder: ["balanced", "cost-optimized", "short-context"],
+        activeProfile: "balanced",
+      },
+    });
+  });
+
+  afterEach(() => {
+    invalidateConfigCache();
+  });
+
+  test("`/model` lists profiles with current marker, status, and description", async () => {
+    const result = await resolveSlash("/model");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toContain("Inference profiles:");
+    expect(result.message).toContain(
+      "`balanced` (Balanced) **[current]** — Default mix of speed and quality",
+    );
+    expect(result.message).toContain(
+      "`cost-optimized` (Cost-optimized) — Cheaper models, slower",
+    );
+    expect(result.message).toContain(
+      "`short-context` (Short context) *(disabled)*",
+    );
+    expect(result.message).toContain("Switch with `/model <name>`.");
+  });
+
+  test("`/model <name>` switches the active profile and writes config to disk", async () => {
+    const result = await resolveSlash("/model cost-optimized");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toBe(
+      "Switched to profile `cost-optimized` (Cost-optimized).",
+    );
+
+    const persisted = loadRawConfig() as {
+      llm?: { activeProfile?: string };
+    };
+    expect(persisted.llm?.activeProfile).toBe("cost-optimized");
+  });
+
+  test("`/model <unknown>` returns an error with available profile names", async () => {
+    const result = await resolveSlash("/model gemini");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toContain("Profile `gemini` not found.");
+    expect(result.message).toContain("`balanced`");
+    expect(result.message).toContain("`cost-optimized`");
+  });
+
+  test("`/model <disabled>` refuses to switch and points at Settings", async () => {
+    const result = await resolveSlash("/model short-context");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toBe(
+      "Profile `short-context` is disabled. Enable it in **Settings → Models & Services** first.",
+    );
+    // Disk should NOT have been written.
+    const persisted = loadRawConfig() as {
+      llm?: { activeProfile?: string };
+    };
+    expect(persisted.llm?.activeProfile).toBe("balanced");
+  });
+
+  test("`/model <current>` is a no-op with a friendly message", async () => {
+    const result = await resolveSlash("/model balanced");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toBe(
+      "Already using profile `balanced` (Balanced).",
+    );
+  });
+
+  test("`/model` with no profiles defined points at Settings", async () => {
+    writeFixtureConfig({
+      llm: { profiles: {}, profileOrder: [] },
+    });
+    const result = await resolveSlash("/model");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toBe(
+      "No inference profiles are defined. Use **Settings → Models & Services** to create one.",
+    );
+  });
+
+  test("`/model <name>` trims surrounding whitespace from the argument", async () => {
+    const result = await resolveSlash("/model   cost-optimized  ");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toBe(
+      "Switched to profile `cost-optimized` (Cost-optimized).",
+    );
+  });
+
+  test("`/models` (plural) is not parsed as a /model invocation", async () => {
+    // /models is a separate command handled elsewhere; this test guards the
+    // boundary so we don't accidentally swallow it as a typo'd /model.
+    expect(classifySlash("/models")).toBe("unknown");
+    // /models foo is passthrough (existing behavior).
+    expect(classifySlash("/models foo")).toBe("passthrough");
+  });
+});

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

@@ -11,6 +11,16 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 const sentMessages: unknown[] = [];
 let mockHasClient = true;
+// Default principal id used for both ctx.trustContext and clients in the
+// existing single-user tests. Tests that exercise cross-user behaviour
+// override this on individual clients and on the SurfaceConversationContext.
+const DEFAULT_PRINCIPAL = "user-1";
+type MockClient = {
+  clientId: string;
+  capabilities: string[];
+  actorPrincipalId?: string;
+};
+let mockHubClients: MockClient[] = [];
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: unknown) => sentMessages.push(msg),
@@ -19,6 +29,12 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
       cap === "host_app_control" && mockHasClient
         ? { id: "mock-client" }
         : null,
+    listClientsByCapability: (cap: string) =>
+      mockHubClients.filter((c) => c.capabilities.includes(cap)),
+    getClientById: (id: string) =>
+      mockHubClients.find((c) => c.clientId === id),
+    getActorPrincipalIdForClient: (id: string) =>
+      mockHubClients.find((c) => c.clientId === id)?.actorPrincipalId,
   },
 }));
 
@@ -56,9 +72,18 @@ function buildMockContext(
   setHostAppControlProxy?: (
     proxy: InstanceType<typeof HostAppControlProxy> | undefined,
   ) => void,
+  trustGuardianPrincipalId: string | null = DEFAULT_PRINCIPAL,
 ): SurfaceConversationContext {
   return {
     conversationId,
+    trustContext:
+      trustGuardianPrincipalId != null
+        ? {
+            sourceChannel: "vellum",
+            trustClass: "guardian",
+            guardianPrincipalId: trustGuardianPrincipalId,
+          }
+        : undefined,
     traceEmitter: { emit: () => {} },
     sendToClient: () => {},
     pendingSurfaceActions: new Map(),
@@ -86,11 +111,13 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
   beforeEach(() => {
     sentMessages.length = 0;
     mockHasClient = true;
+    mockHubClients = [];
     _resetActiveAppControlSession();
   });
 
   afterEach(() => {
     _resetActiveAppControlSession();
+    mockHubClients = [];
   });
 
   // -------------------------------------------------------------------------
@@ -130,15 +157,18 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       proxy.dispose();
     });
 
-    test("returns isError for app_control_stop when no proxy is attached", async () => {
+    test("app_control_stop succeeds idempotently when no proxy is attached", async () => {
+      // Stop is local-only and runs BEFORE the isAvailable() gate so a
+      // disconnected client cannot strand the singleton lock. With no proxy
+      // attached at all, it must still succeed as a no-op without dispatching.
       const ctx = buildMockContext();
 
       const result = await surfaceProxyResolver(ctx, "app_control_stop", {
         tool: "stop",
       });
 
-      expect(result.isError).toBe(true);
-      expect(result.content).toContain("not available");
+      expect(result.isError).toBe(false);
+      expect(result.content.toLowerCase()).toContain("stopped");
       expect(sentMessages).toHaveLength(0);
     });
   });
@@ -325,4 +355,294 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       ownerProxy.dispose();
     });
   });
+
+  // -------------------------------------------------------------------------
+  // target_client_id validation — mirrors host_cu's targetClientId tests in
+  // cu-unified-flow.test.ts. The resolver validates the explicit target
+  // before recordAction-equivalents so an invalid or cross-user id never
+  // reaches the proxy.
+  // -------------------------------------------------------------------------
+
+  describe("target_client_id validation", () => {
+    test("returns fast error when target_client_id does not match any connected client", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-a",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+        target_client_id: "missing-client",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("missing-client");
+      expect(result.content).toContain("host_app_control");
+      // No envelope dispatched — fail-fast before request().
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
+    test("returns fast error when target_client_id points to a client without host_app_control capability", async () => {
+      mockHubClients = [
+        {
+          clientId: "wrong-cap-client",
+          capabilities: ["host_bash"], // not host_app_control
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+        target_client_id: "wrong-cap-client",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("wrong-cap-client");
+      expect(result.content).toContain("does not support host_app_control");
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
+    test("dispatches with targetClientId when target_client_id is valid", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-a",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+        {
+          clientId: "client-b",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+        target_client_id: "client-b",
+      });
+
+      // Exactly one envelope dispatched, addressed to client-b.
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_app_control_request");
+      expect(sent.targetClientId).toBe("client-b");
+
+      proxy.resolve(sent.requestId as string, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+      });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+
+      proxy.dispose();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Multi-client ambiguity guard — when the LLM omits target_client_id and
+  // multiple same-user host_app_control clients are connected, the resolver
+  // must error rather than broadcast (one app-control session per client).
+  // -------------------------------------------------------------------------
+
+  describe("multi-client ambiguity guard", () => {
+    test("errors when multiple same-user clients connected and no target_client_id given", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-a",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+        {
+          clientId: "client-b",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain(
+        "multiple clients support host_app_control",
+      );
+      expect(result.content).toContain("target_client_id");
+      // No envelope dispatched.
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
+    test("auto-resolves to the unique same-user client when cross-user clients are also present", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-mine",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+        {
+          clientId: "client-other",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: "user-2",
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+      });
+
+      // Resolver must explicitly target the same-user client to prevent the
+      // proxy from broadcasting the action across the cross-user client too.
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.targetClientId).toBe("client-mine");
+
+      proxy.resolve(sent.requestId as string, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+      });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+
+      proxy.dispose();
+    });
+
+    test("single same-user client with no target proceeds without forcing targetClientId", async () => {
+      mockHubClients = [
+        {
+          clientId: "only-client",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+      });
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      // No cross-user ambiguity → resolver leaves targetClientId undefined,
+      // letting the proxy use its existing single-client routing.
+      expect(sent.targetClientId).toBeUndefined();
+
+      proxy.resolve(sent.requestId as string, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+      });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+
+      proxy.dispose();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Same-user enforcement — even when target_client_id is provided, a
+  // cross-user client can never be addressed.
+  // -------------------------------------------------------------------------
+
+  describe("same-user enforcement", () => {
+    test("rejects targeted dispatch from a different actor principal", async () => {
+      mockHubClients = [
+        {
+          clientId: "other-user-client",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: "user-2",
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+        target_client_id: "other-user-client",
+      });
+
+      expect(result.isError).toBe(true);
+      // No envelope dispatched.
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
+    test("rejects when the conversation has no source actor principal", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-a",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(
+        proxy,
+        "conv-1",
+        undefined,
+        /* trustGuardianPrincipalId */ null,
+      );
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+        target_client_id: "client-a",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+  });
 });