@vellumai/assistant 0.4.49 → 0.4.51

package/src/__tests__/host-cu-proxy.test.ts

@@ -6,11 +6,17 @@ describe("HostCuProxy", () => {
   let proxy: InstanceType<typeof HostCuProxy>;
   let sentMessages: unknown[];
   let sendToClient: (msg: unknown) => void;
+  let resolvedRequestIds: string[];
 
   function setup(maxSteps?: number) {
     sentMessages = [];
+    resolvedRequestIds = [];
     sendToClient = (msg: unknown) => sentMessages.push(msg);
-    proxy = new HostCuProxy(sendToClient as never, maxSteps);
+    proxy = new HostCuProxy(
+      sendToClient as never,
+      (requestId: string) => resolvedRequestIds.push(requestId),
+      maxSteps,
+    );
   }
 
   afterEach(() => {
@@ -364,6 +370,60 @@ describe("HostCuProxy", () => {
       );
     });
 
+    test("does not emit spurious warning on first observation", async () => {
+      setup();
+
+      // First ever request — no previous AX tree exists
+      proxy.recordAction("computer_use_click", { element_id: 1 });
+      const p1 = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+      );
+      const sent1 = sentMessages[0] as Record<string, unknown>;
+      proxy.resolve(sent1.requestId as string, {
+        axTree: "Button [1]",
+        // No axDiff on first observation — this is normal, not unchanged
+      });
+      const result1 = await p1;
+      expect(result1.content).not.toContain("NO VISIBLE EFFECT");
+    });
+
+    test("skips unchanged warning after computer_use_wait", async () => {
+      setup();
+
+      // Establish previous AX tree
+      const p1 = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+      );
+      proxy.recordAction("computer_use_click", { element_id: 1 });
+      const sent1 = sentMessages[0] as Record<string, unknown>;
+      proxy.resolve(sent1.requestId as string, {
+        axTree: "Button [1]",
+      });
+      await p1;
+
+      // Wait action with unchanged screen — should NOT warn
+      const p2 = proxy.request(
+        "computer_use_wait",
+        { duration_ms: 2000 },
+        "session-1",
+        2,
+      );
+      proxy.recordAction("computer_use_wait", { duration_ms: 2000 });
+      const sent2 = sentMessages[1] as Record<string, unknown>;
+      proxy.resolve(sent2.requestId as string, {
+        axTree: "Button [1]",
+        // No axDiff — screen unchanged, but that's expected after wait
+      });
+      const result2 = await p2;
+      expect(result2.content).not.toContain("NO VISIBLE EFFECT");
+    });
+
     test("resets consecutive count when diff is present", async () => {
       setup();
 
@@ -507,6 +567,35 @@ describe("HostCuProxy", () => {
       expect(result.content).toMatch(/<\/ax-tree>$/m);
     });
 
+    test("includes secondaryWindows after AX tree with cross-window note", () => {
+      setup();
+
+      const result = proxy.formatObservation({
+        axTree: "Button [1]\nLabel [2]",
+        secondaryWindows: "Safari — Window [10]\n  Link [11]",
+      });
+
+      expect(result.content).toContain("Safari — Window [10]");
+      expect(result.content).toContain("Link [11]");
+      expect(result.content).toContain(
+        "Note: The element [ID]s above are from other windows",
+      );
+      // secondaryWindows should appear after the AX tree
+      const axTreeEnd = result.content.indexOf("</ax-tree>");
+      const secondaryIdx = result.content.indexOf("Safari — Window [10]");
+      expect(axTreeEnd).toBeLessThan(secondaryIdx);
+    });
+
+    test("omits secondaryWindows section when field is absent", () => {
+      setup();
+
+      const result = proxy.formatObservation({
+        axTree: "Button [1]",
+      });
+
+      expect(result.content).not.toContain("other windows");
+    });
+
     test("includes diff when present", () => {
       setup();
 
@@ -576,7 +665,7 @@ describe("HostCuProxy", () => {
   // -------------------------------------------------------------------------
 
   describe("dispose", () => {
-    test("rejects all pending requests", () => {
+    test("rejects all pending requests", async () => {
       setup();
 
       const resultPromise = proxy.request(
@@ -593,7 +682,80 @@ describe("HostCuProxy", () => {
       proxy.dispose();
 
       expect(proxy.hasPendingRequest(requestId)).toBe(false);
-      expect(resultPromise).rejects.toThrow("Host CU proxy disposed");
+      await expect(resultPromise).rejects.toThrow("Host CU proxy disposed");
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // onInternalResolve callback
+  // -------------------------------------------------------------------------
+
+  describe("onInternalResolve", () => {
+    test("calls onInternalResolve when abort signal fires", async () => {
+      setup();
+
+      const controller = new AbortController();
+      const resultPromise = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+        undefined,
+        controller.signal,
+      );
+
+      const sent = sentMessages[0] as Record<string, unknown>;
+      const requestId = sent.requestId as string;
+
+      controller.abort();
+
+      await resultPromise;
+      expect(resolvedRequestIds).toContain(requestId);
+    });
+
+    test("calls onInternalResolve on dispose", async () => {
+      setup();
+
+      const resultPromise = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+      );
+
+      const sent = sentMessages[0] as Record<string, unknown>;
+      const requestId = sent.requestId as string;
+
+      proxy.dispose();
+
+      // dispose rejects pending requests — catch to avoid unhandled rejection
+      await resultPromise.catch(() => {});
+
+      expect(resolvedRequestIds).toContain(requestId);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // isAvailable
+  // -------------------------------------------------------------------------
+
+  describe("isAvailable", () => {
+    test("returns false by default", () => {
+      setup();
+      expect(proxy.isAvailable()).toBe(false);
+    });
+
+    test("returns true after updateSender with clientConnected=true", () => {
+      setup();
+      proxy.updateSender(sendToClient as never, true);
+      expect(proxy.isAvailable()).toBe(true);
+    });
+
+    test("returns false after updateSender with clientConnected=false", () => {
+      setup();
+      proxy.updateSender(sendToClient as never, true);
+      proxy.updateSender(sendToClient as never, false);
+      expect(proxy.isAvailable()).toBe(false);
     });
   });
 

package/src/__tests__/http-user-message-parity.test.ts

@@ -170,6 +170,7 @@ function makeSession(overrides: Record<string, unknown> = {}) {
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
     setHostCuProxy: () => {},
+    addPreactivatedSkillId: () => {},
     emitConfirmationStateChanged: () => {},
     emitActivityState: () => {},
     setTurnChannelContext: () => {},

package/src/__tests__/inbound-invite-redemption.test.ts

@@ -85,7 +85,10 @@ mock.module("../runtime/approval-message-composer.js", () => ({
   composeApprovalMessageGenerative: async () => "mock generative message",
 }));
 
-import { findContactChannel } from "../contacts/contact-store.js";
+import {
+  findContactChannel,
+  upsertContact,
+} from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import { createInvite, revokeInvite } from "../memory/invite-store.js";
@@ -106,6 +109,11 @@ afterAll(() => {
 // Helpers
 // ---------------------------------------------------------------------------
 
+/** Create a throwaway contact and return its ID, for use as the invite's contactId. */
+function createTargetContact(displayName = "Test Contact"): string {
+  return upsertContact({ displayName, role: "contact" }).id;
+}
+
 const TEST_BEARER_TOKEN = "test-token";
 let msgCounter = 0;
 
@@ -178,6 +186,7 @@ describe("inbound invite redemption intercept", () => {
   test("non-member with valid invite token becomes active member without guardian approval", async () => {
     const { rawToken } = createInvite({
       sourceChannel: "telegram",
+      contactId: createTargetContact(),
       maxUses: 5,
     });
 
@@ -231,6 +240,7 @@ describe("inbound invite redemption intercept", () => {
   test("non-member with expired token gets appropriate message", async () => {
     const { rawToken } = createInvite({
       sourceChannel: "telegram",
+      contactId: createTargetContact(),
       maxUses: 1,
       expiresInMs: -1, // already expired
     });
@@ -252,6 +262,7 @@ describe("inbound invite redemption intercept", () => {
   test("non-member with revoked token gets refusal text", async () => {
     const { rawToken, invite } = createInvite({
       sourceChannel: "telegram",
+      contactId: createTargetContact(),
       maxUses: 5,
     });
     revokeInvite(invite.id);
@@ -292,6 +303,7 @@ describe("inbound invite redemption intercept", () => {
   test("duplicate Telegram webhook deliveries do not double-redeem", async () => {
     const { rawToken } = createInvite({
       sourceChannel: "telegram",
+      contactId: createTargetContact(),
       maxUses: 5,
     });
 
@@ -353,7 +365,11 @@ describe("inbound invite redemption intercept", () => {
 
   test("channel mismatch returns appropriate message", async () => {
     // Create an invite for voice, but try to redeem via Telegram
-    const { rawToken } = createInvite({ sourceChannel: "phone", maxUses: 5 });
+    const { rawToken } = createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact(),
+      maxUses: 5,
+    });
 
     const req = buildInviteRequest(rawToken);
     const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
@@ -372,6 +388,7 @@ describe("inbound invite redemption intercept", () => {
   test("already-active member with invite token gets acknowledgement", async () => {
     const { rawToken } = createInvite({
       sourceChannel: "telegram",
+      contactId: createTargetContact(),
       maxUses: 5,
     });
 
@@ -397,11 +414,8 @@ describe("inbound invite redemption intercept", () => {
   });
 
   test("reactivation via invite preserves existing guardian-managed member display name", async () => {
-    const { rawToken } = createInvite({
-      sourceChannel: "telegram",
-      maxUses: 5,
-    });
-
+    // Pre-create a revoked member named "Jeff" — the invite should preserve
+    // that guardian-assigned name rather than overwriting with the Telegram name.
     upsertContactChannel({
       sourceChannel: "telegram",
       externalUserId: "user-invite-123",
@@ -411,6 +425,21 @@ describe("inbound invite redemption intercept", () => {
       displayName: "Jeff",
     });
 
+    // Look up the contact that upsertContactChannel created so we can use
+    // its ID as the invite's contactId (satisfies the FK constraint).
+    const existing = findContactChannel({
+      channelType: "telegram",
+      externalUserId: "user-invite-123",
+      externalChatId: "chat-invite-test",
+    });
+    const targetContactId = existing!.contact.id;
+
+    const { rawToken } = createInvite({
+      sourceChannel: "telegram",
+      contactId: targetContactId,
+      maxUses: 5,
+    });
+
     const req = buildInviteRequest(rawToken, {
       actorDisplayName: "Noa Flaherty",
     });

package/src/__tests__/integration-status.test.ts

@@ -10,6 +10,7 @@ const connectedProviders = new Set<string>();
 
 mock.module("../security/secure-keys.js", () => ({
   getSecureKey: (account: string) => secureKeyValues.get(account),
+  getSecureKeyAsync: async (account: string) => secureKeyValues.get(account),
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -45,8 +46,8 @@ describe("integration-status", () => {
   });
 
   describe("getIntegrationSummary", () => {
-    test("returns all disconnected when no keys are set", () => {
-      const summary = getIntegrationSummary();
+    test("returns all disconnected when no keys are set", async () => {
+      const summary = await getIntegrationSummary();
       expect(summary).toEqual([
         { name: "Gmail", category: "email", connected: false },
         { name: "Slack", category: "messaging", connected: false },
@@ -55,25 +56,25 @@ describe("integration-status", () => {
       ]);
     });
 
-    test("returns all connected when all keys are set", () => {
-      setOAuthConnected("integration:gmail");
+    test("returns all connected when all keys are set", async () => {
+      setOAuthConnected("integration:google");
       setOAuthConnected("integration:slack");
       mockTwilioAccountSid = "sid";
       secureKeyValues.set(credentialKey("twilio", "auth_token"), "auth");
       setOAuthConnected("telegram");
 
-      const summary = getIntegrationSummary();
+      const summary = await getIntegrationSummary();
       expect(summary.every((s: { connected: boolean }) => s.connected)).toBe(
         true,
       );
     });
 
-    test("returns mixed status", () => {
+    test("returns mixed status", async () => {
       mockTwilioAccountSid = "sid";
       secureKeyValues.set(credentialKey("twilio", "auth_token"), "auth");
       setOAuthConnected("telegram");
 
-      const summary = getIntegrationSummary();
+      const summary = await getIntegrationSummary();
       const connected = summary.filter(
         (s: { connected: boolean }) => s.connected,
       );
@@ -91,17 +92,17 @@ describe("integration-status", () => {
       ]);
     });
 
-    test("Twilio disconnected when only account_sid is set (missing auth_token)", () => {
+    test("Twilio disconnected when only account_sid is set (missing auth_token)", async () => {
       mockTwilioAccountSid = "sid";
 
-      const summary = getIntegrationSummary();
+      const summary = await getIntegrationSummary();
       const twilio = summary.find((s: { name: string }) => s.name === "Twilio");
       expect(twilio?.connected).toBe(false);
     });
 
-    test("Telegram disconnected when no connection record exists", () => {
+    test("Telegram disconnected when no connection record exists", async () => {
       // No oauth_connection record for telegram — should be disconnected
-      const summary = getIntegrationSummary();
+      const summary = await getIntegrationSummary();
       const telegram = summary.find(
         (s: { name: string }) => s.name === "Telegram",
       );
@@ -110,32 +111,32 @@ describe("integration-status", () => {
   });
 
   describe("formatIntegrationSummary", () => {
-    test("shows checkmarks and crosses", () => {
+    test("shows checkmarks and crosses", async () => {
       mockTwilioAccountSid = "sid";
       secureKeyValues.set(credentialKey("twilio", "auth_token"), "auth");
       setOAuthConnected("telegram");
 
-      const result = formatIntegrationSummary();
+      const result = await formatIntegrationSummary();
       expect(result).toBe(
         "Gmail \u2717 | Slack \u2717 | Twilio \u2713 | Telegram \u2713",
       );
     });
 
-    test("all disconnected", () => {
-      const result = formatIntegrationSummary();
+    test("all disconnected", async () => {
+      const result = await formatIntegrationSummary();
       expect(result).toBe(
         "Gmail \u2717 | Slack \u2717 | Twilio \u2717 | Telegram \u2717",
       );
     });
 
-    test("all connected", () => {
-      setOAuthConnected("integration:gmail");
+    test("all connected", async () => {
+      setOAuthConnected("integration:google");
       setOAuthConnected("integration:slack");
       mockTwilioAccountSid = "sid";
       secureKeyValues.set(credentialKey("twilio", "auth_token"), "auth");
       setOAuthConnected("telegram");
 
-      const result = formatIntegrationSummary();
+      const result = await formatIntegrationSummary();
       expect(result).toBe(
         "Gmail \u2713 | Slack \u2713 | Twilio \u2713 | Telegram \u2713",
       );
@@ -143,28 +144,28 @@ describe("integration-status", () => {
   });
 
   describe("hasCapability", () => {
-    test("returns false when no integrations in category are connected", () => {
-      expect(hasCapability("email")).toBe(false);
-      expect(hasCapability("messaging")).toBe(false);
+    test("returns false when no integrations in category are connected", async () => {
+      expect(await hasCapability("email")).toBe(false);
+      expect(await hasCapability("messaging")).toBe(false);
     });
 
-    test("returns true when any integration in category is connected", () => {
+    test("returns true when any integration in category is connected", async () => {
       setOAuthConnected("telegram");
-      expect(hasCapability("messaging")).toBe(true);
+      expect(await hasCapability("messaging")).toBe(true);
     });
 
-    test("returns false when no connection record exists for category integrations", () => {
+    test("returns false when no connection record exists for category integrations", async () => {
       // No oauth_connection record for telegram — should not count as connected
-      expect(hasCapability("messaging")).toBe(false);
+      expect(await hasCapability("messaging")).toBe(false);
     });
 
-    test("returns false for unknown categories", () => {
-      expect(hasCapability("nonexistent")).toBe(false);
+    test("returns false for unknown categories", async () => {
+      expect(await hasCapability("nonexistent")).toBe(false);
     });
 
-    test("email category checks Gmail", () => {
-      setOAuthConnected("integration:gmail");
-      expect(hasCapability("email")).toBe(true);
+    test("email category checks Gmail", async () => {
+      setOAuthConnected("integration:google");
+      expect(await hasCapability("email")).toBe(true);
     });
   });
 });