@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/live-voice/protocol.ts

@@ -8,6 +8,7 @@ const LIVE_VOICE_CLIENT_FRAME_TYPES = [
   "end",
   "update_config",
   "attach_image",
+  "text",
 ] as const;
 
 type LiveVoiceClientFrameType = (typeof LIVE_VOICE_CLIENT_FRAME_TYPES)[number];
@@ -101,6 +102,22 @@ export interface LiveVoiceClientStartFrame {
    * [{@link MIN_BARGE_IN_MIN_SPEECH_MS}, {@link MAX_BARGE_IN_MIN_SPEECH_MS}].
    */
   readonly bargeInMinSpeechMs?: number;
+  /**
+   * The client has a text input affordance, so it can take a turn without the
+   * microphone (see {@link LiveVoiceClientTextTurnFrame}).
+   *
+   * Load-bearing at startup, not just a feature announcement: a session whose
+   * speech-to-text leg has no working credential is normally rejected outright
+   * (`credentials_unavailable`), because a session that cannot hear is a
+   * session that cannot be used. A client that can type is the exception: for
+   * it, a missing STT leg is degradation rather than failure, so the session
+   * starts text-only and says so on `ready` via `audioInput: false`.
+   *
+   * Absent means false: a client that predates the field has no way to take a
+   * turn without the microphone, so a broken STT leg must still fail its
+   * session rather than open one it cannot speak into.
+   */
+  readonly textInput?: boolean;
   /**
    * Which client opened the session. Absent from clients that predate the
    * field, in which case the originating client is simply unknown.
@@ -129,6 +146,15 @@ export const MAX_SILENCE_THRESHOLD_MS = 5_000;
 export const MIN_BARGE_IN_MIN_SPEECH_MS = 0;
 export const MAX_BARGE_IN_MIN_SPEECH_MS = 3_000;
 
+/**
+ * Longest typed turn accepted on a `text` frame.
+ *
+ * Generous next to anything a person says in one breath, and far below what
+ * would make the reply unspeakable. The cap exists so a socket tuned for 50 ms
+ * audio frames cannot be handed a whole document to synthesize.
+ */
+export const MAX_TEXT_TURN_CHARS = 4_000;
+
 export interface LiveVoiceClientAudioFrame {
   readonly type: "audio";
   readonly dataBase64: string;
@@ -180,6 +206,45 @@ export interface LiveVoiceClientAttachImageFrame {
   readonly attachmentId: string;
 }
 
+/**
+ * A user turn the client already has as text, taken without the microphone.
+ *
+ * The session runs it through the same pipeline a spoken turn takes, joining
+ * at the point STT would have handed over a finished transcript: same turn
+ * runner, same streaming TTS, same barge-in and progress narration. Only the
+ * capture half is skipped, so the reply is spoken exactly as it would be for
+ * speech.
+ *
+ * Deliberately not routed through `processMessage` into the conversation the
+ * session owns. That path diverges from the voice one in ways that have
+ * already produced their own bug class (missing user_message_echo, an
+ * unpersisted conversation row, missing trustContext), and a typed turn that
+ * behaved differently from a spoken one would reintroduce all of it.
+ *
+ * Accepted at any point in a session, not only as its first turn. A user
+ * whose microphone stops working mid-session types the rest of the
+ * conversation; a client with no microphone at all (see the start frame's
+ * `textInput`) types every turn.
+ */
+export interface LiveVoiceClientTextTurnFrame {
+  readonly type: "text";
+  readonly text: string;
+  /**
+   * Marks the turn as an internal instruction rather than something the user
+   * typed. The row still persists and still drives the turn, so the model
+   * sees it, but it is suppressed from the transcript: no live echo, and
+   * `/messages` filters it after a reload.
+   *
+   * For machine signals the user never wrote, such as the greeting that opens
+   * a voice session. A turn the user actually typed leaves it unset.
+   *
+   * Optional, and a daemon that does not understand it simply persists the
+   * turn visibly, so a client cannot tell from the frame alone whether it was
+   * honored.
+   */
+  readonly hidden?: boolean;
+}
+
 export type LiveVoiceClientFrame =
   | LiveVoiceClientStartFrame
   | LiveVoiceClientAudioFrame
@@ -187,7 +252,8 @@ export type LiveVoiceClientFrame =
   | LiveVoiceClientInterruptFrame
   | LiveVoiceClientEndFrame
   | LiveVoiceClientUpdateConfigFrame
-  | LiveVoiceClientAttachImageFrame;
+  | LiveVoiceClientAttachImageFrame
+  | LiveVoiceClientTextTurnFrame;
 
 interface LiveVoiceBinaryAudioFrame {
   readonly type: "binary_audio";
@@ -209,11 +275,55 @@ export interface LiveVoiceReadyServerFrame extends LiveVoiceServerFrameBase {
    * (older daemons) means "manual".
    */
   readonly turnDetection?: LiveVoiceTurnDetectionMode;
+  /**
+   * Whether this daemon will accept `text` frames on the session. Absent
+   * (older daemons) means no, which is what lets a client that asked for
+   * `textInput` fall back rather than type into a socket that would answer
+   * every typed turn with an `unknown_type` error.
+   */
+  readonly textInput?: boolean;
+  /**
+   * Whether the session's speech-to-text leg is live. Absent means yes, which
+   * is the only thing an older daemon can have meant: it rejects a session it
+   * cannot transcribe, so every session it readies can hear.
+   *
+   * False is reachable only for a client that declared `textInput`, and tells
+   * it to present the session as typed rather than draw a microphone that
+   * will never hear anything.
+   */
+  readonly audioInput?: boolean;
+}
+
+/**
+ * Where the session holding the daemon's single live-voice slot is running,
+ * as much of it as the daemon knows.
+ *
+ * Display only: it is what lets a client refused a session say where the one
+ * that blocked it is. Nothing routes, authorizes, or decides capability on
+ * it, and every field is optional, so a holder that names neither its surface
+ * nor a conversation is simply less specific.
+ */
+export interface LiveVoiceSessionHolder {
+  /**
+   * The OS surface the holder is running on, from its `start` frame. A
+   * {@link ClientOs} carries no transport meaning by contract (see
+   * `channels/types.ts`), which is exactly right for a label: it says which
+   * device the user should go looking on, and answers nothing else.
+   */
+  readonly client?: ClientOs;
+  /** The conversation the holder is talking in, once it has one. */
+  readonly conversationId?: string;
 }
 
 export interface LiveVoiceBusyServerFrame extends LiveVoiceServerFrameBase {
   readonly type: "busy";
   readonly activeSessionId: string;
+  /**
+   * Absent from daemons that predate it, and from a holder that revealed
+   * neither field, so a client must degrade to the unspecific copy rather
+   * than assume.
+   */
+  readonly holder?: LiveVoiceSessionHolder;
 }
 
 /**
@@ -544,7 +654,73 @@ export function validateLiveVoiceClientFrame(
       return validateUpdateConfigFrame(value);
     case "attach_image":
       return validateAttachImageFrame(value);
+    case "text":
+      return validateTextTurnFrame(value);
+  }
+}
+
+function validateTextTurnFrame(
+  value: Record<string, unknown>,
+): LiveVoiceParseResult<LiveVoiceClientTextTurnFrame> {
+  if (!("text" in value)) {
+    return protocolError(
+      "missing_required_field",
+      "text frame is missing required field text",
+      "text",
+      "text",
+    );
+  }
+
+  if (typeof value.text !== "string") {
+    return protocolError(
+      "invalid_field",
+      "text frame field text must be a string",
+      "text",
+      "text",
+    );
+  }
+
+  // Trimmed before the emptiness check, so a frame carrying only whitespace is
+  // rejected here rather than reaching the session as a turn with nothing in
+  // it. The trimmed value is what travels, so the turn the session runs is the
+  // one that was validated.
+  const text = value.text.trim();
+
+  if (text.length === 0) {
+    return protocolError(
+      "invalid_field",
+      "text frame field text must not be empty",
+      "text",
+      "text",
+    );
+  }
+
+  if (text.length > MAX_TEXT_TURN_CHARS) {
+    return protocolError(
+      "invalid_field",
+      `text frame field text must be at most ${MAX_TEXT_TURN_CHARS} characters`,
+      "text",
+      "text",
+    );
+  }
+
+  if ("hidden" in value && typeof value.hidden !== "boolean") {
+    return protocolError(
+      "invalid_field",
+      "text frame field hidden must be a boolean",
+      "hidden",
+      "text",
+    );
   }
+
+  return {
+    ok: true,
+    frame: {
+      type: "text",
+      text,
+      ...(value.hidden === true ? { hidden: true } : {}),
+    },
+  };
 }
 
 function validateAttachImageFrame(
@@ -744,6 +920,15 @@ function validateStartFrame(
     );
   }
 
+  if ("textInput" in value && typeof value.textInput !== "boolean") {
+    return protocolError(
+      "invalid_field",
+      "start frame field textInput must be a boolean",
+      "textInput",
+      "start",
+    );
+  }
+
   // An unrecognized client is dropped rather than rejected: the field is an
   // analytics dimension, and failing a session's startup over it would trade a
   // gap in a chart for a user who cannot talk to their assistant.
@@ -767,6 +952,7 @@ function validateStartFrame(
       ...(typeof value.bargeInMinSpeechMs === "number"
         ? { bargeInMinSpeechMs: value.bargeInMinSpeechMs }
         : {}),
+      ...(value.textInput === true ? { textInput: true } : {}),
     },
   };
 }

package/src/messaging/providers/discord/api.ts

@@ -21,7 +21,8 @@ import { retryableCall } from "../retry-policy.js";
 
 const log = getLogger("discord-api");
 
-const DISCORD_API_BASE_URL = "https://discord.com/api/v10";
+/** Exported so a caller validating a not-yet-stored token uses the same base. */
+export const DISCORD_API_BASE_URL = "https://discord.com/api/v10";
 
 /**
  * Discord requires HTTP API clients to identify themselves with a User-Agent

package/src/messaging/providers/discord/withdraw.ts

@@ -0,0 +1,62 @@
+/**
+ * Withdraw a Discord approval card when its underlying guardian request
+ * resolves.
+ *
+ * A Discord card is plain text whose actionable tail (the typed-command
+ * instructions) rides the last chunk, and that chunk's id is what the
+ * delivery row captured. Rewriting it to the terminal outcome removes every
+ * live affordance and shows the decision in one edit, so no separate status
+ * reply is needed. The delivery row's chat id is the guardian's *user*
+ * snowflake, never a room: the DM channel is resolved from the person at
+ * withdrawal time, the same way the adapter resolved it to deliver.
+ */
+
+import {
+  isParkAction,
+  resolveDecisionStatusWord,
+} from "../../../runtime/channel-approval-types.js";
+import { getLogger } from "../../../util/logger.js";
+import { openDiscordDmChannel } from "./api.js";
+import { editDiscordMessage } from "./send.js";
+
+const log = getLogger("discord-withdraw");
+
+const STATUS_GLYPH: Record<string, string> = {
+  approved: "✅",
+  denied: "❌",
+  expired: "⌛",
+};
+
+const PARK_STATUS_GLYPH = "⏸️";
+
+function buildStatusText(status: string, decidedAction?: string): string {
+  const park = status === "denied" && isParkAction(decidedAction);
+  const glyph = park ? PARK_STATUS_GLYPH : (STATUS_GLYPH[status] ?? "");
+  const word = resolveDecisionStatusWord(status, decidedAction);
+  return glyph ? `${glyph} ${word}` : word;
+}
+
+export interface WithdrawDiscordApprovalCardParams {
+  /** The guardian's user snowflake from the delivery row. */
+  guardianUserId: string;
+  /** The card's last-chunk message id from the delivery row. */
+  messageId: string;
+  status: string;
+  decidedAction?: string;
+}
+
+export async function withdrawDiscordApprovalCard(
+  params: WithdrawDiscordApprovalCardParams,
+): Promise<void> {
+  const channelId = await openDiscordDmChannel(params.guardianUserId);
+  await editDiscordMessage(
+    { channelId },
+    params.messageId,
+    buildStatusText(params.status, params.decidedAction),
+    { emphasis: "muted" },
+  );
+  log.info(
+    { guardianUserId: params.guardianUserId, messageId: params.messageId },
+    "Discord approval card withdrawn",
+  );
+}

package/src/messaging/read-provider-metadata.ts

@@ -1,3 +1,4 @@
+import type { ChannelId } from "../channels/types.js";
 import { safeParseRecord } from "../util/json.js";
 import {
   type ProviderMessageMetadata,
@@ -49,3 +50,34 @@ export function readProviderMetadata(
   const slackMeta = readSlackMetadataFromMessageMetadata(metadata, opts);
   return slackMeta ? slackMetadataAsProviderMetadata(slackMeta) : null;
 }
+
+/**
+ * Merge an edit or delete stamp into a row's serialized metadata, producing
+ * the neutral envelope to store back under `providerMeta`.
+ *
+ * The base is whatever the row already says about itself through
+ * {@link readProviderMetadata}, flat-legacy Slack rows included, so fields
+ * the old envelope carried (thread, actor, display name) survive the stamp
+ * rather than being shadowed by a minimal synthesis. A row that says
+ * nothing gets the envelope synthesized from the caller's lookup-derived
+ * facts, so the result always validates on read.
+ */
+export function mergeProviderMessageMetadata(
+  rowMetadata: string | null,
+  seed: {
+    source: ChannelId;
+    conversationExternalId: string;
+    messageId: string;
+    threadId?: string;
+  },
+  patch: { editedAt?: number; deletedAt?: number },
+): string {
+  const base = readProviderMetadata(rowMetadata, { allowFlatLegacy: true }) ?? {
+    source: seed.source,
+    conversationExternalId: seed.conversationExternalId,
+    messageId: seed.messageId,
+    ...(seed.threadId ? { threadId: seed.threadId } : {}),
+    eventKind: "message" as const,
+  };
+  return JSON.stringify({ ...base, ...patch });
+}

package/src/monitoring/__tests__/file-descriptors.test.ts

@@ -7,6 +7,7 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  collectFdUsage,
   createFdPressureState,
   evaluateFdPressure,
   parseOpenFileLimits,
@@ -68,6 +69,37 @@ describe("parseOpenFileLimits", () => {
   });
 });
 
+describe("collectFdUsage", () => {
+  test("uses Win32 handle counts on Windows", () => {
+    expect(
+      collectFdUsage({
+        platform: "win32",
+        processTable: [
+          { pid: 10, ppid: 4, command: "low.exe", handleCount: 5 },
+          { pid: 11, ppid: 4, command: "high.exe", handleCount: 20 },
+        ],
+      }),
+    ).toEqual([
+      {
+        pid: 11,
+        command: "high.exe",
+        openCount: 20,
+        softLimit: null,
+        hardLimit: null,
+        ratio: null,
+      },
+      {
+        pid: 10,
+        command: "low.exe",
+        openCount: 5,
+        softLimit: null,
+        hardLimit: null,
+        ratio: null,
+      },
+    ]);
+  });
+});
+
 describe("evaluateFdPressure", () => {
   const options = { thresholdRatio: 0.8, warnCooldownMs: 60_000 };
 

package/src/monitoring/__tests__/process-memory.test.ts

@@ -1,6 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
-import { effectiveSizeBytes, parseSmapsRollup } from "../process-memory.js";
+import {
+  effectiveSizeBytes,
+  parseSmapsRollup,
+  topProcessesByMemory,
+} from "../process-memory.js";
 
 const SMAPS_ROLLUP = `555c98516000-7ffe248ca000 ---p 00000000 00:00 0                          [rollup]
 Rss:              524288 kB
@@ -65,3 +69,32 @@ describe("effectiveSizeBytes", () => {
     ).toBe(0);
   });
 });
+
+describe("topProcessesByMemory", () => {
+  test("uses Win32 working-set data on Windows", () => {
+    const result = topProcessesByMemory(1, {
+      platform: "win32",
+      processTable: [
+        { pid: 10, ppid: 4, command: "helper.exe", rssBytes: 1024 },
+        {
+          pid: 11,
+          ppid: 4,
+          command: '"C:\\Program Files\\Bun\\bun.exe" worker.ts',
+          rssBytes: 4096,
+        },
+      ],
+    });
+
+    expect(result).toEqual([
+      {
+        pid: 11,
+        command: "worker",
+        rssBytes: 4096,
+        pssBytes: null,
+        pssAnonBytes: null,
+        pssFileBytes: null,
+        pssShmemBytes: null,
+      },
+    ]);
+  });
+});

package/src/monitoring/db-integrity-sample.ts

@@ -66,6 +66,7 @@ async function runCheckSubprocess(
   );
   const child = Bun.spawn({
     cmd: [...command, dbPath],
+    windowsHide: true,
     stdio: ["ignore", "pipe", "ignore"],
   });
   activeChild = child;

package/src/monitoring/file-descriptors.ts

@@ -22,7 +22,12 @@ import { readdirSync, readFileSync } from "node:fs";
 
 import type { MonitoringConfig } from "../config/schemas/monitoring.js";
 import { getLogger } from "../util/logger.js";
-import { readProcessCommand } from "../util/process-tree.js";
+import {
+  getProcessTableRows,
+  type ProcessTableOptions,
+  type ProcessTableRow,
+} from "../util/process-table.js";
+import { deriveName, readProcessCommand } from "../util/process-tree.js";
 
 const log = getLogger("file-descriptors");
 
@@ -40,7 +45,7 @@ export interface ProcessFdUsage {
   pid: number;
   /** Redacted process descriptor (see {@link readProcessCommand}). */
   command: string;
-  /** Entries in `/proc/<pid>/fd`. */
+  /** Open descriptor count, or handle count on Windows. */
   openCount: number;
   softLimit: number | null;
   hardLimit: number | null;
@@ -108,9 +113,34 @@ function readProcessFdUsage(pid: number): ProcessFdUsage | null {
 /**
  * Descriptor usage for every readable process, closest to its soft limit first
  * (processes with an unknown limit sort last, by raw count). Empty when
- * `/proc` is unavailable, e.g. on macOS.
+ * `/proc` is unavailable. Windows reports process handle counts without a
+ * comparable soft limit.
  */
-export function collectFdUsage(): ProcessFdUsage[] {
+export function collectFdUsage(
+  options: ProcessTableOptions = {},
+): ProcessFdUsage[] {
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") {
+    try {
+      return getProcessTableRows(options)
+        .filter(
+          (row): row is ProcessTableRow & { handleCount: number } =>
+            row.handleCount != null,
+        )
+        .map((row) => ({
+          pid: row.pid,
+          command: deriveName(row.command),
+          openCount: row.handleCount,
+          softLimit: null,
+          hardLimit: null,
+          ratio: null,
+        }))
+        .sort((a, b) => b.openCount - a.openCount);
+    } catch {
+      return [];
+    }
+  }
+
   let entries: string[];
   try {
     entries = readdirSync("/proc").filter((entry) => /^\d+$/.test(entry));
@@ -133,8 +163,11 @@ export function collectFdUsage(): ProcessFdUsage[] {
 }
 
 /** The top `limit` processes by descriptor pressure, most pressured first. */
-export function topProcessesByFd(limit: number): ProcessFdUsage[] {
-  return collectFdUsage().slice(0, limit);
+export function topProcessesByFd(
+  limit: number,
+  options: ProcessTableOptions = {},
+): ProcessFdUsage[] {
+  return collectFdUsage(options).slice(0, limit);
 }
 
 /** What a pass concluded about the container's descriptor pressure. */

package/src/monitoring/process-memory.ts

@@ -11,7 +11,12 @@
 
 import { readdirSync, readFileSync } from "node:fs";
 
-import { readProcessCommand } from "../util/process-tree.js";
+import {
+  getProcessTableRows,
+  type ProcessTableOptions,
+  type ProcessTableRow,
+} from "../util/process-table.js";
+import { deriveName, readProcessCommand } from "../util/process-tree.js";
 
 /** Linux page size assumed when converting `/proc/<pid>/statm` pages to bytes. */
 const PAGE_SIZE_BYTES = 4096;
@@ -82,11 +87,38 @@ function readProcessMemory(pid: number): SmapsRollup | null {
 
 /**
  * Best-effort snapshot of the top `limit` processes by PSS (RSS when PSS is
- * unavailable), largest first. Empty when `/proc` is unavailable (e.g. macOS)
- * — the high-memory snapshot's process *tree* still captures what was running
- * in that case.
+ * unavailable), largest first. Windows uses Win32 working-set sizes. Other
+ * hosts without `/proc` return an empty list while the process tree still
+ * captures what was running.
  */
-export function topProcessesByMemory(limit: number): ProcessMemory[] {
+export function topProcessesByMemory(
+  limit: number,
+  options: ProcessTableOptions = {},
+): ProcessMemory[] {
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") {
+    try {
+      return getProcessTableRows(options)
+        .filter(
+          (row): row is ProcessTableRow & { rssBytes: number } =>
+            row.rssBytes != null,
+        )
+        .map((row) => ({
+          pid: row.pid,
+          command: deriveName(row.command),
+          rssBytes: row.rssBytes,
+          pssBytes: null,
+          pssAnonBytes: null,
+          pssFileBytes: null,
+          pssShmemBytes: null,
+        }))
+        .sort((a, b) => b.rssBytes - a.rssBytes)
+        .slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
+
   let pids: string[];
   try {
     pids = readdirSync("/proc").filter((e) => /^\d+$/.test(e));

package/src/monitoring/resource-sampler.ts

@@ -34,7 +34,15 @@ import { diffCounters } from "../util/counter-diff.js";
 import { getDiskUsageInfo } from "../util/disk-usage.js";
 import { getLogger } from "../util/logger.js";
 import { getMonitoringDataDir } from "../util/platform.js";
-import { buildProcessTree, listProcesses } from "../util/process-tree.js";
+import {
+  listProcessTableAsync,
+  type ProcessTableRow,
+} from "../util/process-table.js";
+import {
+  buildProcessTree,
+  buildSystemProcessTree,
+  listProcesses,
+} from "../util/process-tree.js";
 import { readActiveConversations } from "./active-conversations.js";
 import { topProcessesByFd } from "./file-descriptors.js";
 import { getTrackedDataFiles, readFileResidency } from "./page-cache.js";
@@ -149,10 +157,16 @@ export async function writeSnapshot(
   mkdirSync(snapshotsDir, { recursive: true });
 
   let tree: unknown = null;
+  let processTable: ProcessTableRow[] | null = null;
   try {
-    const procs = await listProcesses();
-    // pid 1 is the container init; its subtree is the whole container.
-    tree = buildProcessTree(procs, 1);
+    processTable = await listProcessTableAsync();
+    const procs = await listProcesses(processTable);
+    // pid 1 is the container init; its subtree is the whole container. Windows
+    // has no such root, so every process hangs off a synthetic one.
+    tree =
+      process.platform === "win32"
+        ? buildSystemProcessTree(procs)
+        : buildProcessTree(procs, 1);
   } catch (err) {
     log.warn({ err }, "Failed to enumerate process tree for snapshot");
   }
@@ -166,21 +180,24 @@ export async function writeSnapshot(
     log.warn({ err }, "Failed to read page-cache residency for snapshot");
   }
 
+  const processOptions = { platform: process.platform, processTable };
   const snapshot = {
     ts: sample.ts,
     kind,
     sample,
     fileResidency,
     // PSS-ranked with per-process anon/file split; PSS sums reconcile against
-    // the cgroup total where an RSS sum double-counts shared pages.
-    topProcesses: topProcessesByMemory(15),
+    // the cgroup total where an RSS sum double-counts shared pages. Windows
+    // reports working-set size instead.
+    topProcesses: topProcessesByMemory(15, processOptions),
     // Slab memory belongs to no process; without this, cgroup usage that
     // exceeds the per-process sum has no visible owner.
     topSlabCaches: topSlabCaches(10),
     // Descriptor pressure, ranked against each process's own soft limit. An
     // EMFILE storm and a memory spike look alike from the outside (unrelated
-    // failures across the daemon), so the capture records both.
-    topProcessesByFd: topProcessesByFd(15),
+    // failures across the daemon), so the capture records both. Windows
+    // records raw handle counts since it has no comparable soft limit.
+    topProcessesByFd: topProcessesByFd(15, processOptions),
     processTree: tree,
   };