@vellumai/assistant 0.7.3 → 0.8.1

package/src/runtime/routes/conversation-routes.ts

@@ -47,7 +47,10 @@ import {
 import { renderHistoryContent } from "../../daemon/handlers/shared.js";
 import { HostAppControlProxy } from "../../daemon/host-app-control-proxy.js";
 import { HostCuProxy } from "../../daemon/host-cu-proxy.js";
-import { preactivateHostProxySkills } from "../../daemon/host-proxy-preactivation.js";
+import {
+  preactivateHostProxySkills,
+  shouldAttachHostProxyForCapability,
+} from "../../daemon/host-proxy-preactivation.js";
 import type { ServerMessage } from "../../daemon/message-protocol.js";
 import type {
   HostProxyTransportMetadata,
@@ -652,8 +655,14 @@ export function handleListMessages(
     // on createdAt. The mismatch is benign — it may return slightly extra
     // data on a page boundary but never loses messages.
     const displayTimestamp = m.sentAt ?? m.timestamp;
+    const mergedMessageIds = mergedIdMap.get(m.id) ?? [];
+    const daemonMessageId =
+      m.role === "assistant"
+        ? (mergedMessageIds[mergedMessageIds.length - 1] ?? m.id)
+        : undefined;
     return {
       id: m.id ?? "",
+      ...(daemonMessageId ? { daemonMessageId } : {}),
       role: m.role,
       content: m.text,
       timestamp: new Date(displayTimestamp).toISOString(),
@@ -999,6 +1008,7 @@ function mergeConsecutiveAssistantMessages(messages: MessageRow[]): {
   return { messages: result, mergedIdMap };
 }
 
+/**
 /**
  * Persist the pre-chat onboarding payload to disk.
  *
@@ -1237,6 +1247,15 @@ export async function handleSendMessage(
     );
   }
 
+  // Reject the legacy "private" mode explicitly rather than silently coercing
+  // it to "standard" — clients that still populate this field expect privacy
+  // semantics that no longer exist.
+  if (body.conversationType === "private") {
+    throw new BadRequestError(
+      "Private conversations are no longer supported. Update your client to omit conversationType or send 'standard'.",
+    );
+  }
+
   // Desktop messages are always from the guardian — reset the heartbeat
   // timer so the next heartbeat is a full interval after this interaction.
   HeartbeatService.getInstance()?.resetTimer();
@@ -1391,7 +1410,7 @@ export async function handleSendMessage(
   // Bash/File/Transfer singletons are globally available via isAvailable() —
   // no per-conversation gating needed. CU is per-conversation (owns step
   // count, AX tree history, loop detection).
-  if (supportsHostProxy(sourceInterface, "host_cu")) {
+  if (shouldAttachHostProxyForCapability("host_cu", sourceInterface)) {
     if (!conversation.isProcessing() || !conversation.hostCuProxy) {
       conversation.setHostCuProxy(new HostCuProxy());
     }
@@ -1400,11 +1419,11 @@ export async function handleSendMessage(
   }
   // App-control mirrors CU's per-conversation lifecycle: the proxy owns a
   // singleton lock plus per-session loop tracking. Instantiation is
-  // unconditional when the client supports the capability — feature-flag
-  // gating lives in the skill-projection layer (which reads the
-  // `feature-flag: app-control` declaration in SKILL.md frontmatter), so
-  // an attached proxy is harmless when the flag resolves to off.
-  if (supportsHostProxy(sourceInterface, "host_app_control")) {
+  // unconditional when the capability is reachable — feature-flag gating
+  // lives in the skill-projection layer (which reads the `feature-flag:
+  // app-control` declaration in SKILL.md frontmatter), so an attached proxy
+  // is harmless when the flag resolves to off.
+  if (shouldAttachHostProxyForCapability("host_app_control", sourceInterface)) {
     if (!conversation.isProcessing() || !conversation.hostAppControlProxy) {
       conversation.setHostAppControlProxy(
         new HostAppControlProxy(mapping.conversationId),
@@ -1863,7 +1882,9 @@ export async function handleSendMessage(
           "context_compacting",
           "assistant_turn",
         );
-        const result = await conversation.forceCompact();
+        const result = await conversation.forceCompact({
+          targetInputTokensOverride: slashResult.targetInputTokensOverride,
+        });
         const responseText = formatCompactResult(result);
 
         const assistantMsg = createAssistantMessage(responseText);
@@ -2003,7 +2024,7 @@ async function generateLlmSuggestion(
     systemPrompt,
     {
       config: {
-        callSite: "conversationStarters",
+        callSite: "replySuggestion",
         max_tokens: 60,
         stop_sequences: ["</reply>"],
         temperature: 0.7,
@@ -2132,7 +2153,7 @@ export async function handleGetSuggestion(
     }
 
     // Try LLM suggestion using the configured provider
-    const provider = await getConfiguredProvider("conversationStarters");
+    const provider = await getConfiguredProvider("replySuggestion");
     if (provider) {
       try {
         // Deduplicate concurrent requests

package/src/runtime/routes/conversations-import-routes.ts

@@ -0,0 +1,229 @@
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getConfig } from "../../config/loader.js";
+import { addMessage, createConversation } from "../../memory/conversation-crud.js";
+import {
+  getConversationByKey,
+  setConversationKey,
+} from "../../memory/conversation-key-store.js";
+import { getDb } from "../../memory/db-connection.js";
+import { indexMessageNow } from "../../memory/indexer.js";
+import {
+  conversations as conversationsTable,
+  messages as messagesTable,
+} from "../../memory/schema.js";
+import { getLogger } from "../../util/logger.js";
+import { BadRequestError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+const log = getLogger("conversations-import-routes");
+
+// -- Types --
+
+interface ImportMessage {
+  role: string;
+  content: string | Array<{ type: string; text: string }>;
+  createdAt?: number;
+}
+
+interface ImportConversation {
+  sourceKey?: string;
+  title: string;
+  createdAt?: number;
+  updatedAt?: number;
+  messages: ImportMessage[];
+}
+
+interface ImportPayload {
+  conversations: ImportConversation[];
+}
+
+// -- Helpers (ported from CLI) --
+
+function resolveTimestamps(conv: ImportConversation): {
+  convCreatedAt: number;
+  convUpdatedAt: number;
+  messageTimestamps: number[];
+} {
+  const now = Date.now();
+  const convCreatedAt = conv.createdAt ?? now;
+  const convUpdatedAt = conv.updatedAt ?? conv.createdAt ?? now;
+  const messageTimestamps = conv.messages.map((msg, i) => {
+    if (msg.createdAt != null) return msg.createdAt;
+    return convCreatedAt + i;
+  });
+  return { convCreatedAt, convUpdatedAt, messageTimestamps };
+}
+
+// -- Handler --
+
+async function handleConversationsImport({ body }: RouteHandlerArgs) {
+  if (!body || !Array.isArray((body as Record<string, unknown>).conversations)) {
+    throw new BadRequestError("conversations array required");
+  }
+
+  const payload = body as unknown as ImportPayload;
+  const db = getDb();
+  const memoryConfig = getConfig().memory;
+
+  let imported = 0;
+  let skipped = 0;
+  let totalMessages = 0;
+  const errors: Array<{ index: number; sourceKey?: string; error: string }> = [];
+
+  for (let idx = 0; idx < payload.conversations.length; idx++) {
+    const conv = payload.conversations[idx];
+
+    if (!conv || typeof conv !== "object") {
+      errors.push({ index: idx, error: "invalid conversation entry" });
+      continue;
+    }
+
+    try {
+      // Dedup via sourceKey
+      if (conv.sourceKey) {
+        const existing = getConversationByKey(conv.sourceKey);
+        if (existing) {
+          skipped++;
+          continue;
+        }
+      }
+
+      const { convCreatedAt, convUpdatedAt, messageTimestamps } = resolveTimestamps(conv);
+
+      const conversation = createConversation(conv.title);
+
+      for (const msg of conv.messages) {
+        const contentStr =
+          typeof msg.content === "string"
+            ? msg.content
+            : JSON.stringify(msg.content);
+        await addMessage(conversation.id, msg.role, contentStr, undefined, {
+          skipIndexing: true,
+        });
+      }
+
+      // Override conversation timestamps
+      db.update(conversationsTable)
+        .set({
+          createdAt: convCreatedAt,
+          updatedAt: convUpdatedAt,
+          lastMessageAt: messageTimestamps[messageTimestamps.length - 1],
+        })
+        .where(eq(conversationsTable.id, conversation.id))
+        .run();
+
+      // Override message timestamps
+      const dbMessages = db
+        .select({ id: messagesTable.id })
+        .from(messagesTable)
+        .where(eq(messagesTable.conversationId, conversation.id))
+        .orderBy(messagesTable.createdAt)
+        .all();
+
+      for (let i = 0; i < dbMessages.length && i < messageTimestamps.length; i++) {
+        db.update(messagesTable)
+          .set({ createdAt: messageTimestamps[i] })
+          .where(eq(messagesTable.id, dbMessages[i].id))
+          .run();
+      }
+
+      // Index messages
+      for (let i = 0; i < dbMessages.length && i < conv.messages.length; i++) {
+        const msg = conv.messages[i];
+        const contentStr =
+          typeof msg.content === "string"
+            ? msg.content
+            : JSON.stringify(msg.content);
+        try {
+          await indexMessageNow(
+            {
+              messageId: dbMessages[i].id,
+              conversationId: conversation.id,
+              role: msg.role,
+              content: contentStr,
+              createdAt: messageTimestamps[i],
+            },
+            memoryConfig,
+          );
+        } catch (err) {
+          log.warn(
+            "Failed to index imported message %s in conversation %s: %s",
+            dbMessages[i].id,
+            conversation.id,
+            err instanceof Error ? err.message : String(err),
+          );
+        }
+      }
+
+      if (conv.sourceKey) {
+        setConversationKey(conv.sourceKey, conversation.id);
+      }
+
+      imported++;
+      totalMessages += conv.messages.length;
+    } catch (err) {
+      errors.push({
+        index: idx,
+        sourceKey: conv.sourceKey,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    imported,
+    skipped,
+    messages: totalMessages,
+    errors,
+  };
+}
+
+// -- Routes --
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "conversations_import",
+    endpoint: "conversations/import",
+    method: "POST",
+    handler: handleConversationsImport,
+    summary: "Import conversations",
+    description: "Import conversations from a standard JSON payload.",
+    tags: ["conversations"],
+    requestBody: z.object({
+      conversations: z.array(
+        z.object({
+          sourceKey: z.string().optional(),
+          title: z.string(),
+          createdAt: z.number().optional(),
+          updatedAt: z.number().optional(),
+          messages: z.array(
+            z.object({
+              role: z.string(),
+              content: z.union([
+                z.string(),
+                z.array(z.object({ type: z.string(), text: z.string() })),
+              ]),
+              createdAt: z.number().optional(),
+            }),
+          ),
+        }),
+      ),
+    }),
+    responseBody: z.object({
+      ok: z.boolean(),
+      imported: z.number(),
+      skipped: z.number(),
+      messages: z.number(),
+      errors: z.array(
+        z.object({
+          index: z.number(),
+          sourceKey: z.string().optional(),
+          error: z.string(),
+        }),
+      ),
+    }),
+  },
+];