@agen-ai/provider-acp 0.4.0 → 0.4.2

package/dist/sessionInteractions/request.js

@@ -0,0 +1,173 @@
+import { AcpRequestError } from "@agen-ai/acp-transport";
+import {
+  parseAgentSessionDecisionResponseFor,
+  parseAgentSessionPlanReviewResponseFor
+} from "@agen-ai/agent-protocol";
+import {
+  throwIfAgentOperationAborted
+} from "@agen-ai/agent-runtime";
+import { AcpProviderSessionError } from "../session/errors.js";
+import { deferred } from "../session/queue.js";
+import { nativePlanReviewReply } from "./grokPlanReview.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;
+    const base = {
+      request: input.request,
+      signal: this.presentation.signal,
+      terminal: this.terminal.promise
+    };
+    this.handle = input.request.kind === "plan_review" ? Object.freeze({
+      ...base,
+      kind: "prepared",
+      request: input.request,
+      prepareResponse: (response) => this.prepareResponse(response)
+    }) : Object.freeze({ ...base, kind: "direct", respond: (response) => this.respond(response) });
+    this.nativeReply = this.answer.promise;
+    void input.nativeContext.settled.then(() => {
+      this.nativeSettled = true;
+      this.maybeRetire();
+    });
+    void this.nativeReply.catch(() => {
+    });
+    if (input.hostDeadlineAt !== void 0) this.timer = setTimeout(() => this.expire(), Math.max(0, input.hostDeadlineAt - 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 (this.input.hostDeadlineAt !== void 0 && Date.now() >= this.input.hostDeadlineAt) {
+      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", source: "host_policy" }), 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);
+    if (this.input.request.kind !== "decision") throw new TypeError("Plan review requires prepared response ownership.");
+    const response = parseAgentSessionDecisionResponseFor(this.input.request, { kind: input.kind, choiceId: input.choiceId });
+    this.observeNativeSignal();
+    if (this.input.hostDeadlineAt !== void 0 && Date.now() >= this.input.hostDeadlineAt) 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", response }));
+    return Object.freeze({ status: "delivered" });
+  }
+  prepareResponse(input) {
+    throwIfAgentOperationAborted(input.signal);
+    if (this.input.request.kind !== "plan_review" || !this.input.prepareContinuation) throw new TypeError("This request has no continuation mapping.");
+    const response = parseAgentSessionPlanReviewResponseFor(this.input.request, input.response);
+    return this.input.prepareContinuation({ response, signal: input.signal, nativeSettled: this.input.nativeContext.settled, dispatch: async () => {
+      throwIfAgentOperationAborted(input.signal);
+      this.observeNativeSignal();
+      if (this.input.hostDeadlineAt !== void 0 && Date.now() >= this.input.hostDeadlineAt) this.expire();
+      if (!this.input.accepting() || this.state.kind === "terminal") return Object.freeze({
+        status: "rejected",
+        requestState: "unavailable",
+        error: sessionDecisionError("session_interaction_unavailable", "The plan review is no longer available.")
+      });
+      this.answer.resolve(nativePlanReviewReply(response));
+      this.finalize(Object.freeze({ kind: "answered", response: Object.freeze({
+        kind: "plan_review",
+        action: response.action,
+        choiceId: response.choiceId,
+        planId: response.planId,
+        revision: response.revision
+      }) }));
+      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.input.nativeContext.settled, ...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.2",
   "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/acp-transport": "^0.4.2",
+    "@agen-ai/agent-runtime": "^0.4.2",
+    "@agen-ai/agent-protocol": "^0.4.2"
   },
   "devDependencies": {
     "tsup": "^8.5.0"