@agen-ai/provider-acp 0.4.0 → 0.4.1

package/dist/permissions/mapping.js

@@ -0,0 +1,99 @@
+import { parseAgentApprovalOptionId } from "@agen-ai/agent-protocol";
+import { AcpProviderSessionError } from "../session/errors.js";
+import { displayText, nativeObject, nativeString } from "../session/native.js";
+const GROK_EDIT_MENU = {
+  toolKind: "edit",
+  options: [
+    { optionId: "allow-edits-session", kind: "allow_always" },
+    { optionId: "allow-once", kind: "allow_once" },
+    { optionId: "reject-once", kind: "reject_once" }
+  ]
+};
+function unsupportedConsequence() {
+  throw new AcpProviderSessionError("acp_permission_consequence_unsupported", "The selected ACP permission mapping does not represent this complete native menu.");
+}
+function readNativeOptions(params) {
+  if (!Array.isArray(params.options) || params.options.length < 1 || params.options.length > 16) {
+    throw new AcpProviderSessionError("acp_permission_options_invalid", "ACP permission menus require between one and sixteen options.");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  return params.options.map((value) => {
+    const option = nativeObject(value, "permission option");
+    const optionId = nativeString(option.optionId, "permission option identity");
+    if (!optionId || optionId.length > 256 || optionId !== optionId.trim() || /[\u0000-\u001f\u007f-\u009f]/u.test(optionId)) {
+      throw new AcpProviderSessionError("acp_permission_options_invalid", "ACP permission option identities must be bounded canonical strings.");
+    }
+    if (ids.has(optionId)) throw new AcpProviderSessionError("acp_permission_option_duplicate", "ACP repeated a permission option identity.");
+    ids.add(optionId);
+    const kind = option.kind;
+    if (kind !== "allow_once" && kind !== "reject_once" && kind !== "allow_always" && kind !== "reject_always") {
+      throw new AcpProviderSessionError("acp_permission_options_invalid", "ACP permission option kind is unsupported.");
+    }
+    return { optionId, kind, source: option };
+  });
+}
+function matchesMenu(menu, tool, options) {
+  return menu.toolKind === tool.kind && menu.options.length === options.length && menu.options.every((option, index) => option.optionId === options[index]?.optionId && option.kind === options[index]?.kind);
+}
+function assertCompleteChoiceFields(params, options) {
+  if (Object.keys(params).some((key) => !["sessionId", "toolCall", "options"].includes(key)) || options.some((option) => Object.keys(option.source).some((key) => !["optionId", "name", "kind"].includes(key)))) {
+    unsupportedConsequence();
+  }
+}
+function qualifiedGrokEdit(tool, options) {
+  const input = tool.rawInput;
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return false;
+  return matchesMenu(GROK_EDIT_MENU, tool, options) && Object.keys(input).length === 5 && typeof input.file_path === "string" && input.file_path.length > 0 && typeof input.old_string === "string" && typeof input.new_string === "string" && input.variant === "SearchReplace" && input.replace_all === false;
+}
+function mapAcpPermissionOptions(selection, params) {
+  const native = readNativeOptions(params);
+  const tool = nativeObject(params.toolCall, "permission tool");
+  let complete = false;
+  let fallback = false;
+  if (selection.mapping === "declared-complete-consequences-v1") {
+    assertCompleteChoiceFields(params, native);
+    if (!selection.menus.some((menu) => matchesMenu(menu, tool, native))) unsupportedConsequence();
+    complete = true;
+  } else if (selection.mapping === "grok-build-1.0.50-edit-remembrance-v1") {
+    if (tool.kind === "edit") {
+      assertCompleteChoiceFields(params, native);
+      if (!qualifiedGrokEdit(tool, native)) unsupportedConsequence();
+      complete = true;
+    } else fallback = true;
+  }
+  const nativeOptions = /* @__PURE__ */ new Map();
+  const options = [];
+  for (const [index, option] of native.entries()) {
+    const remembered = option.kind === "allow_always" || option.kind === "reject_always";
+    if (remembered && !complete) continue;
+    const approved = option.kind === "allow_once" || option.kind === "allow_always";
+    const optionId = parseAgentApprovalOptionId(`acp:option:${index + 1}`);
+    nativeOptions.set(optionId, option.optionId);
+    options.push({
+      optionId,
+      label: remembered ? approved ? "Allow and remember" : "Deny and remember" : displayText(option.source.name, approved ? "Allow once" : "Reject once"),
+      decision: approved ? "approved" : "denied",
+      consequence: remembered ? {
+        kind: "provider_managed_remembrance",
+        duration: { kind: "unknown" },
+        applicability: { kind: "unknown" },
+        explanation: "The provider is asked to remember this decision. Duration and future matching are unspecified. Delivery does not establish successful persistence or revocation."
+      } : { kind: "scoped", persistence: "once", scope: { kind: "exact_action" } }
+    });
+  }
+  if (options.length === 0) {
+    if (fallback) unsupportedConsequence();
+    throw new AcpProviderSessionError("acp_permission_persistence_unsupported", "ACP offered no supported once-only permission choice.");
+  }
+  return {
+    options,
+    nativeOptions,
+    ...fallback ? { warning: {
+      code: "acp_permission_remembrance_unmapped",
+      message: "The selected ACP profile does not map remembered choices for this action. Only once-only choices are available."
+    } } : {}
+  };
+}
+export {
+  mapAcpPermissionOptions
+};

package/dist/permissions/selection.d.ts

@@ -0,0 +1,5 @@
+import type { AgentApprovalCapability } from '@agen-ai/agent-protocol';
+import type { AcpPermissionMappingSelection } from './contracts.js';
+export declare function resolveAcpPermissionMapping(value: unknown): AcpPermissionMappingSelection;
+export declare function acpPermissionCapability(selection: AcpPermissionMappingSelection): AgentApprovalCapability;
+//# sourceMappingURL=selection.d.ts.map

package/dist/permissions/selection.js

@@ -0,0 +1,96 @@
+function selectionObject(value, keys) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || Reflect.ownKeys(value).some((key) => typeof key !== "string" || !keys.includes(key))) {
+    throw new TypeError("ACP permission mapping selections must contain only their declared fields.");
+  }
+  return value;
+}
+function canonicalText(value, maximum, identity = false) {
+  if (typeof value !== "string" || !value || value !== value.trim() || value.length > maximum || (identity ? /[\p{Cc}\p{Cf}]/u : /[\u0000-\u001f\u007f-\u009f]/u).test(value)) {
+    throw new TypeError("ACP permission mapping identities must be bounded canonical strings.");
+  }
+  return value;
+}
+function optionKind(value) {
+  switch (value) {
+    case "allow_once":
+    case "reject_once":
+    case "allow_always":
+    case "reject_always":
+      return value;
+    default:
+      throw new TypeError("ACP permission option kind is invalid.");
+  }
+}
+function toolKind(value) {
+  switch (value) {
+    case "read":
+    case "edit":
+    case "delete":
+    case "move":
+    case "search":
+    case "execute":
+    case "think":
+    case "fetch":
+    case "switch_mode":
+    case "other":
+      return value;
+    default:
+      throw new TypeError("ACP permission tool kind is invalid.");
+  }
+}
+function boundedNonempty(value, parse) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > 16) {
+    throw new TypeError("ACP permission declarations require between one and sixteen entries.");
+  }
+  const first = parse(value[0]);
+  return Object.freeze([first, ...Array.from(value.slice(1), parse)]);
+}
+function menuSignature(value) {
+  const menu = selectionObject(value, ["toolKind", "options"]);
+  const ids = /* @__PURE__ */ new Set();
+  const options = boundedNonempty(menu.options, (entry) => {
+    const option = selectionObject(entry, ["optionId", "kind"]);
+    const optionId = canonicalText(option.optionId, 256);
+    if (ids.has(optionId)) throw new TypeError("ACP declared permission option identities must be unique.");
+    ids.add(optionId);
+    return Object.freeze({ optionId, kind: optionKind(option.kind) });
+  });
+  return Object.freeze({ toolKind: toolKind(menu.toolKind), options });
+}
+function resolveAcpPermissionMapping(value) {
+  if (value === void 0) return Object.freeze({ mapping: "once-only-v1" });
+  const selection = selectionObject(value, ["mapping", "agentInfo", "menus"]);
+  if (selection.mapping === "once-only-v1" || selection.mapping === "grok-build-1.0.50-edit-remembrance-v1") {
+    selectionObject(value, ["mapping"]);
+    return Object.freeze({ mapping: selection.mapping });
+  }
+  if (selection.mapping !== "declared-complete-consequences-v1") throw new TypeError("ACP permission mapping is invalid.");
+  const info = selectionObject(selection.agentInfo, ["name", "version"]);
+  const agentInfo = Object.freeze({ name: canonicalText(info.name, 256, true), version: canonicalText(info.version, 160, true) });
+  const signatures = /* @__PURE__ */ new Set();
+  const menus = boundedNonempty(selection.menus, (entry) => {
+    const menu = menuSignature(entry);
+    const signature = JSON.stringify(menu);
+    if (signatures.has(signature)) throw new TypeError("ACP declared permission menus must be unique.");
+    signatures.add(signature);
+    return menu;
+  });
+  return Object.freeze({ mapping: selection.mapping, agentInfo, menus });
+}
+function acpPermissionCapability(selection) {
+  const once = { persistence: "once", scopeKinds: ["exact_action"] };
+  if (selection.mapping === "once-only-v1") {
+    return { kind: "supported", modes: [once], providerManagedRemembrance: false };
+  }
+  if (selection.mapping === "grok-build-1.0.50-edit-remembrance-v1") {
+    return { kind: "supported", modes: [once], providerManagedRemembrance: true };
+  }
+  const options = selection.menus.flatMap((menu) => menu.options);
+  const precise = options.some((option) => option.kind === "allow_once" || option.kind === "reject_once");
+  const remembered = options.some((option) => option.kind === "allow_always" || option.kind === "reject_always");
+  return remembered ? { kind: "supported", modes: precise ? [once] : [], providerManagedRemembrance: true } : { kind: "supported", modes: [once], providerManagedRemembrance: false };
+}
+export {
+  acpPermissionCapability,
+  resolveAcpPermissionMapping
+};

package/dist/session/create.d.ts

@@ -2,6 +2,7 @@ import type { AgentCapabilities, AgentSessionBinding } from '@agen-ai/agent-prot
 import { type AgentProviderCreateSessionInput, type AgentProviderResumeSessionInput, type AgentProviderSession, type AgentProviderSessionContext } from '@agen-ai/agent-runtime';
 import type { AcpInitializedConnection } from '../connection/contracts.js';
 import type { AcpProviderLimits } from '../limits.js';
+import type { AcpPermissionMappingSelection } from '../permissions/contracts.js';
 export interface CreateAcpProviderSessionInput {
     readonly context: AgentProviderCreateSessionInput | AgentProviderResumeSessionInput;
     readonly openingInput: AgentProviderSessionContext;
@@ -13,9 +14,14 @@ export interface CreateAcpProviderSessionInput {
     readonly connection: AcpInitializedConnection;
     readonly capabilities: AgentCapabilities;
     readonly limits: AcpProviderLimits;
+    readonly permissionMapping: AcpPermissionMappingSelection;
     readonly now: () => string;
     readonly onClosed: () => void;
     readonly closeResources: () => Promise<void>;
 }
-export declare function createAcpProviderSession(input: CreateAcpProviderSessionInput): Promise<AgentProviderSession>;
+export interface AcpOpenedProviderSession {
+    readonly session: AgentProviderSession;
+    readonly cleanup: () => Promise<void>;
+}
+export declare function createAcpProviderSession(input: CreateAcpProviderSessionInput): Promise<AcpOpenedProviderSession>;
 //# sourceMappingURL=create.d.ts.map

package/dist/session/create.js

@@ -6,7 +6,9 @@ async function createAcpProviderSession(input) {
   let state;
   try {
     state = new SessionState(input);
-    return await state.open();
+    const session = await state.open();
+    const owner = state;
+    return Object.freeze({ session, cleanup: () => owner.close() });
   } catch (error) {
     const cleanup = () => state ? state.close() : input.closeResources();
     try {

package/dist/session/errors.js

@@ -4,7 +4,6 @@ class AcpProviderSessionError extends Error {
     this.reasonCode = reasonCode;
     this.name = "AcpProviderSessionError";
   }
-  reasonCode;
 }
 function sessionError(error) {
   return error instanceof Error ? error : new AcpProviderSessionError("acp_session_failed", "The ACP session failed.");

package/dist/session/mapping.d.ts

@@ -2,9 +2,14 @@ import type { AcpJsonObject } from '@agen-ai/acp-transport';
 import { type AgentApprovalRequest, type AgentItemId, type AgentSessionId, type AgentTurnCompletedPayload, type AgentTurnId } from '@agen-ai/agent-protocol';
 import { type AgentProviderOutput } from '@agen-ai/agent-runtime';
 import type { SessionQueue } from './queue.js';
+import type { AcpPermissionMappingSelection } from '../permissions/contracts.js';
 export interface MappedPermission {
     readonly request: AgentApprovalRequest;
     readonly nativeOptions: ReadonlyMap<string, string>;
+    readonly warning?: Readonly<{
+        code: string;
+        message: string;
+    }>;
 }
 export declare class TurnMapping {
     private readonly context;
@@ -17,6 +22,7 @@ export declare class TurnMapping {
         readonly sessionId: AgentSessionId;
         readonly turnId: AgentTurnId;
         readonly workingDirectory: string;
+        readonly permissionMapping: AcpPermissionMappingSelection;
         readonly now: () => string;
         readonly nextItemId: () => number;
         readonly nextRequestId: () => number;

package/dist/session/mapping.js

@@ -1,5 +1,4 @@
 import {
-  parseAgentApprovalOptionId,
   parseAgentApprovalRequest,
   parseAgentItemId,
   parseAgentRequestId
@@ -9,11 +8,11 @@ import { AcpProviderSessionError } from "./errors.js";
 import { displayText, nativeObject, nativeString } from "./native.js";
 import { acpPlanSteps } from "./plans.js";
 import { acpToolDiff } from "./files.js";
+import { mapAcpPermissionOptions } from "../permissions/mapping.js";
 class TurnMapping {
   constructor(context) {
     this.context = context;
   }
-  context;
   tools = /* @__PURE__ */ new Map();
   messages = /* @__PURE__ */ new Map();
   files = /* @__PURE__ */ new Map();
@@ -21,7 +20,7 @@ class TurnMapping {
   planRevision = 0;
   event(type, payload) {
     return createAgentEventOutput({
-      protocolVersion: 10,
+      protocolVersion: 11,
       sessionId: this.context.sessionId,
       turnId: this.context.turnId,
       occurredAt: this.context.now(),
@@ -168,28 +167,7 @@ class TurnMapping {
   permission(params, itemId) {
     const tool = nativeObject(params.toolCall, "permission tool");
     const title = displayText(tool.title, "Agent tool");
-    if (!Array.isArray(params.options)) throw new AcpProviderSessionError("acp_permission_options_invalid", "ACP permission options must be an array.");
-    const nativeOptions = /* @__PURE__ */ new Map();
-    const options = params.options.flatMap((value, index) => {
-      const option = nativeObject(value, "permission option");
-      if (option.kind !== "allow_once" && option.kind !== "reject_once") return [];
-      const optionId = parseAgentApprovalOptionId(`acp:option:${index + 1}`);
-      const nativeId = nativeString(option.optionId, "permission option identity");
-      if ([...nativeOptions.values()].includes(nativeId)) {
-        throw new AcpProviderSessionError("acp_permission_option_duplicate", "ACP repeated a permission option identity.");
-      }
-      nativeOptions.set(optionId, nativeId);
-      return [{
-        optionId,
-        label: displayText(option.name, option.kind === "allow_once" ? "Allow once" : "Reject once"),
-        decision: option.kind === "allow_once" ? "approved" : "denied",
-        persistence: "once",
-        scope: { kind: "exact_action" }
-      }];
-    });
-    if (options.length === 0) {
-      throw new AcpProviderSessionError("acp_permission_persistence_unsupported", "ACP offered no supported once-only permission choice.");
-    }
+    const { options, nativeOptions, warning } = mapAcpPermissionOptions(this.context.permissionMapping, params);
     return {
       request: parseAgentApprovalRequest({
         requestKind: "approval",
@@ -198,7 +176,8 @@ class TurnMapping {
         subject: { kind: "tool", title, itemId },
         options
       }),
-      nativeOptions
+      nativeOptions,
+      ...warning ? { warning } : {}
     };
   }
   *complete(payload) {

package/dist/session/opening.d.ts

@@ -18,5 +18,6 @@ export declare function openAcpNativeSession(input: CreateAcpProviderSessionInpu
     readonly replay: AcpHistoryReplay;
     readonly bind: (binding: AgentSessionBinding) => void;
     readonly observeSetup: (result: AcpJsonObject) => void;
+    readonly completeOpeningResponse?: () => void;
 }): Promise<void>;
 //# sourceMappingURL=opening.d.ts.map

package/dist/session/opening.js

@@ -18,7 +18,6 @@ class AcpHistoryReplay {
   constructor(limits) {
     this.limits = limits;
   }
-  limits;
   active = false;
   messages = 0;
   bytes = 0;
@@ -35,6 +34,7 @@ async function openAcpNativeSession(input, hooks) {
   const client = acpSessionControlClient(input);
   const operations = createAcpStandardSessionOperations(client);
   const resumed = input.resume;
+  const sessionInteractions = input.connection.sessionInteractions;
   if (resumed) {
     hooks.bind(resumed.binding);
     hooks.replay.active = resumed.method === "session/load";
@@ -43,6 +43,7 @@ async function openAcpNativeSession(input, hooks) {
   const options = {
     ...input.context.signal === void 0 ? {} : { signal: input.context.signal },
     timeoutMs: input.limits.initializationTimeoutMs,
+    ...sessionInteractions ? { onRequestDispatch: () => sessionInteractions.onOpeningDispatched() } : {},
     onResponseReceived: (response) => {
       hooks.replay.active = false;
       if (response.kind === "error") return;
@@ -54,6 +55,7 @@ async function openAcpNativeSession(input, hooks) {
         input.context.onBindingCreated(binding);
       }
       hooks.observeSetup(result);
+      hooks.completeOpeningResponse?.();
     }
   };
   if (resumed?.method === "session/resume") await client.request("session/resume", { ...params, sessionId: resumed.binding.conversationId }, options);

package/dist/session/queue.js

@@ -13,7 +13,6 @@ class SessionQueue {
   constructor(limits) {
     this.limits = limits;
   }
-  limits;
   entries = [];
   retained = /* @__PURE__ */ new Map();
   wake;

package/dist/session/requests/forms.js

@@ -193,8 +193,6 @@ class AcpFormFlow {
       }]
     });
   }
-  form;
-  nextRequestId;
   phase = "intent";
   request;
   resolve(resolution) {

package/dist/session/requests/pending.js

@@ -8,7 +8,6 @@ class PendingSessionRequests {
   constructor(input) {
     this.input = input;
   }
-  input;
   pending = /* @__PURE__ */ new Set();
   get size() {
     return this.pending.size;

package/dist/session/resources.js

@@ -8,7 +8,6 @@ class AcpSessionResources {
   constructor(input) {
     this.input = input;
   }
-  input;
   lifetime = new AbortController();
   acquisition;
   releaseMcp;
@@ -64,9 +63,12 @@ class AcpSessionResources {
   close() {
     if (this.closed) return Promise.resolve();
     this.lifetime.abort(new DOMException("ACP session resources were closed.", "AbortError"));
+    const nativeCleanup = this.nativeClosed ? Promise.resolve() : this.input.connection.close();
+    void nativeCleanup.catch(() => {
+    });
     this.cleanup ??= Promise.resolve().then(async () => {
       if (!this.nativeClosed) {
-        await this.input.connection.close();
+        await (this.input.connection.execution?.joinCleanup() ?? nativeCleanup);
         this.nativeClosed = true;
       }
       if (this.acquisition) {
@@ -82,7 +84,7 @@ class AcpSessionResources {
       this.cleanup = void 0;
     });
     const deadline = hostDeadline(new AbortController().signal, this.input.limits.hostOperationTimeoutMs);
-    return awaitHost(this.cleanup, deadline.signal).finally(() => {
+    return awaitHost(Promise.all([nativeCleanup, this.cleanup]).then(() => void 0), deadline.signal).finally(() => {
       deadline.close();
     });
   }

package/dist/session/session.d.ts

@@ -15,6 +15,8 @@ export declare class SessionState {
     private nativeSessionId;
     private turn;
     private failure;
+    private failureObserved;
+    private cleanupFailure;
     private closed;
     private closePromise;
     private itemSequence;
@@ -38,6 +40,7 @@ export declare class SessionState {
     private resolveRequest;
     private cancelNative;
     interruptTurn(input: AgentProviderInterruptTurnInput): Promise<AgentProviderTurnInterruptionResult>;
-    close(): Promise<void>;
+    close(observeFailure?: boolean): Promise<void>;
+    private observeFailure;
 }
 //# sourceMappingURL=session.d.ts.map

package/dist/session/session.js

@@ -51,7 +51,6 @@ class SessionState {
     input.connection.stopped.addEventListener("abort", this.onStopped, { once: true });
     if (input.connection.stopped.aborted) this.onStopped();
   }
-  input;
   queue;
   operations;
   requests;
@@ -65,6 +64,8 @@ class SessionState {
   nativeSessionId;
   turn;
   failure;
+  failureObserved = false;
+  cleanupFailure;
   closed = false;
   closePromise;
   itemSequence = 0;
@@ -72,11 +73,13 @@ class SessionState {
   async open() {
     this.requireUsable();
     throwIfAgentOperationAborted(this.input.context.signal);
+    const sessionInteractions = this.input.connection.sessionInteractions;
     await openAcpNativeSession(this.input, {
       replay: this.replay,
       bind: (binding2) => {
         this.binding = binding2;
         this.nativeSessionId = binding2.conversationId;
+        this.input.connection.sessionInteractions?.bindNativeSession(binding2.conversationId);
         this.bindHostSession();
       },
       observeSetup: (result) => {
@@ -91,7 +94,10 @@ class SessionState {
           }
         }
         this.configuration.observeSetup(result);
-      }
+      },
+      ...sessionInteractions ? {
+        completeOpeningResponse: () => sessionInteractions.completeOpeningResponse()
+      } : {}
     });
     this.requireUsable();
     if (!this.binding) throw new AcpProviderSessionError("acp_binding_missing", "ACP did not return a session binding.");
@@ -108,7 +114,7 @@ class SessionState {
       environment: this.environment.port,
       collaboration: Object.freeze({ kind: "unsupported" }),
       generatedResources: Object.freeze({ kind: "unsupported" }),
-      close: async () => this.close()
+      close: async () => this.close(true)
     });
   }
   requireUsable() {
@@ -123,13 +129,16 @@ class SessionState {
   fail(error) {
     if (this.failure) return;
     this.failure = error;
+    this.input.connection.sessionInteractions?.stop({ kind: "failed", cause: error });
     this.turn?.hostInteractions.abort(error);
     this.queue.fail(error);
     this.requests.cancelAll();
     this.environment.close();
     this.turn?.settled.reject(error);
     this.clearTurnTimers();
-    void this.input.connection.close().catch(() => void 0);
+    void this.input.connection.close().catch((cause) => {
+      this.cleanupFailure = cause;
+    });
   }
   admitNotification(context) {
     this.requireUsable();
@@ -204,6 +213,7 @@ class SessionState {
         sessionId: this.input.context.sessionId,
         turnId: input.turnId,
         workingDirectory: this.input.context.workingDirectory,
+        permissionMapping: this.input.permissionMapping,
         now: this.input.now,
         nextItemId: () => ++this.itemSequence,
         nextRequestId: () => ++this.requestSequence,
@@ -330,10 +340,19 @@ class SessionState {
             if (turn.terminal) return "terminal";
             yield* this.emit(next.value);
             if (turn.terminal) return "terminal";
+            if (request.answered || turn.cancelReason) break;
             next = mappedTool.next();
           }
+          if (!next.done) {
+            entry.release();
+            continue;
+          }
           const permission = turn.mapping.permission(request.params, next.value);
           request.mapped = { kind: "permission", permission, request: permission.request };
+          if (permission.warning) {
+            yield* this.emit(turn.mapping.event("runtime.warning", permission.warning));
+            if (turn.terminal) return "terminal";
+          }
         } else {
           if (request.params.toolCallId != null && !turn.mapping.hasTool(nativeString(request.params.toolCallId, "elicitation tool identity"))) {
             this.requests.reject(request, new AcpRpcHandlerError(-32602, "ACP form tool identity was not observed in this turn."));
@@ -346,6 +365,10 @@ class SessionState {
           const flow = new AcpFormFlow(request.form, () => parseAgentRequestId(`acp:request:${++this.requestSequence}`));
           request.mapped = { kind: "form", flow, request: flow.request };
         }
+        if (request.answered || turn.cancelReason) {
+          entry.release();
+          continue;
+        }
         turn.waiting = request;
         yield* this.offerRequest(turn, request);
         if (turn.terminal) return "terminal";
@@ -451,27 +474,46 @@ class SessionState {
       throw error;
     }
   }
-  async close() {
-    if (this.closePromise) return this.closePromise;
-    this.closed = true;
-    this.closePromise = Promise.resolve().then(async () => {
-      await this.input.closeResources();
-      this.input.onClosed();
-    }).catch((error2) => {
-      this.closePromise = void 0;
-      throw error2;
-    });
-    const error = new AcpProviderSessionError("acp_session_closed", "The ACP session is closed.");
-    this.turn?.hostInteractions.abort(error);
-    this.queue.fail(error);
-    this.requests.cancelAll();
-    this.turn?.settled.reject(error);
-    this.clearTurnTimers();
-    this.environment.close();
-    this.turn?.mapping.release();
-    this.detach();
-    this.input.connection.stopped.removeEventListener("abort", this.onStopped);
-    return this.closePromise;
+  async close(observeFailure = false) {
+    if (!this.closePromise) {
+      this.closed = true;
+      this.closePromise = Promise.resolve().then(async () => {
+        await this.input.closeResources();
+        this.input.onClosed();
+      }).catch((error2) => {
+        this.cleanupFailure = error2;
+        this.closePromise = void 0;
+        throw error2;
+      });
+      this.input.connection.sessionInteractions?.stop({ kind: "session_closed" });
+      const error = new AcpProviderSessionError("acp_session_closed", "The ACP session is closed.");
+      this.turn?.hostInteractions.abort(error);
+      this.queue.fail(error);
+      this.requests.cancelAll();
+      this.turn?.settled.reject(error);
+      this.clearTurnTimers();
+      this.environment.close();
+      this.turn?.mapping.release();
+      this.detach();
+      this.input.connection.stopped.removeEventListener("abort", this.onStopped);
+    }
+    try {
+      await this.closePromise;
+    } catch (cause) {
+      const failure2 = this.observeFailure(observeFailure);
+      if (failure2) throw new AggregateError([failure2, cause], "ACP session failure and cleanup remain owned.");
+      throw cause;
+    }
+    const failure = this.observeFailure(observeFailure);
+    if (failure) {
+      if (this.cleanupFailure !== void 0) throw new AggregateError([failure, this.cleanupFailure], "ACP session failed before cleanup completed.");
+      throw failure;
+    }
+  }
+  observeFailure(explicit) {
+    if (!explicit || !this.input.connection.sessionInteractions || !this.failure || this.failureObserved) return void 0;
+    this.failureObserved = true;
+    return this.failure;
   }
 }
 export {