@vellumai/assistant 0.8.3 → 0.8.5

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

@@ -11,6 +11,7 @@ import { z } from "zod";
 
 import { clearAllConversations as clearAllActive } from "../../daemon/handlers/conversations.js";
 import { formatJson, formatMarkdown } from "../../export/formatter.js";
+import { ipcCall as ipcCallGateway } from "../../ipc/gateway-client.js";
 import {
   addMessage,
   createConversation,
@@ -19,8 +20,10 @@ import {
 } from "../../memory/conversation-crud.js";
 import { setConversationKey } from "../../memory/conversation-key-store.js";
 import { listConversations } from "../../memory/conversation-queries.js";
+import { getBindingByConversation } from "../../memory/external-conversation-store.js";
+import { sendSlackReply } from "../../messaging/providers/slack/send.js";
 import { getLogger } from "../../util/logger.js";
-import { BadRequestError, NotFoundError } from "./errors.js";
+import { BadGatewayError, BadRequestError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("conversation-cli-routes");
@@ -142,7 +145,7 @@ function handleExportCli({ body = {} }: RouteHandlerArgs) {
 
 async function handleClearCli(_args: RouteHandlerArgs) {
   // Tear down in-memory conversation state before DB clear.
-  const cleared = clearAllActive();
+  const cleared = await clearAllActive();
   log.info(
     { cleared },
     "CLI conversations clear: active conversations torn down",
@@ -150,6 +153,136 @@ async function handleClearCli(_args: RouteHandlerArgs) {
   return { cleared };
 }
 
+// ---------------------------------------------------------------------------
+// slack detach (CLI)
+// ---------------------------------------------------------------------------
+
+const slackDetachRequestSchema = z.object({
+  conversationId: z.string().trim().min(1).optional(),
+  channelId: z.string().trim().min(1).optional(),
+  threadTs: z.string().trim().min(1).optional(),
+});
+
+const slackDetachResponseSchema = z.object({
+  detached: z.boolean(),
+  channelId: z.string(),
+  threadTs: z.string(),
+  source: z.enum(["explicit", "conversation_binding"]),
+  conversationId: z.string().optional(),
+});
+
+type SlackDetachGatewayResponse = {
+  detached: boolean;
+  channelId: string;
+  threadTs: string;
+};
+
+const SLACK_DETACH_CONFIRMATION_TEXT =
+  "Muted this Slack thread. I won't respond to further replies here unless you mention me again.";
+
+function isSlackDetachGatewayResponse(
+  value: unknown,
+): value is SlackDetachGatewayResponse {
+  return (
+    value != null &&
+    typeof value === "object" &&
+    typeof (value as SlackDetachGatewayResponse).detached === "boolean" &&
+    typeof (value as SlackDetachGatewayResponse).channelId === "string" &&
+    typeof (value as SlackDetachGatewayResponse).threadTs === "string"
+  );
+}
+
+async function handleSlackDetachCli({ body = {} }: RouteHandlerArgs) {
+  const parsed = slackDetachRequestSchema.parse(body);
+  const explicitChannelId = parsed.channelId;
+  const explicitThreadTs = parsed.threadTs;
+
+  let channelId: string;
+  let threadTs: string;
+  let source: "explicit" | "conversation_binding";
+  let conversationId: string | undefined;
+
+  if (explicitChannelId || explicitThreadTs) {
+    if (!explicitChannelId || !explicitThreadTs) {
+      throw new BadRequestError(
+        "Both channelId and threadTs are required when detaching by explicit Slack identifiers",
+      );
+    }
+    channelId = explicitChannelId;
+    threadTs = explicitThreadTs;
+    source = "explicit";
+  } else {
+    if (!parsed.conversationId) {
+      throw new BadRequestError(
+        "conversationId is required unless channelId and threadTs are provided",
+      );
+    }
+
+    const binding = getBindingByConversation(parsed.conversationId);
+    if (!binding) {
+      throw new NotFoundError(
+        `No channel binding found for conversation ${parsed.conversationId}`,
+      );
+    }
+    if (binding.sourceChannel !== "slack") {
+      throw new BadRequestError(
+        `Conversation ${parsed.conversationId} is bound to ${binding.sourceChannel}, not Slack`,
+      );
+    }
+    if (!binding.externalThreadId) {
+      throw new BadRequestError(
+        `Conversation ${parsed.conversationId} is not bound to a Slack thread`,
+      );
+    }
+
+    channelId = binding.externalChatId;
+    threadTs = binding.externalThreadId;
+    source = "conversation_binding";
+    conversationId = parsed.conversationId;
+  }
+
+  const gatewayResult = await ipcCallGateway(
+    "detach_slack_active_thread",
+    { channelId, threadTs },
+    5_000,
+  );
+  if (!isSlackDetachGatewayResponse(gatewayResult)) {
+    throw new BadGatewayError(
+      "Could not detach Slack thread from assistant listening",
+    );
+  }
+
+  if (gatewayResult.detached) {
+    try {
+      await sendSlackReply(
+        gatewayResult.channelId,
+        SLACK_DETACH_CONFIRMATION_TEXT,
+        { threadTs: gatewayResult.threadTs },
+      );
+    } catch (err) {
+      log.warn(
+        {
+          err,
+          channelId: gatewayResult.channelId,
+          threadTs: gatewayResult.threadTs,
+        },
+        "Slack thread detached, but confirmation message failed",
+      );
+      throw new BadGatewayError(
+        "Detached Slack thread but could not send confirmation",
+      );
+    }
+  }
+
+  return {
+    detached: gatewayResult.detached,
+    channelId: gatewayResult.channelId,
+    threadTs: gatewayResult.threadTs,
+    source,
+    ...(conversationId ? { conversationId } : {}),
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------
@@ -230,4 +363,16 @@ export const ROUTES: RouteDefinition[] = [
     }),
     handler: handleClearCli,
   },
+  {
+    operationId: "conversation_slack_detach_cli",
+    endpoint: "conversations/cli/slack/detach",
+    method: "POST",
+    summary: "Detach the assistant from a Slack thread (CLI)",
+    description:
+      "Stops Slack active-thread listening for a Slack thread. The CLI resolves current conversation defaults.",
+    tags: ["conversations"],
+    requestBody: slackDetachRequestSchema,
+    responseBody: slackDetachResponseSchema,
+    handler: handleSlackDetachCli,
+  },
 ];

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

@@ -111,7 +111,7 @@ function handleListConversations({ queryParams = {} }: RouteHandlerArgs) {
   return response;
 }
 
-function handleRecordSeen({ body = {} }: RouteHandlerArgs) {
+function handleRecordSeen({ body = {}, headers }: RouteHandlerArgs) {
   const rawConversationId = body.conversationId as string | undefined;
   if (!rawConversationId) {
     throw new BadRequestError("Missing conversationId");
@@ -142,7 +142,11 @@ function handleRecordSeen({ body = {} }: RouteHandlerArgs) {
     });
 
     if (wasUnseen) {
-      publishConversationListAndMetadataChanged("seen_changed", conversationId);
+      publishConversationListAndMetadataChanged(
+        "seen_changed",
+        conversationId,
+        headers?.["x-vellum-client-id"]?.trim() || undefined,
+      );
     }
 
     return { ok: true };
@@ -152,7 +156,7 @@ function handleRecordSeen({ body = {} }: RouteHandlerArgs) {
   }
 }
 
-function handleMarkUnread({ body = {} }: RouteHandlerArgs) {
+function handleMarkUnread({ body = {}, headers }: RouteHandlerArgs) {
   const rawConversationId = body.conversationId as string | undefined;
   if (!rawConversationId) {
     throw new BadRequestError("Missing conversationId");
@@ -162,7 +166,11 @@ function handleMarkUnread({ body = {} }: RouteHandlerArgs) {
   try {
     const changed = markConversationUnread(conversationId);
     if (changed) {
-      publishConversationListAndMetadataChanged("seen_changed", conversationId);
+      publishConversationListAndMetadataChanged(
+        "seen_changed",
+        conversationId,
+        headers?.["x-vellum-client-id"]?.trim() || undefined,
+      );
     }
     return { ok: true };
   } catch (err) {

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

@@ -84,7 +84,7 @@ function cancelScheduleIfLast(conversationId: string): void {
 // Handlers
 // ---------------------------------------------------------------------------
 
-function handleCreateConversation({ body = {} }: RouteHandlerArgs) {
+function handleCreateConversation({ body = {}, headers }: RouteHandlerArgs) {
   const conversationKey =
     (body.conversationKey as string | undefined) ?? crypto.randomUUID();
   const result = getOrCreateConversation(conversationKey, {
@@ -92,7 +92,11 @@ function handleCreateConversation({ body = {} }: RouteHandlerArgs) {
   });
   if (result.created) {
     updateConversationTitle(result.conversationId, "New Conversation");
-    publishConversationListAndMetadataChanged("created", result.conversationId);
+    publishConversationListAndMetadataChanged(
+      "created",
+      result.conversationId,
+      headers?.["x-vellum-client-id"]?.trim() || undefined,
+    );
   }
   log.info(
     {
@@ -110,7 +114,7 @@ function handleCreateConversation({ body = {} }: RouteHandlerArgs) {
   };
 }
 
-async function handleForkConversation({ body = {} }: RouteHandlerArgs) {
+async function handleForkConversation({ body = {}, headers }: RouteHandlerArgs) {
   const conversationId = body.conversationId as string | undefined;
   if (!conversationId || typeof conversationId !== "string") {
     throw new BadRequestError("Missing conversationId");
@@ -136,7 +140,11 @@ async function handleForkConversation({ body = {} }: RouteHandlerArgs) {
         `Forked conversation ${forkedConversation.id} could not be loaded`,
       );
     }
-    publishConversationListAndMetadataChanged("created", forkedConversation.id);
+    publishConversationListAndMetadataChanged(
+      "created",
+      forkedConversation.id,
+      headers?.["x-vellum-client-id"]?.trim() || undefined,
+    );
     return { conversation: detail.conversation };
   } catch (err) {
     if (err instanceof UserError) {
@@ -171,6 +179,7 @@ async function handleSwitchConversation({ body = {} }: RouteHandlerArgs) {
 async function handleSetInferenceProfile({
   pathParams = {},
   body = {},
+  headers,
 }: RouteHandlerArgs) {
   if (
     body.profile !== null &&
@@ -184,6 +193,7 @@ async function handleSetInferenceProfile({
     profile: body.profile as string | null,
     ttlSeconds: body.ttlSeconds as number | null | undefined,
     sessionId: body.sessionId as string | undefined,
+    originClientId: headers?.["x-vellum-client-id"]?.trim() || undefined,
   });
 
   return result;
@@ -192,6 +202,7 @@ async function handleSetInferenceProfile({
 function handleRenameConversation({
   pathParams = {},
   body = {},
+  headers,
 }: RouteHandlerArgs) {
   const name = body.name as string | undefined;
   if (!name || typeof name !== "string") {
@@ -203,12 +214,18 @@ function handleRenameConversation({
   }
   updateConversationTitle(pathParams.id!, name, 0);
 
-  publishConversationTitleChanged(pathParams.id!, name);
+  publishConversationTitleChanged(
+    pathParams.id!,
+    name,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
 
   return { ok: true };
 }
 
-function handleClearAllConversations({ headers = {} }: RouteHandlerArgs) {
+async function handleClearAllConversations({
+  headers = {},
+}: RouteHandlerArgs) {
   const confirm = headers["x-confirm-destructive"];
   if (confirm !== "clear-all-conversations") {
     throw new BadRequestError(
@@ -216,12 +233,15 @@ function handleClearAllConversations({ headers = {} }: RouteHandlerArgs) {
         "To confirm, set header X-Confirm-Destructive: clear-all-conversations",
     );
   }
-  clearAllConversations();
-  publishConversationListChanged("deleted");
+  await clearAllConversations();
+  publishConversationListChanged(
+    "deleted",
+    headers["x-vellum-client-id"]?.trim() || undefined,
+  );
   return undefined;
 }
 
-function handleWipeConversation({ pathParams = {} }: RouteHandlerArgs) {
+function handleWipeConversation({ pathParams = {}, headers }: RouteHandlerArgs) {
   const resolvedId = resolveOrThrow(pathParams.id!);
 
   cancelScheduleIfLast(resolvedId);
@@ -248,7 +268,11 @@ function handleWipeConversation({ pathParams = {} }: RouteHandlerArgs) {
     },
     "Wiped conversation and reverted memory changes",
   );
-  publishConversationListAndMetadataChanged("deleted", resolvedId);
+  publishConversationListAndMetadataChanged(
+    "deleted",
+    resolvedId,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return {
     wiped: true,
     unsupersededItems: 0,
@@ -257,7 +281,10 @@ function handleWipeConversation({ pathParams = {} }: RouteHandlerArgs) {
   };
 }
 
-function handleDeleteConversation({ pathParams = {} }: RouteHandlerArgs) {
+function handleDeleteConversation({
+  pathParams = {},
+  headers,
+}: RouteHandlerArgs) {
   const resolvedId = resolveOrThrow(pathParams.id!);
 
   cancelScheduleIfLast(resolvedId);
@@ -278,28 +305,46 @@ function handleDeleteConversation({ pathParams = {} }: RouteHandlerArgs) {
   }
   log.info({ conversationId: resolvedId }, "Deleted conversation");
 
-  publishConversationListAndMetadataChanged("deleted", resolvedId);
+  publishConversationListAndMetadataChanged(
+    "deleted",
+    resolvedId,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
 
   return undefined;
 }
 
-function handleArchiveConversation({ pathParams = {} }: RouteHandlerArgs) {
+function handleArchiveConversation({
+  pathParams = {},
+  headers,
+}: RouteHandlerArgs) {
   const resolvedId = resolveOrThrow(pathParams.id!);
   const archived = archiveConversation(resolvedId);
   if (!archived) {
     throw new NotFoundError(`Conversation ${pathParams.id} not found`);
   }
-  publishConversationListAndMetadataChanged("reordered", resolvedId);
+  publishConversationListAndMetadataChanged(
+    "reordered",
+    resolvedId,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return { ok: true, conversationId: resolvedId };
 }
 
-function handleUnarchiveConversation({ pathParams = {} }: RouteHandlerArgs) {
+function handleUnarchiveConversation({
+  pathParams = {},
+  headers,
+}: RouteHandlerArgs) {
   const resolvedId = resolveOrThrow(pathParams.id!);
   const unarchived = unarchiveConversation(resolvedId);
   if (!unarchived) {
     throw new NotFoundError(`Conversation ${pathParams.id} not found`);
   }
-  publishConversationListAndMetadataChanged("reordered", resolvedId);
+  publishConversationListAndMetadataChanged(
+    "reordered",
+    resolvedId,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return { ok: true, conversationId: resolvedId };
 }
 
@@ -339,7 +384,7 @@ async function handleRegenerateResponse({ pathParams = {} }: RouteHandlerArgs) {
   }
 }
 
-function handleReorderConversations({ body = {} }: RouteHandlerArgs) {
+function handleReorderConversations({ body = {}, headers }: RouteHandlerArgs) {
   const updates = body.updates as
     | Array<{
         conversationId: string;
@@ -362,6 +407,7 @@ function handleReorderConversations({ body = {} }: RouteHandlerArgs) {
   publishConversationListAndMetadataChanged(
     "reordered",
     updates.map((u) => u.conversationId),
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
   );
   return { ok: true };
 }
@@ -382,15 +428,26 @@ export const ROUTES: RouteDefinition[] = [
     requestBody: z.object({
       conversationKey: z
         .string()
-        .describe("Idempotency key for the conversation"),
+        .optional()
+        .describe(
+          "Optional external key. Echoed back in the response. Non-vellum channels (Telegram, WhatsApp) use this to scope to a logical channel thread; vellum-web clients can omit it and rely on the assistant-minted `id`.",
+        ),
       conversationType: z
         .literal("standard")
         .optional()
         .describe("Only standard conversations are created by this endpoint"),
     }),
     responseBody: z.object({
-      id: z.string(),
-      conversationKey: z.string(),
+      id: z
+        .string()
+        .describe(
+          "Assistant-minted internal conversation id. The authoritative identifier for the conversation.",
+        ),
+      conversationKey: z
+        .string()
+        .describe(
+          "Echo of the optional external key supplied by the client.",
+        ),
       conversationType: z.string(),
       created: z.boolean(),
     }),