@vellumai/assistant 0.8.11 → 0.8.12-staging.2

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -34,6 +34,12 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import {
+  type InspectPluginDeps,
+  type InspectPluginOptions,
+  type PluginInspection,
+  PluginInspectNotFoundError,
+} from "../../../cli/lib/inspect-plugin.js";
 import {
   type InstallPluginOptions,
   type InstallPluginResult,
@@ -59,6 +65,12 @@ import {
   type UninstallPluginOptions,
   type UninstallPluginResult,
 } from "../../../cli/lib/uninstall-plugin.js";
+import {
+  PluginNotUpgradableError,
+  type PluginUpgradeResult,
+  type UpgradePluginDeps,
+  type UpgradePluginOptions,
+} from "../../../cli/lib/upgrade-plugin.js";
 
 // Mutable list returned by the mocked library function. Tests reassign
 // `installedFixture` before invoking the handler.
@@ -133,6 +145,38 @@ mock.module("../../../cli/lib/plugin-details.js", () => ({
   getPluginDetails: detailsSpy,
 }));
 
+// Mock inspectPlugin: the lib computes the local-vs-remote drift (covered by
+// inspect-plugin.test.ts); the route only forwards the name and maps errors.
+const inspectSpy = mock(
+  async (
+    _opts: InspectPluginOptions,
+    _deps: InspectPluginDeps,
+  ): Promise<PluginInspection> => {
+    throw new Error("inspectSpy default impl not configured");
+  },
+);
+
+mock.module("../../../cli/lib/inspect-plugin.js", () => ({
+  PluginInspectNotFoundError,
+  inspectPlugin: inspectSpy,
+}));
+
+// Mock upgradePlugin: the lib performs the re-pin (covered by
+// upgrade-plugin.test.ts); the route projects its result and maps errors.
+const upgradeSpy = mock(
+  async (
+    _opts: UpgradePluginOptions,
+    _deps: UpgradePluginDeps,
+  ): Promise<PluginUpgradeResult> => {
+    throw new Error("upgradeSpy default impl not configured");
+  },
+);
+
+mock.module("../../../cli/lib/upgrade-plugin.js", () => ({
+  PluginNotUpgradableError,
+  upgradePlugin: upgradeSpy,
+}));
+
 import {
   BadRequestError,
   ConflictError,
@@ -154,6 +198,8 @@ const searchHandler = findHandler("plugins_search");
 const uninstallHandler = findHandler("plugins_uninstall");
 const getHandler = findHandler("plugins_get");
 const installHandler = findHandler("plugins_install");
+const inspectHandler = findHandler("plugins_inspect");
+const upgradeHandler = findHandler("plugins_upgrade");
 
 function invoke(args: RouteHandlerArgs = {}): {
   plugins: Array<Record<string, unknown>>;
@@ -643,6 +689,7 @@ function pluginDetails(overrides: Partial<PluginDetails> = {}): PluginDetails {
     },
     readme: overrides.readme ?? null,
     ref: overrides.ref ?? "main",
+    artifact: overrides.artifact ?? null,
   };
 }
 
@@ -880,3 +927,304 @@ describe("POST /v1/plugins/install", () => {
     expect((caught as Error).message).toContain("ECONNRESET");
   });
 });
+
+function inspection(
+  overrides: Partial<PluginInspection> = {},
+): PluginInspection {
+  return {
+    name: overrides.name ?? "level-up",
+    installed: overrides.installed ?? true,
+    status: overrides.status ?? "update-available",
+    local:
+      overrides.local === undefined
+        ? {
+            target: "/workspace/.vellum/plugins/level-up",
+            commit: "60a392b0000000000000000000000000000000aa",
+            version: "0.1.0",
+            description: "Surfaces a Level Up diff card.",
+            installedAt: "2026-06-08T00:00:00.000Z",
+            source: {
+              kind: "github",
+              owner: "vellum-ai",
+              repo: "level-up",
+              ref: "60a392b0000000000000000000000000000000aa",
+            },
+            localChanges: {
+              modified: [],
+              added: [],
+              removed: [],
+              clean: true,
+            },
+            issues: [],
+          }
+        : overrides.local,
+    remote:
+      overrides.remote === undefined
+        ? {
+            repo: "vellum-ai/level-up",
+            path: "",
+            commit: "3eae1820000000000000000000000000000000bb",
+            description: "Surfaces a Level Up diff card.",
+            homepage: "https://github.com/vellum-ai/level-up",
+            license: "MIT",
+            category: null,
+            marketplaceRef: "main",
+          }
+        : overrides.remote,
+    remoteError: overrides.remoteError ?? null,
+  };
+}
+
+async function invokeInspect(
+  args: RouteHandlerArgs = {},
+): Promise<PluginInspection> {
+  return (await inspectHandler(args)) as PluginInspection;
+}
+
+describe("GET /v1/plugins/:name/inspect", () => {
+  beforeEach(() => {
+    inspectSpy.mockReset();
+  });
+
+  test("forwards the name to inspectPlugin and returns the drift verbatim", async () => {
+    // GIVEN inspectPlugin reports an available update for an installed plugin
+    const view = inspection({ status: "update-available" });
+    inspectSpy.mockImplementation(async () => view);
+
+    // WHEN the route handler is invoked with the path name
+    const result = await invokeInspect({ pathParams: { name: "level-up" } });
+
+    // THEN the inspection is returned unchanged
+    expect(result).toEqual(view);
+    // AND the name is forwarded to the lib (ref is never caller-supplied)
+    expect(inspectSpy.mock.calls[0]?.[0]).toEqual({ name: "level-up" });
+  });
+
+  test("a captured marketplace error is returned as 200 with remote-unavailable, not thrown", async () => {
+    // GIVEN the catalog was unreachable but a local copy exists, so the lib
+    // returns a status rather than throwing
+    const view = inspection({
+      status: "remote-unavailable",
+      remote: null,
+      remoteError: "ENOTFOUND raw.githubusercontent.com",
+    });
+    inspectSpy.mockImplementation(async () => view);
+
+    // WHEN the handler runs
+    const result = await invokeInspect({ pathParams: { name: "level-up" } });
+
+    // THEN it resolves (does not throw) and surfaces the captured error
+    expect(result.status).toBe("remote-unavailable");
+    expect(result.remoteError).toContain("ENOTFOUND");
+  });
+
+  test("InvalidPluginNameError → BadRequestError (400)", async () => {
+    inspectSpy.mockImplementation(async () => {
+      throw new InvalidPluginNameError("../escape");
+    });
+
+    await expect(
+      invokeInspect({ pathParams: { name: "../escape" } }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
+  test("PluginInspectNotFoundError → NotFoundError (404)", async () => {
+    inspectSpy.mockImplementation(async () => {
+      throw new PluginInspectNotFoundError("ghost");
+    });
+
+    await expect(
+      invokeInspect({ pathParams: { name: "ghost" } }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("unknown errors → InternalError with original message preserved", async () => {
+    inspectSpy.mockImplementation(async () => {
+      throw new Error("EUNEXPECTED");
+    });
+
+    let caught: unknown;
+    try {
+      await invokeInspect({ pathParams: { name: "level-up" } });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(InternalError);
+    expect((caught as Error).message).toContain("EUNEXPECTED");
+  });
+});
+
+function upgradeResult(
+  overrides: Partial<PluginUpgradeResult> = {},
+): PluginUpgradeResult {
+  return {
+    name: overrides.name ?? "level-up",
+    outcome: overrides.outcome ?? "upgraded",
+    fromCommit:
+      overrides.fromCommit === undefined
+        ? "60a392b0000000000000000000000000000000aa"
+        : overrides.fromCommit,
+    toCommit: overrides.toCommit ?? "3eae1820000000000000000000000000000000bb",
+    target: overrides.target ?? "/workspace/.vellum/plugins/level-up",
+    fileCount: overrides.fileCount === undefined ? 12 : overrides.fileCount,
+    dryRun: overrides.dryRun ?? false,
+    provenanceWasUnknown: overrides.provenanceWasUnknown ?? false,
+  };
+}
+
+async function invokeUpgrade(args: RouteHandlerArgs = {}): Promise<{
+  name: string;
+  outcome: string;
+  fromCommit: string | null;
+  toCommit: string;
+  target: string;
+  fileCount: number | null;
+  dryRun: boolean;
+  provenanceWasUnknown: boolean;
+}> {
+  return (await upgradeHandler(args)) as {
+    name: string;
+    outcome: string;
+    fromCommit: string | null;
+    toCommit: string;
+    target: string;
+    fileCount: number | null;
+    dryRun: boolean;
+    provenanceWasUnknown: boolean;
+  };
+}
+
+describe("POST /v1/plugins/:name/upgrade", () => {
+  beforeEach(() => {
+    upgradeSpy.mockReset();
+  });
+
+  test("forwards name + dryRun and projects the upgrade result", async () => {
+    // GIVEN upgradePlugin reports a successful re-pin
+    upgradeSpy.mockImplementation(async () => upgradeResult());
+
+    // WHEN the handler runs with an explicit dryRun flag
+    const result = await invokeUpgrade({
+      pathParams: { name: "level-up" },
+      body: { dryRun: false },
+    });
+
+    // THEN the result is projected onto the wire shape
+    expect(result).toEqual({
+      name: "level-up",
+      outcome: "upgraded",
+      fromCommit: "60a392b0000000000000000000000000000000aa",
+      toCommit: "3eae1820000000000000000000000000000000bb",
+      target: "/workspace/.vellum/plugins/level-up",
+      fileCount: 12,
+      dryRun: false,
+      provenanceWasUnknown: false,
+    });
+    // AND the name + dryRun are forwarded to the lib
+    expect(upgradeSpy.mock.calls[0]?.[0]).toEqual({
+      name: "level-up",
+      dryRun: false,
+    });
+  });
+
+  test("omits dryRun (passes undefined) when the body flag is absent", async () => {
+    // GIVEN a no-op upgrade where the install already matches the pin
+    upgradeSpy.mockImplementation(async () =>
+      upgradeResult({
+        outcome: "already-up-to-date",
+        toCommit: "60a392b0000000000000000000000000000000aa",
+        fileCount: null,
+      }),
+    );
+
+    // WHEN invoked without a body
+    const result = await invokeUpgrade({ pathParams: { name: "level-up" } });
+
+    // THEN the no-op outcome is surfaced
+    expect(result.outcome).toBe("already-up-to-date");
+    expect(result.fileCount).toBeNull();
+    // AND dryRun is passed through as undefined (not coerced to false)
+    expect(upgradeSpy.mock.calls[0]?.[0]).toEqual({
+      name: "level-up",
+      dryRun: undefined,
+    });
+  });
+
+  test("InvalidPluginNameError → BadRequestError (400)", async () => {
+    upgradeSpy.mockImplementation(async () => {
+      throw new InvalidPluginNameError("../escape");
+    });
+
+    await expect(
+      invokeUpgrade({ pathParams: { name: "../escape" } }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
+  test("PluginNotInstalledError → NotFoundError (404)", async () => {
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginNotInstalledError(
+        "ghost",
+        "/workspace/.vellum/plugins/ghost",
+      );
+    });
+
+    await expect(
+      invokeUpgrade({ pathParams: { name: "ghost" } }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("PluginNotUpgradableError → ConflictError (409)", async () => {
+    // The install exists but has no marketplace entry to advance to: a
+    // well-formed request that isn't actionable in the current state.
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginNotUpgradableError(
+        "level-up",
+        "it has no marketplace entry to upgrade from",
+      );
+    });
+
+    await expect(
+      invokeUpgrade({ pathParams: { name: "level-up" } }),
+    ).rejects.toBeInstanceOf(ConflictError);
+  });
+
+  test("PluginNotFoundError → NotFoundError (404)", async () => {
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginNotFoundError("level-up", "main", "vellum-ai/level-up");
+    });
+
+    await expect(
+      invokeUpgrade({ pathParams: { name: "level-up" } }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("PluginSourceUnavailableError → ServiceUnavailableError (503)", async () => {
+    // The re-install fetch can hit a rate-limited GitHub; that is retryable,
+    // so surface 503 rather than a misleading 500.
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginSourceUnavailableError(
+        "GitHub tree listing for vellum-ai/level-up: HTTP 403",
+        403,
+      );
+    });
+
+    await expect(
+      invokeUpgrade({ pathParams: { name: "level-up" } }),
+    ).rejects.toBeInstanceOf(ServiceUnavailableError);
+  });
+
+  test("unknown errors → InternalError with original message preserved", async () => {
+    upgradeSpy.mockImplementation(async () => {
+      throw new Error("ECONNRESET");
+    });
+
+    let caught: unknown;
+    try {
+      await invokeUpgrade({ pathParams: { name: "level-up" } });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(InternalError);
+    expect((caught as Error).message).toContain("ECONNRESET");
+  });
+});

package/src/runtime/routes/__tests__/task-routes.test.ts

@@ -206,6 +206,8 @@ mock.module("../../../util/platform.js", () => {
     getPlatformName: () => "linux",
     normalizeAssistantId: (id: string) => id,
     getDataDir: stub,
+    getConfigQuarantineNoticePath: () =>
+      "/mock/workspace/data/config-quarantine-notice.json",
     getEmbeddingModelsDir: stub,
     getSandboxRootDir: stub,
     getSandboxWorkingDir: stub,
@@ -414,9 +416,7 @@ describe("task_delete route", () => {
 
   test("throws Zod validation error for empty task_ids array", async () => {
     const route = findRoute("task_delete");
-    await expect(
-      route.handler({ body: { task_ids: [] } }),
-    ).rejects.toThrow();
+    await expect(route.handler({ body: { task_ids: [] } })).rejects.toThrow();
 
     expect(mockTaskDeleteCalls).toHaveLength(0);
   });

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

@@ -14,7 +14,6 @@
 
 import { z } from "zod";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
 import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import { readNowScratchpad } from "../../daemon/now-scratchpad.js";
@@ -34,9 +33,6 @@ const IDENTITY_INTRO_KEY = "identity-intro";
 
 /** Conversation key used by the client for empty-state greeting generation. */
 const GREETING_KEY = "greeting";
-const EMPTY_STATE_DYNAMIC_GREETINGS_FLAG =
-  "empty-state-dynamic-greetings" as const;
-const STATIC_EMPTY_STATE_GREETING = "What are we working on?";
 
 // ---------------------------------------------------------------------------
 // SSE helpers
@@ -68,16 +64,6 @@ async function handleBtw({
 
   const trimmedContent = content.trim();
 
-  if (
-    conversationKey === GREETING_KEY &&
-    !isAssistantFeatureFlagEnabled(
-      EMPTY_STATE_DYNAMIC_GREETINGS_FLAG,
-      getConfig(),
-    )
-  ) {
-    return streamText(STATIC_EMPTY_STATE_GREETING);
-  }
-
   // ----- Cached identity intro fast-path -----
   if (conversationKey === IDENTITY_INTRO_KEY) {
     const fastText = getCachedIntro()?.greetings[0];

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

@@ -34,30 +34,37 @@
  * which has no compaction immediately before it but had several
  * earlier in the same turn. The turn is the right unit of analysis.
  *
- * # Data model decision (in progress)
+ * # Data sources
  *
- * Today the trail is projected from `llm_request_logs` rows alone — no
- * `compaction_logs` table exists yet (#32055 remains a draft). This MVP
- * route exists precisely to test whether the projected shape is enough.
- * If real-world use surfaces UX needs that aren't in `llm_request_logs`
- * (most likely: per-event duration, structured before/after counts,
- * trigger reason), that becomes the concrete justification for the new
- * table. Until then, missing fields surface as `null` and the Compaction
- * tab renders `"Unavailable"` for them.
+ * When `compactionLogs.destination = "clickhouse"` is configured, the
+ * trail is served from the first-class compaction log: the agent loop's
+ * start/end event pairs written by
+ * `memory/compaction-log-store-clickhouse.ts`. Those rows carry real
+ * durations, summary-model token totals, and trigger reasons — none of
+ * which exist on `llm_request_logs`.
  *
- * In particular, `durationMs` is always `null` for now — the column
- * doesn't exist on `llm_request_logs` and we deliberately ship the route
- * without it to surface the gap in the UI.
+ * The legacy projection over `llm_request_logs` rows with
+ * `call_site = "compactionAgent"` remains as the fallback: it serves
+ * turns that predate the compaction log (the table is append-only from
+ * the moment the destination is configured), assistants that never opt
+ * in, and reads where the ClickHouse query fails. On the legacy path
+ * `durationMs` is always `null` — the column doesn't exist on
+ * `llm_request_logs`.
  */
 
 import { z } from "zod";
 
+import {
+  type CompactionLogEvent,
+  getCompactionLogStore,
+} from "../../memory/compaction-log-store-clickhouse.js";
 import {
   getConversation,
   getTurnTimeBounds,
 } from "../../memory/conversation-crud.js";
 import { getLlmRequestLogSource } from "../../memory/llm-request-log-source.js";
 import type { LogRow } from "../../memory/llm-request-log-store.js";
+import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError, NotFoundError } from "./errors.js";
 import {
@@ -66,6 +73,8 @@ import {
 } from "./llm-context-normalization.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
+const log = getLogger("conversation-compaction-routes");
+
 /**
  * Wire shape for a single compaction event. Mirrors the React Query
  * response type at
@@ -81,12 +90,9 @@ export interface CompactionTrailEvent {
   inputTokens: number | null;
   outputTokens: number | null;
   /**
-   * Per-call wall-clock latency, in milliseconds. **Always `null` for
-   * now** — `llm_request_logs` doesn't carry a duration column. Surfacing
-   * the gap in the UI is intentional: if engineers consistently miss
-   * having latency here, that's a concrete signal to extend the row
-   * (either as a column on `llm_request_logs` or on a dedicated
-   * `compaction_logs` table per the open data-model decision).
+   * Per-attempt wall-clock latency, in milliseconds. Populated from the
+   * compaction log when configured; always `null` on the legacy
+   * `llm_request_logs` path, which has no duration column.
    */
   durationMs: number | null;
   responsePreview: string | null;
@@ -172,6 +178,33 @@ export function projectLogRowToCompactionTrailEvent(
   };
 }
 
+/**
+ * Project a paired compaction-log event into the trail wire shape. Token
+ * counts are the summarizer's own usage (what the compaction itself cost),
+ * matching what the legacy path derived from the compaction agent's
+ * request/response payloads.
+ *
+ * Exported only for unit tests; the route handler is the sole production
+ * caller.
+ */
+export function projectCompactionLogEventToTrailEvent(
+  event: CompactionLogEvent,
+): CompactionTrailEvent {
+  return {
+    id: event.compactionId,
+    createdAt: event.startedAt,
+    model: event.summaryModel,
+    provider: null,
+    inputTokens: event.summaryInputTokens,
+    outputTokens: event.summaryOutputTokens,
+    durationMs: event.durationMs,
+    responsePreview: event.summaryText,
+    requestMessageCount: event.preMessageCount,
+    stopReason: event.reason,
+    estimatedCostUsd: null,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Handler
 // ---------------------------------------------------------------------------
@@ -232,6 +265,40 @@ async function handleGetCompactionTrail({
     turnBounds !== null ? turnBounds.startTime - 1 : null;
   const beforeCreatedAt: number =
     turnBounds !== null ? turnBounds.endTime + 1 : selectedCall.createdAt;
+  // Prefer the first-class compaction log when the assistant has opted
+  // in. Zero rows means the turn predates the log (it is append-only from
+  // the moment the destination is configured), so fall through to the
+  // legacy projection rather than returning an empty trail; same for a
+  // failed ClickHouse read. Writes are best-effort and the start/end rows
+  // land independently, so an event without its end row (no `finishedAt`)
+  // means the end write failed or is lagging — in that case the legacy
+  // projection may still have the summarizer call details, so fall back
+  // rather than serve a trail with null model/tokens/duration.
+  const compactionStore = getCompactionLogStore();
+  if (compactionStore) {
+    try {
+      const events = await compactionStore.getEventsBetween(
+        conversationId,
+        afterCreatedAt,
+        beforeCreatedAt,
+      );
+      if (
+        events.length > 0 &&
+        events.every((event) => event.finishedAt !== null)
+      ) {
+        return {
+          conversationId,
+          events: events.map(projectCompactionLogEventToTrailEvent),
+        };
+      }
+    } catch (err) {
+      log.warn(
+        { err, conversationId, callId },
+        "Compaction log read failed; falling back to llm_request_logs projection",
+      );
+    }
+  }
+
   const logs = await source.getCompactionLogsBetween(
     conversationId,
     afterCreatedAt,
@@ -259,7 +326,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Get the compaction trail leading up to an LLM call",
     description:
-      "Return the chronological list of compaction events that ran in the same agent turn as the call identified by `callId`. Turn bounds are walked from the `messages` table (real user messages — tool-result user messages are not boundaries). Projected from `llm_request_logs` rows where `call_site = \"compactionAgent\"`. When the conversation has no other messages around the selected call, every compaction strictly before the call's `createdAt` is in scope. Drives the Inspector's Compaction tab.",
+      'Return the chronological list of compaction events that ran in the same agent turn as the call identified by `callId`. Turn bounds are walked from the `messages` table (real user messages — tool-result user messages are not boundaries). Served from the first-class compaction log when `compactionLogs.destination = "clickhouse"` is configured, falling back to the legacy projection over `llm_request_logs` rows where `call_site = "compactionAgent"`. When the conversation has no other messages around the selected call, every compaction strictly before the call\'s `createdAt` is in scope. Drives the Inspector\'s Compaction tab.',
     tags: ["conversations"],
     pathParams: [
       {