@vellumai/assistant 0.11.2-dev.202608052324.a11da34 → 0.11.2-dev.202608060040.fd8f444

package/openapi.yaml

@@ -9623,6 +9623,9 @@ paths:
                 cronRunId:
                   type: string
                   minLength: 1
+                scheduleId:
+                  type: string
+                  minLength: 1
                 persist:
                   type: boolean
                 externalContent:
@@ -20880,6 +20883,10 @@ paths:
       responses:
         "200":
           description: Successful response
+        "403":
+          description: The queued message was enqueued by a different actor principal.
+        "404":
+          description: Conversation or queued message not found.
   /v1/migrations/export:
     post:
       operationId: migrations_export_post
@@ -25470,6 +25477,12 @@ paths:
           schema:
             type: string
           description: When 'true', include deferred schedules that are normally hidden.
+        - name: inference_profile
+          in: query
+          required: false
+          schema:
+            type: string
+          description: Return only schedules pinned to this inference profile (llm.profiles key).
       responses:
         "200":
           description: Successful response
@@ -25587,6 +25600,8 @@ paths:
                             - type: "null"
                         isOneShot:
                           type: boolean
+                        isDeferred:
+                          type: boolean
                       required:
                         - id
                         - name
@@ -25618,6 +25633,7 @@ paths:
                         - wakeConversationId
                         - workflowName
                         - isOneShot
+                        - isDeferred
                       additionalProperties: false
                     description: Schedule objects
                 required:
@@ -25679,8 +25695,10 @@ paths:
                     - type: string
                     - type: "null"
                   description:
-                    Inference profile (llm.profiles key) the schedule's runs use. Omitted or null = default, i.e. the mainAgent
-                    call-site model selection.
+                    Inference profile (llm.profiles key) the schedule's runs use. Omitted or null pins the schedule to the
+                    currently resolved default profile, so its model does not move when that default changes.
+                    Workflow-mode schedules resolve a model per workflow step, so the pin is recorded but does not
+                    govern their runs.
               required:
                 - name
                 - expression
@@ -25799,6 +25817,8 @@ paths:
                           - type: "null"
                       isOneShot:
                         type: boolean
+                      isDeferred:
+                        type: boolean
                     required:
                       - id
                       - name
@@ -25830,6 +25850,7 @@ paths:
                       - wakeConversationId
                       - workflowName
                       - isOneShot
+                      - isDeferred
                     additionalProperties: false
                     description: The created schedule
                 required:
@@ -25965,6 +25986,8 @@ paths:
                             - type: "null"
                         isOneShot:
                           type: boolean
+                        isDeferred:
+                          type: boolean
                       required:
                         - id
                         - name
@@ -25996,6 +26019,7 @@ paths:
                         - wakeConversationId
                         - workflowName
                         - isOneShot
+                        - isDeferred
                       additionalProperties: false
                     description: Updated schedule list
                 required:
@@ -26128,6 +26152,8 @@ paths:
                           - type: "null"
                       isOneShot:
                         type: boolean
+                      isDeferred:
+                        type: boolean
                     required:
                       - id
                       - name
@@ -26159,6 +26185,7 @@ paths:
                       - wakeConversationId
                       - workflowName
                       - isOneShot
+                      - isDeferred
                     additionalProperties: false
                     description: Schedule object
                 required:
@@ -26231,8 +26258,9 @@ paths:
                     - type: string
                     - type: "null"
                   description:
-                    Inference profile (llm.profiles key) the schedule's runs use; null clears it back to the default mainAgent
-                    call-site model selection
+                    Inference profile (llm.profiles key) the schedule's runs use; null re-pins the schedule to the currently
+                    resolved default profile. Workflow-mode schedules resolve a model per workflow step, so the pin is
+                    recorded but does not govern their runs.
       responses:
         "200":
           description: Successful response
@@ -26350,6 +26378,8 @@ paths:
                             - type: "null"
                         isOneShot:
                           type: boolean
+                        isDeferred:
+                          type: boolean
                       required:
                         - id
                         - name
@@ -26381,6 +26411,7 @@ paths:
                         - wakeConversationId
                         - workflowName
                         - isOneShot
+                        - isDeferred
                       additionalProperties: false
                     description: Updated schedule list
                 required:
@@ -26516,6 +26547,8 @@ paths:
                             - type: "null"
                         isOneShot:
                           type: boolean
+                        isDeferred:
+                          type: boolean
                       required:
                         - id
                         - name
@@ -26547,6 +26580,7 @@ paths:
                         - wakeConversationId
                         - workflowName
                         - isOneShot
+                        - isDeferred
                       additionalProperties: false
                     description: Updated schedule list
                 required:
@@ -26682,6 +26716,8 @@ paths:
                             - type: "null"
                         isOneShot:
                           type: boolean
+                        isDeferred:
+                          type: boolean
                       required:
                         - id
                         - name
@@ -26713,6 +26749,7 @@ paths:
                         - wakeConversationId
                         - workflowName
                         - isOneShot
+                        - isDeferred
                       additionalProperties: false
                     description: Updated schedule list
                 required:
@@ -26985,6 +27022,8 @@ paths:
                             - type: "null"
                         isOneShot:
                           type: boolean
+                        isDeferred:
+                          type: boolean
                       required:
                         - id
                         - name
@@ -27016,11 +27055,52 @@ paths:
                         - wakeConversationId
                         - workflowName
                         - isOneShot
+                        - isDeferred
                       additionalProperties: false
                     description: Updated schedule list
                 required:
                   - schedules
                 additionalProperties: false
+  /v1/schedules/reassign-profile:
+    post:
+      operationId: schedules_reassignprofile_post
+      summary: Reassign schedules to another inference profile
+      description:
+        Move schedules onto one inference profile. Pass 'from' to move only the schedules pinned to that profile,
+        so deleting a profile does not leave its schedules pointing at a name that no longer exists. Omit 'from' to move
+        every schedule, which re-pins the whole set onto one profile. Schedules already pinned to the target are
+        skipped.
+      tags:
+        - schedules
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                from:
+                  description: Inference profile key the schedules are pinned to now; omit to select every schedule
+                  type: string
+                to:
+                  type: string
+                  description: Inference profile key to move them to; must be configured
+              required:
+                - to
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  reassigned:
+                    type: number
+                    description: Number of schedules moved
+                required:
+                  - reassigned
+                additionalProperties: false
   /v1/schedules/usage-summary:
     get:
       operationId: schedules_usagesummary_get

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.2-dev.202608052324.a11da34",
+  "version": "0.11.2-dev.202608060040.fd8f444",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-loop-mutable-latest-user-message.test.ts

@@ -1,36 +1,22 @@
 /**
- * Verifies that the memory-v3-live cache-anchor signal surfaces on every
- * `SendMessageOptions.config` the loop emits. When v3-live is on, the latest
- * user message carries a volatile `<memory>` block, so the loop sets
- * `providerConfig.mutableLatestUserMessage` to tell the provider to anchor its
- * long-TTL cache breakpoint on the most recent STABLE message instead.
+ * Verifies how the loop derives the `mutableLatestUserMessage` cache-anchor
+ * signal on `SendMessageOptions.config`.
  *
- * The loop reads `config.memory.v3.live` directly where it assembles
- * `providerConfig`, so the signal is sourced from config rather than a run
- * option. When v3-live is off the field is omitted (not `false`/`undefined`) so
- * the wire stays byte-identical to today.
+ * The signal means "the latest user message's bytes do not recur next turn", so
+ * it is set from the history actually being sent: only when the latest user
+ * message carries a memory-v3 `<memory_spotlight>` block, the one injected
+ * block that is strip-and-replaced on the tail every turn. Every other injected
+ * block is frozen into history and re-renders byte-identically, so turns
+ * without a spotlight keep a normal cache anchor even when memory-v3 is live.
+ *
+ * When no spotlight is present the field is omitted entirely (not `false`) so
+ * the wire stays byte-identical for conversations that never see one.
  */
 
-import { afterEach, describe, expect, mock, test } from "bun:test";
-
-// AgentLoop reads the v3-live gate (`config.memory.v3.live`) via
-// `isMemoryV3Live` to decide the cache-anchor signal; drive it per-test.
-let memoryV3LiveSlot = false;
-mock.module("../config/memory-v3-gate.js", () => ({
-  isMemoryV3Live: () => memoryV3LiveSlot,
-  isV3TierActive: () => memoryV3LiveSlot,
-  isMemoryEnabled: (config?: { memory?: { enabled?: boolean } }) =>
-    config?.memory?.enabled !== false,
-  usesConceptPageMemory: (memory?: {
-    enabled?: boolean;
-    v2?: { enabled?: boolean };
-    v3?: { live?: boolean };
-  }) =>
-    memory?.enabled !== false &&
-    (memory?.v3?.live === true || memory?.v2?.enabled === true),
-}));
+import { describe, expect, test } from "bun:test";
 
 import { AgentLoop } from "../agent/loop.js";
+import { wrapMemorySpotlightBlock } from "../plugins/defaults/memory/memory-marker.js";
 import type {
   Message,
   Provider,
@@ -44,6 +30,15 @@ const userMessage: Message = {
   content: [{ type: "text", text: "hi" }],
 };
 
+/** A user turn whose tail block is the ephemeral memory-v3 spotlight. */
+const spotlightUserMessage: Message = {
+  role: "user",
+  content: [
+    { type: "text", text: "hi" },
+    { type: "text", text: wrapMemorySpotlightBlock("recalled: Alice's plan") },
+  ],
+};
+
 function textResponse(text: string): ProviderResponse {
   return {
     content: [{ type: "text", text }],
@@ -87,40 +82,52 @@ function makeRecordingProvider(responses: ProviderResponse[]): {
   return { provider, configs: () => configs };
 }
 
-describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () => {
-  afterEach(() => {
-    memoryV3LiveSlot = false;
-  });
+const echoTool: ToolDefinition = {
+  name: "echo",
+  description: "Echo back the input",
+  input_schema: {
+    type: "object",
+    properties: { value: { type: "string" } },
+  },
+};
 
-  test("sets mutableLatestUserMessage on every LLM call when memory-v3-live is on (multi-turn)", async () => {
-    // GIVEN memory-v3-live is enabled
-    memoryV3LiveSlot = true;
+describe("AgentLoop.run: mutableLatestUserMessage from spotlight presence", () => {
+  test("sets mutableLatestUserMessage when the latest user message carries a spotlight block", async () => {
+    // GIVEN a provider that records the config of each LLM call
+    const { provider, configs } = makeRecordingProvider([textResponse("done")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      config: { maxTokens: 1024 },
+    });
 
-    // AND a provider that records the config of each LLM call across a tool round-trip
-    const { provider, configs } = makeRecordingProvider([
-      toolUseResponse("t1", "echo", { value: "first" }),
-      textResponse("done"),
-    ]);
-    const dummyTools: ToolDefinition[] = [
-      {
-        name: "echo",
-        description: "Echo back the input",
-        input_schema: {
-          type: "object",
-          properties: { value: { type: "string" } },
-        },
-      },
-    ];
+    // WHEN the loop runs over a history whose tail carries the spotlight
+    await loop.run({
+      requestId: "test-request",
+      messages: [spotlightUserMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
+
+    // THEN the send carries the cache-anchor signal
+    expect(configs()).toHaveLength(1);
+    expect(configs()[0]?.mutableLatestUserMessage).toBe(true);
+  });
+
+  test("omits mutableLatestUserMessage when the latest user message carries no spotlight", async () => {
+    // GIVEN a provider that records the config of each LLM call
+    const { provider, configs } = makeRecordingProvider([textResponse("hi")]);
     const loop = new AgentLoop({
-      provider: provider,
+      provider,
       systemPrompt: "system",
       conversationId: "test-conversation",
       config: { maxTokens: 1024 },
-      tools: dummyTools,
-      toolExecutor: async () => ({ content: "ok", isError: false }),
     });
 
-    // WHEN the loop runs
+    // WHEN the loop runs over a spotlight-free history: the shape memory-v3
+    // produces whenever it selects nothing to spotlight
     await loop.run({
       requestId: "test-request",
       messages: [userMessage],
@@ -129,21 +136,16 @@ describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () =>
       callSite: "mainAgent",
     });
 
-    // THEN every send (initial + tool round-trip) carries the cache-anchor signal
-    expect(configs()).toHaveLength(2);
-    for (const cfg of configs()) {
-      expect(cfg?.mutableLatestUserMessage).toBe(true);
-    }
+    // THEN the field is omitted entirely, not carried as false/undefined
+    expect(configs()).toHaveLength(1);
+    expect("mutableLatestUserMessage" in (configs()[0] ?? {})).toBe(false);
   });
 
-  test("omits mutableLatestUserMessage when memory-v3-live is off (flag-off byte-identity)", async () => {
-    // GIVEN memory-v3-live is off (no override; registry default is false)
-    memoryV3LiveSlot = false;
-
-    // AND a provider that records the config of each LLM call
+  test("a text block merely opening with the spotlight tag is not treated as volatile", async () => {
+    // GIVEN a user message discussing the marker rather than carrying one
     const { provider, configs } = makeRecordingProvider([textResponse("hi")]);
     const loop = new AgentLoop({
-      provider: provider,
+      provider,
       systemPrompt: "system",
       conversationId: "test-conversation",
       config: { maxTokens: 1024 },
@@ -152,14 +154,59 @@ describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () =>
     // WHEN the loop runs
     await loop.run({
       requestId: "test-request",
-      messages: [userMessage],
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: "<memory_spotlight>\nwhat does this tag do?",
+            },
+          ],
+        },
+      ],
       onEvent: () => {},
       trust: { sourceChannel: "vellum", trustClass: "unknown" },
       callSite: "mainAgent",
     });
 
-    // THEN the field is omitted entirely, not carried as false/undefined
+    // THEN the unterminated wrapper does not count: matching the full-wrapper
+    // requirement the per-turn strip applies
     expect(configs()).toHaveLength(1);
     expect("mutableLatestUserMessage" in (configs()[0] ?? {})).toBe(false);
   });
+
+  test("the signal holds for every request in a tool loop", async () => {
+    // GIVEN a spotlight-bearing opening message and a tool round-trip
+    const { provider, configs } = makeRecordingProvider([
+      toolUseResponse("t1", "echo", { value: "first" }),
+      textResponse("done"),
+    ]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      config: { maxTokens: 1024 },
+      tools: [echoTool],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+
+    // WHEN the loop runs
+    await loop.run({
+      requestId: "test-request",
+      messages: [spotlightUserMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
+
+    // THEN both calls report the turn as volatile. The signal describes the
+    // turn-starting message, not whichever user message happens to be last, so
+    // the trailing tool-result turn does not clear it. Holding it steady is
+    // what keeps the provider marking that one block at a single TTL for the
+    // whole turn instead of writing it twice.
+    expect(configs()).toHaveLength(2);
+    expect(configs()[0]?.mutableLatestUserMessage).toBe(true);
+    expect(configs()[1]?.mutableLatestUserMessage).toBe(true);
+  });
 });

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

@@ -781,10 +781,11 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(prevLast.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
-  test("mutableLatestUserMessage: during a tool-use loop placement is unchanged (block is fixed within the turn)", async () => {
-    // Turn-start is not the last message (tool_result follows), so the
-    // turn-start block is fixed for the rest of the turn — the flag must not
-    // move the anchor.
+  test("mutableLatestUserMessage: a volatile turn start keeps the 5m TTL through its tool-use loop", async () => {
+    // The turn start is fixed for the rest of the turn, so it stays markable;
+    // but it is volatile ACROSS turns, so the long TTL would buy a write that
+    // can never be read back. Upgrading it here would also mark the same block
+    // at a second TTL, billing two writes for one reusable prefix.
     const messages: Message[] = [
       userMsg("Turn 1"),
       assistantMsg("Response 1"),
@@ -804,14 +805,12 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       }>;
     }>;
 
-    // Turn-start (Turn 2, index 2) still gets the 1h anchor — within a tool-use
-    // loop the block is fixed, so the volatile-latest flag must not move it.
     const turn2 = sent[2];
     const turn2Last = turn2.content[turn2.content.length - 1];
-    expect(turn2Last.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(turn2Last.cache_control).toEqual({ type: "ephemeral", ttl: "5m" });
   });
 
-  test("mutableLatestUserMessage: first turn with no previous user message does not throw and applies no long-TTL anchor", async () => {
+  test("mutableLatestUserMessage: volatile first turn carries the 5m tail but no long-TTL anchor", async () => {
     await provider.sendMessage([userMsg("First ever turn (volatile)")], {
       config: { mutableLatestUserMessage: true },
     });
@@ -823,9 +822,28 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
         cache_control?: { type: string; ttl?: string };
       }>;
     }>;
-    // Only user message is volatile and there is no prior stable one, so no
-    // 1h anchor and no 5m tail bridge land on any user message — there is no
-    // previous-turn anchor to bridge to. Graceful, no throw.
+    // The only user message is volatile, so it gets no 1h anchor: those bytes
+    // do not recur next turn. It does get the 5m tail; the message is fixed
+    // within its own turn, so the tool-loop calls that follow read the system
+    // prompt, tools, and opening message back instead of re-writing them.
+    const lastBlock = sent[0].content[sent[0].content.length - 1];
+    expect(lastBlock.cache_control).toEqual({ type: "ephemeral", ttl: "5m" });
+  });
+
+  test("mutableLatestUserMessage: volatile first turn with disableTurnStartCache places no message breakpoint", async () => {
+    // One-shot call sites opt out of paying for a turn-start write; the 5m
+    // bridge lands on that same block, so it honors the same opt-out.
+    await provider.sendMessage([userMsg("One-shot (volatile)")], {
+      config: { mutableLatestUserMessage: true, disableTurnStartCache: true },
+    });
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
     const lastBlock = sent[0].content[sent[0].content.length - 1];
     expect(lastBlock.cache_control).toBeUndefined();
   });