@sema-agent/core 2.13.0 → 4.0.0

package/dist/engine/execution-env/node-execution-env.d.ts

@@ -1,4 +1,4 @@
-import { type ExecutionEnv, ExecutionError, FileError, type FileInfo, type Result } from "../harness/types.js";
+import { type ExecResult, type ExecutionEnv, ExecutionError, type ExecutionEnvExecOptions, FileError, type FileInfo, type Result } from "../harness/types.js";
 import type { BackgroundShellCapability, BackgroundShellId, BackgroundPoll, BackgroundSpawnOptions } from "../../core/background-shell.js";
 import { BackgroundShellError } from "../../core/background-shell.js";
 import type { SchedulerCapability, ScheduledIntent, SchedulerContext, ScheduledTaskId, ScheduledTaskSummary } from "../../core/scheduler.js";
@@ -54,29 +54,7 @@ export declare class NodeExecutionEnv implements ExecutionEnv, BackgroundShellCa
     list(ctx: SchedulerContext): Promise<Result<ScheduledTaskSummary[], SchedulerError>>;
     absolutePath(path: string): Promise<Result<string, FileError>>;
     joinPath(parts: string[]): Promise<Result<string, FileError>>;
-    exec(command: string, options?: {
-        cwd?: string;
-        env?: Record<string, string>;
-        timeout?: number;
-        abortSignal?: AbortSignal;
-        onStdout?: (chunk: string) => void;
-        onStderr?: (chunk: string) => void;
-        detachSignal?: AbortSignal;
-        onSpawn?: (handle: {
-            pid: number;
-            kill: () => void;
-        }) => void;
-        onDetachAdopted?: () => void;
-        autoBackgroundOnTimeout?: boolean;
-    }): Promise<Result<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-        detached?: {
-            shellId: string;
-            cause?: "timeout";
-        };
-    }, ExecutionError>>;
+    exec(command: string, options?: ExecutionEnvExecOptions): Promise<Result<ExecResult, ExecutionError>>;
     readTextFile(path: string, abortSignal?: AbortSignal): Promise<Result<string, FileError>>;
     readTextLines(path: string, options?: {
         maxLines?: number;

package/dist/engine/harness/agent-harness.d.ts

@@ -92,6 +92,7 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
         images?: ImageContent[];
     } & UserMessageProvenance): Promise<AssistantMessage>;
     private static emptyInjection;
+    private enqueueInjection;
     steer(text: string, options?: {
         images?: ImageContent[];
     } & UserMessageProvenance): Promise<void>;

package/dist/engine/harness/agent-harness.js

@@ -478,14 +478,7 @@ export class AgentHarness {
                     details: result.details,
                     isError,
                 });
-                return patch
-                    ? {
-                        content: patch.content,
-                        details: patch.details,
-                        isError: patch.isError,
-                        terminate: patch.terminate,
-                    }
-                    : undefined;
+                return patch;
             },
             prepareNextTurn: async () => {
                 await this.flushPendingSessionWrites();
@@ -725,42 +718,29 @@ export class AgentHarness {
     static emptyInjection(text, options) {
         return text.trim().length === 0 && (options?.images === undefined || options.images.length === 0);
     }
+    async enqueueInjection(queue, text, options) {
+        if (AgentHarness.emptyInjection(text, options))
+            return;
+        const m = createUserMessage(text, options?.images, options);
+        if (options?.enginePayload !== undefined)
+            engineNotePayloads.set(m, options.enginePayload);
+        queue.push(m);
+        await this.emitQueueUpdate();
+    }
     async steer(text, options) {
         if (this.phase === "idle") {
             throw new AgentHarnessError("invalid_state", "Cannot steer while idle");
         }
-        if (AgentHarness.emptyInjection(text, options))
-            return;
-        {
-            const m = createUserMessage(text, options?.images, options);
-            if (options?.enginePayload !== undefined)
-                engineNotePayloads.set(m, options.enginePayload);
-            this.steerQueue.push(m);
-        }
-        await this.emitQueueUpdate();
+        await this.enqueueInjection(this.steerQueue, text, options);
     }
     async followUp(text, options) {
         if (this.phase === "idle") {
             throw new AgentHarnessError("invalid_state", "Cannot follow up while idle");
         }
-        if (AgentHarness.emptyInjection(text, options))
-            return;
-        {
-            const m = createUserMessage(text, options?.images, options);
-            if (options?.enginePayload !== undefined)
-                engineNotePayloads.set(m, options.enginePayload);
-            this.followUpQueue.push(m);
-        }
-        await this.emitQueueUpdate();
+        await this.enqueueInjection(this.followUpQueue, text, options);
     }
     async nextTurn(text, options) {
-        if (AgentHarness.emptyInjection(text, options))
-            return;
-        const m = createUserMessage(text, options?.images, options);
-        if (options?.enginePayload !== undefined)
-            engineNotePayloads.set(m, options.enginePayload);
-        this.nextTurnQueue.push(m);
-        await this.emitQueueUpdate();
+        await this.enqueueInjection(this.nextTurnQueue, text, options);
     }
     async appendMessage(message) {
         try {

package/dist/engine/harness/types.d.ts

@@ -1,5 +1,6 @@
+import type { PromptEpochDescriptor } from "../../prompt-assembly/epoch.js";
 import type { DocumentContent, ImageContent, Model, SimpleStreamOptions, TextContent, Transport } from "../llm/index.js";
-import type { AgentEvent, AgentMessage, AgentTool, QueueMode, ThinkingLevel } from "../loop/types.js";
+import type { AfterToolCallResult, AgentEvent, AgentMessage, AgentTool, BeforeToolCallResult, QueueMode, ThinkingLevel } from "../loop/types.js";
 import type { AgentCoreRuntimeDeps } from "../loop/runtime-deps.js";
 export type Result<TValue, TError> = {
     ok: true;
@@ -129,16 +130,17 @@ export interface FileSystem {
     }): Promise<Result<string, FileError>>;
     cleanup(): Promise<void>;
 }
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    detached?: {
+        shellId: string;
+        cause?: "timeout";
+    };
+}
 export interface Shell {
-    exec(command: string, options?: ExecutionEnvExecOptions): Promise<Result<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-        detached?: {
-            shellId: string;
-            cause?: "timeout";
-        };
-    }, ExecutionError>>;
+    exec(command: string, options?: ExecutionEnvExecOptions): Promise<Result<ExecResult, ExecutionError>>;
     cleanup(): Promise<void>;
 }
 export interface ExecutionEnv extends FileSystem, Shell {
@@ -195,15 +197,8 @@ export interface LeafEntry extends SessionTreeEntryBase {
     type: "leaf";
     targetId: string | null;
 }
-export interface PromptEpochEntry extends SessionTreeEntryBase {
+export interface PromptEpochEntry extends SessionTreeEntryBase, PromptEpochDescriptor {
     type: "prompt_epoch";
-    epoch: number;
-    artifactDigest: string;
-    packId: string;
-    assemblyApi: number;
-    activatedBy: "session_start" | "compaction" | "legacy_migration";
-    centerArtifactDigest?: string;
-    sourceRevision?: string;
 }
 export interface AnnouncedListingEntry extends SessionTreeEntryBase {
     type: "announced_listing";
@@ -211,28 +206,22 @@ export interface AnnouncedListingEntry extends SessionTreeEntryBase {
     skills?: string[];
     models?: string[];
 }
-export interface WorkspaceStateEntry extends SessionTreeEntryBase {
-    type: "workspace_state";
+export interface ActiveWorktreeSession {
+    worktreeDir: string;
+    originalCwd: string;
+    baseSha: string;
+    entered?: boolean;
+}
+export interface WorkspaceState {
     taskRoot: string;
     handsCwd?: string;
-    activeWorktree?: {
-        worktreeDir: string;
-        originalCwd: string;
-        baseSha: string;
-        entered?: boolean;
-    };
+    activeWorktree?: ActiveWorktreeSession;
+}
+export interface WorkspaceStateEntry extends SessionTreeEntryBase, WorkspaceState {
+    type: "workspace_state";
 }
 export declare const WORKSPACE_STATE_MAX_PATH_CHARS = 4096;
-export declare function normalizeWorkspaceState(value: unknown): {
-    taskRoot: string;
-    handsCwd?: string;
-    activeWorktree?: {
-        worktreeDir: string;
-        originalCwd: string;
-        baseSha: string;
-        entered?: boolean;
-    };
-} | undefined;
+export declare function normalizeWorkspaceState(value: unknown): WorkspaceState | undefined;
 export declare const ANNOUNCED_LISTING_MAX_NAMES = 500;
 export declare const ANNOUNCED_LISTING_MAX_NAME_CHARS = 200;
 export declare function normalizeCompactionStateCarrier(v: unknown): {
@@ -331,26 +320,8 @@ export interface Session<TMetadata extends SessionMetadata = SessionMetadata> {
         skills?: string[];
         models?: string[];
     } | undefined>;
-    appendWorkspaceState(state: {
-        taskRoot: string;
-        handsCwd?: string;
-        activeWorktree?: {
-            worktreeDir: string;
-            originalCwd: string;
-            baseSha: string;
-            entered?: boolean;
-        };
-    }): Promise<string>;
-    getWorkspaceState(): Promise<{
-        taskRoot: string;
-        handsCwd?: string;
-        activeWorktree?: {
-            worktreeDir: string;
-            originalCwd: string;
-            baseSha: string;
-            entered?: boolean;
-        };
-    } | undefined>;
+    appendWorkspaceState(state: WorkspaceState): Promise<string>;
+    getWorkspaceState(): Promise<WorkspaceState | undefined>;
     getPromptEpoch?(): Promise<import("../../prompt-assembly/epoch.js").PromptEpochDescriptor | undefined>;
 }
 export interface SessionCreateOptions {
@@ -487,17 +458,8 @@ export interface BeforeProviderRequestResult {
 export interface BeforeProviderPayloadResult {
     payload: unknown;
 }
-export interface ToolCallResult {
-    block?: boolean;
-    reason?: string;
-    updatedInput?: unknown;
-}
-export interface ToolResultPatch {
-    content?: Array<TextContent | ImageContent | DocumentContent>;
-    details?: unknown;
-    isError?: boolean;
-    terminate?: boolean;
-}
+export type ToolCallResult = BeforeToolCallResult;
+export type ToolResultPatch = AfterToolCallResult;
 export interface SessionBeforeCompactResult {
     cancel?: boolean;
     compaction?: CompactResult;

package/dist/engine/llm/types.d.ts

@@ -143,7 +143,7 @@ export interface AssistantMessage {
     usageMissing?: true;
     stopReason: StopReason;
     errorMessage?: string;
-    errorKind?: "length_empty";
+    errorKind?: "length_empty" | "degenerate" | "walltime_cutoff";
     partialFinalized?: true;
     repetition?: {
         cut?: RepetitionEvent;

package/dist/engine/loop/agent-loop.js

@@ -647,10 +647,16 @@ function partitionToolCalls(toolCalls, tools) {
     }
     return batches;
 }
+function resolveToolConcurrency(configured) {
+    if (configured === undefined)
+        return 10;
+    return Number.isFinite(configured) ? Math.max(1, Math.floor(configured)) : 1;
+}
 async function runCapped(thunks, limit) {
     const results = new Array(thunks.length);
     let next = 0;
-    const workers = Array.from({ length: Math.max(1, Math.min(limit, thunks.length)) }, async () => {
+    const width = Number.isFinite(limit) ? Math.max(1, Math.min(limit, thunks.length)) : 1;
+    const workers = Array.from({ length: width }, async () => {
         while (next < thunks.length) {
             const i = next++;
             results[i] = await thunks[i]();
@@ -660,7 +666,7 @@ async function runCapped(thunks, limit) {
     return results;
 }
 async function executeToolCallsPartitioned(currentContext, assistantMessage, toolCalls, config, signal, emit, executor) {
-    const cap = config.maxToolConcurrency ?? 10;
+    const cap = resolveToolConcurrency(config.maxToolConcurrency);
     const allFinalized = [];
     const messages = [];
     let engineCutSeen = false;
@@ -798,7 +804,7 @@ class StreamToolExecutor {
             this.signal?.aborted ||
             partialAssistant === null ||
             !isBatchSafeToolCall(findToolByName(this.context.tools, toolCall.name), toolCall) ||
-            this.inFlight >= (this.config.maxToolConcurrency ?? 10) ||
+            this.inFlight >= resolveToolConcurrency(this.config.maxToolConcurrency) ||
             this.entries.has(toolCall.id)) {
             this.barrier = true;
             return;
@@ -927,7 +933,8 @@ function prepareToolCallArguments(tool, toolCall) {
 async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
     const tool = findToolByName(currentContext.tools, toolCall.name);
     if (!tool) {
-        const tombstone = TOMBSTONED_TOOLS[toolCall.name];
+        const tombstoneEntry = Object.hasOwn(TOMBSTONED_TOOLS, toolCall.name) ? TOMBSTONED_TOOLS[toolCall.name] : undefined;
+        const tombstone = typeof tombstoneEntry === "string" ? tombstoneEntry : undefined;
         if (tombstone !== undefined) {
             return {
                 kind: "immediate",

package/dist/engine/loop/types.d.ts

@@ -74,21 +74,23 @@ export interface LoopRecoveryOptions {
         hasLiveWriteoutWindow?: () => boolean;
     };
 }
+export interface ToolCutInfo {
+    toolCallId: string;
+    toolName: string;
+    elapsedMs: number;
+    settled: Promise<void>;
+}
+export interface LoopToolDeadline {
+    deadlineMs: () => number | undefined;
+    onCut?: (info: ToolCutInfo) => void;
+}
 export interface AgentLoopConfig extends SimpleStreamOptions {
     model: Model;
     recovery?: LoopRecoveryOptions;
     maxTokensPerCall?: () => number | undefined;
     callDeadlineMsPerCall?: () => number | undefined;
     stallTimeoutsPerCall?: () => import("../llm/types.js").StallTimeouts | undefined;
-    toolDeadline?: {
-        deadlineMs: () => number | undefined;
-        onCut?: (info: {
-            toolCallId: string;
-            toolName: string;
-            elapsedMs: number;
-            settled: Promise<void>;
-        }) => void;
-    };
+    toolDeadline?: LoopToolDeadline;
     maxToolConcurrency?: number;
     streamingToolExecution?: boolean;
     convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;

package/dist/engine/lsp/frame-decoder.js

@@ -8,8 +8,7 @@ export function createFrameDecoder(maxBytes = 50 * 1024 * 1024) {
     return function decode(chunk) {
         const frames = [];
         buf = Buffer.concat([buf, chunk]);
-        if (buf.length > maxBytes + HEADER_SLACK)
-            buf = Buffer.alloc(0);
+        let awaiting;
         for (;;) {
             const he = buf.indexOf("\r\n\r\n");
             if (he === -1)
@@ -25,11 +24,15 @@ export function createFrameDecoder(maxBytes = 50 * 1024 * 1024) {
                 continue;
             }
             const start = he + 4;
-            if (buf.length < start + len)
+            if (buf.length < start + len) {
+                awaiting = start + len;
                 break;
+            }
             frames.push(buf.subarray(start, start + len).toString("utf8"));
             buf = buf.subarray(start + len);
         }
+        if (buf.length > (awaiting ?? maxBytes + HEADER_SLACK))
+            buf = Buffer.alloc(0);
         return frames;
     };
 }

package/dist/engine/lsp/node-lsp-manager.d.ts

@@ -29,6 +29,7 @@ export declare class NodeLspManager implements LspServerManager {
     private readonly cache;
     private readonly opening;
     private readonly failed;
+    private readonly initFailures;
     private disposed;
     constructor(opts?: NodeLspManagerOptions);
     private sweepIdle;
@@ -37,6 +38,7 @@ export declare class NodeLspManager implements LspServerManager {
     private evictOverCap;
     evict(root: string): Promise<void>;
     clearFailed(root?: string): void;
+    unavailableReason(filePath: string, env?: ExecutionEnv): string | undefined;
     private openSession;
     private serverCmd;
     dispose(): Promise<void>;

package/dist/engine/lsp/node-lsp-manager.js

@@ -1,13 +1,13 @@
 import { spawn } from "node:child_process";
 import { killProcessTree } from "../execution-env/kill-tree.js";
-import { readFile, stat } from "node:fs/promises";
+import { open, readFile, stat } from "node:fs/promises";
 import { basename, dirname, extname, resolve as resolvePath } from "node:path";
-import { existsSync } from "node:fs";
+import { constants as fsConstants, existsSync } from "node:fs";
 import { pathToUri } from "../../core/lsp-protocol.js";
 import { LspDiagnosticsRegistry } from "../../core/lsp-diagnostics.js";
 import { TransportLspSession } from "../../core/lsp-session.js";
 import { StdioLspTransport } from "./stdio-lsp-transport.js";
-import { MAX_LSP_FILE_BYTES } from "../../core/lsp.js";
+import { MAX_LSP_FILE_BYTES, SharedAbortScope, settleOnAbort } from "../../core/lsp.js";
 export const DEFAULT_LSP_SERVERS = {
     typescript: "typescript-language-server --stdio",
     javascript: "typescript-language-server --stdio",
@@ -46,6 +46,7 @@ const CLIENT_CAPABILITIES = {
     },
     workspace: { symbol: {}, workspaceFolders: false },
 };
+const INIT_FAILURE_LATCH = 2;
 export class NodeLspManager {
     servers;
     spawnFn;
@@ -60,6 +61,7 @@ export class NodeLspManager {
     cache = new Map();
     opening = new Map();
     failed = new Map();
+    initFailures = new Map();
     disposed = false;
     constructor(opts = {}) {
         this.servers = { ...DEFAULT_LSP_SERVERS, ...opts.servers };
@@ -79,6 +81,10 @@ export class NodeLspManager {
     sweepIdle() {
         const cutoff = Date.now() - this.idleTtlMs;
         for (const [key, e] of [...this.cache]) {
+            if (e.session.inFlight > 0) {
+                e.lastUsed = Date.now();
+                continue;
+            }
             if (e.lastUsed < cutoff) {
                 this.cache.delete(key);
                 this.log("lsp_evict_idle", { key });
@@ -106,19 +112,20 @@ export class NodeLspManager {
             this.cache.delete(key);
             const carry = cached.session.openedFiles();
             this.log("lsp_heal", { language, root, carried: carry.length });
-            const healed = await this.open(key, language, root, signal, env);
-            if (healed && carry.length)
-                await healed.warmOpen(carry, signal).catch(() => undefined);
-            return healed;
+            return this.open(key, language, root, signal, env, carry);
         }
         return this.open(key, language, root, signal, env);
     }
-    open(key, language, root, signal, env) {
+    open(key, language, root, signal, env, carry = []) {
         const inflight = this.opening.get(key);
-        if (inflight)
-            return inflight.job;
-        const entry = { root, cancelled: false, job: undefined };
-        entry.job = this.openSession(language, root, signal, env)
+        if (inflight && !inflight.scope.signal.aborted) {
+            inflight.scope.join(signal);
+            return settleOnAbort(inflight.job, signal, () => undefined);
+        }
+        const scope = new SharedAbortScope();
+        scope.join(signal);
+        const entry = { root, cancelled: false, scope, job: undefined };
+        entry.job = this.openSession(language, root, scope.signal, env)
             .then(async (session) => {
             if (!session)
                 return undefined;
@@ -126,26 +133,41 @@ export class NodeLspManager {
                 await session.close().catch(() => undefined);
                 return undefined;
             }
+            if (carry.length) {
+                const carried = await session.warmOpen(carry, scope.signal).catch(() => ({ opened: 0, failed: carry.length }));
+                this.log("lsp_heal_carried", { language, root, ...carried });
+                if (this.disposed || entry.cancelled) {
+                    await session.close().catch(() => undefined);
+                    return undefined;
+                }
+            }
             this.evictOverCap();
             this.cache.set(key, { session, root, lastUsed: Date.now() });
             return session;
         })
-            .finally(() => this.opening.delete(key));
+            .finally(() => {
+            if (this.opening.get(key) === entry)
+                this.opening.delete(key);
+        });
         this.opening.set(key, entry);
-        return entry.job;
+        return settleOnAbort(entry.job, signal, () => undefined);
     }
     evictOverCap() {
         while (this.cache.size >= this.maxSessions) {
             let lruKey;
             let lruTime = Infinity;
             for (const [k, e] of this.cache) {
+                if (e.session.inFlight > 0)
+                    continue;
                 if (e.lastUsed < lruTime) {
                     lruTime = e.lastUsed;
                     lruKey = k;
                 }
             }
-            if (lruKey === undefined)
+            if (lruKey === undefined) {
+                this.log("lsp_evict_deferred", { size: this.cache.size, maxSessions: this.maxSessions });
                 break;
+            }
             const evicted = this.cache.get(lruKey);
             this.cache.delete(lruKey);
             this.log("lsp_evict_lru", { key: lruKey });
@@ -154,6 +176,7 @@ export class NodeLspManager {
     }
     async evict(root) {
         const closing = [];
+        this.clearFailed(root);
         for (const [key, e] of [...this.cache]) {
             if (e.root === root) {
                 this.cache.delete(key);
@@ -174,8 +197,27 @@ export class NodeLspManager {
             if (root !== undefined && e.root !== root)
                 continue;
             this.failed.delete(key);
-            this.log("lsp_negative_cache_cleared", { key, attempts: e.attempts });
+            this.initFailures.delete(key);
+            this.log("lsp_negative_cache_cleared", { key, attempts: e.attempts, kind: e.kind });
         }
+        for (const [key, _n] of [...this.initFailures]) {
+            if (root === undefined || key.endsWith(` ${root}`))
+                this.initFailures.delete(key);
+        }
+    }
+    unavailableReason(filePath, env) {
+        const language = languageFor(filePath);
+        if (!language)
+            return undefined;
+        const cmd = this.serverCmd(language);
+        if (!cmd)
+            return `no ${language} language server is configured in this environment`;
+        const e = this.failed.get(`${language} ${this.resolveRootFn(filePath, env)}`);
+        if (e?.kind === "missing_binary")
+            return `the ${language} language server ("${e.command}") is not installed on this host`;
+        if (e?.kind === "initialize")
+            return `the ${language} language server ("${e.command}") is installed but failed to initialize`;
+        return undefined;
     }
     async openSession(language, root, signal, _env) {
         const cmd = this.serverCmd(language);
@@ -183,10 +225,18 @@ export class NodeLspManager {
             return undefined;
         const tokens = (cmd.match(/"[^"]*"|\S+/g) ?? []).map((t) => (t.startsWith('"') && t.endsWith('"') && t.length >= 2 ? t.slice(1, -1) : t));
         const [command, ...args] = tokens.length > 0 ? tokens : [""];
-        const child = await this.spawnFn(command, args, root, signal).catch(() => undefined);
+        const key = `${language} ${root}`;
+        let child;
+        try {
+            child = await this.spawnFn(command, args, root, signal);
+        }
+        catch (e) {
+            this.log("lsp_spawn_error", { language, root, command, err: e instanceof Error ? e.message : String(e) });
+            return undefined;
+        }
         if (!child) {
             if (signal?.aborted !== true)
-                this.failed.set(`${language} ${root}`, { root, attempts: 1 });
+                this.failed.set(key, { root, attempts: 1, kind: "missing_binary", command, language });
             this.log("lsp_spawn_degraded", { language, root, command });
             return undefined;
         }
@@ -204,9 +254,18 @@ export class NodeLspManager {
         }
         catch (e) {
             await transport.close();
-            this.log("lsp_init_degraded", { language, root, err: e instanceof Error ? e.message : String(e) });
+            const attempt = (this.initFailures.get(key) ?? 0) + 1;
+            const latched = attempt >= INIT_FAILURE_LATCH && signal?.aborted !== true;
+            if (latched) {
+                this.failed.set(key, { root, attempts: 1, kind: "initialize", command, language });
+                this.initFailures.delete(key);
+            }
+            else
+                this.initFailures.set(key, attempt);
+            this.log("lsp_init_degraded", { language, root, err: e instanceof Error ? e.message : String(e), attempt, latched });
             return undefined;
         }
+        this.initFailures.delete(key);
         this.log("lsp_open", { language, root });
         return new TransportLspSession(transport, language, this.readTextFn, this.log, this.warmup, this.diagnostics);
     }
@@ -249,33 +308,51 @@ export const defaultLspReadText = async (fp, signal) => {
         throw new Error(`not a regular file: ${fp}`);
     if (st.size > MAX_LSP_FILE_BYTES)
         throw new Error(`file too large for LSP analysis (${st.size} bytes exceeds ${MAX_LSP_FILE_BYTES})`);
-    return readFile(fp, { encoding: "utf8", signal });
+    const flags = fsConstants.O_RDONLY | (fsConstants.O_NONBLOCK ?? 0);
+    const fh = await open(fp, flags);
+    try {
+        const fst = await fh.stat();
+        if (!fst.isFile())
+            throw new Error(`not a regular file: ${fp}`);
+        if (fst.size > MAX_LSP_FILE_BYTES)
+            throw new Error(`file too large for LSP analysis (${fst.size} bytes exceeds ${MAX_LSP_FILE_BYTES})`);
+        return await readFile(fh, { encoding: "utf8", signal });
+    }
+    finally {
+        await fh.close().catch(() => undefined);
+    }
 };
 export function lspSpawnOptions(cwd) {
     return process.platform === "win32"
         ? { cwd, stdio: ["pipe", "pipe", "ignore"], shell: true }
         : { cwd, stdio: ["pipe", "pipe", "ignore"] };
 }
-export const defaultLspSpawn = (command, args, cwd, signal) => new Promise((resolve) => {
+export const defaultLspSpawn = (command, args, cwd, signal) => new Promise((resolve, reject) => {
     let child;
     try {
         child = spawn(command, args, lspSpawnOptions(cwd));
     }
-    catch {
-        return resolve(undefined);
+    catch (e) {
+        return reject(e instanceof Error ? e : new Error(String(e)));
     }
+    child.on("error", () => { });
     const onSpawn = () => {
         cleanup();
         resolve(child);
     };
-    const onError = () => {
+    const onError = (err) => {
         cleanup();
-        resolve(undefined);
+        if (err?.code === "ENOENT")
+            resolve(undefined);
+        else
+            reject(err instanceof Error ? err : new Error(String(err)));
     };
     const onAbort = () => {
         cleanup();
         try {
-            if (process.platform === "win32" && child.pid)
+            if (child.pid === undefined)
+                return resolve(undefined);
+            if (process.platform === "win32")
                 killProcessTree(child.pid, { force: true });
             else
                 child.kill();