@agen-ai/provider-acp 0.4.1 → 0.4.2

package/dist/session/session.js

@@ -8,6 +8,10 @@ import {
 import {
   throwIfAgentOperationAborted
 } from "@agen-ai/agent-runtime";
+import { GrokPlanContinuations } from "./continuation.js";
+import { GrokDescendantObservations } from "./descendants.js";
+import { GrokChildPermissionWithdrawals } from "./requests/grokWithdrawals.js";
+import { awaitHost } from "../host/lifecycle.js";
 import { AcpProviderSessionError, sessionError } from "./errors.js";
 import { TurnMapping } from "./mapping.js";
 import { createAcpSessionConfiguration } from "../configuration/control.js";
@@ -26,11 +30,55 @@ class SessionState {
     this.input = input;
     this.queue = new SessionQueue(input.limits);
     this.replay = new AcpHistoryReplay(input.limits);
+    if (input.connection.sessionInteractions?.selectedLifecycle) {
+      this.childWithdrawals = new GrokChildPermissionWithdrawals({
+        reserveState: (value, extraBytes) => this.queue.reserveState(value, extraBytes),
+        currentTurn: () => this.turn,
+        timeoutMs: input.limits.cancellationTimeoutMs,
+        withdraw: (request) => this.requests.withdraw(request, new AcpRpcHandlerError(-32800, "Request cancelled")),
+        fail: (error) => this.fail(error)
+      });
+      this.descendants = new GrokDescendantObservations({
+        reserveState: (value, extraBytes) => this.queue.reserveState(value, extraBytes),
+        rootSessionId: () => this.nativeSessionId,
+        activeTurn: () => this.turn !== void 0 && !this.turn.nativeSettled && !this.turn.terminal,
+        observeHistory: (params) => this.replay.observe(params),
+        withdrawals: this.childWithdrawals
+      });
+    }
+    this.continuations = new GrokPlanContinuations({
+      queue: this.queue,
+      selected: input.connection.sessionInteractions?.selectedLifecycle === true,
+      requireUsable: () => this.requireUsable(),
+      assertNativeSession: (params) => this.assertNativeSession(params),
+      createNativeTurn: (turnId) => this.createNativeTurn(turnId),
+      execution: (turn, stream) => this.execution(turn, stream),
+      stream: (turn, ready) => this.streamContinuation(turn, ready),
+      completeNativeTurn: (turn, payload) => this.completeNativeTurn(turn, payload),
+      close: () => this.close()
+    });
     this.operations = createAcpStandardSessionOperations(input.connection.client);
     this.requests = new PendingSessionRequests({
-      maxPendingRequests: input.limits.maxPendingRequests,
+      maxPendingRequests: input.connection.sessionInteractions?.selectedLifecycle ? Math.min(input.limits.maxPendingRequests, 16) : input.limits.maxPendingRequests,
+      maxRequestMaterialBytes: input.connection.sessionInteractions?.selectedLifecycle ? Math.min(input.limits.maxQueuedBytes, 1048576) : input.limits.maxQueuedBytes,
       admit: (request, bytes) => this.queue.admit({ kind: "request", request }, bytes),
-      fail: (error) => this.fail(error)
+      fail: (error) => this.fail(error),
+      unavailable: (request, requestId) => {
+        try {
+          this.queue.admit({ kind: "unavailable", request, requestId }, nativeBytes(requestId) + 64, true);
+        } catch (cause) {
+          this.fail(sessionError(cause));
+        }
+      },
+      settled: (request) => {
+        this.childWithdrawals?.settle(request);
+        const turn = this.turn;
+        if (turn?.waiting === request && !request.unavailable) {
+          turn.waiting = void 0;
+          this.queue.wakeReader();
+        }
+      },
+      admitted: (request) => this.childWithdrawals?.attach(request)
     });
     this.configuration = createAcpSessionConfiguration({
       capability: input.capabilities.configuration,
@@ -44,10 +92,17 @@ class SessionState {
     this.environment = createAcpSessionEnvironment({ limits: input.limits, now: input.now, signal: input.connection.stopped });
     this.onStopped = () => this.fail(sessionError(input.connection.stopped.reason));
     this.detach = input.connection.attachSession({
+      joinCallbacks: () => this.requests.join(),
+      onExtensionNotification: (context) => {
+        this.requireUsable();
+        if (this.descendants?.admit(context, this.replay.active)) return;
+        this.continuations.admitNotification(context);
+      },
       onNotification: (context) => this.admitNotification(context),
       onPermissionRequest: (context) => this.admitRequest(context, "permission"),
       onElicitationRequest: (context) => this.admitRequest(context, "form")
     });
+    input.connection.sessionInteractions?.attachContinuationOwner((prepared) => this.continuations.prepareResponse(prepared));
     input.connection.stopped.addEventListener("abort", this.onStopped, { once: true });
     if (input.connection.stopped.aborted) this.onStopped();
   }
@@ -70,16 +125,19 @@ class SessionState {
   closePromise;
   itemSequence = 0;
   requestSequence = 0;
+  continuations;
+  descendants;
+  childWithdrawals;
   async open() {
     this.requireUsable();
     throwIfAgentOperationAborted(this.input.context.signal);
-    const sessionInteractions = this.input.connection.sessionInteractions;
+    const sessionInteractions = this.input.context.interactions ? this.input.connection.sessionInteractions : void 0;
     await openAcpNativeSession(this.input, {
       replay: this.replay,
       bind: (binding2) => {
         this.binding = binding2;
         this.nativeSessionId = binding2.conversationId;
-        this.input.connection.sessionInteractions?.bindNativeSession(binding2.conversationId);
+        sessionInteractions?.bindNativeSession(binding2.conversationId);
         this.bindHostSession();
       },
       observeSetup: (result) => {
@@ -127,7 +185,7 @@ class SessionState {
     }
   }
   fail(error) {
-    if (this.failure) return;
+    if (this.failure || this.closed) return;
     this.failure = error;
     this.input.connection.sessionInteractions?.stop({ kind: "failed", cause: error });
     this.turn?.hostInteractions.abort(error);
@@ -135,6 +193,9 @@ class SessionState {
     this.requests.cancelAll();
     this.environment.close();
     this.turn?.settled.reject(error);
+    this.continuations.stop(error);
+    this.descendants?.stop();
+    this.childWithdrawals?.stop(error);
     this.clearTurnTimers();
     void this.input.connection.close().catch((cause) => {
       this.cleanupFailure = cause;
@@ -142,11 +203,13 @@ class SessionState {
   }
   admitNotification(context) {
     this.requireUsable();
+    if (this.descendants?.admit(context, this.replay.active)) return;
     const params = nativeObject(context.params, "session notification");
     this.assertNativeSession(params);
     const update = nativeObject(params.update, "session update");
     const kind = nativeString(update.sessionUpdate, "session update kind");
     this.replay.observe(params);
+    const liveOutput = this.continuations.admitOutput(params, update, this.replay.active);
     if (SESSION_METADATA_UPDATES.has(kind)) {
       if (this.nativeSessionId === void 0) {
         const entry = this.queue.admit({ kind: "update", params }, nativeBytes(params) * 2);
@@ -156,7 +219,7 @@ class SessionState {
       this.observeMetadata(update);
       return;
     }
-    if (this.replay.active) return;
+    if (this.replay.active || !liveOutput) return;
     if (!this.turn || this.turn.nativeSettled || this.turn.terminal) {
       throw new AcpProviderSessionError("acp_update_without_prompt", "ACP emitted turn content without an active native prompt.");
     }
@@ -197,21 +260,45 @@ class SessionState {
   clearTurnTimers() {
     for (const cleanup of this.turn?.cleanup.splice(0) ?? []) cleanup();
   }
+  async *streamContinuation(turn, ready) {
+    let stable = false;
+    try {
+      if (!await ready) {
+        stable = true;
+        return;
+      }
+      yield* this.emit(turn.mapping.event("turn.started", {}));
+      yield* this.drain(turn);
+      await this.requests.join();
+      stable = true;
+    } catch (error) {
+      this.fail(sessionError(error));
+      throw error;
+    } finally {
+      if (!stable && !this.closed) this.fail(new AcpProviderSessionError("acp_turn_abandoned", "The native continuation reader was abandoned."));
+    }
+  }
   startTurn(input) {
     this.requireUsable();
     throwIfAgentOperationAborted(input.signal);
-    if (this.turn && !this.turn.terminal) throw new AcpProviderSessionError("acp_turn_active", "The ACP session already has an active or waiting turn.");
+    if (this.turn && !this.turn.sourceSettled) throw new AcpProviderSessionError("acp_turn_active", "The ACP session already has an active or waiting turn.");
     if (input.interactionMode !== "default") {
       throw new AcpProviderSessionError("acp_input_unsupported", "ACP supports only the default interaction mode.");
     }
     const prompt = prepareAcpPrompt(input.parts, this.input.capabilities);
+    const turn = this.createNativeTurn(input.turnId);
+    return this.execution(turn, () => this.streamTurn(turn, input, prompt));
+  }
+  createNativeTurn(turnId) {
+    this.requireUsable();
+    if (this.turn && !this.turn.sourceSettled) throw new AcpProviderSessionError("acp_turn_active", "The ACP session already has an active or waiting turn.");
     const settled = deferred();
     void settled.promise.catch(() => void 0);
     const turn = {
-      turnId: input.turnId,
+      turnId,
       mapping: new TurnMapping({
         sessionId: this.input.context.sessionId,
-        turnId: input.turnId,
+        turnId,
         workingDirectory: this.input.context.workingDirectory,
         permissionMapping: this.input.permissionMapping,
         now: this.input.now,
@@ -226,22 +313,41 @@ class SessionState {
       nativeStarted: false,
       nativeSettled: false,
       terminal: false,
+      sourceSettled: false,
       waiting: void 0,
       transition: void 0,
       cancelReason: void 0,
       cancellation: void 0
     };
     this.turn = turn;
+    return turn;
+  }
+  execution(turn, stream) {
     let acquired = false;
     const outputs = {
       [Symbol.asyncIterator]: () => {
         if (acquired) throw new AcpProviderSessionError("acp_turn_stream_owned", "The ACP turn output already has a consumer.");
         acquired = true;
-        return this.streamTurn(turn, input, prompt);
+        return this.ownedStream(turn, stream);
       }
     };
     return Object.freeze({ turnId: turn.turnId, outputs, resolveRequest: (resolution) => this.resolveRequest(turn, resolution) });
   }
+  async *ownedStream(turn, stream) {
+    yield* stream();
+    turn.sourceSettled = true;
+  }
+  completeNativeTurn(turn, payload) {
+    turn.nativeSettled = true;
+    if (this.requests.size > 0) {
+      this.fail(new AcpProviderSessionError("acp_terminal_with_request", "ACP completed native work with unanswered interaction requests."));
+      return;
+    }
+    turn.hostInteractions.abort(new DOMException("The ACP native execution settled.", "AbortError"));
+    this.clearTurnTimers();
+    this.queue.admit({ kind: "terminal", payload }, nativeBytes(payload), true);
+    turn.settled.resolve(payload);
+  }
   launchTurn(turn, input, prompt) {
     this.requireUsable();
     throwIfAgentOperationAborted(input.signal);
@@ -254,16 +360,8 @@ class SessionState {
     }, {
       timeoutMs: this.input.limits.promptTimeoutMs,
       onResponseReceived: (response) => {
-        turn.nativeSettled = true;
-        if (this.requests.size > 0) {
-          this.fail(new AcpProviderSessionError("acp_terminal_with_request", "ACP completed a prompt with unanswered interaction requests."));
-          return;
-        }
-        turn.hostInteractions.abort(new DOMException("The ACP native prompt settled.", "AbortError"));
-        this.clearTurnTimers();
         const payload = acpTurnCompletion(response, turn.cancelReason);
-        this.queue.admit({ kind: "terminal", payload }, nativeBytes(payload), true);
-        turn.settled.resolve(payload);
+        this.completeNativeTurn(turn, payload);
       }
     }).then(() => void 0, (error) => {
       if (!turn.nativeSettled) this.fail(sessionError(error));
@@ -329,10 +427,7 @@ class SessionState {
         }
       } else if (message.kind === "request") {
         const request = message.request;
-        if (request.answered || turn.cancelReason) {
-          entry.release();
-          continue;
-        }
+        if (request.answered || turn.cancelReason) continue;
         if (request.kind === "permission") {
           const mappedTool = turn.mapping.tool(nativeObject(request.params.toolCall, "permission tool"), true);
           let next = mappedTool.next();
@@ -343,10 +438,7 @@ class SessionState {
             if (request.answered || turn.cancelReason) break;
             next = mappedTool.next();
           }
-          if (!next.done) {
-            entry.release();
-            continue;
-          }
+          if (!next.done) continue;
           const permission = turn.mapping.permission(request.params, next.value);
           request.mapped = { kind: "permission", permission, request: permission.request };
           if (permission.warning) {
@@ -359,20 +451,26 @@ class SessionState {
             continue;
           }
           if (request.host) {
-            void (async () => request.host())().then((result) => this.requests.answer(request, result), (error) => this.requests.reject(request, sessionError(error)));
+            void this.requests.invokeHost(request).then((result) => this.requests.answer(request, result), (error) => this.requests.reject(request, sessionError(error)));
             continue;
           }
           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;
-        }
+        if (request.answered || turn.cancelReason) continue;
         turn.waiting = request;
         yield* this.offerRequest(turn, request);
         if (turn.terminal) return "terminal";
         continue;
+      } else if (message.kind === "unavailable") {
+        try {
+          const request = message.request;
+          yield* this.emit(turn.mapping.event("request.unavailable", { requestId: message.requestId, reason: "withdrawn" }));
+          if (turn.waiting === request) turn.waiting = void 0;
+          yield* this.emit(turn.mapping.event("turn.state_changed", { state: "running" }));
+        } finally {
+          entry.release();
+        }
       } else {
         try {
           if (this.requests.size > 0) throw new AcpProviderSessionError("acp_terminal_with_request", "ACP completed a prompt with unanswered interaction requests.");
@@ -384,6 +482,7 @@ class SessionState {
           turn.terminal = true;
           turn.waiting = void 0;
           turn.mapping.release();
+          this.continuations.complete(turn);
           this.clearTurnTimers();
           return "terminal";
         } finally {
@@ -394,6 +493,8 @@ class SessionState {
   }
   async *offerRequest(turn, request) {
     const canonical = request.mapped.request;
+    if (!this.requests.canAnswer(request)) return;
+    request.publishedRequestId = canonical.requestId;
     yield* this.emit(turn.mapping.event("request.opened", { request: canonical }));
     if (turn.terminal) return;
     yield* this.emit(turn.mapping.event("turn.state_changed", { state: "waiting_for_request", requestId: canonical.requestId }));
@@ -404,6 +505,7 @@ class SessionState {
       this.launchTurn(turn, input, prompt);
       yield* this.emit(turn.mapping.event("turn.started", {}));
       yield* this.drain(turn);
+      await this.requests.join();
       stable = true;
     } catch (error) {
       this.fail(sessionError(error));
@@ -418,6 +520,9 @@ class SessionState {
     if (this.turn !== turn || turn.terminal || !request?.mapped) {
       throw new AcpProviderSessionError("acp_request_not_pending", "The ACP resolution does not identify an available pending request.");
     }
+    const gate = this.childWithdrawals?.answerGate(request);
+    if (gate) await awaitHost(gate, input.signal ?? this.input.connection.stopped);
+    throwIfAgentOperationAborted(input.signal);
     const result = resolveAcpRequest(this.requests, turn, request, request.mapped, input);
     if (result.status === "delivered") this.queue.wakeReader();
     return result;
@@ -491,6 +596,9 @@ class SessionState {
       this.queue.fail(error);
       this.requests.cancelAll();
       this.turn?.settled.reject(error);
+      this.continuations.stop(error);
+      this.descendants?.stop();
+      this.childWithdrawals?.stop(error);
       this.clearTurnTimers();
       this.environment.close();
       this.turn?.mapping.release();

package/dist/session/turn.d.ts

@@ -1,5 +1,5 @@
 import type { AcpJsonObject } from '@agen-ai/acp-transport';
-import type { AgentTurnCompletedPayload, AgentTurnId } from '@agen-ai/agent-protocol';
+import type { AgentRequestId, AgentTurnCompletedPayload, AgentTurnId } from '@agen-ai/agent-protocol';
 import type { TurnMapping } from './mapping.js';
 import type { deferred } from './queue.js';
 import type { PendingSessionRequest } from './requests/pending.js';
@@ -9,6 +9,10 @@ export type SessionMessage = Readonly<{
 }> | Readonly<{
     kind: 'request';
     request: PendingSessionRequest;
+}> | Readonly<{
+    kind: 'unavailable';
+    request: PendingSessionRequest;
+    requestId: AgentRequestId;
 }> | Readonly<{
     kind: 'terminal';
     payload: AgentTurnCompletedPayload;
@@ -23,6 +27,7 @@ export interface NativeTurn {
     nativeStarted: boolean;
     nativeSettled: boolean;
     terminal: boolean;
+    sourceSettled: boolean;
     waiting: PendingSessionRequest | undefined;
     transition: Readonly<{
         nextRequest?: PendingSessionRequest;

package/dist/sessionInteractions/broker.d.ts

@@ -1,18 +1,22 @@
 import type { AcpJsonValue, AcpReverseRequestContext } from '@agen-ai/acp-transport';
 import type { AgentProviderConversationId, AgentSessionId } from '@agen-ai/agent-protocol';
-import { type AgentSessionInteractionContext } from '@agen-ai/agent-runtime';
+import { type AgentProviderSessionInteractionContext } from '@agen-ai/agent-runtime';
 import type { AcpProviderLimits } from '../limits.js';
+import { type PreparePlanContinuation } from './request.js';
+import type { AcpSessionInteractionSelection } from './contracts.js';
 export type SessionInteractionStop = Readonly<{
     kind: 'session_closed';
 }> | Readonly<{
     kind: 'failed';
     cause: Error;
 }>;
-/** One connection owns one create generation and one retained native decision. */
+/** One connection owns one opening generation and one retained native session request. */
 export declare class SessionInteractionBroker {
     private readonly input;
     private state;
     private requestNumber;
+    private expectedNativeId;
+    private prepareContinuation;
     private retained;
     private readonly entered;
     private openingTimer;
@@ -21,12 +25,16 @@ export declare class SessionInteractionBroker {
     constructor(input: Readonly<{
         stopped: AbortSignal;
         limits: AcpProviderLimits;
+        selection: AcpSessionInteractionSelection;
         onFailure: (cause: Error) => void;
     }>);
+    attachContinuationOwner(prepare: PreparePlanContinuation): void;
+    humanTimeoutMs(): number | undefined;
+    get selectedLifecycle(): boolean;
     prepareOpening(input: Readonly<{
         sessionId: AgentSessionId;
         workingDirectory: string;
-        interactions: AgentSessionInteractionContext;
+        interactions: AgentProviderSessionInteractionContext;
         signal?: AbortSignal;
     }>): void;
     onOpeningDispatched(): void;

package/dist/sessionInteractions/broker.js

@@ -5,6 +5,7 @@ import {
 import { AcpProviderSessionError } from "../session/errors.js";
 import { folderTrustDecision, GROK_FOLDER_TRUST_METHOD, parseNativeFolderTrustRequest } from "./grokFolderTrust.js";
 import { NativeSessionDecision, sessionDecisionError } from "./request.js";
+import { GROK_PLAN_REVIEW_METHOD, parseNativePlanReviewRequest, planReviewRequest } from "./grokPlanReview.js";
 class SessionInteractionBroker {
   constructor(input) {
     this.input = input;
@@ -13,6 +14,8 @@ class SessionInteractionBroker {
   }
   state = { kind: "idle" };
   requestNumber = 0;
+  expectedNativeId;
+  prepareContinuation;
   retained;
   entered = /* @__PURE__ */ new Set();
   openingTimer;
@@ -25,11 +28,12 @@ class SessionInteractionBroker {
   };
   handleRequest = (context) => {
     try {
-      if (context.method !== GROK_FOLDER_TRUST_METHOD) throw failure(
+      const plan = this.input.selection.mapping === "grok-build-1.0.60-session-requests-v1";
+      if (context.method !== (plan ? GROK_PLAN_REVIEW_METHOD : GROK_FOLDER_TRUST_METHOD)) throw failure(
         "acp_session_interaction_invalid",
         "The reverse request does not belong to the selected session mapping."
       );
-      const native = parseNativeFolderTrustRequest(context.params);
+      const native = plan ? parseNativePlanReviewRequest(context.params) : parseNativeFolderTrustRequest(context.params);
       const state = this.state;
       if (state.kind === "stopped") throw state.cause;
       if (state.kind === "idle" || state.kind === "prepared") throw failure(
@@ -40,12 +44,13 @@ class SessionInteractionBroker {
         "acp_session_interaction_capacity",
         "The connection already retains a native session decision."
       );
-      if (native.cwd !== state.owner.workingDirectory || "nativeId" in state && native.sessionId !== state.nativeId) throw failure(
+      if ("cwd" in native && native.cwd !== state.owner.workingDirectory || this.expectedNativeId !== void 0 && native.sessionId !== this.expectedNativeId) throw failure(
         "acp_session_interaction_binding",
         "The native decision does not match its exact session binding."
       );
-      const expiresAt = Date.now() + state.owner.limits.requestTimeoutMs;
-      const request = folderTrustDecision({ native, sessionId: state.owner.sessionId, requestNumber: ++this.requestNumber, expiresAt });
+      const hostDeadlineAt = state.owner.interactions.humanWait?.kind === "until_withdrawn_or_closed" ? void 0 : Date.now() + state.owner.limits.requestTimeoutMs;
+      const requestNumber = ++this.requestNumber;
+      const request = "planContent" in native ? planReviewRequest(native, state.owner.sessionId, requestNumber) : folderTrustDecision({ native, sessionId: state.owner.sessionId, requestNumber });
       const descriptorBytes = Buffer.byteLength(JSON.stringify(request), "utf8");
       const nativeBytes = Buffer.byteLength(JSON.stringify(native), "utf8");
       if (descriptorBytes > state.owner.limits.maxRetainedBytes || descriptorBytes + nativeBytes > this.input.limits.maxQueuedBytes) throw failure(
@@ -54,9 +59,13 @@ class SessionInteractionBroker {
       );
       const decision = new NativeSessionDecision({
         request,
-        nativeContext: Object.freeze({ id: context.id, signal: context.signal }),
-        expiresAt,
-        accepting: () => this.state.kind === "active" || this.state.kind === "open",
+        nativeContext: context,
+        ...hostDeadlineAt === void 0 ? {} : { hostDeadlineAt },
+        ...plan ? { prepareContinuation: (input) => {
+          if (!this.prepareContinuation) throw failure("acp_continuation_owner_missing", "The plan review has no prepared execution owner.");
+          return this.prepareContinuation(input);
+        } } : {},
+        accepting: () => this.state.kind === "open" || !plan && this.state.kind === "active",
         fail: (cause) => this.stop({ kind: "failed", cause }),
         retire: () => {
           if (this.retained?.decision === decision) this.retained = void 0;
@@ -66,7 +75,7 @@ class SessionInteractionBroker {
       this.retained = { decision, nativeId: native.sessionId };
       this.entered.add(decision);
       decision.observeNativeSignal();
-      if (this.state.kind === "active" || this.state.kind === "open") decision.present(state.owner.interactions.onRequest);
+      if (this.state.kind === "open" || !plan && this.state.kind === "active") decision.present(state.owner.interactions.onRequest);
       return decision.nativeReply;
     } catch (cause) {
       const error = cause instanceof Error ? cause : failure(
@@ -81,6 +90,17 @@ class SessionInteractionBroker {
       return rejected;
     }
   };
+  attachContinuationOwner(prepare) {
+    if (this.prepareContinuation) throw this.stateError();
+    this.prepareContinuation = prepare;
+  }
+  humanTimeoutMs() {
+    if (this.state.kind === "idle" || this.state.kind === "stopped") return DEFAULT_AGENT_SESSION_INTERACTION_LIMITS.requestTimeoutMs;
+    return this.state.owner.interactions.humanWait?.kind === "until_withdrawn_or_closed" ? void 0 : this.state.owner.limits.requestTimeoutMs;
+  }
+  get selectedLifecycle() {
+    return this.input.selection.mapping === "grok-build-1.0.60-session-requests-v1";
+  }
   prepareOpening(input) {
     throwIfAgentOperationAborted(input.signal);
     if (this.state.kind !== "idle") throw this.stateError();
@@ -99,7 +119,7 @@ class SessionInteractionBroker {
   }
   onOpeningDispatched() {
     if (this.state.kind !== "prepared") throw this.stateError();
-    this.state = { kind: "dispatched", owner: this.state.owner };
+    this.state = this.expectedNativeId === void 0 ? { kind: "dispatched", owner: this.state.owner } : { kind: "bound", owner: this.state.owner, nativeId: this.expectedNativeId };
     this.openingTimer = setTimeout(
       () => this.stop({ kind: "failed", cause: failure(
         "acp_session_interaction_opening_timeout",
@@ -109,26 +129,28 @@ class SessionInteractionBroker {
     );
   }
   bindNativeSession(nativeId) {
-    if (this.state.kind !== "dispatched") throw this.stateError();
+    if (this.state.kind !== "dispatched" && this.state.kind !== "prepared") throw this.stateError();
     if (this.retained && this.retained.nativeId !== nativeId) {
       const cause = failure("acp_session_interaction_binding", "The buffered decision claimed a different native session.");
       this.stop({ kind: "failed", cause });
       throw cause;
     }
-    this.state = { kind: "bound", owner: this.state.owner, nativeId };
+    this.expectedNativeId = nativeId;
+    if (this.state.kind === "dispatched") this.state = { kind: "bound", owner: this.state.owner, nativeId };
   }
   completeOpeningResponse() {
     if (this.state.kind !== "bound") throw this.stateError();
     this.clearOpeningTimer();
     const owner = this.state.owner;
     this.state = { kind: "active", owner, nativeId: this.state.nativeId };
-    this.retained?.decision.present(owner.interactions.onRequest);
+    if (this.input.selection.mapping === "grok-folder-trust-v1") this.retained?.decision.present(owner.interactions.onRequest);
     this.throwIfStopped();
   }
   adopt() {
     if (this.state.kind !== "active") throw this.stateError();
     this.state.owner.removeAbort();
     this.state = { kind: "open", owner: this.state.owner, nativeId: this.state.nativeId };
+    this.retained?.decision.present(this.state.owner.interactions.onRequest);
   }
   stop(reason) {
     if (this.state.kind === "stopped") return;

package/dist/sessionInteractions/extensions.d.ts

@@ -1,3 +1,4 @@
 import { type AcpExtensionRegistry } from '@agen-ai/acp-transport';
-export declare function createSessionInteractionExtensionRegistry(): AcpExtensionRegistry;
+import type { AcpSessionInteractionSelection } from './contracts.js';
+export declare function createSessionInteractionExtensionRegistry(selection: AcpSessionInteractionSelection): AcpExtensionRegistry;
 //# sourceMappingURL=extensions.d.ts.map

package/dist/sessionInteractions/extensions.js

@@ -4,7 +4,27 @@ import {
   validateNativeFolderTrustRequest,
   validateNativeFolderTrustResult
 } from "./grokFolderTrust.js";
-function createSessionInteractionExtensionRegistry() {
+import {
+  GROK_PLAN_REVIEW_METHOD,
+  GROK_QUEUE_METHOD,
+  GROK_SESSION_NOTIFICATION_METHOD,
+  validateNativePlanReviewRequest,
+  validateNativePlanReviewResult
+} from "./grokPlanReview.js";
+function sessionNotification(input) {
+  return input !== null && typeof input === "object" && !Array.isArray(input) && "sessionId" in input && typeof input.sessionId === "string" && input.sessionId.length > 0 && input.sessionId.length <= 256;
+}
+function createSessionInteractionExtensionRegistry(selection) {
+  if (selection.mapping === "grok-build-1.0.60-session-requests-v1") return createAcpExtensionRegistry([
+    {
+      method: GROK_PLAN_REVIEW_METHOD,
+      direction: "inbound_request",
+      validateParams: validateNativePlanReviewRequest,
+      validateResult: validateNativePlanReviewResult
+    },
+    { method: GROK_QUEUE_METHOD, direction: "inbound_notification", validateParams: (input) => sessionNotification(input) && "entries" in input && Array.isArray(input.entries) && input.entries.length <= 256 },
+    { method: GROK_SESSION_NOTIFICATION_METHOD, direction: "inbound_notification", validateParams: (input) => sessionNotification(input) && "update" in input && input.update !== null && typeof input.update === "object" && !Array.isArray(input.update) && "sessionUpdate" in input.update && typeof input.update.sessionUpdate === "string" }
+  ]);
   return createAcpExtensionRegistry([{
     method: GROK_FOLDER_TRUST_METHOD,
     direction: "inbound_request",

package/dist/sessionInteractions/grokFolderTrust.d.ts

@@ -37,7 +37,6 @@ export declare function folderTrustDecision(input: Readonly<{
     native: NativeFolderTrustRequest;
     sessionId: AgentSessionId;
     requestNumber: number;
-    expiresAt: number;
 }>): AgentSessionDecisionRequest;
 export {};
 //# sourceMappingURL=grokFolderTrust.d.ts.map

package/dist/sessionInteractions/grokFolderTrust.js

@@ -76,7 +76,6 @@ function folderTrustDecision(input) {
     title: "Allow workspace configuration?",
     description: `Detected configuration: ${detected}. Workspace configuration can start tools or hooks and affect provider behavior. These detected categories do not restrict the scope of an authorization.`,
     target: { kind: "workspace", path: input.native.workspace },
-    expiresAt: new Date(input.expiresAt).toISOString(),
     choices: [
       {
         choiceId: "grant",

package/dist/sessionInteractions/grokPlanReview.d.ts

@@ -0,0 +1,16 @@
+import { type AgentProviderConversationId, type AgentSessionId, type AgentSessionPlanReviewRequest, type AgentSessionPlanReviewResponse } from '@agen-ai/agent-protocol';
+import type { AcpJsonValue } from '@agen-ai/acp-transport';
+export declare const GROK_PLAN_REVIEW_METHOD = "_x.ai/exit_plan_mode";
+export declare const GROK_QUEUE_METHOD = "_x.ai/queue/changed";
+export declare const GROK_SESSION_NOTIFICATION_METHOD = "_x.ai/session_notification";
+export interface NativePlanReviewRequest {
+    readonly sessionId: AgentProviderConversationId;
+    readonly toolCallId: string;
+    readonly planContent: string;
+}
+export declare function parseNativePlanReviewRequest(input: unknown): NativePlanReviewRequest;
+export declare function validateNativePlanReviewRequest(input: unknown): boolean;
+export declare function validateNativePlanReviewResult(input: unknown): boolean;
+export declare function planReviewRequest(native: NativePlanReviewRequest, sessionId: AgentSessionId, requestNumber: number): AgentSessionPlanReviewRequest;
+export declare function nativePlanReviewReply(response: AgentSessionPlanReviewResponse): AcpJsonValue;
+//# sourceMappingURL=grokPlanReview.d.ts.map