vellum 0.2.1 → 0.2.7

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

@@ -537,6 +537,25 @@ exports[`IPC message snapshots ClientMessage types vercel_api_config serializes
 }
 `;
 
+exports[`IPC message snapshots ClientMessage types twitter_integration_config serializes to expected JSON 1`] = `
+{
+  "action": "get",
+  "type": "twitter_integration_config",
+}
+`;
+
+exports[`IPC message snapshots ClientMessage types twitter_auth_start serializes to expected JSON 1`] = `
+{
+  "type": "twitter_auth_start",
+}
+`;
+
+exports[`IPC message snapshots ClientMessage types twitter_auth_status serializes to expected JSON 1`] = `
+{
+  "type": "twitter_auth_status",
+}
+`;
+
 exports[`IPC message snapshots ClientMessage types link_open_request serializes to expected JSON 1`] = `
 {
   "type": "link_open_request",
@@ -668,17 +687,6 @@ exports[`IPC message snapshots ClientMessage types work_item_get serializes to e
 }
 `;
 
-exports[`IPC message snapshots ClientMessage types work_item_create serializes to expected JSON 1`] = `
-{
-  "notes": "High priority",
-  "priorityTier": 1,
-  "sortIndex": 0,
-  "taskId": "task-001",
-  "title": "Process report",
-  "type": "work_item_create",
-}
-`;
-
 exports[`IPC message snapshots ClientMessage types work_item_update serializes to expected JSON 1`] = `
 {
   "id": "wi-001",
@@ -709,6 +717,38 @@ exports[`IPC message snapshots ClientMessage types work_item_run_task serializes
 }
 `;
 
+exports[`IPC message snapshots ClientMessage types work_item_output serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "type": "work_item_output",
+}
+`;
+
+exports[`IPC message snapshots ClientMessage types work_item_preflight serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "type": "work_item_preflight",
+}
+`;
+
+exports[`IPC message snapshots ClientMessage types work_item_approve_permissions serializes to expected JSON 1`] = `
+{
+  "approvedTools": [
+    "bash",
+    "file_write",
+  ],
+  "id": "wi-001",
+  "type": "work_item_approve_permissions",
+}
+`;
+
+exports[`IPC message snapshots ClientMessage types work_item_cancel serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "type": "work_item_cancel",
+}
+`;
+
 exports[`IPC message snapshots ClientMessage types document_save serializes to expected JSON 1`] = `
 {
   "content": "# Hello",
@@ -743,7 +783,6 @@ exports[`IPC message snapshots ClientMessage types subagent_abort serializes to
 
 exports[`IPC message snapshots ClientMessage types subagent_status serializes to expected JSON 1`] = `
 {
-  "sessionId": "sess-001",
   "subagentId": "sub-001",
   "type": "subagent_status",
 }
@@ -1451,12 +1490,14 @@ exports[`IPC message snapshots ServerMessage types schedules_list_response seria
       "cronExpression": "0 9 * * 1-5",
       "description": "Every weekday at 9:00 AM",
       "enabled": true,
+      "expression": "0 9 * * 1-5",
       "id": "sched-001",
       "lastRunAt": 1700000000000,
       "lastStatus": "ok",
       "message": "Remind me about the standup",
       "name": "Daily standup reminder",
       "nextRunAt": 1700100000000,
+      "syntax": "cron",
       "timezone": "America/Los_Angeles",
     },
   ],
@@ -1737,6 +1778,34 @@ exports[`IPC message snapshots ServerMessage types vercel_api_config_response se
 }
 `;
 
+exports[`IPC message snapshots ServerMessage types twitter_integration_config_response serializes to expected JSON 1`] = `
+{
+  "connected": false,
+  "localClientConfigured": true,
+  "managedAvailable": false,
+  "mode": "local_byo",
+  "success": true,
+  "type": "twitter_integration_config_response",
+}
+`;
+
+exports[`IPC message snapshots ServerMessage types twitter_auth_result serializes to expected JSON 1`] = `
+{
+  "accountInfo": "@vellum_test",
+  "success": true,
+  "type": "twitter_auth_result",
+}
+`;
+
+exports[`IPC message snapshots ServerMessage types twitter_auth_status_response serializes to expected JSON 1`] = `
+{
+  "accountInfo": "@vellum_test",
+  "connected": true,
+  "mode": "local_byo",
+  "type": "twitter_auth_status_response",
+}
+`;
+
 exports[`IPC message snapshots ServerMessage types open_url serializes to expected JSON 1`] = `
 {
   "title": "Example",
@@ -1987,28 +2056,6 @@ exports[`IPC message snapshots ServerMessage types work_item_get_response serial
 }
 `;
 
-exports[`IPC message snapshots ServerMessage types work_item_create_response serializes to expected JSON 1`] = `
-{
-  "item": {
-    "createdAt": 1700000000,
-    "id": "wi-001",
-    "lastRunConversationId": null,
-    "lastRunId": null,
-    "lastRunStatus": null,
-    "notes": null,
-    "priorityTier": 1,
-    "sortIndex": null,
-    "sourceId": null,
-    "sourceType": null,
-    "status": "queued",
-    "taskId": "task-001",
-    "title": "Process report",
-    "updatedAt": 1700000000,
-  },
-  "type": "work_item_create_response",
-}
-`;
-
 exports[`IPC message snapshots ServerMessage types work_item_update_response serializes to expected JSON 1`] = `
 {
   "item": {
@@ -2048,6 +2095,58 @@ exports[`IPC message snapshots ServerMessage types work_item_run_task_response s
 }
 `;
 
+exports[`IPC message snapshots ServerMessage types work_item_output_response serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "output": {
+    "completedAt": 1700002000,
+    "conversationId": "conv-001",
+    "highlights": [
+      "- Key finding 1",
+      "- Key finding 2",
+    ],
+    "runId": "run-001",
+    "status": "completed",
+    "summary": "Report processed successfully.",
+    "title": "Process report",
+  },
+  "success": true,
+  "type": "work_item_output_response",
+}
+`;
+
+exports[`IPC message snapshots ServerMessage types work_item_preflight_response serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "permissions": [
+    {
+      "currentDecision": "prompt",
+      "description": "Run shell commands",
+      "riskLevel": "medium",
+      "tool": "bash",
+    },
+  ],
+  "success": true,
+  "type": "work_item_preflight_response",
+}
+`;
+
+exports[`IPC message snapshots ServerMessage types work_item_approve_permissions_response serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "success": true,
+  "type": "work_item_approve_permissions_response",
+}
+`;
+
+exports[`IPC message snapshots ServerMessage types work_item_cancel_response serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "success": true,
+  "type": "work_item_cancel_response",
+}
+`;
+
 exports[`IPC message snapshots ServerMessage types work_item_status_changed serializes to expected JSON 1`] = `
 {
   "item": {

package/src/__tests__/account-registry.test.ts

@@ -28,7 +28,7 @@ mock.module('../tools/registry.js', () => ({
   registerTool: () => {},
 }));
 
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import {
   createAccount,
   listAccounts,
@@ -47,6 +47,7 @@ const _ctx: ToolContext = {
 };
 
 afterAll(() => {
+  resetDb();
   mock.restore();
   try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
 });

package/src/__tests__/agent-heartbeat-service.test.ts

@@ -0,0 +1,250 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+// Mock platform to use a temp workspace dir
+let testWorkspaceDir: string;
+
+mock.module('../util/platform.js', () => ({
+  getWorkspacePromptPath: (file: string) => join(testWorkspaceDir, file),
+}));
+
+// Mock config loader
+let mockConfig = {
+  agentHeartbeat: {
+    enabled: true,
+    intervalMs: 60_000,
+    activeHoursStart: undefined as number | undefined,
+    activeHoursEnd: undefined as number | undefined,
+  },
+};
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => mockConfig,
+  loadConfig: () => mockConfig,
+}));
+
+// Mock conversation store
+const createdConversations: Array<{ title: string; threadType: string }> = [];
+let conversationIdCounter = 0;
+
+mock.module('../memory/conversation-store.js', () => ({
+  createConversation: (opts: { title: string; threadType: string }) => {
+    createdConversations.push(opts);
+    return { id: `conv-${++conversationIdCounter}`, ...opts };
+  },
+}));
+
+// Mock logger
+mock.module('../util/logger.js', () => ({
+  getLogger: () => ({
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+}));
+
+// Import after mocks are set up
+const { AgentHeartbeatService } = await import('../agent-heartbeat/agent-heartbeat-service.js');
+
+describe('AgentHeartbeatService', () => {
+  let processMessageCalls: Array<{ conversationId: string; content: string }>;
+  let alerterCalls: Array<{ type: string; title: string; body: string }>;
+
+  beforeEach(() => {
+    testWorkspaceDir = join(tmpdir(), `vellum-agent-hb-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(testWorkspaceDir, { recursive: true });
+
+    processMessageCalls = [];
+    alerterCalls = [];
+    createdConversations.length = 0;
+    conversationIdCounter = 0;
+
+    mockConfig = {
+      agentHeartbeat: {
+        enabled: true,
+        intervalMs: 60_000,
+        activeHoursStart: undefined,
+        activeHoursEnd: undefined,
+      },
+    };
+  });
+
+  function createService(overrides?: {
+    processMessage?: (id: string, content: string) => Promise<{ messageId: string }>;
+    getCurrentHour?: () => number;
+  }) {
+    return new AgentHeartbeatService({
+      processMessage: overrides?.processMessage ?? (async (conversationId: string, content: string) => {
+        processMessageCalls.push({ conversationId, content });
+        return { messageId: 'msg-1' };
+      }),
+      alerter: (alert: { type: string; title: string; body: string }) => {
+        alerterCalls.push(alert);
+      },
+      getCurrentHour: overrides?.getCurrentHour,
+    });
+  }
+
+  test('runOnce() calls processMessage with correct prompt', async () => {
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].conversationId).toBe('conv-1');
+    expect(processMessageCalls[0].content).toContain('<heartbeat-checklist>');
+    expect(processMessageCalls[0].content).toContain('<heartbeat-disposition>');
+    expect(processMessageCalls[0].content).toContain('HEARTBEAT_OK');
+    expect(processMessageCalls[0].content).toContain('HEARTBEAT_ALERT');
+  });
+
+  test('HEARTBEAT.md content is embedded in prompt when file exists', async () => {
+    const customChecklist = '- Check the weather\n- Water the plants';
+    writeFileSync(join(testWorkspaceDir, 'HEARTBEAT.md'), customChecklist);
+
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].content).toContain('Check the weather');
+    expect(processMessageCalls[0].content).toContain('Water the plants');
+  });
+
+  test('default checklist used when no HEARTBEAT.md', async () => {
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].content).toContain('Check the current weather');
+  });
+
+  test('creates background conversation titled "Agent Heartbeat"', async () => {
+    const service = createService();
+    await service.runOnce();
+
+    expect(createdConversations).toHaveLength(1);
+    expect(createdConversations[0].title).toBe('Agent Heartbeat');
+    expect(createdConversations[0].threadType).toBe('background');
+  });
+
+  test('active hours guard skips outside window', async () => {
+    mockConfig.agentHeartbeat.activeHoursStart = 9;
+    mockConfig.agentHeartbeat.activeHoursEnd = 17;
+
+    const service = createService({ getCurrentHour: () => 3 });
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(0);
+  });
+
+  test('active hours guard allows within window', async () => {
+    mockConfig.agentHeartbeat.activeHoursStart = 9;
+    mockConfig.agentHeartbeat.activeHoursEnd = 17;
+
+    const service = createService({ getCurrentHour: () => 12 });
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+  });
+
+  test('active hours handles overnight window', async () => {
+    mockConfig.agentHeartbeat.activeHoursStart = 22;
+    mockConfig.agentHeartbeat.activeHoursEnd = 6;
+
+    // 23:00 should be within the window
+    const service = createService({ getCurrentHour: () => 23 });
+    await service.runOnce();
+    expect(processMessageCalls).toHaveLength(1);
+
+    // 10:00 should be outside the window
+    processMessageCalls.length = 0;
+    createdConversations.length = 0;
+    const service2 = createService({ getCurrentHour: () => 10 });
+    await service2.runOnce();
+    expect(processMessageCalls).toHaveLength(0);
+  });
+
+  test('overlap prevention works', async () => {
+    let resolveFirst: () => void;
+    const firstPromise = new Promise<void>((r) => { resolveFirst = r; });
+
+    const service = createService({
+      processMessage: async () => {
+        await firstPromise;
+        processMessageCalls.push({ conversationId: 'slow', content: 'slow' });
+        return { messageId: 'msg-1' };
+      },
+    });
+
+    // Start first run (will block)
+    const run1 = service.runOnce();
+    // Give the first run a tick to set activeRun
+    await new Promise((r) => setTimeout(r, 10));
+
+    // Second run should be skipped due to overlap
+    await service.runOnce();
+
+    // Resolve the first run
+    resolveFirst!();
+    await run1;
+
+    // Only the first run should have called processMessage
+    expect(processMessageCalls).toHaveLength(1);
+  });
+
+  test('disabled config prevents start', () => {
+    mockConfig.agentHeartbeat.enabled = false;
+    const service = createService();
+    service.start();
+    // No error, just a no-op. We can verify by calling stop which should also be a no-op.
+    // The key assertion is that no timer is set (verified by stop not hanging).
+    service.stop();
+  });
+
+  test('disabled config prevents runOnce', async () => {
+    mockConfig.agentHeartbeat.enabled = false;
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(0);
+  });
+
+  test('alerts on processMessage failure', async () => {
+    const service = createService({
+      processMessage: async () => {
+        throw new Error('LLM timeout');
+      },
+    });
+
+    await service.runOnce();
+
+    expect(alerterCalls).toHaveLength(1);
+    expect(alerterCalls[0].type).toBe('agent_heartbeat_alert');
+    expect(alerterCalls[0].title).toBe('Agent Heartbeat Failed');
+    expect(alerterCalls[0].body).toBe('LLM timeout');
+  });
+
+  test('alerts on conversation creation failure', async () => {
+    // Override createConversation to throw via a fresh import trick:
+    // Since createConversation is mocked at module level, we simulate
+    // this by having processMessage throw before it's called — but the
+    // real fix is that executeRun wraps createConversation in the try/catch.
+    // We verify by checking that any error in executeRun triggers the alert.
+    const service = createService({
+      processMessage: async () => {
+        throw new Error('DB locked');
+      },
+    });
+
+    await service.runOnce();
+
+    expect(alerterCalls).toHaveLength(1);
+    expect(alerterCalls[0].body).toBe('DB locked');
+  });
+
+  test('cleanup', () => {
+    try { rmSync(testWorkspaceDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+});

package/src/__tests__/asset-materialize-tool.test.ts

@@ -36,7 +36,7 @@ mock.module('../config/loader.js', () => ({
   }),
 }));
 
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import { uploadAttachment, linkAttachmentToMessage } from '../memory/attachments-store.js';
 import { createConversation, addMessage } from '../memory/conversation-store.js';
 import { assetMaterializeTool } from '../tools/assets/materialize.js';
@@ -49,6 +49,7 @@ import { mkdirSync } from 'node:fs';
 mkdirSync(sandboxDir, { recursive: true });
 
 afterAll(() => {
+  resetDb();
   try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
 });
 
@@ -103,7 +104,7 @@ describe('AssetMaterializeTool sandbox path enforcement', () => {
   beforeEach(resetTables);
 
   test('rejects path that escapes sandbox via ../', async () => {
-    const stored = uploadAttachment('ast-1', 'test.png', 'image/png', 'AAAA');
+    const stored = uploadAttachment('test.png', 'image/png', 'AAAA');
     const result = await assetMaterializeTool.execute(
       { attachment_id: stored.id, destination_path: '../../etc/evil.png' },
       dummyContext,
@@ -113,7 +114,7 @@ describe('AssetMaterializeTool sandbox path enforcement', () => {
   });
 
   test('rejects absolute path outside sandbox', async () => {
-    const stored = uploadAttachment('ast-1', 'test.png', 'image/png', 'AAAA');
+    const stored = uploadAttachment('test.png', 'image/png', 'AAAA');
     const result = await assetMaterializeTool.execute(
       { attachment_id: stored.id, destination_path: '/tmp/outside-sandbox/evil.png' },
       dummyContext,
@@ -123,7 +124,7 @@ describe('AssetMaterializeTool sandbox path enforcement', () => {
   });
 
   test('accepts relative path inside sandbox', async () => {
-    const stored = uploadAttachment('ast-1', 'test.png', 'image/png', 'AAAA');
+    const stored = uploadAttachment('test.png', 'image/png', 'AAAA');
     const result = await assetMaterializeTool.execute(
       { attachment_id: stored.id, destination_path: 'output.png' },
       dummyContext,
@@ -133,7 +134,7 @@ describe('AssetMaterializeTool sandbox path enforcement', () => {
   });
 
   test('accepts nested path inside sandbox with auto-created subdirs', async () => {
-    const stored = uploadAttachment('ast-1', 'test.png', 'image/png', 'AAAA');
+    const stored = uploadAttachment('test.png', 'image/png', 'AAAA');
     const result = await assetMaterializeTool.execute(
       { attachment_id: stored.id, destination_path: 'subdir/deep/output.png' },
       dummyContext,
@@ -172,7 +173,7 @@ describe('AssetMaterializeTool materialization', () => {
     const originalContent = 'Hello, World!';
     const base64Content = Buffer.from(originalContent).toString('base64');
 
-    const stored = uploadAttachment('ast-1', 'hello.txt', 'text/plain', base64Content);
+    const stored = uploadAttachment('hello.txt', 'text/plain', base64Content);
 
     const destPath = 'materialized-hello.txt';
     const result = await assetMaterializeTool.execute(
@@ -194,7 +195,7 @@ describe('AssetMaterializeTool materialization', () => {
     const binaryBytes = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);
     const base64Content = binaryBytes.toString('base64');
 
-    const stored = uploadAttachment('ast-1', 'tiny.png', 'image/png', base64Content);
+    const stored = uploadAttachment('tiny.png', 'image/png', base64Content);
 
     const result = await assetMaterializeTool.execute(
       { attachment_id: stored.id, destination_path: 'images/tiny.png' },
@@ -209,7 +210,7 @@ describe('AssetMaterializeTool materialization', () => {
 
   test('result includes resolved path', async () => {
     const base64Content = Buffer.from('test').toString('base64');
-    const stored = uploadAttachment('ast-1', 'doc.txt', 'text/plain', base64Content);
+    const stored = uploadAttachment('doc.txt', 'text/plain', base64Content);
 
     const result = await assetMaterializeTool.execute(
       { attachment_id: stored.id, destination_path: 'output/doc.txt' },
@@ -222,7 +223,7 @@ describe('AssetMaterializeTool materialization', () => {
 
   test('result includes filename, MIME type and size info', async () => {
     const base64Content = Buffer.from('some data here').toString('base64');
-    const stored = uploadAttachment('ast-1', 'report.pdf', 'application/pdf', base64Content);
+    const stored = uploadAttachment('report.pdf', 'application/pdf', base64Content);
 
     const result = await assetMaterializeTool.execute(
       { attachment_id: stored.id, destination_path: 'report.pdf' },
@@ -307,7 +308,7 @@ describe('AssetMaterializeTool visibility policy', () => {
   test('materializing from a standard thread works from any context', async () => {
     const standardConv = createConversation({ title: 'standard-conv' });
     const base64Content = Buffer.from('standard content').toString('base64');
-    const attachment = uploadAttachment('ast-1', 'public.txt', 'text/plain', base64Content);
+    const attachment = uploadAttachment('public.txt', 'text/plain', base64Content);
     const msg = addMessage(standardConv.id, 'user', 'standard message');
     linkAttachmentToMessage(msg.id, attachment.id, 0);
 
@@ -330,7 +331,7 @@ describe('AssetMaterializeTool visibility policy', () => {
   test('materializing from a private thread works within the same private thread', async () => {
     const privateConv = createConversation({ title: 'private-conv', threadType: 'private' });
     const base64Content = Buffer.from('private content').toString('base64');
-    const attachment = uploadAttachment('ast-1', 'secret.txt', 'text/plain', base64Content);
+    const attachment = uploadAttachment('secret.txt', 'text/plain', base64Content);
     const msg = addMessage(privateConv.id, 'user', 'private message');
     linkAttachmentToMessage(msg.id, attachment.id, 0);
 
@@ -352,7 +353,7 @@ describe('AssetMaterializeTool visibility policy', () => {
   test('materializing from a private thread is REJECTED from a different conversation', async () => {
     const privateConv = createConversation({ title: 'private-conv', threadType: 'private' });
     const base64Content = Buffer.from('private content').toString('base64');
-    const attachment = uploadAttachment('ast-1', 'secret.txt', 'text/plain', base64Content);
+    const attachment = uploadAttachment('secret.txt', 'text/plain', base64Content);
     const msg = addMessage(privateConv.id, 'user', 'private message');
     linkAttachmentToMessage(msg.id, attachment.id, 0);
 
@@ -376,7 +377,7 @@ describe('AssetMaterializeTool visibility policy', () => {
   test('error message is user-actionable', async () => {
     const privateConv = createConversation({ title: 'private-conv', threadType: 'private' });
     const base64Content = Buffer.from('private content').toString('base64');
-    const attachment = uploadAttachment('ast-1', 'confidential.pdf', 'application/pdf', base64Content);
+    const attachment = uploadAttachment('confidential.pdf', 'application/pdf', base64Content);
     const msg = addMessage(privateConv.id, 'user', 'private message');
     linkAttachmentToMessage(msg.id, attachment.id, 0);
 
@@ -402,7 +403,7 @@ describe('AssetMaterializeTool visibility policy', () => {
   test('materializing from a different private thread is REJECTED', async () => {
     const privateConv1 = createConversation({ title: 'private-conv-1', threadType: 'private' });
     const base64Content = Buffer.from('private content').toString('base64');
-    const attachment = uploadAttachment('ast-1', 'secret.txt', 'text/plain', base64Content);
+    const attachment = uploadAttachment('secret.txt', 'text/plain', base64Content);
     const msg = addMessage(privateConv1.id, 'user', 'private message');
     linkAttachmentToMessage(msg.id, attachment.id, 0);
 
@@ -426,7 +427,7 @@ describe('AssetMaterializeTool visibility policy', () => {
     const privateConv = createConversation({ title: 'private-conv', threadType: 'private' });
     const standardConv = createConversation({ title: 'standard-conv' });
     const base64Content = Buffer.from('shared content').toString('base64');
-    const attachment = uploadAttachment('ast-1', 'shared.txt', 'text/plain', base64Content);
+    const attachment = uploadAttachment('shared.txt', 'text/plain', base64Content);
 
     const msg1 = addMessage(privateConv.id, 'user', 'private message');
     const msg2 = addMessage(standardConv.id, 'user', 'standard message');