@vellumai/assistant 0.8.11 → 0.8.12-staging.1

package/node_modules/@vellumai/gateway-client/src/gateway-ipc-contracts.ts

@@ -0,0 +1,87 @@
+/**
+ * Shared IPC contracts for assistant-to-gateway gateway-owned reads.
+ */
+
+import { z } from "zod";
+
+export const GATEWAY_LOG_LEVEL_NAMES = [
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "fatal",
+] as const;
+export type GatewayLogLevelName = (typeof GATEWAY_LOG_LEVEL_NAMES)[number];
+
+const GatewayLogsTailIpcParamsShape = {
+  n: z.number().int().min(1).max(1000).optional(),
+  level: z.enum(GATEWAY_LOG_LEVEL_NAMES).optional(),
+  module: z.string().optional(),
+};
+
+export const GatewayLogsTailIpcParamsSchema = z
+  .object(GatewayLogsTailIpcParamsShape)
+  .strict()
+  .default({});
+
+export type GatewayLogsTailIpcParams = z.infer<
+  typeof GatewayLogsTailIpcParamsSchema
+>;
+
+export const GatewayLogsTailRouteParamsSchema = z
+  .object({
+    ...GatewayLogsTailIpcParamsShape,
+    n: z.coerce.number().int().min(1).max(1000).optional(),
+  })
+  .strict();
+
+export type GatewayLogsTailRouteParams = z.infer<
+  typeof GatewayLogsTailRouteParamsSchema
+>;
+
+export const GatewayLogsTailIpcResponseSchema = z.object({
+  lines: z.array(z.record(z.string(), z.unknown())),
+  truncated: z.boolean(),
+});
+
+export type GatewayLogsTailIpcResponse = z.infer<
+  typeof GatewayLogsTailIpcResponseSchema
+>;
+
+export const TrustRulesListIpcParamsSchema = z
+  .object({
+    origin: z.string().optional(),
+    tool: z.string().optional(),
+    include_all: z.boolean().optional(),
+    include_deleted: z.boolean().optional(),
+  })
+  .strict()
+  .default({});
+
+export type TrustRulesListIpcParams = z.infer<
+  typeof TrustRulesListIpcParamsSchema
+>;
+
+export const TrustRuleSchema = z.object({
+  id: z.string(),
+  tool: z.string(),
+  pattern: z.string(),
+  risk: z.enum(["low", "medium", "high"]),
+  description: z.string(),
+  origin: z.enum(["default", "user_defined"]),
+  userModified: z.boolean(),
+  deleted: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export type TrustRule = z.infer<typeof TrustRuleSchema>;
+
+export const TrustRulesListIpcResponseSchema = z.object({
+  rules: z.array(TrustRuleSchema),
+});
+
+export type TrustRulesListIpcResponse = z.infer<
+  typeof TrustRulesListIpcResponseSchema
+>;

package/node_modules/@vellumai/gateway-client/src/index.ts

@@ -15,11 +15,9 @@ export {
   deliverChannelReply,
 } from "./http-delivery.js";
 
-export {
-  ipcCall,
-  IpcCallError,
-  PersistentIpcClient,
-} from "./ipc-client.js";
+export * from "./gateway-ipc-contracts.js";
+
+export { ipcCall, IpcCallError, PersistentIpcClient } from "./ipc-client.js";
 
 export type {
   ApprovalActionOption,

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Vellum Assistant API
-  version: 0.8.11
+  version: 0.8.12
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821
@@ -5937,6 +5937,7 @@ paths:
                                 - macos_notification_view
                                 - macos_conversation_opened
                                 - ios_conversation_opened
+                                - web_bulk_mark_read
                                 - telegram_inbound_message
                                 - telegram_callback
                                 - slack_inbound_message
@@ -6300,6 +6301,7 @@ paths:
                               - macos_notification_view
                               - macos_conversation_opened
                               - ios_conversation_opened
+                              - web_bulk_mark_read
                               - telegram_inbound_message
                               - telegram_callback
                               - slack_inbound_message
@@ -6500,6 +6502,7 @@ paths:
                               - macos_notification_view
                               - macos_conversation_opened
                               - ios_conversation_opened
+                              - web_bulk_mark_read
                               - telegram_inbound_message
                               - telegram_callback
                               - slack_inbound_message
@@ -6628,9 +6631,10 @@ paths:
       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.
+        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
       responses:
@@ -7095,6 +7099,44 @@ paths:
           required: true
           schema:
             type: string
+  /v1/conversations/archive/bulk:
+    post:
+      operationId: conversations_archive_bulk_post
+      summary: Bulk archive conversations
+      description: Archive multiple conversations in one request. Emits a single sync invalidation for the entire batch.
+      tags:
+        - conversations
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  ok:
+                    type: boolean
+                  archived:
+                    type: number
+                required:
+                  - ok
+                  - archived
+                additionalProperties: false
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                conversationIds:
+                  minItems: 1
+                  type: array
+                  items:
+                    type: string
+              required:
+                - conversationIds
+              additionalProperties: false
   /v1/conversations/attention:
     get:
       operationId: conversations_attention_get
@@ -7515,6 +7557,7 @@ paths:
                               - macos_notification_view
                               - macos_conversation_opened
                               - ios_conversation_opened
+                              - web_bulk_mark_read
                               - telegram_inbound_message
                               - telegram_callback
                               - slack_inbound_message
@@ -8522,6 +8565,46 @@ paths:
               required:
                 - conversationId
               additionalProperties: false
+  /v1/conversations/seen/bulk:
+    post:
+      operationId: conversations_seen_bulk_post
+      summary: Bulk mark conversations as seen
+      description:
+        Mark multiple conversations as seen in one request. Emits a single sync invalidation for the entire batch
+        instead of per-conversation events.
+      tags:
+        - conversations
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  ok:
+                    type: boolean
+                  updated:
+                    type: number
+                required:
+                  - ok
+                  - updated
+                additionalProperties: false
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                conversationIds:
+                  minItems: 1
+                  type: array
+                  items:
+                    type: string
+              required:
+                - conversationIds
+              additionalProperties: false
   /v1/conversations/switch:
     post:
       operationId: conversations_switch_post
@@ -12920,6 +13003,23 @@ paths:
                   - source
                   - refreshing
                 additionalProperties: false
+      parameters:
+        - name: localHour
+          in: query
+          required: false
+          schema:
+            type: integer
+            minimum: 0
+            maximum: 23
+          description: Optional client-local hour of day used only when refreshing generated greetings.
+        - name: localMinute
+          in: query
+          required: false
+          schema:
+            type: integer
+            minimum: 0
+            maximum: 59
+          description: Optional client-local minute used only when refreshing generated greetings.
   /v1/image-generation/generate:
     post:
       operationId: imagegeneration_generate_post
@@ -19464,6 +19564,27 @@ paths:
                   ref:
                     type: string
                     description: Git ref the catalog metadata / README were resolved at.
+                  artifact:
+                    anyOf:
+                      - type: object
+                        properties:
+                          url:
+                            type: string
+                            description: HTTPS URL the prebuilt client artifact is downloaded from.
+                          sha256:
+                            type: string
+                            description: Lowercase 64-char hex SHA-256 the download is verified against.
+                          label:
+                            description: Optional human label for the download (e.g. "Download for macOS"); absent when the plugin doesn't name it.
+                            type: string
+                        required:
+                          - url
+                          - sha256
+                        additionalProperties: false
+                      - type: "null"
+                    description:
+                      Prebuilt client artifact from `package.json` `vellum.artifact`, or null when the plugin ships none or its
+                      descriptor is incomplete (e.g. a placeholder sha256).
                 required:
                   - name
                   - installed
@@ -19474,6 +19595,7 @@ paths:
                   - source
                   - readme
                   - ref
+                  - artifact
                 additionalProperties: false
         "400":
           description: The plugin name failed sanitization (e.g. contained slashes, dots, or uppercase letters).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.11",
+  "version": "0.8.12-staging.1",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -50,7 +50,6 @@
     "@vellumai/skill-host-contracts": "file:../packages/skill-host-contracts",
     "@vellumai/slack-text": "file:../packages/slack-text",
     "@vellumai/twilio-client": "file:../packages/twilio-client",
-    "archiver": "7.0.1",
     "commander": "13.1.0",
     "croner": "10.0.1",
     "dotenv": "17.3.1",
@@ -97,7 +96,6 @@
   },
   "devDependencies": {
     "@microsoft/api-extractor": "7.58.8",
-    "@types/archiver": "7.0.0",
     "@types/bun": "1.3.10",
     "@types/node": "25.5.0",
     "@types/semver": "7.5.8",

package/src/__tests__/adaptive-thinking-repair.test.ts

@@ -0,0 +1,185 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairAdaptiveThinkingOnManagedProfiles } from "../workspace/adaptive-thinking-repair.js";
+import { enableAdaptiveThinkingManagedProfilesMigration } from "../workspace/migrations/097-enable-adaptive-thinking-managed-profiles.js";
+
+const ADAPTIVE = { enabled: true, streamThinking: true };
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-adaptive-thinking-repair-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function profile(name: string): Record<string, unknown> {
+  const config = readConfig();
+  const llm = config.llm as Record<string, unknown>;
+  const profiles = llm.profiles as Record<string, unknown>;
+  return profiles[name] as Record<string, unknown>;
+}
+
+// The startup repair and migration 097 keep frozen copies of the same logic
+// (migration modules must stay self-contained). Run every scenario against
+// both so the copies can't drift.
+const implementations: Array<[string, (dir: string) => void]> = [
+  ["startup repair", repairAdaptiveThinkingOnManagedProfiles],
+  [
+    "migration 097",
+    (dir) => enableAdaptiveThinkingManagedProfilesMigration.run(dir),
+  ],
+];
+
+describe.each(implementations)("%s", (_label, run) => {
+  test("patches managed Anthropic profiles missing thinking", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-sonnet-4-6" },
+        profiles: {
+          balanced: { source: "managed", provider: "anthropic" },
+          "quality-optimized": {
+            source: "managed",
+            provider: "anthropic",
+            thinking: { enabled: false },
+          },
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toEqual(ADAPTIVE);
+    expect(profile("quality-optimized").thinking).toEqual(ADAPTIVE);
+  });
+
+  test("skips source-less empty shells when llm.default.provider is non-Anthropic", () => {
+    // Migration 052 seeds empty {} shells (no source, no provider) on legacy
+    // non-Anthropic workspaces. They inherit the non-Anthropic provider from
+    // llm.default and must stay off the Anthropic-specific repair.
+    writeConfig({
+      llm: {
+        default: { provider: "gemini", model: "gemini-2.5-pro" },
+        profiles: {
+          balanced: {},
+          "quality-optimized": {},
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced")).toEqual({});
+    expect(profile("quality-optimized")).toEqual({});
+  });
+
+  test("treats absent llm.default.provider as Anthropic for source-less profiles", () => {
+    writeConfig({
+      llm: {
+        default: { model: "claude-sonnet-4-6" },
+        profiles: {
+          balanced: {},
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toEqual(ADAPTIVE);
+  });
+
+  test("explicit Anthropic provider on the profile wins over a non-Anthropic default", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "gemini" },
+        profiles: {
+          balanced: { provider: "anthropic" },
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toEqual(ADAPTIVE);
+  });
+
+  test("skips profiles with an explicit non-Anthropic provider", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: {
+          balanced: { provider: "gemini" },
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toBeUndefined();
+  });
+
+  test("skips source: user profiles", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: {
+          balanced: { source: "user", provider: "anthropic" },
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toBeUndefined();
+  });
+
+  test("is idempotent when thinking is already enabled", () => {
+    const config = {
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: {
+          balanced: {
+            source: "managed",
+            thinking: { enabled: true, streamThinking: false },
+          },
+        },
+      },
+    };
+    writeConfig(config);
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toEqual({
+      enabled: true,
+      streamThinking: false,
+    });
+  });
+});

package/src/__tests__/agent-loop-compaction-events.test.ts

@@ -4,8 +4,9 @@
  * The compaction pipeline between `context_compacting` (start) and
  * `compaction_completed` (end) is plugin-owned, so consumers reconstruct a
  * compaction attempt purely from the pair — correlated by `compactionId`.
- * These tests pin the pairing contract: shared id, trigger, timestamps, and
- * pre-compaction state on the start event.
+ * These tests pin the pairing contract: shared id, trigger, timestamps,
+ * pre-compaction state on the start event, and the unnested
+ * `ContextWindowResult` fields on the end event.
  */
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
@@ -185,11 +186,11 @@ describe("AgentLoop compaction start/end event pair", () => {
     expect(end!.finishedAt).toBeGreaterThanOrEqual(end!.startedAt);
     expect(end!.finishedAt).toBeLessThanOrEqual(after);
 
-    // Start carries the pre-compaction history; end carries the result and
-    // the stripped history the summary was built from.
+    // Start carries the pre-compaction history; end carries the
+    // ContextWindowResult fields unnested on the event.
     expect(start!.messages.length).toBeGreaterThan(0);
-    expect(end!.result.compacted).toBe(true);
-    expect(end!.messages.length).toBeGreaterThan(0);
+    expect(end!.compacted).toBe(true);
+    expect(end!.exhausted).toBe(false);
 
     // Start precedes end in the event stream.
     expect(events.indexOf(start!)).toBeLessThan(events.indexOf(end!));

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

@@ -106,6 +106,7 @@ mock.module("@anthropic-ai/sdk", () => ({
 }));
 
 // Import after mocking
+import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../prompts/cache-boundary.js";
 import { AnthropicProvider } from "../providers/anthropic/client.js";
 import {
   isPlaceholderSentinelText,
@@ -308,6 +309,91 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     });
   });
 
+  test("splits a boundary-carrying system prompt into two cached blocks and drops the tool breakpoint", async () => {
+    /**
+     * Tests that the SYSTEM_PROMPT_CACHE_BOUNDARY marker yields two
+     * independently cached system blocks, and that the explicit
+     * last-tool breakpoint is suppressed (the first system breakpoint
+     * already covers tools) so the total stays within Anthropic's
+     * 4-breakpoint budget.
+     */
+    // GIVEN a system prompt carrying a cache boundary, plus tools and a
+    // tool-use loop (so turn-start and tail breakpoints also apply)
+    const prompt = `stable sections${SYSTEM_PROMPT_CACHE_BOUNDARY}volatile sections`;
+    const messages: Message[] = [
+      userMsg("Do something"),
+      toolUseMsg("tu_1", "bash"),
+      toolResultMsg("tu_1", "output"),
+    ];
+
+    // WHEN the message is sent
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: prompt,
+    });
+
+    // THEN the system prompt is split into two blocks, each 1h-cached
+    const system = lastStreamParams!.system as Array<{
+      type: string;
+      text: string;
+      cache_control?: { type: string; ttl?: string };
+    }>;
+    expect(system).toHaveLength(2);
+    expect(system[0].text).toBe("stable sections");
+    expect(system[1].text).toBe("volatile sections");
+    expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+
+    // AND no tool carries a breakpoint (system block 1 covers them)
+    const tools = lastStreamParams!.tools as Array<{
+      cache_control?: { type: string; ttl?: string };
+    }>;
+    for (const tool of tools) {
+      expect(tool.cache_control).toBeUndefined();
+    }
+
+    // AND the turn-start and tail message breakpoints are unchanged,
+    // keeping the total at the 4-breakpoint cap
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    const turnStart = sent[0];
+    expect(
+      turnStart.content[turnStart.content.length - 1].cache_control,
+    ).toEqual({ type: "ephemeral", ttl: "1h" });
+    const lastMsg = sent[sent.length - 1];
+    expect(lastMsg.content[lastMsg.content.length - 1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "5m",
+    });
+  });
+
+  test("keeps the last-tool breakpoint when the system prompt has no boundary", async () => {
+    /**
+     * Tests that a boundary-free system prompt preserves the explicit
+     * tool breakpoint (single system block leaves budget for it).
+     */
+    // GIVEN a system prompt without a cache boundary and tools
+    // WHEN the message is sent
+    await provider.sendMessage([userMsg("Hi")], {
+      tools: sampleTools,
+      systemPrompt: "You are helpful.",
+    });
+
+    // THEN the last tool keeps its breakpoint
+    const tools = lastStreamParams!.tools as Array<{
+      cache_control?: { type: string; ttl?: string };
+    }>;
+    expect(tools[tools.length - 1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+  });
+
   // -----------------------------------------------------------------------
   // Tool cache control
   // -----------------------------------------------------------------------
@@ -389,6 +475,49 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     ).not.toContain("extended-cache-ttl-2025-04-11");
   });
 
+  test("disableCache sends no cache_control anywhere and strips caller-stamped block markers", async () => {
+    // A one-shot call site that opted out of prompt caching: no breakpoint
+    // on system, tools, turn-start, or tail — and a caller-stamped block
+    // marker is removed rather than forwarded.
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          cachedPrefixBlock("stable pages block"),
+          { type: "text", text: "Do something" },
+        ],
+      },
+      toolUseMsg("tu_1", "bash"),
+      toolResultMsg("tu_1", "output"),
+    ];
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "You are a helpful assistant.",
+      config: { disableCache: true },
+    });
+
+    const system = lastStreamParams!.system as Array<{
+      cache_control?: unknown;
+    }>;
+    expect(system[0].cache_control).toBeUndefined();
+
+    const tools = lastStreamParams!.tools as Array<{
+      cache_control?: unknown;
+    }>;
+    for (const tool of tools) {
+      expect(tool.cache_control).toBeUndefined();
+    }
+
+    const sent = lastStreamParams!.messages as Array<{
+      content: Array<{ cache_control?: unknown }>;
+    }>;
+    for (const message of sent) {
+      for (const block of message.content) {
+        expect(block.cache_control).toBeUndefined();
+      }
+    }
+  });
+
   test("v3-shape call (system + tools + cached prefix block) stays within the 4-breakpoint cap", async () => {
     // Mirrors a v3 L2 selector call: a system prompt, a forced tool, and a user
     // message whose stable <pages> block carries a cache_control breakpoint