@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -63,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";
@@ -231,6 +233,56 @@ function applyStoredProviderToLlmContextResult(
   return { ...normalized, summary };
 }
 
+function normalizeLlmContextLog(log: LogRow): LlmContextRouteResult & {
+  id: string;
+  requestPayload: null;
+  responsePayload: null;
+  createdAt: number;
+  agentLoopExitReason: string | null;
+  callSite: 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,
+    // 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,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Model set context — derived directly from the config watcher singleton
 // ---------------------------------------------------------------------------
@@ -658,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)) {
@@ -831,47 +925,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,
-        // 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,
-      };
-    }),
+    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) {
@@ -930,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) {
@@ -1126,6 +1248,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",