@wrongstack/acp 0.298.0 → 0.298.2

package/dist/client/acp-session-callbacks.d.ts

@@ -6,7 +6,22 @@ export interface ACPResponseSender {
     sendResult(id: string | number, result: unknown): Promise<void>;
     sendErrorResponse(id: string | number, code: number, message: string): Promise<void>;
 }
-export declare function handleAcpPermissionRequest(msg: ACPMessage, permissionPolicy: PermissionPolicy, sender: ACPResponseSender): Promise<void>;
-export declare function handleAcpFsRequest(msg: ACPMessage, fileServer: FileServer, permissionPolicy: PermissionPolicy, sender: ACPResponseSender): Promise<void>;
-export declare function handleAcpTerminalRequest(msg: ACPMessage, terminalServer: TerminalServer, permissionPolicy: PermissionPolicy, sender: ACPResponseSender): Promise<void>;
+export interface ACPCallbackOptions {
+    /** Abort when the owning ACP session/prompt is closed or cancelled. */
+    signal?: AbortSignal | undefined;
+    /**
+     * Maximum time to wait for callback authorization before failing closed.
+     * Defaults to {@link DEFAULT_PERMISSION_TIMEOUT_MS}. Pass
+     * `Number.POSITIVE_INFINITY` to opt out of the wall-clock deadline (e.g.
+     * hosts whose permission policy waits for a human decision, where a short
+     * cap would auto-fail approvals the user is still considering); the
+     * host's `signal` still bounds the wait and fails closed on teardown.
+     * Non-positive or non-finite values (other than the opt-out) fall back to
+     * the fail-closed default.
+     */
+    permissionTimeoutMs?: number | undefined;
+}
+export declare function handleAcpPermissionRequest(msg: ACPMessage, permissionPolicy: PermissionPolicy, sender: ACPResponseSender, callbackOptions?: ACPCallbackOptions): Promise<void>;
+export declare function handleAcpFsRequest(msg: ACPMessage, fileServer: FileServer, permissionPolicy: PermissionPolicy, sender: ACPResponseSender, callbackOptions?: ACPCallbackOptions): Promise<void>;
+export declare function handleAcpTerminalRequest(msg: ACPMessage, terminalServer: TerminalServer, permissionPolicy: PermissionPolicy, sender: ACPResponseSender, callbackOptions?: ACPCallbackOptions): Promise<void>;
 //# sourceMappingURL=acp-session-callbacks.d.ts.map

package/dist/client/acp-session.d.ts

@@ -23,6 +23,8 @@ export declare class ACPSession {
     private readonly timeoutMs;
     private readonly opts;
     private transportOff;
+    private readonly callbackAbort;
+    private promptCallbackAbort;
     private state;
     private sessionId;
     /** Pending outbound requests (initialize, session/new, session/prompt, etc). */
@@ -204,6 +206,7 @@ export declare class ACPSession {
     /** Send a JSON-RPC 2.0 error response (no `method` field, per spec). */
     private sendErrorResponse;
     private responseSender;
+    private callbackOptions;
     private handleMessage;
     private emitProgress;
     /** Live progress handler installed for the duration of a `prompt()` turn. */

package/dist/client.js

@@ -1109,30 +1109,34 @@ function captureToolCall(u, isNew, scratch, emitProgress) {
 }
 
 // src/client/acp-session-callbacks.ts
-async function handleAcpPermissionRequest(msg, permissionPolicy, sender) {
+var DEFAULT_PERMISSION_TIMEOUT_MS = 6e4;
+async function handleAcpPermissionRequest(msg, permissionPolicy, sender, callbackOptions = {}) {
   const id = msg.id;
   if (id === void 0) return;
   const params = msg.params;
   const toolCall = params?.toolCall;
-  const options = Array.isArray(params?.options) ? params.options : [];
+  const permissionOptions = Array.isArray(params?.options) ? params.options : [];
   if (!toolCall) {
     await sender.sendErrorResponse(id, -32602, "toolCall is required");
     return;
   }
-  const policyAbort = new AbortController();
   try {
-    const outcome = await permissionPolicy({
-      toolCall,
-      options,
-      signal: policyAbort.signal
-    });
+    const outcome = await runPermissionWithDeadline(
+      permissionPolicy,
+      {
+        toolCall,
+        options: permissionOptions
+      },
+      callbackOptions
+    );
     await sender.sendResult(id, { outcome });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    await sender.sendErrorResponse(id, -32603, `permission policy failed: ${message}`);
+    const code = isAbortLikeError(err) ? -32800 : -32603;
+    await sender.sendErrorResponse(id, code, `permission policy failed: ${message}`);
   }
 }
-async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender) {
+async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender, callbackOptions = {}) {
   const id = msg.id;
   if (id === void 0) return;
   const params = msg.params;
@@ -1141,14 +1145,23 @@ async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender) {
     return;
   }
   if (msg.method === "fs/write_text_file") {
-    const allowed = await authorizeAcpCallback(permissionPolicy, {
-      toolCallId: `acp-fs-write-${id}`,
-      title: `Write file: ${params.path}`,
-      kind: "edit",
-      rawInput: { path: params.path, sessionId: params.sessionId }
-    });
-    if (!allowed) {
-      await sender.sendErrorResponse(id, -32602, "filesystem write denied by permission policy");
+    const authorization = await authorizeAcpCallback(
+      permissionPolicy,
+      {
+        toolCallId: `acp-fs-write-${id}`,
+        title: `Write file: ${params.path}`,
+        kind: "edit",
+        rawInput: { path: params.path, sessionId: params.sessionId }
+      },
+      callbackOptions
+    );
+    if (authorization !== "allowed") {
+      const isCancelled = authorization === "cancelled";
+      await sender.sendErrorResponse(
+        id,
+        isCancelled ? -32800 : -32602,
+        isCancelled ? "filesystem write permission request cancelled or timed out" : "filesystem write denied by permission policy"
+      );
       return;
     }
   }
@@ -1173,26 +1186,35 @@ async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender) {
     await sender.sendErrorResponse(id, code, message);
   }
 }
-async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, sender) {
+async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, sender, callbackOptions = {}) {
   const id = msg.id;
   if (id === void 0) return;
   const params = msg.params ?? {};
   try {
     switch (msg.method) {
       case "terminal/create": {
-        const allowed = await authorizeAcpCallback(permissionPolicy, {
-          toolCallId: `acp-terminal-create-${id}`,
-          title: `Run command: ${String(params.command ?? "")} ${(Array.isArray(params.args) ? params.args : []).join(" ")}`.trim(),
-          kind: "execute",
-          rawInput: {
-            command: params.command,
-            args: params.args,
-            cwd: params.cwd,
-            sessionId: params.sessionId
-          }
-        });
-        if (!allowed) {
-          await sender.sendErrorResponse(id, -32602, "terminal create denied by permission policy");
+        const authorization = await authorizeAcpCallback(
+          permissionPolicy,
+          {
+            toolCallId: `acp-terminal-create-${id}`,
+            title: `Run command: ${String(params.command ?? "")} ${(Array.isArray(params.args) ? params.args : []).join(" ")}`.trim(),
+            kind: "execute",
+            rawInput: {
+              command: params.command,
+              args: params.args,
+              cwd: params.cwd,
+              sessionId: params.sessionId
+            }
+          },
+          callbackOptions
+        );
+        if (authorization !== "allowed") {
+          const isCancelled = authorization === "cancelled";
+          await sender.sendErrorResponse(
+            id,
+            isCancelled ? -32800 : -32602,
+            isCancelled ? "terminal create permission request cancelled or timed out" : "terminal create denied by permission policy"
+          );
           return;
         }
         const createOpts = {
@@ -1245,28 +1267,77 @@ async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, s
     await sender.sendErrorResponse(id, -32603, message);
   }
 }
-async function authorizeAcpCallback(permissionPolicy, partial) {
+async function authorizeAcpCallback(permissionPolicy, partial, callbackOptions) {
   try {
-    const outcome = await permissionPolicy({
-      toolCall: {
-        sessionUpdate: "tool_call_update",
-        toolCallId: partial.toolCallId,
-        title: partial.title,
-        kind: partial.kind,
-        status: "pending",
-        ...partial.rawInput ? { rawInput: partial.rawInput } : {}
+    const outcome = await runPermissionWithDeadline(
+      permissionPolicy,
+      {
+        toolCall: {
+          sessionUpdate: "tool_call_update",
+          toolCallId: partial.toolCallId,
+          title: partial.title,
+          kind: partial.kind,
+          status: "pending",
+          ...partial.rawInput ? { rawInput: partial.rawInput } : {}
+        },
+        options: [
+          { optionId: "allow", name: "Allow", kind: "allow_once" },
+          { optionId: "reject", name: "Reject", kind: "reject_once" }
+        ]
       },
-      options: [
-        { optionId: "allow", name: "Allow", kind: "allow_once" },
-        { optionId: "reject", name: "Reject", kind: "reject_once" }
-      ],
-      signal: new AbortController().signal
-    });
-    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always";
-  } catch {
-    return false;
+      callbackOptions
+    );
+    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always" ? "allowed" : "denied";
+  } catch (err) {
+    return isAbortLikeError(err) ? "cancelled" : "denied";
+  }
+}
+async function runPermissionWithDeadline(permissionPolicy, call, callbackOptions) {
+  const timeoutMs = resolvePermissionDeadline(callbackOptions.permissionTimeoutMs);
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  const timer = timeoutMs === null ? null : setTimeout(abort, timeoutMs);
+  let removeAbort;
+  if (callbackOptions.signal) {
+    if (callbackOptions.signal.aborted) {
+      abort();
+    } else {
+      callbackOptions.signal.addEventListener("abort", abort, { once: true });
+      removeAbort = () => callbackOptions.signal?.removeEventListener("abort", abort);
+    }
+  }
+  try {
+    return await Promise.race([
+      permissionPolicy({
+        toolCall: call.toolCall,
+        options: call.options,
+        signal: controller.signal
+      }),
+      rejectOnAbort(controller.signal)
+    ]);
+  } finally {
+    if (timer !== null) clearTimeout(timer);
+    removeAbort?.();
   }
 }
+function rejectOnAbort(signal) {
+  return new Promise((_, reject) => {
+    const rejectAbort = () => reject(new Error("permission request cancelled or timed out"));
+    if (signal.aborted) {
+      rejectAbort();
+      return;
+    }
+    signal.addEventListener("abort", rejectAbort, { once: true });
+  });
+}
+function isAbortLikeError(err) {
+  return err instanceof Error && /cancelled|canceled|timed out|aborted/i.test(err.message);
+}
+function resolvePermissionDeadline(value) {
+  if (value === Number.POSITIVE_INFINITY) return null;
+  if (value !== void 0 && Number.isFinite(value) && value > 0) return Math.trunc(value);
+  return DEFAULT_PERMISSION_TIMEOUT_MS;
+}
 
 // src/client/acp-message-routing.ts
 function isBestEffortAckMethod(method) {
@@ -1282,6 +1353,8 @@ var ACPSession = class _ACPSession {
   timeoutMs;
   opts;
   transportOff = null;
+  callbackAbort = new AbortController();
+  promptCallbackAbort = null;
   state = "init";
   sessionId = null;
   /** Pending outbound requests (initialize, session/new, session/prompt, etc). */
@@ -1796,8 +1869,10 @@ var ACPSession = class _ACPSession {
       this.timeoutMs
     );
     let cancelled = false;
+    this.promptCallbackAbort = new AbortController();
     const onAbort = () => {
       cancelled = true;
+      this.promptCallbackAbort?.abort();
       this.transport.send({
         jsonrpc: "2.0",
         method: "session/cancel",
@@ -1820,6 +1895,8 @@ var ACPSession = class _ACPSession {
       throw new ACPSessionError("prompt_failed", `session/prompt failed: ${msg}`, err);
     } finally {
       signal.removeEventListener("abort", onAbort);
+      this.promptCallbackAbort?.abort();
+      this.promptCallbackAbort = null;
       this.progressHandler = null;
     }
     this.state = "done";
@@ -1886,6 +1963,9 @@ var ACPSession = class _ACPSession {
     if (this.closed) return;
     this.closed = true;
     this.state = "closed";
+    this.callbackAbort.abort();
+    this.promptCallbackAbort?.abort();
+    this.promptCallbackAbort = null;
     this.terminalServer.releaseAll();
     if (this.sessionId && this.agentCapabilities.sessionCapabilities?.close) {
       try {
@@ -1981,6 +2061,11 @@ var ACPSession = class _ACPSession {
       sendErrorResponse: (id, code, message) => this.sendErrorResponse(id, code, message)
     };
   }
+  callbackOptions() {
+    const promptSignal = this.promptCallbackAbort?.signal;
+    const signal = promptSignal ? AbortSignal.any([this.callbackAbort.signal, promptSignal]) : this.callbackAbort.signal;
+    return { signal, permissionTimeoutMs: Number.POSITIVE_INFINITY };
+  }
   handleMessage(msg) {
     if (msg.id !== void 0 && (msg.result !== void 0 || msg.error !== void 0)) {
       const pending = this.pending.get(msg.id);
@@ -1999,25 +2084,35 @@ var ACPSession = class _ACPSession {
       return;
     }
     if (msg.method === "session/request_permission") {
-      void handleAcpPermissionRequest(msg, this.permissionPolicy, this.responseSender());
+      handleAcpPermissionRequest(
+        msg,
+        this.permissionPolicy,
+        this.responseSender(),
+        this.callbackOptions()
+      ).catch(() => {
+      });
       return;
     }
     if (msg.method === "fs/read_text_file" || msg.method === "fs/write_text_file") {
-      void handleAcpFsRequest(
+      handleAcpFsRequest(
         msg,
         this.fileServer,
         this.permissionPolicy,
-        this.responseSender()
-      );
+        this.responseSender(),
+        this.callbackOptions()
+      ).catch(() => {
+      });
       return;
     }
     if (msg.method?.startsWith("terminal/")) {
-      void handleAcpTerminalRequest(
+      handleAcpTerminalRequest(
         msg,
         this.terminalServer,
         this.permissionPolicy,
-        this.responseSender()
-      );
+        this.responseSender(),
+        this.callbackOptions()
+      ).catch(() => {
+      });
       return;
     }
     if (isBestEffortAckMethod(msg.method)) {

package/dist/index.js

@@ -2445,30 +2445,34 @@ function captureToolCall(u, isNew, scratch, emitProgress) {
 }
 
 // src/client/acp-session-callbacks.ts
-async function handleAcpPermissionRequest(msg, permissionPolicy, sender) {
+var DEFAULT_PERMISSION_TIMEOUT_MS = 6e4;
+async function handleAcpPermissionRequest(msg, permissionPolicy, sender, callbackOptions = {}) {
   const id = msg.id;
   if (id === void 0) return;
   const params = msg.params;
   const toolCall = params?.toolCall;
-  const options = Array.isArray(params?.options) ? params.options : [];
+  const permissionOptions = Array.isArray(params?.options) ? params.options : [];
   if (!toolCall) {
     await sender.sendErrorResponse(id, -32602, "toolCall is required");
     return;
   }
-  const policyAbort = new AbortController();
   try {
-    const outcome = await permissionPolicy({
-      toolCall,
-      options,
-      signal: policyAbort.signal
-    });
+    const outcome = await runPermissionWithDeadline(
+      permissionPolicy,
+      {
+        toolCall,
+        options: permissionOptions
+      },
+      callbackOptions
+    );
     await sender.sendResult(id, { outcome });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    await sender.sendErrorResponse(id, -32603, `permission policy failed: ${message}`);
+    const code = isAbortLikeError(err) ? -32800 : -32603;
+    await sender.sendErrorResponse(id, code, `permission policy failed: ${message}`);
   }
 }
-async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender) {
+async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender, callbackOptions = {}) {
   const id = msg.id;
   if (id === void 0) return;
   const params = msg.params;
@@ -2477,14 +2481,23 @@ async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender) {
     return;
   }
   if (msg.method === "fs/write_text_file") {
-    const allowed = await authorizeAcpCallback(permissionPolicy, {
-      toolCallId: `acp-fs-write-${id}`,
-      title: `Write file: ${params.path}`,
-      kind: "edit",
-      rawInput: { path: params.path, sessionId: params.sessionId }
-    });
-    if (!allowed) {
-      await sender.sendErrorResponse(id, -32602, "filesystem write denied by permission policy");
+    const authorization = await authorizeAcpCallback(
+      permissionPolicy,
+      {
+        toolCallId: `acp-fs-write-${id}`,
+        title: `Write file: ${params.path}`,
+        kind: "edit",
+        rawInput: { path: params.path, sessionId: params.sessionId }
+      },
+      callbackOptions
+    );
+    if (authorization !== "allowed") {
+      const isCancelled = authorization === "cancelled";
+      await sender.sendErrorResponse(
+        id,
+        isCancelled ? -32800 : -32602,
+        isCancelled ? "filesystem write permission request cancelled or timed out" : "filesystem write denied by permission policy"
+      );
       return;
     }
   }
@@ -2509,26 +2522,35 @@ async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender) {
     await sender.sendErrorResponse(id, code, message);
   }
 }
-async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, sender) {
+async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, sender, callbackOptions = {}) {
   const id = msg.id;
   if (id === void 0) return;
   const params = msg.params ?? {};
   try {
     switch (msg.method) {
       case "terminal/create": {
-        const allowed = await authorizeAcpCallback(permissionPolicy, {
-          toolCallId: `acp-terminal-create-${id}`,
-          title: `Run command: ${String(params.command ?? "")} ${(Array.isArray(params.args) ? params.args : []).join(" ")}`.trim(),
-          kind: "execute",
-          rawInput: {
-            command: params.command,
-            args: params.args,
-            cwd: params.cwd,
-            sessionId: params.sessionId
-          }
-        });
-        if (!allowed) {
-          await sender.sendErrorResponse(id, -32602, "terminal create denied by permission policy");
+        const authorization = await authorizeAcpCallback(
+          permissionPolicy,
+          {
+            toolCallId: `acp-terminal-create-${id}`,
+            title: `Run command: ${String(params.command ?? "")} ${(Array.isArray(params.args) ? params.args : []).join(" ")}`.trim(),
+            kind: "execute",
+            rawInput: {
+              command: params.command,
+              args: params.args,
+              cwd: params.cwd,
+              sessionId: params.sessionId
+            }
+          },
+          callbackOptions
+        );
+        if (authorization !== "allowed") {
+          const isCancelled = authorization === "cancelled";
+          await sender.sendErrorResponse(
+            id,
+            isCancelled ? -32800 : -32602,
+            isCancelled ? "terminal create permission request cancelled or timed out" : "terminal create denied by permission policy"
+          );
           return;
         }
         const createOpts = {
@@ -2581,28 +2603,77 @@ async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, s
     await sender.sendErrorResponse(id, -32603, message);
   }
 }
-async function authorizeAcpCallback(permissionPolicy, partial) {
+async function authorizeAcpCallback(permissionPolicy, partial, callbackOptions) {
   try {
-    const outcome = await permissionPolicy({
-      toolCall: {
-        sessionUpdate: "tool_call_update",
-        toolCallId: partial.toolCallId,
-        title: partial.title,
-        kind: partial.kind,
-        status: "pending",
-        ...partial.rawInput ? { rawInput: partial.rawInput } : {}
+    const outcome = await runPermissionWithDeadline(
+      permissionPolicy,
+      {
+        toolCall: {
+          sessionUpdate: "tool_call_update",
+          toolCallId: partial.toolCallId,
+          title: partial.title,
+          kind: partial.kind,
+          status: "pending",
+          ...partial.rawInput ? { rawInput: partial.rawInput } : {}
+        },
+        options: [
+          { optionId: "allow", name: "Allow", kind: "allow_once" },
+          { optionId: "reject", name: "Reject", kind: "reject_once" }
+        ]
       },
-      options: [
-        { optionId: "allow", name: "Allow", kind: "allow_once" },
-        { optionId: "reject", name: "Reject", kind: "reject_once" }
-      ],
-      signal: new AbortController().signal
-    });
-    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always";
-  } catch {
-    return false;
+      callbackOptions
+    );
+    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always" ? "allowed" : "denied";
+  } catch (err) {
+    return isAbortLikeError(err) ? "cancelled" : "denied";
+  }
+}
+async function runPermissionWithDeadline(permissionPolicy, call, callbackOptions) {
+  const timeoutMs = resolvePermissionDeadline(callbackOptions.permissionTimeoutMs);
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  const timer = timeoutMs === null ? null : setTimeout(abort, timeoutMs);
+  let removeAbort;
+  if (callbackOptions.signal) {
+    if (callbackOptions.signal.aborted) {
+      abort();
+    } else {
+      callbackOptions.signal.addEventListener("abort", abort, { once: true });
+      removeAbort = () => callbackOptions.signal?.removeEventListener("abort", abort);
+    }
+  }
+  try {
+    return await Promise.race([
+      permissionPolicy({
+        toolCall: call.toolCall,
+        options: call.options,
+        signal: controller.signal
+      }),
+      rejectOnAbort(controller.signal)
+    ]);
+  } finally {
+    if (timer !== null) clearTimeout(timer);
+    removeAbort?.();
   }
 }
+function rejectOnAbort(signal) {
+  return new Promise((_, reject) => {
+    const rejectAbort = () => reject(new Error("permission request cancelled or timed out"));
+    if (signal.aborted) {
+      rejectAbort();
+      return;
+    }
+    signal.addEventListener("abort", rejectAbort, { once: true });
+  });
+}
+function isAbortLikeError(err) {
+  return err instanceof Error && /cancelled|canceled|timed out|aborted/i.test(err.message);
+}
+function resolvePermissionDeadline(value) {
+  if (value === Number.POSITIVE_INFINITY) return null;
+  if (value !== void 0 && Number.isFinite(value) && value > 0) return Math.trunc(value);
+  return DEFAULT_PERMISSION_TIMEOUT_MS;
+}
 
 // src/client/acp-message-routing.ts
 function isBestEffortAckMethod(method) {
@@ -2618,6 +2689,8 @@ var ACPSession = class _ACPSession {
   timeoutMs;
   opts;
   transportOff = null;
+  callbackAbort = new AbortController();
+  promptCallbackAbort = null;
   state = "init";
   sessionId = null;
   /** Pending outbound requests (initialize, session/new, session/prompt, etc). */
@@ -3132,8 +3205,10 @@ var ACPSession = class _ACPSession {
       this.timeoutMs
     );
     let cancelled = false;
+    this.promptCallbackAbort = new AbortController();
     const onAbort = () => {
       cancelled = true;
+      this.promptCallbackAbort?.abort();
       this.transport.send({
         jsonrpc: "2.0",
         method: "session/cancel",
@@ -3156,6 +3231,8 @@ var ACPSession = class _ACPSession {
       throw new ACPSessionError("prompt_failed", `session/prompt failed: ${msg}`, err);
     } finally {
       signal.removeEventListener("abort", onAbort);
+      this.promptCallbackAbort?.abort();
+      this.promptCallbackAbort = null;
       this.progressHandler = null;
     }
     this.state = "done";
@@ -3222,6 +3299,9 @@ var ACPSession = class _ACPSession {
     if (this.closed) return;
     this.closed = true;
     this.state = "closed";
+    this.callbackAbort.abort();
+    this.promptCallbackAbort?.abort();
+    this.promptCallbackAbort = null;
     this.terminalServer.releaseAll();
     if (this.sessionId && this.agentCapabilities.sessionCapabilities?.close) {
       try {
@@ -3317,6 +3397,11 @@ var ACPSession = class _ACPSession {
       sendErrorResponse: (id, code, message) => this.sendErrorResponse(id, code, message)
     };
   }
+  callbackOptions() {
+    const promptSignal = this.promptCallbackAbort?.signal;
+    const signal = promptSignal ? AbortSignal.any([this.callbackAbort.signal, promptSignal]) : this.callbackAbort.signal;
+    return { signal, permissionTimeoutMs: Number.POSITIVE_INFINITY };
+  }
   handleMessage(msg) {
     if (msg.id !== void 0 && (msg.result !== void 0 || msg.error !== void 0)) {
       const pending = this.pending.get(msg.id);
@@ -3335,25 +3420,35 @@ var ACPSession = class _ACPSession {
       return;
     }
     if (msg.method === "session/request_permission") {
-      void handleAcpPermissionRequest(msg, this.permissionPolicy, this.responseSender());
+      handleAcpPermissionRequest(
+        msg,
+        this.permissionPolicy,
+        this.responseSender(),
+        this.callbackOptions()
+      ).catch(() => {
+      });
       return;
     }
     if (msg.method === "fs/read_text_file" || msg.method === "fs/write_text_file") {
-      void handleAcpFsRequest(
+      handleAcpFsRequest(
         msg,
         this.fileServer,
         this.permissionPolicy,
-        this.responseSender()
-      );
+        this.responseSender(),
+        this.callbackOptions()
+      ).catch(() => {
+      });
       return;
     }
     if (msg.method?.startsWith("terminal/")) {
-      void handleAcpTerminalRequest(
+      handleAcpTerminalRequest(
         msg,
         this.terminalServer,
         this.permissionPolicy,
-        this.responseSender()
-      );
+        this.responseSender(),
+        this.callbackOptions()
+      ).catch(() => {
+      });
       return;
     }
     if (isBestEffortAckMethod(msg.method)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/acp",
-  "version": "0.298.0",
+  "version": "0.298.2",
   "license": "MIT",
   "description": "ACP (Agent Client Protocol) integration for WrongStack — client + agent support",
   "keywords": [
@@ -52,10 +52,10 @@
   ],
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
-    "@wrongstack/core": "0.298.0"
+    "@wrongstack/core": "0.298.2"
   },
   "devDependencies": {
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.1.2",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },