@agen-ai/provider-acp 0.4.0 → 0.4.2

package/dist/sessionInteractions/broker.js

@@ -0,0 +1,193 @@
+import {
+  DEFAULT_AGENT_SESSION_INTERACTION_LIMITS,
+  throwIfAgentOperationAborted
+} from "@agen-ai/agent-runtime";
+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;
+    input.stopped.addEventListener("abort", this.onStopped, { once: true });
+    if (input.stopped.aborted) this.onStopped();
+  }
+  state = { kind: "idle" };
+  requestNumber = 0;
+  expectedNativeId;
+  prepareContinuation;
+  retained;
+  entered = /* @__PURE__ */ new Set();
+  openingTimer;
+  onStopped = () => {
+    const cause = this.input.stopped.reason;
+    this.stop({ kind: "failed", cause: cause instanceof Error ? cause : new AcpProviderSessionError(
+      "acp_session_interaction_native_failed",
+      "The native session decision producer stopped."
+    ) });
+  };
+  handleRequest = (context) => {
+    try {
+      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 = 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(
+        "acp_session_interaction_owner_missing",
+        "The native decision has no dispatched session opening owner."
+      );
+      if (this.retained) throw failure(
+        "acp_session_interaction_capacity",
+        "The connection already retains a native session decision."
+      );
+      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 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(
+        "acp_session_interaction_capacity",
+        "The native session decision exceeds its retained byte budget."
+      );
+      const decision = new NativeSessionDecision({
+        request,
+        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;
+          this.entered.delete(decision);
+        }
+      });
+      this.retained = { decision, nativeId: native.sessionId };
+      this.entered.add(decision);
+      decision.observeNativeSignal();
+      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(
+        "acp_session_interaction_invalid",
+        "The native session decision could not be admitted.",
+        cause
+      );
+      this.stop({ kind: "failed", cause: error });
+      const rejected = Promise.reject(error);
+      void rejected.catch(() => {
+      });
+      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();
+    const onAbort = () => this.stop({ kind: "failed", cause: input.signal?.reason instanceof Error ? input.signal.reason : new DOMException("The session opening was aborted.", "AbortError") });
+    const owner = Object.freeze({
+      sessionId: input.sessionId,
+      workingDirectory: input.workingDirectory,
+      interactions: input.interactions,
+      limits: Object.freeze({ ...DEFAULT_AGENT_SESSION_INTERACTION_LIMITS, ...input.interactions.limits }),
+      removeAbort: () => input.signal?.removeEventListener("abort", onAbort)
+    });
+    this.state = { kind: "prepared", owner };
+    input.signal?.addEventListener("abort", onAbort, { once: true });
+    if (input.signal?.aborted) onAbort();
+    this.throwIfStopped();
+  }
+  onOpeningDispatched() {
+    if (this.state.kind !== "prepared") throw this.stateError();
+    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",
+        "The native decision opening did not bind before its deadline."
+      ) }),
+      this.input.limits.initializationTimeoutMs
+    );
+  }
+  bindNativeSession(nativeId) {
+    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.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 };
+    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;
+    const cause = reason.kind === "failed" ? reason.cause : failure(
+      "acp_session_interaction_closed",
+      "The session decision owner was closed."
+    );
+    if (this.state.kind !== "idle") this.state.owner.removeAbort();
+    this.clearOpeningTimer();
+    this.state = { kind: "stopped", cause };
+    this.retained?.decision.stop(reason.kind === "failed" ? Object.freeze({ kind: "failed", error: sessionDecisionError(
+      "session_interaction_failed",
+      "The session decision owner failed."
+    ) }) : Object.freeze({ kind: "session_closed" }), cause);
+    if (reason.kind === "failed") this.input.onFailure(cause);
+  }
+  clearOpeningTimer() {
+    if (this.openingTimer) clearTimeout(this.openingTimer);
+    this.openingTimer = void 0;
+  }
+  stateError() {
+    return this.state.kind === "stopped" ? this.state.cause : failure(
+      "acp_session_interaction_binding",
+      "The native session interaction lifecycle is out of order."
+    );
+  }
+  throwIfStopped() {
+    if (this.state.kind === "stopped") throw this.state.cause;
+  }
+  async join() {
+    while (this.entered.size > 0) await Promise.all([...this.entered].map((decision) => decision.join()));
+    if (this.state.kind === "stopped") this.input.stopped.removeEventListener("abort", this.onStopped);
+  }
+}
+function failure(reasonCode, message, cause) {
+  return new AcpProviderSessionError(reasonCode, message, cause === void 0 ? void 0 : { cause });
+}
+export {
+  SessionInteractionBroker
+};

package/dist/sessionInteractions/contracts.d.ts

@@ -0,0 +1,3 @@
+import type { CreateNodeAcpProviderDriverOptions } from '../node/contracts.js';
+export type AcpSessionInteractionSelection = NonNullable<CreateNodeAcpProviderDriverOptions['sessionInteractions']>;
+//# sourceMappingURL=contracts.d.ts.map

package/dist/sessionInteractions/extensions.d.ts

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

package/dist/sessionInteractions/extensions.js

@@ -0,0 +1,37 @@
+import { createAcpExtensionRegistry } from "@agen-ai/acp-transport";
+import {
+  GROK_FOLDER_TRUST_METHOD,
+  validateNativeFolderTrustRequest,
+  validateNativeFolderTrustResult
+} from "./grokFolderTrust.js";
+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",
+    validateParams: validateNativeFolderTrustRequest,
+    validateResult: validateNativeFolderTrustResult
+  }]);
+}
+export {
+  createSessionInteractionExtensionRegistry
+};

package/dist/sessionInteractions/grokFolderTrust.d.ts

@@ -0,0 +1,42 @@
+import { type AgentProviderConversationId, type AgentSessionDecisionRequest, type AgentSessionId } from '@agen-ai/agent-protocol';
+export declare const GROK_FOLDER_TRUST_METHOD = "_x.ai/folder_trust/request";
+export declare const GROK_FOLDER_TRUST_CAPABILITY_META: Readonly<{
+    'x.ai/folderTrust': Readonly<{
+        interactive: true;
+    }>;
+}>;
+declare const CONFIGURATION_EXPLANATIONS: Readonly<{
+    mcp: "Project tool servers";
+    plugins: "Project plugins";
+    permission: "Project tool-permission rules";
+    lsp: "Project language servers";
+    envrc: "Project shell environment scripts";
+    claude: "Imported compatibility settings";
+    hooks: "Project hooks";
+    agents: "Project agent definitions";
+    roles: "Project role definitions";
+    personas: "Project persona definitions";
+    workflows: "Project workflows";
+    instructions: "Project instructions";
+    skills: "Project skills";
+}>;
+type ConfigurationKind = keyof typeof CONFIGURATION_EXPLANATIONS;
+export interface NativeFolderTrustRequest {
+    readonly sessionId: AgentProviderConversationId;
+    readonly cwd: string;
+    readonly workspace: string;
+    readonly configKinds: readonly ConfigurationKind[];
+}
+export type NativeFolderTrustResult = Readonly<{
+    outcome: 'trust' | 'reject';
+}>;
+export declare function parseNativeFolderTrustRequest(input: unknown): NativeFolderTrustRequest;
+export declare function validateNativeFolderTrustRequest(input: unknown): boolean;
+export declare function validateNativeFolderTrustResult(input: unknown): boolean;
+export declare function folderTrustDecision(input: Readonly<{
+    native: NativeFolderTrustRequest;
+    sessionId: AgentSessionId;
+    requestNumber: number;
+}>): AgentSessionDecisionRequest;
+export {};
+//# sourceMappingURL=grokFolderTrust.d.ts.map

package/dist/sessionInteractions/grokFolderTrust.js

@@ -0,0 +1,106 @@
+import { posix } from "node:path";
+import {
+  parseAgentProviderConversationId,
+  parseAgentSessionDecisionRequest
+} from "@agen-ai/agent-protocol";
+import { AcpProviderSessionError } from "../session/errors.js";
+const GROK_FOLDER_TRUST_METHOD = "_x.ai/folder_trust/request";
+const GROK_FOLDER_TRUST_CAPABILITY_META = Object.freeze({
+  "x.ai/folderTrust": Object.freeze({ interactive: true })
+});
+const CONFIGURATION_EXPLANATIONS = Object.freeze({
+  mcp: "Project tool servers",
+  plugins: "Project plugins",
+  permission: "Project tool-permission rules",
+  lsp: "Project language servers",
+  envrc: "Project shell environment scripts",
+  claude: "Imported compatibility settings",
+  hooks: "Project hooks",
+  agents: "Project agent definitions",
+  roles: "Project role definitions",
+  personas: "Project persona definitions",
+  workflows: "Project workflows",
+  instructions: "Project instructions",
+  skills: "Project skills"
+});
+function configurationKind(input) {
+  return typeof input === "string" && Object.hasOwn(CONFIGURATION_EXPLANATIONS, input);
+}
+function exactObject(input, keys) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return false;
+  const own = Reflect.ownKeys(input);
+  return own.length === keys.length && keys.every((key) => Object.hasOwn(input, key));
+}
+function invalidRequest() {
+  return new AcpProviderSessionError("acp_session_interaction_invalid", "The native workspace decision violates the selected mapping.");
+}
+function workspacePath(input) {
+  if (typeof input !== "string" || input.length === 0 || Buffer.byteLength(input, "utf8") > 4096 || /[\p{Cc}\p{Cf}]/u.test(input) || !posix.isAbsolute(input) || posix.normalize(input) !== input) {
+    throw invalidRequest();
+  }
+  return input;
+}
+function parseNativeFolderTrustRequest(input) {
+  if (!exactObject(input, ["sessionId", "cwd", "workspace", "configKinds"]) || Buffer.byteLength(JSON.stringify(input), "utf8") > 65536 || typeof input.sessionId !== "string" || Buffer.byteLength(input.sessionId, "utf8") > 512 || !Array.isArray(input.configKinds) || input.configKinds.length < 1 || input.configKinds.length > 13) {
+    throw invalidRequest();
+  }
+  const kinds = [];
+  for (const kind of input.configKinds) {
+    if (!configurationKind(kind) || kinds.includes(kind)) throw invalidRequest();
+    kinds.push(kind);
+  }
+  return Object.freeze({
+    sessionId: parseAgentProviderConversationId(input.sessionId),
+    cwd: workspacePath(input.cwd),
+    workspace: workspacePath(input.workspace),
+    configKinds: Object.freeze(kinds)
+  });
+}
+function validateNativeFolderTrustRequest(input) {
+  try {
+    parseNativeFolderTrustRequest(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateNativeFolderTrustResult(input) {
+  return exactObject(input, ["outcome"]) && (input.outcome === "trust" || input.outcome === "reject");
+}
+function folderTrustDecision(input) {
+  const detected = input.native.configKinds.map((kind) => CONFIGURATION_EXPLANATIONS[kind]).join("; ");
+  return parseAgentSessionDecisionRequest({
+    kind: "decision",
+    requestId: `session-interaction:${input.requestNumber}`,
+    sessionId: input.sessionId,
+    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 },
+    choices: [
+      {
+        choiceId: "grant",
+        label: "Allow workspace configuration",
+        description: "Authorize configuration for the target workspace, including future configuration. The provider manages persistent trust, which may affect later or sibling sessions using the same profile. This choice does not confirm immediate loading or successful persistence.",
+        consequence: {
+          kind: "grant",
+          scope: "workspace",
+          persistence: { kind: "provider_managed", duration: "persistent", mayAffectOtherSessions: true }
+        }
+      },
+      {
+        choiceId: "decline",
+        label: "Keep configuration gated",
+        description: "Keep workspace configuration gated. Repeat questions may be suppressed for this workspace while this native agent lives. This choice does not revoke an existing grant or promise a persisted denial.",
+        consequence: { kind: "decline", configuration: "remains_gated" }
+      }
+    ]
+  });
+}
+export {
+  GROK_FOLDER_TRUST_CAPABILITY_META,
+  GROK_FOLDER_TRUST_METHOD,
+  folderTrustDecision,
+  parseNativeFolderTrustRequest,
+  validateNativeFolderTrustRequest,
+  validateNativeFolderTrustResult
+};

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

package/dist/sessionInteractions/grokPlanReview.js

@@ -0,0 +1,63 @@
+import {
+  parseAgentProviderConversationId,
+  parseAgentSessionPlanReviewRequest
+} from "@agen-ai/agent-protocol";
+import { AcpProviderSessionError } from "../session/errors.js";
+const GROK_PLAN_REVIEW_METHOD = "_x.ai/exit_plan_mode";
+const GROK_QUEUE_METHOD = "_x.ai/queue/changed";
+const GROK_SESSION_NOTIFICATION_METHOD = "_x.ai/session_notification";
+function parseNativePlanReviewRequest(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input) || Reflect.ownKeys(input).length !== 3 || !("sessionId" in input) || !("toolCallId" in input) || !("planContent" in input) || typeof input.sessionId !== "string" || Buffer.byteLength(input.sessionId, "utf8") > 256 || typeof input.toolCallId !== "string" || !input.toolCallId || Buffer.byteLength(input.toolCallId, "utf8") > 256 || typeof input.planContent !== "string" || !input.planContent || Buffer.byteLength(input.planContent, "utf8") > 65536) {
+    throw new AcpProviderSessionError("acp_session_interaction_invalid", "The native plan review violates the selected mapping.");
+  }
+  return Object.freeze({
+    sessionId: parseAgentProviderConversationId(input.sessionId),
+    toolCallId: input.toolCallId,
+    planContent: input.planContent
+  });
+}
+function validateNativePlanReviewRequest(input) {
+  try {
+    parseNativePlanReviewRequest(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateNativePlanReviewResult(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input) || !("outcome" in input)) return false;
+  return input.outcome === "cancelled" ? Reflect.ownKeys(input).length === 2 && "feedback" in input && typeof input.feedback === "string" && Buffer.byteLength(input.feedback, "utf8") <= 16384 : Reflect.ownKeys(input).length === 1 && (input.outcome === "approved" || input.outcome === "abandoned");
+}
+function planReviewRequest(native, sessionId, requestNumber) {
+  return parseAgentSessionPlanReviewRequest({
+    kind: "plan_review",
+    requestId: `session-interaction:${requestNumber}`,
+    sessionId,
+    title: "Review the restored plan",
+    plan: {
+      planId: `session-plan:${requestNumber}`,
+      revision: "1",
+      title: "Restored plan",
+      content: { kind: "text", format: "markdown", text: native.planContent }
+    },
+    choices: [
+      { choiceId: "approve", action: "approve", label: "Approve plan" },
+      { choiceId: "revise", action: "revise", label: "Revise plan" },
+      { choiceId: "abandon", action: "abandon", label: "Abandon plan" }
+    ]
+  });
+}
+function nativePlanReviewReply(response) {
+  if (response.action === "revise") return Object.freeze({ outcome: "cancelled", feedback: response.feedback });
+  return Object.freeze({ outcome: response.action === "approve" ? "approved" : "abandoned" });
+}
+export {
+  GROK_PLAN_REVIEW_METHOD,
+  GROK_QUEUE_METHOD,
+  GROK_SESSION_NOTIFICATION_METHOD,
+  nativePlanReviewReply,
+  parseNativePlanReviewRequest,
+  planReviewRequest,
+  validateNativePlanReviewRequest,
+  validateNativePlanReviewResult
+};

package/dist/sessionInteractions/request.d.ts

@@ -0,0 +1,46 @@
+import { type AcpJsonValue, type AcpReverseRequestContext } from '@agen-ai/acp-transport';
+import { type AgentError, type AgentSessionDecisionRequest, type AgentSessionPlanReviewRequest, type AgentSessionPlanReviewResponse } from '@agen-ai/agent-protocol';
+import { type AgentRequestResolutionResult, type AgentProviderSessionInteraction, type AgentPreparedSessionResponse, type AgentProviderSessionInteractionContext, type AgentSessionInteractionTerminal } from '@agen-ai/agent-runtime';
+export type PreparePlanContinuation = (input: Readonly<{
+    response: AgentSessionPlanReviewResponse;
+    signal: AbortSignal;
+    nativeSettled: Promise<void>;
+    dispatch: () => Promise<AgentRequestResolutionResult>;
+}>) => AgentPreparedSessionResponse;
+export declare function sessionDecisionError(code: string, message: string): AgentError;
+export declare class NativeSessionDecision {
+    private readonly input;
+    readonly handle: AgentProviderSessionInteraction;
+    readonly nativeReply: Promise<AcpJsonValue>;
+    private readonly answer;
+    private readonly terminal;
+    private readonly presentation;
+    private state;
+    private callback;
+    private callbackSettled;
+    private nativeSettled;
+    private presented;
+    private retired;
+    private readonly timer;
+    private readonly onNativeAbort;
+    constructor(input: Readonly<{
+        request: AgentSessionDecisionRequest | AgentSessionPlanReviewRequest;
+        nativeContext: Pick<AcpReverseRequestContext, 'id' | 'signal' | 'settled'>;
+        hostDeadlineAt?: number;
+        prepareContinuation?: PreparePlanContinuation;
+        accepting: () => boolean;
+        fail: (cause: Error) => void;
+        retire: () => void;
+    }>);
+    observeNativeSignal(): void;
+    present(handler: AgentProviderSessionInteractionContext['onRequest']): void;
+    stop(terminal: AgentSessionInteractionTerminal, cause: Error): void;
+    private finalize;
+    private expire;
+    private nativeAborted;
+    private respond;
+    private prepareResponse;
+    private maybeRetire;
+    join(): Promise<void>;
+}
+//# sourceMappingURL=request.d.ts.map