@vellumai/assistant 0.5.1 → 0.5.2

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -0,0 +1,439 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { createAssistantMessage } from "../agent/message-types.js";
+import type { Conversation } from "../daemon/conversation.js";
+import { persistUserMessage } from "../daemon/conversation-messaging.js";
+import {
+  addMessage,
+  getConversation,
+  provenanceFromTrustContext,
+} from "../memory/conversation-crud.js";
+import {
+  getConversationDirPath,
+  syncMessageToDisk,
+} from "../memory/conversation-disk-view.js";
+import {
+  getConversationByKey,
+  getOrCreateConversation as getOrCreateConversationMapping,
+} from "../memory/conversation-key-store.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import type { AuthContext } from "../runtime/auth/types.js";
+import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
+
+const testDir = realpathSync(
+  mkdtempSync(join(tmpdir(), "conversation-routes-disk-view-test-")),
+);
+const workspaceDir = join(testDir, "workspace");
+const conversationsDir = join(workspaceDir, "conversations");
+mkdirSync(conversationsDir, { recursive: true });
+
+mock.module("../util/platform.js", () => ({
+  getRootDir: () => testDir,
+  getDataDir: () => join(testDir, "data"),
+  getWorkspaceDir: () => workspaceDir,
+  getConversationsDir: () => conversationsDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+    contextWindow: { maxInputTokens: 200000 },
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
+  }),
+}));
+
+initializeDb();
+
+const conversationInstances = new Map<string, Conversation>();
+
+const authContext: AuthContext = {
+  subject: "svc_gateway:self",
+  principalType: "svc_gateway",
+  assistantId: "self",
+  scopeProfile: "gateway_service_v1",
+  scopes: new Set([
+    "chat.read",
+    "chat.write",
+    "approval.read",
+    "approval.write",
+    "settings.read",
+    "settings.write",
+    "attachments.read",
+    "attachments.write",
+    "calls.read",
+    "calls.write",
+    "feature_flags.read",
+    "feature_flags.write",
+  ]),
+  policyEpoch: 1,
+};
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+  db.run("DELETE FROM conversation_keys");
+}
+
+function resetConversationsDir(): void {
+  rmSync(conversationsDir, { recursive: true, force: true });
+  mkdirSync(conversationsDir, { recursive: true });
+}
+
+function createFakeConversation(conversationId: string): Conversation {
+  const conversation = {
+    conversationId,
+    processing: false,
+    currentRequestId: undefined as string | undefined,
+    abortController: null as AbortController | null,
+    trustContext: undefined as unknown,
+    turnChannelContext: null as
+      | {
+          userMessageChannel: string;
+          assistantMessageChannel: string;
+        }
+      | null,
+    turnInterfaceContext: null as
+      | {
+          userMessageInterface: string;
+          assistantMessageInterface: string;
+        }
+      | null,
+    messages: [] as Array<unknown>,
+    hostBashProxy: undefined as unknown,
+    hostFileProxy: undefined as unknown,
+    hostCuProxy: undefined as unknown,
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
+    memoryPolicy: {
+      scopeId: "default",
+      includeDefaultFallback: false,
+      strictSideEffects: false,
+    },
+    isProcessing(this: { processing: boolean }) {
+      return this.processing;
+    },
+    setChannelCapabilities: () => {},
+    setAssistantId: () => {},
+    setTrustContext(this: { trustContext: unknown }, ctx: unknown) {
+      this.trustContext = ctx;
+    },
+    setAuthContext: () => {},
+    setCommandIntent: () => {},
+    setTurnChannelContext(
+      this: {
+        turnChannelContext: {
+          userMessageChannel: string;
+          assistantMessageChannel: string;
+        } | null;
+      },
+      ctx: { userMessageChannel: string; assistantMessageChannel: string },
+    ) {
+      this.turnChannelContext = ctx;
+    },
+    getTurnChannelContext(this: {
+      turnChannelContext: {
+        userMessageChannel: string;
+        assistantMessageChannel: string;
+      } | null;
+    }) {
+      return this.turnChannelContext;
+    },
+    setTurnInterfaceContext(
+      this: {
+        turnInterfaceContext: {
+          userMessageInterface: string;
+          assistantMessageInterface: string;
+        } | null;
+      },
+      ctx: {
+        userMessageInterface: string;
+        assistantMessageInterface: string;
+      },
+    ) {
+      this.turnInterfaceContext = ctx;
+    },
+    getTurnInterfaceContext(this: {
+      turnInterfaceContext: {
+        userMessageInterface: string;
+        assistantMessageInterface: string;
+      } | null;
+    }) {
+      return this.turnInterfaceContext;
+    },
+    ensureActorScopedHistory: async () => {},
+    updateClient: () => {},
+    setHostBashProxy(this: { hostBashProxy: unknown }, proxy: unknown) {
+      this.hostBashProxy = proxy;
+    },
+    setHostFileProxy(this: { hostFileProxy: unknown }, proxy: unknown) {
+      this.hostFileProxy = proxy;
+    },
+    setHostCuProxy(this: { hostCuProxy: unknown }, proxy: unknown) {
+      this.hostCuProxy = proxy;
+    },
+    addPreactivatedSkillId: () => {},
+    hasAnyPendingConfirmation: () => false,
+    hasPendingConfirmation: () => false,
+    denyAllPendingConfirmations: () => {},
+    emitConfirmationStateChanged: () => {},
+    emitActivityState: () => {},
+    enqueueMessage: () => ({ queued: true, requestId: crypto.randomUUID() }),
+    getQueueDepth: () => 0,
+    handleConfirmationResponse: () => {},
+    handleSecretResponse: () => {},
+    getMessages(this: { messages: Array<unknown> }) {
+      return this.messages as never[];
+    },
+    persistUserMessage(
+      this: Conversation,
+      content: string,
+      attachments: Array<{
+        id: string;
+        filename: string;
+        mimeType: string;
+        data: string;
+        extractedText?: string;
+        filePath?: string;
+      }>,
+      requestId?: string,
+      metadata?: Record<string, unknown>,
+      displayContent?: string,
+    ): Promise<string> {
+      return persistUserMessage(
+        this as Parameters<typeof persistUserMessage>[0],
+        content,
+        attachments,
+        requestId,
+        metadata,
+        displayContent,
+      );
+    },
+    async runAgentLoop(
+      this: {
+        conversationId: string;
+        turnChannelContext: {
+          userMessageChannel: string;
+          assistantMessageChannel: string;
+        } | null;
+        turnInterfaceContext: {
+          userMessageInterface: string;
+          assistantMessageInterface: string;
+        } | null;
+        trustContext: unknown;
+        messages: Array<unknown>;
+        processing: boolean;
+        abortController: AbortController | null;
+        currentRequestId?: string;
+      },
+      _content: string,
+      _userMessageId: string,
+      onEvent: (msg: Record<string, unknown>) => void,
+    ): Promise<void> {
+      const assistantText = "Synthetic assistant reply";
+      const assistantMessage = createAssistantMessage(assistantText);
+      const assistantMetadata = {
+        ...provenanceFromTrustContext(this.trustContext as never),
+        ...(this.turnChannelContext
+          ? {
+              userMessageChannel: this.turnChannelContext.userMessageChannel,
+              assistantMessageChannel:
+                this.turnChannelContext.assistantMessageChannel,
+            }
+          : {}),
+        ...(this.turnInterfaceContext
+          ? {
+              userMessageInterface:
+                this.turnInterfaceContext.userMessageInterface,
+              assistantMessageInterface:
+                this.turnInterfaceContext.assistantMessageInterface,
+            }
+          : {}),
+      };
+
+      const persistedAssistant = await addMessage(
+        this.conversationId,
+        "assistant",
+        JSON.stringify(assistantMessage.content),
+        assistantMetadata,
+      );
+      this.messages.push(assistantMessage);
+
+      const conversationRow = getConversation(this.conversationId);
+      if (conversationRow) {
+        syncMessageToDisk(
+          this.conversationId,
+          persistedAssistant.id,
+          conversationRow.createdAt,
+        );
+      }
+
+      onEvent({
+        type: "assistant_text_delta",
+        text: assistantText,
+        conversationId: this.conversationId,
+      });
+      onEvent({
+        type: "message_complete",
+        conversationId: this.conversationId,
+      });
+
+      this.processing = false;
+      this.abortController = null;
+      this.currentRequestId = undefined;
+    },
+  };
+
+  return conversation as unknown as Conversation;
+}
+
+function getOrCreateFakeConversation(conversationId: string): Conversation {
+  const existing = conversationInstances.get(conversationId);
+  if (existing) return existing;
+  const created = createFakeConversation(conversationId);
+  conversationInstances.set(conversationId, created);
+  return created;
+}
+
+async function waitFor<T>(
+  getter: () => T | undefined,
+  timeoutMs = 3000,
+): Promise<T> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const value = getter();
+    if (value !== undefined) return value;
+    await Bun.sleep(20);
+  }
+  throw new Error("Timed out waiting for expected disk-view output");
+}
+
+beforeEach(() => {
+  resetTables();
+  resetConversationsDir();
+  conversationInstances.clear();
+});
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: true, force: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+describe("conversationKey send path disk-view regression", () => {
+  test("first send on a fresh conversationKey creates disk-view dir and writes user+assistant records", async () => {
+    const conversationKey = `fresh-conv-key-${crypto.randomUUID()}`;
+    const content = "Please persist this first turn.";
+
+    const response = await handleSendMessage(
+      new Request("http://localhost/v1/messages", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          conversationKey,
+          content,
+          sourceChannel: "vellum",
+          interface: "macos",
+        }),
+      }),
+      {
+        sendMessageDeps: {
+          getOrCreateConversation: async (conversationId: string) =>
+            getOrCreateFakeConversation(conversationId),
+          assistantEventHub: new AssistantEventHub(),
+          resolveAttachments: () => [],
+        },
+      },
+      authContext,
+    );
+
+    expect(response.status).toBe(202);
+    const body = (await response.json()) as {
+      accepted: boolean;
+      conversationId: string;
+      messageId: string;
+    };
+    expect(body.accepted).toBe(true);
+    expect(body.conversationId).toBeDefined();
+    expect(body.messageId).toBeDefined();
+
+    // Verify the real key store mapping is reused after the first send.
+    const mapping = getOrCreateConversationMapping(conversationKey);
+    expect(mapping.created).toBe(false);
+    expect(mapping.conversationId).toBe(body.conversationId);
+    expect(getConversationByKey(conversationKey)?.conversationId).toBe(
+      body.conversationId,
+    );
+
+    const conversationRow = getConversation(body.conversationId);
+    expect(conversationRow).not.toBeNull();
+    const conversationDir = getConversationDirPath(
+      body.conversationId,
+      conversationRow!.createdAt,
+    );
+    const metaPath = join(conversationDir, "meta.json");
+    const messagesPath = join(conversationDir, "messages.jsonl");
+
+    expect(existsSync(conversationDir)).toBe(true);
+    expect(existsSync(metaPath)).toBe(true);
+
+    const lines = await waitFor(() => {
+      if (!existsSync(messagesPath)) return undefined;
+      const raw = readFileSync(messagesPath, "utf-8").trim();
+      if (!raw) return undefined;
+      const parsed = raw
+        .split("\n")
+        .map((line) => JSON.parse(line) as { role: string; content?: string });
+      return parsed.length >= 2 ? parsed : undefined;
+    });
+
+    expect(lines[0]?.role).toBe("user");
+    expect(lines[0]?.content).toBe(content);
+    expect(lines[1]?.role).toBe("assistant");
+    expect(lines[1]?.content).toBe("Synthetic assistant reply");
+  });
+});

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -216,7 +216,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
     expect(runAgentLoop).toHaveBeenCalledTimes(0);
   });
 
-  test("passes undefined pendingRequestIds when no canonical hints are found", async () => {
+  test("passes empty pendingRequestIds array when no canonical hints are found", async () => {
     listPendingByDestinationMock.mockReturnValue([]);
     listCanonicalMock.mockReturnValue([]);
     routeGuardianReplyMock.mockResolvedValue({
@@ -279,7 +279,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
     expect(routeGuardianReplyMock).toHaveBeenCalledTimes(1);
     const routerCall = (routeGuardianReplyMock as any).mock
       .calls[0][0] as Record<string, unknown>;
-    expect(routerCall.pendingRequestIds).toBeUndefined();
+    expect(routerCall.pendingRequestIds).toEqual([]);
     expect(persistUserMessage).toHaveBeenCalledTimes(1);
     expect(runAgentLoop).toHaveBeenCalledTimes(1);
   });

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -2,7 +2,7 @@
  * Tests for slash command interception in the POST /v1/messages handler.
  *
  * Validates that:
- * - Built-in slash commands (/status, /model, /commands) are intercepted and
+ * - Built-in slash commands (/status, /models, /commands) are intercepted and
  *   do NOT trigger the agent loop.
  * - Regular messages pass through to the agent loop unchanged.
  */
@@ -122,12 +122,7 @@ mock.module("../daemon/conversation-process.js", () => ({
     configuredProviders: ["anthropic", "ollama"],
   }),
   isModelSlashCommand: (content: string) => {
-    const trimmed = content.trim();
-    return (
-      trimmed === "/model" ||
-      trimmed === "/models" ||
-      trimmed.startsWith("/model ")
-    );
+    return content.trim() === "/models";
   },
 }));
 

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -1065,9 +1065,24 @@ describe("buildTurnContextBlock (channel-only)", () => {
       },
       undefined,
     );
-    expect(block).toBe(
-      "<turn_context>\n" + "channel: telegram\n" + "</turn_context>",
+    expect(block).toContain("<turn_context>");
+    expect(block).toContain("channel: telegram");
+    expect(block).toContain("response_discretion:");
+    expect(block).toContain("</turn_context>");
+  });
+
+  test("omits response_discretion for vellum channel", () => {
+    const block = buildTurnContextBlock(
+      {
+        turnContext: {
+          userMessageChannel: "vellum",
+          assistantMessageChannel: "vellum",
+        },
+        conversationOriginChannel: "vellum",
+      },
+      undefined,
     );
+    expect(block).not.toContain("response_discretion:");
   });
 
   test('uses "unknown" when conversationOriginChannel is null', () => {

package/src/__tests__/conversation-skill-tools.test.ts

@@ -1779,14 +1779,9 @@ describe("bundled skill: claude-code", () => {
 
 const APP_BUILDER_TOOL_NAMES = [
   "app_create",
-  "app_list",
-  "app_query",
-  "app_update",
   "app_delete",
-  "app_file_list",
-  "app_file_read",
-  "app_file_edit",
-  "app_file_write",
+  "app_generate_icon",
+  "app_refresh",
 ] as const;
 
 describe("bundled skill: app-builder", () => {
@@ -1803,7 +1798,7 @@ describe("bundled skill: app-builder", () => {
     sessionState = new Map<string, string>();
   });
 
-  test("app-builder skill activation registers all 9 canonical non-proxy tools in allowedToolNames", () => {
+  test("app-builder skill activation registers all 4 canonical non-proxy tools in allowedToolNames", () => {
     mockCatalog = [
       makeSkill("app-builder", "/path/to/bundled-skills/app-builder"),
     ];
@@ -1862,7 +1857,7 @@ describe("bundled skill: app-builder", () => {
 
     const tools = mockRegisteredTools.get("app-builder");
     expect(tools).toBeDefined();
-    expect(tools!.length).toBe(9);
+    expect(tools!.length).toBe(4);
 
     // All tools should have skill origin metadata
     for (const tool of tools!) {

package/src/__tests__/conversation-slash-commands.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  resolveSlash,
+  type SlashContext,
+} from "../daemon/conversation-slash.js";
+
+function makeSlashContext(
+  overrides: Partial<SlashContext> = {},
+): SlashContext {
+  return {
+    messageCount: 4,
+    inputTokens: 1024,
+    outputTokens: 256,
+    maxInputTokens: 200000,
+    model: "claude-opus-4-6",
+    provider: "anthropic",
+    estimatedCost: 0.03,
+    ...overrides,
+  };
+}
+
+async function resolveCommandsLines(context?: SlashContext): Promise<string[]> {
+  const result = await resolveSlash("/commands", context);
+  expect(result.kind).toBe("unknown");
+  if (result.kind !== "unknown") {
+    throw new Error("Expected /commands to resolve to kind=unknown");
+  }
+  return result.message.split("\n");
+}
+
+describe("resolveSlash /commands interface-aware help", () => {
+  test("renders desktop command help for macOS", async () => {
+    const lines = await resolveCommandsLines(
+      makeSlashContext({ userMessageInterface: "macos" }),
+    );
+    expect(lines).toEqual([
+      "/commands — List all available commands",
+      "/models — List all available models",
+      "/status — Show conversation status and context usage",
+      "/btw — Ask a side question while the assistant is working",
+      "/fork — Fork the current conversation into a new branch",
+      "/pair — Generate pairing info for connecting a mobile device",
+    ]);
+    expect(lines).not.toContain(
+      "/model — Switch the active model",
+    );
+  });
+
+  test("renders iOS command help with /fork but without /pair", async () => {
+    const lines = await resolveCommandsLines(
+      makeSlashContext({ userMessageInterface: "ios" }),
+    );
+    expect(lines).toEqual([
+      "/commands — List all available commands",
+      "/models — List all available models",
+      "/status — Show conversation status and context usage",
+      "/btw — Ask a side question while the assistant is working",
+      "/fork — Fork the current conversation into a new branch",
+    ]);
+  });
+
+  test("renders explicit cli command help without /pair", async () => {
+    const lines = await resolveCommandsLines(
+      makeSlashContext({ userMessageInterface: "cli" }),
+    );
+    expect(lines).toEqual([
+      "/commands — List all available commands",
+      "/models — List all available models",
+      "/status — Show conversation status and context usage",
+      "/btw — Ask a side question while the assistant is working",
+    ]);
+  });
+
+  test("keeps legacy fallback help when no interface is provided", async () => {
+    const lines = await resolveCommandsLines(makeSlashContext());
+    expect(lines).toEqual([
+      "/commands — List all available commands",
+      "/models — List all available models",
+      "/pair — Generate pairing info for connecting a mobile device",
+      "/status — Show conversation status and context usage",
+    ]);
+  });
+
+  test("keeps context-free fallback without /status", async () => {
+    const lines = await resolveCommandsLines();
+    expect(lines).toEqual([
+      "/commands — List all available commands",
+      "/models — List all available models",
+      "/pair — Generate pairing info for connecting a mobile device",
+    ]);
+  });
+});
+
+describe("resolveSlash command contract", () => {
+  test("keeps unsupported slash forms as passthrough", async () => {
+    const slashForms = [
+      "/commands foo",
+      "/models foo",
+      "/status foo",
+      "/pair foo",
+      "/btw",
+    ];
+
+    for (const input of slashForms) {
+      const result = await resolveSlash(
+        input,
+        makeSlashContext({ userMessageInterface: "macos" }),
+      );
+      expect(result).toEqual({ kind: "passthrough", content: input });
+    }
+  });
+
+  test("rejects /pair on iOS interfaces", async () => {
+    const result = await resolveSlash(
+      "/pair",
+      makeSlashContext({ userMessageInterface: "ios" }),
+    );
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") {
+      throw new Error("Expected /pair on iOS to resolve to kind=unknown");
+    }
+    expect(result.message).toContain("only available in the macOS desktop app");
+  });
+
+  test("keeps /pair rejected for explicit non-macOS interfaces", async () => {
+    const result = await resolveSlash(
+      "/pair",
+      makeSlashContext({ userMessageInterface: "cli" }),
+    );
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") {
+      throw new Error("Expected /pair on cli to resolve to kind=unknown");
+    }
+    expect(result.message).toContain("only available in the macOS desktop app");
+  });
+
+  test("keeps /pair handling enabled on macOS interfaces", async () => {
+    const result = await resolveSlash(
+      "/pair",
+      makeSlashContext({ userMessageInterface: "macos" }),
+    );
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") {
+      throw new Error("Expected /pair on macOS to resolve to kind=unknown");
+    }
+    expect(result.message).toContain("Pairing is not available");
+  });
+});