@vellumai/assistant 0.8.9-staging.3 → 0.8.9-staging.4

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Vellum Assistant API
-  version: 0.8.8
+  version: 0.8.9
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821
@@ -480,6 +480,8 @@ paths:
                           type: string
                         createdAt:
                           type: number
+                        updatedAt:
+                          type: number
                         version:
                           type: string
                         contentId:
@@ -488,6 +490,7 @@ paths:
                         - id
                         - name
                         - createdAt
+                        - updatedAt
                         - version
                         - contentId
                       additionalProperties: false
@@ -15854,10 +15857,10 @@ paths:
               type: object
               properties: {}
               additionalProperties: false
-  /v1/memory/v3/health:
+  /v1/memory/v3/backfill-sections:
     post:
-      operationId: memory_v3_health_post
-      summary: Print the v3 structural health report (read-only)
+      operationId: memory_v3_backfillsections_post
+      summary: "One-time: embed every page's sections (incl synthetic skill/CLI rows) into the dense store"
       tags:
         - memory
       responses:
@@ -15868,31 +15871,16 @@ paths:
               schema:
                 type: object
                 properties:
-                  rendered:
-                    type: string
-                  counts:
-                    type: object
-                    properties:
-                      unassigned:
-                        type: number
-                      danglingRefs:
-                        type: number
-                      novelClusters:
-                        type: number
-                      oversizedLeaves:
-                        type: number
-                      tinyLeaves:
-                        type: number
-                    required:
-                      - unassigned
-                      - danglingRefs
-                      - novelClusters
-                      - oversizedLeaves
-                      - tinyLeaves
-                    additionalProperties: false
+                  articles:
+                    type: number
+                  sections:
+                    type: number
+                  failures:
+                    type: number
                 required:
-                  - rendered
-                  - counts
+                  - articles
+                  - sections
+                  - failures
                 additionalProperties: false
   /v1/memory/v3/rebuild-index:
     post:
@@ -15914,93 +15902,6 @@ paths:
                 required:
                   - ok
                 additionalProperties: false
-  /v1/memory/v3/reconcile:
-    post:
-      operationId: memory_v3_reconcile_post
-      summary: v1 convergence/prune pass over page+core refs (no rename detection without a prior snapshot)
-      tags:
-        - memory
-      responses:
-        "200":
-          description: Successful response
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  renames:
-                    type: array
-                    items:
-                      type: object
-                      properties:
-                        id:
-                          type: string
-                        oldPath:
-                          type: string
-                        newPath:
-                          type: string
-                      required:
-                        - oldPath
-                        - newPath
-                      additionalProperties: false
-                  deleted:
-                    type: array
-                    items:
-                      type: string
-                  prunedCore:
-                    type: array
-                    items:
-                      type: string
-                required:
-                  - renames
-                  - deleted
-                  - prunedCore
-                additionalProperties: false
-  /v1/memory/v3/set-core:
-    post:
-      operationId: memory_v3_setcore_post
-      summary: Add/remove always-on core leaves (validates + previews cost)
-      tags:
-        - memory
-      responses:
-        "200":
-          description: Successful response
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  nextCore:
-                    type: array
-                    items:
-                      type: string
-                  alwaysOnPageCount:
-                    type: number
-                  written:
-                    type: boolean
-                required:
-                  - nextCore
-                  - alwaysOnPageCount
-                  - written
-                additionalProperties: false
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                add:
-                  type: array
-                  items:
-                    type: string
-                remove:
-                  type: array
-                  items:
-                    type: string
-                write:
-                  type: boolean
-              additionalProperties: false
   /v1/messages:
     get:
       operationId: messages_get

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.9-staging.3",
+  "version": "0.8.9-staging.4",
   "license": "MIT",
   "type": "module",
   "exports": {

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

@@ -2,7 +2,11 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { Anthropic } from "@anthropic-ai/sdk";
 
-import type { Message, ToolDefinition } from "../providers/types.js";
+import type {
+  ContentBlock,
+  Message,
+  ToolDefinition,
+} from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
 // Mock Anthropic SDK — must be before importing the provider
@@ -102,7 +106,6 @@ mock.module("@anthropic-ai/sdk", () => ({
 }));
 
 // Import after mocking
-import { cachedTextBlock } from "../plugins/defaults/memory-v3-shadow/provider-blocks.js";
 import { AnthropicProvider } from "../providers/anthropic/client.js";
 import {
   isPlaceholderSentinelText,
@@ -138,6 +141,18 @@ function toolResultMsg(toolUseId: string, content: string): Message {
   };
 }
 
+// A stable prefix text block carrying a 1h-TTL cache_control breakpoint, as a
+// caller may stamp before the provider sees it. The internal ContentBlock type
+// omits cache_control (only the provider transforms it onto the wire), so reach
+// it via a cast.
+function cachedPrefixBlock(text: string): ContentBlock {
+  return {
+    type: "text",
+    text,
+    cache_control: { type: "ephemeral", ttl: "1h" },
+  } as unknown as ContentBlock;
+}
+
 const sampleTools: ToolDefinition[] = [
   {
     name: "file_read",
@@ -325,13 +340,13 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   });
 
   test("preserves a caller's 1h block cache_control and sends the extended-cache beta (non-Haiku)", async () => {
-    // v3's `cachedTextBlock` stamps a stable prefix block with a 1h TTL; the
-    // non-Haiku path must forward it unchanged and send the beta header.
+    // A caller that stamps a stable prefix block with a 1h TTL: the non-Haiku
+    // path must forward it unchanged and send the beta header.
     await provider.sendMessage([
       {
         role: "user",
         content: [
-          cachedTextBlock("stable pages block"),
+          cachedPrefixBlock("stable pages block"),
           { type: "text", text: "volatile current message" },
         ],
       },
@@ -349,7 +364,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
 
   test("strips ttl from a caller's block cache_control and omits the beta for Haiku", async () => {
     // Haiku doesn't support the extended-cache-ttl beta, so a caller-stamped
-    // 1h ttl (e.g. from `cachedTextBlock`) must be stripped before sending.
+    // 1h ttl on a message block must be stripped before sending.
     const haiku = new AnthropicProvider(
       "sk-ant-test",
       "claude-haiku-4-5-20251001",
@@ -358,7 +373,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       {
         role: "user",
         content: [
-          cachedTextBlock("stable pages block"),
+          cachedPrefixBlock("stable pages block"),
           { type: "text", text: "volatile current message" },
         ],
       },
@@ -385,7 +400,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
         {
           role: "user",
           content: [
-            cachedTextBlock("stable pages block"),
+            cachedPrefixBlock("stable pages block"),
             { type: "text", text: "volatile current message" },
           ],
         },

package/src/__tests__/context-window-manager-compact-retry.test.ts

@@ -56,6 +56,11 @@ let runCalls: Array<{
 let runResults: CompactionRunResult[] = [];
 const estimateReturns: number[] = [];
 
+// Captured arguments from each runEmergencyCompaction invocation, so the
+// emergencyCompact tests can assert the manager fills in the fields it owns.
+let emergencyCalls: Record<string, unknown>[] = [];
+let emergencyResult: CompactionRunResult | undefined;
+
 mock.module("../context/token-estimator.js", () => ({
   estimatePromptTokens: (): number => {
     const next = estimateReturns.shift();
@@ -92,6 +97,15 @@ mock.module("../context/compactor.js", () => ({
     }
     return result;
   },
+  runEmergencyCompaction: async (
+    args: Record<string, unknown>,
+  ): Promise<CompactionRunResult> => {
+    emergencyCalls.push(args);
+    if (!emergencyResult) {
+      throw new Error("emergencyResult not seeded");
+    }
+    return emergencyResult;
+  },
 }));
 
 import { ContextWindowManager } from "../plugins/defaults/compaction/window-manager.js";
@@ -142,24 +156,28 @@ function compactResult(
   };
 }
 
+function makeConfig(maxAttempts: number = 3) {
+  return {
+    enabled: true,
+    maxInputTokens: 200_000,
+    targetBudgetRatio: 0.3,
+    compactThreshold: 0.8,
+    summaryBudgetRatio: 0.05,
+    overflowRecovery: {
+      enabled: true,
+      safetyMarginRatio: 0.05,
+      maxAttempts,
+      interactiveLatestTurnCompression: "summarize" as const,
+      nonInteractiveLatestTurnCompression: "summarize" as const,
+    },
+  };
+}
+
 function buildManager(maxAttempts: number = 3): ContextWindowManager {
   return new ContextWindowManager({
     provider: makeProvider(),
     systemPrompt: "you are a test assistant",
-    config: {
-      enabled: true,
-      maxInputTokens: 200_000,
-      targetBudgetRatio: 0.3,
-      compactThreshold: 0.8,
-      summaryBudgetRatio: 0.05,
-      overflowRecovery: {
-        enabled: true,
-        safetyMarginRatio: 0.05,
-        maxAttempts,
-        interactiveLatestTurnCompression: "summarize",
-        nonInteractiveLatestTurnCompression: "summarize",
-      },
-    },
+    config: makeConfig(maxAttempts),
     conversationId: "conv-test",
   });
 }
@@ -289,3 +307,91 @@ describe("ContextWindowManager.maybeCompact retry budget", () => {
     expect(result.estimatedInputTokens).toBe(165_000);
   });
 });
+
+describe("ContextWindowManager.emergencyCompact", () => {
+  beforeEach(() => {
+    emergencyCalls = [];
+    emergencyResult = undefined;
+    estimateReturns.length = 0;
+  });
+
+  test("supplies manager-owned fields and forwards only overflow inputs", async () => {
+    /**
+     * The manager owns provider, system prompt, token budget, conversation
+     * id, compaction config, and non-persisted prefix count; the caller
+     * provides only the overflow-specific inputs.
+     */
+    // GIVEN a manager seeded with a non-persisted prefix and a canned result
+    emergencyResult = compactResult({
+      compacted: true,
+      compactedMessages: 40,
+      summaryText: "emergency summary",
+    });
+    const manager = buildManager();
+    manager.seedNonPersistedPrefix(3);
+    const messages = makeMessages(8);
+    const signal = new AbortController().signal;
+
+    // WHEN emergency compaction runs
+    const result = await manager.emergencyCompact(
+      messages,
+      { previousEstimatedInputTokens: 242_201, overrideProfile: "fast" },
+      signal,
+    );
+
+    // THEN the manager fills its owned fields and forwards the caller inputs
+    expect(emergencyCalls.length).toBe(1);
+    const args = emergencyCalls[0]!;
+    expect(args.conversationId).toBe("conv-test");
+    expect(args.systemPrompt).toBe("you are a test assistant");
+    expect(args.maxInputTokens).toBe(200_000);
+    expect(args.nonPersistedPrefixCount).toBe(3);
+    expect(args.tools).toBeUndefined();
+    expect(args.force).toBe(true);
+    expect(args.signal).toBe(signal);
+    expect(args.messages).toBe(messages);
+    expect(args.previousEstimatedInputTokens).toBe(242_201);
+    expect(args.overrideProfile).toBe("fast");
+    expect((args.provider as { name: string }).name).toBe("mock-provider");
+    expect(result.summaryText).toBe("emergency summary");
+  });
+
+  test("defaults overrideProfile to null when omitted", async () => {
+    /**
+     * Callers that don't resolve a per-conversation profile get an explicit
+     * null forwarded to the summary call.
+     */
+    // GIVEN a manager and a canned result
+    emergencyResult = compactResult({ compacted: true });
+    const manager = buildManager();
+
+    // WHEN emergency compaction runs without an override profile
+    await manager.emergencyCompact(makeMessages(6), {
+      previousEstimatedInputTokens: 210_000,
+    });
+
+    // THEN overrideProfile is forwarded as null
+    expect(emergencyCalls[0]!.overrideProfile).toBeNull();
+  });
+
+  test("throws when the manager has no conversation id", async () => {
+    /**
+     * Emergency compaction needs a conversation id for attachment and
+     * timestamp lookups; a manager without one cannot run it.
+     */
+    // GIVEN a manager constructed without a conversation id
+    const manager = new ContextWindowManager({
+      provider: makeProvider(),
+      systemPrompt: "you are a test assistant",
+      config: makeConfig(),
+    });
+
+    // WHEN/THEN emergency compaction rejects without invoking the compactor
+    await expect(
+      manager.emergencyCompact(makeMessages(4), {
+        previousEstimatedInputTokens: 210_000,
+      }),
+    ).rejects.toThrow(/conversationId/);
+    expect(emergencyCalls.length).toBe(0);
+  });
+});

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -2,9 +2,9 @@
  * Regression tests for app surface refresh and eventing side effects in
  * createToolExecutor (conversation-tool-setup.ts).
  *
- * Tests verify that app_refresh, app_create, and app_delete hooks fire
- * correctly, and that removed hooks (app_update, app_file_edit,
- * app_file_write) no longer trigger side effects.
+ * Tests verify that app_refresh, app_update, app_create, and app_delete hooks
+ * fire correctly, and that non-hooked tools (app_file_edit, app_file_write) do
+ * not trigger side effects.
  *
  * File-change detection for file_write/file_edit is handled by
  * AppSourceWatcher (see app-source-watcher.test.ts).
@@ -248,6 +248,76 @@ describe("session-tool-setup app refresh side effects", () => {
     });
   });
 
+  // ── app_update ──────────────────────────────────────────────────────
+
+  describe("app_update", () => {
+    test("triggers refreshSurfacesForApp and broadcast on success", async () => {
+      const ctx = makeCtx();
+      const executor = makeFakeExecutor({
+        content: '{"updated":true,"appId":"app-7"}',
+        isError: false,
+      });
+
+      const toolFn = createToolExecutor(
+        executor as unknown as ToolExecutor,
+        noopPrompter,
+        noopSecretPrompter,
+        ctx,
+        noopLifecycleHandler,
+      );
+
+      await toolFn("app_update", { app_id: "app-7" });
+
+      expect(refreshSpy).toHaveBeenCalledTimes(1);
+      expect((refreshSpy.mock.calls as unknown[][])[0][1]).toBe("app-7");
+      expectAppChangeBroadcast("app-7");
+      expect(updatePublishedSpy).toHaveBeenCalledTimes(1);
+      expect((updatePublishedSpy.mock.calls as unknown[][])[0][0]).toBe(
+        "app-7",
+      );
+    });
+
+    test("skips side effects when result is an error", async () => {
+      const ctx = makeCtx();
+      const executor = makeFakeExecutor({
+        content: "Error: not found",
+        isError: true,
+      });
+
+      const toolFn = createToolExecutor(
+        executor as unknown as ToolExecutor,
+        noopPrompter,
+        noopSecretPrompter,
+        ctx,
+        noopLifecycleHandler,
+      );
+
+      await toolFn("app_update", { app_id: "app-err" });
+
+      expect(refreshSpy).not.toHaveBeenCalled();
+      expect(broadcastSpy).not.toHaveBeenCalled();
+      expect(updatePublishedSpy).not.toHaveBeenCalled();
+    });
+
+    test("skips side effects when app_id is missing", async () => {
+      const ctx = makeCtx();
+      const executor = makeFakeExecutor({ content: "{}", isError: false });
+
+      const toolFn = createToolExecutor(
+        executor as unknown as ToolExecutor,
+        noopPrompter,
+        noopSecretPrompter,
+        ctx,
+        noopLifecycleHandler,
+      );
+
+      await toolFn("app_update", {});
+
+      expect(refreshSpy).not.toHaveBeenCalled();
+      expect(broadcastSpy).not.toHaveBeenCalled();
+    });
+  });
+
   // ── app_create side effects ─────────────────────────────────────────
 
   describe("app_create side effects", () => {
@@ -518,7 +588,6 @@ describe("session-tool-setup app refresh side effects", () => {
         "write_file",
         "shell",
         "app_list",
-        "app_update",
         "app_file_edit",
         "app_file_write",
       ]) {

package/src/__tests__/credential-security-invariants.test.ts

@@ -230,6 +230,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "runtime/routes/platform-routes.ts", // CLI platform connect/disconnect/status routes (CLI-migrated to IPC)
       "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
       "daemon/external-plugins-bootstrap.ts", // reads credentials at plugin init (manifest.requiresCredential) via the CES-mediated getSecureKeyAsync path
+      "plugins/external-api.ts", // globalThis runtime bridge that exposes getSecureKeyAsync to dynamically-imported workspace plugins (compiled-binary plugin loading)
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup

package/src/__tests__/llm-resolver.test.ts

@@ -1249,3 +1249,76 @@ describe("resolveDefaultProfileKey", () => {
     expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("balanced");
   });
 });
+
+describe("resolveCallSiteConfig logitBias provenance", () => {
+  const kimi = "accounts/fireworks/models/kimi-k2p6";
+
+  test("forwards logitBias from the active profile that opted in", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "balanced-economy": {
+          provider: "fireworks",
+          model: kimi,
+          logitBias: "suppress-cjk",
+        },
+      },
+      activeProfile: "balanced-economy",
+    });
+    expect(resolveCallSiteConfig("mainAgent", llm).logitBias).toBe(
+      "suppress-cjk",
+    );
+  });
+
+  test("a higher-precedence override profile that omits logitBias clears it", () => {
+    // Active profile opts in, but a pinned (override) Kimi profile did not —
+    // the override must not inherit suppress-cjk just because it resolves to
+    // Fireworks.
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "balanced-economy": {
+          provider: "fireworks",
+          model: kimi,
+          logitBias: "suppress-cjk",
+        },
+        "my-kimi": { provider: "fireworks", model: kimi },
+      },
+      activeProfile: "balanced-economy",
+    });
+    const resolved = resolveCallSiteConfig("mainAgent", llm, {
+      overrideProfile: "my-kimi",
+    });
+    expect(resolved.logitBias).toBeUndefined();
+  });
+
+  test("does not leak the active profile's logitBias into a call site's own profile", () => {
+    // For non-main call sites the call-site profile wins; since it didn't opt
+    // in, the active profile's preset must not bleed through.
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "balanced-economy": {
+          provider: "fireworks",
+          model: kimi,
+          logitBias: "suppress-cjk",
+        },
+        plain: { provider: "anthropic", model: "claude-opus-4-7" },
+      },
+      activeProfile: "balanced-economy",
+      callSites: { memoryExtraction: { profile: "plain" } },
+    });
+    expect(
+      resolveCallSiteConfig("memoryExtraction", llm).logitBias,
+    ).toBeUndefined();
+  });
+
+  test("a logitBias on a non-profile layer (llm.default) does not apply when the winning profile omits it", () => {
+    const llm = LLMSchema.parse({
+      default: { ...fullDefault, logitBias: "suppress-cjk" },
+      profiles: { plain: { provider: "anthropic", model: "claude-opus-4-7" } },
+      activeProfile: "plain",
+    });
+    expect(resolveCallSiteConfig("mainAgent", llm).logitBias).toBeUndefined();
+  });
+});

package/src/__tests__/plugin-external-api.test.ts

@@ -0,0 +1,68 @@
+/**
+ * Tests for the `globalThis.__vellumPluginRuntime` bridge.
+ *
+ * The bridge exists so workspace-local plugins (`<workspaceDir>/plugins/*`)
+ * can register with the daemon's bundled module instances even when the
+ * daemon is a `bun --compile` binary. Absolute-path imports against a
+ * compiled binary load fresh disk copies into a disjoint module graph; the
+ * bridge sidesteps that by attaching a stable handle to globalThis.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getPluginRuntime,
+  installPluginRuntime,
+  uninstallPluginRuntimeForTests,
+} from "../plugins/external-api.js";
+import { registerPlugin } from "../plugins/registry.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { getSecureKeyAsync } from "../security/secure-keys.js";
+
+describe("plugin external-api bridge", () => {
+  beforeEach(() => {
+    uninstallPluginRuntimeForTests();
+  });
+
+  afterEach(() => {
+    uninstallPluginRuntimeForTests();
+  });
+
+  test("installs a runtime handle on globalThis", () => {
+    expect(getPluginRuntime()).toBeUndefined();
+    installPluginRuntime();
+    const runtime = getPluginRuntime();
+    expect(runtime).toBeDefined();
+    expect(runtime?.version).toBe(1);
+  });
+
+  test("exposes the canonical registerPlugin / hub / secrets references", () => {
+    installPluginRuntime();
+    const runtime = getPluginRuntime();
+    expect(runtime?.registerPlugin).toBe(registerPlugin);
+    expect(runtime?.assistantEventHub).toBe(assistantEventHub);
+    expect(runtime?.getSecureKeyAsync).toBe(getSecureKeyAsync);
+  });
+
+  test("plugins can read the runtime via the documented globalThis key", () => {
+    installPluginRuntime();
+    // Mirror the access pattern documented for plugin authors.
+    const runtime = (
+      globalThis as { __vellumPluginRuntime?: { version: number } }
+    ).__vellumPluginRuntime;
+    expect(runtime).toBeDefined();
+    expect(runtime?.version).toBe(1);
+  });
+
+  test("install is idempotent — repeat calls preserve the same handle", () => {
+    installPluginRuntime();
+    const first = getPluginRuntime();
+    installPluginRuntime();
+    installPluginRuntime();
+    expect(getPluginRuntime()).toBe(first);
+  });
+
+  test("getPluginRuntime returns undefined when the bridge is not installed", () => {
+    expect(getPluginRuntime()).toBeUndefined();
+  });
+});