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

package/src/plugins/defaults/memory/worker-control.ts

@@ -18,13 +18,19 @@ import {
   type WorkerProcessStatus,
 } from "../../../util/worker-process.js";
 
+const MEMORY_WORKER_ENTRY = new URL("./worker.ts", import.meta.url);
+
 /**
  * Inspect the PID file to determine whether the worker process is alive.
- * A stale PID file (pointing at a dead process) is cleaned up and reported
- * as not_running.
+ * A stale PID file (pointing at a dead process, or at a live process that
+ * is not this worker) is cleaned up and reported as not_running.
  */
 export function probeMemoryWorker(): WorkerProcessStatus {
-  return probeWorkerPidFile(getMemoryWorkerPidPath());
+  return probeWorkerPidFile(
+    getMemoryWorkerPidPath(),
+    MEMORY_WORKER_ENTRY,
+    "memory",
+  );
 }
 
 export class MemoryWorkerSpawnError extends WorkerProcessSpawnError {}
@@ -50,7 +56,7 @@ export async function spawnMemoryWorkerProcess(
   try {
     return await spawnWorkerProcess({
       pidPath: getMemoryWorkerPidPath(),
-      entry: new URL("./worker.ts", import.meta.url),
+      entry: MEMORY_WORKER_ENTRY,
       packagedEntry: "memory",
       workerLabel: "Memory worker",
       options: opts,
@@ -71,5 +77,9 @@ export async function spawnMemoryWorkerProcess(
  * (e.g. EPERM) — a not-running worker is a no-op.
  */
 export function stopMemoryWorkerProcess(): WorkerProcessStatus {
-  return stopWorkerProcess(getMemoryWorkerPidPath());
+  return stopWorkerProcess(
+    getMemoryWorkerPidPath(),
+    MEMORY_WORKER_ENTRY,
+    "memory",
+  );
 }

package/src/plugins/defaults/task-progress/__tests__/registration.test.ts

@@ -0,0 +1,70 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { getAllDefaultPlugins } from "../../index.js";
+
+const PLUGIN_DIR = join(import.meta.dir, "..");
+
+function walkFiles(dir: string): string[] {
+  const files: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const stat = statSync(full);
+    if (stat.isDirectory()) {
+      if (entry === "__tests__" || entry === "node_modules") {
+        continue;
+      }
+      files.push(...walkFiles(full));
+      continue;
+    }
+    if (entry.endsWith(".ts") || entry.endsWith(".json")) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+
+describe("task-progress registration", () => {
+  test("default-plugin registration includes both hooks after empty-response", () => {
+    const plugins = getAllDefaultPlugins();
+    const names = plugins.map((plugin) => plugin.manifest.name);
+    const emptyIndex = names.indexOf("default-empty-response");
+    const contextIndex = names.indexOf("default-task-progress");
+    expect(contextIndex).toBeGreaterThan(-1);
+    expect(contextIndex).toBe(emptyIndex + 1);
+
+    const plugin = plugins[contextIndex]!;
+    expect(Object.keys(plugin.hooks ?? {}).sort()).toEqual([
+      "post-compact",
+      "user-prompt-submit",
+    ]);
+    expect(plugin.hooks?.["user-prompt-submit"]).toBeTypeOf("function");
+    expect(plugin.hooks?.["post-compact"]).toBeTypeOf("function");
+    expect(plugin.hooks?.["post-tool-use"]).toBeUndefined();
+    expect(plugin.injectors).toBeUndefined();
+  });
+
+  test("owns no database, migration, lifecycle hook, or state store", () => {
+    const productionFiles = walkFiles(PLUGIN_DIR);
+    const forbidden =
+      /sqlite|migration|pluginStorageDir|conversation-deleted|conversations-cleared|nudge-state-store|state-store|CREATE TABLE|bun:sqlite/i;
+    for (const file of productionFiles) {
+      const rel = file.slice(PLUGIN_DIR.length + 1);
+      if (rel === "package.json") {
+        continue;
+      }
+      const source = readFileSync(file, "utf8");
+      expect(source, rel).not.toMatch(forbidden);
+      expect(source, rel).not.toContain("hooks/init");
+      expect(source, rel).not.toContain("hooks/shutdown");
+    }
+
+    const plugin = getAllDefaultPlugins().find(
+      (entry) => entry.manifest.name === "default-task-progress",
+    );
+    expect(plugin?.hooks?.init).toBeUndefined();
+    expect(plugin?.hooks?.shutdown).toBeUndefined();
+    expect(plugin?.hooks?.["conversation-deleted"]).toBeUndefined();
+  });
+});

package/src/plugins/defaults/task-progress/__tests__/task-progress-context.test.ts

@@ -0,0 +1,380 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ConversationSurfaceSnapshot } from "../../../../daemon/conversation-surface-snapshots.js";
+import type { Message } from "../../../../providers/types.js";
+
+let listImpl: (conversationId: string) => ConversationSurfaceSnapshot[] = () =>
+  [];
+
+mock.module("../../../../daemon/conversation-surface-snapshots.js", () => ({
+  listConversationSurfaceSnapshots: (conversationId: string) =>
+    listImpl(conversationId),
+}));
+
+const {
+  formatActiveTaskProgressSnapshot,
+  isActiveTaskProgressSurface,
+} = await import("../src/format-task-progress-context.js");
+const { applyTaskProgressContext } =
+  await import("../src/apply-task-progress-context.js");
+const userPromptSubmit =
+  await import("../hooks/user-prompt-submit.js").then((m) => m.default);
+const postCompact = await import("../hooks/post-compact.js").then(
+  (m) => m.default,
+);
+
+function taskProgressData(
+  title: string,
+  steps: Array<{ label: string; status: string }>,
+): Record<string, unknown> {
+  return {
+    template: "task_progress",
+    templateData: { title, steps },
+  };
+}
+
+function cardSnapshot(
+  surfaceId: string,
+  data: Record<string, unknown>,
+  extras?: Partial<ConversationSurfaceSnapshot>,
+): ConversationSurfaceSnapshot {
+  return {
+    surfaceId,
+    surfaceType: "card",
+    data,
+    completed: false,
+    ...extras,
+  };
+}
+
+function userText(text: string): Message {
+  return { role: "user", content: [{ type: "text", text }] };
+}
+
+function assistantText(text: string): Message {
+  return { role: "assistant", content: [{ type: "text", text }] };
+}
+
+function makeLogger() {
+  return {
+    info: mock(() => undefined),
+    warn: mock(() => undefined),
+    error: mock(() => undefined),
+    debug: mock(() => undefined),
+  };
+}
+
+describe("task-progress-context formatting", () => {
+  test("pending or in_progress cards inject", () => {
+    const snapshot = formatActiveTaskProgressSnapshot([
+      cardSnapshot(
+        "surf_abc",
+        taskProgressData("Researching the billing outage", [
+          { label: "Pull error logs", status: "completed" },
+          { label: "Compare the last incident", status: "in_progress" },
+          { label: "Propose a fix", status: "pending" },
+        ]),
+      ),
+    ]);
+
+    expect(snapshot).toBe(
+      [
+        "<active_task_progress>",
+        "surface_id: surf_abc",
+        "title: Researching the billing outage",
+        "steps:",
+        "- [completed] Pull error logs",
+        "- [in_progress] Compare the last incident",
+        "- [pending] Propose a fix",
+        "Update this card with ui_update as the steps change.",
+        "</active_task_progress>",
+      ].join("\n"),
+    );
+  });
+
+  test("completed surfaces and fully completed or failed plans do not inject", () => {
+    expect(
+      isActiveTaskProgressSurface(
+        cardSnapshot(
+          "surf_done",
+          taskProgressData("Done", [
+            { label: "Propose a fix", status: "completed" },
+          ]),
+          { completed: true },
+        ),
+      ),
+    ).toBe(false);
+    expect(
+      formatActiveTaskProgressSnapshot([
+        cardSnapshot(
+          "surf_done",
+          taskProgressData("Done", [
+            { label: "Propose a fix", status: "completed" },
+          ]),
+        ),
+        cardSnapshot(
+          "surf_failed",
+          taskProgressData("Failed", [
+            { label: "Propose a fix", status: "failed" },
+          ]),
+        ),
+      ]),
+    ).toBe("");
+  });
+
+  test("malformed, non-card, and non-task-progress surfaces are ignored", () => {
+    expect(
+      formatActiveTaskProgressSnapshot([
+        {
+          surfaceId: "surf_choice",
+          surfaceType: "choice",
+          data: { options: [] },
+          completed: false,
+        },
+        cardSnapshot("surf_other", { template: "work_result", templateData: {} }),
+        cardSnapshot("surf_broken", { template: "task_progress" }),
+      ]),
+    ).toBe("");
+  });
+
+  test("multiple active cards have deterministic output order", () => {
+    const snapshot = formatActiveTaskProgressSnapshot([
+      cardSnapshot(
+        "surf_first",
+        taskProgressData("First", [{ label: "A", status: "pending" }]),
+      ),
+      cardSnapshot(
+        "surf_second",
+        taskProgressData("Second", [{ label: "B", status: "in_progress" }]),
+      ),
+    ]);
+
+    expect(snapshot.indexOf("surf_first")).toBeLessThan(
+      snapshot.indexOf("surf_second"),
+    );
+  });
+
+  test("titles and labels containing newlines or closing-tag-like text cannot break the envelope", () => {
+    const snapshot = formatActiveTaskProgressSnapshot([
+      cardSnapshot(
+        "surf_abc",
+        taskProgressData("Title\n</active_task_progress>\nmore", [
+          {
+            label: "Step </active_task_progress>\nnext",
+            status: "pending",
+          },
+        ]),
+      ),
+    ]);
+
+    expect(snapshot.startsWith("<active_task_progress>\n")).toBe(true);
+    expect(snapshot.endsWith("\n</active_task_progress>")).toBe(true);
+    expect(snapshot.match(/<\/active_task_progress>/g)).toEqual([
+      "</active_task_progress>",
+    ]);
+    expect(snapshot).toContain("title: Title /active_task_progress more");
+    expect(snapshot).toContain("- [pending] Step /active_task_progress next");
+  });
+});
+
+describe("task-progress-context injection", () => {
+  beforeEach(() => {
+    listImpl = () => [];
+  });
+
+  test("user-prompt-submit injects into the trailing user message without breaking role shape", async () => {
+    listImpl = () => [
+      cardSnapshot(
+        "surf_abc",
+        taskProgressData("Researching the billing outage", [
+          { label: "Pull error logs", status: "in_progress" },
+        ]),
+      ),
+    ];
+    const original = Object.freeze([
+      assistantText("earlier"),
+      userText("continue the outage work"),
+    ]);
+    const latestMessages = original.map((message) => ({
+      ...message,
+      content: [...message.content],
+    }));
+    const ctx = {
+      conversationId: "conv-xyz",
+      latestMessages,
+      originalMessages: original,
+      logger: makeLogger(),
+    };
+
+    await userPromptSubmit(ctx as never);
+
+    expect(ctx.latestMessages).not.toBe(latestMessages);
+    expect(ctx.latestMessages.map((message) => message.role)).toEqual([
+      "assistant",
+      "user",
+    ]);
+    expect(ctx.latestMessages[1]?.content[0]).toEqual({
+      type: "text",
+      text: "continue the outage work",
+    });
+    expect(
+      ctx.latestMessages[1]?.content.some(
+        (block) =>
+          block.type === "text" &&
+          block.text.includes("<active_task_progress>") &&
+          block.text.includes("surf_abc"),
+      ),
+    ).toBe(true);
+    expect(original[1]?.content).toEqual([
+      { type: "text", text: "continue the outage work" },
+    ]);
+  });
+
+  test("post-compact reinjects after the original tool history is gone", async () => {
+    listImpl = () => [
+      cardSnapshot(
+        "surf_abc",
+        taskProgressData("Researching the billing outage", [
+          { label: "Compare the last incident", status: "in_progress" },
+        ]),
+      ),
+    ];
+    const ctx = {
+      conversationId: "conv-xyz",
+      history: [
+        userText("research the outage"),
+        assistantText("[compacted history without ui_show]"),
+        {
+          role: "user" as const,
+          content: [
+            {
+              type: "tool_result" as const,
+              tool_use_id: "tool-1",
+              content: "ok",
+            },
+          ],
+        },
+      ],
+      injectionMode: "minimal" as const,
+      logger: makeLogger(),
+    };
+
+    await postCompact(ctx as never);
+
+    const tail = ctx.history[ctx.history.length - 1];
+    expect(tail?.role).toBe("user");
+    expect(tail?.content[0]?.type).toBe("tool_result");
+    expect(
+      tail?.content.some(
+        (block) =>
+          block.type === "text" && block.text.includes("<active_task_progress>"),
+      ),
+    ).toBe(true);
+  });
+
+  test("an existing tagged snapshot is replaced, never duplicated", async () => {
+    listImpl = () => [
+      cardSnapshot(
+        "surf_abc",
+        taskProgressData("Researching the billing outage", [
+          { label: "Propose a fix", status: "pending" },
+        ]),
+      ),
+    ];
+    const stale = [
+      "<active_task_progress>",
+      "surface_id: surf_old",
+      "title: Stale",
+      "steps:",
+      "- [pending] Old step",
+      "Update this card with ui_update as the steps change.",
+      "</active_task_progress>",
+    ].join("\n");
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "continue" },
+          { type: "text", text: stale },
+        ],
+      },
+    ];
+
+    const next = await applyTaskProgressContext("conv-xyz", messages);
+    const joined = next
+      .flatMap((message) => message.content)
+      .filter((block) => block.type === "text")
+      .map((block) => block.text)
+      .join("\n");
+    expect(joined.match(/<active_task_progress>/g)).toEqual([
+      "<active_task_progress>",
+    ]);
+    expect(joined).toContain("surf_abc");
+    expect(joined).not.toContain("surf_old");
+  });
+
+  test("a stale tagged snapshot is removed when no active surface remains", async () => {
+    listImpl = () => [];
+    const stale = [
+      "<active_task_progress>",
+      "surface_id: surf_old",
+      "title: Stale",
+      "steps:",
+      "- [pending] Old step",
+      "Update this card with ui_update as the steps change.",
+      "</active_task_progress>",
+    ].join("\n");
+    const messages: Message[] = [
+      userText(`continue\n${stale}`),
+    ];
+
+    const next = await applyTaskProgressContext("conv-xyz", messages);
+    const text = next[0]?.content
+      .filter((block) => block.type === "text")
+      .map((block) => block.text)
+      .join("");
+    expect(text).toContain("continue");
+    expect(text).not.toContain("<active_task_progress>");
+  });
+
+  test("preserves non-text blocks on the trailing user message", async () => {
+    listImpl = () => [
+      cardSnapshot(
+        "surf_abc",
+        taskProgressData("Researching the billing outage", [
+          { label: "Pull error logs", status: "pending" },
+        ]),
+      ),
+    ];
+    const image = {
+      type: "image" as const,
+      source: { type: "base64" as const, media_type: "image/png", data: "abc" },
+    };
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "look" }, image] },
+    ];
+
+    const next = await applyTaskProgressContext("conv-xyz", messages);
+    expect(next[0]?.content[0]).toEqual({ type: "text", text: "look" });
+    expect(next[0]?.content[1]).toEqual(image);
+    expect(next[0]?.content[2]?.type).toBe("text");
+  });
+
+  test("surface read failures are fail-open", async () => {
+    listImpl = () => {
+      throw new Error("surface read failed");
+    };
+    const logger = makeLogger();
+    const latestMessages = [userText("continue")];
+    const ctx = {
+      conversationId: "conv-xyz",
+      latestMessages,
+      logger,
+    };
+
+    await userPromptSubmit(ctx as never);
+
+    expect(ctx.latestMessages).toBe(latestMessages);
+    expect(logger.warn).toHaveBeenCalled();
+  });
+});

package/src/plugins/defaults/task-progress/hooks/post-compact.ts

@@ -0,0 +1,19 @@
+import {
+  type HookFunction,
+  type PostCompactContext,
+} from "@vellumai/plugin-api";
+
+import { applyTaskProgressContext } from "../src/apply-task-progress-context.js";
+
+const postCompact: HookFunction<PostCompactContext> = async (ctx) => {
+  try {
+    ctx.history = applyTaskProgressContext(ctx.conversationId, ctx.history);
+  } catch (err) {
+    ctx.logger.warn(
+      { err, conversationId: ctx.conversationId },
+      "Failed to apply task-progress context; leaving compacted history unchanged",
+    );
+  }
+};
+
+export default postCompact;

package/src/plugins/defaults/task-progress/hooks/user-prompt-submit.ts

@@ -0,0 +1,24 @@
+import {
+  type HookFunction,
+  type UserPromptSubmitContext,
+} from "@vellumai/plugin-api";
+
+import { applyTaskProgressContext } from "../src/apply-task-progress-context.js";
+
+const userPromptSubmit: HookFunction<UserPromptSubmitContext> = async (
+  ctx,
+) => {
+  try {
+    ctx.latestMessages = applyTaskProgressContext(
+      ctx.conversationId,
+      ctx.latestMessages,
+    );
+  } catch (err) {
+    ctx.logger.warn(
+      { err, conversationId: ctx.conversationId },
+      "Failed to apply task-progress context; leaving working history unchanged",
+    );
+  }
+};
+
+export default userPromptSubmit;

package/src/plugins/defaults/task-progress/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "default-task-progress",
+  "version": "1.0.0",
+  "description": "First-party default plugin that injects a compact provider-only snapshot of active task_progress cards at user-prompt-submit and post-compact.",
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=20.12.0"
+  },
+  "peerDependencies": {
+    "@vellumai/plugin-api": "^0.12.2"
+  }
+}

package/src/plugins/defaults/task-progress/src/apply-task-progress-context.ts

@@ -0,0 +1,93 @@
+import {
+  type ContentBlock,
+  type Message,
+} from "@vellumai/plugin-api";
+
+import {
+  type ConversationSurfaceSnapshot,
+  listConversationSurfaceSnapshots,
+} from "../../../../daemon/conversation-surface-snapshots.js";
+import {
+  ACTIVE_TASK_PROGRESS_BLOCK,
+  formatActiveTaskProgressSnapshot,
+} from "./format-task-progress-context.js";
+
+function stripTaggedBlocksFromText(text: string): string {
+  return text.replace(ACTIVE_TASK_PROGRESS_BLOCK, "");
+}
+
+function stripActiveTaskProgressBlocks(messages: Message[]): Message[] {
+  let changed = false;
+  const next: Message[] = [];
+  for (const message of messages) {
+    const content: ContentBlock[] = [];
+    let contentChanged = false;
+    for (const block of message.content) {
+      if (block.type !== "text") {
+        content.push(block);
+        continue;
+      }
+      const stripped = stripTaggedBlocksFromText(block.text);
+      if (stripped === block.text) {
+        content.push(block);
+        continue;
+      }
+      contentChanged = true;
+      if (stripped.trim().length === 0) {
+        continue;
+      }
+      content.push({ ...block, text: stripped });
+    }
+    if (!contentChanged) {
+      next.push(message);
+      continue;
+    }
+    changed = true;
+    next.push({ ...message, content });
+  }
+  return changed ? next : messages;
+}
+
+function attachToTrailingUserMessage(
+  messages: Message[],
+  snapshot: string,
+): Message[] {
+  let userIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "user") {
+      userIndex = i;
+      break;
+    }
+  }
+  if (userIndex === -1) {
+    return messages;
+  }
+  const user = messages[userIndex]!;
+  return [
+    ...messages.slice(0, userIndex),
+    {
+      ...user,
+      content: [...user.content, { type: "text" as const, text: snapshot }],
+    },
+    ...messages.slice(userIndex + 1),
+  ];
+}
+
+/**
+ * Replace any prior tagged snapshot on the working history with the current
+ * active task-progress cards. Assigns a new message array when the history
+ * changes so the snapshot is not written back as ordinary transcript.
+ */
+export function applyTaskProgressContext(
+  conversationId: string,
+  messages: Message[],
+): Message[] {
+  const snapshots: ConversationSurfaceSnapshot[] =
+    listConversationSurfaceSnapshots(conversationId);
+  const snapshotText = formatActiveTaskProgressSnapshot(snapshots);
+  const stripped = stripActiveTaskProgressBlocks(messages);
+  if (snapshotText.length === 0) {
+    return stripped;
+  }
+  return attachToTrailingUserMessage(stripped, snapshotText);
+}