@vellumai/assistant 0.8.2 → 0.8.4

package/src/memory/llm-request-log-store.ts

@@ -1,6 +1,7 @@
-import { and, eq, gte, inArray, isNull, lte, sql } from "drizzle-orm";
+import { and, desc, eq, gte, inArray, isNull, lte, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { AssistantError, ProviderError } from "../util/errors.js";
 import {
   getAssistantMessageIdsInTurn,
   getMessageById,
@@ -18,8 +19,54 @@ export type LogRow = {
   requestPayload: string;
   responsePayload: string;
   createdAt: number;
+  /**
+   * Set on the final log row of an `AgentLoop.run` once the loop body
+   * exits. NULL on intermediate rows — that's the canonical "loop kept
+   * going" signal. Values are the stable strings from
+   * `AgentLoopExitReason` in `agent/loop.ts`.
+   */
+  agentLoopExitReason: string | null;
 };
 
+/**
+ * Build the structured response-payload object recorded in
+ * `llm_request_logs.responsePayload` for a provider-rejected LLM call.
+ *
+ * Mirrors the shape of a successful `usage.rawResponse` row by placing
+ * the error under a top-level `error` key, so an inspector consumer can
+ * branch on `row.responsePayload.error` vs the success shape without
+ * parsing twice. Extracts queryable fields from `ProviderError`
+ * (provider tag, status code, retry-after) and `AssistantError`
+ * (structured `ErrorCode`) when present so the row isn't opaque text.
+ * Other `Error` shapes degrade gracefully to `{name, message}`.
+ *
+ * Returns the structured object rather than a JSON string so callers
+ * can either stringify it directly (daemon-path `recordRequestLog`) or
+ * store it on a pending-log queue that stringifies later (wake-path
+ * `PendingLog.rawResponse`), without double-encoding.
+ */
+export function buildProviderErrorResponsePayload(err: Error): {
+  error: Record<string, unknown>;
+} {
+  const payload: Record<string, unknown> = {
+    name: err.name,
+    message: err.message,
+  };
+  if (err instanceof ProviderError) {
+    payload.code = err.code;
+    payload.provider = err.provider;
+    if (err.statusCode !== undefined) {
+      payload.statusCode = err.statusCode;
+    }
+    if (err.retryAfterMs !== undefined) {
+      payload.retryAfterMs = err.retryAfterMs;
+    }
+  } else if (err instanceof AssistantError) {
+    payload.code = err.code;
+  }
+  return { error: payload };
+}
+
 export function recordRequestLog(
   conversationId: string,
   requestPayload: string,
@@ -38,11 +85,51 @@ export function recordRequestLog(
       requestPayload,
       responsePayload,
       createdAt: Date.now(),
+      // Stamped later via setAgentLoopExitReasonOnLatestLog, once the
+      // agent loop body actually exits. Intermediate rows stay NULL.
+      agentLoopExitReason: null,
     })
     .run();
   return id;
 }
 
+/**
+ * Stamp an `agent_loop_exit_reason` onto the most-recent unstamped
+ * `llm_request_logs` row for the given conversation. Called by the
+ * agent-loop event dispatch (both `dispatchAgentEvent` and the wake's
+ * `onEvent`) when an `agent_loop_exit` event is observed.
+ *
+ * The `IS NULL` guard prevents a current run from clobbering a previous
+ * run's exit reason when the current run exits before landing any log
+ * row of its own (reachable via `aborted_pre_call`, `aborted_via_error`
+ * during pre-call setup, or `error` when system-prompt/tool resolution
+ * throws). In those cases the latest row belongs to a prior run and is
+ * already stamped — leave it alone.
+ */
+export function setAgentLoopExitReasonOnLatestLog(
+  conversationId: string,
+  reason: string,
+): void {
+  const db = getDb();
+  const latest = db
+    .select({ id: llmRequestLogs.id })
+    .from(llmRequestLogs)
+    .where(
+      and(
+        eq(llmRequestLogs.conversationId, conversationId),
+        isNull(llmRequestLogs.agentLoopExitReason),
+      ),
+    )
+    .orderBy(desc(llmRequestLogs.createdAt))
+    .limit(1)
+    .get();
+  if (!latest) return;
+  db.update(llmRequestLogs)
+    .set({ agentLoopExitReason: reason })
+    .where(eq(llmRequestLogs.id, latest.id))
+    .run();
+}
+
 export function backfillMessageIdOnLogs(
   conversationId: string,
   messageId: string,
@@ -94,6 +181,7 @@ function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
       requestPayload: llmRequestLogs.requestPayload,
       responsePayload: llmRequestLogs.responsePayload,
       createdAt: llmRequestLogs.createdAt,
+      agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
     })
     .from(llmRequestLogs)
     .where(inArray(llmRequestLogs.messageId, messageIds))
@@ -125,6 +213,7 @@ function selectOrphanedLogsInRange(
       requestPayload: llmRequestLogs.requestPayload,
       responsePayload: llmRequestLogs.responsePayload,
       createdAt: llmRequestLogs.createdAt,
+      agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
     })
     .from(llmRequestLogs)
     .leftJoin(messages, eq(llmRequestLogs.messageId, messages.id))
@@ -165,6 +254,7 @@ function selectUnlinkedLogsInRange(
       requestPayload: llmRequestLogs.requestPayload,
       responsePayload: llmRequestLogs.responsePayload,
       createdAt: llmRequestLogs.createdAt,
+      agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
     })
     .from(llmRequestLogs)
     .where(
@@ -191,6 +281,7 @@ export function getRequestLogById(logId: string): LogRow | null {
         requestPayload: llmRequestLogs.requestPayload,
         responsePayload: llmRequestLogs.responsePayload,
         createdAt: llmRequestLogs.createdAt,
+        agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
       })
       .from(llmRequestLogs)
       .where(eq(llmRequestLogs.id, logId))

package/src/memory/memory-retrospective-constants.ts

@@ -5,9 +5,37 @@
  */
 export const MEMORY_RETROSPECTIVE_SOURCE = "memory-retrospective";
 
+/**
+ * Sentinel value for the `source` column of fork-based memory-retrospective
+ * conversations (the new `memory-retrospective-fork` flag path). Distinct
+ * from MEMORY_RETROSPECTIVE_SOURCE so dedup can scope its message scan to the
+ * post-fork tail — fork-kind rows carry the full source prefix and would
+ * otherwise pollute prior-remember dedup with source-inline `remember` calls.
+ */
+export const MEMORY_RETROSPECTIVE_FORK_SOURCE = "memory-retrospective-fork";
+
+/**
+ * Union of both retrospective source sentinels. Use when looking up the most
+ * recent retrospective for a source conversation (either kind is valid) or
+ * when filtering retrospective bg conversations out of recursion queries.
+ */
+export const MEMORY_RETROSPECTIVE_SOURCES: readonly string[] = [
+  MEMORY_RETROSPECTIVE_SOURCE,
+  MEMORY_RETROSPECTIVE_FORK_SOURCE,
+];
+
 /**
  * Dedicated `group_id` value for memory-retrospective background
  * conversations. Placed under `system:background` alongside auto-analysis,
  * heartbeat, and filing conversations.
  */
 export const MEMORY_RETROSPECTIVE_GROUP_ID = "system:background";
+
+/**
+ * `metadata.kind` value stamped on the user-role instruction message that
+ * fork-based retrospectives append to the forked conversation. Used purely
+ * for observability — operators inspecting a retrospective fork's history
+ * can tell the user-role message apart from a real user turn.
+ */
+export const MEMORY_RETROSPECTIVE_INSTRUCTION_KIND =
+  "memory_retrospective_instruction";

package/src/memory/memory-retrospective-enqueue.ts

@@ -2,9 +2,7 @@
 // Memory retrospective — enqueue helper.
 // ---------------------------------------------------------------------------
 //
-// Conditionally enqueue a `memory_retrospective` job for the given
-// conversation. Gates on:
-//   - `memory-retrospective` feature flag enabled.
+// Enqueue a `memory_retrospective` job for the given conversation. Gates on:
 //   - Source conversation isn't a memory-retrospective conversation itself
 //     (recursion guard — we never run a retrospective over reflective
 //     musings from the retrospective agent's own writes).
@@ -15,8 +13,6 @@
 // after the corresponding signal settles; `interval` and `message_count`
 // fire immediately.
 
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
-import { getConfig } from "../config/loader.js";
 import {
   isUntrustedTrustClass,
   type TrustClass,
@@ -24,7 +20,7 @@ import {
 import { getLogger } from "../util/logger.js";
 import { getConversationSource } from "./conversation-crud.js";
 import { upsertMemoryRetrospectiveJob } from "./jobs-store.js";
-import { MEMORY_RETROSPECTIVE_SOURCE } from "./memory-retrospective-constants.js";
+import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
 
 const log = getLogger("memory-retrospective-enqueue");
 
@@ -42,21 +38,6 @@ export function enqueueMemoryRetrospectiveIfEnabled(args: {
 }): void {
   const { conversationId, trigger } = args;
 
-  let config;
-  try {
-    config = getConfig();
-  } catch (err) {
-    log.warn(
-      { err, conversationId, trigger },
-      "Skipping memory-retrospective enqueue: failed to load config",
-    );
-    return;
-  }
-
-  if (!isAssistantFeatureFlagEnabled("memory-retrospective", config)) {
-    return;
-  }
-
   if (isMemoryRetrospectiveConversation(conversationId)) {
     log.debug(
       { conversationId, trigger },
@@ -86,7 +67,8 @@ export function enqueueMemoryRetrospectiveIfEnabled(args: {
 export function isMemoryRetrospectiveConversation(
   conversationId: string,
 ): boolean {
-  return getConversationSource(conversationId) === MEMORY_RETROSPECTIVE_SOURCE;
+  const source = getConversationSource(conversationId);
+  return source !== null && MEMORY_RETROSPECTIVE_SOURCES.includes(source);
 }
 
 /**