@vellumai/assistant 0.4.44 → 0.4.45

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

package/src/tools/browser/x-auto-navigate.ts

@@ -1,254 +0,0 @@
-/**
- * CDP-based auto-navigation for X.com.
- *
- * Drives Chrome through key X.com pages to trigger GraphQL API calls,
- * so the NetworkRecorder captures the full API surface without manual browsing.
- */
-
-import { getLogger } from "../../util/logger.js";
-
-const log = getLogger("x-auto-navigate");
-
-const DEFAULT_CDP_BASE = "http://localhost:9222";
-
-interface NavStep {
-  label: string;
-  url?: string;
-  clickSelector?: string;
-}
-
-/** Minimal CDP client — connects to one page tab. */
-class MiniCDP {
-  private ws: WebSocket | null = null;
-  private nextId = 1;
-  private callbacks = new Map<
-    number,
-    { resolve: (v: unknown) => void; reject: (e: Error) => void }
-  >();
-
-  async connect(wsUrl: string): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const ws = new WebSocket(wsUrl);
-      ws.onopen = () => {
-        this.ws = ws;
-        resolve();
-      };
-      ws.onerror = (e) => reject(new Error(`CDP error: ${e}`));
-      ws.onclose = () => {
-        this.ws = null;
-      };
-      ws.onmessage = (event) => {
-        const msg = JSON.parse(String(event.data));
-        if (msg.id != null) {
-          const cb = this.callbacks.get(msg.id);
-          if (cb) {
-            this.callbacks.delete(msg.id);
-            if (msg.error) {
-              cb.reject(new Error(msg.error.message));
-            } else {
-              cb.resolve(msg.result);
-            }
-          }
-        }
-      };
-    });
-  }
-
-  async send(
-    method: string,
-    params?: Record<string, unknown>,
-  ): Promise<unknown> {
-    if (!this.ws) throw new Error("Not connected");
-    const id = this.nextId++;
-    return new Promise((resolve, reject) => {
-      this.callbacks.set(id, { resolve, reject });
-      this.ws!.send(JSON.stringify({ id, method, params }));
-    });
-  }
-
-  close() {
-    this.ws?.close();
-  }
-}
-
-export interface NavigateXPagesOptions {
-  abortSignal?: { aborted: boolean };
-  cdpBaseUrl?: string;
-}
-
-/**
- * Navigate Chrome through X.com pages to trigger GraphQL calls.
- * The NetworkRecorder should already be attached and capturing.
- *
- * @param options Optional configuration for abort and CDP base URL.
- * @returns List of step labels that completed successfully.
- */
-export async function navigateXPages(
-  options?: NavigateXPagesOptions,
-): Promise<string[]> {
-  const { abortSignal, cdpBaseUrl = DEFAULT_CDP_BASE } = options ?? {};
-  let wsUrl: string | null = null;
-  try {
-    const res = await fetch(`${cdpBaseUrl}/json/list`);
-    if (!res.ok) {
-      log.warn("CDP not available for auto-navigation");
-      return [];
-    }
-    const targets = (await res.json()) as Array<{
-      type: string;
-      url: string;
-      webSocketDebuggerUrl: string;
-    }>;
-    const xTab = targets.find(
-      (t) =>
-        t.type === "page" &&
-        (t.url.includes("x.com") || t.url.includes("twitter.com")),
-    );
-    wsUrl =
-      xTab?.webSocketDebuggerUrl ??
-      targets.find((t) => t.type === "page")?.webSocketDebuggerUrl ??
-      null;
-  } catch (err) {
-    log.warn({ err }, "Failed to discover Chrome tabs");
-    return [];
-  }
-
-  if (!wsUrl) {
-    log.warn("No Chrome tab found for auto-navigation");
-    return [];
-  }
-
-  const cdp = new MiniCDP();
-  try {
-    await cdp.connect(wsUrl);
-  } catch (err) {
-    log.warn({ err }, "Failed to connect CDP for auto-navigation");
-    return [];
-  }
-
-  await cdp.send("Page.enable").catch(() => {});
-  const completed: string[] = [];
-
-  // Navigate to home first to discover the screen name
-  try {
-    await cdp.send("Page.navigate", { url: "https://x.com/home" });
-    await sleep(3000);
-  } catch (err) {
-    log.warn({ err }, "Failed to navigate to home");
-    cdp.close();
-    return [];
-  }
-
-  // Resolve screen name for profile-based URLs
-  let screenName: string | null = null;
-  try {
-    const result = (await cdp.send("Runtime.evaluate", {
-      expression: `
-        (function() {
-          const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
-          if (link) return link.getAttribute('href')?.replace('/', '') ?? null;
-          return null;
-        })()
-      `,
-      awaitPromise: false,
-      returnByValue: true,
-    })) as { result?: { value?: string | null } };
-    screenName = result?.result?.value ?? null;
-  } catch {
-    /* ignore */
-  }
-
-  log.info({ screenName }, "Detected screen name");
-
-  // Build steps with resolved URLs
-  const steps: NavStep[] = [
-    { label: "Home timeline", url: "https://x.com/home" },
-    {
-      label: "Profile",
-      clickSelector: 'a[data-testid="AppTabBar_Profile_Link"]',
-    },
-    {
-      label: "Tweet detail",
-      clickSelector: 'article[data-testid="tweet"] a[href*="/status/"]',
-    },
-    { label: "Search", url: "https://x.com/search?q=hello&src=typed_query" },
-    { label: "Bookmarks", url: "https://x.com/i/bookmarks" },
-    { label: "Notifications", url: "https://x.com/notifications" },
-  ];
-
-  // Add profile-based URLs if we have the screen name
-  if (screenName) {
-    steps.push(
-      { label: "Likes", url: `https://x.com/${screenName}/likes` },
-      { label: "Followers", url: `https://x.com/${screenName}/followers` },
-      { label: "Following", url: `https://x.com/${screenName}/following` },
-      { label: "Media", url: `https://x.com/${screenName}/media` },
-    );
-  }
-
-  for (const step of steps) {
-    if (abortSignal?.aborted) break;
-
-    log.info({ step: step.label }, "Auto-navigate step starting");
-
-    try {
-      if (step.url) {
-        await cdp.send("Page.navigate", { url: step.url });
-        await sleep(3000);
-      }
-
-      if (step.clickSelector) {
-        await sleep(1500);
-        await clickInPage(cdp, step.clickSelector);
-        await sleep(2000);
-      }
-
-      // Scroll to trigger lazy-loaded content
-      await cdp
-        .send("Runtime.evaluate", {
-          expression: "window.scrollBy(0, 800)",
-          awaitPromise: false,
-        })
-        .catch(() => {});
-
-      await sleep(2000);
-
-      completed.push(step.label);
-      log.info({ step: step.label }, "Auto-navigate step completed");
-    } catch (err) {
-      log.warn({ err, step: step.label }, "Auto-navigate step failed");
-    }
-  }
-
-  cdp.close();
-  log.info(
-    { completed: completed.length, total: steps.length },
-    "Auto-navigation finished",
-  );
-  return completed;
-}
-
-async function clickInPage(cdp: MiniCDP, selector: string): Promise<boolean> {
-  try {
-    const result = (await cdp.send("Runtime.evaluate", {
-      expression: `
-        (function() {
-          const el = document.querySelector(${JSON.stringify(selector)});
-          if (!el) return false;
-          el.scrollIntoView({ block: 'center' });
-          el.click();
-          return true;
-        })()
-      `,
-      awaitPromise: false,
-      returnByValue: true,
-    })) as { result?: { value?: boolean } };
-    return result?.result?.value === true;
-  } catch {
-    return false;
-  }
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((r) => setTimeout(r, ms));
-}