@agen-ai/provider-acp 0.4.0 → 0.4.1

package/dist/sessionInteractions/broker.d.ts

@@ -0,0 +1,42 @@
+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 { AcpProviderLimits } from '../limits.js';
+export type SessionInteractionStop = Readonly<{
+    kind: 'session_closed';
+}> | Readonly<{
+    kind: 'failed';
+    cause: Error;
+}>;
+/** One connection owns one create generation and one retained native decision. */
+export declare class SessionInteractionBroker {
+    private readonly input;
+    private state;
+    private requestNumber;
+    private retained;
+    private readonly entered;
+    private openingTimer;
+    private readonly onStopped;
+    readonly handleRequest: (context: AcpReverseRequestContext) => Promise<AcpJsonValue>;
+    constructor(input: Readonly<{
+        stopped: AbortSignal;
+        limits: AcpProviderLimits;
+        onFailure: (cause: Error) => void;
+    }>);
+    prepareOpening(input: Readonly<{
+        sessionId: AgentSessionId;
+        workingDirectory: string;
+        interactions: AgentSessionInteractionContext;
+        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

package/dist/sessionInteractions/broker.js

@@ -0,0 +1,171 @@
+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";
+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;
+  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 {
+      if (context.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 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 (native.cwd !== state.owner.workingDirectory || "nativeId" in state && native.sessionId !== state.nativeId) 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 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: Object.freeze({ id: context.id, signal: context.signal }),
+        expiresAt,
+        accepting: () => this.state.kind === "active" || this.state.kind === "open",
+        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 === "active" || this.state.kind === "open") 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;
+    }
+  };
+  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 = { kind: "dispatched", owner: this.state.owner };
+    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") 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 };
+  }
+  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);
+    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 };
+  }
+  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,3 @@
+import { type AcpExtensionRegistry } from '@agen-ai/acp-transport';
+export declare function createSessionInteractionExtensionRegistry(): AcpExtensionRegistry;
+//# sourceMappingURL=extensions.d.ts.map

package/dist/sessionInteractions/extensions.js

@@ -0,0 +1,17 @@
+import { createAcpExtensionRegistry } from "@agen-ai/acp-transport";
+import {
+  GROK_FOLDER_TRUST_METHOD,
+  validateNativeFolderTrustRequest,
+  validateNativeFolderTrustResult
+} from "./grokFolderTrust.js";
+function createSessionInteractionExtensionRegistry() {
+  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,43 @@
+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;
+    expiresAt: number;
+}>): AgentSessionDecisionRequest;
+export {};
+//# sourceMappingURL=grokFolderTrust.d.ts.map

package/dist/sessionInteractions/grokFolderTrust.js

@@ -0,0 +1,107 @@
+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 },
+    expiresAt: new Date(input.expiresAt).toISOString(),
+    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/request.d.ts

@@ -0,0 +1,38 @@
+import { type AcpJsonValue, type AcpReverseRequestContext } from '@agen-ai/acp-transport';
+import { type AgentError, type AgentSessionDecisionRequest } from '@agen-ai/agent-protocol';
+import { type AgentSessionInteraction, type AgentSessionInteractionHandler, type AgentSessionInteractionTerminal } from '@agen-ai/agent-runtime';
+export declare function sessionDecisionError(code: string, message: string): AgentError;
+export declare class NativeSessionDecision {
+    private readonly input;
+    readonly handle: AgentSessionInteraction;
+    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;
+        nativeContext: Pick<AcpReverseRequestContext, 'id' | 'signal'>;
+        expiresAt: number;
+        accepting: () => boolean;
+        fail: (cause: Error) => void;
+        retire: () => void;
+    }>);
+    observeNativeSignal(): void;
+    present(handler: AgentSessionInteractionHandler): void;
+    stop(terminal: AgentSessionInteractionTerminal, cause: Error): void;
+    private finalize;
+    private expire;
+    private nativeAborted;
+    private respond;
+    private maybeRetire;
+    join(): Promise<void>;
+}
+//# sourceMappingURL=request.d.ts.map

package/dist/sessionInteractions/request.js

@@ -0,0 +1,145 @@
+import { AcpRequestError } from "@agen-ai/acp-transport";
+import {
+  parseAgentSessionDecisionResponseFor
+} from "@agen-ai/agent-protocol";
+import {
+  throwIfAgentOperationAborted
+} from "@agen-ai/agent-runtime";
+import { AcpProviderSessionError } from "../session/errors.js";
+import { deferred } from "../session/queue.js";
+function sessionDecisionError(code, message) {
+  return Object.freeze({ category: "invalid_request", code, message, recovery: Object.freeze({ kind: "none" }) });
+}
+class NativeSessionDecision {
+  constructor(input) {
+    this.input = input;
+    this.handle = Object.freeze({
+      request: input.request,
+      signal: this.presentation.signal,
+      terminal: this.terminal.promise,
+      respond: (response) => this.respond(response)
+    });
+    this.nativeReply = this.answer.promise.then((result) => {
+      this.nativeSettled = true;
+      this.maybeRetire();
+      return result;
+    }, (cause) => {
+      this.nativeSettled = true;
+      this.maybeRetire();
+      throw cause;
+    });
+    void this.nativeReply.catch(() => {
+    });
+    this.timer = setTimeout(() => this.expire(), Math.max(0, input.expiresAt - Date.now()));
+    input.nativeContext.signal.addEventListener("abort", this.onNativeAbort, { once: true });
+  }
+  handle;
+  nativeReply;
+  answer = deferred();
+  terminal = deferred();
+  presentation = new AbortController();
+  state = { kind: "pending" };
+  callback;
+  callbackSettled = true;
+  nativeSettled = false;
+  presented = false;
+  retired = false;
+  timer;
+  onNativeAbort = () => this.nativeAborted();
+  observeNativeSignal() {
+    if (this.input.nativeContext.signal.aborted) this.nativeAborted();
+  }
+  present(handler) {
+    if (this.presented || this.state.kind !== "pending") return;
+    this.observeNativeSignal();
+    if (this.state.kind !== "pending" || !this.input.accepting()) return;
+    if (Date.now() >= this.input.expiresAt) {
+      this.expire();
+      return;
+    }
+    this.presented = true;
+    this.callbackSettled = false;
+    let synchronousFailure;
+    try {
+      this.callback = Promise.resolve(handler(this.handle));
+    } catch (cause) {
+      synchronousFailure = { cause };
+      this.callback = Promise.reject(cause);
+    }
+    void this.callback.then(() => {
+      this.callbackSettled = true;
+      this.maybeRetire();
+    }, (cause) => {
+      this.callbackSettled = true;
+      this.input.fail(callbackError(cause));
+      this.maybeRetire();
+    });
+    if (synchronousFailure) this.input.fail(callbackError(synchronousFailure.cause));
+  }
+  stop(terminal, cause) {
+    if (this.state.kind === "terminal") return;
+    this.finalize(terminal);
+    this.answer.reject(cause);
+  }
+  finalize(terminal) {
+    if (this.state.kind === "terminal") return;
+    this.state = { kind: "terminal", terminal: Object.freeze(terminal) };
+    clearTimeout(this.timer);
+    this.input.nativeContext.signal.removeEventListener("abort", this.onNativeAbort);
+    this.terminal.resolve(this.state.terminal);
+    this.presentation.abort(new DOMException("The session decision is no longer answerable.", "AbortError"));
+    this.maybeRetire();
+  }
+  expire() {
+    if (this.state.kind === "terminal") return;
+    const cause = new AcpProviderSessionError("acp_session_interaction_expired", "The session decision expired before acceptance.");
+    this.stop(Object.freeze({ kind: "expired" }), cause);
+    this.input.fail(cause);
+  }
+  nativeAborted() {
+    if (this.state.kind === "terminal") return;
+    const reason = this.input.nativeContext.signal.reason;
+    if (reason instanceof AcpRequestError && reason.reasonCode === "acp_reverse_request_canceled" && reason.requestId === this.input.nativeContext.id) {
+      this.stop(Object.freeze({ kind: "withdrawn" }), reason);
+      return;
+    }
+    this.input.fail(reason instanceof Error ? reason : new AcpProviderSessionError(
+      "acp_session_interaction_native_failed",
+      "The native session decision producer stopped."
+    ));
+  }
+  async respond(input) {
+    throwIfAgentOperationAborted(input.signal);
+    const response = parseAgentSessionDecisionResponseFor(this.handle.request, { choiceId: input.choiceId });
+    this.observeNativeSignal();
+    if (Date.now() >= this.input.expiresAt) this.expire();
+    if (!this.input.accepting() || this.state.kind === "terminal") {
+      return Object.freeze({ status: "rejected", requestState: "unavailable", error: sessionDecisionError(
+        "session_interaction_unavailable",
+        "The session decision is no longer available."
+      ) });
+    }
+    this.answer.resolve(Object.freeze({ outcome: response.choiceId === "grant" ? "trust" : "reject" }));
+    this.finalize(Object.freeze({ kind: "answered", choiceId: response.choiceId }));
+    return Object.freeze({ status: "delivered" });
+  }
+  maybeRetire() {
+    if (this.retired || this.state.kind !== "terminal" || !this.nativeSettled || !this.callbackSettled) return;
+    this.retired = true;
+    this.input.retire();
+  }
+  async join() {
+    await Promise.allSettled([this.nativeReply, ...this.callback ? [this.callback] : []]);
+  }
+}
+function callbackError(cause) {
+  return cause instanceof Error ? cause : new AcpProviderSessionError(
+    "acp_session_interaction_handler_failed",
+    "The session decision handler failed.",
+    { cause }
+  );
+}
+export {
+  NativeSessionDecision,
+  sessionDecisionError
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/provider-acp",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "private": false,
   "description": "Optional Agent Client Protocol provider for the AgenAI coding-agent runtime.",
   "type": "module",
@@ -27,9 +27,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@agen-ai/acp-transport": "^0.4.0",
-    "@agen-ai/agent-protocol": "^0.4.0",
-    "@agen-ai/agent-runtime": "^0.4.0"
+    "@agen-ai/agent-protocol": "^0.4.1",
+    "@agen-ai/acp-transport": "^0.4.1",
+    "@agen-ai/agent-runtime": "^0.4.1"
   },
   "devDependencies": {
     "tsup": "^8.5.0"