@vellumai/assistant 0.8.7 → 0.8.8

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

@@ -363,6 +363,32 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Get character components",
     description: "Return available avatar character components.",
     tags: ["avatar"],
+    responseBody: z.object({
+      bodyShapes: z.array(
+        z.object({
+          id: z.string(),
+          viewBox: z.object({ width: z.number(), height: z.number() }),
+          faceCenter: z.object({ x: z.number(), y: z.number() }),
+          svgPath: z.string(),
+        }),
+      ),
+      eyeStyles: z.array(
+        z.object({
+          id: z.string(),
+          sourceViewBox: z.object({ width: z.number(), height: z.number() }),
+          eyeCenter: z.object({ x: z.number(), y: z.number() }),
+          paths: z.array(z.object({ svgPath: z.string(), color: z.string() })),
+        }),
+      ),
+      colors: z.array(z.object({ id: z.string(), hex: z.string() })),
+      faceCenterOverrides: z.array(
+        z.object({
+          bodyShape: z.string(),
+          eyeStyle: z.string(),
+          faceCenter: z.object({ x: z.number(), y: z.number() }),
+        }),
+      ),
+    }),
   },
   {
     operationId: "avatar_get_state",

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

@@ -9,21 +9,18 @@
  * intro generation. The response is streamed as SSE events (`btw_text_delta`,
  * `btw_complete`, `btw_error`).
  *
- * No messages are persisted. `conversation.processing` is never set or checked.
+ * No messages are persisted. The conversation's processing flag is never set or checked.
  */
 
-import { existsSync, readFileSync } from "node:fs";
-
 import { z } from "zod";
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
-import { readNowScratchpad } from "../../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../../daemon/conversation-store.js";
-import { parseIdentityFields } from "../../daemon/handlers/identity.js";
+import { readNowScratchpad } from "../../daemon/now-scratchpad.js";
 import { getConversationByKey } from "../../memory/conversation-key-store.js";
 import { getAllToolDefinitions } from "../../tools/registry.js";
 import { getLogger } from "../../util/logger.js";
-import { getWorkspacePromptPath } from "../../util/platform.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { runBtwSidechain } from "../btw-sidechain.js";
 import { BadRequestError, ServiceUnavailableError } from "./errors.js";
@@ -37,6 +34,9 @@ const IDENTITY_INTRO_KEY = "identity-intro";
 
 /** Conversation key used by the client for empty-state greeting generation. */
 const GREETING_KEY = "greeting";
+const EMPTY_STATE_DYNAMIC_GREETINGS_FLAG =
+  "empty-state-dynamic-greetings" as const;
+const STATIC_EMPTY_STATE_GREETING = "What are we working on?";
 
 // ---------------------------------------------------------------------------
 // SSE helpers
@@ -68,26 +68,22 @@ async function handleBtw({
 
   const trimmedContent = content.trim();
 
-  // ----- Identity intro fast-path -----
+  if (
+    conversationKey === GREETING_KEY &&
+    !isAssistantFeatureFlagEnabled(
+      EMPTY_STATE_DYNAMIC_GREETINGS_FLAG,
+      getConfig(),
+    )
+  ) {
+    return streamText(STATIC_EMPTY_STATE_GREETING);
+  }
+
+  // ----- Cached identity intro fast-path -----
   if (conversationKey === IDENTITY_INTRO_KEY) {
-    let fastText: string | undefined;
-    const identityPath = getWorkspacePromptPath("IDENTITY.md");
-    if (existsSync(identityPath)) {
-      const fields = parseIdentityFields(readFileSync(identityPath, "utf-8"));
-      if (fields.name) {
-        fastText = `Hi, I'm ${fields.name}!`;
-      }
-    }
-    fastText ??= getCachedIntro()?.greetings[0];
+    const fastText = getCachedIntro()?.greetings[0];
     if (fastText) {
       log.debug("Returning identity intro fast-path");
-      return new ReadableStream({
-        start(controller) {
-          controller.enqueue(sseEvent("btw_text_delta", { text: fastText }));
-          controller.enqueue(sseEvent("btw_complete", {}));
-          controller.close();
-        },
-      });
+      return streamText(fastText);
     }
   }
 
@@ -171,6 +167,16 @@ async function handleBtw({
   });
 }
 
+function streamText(text: string): ReadableStream<Uint8Array> {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(sseEvent("btw_text_delta", { text }));
+      controller.enqueue(sseEvent("btw_complete", {}));
+      controller.close();
+    },
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------

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

@@ -15,26 +15,39 @@
 
 import { z } from "zod";
 
-import { getConfig } from "../../config/loader.js";
+import {
+  getConfig,
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+} from "../../config/loader.js";
+import type { AssistantConfig } from "../../config/schema.js";
 import { getMemoryCheckpoint } from "../../memory/checkpoints.js";
 import {
   getMessageRoleStatsByConversation,
   listConversationsBySource,
 } from "../../memory/conversation-queries.js";
 import {
+  cancelPendingAutomaticConsolidationJobs,
   enqueueMemoryJob,
   hasActiveJobOfType,
+  MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS,
 } from "../../memory/jobs-store.js";
 import { GRAPH_MAINTENANCE_CHECKPOINTS } from "../../memory/jobs-worker.js";
+import { getUsageCostForConversationWindow } from "../../memory/llm-usage-store.js";
 import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../../memory/v2/constants.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
-import { BadRequestError } from "./errors.js";
+import { BadRequestError, InternalError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 function isConsolidationAvailable(): boolean {
   return getConfig().memory.v2.enabled;
 }
 
+function isAutomaticConsolidationEnabled(config: AssistantConfig): boolean {
+  return config.memory.v2.enabled && config.memory.v2.consolidation_enabled;
+}
+
 function consolidationIntervalMs(): number {
   return getConfig().memory.v2.consolidation_interval_hours * 60 * 60 * 1000;
 }
@@ -48,6 +61,61 @@ function readLastRunAt(): number | null {
   return Number.isFinite(parsed) ? parsed : null;
 }
 
+function readConsolidationConfigResponse() {
+  const config = getConfig();
+  const available = config.memory.v2.enabled;
+  const enabled = isAutomaticConsolidationEnabled(config);
+  const intervalMs = consolidationIntervalMs();
+  const lastRunAt = readLastRunAt();
+  const nextRunAt =
+    enabled && lastRunAt != null ? lastRunAt + intervalMs : null;
+  return {
+    available,
+    enabled,
+    intervalMs,
+    nextRunAt,
+    lastRunAt,
+    success: true,
+  };
+}
+
+function handleUpdateConfig(body: Record<string, unknown>) {
+  const consolidationPatch: Record<string, unknown> = {};
+  const disablingAutomaticConsolidation = body.enabled === false;
+  if ("enabled" in body && typeof body.enabled === "boolean") {
+    consolidationPatch.consolidation_enabled = body.enabled;
+  }
+
+  try {
+    const raw = loadRawConfig() as Record<string, unknown>;
+    const memory =
+      raw.memory != null && typeof raw.memory === "object"
+        ? (raw.memory as Record<string, unknown>)
+        : {};
+    const v2 =
+      memory.v2 != null && typeof memory.v2 === "object"
+        ? (memory.v2 as Record<string, unknown>)
+        : {};
+
+    raw.memory = {
+      ...memory,
+      v2: {
+        ...v2,
+        ...consolidationPatch,
+      },
+    };
+    saveRawConfig(raw);
+    invalidateConfigCache();
+    if (disablingAutomaticConsolidation) {
+      cancelPendingAutomaticConsolidationJobs();
+    }
+  } catch {
+    throw new InternalError("Failed to save consolidation config");
+  }
+
+  return readConsolidationConfigResponse();
+}
+
 // ---------------------------------------------------------------------------
 // Shared ROUTES
 // ---------------------------------------------------------------------------
@@ -74,18 +142,36 @@ export const ROUTES: RouteDefinition[] = [
       success: z.boolean(),
     }),
     handler: async (_args: RouteHandlerArgs) => {
-      const enabled = getConfig().memory.v2.enabled;
-      const intervalMs = consolidationIntervalMs();
-      const lastRunAt = readLastRunAt();
-      const nextRunAt = lastRunAt != null ? lastRunAt + intervalMs : null;
-      return {
-        available: enabled,
-        enabled,
-        intervalMs,
-        nextRunAt,
-        lastRunAt,
-        success: true,
-      };
+      return readConsolidationConfigResponse();
+    },
+  },
+  {
+    operationId: "updateConsolidationConfig",
+    endpoint: "consolidation/config",
+    method: "PUT",
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Update consolidation config",
+    description: "Update the memory v2 consolidation schedule configuration.",
+    tags: ["consolidation"],
+    requestBody: z.object({
+      enabled: z
+        .boolean()
+        .optional()
+        .describe("Enable or disable automatic consolidation"),
+    }),
+    responseBody: z.object({
+      available: z.boolean(),
+      enabled: z.boolean(),
+      intervalMs: z.number(),
+      nextRunAt: z.number().nullable(),
+      lastRunAt: z.number().nullable(),
+      success: z.boolean(),
+    }),
+    handler: async ({ body = {} }: RouteHandlerArgs) => {
+      return handleUpdateConfig(body);
     },
   },
   {
@@ -117,7 +203,9 @@ export const ROUTES: RouteDefinition[] = [
       if (hasActiveJobOfType("memory_v2_consolidate")) {
         return { success: true, ran: false, jobId: null };
       }
-      const jobId = enqueueMemoryJob("memory_v2_consolidate", {});
+      const jobId = enqueueMemoryJob("memory_v2_consolidate", {
+        trigger: MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS.manual,
+      });
       return { success: true, ran: true, jobId };
     },
   },
@@ -170,6 +258,9 @@ export const ROUTES: RouteDefinition[] = [
             skipReason: z.string().nullable(),
             error: z.string().nullable(),
             conversationId: z.string().nullable(),
+            conversationExists: z.boolean(),
+            conversationArchivedAt: z.number().nullable(),
+            estimatedCostUsd: z.number(),
             createdAt: z.number(),
           }),
         )
@@ -195,24 +286,33 @@ export const ROUTES: RouteDefinition[] = [
         rows.map((r) => r.id),
         "assistant",
       );
+      const now = Date.now();
       return {
         runs: rows.map((c) => {
           const stat = assistantStats.get(c.id);
           const hasAssistantOutput = (stat?.count ?? 0) > 0;
           const finishedAt = hasAssistantOutput ? stat!.lastAt : null;
+          const estimatedCostUsd =
+            c.totalEstimatedCost > 0
+              ? c.totalEstimatedCost
+              : getUsageCostForConversationWindow({
+                  conversationId: c.id,
+                  from: c.createdAt,
+                  to: finishedAt ?? now,
+                });
           return {
             id: c.id,
             scheduledFor: c.createdAt,
             startedAt: c.createdAt,
             finishedAt,
-            durationMs:
-              finishedAt != null ? finishedAt - c.createdAt : null,
-            status: (hasAssistantOutput ? "ok" : "running") as
-              | "ok"
-              | "running",
+            durationMs: finishedAt != null ? finishedAt - c.createdAt : null,
+            status: (hasAssistantOutput ? "ok" : "running") as "ok" | "running",
             skipReason: null,
             error: null,
             conversationId: c.id,
+            conversationExists: true,
+            conversationArchivedAt: c.archivedAt,
+            estimatedCostUsd,
             createdAt: c.createdAt,
           };
         }),

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

@@ -1171,6 +1171,8 @@ export const ROUTES: RouteDefinition[] = [
     description:
       "Deep-merge a partial JSON object into the settings.json configuration.",
     tags: ["config"],
+    requestBody: z.record(z.string(), z.unknown()),
+    responseBody: z.object({ ok: z.boolean() }),
     handler: handlePatchConfig,
   },
   {