@vellumai/assistant 0.7.2 → 0.7.3

package/ARCHITECTURE.md

@@ -21,6 +21,20 @@ This document owns assistant-runtime architecture details. The repo-level archit
 - Voice calls mirror the same prompt contract: `CallController` receives guardian context on setup and refreshes it immediately after successful voice challenge verification, so the first post-verification turn is grounded as `actor_role: guardian`.
 - Voice-specific behavior (DTMF/speech verification flow, relay state machine) remains voice-local; only actor-role resolution is shared.
 
+### Safe Storage Limits
+
+Safe storage limits are gated by the assistant feature flag `safe-storage-limits`, default off. When the flag is off, the disk pressure guard reports a disabled status and no runtime path blocks work, injects cleanup guidance, or changes tool access.
+
+**Disk pressure state:** `src/daemon/disk-pressure-guard.ts` samples workspace storage usage every 60 seconds through `src/util/disk-usage.ts`. At or above the 95% critical threshold it creates an in-memory lock with `lockId`, usage snapshot, `acknowledged`, `overrideActive`, `effectivelyLocked`, and the blocked capabilities `agent-turns`, `background-work`, and `remote-ingress`. The lock clears when usage drops below the threshold or the process restarts. `acknowledgeDiskPressureLock()` only lets the guardian enter cleanup mode; `overrideDiskPressureLock()` requires the exact phrase `I understand the risks` and disables the effective lock while usage remains critical.
+
+**Runtime API and events:** `src/runtime/routes/disk-pressure-routes.ts` exposes `GET /v1/disk-pressure/status`, `POST /v1/disk-pressure/acknowledge`, and `POST /v1/disk-pressure/override`. Route auth policies require normal runtime protection, and `disk_pressure_status_changed` events are emitted when the status changes so clients can update live.
+
+**Turn policy:** `src/daemon/disk-pressure-policy.ts` classifies turns before the main agent loop. Local guardian/owner turns are allowed in cleanup mode; trusted contacts, non-guardian actors, unknown remote senders, background conversations, direct wakes, and non-main LLM call sites are blocked while `effectivelyLocked` is true. Blocked turns emit terminal conversation errors rather than reaching the provider.
+
+**Background work:** Heartbeats, scheduled tasks, filing work, retry sweeps, and background tool completions call `src/daemon/disk-pressure-background-gate.ts` before starting work. While effectively locked they skip the wake or job and log throttled disk-pressure fields.
+
+**Prompt and tools:** Cleanup-mode turns carry `diskPressureContext` through runtime assembly and receive the `<disk_pressure_warning>` injector in `src/plugins/defaults/injectors.ts`. The instruction tells the assistant to warn first, focus only on freeing storage, inspect before deleting, ask for deletion approval, and explain that background processes and trusted-contact messages are blocked. Tool setup marks the turn as cleanup mode; `src/tools/tool-approval-handler.ts` rejects non-cleanup-safe tools, and foreground shell inspection remains available while background `bash` and `host_bash` modes are rejected. When a new lock is created, active background terminal tools are cancelled with reason `disk_pressure`.
+
 ### Single-Header JWT Auth Model
 
 All HTTP API requests use a single `Authorization: Bearer <jwt>` header for authentication. The JWT carries identity, permissions, and policy versioning in a unified token.
@@ -966,6 +980,7 @@ The daemon emits two distinct error message types via SSE:
 | -------------------------------- | ----------------------------------------------------------------------- | --------- |
 | `PROVIDER_NETWORK`               | Unable to reach the LLM provider (connection refused, timeout, DNS)     | Yes       |
 | `PROVIDER_RATE_LIMIT`            | LLM provider rate-limited the request (HTTP 429)                        | Yes       |
+| `MANAGED_USAGE_LIMIT`            | Vellum managed inference usage limit or quota was exceeded (HTTP 429)   | Yes       |
 | `PROVIDER_API`                   | Provider returned a server error (5xx) or retryable 4xx                 | Yes       |
 | `PROVIDER_BILLING`               | Invalid/expired API key or insufficient credits (HTTP 401, billing 4xx) | No        |
 | `CONTEXT_TOO_LARGE`              | Request exceeds the model's context window (HTTP 413, token limit)      | No        |
@@ -980,7 +995,7 @@ The daemon classifies errors via `classifyConversationError()` in `conversation-
 
 Classification uses a two-tier strategy:
 
-1. **Structured provider errors**: If the error is a `ProviderError` with a `statusCode`, the status code determines the category deterministically — `413` maps to `CONTEXT_TOO_LARGE` (not retryable), `401` maps to `PROVIDER_BILLING` (not retryable, invalid/expired key), `429` maps to `PROVIDER_RATE_LIMIT` (retryable), `5xx` to `PROVIDER_API` (retryable), other `4xx` to `PROVIDER_API` (retryable) unless a message pattern matches a more specific non-retryable category (context-too-large, billing/auth).
+1. **Structured provider errors**: If the error is a `ProviderError` with a `statusCode`, the status code determines the category deterministically — `413` maps to `CONTEXT_TOO_LARGE` (not retryable), `401` maps to `PROVIDER_BILLING` (not retryable, invalid/expired key), `429` maps to `MANAGED_USAGE_LIMIT` when the provider is routed through the managed proxy or the payload matches a Vellum managed quota/limit response, otherwise `PROVIDER_RATE_LIMIT` (retryable), `5xx` to `PROVIDER_API` (retryable), other `4xx` to `PROVIDER_API` (retryable) unless a message pattern matches a more specific non-retryable category (context-too-large, billing/auth).
 2. **Regex fallback**: For non-provider errors or `ProviderError` without a status code, regex pattern matching against the error message detects network failures, rate limits, and API errors. Phase-specific overrides handle regeneration contexts.
 
 Debug details are capped at 4,000 characters to prevent oversized payloads.

package/docs/architecture/memory.md

@@ -472,7 +472,7 @@ The Anthropic provider places `cache_control: { type: 'ephemeral' }` on the **la
 
 The session injects a unified `<turn_context>` block into every user message, giving the model awareness of the current timestamp (with timezone), interface, channel, and actor identity. This replaces the former separate `<temporal_context>`, `<inbound_actor_context>`, and per-channel turn context blocks. The unified block persists in conversation history so the assistant retains temporal and actor grounding across turns. Legacy blocks from pre-change history are stripped for backward compatibility.
 
-The `current_time:` field format is: `2026-04-02 (Wednesday) 14:30:00 -05:00 (America/Chicago)` — date, weekday name, local time, UTC offset, and IANA timezone name.
+The `current_time:` field format is: `2026-04-02 (Wednesday) 14:30:00 -05:00 (America/Chicago)` — date, weekday name, local time, UTC offset, and IANA timezone name. The timestamp is grounded in the user's effective timezone, not UTC, so a message sent at 10pm local time is represented as 10pm for date/time reasoning.
 
 ### Per-turn flow
 
@@ -492,7 +492,10 @@ graph TB
 
 - **Fresh each turn**: `buildUnifiedTurnContextBlock()` is called at the start of every agent loop invocation, ensuring the model always sees the current timestamp even in long-running conversations.
 - **Clock source invariant**: Absolute time (`now`) always comes from the assistant host clock (`Date.now()`), never from channel/client clocks.
-- **Timezone precedence**: If `ui.userTimezone` is configured, turn context uses it for local-date interpretation. Otherwise it falls back to memory-stored timezone, then assistant host timezone.
+- **Timezone precedence**: Turn context resolves the effective timezone in this order: explicit runtime override for tests/legacy callers, manual `ui.userTimezone`, current turn `clientTimezone`, persisted `ui.detectedTimezone`, then assistant host timezone. The host clock still supplies the absolute instant; this cascade only selects the local timezone used to render `current_time`.
+- **Manual override semantics**: `ui.userTimezone` is a historical config path, but it is runtime-affecting, not purely presentational. When set, it is authoritative for `current_time` across all clients until the user clears or changes it.
+- **Device timezone semantics**: `clientTimezone` is the timezone reported with the active message for this turn. `ui.detectedTimezone` is the last device-detected timezone persisted by a client and is only used when there is no manual override and the current message does not carry a client timezone.
+- **Timezone mismatch guidance**: When `ui.userTimezone` differs from the current device timezone (`clientTimezone`, or `ui.detectedTimezone` when no current client value exists), `<turn_context>` also includes `configured_user_timezone`, `client_device_timezone`, and `timezone_update_available`. The last line tells the assistant that, after explicit user confirmation, it can persist the device timezone with `assistant config set ui.userTimezone "<IANA zone>"`. This gives the assistant a natural-language path to fix stale manual overrides without adding a dedicated tool.
 - **Timezone-aware**: Uses `Intl.DateTimeFormat` APIs for DST-safe date arithmetic and timezone validation/canonicalization.
 - **Persists in history**: The `<turn_context>` block persists in conversation history. Legacy `<temporal_context>`, `<inbound_actor_context>`, and separate channel context blocks from pre-change history are stripped for backward compatibility.
 - **Retry paths**: Turn context is included in all `applyRuntimeInjections` call sites (main path, compact retry, media-trim retry).

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

@@ -62,13 +62,22 @@ const CONNECT_TIMEOUT_MS = 3_000;
  * Designed for CLI and daemon startup where we need a single RPC call
  * without leaving open handles. Returns `undefined` on any failure
  * (socket not found, timeout, parse error) so callers can fall back.
+ *
+ * @param timeoutMs - Optional override for both the connect and call
+ *   timeouts. When omitted, defaults to the module constants
+ *   (CONNECT_TIMEOUT_MS / DEFAULT_CALL_TIMEOUT_MS). Pass a small value
+ *   (e.g. 200) for opportunistic CLI checks where a slow/absent gateway
+ *   should fail fast rather than block startup.
  */
 export async function ipcCall(
   socketPath: string,
   method: string,
   params?: Record<string, unknown>,
   log: Logger = noopLogger,
+  timeoutMs?: number,
 ): Promise<unknown> {
+  const connectTimeoutMs = timeoutMs ?? CONNECT_TIMEOUT_MS;
+  const callTimeoutMs = timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
   return new Promise<unknown>((resolve) => {
     let settled = false;
     let callTimer: ReturnType<typeof setTimeout> | undefined;
@@ -84,11 +93,11 @@ export async function ipcCall(
 
     const connectTimer = setTimeout(() => {
       log.warn(
-        { method, socketPath, timeoutMs: CONNECT_TIMEOUT_MS },
+        { method, socketPath, timeoutMs: connectTimeoutMs },
         "IPC connect timed out",
       );
       finish(undefined);
-    }, CONNECT_TIMEOUT_MS);
+    }, connectTimeoutMs);
 
     const socket: Socket = connect(socketPath);
     socket.unref();
@@ -103,11 +112,11 @@ export async function ipcCall(
 
       callTimer = setTimeout(() => {
         log.warn(
-          { method, socketPath, timeoutMs: DEFAULT_CALL_TIMEOUT_MS },
+          { method, socketPath, timeoutMs: callTimeoutMs },
           "IPC call timed out waiting for response",
         );
         finish(undefined);
-      }, DEFAULT_CALL_TIMEOUT_MS);
+      }, callTimeoutMs);
 
       socket.on("data", (chunk) => {
         buffer += chunk.toString();

package/node_modules/@vellumai/skill-host-contracts/src/assistant-event.ts

@@ -84,12 +84,3 @@ export function formatSseFrame(event: AssistantEvent): string {
 export function formatSseHeartbeat(): string {
   return ": heartbeat\n\n";
 }
-
-/**
- * Format a keep-alive as both an SSE comment (for proxy keepalive) and a
- * data-bearing event (so fetch-based SSE clients that cannot observe comment
- * lines can still detect heartbeats for disconnect watchdogs).
- */
-export function formatSseHeartbeatWithData(): string {
-  return `${formatSseHeartbeat()}event: assistant_event\ndata: ${JSON.stringify({ type: "heartbeat" })}\n\n`;
-}

package/node_modules/@vellumai/slack-text/src/index.test.ts

@@ -4,8 +4,6 @@ import {
   buildSlackUserLabelMap,
   extractSlackUserMentionIds,
   renderSlackTextForModel,
-  stripLeadingSlackMentionFallback,
-  stripLeadingSlackUserMention,
 } from "./index.js";
 
 describe("extractSlackUserMentionIds", () => {
@@ -16,34 +14,6 @@ describe("extractSlackUserMentionIds", () => {
   });
 });
 
-describe("stripLeadingSlackUserMention", () => {
-  test("strips only leading mentions for the exact bot ID", () => {
-    expect(stripLeadingSlackUserMention("<@U111> <@U222> hi", "U111")).toBe(
-      "<@U222> hi"
-    );
-  });
-
-  test("strips repeated leading mentions for the exact bot ID", () => {
-    expect(stripLeadingSlackUserMention(" <@U111> <@U111> hi", "U111")).toBe(
-      "hi"
-    );
-  });
-
-  test("preserves text when the leading mention is a different user", () => {
-    expect(stripLeadingSlackUserMention("<@U222> hi <@U111>", "U111")).toBe(
-      "<@U222> hi <@U111>"
-    );
-  });
-});
-
-describe("stripLeadingSlackMentionFallback", () => {
-  test("strips only the first leading Slack user mention", () => {
-    expect(stripLeadingSlackMentionFallback(" <@U111> <@U222> hi")).toBe(
-      "<@U222> hi"
-    );
-  });
-});
-
 describe("renderSlackTextForModel", () => {
   test("renders resolved user mentions", () => {
     expect(
@@ -123,19 +93,32 @@ describe("renderSlackTextForModel", () => {
 });
 
 describe("buildSlackUserLabelMap", () => {
-  test("dedupes mentioned users across text inputs and ignores configured IDs", async () => {
+  test("dedupes mentioned users across text inputs and resolves them in parallel", async () => {
     const resolved: string[] = [];
     const labels = await buildSlackUserLabelMap(
       ["<@U123> hi <@U999>", undefined, "<@U123> and <@W456>"],
       async (userId) => {
         resolved.push(userId);
+        if (userId === "U999") return "Charlie";
         return userId === "W456" ? "Bob" : "Alice";
-      },
-      { ignoredUserIds: ["U999"] }
+      }
+    );
+
+    expect(resolved.sort()).toEqual(["U123", "U999", "W456"]);
+    expect(labels).toEqual({ U123: "Alice", U999: "Charlie", W456: "Bob" });
+  });
+
+  test("resolves bot and human user mentions together", async () => {
+    const labels = await buildSlackUserLabelMap(
+      ["<@UBOT> can you help <@ULEO> with the deploy?"],
+      async (userId) => {
+        if (userId === "UBOT") return "vex";
+        if (userId === "ULEO") return "leo";
+        return undefined;
+      }
     );
 
-    expect(resolved).toEqual(["U123", "W456"]);
-    expect(labels).toEqual({ U123: "Alice", W456: "Bob" });
+    expect(labels).toEqual({ UBOT: "vex", ULEO: "leo" });
   });
 
   test("omits unresolved labels and labels equal to the Slack user ID", async () => {

package/node_modules/@vellumai/slack-text/src/index.ts

@@ -5,12 +5,7 @@ export interface RenderSlackTextOptions {
   channelFallbackLabel?: string;
 }
 
-export interface BuildSlackUserLabelMapOptions {
-  ignoredUserIds?: Iterable<string | undefined>;
-}
-
 const SLACK_USER_MENTION_RE = /<@([UW][A-Z0-9]+)>/g;
-const LEADING_SLACK_USER_MENTION_RE = /^\s*<@[UW][A-Z0-9]+>\s*/;
 
 export function extractSlackUserMentionIds(text: string): string[] {
   const seen = new Set<string>();
@@ -27,30 +22,6 @@ export function extractSlackUserMentionIds(text: string): string[] {
   return ids;
 }
 
-export function stripLeadingSlackUserMention(
-  text: string,
-  userId: string
-): string {
-  if (!isSlackUserId(userId)) {
-    return text;
-  }
-
-  const mention = `<@${userId}>`;
-  let stripped = text;
-
-  while (true) {
-    const next = stripLeadingExactToken(stripped, mention);
-    if (next === stripped) {
-      return stripped;
-    }
-    stripped = next;
-  }
-}
-
-export function stripLeadingSlackMentionFallback(text: string): string {
-  return text.replace(LEADING_SLACK_USER_MENTION_RE, "");
-}
-
 export function renderSlackTextForModel(
   text: string,
   options: RenderSlackTextOptions = {}
@@ -78,21 +49,15 @@ export function renderSlackTextForModel(
 
 export async function buildSlackUserLabelMap(
   texts: Iterable<string | undefined>,
-  resolveLabel: (userId: string) => Promise<string | undefined | null>,
-  options: BuildSlackUserLabelMapOptions = {}
+  resolveLabel: (userId: string) => Promise<string | undefined | null>
 ): Promise<Record<string, string>> {
-  const ignored = new Set(
-    [...(options.ignoredUserIds ?? [])].filter(
-      (id): id is string => typeof id === "string" && id.length > 0
-    )
-  );
   const ids: string[] = [];
   const seen = new Set<string>();
 
   for (const text of texts) {
     if (!text) continue;
     for (const id of extractSlackUserMentionIds(text)) {
-      if (ignored.has(id) || seen.has(id)) continue;
+      if (seen.has(id)) continue;
       seen.add(id);
       ids.push(id);
     }
@@ -215,17 +180,6 @@ function sanitizeOptionalLabel(label: string | undefined): string | undefined {
     .trim();
 }
 
-function stripLeadingExactToken(text: string, token: string): string {
-  const leadingWhitespaceLength = text.length - text.trimStart().length;
-  const afterWhitespace = text.slice(leadingWhitespaceLength);
-
-  if (!afterWhitespace.startsWith(token)) {
-    return text;
-  }
-
-  return afterWhitespace.slice(token.length).trimStart();
-}
-
 function isSlackUserId(value: string): boolean {
   return /^[UW][A-Z0-9]+$/.test(value);
 }