effect-inngest 0.3.0-beta.3 → 0.4.0-beta1

package/dist/Group.d.ts

@@ -1,6 +1,7 @@
 import { InngestClient } from "./Client.js";
 import { InngestFunction } from "./Function.js";
 import { HandlerContext } from "./internal/runtime/HandlerContext.js";
+import { StepTools } from "./internal/runtime/StepTools.js";
 import { Context, Effect, Layer } from "effect";
 import * as HttpClient from "effect/unstable/http/HttpClient";
 import * as _$effect_unstable_http_HttpServerRequest0 from "effect/unstable/http/HttpServerRequest";
@@ -24,7 +25,7 @@ type TypeId = typeof TypeId;
  * @since 0.1.0
  * @category models
  */
-type HandlerFn<F extends InngestFunction.Any> = (context: HandlerContext<F>) => Effect.Effect<InngestFunction.Success<F>, unknown, unknown>;
+type HandlerFn<F extends InngestFunction.Any> = (context: HandlerContext<F>) => Effect.Effect<unknown, unknown, unknown>;
 /**
  * @since 0.1.0
  * @category models
@@ -41,12 +42,13 @@ type HandlerFrom<Fns extends InngestFunction.Any, Tag extends InngestFunction.Ta
  * @since 0.1.0
  * @category models
  */
-type HandlersRequirements<H> = H extends Record<string, (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, unknown, infer R>> ? R : never;
+type RuntimeRequirements = InngestClient | StepTools;
+type HandlersRequirements<H> = H extends Record<string, (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, unknown, infer R>> ? Exclude<R, RuntimeRequirements> : never;
 /**
  * @since 0.1.0
  * @category models
  */
-type HandlerRequirements<Handler> = Handler extends ((...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, unknown, infer R>) ? R : never;
+type HandlerRequirements<Handler> = Handler extends ((...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, unknown, infer R>) ? Exclude<R, RuntimeRequirements> : never;
 /**
  * A nominal type representing a registered handler for a specific function tag.
  * @since 0.1.0
@@ -63,7 +65,7 @@ interface Handler<Tag extends string> {
  * @since 0.1.0
  * @category models
  */
-type ToHandler<F extends InngestFunction.Any> = F extends InngestFunction<infer Tag, infer _Triggers, infer _Success> ? Handler<Tag> : never;
+type ToHandler<F extends InngestFunction.Any> = F extends InngestFunction<infer Tag, infer _Triggers> ? Handler<Tag> : never;
 /**
  * @since 0.1.0
  * @category models
@@ -88,9 +90,7 @@ interface InngestGroup<Fns extends InngestFunction.Any> {
    */
   readonly accessHandler: <Tag extends InngestFunction.Tag<Fns>>(tag: Tag) => Effect.Effect<(context: HandlerContext<Extract<Fns, {
     readonly _tag: Tag;
-  }>>) => Effect.Effect<InngestFunction.Success<Extract<Fns, {
-    readonly _tag: Tag;
-  }>>, unknown>, never, Handler<Tag>>;
+  }>>) => Effect.Effect<unknown, unknown>, never, Handler<Tag>>;
 }
 /**
  * @since 0.1.0

package/dist/Group.js

@@ -1,4 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import "./internal/runtime/StepTools.js";
 import "./internal/runtime/HandlerContext.js";
 import { toHttpApp as toHttpApp$1, toWebHandler as toWebHandler$1 } from "./internal/serve/HttpApp.js";
 import { Context, Effect, Layer } from "effect";

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/Inngest.d.ts

@@ -0,0 +1,60 @@
+import { InngestClient } from "./Client.js";
+import { EventType as EventType$1 } from "./Event.js";
+import { InngestFunction } from "./Function.js";
+import { EventSchema } from "./internal/codec/EventPayload.js";
+import { SendEventError, StepError } from "./internal/errors.js";
+import { StepInput } from "./internal/domain/StepInput.js";
+import { InvokeOptions, OutgoingEvent, StepTools, WaitForEventOptions } from "./internal/runtime/StepTools.js";
+import { Duration, Effect, Option } from "effect";
+
+//#region src/Inngest.d.ts
+declare namespace Inngest_d_exports {
+  export { EventType, invoke, run, sendEvent, sleep, sleepUntil, waitForEvent };
+}
+/**
+ * Execute an Effect as a durable, memoized step.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const run: <A, Err, R>(id: StepInput, effect: Effect.Effect<A, Err, R>) => Effect.Effect<A, StepError | Err, R | StepTools>;
+/**
+ * Sleep durably for a duration.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const sleep: (id: StepInput, duration: Duration.Input) => Effect.Effect<void, never, StepTools>;
+/**
+ * Sleep durably until a timestamp.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const sleepUntil: (id: StepInput, timestamp: Date | number | string) => Effect.Effect<void, never, StepTools>;
+/**
+ * Wait for a matching event.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const waitForEvent: <E extends EventSchema>(id: StepInput, event: E, options: WaitForEventOptions) => Effect.Effect<Option.Option<EventType$1<E>>, StepError, StepTools>;
+/**
+ * Invoke another Inngest function.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const invoke: <F extends InngestFunction.Any>(id: StepInput, options: InvokeOptions<F>) => Effect.Effect<unknown, StepError, StepTools>;
+/**
+ * Send one or more Inngest events.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+declare const sendEvent: (id: StepInput, payload: OutgoingEvent | ReadonlyArray<OutgoingEvent>) => Effect.Effect<{
+  readonly ids: ReadonlyArray<string>;
+}, SendEventError, StepTools | InngestClient>;
+type EventType<E extends EventSchema> = EventType$1<E>;
+//#endregion
+export { Inngest_d_exports };

package/dist/Inngest.js

@@ -0,0 +1,61 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { StepTools } from "./internal/runtime/StepTools.js";
+import { Effect } from "effect";
+//#region src/Inngest.ts
+/**
+* Durable workflow operations for Inngest handlers.
+*
+* @since 0.1.0
+*/
+var Inngest_exports = /* @__PURE__ */ __exportAll({
+	invoke: () => invoke,
+	run: () => run,
+	sendEvent: () => sendEvent,
+	sleep: () => sleep,
+	sleepUntil: () => sleepUntil,
+	waitForEvent: () => waitForEvent
+});
+/**
+* Execute an Effect as a durable, memoized step.
+*
+* @since 0.1.0
+* @category steps
+*/
+const run = (id, effect) => Effect.flatMap(StepTools, (step) => step.run(id, effect));
+/**
+* Sleep durably for a duration.
+*
+* @since 0.1.0
+* @category steps
+*/
+const sleep = (id, duration) => Effect.flatMap(StepTools, (step) => step.sleep(id, duration));
+/**
+* Sleep durably until a timestamp.
+*
+* @since 0.1.0
+* @category steps
+*/
+const sleepUntil = (id, timestamp) => Effect.flatMap(StepTools, (step) => step.sleepUntil(id, timestamp));
+/**
+* Wait for a matching event.
+*
+* @since 0.1.0
+* @category steps
+*/
+const waitForEvent = (id, event, options) => Effect.flatMap(StepTools, (step) => step.waitForEvent(id, event, options));
+/**
+* Invoke another Inngest function.
+*
+* @since 0.1.0
+* @category steps
+*/
+const invoke = (id, options) => Effect.flatMap(StepTools, (step) => step.invoke(id, options));
+/**
+* Send one or more Inngest events.
+*
+* @since 0.1.0
+* @category steps
+*/
+const sendEvent = (id, payload) => Effect.flatMap(StepTools, (step) => step.sendEvent(id, payload));
+//#endregion
+export { Inngest_exports };

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import { Client_d_exports } from "./Client.js";
 import { Event_d_exports } from "./Event.js";
 import { Events_d_exports } from "./Events.js";
+import { Cron_d_exports } from "./Cron.js";
 import { Function_d_exports } from "./Function.js";
 import { NonRetriableError, RetryAfterError } from "./internal/errors.js";
 import { Group_d_exports } from "./Group.js";
 import { HttpApi_d_exports } from "./HttpApi.js";
-export { Client_d_exports as InngestClient, Event_d_exports as InngestEvent, Events_d_exports as InngestEvents, Function_d_exports as InngestFunction, Group_d_exports as InngestGroup, HttpApi_d_exports as InngestHttpApi, NonRetriableError, RetryAfterError };
+import { Inngest_d_exports } from "./Inngest.js";
+export { Inngest_d_exports as Inngest, Client_d_exports as InngestClient, Cron_d_exports as InngestCron, Event_d_exports as InngestEvent, Events_d_exports as InngestEvents, Function_d_exports as InngestFunction, Group_d_exports as InngestGroup, HttpApi_d_exports as InngestHttpApi, NonRetriableError, RetryAfterError };

package/dist/index.js

@@ -1,8 +1,10 @@
-import { Function_exports } from "./Function.js";
 import { Event_exports } from "./Event.js";
+import { Cron_exports } from "./Cron.js";
+import { Function_exports } from "./Function.js";
 import { Client_exports } from "./Client.js";
 import { NonRetriableError, RetryAfterError } from "./internal/errors.js";
 import { Events_exports } from "./Events.js";
 import { Group_exports } from "./Group.js";
+import { Inngest_exports } from "./Inngest.js";
 import { HttpApi_exports } from "./HttpApi.js";
-export { Client_exports as InngestClient, Event_exports as InngestEvent, Events_exports as InngestEvents, Function_exports as InngestFunction, Group_exports as InngestGroup, HttpApi_exports as InngestHttpApi, NonRetriableError, RetryAfterError };
+export { Inngest_exports as Inngest, Client_exports as InngestClient, Cron_exports as InngestCron, Event_exports as InngestEvent, Events_exports as InngestEvents, Function_exports as InngestFunction, Group_exports as InngestGroup, HttpApi_exports as InngestHttpApi, NonRetriableError, RetryAfterError };

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/codec/StepResult.js

@@ -1,5 +1,5 @@
 import { StepError } from "../errors.js";
-import { Effect, Function, Option, Predicate, Schema } from "effect";
+import { Effect, Function, Predicate } from "effect";
 //#region src/internal/codec/StepResult.ts
 const messageFromCause = (cause) => {
 	if (Predicate.hasProperty(cause, "cause")) {
@@ -25,16 +25,6 @@ const mapMemoDecodeError = Function.dual(2, (effect, stepId) => effect.pipe(Effe
 	stepId,
 	cause
 }))));
-const decodeMemo = Function.dual(3, (value, schema, stepId) => Schema.decodeUnknownEffect(schema)(value).pipe(mapMemoDecodeError(stepId)));
-const encodeMemo = Function.dual(3, (value, schema, stepId) => Schema.encodeUnknownEffect(Schema.toCodecJson(schema))(value).pipe(mapMemoDecodeError(stepId)));
-const decodeStepRunMemo = (schema, stepId) => (value) => Option.match(schema, {
-	onNone: () => Effect.void,
-	onSome: (codec) => decodeMemo(codec, stepId)(value)
-});
-const encodeStepRunMemo = (schema, stepId) => (value) => Option.match(schema, {
-	onNone: () => Predicate.isUndefined(value) ? Effect.succeed(void 0) : decodeMemo(Schema.Json, stepId)(value),
-	onSome: (codec) => encodeMemo(codec, stepId)(value)
-});
 const failStepRunMemoError = (stepId, error) => Effect.fail(StepError.make({
 	stepId,
 	message: Predicate.hasProperty(error, "message") ? String(error.message) : "Step failed",
@@ -52,4 +42,4 @@ const failUnexpectedStepRunMemoInput = (stepId, input) => Effect.fail(StepError.
 	cause: input
 }));
 //#endregion
-export { decodeMemo, decodeStepRunMemo, encodeStepRunMemo, failMemoDecode, failStepRunMemoError, failStepRunMemoTimeout, failUnexpectedStepRunMemoInput, mapMemoDecodeError };
+export { failMemoDecode, failStepRunMemoError, failStepRunMemoTimeout, failUnexpectedStepRunMemoInput, mapMemoDecodeError };

package/dist/internal/driver.js

@@ -1,4 +1,5 @@
 import "./protocol.js";
+import "./runtime/StepTools.js";
 import { provide } from "./execution/ExecutionScope.js";
 import { run, withCheckpointDeadline } from "./execution/HandlerRun.js";
 import "./execution/ExecutionResult.js";

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/execution/HandlerRun.js

@@ -1,10 +1,11 @@
 import { CurrentCheckpoint } from "../runtime/CheckpointContext.js";
+import { normalize } from "../utils/safe-stringify.js";
 import { make } from "../runtime/HandlerContext.js";
 import { Effect, Option, Schema } from "effect";
 //#region src/internal/execution/HandlerRun.ts
 var HandlerSucceeded = class extends Schema.TaggedClass()("HandlerSucceeded", { value: Schema.Unknown }) {};
 Schema.TaggedClass()("CheckpointDeadlineElapsed", {});
-const run = (args) => make({ fn: args.fn }).pipe(Effect.flatMap(args.handler), Effect.map((value) => HandlerSucceeded.make({ value })));
+const run = (args) => make({ fn: args.fn }).pipe(Effect.flatMap(args.handler), Effect.map((value) => HandlerSucceeded.make({ value: normalize(value) })));
 const withCheckpointDeadline = (effect) => Effect.gen(function* () {
 	const checkpoint = yield* CurrentCheckpoint;
 	return yield* Option.match(checkpoint, {

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/runtime/HandlerContext.d.ts

@@ -1,12 +1,10 @@
 import { InngestFunction } from "../../Function.js";
 import { ExecutionInput } from "../domain/ExecutionInput.js";
-import { StepTools } from "./StepTools.js";
 import { Effect } from "effect";
 
 //#region src/internal/runtime/HandlerContext.d.ts
 interface HandlerContext<F extends InngestFunction.Any = InngestFunction.Any> {
   readonly event: InngestFunction.EventType<F>;
-  readonly step: StepTools.Service;
   readonly run: ExecutionInput["run"];
 }
 //#endregion

package/dist/internal/runtime/HandlerContext.js

@@ -1,17 +1,14 @@
 import { CurrentExecutionInput } from "../domain/ExecutionInput.js";
 import { decodeInvocation } from "../codec/EventPayload.js";
-import { StepTools } from "./StepTools.js";
 import { Effect } from "effect";
 //#region src/internal/runtime/HandlerContext.ts
 const make = (args) => Effect.gen(function* () {
 	const input = yield* CurrentExecutionInput;
-	const step = yield* StepTools;
 	return {
 		event: yield* decodeInvocation({
 			fn: args.fn,
 			input
 		}),
-		step,
 		run: input.run
 	};
 });

package/dist/internal/runtime/StepTools.d.ts

@@ -8,13 +8,9 @@ import { StepInput } from "../domain/StepInput.js";
 import { HandlerFiberScope } from "./HandlerFiberScope.js";
 import { StepCommandBus } from "./StepCommandBus.js";
 import { StepIdentity } from "./StepIdentity.js";
-import { Context, Duration, Effect, Layer, Option, Schema } from "effect";
+import { Context, Duration, Effect, Layer, Option } from "effect";
 
 //#region src/internal/runtime/StepTools.d.ts
-type JsonSchema<A = unknown> = Schema.Codec<A, unknown, never, never>;
-interface RunOptions<S extends JsonSchema> {
-  readonly schema: S;
-}
 interface WaitForEventOptions {
   readonly timeout: Duration.Input;
   readonly if?: string;
@@ -29,8 +25,7 @@ type InvokeOptions<F extends InngestFunction.Any> = [InngestFunction.EventPayloa
   readonly data: InngestFunction.EventPayload<F>;
 };
 interface Run {
-  <Err, R>(id: StepInput, effect: Effect.Effect<void, Err, R>): Effect.Effect<void, StepError | Err, R>;
-  <S extends JsonSchema, Err, R>(id: StepInput, effect: Effect.Effect<Schema.Schema.Type<S>, Err, R>, options: RunOptions<S>): Effect.Effect<Schema.Schema.Type<S>, StepError | Err, R>;
+  <A, Err, R>(id: StepInput, effect: Effect.Effect<A, Err, R>): Effect.Effect<A, StepError | Err, R>;
 }
 interface Sleep {
   (id: StepInput, duration: Duration.Input): Effect.Effect<void>;
@@ -42,7 +37,7 @@ interface WaitForEvent {
   <E extends EventSchema>(id: StepInput, event: E, options: WaitForEventOptions): Effect.Effect<Option.Option<EventType<E>>, StepError>;
 }
 interface Invoke {
-  <F extends InngestFunction.Any>(id: StepInput, options: InvokeOptions<F>): Effect.Effect<InngestFunction.Success<F>, StepError>;
+  <F extends InngestFunction.Any>(id: StepInput, options: InvokeOptions<F>): Effect.Effect<unknown, StepError>;
 }
 interface OutgoingEvent {
   readonly name: string;
@@ -66,18 +61,15 @@ declare namespace StepTools {
 declare const StepTools_base: Context.ServiceClass<StepTools, "effect-inngest/internal/runtime/StepTools", StepTools.Service>;
 declare class StepTools extends StepTools_base {
   static readonly make: Effect.Effect<{
-    run: {
-      <Err, R>(id: StepInput, effect: Effect.Effect<void, Err, R>): Effect.Effect<void, StepError | Err, R>;
-      <S extends JsonSchema, Err, R>(id: StepInput, effect: Effect.Effect<Schema.Schema.Type<S>, Err, R>, options: RunOptions<S>): Effect.Effect<Schema.Schema.Type<S>, StepError | Err, R>;
-    };
+    run: <A, Err, R>(id: StepInput, effect: Effect.Effect<A, Err, R>) => Effect.Effect<A, StepError | Err, Exclude<R, CurrentExecutionInput | HandlerFiberScope | InngestConfig | StepCommandBus | StepIdentity>>;
     sleep: Sleep;
     sleepUntil: SleepUntil;
     waitForEvent: WaitForEvent;
     invoke: Invoke;
     sendEvent: SendEvent;
-  }, never, InngestConfig | CurrentExecutionInput | StepIdentity | StepCommandBus | HandlerFiberScope>;
-  static readonly layer: Layer.Layer<StepTools, never, InngestConfig | CurrentExecutionInput | StepIdentity | StepCommandBus | HandlerFiberScope>;
-  static readonly live: Layer.Layer<StepTools, never, InngestConfig | CurrentExecutionInput | StepIdentity | HandlerFiberScope>;
+  }, never, CurrentExecutionInput | HandlerFiberScope | InngestConfig | StepCommandBus | StepIdentity>;
+  static readonly layer: Layer.Layer<StepTools, never, CurrentExecutionInput | HandlerFiberScope | InngestConfig | StepCommandBus | StepIdentity>;
+  static readonly live: Layer.Layer<StepTools, never, CurrentExecutionInput | HandlerFiberScope | InngestConfig | StepIdentity>;
 }
 //#endregion
-export { StepTools };
+export { InvokeOptions, OutgoingEvent, StepTools, WaitForEventOptions };

package/dist/internal/runtime/StepTools.js

@@ -10,7 +10,7 @@ import { sleep } from "./steps/SleepStep.js";
 import { sleepUntil } from "./steps/SleepUntilStep.js";
 import { run } from "./steps/StepRun.js";
 import { waitForEvent } from "./steps/WaitForEventStep.js";
-import { Context, Effect, Layer, Predicate, pipe } from "effect";
+import { Context, Effect, Layer, pipe } from "effect";
 //#region src/internal/runtime/StepTools.ts
 var StepTools = class extends Context.Service()("effect-inngest/internal/runtime/StepTools") {
 	static make = Effect.gen(function* () {
@@ -21,13 +21,7 @@ var StepTools = class extends Context.Service()("effect-inngest/internal/runtime
 		const bus = yield* StepCommandBus;
 		const handlerFiberScope = yield* HandlerFiberScope;
 		const runtime = pipe(Context.make(StepIdentity, identity), Context.add(StepCommandBus, bus), Context.add(CurrentExecutionInput, input), Context.add(CurrentCheckpoint, checkpoint), Context.add(InngestConfig, config), Context.add(HandlerFiberScope, handlerFiberScope));
-		function run$1(id, effect, options) {
-			if (Predicate.isNotUndefined(options)) return run({
-				input,
-				id: identity.reserve(id),
-				effect,
-				options
-			}).pipe(Effect.provide(runtime));
+		function run$1(id, effect) {
 			return run({
 				input,
 				id: identity.reserve(id),

package/dist/internal/runtime/steps/InvokeStep.js

@@ -4,7 +4,6 @@ import { StepError } from "../../errors.js";
 import { InvokeFunction } from "../../domain/StepCommand.js";
 import { StepCommandBus } from "../StepCommandBus.js";
 import { StepIdentity } from "../StepIdentity.js";
-import { decodeMemo } from "../../codec/StepResult.js";
 import { Duration, Effect, Match, Predicate, Schema } from "effect";
 //#region src/internal/runtime/steps/InvokeStep.ts
 const invoke = (args) => Effect.gen(function* () {
@@ -13,7 +12,7 @@ const invoke = (args) => Effect.gen(function* () {
 	const bus = yield* StepCommandBus;
 	const info = yield* identity.resolve(args.id);
 	const memo = args.input.memoForStep(info);
-	return yield* Match.value(memo).pipe(Match.tag("MemoData", ({ data }) => decodeMemo(Schema.toCodecJson(args.options.function.success), info.id)(data)), Match.tag("MemoError", ({ error }) => Effect.fail(StepError.make({
+	return yield* Match.value(memo).pipe(Match.tag("MemoData", ({ data }) => Effect.succeed(data)), Match.tag("MemoError", ({ error }) => Effect.fail(StepError.make({
 		stepId: info.id,
 		message: Predicate.hasProperty(error, "message") ? String(error.message) : "Invoke failed",
 		cause: error