@vellumai/assistant 0.4.43 → 0.4.45

package/src/messaging/outreach-classifier.ts

@@ -1,185 +0,0 @@
-/**
- * LLM-powered classifier for cold outreach emails (sales, recruiting, marketing).
- * Works with metadata only (from, subject) to keep token usage low.
- */
-
-import {
-  createTimeout,
-  extractToolUse,
-  getConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
-import { getLogger } from "../util/logger.js";
-import type { EmailMetadata } from "./email-classifier.js";
-
-const log = getLogger("outreach-classifier");
-
-const MODEL_INTENT = "latency-optimized" as const;
-const TIMEOUT_MS = 30_000;
-const BATCH_SIZE = 100;
-const CLASSIFY_CONCURRENCY = 3;
-
-export type OutreachType = "sales" | "recruiting" | "marketing" | "other";
-
-export interface OutreachClassification {
-  id: string;
-  isOutreach: boolean;
-  outreachType: OutreachType;
-  confidence: number; // 0-1
-  reasoning: string;
-}
-
-const VALID_OUTREACH_TYPES = new Set<OutreachType>([
-  "sales",
-  "recruiting",
-  "marketing",
-  "other",
-]);
-
-const SYSTEM_PROMPT =
-  'You are a cold outreach detection system. Given email metadata (sender, subject), classify each email as outreach or not.\n\nOutreach signals to look for:\n- Generic greetings ("Hi there", "Hope this finds you well")\n- Scheduling links (Calendly, Chili Piper, cal.com)\n- Pitch language ("quick chat", "15 minutes", "love to connect", "touching base")\n- Recruiting templates ("exciting opportunity", "your background", "perfect fit")\n- Product/service promotion from unknown senders\n- Cold intro patterns ("I came across your profile", "saw your company")\n\nExplicitly NOT outreach (classify as other with isOutreach=false):\n- Personal emails from known contacts\n- Transactional emails (receipts, shipping, password resets)\n- Newsletters (these are already filtered out by query)\n- Calendar invites and event notifications\n\nFor each email, provide:\n- isOutreach: true if this is cold outreach, false otherwise\n- outreachType: "sales" (product/service pitch), "recruiting" (job opportunity), "marketing" (promotional from unknown sender), or "other" (not outreach)\n- confidence: 0.0 (uncertain) to 1.0 (certain)\n- reasoning: Brief explanation (1 sentence)\n\nYou MUST respond using the `store_outreach_classifications` tool. Do not respond with text.';
-
-const STORE_OUTREACH_TOOL = {
-  name: "store_outreach_classifications",
-  description: "Store outreach classification results",
-  input_schema: {
-    type: "object" as const,
-    properties: {
-      classifications: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            id: { type: "string", description: "Email ID" },
-            is_outreach: {
-              type: "boolean",
-              description: "Whether this is cold outreach",
-            },
-            outreach_type: {
-              type: "string",
-              enum: ["sales", "recruiting", "marketing", "other"],
-            },
-            confidence: { type: "number", description: "Confidence score 0-1" },
-            reasoning: {
-              type: "string",
-              description: "Brief classification reasoning",
-            },
-          },
-          required: [
-            "id",
-            "is_outreach",
-            "outreach_type",
-            "confidence",
-            "reasoning",
-          ],
-        },
-      },
-    },
-    required: ["classifications"],
-  },
-};
-
-function formatEmailsForPrompt(emails: EmailMetadata[]): string {
-  return emails
-    .map((e, i) =>
-      [
-        "--- Email " + (i + 1) + " (ID: " + e.id + ") ---",
-        "From: " + e.from,
-        "Subject: " + e.subject,
-      ].join("\n"),
-    )
-    .join("\n\n");
-}
-
-async function classifyBatch(
-  emails: EmailMetadata[],
-): Promise<OutreachClassification[]> {
-  const provider = getConfiguredProvider();
-  if (!provider) {
-    log.warn("Configured provider unavailable for outreach classification");
-    return [];
-  }
-
-  const prompt =
-    "Classify these " +
-    emails.length +
-    " emails as outreach or not:\n\n" +
-    formatEmailsForPrompt(emails);
-  const { signal, cleanup } = createTimeout(TIMEOUT_MS);
-
-  try {
-    const response = await provider.sendMessage(
-      [userMessage(prompt)],
-      [STORE_OUTREACH_TOOL],
-      SYSTEM_PROMPT,
-      {
-        config: {
-          modelIntent: MODEL_INTENT,
-          max_tokens: 4096,
-          tool_choice: {
-            type: "tool" as const,
-            name: "store_outreach_classifications",
-          },
-        },
-        signal,
-      },
-    );
-    cleanup();
-
-    const toolBlock = extractToolUse(response);
-    if (!toolBlock) {
-      log.warn("No tool_use block in outreach classification response");
-      return [];
-    }
-
-    const input = toolBlock.input as {
-      classifications?: Array<{
-        id: string;
-        is_outreach: boolean;
-        outreach_type: string;
-        confidence: number;
-        reasoning: string;
-      }>;
-    };
-
-    return (input.classifications ?? []).map((c) => ({
-      id: c.id,
-      isOutreach: Boolean(c.is_outreach),
-      outreachType: VALID_OUTREACH_TYPES.has(c.outreach_type as OutreachType)
-        ? (c.outreach_type as OutreachType)
-        : "other",
-      confidence: Math.max(0, Math.min(1, c.confidence)),
-      reasoning: c.reasoning,
-    }));
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    log.warn({ err: message }, "Outreach classification LLM call failed");
-    return [];
-  } finally {
-    cleanup();
-  }
-}
-
-export async function classifyOutreach(
-  emails: EmailMetadata[],
-): Promise<OutreachClassification[]> {
-  if (emails.length === 0) return [];
-
-  // Split into batches
-  const batches: EmailMetadata[][] = [];
-  for (let i = 0; i < emails.length; i += BATCH_SIZE) {
-    batches.push(emails.slice(i, i + BATCH_SIZE));
-  }
-
-  // Process batches with bounded concurrency
-  const results: OutreachClassification[] = [];
-  for (let i = 0; i < batches.length; i += CLASSIFY_CONCURRENCY) {
-    const concurrentBatches = batches.slice(i, i + CLASSIFY_CONCURRENCY);
-    const batchResults = await Promise.all(
-      concurrentBatches.map((batch) => classifyBatch(batch)),
-    );
-    for (const r of batchResults) results.push(...r);
-  }
-
-  return results;
-}

package/src/messaging/thread-summarizer.ts

@@ -1,346 +0,0 @@
-import {
-  createTimeout,
-  extractToolUse,
-  getConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
-import { getLogger } from "../util/logger.js";
-import { truncate } from "../util/truncate.js";
-import type { ThreadMessage, ThreadSummary } from "./types.js";
-
-const log = getLogger("thread-summarizer");
-
-const SUMMARIZATION_MODEL_INTENT = "latency-optimized" as const;
-const SUMMARIZATION_TIMEOUT_MS = 20_000;
-const DEFAULT_MAX_TOKENS = 4000;
-const CHARS_PER_TOKEN = 4;
-
-// Keep the first N and last N messages when truncating long threads
-const KEEP_FIRST = 2;
-const KEEP_LAST = 3;
-
-const EMPTY_SUMMARY: ThreadSummary = {
-  summary: "",
-  participants: [],
-  openQuestions: [],
-  lastAction: "",
-  sentiment: "neutral",
-  messageCount: 0,
-};
-
-const SYSTEM_PROMPT = `You are a thread summarization system. Given a conversation transcript, extract a structured summary.
-
-Analyze the conversation and provide:
-- summary: A concise overview of the conversation (2-4 sentences)
-- participants: List of participants with optional roles (inferred from context)
-- openQuestions: Unresolved questions or pending items raised in the thread
-- lastAction: The most recent meaningful action or statement in the thread
-- sentiment: Overall emotional tone of the conversation (positive, neutral, negative, or mixed)
-
-You MUST respond using the \`store_thread_summary\` tool. Do not respond with text.`;
-
-const STORE_SUMMARY_TOOL = {
-  name: "store_thread_summary",
-  description: "Store the extracted thread summary",
-  input_schema: {
-    type: "object" as const,
-    properties: {
-      summary: {
-        type: "string",
-        description: "Concise overview of the conversation (2-4 sentences)",
-      },
-      participants: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            name: { type: "string" },
-            role: {
-              type: "string",
-              description: "Optional role inferred from context",
-            },
-          },
-          required: ["name"],
-        },
-        description: "List of conversation participants",
-      },
-      openQuestions: {
-        type: "array",
-        items: { type: "string" },
-        description: "Unresolved questions or pending items",
-      },
-      lastAction: {
-        type: "string",
-        description: "The most recent meaningful action or statement",
-      },
-      sentiment: {
-        type: "string",
-        enum: ["positive", "neutral", "negative", "mixed"],
-        description: "Overall emotional tone of the conversation",
-      },
-    },
-    required: [
-      "summary",
-      "participants",
-      "openQuestions",
-      "lastAction",
-      "sentiment",
-    ],
-  },
-};
-
-// ── Formatting helpers ─────────────────────────────────────────────────
-
-function formatTimestamp(ts: number): string {
-  return new Date(ts)
-    .toISOString()
-    .replace("T", " ")
-    .replace(/\.\d{3}Z$/, " UTC");
-}
-
-function formatTranscript(messages: ThreadMessage[]): string {
-  return messages
-    .map(
-      (m) =>
-        `[${formatTimestamp(m.timestamp)}] ${m.sender} (${m.channel}):\n${
-          m.body
-        }`,
-    )
-    .join("\n\n");
-}
-
-/**
- * Truncate a thread to fit within a token budget while preserving context.
- * Always keeps the first few and last few messages so the LLM sees
- * the opening context and the most recent state.
- */
-function truncateMessages(
-  messages: ThreadMessage[],
-  maxTokens: number,
-): ThreadMessage[] {
-  const fullTranscript = formatTranscript(messages);
-  const estimatedTokens = fullTranscript.length / CHARS_PER_TOKEN;
-
-  if (estimatedTokens <= maxTokens) {
-    return messages;
-  }
-
-  // Always keep first KEEP_FIRST and last KEEP_LAST messages
-  const first = messages.slice(0, KEEP_FIRST);
-  const last = messages.slice(-KEEP_LAST);
-
-  // If the thread is short enough that first+last windows overlap, we can't
-  // split into first/middle/last — but we still need to honor the token budget.
-  // Progressively drop the oldest messages (from the front) to keep the
-  // newest context, which is more valuable for summarization.
-  if (KEEP_FIRST + KEEP_LAST >= messages.length) {
-    const kept = [...messages];
-    while (kept.length > 1) {
-      const transcript = formatTranscript(kept);
-      if (transcript.length / CHARS_PER_TOKEN <= maxTokens) {
-        return kept;
-      }
-      // Drop the first (oldest) message to prioritize keeping latest context
-      kept.shift();
-    }
-    return kept;
-  }
-
-  // Try adding middle messages until budget is exceeded
-  const middle = messages.slice(KEEP_FIRST, -KEEP_LAST);
-  const kept: ThreadMessage[] = [...first];
-  const budgetChars = maxTokens * CHARS_PER_TOKEN;
-
-  // Reserve space for the last messages
-  const lastTranscript = formatTranscript(last);
-  const separatorOverhead = 40; // "[... N messages truncated ...]\n\n"
-  let usedChars =
-    formatTranscript(first).length + lastTranscript.length + separatorOverhead;
-
-  for (const msg of middle) {
-    const msgText = formatTranscript([msg]);
-    if (usedChars + msgText.length > budgetChars) break;
-    kept.push(msg);
-    usedChars += msgText.length;
-  }
-
-  const truncatedCount = messages.length - kept.length - last.length;
-  if (truncatedCount > 0) {
-    // Insert a placeholder message to indicate truncation
-    kept.push({
-      id: "__truncated__",
-      sender: "system",
-      body: `[... ${truncatedCount} message(s) omitted for brevity ...]`,
-      timestamp: kept[kept.length - 1].timestamp + 1,
-      channel: "system",
-    });
-  }
-
-  kept.push(...last);
-  return kept;
-}
-
-function extractParticipants(
-  messages: ThreadMessage[],
-): Array<{ name: string }> {
-  const seen = new Set<string>();
-  const participants: Array<{ name: string }> = [];
-  for (const msg of messages) {
-    if (!seen.has(msg.sender)) {
-      seen.add(msg.sender);
-      participants.push({ name: msg.sender });
-    }
-  }
-  return participants;
-}
-
-// ── Single-message pass-through ────────────────────────────────────────
-
-function summarizeSingleMessage(message: ThreadMessage): ThreadSummary {
-  return {
-    summary: truncate(message.body, 200),
-    participants: [{ name: message.sender }],
-    openQuestions: [],
-    lastAction: truncate(message.body, 200),
-    sentiment: "neutral",
-    messageCount: 1,
-  };
-}
-
-// ── LLM-powered summarization ──────────────────────────────────────────
-
-async function summarizeWithLLM(
-  messages: ThreadMessage[],
-  maxTokens: number,
-): Promise<ThreadSummary> {
-  const provider = getConfiguredProvider();
-  if (!provider) {
-    log.warn(
-      "Configured provider unavailable for thread summarization, returning basic summary",
-    );
-    return buildFallbackSummary(messages);
-  }
-
-  const truncatedMsgs = truncateMessages(messages, maxTokens);
-  const transcript = formatTranscript(truncatedMsgs);
-
-  try {
-    const { signal, cleanup } = createTimeout(SUMMARIZATION_TIMEOUT_MS);
-
-    try {
-      const response = await provider.sendMessage(
-        [
-          userMessage(
-            `Summarize this conversation thread (${messages.length} messages):\n\n${transcript}`,
-          ),
-        ],
-        [STORE_SUMMARY_TOOL],
-        SYSTEM_PROMPT,
-        {
-          config: {
-            modelIntent: SUMMARIZATION_MODEL_INTENT,
-            max_tokens: 1024,
-            tool_choice: {
-              type: "tool" as const,
-              name: "store_thread_summary",
-            },
-          },
-          signal,
-        },
-      );
-      cleanup();
-
-      const toolBlock = extractToolUse(response);
-      if (!toolBlock) {
-        log.warn(
-          "No tool_use block in summarization response, returning fallback",
-        );
-        return buildFallbackSummary(messages);
-      }
-
-      const input = toolBlock.input as {
-        summary?: string;
-        participants?: Array<{ name: string; role?: string }>;
-        openQuestions?: string[];
-        lastAction?: string;
-        sentiment?: string;
-      };
-
-      const validSentiments = new Set([
-        "positive",
-        "neutral",
-        "negative",
-        "mixed",
-      ]);
-      const sentiment = validSentiments.has(input.sentiment ?? "")
-        ? (input.sentiment as ThreadSummary["sentiment"])
-        : "neutral";
-
-      return {
-        summary: truncate(String(input.summary ?? ""), 2000, ""),
-        participants: Array.isArray(input.participants)
-          ? input.participants.map((p) => ({
-              name: String(p.name),
-              ...(p.role ? { role: String(p.role) } : {}),
-            }))
-          : extractParticipants(messages),
-        openQuestions: Array.isArray(input.openQuestions)
-          ? input.openQuestions.map((q) => String(q))
-          : [],
-        lastAction: truncate(String(input.lastAction ?? ""), 500, ""),
-        sentiment,
-        messageCount: messages.length,
-      };
-    } finally {
-      cleanup();
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.warn(
-      { err: message },
-      "Thread summarization LLM call failed, returning fallback",
-    );
-    return buildFallbackSummary(messages);
-  }
-}
-
-// ── Fallback summary (no LLM) ─────────────────────────────────────────
-
-function buildFallbackSummary(messages: ThreadMessage[]): ThreadSummary {
-  const sorted = [...messages].sort((a, b) => a.timestamp - b.timestamp);
-  const lastMsg = sorted[sorted.length - 1];
-
-  return {
-    summary: `Thread with ${
-      messages.length
-    } message(s) from ${extractParticipants(messages)
-      .map((p) => p.name)
-      .join(", ")}.`,
-    participants: extractParticipants(messages),
-    openQuestions: [],
-    lastAction: truncate(lastMsg.body, 200),
-    sentiment: "neutral",
-    messageCount: messages.length,
-  };
-}
-
-// ── Public API ─────────────────────────────────────────────────────────
-
-export async function summarizeThread(
-  messages: ThreadMessage[],
-  options?: { maxTokens?: number },
-): Promise<ThreadSummary> {
-  if (messages.length === 0) {
-    return { ...EMPTY_SUMMARY, participants: [], openQuestions: [] };
-  }
-
-  // Sort chronologically
-  const sorted = [...messages].sort((a, b) => a.timestamp - b.timestamp);
-
-  if (sorted.length === 1) {
-    return summarizeSingleMessage(sorted[0]);
-  }
-
-  const maxTokens = options?.maxTokens ?? DEFAULT_MAX_TOKENS;
-  return summarizeWithLLM(sorted, maxTokens);
-}

package/src/messaging/types.ts

@@ -1,17 +0,0 @@
-export interface ThreadMessage {
-  id: string;
-  sender: string;
-  body: string;
-  timestamp: number; // epoch ms
-  channel: string; // email, slack, whatsapp, etc.
-  metadata?: Record<string, unknown>;
-}
-
-export interface ThreadSummary {
-  summary: string;
-  participants: Array<{ name: string; role?: string }>;
-  openQuestions: string[];
-  lastAction: string;
-  sentiment: "positive" | "neutral" | "negative" | "mixed";
-  messageCount: number;
-}