@vellumai/assistant 0.5.1 → 0.5.3

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

@@ -1,7 +1,7 @@
 /**
  * Route handlers for attachment upload, download, and deletion.
  */
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 
 import * as attachmentsStore from "../../memory/attachments-store.js";
 import {
@@ -29,9 +29,10 @@ export async function handleUploadAttachment(req: Request): Promise<Response> {
     filename?: string;
     mimeType?: string;
     data?: string;
+    filePath?: string;
   };
 
-  const { filename, mimeType, data } = body;
+  const { filename, mimeType, data, filePath } = body;
 
   if (!filename || typeof filename !== "string") {
     return httpError("BAD_REQUEST", "filename is required", 400);
@@ -41,24 +42,49 @@ export async function handleUploadAttachment(req: Request): Promise<Response> {
     return httpError("BAD_REQUEST", "mimeType is required", 400);
   }
 
-  if (!data || typeof data !== "string") {
-    return httpError("BAD_REQUEST", "data (base64) is required", 400);
-  }
-
   const validation = validateAttachmentUpload(filename, mimeType);
   if (!validation.ok) {
     return httpError("UNPROCESSABLE_ENTITY", validation.error, 415);
   }
 
   let attachment: attachmentsStore.StoredAttachment;
-  try {
-    attachment = attachmentsStore.uploadAttachment(filename, mimeType, data);
-  } catch (err) {
-    if (err instanceof AttachmentUploadError) {
-      const status = err.message.startsWith("Attachment too large") ? 413 : 400;
-      return httpError("BAD_REQUEST", err.message, status);
+
+  // File-backed upload: when filePath is provided and data is empty/missing,
+  // register the attachment by path reference instead of requiring base64 data.
+  // This supports retry of file-backed attachments (e.g. recordings) where the
+  // client no longer holds the inline data but the file still exists on disk.
+  if (filePath && typeof filePath === "string" && (!data || data === "")) {
+    if (!existsSync(filePath)) {
+      return httpError("BAD_REQUEST", "filePath does not exist on disk", 400);
+    }
+    const sizeBytes = statSync(filePath).size;
+    attachment = attachmentsStore.uploadFileBackedAttachment(
+      filename,
+      mimeType,
+      filePath,
+      sizeBytes,
+    );
+  } else {
+    if (!data || typeof data !== "string") {
+      return httpError("BAD_REQUEST", "data (base64) is required", 400);
+    }
+
+    try {
+      attachment = attachmentsStore.uploadAttachment(
+        filename,
+        mimeType,
+        data,
+        filePath ?? undefined,
+      );
+    } catch (err) {
+      if (err instanceof AttachmentUploadError) {
+        const status = err.message.startsWith("Attachment too large")
+          ? 413
+          : 400;
+        return httpError("BAD_REQUEST", err.message, status);
+      }
+      throw err;
     }
-    throw err;
   }
 
   return Response.json({
@@ -102,7 +128,9 @@ export async function handleDeleteAttachment(req: Request): Promise<Response> {
 }
 
 function handleGetAttachment(attachmentId: string): Response {
-  const attachment = attachmentsStore.getAttachmentById(attachmentId);
+  const attachment = attachmentsStore.getAttachmentById(attachmentId, {
+    hydrateFileData: true,
+  });
   if (!attachment) {
     return httpError("NOT_FOUND", "Attachment not found", 404);
   }
@@ -132,7 +160,9 @@ export function handleGetAttachmentContent(
   attachmentId: string,
   req: Request,
 ): Response {
-  const attachment = attachmentsStore.getAttachmentById(attachmentId);
+  const attachment = attachmentsStore.getAttachmentById(attachmentId, {
+    hydrateFileData: true,
+  });
   if (!attachment) {
     return httpError("NOT_FOUND", "Attachment not found", 404);
   }

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

@@ -14,17 +14,12 @@
 
 import { existsSync, readFileSync } from "node:fs";
 
-import { buildToolDefinitions } from "../../daemon/conversation-tool-setup.js";
 import { getConversationByKey } from "../../memory/conversation-key-store.js";
-import { buildSystemPrompt } from "../../prompts/system-prompt.js";
-import {
-  createTimeout,
-  userMessage,
-} from "../../providers/provider-send-message.js";
 import { checkIngressForSecrets } from "../../security/secret-ingress.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspacePromptPath } from "../../util/platform.js";
 import type { AuthContext } from "../auth/types.js";
+import { runBtwSidechain } from "../btw-sidechain.js";
 import { httpError } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
 import type { SendMessageDeps } from "../http-types.js";
@@ -159,73 +154,42 @@ async function handleBtw(
   const conversation =
     await deps.sendMessageDeps.getOrCreateConversation(conversationId);
 
-  const messages = [...conversation.getMessages(), userMessage(trimmedContent)];
-  const tools = buildToolDefinitions();
-  const { signal: timeoutSignal, cleanup: cleanupTimeout } =
-    createTimeout(30_000);
-
-  // Combine the timeout signal with the request's abort signal so that
-  // disconnection or timeout both cancel the provider call.
-  const combinedController = new AbortController();
-  const onTimeoutAbort = () => combinedController.abort();
-  const onRequestAbort = () => combinedController.abort();
-  timeoutSignal.addEventListener("abort", onTimeoutAbort, { once: true });
-  req.signal.addEventListener("abort", onRequestAbort, { once: true });
-  const combinedSignal = combinedController.signal;
-
   const encoder = new TextEncoder();
 
   const stream = new ReadableStream({
     start(controller) {
       (async () => {
         try {
-          // Preserve any conversation-specific systemPromptOverride so
-          // side-chain responses match the active conversation contract.  Only
-          // fall back to a fresh prompt (excluding BOOTSTRAP.md) for
-          // default conversations where no override was provided.
-          const systemPrompt = conversation.hasSystemPromptOverride
-            ? conversation.systemPrompt
-            : buildSystemPrompt({ excludeBootstrap: true });
-
           const isIntroRequest = conversationKey === IDENTITY_INTRO_KEY;
-          let textDeltaCount = 0;
-          let collectedText = "";
-          await conversation.provider.sendMessage(
-            messages,
-            tools,
-            systemPrompt,
-            {
-              config: {
-                max_tokens: 1024,
-                tool_choice: { type: "none" },
-                modelIntent: "latency-optimized",
-              },
-              onEvent: (event) => {
-                if (event.type === "text_delta") {
-                  textDeltaCount++;
-                  if (isIntroRequest) collectedText += event.text;
-                  controller.enqueue(
-                    encoder.encode(
-                      `event: btw_text_delta\ndata: ${JSON.stringify({ text: event.text })}\n\n`,
-                    ),
-                  );
-                }
-              },
-              signal: combinedSignal,
+          const result = await runBtwSidechain({
+            content: trimmedContent,
+            conversation,
+            signal: req.signal,
+            onEvent: (event) => {
+              if (event.type === "text_delta") {
+                controller.enqueue(
+                  encoder.encode(
+                    `event: btw_text_delta\ndata: ${JSON.stringify({ text: event.text })}\n\n`,
+                  ),
+                );
+              }
             },
-          );
+          });
 
-          if (textDeltaCount === 0) {
+          if (!result.hadTextDeltas) {
             log.warn(
-              { conversationKey, messageCount: messages.length },
+              {
+                conversationKey,
+                messageCount: conversation.getMessages().length + 1,
+              },
               "btw side-chain completed with no text deltas",
             );
           }
 
           // Cache the generated identity intro for subsequent requests.
-          if (isIntroRequest && collectedText.trim()) {
+          if (isIntroRequest && result.text) {
             try {
-              setCachedIntro(collectedText.trim());
+              setCachedIntro(result.text);
               log.debug("Cached identity intro text");
             } catch {
               // Non-fatal — next request will regenerate.
@@ -249,10 +213,6 @@ async function handleBtw(
           } catch {
             /* stream already closed */
           }
-        } finally {
-          cleanupTimeout();
-          timeoutSignal.removeEventListener("abort", onTimeoutAbort);
-          req.signal.removeEventListener("abort", onRequestAbort);
         }
       })();
     },

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

@@ -2,6 +2,7 @@
  * Route handlers for conversation management operations.
  *
  * POST   /v1/conversations/switch         — switch to an existing conversation
+ * POST   /v1/conversations/fork           — fork an existing conversation
  * PATCH  /v1/conversations/:id/name       — rename a conversation
  * DELETE /v1/conversations                 — clear all conversations
  * POST   /v1/conversations/:id/wipe       — wipe conversation and revert memory
@@ -15,6 +16,7 @@
 import {
   batchSetDisplayOrders,
   deleteConversation,
+  PRIVATE_CONVERSATION_FORK_ERROR,
   wipeConversation,
 } from "../../memory/conversation-crud.js";
 import {
@@ -22,6 +24,7 @@ import {
   setConversationKeyIfAbsent,
 } from "../../memory/conversation-key-store.js";
 import { enqueueMemoryJob } from "../../memory/jobs-store.js";
+import { UserError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import { httpError } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
@@ -33,6 +36,10 @@ const log = getLogger("conversation-management-routes");
 // ---------------------------------------------------------------------------
 
 export interface ConversationManagementDeps {
+  forkConversation?: (params: {
+    conversationId: string;
+    throughMessageId?: string;
+  }) => Promise<Record<string, unknown>> | Record<string, unknown>;
   switchConversation: (conversationId: string) => Promise<{
     conversationId: string;
     title: string;
@@ -59,6 +66,67 @@ export function conversationManagementRouteDefinitions(
   deps: ConversationManagementDeps,
 ): RouteDefinition[] {
   return [
+    {
+      endpoint: "conversations/fork",
+      method: "POST",
+      policyKey: "conversations/fork",
+      handler: async ({ req }) => {
+        if (!deps.forkConversation) {
+          return httpError(
+            "INTERNAL_ERROR",
+            "Conversation forking not available",
+            500,
+          );
+        }
+
+        const rawBody = (await req.json()) as unknown;
+        if (
+          rawBody == null ||
+          typeof rawBody !== "object" ||
+          Array.isArray(rawBody)
+        ) {
+          return httpError("BAD_REQUEST", "Invalid request body", 400);
+        }
+
+        const body = rawBody as {
+          conversationId?: string;
+          throughMessageId?: string;
+        };
+        const conversationId = body.conversationId;
+        if (!conversationId || typeof conversationId !== "string") {
+          return httpError("BAD_REQUEST", "Missing conversationId", 400);
+        }
+        if (
+          body.throughMessageId !== undefined &&
+          typeof body.throughMessageId !== "string"
+        ) {
+          return httpError(
+            "BAD_REQUEST",
+            "throughMessageId must be a string",
+            400,
+          );
+        }
+
+        const resolvedConversationId =
+          resolveConversationId(conversationId) ?? conversationId;
+
+        try {
+          const conversation = await deps.forkConversation({
+            conversationId: resolvedConversationId,
+            throughMessageId: body.throughMessageId,
+          });
+          return Response.json({ conversation });
+        } catch (err) {
+          if (err instanceof UserError) {
+            if (err.message === PRIVATE_CONVERSATION_FORK_ERROR) {
+              return httpError("FORBIDDEN", err.message, 403);
+            }
+            return httpError("NOT_FOUND", err.message, 404);
+          }
+          throw err;
+        }
+      },
+    },
     {
       endpoint: "conversations/switch",
       method: "POST",
@@ -207,6 +275,12 @@ export function conversationManagementRouteDefinitions(
             targetId: itemId,
           });
         }
+        for (const summaryId of deleted.deletedSummaryIds) {
+          enqueueMemoryJob("delete_qdrant_vectors", {
+            targetType: "summary",
+            targetId: summaryId,
+          });
+        }
         log.info({ conversationId: resolvedId }, "Deleted conversation");
         return new Response(null, { status: 204 });
       },

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

@@ -1,17 +1,27 @@
 /**
- * HTTP route definitions for model configuration, conversation search,
- * message content, and queued message deletion.
+ * HTTP route definitions for model configuration, embedding configuration,
+ * conversation search, message content, LLM context inspection, and queued
+ * message deletion.
  *
  * These routes expose conversation query functionality over the HTTP API.
  *
- * GET    /v1/model                   — current model info
- * PUT    /v1/model                   — set model
- * PUT    /v1/model/image-gen         — set image-gen model
- * GET    /v1/conversations/search    — search conversations
- * GET    /v1/messages/:id/content    — full message content
- * DELETE /v1/messages/queued/:id     — delete queued message
+ * GET    /v1/model                      — current model info
+ * PUT    /v1/model                      — set model
+ * PUT    /v1/model/image-gen            — set image-gen model
+ * GET    /v1/config/embeddings          — current embedding config
+ * PUT    /v1/config/embeddings          — set embedding provider/model
+ * GET    /v1/conversations/search       — search conversations
+ * GET    /v1/messages/:id/content       — full message content
+ * GET    /v1/messages/:id/llm-context   — LLM request logs for a message
+ * DELETE /v1/messages/queued/:id        — delete queued message
  */
 
+import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
+import { VALID_INFERENCE_PROVIDERS } from "../../config/schemas/services.js";
+import {
+  getEmbeddingConfigInfo,
+  setEmbeddingConfig,
+} from "../../daemon/handlers/config-embeddings.js";
 import {
   getModelInfo,
   type ModelSetContext,
@@ -23,8 +33,45 @@ import {
   performConversationSearch,
 } from "../../daemon/handlers/conversation-history.js";
 import { deleteQueuedMessage } from "../../daemon/handlers/conversations.js";
+import { getRequestLogsByMessageId } from "../../memory/llm-request-log-store.js";
 import { httpError } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
+import { normalizeLlmContextPayloads } from "./llm-context-normalization.js";
+
+const validProviderSet = new Set<string>(VALID_INFERENCE_PROVIDERS);
+const validEmbeddingProviderSet = new Set<string>(
+  VALID_MEMORY_EMBEDDING_PROVIDERS,
+);
+
+type LlmContextNormalizationResult = ReturnType<
+  typeof normalizeLlmContextPayloads
+>;
+
+type LlmContextSummaryResponse = NonNullable<
+  Omit<NonNullable<LlmContextNormalizationResult["summary"]>, "provider">
+> & {
+  provider: string;
+};
+
+type LlmContextRouteResult = Omit<LlmContextNormalizationResult, "summary"> & {
+  summary?: LlmContextSummaryResponse;
+};
+
+function applyStoredProviderToLlmContextResult(
+  normalized: LlmContextNormalizationResult,
+  provider: string | null,
+): LlmContextRouteResult {
+  if (!provider) {
+    return normalized as LlmContextRouteResult;
+  }
+
+  return {
+    ...normalized,
+    summary: normalized.summary
+      ? { ...normalized.summary, provider }
+      : { provider },
+  };
+}
 
 // ---------------------------------------------------------------------------
 // Dependency interfaces
@@ -65,7 +112,10 @@ export function conversationQueryRouteDefinitions(
         if (!deps.getModelSetContext) {
           return httpError("INTERNAL_ERROR", "Model set not available", 500);
         }
-        const body = (await req.json()) as { modelId?: string };
+        const body = (await req.json()) as {
+          modelId?: string;
+          provider?: string;
+        };
         if (!body.modelId || typeof body.modelId !== "string") {
           return httpError(
             "BAD_REQUEST",
@@ -73,8 +123,23 @@ export function conversationQueryRouteDefinitions(
             400,
           );
         }
+        if (
+          body.provider !== undefined &&
+          (typeof body.provider !== "string" ||
+            !validProviderSet.has(body.provider))
+        ) {
+          return httpError(
+            "BAD_REQUEST",
+            `Invalid provider "${body.provider}". Valid providers: ${[...validProviderSet].join(", ")}`,
+            400,
+          );
+        }
         try {
-          const info = await setModel(body.modelId, deps.getModelSetContext());
+          const info = await setModel(
+            body.modelId,
+            deps.getModelSetContext(),
+            body.provider,
+          );
           return Response.json(info);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -120,6 +185,71 @@ export function conversationQueryRouteDefinitions(
       },
     },
 
+    // ── Embedding config ─────────────────────────────────────────────
+    {
+      endpoint: "config/embeddings",
+      method: "GET",
+      policyKey: "config/embeddings",
+      handler: async () => {
+        const info = await getEmbeddingConfigInfo();
+        return Response.json(info);
+      },
+    },
+    {
+      endpoint: "config/embeddings",
+      method: "PUT",
+      policyKey: "config/embeddings",
+      handler: async ({ req }) => {
+        if (!deps.getModelSetContext) {
+          return httpError(
+            "INTERNAL_ERROR",
+            "Embedding config not available",
+            500,
+          );
+        }
+        const body = (await req.json()) as {
+          provider?: string;
+          model?: string;
+        };
+        if (!body.provider || typeof body.provider !== "string") {
+          return httpError(
+            "BAD_REQUEST",
+            "Missing required field: provider",
+            400,
+          );
+        }
+        if (!validEmbeddingProviderSet.has(body.provider)) {
+          return httpError(
+            "BAD_REQUEST",
+            `Invalid provider "${body.provider}". Valid providers: ${[...validEmbeddingProviderSet].join(", ")}`,
+            400,
+          );
+        }
+        if (body.model !== undefined && typeof body.model !== "string") {
+          return httpError(
+            "BAD_REQUEST",
+            "Field 'model' must be a string",
+            400,
+          );
+        }
+        try {
+          const info = await setEmbeddingConfig(
+            body.provider,
+            body.model,
+            deps.getModelSetContext(),
+          );
+          return Response.json(info);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return httpError(
+            "INTERNAL_ERROR",
+            `Failed to set embedding config: ${message}`,
+            500,
+          );
+        }
+      },
+    },
+
     // ── Conversation search ───────────────────────────────────────────
     {
       endpoint: "conversations/search",
@@ -167,6 +297,53 @@ export function conversationQueryRouteDefinitions(
       },
     },
 
+    // ── LLM context (request logs) for a message ───────────────────────
+    {
+      endpoint: "messages/:id/llm-context",
+      method: "GET",
+      policyKey: "messages/llm-context",
+      handler: ({ params }) => {
+        const messageId = params.id;
+        if (!messageId) {
+          return httpError("BAD_REQUEST", "message id is required", 400);
+        }
+        const logs = getRequestLogsByMessageId(messageId);
+        return Response.json({
+          messageId,
+          logs: logs.map((log) => {
+            let requestPayload: unknown;
+            try {
+              requestPayload = JSON.parse(log.requestPayload);
+            } catch {
+              requestPayload = log.requestPayload;
+            }
+            let responsePayload: unknown;
+            try {
+              responsePayload = JSON.parse(log.responsePayload);
+            } catch {
+              responsePayload = log.responsePayload;
+            }
+            const normalized = normalizeLlmContextPayloads({
+              requestPayload,
+              responsePayload,
+              createdAt: log.createdAt,
+            });
+            const result = applyStoredProviderToLlmContextResult(
+              normalized,
+              log.provider,
+            );
+            return {
+              id: log.id,
+              requestPayload,
+              responsePayload,
+              createdAt: log.createdAt,
+              ...result,
+            };
+          }),
+        });
+      },
+    },
+
     // ── Delete queued message ─────────────────────────────────────────
     {
       endpoint: "messages/queued/:id",