@adcp/sdk 12.1.0 → 13.0.0-rc.0

package/dist/lib/core/TaskExecutor.mjs

@@ -123,6 +123,7 @@ function resolveIdempotencyKey(taskName, params) {
   if (isMutatingTask(taskName)) return generateIdempotencyKey();
   return void 0;
 }
+const COMPACTED_TASK_STATE_LIMIT = 1e4;
 class TaskExecutor {
   constructor(config = {}) {
     this.config = config;
@@ -152,6 +153,7 @@ class TaskExecutor {
   config;
   responseParser;
   activeTasks = /* @__PURE__ */ new Map();
+  compactedTaskIds = /* @__PURE__ */ new Map();
   conversationStorage;
   governanceMiddleware;
   lastKnownServerVersion;
@@ -167,6 +169,17 @@ class TaskExecutor {
     const params = this.activeTasks.get(taskId)?.params;
     return params && typeof params === "object" && !Array.isArray(params) ? params : void 0;
   }
+  /**
+   * Reconcile a push-delivered terminal status with the local runner task.
+   * Submitted task state is already compacted after dispatch; this schedules
+   * the same short final-status retention used by synchronous completions.
+   *
+   * @internal
+   */
+  observeExternalTaskStatus(taskId, status, result) {
+    if (!["completed", "failed", "rejected", "canceled"].includes(status)) return;
+    this.updateTaskStatus(taskId, status, result);
+  }
   /**
    * Run the configured pre-send schema check against the user-facing request
    * shape. Callers invoke this on the unadapted (v3) params before any wire
@@ -303,10 +316,14 @@ class TaskExecutor {
         );
         const isBlocking = true;
         if (govResult.status === "denied" && isBlocking) {
-          return attachMatch(this.buildGovernanceResult(govResult, taskId, taskName, agent, startTime, debugLogs));
+          const denied = this.buildGovernanceResult(govResult, taskId, taskName, agent, startTime, debugLogs);
+          this.updateTaskStatus(taskId, "governance-denied", void 0, denied.error);
+          return attachMatch(denied);
         }
         if (govResult.status === "conditions" && !govResult.conditionsApplied && isBlocking) {
-          return attachMatch(this.buildGovernanceResult(govResult, taskId, taskName, agent, startTime, debugLogs));
+          const denied = this.buildGovernanceResult(govResult, taskId, taskName, agent, startTime, debugLogs);
+          this.updateTaskStatus(taskId, "governance-denied", void 0, denied.error);
+          return attachMatch(denied);
         }
         governanceCheckId = govResult.checkId;
         governanceResult = govResult;
@@ -403,6 +420,9 @@ class TaskExecutor {
           result.governance = { ...result.governance ?? {}, checkId: governanceCheckId };
         }
       }
+      if (["completed", "failed", "rejected", "canceled", "governance-denied", "aborted"].includes(result.status) && this.activeTasks.get(taskId)?.status !== result.status) {
+        this.updateTaskStatus(taskId, result.status, result.data, result.error);
+      }
       return attachMatch(result);
     } catch (error) {
       if (isAbortOrTimeoutError(error)) {
@@ -410,6 +430,7 @@ class TaskExecutor {
           error.idempotency_key = idempotencyKey;
           error.idempotencyKey = idempotencyKey;
         }
+        this.updateTaskStatus(taskId, "aborted", void 0, error instanceof Error ? error.message : String(error));
         throw error;
       }
       if (governanceCheckId && this.governanceMiddleware && governanceResult?.governanceContext) {
@@ -422,7 +443,9 @@ class TaskExecutor {
           governanceResult.governanceContext
         );
       }
-      return attachMatch(this.createErrorResult(taskId, agent, error, debugLogs, startTime));
+      const failed = this.createErrorResult(taskId, agent, error, debugLogs, startTime);
+      this.updateTaskStatus(taskId, "failed", void 0, failed.error);
+      return attachMatch(failed);
     }
   }
   /**
@@ -691,19 +714,21 @@ class TaskExecutor {
    */
   async waitForWorkingCompletion(agent, taskId, taskName, params, initialResponse, messages, inputHandler, options = {}, debugLogs = [], startTime = Date.now()) {
     const partialData = this.extractResponseData(initialResponse, debugLogs, taskName);
+    const metadata = this.buildMetadata({
+      taskId,
+      taskName,
+      agent,
+      startTime,
+      status: "working",
+      response: initialResponse
+    });
+    this.compactIntermediateTaskState(taskId, "working");
     return {
       success: true,
       // The task is progressing, not failed
       status: "working",
       data: partialData,
-      metadata: this.buildMetadata({
-        taskId,
-        taskName,
-        agent,
-        startTime,
-        status: "working",
-        response: initialResponse
-      }),
+      metadata,
       conversation: messages,
       debug_logs: debugLogs
     };
@@ -720,6 +745,7 @@ class TaskExecutor {
     }
     const extractedServerTaskId = this.responseParser.getTaskId(response);
     const serverTaskId = extractedServerTaskId ?? taskId;
+    const pollingTransport = options.transport;
     if (!extractedServerTaskId) {
       debugLogs.push({
         type: "warning",
@@ -732,27 +758,63 @@ class TaskExecutor {
     const submitted = {
       taskId: serverTaskId,
       webhookUrl,
-      track: (transport) => this.getTaskStatus(agent, serverTaskId, transport ?? options.transport),
-      waitForCompletion: (pollInterval = 6e4, signal) => this.pollTaskCompletion(agent, serverTaskId, pollInterval, options.transport, signal)
+      track: async (transport) => {
+        const task = await this.getTaskStatus(agent, serverTaskId, transport ?? pollingTransport);
+        if (["completed", "failed", "rejected", "canceled"].includes(task.status)) {
+          this.updateTaskStatus(taskId, task.status, task.result, task.error);
+        }
+        return task;
+      },
+      waitForCompletion: async (pollInterval = 6e4, signal) => {
+        const completed = await this.pollTaskCompletion(agent, serverTaskId, pollInterval, pollingTransport, signal);
+        this.updateTaskStatus(taskId, completed.status, completed.data, completed.error);
+        return completed;
+      }
     };
+    const metadata = this.buildMetadata({
+      taskId,
+      taskName,
+      agent,
+      startTime,
+      status: "submitted",
+      response
+    });
+    this.compactIntermediateTaskState(taskId, "submitted");
     return {
       success: true,
       // The task is progressing, not failed
       status: "submitted",
       submitted,
       data: partialData,
-      metadata: this.buildMetadata({
-        taskId,
-        taskName,
-        agent,
-        startTime,
-        status: "submitted",
-        response
-      }),
+      metadata,
       conversation: messages,
       debug_logs: debugLogs
     };
   }
+  /**
+   * A working/submitted response carries everything needed to poll externally.
+   * Keeping the original request in activeTasks after dispatch would pin
+   * inline assets, webhook credentials, conversation payloads, and per-call
+   * options for an unbounded amount of time while the seller works. Retain
+   * only lifecycle metadata and the separately tracked idempotency key.
+   */
+  compactIntermediateTaskState(taskId, status) {
+    const task = this.activeTasks.get(taskId);
+    if (!task) return;
+    task.status = status;
+    task.params = void 0;
+    task.messages = [];
+    task.options = {};
+    delete task.pendingInput;
+    this.compactedTaskIds.delete(taskId);
+    this.compactedTaskIds.set(taskId, true);
+    while (this.compactedTaskIds.size > COMPACTED_TASK_STATE_LIMIT) {
+      const oldest = this.compactedTaskIds.keys().next().value;
+      if (oldest === void 0) break;
+      this.compactedTaskIds.delete(oldest);
+      this.activeTasks.delete(oldest);
+    }
+  }
   /**
    * Handle input-required status
    *
@@ -765,20 +827,22 @@ class TaskExecutor {
     const inputRequest = this.responseParser.parseInputRequest(response);
     if (!inputHandler) {
       const partialData = this.extractResponseData(response, debugLogs, taskName);
+      const metadata = this.buildMetadata({
+        taskId,
+        taskName,
+        agent,
+        startTime,
+        status: "input-required",
+        response,
+        inputRequest
+      });
+      this.compactIntermediateTaskState(taskId, "input-required");
       return {
         success: true,
         // The task is progressing, not failed
         status: "input-required",
         data: partialData,
-        metadata: this.buildMetadata({
-          taskId,
-          taskName,
-          agent,
-          startTime,
-          status: "input-required",
-          response,
-          inputRequest
-        }),
+        metadata,
         conversation: messages,
         debug_logs: debugLogs
       };
@@ -826,6 +890,7 @@ class TaskExecutor {
           createdAt: Date.now()
         });
       }
+      this.compactIntermediateTaskState(taskId, "deferred");
       const deferred = {
         token,
         question: inputRequest.question,
@@ -942,7 +1007,7 @@ class TaskExecutor {
         const reason = signal.reason instanceof Error ? signal.reason.message : String(signal.reason ?? "polling cancelled");
         if (agent.protocol === "a2a" && taskId && agent.agent_uri) {
           try {
-            void cancelA2ATask(agent, taskId).catch(() => {
+            void cancelA2ATask(agent, taskId, (transport ?? this.config.transport)?.fetchFn).catch(() => {
             });
           } catch {
           }
@@ -1085,18 +1150,34 @@ class TaskExecutor {
     if (!state) {
       throw new Error(`Deferred task not found: ${token}`);
     }
-    const resumed = await this.continueTaskWithInput(
-      state.agent,
-      state.taskId,
-      state.taskName,
-      state.params,
-      state.contextId,
-      input,
-      state.messages,
-      void 0
-      // No handler for deferred tasks - input was provided by human
-    );
-    return attachMatch(resumed);
+    try {
+      const resumed = await this.continueTaskWithInput(
+        state.agent,
+        state.taskId,
+        state.taskName,
+        state.params,
+        state.contextId,
+        input,
+        state.messages,
+        void 0
+        // No handler for deferred tasks - input was provided by human
+      );
+      const remainsPaused = ["input-required", "auth-required", "deferred"].includes(resumed.status);
+      if (["completed", "failed", "rejected", "canceled", "governance-denied", "aborted"].includes(resumed.status) && this.activeTasks.get(state.taskId)?.status !== resumed.status) {
+        this.updateTaskStatus(state.taskId, resumed.status, resumed.data, resumed.error);
+      }
+      if (!remainsPaused) {
+        await this.config.deferredStorage.delete(token);
+      }
+      return attachMatch(resumed);
+    } catch (error) {
+      this.updateTaskStatus(state.taskId, "failed", void 0, error instanceof Error ? error.message : String(error));
+      try {
+        await this.config.deferredStorage.delete(token);
+      } catch {
+      }
+      throw error;
+    }
   }
   /**
    * Continue a task after receiving input
@@ -1223,6 +1304,10 @@ class TaskExecutor {
   async getTaskInfo(taskId) {
     const localTask = this.activeTasks.get(taskId);
     if (localTask) {
+      if (this.compactedTaskIds.has(taskId)) {
+        this.compactedTaskIds.delete(taskId);
+        this.compactedTaskIds.set(taskId, true);
+      }
       return {
         taskId: localTask.taskId,
         status: localTask.status,
@@ -1408,9 +1493,17 @@ class TaskExecutor {
         payload: result ?? (error ? { error } : void 0),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
-      if (["completed", "failed", "rejected", "canceled"].includes(status)) {
+      if (status === "input-required" || status === "auth-required") {
+        this.compactIntermediateTaskState(taskId, status);
+      }
+      if (["completed", "failed", "rejected", "canceled", "governance-denied", "aborted"].includes(status)) {
+        task.params = void 0;
+        task.messages = [];
+        task.options = {};
+        delete task.pendingInput;
         setTimeout(() => {
           this.activeTasks.delete(taskId);
+          this.compactedTaskIds.delete(taskId);
         }, 3e4).unref();
       }
     }