@vellumai/assistant 0.3.0

package/src/config/bundled-skills/messaging/tools/messaging-analyze-style.ts

@@ -0,0 +1,125 @@
+import { and, eq } from 'drizzle-orm';
+import { v4 as uuid } from 'uuid';
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { getDb } from '../../../../memory/db.js';
+import { computeMemoryFingerprint } from '../../../../memory/fingerprint.js';
+import { memoryItems } from '../../../../memory/schema.js';
+import { enqueueMemoryJob } from '../../../../memory/jobs-store.js';
+import { extractStylePatterns } from '../../../../messaging/style-analyzer.js';
+import { truncate } from '../../../../util/truncate.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function upsertMemoryItem(opts: {
+  kind: string;
+  subject: string;
+  statement: string;
+  importance: number;
+  scopeId: string;
+}): void {
+  const db = getDb();
+  const now = Date.now();
+  const fingerprint = computeMemoryFingerprint(opts.scopeId, opts.kind, opts.subject, opts.statement);
+
+  const existing = db
+    .select()
+    .from(memoryItems)
+    .where(and(eq(memoryItems.fingerprint, fingerprint), eq(memoryItems.scopeId, opts.scopeId)))
+    .get();
+
+  if (existing) {
+    db.update(memoryItems)
+      .set({
+        statement: opts.statement,
+        status: 'active',
+        importance: Math.max(existing.importance ?? 0, opts.importance),
+        lastSeenAt: now,
+        verificationState: 'assistant_inferred',
+      })
+      .where(eq(memoryItems.id, existing.id))
+      .run();
+    enqueueMemoryJob('embed_item', { itemId: existing.id });
+  } else {
+    const id = uuid();
+    db.insert(memoryItems).values({
+      id,
+      kind: opts.kind,
+      subject: opts.subject,
+      statement: opts.statement,
+      status: 'active',
+      confidence: 0.8,
+      importance: opts.importance,
+      fingerprint,
+      verificationState: 'assistant_inferred',
+      scopeId: opts.scopeId,
+      firstSeenAt: now,
+      lastSeenAt: now,
+      lastUsedAt: null,
+    }).run();
+    enqueueMemoryJob('embed_item', { itemId: id });
+  }
+}
+
+export async function run(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const maxMessages = Math.min(Math.max((input.max_messages as number) ?? 50, 1), 100);
+  const queryFilter = input.query_filter as string | undefined;
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      // Search for sent messages using the platform's search
+      const query = queryFilter ?? (provider.id === 'gmail' ? 'in:sent' : 'from:me');
+      const searchResult = await provider.search(token, query, { count: maxMessages });
+
+      if (searchResult.messages.length === 0) {
+        return err('No sent messages found. Send some messages first, then try again.');
+      }
+
+      const result = await extractStylePatterns(searchResult.messages);
+
+      if (result.stylePatterns.length === 0) {
+        return err('No style patterns were extracted. Try with more messages.');
+      }
+
+      const scopeId = context.memoryScopeId ?? 'default';
+      let savedCount = 0;
+
+      for (const pattern of result.stylePatterns) {
+        const subject = `${provider.id} writing style: ${pattern.aspect}`;
+        const importance = clamp(pattern.importance ?? 0.65, 0.55, 0.85);
+        upsertMemoryItem({ kind: 'style', subject, statement: pattern.summary, importance, scopeId });
+        savedCount++;
+      }
+
+      for (const contact of result.contactObservations) {
+        if (!contact.name || !contact.toneNote) continue;
+        const subject = `${provider.id} relationship: ${contact.name}`;
+        upsertMemoryItem({
+          kind: 'relationship',
+          subject,
+          statement: truncate(`${contact.name} (${contact.email}): ${contact.toneNote}`, 500, ''),
+          importance: 0.6,
+          scopeId,
+        });
+        savedCount++;
+      }
+
+      const aspects = result.stylePatterns.map((p) => p.aspect).join(', ');
+      const contactCount = result.contactObservations.length;
+      const summary = [
+        `Analyzed ${searchResult.messages.length} messages on ${provider.displayName}.`,
+        `Extracted ${result.stylePatterns.length} style patterns (${aspects}).`,
+        contactCount > 0 ? `Noted ${contactCount} recurring contact relationship(s).` : '',
+        `Saved ${savedCount} memory items. Future drafts will automatically reflect your writing style.`,
+      ].filter(Boolean).join(' ');
+
+      return ok(summary);
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-auth-test.ts

@@ -0,0 +1,16 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const info = await provider.testConnection(token);
+      return ok(JSON.stringify(info, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-draft.ts

@@ -0,0 +1,49 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { createDraft, listDrafts, deleteDraft } from '../../../../messaging/draft-store.js';
+import { ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const action = input.action as string;
+
+  switch (action) {
+    case 'create': {
+      const platform = input.platform as string | undefined;
+      const conversationId = input.conversation_id as string | undefined;
+      const text = input.text as string | undefined;
+
+      if (!platform) return err('platform is required for creating a draft.');
+      if (!conversationId) return err('conversation_id is required for creating a draft.');
+      if (!text) return err('text is required for creating a draft.');
+
+      const draft = createDraft({
+        platform,
+        conversationId,
+        text,
+        threadId: input.thread_id as string | undefined,
+        subject: input.subject as string | undefined,
+      });
+      return ok(`Draft created (ID: ${draft.id}). Stored locally for review.`);
+    }
+
+    case 'list': {
+      const platform = input.platform as string | undefined;
+      if (!platform) return err('platform is required for listing drafts.');
+      const drafts = listDrafts(platform);
+      if (drafts.length === 0) return ok('No drafts found.');
+      return ok(JSON.stringify(drafts, null, 2));
+    }
+
+    case 'delete': {
+      const draftId = input.draft_id as string | undefined;
+      const platform = input.platform as string | undefined;
+      if (!draftId) return err('draft_id is required for deleting a draft.');
+      if (!platform) return err('platform is required for deleting a draft.');
+      const deleted = deleteDraft(platform, draftId);
+      if (!deleted) return err('Draft not found.');
+      return ok('Draft deleted.');
+    }
+
+    default:
+      return err(`Unknown action "${action}". Use "create", "list", or "delete".`);
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-list-conversations.ts

@@ -0,0 +1,21 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const types = input.types as string[] | undefined;
+  const limit = input.limit as number | undefined;
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const conversations = await provider.listConversations(token, {
+        types: types as Array<'channel' | 'dm' | 'group' | 'inbox'> | undefined,
+        limit,
+      });
+      return ok(JSON.stringify(conversations, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-mark-read.ts

@@ -0,0 +1,25 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const conversationId = input.conversation_id as string;
+  const messageId = input.message_id as string | undefined;
+
+  if (!conversationId) {
+    return err('conversation_id is required.');
+  }
+
+  try {
+    const provider = resolveProvider(platform);
+    if (!provider.markRead) {
+      return err(`${provider.displayName} does not support marking messages as read.`);
+    }
+    return withProviderToken(provider, async (token) => {
+      await provider.markRead!(token, conversationId, messageId);
+      return ok('Marked as read.');
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-read.ts

@@ -0,0 +1,28 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const conversationId = input.conversation_id as string;
+  const limit = input.limit as number | undefined;
+  const threadId = input.thread_id as string | undefined;
+
+  if (!conversationId) {
+    return err('conversation_id is required.');
+  }
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      let messages;
+      if (threadId && provider.getThreadReplies) {
+        messages = await provider.getThreadReplies(token, conversationId, threadId, { limit });
+      } else {
+        messages = await provider.getHistory(token, conversationId, { limit });
+      }
+      return ok(JSON.stringify(messages, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-reply.ts

@@ -0,0 +1,32 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const conversationId = input.conversation_id as string;
+  const threadId = input.thread_id as string;
+  const text = input.text as string;
+
+  if (!conversationId) {
+    return err('conversation_id is required.');
+  }
+  if (!threadId) {
+    return err('thread_id is required.');
+  }
+  if (!text) {
+    return err('text is required.');
+  }
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const result = await provider.sendMessage(token, conversationId, text, {
+        threadId,
+      });
+
+      return ok(`Reply sent (ID: ${result.id}).`);
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-search.ts

@@ -0,0 +1,22 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const query = input.query as string;
+  const maxResults = input.max_results as number | undefined;
+
+  if (!query) {
+    return err('query is required.');
+  }
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const result = await provider.search(token, query, { count: maxResults });
+      return ok(JSON.stringify(result, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-send.ts

@@ -0,0 +1,31 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const conversationId = input.conversation_id as string;
+  const text = input.text as string;
+  const subject = input.subject as string | undefined;
+  const inReplyTo = input.in_reply_to as string | undefined;
+
+  if (!conversationId) {
+    return err('conversation_id is required.');
+  }
+  if (!text) {
+    return err('text is required.');
+  }
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const result = await provider.sendMessage(token, conversationId, text, {
+        subject,
+        inReplyTo,
+      });
+
+      return ok(`Message sent (ID: ${result.id}).`);
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/shared.ts

@@ -0,0 +1,76 @@
+/**
+ * Shared utilities for messaging skill tools.
+ */
+
+import { request as httpsRequest, type RequestOptions as HttpsRequestOptions } from 'node:https';
+import { withValidToken } from '../../../../security/token-manager.js';
+import { getMessagingProvider, getConnectedProviders } from '../../../../messaging/registry.js';
+import type { MessagingProvider } from '../../../../messaging/provider.js';
+import type { ToolExecutionResult } from '../../../../tools/types.js';
+
+export function ok(content: string): ToolExecutionResult {
+  return { content, isError: false };
+}
+
+export function err(message: string): ToolExecutionResult {
+  return { content: message, isError: true };
+}
+
+/**
+ * Resolve the messaging provider from user input.
+ * If platform is specified, look it up directly.
+ * If only one provider is connected, auto-select it.
+ * Otherwise, throw asking the user to specify.
+ */
+export function resolveProvider(platformInput?: string): MessagingProvider {
+  if (platformInput) return getMessagingProvider(platformInput);
+
+  const connected = getConnectedProviders();
+  if (connected.length === 1) return connected[0];
+  if (connected.length === 0) {
+    throw new Error('No messaging platforms are connected. Use messaging_auth_test to check connection status, then set up a platform.');
+  }
+
+  const names = connected.map((p) => `"${p.id}"`).join(', ');
+  throw new Error(`Multiple platforms connected (${names}). Specify platform parameter.`);
+}
+
+/**
+ * Execute a callback with a valid OAuth token for the given provider.
+ * Providers that manage their own auth (e.g. Telegram with a bot token)
+ * expose isConnected() and don't need an OAuth access_token lookup.
+ */
+export async function withProviderToken<T>(
+  provider: MessagingProvider,
+  fn: (token: string) => Promise<T>,
+): Promise<T> {
+  if (provider.isConnected?.()) {
+    return fn('');
+  }
+  return withValidToken(provider.credentialService, fn);
+}
+
+/** Make an HTTPS request pinned to a specific resolved IP to prevent DNS rebinding. */
+export function pinnedHttpsRequest(
+  target: URL,
+  resolvedAddress: string,
+  options?: { method?: string; headers?: Record<string, string>; body?: string },
+): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const reqOpts: HttpsRequestOptions = {
+      method: options?.method ?? 'GET',
+      hostname: resolvedAddress,
+      port: target.port ? Number(target.port) : undefined,
+      path: `${target.pathname}${target.search}`,
+      headers: { host: target.host, ...options?.headers },
+      servername: target.hostname,
+    };
+    const req = httpsRequest(reqOpts, (res) => {
+      res.resume();
+      resolve(res.statusCode ?? 0);
+    });
+    req.once('error', reject);
+    if (options?.body) req.write(options.body);
+    req.end();
+  });
+}

package/src/config/bundled-skills/messaging/tools/slack-add-reaction.ts

@@ -0,0 +1,25 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { withValidToken } from '../../../../security/token-manager.js';
+import { getMessagingProvider } from '../../../../messaging/registry.js';
+import { addReaction } from '../../../../messaging/providers/slack/client.js';
+import { ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const channel = input.channel as string;
+  const timestamp = input.timestamp as string;
+  const emoji = input.emoji as string;
+
+  if (!channel || !timestamp || !emoji) {
+    return err('channel, timestamp, and emoji are all required.');
+  }
+
+  try {
+    const provider = getMessagingProvider('slack');
+    return withValidToken(provider.credentialService, async (token) => {
+      await addReaction(token, channel, timestamp, emoji);
+      return ok(`Added :${emoji}: reaction.`);
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/slack-leave-channel.ts

@@ -0,0 +1,23 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { withValidToken } from '../../../../security/token-manager.js';
+import { getMessagingProvider } from '../../../../messaging/registry.js';
+import { leaveConversation } from '../../../../messaging/providers/slack/client.js';
+import { ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const channel = input.channel as string;
+
+  if (!channel) {
+    return err('channel is required.');
+  }
+
+  try {
+    const provider = getMessagingProvider('slack');
+    return withValidToken(provider.credentialService, async (token) => {
+      await leaveConversation(token, channel);
+      return ok('Left channel.');
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}