@vellumai/assistant 0.7.0 → 0.7.1

package/scripts/generate-openapi.ts

@@ -4,10 +4,9 @@
  * HTTP route definitions.
  *
  * Pipeline:
- *   1. Programmatically import and invoke all *RouteDefinitions() exports
- *      from src/runtime/routes/ — no regex, no source-text parsing.
- *   2. Combine with inline routes (defined in buildRouteTable()) and
- *      pre-auth / non-v1 routes.
+ *   1. Programmatically import every route module under src/runtime/routes/
+ *      and collect all exported ROUTES arrays — no regex, no source-text parsing.
+ *   2. Combine with pre-auth / non-v1 routes.
  *   3. Convert to OpenAPI path items.
  *   4. Write to openapi.yaml.
  *
@@ -132,40 +131,12 @@ function toJSONSchemaObject(schema: unknown): JSONSchemaObject {
 // ---------------------------------------------------------------------------
 
 /**
- * Create a recursive proxy that stands in for any dependency object.
+ * Dynamically import every route module under `src/runtime/routes/`
+ * and collect all exported `ROUTES` arrays.
  *
- * Route definition functions capture deps in handler closures but never
- * access them during array construction, so this stub is never actually
- * invoked at runtime — it just needs to be truthy and not throw when
- * properties are read or the value is called as a function.
- */
-function createDeepStub(): unknown {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const stub: any = new Proxy(function () {}, {
-    get(_target, prop) {
-      // Prevent the stub from being treated as a Promise (await-able).
-      if (prop === "then") return undefined;
-      // Prevent infinite iteration.
-      if (prop === Symbol.iterator) return undefined;
-      // String coercion.
-      if (prop === Symbol.toPrimitive) return () => "";
-      return createDeepStub();
-    },
-    apply() {
-      return createDeepStub();
-    },
-  });
-  return stub;
-}
-
-/**
- * Dynamically import every route module under `src/runtime/routes/`,
- * find all exported functions whose names end with `RouteDefinitions`,
- * invoke each with a deep stub as its first argument, and collect the
- * `{ endpoint, method }` pairs from the returned arrays.
- *
- * This replaces the previous regex + balanced-brace scanning approach
- * and automatically picks up new route modules without manual updates.
+ * Each route module is expected to export a `ROUTES: RouteDefinition[]`
+ * constant. The function automatically picks up new route modules
+ * without manual updates.
  */
 async function collectRoutesFromModules(): Promise<RouteEntry[]> {
   const routes: RouteEntry[] = [];
@@ -191,41 +162,13 @@ async function collectRoutesFromModules(): Promise<RouteEntry[]> {
       continue;
     }
 
-    for (const [exportName, exportValue] of Object.entries(mod)) {
-      if (exportName === "ROUTES" && Array.isArray(exportValue)) {
-        for (const raw of exportValue) {
-          const result = RouteEntrySchema.safeParse({
-            ...(typeof raw === "object" && raw !== null ? raw : {}),
-            sourceModule: file,
-          });
-          if (result.success) routes.push(result.data);
-        }
-        continue;
-      }
-
-      if (
-        !exportName.endsWith("RouteDefinitions") ||
-        typeof exportValue !== "function"
-      ) {
-        continue;
-      }
-
-      try {
-        const rawDefs = exportValue(createDeepStub());
-        if (!Array.isArray(rawDefs)) continue;
-        for (const raw of rawDefs) {
-          const result = RouteEntrySchema.safeParse({
-            ...(typeof raw === "object" && raw !== null ? raw : {}),
-            sourceModule: file,
-          });
-          if (result.success) {
-            routes.push(result.data);
-          }
-        }
-      } catch (err) {
-        console.warn(
-          `Warning: ${exportName}() in ${file} threw: ${err instanceof Error ? err.message : err}`,
-        );
+    if ("ROUTES" in mod && Array.isArray(mod.ROUTES)) {
+      for (const raw of mod.ROUTES) {
+        const result = RouteEntrySchema.safeParse({
+          ...(typeof raw === "object" && raw !== null ? raw : {}),
+          sourceModule: file,
+        });
+        if (result.success) routes.push(result.data);
       }
     }
   }
@@ -233,40 +176,6 @@ async function collectRoutesFromModules(): Promise<RouteEntry[]> {
   return routes;
 }
 
-/**
- * Routes defined inline in RuntimeHttpServer.buildRouteTable() that are
- * not exported from any route module. These are kept here because they
- * depend on cross-cutting concerns specific to the RuntimeHttpServer
- * instance (see B2 in the improvement plan for the recommendation to
- * extract these into modules).
- *
- * Whenever buildRouteTable() gains or loses an inline route, this list
- * must be updated manually. Note: `--check` only compares the generated
- * YAML against the committed YAML, so it will NOT catch a missing entry
- * here if openapi.yaml is also stale. Plan items B2/C2 address this gap.
- */
-const INLINE_ROUTES: RouteEntry[] = [
-  { endpoint: "conversations", method: "GET" },
-  { endpoint: "conversations/seen", method: "POST" },
-  { endpoint: "conversations/unread", method: "POST" },
-  { endpoint: "conversations/:id", method: "GET" },
-  { endpoint: "interfaces/:path*", method: "GET" },
-  { endpoint: "internal/twilio/voice-webhook", method: "POST" },
-  { endpoint: "internal/twilio/status", method: "POST" },
-  { endpoint: "internal/twilio/connect-action", method: "POST" },
-  { endpoint: "internal/oauth/callback", method: "POST" },
-];
-
-/**
- * Pre-auth routes handled directly in routeRequest() before the router.
- * These are a small, stable set that bypass JWT authentication and are
- * not part of the declarative route table.
- */
-const PRE_AUTH_ROUTES: RouteEntry[] = [
-  { method: "POST", endpoint: "pairing/request" },
-  { method: "GET", endpoint: "pairing/status" },
-];
-
 /**
  * Top-level routes outside the /v1/ namespace.
  * These are added to the spec separately.
@@ -551,11 +460,7 @@ async function main() {
   const moduleRoutes = await collectRoutesFromModules();
 
   // Combine all route sources
-  const allRoutes: RouteEntry[] = [
-    ...PRE_AUTH_ROUTES,
-    ...INLINE_ROUTES,
-    ...moduleRoutes,
-  ];
+  const allRoutes: RouteEntry[] = moduleRoutes;
 
   // Build the spec
   const spec = buildSpec(allRoutes, version);

package/src/__tests__/agent-wake-override-profile.test.ts

@@ -20,7 +20,8 @@
  * asserts that:
  *   1. The wake forwards `overrideProfile` to `agentLoop.run`.
  *   2. The wake forwards `callSite: "mainAgent"` to `agentLoop.run`.
- *   3. With both set, `RetryProvider.normalizeSendMessageOptions` actually
+ *   3. The wake resolves and forwards the effective max input token budget.
+ *   4. With both routing keys set, `RetryProvider.normalizeSendMessageOptions` actually
  *      invokes the resolver and replaces workspace defaults with the
  *      pinned-profile values.
  */
@@ -69,6 +70,7 @@ interface RunArgs {
   callSite: unknown;
   turnContext: unknown;
   overrideProfile: string | undefined;
+  effectiveMaxInputTokens: number | undefined;
 }
 
 function makeTarget(): {
@@ -93,6 +95,7 @@ function makeTarget(): {
         callSite?: unknown,
         turnContext?: unknown,
         overrideProfile?: string,
+        effectiveMaxInputTokens?: number,
       ) => {
         runArgs.push({
           messages: [...messages],
@@ -102,6 +105,7 @@ function makeTarget(): {
           callSite,
           turnContext,
           overrideProfile,
+          effectiveMaxInputTokens,
         });
         // Return the input verbatim → silent no-op (no assistant tail).
         return messages;
@@ -133,6 +137,22 @@ afterEach(() => {
 describe("wakeAgentForOpportunity — overrideProfile forwarding", () => {
   test("forwards the conversation's pinned overrideProfile + mainAgent callSite to agentLoop.run", async () => {
     mockOverrideProfile = "frontier";
+    mockLlmConfig = LLMSchema.parse({
+      default: {
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        maxTokens: 64000,
+        contextWindow: { maxInputTokens: 200000 },
+      },
+      profiles: {
+        frontier: {
+          contextWindow: { maxInputTokens: 150000 },
+        },
+      },
+      callSites: {
+        mainAgent: {},
+      },
+    }) as Record<string, unknown>;
     const { target, runArgs } = makeTarget();
 
     const result = await wakeAgentForOpportunity(
@@ -155,6 +175,7 @@ describe("wakeAgentForOpportunity — overrideProfile forwarding", () => {
     // short-circuit and silently drop both the call-site config and the
     // pinned override profile.
     expect(runArgs[0]!.callSite).toBe("mainAgent");
+    expect(runArgs[0]!.effectiveMaxInputTokens).toBe(150000);
     // Sanity: the wake-source tag still propagates as requestId.
     expect(runArgs[0]!.requestId).toBe("wake:scheduler");
   });
@@ -179,6 +200,7 @@ describe("wakeAgentForOpportunity — overrideProfile forwarding", () => {
     // maxTokens, effort, etc.). Otherwise the wake silently runs under
     // workspace defaults regardless of any per-call-site configuration.
     expect(runArgs[0]!.callSite).toBe("mainAgent");
+    expect(runArgs[0]!.effectiveMaxInputTokens).toBeGreaterThan(0);
   });
 });
 

package/src/__tests__/anthropic-provider.test.ts

@@ -374,17 +374,53 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     }>;
 
     const userMessages = sent.filter((m) => m.role === "user");
-    // Only the last user message (turn-starting) gets cache_control
-    for (const user of userMessages.slice(0, -1)) {
-      for (const block of user.content) {
-        expect(block.cache_control).toBeUndefined();
-      }
+    // Oldest user message (Turn 1) has no cache_control
+    for (const block of userMessages[0].content) {
+      expect(block.cache_control).toBeUndefined();
     }
+    // Previous-turn anchor (Turn 2) gets 1h cache on its last block to
+    // preserve the cached prefix across turn transitions
+    const prevTurn = userMessages[userMessages.length - 2];
+    const prevTurnLast = prevTurn.content[prevTurn.content.length - 1];
+    expect(prevTurnLast.cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+    // Current-turn anchor (Turn 3) gets 1h cache on its last block
     const lastUser = userMessages[userMessages.length - 1];
     const lastBlock = lastUser.content[lastUser.content.length - 1];
     expect(lastBlock.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
+  test("previous-turn anchor is NOT applied during a tool-use loop", async () => {
+    // When the request is mid tool-use (last msg is a tool_result), the
+    // turn-start anchor already covers the long prefix, so we must not
+    // place a second anchor on the prior turn — that would push us over
+    // the 4-breakpoint budget without adding cache value.
+    const messages: Message[] = [
+      userMsg("Turn 1"),
+      assistantMsg("Response 1"),
+      userMsg("Turn 2"),
+      toolUseMsg("tu_1", "bash"),
+      toolResultMsg("tu_1", "output"),
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    // Turn 1 user message must have no cache_control (would be the
+    // prev-turn-anchor if we applied it, which we shouldn't here)
+    const turn1 = sent[0];
+    for (const block of turn1.content) {
+      expect(block.cache_control).toBeUndefined();
+    }
+  });
+
   // -----------------------------------------------------------------------
   // Negative: assistant messages never get cache_control
   // -----------------------------------------------------------------------
@@ -1621,7 +1657,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(sent[4].content[0].text).toBe("Follow-up question");
   });
 
-  test("multi-turn with workspace injection: only last user message gets 1h cache", async () => {
+  test("multi-turn with workspace injection: prev-turn + last user message get 1h cache", async () => {
     const messages: Message[] = [
       {
         role: "user",
@@ -1669,14 +1705,21 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     const userMsgs = sent.filter((m) => m.role === "user");
     expect(userMsgs).toHaveLength(3);
 
-    // Earlier user messages: no cache_control
-    for (const user of userMsgs.slice(0, -1)) {
-      for (const block of user.content) {
-        expect(block.cache_control).toBeUndefined();
-      }
+    // Oldest user message (turn 1): no cache_control
+    for (const block of userMsgs[0].content) {
+      expect(block.cache_control).toBeUndefined();
     }
 
-    // Last user message (turn 3): 1h cache on last block only
+    // Previous-turn anchor (turn 2): 1h cache on last block to preserve the
+    // cached prefix across turn transitions
+    const prevTurn = userMsgs[userMsgs.length - 2];
+    expect(prevTurn.content[0].cache_control).toBeUndefined();
+    expect(prevTurn.content[1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+
+    // Current-turn anchor (turn 3): 1h cache on last block
     const lastUser = userMsgs[userMsgs.length - 1];
     expect(lastUser.content[0].cache_control).toBeUndefined();
     expect(lastUser.content[1].cache_control).toEqual({
@@ -2100,7 +2143,7 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
     expect(system[0].cache_control).not.toHaveProperty("ttl");
   });
 
-  test("betas array is empty for Haiku (no extended cache TTL or 1M context)", async () => {
+  test("betas array is empty for Haiku (no extended cache TTL)", async () => {
     await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
 
     // When betas is empty, the non-beta stream path is used, so no betas

package/src/__tests__/app-conversation-ids-backfill.test.ts

@@ -0,0 +1,278 @@
+import { existsSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  addAppConversationId,
+  backfillAppConversationIds,
+  createApp,
+  getApp,
+} from "../memory/app-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { rawRun } from "../memory/raw-query.js";
+
+// Initialize db once for all tests
+initializeDb();
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let testDataDir: string;
+
+function freshTempDir(): string {
+  return join(
+    tmpdir(),
+    `vellum-app-backfill-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+}
+
+function makeAppParams(name: string) {
+  return {
+    name,
+    schemaJson: "{}",
+    htmlDefinition: "<h1>Hello</h1>",
+  };
+}
+
+/** Insert a message row with the given conversation_id and content JSON. */
+function insertMessage(
+  conversationId: string,
+  content: unknown[],
+  role = "assistant",
+): void {
+  const id = `msg-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const contentStr = JSON.stringify(content);
+  rawRun(
+    `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)`,
+    id,
+    conversationId,
+    role,
+    contentStr,
+    Date.now(),
+  );
+}
+
+/** Insert a conversation row so FK constraints are satisfied. */
+function insertConversation(id: string): void {
+  const now = Date.now();
+  rawRun(
+    `INSERT OR IGNORE INTO conversations (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)`,
+    id,
+    "test",
+    now,
+    now,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  // Clean database tables between tests
+  const db = getDb();
+  db.run(`DELETE FROM messages`);
+  db.run(`DELETE FROM conversations`);
+
+  // Fresh temp dir for app-store filesystem operations
+  testDataDir = freshTempDir();
+  process.env.VELLUM_WORKSPACE_DIR = testDataDir;
+});
+
+afterEach(() => {
+  if (existsSync(testDataDir)) {
+    rmSync(testDataDir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// backfillAppConversationIds
+// ---------------------------------------------------------------------------
+
+describe("backfillAppConversationIds", () => {
+  test("populates conversationIds from ui_surface blocks in messages", () => {
+    const app = createApp(makeAppParams("My App"));
+    const convId = "conv-backfill-1";
+    insertConversation(convId);
+
+    // Insert a message with a ui_surface block referencing the app
+    insertMessage(convId, [
+      { type: "text", text: "Here is your app" },
+      {
+        type: "ui_surface",
+        surfaceType: "dynamic_page",
+        data: { appId: app.id, html: "<h1>App</h1>" },
+      },
+    ]);
+
+    backfillAppConversationIds();
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toEqual([convId]);
+  });
+
+  test("handles multiple apps and conversations", () => {
+    const app1 = createApp(makeAppParams("App One"));
+    const app2 = createApp(makeAppParams("App Two"));
+    const conv1 = "conv-multi-1";
+    const conv2 = "conv-multi-2";
+    insertConversation(conv1);
+    insertConversation(conv2);
+
+    // app1 referenced in conv1 and conv2
+    insertMessage(conv1, [
+      {
+        type: "ui_surface",
+        surfaceType: "dynamic_page",
+        data: { appId: app1.id, html: "<h1>A1</h1>" },
+      },
+    ]);
+    insertMessage(conv2, [
+      {
+        type: "ui_surface",
+        surfaceType: "dynamic_page",
+        data: { appId: app1.id, html: "<h1>A1</h1>" },
+      },
+    ]);
+
+    // app2 referenced only in conv2
+    insertMessage(conv2, [
+      {
+        type: "ui_surface",
+        surfaceType: "dynamic_page",
+        data: { appId: app2.id, html: "<h1>A2</h1>" },
+      },
+    ]);
+
+    backfillAppConversationIds();
+
+    const loaded1 = getApp(app1.id);
+    expect(loaded1?.conversationIds?.sort()).toEqual([conv1, conv2].sort());
+
+    const loaded2 = getApp(app2.id);
+    expect(loaded2?.conversationIds).toEqual([conv2]);
+  });
+
+  test("is idempotent — running twice does not duplicate associations", () => {
+    const app = createApp(makeAppParams("Idempotent App"));
+    const convId = "conv-idemp-1";
+    insertConversation(convId);
+
+    insertMessage(convId, [
+      {
+        type: "ui_surface",
+        surfaceType: "dynamic_page",
+        data: { appId: app.id, html: "<h1>App</h1>" },
+      },
+    ]);
+
+    backfillAppConversationIds();
+    backfillAppConversationIds();
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toEqual([convId]);
+  });
+
+  test("apps with no message references remain unchanged", () => {
+    const app = createApp(makeAppParams("Untouched App"));
+    const convId = "conv-unrelated";
+    insertConversation(convId);
+
+    // Insert a message with no ui_surface blocks
+    insertMessage(convId, [{ type: "text", text: "Hello world" }]);
+
+    backfillAppConversationIds();
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toBeUndefined();
+  });
+
+  test("skips malformed message rows without error", () => {
+    const app = createApp(makeAppParams("Robust App"));
+    const convId = "conv-malformed";
+    insertConversation(convId);
+
+    // Insert a message with invalid JSON that happens to match the LIKE filter
+    const msgId = `msg-malformed-${Date.now()}`;
+    rawRun(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)`,
+      msgId,
+      convId,
+      "assistant",
+      'not valid json but has "type":"ui_surface" in it',
+      Date.now(),
+    );
+
+    // Also insert a valid message referencing the app
+    const convId2 = "conv-valid";
+    insertConversation(convId2);
+    insertMessage(convId2, [
+      {
+        type: "ui_surface",
+        surfaceType: "dynamic_page",
+        data: { appId: app.id, html: "<h1>App</h1>" },
+      },
+    ]);
+
+    // Should not throw, and should still process the valid message
+    backfillAppConversationIds();
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toEqual([convId2]);
+  });
+
+  test("skips ui_surface blocks without data.appId", () => {
+    const app = createApp(makeAppParams("No AppId App"));
+    const convId = "conv-no-appid";
+    insertConversation(convId);
+
+    // ui_surface block without appId in data
+    insertMessage(convId, [
+      {
+        type: "ui_surface",
+        surfaceType: "card",
+        data: { title: "Hello", body: "World" },
+      },
+    ]);
+
+    backfillAppConversationIds();
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toBeUndefined();
+  });
+
+  test("preserves existing conversationIds added before backfill", () => {
+    const app = createApp(makeAppParams("Pre-existing App"));
+    const existingConvId = "conv-existing";
+    const backfillConvId = "conv-from-backfill";
+    insertConversation(existingConvId);
+    insertConversation(backfillConvId);
+
+    // Manually add a conversationId before backfill
+    addAppConversationId(app.id, existingConvId);
+
+    // Insert a message referencing the app from a different conversation
+    insertMessage(backfillConvId, [
+      {
+        type: "ui_surface",
+        surfaceType: "dynamic_page",
+        data: { appId: app.id, html: "<h1>App</h1>" },
+      },
+    ]);
+
+    backfillAppConversationIds();
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toEqual([existingConvId, backfillConvId]);
+  });
+});