effect-inngest 0.3.0-beta.3 → 0.3.0-beta.4

package/dist/Group.d.ts

@@ -127,7 +127,7 @@ declare const make: <Fns extends ReadonlyArray<InngestFunction.Any>>(...fns: Fns
  * )
  * ```
  */
-declare const toHttpApp: (group: InngestGroup.Any) => Effect.Effect<_$effect_unstable_http_HttpServerResponse0.HttpServerResponse, never, InngestClient | HttpClient.HttpClient | _$effect_unstable_http_HttpServerRequest0.HttpServerRequest>;
+declare const toHttpApp: (group: InngestGroup.Any) => Effect.Effect<_$effect_unstable_http_HttpServerResponse0.HttpServerResponse, never, InngestClient | _$effect_unstable_http_HttpServerRequest0.HttpServerRequest | HttpClient.HttpClient>;
 /**
  * Create a standalone web handler from an InngestGroup.
  *

package/dist/HttpApi.d.ts

@@ -49,13 +49,13 @@ declare const InngestApiGroup_base: HttpApiGroup.HttpApiGroup<"inngest", HttpApi
   readonly authentication_succeeded: Schema.optional<Schema.Union<readonly [Schema.Literal<false>, Schema.Null]>>;
   readonly capabilities: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
   readonly functions: Schema.optionalKey<Schema.$Array<Schema.Unknown>>;
-}>]>>, HttpApiEndpoint.Json<typeof FunctionNotFoundError | typeof InvalidRequestError | typeof SignatureError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"register", "PUT", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>]>>, HttpApiEndpoint.Json<typeof InvalidRequestError | typeof FunctionNotFoundError | typeof SignatureError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"register", "PUT", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
   readonly message: Schema.String;
   readonly modified: Schema.Boolean;
-}>>, HttpApiEndpoint.Json<typeof FunctionNotFoundError | typeof InvalidRequestError | typeof SignatureError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"execute", "POST", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, HttpApiEndpoint.Json<typeof InvalidRequestError | typeof FunctionNotFoundError | typeof SignatureError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"execute", "POST", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
   readonly fnId: Schema.String;
   readonly stepId: Schema.optional<Schema.String>;
-}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Unknown>, HttpApiEndpoint.Json<typeof FunctionNotFoundError | typeof InvalidRequestError | typeof SignatureError>, never, never>, false>;
+}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Unknown>, HttpApiEndpoint.Json<typeof InvalidRequestError | typeof FunctionNotFoundError | typeof SignatureError>, never, never>, false>;
 /**
  * @since 0.1.0
  * @category api

package/dist/HttpApi.js

@@ -56,7 +56,8 @@ const layerGroup = (api, group) => {
 			group,
 			fnId: query.fnId,
 			urlStepId: query.stepId,
-			body: payload
+			body: payload,
+			headers: request.headers
 		})), Effect.map((r) => r.body)));
 	})).pipe(Layer.provide(SignatureLive));
 };

package/dist/internal/checkpoint/Abort.d.ts

@@ -0,0 +1 @@
+import { Schema } from "effect";

package/dist/internal/checkpoint/Abort.js

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+//#region src/internal/checkpoint/Abort.ts
+var StaleDispatch = class extends Schema.TaggedClass()("StaleDispatch", {}) {};
+//#endregion
+export { StaleDispatch };

package/dist/internal/checkpoint/State.d.ts

@@ -1 +1 @@
-import { Effect } from "effect";
+import { Effect, Option } from "effect";

package/dist/internal/checkpoint/State.js

@@ -1,3 +1,4 @@
+import { StaleDispatch } from "./Abort.js";
 import { Array, Clock, Duration, Effect, Option, Ref, Result } from "effect";
 //#region src/internal/checkpoint/State.ts
 const make = (args) => Effect.sync(() => {
@@ -5,12 +6,17 @@ const make = (args) => Effect.sync(() => {
 	const plannedBuffer = Ref.makeUnsafe(Array.empty());
 	const intervalStartedAt = Ref.makeUnsafe(Option.none());
 	const runtimeExceeded = Ref.makeUnsafe(false);
+	const abort = Ref.makeUnsafe(Option.none());
 	const maxIntervalMs = Duration.toMillis(args.config.maxInterval);
 	const flushInner = Effect.gen(function* () {
 		const steps = yield* Ref.modify(buffer, (current) => [current, Array.empty()]);
 		if (steps.length === 0) return;
 		const result = yield* Effect.result(args.checkpointAsync(steps));
 		if (Result.isFailure(result)) {
+			if (result.failure.status === 409) {
+				yield* Ref.set(abort, Option.some(StaleDispatch.make({})));
+				return yield* Effect.interrupt;
+			}
 			yield* Ref.update(buffer, (current) => [...steps, ...current]);
 			return;
 		}
@@ -47,7 +53,8 @@ const make = (args) => Effect.sync(() => {
 		flush: flushInner,
 		takeCompleted,
 		markRuntimeExceeded: Ref.set(runtimeExceeded, true),
-		isRuntimeExceeded: Ref.get(runtimeExceeded)
+		isRuntimeExceeded: Ref.get(runtimeExceeded),
+		abort: Ref.get(abort)
 	};
 });
 //#endregion

package/dist/internal/errors.js

@@ -21,6 +21,6 @@ var RetryAfterError = class extends Schema.TaggedErrorClass()("RetryAfterError",
 	retryAfter: Schema.DurationFromMillis,
 	cause: Schema.optional(Schema.Unknown)
 }) {};
-const isRetryAfterError = Predicate.isTagged("RetryAfterError");
+const isRetryAfterError = Schema.is(RetryAfterError);
 //#endregion
 export { NonRetriableError, RetryAfterError, SendEventError, StepError, isNonRetriableError, isRetryAfterError, isStepError };

package/dist/internal/execution/ExecutionResponse.js

@@ -1,6 +1,7 @@
 import { GeneratorOpcode } from "../protocol.js";
 import { InngestConfig } from "../../Client.js";
 import { CurrentCheckpoint } from "../runtime/CheckpointContext.js";
+import { StepError } from "../errors.js";
 import { StepCommandBus } from "../runtime/StepCommandBus.js";
 import { ExecutionFailure } from "./ExecutionFailure.js";
 import { RetryDisposition, base } from "./ExecutionHeaders.js";
@@ -23,7 +24,27 @@ const fromSuccess = (args) => Effect.gen(function* () {
 		headers: args.headers
 	})), Match.tag("CheckpointDeadlineElapsed", () => ExecutionResult.checkpointDeadlineOutsideCheckpoint(args)), Match.exhaustive);
 });
+const fromCheckpointAbort = (args) => Match.value(args.abort).pipe(Match.tag("StaleDispatch", () => {
+	const error = new StepError({
+		stepId: "checkpoint",
+		message: "Stale dispatch: checkpoint returned 409",
+		noRetry: true
+	});
+	return ExecutionResult.userError({
+		error,
+		headers: args.headers,
+		disposition: RetryDisposition.fromError(error)
+	});
+}), Match.exhaustive);
 const fromFailure = (args) => Effect.gen(function* () {
+	const checkpoint = yield* CurrentCheckpoint;
+	if (Cause.hasInterruptsOnly(args.cause) && Option.isSome(checkpoint)) {
+		const abort = yield* checkpoint.value.abort;
+		if (Option.isSome(abort)) return fromCheckpointAbort({
+			abort: abort.value,
+			headers: args.headers
+		});
+	}
 	const commands = yield* (yield* StepCommandBus).takeSuspension();
 	if (commands.suspendedCount > 0 && Cause.hasInterruptsOnly(args.cause)) return ExecutionResult.opcodesWithRetry({
 		opcodes: commands.opcodes,
@@ -45,10 +66,18 @@ const fromFailure = (args) => Effect.gen(function* () {
 	});
 });
 const fromExit = (exit) => Effect.gen(function* () {
-	const config = yield* InngestConfig;
-	const bus = yield* StepCommandBus;
-	const headers = base(config);
-	const planned = yield* bus.takePlanned();
+	const headers = base(yield* InngestConfig);
+	if (Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) {
+		const checkpoint = yield* CurrentCheckpoint;
+		if (Option.isSome(checkpoint)) {
+			const abort = yield* checkpoint.value.abort;
+			if (Option.isSome(abort)) return fromCheckpointAbort({
+				abort: abort.value,
+				headers
+			});
+		}
+	}
+	const planned = yield* (yield* StepCommandBus).takePlanned();
 	if (planned.length > 0) return ExecutionResult.opcodes({
 		opcodes: planned,
 		headers

package/dist/internal/handler.js

@@ -1,5 +1,5 @@
 import { resolveConfig } from "./checkpoint/Config.js";
-import { Headers, RegisterServerResponse, SDKRequestBody, SDKRequestContext, UserError } from "./protocol.js";
+import { Headers as Headers$1, RegisterServerResponse, SDKRequestBody, SDKRequestContext, UserError } from "./protocol.js";
 import "./serve/Signature.js";
 import { InngestClient } from "../Client.js";
 import { schemaBodyJson, verifySignature } from "./serve/Request.js";
@@ -9,16 +9,17 @@ import * as HttpClient from "effect/unstable/http/HttpClient";
 import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
 import "effect/unstable/http/HttpServerRequest";
+import * as Headers from "effect/unstable/http/Headers";
 //#region src/internal/handler.ts
 var InvalidRequestError = class extends Schema.TaggedErrorClass()("InvalidRequestError", { message: Schema.String }) {};
 const SDK_VERSION = "2.0.0";
 const baseHeaders = (framework) => ({
 	"Content-Type": "application/json",
 	"User-Agent": `effect-inngest:v${SDK_VERSION}`,
-	[Headers.SDK]: `effect-inngest:v${SDK_VERSION}`,
-	[Headers.SDKHandled]: "true",
-	[Headers.RequestVersion]: "2",
-	...framework ? { [Headers.Framework]: framework } : {}
+	[Headers$1.SDK]: `effect-inngest:v${SDK_VERSION}`,
+	[Headers$1.SDKHandled]: "true",
+	[Headers$1.RequestVersion]: "2",
+	...framework ? { [Headers$1.Framework]: framework } : {}
 });
 const buildServeUrl = (args) => {
 	const url = new URL(args.requestUrl);
@@ -66,11 +67,11 @@ const handleRegistration = Effect.fn("effect-inngest/handler/handleRegistration"
 	const framework = config.framework;
 	const registerUrl = new URL("fn/register", client.apiBaseUrl).toString();
 	const registerHeaders = baseHeaders(framework);
-	delete registerHeaders[Headers.RequestVersion];
+	delete registerHeaders[Headers$1.RequestVersion];
 	const request = HttpClientRequest.post(registerUrl).pipe(HttpClientRequest.setHeaders({
 		...registerHeaders,
 		Authorization: `Bearer ${config.signingKey ?? ""}`,
-		[Headers.SyncKind]: "out_of_band"
+		[Headers$1.SyncKind]: "out_of_band"
 	}), HttpClientRequest.bodyJsonUnsafe({
 		url: url.href,
 		deployType: "ping",
@@ -99,7 +100,7 @@ const handleRegistration = Effect.fn("effect-inngest/handler/handleRegistration"
 			status: 200,
 			headers: {
 				...baseHeaders(config.framework),
-				[Headers.SyncKind]: "out_of_band"
+				[Headers$1.SyncKind]: "out_of_band"
 			},
 			body: {
 				message: "Successfully registered",
@@ -131,7 +132,7 @@ const handleExecution = Effect.fn("effect-inngest/handler/handleExecution")(func
 		status: 500,
 		headers: {
 			...baseHeaders(client.config.framework),
-			[Headers.NoRetry]: "false"
+			[Headers$1.NoRetry]: "false"
 		},
 		body: UserError.make({
 			name: "FunctionNotFoundError",
@@ -139,27 +140,39 @@ const handleExecution = Effect.fn("effect-inngest/handler/handleExecution")(func
 		})
 	};
 	const requestedStepId = args.urlStepId === "step" ? void 0 : args.urlStepId;
+	const requestId = (args.headers ? Option.getOrUndefined(Headers.get(args.headers, Headers$1.RequestId)) : void 0) ?? args.body.ctx.request_id;
+	const rawGenerationId = args.headers ? Option.getOrUndefined(Headers.get(args.headers, Headers$1.GenerationId)) : void 0;
+	const parsedGenerationId = rawGenerationId ? Number(rawGenerationId) : void 0;
+	const generationId = Predicate.isNumber(parsedGenerationId) && Number.isInteger(parsedGenerationId) ? parsedGenerationId : args.body.ctx.generation_id;
+	const withExecutionHeaders = (ctx) => SDKRequestContext.make({
+		fn_id: ctx.fn_id,
+		run_id: ctx.run_id,
+		env: ctx.env,
+		step_id: requestedStepId ?? ctx.step_id,
+		attempt: ctx.attempt,
+		max_attempts: ctx.max_attempts,
+		qi_id: ctx.qi_id,
+		...Predicate.isNotUndefined(requestId) ? { request_id: requestId } : {},
+		...Predicate.isNotUndefined(generationId) ? { generation_id: generationId } : {},
+		disable_immediate_execution: ctx.disable_immediate_execution,
+		use_api: ctx.use_api,
+		stack: ctx.stack
+	});
 	const effectiveBody = requestedStepId && requestedStepId !== args.body.ctx.step_id ? SDKRequestBody.make({
 		event: args.body.event,
 		events: args.body.events,
 		steps: args.body.steps,
-		ctx: SDKRequestContext.make({
-			fn_id: args.body.ctx.fn_id,
-			run_id: args.body.ctx.run_id,
-			env: args.body.ctx.env,
-			step_id: requestedStepId,
-			attempt: args.body.ctx.attempt,
-			max_attempts: args.body.ctx.max_attempts,
-			qi_id: args.body.ctx.qi_id,
-			...Predicate.isNotUndefined(args.body.ctx.request_id) ? { request_id: args.body.ctx.request_id } : {},
-			...Predicate.isNotUndefined(args.body.ctx.generation_id) ? { generation_id: args.body.ctx.generation_id } : {},
-			disable_immediate_execution: args.body.ctx.disable_immediate_execution,
-			use_api: args.body.ctx.use_api,
-			stack: args.body.ctx.stack
-		}),
+		ctx: withExecutionHeaders(args.body.ctx),
 		version: args.body.version,
 		use_api: args.body.use_api
-	}) : args.body;
+	}) : SDKRequestBody.make({
+		event: args.body.event,
+		events: args.body.events,
+		steps: args.body.steps,
+		ctx: withExecutionHeaders(args.body.ctx),
+		version: args.body.version,
+		use_api: args.body.use_api
+	});
 	const checkpointConfig = !requestedStepId && effectiveBody.ctx.fn_id !== "" && !effectiveBody.ctx.disable_immediate_execution && effectiveBody.ctx.attempt === 0 ? Option.fromNullishOr(resolveConfig(fn.options.checkpointing, client.config.checkpointing)) : Option.none();
 	const result = yield* Effect.provide(execute({
 		fn,

package/dist/internal/protocol.js

@@ -90,6 +90,9 @@ const Headers = {
 	SyncKind: "x-inngest-sync-kind",
 	ServerKind: "X-Inngest-Server-Kind",
 	ExpectedServerKind: "X-Inngest-Expected-Server-Kind",
+	RequestId: "x-request-id",
+	GenerationId: "x-inngest-generation-id",
+	JobId: "x-inngest-job-id",
 	RunID: "X-Run-ID",
 	Framework: "X-Inngest-Framework",
 	Platform: "X-Inngest-Platform",

package/dist/internal/serve/HttpApp.js

@@ -54,7 +54,8 @@ const toHttpApp = (group) => Effect.gen(function* () {
 			group,
 			fnId: params.fnId,
 			urlStepId: params.stepId,
-			body
+			body,
+			headers: request.headers
 		});
 		return yield* HttpServerResponse.json(result.body, {
 			status: result.status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-inngest",
-  "version": "0.3.0-beta.3",
+  "version": "0.3.0-beta.4",
   "description": "Native Effect client library for Inngest - build durable, type-safe workflows",
   "keywords": [
     "background-jobs",

package/src/HttpApi.ts

@@ -78,7 +78,13 @@ export const layerGroup = <ApiId extends string, Groups extends HttpApiGroup.Any
         .handleRaw("execute", ({ query, request }) =>
           InternalHandler.verifyAndParseRequestBody(request).pipe(
             Effect.flatMap((payload) =>
-              InternalHandler.handleExecution({ group, fnId: query.fnId, urlStepId: query.stepId, body: payload }),
+              InternalHandler.handleExecution({
+                group,
+                fnId: query.fnId,
+                urlStepId: query.stepId,
+                body: payload,
+                headers: request.headers,
+              }),
             ),
             Effect.map((r) => r.body),
           ),

package/src/internal/checkpoint/Abort.ts

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+
+export class StaleDispatch extends Schema.TaggedClass<StaleDispatch>()("StaleDispatch", {}) {}
+
+export type CheckpointAbort = StaleDispatch;

package/src/internal/checkpoint/State.ts

@@ -1,4 +1,5 @@
 import { Array as Arr, Clock, Duration, Effect, Option, Ref, Result } from "effect";
+import * as CheckpointAbort from "./Abort.js";
 import type { CheckpointConfig } from "./Config.js";
 import type { CheckpointApiError } from "./Error.js";
 import type * as StepCommand from "../domain/StepCommand.js";
@@ -16,6 +17,7 @@ export interface CheckpointState {
   readonly takeCompleted: () => Effect.Effect<ReadonlyArray<typeof Protocol.GeneratorOpcode.Type>>;
   readonly markRuntimeExceeded: Effect.Effect<void>;
   readonly isRuntimeExceeded: Effect.Effect<boolean>;
+  readonly abort: Effect.Effect<Option.Option<CheckpointAbort.CheckpointAbort>>;
 }
 
 export const make = (args: {
@@ -32,6 +34,7 @@ export const make = (args: {
     const plannedBuffer = Ref.makeUnsafe<ReadonlyArray<StepCommand.PlannedOpcode>>(Arr.empty());
     const intervalStartedAt = Ref.makeUnsafe<Option.Option<number>>(Option.none());
     const runtimeExceeded = Ref.makeUnsafe(false);
+    const abort = Ref.makeUnsafe<Option.Option<CheckpointAbort.CheckpointAbort>>(Option.none());
 
     const maxIntervalMs = Duration.toMillis(args.config.maxInterval);
 
@@ -50,6 +53,10 @@ export const make = (args: {
       }
       const result = yield* Effect.result(args.checkpointAsync(steps));
       if (Result.isFailure(result)) {
+        if (result.failure.status === 409) {
+          yield* Ref.set(abort, Option.some(CheckpointAbort.StaleDispatch.make({})));
+          return yield* Effect.interrupt;
+        }
         // Restore at the head so subsequent `completed` includes them in the 206.
         yield* Ref.update(buffer, (current) => [...steps, ...current]);
         return;
@@ -103,5 +110,6 @@ export const make = (args: {
       takeCompleted,
       markRuntimeExceeded: Ref.set(runtimeExceeded, true),
       isRuntimeExceeded: Ref.get(runtimeExceeded),
+      abort: Ref.get(abort),
     };
   });

package/src/internal/errors.ts

@@ -31,6 +31,4 @@ export class RetryAfterError extends Schema.TaggedErrorClass<RetryAfterError>()(
   cause: Schema.optional(Schema.Unknown),
 }) {}
 
-export const isRetryAfterError: (u: unknown) => u is RetryAfterError = Predicate.isTagged("RetryAfterError") as (
-  u: unknown,
-) => u is RetryAfterError;
+export const isRetryAfterError = Schema.is(RetryAfterError);

package/src/internal/execution/ExecutionResponse.ts

@@ -1,8 +1,10 @@
 import type * as Headers from "effect/unstable/http/Headers";
 import { Cause, Effect, Exit, Match, Option } from "effect";
 import { InngestConfig } from "../../Client.js";
+import type * as CheckpointAbort from "../checkpoint/Abort.js";
 import { CurrentCheckpoint } from "../runtime/CheckpointContext.js";
 import { StepCommandBus } from "../runtime/StepCommandBus.js";
+import { StepError } from "../errors.js";
 import * as Protocol from "../protocol.js";
 import { ExecutionFailure } from "./ExecutionFailure.js";
 import * as ExecutionHeaders from "./ExecutionHeaders.js";
@@ -34,8 +36,38 @@ const fromSuccess = (args: { readonly completion: HandlerRun.HandlerCompletion;
     );
   });
 
+const fromCheckpointAbort = (args: {
+  readonly abort: CheckpointAbort.CheckpointAbort;
+  readonly headers: Headers.Headers;
+}) =>
+  Match.value(args.abort).pipe(
+    Match.tag("StaleDispatch", () => {
+      const error = new StepError({
+        stepId: "checkpoint",
+        message: "Stale dispatch: checkpoint returned 409",
+        noRetry: true,
+      });
+
+      return ExecutionResult.userError({
+        error,
+        headers: args.headers,
+        disposition: ExecutionHeaders.RetryDisposition.fromError(error),
+      });
+    }),
+    Match.exhaustive,
+  );
+
 const fromFailure = (args: { readonly cause: Cause.Cause<unknown>; readonly headers: Headers.Headers }) =>
   Effect.gen(function* () {
+    const checkpoint = yield* CurrentCheckpoint;
+
+    if (Cause.hasInterruptsOnly(args.cause) && Option.isSome(checkpoint)) {
+      const abort = yield* checkpoint.value.abort;
+      if (Option.isSome(abort)) {
+        return fromCheckpointAbort({ abort: abort.value, headers: args.headers });
+      }
+    }
+
     const bus = yield* StepCommandBus;
     const commands = yield* bus.takeSuspension();
 
@@ -64,8 +96,19 @@ const fromFailure = (args: { readonly cause: Cause.Cause<unknown>; readonly head
 export const fromExit = (exit: Exit.Exit<HandlerRun.HandlerCompletion, unknown>) =>
   Effect.gen(function* () {
     const config = yield* InngestConfig;
-    const bus = yield* StepCommandBus;
     const headers = ExecutionHeaders.base(config);
+
+    if (Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) {
+      const checkpoint = yield* CurrentCheckpoint;
+      if (Option.isSome(checkpoint)) {
+        const abort = yield* checkpoint.value.abort;
+        if (Option.isSome(abort)) {
+          return fromCheckpointAbort({ abort: abort.value, headers });
+        }
+      }
+    }
+
+    const bus = yield* StepCommandBus;
     const planned = yield* bus.takePlanned();
 
     if (planned.length > 0) {

package/src/internal/handler.ts

@@ -1,13 +1,13 @@
 import * as HttpClient from "effect/unstable/http/HttpClient";
 import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import * as Headers from "effect/unstable/http/Headers";
 import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import { Cause, Context, Effect, Option, Predicate, Schema } from "effect";
 import { InngestClient } from "../Client.js";
 import type { InngestFunction } from "../Function.js";
 import type { InngestGroup } from "../Group.js";
 import * as Checkpoint from "./checkpoint.js";
-import { SignatureError } from "./serve/Signature.js";
 import * as SdkRequest from "./serve/Request.js";
 import * as Protocol from "./protocol.js";
 export { SignatureError } from "./serve/Signature.js";
@@ -130,9 +130,6 @@ export const handleRegistration = Effect.fn("effect-inngest/handler/handleRegist
     }),
   );
 
-  // Spec §4.3.1: PUT sync responds with `{ message: string; modified: boolean }`.
-  // Spec §4.3.3 / §4.3.4: 500 on failure with `modified: false`; 200 on success
-  // with the executor-supplied `modified` value (or `false` if omitted).
   return yield* Effect.gen(function* () {
     const response = yield* httpClient.execute(request).pipe(Effect.scoped);
     const responseBody = yield* HttpClientResponse.schemaBodyJson(Protocol.RegisterServerResponse)(response).pipe(
@@ -163,9 +160,6 @@ export const handleRegistration = Effect.fn("effect-inngest/handler/handleRegist
     } as HandlerResponse<typeof Protocol.RegisterResponse.Type>;
   }).pipe(
     Effect.catchCause((cause) => {
-      // Network/transport failure (e.g. die from HttpClient mock). Per
-      // §4.3.3 SHOULD return 500 with the body shape; never let the
-      // toWebHandler default 500 wrapper escape.
       const errorOpt = Cause.findErrorOption(cause);
       const dieReason = cause.reasons.find(Cause.isDieReason);
       const message = Option.isSome(errorOpt)
@@ -197,6 +191,7 @@ export const handleExecution = Effect.fn("effect-inngest/handler/handleExecution
   readonly fnId: string;
   readonly urlStepId: string | undefined;
   readonly body: typeof Protocol.SDKRequestBody.Type;
+  readonly headers?: Headers.Headers;
 }) {
   const client = yield* InngestClient;
   const context = yield* Effect.context<never>();
@@ -209,9 +204,6 @@ export const handleExecution = Effect.fn("effect-inngest/handler/handleExecution
   const entry = fn ? (context.mapUnsafe.get(fn.key) as Handler<string> | undefined) : undefined;
 
   if (!fn || !entry) {
-    // Spec §4.4.1: unknown function MUST return 500 with the error payload
-    // at the response root (no { error: ... } envelope).
-    // Spec §4.4.3 pair rule: 500 MUST pair with X-Inngest-No-Retry: false.
     return {
       status: 500 as const,
       headers: { ...baseHeaders(client.config.framework), [Protocol.Headers.NoRetry]: "false" },
@@ -220,41 +212,54 @@ export const handleExecution = Effect.fn("effect-inngest/handler/handleExecution
   }
 
   const requestedStepId = args.urlStepId === "step" ? undefined : args.urlStepId;
+  const headerRequestId = args.headers
+    ? Option.getOrUndefined(Headers.get(args.headers, Protocol.Headers.RequestId))
+    : undefined;
+  const requestId = headerRequestId ?? args.body.ctx.request_id;
+  const rawGenerationId = args.headers
+    ? Option.getOrUndefined(Headers.get(args.headers, Protocol.Headers.GenerationId))
+    : undefined;
+  const parsedGenerationId = rawGenerationId ? Number(rawGenerationId) : undefined;
+  const generationId =
+    Predicate.isNumber(parsedGenerationId) && Number.isInteger(parsedGenerationId)
+      ? parsedGenerationId
+      : args.body.ctx.generation_id;
+
+  const withExecutionHeaders = (ctx: typeof Protocol.SDKRequestContext.Type) =>
+    Protocol.SDKRequestContext.make({
+      fn_id: ctx.fn_id,
+      run_id: ctx.run_id,
+      env: ctx.env,
+      step_id: requestedStepId ?? ctx.step_id,
+      attempt: ctx.attempt,
+      max_attempts: ctx.max_attempts,
+      qi_id: ctx.qi_id,
+      ...(Predicate.isNotUndefined(requestId) ? { request_id: requestId } : {}),
+      ...(Predicate.isNotUndefined(generationId) ? { generation_id: generationId } : {}),
+      disable_immediate_execution: ctx.disable_immediate_execution,
+      use_api: ctx.use_api,
+      stack: ctx.stack,
+    });
 
-  // Non-root URL stepId takes precedence over body.ctx.step_id. The root
-  // `stepId=step` identifies the function run step, not a targeted child step.
   const effectiveBody =
     requestedStepId && requestedStepId !== args.body.ctx.step_id
       ? Protocol.SDKRequestBody.make({
           event: args.body.event,
           events: args.body.events,
           steps: args.body.steps,
-          ctx: Protocol.SDKRequestContext.make({
-            fn_id: args.body.ctx.fn_id,
-            run_id: args.body.ctx.run_id,
-            env: args.body.ctx.env,
-            step_id: requestedStepId,
-            attempt: args.body.ctx.attempt,
-            max_attempts: args.body.ctx.max_attempts,
-            qi_id: args.body.ctx.qi_id,
-            ...(Predicate.isNotUndefined(args.body.ctx.request_id) ? { request_id: args.body.ctx.request_id } : {}),
-            ...(Predicate.isNotUndefined(args.body.ctx.generation_id)
-              ? { generation_id: args.body.ctx.generation_id }
-              : {}),
-            disable_immediate_execution: args.body.ctx.disable_immediate_execution,
-            use_api: args.body.ctx.use_api,
-            stack: args.body.ctx.stack,
-          }),
+          ctx: withExecutionHeaders(args.body.ctx),
           version: args.body.version,
           use_api: args.body.use_api,
         })
-      : args.body;
+      : Protocol.SDKRequestBody.make({
+          event: args.body.event,
+          events: args.body.events,
+          steps: args.body.steps,
+          ctx: withExecutionHeaders(args.body.ctx),
+          version: args.body.version,
+          use_api: args.body.use_api,
+        });
 
-  // Checkpoint mode entry decision (spec §10):
-  //   - non-root URL stepId NOT set (we are not running a targeted child step)
-  //   - ctx.fn_id present (executor knows the function)
-  //   - ctx.disable_immediate_execution false (executor allowed it)
-  //   - resolved per-fn or per-client config not opted out
   const enterCheckpoint =
     !requestedStepId &&
     effectiveBody.ctx.fn_id !== "" &&

package/src/internal/protocol.ts

@@ -115,6 +115,9 @@ export const Headers = {
   SyncKind: "x-inngest-sync-kind",
   ServerKind: "X-Inngest-Server-Kind",
   ExpectedServerKind: "X-Inngest-Expected-Server-Kind",
+  RequestId: "x-request-id",
+  GenerationId: "x-inngest-generation-id",
+  JobId: "x-inngest-job-id",
   RunID: "X-Run-ID",
   Framework: "X-Inngest-Framework",
   Platform: "X-Inngest-Platform",

package/src/internal/serve/HttpApp.ts

@@ -95,6 +95,7 @@ export const toHttpApp = (group: InngestGroup.Any) =>
         fnId: params.fnId,
         urlStepId: params.stepId,
         body,
+        headers: request.headers,
       });
 
       return yield* HttpServerResponse.json(result.body, {