@vellumai/assistant 0.3.28 → 0.4.0

package/src/__tests__/ingress-routes-http.test.ts

@@ -92,7 +92,7 @@ describe('ingress member HTTP routes', () => {
     });
 
     const res = await handleUpsertMember(req);
-    const body = await res.json() as Record<string, unknown>;
+    const body = await res.json() as { ok: boolean; error: string };
 
     expect(res.status).toBe(400);
     expect(body.ok).toBe(false);
@@ -109,7 +109,7 @@ describe('ingress member HTTP routes', () => {
     });
 
     const res = await handleUpsertMember(req);
-    const body = await res.json() as Record<string, unknown>;
+    const body = await res.json() as { ok: boolean; error: string };
 
     expect(res.status).toBe(400);
     expect(body.ok).toBe(false);
@@ -278,6 +278,42 @@ describe('ingress invite HTTP routes', () => {
     expect((invite.token as string).length).toBeGreaterThan(0);
   });
 
+  test('POST /v1/ingress/invites — includes canonical share URL when bot username is configured', async () => {
+    const prevBotUsername = process.env.TELEGRAM_BOT_USERNAME;
+    process.env.TELEGRAM_BOT_USERNAME = 'test_invite_bot';
+
+    try {
+      const req = new Request('http://localhost/v1/ingress/invites', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          sourceChannel: 'telegram',
+          note: 'Share link test',
+        }),
+      });
+
+      const res = await handleCreateInvite(req);
+      const body = await res.json() as Record<string, unknown>;
+      const invite = body.invite as Record<string, unknown>;
+      const token = invite.token as string;
+      const share = invite.share as Record<string, unknown>;
+
+      expect(res.status).toBe(201);
+      expect(body.ok).toBe(true);
+      expect(typeof token).toBe('string');
+      expect(token.length).toBeGreaterThan(0);
+      expect(share).toBeDefined();
+      expect(share.url).toBe(`https://t.me/test_invite_bot?start=iv_${token}`);
+      expect(typeof share.displayText).toBe('string');
+    } finally {
+      if (prevBotUsername === undefined) {
+        delete process.env.TELEGRAM_BOT_USERNAME;
+      } else {
+        process.env.TELEGRAM_BOT_USERNAME = prevBotUsername;
+      }
+    }
+  });
+
   test('POST /v1/ingress/invites — missing sourceChannel returns 400', async () => {
     const req = new Request('http://localhost/v1/ingress/invites', {
       method: 'POST',
@@ -286,7 +322,7 @@ describe('ingress invite HTTP routes', () => {
     });
 
     const res = await handleCreateInvite(req);
-    const body = await res.json() as Record<string, unknown>;
+    const body = await res.json() as { ok: boolean; error: string };
 
     expect(res.status).toBe(400);
     expect(body.ok).toBe(false);
@@ -376,7 +412,7 @@ describe('ingress invite HTTP routes', () => {
     });
 
     const res = await handleRedeemInvite(req);
-    const body = await res.json() as Record<string, unknown>;
+    const body = await res.json() as { ok: boolean; error: string };
 
     expect(res.status).toBe(400);
     expect(body.ok).toBe(false);
@@ -441,3 +477,194 @@ describe('ingress service shared logic', () => {
     expect(revoked.invite.id).toBe(created.invite.id);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Voice invite routes
+// ---------------------------------------------------------------------------
+
+describe('voice invite HTTP routes', () => {
+  beforeEach(resetTables);
+
+  test('POST /v1/ingress/invites with sourceChannel voice — creates invite with voiceCode, stores hash only', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'voice',
+        expectedExternalUserId: '+15551234567',
+        maxUses: 3,
+      }),
+    });
+
+    const res = await handleCreateInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(201);
+    expect(body.ok).toBe(true);
+    const invite = body.invite as Record<string, unknown>;
+    expect(invite.sourceChannel).toBe('voice');
+    // Voice code should be returned (6 digits by default)
+    expect(typeof invite.voiceCode).toBe('string');
+    expect((invite.voiceCode as string).length).toBe(6);
+    expect(/^\d{6}$/.test(invite.voiceCode as string)).toBe(true);
+    // Hash should be stored
+    expect(typeof invite.tokenHash).toBe('string');
+    expect((invite.tokenHash as string).length).toBeGreaterThan(0);
+    // voiceCodeDigits should be recorded
+    expect(invite.voiceCodeDigits).toBe(6);
+    // expectedExternalUserId should be recorded
+    expect(invite.expectedExternalUserId).toBe('+15551234567');
+  });
+
+  test('voice invite creation requires expectedExternalUserId', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'voice',
+      }),
+    });
+
+    const res = await handleCreateInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error).toContain('expectedExternalUserId');
+  });
+
+  test('voice invite creation validates E.164 format', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'voice',
+        expectedExternalUserId: 'not-a-phone-number',
+      }),
+    });
+
+    const res = await handleCreateInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error).toContain('E.164');
+  });
+
+  test('voiceCodeDigits is always 6 — custom values are ignored', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'voice',
+        expectedExternalUserId: '+15551234567',
+        voiceCodeDigits: 8,
+      }),
+    });
+
+    const res = await handleCreateInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(201);
+    expect(body.ok).toBe(true);
+    const invite = body.invite as Record<string, unknown>;
+    expect((invite.voiceCode as string).length).toBe(6);
+    expect(invite.voiceCodeDigits).toBe(6);
+  });
+
+  test('voice invites do NOT return token in response', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'voice',
+        expectedExternalUserId: '+15551234567',
+      }),
+    });
+
+    const res = await handleCreateInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(201);
+    const invite = body.invite as Record<string, unknown>;
+    // Voice invites must not expose the raw token — callers redeem via
+    // the identity-bound voice code flow
+    expect(invite.token).toBeUndefined();
+  });
+
+  test('POST /v1/ingress/invites/redeem — redeems a voice invite code via unified endpoint', async () => {
+    // Create a voice invite
+    const createRes = await handleCreateInvite(new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'voice',
+        expectedExternalUserId: '+15551234567',
+        maxUses: 1,
+      }),
+    }));
+    const created = await createRes.json() as { invite: { voiceCode: string } };
+
+    // Redeem the voice code via the unified /redeem endpoint
+    const redeemReq = new Request('http://localhost/v1/ingress/invites/redeem', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        callerExternalUserId: '+15551234567',
+        code: created.invite.voiceCode,
+      }),
+    });
+
+    const res = await handleRedeemInvite(redeemReq);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.type).toBe('redeemed');
+    expect(typeof body.memberId).toBe('string');
+    expect(typeof body.inviteId).toBe('string');
+  });
+
+  test('POST /v1/ingress/invites/redeem — voice code missing fields returns 400', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites/redeem', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ callerExternalUserId: '+15551234567' }),
+    });
+
+    const res = await handleRedeemInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    // No `code` and no `token` → falls through to token-based path which requires token
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+  });
+
+  test('POST /v1/ingress/invites/redeem — wrong voice code returns 400', async () => {
+    // Create a voice invite
+    await handleCreateInvite(new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'voice',
+        expectedExternalUserId: '+15551234567',
+        maxUses: 1,
+      }),
+    }));
+
+    const req = new Request('http://localhost/v1/ingress/invites/redeem', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        callerExternalUserId: '+15551234567',
+        code: '000000',
+      }),
+    });
+
+    const res = await handleRedeemInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+  });
+});

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

@@ -48,6 +48,8 @@ mock.module('../util/logger.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     sandbox: { enabled: false, backend: 'local' },
   }),
 }));

package/src/__tests__/ipc-snapshot.test.ts

@@ -830,6 +830,12 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
       { filename: 'chart.png', mimeType: 'image/png', data: 'iVBORw0K' },
     ],
   },
+  message_request_complete: {
+    type: 'message_request_complete',
+    sessionId: 'sess-001',
+    requestId: 'req-inline-001',
+    runStillActive: true,
+  },
   session_info: {
     type: 'session_info',
     sessionId: 'sess-001',
@@ -2179,6 +2185,13 @@ describe('IPC message snapshots', () => {
       const complete = serverMessages.message_complete;
       expect(complete.type).toBe('message_complete');
     });
+
+    test('message_request_complete has sessionId and requestId fields', () => {
+      const complete = serverMessages.message_request_complete;
+      expect(complete.type).toBe('message_request_complete');
+      expect((complete as unknown as { sessionId: string }).sessionId).toBe('sess-001');
+      expect((complete as unknown as { requestId: string }).requestId).toBe('req-inline-001');
+    });
   });
 
   // Baseline: session contract includes threadType metadata

package/src/__tests__/media-generate-image.test.ts

@@ -19,6 +19,8 @@ let mockGenerateError: Error | null = null;
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     apiKeys: { gemini: mockApiKey },
   }),
 }));
@@ -70,6 +72,25 @@ mock.module('drizzle-orm', () => ({
 }));
 
 mock.module('../memory/conversation-store.js', () => ({
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  updateConversationTitle: () => {},
+  updateConversationUsage: () => {},
+  addMessage: () => ({ id: 'mock-msg-id' }),
+  getMessages: () => [],
+  getConversation: () => ({
+    id: 'conv-1',
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+    title: null,
+  }),
+  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
   getConversationThreadType: () => 'standard',
 }));
 

package/src/__tests__/media-reuse-story.e2e.test.ts

@@ -49,6 +49,8 @@ mock.module('../util/logger.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     model: 'test',
     provider: 'test',
     apiKeys: {},

package/src/__tests__/memory-regressions.test.ts

@@ -4448,7 +4448,7 @@ describe('Memory regressions', () => {
       role: 'user',
       content: 'Untrusted sender says preferences should not become durable profile memory.',
       metadata: JSON.stringify({
-        provenanceActorRole: 'non-guardian',
+        provenanceTrustClass: 'trusted_contact',
         provenanceSourceChannel: 'telegram',
       }),
       createdAt: conv.createdAt + 1,
@@ -4516,7 +4516,7 @@ describe('Memory regressions', () => {
           conversationId: 'conv-relation-provenance-gate',
           role: 'user',
           content: JSON.stringify([{ type: 'text', text: 'Trusted guardian message for relation backfill.' }]),
-          metadata: JSON.stringify({ provenanceActorRole: 'guardian', provenanceSourceChannel: 'telegram' }),
+          metadata: JSON.stringify({ provenanceTrustClass: 'guardian', provenanceSourceChannel: 'telegram' }),
           createdAt: now + 1,
         },
         {
@@ -4524,7 +4524,7 @@ describe('Memory regressions', () => {
           conversationId: 'conv-relation-provenance-gate',
           role: 'user',
           content: JSON.stringify([{ type: 'text', text: 'Untrusted message that should be excluded from relation backfill extraction.' }]),
-          metadata: JSON.stringify({ provenanceActorRole: 'non-guardian', provenanceSourceChannel: 'telegram' }),
+          metadata: JSON.stringify({ provenanceTrustClass: 'trusted_contact', provenanceSourceChannel: 'telegram' }),
           createdAt: now + 2,
         },
       ]).run();
@@ -4566,7 +4566,7 @@ describe('Memory regressions', () => {
     const conv = createConversation('provenance-preserve');
     const metadata = {
       userMessageChannel: 'telegram' as const,
-      provenanceActorRole: 'non-guardian' as const,
+      provenanceTrustClass: 'trusted_contact' as const,
       provenanceSourceChannel: 'telegram' as const,
       provenanceGuardianExternalUserId: 'guardian-123',
       provenanceRequesterIdentifier: 'Alice',
@@ -4582,7 +4582,7 @@ describe('Memory regressions', () => {
 
     expect(stored).toBeTruthy();
     const parsed = JSON.parse(stored!.metadata!);
-    expect(parsed.provenanceActorRole).toBe('non-guardian');
+    expect(parsed.provenanceTrustClass).toBe('trusted_contact');
     expect(parsed.provenanceSourceChannel).toBe('telegram');
     expect(parsed.provenanceGuardianExternalUserId).toBe('guardian-123');
     expect(parsed.provenanceRequesterIdentifier).toBe('Alice');
@@ -4590,13 +4590,13 @@ describe('Memory regressions', () => {
 
   test('messageMetadataSchema validates provenance fields', () => {
     const valid = messageMetadataSchema.safeParse({
-      provenanceActorRole: 'guardian',
-      provenanceSourceChannel: 'macos',
+      provenanceTrustClass: 'guardian',
+      provenanceSourceChannel: 'vellum',
     });
     expect(valid.success).toBe(true);
 
     const validNonGuardian = messageMetadataSchema.safeParse({
-      provenanceActorRole: 'non-guardian',
+      provenanceTrustClass: 'trusted_contact',
       provenanceSourceChannel: 'telegram',
       provenanceGuardianExternalUserId: 'g-123',
       provenanceRequesterIdentifier: 'Bob',
@@ -4604,41 +4604,41 @@ describe('Memory regressions', () => {
     expect(validNonGuardian.success).toBe(true);
 
     const validUnverified = messageMetadataSchema.safeParse({
-      provenanceActorRole: 'unverified_channel',
+      provenanceTrustClass: 'unknown',
     });
     expect(validUnverified.success).toBe(true);
   });
 
   test('provenanceFromGuardianContext returns unverified_channel default when no context', () => {
     const result = provenanceFromGuardianContext(null);
-    expect(result.provenanceActorRole).toBe('unverified_channel');
+    expect(result.provenanceTrustClass).toBe('unknown');
     expect(result.provenanceSourceChannel).toBeUndefined();
 
     const result2 = provenanceFromGuardianContext(undefined);
-    expect(result2.provenanceActorRole).toBe('unverified_channel');
+    expect(result2.provenanceTrustClass).toBe('unknown');
   });
 
   test('provenanceFromGuardianContext extracts fields from guardian context', () => {
     const ctx = {
       sourceChannel: 'telegram' as const,
-      actorRole: 'non-guardian' as const,
+      trustClass: 'trusted_contact' as const,
       guardianExternalUserId: 'g-456',
       requesterIdentifier: 'Charlie',
     };
     const result = provenanceFromGuardianContext(ctx);
-    expect(result.provenanceActorRole).toBe('non-guardian');
+    expect(result.provenanceTrustClass).toBe('trusted_contact');
     expect(result.provenanceSourceChannel).toBe('telegram');
     expect(result.provenanceGuardianExternalUserId).toBe('g-456');
     expect(result.provenanceRequesterIdentifier).toBe('Charlie');
   });
 
-  test('indexMessageNow receives provenanceActorRole when metadata includes it', async () => {
+  test('indexMessageNow receives provenanceTrustClass when metadata includes it', async () => {
     const conv = createConversation('provenance-indexer');
     const metadata = {
-      provenanceActorRole: 'non-guardian' as const,
+      provenanceTrustClass: 'trusted_contact' as const,
       provenanceSourceChannel: 'telegram' as const,
     };
-    // addMessage parses metadata and passes provenanceActorRole to indexMessageNow.
+    // addMessage parses metadata and passes provenanceTrustClass to indexMessageNow.
     // We verify indirectly: the message is persisted with metadata and segments are indexed.
     const msg = await addMessage(conv.id, 'user', 'Test provenance indexing message with enough content to segment', metadata);
     expect(msg.id).toBeTruthy();
@@ -4683,7 +4683,7 @@ describe('Memory regressions', () => {
       role: 'user',
       content: JSON.stringify([{ type: 'text', text: 'Untrusted user preference for dark mode.' }]),
       createdAt: now,
-      provenanceActorRole: 'non-guardian',
+      provenanceTrustClass: 'trusted_contact',
     }, DEFAULT_CONFIG.memory);
 
     expect(result.indexedSegments).toBeGreaterThan(0);
@@ -4733,7 +4733,7 @@ describe('Memory regressions', () => {
       role: 'user',
       content: JSON.stringify([{ type: 'text', text: 'Trusted guardian preference for light mode.' }]),
       createdAt: now,
-      provenanceActorRole: 'guardian',
+      provenanceTrustClass: 'guardian',
     }, DEFAULT_CONFIG.memory);
 
     expect(result.indexedSegments).toBeGreaterThan(0);
@@ -4779,7 +4779,7 @@ describe('Memory regressions', () => {
       role: 'user',
       content: JSON.stringify([{ type: 'text', text: 'Legacy message with no provenance info.' }]),
       createdAt: now,
-      // provenanceActorRole is intentionally omitted (undefined) for backwards compat
+      // provenanceTrustClass is intentionally omitted (undefined) for backwards compat
     }, DEFAULT_CONFIG.memory);
 
     expect(result.indexedSegments).toBeGreaterThan(0);
@@ -4824,7 +4824,7 @@ describe('Memory regressions', () => {
       role: 'user',
       content: JSON.stringify([{ type: 'text', text: 'Unverified channel preference for compact layout.' }]),
       createdAt: now,
-      provenanceActorRole: 'unverified_channel',
+      provenanceTrustClass: 'unknown',
     }, DEFAULT_CONFIG.memory);
 
     expect(result.indexedSegments).toBeGreaterThan(0);