@agen-ai/provider-acp 0.4.0 → 0.4.2

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,10 +15,15 @@ export declare class SessionState {
     private nativeSessionId;
     private turn;
     private failure;
+    private failureObserved;
+    private cleanupFailure;
     private closed;
     private closePromise;
     private itemSequence;
     private requestSequence;
+    private readonly continuations;
+    private readonly descendants;
+    private readonly childWithdrawals;
     constructor(input: CreateAcpProviderSessionInput);
     open(): Promise<AgentProviderSession>;
     private requireUsable;
@@ -29,7 +34,12 @@ export declare class SessionState {
     private observeMetadata;
     private admitRequest;
     private clearTurnTimers;
+    private streamContinuation;
     startTurn(input: AgentProviderStartTurnInput): AgentProviderTurnExecution;
+    private createNativeTurn;
+    private execution;
+    private ownedStream;
+    private completeNativeTurn;
     private launchTurn;
     private emit;
     private drain;
@@ -38,6 +48,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

@@ -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,14 +92,20 @@ 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();
   }
-  input;
   queue;
   operations;
   requests;
@@ -65,18 +119,25 @@ class SessionState {
   nativeSessionId;
   turn;
   failure;
+  failureObserved = false;
+  cleanupFailure;
   closed = false;
   closePromise;
   itemSequence = 0;
   requestSequence = 0;
+  continuations;
+  descendants;
+  childWithdrawals;
   async open() {
     this.requireUsable();
     throwIfAgentOperationAborted(this.input.context.signal);
+    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;
+        sessionInteractions?.bindNativeSession(binding2.conversationId);
         this.bindHostSession();
       },
       observeSetup: (result) => {
@@ -91,7 +152,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 +172,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() {
@@ -121,23 +185,31 @@ 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);
     this.queue.fail(error);
     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(() => void 0);
+    void this.input.connection.close().catch((cause) => {
+      this.cleanupFailure = cause;
+    });
   }
   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);
@@ -147,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.");
     }
@@ -188,22 +260,47 @@ 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,
         nextItemId: () => ++this.itemSequence,
         nextRequestId: () => ++this.requestSequence,
@@ -216,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);
@@ -244,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));
@@ -319,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();
@@ -330,26 +435,42 @@ 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) 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."));
             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) 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.");
@@ -361,6 +482,7 @@ class SessionState {
           turn.terminal = true;
           turn.waiting = void 0;
           turn.mapping.release();
+          this.continuations.complete(turn);
           this.clearTurnTimers();
           return "terminal";
         } finally {
@@ -371,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 }));
@@ -381,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));
@@ -395,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;
@@ -451,27 +579,49 @@ 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.continuations.stop(error);
+      this.descendants?.stop();
+      this.childWithdrawals?.stop(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 {

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

@@ -0,0 +1,50 @@
+import type { AcpJsonValue, AcpReverseRequestContext } from '@agen-ai/acp-transport';
+import type { AgentProviderConversationId, AgentSessionId } from '@agen-ai/agent-protocol';
+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 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;
+    private readonly onStopped;
+    readonly handleRequest: (context: AcpReverseRequestContext) => Promise<AcpJsonValue>;
+    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: AgentProviderSessionInteractionContext;
+        signal?: AbortSignal;
+    }>): void;
+    onOpeningDispatched(): void;
+    bindNativeSession(nativeId: AgentProviderConversationId): void;
+    completeOpeningResponse(): void;
+    adopt(): void;
+    stop(reason: SessionInteractionStop): void;
+    private clearOpeningTimer;
+    private stateError;
+    private throwIfStopped;
+    join(): Promise<void>;
+}
+//# sourceMappingURL=broker.d.ts.map