effect-inngest 0.3.0-beta.4 → 0.4.0-beta2

package/src/Events.ts

@@ -82,7 +82,7 @@ export const FunctionCancelled = InngestEvent.make(
 );
 
 /**
- * Sent when a function is invoked via step.invoke().
+ * Sent when a function is invoked via Inngest.invoke().
  * @since 0.1.0
  */
 export const FunctionInvoked = InngestEvent.make(

package/src/Function.ts

@@ -6,7 +6,9 @@ import { pipeArguments, type Pipeable } from "effect/Pipeable";
 import * as Checkpoint from "./internal/checkpoint.js";
 import type { CheckpointingOption } from "./internal/checkpoint.js";
 import { InngestDuration } from "./internal/wire/Duration.js";
-import type * as InngestEvent from "./Event.js";
+import * as InngestEvent from "./Event.js";
+import type * as InngestCron from "./Cron.js";
+import { isCron } from "./Cron.js";
 
 export type { CheckpointingOption } from "./internal/checkpoint.js";
 
@@ -36,6 +38,11 @@ export interface EventTrigger<E extends EventSchema = EventSchema> {
   readonly if?: string;
 }
 
+export interface NormalizedEventTrigger<E extends EventSchema = EventSchema> {
+  readonly event: E;
+  readonly if?: string;
+}
+
 /**
  * A cron-based trigger configuration.
  *
@@ -44,6 +51,7 @@ export interface EventTrigger<E extends EventSchema = EventSchema> {
  */
 export interface CronTrigger {
   readonly cron: string;
+  readonly jitter?: string;
 }
 
 /**
@@ -52,13 +60,23 @@ export interface CronTrigger {
  * @since 0.1.0
  * @category triggers
  */
-export type Trigger<E extends EventSchema = EventSchema> = EventTrigger<E> | CronTrigger;
+export type NormalizedTrigger<E extends EventSchema = EventSchema> = NormalizedEventTrigger<E> | CronTrigger;
+
+export type Trigger<E extends EventSchema = EventSchema> =
+  | E
+  | InngestCron.CronDefinition
+  | EventTrigger<E>
+  | CronTrigger;
+
+export type TriggerDefinition<E extends EventSchema = EventSchema> = Trigger<E>;
 
 /**
  * @since 0.1.0
  * @category triggers
  */
-export type TriggerInput<E extends EventSchema = EventSchema> = Trigger<E> | ReadonlyArray<Trigger<E>>;
+export type TriggerInput<E extends EventSchema = EventSchema> =
+  | TriggerDefinition<E>
+  | ReadonlyArray<TriggerDefinition<E>>;
 
 export interface ConcurrencyOption {
   /**
@@ -356,6 +374,7 @@ export interface FunctionRegistration {
     event?: string;
     cron?: string;
     expression?: string;
+    jitter?: string;
   }>;
   readonly steps: {
     readonly step: {
@@ -421,15 +440,13 @@ export interface FunctionRegistration {
  */
 export interface InngestFunction<
   Tag extends string,
-  Triggers extends Trigger,
-  Success extends Schema.Codec<unknown, unknown, never, never>,
+  Triggers extends NormalizedTrigger,
   Options extends FunctionOptions = FunctionOptions,
 > extends Pipeable {
   readonly [TypeId]: TypeId;
   readonly _tag: Tag;
   readonly key: string;
   readonly triggers: ReadonlyArray<Triggers>;
-  readonly success: Success;
   readonly options: Options;
   readonly toRegistration: (config: RegistrationConfig) => FunctionRegistration;
 }
@@ -439,11 +456,11 @@ export interface InngestFunction<
  * @category models
  */
 export declare namespace InngestFunction {
-  export type Any = InngestFunction<string, Trigger, Schema.Codec<any, any, never, never>, FunctionOptions>;
-  export type Tag<F> = F extends InngestFunction<infer T, any, any, any> ? T : never;
-  export type Triggers<F> = F extends InngestFunction<any, infer T, any, any> ? T : never;
+  export type Any = InngestFunction<string, NormalizedTrigger, FunctionOptions>;
+  export type Tag<F> = F extends InngestFunction<infer T, any, any> ? T : never;
+  export type Triggers<F> = F extends InngestFunction<any, infer T, any> ? T : never;
   export type Events<F> =
-    F extends InngestFunction<any, infer T, any, any> ? (T extends EventTrigger<infer E> ? E : never) : never;
+    F extends InngestFunction<any, infer T, any> ? (T extends NormalizedEventTrigger<infer E> ? E : never) : never;
   export type EventPayload<F> = EventEnvelope<Events<F>>;
   export type HasBatchEvents<O> = O extends { readonly batchEvents: infer BatchEvents }
     ? Exclude<BatchEvents, undefined> extends BatchEventsOption
@@ -452,12 +469,10 @@ export declare namespace InngestFunction {
     : false;
   export type EventType<F> = HasBatchEvents<Options<F>> extends true ? ReadonlyArray<EventPayload<F>> : EventPayload<F>;
 
-  export type SuccessSchema<F> = F extends InngestFunction<any, any, infer S, any> ? S : never;
-  export type Success<F> = Schema.Schema.Type<SuccessSchema<F>>;
-  export type Options<F> = F extends InngestFunction<any, any, any, infer O> ? O : never;
+  export type Options<F> = F extends InngestFunction<any, any, infer O> ? O : never;
 }
 
-const isEventTrigger = (t: Trigger): t is EventTrigger => Predicate.hasProperty(t, "event");
+const isEventTrigger = (t: NormalizedTrigger): t is NormalizedEventTrigger => Predicate.hasProperty(t, "event");
 
 const encodeDuration = (input: Duration.Input): string =>
   Schema.encodeSync(InngestDuration)(Duration.fromInputUnsafe(input));
@@ -480,7 +495,7 @@ const Proto = {
       if (isEventTrigger(t)) {
         triggers.push({ event: t.event.identifier, expression: t.if });
       } else {
-        triggers.push({ cron: t.cron });
+        triggers.push({ cron: t.cron, ...(Predicate.isNotUndefined(t.jitter) ? { jitter: t.jitter } : {}) });
       }
     }
 
@@ -597,7 +612,30 @@ const Proto = {
   },
 };
 
-type NormalizeTriggers<T extends TriggerInput> = T extends ReadonlyArray<Trigger> ? T[number] : T;
+export type NormalizeTrigger<T> = T extends EventSchema
+  ? NormalizedEventTrigger<T>
+  : T extends InngestCron.CronDefinition
+    ? CronTrigger
+    : T extends EventTrigger<infer E>
+      ? NormalizedEventTrigger<E>
+      : T extends CronTrigger
+        ? T
+        : never;
+
+export type NormalizeTriggers<T extends TriggerInput> =
+  T extends ReadonlyArray<infer Item> ? NormalizeTrigger<Item> : NormalizeTrigger<T>;
+
+const normalizeTrigger = (trigger: TriggerDefinition): NormalizedTrigger => {
+  if (InngestEvent.isEventSchema(trigger)) {
+    return { event: trigger };
+  }
+
+  if (isCron(trigger)) {
+    return { cron: trigger.cron, ...(Predicate.isNotUndefined(trigger.jitter) ? { jitter: trigger.jitter } : {}) };
+  }
+
+  return trigger;
+};
 
 /**
  * @since 0.1.0
@@ -606,46 +644,36 @@ type NormalizeTriggers<T extends TriggerInput> = T extends ReadonlyArray<Trigger
  * ```ts
  * // Event trigger
  * const Fn1 = InngestFunction.make("Hello", {
- *   trigger: { event: HelloEvent },
- *   success: Schema.Void,
+ *   trigger: HelloEvent,
  * })
  *
  * // Event trigger with CEL filter
  * const Fn2 = InngestFunction.make("Hello", {
  *   trigger: { event: HelloEvent, if: "event.data.name != ''" },
- *   success: Schema.Void,
  * })
  *
  * // Cron trigger
  * const Fn3 = InngestFunction.make("Scheduled", {
- *   trigger: { cron: "0 * * * *" },
- *   success: Schema.Void,
+ *   trigger: InngestCron.make("0 * * * *"),
  * })
  *
  * // Multiple triggers
  * const Fn4 = InngestFunction.make("Multi", {
  *   trigger: [
- *     { event: HelloEvent },
- *     { cron: "0 0 * * *" },
+ *     HelloEvent,
+ *     InngestCron.make("0 0 * * *"),
  *   ],
- *   success: Schema.Void,
  * })
  * ```
  */
-export function make<
-  const Tag extends string,
-  T extends TriggerInput,
-  S extends Schema.Codec<unknown, unknown, never, never>,
-  const O extends FunctionOptions = {},
->(
+export function make<const Tag extends string, T extends TriggerInput, const O extends FunctionOptions = {}>(
   tag: Tag,
-  options: { readonly trigger: T; readonly success: S } & O,
-): InngestFunction<Tag, NormalizeTriggers<T>, S, O> {
+  options: { readonly trigger: T } & O,
+): InngestFunction<Tag, NormalizeTriggers<T>, O> {
   const fn = Object.create(Proto);
   fn._tag = tag;
   fn.key = `effect-inngest/Function/${tag}`;
-  fn.triggers = Arr.ensure(options.trigger);
-  fn.success = options.success;
+  fn.triggers = Arr.map(Arr.ensure(options.trigger), normalizeTrigger);
   fn.options = options;
   return fn;
 }

package/src/Group.ts

@@ -8,6 +8,7 @@ import type { InngestFunction } from "./Function.js";
 import * as ServeHttp from "./internal/serve/HttpApp.js";
 
 import { type HandlerContext } from "./internal/runtime/HandlerContext.js";
+import { StepTools } from "./internal/runtime/StepTools.js";
 
 /**
  * Re-export HandlerContext.
@@ -34,7 +35,7 @@ export type TypeId = typeof TypeId;
  */
 export type HandlerFn<F extends InngestFunction.Any> = (
   context: HandlerContext<F>,
-) => Effect.Effect<InngestFunction.Success<F>, unknown, unknown>;
+) => Effect.Effect<unknown, unknown, unknown>;
 
 /**
  * @since 0.1.0
@@ -59,8 +60,12 @@ export type HandlerFrom<Fns extends InngestFunction.Any, Tag extends InngestFunc
  * @since 0.1.0
  * @category models
  */
+type RuntimeRequirements = InngestClient | StepTools;
+
 export type HandlersRequirements<H> =
-  H extends Record<string, (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, unknown, infer R>> ? R : never;
+  H extends Record<string, (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, unknown, infer R>>
+    ? Exclude<R, RuntimeRequirements>
+    : never;
 
 /**
  * @since 0.1.0
@@ -69,7 +74,7 @@ export type HandlersRequirements<H> =
 export type HandlerRequirements<Handler> = Handler extends (
   ...args: ReadonlyArray<unknown>
 ) => Effect.Effect<unknown, unknown, infer R>
-  ? R
+  ? Exclude<R, RuntimeRequirements>
   : never;
 
 /**
@@ -90,7 +95,7 @@ export interface Handler<Tag extends string> {
  * @category models
  */
 export type ToHandler<F extends InngestFunction.Any> =
-  F extends InngestFunction<infer Tag, infer _Triggers, infer _Success> ? Handler<Tag> : never;
+  F extends InngestFunction<infer Tag, infer _Triggers> ? Handler<Tag> : never;
 
 /**
  * @since 0.1.0
@@ -128,9 +133,7 @@ export 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>,
+    (context: HandlerContext<Extract<Fns, { readonly _tag: Tag }>>) => Effect.Effect<unknown, unknown>,
     never,
     Handler<Tag>
   >;

package/src/Inngest.ts

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

package/src/index.ts

@@ -2,13 +2,13 @@
  * This module provides types and functions for defining Inngest functions.
  *
  * Functions are the core building blocks of Inngest applications. Each function
- * defines what events trigger it, what it returns on success, and optional
- * configuration like retries, concurrency limits, rate limiting, and more.
+ * defines what events trigger it and optional configuration like retries,
+ * concurrency limits, rate limiting, and more.
  *
  * @example
  * ```ts
  * import { Effect, Schema } from "effect"
- * import { InngestEvent, InngestFunction, InngestGroup } from "effect-inngest"
+ * import { InngestEvent, InngestFunction, InngestGroup, Inngest } from "effect-inngest"
  *
  * const UserCreated = InngestEvent.make(
  *   "user/created",
@@ -20,8 +20,7 @@
  *
  * // Define functions
  * const SendWelcomeEmail = InngestFunction.make("send-welcome-email", {
- *   trigger: { event: UserCreated },
- *   success: Schema.Void,
+ *   trigger: UserCreated,
  *   retries: 3,
  * })
  *
@@ -50,6 +49,14 @@ export * as InngestFunction from "./Function.js";
  */
 export * as InngestEvent from "./Event.js";
 
+/**
+ * Public cron trigger helpers.
+ *
+ * @module InngestCron
+ * @since 0.1.0
+ */
+export * as InngestCron from "./Cron.js";
+
 /**
  * This module provides types and functions for grouping Inngest functions
  * and creating handler layers.
@@ -109,6 +116,14 @@ export * as InngestGroup from "./Group.js";
  */
 export * as InngestClient from "./Client.js";
 
+/**
+ * Durable workflow operations used inside handlers.
+ *
+ * @module Inngest
+ * @since 0.1.0
+ */
+export * as Inngest from "./Inngest.js";
+
 /**
  * This module provides integration with `@effect/platform` HttpApi.
  *
@@ -152,8 +167,7 @@ export * as InngestHttpApi from "./HttpApi.js";
  *
  * // React to function failures
  * const HandleFailure = InngestFunction.make("handle-failure", {
- *   trigger: { event: InngestEvents.FunctionFailed },
- *   success: Schema.Void,
+ *   trigger: InngestEvents.FunctionFailed,
  * })
  * ```
  *

package/src/internal/codec/StepResult.ts

@@ -1,8 +1,6 @@
-import { Effect, Function, Option, Predicate, Schema } from "effect";
+import { Effect, Function, Predicate } from "effect";
 import { StepError } from "../errors.js";
 
-export type OptionalMemoCodec<A> = Option.Option<Schema.Codec<A, Schema.Json, never, never>>;
-
 const messageFromCause = (cause: unknown): string => {
   if (Predicate.hasProperty(cause, "cause")) {
     const nested = messageFromCause(cause.cause);
@@ -38,46 +36,6 @@ export const mapMemoDecodeError: {
   effect.pipe(Effect.mapError((cause) => memoDecodeError({ stepId, cause }))),
 );
 
-export const decodeMemo: {
-  <A>(
-    schema: Schema.Codec<A, Schema.Json, never, never>,
-    stepId: string,
-  ): (value: unknown) => Effect.Effect<A, StepError>;
-  <A>(value: unknown, schema: Schema.Codec<A, Schema.Json, never, never>, stepId: string): Effect.Effect<A, StepError>;
-} = Function.dual(3, <A>(value: unknown, schema: Schema.Codec<A, Schema.Json, never, never>, stepId: string) =>
-  Schema.decodeUnknownEffect(schema)(value).pipe(mapMemoDecodeError(stepId)),
-);
-
-export const encodeMemo: {
-  <A, I>(
-    schema: Schema.Codec<A, I, never, never>,
-    stepId: string,
-  ): (value: unknown) => Effect.Effect<Schema.Json, StepError>;
-  <A, I>(
-    value: unknown,
-    schema: Schema.Codec<A, I, never, never>,
-    stepId: string,
-  ): Effect.Effect<Schema.Json, StepError>;
-} = Function.dual(3, <A, I>(value: unknown, schema: Schema.Codec<A, I, never, never>, stepId: string) =>
-  Schema.encodeUnknownEffect(Schema.toCodecJson(schema))(value).pipe(mapMemoDecodeError(stepId)),
-);
-
-export const decodeStepRunMemo =
-  <A>(schema: OptionalMemoCodec<A>, stepId: string) =>
-  (value: unknown): Effect.Effect<A | void, StepError> =>
-    Option.match(schema, {
-      onNone: () => Effect.void,
-      onSome: (codec) => decodeMemo(codec, stepId)(value),
-    });
-
-export const encodeStepRunMemo =
-  <A>(schema: OptionalMemoCodec<A>, stepId: string) =>
-  (value: unknown): Effect.Effect<Schema.Json | undefined, StepError> =>
-    Option.match(schema, {
-      onNone: () => (Predicate.isUndefined(value) ? Effect.succeed(undefined) : decodeMemo(Schema.Json, stepId)(value)),
-      onSome: (codec) => encodeMemo(codec, stepId)(value),
-    });
-
 export const failStepRunMemoError = (stepId: string, error: unknown): Effect.Effect<never, StepError> =>
   Effect.fail(
     StepError.make({

package/src/internal/driver.ts

@@ -8,15 +8,26 @@ import * as ExecutionScope from "./execution/ExecutionScope.js";
 import * as HandlerRun from "./execution/HandlerRun.js";
 import * as ExecutionResponse from "./execution/ExecutionResponse.js";
 import { ExecutionResult } from "./execution/ExecutionResult.js";
+import { CurrentExecutionInput } from "./domain/ExecutionInput.js";
+import { InngestConfig } from "../Client.js";
+import { HandlerFiberScope } from "./runtime/HandlerFiberScope.js";
+import { StepCommandBus } from "./runtime/StepCommandBus.js";
+import { StepIdentity } from "./runtime/StepIdentity.js";
+import { StepTools } from "./runtime/StepTools.js";
 
 export { ExecutionResult };
 
 export const execute = <F extends InngestFunction.Any, R>(args: {
   readonly fn: F;
-  readonly handler: (ctx: HandlerContext<F>) => Effect.Effect<InngestFunction.Success<F>, unknown, R>;
+  readonly handler: (ctx: HandlerContext<F>) => Effect.Effect<unknown, unknown, R>;
   readonly request: Protocol.SDKRequestBody;
   readonly checkpointConfig?: Option.Option<CheckpointConfig>;
-}): Effect.Effect<ExecutionResult, never, R | InngestClient> =>
+}): Effect.Effect<
+  ExecutionResult,
+  never,
+  | Exclude<R, CurrentExecutionInput | HandlerFiberScope | InngestConfig | StepCommandBus | StepIdentity | StepTools>
+  | InngestClient
+> =>
   HandlerRun.run({ fn: args.fn, handler: args.handler }).pipe(
     HandlerRun.withCheckpointDeadline,
     Effect.scoped,

package/src/internal/execution/HandlerRun.ts

@@ -2,6 +2,7 @@ import { Effect, Option, Schema } from "effect";
 import type { InngestFunction } from "../../Function.js";
 import * as HandlerContext from "../runtime/HandlerContext.js";
 import { CurrentCheckpoint } from "../runtime/CheckpointContext.js";
+import * as SafeStringify from "../utils/safe-stringify.js";
 
 export class HandlerSucceeded extends Schema.TaggedClass<HandlerSucceeded>()("HandlerSucceeded", {
   value: Schema.Unknown,
@@ -16,11 +17,11 @@ export type HandlerCompletion = HandlerSucceeded | CheckpointDeadlineElapsed;
 
 export const run = <F extends InngestFunction.Any, R>(args: {
   readonly fn: F;
-  readonly handler: (ctx: HandlerContext.HandlerContext<F>) => Effect.Effect<InngestFunction.Success<F>, unknown, R>;
+  readonly handler: (ctx: HandlerContext.HandlerContext<F>) => Effect.Effect<unknown, unknown, R>;
 }) =>
   HandlerContext.make({ fn: args.fn }).pipe(
     Effect.flatMap(args.handler),
-    Effect.map((value) => HandlerSucceeded.make({ value })),
+    Effect.map((value) => HandlerSucceeded.make({ value: SafeStringify.normalize(value) })),
   );
 
 export const withCheckpointDeadline = <E, R>(effect: Effect.Effect<HandlerCompletion, E, R>) =>

package/src/internal/runtime/HandlerContext.ts

@@ -2,20 +2,17 @@ import { Effect } from "effect";
 import type { InngestFunction } from "../../Function.js";
 import * as EventPayload from "../codec/EventPayload.js";
 import { CurrentExecutionInput, type ExecutionInput } from "../domain/ExecutionInput.js";
-import { StepTools } from "./StepTools.js";
 
 export interface HandlerContext<F extends InngestFunction.Any = InngestFunction.Any> {
   readonly event: InngestFunction.EventType<F>;
-  readonly step: StepTools.Service;
   readonly run: ExecutionInput["run"];
 }
 
 export const make = <F extends InngestFunction.Any>(args: {
   readonly fn: F;
-}): Effect.Effect<HandlerContext<F>, EventPayload.EventDecodeError, StepTools | CurrentExecutionInput> =>
+}): Effect.Effect<HandlerContext<F>, EventPayload.EventDecodeError, CurrentExecutionInput> =>
   Effect.gen(function* () {
     const input = yield* CurrentExecutionInput;
-    const step = yield* StepTools;
     const event = yield* EventPayload.decodeInvocation({ fn: args.fn, input });
-    return { event, step, run: input.run };
+    return { event, run: input.run };
   });

package/src/internal/runtime/StepTools.ts

@@ -1,4 +1,4 @@
-import { Context, Duration, Effect, Layer, Option, Predicate, Schema, pipe } from "effect";
+import { Context, Duration, Effect, Layer, Option, pipe } from "effect";
 import { InngestClient, InngestConfig } from "../../Client.js";
 import type * as InngestEvent from "../../Event.js";
 import type { InngestFunction } from "../../Function.js";
@@ -17,12 +17,6 @@ import * as SleepUntilStep from "./steps/SleepUntilStep.js";
 import * as StepRun from "./steps/StepRun.js";
 import * as WaitForEventStep from "./steps/WaitForEventStep.js";
 
-export type JsonSchema<A = unknown> = Schema.Codec<A, unknown, never, never>;
-
-export interface RunOptions<S extends JsonSchema> {
-  readonly schema: S;
-}
-
 export interface WaitForEventOptions {
   readonly timeout: Duration.Input;
   readonly if?: string;
@@ -40,12 +34,7 @@ export type InvokeOptions<F extends InngestFunction.Any> = [InngestFunction.Even
   : InvokeOptionsBase<F> & { readonly data: InngestFunction.EventPayload<F> };
 
 export 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>;
 }
 
 export interface Sleep {
@@ -65,10 +54,7 @@ export interface WaitForEvent {
 }
 
 export 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>;
 }
 
 export interface OutgoingEvent {
@@ -113,20 +99,7 @@ export class StepTools extends Context.Service<StepTools, StepTools.Service>()(
       Context.add(HandlerFiberScope, handlerFiberScope),
     );
 
-    function run<Err, R>(id: StepInput, effect: Effect.Effect<void, Err, R>): Effect.Effect<void, StepError | Err, R>;
-    function run<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>;
-    function run<S extends JsonSchema, Err, R>(
-      id: StepInput,
-      effect: Effect.Effect<void | Schema.Schema.Type<S>, Err, R>,
-      options?: RunOptions<S>,
-    ) {
-      if (Predicate.isNotUndefined(options)) {
-        return StepRun.run({ input, id: identity.reserve(id), effect, options }).pipe(Effect.provide(runtime));
-      }
+    function run<A, Err, R>(id: StepInput, effect: Effect.Effect<A, Err, R>) {
       return StepRun.run({ input, id: identity.reserve(id), effect }).pipe(Effect.provide(runtime));
     }
 

package/src/internal/runtime/steps/InvokeStep.ts

@@ -2,7 +2,6 @@ import { Duration, Effect, Match, Predicate, Schema } from "effect";
 import { InngestConfig } from "../../../Client.js";
 import type { InngestFunction } from "../../../Function.js";
 import { StepError } from "../../errors.js";
-import * as StepResult from "../../codec/StepResult.js";
 import { InngestDuration } from "../../wire/Duration.js";
 import type { ExecutionInput } from "../../domain/ExecutionInput.js";
 import * as StepCommand from "../../domain/StepCommand.js";
@@ -23,9 +22,7 @@ export const invoke = <F extends InngestFunction.Any>(args: {
     const memo = args.input.memoForStep(info);
 
     return yield* Match.value(memo).pipe(
-      Match.tag("MemoData", ({ data }) =>
-        StepResult.decodeMemo(Schema.toCodecJson(args.options.function.success), info.id)(data),
-      ),
+      Match.tag("MemoData", ({ data }) => Effect.succeed(data)),
       Match.tag("MemoError", ({ error }) =>
         Effect.fail(
           StepError.make({