@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/daemon/message-types/messages.ts

@@ -13,8 +13,14 @@ import type { MessageQueuedDeletedEvent } from "../../api/events/message-queued-
 import type { MessageRequestCompleteEvent } from "../../api/events/message-request-complete.js";
 import type { QuestionRequestEvent } from "../../api/events/question-request.js";
 import type { SecretRequestEvent } from "../../api/events/secret-request.js";
+import type { ToolOutputChunkEvent } from "../../api/events/tool-output-chunk.js";
 import type { ToolResultEvent } from "../../api/events/tool-result.js";
+import type { ToolUsePreviewStartEvent } from "../../api/events/tool-use-preview-start.js";
 import type { ToolUseStartEvent } from "../../api/events/tool-use-start.js";
+import type {
+  TraceEvent,
+  TraceEventKind,
+} from "../../api/events/trace-event.js";
 import type { TurnProfileAutoRoutedEvent } from "../../api/events/turn-profile-auto-routed.js";
 import type { UserMessageEchoEvent } from "../../api/events/user-message-echo.js";
 import type { ChannelId, InterfaceId } from "../../channels/types.js";
@@ -79,31 +85,6 @@ export interface AssistantThinkingDelta {
   messageId?: string;
 }
 
-export interface ToolOutputChunk {
-  type: "tool_output_chunk";
-  chunk: string;
-  conversationId?: string;
-  toolUseId?: string;
-  subType?: "tool_start" | "tool_complete" | "status";
-  subToolName?: string;
-  subToolInput?: string;
-  subToolIsError?: boolean;
-  subToolId?: string;
-  /** Database ID of the assistant message that owns the parent tool_use
-   *  block. Same semantics as `AssistantTextDeltaEvent.messageId`. */
-  messageId?: string;
-}
-
-export interface ToolUsePreviewStart {
-  type: "tool_use_preview_start";
-  toolUseId: string;
-  toolName: string;
-  conversationId?: string;
-  /** Database ID of the assistant message that owns this tool_use block.
-   *  Same semantics as `AssistantTextDeltaEvent.messageId`. */
-  messageId?: string;
-}
-
 export interface ToolInputDelta {
   type: "tool_input_delta";
   toolName: string;
@@ -165,36 +146,7 @@ export interface ConversationInferenceProfileUpdated {
   expiresAt?: number | null;
 }
 
-export type TraceEventKind =
-  | "request_received"
-  | "request_queued"
-  | "request_dequeued"
-  | "llm_call_started"
-  | "llm_call_finished"
-  | "assistant_message"
-  | "tool_started"
-  | "tool_permission_requested"
-  | "tool_permission_decided"
-  | "tool_finished"
-  | "tool_failed"
-  | "generation_handoff"
-  | "message_complete"
-  | "generation_cancelled"
-  | "request_error"
-  | "tool_profiling_summary";
-
-export interface TraceEvent {
-  type: "trace_event";
-  eventId: string;
-  conversationId: string;
-  requestId?: string;
-  timestampMs: number;
-  sequence: number;
-  kind: TraceEventKind;
-  status?: "info" | "success" | "warning" | "error";
-  summary: string;
-  attributes?: Record<string, string | number | boolean | null>;
-}
+export type { TraceEvent, TraceEventKind };
 
 // --- Domain-level union aliases (consumed by the barrel file) ---
 
@@ -210,8 +162,8 @@ export type _MessagesServerMessages =
   | AssistantTextDeltaEvent
   | AssistantThinkingDelta
   | ToolUseStartEvent
-  | ToolUsePreviewStart
-  | ToolOutputChunk
+  | ToolUsePreviewStartEvent
+  | ToolOutputChunkEvent
   | ToolInputDelta
   | ToolResultEvent
   | ConfirmationRequestEvent

package/src/daemon/message-types/skills.ts

@@ -86,6 +86,7 @@ interface SlimSkillBase {
   id: string;
   name: string;
   description: string;
+  icon?: string;
   emoji?: string;
   kind: "bundled" | "installed" | "catalog";
   status: "enabled" | "disabled" | "available";
@@ -157,6 +158,7 @@ interface SkillDetailBase {
   id: string;
   name: string;
   description: string;
+  icon?: string;
   emoji?: string;
   kind: "bundled" | "installed" | "catalog";
   status: "enabled" | "disabled" | "available";

package/src/daemon/message-types/surfaces.ts

@@ -4,6 +4,9 @@
 
 export type SurfaceType =
   | "card"
+  | "choice"
+  | "copy_block"
+  | "oauth_connect"
   | "form"
   | "list"
   | "table"
@@ -11,9 +14,12 @@ export type SurfaceType =
   | "dynamic_page"
   | "file_upload"
   | "document_preview"
-  | "task_preferences";
+  | "task_preferences"
+  | "work_result";
 
 export const INTERACTIVE_SURFACE_TYPES: SurfaceType[] = [
+  "choice",
+  "oauth_connect",
   "form",
   "confirmation",
   "dynamic_page",
@@ -40,6 +46,45 @@ export interface CardSurfaceData {
   templateData?: Record<string, unknown>;
 }
 
+export interface ChoiceOption {
+  id: string;
+  title: string;
+  description?: string;
+  /** Visually highlight this option as the assistant's recommendation. */
+  recommended?: boolean;
+  /** Optional structured payload returned with this choice. */
+  data?: Record<string, unknown>;
+}
+
+export interface ChoiceSurfaceData {
+  description?: string;
+  options: ChoiceOption[];
+  selectionMode?: "single" | "multiple";
+  /**
+   * When true, clicking an option submits it immediately. Defaults to true for
+   * single-select choice surfaces.
+   */
+  commitOnSelect?: boolean;
+  submitLabel?: string;
+}
+
+export interface CopyBlockSurfaceData {
+  text: string;
+  label?: string;
+  language?: string;
+}
+
+export interface OAuthConnectSurfaceData {
+  /** OAuth provider key from the managed provider catalog, e.g. "google". */
+  providerKey: string;
+  /** Optional display label. The client falls back to the provider catalog. */
+  displayName?: string;
+  /** Optional helper text. The client falls back to the provider catalog. */
+  description?: string;
+  /** Optional provider logo URL. The client falls back to the provider catalog. */
+  logoUrl?: string | null;
+}
+
 export interface FormField {
   id: string;
   type: "text" | "textarea" | "select" | "toggle" | "number" | "password";
@@ -148,15 +193,79 @@ export interface DocumentPreviewSurfaceData {
   subtitle?: string;
 }
 
+export type WorkResultStatus =
+  | "completed"
+  | "partial"
+  | "failed"
+  | "in_progress";
+
+export type WorkResultTone = "neutral" | "positive" | "warning" | "negative";
+
+export type WorkResultSectionType =
+  | "items"
+  | "timeline"
+  | "diff"
+  | "artifacts"
+  | "warnings";
+
+export interface WorkResultMetric {
+  label: string;
+  value: string | number;
+  detail?: string;
+  tone?: WorkResultTone;
+}
+
+export interface WorkResultMetadata {
+  label: string;
+  value: string | number;
+}
+
+export interface WorkResultItem {
+  id?: string;
+  title: string;
+  description?: string;
+  status?: string;
+  tone?: WorkResultTone;
+  metadata?: WorkResultMetadata[];
+  href?: string;
+}
+
+export interface WorkResultDiff {
+  label?: string;
+  before?: string;
+  after?: string;
+}
+
+export interface WorkResultSection {
+  id?: string;
+  title: string;
+  description?: string;
+  type?: WorkResultSectionType;
+  items?: WorkResultItem[];
+  diffs?: WorkResultDiff[];
+}
+
+export interface WorkResultSurfaceData {
+  eyebrow?: string;
+  status?: WorkResultStatus;
+  summary?: string;
+  metrics?: WorkResultMetric[];
+  sections?: WorkResultSection[];
+}
+
 export type SurfaceData =
   | CardSurfaceData
+  | ChoiceSurfaceData
+  | CopyBlockSurfaceData
+  | OAuthConnectSurfaceData
   | FormSurfaceData
   | ListSurfaceData
   | TableSurfaceData
   | ConfirmationSurfaceData
   | DynamicPageSurfaceData
   | FileUploadSurfaceData
-  | DocumentPreviewSurfaceData;
+  | DocumentPreviewSurfaceData
+  | WorkResultSurfaceData;
 
 // === Client → Server ===
 
@@ -197,6 +306,21 @@ export interface UiSurfaceShowCard extends UiSurfaceShowBase {
   data: CardSurfaceData;
 }
 
+export interface UiSurfaceShowChoice extends UiSurfaceShowBase {
+  surfaceType: "choice";
+  data: ChoiceSurfaceData;
+}
+
+export interface UiSurfaceShowCopyBlock extends UiSurfaceShowBase {
+  surfaceType: "copy_block";
+  data: CopyBlockSurfaceData;
+}
+
+export interface UiSurfaceShowOAuthConnect extends UiSurfaceShowBase {
+  surfaceType: "oauth_connect";
+  data: OAuthConnectSurfaceData;
+}
+
 export interface UiSurfaceShowForm extends UiSurfaceShowBase {
   surfaceType: "form";
   data: FormSurfaceData;
@@ -232,15 +356,24 @@ export interface UiSurfaceShowDocumentPreview extends UiSurfaceShowBase {
   data: DocumentPreviewSurfaceData;
 }
 
+export interface UiSurfaceShowWorkResult extends UiSurfaceShowBase {
+  surfaceType: "work_result";
+  data: WorkResultSurfaceData;
+}
+
 export type UiSurfaceShow =
   | UiSurfaceShowCard
+  | UiSurfaceShowChoice
+  | UiSurfaceShowCopyBlock
+  | UiSurfaceShowOAuthConnect
   | UiSurfaceShowForm
   | UiSurfaceShowList
   | UiSurfaceShowTable
   | UiSurfaceShowConfirmation
   | UiSurfaceShowDynamicPage
   | UiSurfaceShowFileUpload
-  | UiSurfaceShowDocumentPreview;
+  | UiSurfaceShowDocumentPreview
+  | UiSurfaceShowWorkResult;
 
 export interface UiSurfaceUpdate {
   type: "ui_surface_update";

package/src/daemon/now-scratchpad.ts

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync } from "node:fs";
+
+import { getWorkspacePromptPath } from "../util/platform.js";
+import { stripCommentLines } from "../util/strip-comment-lines.js";
+
+/**
+ * Read the NOW.md scratchpad from the workspace prompt directory.
+ *
+ * Returns the trimmed content with `_`-prefixed comment lines stripped,
+ * or `null` if the file is missing, empty, or unreadable.
+ */
+export function readNowScratchpad(): string | null {
+  const nowPath = getWorkspacePromptPath("NOW.md");
+  if (!existsSync(nowPath)) return null;
+  try {
+    const stripped = stripCommentLines(readFileSync(nowPath, "utf-8")).trim();
+    return stripped.length > 0 ? stripped : null;
+  } catch {
+    return null;
+  }
+}

package/src/daemon/orphan-reaper.test.ts

@@ -0,0 +1,210 @@
+/**
+ * Tests for the orphan subprocess reaper.
+ *
+ * - `parseProcStat` must read state/ppid correctly even when the executable
+ *   name (`comm`) contains spaces and parentheses.
+ * - `selectReapable` must defer a zombie for one full scan interval (so libuv
+ *   reaps its own tracked children first) and reap it on the next scan.
+ * - An integration test makes the test process a child subreaper via
+ *   `PR_SET_CHILD_SUBREAPER`, orphans a grandchild, and verifies the
+ *   exported logic defers-then-reaps the real `<defunct>` entry while libuv
+ *   independently reaps the directly-spawned (tracked) child.
+ */
+import { spawn } from "node:child_process";
+import { readdirSync, readFileSync } from "node:fs";
+import { dlopen, FFIType, ptr } from "bun:ffi";
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+const { parseProcStat, selectReapable } = await import("./orphan-reaper.js");
+const { DaemonConfigSchema } = await import("../config/schemas/platform.js");
+
+describe("parseProcStat", () => {
+  test("parses a normal stat line", () => {
+    // GIVEN a well-formed /proc/<pid>/stat line for a zombie
+    const line = "1234 (bash) Z 1 1234 1234 0 -1 ...";
+    // WHEN it is parsed
+    const parsed = parseProcStat(line);
+    // THEN comm, state, and ppid are extracted
+    expect(parsed).toEqual({ comm: "bash", state: "Z", ppid: 1 });
+  });
+
+  test("handles comm containing spaces and parentheses", () => {
+    // GIVEN a stat line whose comm field itself contains spaces and parens
+    const line = "42 (weird (name) x) Z 1 42 42 0 -1 4194560";
+    // WHEN it is parsed
+    const parsed = parseProcStat(line);
+    // THEN fields are read relative to the final ')', not naive splitting
+    expect(parsed).toEqual({ comm: "weird (name) x", state: "Z", ppid: 1 });
+  });
+
+  test("reads a non-zombie running state", () => {
+    // GIVEN a running (non-zombie) process line
+    const line = "77 (node) R 12 77 77";
+    // WHEN it is parsed
+    const parsed = parseProcStat(line);
+    // THEN the running state and parent pid are reported
+    expect(parsed?.state).toBe("R");
+    expect(parsed?.ppid).toBe(12);
+  });
+
+  test("returns null for malformed lines", () => {
+    // GIVEN malformed or truncated stat content
+    // WHEN each is parsed
+    // THEN null is returned rather than a bogus record
+    expect(parseProcStat("")).toBeNull();
+    expect(parseProcStat("no parens here")).toBeNull();
+    expect(parseProcStat("123 (proc)")).toBeNull();
+  });
+});
+
+describe("selectReapable", () => {
+  test("defers a newly-seen zombie for one interval", () => {
+    // GIVEN zombies never seen on a previous scan
+    // WHEN deciding what to reap with an empty seen set
+    const { reap, nextSeen } = selectReapable([100, 101], new Set());
+    // THEN nothing is reaped yet, but both are carried into the next scan
+    expect(reap).toEqual([]);
+    expect([...nextSeen].sort()).toEqual([100, 101]);
+  });
+
+  test("reaps a zombie that survived the previous scan", () => {
+    // GIVEN pid 100 was already seen on the prior scan and 101 is new
+    // WHEN deciding what to reap
+    const { reap } = selectReapable([100, 101], new Set([100]));
+    // THEN only the survivor (100) is reaped; the newcomer is deferred
+    expect(reap).toEqual([100]);
+  });
+
+  test("drops PIDs that have disappeared from the next seen set", () => {
+    // GIVEN pid 100 was seen before but is gone now
+    // WHEN computing the next seen set
+    const { nextSeen } = selectReapable([101], new Set([100, 101]));
+    // THEN only currently-present pids are retained
+    expect([...nextSeen]).toEqual([101]);
+  });
+});
+
+describe("daemon.reapOrphanedSubprocesses gate", () => {
+  test("defaults to off so the reaper is opt-in", () => {
+    // GIVEN a daemon config with the reaper flag unspecified
+    // WHEN it is parsed with schema defaults
+    const parsed = DaemonConfigSchema.parse({});
+    // THEN the reaper is disabled unless explicitly turned on
+    expect(parsed.reapOrphanedSubprocesses).toBe(false);
+  });
+
+  test("honors an explicit opt-in", () => {
+    // GIVEN a daemon config that explicitly enables the reaper
+    // WHEN it is parsed
+    const parsed = DaemonConfigSchema.parse({ reapOrphanedSubprocesses: true });
+    // THEN the flag is respected
+    expect(parsed.reapOrphanedSubprocesses).toBe(true);
+  });
+});
+
+// ── Integration: real reparented orphan on Linux ────────────────────────────
+const itLinux = process.platform === "linux" ? test : test.skip;
+
+// Bind libc only on Linux — "libc.so.6" does not exist on macOS, so binding it
+// unconditionally would throw at import and break the pure-function tests too.
+const lib =
+  process.platform === "linux"
+    ? dlopen("libc.so.6", {
+        waitpid: {
+          args: [FFIType.i32, FFIType.ptr, FFIType.i32],
+          returns: FFIType.i32,
+        },
+        prctl: {
+          args: [
+            FFIType.i32,
+            FFIType.u64,
+            FFIType.u64,
+            FFIType.u64,
+            FFIType.u64,
+          ],
+          returns: FFIType.i32,
+        },
+      })
+    : null;
+const WNOHANG = 1;
+const PR_SET_CHILD_SUBREAPER = 36;
+const statusBuf = new Int32Array(1);
+
+function zombieChildPids(): number[] {
+  const self = process.pid;
+  const out: number[] = [];
+  for (const entry of readdirSync("/proc")) {
+    const pid = Number(entry);
+    if (!Number.isInteger(pid) || pid <= 1) continue;
+    let stat: string;
+    try {
+      stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+    } catch {
+      continue;
+    }
+    const parsed = parseProcStat(stat);
+    if (parsed && parsed.state === "Z" && parsed.ppid === self) out.push(pid);
+  }
+  return out;
+}
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+afterAll(() => {
+  if (!lib) return;
+  // Reap anything still lingering so the test process leaves no zombies.
+  for (const pid of zombieChildPids())
+    lib.symbols.waitpid(pid, ptr(statusBuf), WNOHANG);
+});
+
+itLinux(
+  "defers then reaps a reparented orphan while libuv reaps the tracked child",
+  async () => {
+    if (!lib) return;
+    // GIVEN this process is a child subreaper, so orphaned grandchildren
+    // reparent here exactly as they reparent to a PID-1 daemon
+    expect(lib.symbols.prctl(PR_SET_CHILD_SUBREAPER, 1n, 0n, 0n, 0n)).toBe(0);
+
+    // AND a libuv-tracked child (A) that detaches a grandchild (B) into its
+    // own session and exits immediately; B reparents to us and, once it
+    // exits, becomes a zombie with our pid as its parent
+    let trackedChildExited = false;
+    const a = spawn("bash", ["-c", "setsid -f sleep 0.4; exit 0"], {
+      stdio: "ignore",
+    });
+    a.on("exit", () => {
+      trackedChildExited = true;
+    });
+
+    // AND we wait for that orphan to surface as our zombie child
+    let zombies: number[] = [];
+    for (let i = 0; i < 40 && zombies.length === 0; i++) {
+      await sleep(50);
+      zombies = zombieChildPids();
+    }
+    expect(zombies.length).toBeGreaterThan(0);
+    expect(trackedChildExited).toBe(true); // libuv reaped A independently
+
+    // WHEN we run the deferred-reap algorithm across two scans
+    // (scan #1 is the grace pass, scan #2 reaps the survivor)
+    const scan1 = selectReapable(zombieChildPids(), new Set<number>());
+    const scan2 = selectReapable(zombieChildPids(), scan1.nextSeen);
+    let reaped = 0;
+    for (const pid of scan2.reap) {
+      if (lib.symbols.waitpid(pid, ptr(statusBuf), WNOHANG) > 0) reaped++;
+    }
+    await sleep(50);
+
+    // THEN nothing is reaped on the grace pass, the survivor is reaped on the
+    // second pass, and no defunct child remains
+    expect(scan1.reap).toEqual([]);
+    expect(scan2.reap.length).toBeGreaterThan(0);
+    expect(reaped).toBeGreaterThan(0);
+    expect(zombieChildPids()).toEqual([]);
+  },
+);