@agentfield/sdk 0.1.77-rc.4 → 0.1.77-rc.5

package/dist/index.d.ts

@@ -641,6 +641,15 @@ declare class ReasonerContext<TInput = any> {
     readonly memory: MemoryInterface;
     readonly workflow: WorkflowReporter;
     readonly did: DidInterface;
+    /**
+     * AbortSignal that fires when the control plane cancels this execution
+     * (per-execution cancel, the bottom-up cancel-tree endpoint, or any
+     * future source that flips the bus). Pass it through to `fetch`, the
+     * @anthropic-ai/sdk, the openai SDK, or anywhere that accepts
+     * `{ signal }` to short-circuit in-flight work mid-call. For pure-JS
+     * CPU loops, check `ctx.signal.aborted` periodically and throw.
+     */
+    readonly signal: AbortSignal;
     constructor(params: {
         input: TInput;
         executionId: string;
@@ -662,6 +671,7 @@ declare class ReasonerContext<TInput = any> {
         memory: MemoryInterface;
         workflow: WorkflowReporter;
         did: DidInterface;
+        signal?: AbortSignal;
     });
     ai<T>(prompt: string, options: AIRequestOptions & {
         schema: ZodSchema<T>;
@@ -719,6 +729,8 @@ declare class SkillContext<TInput = any> {
     readonly memory: MemoryInterface;
     readonly workflow: WorkflowReporter;
     readonly did: DidInterface;
+    /** AbortSignal — see ReasonerContext for usage. */
+    readonly signal: AbortSignal;
     constructor(params: {
         input: TInput;
         executionId: string;
@@ -735,6 +747,7 @@ declare class SkillContext<TInput = any> {
         memory: MemoryInterface;
         workflow: WorkflowReporter;
         did: DidInterface;
+        signal?: AbortSignal;
     });
     discover(options?: DiscoveryOptions): Promise<DiscoveryResult>;
 }
@@ -1086,6 +1099,11 @@ declare class Agent {
     private readonly realtimeValidationFunctions;
     private readonly processLogRing;
     private readonly executionLogger;
+    /** Tracks an AbortController per in-flight execution_id so the
+     *  `/_internal/executions/:id/cancel` route can short-circuit reasoner
+     *  code that respects `signal.aborted` (fetch, anthropic SDK, openai
+     *  SDK, etc.). See ./cancel.ts. */
+    private readonly cancelRegistry;
     constructor(config: AgentConfig);
     reasoner<TInput = any, TOutput = any>(name: string, handler: ReasonerHandler<TInput, TOutput>, options?: ReasonerOptions): this;
     skill<TInput = any, TOutput = any>(name: string, handler: SkillHandler<TInput, TOutput>, options?: SkillOptions): this;

package/dist/index.js

@@ -877,6 +877,86 @@ var SkillRegistry = class {
     return Array.from(this.skills.values());
   }
 };
+
+// src/agent/cancel.ts
+var CancelRegistry = class {
+  controllers = /* @__PURE__ */ new Map();
+  /**
+   * Register a fresh AbortController against an execution_id. Returns the
+   * controller and a `release()` cleanup function that must be called on
+   * completion (success, failure, or cancellation) to drop the entry.
+   * Empty `executionId` produces a controller that is NOT registered,
+   * so callers always get a usable signal even outside the control-plane
+   * dispatch path (e.g. local manual invocations).
+   */
+  register(executionId) {
+    const controller = new AbortController();
+    if (!executionId) {
+      return { controller, release: () => {
+      } };
+    }
+    this.controllers.set(executionId, controller);
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      const current = this.controllers.get(executionId);
+      if (current === controller) {
+        this.controllers.delete(executionId);
+      }
+    };
+    return { controller, release };
+  }
+  /**
+   * Cancel the AbortController registered for `executionId`. Returns
+   * true if a matching controller was found and aborted, false if there
+   * was no active execution (already finished, or never dispatched here).
+   */
+  cancel(executionId, reason) {
+    if (!executionId) return false;
+    const controller = this.controllers.get(executionId);
+    if (!controller) return false;
+    if (controller.signal.aborted) {
+      return true;
+    }
+    controller.abort(reason ?? "cancelled_by_control_plane");
+    this.controllers.delete(executionId);
+    return true;
+  }
+  /** Number of in-flight registrations. Useful for tests. */
+  size() {
+    return this.controllers.size;
+  }
+};
+function installCancelRoute(app, registry, logger) {
+  app.post(
+    "/_internal/executions/:executionId/cancel",
+    (req, res) => {
+      const executionId = (req.params.executionId ?? "").trim();
+      if (!executionId) {
+        res.status(404).json({ error: "invalid execution_id" });
+        return;
+      }
+      const cancelled = registry.cancel(
+        executionId,
+        typeof req.body?.reason === "string" ? req.body.reason : void 0
+      );
+      if (cancelled) {
+        logger?.info("cancel-callback fired", {
+          executionId,
+          source: req.headers["x-agentfield-source"] ?? "unknown"
+        });
+        res.status(200).json({ cancelled: true, execution_id: executionId });
+      } else {
+        res.status(200).json({
+          cancelled: false,
+          execution_id: executionId,
+          reason: "execution_not_active"
+        });
+      }
+    }
+  );
+}
 var store = new AsyncLocalStorage();
 var ExecutionContext = class {
   input;
@@ -1217,6 +1297,15 @@ var ReasonerContext = class {
   memory;
   workflow;
   did;
+  /**
+   * AbortSignal that fires when the control plane cancels this execution
+   * (per-execution cancel, the bottom-up cancel-tree endpoint, or any
+   * future source that flips the bus). Pass it through to `fetch`, the
+   * @anthropic-ai/sdk, the openai SDK, or anywhere that accepts
+   * `{ signal }` to short-circuit in-flight work mid-call. For pure-JS
+   * CPU loops, check `ctx.signal.aborted` periodically and throw.
+   */
+  signal;
   constructor(params) {
     this.input = params.input;
     this.executionId = params.executionId;
@@ -1238,6 +1327,7 @@ var ReasonerContext = class {
     this.memory = params.memory;
     this.workflow = params.workflow;
     this.did = params.did;
+    this.signal = params.signal ?? new AbortController().signal;
   }
   ai(prompt, options) {
     if (options?.tools) {
@@ -1341,6 +1431,8 @@ var SkillContext = class {
   memory;
   workflow;
   did;
+  /** AbortSignal — see ReasonerContext for usage. */
+  signal;
   constructor(params) {
     this.input = params.input;
     this.executionId = params.executionId;
@@ -1357,6 +1449,7 @@ var SkillContext = class {
     this.memory = params.memory;
     this.workflow = params.workflow;
     this.did = params.did;
+    this.signal = params.signal ?? new AbortController().signal;
   }
   discover(options) {
     return this.agent.discover(options);
@@ -3613,6 +3706,11 @@ var Agent = class {
   realtimeValidationFunctions = /* @__PURE__ */ new Set();
   processLogRing = new ProcessLogRing();
   executionLogger;
+  /** Tracks an AbortController per in-flight execution_id so the
+   *  `/_internal/executions/:id/cancel` route can short-circuit reasoner
+   *  code that respects `signal.aborted` (fetch, anthropic SDK, openai
+   *  SDK, etc.). See ./cancel.ts. */
+  cancelRegistry = new CancelRegistry();
   constructor(config) {
     this.config = {
       port: 8001,
@@ -3648,6 +3746,9 @@ var Agent = class {
     this.registerDefaultRoutes();
     installStdioLogCapture(this.processLogRing);
     registerAgentfieldLogsRoute(this.app, this.processLogRing);
+    installCancelRoute(this.app, this.cancelRegistry, {
+      info: (message, meta) => this.executionLogger.system("execution.cancel.received", message, meta ?? {})
+    });
   }
   reasoner(name, handler, options) {
     this.reasoners.register(name, handler, options);
@@ -4500,6 +4601,9 @@ var Agent = class {
       res,
       agent: this
     });
+    const { controller, release } = this.cancelRegistry.register(
+      executionMetadata.executionId
+    );
     return ExecutionContext.run(execCtx, async () => {
       this.executionLogger.system("execution.started", "Execution started", {
         target: params.targetName,
@@ -4538,7 +4642,8 @@ var Agent = class {
           aiClient: this.aiClient,
           memory: this.getMemoryInterface(executionMetadata),
           workflow: this.getWorkflowReporter(executionMetadata),
-          did: this.getDidInterface(executionMetadata, params.input, params.targetName)
+          did: this.getDidInterface(executionMetadata, params.input, params.targetName),
+          signal: controller.signal
         });
         const result = await reasoner.handler(ctx);
         this.executionLogger.system("reasoner.completed", "Reasoner execution completed", {
@@ -4597,6 +4702,8 @@ var Agent = class {
           return;
         }
         throw err;
+      } finally {
+        release();
       }
     });
   }
@@ -4615,6 +4722,9 @@ var Agent = class {
       res,
       agent: this
     });
+    const { controller, release } = this.cancelRegistry.register(
+      executionMetadata.executionId
+    );
     return ExecutionContext.run(execCtx, async () => {
       this.executionLogger.system("execution.started", "Execution started", {
         target: params.targetName,
@@ -4646,7 +4756,8 @@ var Agent = class {
           logger: this.executionLogger,
           memory: this.getMemoryInterface(executionMetadata),
           workflow: this.getWorkflowReporter(executionMetadata),
-          did: this.getDidInterface(executionMetadata, params.input, params.targetName)
+          did: this.getDidInterface(executionMetadata, params.input, params.targetName),
+          signal: controller.signal
         });
         const result = await skill.handler(ctx);
         this.executionLogger.system("skill.completed", "Skill execution completed", {
@@ -4705,6 +4816,8 @@ var Agent = class {
           return;
         }
         throw err;
+      } finally {
+        release();
       }
     });
   }