@vellumai/assistant 0.8.0 → 0.8.2

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,
@@ -87,6 +90,12 @@ import {
   getOrCreateConversation,
 } from "../../memory/conversation-key-store.js";
 import { searchConversations } from "../../memory/conversation-queries.js";
+import { recordOnboardingEvent } from "../../memory/onboarding-events-store.js";
+import { buildSlackMessageDeepLinks } from "../../messaging/providers/slack/deep-link.js";
+import {
+  readSlackMetadataFromMessageMetadata,
+  type SlackMessageMetadata,
+} from "../../messaging/providers/slack/message-metadata.js";
 import { normalizeOnboardingContext } from "../../prompts/normalize-onboarding.js";
 import { writeOnboardingSection } from "../../prompts/persona-resolver.js";
 import { getConfiguredProvider } from "../../providers/provider-send-message.js";
@@ -98,7 +107,6 @@ import {
   getWorkspacePromptPath,
 } from "../../util/platform.js";
 import { silentlyWithLog } from "../../util/silently.js";
-import { buildAssistantEvent } from "../assistant-event.js";
 import { assistantEventHub, broadcastMessage } from "../assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import { routeGuardianReply } from "../guardian-reply-router.js";
@@ -111,6 +119,10 @@ import type {
 } from "../http-types.js";
 import { resolveLocalTrustContext } from "../local-actor-identity.js";
 import * as pendingInteractions from "../pending-interactions.js";
+import {
+  publishConversationListAndMetadataChanged,
+  publishConversationMessagesChanged,
+} from "../sync/resource-sync-events.js";
 import {
   resolveTrustContext,
   withSourceChannel,
@@ -135,6 +147,36 @@ function isValidRiskThreshold(value: unknown): value is RiskThreshold {
   );
 }
 
+function buildSlackHistoryMessage(
+  slackMeta: SlackMessageMetadata | null,
+): RuntimeMessagePayload["slackMessage"] | undefined {
+  if (!slackMeta) return undefined;
+
+  const slackConfig = getConfig().slack;
+  const messageLink = buildSlackMessageDeepLinks({
+    teamId: slackConfig?.teamId,
+    teamUrl: slackConfig?.teamUrl,
+    channelId: slackMeta.channelId,
+    messageTs: slackMeta.channelTs,
+  });
+  const threadLink = slackMeta.threadTs
+    ? buildSlackMessageDeepLinks({
+        teamId: slackConfig?.teamId,
+        teamUrl: slackConfig?.teamUrl,
+        channelId: slackMeta.channelId,
+        messageTs: slackMeta.threadTs,
+      })
+    : undefined;
+
+  return {
+    channelId: slackMeta.channelId,
+    channelTs: slackMeta.channelTs,
+    ...(slackMeta.threadTs ? { threadTs: slackMeta.threadTs } : {}),
+    ...(messageLink ? { messageLink } : {}),
+    ...(threadLink ? { threadLink } : {}),
+  };
+}
+
 function collectCanonicalGuardianRequestHintIds(
   conversationId: string,
   sourceChannel: string,
@@ -336,6 +378,7 @@ async function tryConsumeCanonicalGuardianReply(params: {
       });
       onEvent({ type: "message_complete", conversationId: conversationId });
     }
+    publishConversationMessagesChanged(conversationId);
   } catch (err) {
     log.warn(
       { err, conversationId },
@@ -503,6 +546,9 @@ export function handleListMessages(
               ...(typeof n.conversationId === "string"
                 ? { conversationId: n.conversationId }
                 : {}),
+              ...(typeof n.objective === "string"
+                ? { objective: n.objective }
+                : {}),
             };
           }
         }
@@ -510,6 +556,9 @@ export function handleListMessages(
         // Ignore malformed metadata
       }
     }
+    const slackMessage = buildSlackHistoryMessage(
+      readSlackMetadataFromMessageMetadata(msg.metadata),
+    );
 
     // Strip <no_response/> markers from assistant messages so web/API
     // clients never see the raw sentinel. Only assistant messages produce
@@ -549,6 +598,7 @@ export function handleListMessages(
         textSegments: filteredSegments,
         contentOrder: filteredContentOrder,
         surfaces: rendered.surfaces,
+        slackMessage,
         ...(rendered.thinkingSegments.length > 0
           ? { thinkingSegments: rendered.thinkingSegments }
           : {}),
@@ -567,6 +617,7 @@ export function handleListMessages(
       textSegments: rendered.textSegments,
       contentOrder: rendered.contentOrder,
       surfaces: rendered.surfaces,
+      slackMessage,
       ...(rendered.thinkingSegments.length > 0
         ? { thinkingSegments: rendered.thinkingSegments }
         : {}),
@@ -652,8 +703,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(),
@@ -669,6 +726,7 @@ export function handleListMessages(
       ...(m.subagentNotification
         ? { subagentNotification: m.subagentNotification }
         : {}),
+      ...(m.slackMessage ? { slackMessage: m.slackMessage } : {}),
     };
   });
 
@@ -999,6 +1057,7 @@ function mergeConsecutiveAssistantMessages(messages: MessageRow[]): {
   return { messages: result, mergedIdMap };
 }
 
+/**
 /**
  * Persist the pre-chat onboarding payload to disk.
  *
@@ -1107,6 +1166,8 @@ export async function handleSendMessage(
       tone: string;
       userName?: string;
       assistantName?: string;
+      googleConnected?: boolean;
+      googleScopes?: string[];
     };
   };
 
@@ -1237,6 +1298,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();
@@ -1274,16 +1344,10 @@ export async function handleSendMessage(
   // that other clients don't yet know about.
   if (mapping.conversationType === "standard") {
     if (!hasMessages(mapping.conversationId)) {
-      smDeps.assistantEventHub
-        .publish(
-          buildAssistantEvent({
-            type: "conversation_list_invalidated",
-            reason: "created",
-          }),
-        )
-        .catch((err) => {
-          log.warn({ err }, "Failed to publish conversation_list_invalidated");
-        });
+      publishConversationListAndMetadataChanged(
+        "created",
+        mapping.conversationId,
+      );
     }
   }
 
@@ -1391,7 +1455,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 +1464,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),
@@ -1490,6 +1554,18 @@ export async function handleSendMessage(
 
       if (isFirstOnboarding) {
         persistOnboardingArtifacts(body.onboarding!);
+        try {
+          recordOnboardingEvent({
+            screen: "complete",
+            tools: body.onboarding!.tools,
+            tasks: body.onboarding!.tasks,
+            tone: body.onboarding!.tone,
+            googleConnected: body.onboarding!.googleConnected,
+            googleScopes: body.onboarding!.googleScopes,
+          });
+        } catch (err) {
+          log.warn({ err }, "Failed to record onboarding telemetry event");
+        }
       }
 
       setTimeout(() => {
@@ -1506,6 +1582,7 @@ export async function handleSendMessage(
           conversationId,
         });
         broadcastMessage({ type: "message_complete", conversationId });
+        publishConversationMessagesChanged(conversationId);
         conversation.processing = false;
         silentlyWithLog(
           conversation.drainQueue(),
@@ -1531,6 +1608,18 @@ export async function handleSendMessage(
 
   if (isFirstOnboarding) {
     persistOnboardingArtifacts(body.onboarding!);
+    try {
+      recordOnboardingEvent({
+        screen: "complete",
+        tools: body.onboarding!.tools,
+        tasks: body.onboarding!.tasks,
+        tone: body.onboarding!.tone,
+        googleConnected: body.onboarding!.googleConnected,
+        googleScopes: body.onboarding!.googleScopes,
+      });
+    } catch (err) {
+      log.warn({ err }, "Failed to record onboarding telemetry event");
+    }
   }
 
   const attachments = hasAttachments
@@ -1809,6 +1898,7 @@ export async function handleSendMessage(
           type: "message_complete",
           conversationId: conversationId,
         });
+        publishConversationMessagesChanged(conversationId);
         conversation.processing = false;
         silentlyWithLog(conversation.drainQueue(), "slash-command queue drain");
       }, 0);
@@ -1850,6 +1940,7 @@ export async function handleSendMessage(
     // forceCompact() makes an LLM call that can exceed the client's
     // HTTP timeout on large contexts, causing a false "Failed to send".
     (async () => {
+      let assistantMessagePersisted = false;
       try {
         broadcastMessage({
           type: "user_message_echo",
@@ -1858,12 +1949,15 @@ export async function handleSendMessage(
           messageId: persisted.id,
           clientMessageId,
         });
+        publishConversationMessagesChanged(conversationId);
         conversation.emitActivityState(
           "thinking",
           "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);
@@ -1873,6 +1967,7 @@ export async function handleSendMessage(
           JSON.stringify(assistantMsg.content),
           channelMeta,
         );
+        assistantMessagePersisted = true;
         conversation.getMessages().push(assistantMsg);
 
         broadcastMessage({
@@ -1881,7 +1976,11 @@ export async function handleSendMessage(
           conversationId,
         });
         broadcastMessage({ type: "message_complete", conversationId });
+        publishConversationMessagesChanged(conversationId);
       } catch (err) {
+        if (assistantMessagePersisted) {
+          publishConversationMessagesChanged(conversationId);
+        }
         log.error({ err, conversationId }, "Compact command failed");
         broadcastMessage({
           type: "conversation_error",
@@ -1929,6 +2028,7 @@ export async function handleSendMessage(
     requestId,
     clientMessageId,
   });
+  publishConversationMessagesChanged(mapping.conversationId);
 
   // Fire-and-forget the agent loop; events flow to the hub via broadcastMessage.
   conversation
@@ -2003,7 +2103,7 @@ async function generateLlmSuggestion(
     systemPrompt,
     {
       config: {
-        callSite: "conversationStarters",
+        callSite: "replySuggestion",
         max_tokens: 60,
         stop_sequences: ["</reply>"],
         temperature: 0.7,
@@ -2132,7 +2232,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(),
+        }),
+      ),
+    }),
+  },
+];