@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/tools/schedule/update.ts

@@ -1,7 +1,10 @@
 import { z } from "zod";
 
 import { resolveCapabilities } from "../../runtime/capabilities.js";
-import { validateScheduleInferenceProfile } from "../../schedule/inference-profile.js";
+import {
+  formatScheduleInferenceProfile,
+  validateScheduleInferenceProfile,
+} from "../../schedule/inference-profile.js";
 import { validateRruleSetLines } from "../../schedule/recurrence-engine.js";
 import {
   detectScheduleSyntax,
@@ -17,6 +20,7 @@ import {
   describeCronExpression,
   formatLocalDate,
   getSchedule,
+  setUserEnabled,
   updateSchedule,
 } from "../../schedule/schedule-store.js";
 import { resolveGroupReference } from "../conversation-groups/group_shared.js";
@@ -45,8 +49,9 @@ const VALID_ROUTING_INTENTS: RoutingIntent[] = [
  *   preprocessing that would silently turn an explicit update into a no-op.
  * - `timezone` and `script` are nullable at runtime though advertised as
  *   plain strings: `updateSchedule` persists null as "clear this field".
- * - `timeout_ms` / `inference_profile` / `group` advertise null (it reverts
- *   to the default); the executor's bespoke handling stays.
+ * - `timeout_ms` / `group` advertise null (it reverts to the default), and
+ *   `inference_profile` advertises null (it re-pins to the current default);
+ *   the executor's bespoke handling stays.
  * - `mode`, `routing_intent`, `workflow_name`, and `workflow_args` are
  *   deliberately UNDECLARED (loose passthrough): the first two keep bespoke
  *   `VALID_*` errors; `workflow_name` has bespoke coercion semantics in the
@@ -94,10 +99,11 @@ export async function executeScheduleUpdate(
     return { content: "Error: job_id is required", isError: true };
   }
 
+  const existing = getSchedule(jobId);
+
   // Prevent changing a one-shot to recurring or vice versa. (`fire_at` is
   // not an advertised update field, so it stays a raw-input read.)
   if (parsed.expression !== undefined || input.fire_at !== undefined) {
-    const existing = getSchedule(jobId);
     if (!existing) {
       return { content: `Error: Schedule not found: ${jobId}`, isError: true };
     }
@@ -203,8 +209,8 @@ export async function executeScheduleUpdate(
     updates.retryBackoffMs = parsed.retry_backoff_ms;
   }
 
-  // Inference profile override (null clears it, reverting to the default
-  // main-agent model selection)
+  // Inference profile (null re-pins the schedule to the currently resolved
+  // default rather than leaving it to follow whatever the default becomes)
   if (parsed.inference_profile !== undefined) {
     if (parsed.inference_profile === null) {
       updates.inferenceProfile = null;
@@ -278,6 +284,22 @@ export async function executeScheduleUpdate(
     };
   }
 
+  // A plugin-sourced schedule accepts only the enabled toggle, recorded as
+  // the user_enabled override exactly like the HTTP toggle route. Every other
+  // field is owned by the plugin's schedule file, and the reconciler would
+  // overwrite a direct edit on its next pass.
+  const isPluginSourced = existing?.sourceKey != null;
+  if (
+    isPluginSourced &&
+    Object.keys(updates).some((field) => field !== "enabled")
+  ) {
+    return {
+      content:
+        "Error: This schedule is managed by a plugin, so only enabled can be changed here. To change anything else, edit the plugin's schedule file.",
+      isError: true,
+    };
+  }
+
   // Mirror the HTTP route: a schedule whose RESULTING mode is `workflow` must
   // carry a non-empty workflowName. Compute the post-update
   // state (the update's value if present, else the persisted one) so both
@@ -285,7 +307,6 @@ export async function executeScheduleUpdate(
   // schedule" are rejected — otherwise the scheduler hits the `!job.workflowName`
   // skip branch and a one-shot firing job wedges.
   if (updates.mode !== undefined || updates.workflowName !== undefined) {
-    const existing = getSchedule(jobId);
     if (existing) {
       const resultingMode =
         updates.mode !== undefined ? (updates.mode as string) : existing.mode;
@@ -325,31 +346,33 @@ export async function executeScheduleUpdate(
   }
 
   try {
-    const job = await updateSchedule(
-      jobId,
-      updates as {
-        name?: string;
-        description?: string;
-        cronExpression?: string;
-        timezone?: string | null;
-        message?: string;
-        script?: string | null;
-        enabled?: boolean;
-        syntax?: ScheduleSyntax;
-        expression?: string;
-        mode?: ScheduleMode;
-        routingIntent?: RoutingIntent;
-        routingHints?: Record<string, unknown>;
-        quiet?: boolean;
-        reuseConversation?: boolean;
-        maxRetries?: number;
-        retryBackoffMs?: number;
-        timeoutMs?: number | null;
-        workflowName?: string | null;
-        workflowArgs?: unknown;
-        inferenceProfile?: string | null;
-      },
-    );
+    const job = isPluginSourced
+      ? await setUserEnabled(jobId, updates.enabled as boolean)
+      : await updateSchedule(
+          jobId,
+          updates as {
+            name?: string;
+            description?: string;
+            cronExpression?: string;
+            timezone?: string | null;
+            message?: string;
+            script?: string | null;
+            enabled?: boolean;
+            syntax?: ScheduleSyntax;
+            expression?: string;
+            mode?: ScheduleMode;
+            routingIntent?: RoutingIntent;
+            routingHints?: Record<string, unknown>;
+            quiet?: boolean;
+            reuseConversation?: boolean;
+            maxRetries?: number;
+            retryBackoffMs?: number;
+            timeoutMs?: number | null;
+            workflowName?: string | null;
+            workflowArgs?: unknown;
+            inferenceProfile?: string | null;
+          },
+        );
 
     if (!job) {
       return { content: `Error: Schedule not found: ${jobId}`, isError: true };
@@ -369,7 +392,7 @@ export async function executeScheduleUpdate(
         `  Description: ${job.description}`,
         `  Syntax: ${job.syntax}`,
         `  Mode: ${job.mode}`,
-        `  Inference profile: ${job.inferenceProfile ?? "default (mainAgent)"}`,
+        `  Inference profile: ${formatScheduleInferenceProfile(job.inferenceProfile)}`,
         `  Schedule: ${scheduleDescription}${job.timezone ? ` (${job.timezone})` : ""}`,
         `  Enabled: ${job.enabled}`,
         `  Next run: ${job.enabled ? formatLocalDate(job.nextRunAt) : "n/a (disabled)"}`,

package/src/tools/shared/filesystem/audio-read.ts

@@ -1,4 +1,4 @@
-import { readFileSync, statSync } from "node:fs";
+import { readFile, stat as fsStat } from "node:fs/promises";
 import { basename, extname } from "node:path";
 
 import { GEMINI_MAX_INLINE_AUDIO_BYTES } from "../../../providers/gemini/inline-media.js";
@@ -67,7 +67,9 @@ function buildAudioToolResult(
  * The caller is responsible for path resolution and sandbox enforcement —
  * `resolvedPath` must be an already-validated absolute path.
  */
-export function readAudioFile(resolvedPath: string): ToolExecutionResult {
+export async function readAudioFile(
+  resolvedPath: string,
+): Promise<ToolExecutionResult> {
   const mimeType = EXTENSION_MIME[extname(resolvedPath).toLowerCase()];
   if (!mimeType) {
     // Defensive: callers gate on AUDIO_EXTENSIONS, so this is unreachable.
@@ -79,7 +81,7 @@ export function readAudioFile(resolvedPath: string): ToolExecutionResult {
 
   let stat;
   try {
-    stat = statSync(resolvedPath);
+    stat = await fsStat(resolvedPath);
   } catch {
     return { content: `Error: file not found: ${resolvedPath}`, isError: true };
   }
@@ -96,7 +98,7 @@ export function readAudioFile(resolvedPath: string): ToolExecutionResult {
 
   let buffer: Buffer;
   try {
-    buffer = readFileSync(resolvedPath) as Buffer;
+    buffer = (await readFile(resolvedPath)) as Buffer;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { content: `Error reading file: ${msg}`, isError: true };

package/src/tools/shared/filesystem/file-ops-service.ts

@@ -1,10 +1,4 @@
-import {
-  lstatSync,
-  readdirSync,
-  readFileSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
+import { lstat, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 
 import { minimatch } from "minimatch";
@@ -42,6 +36,32 @@ export type PathPolicy = (
 // Service
 // ---------------------------------------------------------------------------
 
+// Serialize mutations per resolved path. The agent loop executes sibling
+// tool calls in parallel, and the async read -> apply -> write window would
+// otherwise let two edits of the same file both read the same old content and
+// have the later write silently drop the earlier edit (the previous
+// synchronous service made each mutation atomic within the event loop).
+const fileWriteLocks = new Map<string, Promise<void>>();
+
+async function withFileWriteLock<T>(
+  filePath: string,
+  fn: () => Promise<T>,
+): Promise<T> {
+  const prev = fileWriteLocks.get(filePath) ?? Promise.resolve();
+  const run = prev.then(fn, fn);
+  const tail = run.then(
+    () => undefined,
+    () => undefined,
+  );
+  fileWriteLocks.set(filePath, tail);
+  void tail.then(() => {
+    if (fileWriteLocks.get(filePath) === tail) {
+      fileWriteLocks.delete(filePath);
+    }
+  });
+  return run;
+}
+
 function pathError(
   path: string,
   reason: PathFailureReason,
@@ -57,6 +77,29 @@ function pathError(
   }
 }
 
+/**
+ * Lines returned by a read that names no `limit`. Without a default the read
+ * returns the whole file, and a file-read result is honored in full for the
+ * rest of the turn (see `isSpoolEligible` in `context/tool-result-spool.ts`),
+ * so one unbounded read of a large file rides every subsequent LLM call in
+ * that turn. The cap bounds that; `offset`/`limit` page past it, and
+ * {@link truncationNotice} tells the model when it is looking at a window
+ * rather than the whole file.
+ */
+export const DEFAULT_READ_LINE_LIMIT = 2000;
+
+/**
+ * Trailing marker appended when a read stops short of the last line. Silent
+ * truncation is the failure mode worth avoiding: a model that cannot tell a
+ * window from a whole file reasons about code it never saw.
+ */
+function truncationNotice(
+  lastLineReturned: number,
+  totalLines: number,
+): string {
+  return `\n\n[Truncated: showing through line ${lastLineReturned} of ${totalLines}. Read on with offset=${lastLineReturned + 1}, or pass an explicit limit.]`;
+}
+
 export class FileSystemOps {
   private policy: PathPolicy;
   private sizeLimit: number | undefined;
@@ -70,7 +113,7 @@ export class FileSystemOps {
   // Read
   // -------------------------------------------------------------------------
 
-  readFileSafe(input: ReadInput): ReadResult {
+  async readFileSafe(input: ReadInput): Promise<ReadResult> {
     const pathCheck = this.policy(input.path, { mustExist: true });
     if (!pathCheck.ok) {
       return {
@@ -84,23 +127,24 @@ export class FileSystemOps {
       return { ok: false, error: Err.notFound(filePath) };
     }
 
-    const stat = statSync(filePath);
-    if (!stat.isFile()) {
+    const pathStat = await stat(filePath);
+    if (!pathStat.isFile()) {
       return { ok: false, error: Err.notAFile(filePath) };
     }
 
-    const sizeErr = checkFileSizeOnDisk(filePath, this.sizeLimit);
+    const sizeErr = await checkFileSizeOnDisk(filePath, this.sizeLimit);
     if (sizeErr) {
       return { ok: false, error: Err.sizeLimitExceeded(filePath, sizeErr) };
     }
 
     try {
-      const raw = readFileSync(filePath, "utf-8");
+      const raw = await readFile(filePath, "utf-8");
       const lines = raw.split("\n");
 
       const offset = (input.offset ?? 1) - 1;
-      const limit = input.limit ?? lines.length;
-      const selected = lines.slice(Math.max(0, offset), offset + limit);
+      const start = Math.max(0, offset);
+      const limit = input.limit ?? DEFAULT_READ_LINE_LIMIT;
+      const selected = lines.slice(start, offset + limit);
 
       const numbered = selected
         .map((line, i) => {
@@ -109,7 +153,16 @@ export class FileSystemOps {
         })
         .join("\n");
 
-      return { ok: true, value: { content: numbered } };
+      // Only when the window stops before the last line. An empty window means
+      // the caller paged past the end or asked for nothing, which is not a
+      // truncated read.
+      const lastLineReturned = start + selected.length;
+      const content =
+        selected.length > 0 && lastLineReturned < lines.length
+          ? numbered + truncationNotice(lastLineReturned, lines.length)
+          : numbered;
+
+      return { ok: true, value: { content } };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       return { ok: false, error: Err.ioError(filePath, msg) };
@@ -120,7 +173,7 @@ export class FileSystemOps {
   // Write
   // -------------------------------------------------------------------------
 
-  writeFileSafe(input: WriteInput): WriteResult {
+  async writeFileSafe(input: WriteInput): Promise<WriteResult> {
     const pathCheck = this.policy(input.path, { mustExist: false });
     if (!pathCheck.ok) {
       return {
@@ -135,41 +188,43 @@ export class FileSystemOps {
       return { ok: false, error: Err.sizeLimitExceeded(filePath, sizeErr) };
     }
 
-    try {
-      ensureDir(dirname(filePath));
-
-      let oldContent = "";
-      const isNewFile = !pathExists(filePath);
-      if (!isNewFile) {
-        try {
-          oldContent = readFileSync(filePath, "utf-8");
-        } catch {
-          // Unreadable existing file - keep oldContent as empty string.
+    return withFileWriteLock(filePath, async (): Promise<WriteResult> => {
+      try {
+        ensureDir(dirname(filePath));
+
+        let oldContent = "";
+        const isNewFile = !pathExists(filePath);
+        if (!isNewFile) {
+          try {
+            oldContent = await readFile(filePath, "utf-8");
+          } catch {
+            // Unreadable existing file - keep oldContent as empty string.
+          }
         }
-      }
-
-      writeFileSync(filePath, input.content);
 
-      return {
-        ok: true,
-        value: {
-          filePath,
-          isNewFile,
-          oldContent,
-          newContent: input.content,
-        },
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: Err.ioError(filePath, msg) };
-    }
+        await writeFile(filePath, input.content);
+
+        return {
+          ok: true,
+          value: {
+            filePath,
+            isNewFile,
+            oldContent,
+            newContent: input.content,
+          },
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: Err.ioError(filePath, msg) };
+      }
+    });
   }
 
   // -------------------------------------------------------------------------
   // Edit
   // -------------------------------------------------------------------------
 
-  editFileSafe(input: EditInput): EditResult {
+  async editFileSafe(input: EditInput): Promise<EditResult> {
     const pathCheck = this.policy(input.path, { mustExist: true });
     if (!pathCheck.ok) {
       return {
@@ -179,82 +234,85 @@ export class FileSystemOps {
     }
     const filePath = pathCheck.resolved;
 
-    // Size-check the file on disk (swallow ENOENT - readFileSync gives a clearer error)
-    try {
-      const sizeErr = checkFileSizeOnDisk(filePath, this.sizeLimit);
-      if (sizeErr) {
-        return { ok: false, error: Err.sizeLimitExceeded(filePath, sizeErr) };
+    return withFileWriteLock(filePath, async (): Promise<EditResult> => {
+      // Size-check the file on disk (swallow ENOENT - the read below gives a
+      // clearer error)
+      try {
+        const sizeErr = await checkFileSizeOnDisk(filePath, this.sizeLimit);
+        if (sizeErr) {
+          return { ok: false, error: Err.sizeLimitExceeded(filePath, sizeErr) };
+        }
+      } catch {
+        // Fall through - the read below will surface NOT_FOUND.
       }
-    } catch {
-      // Fall through - the readFileSync below will surface NOT_FOUND.
-    }
 
-    let content: string;
-    try {
-      content = readFileSync(filePath, "utf-8");
-    } catch (err) {
-      const code =
-        err instanceof Error && "code" in err
-          ? (err as NodeJS.ErrnoException).code
-          : undefined;
-      if (code === "EISDIR") {
-        return { ok: false, error: Err.notAFile(filePath) };
+      let content: string;
+      try {
+        content = await readFile(filePath, "utf-8");
+      } catch (err) {
+        const code =
+          err instanceof Error && "code" in err
+            ? (err as NodeJS.ErrnoException).code
+            : undefined;
+        if (code === "EISDIR") {
+          return { ok: false, error: Err.notAFile(filePath) };
+        }
+        if (code === "ENOENT") {
+          return { ok: false, error: Err.notFound(filePath) };
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: Err.ioError(filePath, msg) };
       }
-      if (code === "ENOENT") {
-        return { ok: false, error: Err.notFound(filePath) };
+
+      if (input.oldString.length === 0) {
+        return { ok: false, error: Err.matchNotFound(filePath) };
       }
-      const msg = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: Err.ioError(filePath, msg) };
-    }
 
-    if (input.oldString.length === 0) {
-      return { ok: false, error: Err.matchNotFound(filePath) };
-    }
+      const result = applyEdit(
+        content,
+        input.oldString,
+        input.newString,
+        input.replaceAll,
+      );
 
-    const result = applyEdit(
-      content,
-      input.oldString,
-      input.newString,
-      input.replaceAll,
-    );
+      if (!result.ok) {
+        if (result.reason === "not_found") {
+          return { ok: false, error: Err.matchNotFound(filePath) };
+        }
+        return {
+          ok: false,
+          error: Err.matchAmbiguous(filePath, result.matchCount),
+        };
+      }
 
-    if (!result.ok) {
-      if (result.reason === "not_found") {
-        return { ok: false, error: Err.matchNotFound(filePath) };
+      try {
+        await writeFile(filePath, result.updatedContent);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: Err.ioError(filePath, msg) };
       }
+
       return {
-        ok: false,
-        error: Err.matchAmbiguous(filePath, result.matchCount),
+        ok: true,
+        value: {
+          filePath,
+          matchCount: result.matchCount,
+          oldContent: content,
+          newContent: result.updatedContent,
+          matchMethod: result.matchMethod,
+          similarity: result.similarity,
+          actualOld: result.actualOld,
+          actualNew: result.actualNew,
+        },
       };
-    }
-
-    try {
-      writeFileSync(filePath, result.updatedContent);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: Err.ioError(filePath, msg) };
-    }
-
-    return {
-      ok: true,
-      value: {
-        filePath,
-        matchCount: result.matchCount,
-        oldContent: content,
-        newContent: result.updatedContent,
-        matchMethod: result.matchMethod,
-        similarity: result.similarity,
-        actualOld: result.actualOld,
-        actualNew: result.actualNew,
-      },
-    };
+    });
   }
 
   // -------------------------------------------------------------------------
   // List
   // -------------------------------------------------------------------------
 
-  listDirSafe(input: ListInput): ListResult {
+  async listDirSafe(input: ListInput): Promise<ListResult> {
     const pathCheck = this.policy(input.path, { mustExist: true });
     if (!pathCheck.ok) {
       return {
@@ -268,13 +326,13 @@ export class FileSystemOps {
       return { ok: false, error: Err.notFound(resolved) };
     }
 
-    const stat = statSync(resolved);
-    if (!stat.isDirectory()) {
+    const pathStat = await stat(resolved);
+    if (!pathStat.isDirectory()) {
       return { ok: false, error: Err.notADirectory(resolved) };
     }
 
     try {
-      let entries = readdirSync(resolved, { withFileTypes: true });
+      let entries = await readdir(resolved, { withFileTypes: true });
 
       if (input.glob) {
         const pattern = input.glob;
@@ -294,16 +352,18 @@ export class FileSystemOps {
       const truncated = sorted.length > MAX_ENTRIES;
       const visible = sorted.slice(0, MAX_ENTRIES);
 
-      const lines = visible.map((entry) => {
-        if (entry.isDirectory()) {
-          return `${entry.name}/`;
-        }
-        if (entry.isSymbolicLink()) {
-          return `${entry.name}@`;
-        }
-        const fileStat = lstatSync(join(resolved, entry.name));
-        return `${entry.name}  ${formatSize(fileStat.size)}`;
-      });
+      const lines = await Promise.all(
+        visible.map(async (entry) => {
+          if (entry.isDirectory()) {
+            return `${entry.name}/`;
+          }
+          if (entry.isSymbolicLink()) {
+            return `${entry.name}@`;
+          }
+          const fileStat = await lstat(join(resolved, entry.name));
+          return `${entry.name}  ${formatSize(fileStat.size)}`;
+        }),
+      );
 
       if (truncated) {
         lines.push(

package/src/tools/shared/filesystem/image-read.ts

@@ -1,4 +1,4 @@
-import { readFileSync, statSync } from "node:fs";
+import { readFile, stat as fsStat } from "node:fs/promises";
 
 import { optimizeImageForTransport } from "../../../agent/image-optimize.js";
 import type { ImageContent } from "../../../providers/types.js";
@@ -63,10 +63,10 @@ export function detectMediaType(buf: Buffer): string | null {
   return null;
 }
 
-function buildImageToolResult(
+async function buildImageToolResult(
   buffer: Buffer,
   sourceLabel: string,
-): ToolExecutionResult {
+): Promise<ToolExecutionResult> {
   if (buffer.length > MAX_SOURCE_SIZE_BYTES) {
     const sizeMB = (buffer.length / (1024 * 1024)).toFixed(1);
     return {
@@ -87,10 +87,8 @@ function buildImageToolResult(
 
   // Optimize before size-checking — oversized images may compress under the limit.
   const rawBase64 = buffer.toString("base64");
-  const { data: base64Data, mediaType: finalType } = optimizeImageForTransport(
-    rawBase64,
-    detectedType,
-  );
+  const { data: base64Data, mediaType: finalType } =
+    await optimizeImageForTransport(rawBase64, detectedType);
   const optimized = base64Data !== rawBase64;
 
   const optimizedBytes = Buffer.from(base64Data, "base64").length;
@@ -124,10 +122,10 @@ function buildImageToolResult(
   };
 }
 
-export function readImageBase64(
+export async function readImageBase64(
   base64Data: string,
   sourceLabel: string,
-): ToolExecutionResult {
+): Promise<ToolExecutionResult> {
   return buildImageToolResult(Buffer.from(base64Data, "base64"), sourceLabel);
 }
 
@@ -138,10 +136,12 @@ export function readImageBase64(
  * The caller is responsible for path resolution and sandbox enforcement -
  * `resolvedPath` must be an already-validated absolute path.
  */
-export function readImageFile(resolvedPath: string): ToolExecutionResult {
+export async function readImageFile(
+  resolvedPath: string,
+): Promise<ToolExecutionResult> {
   let stat;
   try {
-    stat = statSync(resolvedPath);
+    stat = await fsStat(resolvedPath);
   } catch {
     return {
       content: `Error: file not found: ${resolvedPath}`,
@@ -163,7 +163,7 @@ export function readImageFile(resolvedPath: string): ToolExecutionResult {
 
   let buffer: Buffer;
   try {
-    buffer = readFileSync(resolvedPath) as Buffer;
+    buffer = (await readFile(resolvedPath)) as Buffer;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { content: `Error reading file: ${msg}`, isError: true };