@agen-ai/provider-acp 0.4.1 → 0.4.2

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

@@ -1,10 +1,16 @@
 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';
+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: AgentSessionInteraction;
+    readonly handle: AgentProviderSessionInteraction;
     readonly nativeReply: Promise<AcpJsonValue>;
     private readonly answer;
     private readonly terminal;
@@ -18,20 +24,22 @@ export declare class NativeSessionDecision {
     private readonly timer;
     private readonly onNativeAbort;
     constructor(input: Readonly<{
-        request: AgentSessionDecisionRequest;
-        nativeContext: Pick<AcpReverseRequestContext, 'id' | 'signal'>;
-        expiresAt: number;
+        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: AgentSessionInteractionHandler): 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>;
 }

package/dist/sessionInteractions/request.js

@@ -1,36 +1,39 @@
 import { AcpRequestError } from "@agen-ai/acp-transport";
 import {
-  parseAgentSessionDecisionResponseFor
+  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;
-    this.handle = Object.freeze({
+    const base = {
       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) => {
+      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();
-      throw cause;
     });
     void this.nativeReply.catch(() => {
     });
-    this.timer = setTimeout(() => this.expire(), Math.max(0, input.expiresAt - Date.now()));
+    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;
@@ -53,7 +56,7 @@ class NativeSessionDecision {
     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) {
+    if (this.input.hostDeadlineAt !== void 0 && Date.now() >= this.input.hostDeadlineAt) {
       this.expire();
       return;
     }
@@ -93,7 +96,7 @@ class NativeSessionDecision {
   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.stop(Object.freeze({ kind: "expired", source: "host_policy" }), cause);
     this.input.fail(cause);
   }
   nativeAborted() {
@@ -110,9 +113,10 @@ class NativeSessionDecision {
   }
   async respond(input) {
     throwIfAgentOperationAborted(input.signal);
-    const response = parseAgentSessionDecisionResponseFor(this.handle.request, { choiceId: input.choiceId });
+    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 (Date.now() >= this.input.expiresAt) this.expire();
+    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",
@@ -120,16 +124,40 @@ class NativeSessionDecision {
       ) });
     }
     this.answer.resolve(Object.freeze({ outcome: response.choiceId === "grant" ? "trust" : "reject" }));
-    this.finalize(Object.freeze({ kind: "answered", choiceId: response.choiceId }));
+    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.nativeReply, ...this.callback ? [this.callback] : []]);
+    await Promise.allSettled([this.input.nativeContext.settled, ...this.callback ? [this.callback] : []]);
   }
 }
 function callbackError(cause) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/provider-acp",
-  "version": "0.4.1",
+  "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/agent-protocol": "^0.4.1",
-    "@agen-ai/acp-transport": "^0.4.1",
-    "@agen-ai/agent-runtime": "^0.4.1"
+    "@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"