@vellumai/assistant 0.8.3 → 0.8.5

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

@@ -15,6 +15,7 @@
  * GET    /v1/messages/:id/llm-context   — LLM request logs for a message
  * GET    /v1/llm-request-logs/:id/payload — raw payload for a single log
  * DELETE /v1/messages/queued/:id        — delete queued message
+ * POST   /v1/messages/queued/:id/steer — steer to a queued message
  */
 
 import { z } from "zod";
@@ -49,7 +50,10 @@ import {
   getMessageContent,
   performConversationSearch,
 } from "../../daemon/handlers/conversation-history.js";
-import { deleteQueuedMessage } from "../../daemon/handlers/conversations.js";
+import {
+  deleteQueuedMessage,
+  steerToMessage,
+} from "../../daemon/handlers/conversations.js";
 import {
   CONFIG_RELOAD_DEBOUNCE_MS,
   log,
@@ -59,9 +63,11 @@ import {
   getConversation,
   getMessageById,
 } from "../../memory/conversation-crud.js";
+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 { 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";
@@ -227,6 +233,46 @@ function applyStoredProviderToLlmContextResult(
   return { ...normalized, summary };
 }
 
+function normalizeLlmContextLog(log: LogRow): LlmContextRouteResult & {
+  id: string;
+  requestPayload: null;
+  responsePayload: null;
+  createdAt: number;
+  agentLoopExitReason: string | null;
+} {
+  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: null,
+    responsePayload: null,
+    createdAt: log.createdAt,
+    // Agent-loop exit reason for the iteration that produced this call,
+    // stamped onto the most-recent unstamped log by
+    // `conversation-agent-loop-handlers.ts` after the loop yields. Only the
+    // terminal call in each loop iteration carries a value; non-terminal calls
+    // land here as `null`.
+    agentLoopExitReason: log.agentLoopExitReason ?? null,
+    ...result,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Model set context — derived directly from the config watcher singleton
 // ---------------------------------------------------------------------------
@@ -827,41 +873,77 @@ async function handleGetLlmContext({ pathParams = {} }: RouteHandlerArgs) {
     messageId,
     conversationKind,
     conversationTotalEstimatedCostUsd,
-    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: null,
-        responsePayload: null,
-        createdAt: log.createdAt,
-        ...result,
-      };
-    }),
+    logs: logs.map(normalizeLlmContextLog),
     memoryRecall: memoryRecallLog ?? null,
     memoryV2Activation: memoryV2Activation ?? null,
   };
 }
 
+async function handleGetConversationLlmContext({
+  queryParams = {},
+}: RouteHandlerArgs) {
+  const conversationKey = queryParams.conversationKey;
+  const requestedConversationId = queryParams.conversationId;
+
+  let conversationId: string | undefined = requestedConversationId;
+  if (!conversationId && conversationKey) {
+    const mapping = getConversationByKey(conversationKey);
+    conversationId = mapping?.conversationId;
+  }
+
+  if (!conversationId) {
+    if (conversationKey) {
+      return {
+        conversationKey,
+        conversationId: null,
+        conversationKind: "user",
+        conversationTotalEstimatedCostUsd: null,
+        logs: [],
+        memoryRecall: null,
+        memoryV2Activation: null,
+      };
+    }
+    throw new BadRequestError(
+      "conversationKey or conversationId query parameter is required",
+    );
+  }
+
+  const conversation = getConversation(conversationId);
+  if (!conversation) {
+    if (conversationKey) {
+      return {
+        conversationKey,
+        conversationId,
+        conversationKind: "user",
+        conversationTotalEstimatedCostUsd: null,
+        logs: [],
+        memoryRecall: null,
+        memoryV2Activation: null,
+      };
+    }
+    throw new NotFoundError(`Conversation ${conversationId} not found`);
+  }
+
+  const source = await getLlmRequestLogSource();
+  const logs = await source.getRequestLogsByConversationId(conversation.id);
+  const conversationKind = resolveConversationKind(
+    conversation.source,
+    conversation.conversationType,
+  );
+  const conversationTotalEstimatedCostUsd =
+    conversation.totalEstimatedCost ?? null;
+
+  return {
+    conversationKey: conversationKey ?? null,
+    conversationId: conversation.id,
+    conversationKind,
+    conversationTotalEstimatedCostUsd,
+    logs: logs.map(normalizeLlmContextLog),
+    memoryRecall: null,
+    memoryV2Activation: null,
+  };
+}
+
 async function handleGetLlmRequestLogPayload({
   pathParams = {},
 }: RouteHandlerArgs) {
@@ -909,6 +991,36 @@ function handleDeleteQueuedMessage({
   throw new NotFoundError("Queued message not found");
 }
 
+function handleSteerToMessage({
+  queryParams = {},
+  pathParams = {},
+  body,
+}: RouteHandlerArgs) {
+  const conversationId =
+    queryParams.conversationId ??
+    (body && typeof body === "object" && "conversationId" in body
+      ? (body as Record<string, unknown>).conversationId
+      : undefined);
+  if (!conversationId || typeof conversationId !== "string") {
+    throw new BadRequestError(
+      "Missing required parameter: conversationId",
+    );
+  }
+  const result = steerToMessage(conversationId, pathParams.id ?? "");
+  if (result.steered) {
+    return { ok: true, conversationId, requestId: pathParams.id };
+  }
+  if (result.reason === "conversation_not_found") {
+    throw new NotFoundError("Conversation not found");
+  }
+  if (result.reason === "not_processing") {
+    throw new BadRequestError(
+      "Cannot steer: conversation is not currently processing",
+    );
+  }
+  throw new NotFoundError("Queued message not found");
+}
+
 // ---------------------------------------------------------------------------
 // Route definitions (shared HTTP + IPC)
 // ---------------------------------------------------------------------------
@@ -1086,6 +1198,40 @@ export const ROUTES: RouteDefinition[] = [
     ],
     handler: handleGetMessageContent,
   },
+  {
+    operationId: "conversations_llm_context_get",
+    endpoint: "conversations/llm-context",
+    method: "GET",
+    policyKey: "conversations/llm-context",
+    summary: "Get LLM context for a conversation",
+    description:
+      "Returns normalized LLM request/response logs for an entire conversation.",
+    tags: ["conversations"],
+    queryParams: [
+      {
+        name: "conversationKey",
+        required: false,
+        schema: { type: "string" },
+        description: "Stable external conversation key.",
+      },
+      {
+        name: "conversationId",
+        required: false,
+        schema: { type: "string" },
+        description: "Internal conversation identifier.",
+      },
+    ],
+    responseBody: z.object({
+      conversationKey: z.string().nullable().optional(),
+      conversationId: z.string().nullable(),
+      conversationKind: z.enum(CONVERSATION_KINDS),
+      conversationTotalEstimatedCostUsd: z.number().nullable(),
+      logs: z.array(z.unknown()),
+      memoryRecall: z.object({}).passthrough().nullable(),
+      memoryV2Activation: z.object({}).passthrough().nullable(),
+    }),
+    handler: handleGetConversationLlmContext,
+  },
   {
     operationId: "messages_llm_context_get",
     endpoint: "messages/:id/llm-context",
@@ -1140,4 +1286,23 @@ export const ROUTES: RouteDefinition[] = [
     ],
     handler: handleDeleteQueuedMessage,
   },
+  {
+    operationId: "messages_queued_steer",
+    endpoint: "messages/queued/:id/steer",
+    method: "POST",
+    policyKey: "messages/queued",
+    summary: "Steer to a queued message",
+    description:
+      "Promote a queued message to the head of the queue and abort the current generation so it is processed next.",
+    tags: ["messages"],
+    queryParams: [
+      {
+        name: "conversationId",
+        schema: { type: "string" },
+        required: true,
+        description: "Conversation ID (required)",
+      },
+    ],
+    handler: handleSteerToMessage,
+  },
 ];