@agen-ai/acp-transport 0.4.3 → 0.4.4

package/README.md

@@ -76,7 +76,7 @@ slow output consumer does not block correlated responses or cancellation. Hosts
 must reserve bounded queue capacity during handler admission and retain that
 reservation until processing completes.
 
-Request deadlines and bounded shutdown drains keep Node's event loop alive until
+Finite request deadlines and bounded shutdown drains keep Node's event loop alive until
 the operation settles, including when the supplied streams have no active I/O
 handles. Settlement clears the operation's timer. Always await `client.dispose()`
 when the connection is no longer needed to reject pending requests and complete
@@ -153,6 +153,20 @@ and output backpressure. Notification delivery alone does not provide a durable
 event journal or a provider-neutral turn state machine.
 
 Request cancellation or timeout does not prove that the peer stopped execution.
+Requests default to bounded waiting, using the configured finite timeout and the
+earlier optional `deadlineAt`. Existing numeric `timeoutMs` and `deadlineAt` calls
+retain those limits. `lifetime: 'bounded'` makes that default explicit.
+
+Select `{ lifetime: 'until_settled' }` for an execution request that must retain
+its original RPC waiter until a response, explicit abort, disposal or connection
+failure. This choice schedules no request timer and cannot be combined with
+`timeoutMs` or `deadlineAt`, even when either property is explicitly `undefined`.
+Contradictions reject before dispatch. The request still consumes bounded pending
+capacity, retains its exact ID and response validation, and respects signals and
+disposal. The caller must own cancellation, output consumption and cleanup. For a
+long native operation, request abort alone does not establish native cancellation;
+retain the RPC while performing the protocol's cancellation-confirmation flow.
+
 `onRequestDispatch` receives the exact allocated `requestId` at the boundary immediately
 before the first write, allowing request-scoped reverse traffic to be correlated before
 the peer can respond. A callback that aborts or rejects admission prevents the request

package/dist/client.js

@@ -11,7 +11,7 @@ import {
 } from "./protocol.js";
 import { createAcpSchemaValidator } from "./schema.js";
 import {
-  boundedTimeout,
+  resolveRequestTimeout,
   cleanupPendingRequest,
   deferred,
   isCriticalExtensionMethod
@@ -410,13 +410,13 @@ function createAcpClient(options) {
         );
       }
       const extension = validateOutbound("request", method, params);
-      const timeoutMs = boundedTimeout({
+      const timeoutMs = resolveRequestTimeout({
         options: requestOptions,
         now: now(),
         defaultMs: limits.defaultRequestTimeoutMs,
         maximumMs: limits.maxRequestTimeoutMs
       });
-      if (timeoutMs <= 0 || requestOptions.signal?.aborted) {
+      if (timeoutMs !== void 0 && timeoutMs <= 0 || requestOptions.signal?.aborted) {
         throw new AcpRequestError("acp_request_aborted", 0);
       }
       const id = allocateRequestId();
@@ -430,7 +430,7 @@ function createAcpClient(options) {
           sendCancellation(id);
         };
         requestOptions.signal?.addEventListener("abort", abort, { once: true });
-        const timer = setTimeout(() => {
+        const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
           const entry2 = pending.get(key);
           if (!entry2) return;
           cleanupPending(entry2);

package/dist/clientContracts.d.ts

@@ -47,15 +47,22 @@ export interface CreateAcpClientOptions {
     readonly onFatalError?: (error: Error) => void;
     readonly disposeTransport?: () => void | Promise<void>;
 }
-export interface AcpRequestOptions {
-    readonly timeoutMs?: number;
-    readonly deadlineAt?: number | Date;
+interface AcpRequestContextOptions {
     readonly signal?: AbortSignal;
     /** Runs synchronously after local admission and immediately before the transport write. */
     readonly onRequestDispatch?: (context: AcpRequestDispatchContext) => void;
     /** Runs synchronously after response validation, before promise settlement and the next frame. */
     readonly onResponseReceived?: (response: AcpResponseReceived) => void;
 }
+export type AcpRequestOptions = AcpRequestContextOptions & (Readonly<{
+    lifetime?: 'bounded';
+    timeoutMs?: number;
+    deadlineAt?: number | Date;
+}> | Readonly<{
+    lifetime: 'until_settled';
+    timeoutMs?: never;
+    deadlineAt?: never;
+}>);
 export interface AcpClientCloseResult {
     readonly kind: 'disposed' | 'peer_closed' | 'fatal';
     readonly error?: Error;
@@ -67,4 +74,5 @@ export interface AcpClient {
     readonly closed: Promise<AcpClientCloseResult>;
     readonly dispose: () => Promise<void>;
 }
+export {};
 //# sourceMappingURL=clientContracts.d.ts.map

package/dist/clientState.d.ts

@@ -7,7 +7,7 @@ export interface PendingRequest {
     readonly extension: boolean;
     readonly resolve: (value: AcpJsonValue) => void;
     readonly reject: (error: Error) => void;
-    readonly timer: ReturnType<typeof setTimeout>;
+    readonly timer: ReturnType<typeof setTimeout> | undefined;
     readonly removeAbortListener: () => void;
     readonly onResponseReceived?: AcpRequestOptions['onResponseReceived'];
 }
@@ -21,11 +21,11 @@ export declare function deferred<T>(): {
     reject: (error: unknown) => void;
 };
 export declare function isCriticalExtensionMethod(method: string): boolean;
-export declare function boundedTimeout(input: {
+export declare function resolveRequestTimeout(input: {
     readonly options: AcpRequestOptions;
     readonly now: number;
     readonly defaultMs: number;
     readonly maximumMs: number;
-}): number;
+}): number | undefined;
 export declare function cleanupPendingRequest(pending: Map<string, PendingRequest>, entry: PendingRequest): void;
 //# sourceMappingURL=clientState.d.ts.map

package/dist/clientState.js

@@ -11,12 +11,21 @@ function deferred() {
 function isCriticalExtensionMethod(method) {
   return method.startsWith("_") || method.startsWith("$/");
 }
-function boundedTimeout(input) {
+function resolveRequestTimeout(input) {
+  if (input.options.lifetime === "until_settled") {
+    if (Reflect.has(input.options, "timeoutMs") || Reflect.has(input.options, "deadlineAt")) {
+      throw new TypeError("Until-settled ACP requests cannot select finite timing.");
+    }
+    return void 0;
+  }
+  if (input.options.lifetime !== void 0 && input.options.lifetime !== "bounded") {
+    throw new TypeError("ACP request lifetime is invalid.");
+  }
   const requested = input.options.timeoutMs ?? input.defaultMs;
   if (!Number.isSafeInteger(requested) || requested <= 0 || requested > input.maximumMs) {
     throw new TypeError("ACP request timeout is outside the supported range.");
   }
-  if (!input.options.deadlineAt) return requested;
+  if (input.options.deadlineAt === void 0) return requested;
   const deadline = input.options.deadlineAt instanceof Date ? input.options.deadlineAt.getTime() : input.options.deadlineAt;
   if (!Number.isFinite(deadline)) throw new TypeError("ACP request deadline is invalid.");
   return Math.min(requested, Math.floor(deadline - input.now));
@@ -27,8 +36,8 @@ function cleanupPendingRequest(pending, entry) {
   pending.delete(acpRequestIdKey(entry.id));
 }
 export {
-  boundedTimeout,
   cleanupPendingRequest,
   deferred,
-  isCriticalExtensionMethod
+  isCriticalExtensionMethod,
+  resolveRequestTimeout
 };

package/dist/standardSessionOperations.d.ts

@@ -127,10 +127,21 @@ export type AcpStandardCancelParams = AcpStandardObject<{
     sessionId: string;
     _meta?: AcpStandardMeta;
 }>;
+export type AcpStandardListSessionsParams = AcpStandardObject<{
+    cwd?: string | null;
+    cursor?: string | null;
+    _meta?: AcpStandardMeta;
+}>;
+export type AcpStandardDeleteSessionParams = AcpStandardObject<{
+    sessionId: string;
+    _meta?: AcpStandardMeta;
+}>;
 export interface AcpStandardSessionOperations {
     readonly initialize: (params: AcpStandardInitializeParams, options?: AcpRequestOptions) => Promise<AcpJsonValue>;
     readonly newSession: (params: AcpStandardNewSessionParams, options?: AcpRequestOptions) => Promise<AcpJsonValue>;
     readonly loadSession: (params: AcpStandardLoadSessionParams, options?: AcpRequestOptions) => Promise<AcpJsonValue>;
+    readonly listSessions: (params: AcpStandardListSessionsParams, options?: AcpRequestOptions) => Promise<AcpJsonValue>;
+    readonly deleteSession: (params: AcpStandardDeleteSessionParams, options?: AcpRequestOptions) => Promise<AcpJsonValue>;
     readonly prompt: (params: AcpStandardPromptParams, options?: AcpRequestOptions) => Promise<AcpJsonValue>;
     readonly cancel: (params: AcpStandardCancelParams) => Promise<void>;
 }

package/dist/standardSessionOperations.js

@@ -2,6 +2,8 @@ const STANDARD_METHODS = Object.freeze({
   initialize: "initialize",
   newSession: "session/new",
   loadSession: "session/load",
+  listSessions: "session/list",
+  deleteSession: "session/delete",
   prompt: "session/prompt",
   cancel: "session/cancel"
 });
@@ -22,6 +24,16 @@ function createAcpStandardSessionOperations(client) {
       params,
       options
     ),
+    listSessions: (params, options) => client.request(
+      STANDARD_METHODS.listSessions,
+      params,
+      options
+    ),
+    deleteSession: (params, options) => client.request(
+      STANDARD_METHODS.deleteSession,
+      params,
+      options
+    ),
     prompt: (params, options) => client.request(
       STANDARD_METHODS.prompt,
       params,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/acp-transport",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "private": false,
   "type": "module",
   "sideEffects": false,