@vellumai/assistant 0.4.44 → 0.4.45

package/src/messaging/email-classifier.ts

@@ -1,208 +0,0 @@
-/**
- * LLM-powered email classification for inbox triage.
- * Works with metadata only (from, subject, snippet, labels) to keep token usage low.
- */
-
-import {
-  createTimeout,
-  extractToolUse,
-  getConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
-import { getLogger } from "../util/logger.js";
-
-const log = getLogger("email-classifier");
-
-const CLASSIFICATION_MODEL_INTENT = "latency-optimized" as const;
-const CLASSIFICATION_TIMEOUT_MS = 30_000;
-
-export type EmailCategory =
-  | "needs_reply"
-  | "fyi_only"
-  | "can_archive"
-  | "urgent"
-  | "newsletter"
-  | "promotional";
-
-export interface EmailMetadata {
-  id: string;
-  from: string;
-  subject: string;
-  snippet: string;
-  labels: string[];
-}
-
-export interface ClassifiedEmail {
-  id: string;
-  category: EmailCategory;
-  reasoning: string;
-  suggestedAction: string;
-  urgencyScore: number; // 0-1
-}
-
-export interface ClassificationResult {
-  classifications: ClassifiedEmail[];
-}
-
-const VALID_CATEGORIES = new Set<EmailCategory>([
-  "needs_reply",
-  "fyi_only",
-  "can_archive",
-  "urgent",
-  "newsletter",
-  "promotional",
-]);
-
-const SYSTEM_PROMPT = `You are an email triage system. Given email metadata (sender, subject, snippet, labels), classify each email into exactly one category:
-
-- needs_reply: Requires a personal response from the user
-- fyi_only: Informational, no action needed but worth reading
-- can_archive: Safe to archive without reading (automated notifications, receipts, etc.)
-- urgent: Time-sensitive and requires immediate attention
-- newsletter: Regular newsletter or digest
-- promotional: Marketing, sales, or promotional content
-
-For each email, provide:
-- category: One of the categories above
-- reasoning: Brief explanation of the classification (1 sentence)
-- suggested_action: What the user should do (e.g., "Reply to confirm", "Archive", "Read later")
-- urgency_score: 0.0 (not urgent) to 1.0 (extremely urgent)
-
-You MUST respond using the \`store_classifications\` tool. Do not respond with text.`;
-
-const STORE_CLASSIFICATIONS_TOOL = {
-  name: "store_classifications",
-  description: "Store email classification results",
-  input_schema: {
-    type: "object" as const,
-    properties: {
-      classifications: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            id: { type: "string", description: "Email ID" },
-            category: {
-              type: "string",
-              enum: [
-                "needs_reply",
-                "fyi_only",
-                "can_archive",
-                "urgent",
-                "newsletter",
-                "promotional",
-              ],
-            },
-            reasoning: {
-              type: "string",
-              description: "Brief classification reasoning",
-            },
-            suggested_action: {
-              type: "string",
-              description: "Suggested action for the user",
-            },
-            urgency_score: { type: "number", description: "Urgency score 0-1" },
-          },
-          required: [
-            "id",
-            "category",
-            "reasoning",
-            "suggested_action",
-            "urgency_score",
-          ],
-        },
-      },
-    },
-    required: ["classifications"],
-  },
-};
-
-function formatEmailsForPrompt(emails: EmailMetadata[]): string {
-  return emails
-    .map((e, i) =>
-      [
-        `--- Email ${i + 1} (ID: ${e.id}) ---`,
-        `From: ${e.from}`,
-        `Subject: ${e.subject}`,
-        `Snippet: ${e.snippet}`,
-        `Labels: ${e.labels.join(", ") || "none"}`,
-      ].join("\n"),
-    )
-    .join("\n\n");
-}
-
-export async function classifyEmails(
-  emails: EmailMetadata[],
-): Promise<ClassificationResult> {
-  if (emails.length === 0) {
-    return { classifications: [] };
-  }
-
-  const provider = getConfiguredProvider();
-  if (!provider) {
-    log.warn("Configured provider unavailable for email classification");
-    return { classifications: [] };
-  }
-
-  const prompt = `Classify these ${
-    emails.length
-  } emails:\n\n${formatEmailsForPrompt(emails)}`;
-
-  try {
-    const { signal, cleanup } = createTimeout(CLASSIFICATION_TIMEOUT_MS);
-
-    try {
-      const response = await provider.sendMessage(
-        [userMessage(prompt)],
-        [STORE_CLASSIFICATIONS_TOOL],
-        SYSTEM_PROMPT,
-        {
-          config: {
-            modelIntent: CLASSIFICATION_MODEL_INTENT,
-            max_tokens: 2048,
-            tool_choice: {
-              type: "tool" as const,
-              name: "store_classifications",
-            },
-          },
-          signal,
-        },
-      );
-      cleanup();
-
-      const toolBlock = extractToolUse(response);
-      if (!toolBlock) {
-        log.warn("No tool_use block in classification response");
-        return { classifications: [] };
-      }
-
-      const input = toolBlock.input as {
-        classifications?: Array<{
-          id: string;
-          category: string;
-          reasoning: string;
-          suggested_action: string;
-          urgency_score: number;
-        }>;
-      };
-
-      const classifications: ClassifiedEmail[] = (input.classifications ?? [])
-        .filter((c) => VALID_CATEGORIES.has(c.category as EmailCategory))
-        .map((c) => ({
-          id: c.id,
-          category: c.category as EmailCategory,
-          reasoning: c.reasoning,
-          suggestedAction: c.suggested_action,
-          urgencyScore: Math.max(0, Math.min(1, c.urgency_score)),
-        }));
-
-      return { classifications };
-    } finally {
-      cleanup();
-    }
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    log.warn({ err: message }, "Email classification LLM call failed");
-    return { classifications: [] };
-  }
-}

package/src/messaging/index.ts

@@ -1,2 +0,0 @@
-export { summarizeThread } from "./thread-summarizer.js";
-export * from "./types.js";

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;
-}