@vellumai/assistant 0.8.5 → 0.8.6

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

@@ -7,6 +7,8 @@
  * GET    /v1/conversations/:id      — conversation detail
  */
 
+import { z } from "zod";
+
 import {
   type Confidence,
   getAttentionStateByConversationIds,
@@ -43,6 +45,112 @@ import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("conversation-list-routes");
 
+// ---------------------------------------------------------------------------
+// Response schemas
+// ---------------------------------------------------------------------------
+
+const channelIdSchema = z.enum([
+  "telegram",
+  "phone",
+  "vellum",
+  "whatsapp",
+  "slack",
+  "email",
+  "platform",
+  "a2a",
+]);
+
+const assistantAttentionSchema = z.object({
+  hasUnseenLatestAssistantMessage: z.boolean(),
+  latestAssistantMessageAt: z.number().optional(),
+  lastSeenAssistantMessageAt: z.number().optional(),
+  lastSeenConfidence: z.enum(["explicit", "inferred"]).optional(),
+  lastSeenSignalType: z
+    .enum([
+      "macos_notification_view",
+      "macos_conversation_opened",
+      "ios_conversation_opened",
+      "telegram_inbound_message",
+      "telegram_callback",
+      "slack_inbound_message",
+      "slack_callback",
+    ])
+    .optional(),
+});
+
+const slackThreadSchema = z.object({
+  channelId: z.string(),
+  threadTs: z.string(),
+  link: z
+    .object({
+      appUrl: z.string().optional(),
+      webUrl: z.string().optional(),
+    })
+    .optional(),
+});
+
+const slackChannelSchema = z.object({
+  channelId: z.string(),
+  name: z.string().optional(),
+  link: z.object({ webUrl: z.string() }).optional(),
+});
+
+const channelBindingSchema = z.object({
+  sourceChannel: z.string(),
+  externalChatId: z.string(),
+  externalChatName: z.string().optional(),
+  externalThreadId: z.string().optional(),
+  externalUserId: z.string().nullable(),
+  displayName: z.string().nullable(),
+  username: z.string().nullable(),
+  slackThread: slackThreadSchema.optional(),
+  slackChannel: slackChannelSchema.optional(),
+});
+
+const forkParentSchema = z.object({
+  conversationId: z.string(),
+  messageId: z.string(),
+  title: z.string(),
+});
+
+export const conversationSummarySchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  lastMessageAt: z.number().nullable(),
+  conversationType: z.enum(["standard", "background", "scheduled"]),
+  source: z.string(),
+  scheduleJobId: z.string().optional(),
+  channelBinding: channelBindingSchema.optional(),
+  conversationOriginChannel: channelIdSchema.nullable().optional(),
+  assistantAttention: assistantAttentionSchema.optional(),
+  isPinned: z.literal(true).optional(),
+  displayOrder: z.number().nullable().optional(),
+  groupId: z.string().nullable(),
+  forkParent: forkParentSchema.optional(),
+  archivedAt: z.number().optional(),
+  inferenceProfile: z.string().optional(),
+});
+
+const groupSummarySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  sortPosition: z.number(),
+  isSystemGroup: z.boolean(),
+});
+
+const listConversationsResponseSchema = z.object({
+  conversations: z.array(conversationSummarySchema),
+  nextOffset: z.number(),
+  hasMore: z.boolean(),
+  groups: z.array(groupSummarySchema).optional(),
+});
+
+const conversationDetailResponseSchema = z.object({
+  conversation: conversationSummarySchema,
+});
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -204,6 +312,29 @@ export const ROUTES: RouteDefinition[] = [
     description:
       "Paginated list of conversations with attention state and display metadata.",
     tags: ["conversations"],
+    queryParams: [
+      {
+        name: "limit",
+        type: "integer",
+        required: false,
+        description: "Maximum number of conversations to return (default 50).",
+      },
+      {
+        name: "offset",
+        type: "integer",
+        required: false,
+        description: "Number of conversations to skip (default 0).",
+      },
+      {
+        name: "conversationType",
+        type: "string",
+        required: false,
+        description:
+          'Filter by conversation type. Pass "background" to list only background/scheduled conversations.',
+        schema: { type: "string", enum: ["background"] },
+      },
+    ],
+    responseBody: listConversationsResponseSchema,
     handler: handleListConversations,
   },
   {
@@ -214,6 +345,17 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Record a seen signal",
     description: "Mark a conversation as seen, advancing the attention cursor.",
     tags: ["conversations"],
+    requestBody: z.object({
+      conversationId: z.string(),
+      sourceChannel: z.string().optional(),
+      signalType: z.string().optional(),
+      confidence: z.enum(["explicit", "inferred"]).optional(),
+      source: z.string().optional(),
+      evidenceText: z.string().optional(),
+      metadata: z.record(z.string(), z.unknown()).optional(),
+      observedAt: z.number().optional(),
+    }),
+    responseBody: z.object({ ok: z.boolean() }),
     handler: handleRecordSeen,
   },
   {
@@ -224,6 +366,10 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Mark conversation unread",
     description: "Reset the seen cursor so the conversation appears unread.",
     tags: ["conversations"],
+    requestBody: z.object({
+      conversationId: z.string(),
+    }),
+    responseBody: z.object({ ok: z.boolean() }),
     handler: handleMarkUnread,
   },
   {
@@ -234,6 +380,7 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Get conversation detail",
     description: "Retrieve a single conversation with full metadata.",
     tags: ["conversations"],
+    responseBody: conversationDetailResponseSchema,
     handler: handleGetConversation,
   },
 ];

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

@@ -28,6 +28,7 @@ import {
   undoLastMessage,
 } from "../../daemon/handlers/conversations.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
+import { stripConversationIds } from "../../home/feed-writer.js";
 import {
   archiveConversation,
   batchSetDisplayOrders,
@@ -54,6 +55,7 @@ import {
   publishConversationListChanged,
   publishConversationTitleChanged,
 } from "../sync/resource-sync-events.js";
+import { conversationSummarySchema } from "./conversation-list-routes.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
 import { setInferenceProfileSession } from "./inference-profile-session-handler.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -114,7 +116,10 @@ function handleCreateConversation({ body = {}, headers }: RouteHandlerArgs) {
   };
 }
 
-async function handleForkConversation({ body = {}, headers }: RouteHandlerArgs) {
+async function handleForkConversation({
+  body = {},
+  headers,
+}: RouteHandlerArgs) {
   const conversationId = body.conversationId as string | undefined;
   if (!conversationId || typeof conversationId !== "string") {
     throw new BadRequestError("Missing conversationId");
@@ -223,9 +228,7 @@ function handleRenameConversation({
   return { ok: true };
 }
 
-async function handleClearAllConversations({
-  headers = {},
-}: RouteHandlerArgs) {
+async function handleClearAllConversations({ headers = {} }: RouteHandlerArgs) {
   const confirm = headers["x-confirm-destructive"];
   if (confirm !== "clear-all-conversations") {
     throw new BadRequestError(
@@ -241,7 +244,10 @@ async function handleClearAllConversations({
   return undefined;
 }
 
-function handleWipeConversation({ pathParams = {}, headers }: RouteHandlerArgs) {
+function handleWipeConversation({
+  pathParams = {},
+  headers,
+}: RouteHandlerArgs) {
   const resolvedId = resolveOrThrow(pathParams.id!);
 
   cancelScheduleIfLast(resolvedId);
@@ -273,6 +279,9 @@ function handleWipeConversation({ pathParams = {}, headers }: RouteHandlerArgs)
     resolvedId,
     headers?.["x-vellum-client-id"]?.trim() || undefined,
   );
+
+  void stripConversationIds(resolvedId);
+
   return {
     wiped: true,
     unsupersededItems: 0,
@@ -311,6 +320,8 @@ function handleDeleteConversation({
     headers?.["x-vellum-client-id"]?.trim() || undefined,
   );
 
+  void stripConversationIds(resolvedId);
+
   return undefined;
 }
 
@@ -400,7 +411,7 @@ function handleReorderConversations({ body = {}, headers }: RouteHandlerArgs) {
     updates.map((u) => ({
       id: u.conversationId,
       displayOrder: u.displayOrder ?? null,
-      isPinned: u.isPinned ?? false,
+      isPinned: u.isPinned,
       groupId: u.groupId,
     })),
   );
@@ -445,9 +456,7 @@ export const ROUTES: RouteDefinition[] = [
         ),
       conversationKey: z
         .string()
-        .describe(
-          "Echo of the optional external key supplied by the client.",
-        ),
+        .describe("Echo of the optional external key supplied by the client."),
       conversationType: z.string(),
       created: z.boolean(),
     }),
@@ -469,6 +478,9 @@ export const ROUTES: RouteDefinition[] = [
         .describe("Truncate the fork at this message")
         .optional(),
     }),
+    responseBody: z.object({
+      conversation: conversationSummarySchema,
+    }),
     handler: handleForkConversation,
   },
   {
@@ -538,6 +550,7 @@ export const ROUTES: RouteDefinition[] = [
     requestBody: z.object({
       name: z.string(),
     }),
+    responseBody: z.object({ ok: z.boolean() }),
     handler: handleRenameConversation,
   },
   {
@@ -590,6 +603,10 @@ export const ROUTES: RouteDefinition[] = [
     description: "Move a conversation to the archived state.",
     tags: ["conversations"],
     pathParams: [{ name: "id", type: "uuid" }],
+    responseBody: z.object({
+      ok: z.boolean(),
+      conversationId: z.string(),
+    }),
     handler: handleArchiveConversation,
   },
   {
@@ -602,6 +619,10 @@ export const ROUTES: RouteDefinition[] = [
       "Restore an archived conversation back to the default sidebar.",
     tags: ["conversations"],
     pathParams: [{ name: "id", type: "uuid" }],
+    responseBody: z.object({
+      ok: z.boolean(),
+      conversationId: z.string(),
+    }),
     handler: handleUnarchiveConversation,
   },
   {
@@ -659,12 +680,16 @@ export const ROUTES: RouteDefinition[] = [
     description: "Batch-update display order and pin state for conversations.",
     tags: ["conversations"],
     requestBody: z.object({
-      updates: z
-        .array(z.unknown())
-        .describe(
-          "Array of { conversationId, displayOrder?, isPinned? } objects",
-        ),
+      updates: z.array(
+        z.object({
+          conversationId: z.string(),
+          displayOrder: z.number().optional(),
+          isPinned: z.boolean().optional(),
+          groupId: z.string().nullable().optional(),
+        }),
+      ),
     }),
+    responseBody: z.object({ ok: z.boolean() }),
     handler: handleReorderConversations,
   },
 ];

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

@@ -67,7 +67,7 @@ import { getConversationByKey } from "../../memory/conversation-key-store.js";
 import { getDb } from "../../memory/db-connection.js";
 import { clearEmbeddingBackendCache } from "../../memory/embedding-backend.js";
 import { getLlmRequestLogSource } from "../../memory/llm-request-log-source.js";
-import type { LogRow } from "../../memory/llm-request-log-store.js";
+import { type LogRow } from "../../memory/llm-request-log-store.js";
 import { getMemoryRecallLogByMessageIds } from "../../memory/memory-recall-log-store.js";
 import { getMemoryV2ActivationLogByMessageIds } from "../../memory/memory-v2-activation-log-store.js";
 import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../../memory/v2/constants.js";
@@ -239,6 +239,7 @@ function normalizeLlmContextLog(log: LogRow): LlmContextRouteResult & {
   responsePayload: null;
   createdAt: number;
   agentLoopExitReason: string | null;
+  callSite: string | null;
 } {
   let requestPayload: unknown;
   try {
@@ -257,7 +258,10 @@ function normalizeLlmContextLog(log: LogRow): LlmContextRouteResult & {
     responsePayload,
     createdAt: log.createdAt,
   });
-  const result = applyStoredProviderToLlmContextResult(normalized, log.provider);
+  const result = applyStoredProviderToLlmContextResult(
+    normalized,
+    log.provider,
+  );
   return {
     id: log.id,
     requestPayload: null,
@@ -269,6 +273,12 @@ function normalizeLlmContextLog(log: LogRow): LlmContextRouteResult & {
     // terminal call in each loop iteration carries a value; non-terminal calls
     // land here as `null`.
     agentLoopExitReason: log.agentLoopExitReason ?? null,
+    // Logical call site (`mainAgent`, `compactionAgent`,
+    // `syntheticAgentErrorMessage`, …). Exposed to the inspector so synthetic
+    // rows can be rendered distinctly without re-deriving the kind from
+    // other fields — the frontend branches on this value alone, and the
+    // existing `agent_loop_exit_reason` column tells it WHICH error fired.
+    callSite: log.callSite ?? null,
     ...result,
   };
 }
@@ -700,15 +710,57 @@ async function handleReplaceInferenceProfile({
       );
     }
   }
-  // When the UI sends provider but no provider_connection ("Any active X
-  // connection"), derive the connection now so the config deep-merge doesn't
-  // inherit a stale connection from the default layer.
+  // Mix profiles reference other profiles by name. `ProfileEntry.safeParse`
+  // above validates the fragment in isolation, so the cross-profile integrity
+  // rules `LLMSchema.superRefine` enforces on full-config load (every arm
+  // exists, no nesting, no self-reference, no config fields) must be checked
+  // here against the live profile set — otherwise an invalid mix would persist
+  // and break the next full config reparse.
+  if (parsed.data.mix != null) {
+    const MIX_ALLOWED_KEYS = new Set([
+      "mix",
+      "label",
+      "description",
+      "status",
+      "source",
+    ]);
+    const extraneous = Object.keys(parsed.data).filter(
+      (k) => !MIX_ALLOWED_KEYS.has(k),
+    );
+    if (extraneous.length > 0) {
+      throw new BadRequestError(
+        `Mix profile "${name}" cannot also set [${extraneous.join(", ")}] — a mix only references other profiles plus metadata (label, description, status).`,
+      );
+    }
+    const existingProfiles = getConfig().llm.profiles ?? {};
+    parsed.data.mix.forEach((arm, index) => {
+      if (arm.profile === name) {
+        throw new BadRequestError(
+          `Mix profile "${name}" cannot reference itself (arm ${index}).`,
+        );
+      }
+      const target = existingProfiles[arm.profile];
+      if (target == null) {
+        throw new BadRequestError(
+          `Mix profile "${name}" references profile "${arm.profile}" which is not defined.`,
+        );
+      }
+      if (target.mix != null) {
+        throw new BadRequestError(
+          `Mix profile "${name}" references another mix profile "${arm.profile}" — mixes cannot be nested; constituents must be standard profiles.`,
+        );
+      }
+    });
+  }
+
+  // When the UI sends provider but no provider_connection, derive the connection
+  // now so the config deep-merge doesn't inherit a stale connection from the
+  // default layer.
   const fragment = parsed.data as Record<string, unknown>;
   if (!isManaged && fragment.provider && !fragment.provider_connection) {
     const provider = fragment.provider as string;
     const db = getDb();
-    const candidates = listConnections(db, { provider });
-    const active = candidates.find((c) => c.status === "active");
+    const [active] = listConnections(db, { provider });
     if (active) {
       fragment.provider_connection = active.name;
     } else if (!PROVIDERS_REQUIRING_BASE_URL_AND_MODELS.has(provider)) {
@@ -1002,9 +1054,7 @@ function handleSteerToMessage({
       ? (body as Record<string, unknown>).conversationId
       : undefined);
   if (!conversationId || typeof conversationId !== "string") {
-    throw new BadRequestError(
-      "Missing required parameter: conversationId",
-    );
+    throw new BadRequestError("Missing required parameter: conversationId");
   }
   const result = steerToMessage(conversationId, pathParams.id ?? "");
   if (result.steered) {