@vellumai/assistant 0.11.4 → 0.11.5-staging.1

package/src/plugins/plugin-tree-walk.ts

@@ -15,9 +15,30 @@
  * root (`realpathSync`) before walking.
  */
 
-import { readdirSync } from "node:fs";
+import {
+  copyFileSync,
+  cpSync,
+  existsSync,
+  readdirSync,
+  rmSync,
+  statSync,
+} from "node:fs";
 import { join } from "node:path";
 
+/**
+ * Top-level runtime-owned entries that belong to the live install, not the
+ * plugin's source tree. An upgrade must never take these from the incoming
+ * pin: `config.json` is user-edited, `data/` is whatever the plugin wrote at
+ * runtime, and `.disabled` is created by `assistant plugins disable`.
+ *
+ * The provenance sidecar is not in this list. Install rewrites `install-meta.json`
+ * at the swap boundary; carrying the outgoing copy forward would pin the
+ * upgrade to the previous commit.
+ */
+export const USER_STATE_ENTRIES = ["config.json", "data", ".disabled"] as const;
+
+const USER_STATE_NAME_SET: ReadonlySet<string> = new Set(USER_STATE_ENTRIES);
+
 /**
  * Top-level entries that are preserved across upgrades and excluded from
  * fingerprinting / drift detection / content hashing. These are runtime-owned
@@ -35,11 +56,49 @@ import { join } from "node:path";
  */
 export const PRESERVED_ENTRIES = [
   "install-meta.json",
-  "config.json",
-  "data",
-  ".disabled",
+  ...USER_STATE_ENTRIES,
 ] as const;
 
+/** True when `name` is a top-level user-state entry (`config.json`, `data`, `.disabled`). */
+export function isPluginUserStateEntry(name: string): boolean {
+  return USER_STATE_NAME_SET.has(name);
+}
+
+/**
+ * Remove user-state entries from `dir` so a pin-shipped `config.json` or
+ * `data/` cannot ride the swap. No-op when those paths are already absent.
+ */
+export function stripPreservedUserState(dir: string): void {
+  for (const entry of USER_STATE_ENTRIES) {
+    rmSync(join(dir, entry), { recursive: true, force: true });
+  }
+}
+
+/**
+ * Copy live user-state (`config.json`, `data/`, `.disabled`) from `fromDir`
+ * into `toDir`, replacing any copy already at the destination so the live
+ * bytes win whole-file / whole-tree.
+ */
+export function copyPreservedUserState(fromDir: string, toDir: string): void {
+  if (!existsSync(fromDir)) {
+    return;
+  }
+  for (const entry of USER_STATE_ENTRIES) {
+    const src = join(fromDir, entry);
+    if (!existsSync(src)) {
+      continue;
+    }
+    const dest = join(toDir, entry);
+    rmSync(dest, { recursive: true, force: true });
+    const stat = statSync(src);
+    if (stat.isDirectory()) {
+      cpSync(src, dest, { recursive: true });
+    } else {
+      copyFileSync(src, dest);
+    }
+  }
+}
+
 /**
  * Directory names {@link walkPluginTree} skips at any depth, unconditionally.
  * `node_modules` holds a plugin's installed dependencies — derived from the

package/src/providers/anthropic/__tests__/pause-turn-continuation.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, test } from "bun:test";
+
+import type Anthropic from "@anthropic-ai/sdk";
+
+import { AnthropicProvider, MAX_PAUSE_TURN_CONTINUATIONS } from "../client.js";
+
+function makeMessage(overrides: {
+  stop_reason: Anthropic.Message["stop_reason"];
+  content: Anthropic.ContentBlock[];
+  usage?: Partial<Anthropic.Usage>;
+}): Anthropic.Message {
+  return {
+    id: "msg_test",
+    type: "message",
+    role: "assistant",
+    model: "claude-opus-4-6",
+    stop_sequence: null,
+    content: overrides.content,
+    stop_reason: overrides.stop_reason,
+    usage: {
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_creation_input_tokens: null,
+      cache_read_input_tokens: null,
+      ...overrides.usage,
+    } as Anthropic.Usage,
+  } as Anthropic.Message;
+}
+
+function textBlock(text: string): Anthropic.ContentBlock {
+  return { type: "text", text, citations: null } as Anthropic.ContentBlock;
+}
+
+function serverToolUseBlock(id: string): Anthropic.ContentBlock {
+  return {
+    type: "server_tool_use",
+    id,
+    name: "web_search",
+    input: { query: "test" },
+  } as Anthropic.ContentBlock;
+}
+
+/**
+ * Stub the SDK client on a provider instance. Every stream call records its
+ * params and resolves to the next response in `responses` (repeating the last
+ * one once exhausted). Both the plain and beta endpoints share the recorder —
+ * which endpoint fires depends on the model's beta set.
+ */
+function stubProvider(responses: Anthropic.Message[]): {
+  provider: AnthropicProvider;
+  calls: Anthropic.MessageStreamParams[];
+} {
+  const provider = new AnthropicProvider("test-key", "claude-opus-4-6");
+  const calls: Anthropic.MessageStreamParams[] = [];
+  const stream = (params: Anthropic.MessageStreamParams) => {
+    calls.push(params);
+    const response =
+      responses[Math.min(calls.length - 1, responses.length - 1)];
+    return {
+      on() {
+        return this;
+      },
+      async finalMessage() {
+        return response;
+      },
+    };
+  };
+  (provider as unknown as { client: unknown }).client = {
+    baseURL: "https://api.anthropic.com",
+    messages: { stream },
+    beta: { messages: { stream } },
+  };
+  return { provider, calls };
+}
+
+describe("pause_turn continuation", () => {
+  test("resends the paused assistant content as-is and merges the segments", async () => {
+    const pausedContent = [
+      textBlock("Searching..."),
+      serverToolUseBlock("srvtoolu_1"),
+    ];
+    const { provider, calls } = stubProvider([
+      makeMessage({
+        stop_reason: "pause_turn",
+        content: pausedContent,
+        usage: { input_tokens: 10, output_tokens: 5 },
+      }),
+      makeMessage({
+        stop_reason: "end_turn",
+        content: [textBlock("Done")],
+        usage: {
+          input_tokens: 20,
+          output_tokens: 7,
+          cache_creation_input_tokens: 3,
+          cache_read_input_tokens: 4,
+        },
+      }),
+    ]);
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "search something" }] },
+    ]);
+
+    expect(calls.length).toBe(2);
+    // The continuation appends the paused assistant message unchanged.
+    expect(calls[1].messages.length).toBe(calls[0].messages.length + 1);
+    const appended = calls[1].messages[calls[1].messages.length - 1];
+    expect(appended.role).toBe("assistant");
+    expect(appended.content).toBe(pausedContent);
+
+    // Content is the concatenation of the paused segment and the final one.
+    expect(result.content).toEqual([
+      { type: "text", text: "Searching..." },
+      {
+        type: "server_tool_use",
+        id: "srvtoolu_1",
+        name: "web_search",
+        input: { query: "test" },
+      },
+      { type: "text", text: "Done" },
+    ]);
+    expect(result.stopReason).toBe("end_turn");
+
+    // Usage sums across both billed requests (input includes cache tokens).
+    expect(result.usage.inputTokens).toBe(10 + 20 + 3 + 4);
+    expect(result.usage.outputTokens).toBe(12);
+    expect(result.usage.cacheCreationInputTokens).toBe(3);
+    expect(result.usage.cacheReadInputTokens).toBe(4);
+  });
+
+  test("a turn that never pauses issues a single request", async () => {
+    const { provider, calls } = stubProvider([
+      makeMessage({
+        stop_reason: "end_turn",
+        content: [textBlock("Hi")],
+        usage: { input_tokens: 8, output_tokens: 2 },
+      }),
+    ]);
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "hello" }] },
+    ]);
+
+    expect(calls.length).toBe(1);
+    expect(result.content).toEqual([{ type: "text", text: "Hi" }]);
+    expect(result.stopReason).toBe("end_turn");
+    expect(result.usage.inputTokens).toBe(8);
+    expect(result.usage.cacheCreationInputTokens).toBeUndefined();
+    expect(result.usage.cacheReadInputTokens).toBeUndefined();
+  });
+
+  test("stops resending at the continuation cap and returns the paused response", async () => {
+    const { provider, calls } = stubProvider([
+      makeMessage({
+        stop_reason: "pause_turn",
+        content: [serverToolUseBlock("srvtoolu_stuck")],
+        usage: { input_tokens: 1, output_tokens: 1 },
+      }),
+    ]);
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "search forever" }] },
+    ]);
+
+    expect(calls.length).toBe(1 + MAX_PAUSE_TURN_CONTINUATIONS);
+    expect(result.stopReason).toBe("pause_turn");
+    // Every billed request's usage is accounted for.
+    expect(result.usage.inputTokens).toBe(1 + MAX_PAUSE_TURN_CONTINUATIONS);
+  });
+});