@vellumai/assistant 0.8.9-staging.1 → 0.8.9-staging.2

package/ARCHITECTURE.md

@@ -1088,12 +1088,12 @@ All overflow recovery settings live under `contextWindow.overflowRecovery` in th
 
 ### Key Source Files
 
-| File                                     | Purpose                                                                       |
-| ---------------------------------------- | ----------------------------------------------------------------------------- |
-| `src/daemon/context-overflow-reducer.ts` | Tiered reducer: four-tier pipeline with idempotent steps and cumulative state |
-| `src/daemon/context-overflow-policy.ts`  | Overflow policy resolver: maps config + interactivity to concrete action      |
-| `src/daemon/conversation-agent-loop.ts`  | Integration: preflight budget check, convergence loop, emergency compaction   |
-| `src/config/core-schema.ts`              | `ContextOverflowRecoveryConfigSchema` with defaults and validation            |
+| File                                                          | Purpose                                                                       |
+| ------------------------------------------------------------- | ----------------------------------------------------------------------------- |
+| `src/plugins/defaults/compaction/context-overflow-reducer.ts` | Tiered reducer: four-tier pipeline with idempotent steps and cumulative state |
+| `src/daemon/context-overflow-policy.ts`                       | Overflow policy resolver: maps config + interactivity to concrete action      |
+| `src/daemon/conversation-agent-loop.ts`                       | Integration: preflight budget check, convergence loop, emergency compaction   |
+| `src/config/core-schema.ts`                                   | `ContextOverflowRecoveryConfigSchema` with defaults and validation            |
 
 ---
 

package/openapi.yaml

@@ -19548,11 +19548,13 @@ paths:
       operationId: plugins_install_post
       summary: Install a plugin
       description:
-        Install a plugin by name from the canonical source — a whitelisted `experimental/plugins/marketplace.json`
-        entry, else the first-party `experimental/plugins/<name>/` convention. Materializes the plugin under
-        `<workspaceDir>/plugins/<name>/`; the assistant must be restarted to load it. Mirrors the CLI's `assistant
+        "Install a plugin by name from the canonical source — a whitelisted `experimental/plugins/marketplace.json`
+        entry, else the first-party `experimental/plugins/<name>/` convention. Always resolves against the curated
+        default git ref (no caller-supplied ref): installing from an unreviewed revision would bypass the
+        marketplace/first-party curation boundary and let attacker-controlled code be loaded. Materializes the plugin
+        under `<workspaceDir>/plugins/<name>/`; the assistant must be restarted to load it. Mirrors the CLI's `assistant
         plugins install <name>`. An already-installed name without `force` returns 409; a name that resolves to nothing
-        at the ref returns 404. Sibling to `POST /v1/skills/install`.
+        returns 404. Sibling to `POST /v1/skills/install`."
       tags:
         - plugins
       responses:
@@ -19601,9 +19603,6 @@ paths:
                 name:
                   type: string
                   description: Install name to resolve against the catalog (first-party directory or marketplace entry).
-                ref:
-                  description: Optional git ref to install from. Defaults to the CLI's `DEFAULT_PLUGIN_REF`.
-                  type: string
                 force:
                   description: Overwrite an existing install in place. Defaults to false.
                   type: boolean

package/package.json

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

package/src/__tests__/agent-loop-exit-reason.test.ts

@@ -13,16 +13,21 @@
  * Sites not exercised here (`aborted_via_error`) require deeper provider
  * fakery and are best covered by integration tests.
  */
-import { describe, expect, mock, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 import type {
   AgentEvent,
-  AgentLoopRunOptions,
   CheckpointDecision,
   CheckpointInfo,
 } from "../agent/loop.js";
 import { AgentLoop, isMaxTokensStopReason } from "../agent/loop.js";
+import type { ContextWindowConfig } from "../config/types.js";
 import type { TrustContext } from "../daemon/trust-context.js";
+import {
+  createContextWindowManager,
+  disposeContextWindowManager,
+  getContextWindowManager,
+} from "../plugins/defaults/compaction/manager-store.js";
 import type { PostCompactContext } from "../plugins/defaults/memory-retrieval/hooks/post-compact.js";
 import type {
   Message,
@@ -118,20 +123,26 @@ const userMessage: Message = {
   content: [{ type: "text", text: "Hello" }],
 };
 
-// A trust snapshot plus a context-window manager whose `maybeCompact` returns a
-// canned result, so the loop's compaction call runs without the real
-// orchestrator machinery. Both are supplied to the loop as dedicated run
-// options.
-function fakeCompaction(result: { compacted: boolean; exhausted: boolean }): {
-  trust: TrustContext;
-  contextWindowManager: AgentLoopRunOptions["contextWindowManager"];
-} {
-  return {
-    trust: { sourceChannel: "vellum", trustClass: "unknown" },
-    contextWindowManager: {
-      maybeCompact: async () => result,
-    } as unknown as AgentLoopRunOptions["contextWindowManager"],
-  };
+// Register a context-window manager whose `maybeCompact` returns a canned
+// result in the compaction store the loop resolves from, so the loop's
+// compaction call runs without the real orchestrator machinery. Returns the
+// trust snapshot the loop also needs as a run option.
+function fakeCompaction(
+  conversationId: string,
+  result: { compacted: boolean; exhausted: boolean },
+): { trust: TrustContext } {
+  createContextWindowManager({
+    provider: { name: "mock-provider" } as unknown as Provider,
+    systemPrompt: "system",
+    config: {} as unknown as ContextWindowConfig,
+    conversationId,
+  });
+  const manager = getContextWindowManager(conversationId);
+  if (manager) {
+    manager.maybeCompact = (async () =>
+      result) as unknown as typeof manager.maybeCompact;
+  }
+  return { trust: { sourceChannel: "vellum", trustClass: "unknown" } };
 }
 
 function lastExitEvent(
@@ -152,6 +163,10 @@ function countExitEvents(events: AgentEvent[]): number {
 // ---------------------------------------------------------------------------
 
 describe("AgentLoop exit-reason instrumentation", () => {
+  afterEach(() => {
+    disposeContextWindowManager("test-conversation");
+  });
+
   test("recognizes provider output-token stop reasons", () => {
     expect(isMaxTokensStopReason("max_tokens")).toBe(true);
     expect(isMaxTokensStopReason("MAX_TOKENS")).toBe(true);
@@ -457,7 +472,7 @@ describe("AgentLoop exit-reason instrumentation", () => {
         overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
       }),
       compactInPlace: true,
-      ...fakeCompaction({
+      ...fakeCompaction("test-conversation", {
         compacted: true,
         exhausted: false,
       }),
@@ -502,7 +517,7 @@ describe("AgentLoop exit-reason instrumentation", () => {
         overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
       }),
       compactInPlace: true,
-      ...fakeCompaction({
+      ...fakeCompaction("test-conversation", {
         compacted: false,
         exhausted: true,
       }),

package/src/__tests__/app-builder-tool-scripts.test.ts

@@ -81,6 +81,7 @@ mock.module("../bundler/app-compiler.js", () => ({
 import * as appCreateScript from "../config/bundled-skills/app-builder/tools/app-create.js";
 import * as appDeleteScript from "../config/bundled-skills/app-builder/tools/app-delete.js";
 import * as appRefreshScript from "../config/bundled-skills/app-builder/tools/app-refresh.js";
+import * as appUpdateScript from "../config/bundled-skills/app-builder/tools/app-update.js";
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -171,4 +172,24 @@ describe("app-builder skill tool scripts", () => {
       expect(parsed.appId).toBe("app-1");
     });
   });
+
+  // ---- app-update --------------------------------------------------------
+
+  describe("app-update", () => {
+    test("exports a run function", () => {
+      expect(typeof appUpdateScript.run).toBe("function");
+    });
+
+    test("delegates to executeAppUpdate and returns result", async () => {
+      const result = await appUpdateScript.run(
+        { app_id: "app-1", name: "Renamed" },
+        makeContext(),
+      );
+      expect(result.isError).toBe(false);
+      const parsed = JSON.parse(result.content);
+      expect(parsed.updated).toBe(true);
+      expect(parsed.appId).toBe("app-1");
+      expect(parsed.name).toBe("Renamed");
+    });
+  });
 });

package/src/__tests__/app-executors.test.ts

@@ -32,6 +32,7 @@ import type { AppStore } from "../tools/apps/executors.js";
 import {
   executeAppCreate,
   executeAppRefresh,
+  executeAppUpdate,
 } from "../tools/apps/executors.js";
 
 // ---------------------------------------------------------------------------
@@ -89,6 +90,46 @@ function mockStore(
 // ---------------------------------------------------------------------------
 
 describe("executeAppCreate", () => {
+  test("falls back to the preview title when the name is omitted or blank", async () => {
+    let createdParams: Record<string, unknown> | undefined;
+    const app = makeMultifileApp({ name: "Coffee Tracker" });
+    const store: AppStore = {
+      ...mockStore(app, {}),
+      createApp: (params) => {
+        createdParams = params as unknown as Record<string, unknown>;
+        return app;
+      },
+    };
+
+    const result = await executeAppCreate(
+      { name: "   ", preview: { title: "Coffee Tracker" } },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(createdParams?.name).toBe("Coffee Tracker");
+  });
+
+  test("defaults the name to 'New App' when neither name nor preview title is given", async () => {
+    let createdParams: Record<string, unknown> | undefined;
+    const app = makeMultifileApp({ name: "New App" });
+    const store: AppStore = {
+      ...mockStore(app, {}),
+      createApp: (params) => {
+        createdParams = params as unknown as Record<string, unknown>;
+        return app;
+      },
+    };
+
+    const result = await executeAppCreate(
+      {} as unknown as Parameters<typeof executeAppCreate>[0],
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(createdParams?.name).toBe("New App");
+  });
+
   test("creates multifile app with src/ scaffold", async () => {
     const files: Record<string, string> = {};
     let createdParams: Record<string, unknown> | undefined;
@@ -408,3 +449,94 @@ describe("executeAppRefresh", () => {
     expect(parsed.error).toContain("not found");
   });
 });
+
+// ---------------------------------------------------------------------------
+// executeAppUpdate
+// ---------------------------------------------------------------------------
+
+describe("executeAppUpdate", () => {
+  test("updates metadata and recompiles a multifile app", async () => {
+    const app = makeMultifileApp({ name: "Old", description: "old desc" });
+    let updateArgs: unknown;
+    const store: AppStore = {
+      ...mockStore(app),
+      updateApp: (_id, updates) => {
+        updateArgs = updates;
+        return { ...app, ...updates };
+      },
+    };
+
+    const result = await executeAppUpdate(
+      { app_id: app.id, name: "New Name", description: "new desc" },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(updateArgs).toEqual({ name: "New Name", description: "new desc" });
+    const parsed = JSON.parse(result.content);
+    expect(parsed.updated).toBe(true);
+    expect(parsed.name).toBe("New Name");
+    expect(parsed.description).toBe("new desc");
+    expect(parsed.compiled).toBe(true);
+  });
+
+  test("writes source_files before recompiling", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp();
+    const store: AppStore = {
+      ...mockStore(app, files),
+      updateApp: (_id, updates) => ({ ...app, ...updates }),
+    };
+
+    const result = await executeAppUpdate(
+      { app_id: app.id, source_files: { "src/App.tsx": "// new code" } },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(files["src/App.tsx"]).toBe("// new code");
+    expect(JSON.parse(result.content).compiled).toBe(true);
+  });
+
+  test("legacy app: updates without compiling", async () => {
+    const app = makeLegacyApp({ name: "Legacy" });
+    const store: AppStore = {
+      ...mockStore(app),
+      updateApp: (_id, updates) => ({ ...app, ...updates }),
+    };
+
+    const result = await executeAppUpdate(
+      { app_id: app.id, name: "Renamed" },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.updated).toBe(true);
+    expect(parsed.name).toBe("Renamed");
+    expect(parsed.compiled).toBeUndefined();
+  });
+
+  test("returns error for unknown app", async () => {
+    const store = mockStore(makeMultifileApp());
+    const result = await executeAppUpdate({ app_id: "nope" }, store);
+
+    expect(result.isError).toBe(true);
+    expect(JSON.parse(result.content).error).toContain("not found");
+  });
+
+  test("rejects invalid source_files", async () => {
+    const app = makeMultifileApp();
+    const store = mockStore(app);
+    const result = await executeAppUpdate(
+      {
+        app_id: app.id,
+        source_files: { "src/App.tsx": 123 as unknown as string },
+      },
+      store,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(JSON.parse(result.content).error).toContain("must be a string");
+  });
+});

package/src/__tests__/compactor-web-search-strip.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getMessages: () => [],
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+  getAttachmentContent: () => null,
+}));
+
+import {
+  runAssistantDrivenCompaction,
+  runEmergencyCompaction,
+} from "../context/compactor.js";
+import type { Message, Provider } from "../providers/types.js";
+
+const TAIL_TIMESTAMP =
+  "2026-05-21 (Thursday) 10:00:00 -05:00 (America/Chicago)";
+
+const compactionResponse = `
+<compaction_result>
+<summary>
+Earlier turns summarized here.
+</summary>
+
+<key_state>
+- Nothing critical pending.
+</key_state>
+
+<tail_start timestamp="${TAIL_TIMESTAMP}" preview="tail anchor message" />
+</compaction_result>
+`;
+
+const ENCRYPTED_TOKEN = "expired_encrypted_token_abc123";
+
+const userText = (text: string): Message => ({
+  role: "user",
+  content: [{ type: "text", text }],
+});
+
+const userTextWithTurnContext = (text: string, timestamp: string): Message => ({
+  role: "user",
+  content: [
+    {
+      type: "text",
+      text: `<turn_context>\ncurrent_time: ${timestamp}\n</turn_context>\n${text}`,
+    },
+  ],
+});
+
+const assistantWithWebSearch = (): Message => ({
+  role: "assistant",
+  content: [
+    {
+      type: "server_tool_use",
+      id: "stu_1",
+      name: "web_search",
+      input: { query: "cats" },
+    },
+    {
+      type: "web_search_tool_result",
+      tool_use_id: "stu_1",
+      content: [
+        {
+          type: "web_search_result",
+          url: "https://cats.example",
+          title: "All About Cats",
+          encrypted_content: ENCRYPTED_TOKEN,
+        },
+      ],
+    },
+  ],
+});
+
+const assistantToolUse = (): Message => ({
+  role: "assistant",
+  content: [
+    { type: "tool_use", id: "tu_1", name: "bash", input: { cmd: "ls" } },
+  ],
+});
+
+const toolResult = (): Message => ({
+  role: "user",
+  content: [{ type: "tool_result", tool_use_id: "tu_1", content: "ok" }],
+});
+
+function serializeBlocks(messages: Message[]): string {
+  return JSON.stringify(messages);
+}
+
+// Records the exact message list the provider is asked to summarize.
+function recordingProvider(sink: { sent: Message[] }): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async (msgs: Message[]) => {
+      sink.sent = msgs;
+      return {
+        content: [{ type: "text", text: compactionResponse }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+}
+
+// Expired Anthropic web-search tokens must never reach the summarization LLM:
+// both compaction provider calls funnel through the same request builder, so
+// each is guarded here.
+describe("compaction summary calls — historical web-search sanitization", () => {
+  test("runAssistantDrivenCompaction strips expired encrypted_content from the request while leaving durable history untouched", async () => {
+    // GIVEN a history whose older turn contains a native web_search_tool_result
+    // block carrying an opaque, expired `encrypted_content` token
+    const messages: Message[] = [
+      userText("old user turn"),
+      assistantWithWebSearch(),
+      userTextWithTurnContext("tail anchor message", TAIL_TIMESTAMP),
+      assistantWithWebSearch(),
+    ];
+
+    // AND a snapshot of the caller's array so we can assert it is not mutated
+    const inputSnapshot = serializeBlocks(messages);
+    const sink = { sent: [] as Message[] };
+
+    // WHEN compaction runs over that history
+    const result = await runAssistantDrivenCompaction({
+      conversationId: "conv-web-search",
+      messages,
+      provider: recordingProvider(sink),
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      maxInputTokens: 1000,
+      previousEstimatedInputTokens: 900,
+    });
+
+    // THEN the summary request the provider received carries no expired token
+    // and no native web_search blocks, but keeps the search content as text
+    const sentSerialized = serializeBlocks(sink.sent);
+    expect(sentSerialized).not.toContain(ENCRYPTED_TOKEN);
+    expect(sentSerialized).not.toContain("web_search_tool_result");
+    expect(sentSerialized).not.toContain("server_tool_use");
+    expect(sentSerialized).toContain("All About Cats");
+    expect(sentSerialized).toContain("https://cats.example");
+
+    // AND the caller's durable history array is left byte-for-byte untouched,
+    // so persisted messages keep the original rich blocks
+    expect(serializeBlocks(messages)).toBe(inputSnapshot);
+    expect(result.compacted).toBe(true);
+  });
+
+  test("runEmergencyCompaction strips expired encrypted_content from the prefix request", async () => {
+    // GIVEN a mid-turn history whose prefix (before the last tool pair) holds a
+    // web_search_tool_result block with an expired token
+    const messages: Message[] = [
+      userText("old user turn"),
+      assistantWithWebSearch(),
+      userText("keep going"),
+      assistantToolUse(),
+      toolResult(),
+    ];
+
+    const inputSnapshot = serializeBlocks(messages);
+    const sink = { sent: [] as Message[] };
+
+    // WHEN emergency compaction splits at the last tool pair and summarizes the
+    // prefix
+    const result = await runEmergencyCompaction({
+      conversationId: "conv-web-search-emergency",
+      messages,
+      provider: recordingProvider(sink),
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      // Large budget so the prefix is not front-truncated — this test exercises
+      // the web-search sanitizer, not the truncation fallback.
+      maxInputTokens: 100000,
+      previousEstimatedInputTokens: 90000,
+    });
+
+    // THEN the prefix sent to the provider carries no expired token
+    const sentSerialized = serializeBlocks(sink.sent);
+    expect(sentSerialized).not.toContain(ENCRYPTED_TOKEN);
+    expect(sentSerialized).not.toContain("web_search_tool_result");
+    expect(sentSerialized).not.toContain("server_tool_use");
+    expect(sentSerialized).toContain("All About Cats");
+
+    // AND the caller's durable history is untouched
+    expect(serializeBlocks(messages)).toBe(inputSnapshot);
+    expect(result.compacted).toBe(true);
+  });
+});

package/src/__tests__/context-overflow-reducer.test.ts

@@ -11,7 +11,7 @@ import {
   reduceContextOverflow,
   type ReducerConfig,
   type ReducerState,
-} from "../daemon/context-overflow-reducer.js";
+} from "../plugins/defaults/compaction/context-overflow-reducer.js";
 import type { Message } from "../providers/types.js";
 
 function msg(role: "user" | "assistant", text: string): Message {

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -102,23 +102,26 @@ mock.module("../context/token-estimator.js", () => ({
   estimateToolsTokens: () => 0,
 }));
 
-mock.module("../daemon/context-overflow-reducer.js", () => ({
-  createInitialReducerState: () => ({
-    appliedTiers: [],
-    injectionMode: "full" as const,
-    exhausted: false,
-  }),
-  reduceContextOverflow: async (msgs: Message[]) => ({
-    messages: msgs,
-    tier: "forced_compaction",
-    state: {
-      appliedTiers: ["forced_compaction"],
-      injectionMode: "full",
-      exhausted: true,
-    },
-    estimatedTokens: 1000,
+mock.module(
+  "../plugins/defaults/compaction/context-overflow-reducer.js",
+  () => ({
+    createInitialReducerState: () => ({
+      appliedTiers: [],
+      injectionMode: "full" as const,
+      exhausted: false,
+    }),
+    reduceContextOverflow: async (msgs: Message[]) => ({
+      messages: msgs,
+      tier: "forced_compaction",
+      state: {
+        appliedTiers: ["forced_compaction"],
+        injectionMode: "full",
+        exhausted: true,
+      },
+      estimatedTokens: 1000,
+    }),
   }),
-}));
+);
 
 mock.module("../daemon/context-overflow-policy.js", () => ({
   resolveOverflowAction: () => "fail_gracefully",