@vellumai/assistant 0.4.11 → 0.4.13

package/src/__tests__/slack-skill.test.ts

@@ -0,0 +1,124 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { describe, expect, test } from 'bun:test';
+
+import type { SlackConversation } from '../messaging/providers/slack/types.js';
+
+const BUNDLED_SKILLS_DIR = join(import.meta.dir, '..', 'config', 'bundled-skills');
+
+describe('slack adapter isPrivate mapping', () => {
+  // Inline the mapping logic to test it independently of the adapter module
+  function mapIsPrivate(conv: Partial<SlackConversation>): boolean {
+    return conv.is_private ?? conv.is_group ?? false;
+  }
+
+  test('public channel is not private', () => {
+    expect(mapIsPrivate({ is_channel: true, is_private: false })).toBe(false);
+  });
+
+  test('private channel with is_private flag', () => {
+    expect(mapIsPrivate({ is_channel: true, is_private: true })).toBe(true);
+  });
+
+  test('private channel via is_group (legacy)', () => {
+    expect(mapIsPrivate({ is_group: true })).toBe(true);
+  });
+
+  test('is_private takes precedence over is_group', () => {
+    expect(mapIsPrivate({ is_private: false, is_group: true })).toBe(false);
+  });
+
+  test('DM defaults to not private when flags absent', () => {
+    expect(mapIsPrivate({ is_im: true })).toBe(false);
+  });
+
+  test('mpim (group DM) defaults to not private when is_private absent', () => {
+    expect(mapIsPrivate({ is_mpim: true })).toBe(false);
+  });
+
+  test('undefined flags default to false', () => {
+    expect(mapIsPrivate({})).toBe(false);
+  });
+});
+
+describe('slack skill TOOLS.json', () => {
+  const toolsPath = join(BUNDLED_SKILLS_DIR, 'slack', 'TOOLS.json');
+  const toolsJson = JSON.parse(readFileSync(toolsPath, 'utf-8'));
+
+  test('is valid JSON with correct version', () => {
+    expect(toolsJson.version).toBe(1);
+    expect(Array.isArray(toolsJson.tools)).toBe(true);
+  });
+
+  test('has expected tools', () => {
+    const names = toolsJson.tools.map((t: { name: string }) => t.name);
+    expect(names).toContain('slack_scan_digest');
+    expect(names).toContain('slack_channel_details');
+    expect(names).toContain('slack_configure_channels');
+    expect(names).toContain('slack_add_reaction');
+    expect(names).toContain('slack_delete_message');
+    expect(names).toContain('slack_leave_channel');
+  });
+
+  test('has 6 tools total', () => {
+    expect(toolsJson.tools.length).toBe(6);
+  });
+
+  test('all tools have required fields', () => {
+    for (const tool of toolsJson.tools) {
+      expect(tool.name).toBeDefined();
+      expect(tool.description).toBeDefined();
+      expect(tool.category).toBeDefined();
+      expect(tool.risk).toBeDefined();
+      expect(tool.input_schema).toBeDefined();
+      expect(tool.executor).toBeDefined();
+      expect(tool.execution_target).toBeDefined();
+    }
+  });
+
+  test('all executor files exist', () => {
+    const slackSkillDir = join(BUNDLED_SKILLS_DIR, 'slack');
+    for (const tool of toolsJson.tools) {
+      const executorPath = join(slackSkillDir, tool.executor);
+      expect(() => readFileSync(executorPath)).not.toThrow();
+    }
+  });
+});
+
+describe('messaging skill no longer has Slack tools', () => {
+  const messagingToolsPath = join(BUNDLED_SKILLS_DIR, 'messaging', 'TOOLS.json');
+  const messagingToolsJson = JSON.parse(readFileSync(messagingToolsPath, 'utf-8'));
+
+  test('slack_add_reaction not in messaging TOOLS.json', () => {
+    const names = messagingToolsJson.tools.map((t: { name: string }) => t.name);
+    expect(names).not.toContain('slack_add_reaction');
+  });
+
+  test('slack_delete_message not in messaging TOOLS.json', () => {
+    const names = messagingToolsJson.tools.map((t: { name: string }) => t.name);
+    expect(names).not.toContain('slack_delete_message');
+  });
+
+  test('slack_leave_channel not in messaging TOOLS.json', () => {
+    const names = messagingToolsJson.tools.map((t: { name: string }) => t.name);
+    expect(names).not.toContain('slack_leave_channel');
+  });
+});
+
+describe('slack skill SKILL.md', () => {
+  const skillMd = readFileSync(join(BUNDLED_SKILLS_DIR, 'slack', 'SKILL.md'), 'utf-8');
+
+  test('has correct frontmatter name', () => {
+    expect(skillMd).toContain('name: "Slack"');
+  });
+
+  test('is user-invocable', () => {
+    expect(skillMd).toContain('user-invocable: true');
+  });
+
+  test('mentions privacy rules', () => {
+    expect(skillMd).toContain('isPrivate');
+    expect(skillMd).toContain('MUST NEVER be shared');
+  });
+});

package/src/__tests__/starter-task-flow.test.ts

@@ -46,6 +46,7 @@ function makeContext(): SurfaceSessionContext {
     lastSurfaceAction: new Map<string, { actionId: string; data?: Record<string, unknown> }>(),
     surfaceState: new Map(),
     surfaceUndoStacks: new Map(),
+    surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     isProcessing: () => false,
     enqueueMessage: () => ({ queued: false, requestId: 'req-1' }),
@@ -74,7 +75,7 @@ describe('starter task surface actions', () => {
     expect(ctx.pendingSurfaceActions.has('surf-1')).toBe(true);
   });
 
-  test('falls back to structured payload when prompt is absent', () => {
+  test('falls back to human-readable summary with action data when prompt is absent', () => {
     const forwarded: string[] = [];
     const ctx = makeContext();
     ctx.processMessage = async (content) => {
@@ -86,16 +87,9 @@ describe('starter task surface actions', () => {
     handleSurfaceAction(ctx, 'surf-2', 'relay_prompt', { topic: 'weather in sf' });
 
     expect(forwarded).toHaveLength(1);
-    const parsed = JSON.parse(forwarded[0]) as {
-      surfaceAction: boolean;
-      surfaceId: string;
-      actionId: string;
-      data: Record<string, unknown>;
-    };
-    expect(parsed.surfaceAction).toBe(true);
-    expect(parsed.surfaceId).toBe('surf-2');
-    expect(parsed.actionId).toBe('relay_prompt');
-    expect(parsed.data.topic).toBe('weather in sf');
+    expect(forwarded[0]).toContain('[User action on dynamic_page surface:');
+    expect(forwarded[0]).toContain('Action data:');
+    expect(forwarded[0]).toContain('"topic":"weather in sf"');
     expect(ctx.pendingSurfaceActions.has('surf-2')).toBe(true);
   });
 
@@ -111,12 +105,8 @@ describe('starter task surface actions', () => {
     handleSurfaceAction(ctx, 'surf-3', 'save_filters', { prompt: 'keep this literal field' });
 
     expect(forwarded).toHaveLength(1);
-    const parsed = JSON.parse(forwarded[0]) as {
-      actionId: string;
-      data: Record<string, unknown>;
-    };
-    expect(parsed.actionId).toBe('save_filters');
-    expect(parsed.data.prompt).toBe('keep this literal field');
+    expect(forwarded[0]).toContain('[User action on dynamic_page surface:');
+    expect(forwarded[0]).toContain('"prompt":"keep this literal field"');
   });
 
   test('consumes non-dynamic pending actions after forwarding', () => {

package/src/agent/loop.ts

@@ -41,7 +41,7 @@ export type AgentEvent =
 
 const DEFAULT_CONFIG: AgentLoopConfig = {
   maxTokens: 16000,
-  maxToolUseTurns: 0,
+  maxToolUseTurns: 40,
   minTurnIntervalMs: 150,
 };
 
@@ -65,14 +65,14 @@ export class AgentLoop {
   private tools: ToolDefinition[];
   private resolveTools: ((history: Message[]) => ToolDefinition[]) | null;
   private resolveSystemPrompt: ((history: Message[]) => ResolvedSystemPrompt) | null;
-  private toolExecutor: ((name: string, input: Record<string, unknown>, onOutput?: (chunk: string) => void) => Promise<{ content: string; isError: boolean; diff?: { filePath: string; oldContent: string; newContent: string; isNewFile: boolean }; status?: string; contentBlocks?: ContentBlock[]; sensitiveBindings?: SensitiveOutputBinding[] }>) | null;
+  private toolExecutor: ((name: string, input: Record<string, unknown>, onOutput?: (chunk: string) => void) => Promise<{ content: string; isError: boolean; diff?: { filePath: string; oldContent: string; newContent: string; isNewFile: boolean }; status?: string; contentBlocks?: ContentBlock[]; sensitiveBindings?: SensitiveOutputBinding[]; yieldToUser?: boolean }>) | null;
 
   constructor(
     provider: Provider,
     systemPrompt: string,
     config?: Partial<AgentLoopConfig>,
     tools?: ToolDefinition[],
-    toolExecutor?: (name: string, input: Record<string, unknown>, onOutput?: (chunk: string) => void) => Promise<{ content: string; isError: boolean; diff?: { filePath: string; oldContent: string; newContent: string; isNewFile: boolean }; status?: string; contentBlocks?: ContentBlock[]; sensitiveBindings?: SensitiveOutputBinding[] }>,
+    toolExecutor?: (name: string, input: Record<string, unknown>, onOutput?: (chunk: string) => void) => Promise<{ content: string; isError: boolean; diff?: { filePath: string; oldContent: string; newContent: string; isNewFile: boolean }; status?: string; contentBlocks?: ContentBlock[]; sensitiveBindings?: SensitiveOutputBinding[]; yieldToUser?: boolean }>,
     resolveTools?: (history: Message[]) => ToolDefinition[],
     resolveSystemPrompt?: (history: Message[]) => ResolvedSystemPrompt,
   ) {
@@ -479,6 +479,13 @@ export class AgentLoop {
           break;
         }
 
+        // If any tool result requests yielding to the user (e.g. interactive
+        // surface awaiting a button click), push results and stop the loop.
+        if (toolResults.some(({ result }) => result.yieldToUser)) {
+          history.push({ role: 'user', content: resultBlocks });
+          break;
+        }
+
         // Track tool-use turns and inject progress reminder every N turns
         toolUseTurns++;
         if (this.config.maxToolUseTurns && this.config.maxToolUseTurns > 0 && toolUseTurns >= this.config.maxToolUseTurns) {

package/src/config/bundled-skills/chatgpt-import/tools/chatgpt-import.ts

@@ -0,0 +1,449 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { inflateRawSync } from "node:zlib";
+
+import { Database } from "bun:sqlite";
+import { eq } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { v4 as uuid } from "uuid";
+
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+
+// -- Inline schema (only the tables this tool touches) --
+
+const conversations = sqliteTable("conversations", {
+  id: text("id").primaryKey(),
+  title: text("title"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+  totalInputTokens: integer("total_input_tokens").notNull().default(0),
+  totalOutputTokens: integer("total_output_tokens").notNull().default(0),
+  totalEstimatedCost: real("total_estimated_cost").notNull().default(0),
+  contextSummary: text("context_summary"),
+  contextCompactedMessageCount: integer("context_compacted_message_count")
+    .notNull()
+    .default(0),
+  contextCompactedAt: integer("context_compacted_at"),
+  threadType: text("thread_type").notNull().default("standard"),
+  memoryScopeId: text("memory_scope_id").notNull().default("default"),
+});
+
+const messagesTable = sqliteTable("messages", {
+  id: text("id").primaryKey(),
+  conversationId: text("conversation_id")
+    .notNull()
+    .references(() => conversations.id),
+  role: text("role").notNull(),
+  content: text("content").notNull(),
+  createdAt: integer("created_at").notNull(),
+  metadata: text("metadata"),
+});
+
+const conversationKeys = sqliteTable("conversation_keys", {
+  id: text("id").primaryKey(),
+  conversationKey: text("conversation_key").notNull(),
+  conversationId: text("conversation_id")
+    .notNull()
+    .references(() => conversations.id, { onDelete: "cascade" }),
+  createdAt: integer("created_at").notNull(),
+});
+
+// -- Inline DB access --
+
+const schema = { conversations, messages: messagesTable, conversationKeys };
+
+function getDbPath(): string {
+  const baseDir = process.env.BASE_DATA_DIR?.trim() || homedir();
+  return join(baseDir, ".vellum", "workspace", "data", "db", "assistant.db");
+}
+
+let db: ReturnType<typeof drizzle<typeof schema>> | null = null;
+
+function getDb() {
+  if (!db) {
+    const dbPath = getDbPath();
+    const dbDir = join(dbPath, "..");
+    mkdirSync(dbDir, { recursive: true });
+    const sqlite = new Database(dbPath);
+    sqlite.exec("PRAGMA journal_mode=WAL");
+    sqlite.exec("PRAGMA foreign_keys = ON");
+    db = drizzle(sqlite, { schema });
+  }
+  return db;
+}
+
+// -- Inline conversation helpers --
+
+let lastTimestamp = 0;
+function monotonicNow(): number {
+  const now = Date.now();
+  lastTimestamp = Math.max(now, lastTimestamp + 1);
+  return lastTimestamp;
+}
+
+function createConversation(title: string) {
+  const database = getDb();
+  const now = Date.now();
+  const id = uuid();
+  const conversation = {
+    id,
+    title,
+    createdAt: now,
+    updatedAt: now,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+    contextSummary: null as string | null,
+    contextCompactedMessageCount: 0,
+    contextCompactedAt: null as number | null,
+    threadType: "standard" as const,
+    memoryScopeId: "default",
+  };
+  database.insert(conversations).values(conversation).run();
+  return conversation;
+}
+
+function addMessage(conversationId: string, role: string, content: string) {
+  const database = getDb();
+  const now = monotonicNow();
+  const message = {
+    id: uuid(),
+    conversationId,
+    role,
+    content,
+    createdAt: now,
+  };
+  database.transaction((tx) => {
+    tx.insert(messagesTable).values(message).run();
+    tx.update(conversations)
+      .set({ updatedAt: now })
+      .where(eq(conversations.id, conversationId))
+      .run();
+  });
+  return message;
+}
+
+// -- ChatGPT export format types --
+
+interface ChatGPTContent {
+  content_type: string;
+  parts?: (string | null | Record<string, unknown>)[];
+}
+
+interface ChatGPTNode {
+  message: {
+    author: { role: string };
+    content: ChatGPTContent;
+    create_time?: number | null;
+  } | null;
+  parent: string | null;
+  children: string[];
+}
+
+interface ChatGPTConversation {
+  id?: string;
+  title: string;
+  create_time: number;
+  update_time: number;
+  current_node: string;
+  mapping: Record<string, ChatGPTNode>;
+}
+
+interface ImportedMessage {
+  role: string;
+  content: Array<{ type: string; text: string }>;
+  createdAt: number;
+}
+
+interface ImportedConversation {
+  sourceId: string;
+  title: string;
+  createdAt: number;
+  updatedAt: number;
+  messages: ImportedMessage[];
+}
+
+// -- Tool entry point --
+
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const filePath = input.file_path as string;
+
+  if (!filePath) {
+    return { content: "Error: file_path is required", isError: true };
+  }
+
+  if (!filePath.endsWith(".zip")) {
+    return {
+      content:
+        "Error: Only ZIP files are accepted. Please provide the ChatGPT export ZIP file.",
+      isError: true,
+    };
+  }
+
+  if (!existsSync(filePath)) {
+    return { content: `Error: File not found: ${filePath}`, isError: true };
+  }
+
+  let imported: ImportedConversation[];
+  try {
+    imported = parseChatGPTExport(filePath);
+  } catch (err) {
+    return {
+      content: `Error parsing export file: ${err instanceof Error ? err.message : String(err)}`,
+      isError: true,
+    };
+  }
+
+  if (imported.length === 0) {
+    return {
+      content: "No conversations found in the export file.",
+      isError: false,
+    };
+  }
+
+  const database = getDb();
+  let importedCount = 0;
+  let skippedCount = 0;
+  let messageCount = 0;
+
+  for (const conv of imported) {
+    const convKey = `chatgpt:${conv.sourceId}`;
+
+    const existing = database
+      .select()
+      .from(conversationKeys)
+      .where(eq(conversationKeys.conversationKey, convKey))
+      .get();
+
+    if (existing) {
+      skippedCount++;
+      continue;
+    }
+
+    const conversation = createConversation(conv.title);
+
+    for (const msg of conv.messages) {
+      addMessage(conversation.id, msg.role, JSON.stringify(msg.content));
+    }
+
+    // Override timestamps to match ChatGPT originals
+    database
+      .update(conversations)
+      .set({ createdAt: conv.createdAt, updatedAt: conv.updatedAt })
+      .where(eq(conversations.id, conversation.id))
+      .run();
+
+    // Update message timestamps to match ChatGPT originals
+    const dbMessages = database
+      .select({ id: messagesTable.id })
+      .from(messagesTable)
+      .where(eq(messagesTable.conversationId, conversation.id))
+      .orderBy(messagesTable.createdAt)
+      .all();
+
+    for (let i = 0; i < dbMessages.length && i < conv.messages.length; i++) {
+      database
+        .update(messagesTable)
+        .set({ createdAt: conv.messages[i].createdAt })
+        .where(eq(messagesTable.id, dbMessages[i].id))
+        .run();
+    }
+
+    database
+      .insert(conversationKeys)
+      .values({
+        id: uuid(),
+        conversationKey: convKey,
+        conversationId: conversation.id,
+        createdAt: Date.now(),
+      })
+      .run();
+
+    importedCount++;
+    messageCount += conv.messages.length;
+  }
+
+  const lines = [
+    `Imported ${importedCount} conversation(s) with ${messageCount} message(s).`,
+  ];
+  if (skippedCount > 0) {
+    lines.push(`Skipped ${skippedCount} already-imported conversation(s).`);
+  }
+  return { content: lines.join("\n"), isError: false };
+}
+
+// -- Parser --
+
+function parseChatGPTExport(zipPath: string): ImportedConversation[] {
+  const jsonContent = extractConversationsJsonFromZip(zipPath);
+
+  const raw = JSON.parse(jsonContent);
+  if (!Array.isArray(raw)) {
+    throw new Error("Expected conversations.json to contain a JSON array");
+  }
+
+  const results: ImportedConversation[] = [];
+  for (const conv of raw as ChatGPTConversation[]) {
+    const imported = parseConversation(conv);
+    if (imported) {
+      results.push(imported);
+    }
+  }
+  return results;
+}
+
+function parseConversation(
+  conv: ChatGPTConversation,
+): ImportedConversation | null {
+  const { mapping, current_node } = conv;
+  if (!mapping || !current_node || !mapping[current_node]) return null;
+
+  // Walk from current_node to root via parent pointers, then reverse for chronological order
+  const nodeIds: string[] = [];
+  let nodeId: string | null = current_node;
+  while (nodeId) {
+    nodeIds.push(nodeId);
+    nodeId = mapping[nodeId]?.parent ?? null;
+  }
+  nodeIds.reverse();
+
+  const messages: ImportedMessage[] = [];
+  for (const id of nodeIds) {
+    const node = mapping[id];
+    if (!node?.message) continue;
+
+    const { author, content, create_time } = node.message;
+    const role = author?.role;
+    if (role !== "user" && role !== "assistant") continue;
+
+    const text = extractText(content);
+    if (!text) continue;
+
+    messages.push({
+      role,
+      content: [{ type: "text", text }],
+      createdAt: create_time
+        ? Math.round(create_time * 1000)
+        : Math.round(conv.create_time * 1000),
+    });
+  }
+
+  if (messages.length === 0) return null;
+
+  return {
+    sourceId: conv.id ?? `${conv.title}-${conv.create_time}`,
+    title: conv.title || "Untitled",
+    createdAt: Math.round(conv.create_time * 1000),
+    updatedAt: Math.round(conv.update_time * 1000),
+    messages,
+  };
+}
+
+function extractText(content: ChatGPTContent): string {
+  if (!content?.parts) return "";
+  return content.parts
+    .filter((p): p is string => typeof p === "string")
+    .join("");
+}
+
+// -- ZIP extraction --
+
+function extractConversationsJsonFromZip(zipPath: string): string {
+  const buffer = readFileSync(zipPath);
+
+  // Find end of central directory record (EOCD signature: 0x06054b50)
+  let eocdOffset = -1;
+  for (let i = buffer.length - 22; i >= 0; i--) {
+    if (
+      buffer[i] === 0x50 &&
+      buffer[i + 1] === 0x4b &&
+      buffer[i + 2] === 0x05 &&
+      buffer[i + 3] === 0x06
+    ) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset === -1) {
+    throw new Error(
+      "Invalid ZIP file: could not find end of central directory",
+    );
+  }
+
+  const centralDirOffset = buffer.readUInt32LE(eocdOffset + 16);
+  const centralDirEntries = buffer.readUInt16LE(eocdOffset + 10);
+
+  // Walk central directory to find conversations.json
+  let offset = centralDirOffset;
+  for (let i = 0; i < centralDirEntries; i++) {
+    if (
+      buffer[offset] !== 0x50 ||
+      buffer[offset + 1] !== 0x4b ||
+      buffer[offset + 2] !== 0x01 ||
+      buffer[offset + 3] !== 0x02
+    ) {
+      throw new Error("Invalid ZIP central directory entry");
+    }
+
+    const cdCompressedSize = buffer.readUInt32LE(offset + 20);
+    const fileNameLength = buffer.readUInt16LE(offset + 28);
+    const extraLength = buffer.readUInt16LE(offset + 30);
+    const commentLength = buffer.readUInt16LE(offset + 32);
+    const localHeaderOffset = buffer.readUInt32LE(offset + 42);
+    const fileName = buffer
+      .subarray(offset + 46, offset + 46 + fileNameLength)
+      .toString("utf-8");
+
+    if (
+      fileName === "conversations.json" ||
+      fileName.endsWith("/conversations.json")
+    ) {
+      return extractLocalFile(buffer, localHeaderOffset, cdCompressedSize);
+    }
+
+    offset += 46 + fileNameLength + extraLength + commentLength;
+  }
+
+  throw new Error("conversations.json not found in ZIP file");
+}
+
+function extractLocalFile(
+  buffer: Buffer,
+  offset: number,
+  cdCompressedSize: number,
+): string {
+  if (
+    buffer[offset] !== 0x50 ||
+    buffer[offset + 1] !== 0x4b ||
+    buffer[offset + 2] !== 0x03 ||
+    buffer[offset + 3] !== 0x04
+  ) {
+    throw new Error("Invalid ZIP local file header");
+  }
+
+  const compressionMethod = buffer.readUInt16LE(offset + 8);
+  const localCompressedSize = buffer.readUInt32LE(offset + 18);
+  const compressedSize =
+    cdCompressedSize > 0 ? cdCompressedSize : localCompressedSize;
+  const fileNameLength = buffer.readUInt16LE(offset + 26);
+  const extraLength = buffer.readUInt16LE(offset + 28);
+
+  const dataOffset = offset + 30 + fileNameLength + extraLength;
+  const fileData = buffer.subarray(dataOffset, dataOffset + compressedSize);
+
+  if (compressionMethod === 0) {
+    return fileData.toString("utf-8");
+  } else if (compressionMethod === 8) {
+    return inflateRawSync(fileData).toString("utf-8");
+  } else {
+    throw new Error(`Unsupported ZIP compression method: ${compressionMethod}`);
+  }
+}