@agen-ai/provider-acp 0.4.1 → 0.4.3

package/dist/session/requests/grokWithdrawals.js

@@ -0,0 +1,135 @@
+import { AcpProviderSessionError } from "../errors.js";
+import { nativeIdentity, nativeObject } from "../native.js";
+import { deferred } from "../queue.js";
+const PERMISSION_STATE_OVERHEAD_BYTES = 256;
+class GrokChildPermissionWithdrawals {
+  constructor(input) {
+    this.input = input;
+  }
+  children = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  observe(identity, update) {
+    if (identity.attemptId === void 0 || update.sessionUpdate !== "pending_interaction" && update.sessionUpdate !== "interaction_resolved") return;
+    if (update.sessionUpdate === "pending_interaction" && update.kind !== "permission") return;
+    const toolId = nativeIdentity(update.tool_call_id, "child permission tool identity");
+    const child = this.child(identity);
+    const prior = child.interactions.get(toolId);
+    if (update.sessionUpdate === "pending_interaction") {
+      const turn2 = this.input.currentTurn();
+      if (child.finished || prior?.phase.kind === "retired" || !turn2 || turn2.nativeSettled || turn2.terminal || prior && prior.phase.turn !== turn2) throw this.stale();
+      if (!prior) child.interactions.set(toolId, {
+        phase: { kind: "announced", turn: turn2 },
+        release: this.input.reserveState({ childSessionId: identity.childSessionId, toolId }, PERMISSION_STATE_OVERHEAD_BYTES)
+      });
+      return;
+    }
+    if (!prior) {
+      child.interactions.set(toolId, {
+        phase: { kind: "retired" },
+        release: this.input.reserveState({ childSessionId: identity.childSessionId, toolId }, PERMISSION_STATE_OVERHEAD_BYTES)
+      });
+      return;
+    }
+    if (prior.phase.kind === "announced") {
+      prior.phase = { kind: "retired" };
+      return;
+    }
+    if (prior.phase.kind !== "attached") return;
+    const { turn, request } = prior.phase;
+    if (turn !== this.input.currentTurn() || turn.nativeSettled || turn.terminal) throw this.stale();
+    const hold = request.answered ? void 0 : { ready: deferred(), timer: setTimeout(
+      () => this.input.fail(
+        new AcpProviderSessionError("acp_native_permission_uncertain", "The resolved native child permission lacks exact cancellation corroboration.")
+      ),
+      this.input.timeoutMs
+    ) };
+    if (hold) void hold.ready.promise.catch(() => {
+    });
+    prior.phase = { kind: "resolved", turn, request, hold };
+  }
+  attach(request) {
+    if (request.kind !== "permission") return;
+    const tool = nativeObject(request.params.toolCall, "permission tool");
+    const meta = tool._meta === void 0 ? void 0 : nativeObject(tool._meta, "permission tool metadata");
+    if (meta?.["x.ai/requestingSessionId"] === void 0) return;
+    const childId = nativeIdentity(meta["x.ai/requestingSessionId"], "requesting child session identity");
+    if (childId === request.params.sessionId) return;
+    const child = this.children.get(childId);
+    if (!child) return;
+    const interaction = child.interactions.get(nativeIdentity(tool.toolCallId, "permission tool identity"));
+    if (child.finished || interaction && (interaction.phase.kind !== "announced" || interaction.phase.turn !== this.input.currentTurn())) throw this.stale();
+    if (!interaction || interaction.phase.kind !== "announced") return;
+    interaction.phase = { kind: "attached", turn: interaction.phase.turn, request };
+    this.requests.set(request, interaction);
+  }
+  finish(identity, update) {
+    if (identity.attemptId === void 0) return;
+    if (nativeIdentity(update.subagent_id, "finished subagent identity") !== identity.subagentId || nativeIdentity(update.attempt_id, "finished attempt identity") !== identity.attemptId) throw new AcpProviderSessionError(
+      "acp_native_permission_identity_conflict",
+      "The native child finish does not identify its exact announced attempt."
+    );
+    const child = this.child(identity);
+    if (child.finished) return;
+    child.finished = true;
+    for (const interaction of child.interactions.values()) {
+      const phase = interaction.phase;
+      if (phase.kind !== "attached" && phase.kind !== "resolved" || phase.turn !== this.input.currentTurn() || phase.turn.nativeSettled || phase.turn.terminal) continue;
+      if (phase.kind !== "resolved" || update.status !== "cancelled") {
+        if (!phase.request.answered) throw new AcpProviderSessionError(
+          "acp_native_permission_uncertain",
+          "The native child finish lacks the exact ordered permission cancellation facts."
+        );
+        continue;
+      }
+      this.input.withdraw(phase.request);
+      this.retire(interaction);
+    }
+  }
+  answerGate(request) {
+    const phase = this.requests.get(request)?.phase;
+    return phase?.kind === "resolved" ? phase.hold?.ready.promise : void 0;
+  }
+  settle(request) {
+    const interaction = this.requests.get(request);
+    if (interaction) this.retire(interaction);
+    this.requests.delete(request);
+  }
+  child(identity) {
+    let child = this.children.get(identity.childSessionId);
+    if (!child) {
+      child = { interactions: /* @__PURE__ */ new Map(), finished: false, release: this.input.reserveState({
+        childSessionId: identity.childSessionId,
+        subagentId: identity.subagentId,
+        attemptId: identity.attemptId
+      }) };
+      this.children.set(identity.childSessionId, child);
+    }
+    return child;
+  }
+  retire(interaction, error) {
+    const phase = interaction.phase;
+    if (phase.kind === "resolved" && phase.hold) {
+      clearTimeout(phase.hold.timer);
+      if (error) phase.hold.ready.reject(error);
+      else phase.hold.ready.resolve();
+    }
+    interaction.phase = { kind: "retired" };
+  }
+  stale() {
+    return new AcpProviderSessionError("acp_native_permission_stale", "The native child permission does not identify a fresh callback in its original turn.");
+  }
+  stop(error) {
+    for (const child of this.children.values()) {
+      for (const interaction of child.interactions.values()) {
+        this.retire(interaction, error);
+        interaction.release();
+      }
+      child.release();
+    }
+    this.children.clear();
+    this.requests.clear();
+  }
+}
+export {
+  GrokChildPermissionWithdrawals
+};

package/dist/session/requests/pending.d.ts

@@ -1,5 +1,5 @@
-import type { AcpJsonObject, AcpJsonValue, AcpReverseRequestContext } from '@agen-ai/acp-transport';
-import type { AgentRequest } from '@agen-ai/agent-protocol';
+import { type AcpJsonObject, type AcpJsonValue, type AcpReverseRequestContext } from '@agen-ai/acp-transport';
+import type { AgentRequest, AgentRequestId } from '@agen-ai/agent-protocol';
 import type { MappedPermission } from '../mapping.js';
 import { deferred, type QueueEntry } from '../queue.js';
 import type { AcpFormFlow, PreparedAcpForm } from './forms.js';
@@ -16,12 +16,16 @@ export interface PendingSessionRequest {
     readonly kind: 'permission' | 'form';
     readonly params: AcpJsonObject;
     readonly form?: PreparedAcpForm;
-    readonly host?: () => Promise<AcpJsonValue>;
+    readonly host?: (observeCallback: (work: Promise<void>) => void) => Promise<AcpJsonValue>;
+    hostWork: Promise<void> | undefined;
     readonly response: ReturnType<typeof deferred<AcpJsonValue>>;
     readonly signal: AbortSignal;
+    readonly transportSettled: Promise<void>;
     entry: QueueEntry<unknown> | undefined;
     mapped: MappedSessionRequest | undefined;
     answered: boolean;
+    publishedRequestId: AgentRequestId | undefined;
+    unavailable: boolean;
     readonly onAbort: () => void;
 }
 export declare function canceledRequestReply(kind: PendingSessionRequest['kind']): AcpJsonValue;
@@ -29,14 +33,23 @@ export declare function canceledRequestReply(kind: PendingSessionRequest['kind']
 export declare class PendingSessionRequests {
     private readonly input;
     private readonly pending;
+    private readonly retained;
+    private retainedBytes;
     constructor(input: {
         readonly maxPendingRequests: number;
+        readonly maxRequestMaterialBytes: number;
         readonly admit: (request: PendingSessionRequest, bytes: number) => QueueEntry<unknown>;
         readonly fail: (error: Error) => void;
+        readonly unavailable: (request: PendingSessionRequest, requestId: AgentRequestId) => void;
+        readonly settled: (request: PendingSessionRequest) => void;
+        readonly admitted?: (request: PendingSessionRequest) => void;
     });
     get size(): number;
-    admit(context: AcpReverseRequestContext, kind: PendingSessionRequest['kind'], params: AcpJsonObject, form?: PreparedAcpForm, host?: () => Promise<AcpJsonValue>): Promise<AcpJsonValue>;
+    admit(context: AcpReverseRequestContext, kind: PendingSessionRequest['kind'], params: AcpJsonObject, form?: PreparedAcpForm, host?: PendingSessionRequest['host']): Promise<AcpJsonValue>;
     canAnswer(request: PendingSessionRequest): boolean;
+    withdraw(request: PendingSessionRequest, error: Error): void;
+    invokeHost(request: PendingSessionRequest): Promise<AcpJsonValue>;
+    join(): Promise<void>;
     answer(request: PendingSessionRequest, result: AcpJsonValue): boolean;
     reject(request: PendingSessionRequest, error: Error): void;
     private release;

package/dist/session/requests/pending.js

@@ -1,3 +1,4 @@
+import { AcpRequestError } from "@agen-ai/acp-transport";
 import { AcpProviderSessionError } from "../errors.js";
 import { nativeBytes } from "../native.js";
 import { deferred } from "../queue.js";
@@ -9,16 +10,24 @@ class PendingSessionRequests {
     this.input = input;
   }
   pending = /* @__PURE__ */ new Set();
+  retained = /* @__PURE__ */ new Set();
+  retainedBytes = 0;
   get size() {
     return this.pending.size;
   }
   admit(context, kind, params, form, host) {
-    if (this.pending.size >= this.input.maxPendingRequests) {
+    if (this.retained.size >= this.input.maxPendingRequests) {
       const error = new AcpProviderSessionError("acp_request_queue_full", "The ACP pending request budget is exhausted.");
       this.input.fail(error);
       throw error;
     }
     const response = deferred();
+    const bytes = nativeBytes(params) * 2 + (form ? nativeBytes(form) : 0);
+    if (this.retainedBytes + bytes > this.input.maxRequestMaterialBytes) {
+      const error = new AcpProviderSessionError("acp_session_queue_full", "The ACP retained request material budget is exhausted.");
+      this.input.fail(error);
+      throw error;
+    }
     const request = {
       kind,
       params,
@@ -26,18 +35,37 @@ class PendingSessionRequests {
       ...host === void 0 ? {} : { host },
       response,
       signal: context.signal,
+      transportSettled: context.settled,
       entry: void 0,
       mapped: void 0,
       answered: false,
+      publishedRequestId: void 0,
+      unavailable: false,
+      hostWork: void 0,
       onAbort: () => {
-        this.cancel(request);
-        this.input.fail(new AcpProviderSessionError("acp_request_revoked", "The peer canceled a pending ACP interaction request."));
+        const cause = context.signal.reason;
+        if (cause instanceof AcpRequestError && cause.reasonCode === "acp_reverse_request_canceled" && cause.requestId === context.id) {
+          this.withdraw(request, cause);
+          return;
+        }
+        this.input.fail(cause instanceof Error ? cause : new AcpProviderSessionError("acp_request_revoked", "The native callback producer stopped."));
       }
     };
     try {
-      request.entry = this.input.admit(request, nativeBytes(params) * 2 + (form ? nativeBytes(form) : 0));
+      request.entry = this.input.admit(request, bytes);
       this.pending.add(request);
+      this.retained.add(request);
+      this.retainedBytes += bytes;
+      void context.settled.then(async () => {
+        await request.hostWork;
+        context.signal.removeEventListener("abort", request.onAbort);
+        this.retained.delete(request);
+        this.retainedBytes -= bytes;
+        request.entry?.release();
+        this.input.settled(request);
+      });
       context.signal.addEventListener("abort", request.onAbort, { once: true });
+      this.input.admitted?.(request);
       if (context.signal.aborted) request.onAbort();
       return response.promise;
     } catch (error) {
@@ -46,7 +74,37 @@ class PendingSessionRequests {
     }
   }
   canAnswer(request) {
-    return this.pending.has(request) && !request.answered && !request.signal.aborted;
+    return this.pending.has(request) && !request.answered && !request.unavailable && !request.signal.aborted;
+  }
+  withdraw(request, error) {
+    if (request.unavailable) return;
+    request.unavailable = true;
+    if (request.publishedRequestId !== void 0 && request.publishedRequestId === request.mapped?.request.requestId) {
+      this.input.unavailable(request, request.publishedRequestId);
+    }
+    if (!request.answered) this.reject(request, error);
+  }
+  invokeHost(request) {
+    if (!request.host) throw new TypeError("The native request has no host callback.");
+    const joined = deferred();
+    request.hostWork = joined.promise;
+    let callback = Promise.resolve();
+    let work;
+    try {
+      work = request.host((actual) => {
+        callback = actual;
+      });
+    } catch (cause) {
+      work = Promise.reject(cause);
+    }
+    void work.then(() => callback, () => callback).then(joined.resolve, () => joined.resolve());
+    return work;
+  }
+  async join() {
+    while (this.retained.size > 0) await Promise.all([...this.retained].map(async (request) => {
+      await request.transportSettled;
+      await request.hostWork;
+    }));
   }
   answer(request, result) {
     if (!this.canAnswer(request) || !this.release(request)) return false;
@@ -60,9 +118,7 @@ class PendingSessionRequests {
   release(request) {
     if (!this.pending.has(request) || request.answered) return false;
     request.answered = true;
-    request.signal.removeEventListener("abort", request.onAbort);
     this.pending.delete(request);
-    request.entry?.release();
     return true;
   }
   cancelAll() {

package/dist/session/requests/resolution.js

@@ -15,8 +15,10 @@ function resolveAcpRequest(requests, turn, request, mapped, input) {
     request.mapped = { ...mapped, request: mapped.flow.request };
   }
   if (reply !== void 0 && !requests.answer(request, reply)) return requestUnavailable();
-  turn.waiting = void 0;
-  turn.transition = reply === void 0 ? { nextRequest: request } : {};
+  if (reply === void 0) {
+    turn.waiting = void 0;
+    turn.transition = { nextRequest: request };
+  } else turn.transition = {};
   return { status: "delivered" };
 }
 function requestUnavailable() {

package/dist/session/session.d.ts

@@ -21,6 +21,9 @@ export declare class SessionState {
     private closePromise;
     private itemSequence;
     private requestSequence;
+    private readonly continuations;
+    private readonly descendants;
+    private readonly childWithdrawals;
     constructor(input: CreateAcpProviderSessionInput);
     open(): Promise<AgentProviderSession>;
     private requireUsable;
@@ -31,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;