@vellumai/assistant 0.4.54 → 0.4.56

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

@@ -133,6 +133,19 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     contextWindow: { maxInputTokens: 200000 },
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-2.5-flash-image",
+      },
+      "web-search": { mode: "your-own", provider: "anthropic-native" },
+    },
   }),
 }));
 
@@ -162,8 +175,8 @@ const testAuthContext: AuthContext = {
   policyEpoch: 1,
 };
 
-// ── Helper: create a minimal mock session ──────────────────────────────────
-function makeSession(overrides: Record<string, unknown> = {}) {
+// ── Helper: create a minimal mock conversation ─────────────────────────────
+function makeConversation(overrides: Record<string, unknown> = {}) {
   return {
     setTrustContext: () => {},
     updateClient: () => {},
@@ -188,7 +201,7 @@ function makeSession(overrides: Record<string, unknown> = {}) {
     trustContext: undefined,
     hasPendingConfirmation: () => false,
     ...overrides,
-  } as unknown as import("../daemon/session.js").Session;
+  } as unknown as import("../daemon/conversation.js").Conversation;
 }
 
 // ── Helper: create an HTTP request to POST /v1/messages ────────────────────
@@ -209,14 +222,14 @@ function makeRequest(content: string, extra: Record<string, unknown> = {}) {
 // ── Helper: send a message through handleSendMessage ───────────────────────
 async function sendMessage(
   content: string,
-  session: import("../daemon/session.js").Session,
+  conversationObj: import("../daemon/conversation.js").Conversation,
   extra: Record<string, unknown> = {},
 ) {
   return handleSendMessage(
     makeRequest(content, extra),
     {
       sendMessageDeps: {
-        getOrCreateSession: async () => session,
+        getOrCreateConversation: async () => conversationObj,
         assistantEventHub: { publish: async () => {} } as any,
         resolveAttachments: () => [],
       },
@@ -241,9 +254,9 @@ describe("HTTP POST /v1/messages blocks secret ingress", () => {
       "Set up Telegram with my bot token 123456789:ABCDefGHIJklmnopQRSTuvwxyz012345678";
     const persistUserMessage = mock(async () => "persisted-msg-id");
     const runAgentLoop = mock(async () => undefined);
-    const session = makeSession({ persistUserMessage, runAgentLoop });
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
-    const res = await sendMessage(secretContent, session);
+    const res = await sendMessage(secretContent, conversation);
 
     expect(res.status).toBe(422);
     const body = (await res.json()) as {
@@ -266,9 +279,9 @@ describe("HTTP POST /v1/messages blocks secret ingress", () => {
       "Here is my AWS key AKIAQRSTUVWXYZ123456 and secret wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY";
     const persistUserMessage = mock(async () => "persisted-msg-id");
     const runAgentLoop = mock(async () => undefined);
-    const session = makeSession({ persistUserMessage, runAgentLoop });
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
-    const res = await sendMessage(secretContent, session);
+    const res = await sendMessage(secretContent, conversation);
 
     expect(res.status).toBe(422);
     const body = (await res.json()) as {
@@ -287,9 +300,9 @@ describe("HTTP POST /v1/messages blocks secret ingress", () => {
     const secretContent = "My Stripe key is sk_live_4eC39HqLyjWDarjtT1zdp7dc";
     const persistUserMessage = mock(async () => "persisted-msg-id");
     const runAgentLoop = mock(async () => undefined);
-    const session = makeSession({ persistUserMessage, runAgentLoop });
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
-    const res = await sendMessage(secretContent, session);
+    const res = await sendMessage(secretContent, conversation);
 
     expect(res.status).toBe(422);
     const body = (await res.json()) as {
@@ -308,9 +321,9 @@ describe("HTTP POST /v1/messages blocks secret ingress", () => {
     const normalContent = "What is the weather today?";
     const persistUserMessage = mock(async () => "persisted-msg-id");
     const runAgentLoop = mock(async () => undefined);
-    const session = makeSession({ persistUserMessage, runAgentLoop });
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
-    const res = await sendMessage(normalContent, session);
+    const res = await sendMessage(normalContent, conversation);
 
     expect(res.status).toBe(202);
     const body = (await res.json()) as { accepted: boolean };
@@ -340,9 +353,9 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
     // legacy handleUserMessage entry point.
     const persistUserMessage = mock(async () => "persisted-msg-id");
     const runAgentLoop = mock(async () => undefined);
-    const session = makeSession({ persistUserMessage, runAgentLoop });
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
-    const res = await sendMessage("start recording", session);
+    const res = await sendMessage("start recording", conversation);
 
     expect(res.status).toBe(202);
     expect(persistUserMessage).toHaveBeenCalledTimes(1);
@@ -357,9 +370,9 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
     // be caught.
     const persistUserMessage = mock(async () => "persisted-msg-id");
     const runAgentLoop = mock(async () => undefined);
-    const session = makeSession({ persistUserMessage, runAgentLoop });
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
-    const res = await sendMessage("start screen recording", session, {
+    const res = await sendMessage("start screen recording", conversation, {
       commandIntent: { type: "start_recording", payload: "screen" },
     });
 
@@ -371,9 +384,9 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
   test("stop recording commands pass through to the agent loop", async () => {
     const persistUserMessage = mock(async () => "persisted-msg-id");
     const runAgentLoop = mock(async () => undefined);
-    const session = makeSession({ persistUserMessage, runAgentLoop });
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
-    const res = await sendMessage("stop recording", session);
+    const res = await sendMessage("stop recording", conversation);
 
     expect(res.status).toBe(202);
     expect(persistUserMessage).toHaveBeenCalledTimes(1);

package/src/__tests__/intent-routing.test.ts

@@ -55,8 +55,19 @@ mock.module("../config/loader.js", () => ({
     ui: {},
 
     sandbox: { enabled: false, backend: "local" },
-    assistantFeatureFlagValues: {
-      "feature_flags.guardian-verify-setup.enabled": true,
+    assistantFeatureFlagValues: {},
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-2.5-flash-image",
+      },
+      "web-search": { mode: "your-own", provider: "anthropic-native" },
     },
   }),
   loadConfig: () => ({}),
@@ -233,10 +244,10 @@ describe("cross-tool routing consistency", () => {
 });
 
 // =====================================================================
-// 4. Guardian verification routing section in system prompt
+// 4. Activation hints in <available_skills> XML (replaces domain routing sections)
 // =====================================================================
 
-describe("Guardian verification routing section in system prompt", () => {
+describe("Activation hints in available_skills XML", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
   });
@@ -247,92 +258,68 @@ describe("Guardian verification routing section in system prompt", () => {
     }
   });
 
-  test("system prompt includes the guardian verification routing heading", () => {
+  test("available_skills XML does NOT contain location attribute", () => {
     const prompt = buildSystemPrompt();
-    expect(prompt).toContain("## Routing: Guardian Verification");
+    const start = prompt.indexOf("<available_skills>");
+    const end = prompt.indexOf("</available_skills>");
+    expect(start).not.toBe(-1);
+    expect(end).not.toBe(-1);
+    const skillsXml = prompt.substring(start, end);
+    expect(skillsXml).not.toContain("location=");
   });
 
-  test('routing section includes trigger phrase "verify guardian"', () => {
+  test("phone-calls bundled skill has hints and avoid-when attributes in XML", () => {
     const prompt = buildSystemPrompt();
-    expect(prompt).toContain("verify guardian");
-  });
-
-  test("routing section does not include legacy channel trigger phrases", () => {
-    const prompt = buildSystemPrompt();
-    // Verify no legacy channel trigger phrases remain in the routing section
-    expect(prompt).not.toContain("set guardian for");
-  });
-
-  test('routing section includes trigger phrase "verify my Telegram account"', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain("verify my Telegram account");
-  });
-
-  test('routing section includes trigger phrase "verify phone channel"', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain("verify phone channel");
-  });
-
-  test('routing section includes trigger phrase "verify my phone number"', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain("verify my phone number");
-  });
-
-  test('routing section includes trigger phrase "set up guardian verification"', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain("set up guardian verification");
-  });
-
-  test("routing section references the guardian-verify-setup skill", () => {
+    const start = prompt.indexOf("<available_skills>");
+    const end = prompt.indexOf("</available_skills>");
+    expect(start).not.toBe(-1);
+    expect(end).not.toBe(-1);
+    const skillsXml = prompt.substring(start, end);
+    expect(skillsXml).toContain('id="phone-calls"');
+    const skillLine = skillsXml
+      .split("\n")
+      .find((l) => l.includes('id="phone-calls"'));
+    expect(skillLine).toBeDefined();
+    expect(skillLine).toContain("hints=");
+    expect(skillLine).toContain("avoid-when=");
+  });
+
+  test("orchestration bundled skill has hints and avoid-when attributes in XML", () => {
     const prompt = buildSystemPrompt();
-    expect(prompt).toContain("guardian-verify-setup");
-  });
-
-  test("routing section mentions phone and telegram channels but not legacy channels", () => {
-    const prompt = buildSystemPrompt();
-    const routingStart = prompt.indexOf("## Routing: Guardian Verification");
-    const routingSection = prompt.substring(routingStart, routingStart + 1000);
-    expect(routingSection).toContain("phone");
-    expect(routingSection).toContain("telegram");
-  });
-
-  test("routing section contains exclusivity wording", () => {
-    const prompt = buildSystemPrompt();
-    const lower = prompt.toLowerCase();
-    // Must contain "exclusively" or "must only" to enforce exclusive handling
-    expect(lower.includes("exclusively") || lower.includes("must only")).toBe(
-      true,
-    );
-  });
-
-  test("routing section prohibits loading phone-calls for guardian verification", () => {
+    const start = prompt.indexOf("<available_skills>");
+    const end = prompt.indexOf("</available_skills>");
+    expect(start).not.toBe(-1);
+    expect(end).not.toBe(-1);
+    const skillsXml = prompt.substring(start, end);
+    expect(skillsXml).toContain('id="orchestration"');
+    const skillLine = skillsXml
+      .split("\n")
+      .find((l) => l.includes('id="orchestration"'));
+    expect(skillLine).toBeDefined();
+    expect(skillLine).toContain("hints=");
+    expect(skillLine).toContain("avoid-when=");
+  });
+
+  test("browser bundled skill has hints attribute in XML", () => {
     const prompt = buildSystemPrompt();
-    const lower = prompt.toLowerCase();
-    // Must explicitly prohibit phone-calls for guardian verification intents
-    expect(lower).toContain("do not load");
-    expect(lower).toContain("phone-calls");
-  });
-
-  test("routing section includes channel-preservation guidance", () => {
-    const prompt = buildSystemPrompt();
-    const lower = prompt.toLowerCase();
-    // Must advise not to re-ask channel if already specified
-    expect(
-      lower.includes("do not re-ask") || lower.includes("already specified"),
-    ).toBe(true);
-  });
-
-  test('routing section disambiguates "set myself up as your guardian" phrasing', () => {
-    const prompt = buildSystemPrompt();
-    const lower = prompt.toLowerCase();
-    expect(lower).toContain("help me set myself up as your guardian");
-    expect(lower).toContain("asking to verify themselves as guardian");
-  });
-
-  test("routing section discourages conceptual detours for direct setup requests", () => {
+    const start = prompt.indexOf("<available_skills>");
+    const end = prompt.indexOf("</available_skills>");
+    expect(start).not.toBe(-1);
+    expect(end).not.toBe(-1);
+    const skillsXml = prompt.substring(start, end);
+    expect(skillsXml).toContain('id="browser"');
+    const skillLine = skillsXml
+      .split("\n")
+      .find((l) => l.includes('id="browser"'));
+    expect(skillLine).toBeDefined();
+    expect(skillLine).toContain("hints=");
+  });
+
+  test("domain routing sections are no longer in system prompt", () => {
     const prompt = buildSystemPrompt();
-    const lower = prompt.toLowerCase();
-    expect(lower).toContain("do not give conceptual");
-    expect(lower).toContain("unless the user explicitly asks");
+    expect(prompt).not.toContain("## Routing: Guardian Verification");
+    expect(prompt).not.toContain("## Routing: Phone Calls");
+    expect(prompt).not.toContain("## Routing: Voice Setup");
+    expect(prompt).not.toContain("## Routing: Starter Tasks");
   });
 });

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

@@ -361,6 +361,41 @@ describe("invite-redemption-service", () => {
     expect(guardian!.role).toBe("guardian");
   });
 
+  test("downgrades guardian to contact when redeeming invite targeting own contact", () => {
+    // Create a guardian contact with a revoked channel
+    const guardianContact = upsertContact({
+      displayName: "Guardian",
+      role: "guardian",
+      channels: [
+        {
+          type: "telegram",
+          address: "guardian-own-id",
+          externalUserId: "guardian-own-id",
+          status: "revoked",
+        },
+      ],
+    });
+
+    // Create invite targeting the guardian's own contact
+    const { rawToken } = createInvite({
+      sourceChannel: "telegram",
+      contactId: guardianContact.id,
+      maxUses: 5,
+    });
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: "telegram",
+      externalUserId: "guardian-own-id",
+    });
+
+    expect(outcome.ok).toBe(true);
+
+    // The guardian should now be downgraded to "contact"
+    const updated = getContact(guardianContact.id);
+    expect(updated!.role).toBe("contact");
+  });
+
   test("binds redeemer to the invite's target contact via 6-digit code, not the guardian", () => {
     // Pre-create a guardian contact with a revoked telegram channel
     const guardianContact = upsertContact({

package/src/__tests__/keychain-broker-client.test.ts

@@ -508,4 +508,154 @@ describe("keychain-broker-client", () => {
       expect(connectionCount).toBe(1);
     });
   });
+
+  // -----------------------------------------------------------------------
+  // Cooldown-based retry
+  // -----------------------------------------------------------------------
+  describe("cooldown-based retry", () => {
+    const originalDateNow = Date.now;
+    let fakeNow: number;
+
+    beforeEach(() => {
+      fakeNow = originalDateNow.call(Date);
+      Date.now = () => fakeNow;
+      writeFileSync(TOKEN_PATH, TEST_TOKEN);
+    });
+
+    afterEach(() => {
+      Date.now = originalDateNow;
+    });
+
+    test("retries connection after cooldown period elapses", async () => {
+      // No socket file — two connection failures (first + immediate retry)
+      const client = createBrokerClient();
+      const result = await client.ping();
+      expect(result).toBeNull();
+
+      // Client should be in cooldown — isAvailable() returns false even with
+      // socket + token files present.
+      writeFileSync(SOCKET_PATH, "");
+      expect(client.isAvailable()).toBe(false);
+
+      // Advance time past the first cooldown (30s)
+      fakeNow += 30_001;
+      expect(client.isAvailable()).toBe(true);
+
+      // Now start a real broker and verify the client reconnects
+      rmSync(SOCKET_PATH, { force: true });
+      const broker = createMockBroker();
+      broker.setHandler(() => ({ ok: true, result: { pong: true } }));
+      await broker.start();
+
+      const retryResult = await client.ping();
+      expect(retryResult).toEqual({ pong: true });
+
+      await broker.stop();
+    });
+
+    test("resets failure count after successful reconnection", async () => {
+      // No socket file — two connection failures
+      const client = createBrokerClient();
+      await client.ping();
+
+      // Advance past first cooldown (30s)
+      fakeNow += 30_001;
+
+      // Start broker — reconnection should succeed and reset counters
+      const broker = createMockBroker();
+      broker.setHandler(() => ({ ok: true, result: { pong: true } }));
+      await broker.start();
+
+      const result = await client.ping();
+      expect(result).toEqual({ pong: true });
+
+      // Stop broker and remove socket — simulate another disconnection.
+      // Yield after stop so the client socket receives the close event
+      // before the next ping (otherwise ensureConnected returns the stale
+      // socket and sendRequest waits REQUEST_TIMEOUT_MS for a response).
+      await broker.stop();
+      await new Promise((r) => setTimeout(r, 50));
+      rmSync(SOCKET_PATH, { force: true });
+
+      // This new failure should start from the beginning of the cooldown
+      // schedule (30s), not escalated.
+      await client.ping();
+
+      // Verify cooldown is back to 30s (not 60s)
+      writeFileSync(SOCKET_PATH, "");
+      expect(client.isAvailable()).toBe(false);
+
+      // 30s should be enough to clear cooldown
+      fakeNow += 30_001;
+      expect(client.isAvailable()).toBe(true);
+    }, 15_000);
+
+    test("escalates cooldown on repeated failures", async () => {
+      const client = createBrokerClient();
+
+      // First failure round: two attempts (first + immediate retry) ->
+      // consecutiveFailures=2, cooldown index = max(2-2,0) = 0 -> 30s.
+      await client.ping();
+
+      writeFileSync(SOCKET_PATH, "");
+      expect(client.isAvailable()).toBe(false);
+
+      // 30s should clear the first cooldown
+      fakeNow += 30_001;
+      expect(client.isAvailable()).toBe(true);
+
+      // Remove socket to trigger another failure. After cooldown elapses,
+      // ensureConnected clears unavailableSince and tries connect().
+      // This failure increments consecutiveFailures to 3 (no immediate retry
+      // since consecutiveFailures > 1 after increment).
+      // Cooldown index = max(3-2,0) = 1 -> 60s.
+      rmSync(SOCKET_PATH, { force: true });
+      await client.ping();
+
+      writeFileSync(SOCKET_PATH, "");
+      expect(client.isAvailable()).toBe(false);
+
+      fakeNow += 30_001;
+      expect(client.isAvailable()).toBe(false); // 30s not enough
+
+      fakeNow += 30_000; // total 60_001ms since this cooldown started
+      expect(client.isAvailable()).toBe(true);
+
+      // Another failure -> consecutiveFailures=4, index = max(4-2,0) = 2 -> 120s (2min)
+      rmSync(SOCKET_PATH, { force: true });
+      await client.ping();
+
+      writeFileSync(SOCKET_PATH, "");
+      expect(client.isAvailable()).toBe(false);
+
+      fakeNow += 60_001;
+      expect(client.isAvailable()).toBe(false);
+
+      fakeNow += 60_000; // total 120_001ms
+      expect(client.isAvailable()).toBe(true);
+
+      // Another failure -> consecutiveFailures=5, index = max(5-2,0) = 3 -> 300s (5min)
+      rmSync(SOCKET_PATH, { force: true });
+      await client.ping();
+
+      writeFileSync(SOCKET_PATH, "");
+      expect(client.isAvailable()).toBe(false);
+
+      fakeNow += 120_001;
+      expect(client.isAvailable()).toBe(false);
+
+      fakeNow += 180_000; // total 300_001ms
+      expect(client.isAvailable()).toBe(true);
+
+      // Another failure -> consecutiveFailures=6, index = min(max(6-2,0), 3) = 3 -> 300s (capped)
+      rmSync(SOCKET_PATH, { force: true });
+      await client.ping();
+
+      writeFileSync(SOCKET_PATH, "");
+      expect(client.isAvailable()).toBe(false);
+
+      fakeNow += 300_001;
+      expect(client.isAvailable()).toBe(true);
+    });
+  });
 });

package/src/__tests__/list-messages-attachments.test.ts

@@ -4,7 +4,7 @@
  * Verifies that:
  * - User message image attachments include base64 data for client thumbnail generation
  * - User message non-image attachments stay metadata-only (no base64 blob)
- * - Assistant message attachments remain metadata-only
+ * - Assistant message image attachments include base64 data (same as user messages)
  */
 
 import { mkdtempSync, rmSync } from "node:fs";
@@ -140,7 +140,7 @@ describe("handleListMessages attachments", () => {
     expect(attachments![0].data).toBeUndefined();
   });
 
-  test("assistant message attachments remain metadata-only", async () => {
+  test("assistant message image attachments include base64 data", async () => {
     const conv = createConversation();
     const msg = await addMessage(
       conv.id,
@@ -158,8 +158,8 @@ describe("handleListMessages attachments", () => {
     expect(attachments).toBeDefined();
     expect(attachments).toHaveLength(1);
     expect(attachments![0].mimeType).toBe("image/png");
-    // Assistant attachments should NOT include base64 data (metadata-only)
-    expect(attachments![0].data).toBeUndefined();
+    // Assistant image attachments include base64 data for inline rendering
+    expect(attachments![0].data).toBe(IMAGE_BASE64);
   });
 
   test("user message with mixed attachments only inlines images", async () => {