@telorun/http-server 0.7.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # @telorun/http-server
 
+## 0.8.1
+
+### Patch Changes
+
+- e3146f3: Fix spurious request cancellation (HTTP 499) for body-bearing requests whose handler awaits before replying. Per-request cancellation was wired to the request stream's `close` event, which fires as normal cleanup once a request body has been fully received — so any `PUT`/`POST` whose handler did async work (e.g. a DB query) before sending a response was cancelled mid-flight and answered with 499. Cancellation now listens on the response socket, which only closes early on a genuine client disconnect; normal completions and synchronous rejects are unaffected.
+
+## 0.8.0
+
+### Minor Changes
+
+- 5331205: Add cooperative invoke cancellation via an out-of-band `InvokeContext`.
+
+  Every `invoke(inputs, ctx?)` now receives a second argument carrying a read-only
+  cancellation token (`ctx.cancellation`): poll `isCancelled`, subscribe via
+  `onCancelled`, bail with `throwIfCancelled`, or hand its `signal` to a Web API.
+  The SDK exposes the source/token split (`createCancellationSource`,
+  `CancellationSource`/`CancellationToken`), a never-cancellable sentinel, and the
+  `isCancellationError` helper. Deadlines are scheduled cancellation
+  (`source.cancelAt(epochMs)` / `cancelAfter(ms)`).
+
+  The kernel mints one cancellation scope per invocation tree (inherited by nested
+  invokes via a kernel-internal `AsyncLocalStorage`, always passed to controllers
+  as the explicit argument), refuses a not-yet-dispatched invoke whose tree was
+  cancelled with `ERR_INVOKE_CANCELLED`, and emits a scoped `InvokeCancelled`
+  event. `Kernel.invoke(ref, inputs, opts?)` accepts `{ signal, deadlineAt }`.
+  Sources are allocated lazily, so invokes that never touch cancellation pay no
+  extra allocation.
+
+  The boot `targets` run is also cancellable: `Runnable.run(ctx?)` now receives
+  the token, `Kernel.cancel(reason?)` cancels the boot scope, and the CLI's
+  SIGINT/SIGTERM handler calls it so Ctrl-C cooperatively stops honoring targets
+  and in-flight invoke trees (then unblocks graceful exit via `forceIdle`).
+
+  Honoring leaves: `Ai.Text` / `Ai.TextStream` / `Ai.Agent` forward the token's
+  signal into the model (aborting a live LLM stream on cancel); `http-client`
+  merges it with its request timeout. Triggers: `http-server` cancels on client
+  disconnect and returns 499; `lambda` arms cancellation at the AWS deadline.
+
+### Patch Changes
+
+- @telorun/http-dispatch@0.4.1
+
 ## 0.7.0
 
 ### Minor Changes

package/dist/http-api-controller.js

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import { CatchEntry, dispatchCatches, dispatchReturns, ReturnEntry, validateNoContentTypeHeader, validateStreamWhenDoesNotReferenceResult, } from "@telorun/http-dispatch";
-import { InvokeError, isInvokeError, Ref, Stream, } from "@telorun/sdk";
+import { InvokeError, isCancellationError, isInvokeError, Ref, Stream, } from "@telorun/sdk";
 import { fastifyReplySink } from "./fastify-reply-sink.js";
 const HttpApiRouteManifest = Type.Object({
     request: Type.Object({
@@ -106,13 +106,29 @@ export class HttpServerApi {
                     inputs: resolvedInputs,
                 };
                 const sink = fastifyReplySink(reply);
+                // Per-request cancellation: abandon downstream work when the client
+                // disconnects before the response is sent. Listen on the response
+                // socket, not the request stream — the latter's `close` fires as normal
+                // cleanup once a request body has been fully received, which would
+                // cancel any body-bearing request that awaits (e.g. a DB call) before
+                // replying. The response socket only closes early on a real disconnect.
+                const cancellation = this.ctx.createCancellationSource();
+                reply.raw.on("close", () => {
+                    if (!reply.sent)
+                        cancellation.cancel("client-disconnect");
+                });
                 let result;
                 try {
                     result = handler
-                        ? await this.ctx.invokeResolved(handlerKind, handlerName, handler, invokeInput)
+                        ? await this.ctx.invokeResolved(handlerKind, handlerName, handler, invokeInput, cancellation.context)
                         : undefined;
                 }
                 catch (err) {
+                    if (isCancellationError(err)) {
+                        if (!reply.sent)
+                            reply.code(499).send();
+                        return;
+                    }
                     if (!isInvokeError(err))
                         throw err;
                     return dispatchCatches(route.catches, { code: err.code, message: err.message, data: err.data }, requestContext, acceptHeader, this.ctx.moduleContext, this.ctx.validateSchema.bind(this.ctx), sink);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/http-server",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Telo HTTP Server module - HTTP server and API resource kinds for Telo manifests.",
   "keywords": [
     "telo",
@@ -49,7 +49,7 @@
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.8",
-    "@telorun/sdk": "0.18.0"
+    "@telorun/sdk": "0.19.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/http-api-controller.ts

@@ -12,6 +12,7 @@ import {
   ControllerContext,
   Invocable,
   InvokeError,
+  isCancellationError,
   isInvokeError,
   KindRef,
   Ref,
@@ -146,12 +147,33 @@ export class HttpServerApi implements ResourceInstance {
 
         const sink = fastifyReplySink(reply);
 
+        // Per-request cancellation: abandon downstream work when the client
+        // disconnects before the response is sent. Listen on the response
+        // socket, not the request stream — the latter's `close` fires as normal
+        // cleanup once a request body has been fully received, which would
+        // cancel any body-bearing request that awaits (e.g. a DB call) before
+        // replying. The response socket only closes early on a real disconnect.
+        const cancellation = this.ctx.createCancellationSource();
+        reply.raw.on("close", () => {
+          if (!reply.sent) cancellation.cancel("client-disconnect");
+        });
+
         let result: unknown;
         try {
           result = handler
-            ? await this.ctx.invokeResolved(handlerKind, handlerName, handler, invokeInput)
+            ? await this.ctx.invokeResolved(
+                handlerKind,
+                handlerName,
+                handler,
+                invokeInput,
+                cancellation.context,
+              )
             : undefined;
         } catch (err) {
+          if (isCancellationError(err)) {
+            if (!reply.sent) reply.code(499).send();
+            return;
+          }
           if (!isInvokeError(err)) throw err;
           return dispatchCatches(
             route.catches,