@restatedev/restate-sdk-testcontainers 1.11.1 → 1.13.0

package/dist/index.d.cts

@@ -3,11 +3,12 @@ import { Serde } from "./restate-sdk-core/src/serde_api.cjs";
 import { Duration } from "./restate-sdk-core/src/duration.cjs";
 import { JournalValueCodec } from "./restate-sdk-core/src/entry_codec.cjs";
 import { RestateError, TerminalError } from "./restate-sdk/src/types/errors.cjs";
+import { Hooks, HooksProvider, Interceptor } from "./restate-sdk/src/hooks.cjs";
 import { ObjectOptions, RetryPolicy, ServiceOptions, WorkflowOptions } from "./restate-sdk/src/types/rpc.cjs";
-import { Request, TypedState, UntypedState } from "./restate-sdk/src/context.cjs";
+import { InvocationId, Request, Target, TypedState, UntypedState } from "./restate-sdk/src/context.cjs";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./restate-sdk/src/logging/logger_transport.cjs";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./restate-sdk/src/endpoint.cjs";
 import { EndpointOptions } from "./restate-sdk/src/endpoint/types.cjs";
 import "./restate-sdk/src/index.cjs";
-import { RestateContainer, RestateTestEnvironment, StateProxy } from "./restate_test_environment.cjs";
-export { type DefaultServiceOptions, type Duration, type EndpointOptions, type JournalValueCodec, type LogMetadata, type LogSource, type LoggerContext, type LoggerTransport, type ObjectOptions, type Request, RestateContainer, type RestateEndpoint, type RestateEndpointBase, type RestateError, type RestateLogLevel, RestateTestEnvironment, type RetryPolicy, type Serde, type ServiceDefinition, type ServiceOptions, StateProxy, type TerminalError, type TypedState, type UntypedState, type VirtualObjectDefinition, type WorkflowDefinition, type WorkflowOptions };
+import { RestateContainer, RestateTestEnvironment, StateProxy, TestEnvironmentOptions } from "./restate_test_environment.cjs";
+export { type DefaultServiceOptions, type Duration, type EndpointOptions, type Hooks, type HooksProvider, type Interceptor, type InvocationId, type JournalValueCodec, type LogMetadata, type LogSource, type LoggerContext, type LoggerTransport, type ObjectOptions, type Request, RestateContainer, type RestateEndpoint, type RestateEndpointBase, type RestateError, type RestateLogLevel, RestateTestEnvironment, type RetryPolicy, type Serde, type ServiceDefinition, type ServiceOptions, StateProxy, type Target, type TerminalError, type TestEnvironmentOptions, type TypedState, type UntypedState, type VirtualObjectDefinition, type WorkflowDefinition, type WorkflowOptions };

package/dist/index.d.ts

@@ -3,11 +3,12 @@ import { Serde } from "./restate-sdk-core/src/serde_api.js";
 import { Duration } from "./restate-sdk-core/src/duration.js";
 import { JournalValueCodec } from "./restate-sdk-core/src/entry_codec.js";
 import { RestateError, TerminalError } from "./restate-sdk/src/types/errors.js";
+import { Hooks, HooksProvider, Interceptor } from "./restate-sdk/src/hooks.js";
 import { ObjectOptions, RetryPolicy, ServiceOptions, WorkflowOptions } from "./restate-sdk/src/types/rpc.js";
-import { Request, TypedState, UntypedState } from "./restate-sdk/src/context.js";
+import { InvocationId, Request, Target, TypedState, UntypedState } from "./restate-sdk/src/context.js";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./restate-sdk/src/logging/logger_transport.js";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./restate-sdk/src/endpoint.js";
 import { EndpointOptions } from "./restate-sdk/src/endpoint/types.js";
 import "./restate-sdk/src/index.js";
-import { RestateContainer, RestateTestEnvironment, StateProxy } from "./restate_test_environment.js";
-export { type DefaultServiceOptions, type Duration, type EndpointOptions, type JournalValueCodec, type LogMetadata, type LogSource, type LoggerContext, type LoggerTransport, type ObjectOptions, type Request, RestateContainer, type RestateEndpoint, type RestateEndpointBase, type RestateError, type RestateLogLevel, RestateTestEnvironment, type RetryPolicy, type Serde, type ServiceDefinition, type ServiceOptions, StateProxy, type TerminalError, type TypedState, type UntypedState, type VirtualObjectDefinition, type WorkflowDefinition, type WorkflowOptions };
+import { RestateContainer, RestateTestEnvironment, StateProxy, TestEnvironmentOptions } from "./restate_test_environment.js";
+export { type DefaultServiceOptions, type Duration, type EndpointOptions, type Hooks, type HooksProvider, type Interceptor, type InvocationId, type JournalValueCodec, type LogMetadata, type LogSource, type LoggerContext, type LoggerTransport, type ObjectOptions, type Request, RestateContainer, type RestateEndpoint, type RestateEndpointBase, type RestateError, type RestateLogLevel, RestateTestEnvironment, type RetryPolicy, type Serde, type ServiceDefinition, type ServiceOptions, StateProxy, type Target, type TerminalError, type TestEnvironmentOptions, type TypedState, type UntypedState, type VirtualObjectDefinition, type WorkflowDefinition, type WorkflowOptions };

package/dist/restate-sdk/src/common_api.d.ts

@@ -3,8 +3,10 @@ import { Serde } from "../../restate-sdk-core/src/serde_api.js";
 import { Duration } from "../../restate-sdk-core/src/duration.js";
 import { JournalValueCodec } from "../../restate-sdk-core/src/entry_codec.js";
 import { RestateError, TerminalError } from "./types/errors.js";
+import { Hooks, HooksProvider, Interceptor } from "./hooks.js";
 import { ObjectOptions, RetryPolicy, ServiceOptions, WorkflowOptions } from "./types/rpc.js";
-import { Request, TypedState, UntypedState } from "./context.js";
+import { InvocationId, Request, Target, TypedState, UntypedState } from "./context.js";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.js";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.js";
+import "./promises.js";
 import { EndpointOptions } from "./endpoint/types.js";

package/dist/restate-sdk/src/context.d.cts

@@ -1,5 +1,11 @@
 //#region ../restate-sdk/src/context.d.ts
 
+interface Target {
+  service: string;
+  handler: string;
+  key?: string;
+  toString(): string;
+}
 /**
  * Represents the original request as sent to this handler.
  *
@@ -7,11 +13,12 @@
  * request body.
  */
 interface Request {
+  readonly target: Target;
   /**
    * The unique id that identifies the current function invocation. This id is guaranteed to be
    * unique across invocations, but constant across reties and suspensions.
    */
-  readonly id: string;
+  readonly id: InvocationId;
   /**
    * Request headers - the following headers capture the original invocation headers, as provided to
    * the ingress.
@@ -48,6 +55,13 @@ type TypedState = Record<string, any>;
 type UntypedState = {
   _: never;
 };
+/**
+ * Represents an invocation id.
+ * @see {@link InvocationIdParser}
+ */
+type InvocationId = string & {
+  __brand: "InvocationId";
+};
 //#endregion
-export { Request, TypedState, UntypedState };
+export { InvocationId, Request, Target, TypedState, UntypedState };
 //# sourceMappingURL=context.d.cts.map

package/dist/restate-sdk/src/context.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.cts","names":[],"sources":["../../../../restate-sdk/src/context.ts"],"sourcesContent":[],"mappings":";;;;;;AAiFA;AACA;UA9CiB,OAAA;;;;;;;;;;oBAWG;;;;;;2BAOO;;;;iBAKV;;;;;;;;;;;;;;;;mCAkBkB;;KAIvB,UAAA,GAAa;KACb,YAAA"}
+{"version":3,"file":"context.d.cts","names":[],"sources":["../../../../restate-sdk/src/context.ts"],"sourcesContent":[],"mappings":";;AAgDmB,UAdF,MAAA,CAcE;EAMJ,OAAA,EAAA,MAAA;EAMK,OAAA,EAAA,MAAA;EAOO,GAAA,CAAA,EAAA,MAAA;EAKV,QAAA,EAAA,EAAA,MAAA;;;AAsBjB;AACA;AA6lBA;;;UA7oBiB,OAAA;mBACE;;;;;eAMJ;;;;;oBAMK;;;;;;2BAOO;;;;iBAKV;;;;;;;;;;;;;;;;mCAkBkB;;KAIvB,UAAA,GAAa;KACb,YAAA;;;;;;;KA6lBA,YAAA"}

package/dist/restate-sdk/src/context.d.ts

@@ -1,5 +1,11 @@
 //#region ../restate-sdk/src/context.d.ts
 
+interface Target {
+  service: string;
+  handler: string;
+  key?: string;
+  toString(): string;
+}
 /**
  * Represents the original request as sent to this handler.
  *
@@ -7,11 +13,12 @@
  * request body.
  */
 interface Request {
+  readonly target: Target;
   /**
    * The unique id that identifies the current function invocation. This id is guaranteed to be
    * unique across invocations, but constant across reties and suspensions.
    */
-  readonly id: string;
+  readonly id: InvocationId;
   /**
    * Request headers - the following headers capture the original invocation headers, as provided to
    * the ingress.
@@ -48,6 +55,13 @@ type TypedState = Record<string, any>;
 type UntypedState = {
   _: never;
 };
+/**
+ * Represents an invocation id.
+ * @see {@link InvocationIdParser}
+ */
+type InvocationId = string & {
+  __brand: "InvocationId";
+};
 //#endregion
-export { Request, TypedState, UntypedState };
+export { InvocationId, Request, Target, TypedState, UntypedState };
 //# sourceMappingURL=context.d.ts.map

package/dist/restate-sdk/src/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","names":[],"sources":["../../../../restate-sdk/src/context.ts"],"sourcesContent":[],"mappings":";;;;;;AAiFA;AACA;UA9CiB,OAAA;;;;;;;;;;oBAWG;;;;;;2BAOO;;;;iBAKV;;;;;;;;;;;;;;;;mCAkBkB;;KAIvB,UAAA,GAAa;KACb,YAAA"}
+{"version":3,"file":"context.d.ts","names":[],"sources":["../../../../restate-sdk/src/context.ts"],"sourcesContent":[],"mappings":";;AAgDmB,UAdF,MAAA,CAcE;EAMJ,OAAA,EAAA,MAAA;EAMK,OAAA,EAAA,MAAA;EAOO,GAAA,CAAA,EAAA,MAAA;EAKV,QAAA,EAAA,EAAA,MAAA;;;AAsBjB;AACA;AA6lBA;;;UA7oBiB,OAAA;mBACE;;;;;eAMJ;;;;;oBAMK;;;;;;2BAOO;;;;iBAKV;;;;;;;;;;;;;;;;mCAkBkB;;KAIvB,UAAA,GAAa;KACb,YAAA;;;;;;;KA6lBA,YAAA"}

package/dist/restate-sdk/src/context_impl.d.ts

@@ -0,0 +1,2 @@
+import "./endpoint/handlers/types.js";
+import "./promises.js";

package/dist/restate-sdk/src/endpoint/endpoint.d.ts

@@ -0,0 +1 @@
+import "../endpoint.js";

package/dist/restate-sdk/src/endpoint/handlers/types.d.ts

@@ -0,0 +1 @@
+import "../endpoint.js";

package/dist/restate-sdk/src/endpoint/types.d.cts

@@ -2,11 +2,10 @@ import { ServiceDefinition, VirtualObjectDefinition, WorkflowDefinition } from "
 import { JournalValueCodec } from "../../../restate-sdk-core/src/entry_codec.cjs";
 import { LoggerTransport } from "../logging/logger_transport.cjs";
 import { DefaultServiceOptions } from "../endpoint.cjs";
-import "../common_api.cjs";
 
 //#region ../restate-sdk/src/endpoint/types.d.ts
 /**
- * Options for creating an endpoint handler for Node.js HTTP/2 servers.
+ * Options for creating an endpoint handler.
  */
 interface EndpointOptions {
   /**

package/dist/restate-sdk/src/endpoint/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../../../../../restate-sdk/src/endpoint/types.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAYiB,eAAA;;;AAAjB;EAKM,QAAA,EADM,KACN,CAAA,iBAAA,CAAA,MAAA,EAAA,OAAA,CAAA,GACA,uBADA,CAAA,MAAA,EAAA,OAAA,CAAA,GAEA,kBAFA,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EACA;;;;;;;;;;;;;;;0BAkBoB;;;;;;;;;;;;;;;;;;;;;WAqBf;;;;;;;oCAQyB,QAAQ"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../../../../restate-sdk/src/endpoint/types.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAYiB,eAAA;;AAAjB;;EAMM,QAAA,EAFM,KAEN,CADA,iBACA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,uBAAA,CAAA,MAAA,EAAA,OAAA,CAAA,GACA,kBADA,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EACA;;;;;;;;;;;;;;;0BAiBoB;;;;;;;;;;;;;;;;;;;;;WAqBf;;;;;;;oCAQyB,QAAQ"}

package/dist/restate-sdk/src/endpoint/types.d.ts

@@ -6,7 +6,7 @@ import "../common_api.js";
 
 //#region ../restate-sdk/src/endpoint/types.d.ts
 /**
- * Options for creating an endpoint handler for Node.js HTTP/2 servers.
+ * Options for creating an endpoint handler.
  */
 interface EndpointOptions {
   /**

package/dist/restate-sdk/src/endpoint.d.cts

@@ -2,7 +2,8 @@ import { ServiceDefinition, VirtualObjectDefinition, WorkflowDefinition } from "
 import { JournalValueCodec } from "../../restate-sdk-core/src/entry_codec.cjs";
 import { ObjectOptions, ServiceOptions, WorkflowOptions } from "./types/rpc.cjs";
 import { LoggerTransport } from "./logging/logger_transport.cjs";
-import { Http2ServerRequest, Http2ServerResponse } from "http2";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
 
 //#region ../restate-sdk/src/endpoint.d.ts
 type DefaultServiceOptions = ServiceOptions & ObjectOptions & WorkflowOptions;
@@ -64,12 +65,15 @@ interface RestateEndpointBase<E> {
 /**
  * RestateEndpoint encapsulates all the Restate services served by this endpoint.
  *
- * A RestateEndpoint can either be served as HTTP2 server, using the methods {@link RestateEndpoint.listen} or {@link RestateEndpoint.http2Handler}.
+ * A RestateEndpoint can be served as:
+ * - An HTTP/2 server using {@link RestateEndpoint.listen}, {@link RestateEndpoint.http2Handler}
+ * - An HTTP/1.1 server using {@link RestateEndpoint.http1Handler}
+ * - A combined HTTP/1.1 + HTTP/2 server using {@link RestateEndpoint.handler}
  *
  * For Lambda, check {@link LambdaEndpoint}
  *
  * @example
- * A typical endpoint served as HTTP server would look like this:
+ * A typical endpoint served as HTTP/2 server:
  * ```
  * import * as restate from "@restatedev/restate-sdk";
  *
@@ -78,6 +82,28 @@ interface RestateEndpointBase<E> {
  *   .bind(myService)
  *   .listen(8000);
  * ```
+ *
+ * @example
+ * Using the HTTP/1.1 handler with your own server:
+ * ```
+ * import * as http from "node:http";
+ * import * as restate from "@restatedev/restate-sdk";
+ *
+ * const endpoint = restate.endpoint().bind(myService);
+ * const server = http.createServer(endpoint.http1Handler());
+ * server.listen(8000);
+ * ```
+ *
+ * @example
+ * Using the combined handler with an HTTP/2 server that also accepts HTTP/1.1:
+ * ```
+ * import * as http2 from "node:http2";
+ * import * as restate from "@restatedev/restate-sdk";
+ *
+ * const endpoint = restate.endpoint().bind(myService);
+ * const server = http2.createSecureServer({ key, cert, allowHTTP1: true }, endpoint.handler());
+ * server.listen(8000);
+ * ```
  */
 interface RestateEndpoint extends RestateEndpointBase<RestateEndpoint> {
   /**
@@ -104,9 +130,65 @@ interface RestateEndpoint extends RestateEndpointBase<RestateEndpoint> {
    */
   listen(port?: number): Promise<number>;
   /**
-   * Returns an http2 server handler. See {@link RestateEndpoint.listen} for more details.
+   * Returns an http2 server handler.
+   *
+   * By default, this handler uses bidirectional streaming (`BIDI_STREAM`).
+   * Set `bidirectional: false` to use request-response mode (`REQUEST_RESPONSE`).
+   *
+   * See {@link RestateEndpoint.listen} for more details.
+   */
+  http2Handler(options?: {
+    bidirectional?: boolean;
+  }): (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+  /**
+   * Returns an http1 server handler.
+   *
+   * By default, this handler operates in request-response protocol mode (`REQUEST_RESPONSE`),
+   * which buffers the full request before sending the response. This is the safest mode
+   * for HTTP/1.1 and works across all environments and proxies.
+   *
+   * Set `bidirectional: true` to enable bidirectional streaming (`BIDI_STREAM`) for
+   * HTTP/1.1 servers that support it. Note that some proxies and clients may not
+   * handle HTTP/1.1 bidirectional streaming correctly.
+   *
+   * @example
+   * ```
+   * const httpServer = http.createServer(endpoint.http1Handler());
+   * httpServer.listen(port);
+   * ```
+   */
+  http1Handler(options?: {
+    bidirectional?: boolean;
+  }): (request: IncomingMessage, response: ServerResponse) => void;
+  /**
+   * Returns a combined request handler that auto-detects HTTP/1 vs HTTP/2
+   * requests and dispatches to the appropriate internal handler.
+   *
+   * By default (when `bidirectional` is omitted), HTTP/2+ requests use
+   * bidirectional streaming (`BIDI_STREAM`) and HTTP/1 requests use
+   * request-response mode (`REQUEST_RESPONSE`).
+   *
+   * Set `bidirectional: true` to force `BIDI_STREAM` for all requests,
+   * or `bidirectional: false` to force `REQUEST_RESPONSE` for all requests.
+   *
+   * This is useful with `http2.createSecureServer({ allowHTTP1: true })`, where
+   * the same server handles both HTTP/1.1 and HTTP/2 connections.
+   *
+   * @example
+   * ```
+   * const server = http2.createSecureServer(
+   *   { key, cert, allowHTTP1: true },
+   *   endpoint.handler()
+   * );
+   * server.listen(port);
+   * ```
    */
-  http2Handler(): (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+  handler(options?: {
+    bidirectional?: boolean;
+  }): {
+    (request: IncomingMessage, response: ServerResponse): void;
+    (request: Http2ServerRequest, response: Http2ServerResponse): void;
+  };
 }
 //#endregion
 export { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase };

package/dist/restate-sdk/src/endpoint.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"endpoint.d.cts","names":[],"sources":["../../../../restate-sdk/src/endpoint.ts"],"sourcesContent":[],"mappings":";;;;;;;KAyBY,qBAAA,GAAwB,iBAClC,gBACA;UAEe;;AAJjB;;;;EAEiB,IAAA,CAAA,UAAA,MAAA,EAAA,CAAA,CAAA,CAAA,OAAA,EAUT,iBAVS,CAUS,CAVT,EAUY,CAVZ,CAAA,GAWT,uBAXS,CAWe,CAXf,EAWkB,CAXlB,CAAA,GAYT,kBAZS,CAYU,CAZV,EAYa,CAZb,CAAA,CAAA,EAaZ,CAbY;EAEA;;;;;;;;;EAUT,cAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,EAY6B,CAZ7B;EACH;;;;;;;EAmD4C,qBAAA,CAAA,OAAA,EA/BhB,qBA+BgB,CAAA,EA/BQ,CA+BR;EAA6B;;AAqB9E;;;;;;;;;;;;;;;;;;;oBA7BoB,kBAAkB;;;;;;;iDAQW,QAAQ,qBAAqB;;;;;;;;;;;;;;;;;;;;UAqB7D,eAAA,SAAwB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;yBAuBpC;;;;4BAMZ,8BACC"}
+{"version":3,"file":"endpoint.d.cts","names":[],"sources":["../../../../restate-sdk/src/endpoint.ts"],"sourcesContent":[],"mappings":";;;;;;;;KA0BY,qBAAA,GAAwB,iBAClC,gBACA;UAEe;;AAJjB;;;;EAEiB,IAAA,CAAA,UAAA,MAAA,EAAA,CAAA,CAAA,CAAA,OAAA,EAUT,iBAVS,CAUS,CAVT,EAUY,CAVZ,CAAA,GAWT,uBAXS,CAWe,CAXf,EAWkB,CAXlB,CAAA,GAYT,kBAZS,CAYU,CAZV,EAYa,CAZb,CAAA,CAAA,EAaZ,CAbY;EAEA;;;;;;;;;EAUT,cAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,EAY6B,CAZ7B;EACH;;;;;;;EAmD4C,qBAAA,CAAA,OAAA,EA/BhB,qBA+BgB,CAAA,EA/BQ,CA+BR;EAA6B;;AA8C9E;;;;;;;;;;;;;;;;;;;oBAtDoB,kBAAkB;;;;;;;iDAQW,QAAQ,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8C7D,eAAA,SAAwB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;yBAuBpC;;;;;;;;;;;gBAYT,8BAA8B;;;;;;;;;;;;;;;;;;;;gBAqB9B,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0B7B,2BAA2B;cAC3B,8BAA8B"}

package/dist/restate-sdk/src/endpoint.d.ts

@@ -2,7 +2,8 @@ import { ServiceDefinition, VirtualObjectDefinition, WorkflowDefinition } from "
 import { JournalValueCodec } from "../../restate-sdk-core/src/entry_codec.js";
 import { ObjectOptions, ServiceOptions, WorkflowOptions } from "./types/rpc.js";
 import { LoggerTransport } from "./logging/logger_transport.js";
-import { Http2ServerRequest, Http2ServerResponse } from "http2";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
 
 //#region ../restate-sdk/src/endpoint.d.ts
 type DefaultServiceOptions = ServiceOptions & ObjectOptions & WorkflowOptions;
@@ -64,12 +65,15 @@ interface RestateEndpointBase<E> {
 /**
  * RestateEndpoint encapsulates all the Restate services served by this endpoint.
  *
- * A RestateEndpoint can either be served as HTTP2 server, using the methods {@link RestateEndpoint.listen} or {@link RestateEndpoint.http2Handler}.
+ * A RestateEndpoint can be served as:
+ * - An HTTP/2 server using {@link RestateEndpoint.listen}, {@link RestateEndpoint.http2Handler}
+ * - An HTTP/1.1 server using {@link RestateEndpoint.http1Handler}
+ * - A combined HTTP/1.1 + HTTP/2 server using {@link RestateEndpoint.handler}
  *
  * For Lambda, check {@link LambdaEndpoint}
  *
  * @example
- * A typical endpoint served as HTTP server would look like this:
+ * A typical endpoint served as HTTP/2 server:
  * ```
  * import * as restate from "@restatedev/restate-sdk";
  *
@@ -78,6 +82,28 @@ interface RestateEndpointBase<E> {
  *   .bind(myService)
  *   .listen(8000);
  * ```
+ *
+ * @example
+ * Using the HTTP/1.1 handler with your own server:
+ * ```
+ * import * as http from "node:http";
+ * import * as restate from "@restatedev/restate-sdk";
+ *
+ * const endpoint = restate.endpoint().bind(myService);
+ * const server = http.createServer(endpoint.http1Handler());
+ * server.listen(8000);
+ * ```
+ *
+ * @example
+ * Using the combined handler with an HTTP/2 server that also accepts HTTP/1.1:
+ * ```
+ * import * as http2 from "node:http2";
+ * import * as restate from "@restatedev/restate-sdk";
+ *
+ * const endpoint = restate.endpoint().bind(myService);
+ * const server = http2.createSecureServer({ key, cert, allowHTTP1: true }, endpoint.handler());
+ * server.listen(8000);
+ * ```
  */
 interface RestateEndpoint extends RestateEndpointBase<RestateEndpoint> {
   /**
@@ -104,9 +130,65 @@ interface RestateEndpoint extends RestateEndpointBase<RestateEndpoint> {
    */
   listen(port?: number): Promise<number>;
   /**
-   * Returns an http2 server handler. See {@link RestateEndpoint.listen} for more details.
+   * Returns an http2 server handler.
+   *
+   * By default, this handler uses bidirectional streaming (`BIDI_STREAM`).
+   * Set `bidirectional: false` to use request-response mode (`REQUEST_RESPONSE`).
+   *
+   * See {@link RestateEndpoint.listen} for more details.
+   */
+  http2Handler(options?: {
+    bidirectional?: boolean;
+  }): (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+  /**
+   * Returns an http1 server handler.
+   *
+   * By default, this handler operates in request-response protocol mode (`REQUEST_RESPONSE`),
+   * which buffers the full request before sending the response. This is the safest mode
+   * for HTTP/1.1 and works across all environments and proxies.
+   *
+   * Set `bidirectional: true` to enable bidirectional streaming (`BIDI_STREAM`) for
+   * HTTP/1.1 servers that support it. Note that some proxies and clients may not
+   * handle HTTP/1.1 bidirectional streaming correctly.
+   *
+   * @example
+   * ```
+   * const httpServer = http.createServer(endpoint.http1Handler());
+   * httpServer.listen(port);
+   * ```
+   */
+  http1Handler(options?: {
+    bidirectional?: boolean;
+  }): (request: IncomingMessage, response: ServerResponse) => void;
+  /**
+   * Returns a combined request handler that auto-detects HTTP/1 vs HTTP/2
+   * requests and dispatches to the appropriate internal handler.
+   *
+   * By default (when `bidirectional` is omitted), HTTP/2+ requests use
+   * bidirectional streaming (`BIDI_STREAM`) and HTTP/1 requests use
+   * request-response mode (`REQUEST_RESPONSE`).
+   *
+   * Set `bidirectional: true` to force `BIDI_STREAM` for all requests,
+   * or `bidirectional: false` to force `REQUEST_RESPONSE` for all requests.
+   *
+   * This is useful with `http2.createSecureServer({ allowHTTP1: true })`, where
+   * the same server handles both HTTP/1.1 and HTTP/2 connections.
+   *
+   * @example
+   * ```
+   * const server = http2.createSecureServer(
+   *   { key, cert, allowHTTP1: true },
+   *   endpoint.handler()
+   * );
+   * server.listen(port);
+   * ```
    */
-  http2Handler(): (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+  handler(options?: {
+    bidirectional?: boolean;
+  }): {
+    (request: IncomingMessage, response: ServerResponse): void;
+    (request: Http2ServerRequest, response: Http2ServerResponse): void;
+  };
 }
 //#endregion
 export { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase };

package/dist/restate-sdk/src/endpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"endpoint.d.ts","names":[],"sources":["../../../../restate-sdk/src/endpoint.ts"],"sourcesContent":[],"mappings":";;;;;;;KAyBY,qBAAA,GAAwB,iBAClC,gBACA;UAEe;;AAJjB;;;;EAEiB,IAAA,CAAA,UAAA,MAAA,EAAA,CAAA,CAAA,CAAA,OAAA,EAUT,iBAVS,CAUS,CAVT,EAUY,CAVZ,CAAA,GAWT,uBAXS,CAWe,CAXf,EAWkB,CAXlB,CAAA,GAYT,kBAZS,CAYU,CAZV,EAYa,CAZb,CAAA,CAAA,EAaZ,CAbY;EAEA;;;;;;;;;EAUT,cAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,EAY6B,CAZ7B;EACH;;;;;;;EAmD4C,qBAAA,CAAA,OAAA,EA/BhB,qBA+BgB,CAAA,EA/BQ,CA+BR;EAA6B;;AAqB9E;;;;;;;;;;;;;;;;;;;oBA7BoB,kBAAkB;;;;;;;iDAQW,QAAQ,qBAAqB;;;;;;;;;;;;;;;;;;;;UAqB7D,eAAA,SAAwB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;yBAuBpC;;;;4BAMZ,8BACC"}
+{"version":3,"file":"endpoint.d.ts","names":[],"sources":["../../../../restate-sdk/src/endpoint.ts"],"sourcesContent":[],"mappings":";;;;;;;;KA0BY,qBAAA,GAAwB,iBAClC,gBACA;UAEe;;AAJjB;;;;EAEiB,IAAA,CAAA,UAAA,MAAA,EAAA,CAAA,CAAA,CAAA,OAAA,EAUT,iBAVS,CAUS,CAVT,EAUY,CAVZ,CAAA,GAWT,uBAXS,CAWe,CAXf,EAWkB,CAXlB,CAAA,GAYT,kBAZS,CAYU,CAZV,EAYa,CAZb,CAAA,CAAA,EAaZ,CAbY;EAEA;;;;;;;;;EAUT,cAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,EAY6B,CAZ7B;EACH;;;;;;;EAmD4C,qBAAA,CAAA,OAAA,EA/BhB,qBA+BgB,CAAA,EA/BQ,CA+BR;EAA6B;;AA8C9E;;;;;;;;;;;;;;;;;;;oBAtDoB,kBAAkB;;;;;;;iDAQW,QAAQ,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8C7D,eAAA,SAAwB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;yBAuBpC;;;;;;;;;;;gBAYT,8BAA8B;;;;;;;;;;;;;;;;;;;;gBAqB9B,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0B7B,2BAA2B;cAC3B,8BAA8B"}

package/dist/restate-sdk/src/hooks.d.cts

@@ -0,0 +1,87 @@
+import { Request } from "./context.cjs";
+
+//#region ../restate-sdk/src/hooks.d.ts
+
+/**
+ * Interceptors wrap handler and ctx.run() execution. They are part of the
+ * invocation — anything that happens inside them (including after `next()`)
+ * affects the invocation outcome.
+ *
+ * ## Error behavior
+ *
+ * Errors thrown at any point (before or after `next()`) affect the invocation:
+ *
+ * - **{@link TerminalError}** — the invocation **fails immediately**, no retry.
+ * - **Any other error** — Restate **retries** the invocation.
+ * - On suspension or pause, `next()` also rejects with an error. This does not
+ *   mean the invocation failed — the attempt is simply ending. Do any cleanup
+ *   you need and rethrow.
+ *
+ * ## Output
+ *
+ * Interceptors **cannot alter the handler's success return value** (the `void`
+ * signature means there is no way to replace it), but they **can transform
+ * errors** by catching and rethrowing a different error.
+ *
+ * ## Rules
+ *
+ * - `next()` must be called exactly once.
+ *
+ * ## When interceptors fire
+ *
+ * - `handler` fires on every attempt.
+ * - `run` fires when the `ctx.run()` closure executes. If the result is
+ *   already in the journal, the closure is skipped and so is the interceptor.
+ *
+ * @example
+ * ```ts
+ * interceptor: {
+ *   handler: async (next) => {
+ *     console.log(`before ${ctx.request.target}`);
+ *     try {
+ *       await next();
+ *       console.log(`after ${ctx.request.target}`);
+ *     } catch (e) {
+ *       console.log(`error ${ctx.request.target}: ${e}`);
+ *       // Always rethrow — swallowing the error changes the
+ *       // invocation outcome. You can also throw a different
+ *       // error (e.g. TerminalError to fail immediately).
+ *       throw e;
+ *     }
+ *   },
+ *   run: async (name, next) => {
+ *     console.log(`  before run "${name}"`);
+ *     try {
+ *       await next();
+ *       console.log(`  after run "${name}"`);
+ *     } catch (e) {
+ *       console.log(`  error run "${name}": ${e}`);
+ *       throw e;
+ *     }
+ *   },
+ * }
+ * ```
+ */
+interface Interceptor {
+  /** Wraps the entire handler invocation. Fires on every attempt. */
+  handler?: (next: () => Promise<void>) => Promise<void>;
+  /**
+   * Wraps each `ctx.run()` call. Only fires for runs that actually execute —
+   * replayed runs (already in the journal) are skipped.
+   * `name` is the run's label.
+   */
+  run?: (name: string, next: () => Promise<void>) => Promise<void>;
+}
+interface Hooks {
+  interceptor?: Interceptor;
+}
+/**
+ * Factory called on every attempt. Receives the invocation request,
+ * returns hooks for that attempt's lifetime. Each attempt gets a fresh call.
+ */
+type HooksProvider = (ctx: {
+  request: Request;
+}) => Hooks;
+//#endregion
+export { Hooks, HooksProvider, Interceptor };
+//# sourceMappingURL=hooks.d.cts.map

package/dist/restate-sdk/src/hooks.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.cts","names":[],"sources":["../../../../restate-sdk/src/hooks.ts"],"sourcesContent":[],"mappings":";;;;;;AAgEA;;;;;;AAaA;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAvBiB,WAAA;;yBAEQ,kBAAkB;;;;;;mCAMR,kBAAkB;;UAKpC,KAAA;gBACD;;;;;;KASJ,aAAA;WAAiC;MAAc"}

package/dist/restate-sdk/src/hooks.d.ts

@@ -0,0 +1,87 @@
+import { Request } from "./context.js";
+
+//#region ../restate-sdk/src/hooks.d.ts
+
+/**
+ * Interceptors wrap handler and ctx.run() execution. They are part of the
+ * invocation — anything that happens inside them (including after `next()`)
+ * affects the invocation outcome.
+ *
+ * ## Error behavior
+ *
+ * Errors thrown at any point (before or after `next()`) affect the invocation:
+ *
+ * - **{@link TerminalError}** — the invocation **fails immediately**, no retry.
+ * - **Any other error** — Restate **retries** the invocation.
+ * - On suspension or pause, `next()` also rejects with an error. This does not
+ *   mean the invocation failed — the attempt is simply ending. Do any cleanup
+ *   you need and rethrow.
+ *
+ * ## Output
+ *
+ * Interceptors **cannot alter the handler's success return value** (the `void`
+ * signature means there is no way to replace it), but they **can transform
+ * errors** by catching and rethrowing a different error.
+ *
+ * ## Rules
+ *
+ * - `next()` must be called exactly once.
+ *
+ * ## When interceptors fire
+ *
+ * - `handler` fires on every attempt.
+ * - `run` fires when the `ctx.run()` closure executes. If the result is
+ *   already in the journal, the closure is skipped and so is the interceptor.
+ *
+ * @example
+ * ```ts
+ * interceptor: {
+ *   handler: async (next) => {
+ *     console.log(`before ${ctx.request.target}`);
+ *     try {
+ *       await next();
+ *       console.log(`after ${ctx.request.target}`);
+ *     } catch (e) {
+ *       console.log(`error ${ctx.request.target}: ${e}`);
+ *       // Always rethrow — swallowing the error changes the
+ *       // invocation outcome. You can also throw a different
+ *       // error (e.g. TerminalError to fail immediately).
+ *       throw e;
+ *     }
+ *   },
+ *   run: async (name, next) => {
+ *     console.log(`  before run "${name}"`);
+ *     try {
+ *       await next();
+ *       console.log(`  after run "${name}"`);
+ *     } catch (e) {
+ *       console.log(`  error run "${name}": ${e}`);
+ *       throw e;
+ *     }
+ *   },
+ * }
+ * ```
+ */
+interface Interceptor {
+  /** Wraps the entire handler invocation. Fires on every attempt. */
+  handler?: (next: () => Promise<void>) => Promise<void>;
+  /**
+   * Wraps each `ctx.run()` call. Only fires for runs that actually execute —
+   * replayed runs (already in the journal) are skipped.
+   * `name` is the run's label.
+   */
+  run?: (name: string, next: () => Promise<void>) => Promise<void>;
+}
+interface Hooks {
+  interceptor?: Interceptor;
+}
+/**
+ * Factory called on every attempt. Receives the invocation request,
+ * returns hooks for that attempt's lifetime. Each attempt gets a fresh call.
+ */
+type HooksProvider = (ctx: {
+  request: Request;
+}) => Hooks;
+//#endregion
+export { Hooks, HooksProvider, Interceptor };
+//# sourceMappingURL=hooks.d.ts.map

package/dist/restate-sdk/src/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","names":[],"sources":["../../../../restate-sdk/src/hooks.ts"],"sourcesContent":[],"mappings":";;;;;;AAgEA;;;;;;AAaA;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAvBiB,WAAA;;yBAEQ,kBAAkB;;;;;;mCAMR,kBAAkB;;UAKpC,KAAA;gBACD;;;;;;KASJ,aAAA;WAAiC;MAAc"}

package/dist/restate-sdk/src/index.d.cts

@@ -3,8 +3,9 @@ import { Serde } from "../../restate-sdk-core/src/serde_api.cjs";
 import { Duration } from "../../restate-sdk-core/src/duration.cjs";
 import { JournalValueCodec } from "../../restate-sdk-core/src/entry_codec.cjs";
 import { RestateError, TerminalError } from "./types/errors.cjs";
+import { Hooks, HooksProvider, Interceptor } from "./hooks.cjs";
 import { ObjectOptions, RetryPolicy, ServiceOptions, WorkflowOptions } from "./types/rpc.cjs";
-import { Request, TypedState, UntypedState } from "./context.cjs";
+import { InvocationId, Request, Target, TypedState, UntypedState } from "./context.cjs";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.cjs";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.cjs";
 import { EndpointOptions } from "./endpoint/types.cjs";

package/dist/restate-sdk/src/index.d.ts

@@ -3,8 +3,9 @@ import { Serde } from "../../restate-sdk-core/src/serde_api.js";
 import { Duration } from "../../restate-sdk-core/src/duration.js";
 import { JournalValueCodec } from "../../restate-sdk-core/src/entry_codec.js";
 import { RestateError, TerminalError } from "./types/errors.js";
+import { Hooks, HooksProvider, Interceptor } from "./hooks.js";
 import { ObjectOptions, RetryPolicy, ServiceOptions, WorkflowOptions } from "./types/rpc.js";
-import { Request, TypedState, UntypedState } from "./context.js";
+import { InvocationId, Request, Target, TypedState, UntypedState } from "./context.js";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.js";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.js";
 import { EndpointOptions } from "./endpoint/types.js";

package/dist/restate-sdk/src/io.d.ts

@@ -0,0 +1 @@
+import "./endpoint/handlers/types.js";