@agen-ai/provider-acp 0.4.0 → 0.4.2

package/dist/session/descendants.js

@@ -0,0 +1,97 @@
+import { GROK_QUEUE_METHOD, GROK_SESSION_NOTIFICATION_METHOD } from "../sessionInteractions/grokPlanReview.js";
+import { AcpProviderSessionError } from "./errors.js";
+import { nativeIdentity, nativeObject, nativeString } from "./native.js";
+class GrokDescendantObservations {
+  constructor(input) {
+    this.input = input;
+  }
+  bySession = /* @__PURE__ */ new Map();
+  bySubagent = /* @__PURE__ */ new Map();
+  /** Returns true only when this notification is wholly owned by the observation scope. */
+  admit(context, historical) {
+    const params = nativeObject(context.params, "descendant notification");
+    const meta = params._meta === void 0 ? void 0 : nativeObject(params._meta, "descendant metadata");
+    if (meta?.isReplay !== void 0 && typeof meta.isReplay !== "boolean") throw new AcpProviderSessionError(
+      "acp_descendant_replay_invalid",
+      "The selected native replay marker must be a boolean."
+    );
+    const replay = historical || meta?.isReplay === true;
+    const root = this.input.rootSessionId();
+    if (params.sessionId === root && root !== void 0) {
+      if (context.method !== GROK_SESSION_NOTIFICATION_METHOD) return false;
+      const update = nativeObject(params.update, "descendant session update");
+      if (update.sessionUpdate === "subagent_spawned") this.spawn(update, root, replay);
+      else if (update.sessionUpdate === "subagent_finished") {
+        const child = this.bySession.get(nativeIdentity(update.child_session_id, "finished child session identity"));
+        if (child?.origin === "live" && !replay) this.input.withdrawals.finish(child.identity, update);
+      } else return false;
+      this.input.observeHistory(params);
+      return true;
+    }
+    if (root === void 0) return false;
+    const sessionId = nativeIdentity(params.sessionId, "child session identity");
+    const observation = this.bySession.get(sessionId);
+    if (!observation || observation.origin === "historical" && !replay) return false;
+    if (context.method === GROK_QUEUE_METHOD) {
+      this.validateQueue(params);
+    } else {
+      const update = nativeObject(params.update, "child session update");
+      const kind = nativeString(update.sessionUpdate, "child session update kind");
+      if (kind === "subagent_spawned") throw new AcpProviderSessionError(
+        "acp_descendant_nested_unsupported",
+        "The selected native mapping does not admit nested descendant relationships."
+      );
+      if (context.method === GROK_SESSION_NOTIFICATION_METHOD && !replay) this.input.withdrawals.observe(observation.identity, update);
+    }
+    this.input.observeHistory(params);
+    return true;
+  }
+  spawn(update, root, historical) {
+    const value = Object.freeze({
+      parentSessionId: nativeIdentity(update.parent_session_id, "parent session identity"),
+      childSessionId: nativeIdentity(update.child_session_id, "child session identity"),
+      subagentId: nativeIdentity(update.subagent_id, "subagent identity"),
+      ...update.attempt_id === void 0 ? {} : { attemptId: nativeIdentity(update.attempt_id, "attempt identity") },
+      ...update.parent_prompt_id === void 0 ? {} : { parentPromptId: nativeIdentity(update.parent_prompt_id, "parent prompt identity") }
+    });
+    if (value.parentSessionId !== root || value.childSessionId === root || value.subagentId === root) throw new AcpProviderSessionError(
+      "acp_descendant_identity_invalid",
+      "The selected native spawn does not identify a direct child of the bound root."
+    );
+    const prior = this.bySession.get(value.childSessionId) ?? this.bySubagent.get(value.subagentId);
+    if (prior) {
+      if (JSON.stringify(prior.identity) !== JSON.stringify(value) || prior.origin === "historical" && !historical) throw new AcpProviderSessionError(
+        "acp_descendant_identity_conflict",
+        "The selected native descendant identity cannot be rebound or revived."
+      );
+      return;
+    }
+    if (!historical && !this.input.activeTurn()) throw new AcpProviderSessionError(
+      "acp_descendant_without_prompt",
+      "A live native descendant requires active owned parent work."
+    );
+    const observation = {
+      identity: value,
+      origin: historical ? "historical" : "live",
+      release: this.input.reserveState(value)
+    };
+    this.bySession.set(value.childSessionId, observation);
+    this.bySubagent.set(value.subagentId, observation);
+  }
+  validateQueue(params) {
+    if (!Array.isArray(params.entries) || params.entries.length > 256) throw new AcpProviderSessionError(
+      "acp_descendant_queue_invalid",
+      "The selected native child queue is invalid."
+    );
+    for (const entry of params.entries) nativeIdentity(nativeObject(entry, "child queue entry").id, "child queue prompt identity");
+    if (params.runningPromptId != null) nativeIdentity(params.runningPromptId, "running child prompt identity");
+  }
+  stop() {
+    for (const observation of this.bySession.values()) observation.release();
+    this.bySession.clear();
+    this.bySubagent.clear();
+  }
+}
+export {
+  GrokDescendantObservations
+};

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: 12,
       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/native.d.ts

@@ -1,6 +1,7 @@
 import type { AcpJsonObject, AcpJsonValue } from '@agen-ai/acp-transport';
 export declare function nativeObject(value: AcpJsonValue | undefined, field: string): AcpJsonObject;
 export declare function nativeString(value: AcpJsonValue | undefined, field: string): string;
+export declare function nativeIdentity(value: unknown, field: string): string;
 export declare function displayText(value: AcpJsonValue | undefined, fallback: string, limit?: number): string;
 export declare function nativeBytes(value: unknown): number;
 export declare const SESSION_METADATA_UPDATES: Set<string>;

package/dist/session/native.js

@@ -11,6 +11,13 @@ function nativeString(value, field) {
   }
   return value;
 }
+function nativeIdentity(value, field) {
+  if (typeof value !== "string" || !value || value !== value.trim() || Buffer.byteLength(value, "utf8") > 256 || /[\p{Cc}\p{Cf}]/u.test(value)) throw new AcpProviderSessionError(
+    "acp_descendant_identity_invalid",
+    `The selected native ${field} is invalid.`
+  );
+  return value;
+}
 function displayText(value, fallback, limit = 120) {
   const text = typeof value === "string" ? value.trim() : "";
   return (text || fallback).slice(0, limit).trimEnd();
@@ -29,6 +36,7 @@ export {
   SESSION_METADATA_UPDATES,
   displayText,
   nativeBytes,
+  nativeIdentity,
   nativeObject,
   nativeString
 };

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.context.interactions ? input.connection.sessionInteractions : void 0;
   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/elicitation.d.ts

@@ -9,6 +9,6 @@ export declare function prepareAcpSessionElicitation(input: {
     readonly host: AcpInitializedConnection['hostElicitation'];
 }): Readonly<{
     form?: PreparedAcpForm;
-    host?: () => Promise<AcpJsonValue>;
+    host?: (observeCallback: (work: Promise<void>) => void) => Promise<AcpJsonValue>;
 }>;
 //# sourceMappingURL=elicitation.d.ts.map

package/dist/session/requests/elicitation.js

@@ -14,7 +14,7 @@ function prepareAcpSessionElicitation(input) {
     const invoke = input.host;
     if (!invoke) throw new Error("This ACP elicitation requires an explicitly configured host UI.");
     const signal = AbortSignal.any([input.context.signal, input.lifetime]);
-    return { host: () => invoke({ ...input.context, signal }) };
+    return { host: (observeCallback) => invoke({ ...input.context, signal }, observeCallback) };
   } catch (error) {
     throw new AcpRpcHandlerError(-32602, error instanceof Error ? error.message : "Unsupported ACP form.");
   }

package/dist/session/requests/forms.js

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

package/dist/session/requests/grokWithdrawals.d.ts

@@ -0,0 +1,28 @@
+import type { AcpJsonObject } from '@agen-ai/acp-transport';
+import type { DescendantIdentity } from '../descendants.js';
+import { type SessionQueue } from '../queue.js';
+import type { NativeTurn } from '../turn.js';
+import type { PendingSessionRequest } from './pending.js';
+/** Only the observed ordered child/tool callback and exact canceled attempt can withdraw a permission. */
+export declare class GrokChildPermissionWithdrawals {
+    private readonly input;
+    private readonly children;
+    private readonly requests;
+    constructor(input: Readonly<{
+        reserveState: SessionQueue<unknown>['reserveState'];
+        currentTurn: () => NativeTurn | undefined;
+        timeoutMs: number;
+        withdraw: (request: PendingSessionRequest) => void;
+        fail: (error: Error) => void;
+    }>);
+    observe(identity: DescendantIdentity, update: AcpJsonObject): void;
+    attach(request: PendingSessionRequest): void;
+    finish(identity: DescendantIdentity, update: AcpJsonObject): void;
+    answerGate(request: PendingSessionRequest): Promise<void> | undefined;
+    settle(request: PendingSessionRequest): void;
+    private child;
+    private retire;
+    private stale;
+    stop(error: Error): void;
+}
+//# sourceMappingURL=grokWithdrawals.d.ts.map

package/dist/session/requests/grokWithdrawals.js

@@ -0,0 +1,135 @@
+import { AcpProviderSessionError } from "../errors.js";
+import { nativeIdentity, nativeObject } from "../native.js";
+import { deferred } from "../queue.js";
+const PERMISSION_STATE_OVERHEAD_BYTES = 256;
+class GrokChildPermissionWithdrawals {
+  constructor(input) {
+    this.input = input;
+  }
+  children = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  observe(identity, update) {
+    if (identity.attemptId === void 0 || update.sessionUpdate !== "pending_interaction" && update.sessionUpdate !== "interaction_resolved") return;
+    if (update.sessionUpdate === "pending_interaction" && update.kind !== "permission") return;
+    const toolId = nativeIdentity(update.tool_call_id, "child permission tool identity");
+    const child = this.child(identity);
+    const prior = child.interactions.get(toolId);
+    if (update.sessionUpdate === "pending_interaction") {
+      const turn2 = this.input.currentTurn();
+      if (child.finished || prior?.phase.kind === "retired" || !turn2 || turn2.nativeSettled || turn2.terminal || prior && prior.phase.turn !== turn2) throw this.stale();
+      if (!prior) child.interactions.set(toolId, {
+        phase: { kind: "announced", turn: turn2 },
+        release: this.input.reserveState({ childSessionId: identity.childSessionId, toolId }, PERMISSION_STATE_OVERHEAD_BYTES)
+      });
+      return;
+    }
+    if (!prior) {
+      child.interactions.set(toolId, {
+        phase: { kind: "retired" },
+        release: this.input.reserveState({ childSessionId: identity.childSessionId, toolId }, PERMISSION_STATE_OVERHEAD_BYTES)
+      });
+      return;
+    }
+    if (prior.phase.kind === "announced") {
+      prior.phase = { kind: "retired" };
+      return;
+    }
+    if (prior.phase.kind !== "attached") return;
+    const { turn, request } = prior.phase;
+    if (turn !== this.input.currentTurn() || turn.nativeSettled || turn.terminal) throw this.stale();
+    const hold = request.answered ? void 0 : { ready: deferred(), timer: setTimeout(
+      () => this.input.fail(
+        new AcpProviderSessionError("acp_native_permission_uncertain", "The resolved native child permission lacks exact cancellation corroboration.")
+      ),
+      this.input.timeoutMs
+    ) };
+    if (hold) void hold.ready.promise.catch(() => {
+    });
+    prior.phase = { kind: "resolved", turn, request, hold };
+  }
+  attach(request) {
+    if (request.kind !== "permission") return;
+    const tool = nativeObject(request.params.toolCall, "permission tool");
+    const meta = tool._meta === void 0 ? void 0 : nativeObject(tool._meta, "permission tool metadata");
+    if (meta?.["x.ai/requestingSessionId"] === void 0) return;
+    const childId = nativeIdentity(meta["x.ai/requestingSessionId"], "requesting child session identity");
+    if (childId === request.params.sessionId) return;
+    const child = this.children.get(childId);
+    if (!child) return;
+    const interaction = child.interactions.get(nativeIdentity(tool.toolCallId, "permission tool identity"));
+    if (child.finished || interaction && (interaction.phase.kind !== "announced" || interaction.phase.turn !== this.input.currentTurn())) throw this.stale();
+    if (!interaction || interaction.phase.kind !== "announced") return;
+    interaction.phase = { kind: "attached", turn: interaction.phase.turn, request };
+    this.requests.set(request, interaction);
+  }
+  finish(identity, update) {
+    if (identity.attemptId === void 0) return;
+    if (nativeIdentity(update.subagent_id, "finished subagent identity") !== identity.subagentId || nativeIdentity(update.attempt_id, "finished attempt identity") !== identity.attemptId) throw new AcpProviderSessionError(
+      "acp_native_permission_identity_conflict",
+      "The native child finish does not identify its exact announced attempt."
+    );
+    const child = this.child(identity);
+    if (child.finished) return;
+    child.finished = true;
+    for (const interaction of child.interactions.values()) {
+      const phase = interaction.phase;
+      if (phase.kind !== "attached" && phase.kind !== "resolved" || phase.turn !== this.input.currentTurn() || phase.turn.nativeSettled || phase.turn.terminal) continue;
+      if (phase.kind !== "resolved" || update.status !== "cancelled") {
+        if (!phase.request.answered) throw new AcpProviderSessionError(
+          "acp_native_permission_uncertain",
+          "The native child finish lacks the exact ordered permission cancellation facts."
+        );
+        continue;
+      }
+      this.input.withdraw(phase.request);
+      this.retire(interaction);
+    }
+  }
+  answerGate(request) {
+    const phase = this.requests.get(request)?.phase;
+    return phase?.kind === "resolved" ? phase.hold?.ready.promise : void 0;
+  }
+  settle(request) {
+    const interaction = this.requests.get(request);
+    if (interaction) this.retire(interaction);
+    this.requests.delete(request);
+  }
+  child(identity) {
+    let child = this.children.get(identity.childSessionId);
+    if (!child) {
+      child = { interactions: /* @__PURE__ */ new Map(), finished: false, release: this.input.reserveState({
+        childSessionId: identity.childSessionId,
+        subagentId: identity.subagentId,
+        attemptId: identity.attemptId
+      }) };
+      this.children.set(identity.childSessionId, child);
+    }
+    return child;
+  }
+  retire(interaction, error) {
+    const phase = interaction.phase;
+    if (phase.kind === "resolved" && phase.hold) {
+      clearTimeout(phase.hold.timer);
+      if (error) phase.hold.ready.reject(error);
+      else phase.hold.ready.resolve();
+    }
+    interaction.phase = { kind: "retired" };
+  }
+  stale() {
+    return new AcpProviderSessionError("acp_native_permission_stale", "The native child permission does not identify a fresh callback in its original turn.");
+  }
+  stop(error) {
+    for (const child of this.children.values()) {
+      for (const interaction of child.interactions.values()) {
+        this.retire(interaction, error);
+        interaction.release();
+      }
+      child.release();
+    }
+    this.children.clear();
+    this.requests.clear();
+  }
+}
+export {
+  GrokChildPermissionWithdrawals
+};

package/dist/session/requests/pending.d.ts

@@ -1,5 +1,5 @@
-import type { AcpJsonObject, AcpJsonValue, AcpReverseRequestContext } from '@agen-ai/acp-transport';
-import type { AgentRequest } from '@agen-ai/agent-protocol';
+import { type AcpJsonObject, type AcpJsonValue, type AcpReverseRequestContext } from '@agen-ai/acp-transport';
+import type { AgentRequest, AgentRequestId } from '@agen-ai/agent-protocol';
 import type { MappedPermission } from '../mapping.js';
 import { deferred, type QueueEntry } from '../queue.js';
 import type { AcpFormFlow, PreparedAcpForm } from './forms.js';
@@ -16,12 +16,16 @@ export interface PendingSessionRequest {
     readonly kind: 'permission' | 'form';
     readonly params: AcpJsonObject;
     readonly form?: PreparedAcpForm;
-    readonly host?: () => Promise<AcpJsonValue>;
+    readonly host?: (observeCallback: (work: Promise<void>) => void) => Promise<AcpJsonValue>;
+    hostWork: Promise<void> | undefined;
     readonly response: ReturnType<typeof deferred<AcpJsonValue>>;
     readonly signal: AbortSignal;
+    readonly transportSettled: Promise<void>;
     entry: QueueEntry<unknown> | undefined;
     mapped: MappedSessionRequest | undefined;
     answered: boolean;
+    publishedRequestId: AgentRequestId | undefined;
+    unavailable: boolean;
     readonly onAbort: () => void;
 }
 export declare function canceledRequestReply(kind: PendingSessionRequest['kind']): AcpJsonValue;
@@ -29,14 +33,23 @@ export declare function canceledRequestReply(kind: PendingSessionRequest['kind']
 export declare class PendingSessionRequests {
     private readonly input;
     private readonly pending;
+    private readonly retained;
+    private retainedBytes;
     constructor(input: {
         readonly maxPendingRequests: number;
+        readonly maxRequestMaterialBytes: number;
         readonly admit: (request: PendingSessionRequest, bytes: number) => QueueEntry<unknown>;
         readonly fail: (error: Error) => void;
+        readonly unavailable: (request: PendingSessionRequest, requestId: AgentRequestId) => void;
+        readonly settled: (request: PendingSessionRequest) => void;
+        readonly admitted?: (request: PendingSessionRequest) => void;
     });
     get size(): number;
-    admit(context: AcpReverseRequestContext, kind: PendingSessionRequest['kind'], params: AcpJsonObject, form?: PreparedAcpForm, host?: () => Promise<AcpJsonValue>): Promise<AcpJsonValue>;
+    admit(context: AcpReverseRequestContext, kind: PendingSessionRequest['kind'], params: AcpJsonObject, form?: PreparedAcpForm, host?: PendingSessionRequest['host']): Promise<AcpJsonValue>;
     canAnswer(request: PendingSessionRequest): boolean;
+    withdraw(request: PendingSessionRequest, error: Error): void;
+    invokeHost(request: PendingSessionRequest): Promise<AcpJsonValue>;
+    join(): Promise<void>;
     answer(request: PendingSessionRequest, result: AcpJsonValue): boolean;
     reject(request: PendingSessionRequest, error: Error): void;
     private release;

package/dist/session/requests/pending.js

@@ -1,3 +1,4 @@
+import { AcpRequestError } from "@agen-ai/acp-transport";
 import { AcpProviderSessionError } from "../errors.js";
 import { nativeBytes } from "../native.js";
 import { deferred } from "../queue.js";
@@ -8,18 +9,25 @@ class PendingSessionRequests {
   constructor(input) {
     this.input = input;
   }
-  input;
   pending = /* @__PURE__ */ new Set();
+  retained = /* @__PURE__ */ new Set();
+  retainedBytes = 0;
   get size() {
     return this.pending.size;
   }
   admit(context, kind, params, form, host) {
-    if (this.pending.size >= this.input.maxPendingRequests) {
+    if (this.retained.size >= this.input.maxPendingRequests) {
       const error = new AcpProviderSessionError("acp_request_queue_full", "The ACP pending request budget is exhausted.");
       this.input.fail(error);
       throw error;
     }
     const response = deferred();
+    const bytes = nativeBytes(params) * 2 + (form ? nativeBytes(form) : 0);
+    if (this.retainedBytes + bytes > this.input.maxRequestMaterialBytes) {
+      const error = new AcpProviderSessionError("acp_session_queue_full", "The ACP retained request material budget is exhausted.");
+      this.input.fail(error);
+      throw error;
+    }
     const request = {
       kind,
       params,
@@ -27,18 +35,37 @@ class PendingSessionRequests {
       ...host === void 0 ? {} : { host },
       response,
       signal: context.signal,
+      transportSettled: context.settled,
       entry: void 0,
       mapped: void 0,
       answered: false,
+      publishedRequestId: void 0,
+      unavailable: false,
+      hostWork: void 0,
       onAbort: () => {
-        this.cancel(request);
-        this.input.fail(new AcpProviderSessionError("acp_request_revoked", "The peer canceled a pending ACP interaction request."));
+        const cause = context.signal.reason;
+        if (cause instanceof AcpRequestError && cause.reasonCode === "acp_reverse_request_canceled" && cause.requestId === context.id) {
+          this.withdraw(request, cause);
+          return;
+        }
+        this.input.fail(cause instanceof Error ? cause : new AcpProviderSessionError("acp_request_revoked", "The native callback producer stopped."));
       }
     };
     try {
-      request.entry = this.input.admit(request, nativeBytes(params) * 2 + (form ? nativeBytes(form) : 0));
+      request.entry = this.input.admit(request, bytes);
       this.pending.add(request);
+      this.retained.add(request);
+      this.retainedBytes += bytes;
+      void context.settled.then(async () => {
+        await request.hostWork;
+        context.signal.removeEventListener("abort", request.onAbort);
+        this.retained.delete(request);
+        this.retainedBytes -= bytes;
+        request.entry?.release();
+        this.input.settled(request);
+      });
       context.signal.addEventListener("abort", request.onAbort, { once: true });
+      this.input.admitted?.(request);
       if (context.signal.aborted) request.onAbort();
       return response.promise;
     } catch (error) {
@@ -47,7 +74,37 @@ class PendingSessionRequests {
     }
   }
   canAnswer(request) {
-    return this.pending.has(request) && !request.answered && !request.signal.aborted;
+    return this.pending.has(request) && !request.answered && !request.unavailable && !request.signal.aborted;
+  }
+  withdraw(request, error) {
+    if (request.unavailable) return;
+    request.unavailable = true;
+    if (request.publishedRequestId !== void 0 && request.publishedRequestId === request.mapped?.request.requestId) {
+      this.input.unavailable(request, request.publishedRequestId);
+    }
+    if (!request.answered) this.reject(request, error);
+  }
+  invokeHost(request) {
+    if (!request.host) throw new TypeError("The native request has no host callback.");
+    const joined = deferred();
+    request.hostWork = joined.promise;
+    let callback = Promise.resolve();
+    let work;
+    try {
+      work = request.host((actual) => {
+        callback = actual;
+      });
+    } catch (cause) {
+      work = Promise.reject(cause);
+    }
+    void work.then(() => callback, () => callback).then(joined.resolve, () => joined.resolve());
+    return work;
+  }
+  async join() {
+    while (this.retained.size > 0) await Promise.all([...this.retained].map(async (request) => {
+      await request.transportSettled;
+      await request.hostWork;
+    }));
   }
   answer(request, result) {
     if (!this.canAnswer(request) || !this.release(request)) return false;
@@ -61,9 +118,7 @@ class PendingSessionRequests {
   release(request) {
     if (!this.pending.has(request) || request.answered) return false;
     request.answered = true;
-    request.signal.removeEventListener("abort", request.onAbort);
     this.pending.delete(request);
-    request.entry?.release();
     return true;
   }
   cancelAll() {

package/dist/session/requests/resolution.js

@@ -15,8 +15,10 @@ function resolveAcpRequest(requests, turn, request, mapped, input) {
     request.mapped = { ...mapped, request: mapped.flow.request };
   }
   if (reply !== void 0 && !requests.answer(request, reply)) return requestUnavailable();
-  turn.waiting = void 0;
-  turn.transition = reply === void 0 ? { nextRequest: request } : {};
+  if (reply === void 0) {
+    turn.waiting = void 0;
+    turn.transition = { nextRequest: request };
+  } else turn.transition = {};
   return { status: "delivered" };
 }
 function requestUnavailable() {