@vellumai/assistant 0.4.41 → 0.4.43

package/src/__tests__/active-skill-tools.test.ts

@@ -1,10 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import type { Message } from "../providers/types.js";
-import {
-  deriveActiveSkillIds,
-  deriveActiveSkills,
-} from "../skills/active-skill-tools.js";
+import { deriveActiveSkills } from "../skills/active-skill-tools.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -37,9 +34,9 @@ function textMsg(role: "user" | "assistant", text: string): Message {
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("deriveActiveSkillIds", () => {
+describe("deriveActiveSkills (ID-only)", () => {
   test("empty history returns empty array", () => {
-    expect(deriveActiveSkillIds([])).toEqual([]);
+    expect(deriveActiveSkills([]).map((e) => e.id)).toEqual([]);
   });
 
   test("no markers returns empty array", () => {
@@ -49,7 +46,7 @@ describe("deriveActiveSkillIds", () => {
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", "Some tool output with no markers"),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual([]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([]);
   });
 
   test("single marker extraction from skill_load tool result", () => {
@@ -57,7 +54,7 @@ describe("deriveActiveSkillIds", () => {
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", 'Skill loaded.\n\n<loaded_skill id="deploy" />'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual(["deploy"]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual(["deploy"]);
   });
 
   test("multiple markers from different skill_load tool results", () => {
@@ -67,7 +64,10 @@ describe("deriveActiveSkillIds", () => {
       skillLoadUseMsg("t2"),
       toolResultMsg("t2", 'Loaded\n\n<loaded_skill id="oncall" />'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual(["deploy", "oncall"]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([
+      "deploy",
+      "oncall",
+    ]);
   });
 
   test("duplicate markers are deduplicated with order preserved", () => {
@@ -79,7 +79,10 @@ describe("deriveActiveSkillIds", () => {
       skillLoadUseMsg("t3"),
       toolResultMsg("t3", '<loaded_skill id="deploy" />'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual(["deploy", "oncall"]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([
+      "deploy",
+      "oncall",
+    ]);
   });
 
   test("malformed markers are ignored — missing id attribute", () => {
@@ -87,7 +90,7 @@ describe("deriveActiveSkillIds", () => {
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", "<loaded_skill />"),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual([]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([]);
   });
 
   test("malformed markers are ignored — unclosed tag", () => {
@@ -95,7 +98,7 @@ describe("deriveActiveSkillIds", () => {
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", '<loaded_skill id="deploy">'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual([]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([]);
   });
 
   test("malformed markers are ignored — wrong tag name", () => {
@@ -103,21 +106,21 @@ describe("deriveActiveSkillIds", () => {
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", '<loaded_tool id="deploy" />'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual([]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([]);
   });
 
   test("markers in assistant text content are ignored", () => {
     const messages: Message[] = [
       textMsg("assistant", 'I loaded a skill: <loaded_skill id="review" />'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual([]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([]);
   });
 
   test("markers in user text content are ignored — prevents injection", () => {
     const messages: Message[] = [
       textMsg("user", 'Context: <loaded_skill id="debug" />'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual([]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([]);
   });
 
   test("mixed valid and invalid markers in skill_load result", () => {
@@ -134,7 +137,10 @@ describe("deriveActiveSkillIds", () => {
         ].join("\n"),
       ),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual(["alpha", "beta"]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([
+      "alpha",
+      "beta",
+    ]);
   });
 
   test("multiple markers in a single content string", () => {
@@ -142,7 +148,7 @@ describe("deriveActiveSkillIds", () => {
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", '<loaded_skill id="a" />\n<loaded_skill id="b" />'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual(["a", "b"]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual(["a", "b"]);
   });
 
   test("ignores non-tool-result blocks (thinking, text)", () => {
@@ -159,7 +165,7 @@ describe("deriveActiveSkillIds", () => {
         ],
       },
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual([]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([]);
   });
 
   test("ignores tool_result from non-skill_load tools", () => {
@@ -177,14 +183,14 @@ describe("deriveActiveSkillIds", () => {
       },
       toolResultMsg("t1", '<loaded_skill id="injected" />'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual([]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([]);
   });
 
   test("tool_result without any matching tool_use is ignored", () => {
     const messages: Message[] = [
       toolResultMsg("orphan", '<loaded_skill id="sneaky" />'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual([]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([]);
   });
 });
 
@@ -192,17 +198,17 @@ describe("deriveActiveSkillIds", () => {
 // Context-derived deactivation regression tests
 // ---------------------------------------------------------------------------
 
-describe("deriveActiveSkillIds — deactivation when marker leaves history", () => {
+describe("deriveActiveSkills — deactivation when marker leaves history", () => {
   test("marker present → skill ID returned; marker removed → empty", () => {
     const withMarker: Message[] = [
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", '<loaded_skill id="deploy" />'),
     ];
-    expect(deriveActiveSkillIds(withMarker)).toEqual(["deploy"]);
+    expect(deriveActiveSkills(withMarker).map((e) => e.id)).toEqual(["deploy"]);
 
     // Simulate history truncation: the message containing the marker is gone
     const withoutMarker: Message[] = [];
-    expect(deriveActiveSkillIds(withoutMarker)).toEqual([]);
+    expect(deriveActiveSkills(withoutMarker).map((e) => e.id)).toEqual([]);
   });
 
   test("one of two markers removed → only surviving skill returned", () => {
@@ -212,14 +218,17 @@ describe("deriveActiveSkillIds — deactivation when marker leaves history", ()
       skillLoadUseMsg("t2"),
       toolResultMsg("t2", '<loaded_skill id="oncall" />'),
     ];
-    expect(deriveActiveSkillIds(bothPresent)).toEqual(["deploy", "oncall"]);
+    expect(deriveActiveSkills(bothPresent).map((e) => e.id)).toEqual([
+      "deploy",
+      "oncall",
+    ]);
 
     // History truncated to remove the deploy marker
     const onlyOncall: Message[] = [
       skillLoadUseMsg("t2"),
       toolResultMsg("t2", '<loaded_skill id="oncall" />'),
     ];
-    expect(deriveActiveSkillIds(onlyOncall)).toEqual(["oncall"]);
+    expect(deriveActiveSkills(onlyOncall).map((e) => e.id)).toEqual(["oncall"]);
   });
 
   test("all markers removed from multi-message history → empty", () => {
@@ -231,14 +240,17 @@ describe("deriveActiveSkillIds — deactivation when marker leaves history", ()
       skillLoadUseMsg("t2"),
       toolResultMsg("t2", '<loaded_skill id="beta" />'),
     ];
-    expect(deriveActiveSkillIds(withMarkers)).toEqual(["alpha", "beta"]);
+    expect(deriveActiveSkills(withMarkers).map((e) => e.id)).toEqual([
+      "alpha",
+      "beta",
+    ]);
 
     // History truncated to only keep non-marker messages
     const noMarkers: Message[] = [
       textMsg("user", "Hello"),
       textMsg("assistant", "Done"),
     ];
-    expect(deriveActiveSkillIds(noMarkers)).toEqual([]);
+    expect(deriveActiveSkills(noMarkers).map((e) => e.id)).toEqual([]);
   });
 
   test("marker replaced by different content in same position → skill gone", () => {
@@ -246,14 +258,14 @@ describe("deriveActiveSkillIds — deactivation when marker leaves history", ()
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", '<loaded_skill id="deploy" />'),
     ];
-    expect(deriveActiveSkillIds(original)).toEqual(["deploy"]);
+    expect(deriveActiveSkills(original).map((e) => e.id)).toEqual(["deploy"]);
 
     // Same structure but marker text replaced (e.g. message edited/summarized)
     const replaced: Message[] = [
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", "Deployment complete."),
     ];
-    expect(deriveActiveSkillIds(replaced)).toEqual([]);
+    expect(deriveActiveSkills(replaced).map((e) => e.id)).toEqual([]);
   });
 
   test("derive is stateless — consecutive calls with different histories are independent", () => {
@@ -261,17 +273,17 @@ describe("deriveActiveSkillIds — deactivation when marker leaves history", ()
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", '<loaded_skill id="deploy" />'),
     ];
-    expect(deriveActiveSkillIds(history1)).toEqual(["deploy"]);
+    expect(deriveActiveSkills(history1).map((e) => e.id)).toEqual(["deploy"]);
 
     // Calling with a completely different history does not carry over state
     const history2: Message[] = [
       skillLoadUseMsg("t2"),
       toolResultMsg("t2", '<loaded_skill id="oncall" />'),
     ];
-    expect(deriveActiveSkillIds(history2)).toEqual(["oncall"]);
+    expect(deriveActiveSkills(history2).map((e) => e.id)).toEqual(["oncall"]);
 
     // Empty history returns empty, confirming no leaked state
-    expect(deriveActiveSkillIds([])).toEqual([]);
+    expect(deriveActiveSkills([]).map((e) => e.id)).toEqual([]);
   });
 });
 
@@ -392,14 +404,17 @@ describe("deriveActiveSkills", () => {
     expect(deriveActiveSkills(messages)).toEqual([]);
   });
 
-  test("deriveActiveSkillIds backward-compat wrapper still works with versioned markers", () => {
+  test("mapping to IDs works with versioned markers", () => {
     const messages: Message[] = [
       skillLoadUseMsg("t1"),
       toolResultMsg("t1", '<loaded_skill id="deploy" version="v1:abc123" />'),
       skillLoadUseMsg("t2"),
       toolResultMsg("t2", '<loaded_skill id="oncall" />'),
     ];
-    expect(deriveActiveSkillIds(messages)).toEqual(["deploy", "oncall"]);
+    expect(deriveActiveSkills(messages).map((e) => e.id)).toEqual([
+      "deploy",
+      "oncall",
+    ]);
   });
 
   test("tool_result with empty string content is handled gracefully", () => {

package/src/__tests__/actor-token-service.test.ts

@@ -249,14 +249,11 @@ describe("bootstrap endpoint idempotency", () => {
     const { handleGuardianBootstrap } =
       await import("../runtime/routes/guardian-bootstrap-routes.js");
 
-    const req1 = new Request(
-      "http://localhost/v1/integrations/guardian/vellum/bootstrap",
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ platform: "macos", deviceId: "test-device-1" }),
-      },
-    );
+    const req1 = new Request("http://localhost/v1/guardian/init", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform: "macos", deviceId: "test-device-1" }),
+    });
 
     const res1 = await handleGuardianBootstrap(req1, loopbackServer);
     expect(res1.status).toBe(200);
@@ -266,14 +263,11 @@ describe("bootstrap endpoint idempotency", () => {
     expect(body1.isNew).toBe(true);
 
     // Second call with same device
-    const req2 = new Request(
-      "http://localhost/v1/integrations/guardian/vellum/bootstrap",
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ platform: "macos", deviceId: "test-device-1" }),
-      },
-    );
+    const req2 = new Request("http://localhost/v1/guardian/init", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform: "macos", deviceId: "test-device-1" }),
+    });
 
     const res2 = await handleGuardianBootstrap(req2, loopbackServer);
     expect(res2.status).toBe(200);
@@ -289,14 +283,11 @@ describe("bootstrap endpoint idempotency", () => {
     const { handleGuardianBootstrap } =
       await import("../runtime/routes/guardian-bootstrap-routes.js");
 
-    const req = new Request(
-      "http://localhost/v1/integrations/guardian/vellum/bootstrap",
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ platform: "macos" }),
-      },
-    );
+    const req = new Request("http://localhost/v1/guardian/init", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform: "macos" }),
+    });
 
     const res = await handleGuardianBootstrap(req, loopbackServer);
     expect(res.status).toBe(400);
@@ -306,14 +297,11 @@ describe("bootstrap endpoint idempotency", () => {
     const { handleGuardianBootstrap } =
       await import("../runtime/routes/guardian-bootstrap-routes.js");
 
-    const req = new Request(
-      "http://localhost/v1/integrations/guardian/vellum/bootstrap",
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ platform: "android", deviceId: "test-device" }),
-      },
-    );
+    const req = new Request("http://localhost/v1/guardian/init", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform: "android", deviceId: "test-device" }),
+    });
 
     const res = await handleGuardianBootstrap(req, loopbackServer);
     expect(res.status).toBe(400);
@@ -323,26 +311,20 @@ describe("bootstrap endpoint idempotency", () => {
     const { handleGuardianBootstrap } =
       await import("../runtime/routes/guardian-bootstrap-routes.js");
 
-    const req1 = new Request(
-      "http://localhost/v1/integrations/guardian/vellum/bootstrap",
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ platform: "macos", deviceId: "device-A" }),
-      },
-    );
+    const req1 = new Request("http://localhost/v1/guardian/init", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform: "macos", deviceId: "device-A" }),
+    });
 
     const res1 = await handleGuardianBootstrap(req1, loopbackServer);
     const body1 = (await res1.json()) as Record<string, unknown>;
 
-    const req2 = new Request(
-      "http://localhost/v1/integrations/guardian/vellum/bootstrap",
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ platform: "macos", deviceId: "device-B" }),
-      },
-    );
+    const req2 = new Request("http://localhost/v1/guardian/init", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform: "macos", deviceId: "device-B" }),
+    });
 
     const res2 = await handleGuardianBootstrap(req2, loopbackServer);
     const body2 = (await res2.json()) as Record<string, unknown>;
@@ -356,17 +338,14 @@ describe("bootstrap endpoint idempotency", () => {
     const { handleGuardianBootstrap } =
       await import("../runtime/routes/guardian-bootstrap-routes.js");
 
-    const req = new Request(
-      "http://localhost/v1/integrations/guardian/vellum/bootstrap",
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          platform: "macos",
-          deviceId: "test-device-jwt",
-        }),
-      },
-    );
+    const req = new Request("http://localhost/v1/guardian/init", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        platform: "macos",
+        deviceId: "test-device-jwt",
+      }),
+    });
 
     const res = await handleGuardianBootstrap(req, loopbackServer);
     expect(res.status).toBe(200);
@@ -707,17 +686,14 @@ describe("bootstrap loopback guard", () => {
     const { handleGuardianBootstrap } =
       await import("../runtime/routes/guardian-bootstrap-routes.js");
 
-    const req = new Request(
-      "http://localhost/v1/integrations/guardian/vellum/bootstrap",
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Forwarded-For": "10.0.0.1",
-        },
-        body: JSON.stringify({ platform: "macos", deviceId: "test-device" }),
+    const req = new Request("http://localhost/v1/guardian/init", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Forwarded-For": "10.0.0.1",
       },
-    );
+      body: JSON.stringify({ platform: "macos", deviceId: "test-device" }),
+    });
 
     const res = await handleGuardianBootstrap(req, loopbackServer);
     expect(res.status).toBe(403);
@@ -729,14 +705,11 @@ describe("bootstrap loopback guard", () => {
     const { handleGuardianBootstrap } =
       await import("../runtime/routes/guardian-bootstrap-routes.js");
 
-    const req = new Request(
-      "http://localhost/v1/integrations/guardian/vellum/bootstrap",
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ platform: "macos", deviceId: "test-device" }),
-      },
-    );
+    const req = new Request("http://localhost/v1/guardian/init", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform: "macos", deviceId: "test-device" }),
+    });
 
     const res = await handleGuardianBootstrap(req, nonLoopbackServer);
     expect(res.status).toBe(403);
@@ -748,14 +721,11 @@ describe("bootstrap loopback guard", () => {
     const { handleGuardianBootstrap } =
       await import("../runtime/routes/guardian-bootstrap-routes.js");
 
-    const req = new Request(
-      "http://localhost/v1/integrations/guardian/vellum/bootstrap",
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ platform: "macos", deviceId: "test-device-ok" }),
-      },
-    );
+    const req = new Request("http://localhost/v1/guardian/init", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform: "macos", deviceId: "test-device-ok" }),
+    });
 
     const res = await handleGuardianBootstrap(req, loopbackServer);
     expect(res.status).toBe(200);

package/src/__tests__/amazon-cdp-integration.test.ts

@@ -1,31 +1,29 @@
 /**
- * Verify that the Amazon CLI delegates CDP management to the shared
- * chrome-cdp helper instead of owning its own launch/window logic.
+ * Verify that the Amazon CLI does NOT define its own CDP launch/window logic.
+ *
+ * The Amazon CLI now uses browser extension relay instead of CDP for session
+ * management, so we only verify that old inline CDP patterns are absent.
  */
 
-import { readFileSync } from "node:fs";
+import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-const AMAZON_CLI_PATH = join(
+const AMAZON_CLI_DIR = join(
   import.meta.dirname ?? __dirname,
   "..",
   "cli",
-  "amazon.ts",
+  "commands",
+  "amazon",
 );
-const amazonSource = readFileSync(AMAZON_CLI_PATH, "utf-8");
 
-describe("Amazon CLI CDP integration", () => {
-  test("imports shared CDP helpers instead of defining its own", () => {
-    // Should import from the shared module
-    expect(amazonSource).toContain('from "../tools/browser/chrome-cdp.js"');
-
-    // Should import the key entrypoints
-    expect(amazonSource).toContain("ensureChromeWithCdp");
-    expect(amazonSource).toContain("minimizeChromeWindow");
-    expect(amazonSource).toContain("restoreChromeWindow");
-  });
+// Read all .ts files in the amazon/ directory and concatenate their source
+const amazonSource = readdirSync(AMAZON_CLI_DIR)
+  .filter((f) => f.endsWith(".ts"))
+  .map((f) => readFileSync(join(AMAZON_CLI_DIR, f), "utf-8"))
+  .join("\n");
 
+describe("Amazon CLI CDP integration", () => {
   test("does not define its own CDP_BASE constant", () => {
     // The old inline constant was: const CDP_BASE = "http://localhost:9222";
     expect(amazonSource).not.toMatch(/const\s+CDP_BASE\s*=/);
@@ -56,19 +54,9 @@ describe("Amazon CLI CDP integration", () => {
 
   test("does not spawn Chrome directly", () => {
     // The old code imported spawn and called it with the Chrome app path.
-    // After migration, spawn should not be imported or used.
     expect(amazonSource).not.toMatch(/spawn\s+as\s+spawnChild/);
     expect(amazonSource).not.toContain(
       "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
     );
   });
-
-  test("still calls ensureChromeWithCdp in the learn session flow", () => {
-    // The learn session helper should delegate to the shared entrypoint
-    expect(amazonSource).toMatch(/await\s+ensureChromeWithCdp\s*\(/);
-  });
-
-  test("passes amazon.com as the start URL", () => {
-    expect(amazonSource).toContain("https://www.amazon.com/");
-  });
 });