inngest 4.7.0 → 4.8.0

package/components/InngestStepTools.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"InngestStepTools.d.cts","names":[],"sources":["../../src/components/InngestStepTools.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"InngestStepTools.d.cts","names":[],"sources":["../../src/components/InngestStepTools.ts"],"sourcesContent":[],"mappings":"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"}

package/components/InngestStepTools.d.ts

@@ -1,13 +1,14 @@
 import { InngestApi } from "../api/api.js";
 import { ExclusiveKeys, ParametersExceptFirst, SendEventPayload } from "../helpers/types.js";
-import { StepFetch } from "./Fetch.js";
 import { Jsonify } from "../helpers/jsonify.js";
+import { StepFetch } from "./Fetch.js";
 import { DurationLike, InstantLike, ZonedDateTimeLike } from "../helpers/temporal.js";
 import { GroupTools } from "./InngestGroupTools.js";
-import { Middleware } from "./middleware/middleware.js";
+import { MetadataStepTool, metadataSymbol } from "./InngestMetadata.js";
+import { ScoreStepTool, scoreSymbol } from "./InngestScore.js";
 import { Realtime } from "./realtime/types.js";
 import { EventType } from "./triggers/triggers.js";
-import { MetadataStepTool, metadataSymbol } from "./InngestMetadata.js";
+import { Middleware } from "./middleware/middleware.js";
 import { InngestExecution } from "./execution/InngestExecution.js";
 import { ApplyAllMiddlewareTransforms, Context, EventMeta, EventPayload, HashedOp, InvocationResult, InvokeTargetFunctionDefinition, OutgoingOp, ReceivedEventMeta, SendEventOutput, StepOptions, StepOptionsOrId, TriggerEventFromFunction } from "../types.js";
 import { ClientOptionsFromInngest, GetFunctionOutputRaw, GetStepTools, Inngest } from "./Inngest.js";
@@ -329,6 +330,7 @@ declare const createStepTools: <TClient extends Inngest.Any, TFnMiddleware exten
 type GenericStepTools = GetStepTools<Inngest.Any>;
 type ExperimentalStepTools = GetStepTools<Inngest.Any> & {
   [metadataSymbol]: (memoizationId: string) => MetadataStepTool;
+  [scoreSymbol]: ScoreStepTool;
 };
 /**
  * A generic set of step tools that can be used without typing information about

package/components/InngestStepTools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InngestStepTools.d.ts","names":[],"sources":["../../src/components/InngestStepTools.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAiEA;;;;;;AAsBiB,UAtBA,qBAAA,CAsBU;EAAA;;;;;;EAAgB,gBAAA,EAAA,CAAA,OAAA,EAAA,GAAA,GAfP,OAeO,CAAA,OAAA,CAAA,EAAA,GAAA,IAAA;EA+E/B;;;;UAKG,EA7FH,UAAA,CAAW,QA6FR;;;;;EAKN,cAAA,EAAA,GAAA,GA5Fe,OA4Ff,CAAA,OAAA,CAAA;AAET;AAAuB,UA3FN,SAAA,SAAkB,QA2FZ,CAAA;UACZ,EAAA,MAAA;KACF,EAAA,CAAA,GAAA,IAAA,EAAA,OAAA,EAAA,EAAA,GAAA,OAAA;SACA,EAAA,OAAA,EAAA;;;AAGT;;;;;;;EAsB4C,SAAA,EAAA,OAAA;EA4BvC;;;;;;;;;cAOC,EAAA,OAAA;SAAsB,EAAA,OAAW;;;AAGvC;EAkwBC,OAAA,EA/3BU,OA+3BV,CAAA,OAAA,CAAA;;;;;QA5vBc,EAAA,GAAA,GAAA,OAAA;OAiNM,CAAA,EAAA,OAAA;;;;;YAEV,EAtUG,qBAsUH;;;;;;;;;;;qBA4EE,CAAA,EAAA;IAqDQ,OAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,IAAA;IACP,MAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,IAAA;;;;;;;0BAkEA,CAAA,EApfe,OAoff,CAAA,OAAA,CAAA;;;;;UAKK,CAAA,EAnfN,UAmfM,CAAA,UAAA,CAAA;;AA/UE,KAjKT,SAiKS,CAAA,UAAA,CAAA,GAAA,IAAA,EAAA,OAAA,EAAA,EAAA,GAhKe,OAgKf,CAAA,OAAA,CAAA,GAAA,CAAA,GAAA,IAAA,EAAA,OAAA,EAAA,EAAA,GA9Jd,OA8Jc,CAAA,OAAA,CAAA,CAAA,GAAA,CAAA,WAAA,EA5JN,WA4JM;;;;OAoBM,EA5KhB,qBA4KgB,CA5KM,CA4KN,CAAA,EAAA,GA3KtB,IA2KsB,CA3KjB,QA2KiB,EAAA,MAAA,GAAA,OAAA,CAAA;AAAS,KAzKxB,WAAA,GAyKwB,CAAA,IAAA,EAAA;SAA1B,EAxKC,SAwKD;MACA,CAAA,EAxKD,eAwKC;MAAiC,EAAA,CAvKlC,eAuKkC,EAAA,GAAA,OAAA,EAAA,CAAA;MAtKrC,OAsK0B,CAAA,OAAA,CAAA;AAAoB,UApKnC,eAoKmC,CAAA,UAAA,CAAA,GAAA,IAAA,EAAA,OAAA,EAAA,EAAA,GAnKhB,OAmKgB,CAAA,OAAA,CAAA,GAAA,CAAA,GAAA,IAAA,EAAA,OAAA,EAAA,EAAA,GAjK7C,OAiK6C,CAAA,OAAA,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;KAXxC,EAAA,CAAA,GAAA,IAAA,EAAA,CAnIM,OAAA,CAAQ,GAmId,EAAA,GAnIsB,UAmItB,CAnIiC,CAmIjC,CAAA,CAAA,EAAA,GAAA,OAAA;;;;;;;;;;;;;;KAvGP,iCACa,OAAA,CAAQ,2BACF,UAAA,CAAW,4BAE7B,yBAAyB,+BAA+B,UAAA,CAAW,UACnE,yBAAyB,kCAEzB,sBAAsB,UAAA,CAAW,UAAU;cAGpC,kCACK,OAAA,CAAQ,2BACF,UAAA,CAAW,yCAEzB,oBACG,+BACE;;;;;;;;;;;;;;;;;;;;;;;;;;;WA+mBL,EAAA,CAAA,WAAA,EA9ZW,eA8ZX,EAAA,OAAA,EA7ZO,gBA6ZP,EAAA,GA5ZC,OA4ZD,CA5ZS,eA4ZT,CA5ZyB,wBA4ZzB,CA5ZkD,OA4ZlD,CAAA,CAAA,CAAA;;;;;AAmJV;;;eAA+B,EAAA,CAAA,KAAA,CAAA,CAAA,WAAA,EA1gBV,eA0gBU,EAAA,IAAA,EAzgBjB,iBAygBiB,EAAA,GAxgBpB,OAwgBoB,CAAA;IAAY,MAAA,EAAA,MAAA;IAe/B,IAAA,EAvhB+B,OAuhB/B,CAvhBuC,KAuhBvC,CAAqB;EAAA,CAAA,GAAA,IAAA,CAAA;;;;;;AAwBjC;AAwFA;AAmBG;EAEsB,QAAA,EAAA;IAAmB;;;AACvB;;;IAIE,OAAA,EAAA,CAAA,KAAA,CAAA,CAAA,WAAA,EA/nBA,eA+nBA,EAAA,QAAA,EA9nBH,QAAA,CAAS,QA8nBN,CA9nBe,KA8nBf,CAAA,EAAA,IAAA,EA7nBP,KA6nBO,EAAA,GA5nBV,OA4nBU,CA5nBF,KA4nBE,CAAA;;;;;YASV,EAAA,CAAA,WAAA,EAhlBQ,eAglBR,EAAA,IAAA,EA/kBC,cA+kBD,EAAA,GA9kBF,OA8kBE,CA9kBM,UAAA,CAAW,kBA8kBjB,CAAA;;;;;;AAuBuB;AAMjB;;;cAqCb,EAAA,CAAA,cAAA;IACA;;;IAyBD,KAAA,EAAA,MAAA,GA7nBS,SA6nBS,CAAA,MAAA,EAAA,GAAA,CAAA;IAAA;;;;;;;;;;;;IA2BN,OAAA,EAAA,MAAA,GAAA,MAAA,GAvoBH,IAuoBG,GAtoBH,YAsoBG,GAroBH,WAqoBG,GApoBH,iBAooBG;MAnoBL,aAsoBJ,CAAA;IAG0B,KAAA,CAAA,EAAA,MAAA;IADd,EAAA,CAAA,EAAA,MAAA;KAKF,OAAA,EAAA,IAAA,CAAA,CAAA,CAAA,WAAA,EA3oBG,eA2oBH,EAAA,IAAA,EA1oBJ,KA0oBI,EAAA,GAzoBP,OAyoBO,CAzoBC,kBAyoBD,CAzoBoB,KAyoBpB,CAAA,CAAA;;;;;;;;;AAkBM;;;;KA6BA,EAAA,CAAA,YAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,OAAA,CAAA,CAAA,WAAA,EAvgCH,eAugCG,EAAA,EAAA,EA7/BZ,GA6/BY,EAAA,GAAA,KAAA,EAt/BN,UAs/BM,CAt/BK,GAs/BL,CAAA,EAAA,GAr/Bb,OAq/Ba,CAp/BhB,4BAo/BgB,CAn/Bd,gBAm/Bc,CAn/BG,OAm/BH,EAn/BY,aAm/BZ,CAAA,EAl/Bd,GAk/Bc,UAAA,CAAA,GAAA,IAAA,EAl/BQ,UAk/BR,CAl/BmB,GAk/BnB,CAAA,EAAA,GAl/B4B,OAk/B5B,CAAA,KAAA,EAAA,CAAA,IAj/BV,OAi/BU,CAj/BF,CAi/BE,SAAA,IAAA,GAAA,IAAA,GAj/BsB,CAi/BtB,CAAA,GAh/BV,UAg/BU,CAh/BC,GAg/BD,CAAA,SAAA,IAAA,GAAA,IAAA,GA9+BR,UA8+BQ,CA9+BG,GA8+BH,CAAA,CAAA,CAAA;;;;;;;;;;;6BAznBE,wBACH,0BACJ,YAAY,cAClB,QAAQ,SAAA,CAAU,OAAO;;;;;;;;;iEAjZjB,qBAUT,eAOM,WAAW,SAClB,QACH,6BACE,iBAAiB,SAAS,gBAC1B,uBAAsB,WAAW,SAAS,oBACtC,QAAQ,wBAAwB,KAChC,WAAW,2BAET,WAAW;;;;;;;;;;;;;;;;;;;;;;uBAobN,yCAKW,iBACrB;;;;;;;4BA0BU,uBAKP,gBAAgB,cAAuB,sBAC1C;;;;;;6BAyCc,6CACJ,uBACP,eAAe,eAClB,iBACH,6BACE,iBAAiB,SAAS,gBAC1B,qBAAqB;;;;;;;;SAHJ;;;;;;KAsJf,gBAAA,GAAmB,aAAa,OAAA,CAAQ;KAexC,qBAAA,GAAwB,aAAa,OAAA,CAAQ;GACtD,cAAA,8BAA4C;;;;;;;;;;;;;cAuBlC,MAAM;;;;;;cAwFN,OAAO;KAqBf,uCAAuC;YAChC;;KAGP,iCAAiC,kCACpC,qBAAqB,aACnB,KAAK,yBAAyB;;;;;;;;SAQrB;;;;;;;;;;;;;;;;8BAoBH,OACA,eACA,cACA;;;;;KAML,cAAA;;;;;;;;;;;;;KAeA,iBAAA;;;;;;;;;;;;;;;;;6BAqBC,OACA,eACA,cACA;;;;;;;;;;;;;;;;;;;;;;KAwBD,4BAEH;SACS,sCAEL,qCAAqC;;QAI7B;QACA;;;;SAIC;WAGT;SACW;;QAGD;QAEA;;;;SAIC;WAGT;;UAEY,qCACc;;QAIhB;QACA;;;;SAIC;WAGT;;;QAEU;QAEA;;;;SAIC;WAET;;;;KAKP,2BAA2B;;;;;;;;;;;;;;;;;;;SAmBvB;;;;QAKD,SAAA,CAAU,MAAM"}
+{"version":3,"file":"InngestStepTools.d.ts","names":[],"sources":["../../src/components/InngestStepTools.ts"],"sourcesContent":[],"mappings":"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"}

package/components/InngestStepTools.js

@@ -6,6 +6,7 @@ import { getAsyncCtx, getAsyncCtxSync } from "./execution/als.js";
 import { normalizeEventMeta } from "../helpers/sessions.js";
 import { InngestFunction } from "./InngestFunction.js";
 import { UnscopedMetadataBuilder, metadataSymbol } from "./InngestMetadata.js";
+import { scoreSymbol, sendStepScore, validateStepScoreOptions } from "./InngestScore.js";
 import { fetch } from "./Fetch.js";
 import { InngestFunctionReference } from "./InngestFunctionReference.js";
 import { internalLoggerSymbol } from "./Inngest.js";
@@ -101,6 +102,13 @@ const createStepTools = (client, execution, stepHandler) => {
 			}
 		};
 	};
+	const createStepScoreWrapper = async (memoizationId, options) => {
+		if (!client["experimentalScoreEnabled"]) throw new NonRetriableError("step.score() is experimental. Enable it by adding scoreMiddleware() from \"inngest/experimental\" to your client middleware.");
+		validateStepScoreOptions(options);
+		await tools.run(memoizationId, async () => {
+			await sendStepScore(client, options);
+		});
+	};
 	/**
 	* Define the set of tools the user has access to for their step functions.
 	*
@@ -306,6 +314,7 @@ const createStepTools = (client, execution, stepHandler) => {
 		fetch
 	};
 	tools[metadataSymbol] = (memoizationId) => createStepMetadataWrapper(memoizationId);
+	tools[scoreSymbol] = createStepScoreWrapper;
 	tools[experimentStepRunSymbol] = createStepRun("group.experiment");
 	tools[gatewaySymbol] = createTool(({ id, name }, input, init) => {
 		const url = input instanceof Request ? input.url : input.toString();

package/components/InngestStepTools.js.map

@@ -1 +1 @@
-{"version":3,"file":"InngestStepTools.js","names":["wrappedMatchOp: MatchOpFn<T>","opts: HashedOp[\"opts\"]","matchOpts: { timeout: string; if?: string }","msTimeStr: string","Temporal.getISOString","v","Temporal.isTemporalDuration","Temporal.isTemporalInstant","Temporal.isTemporalZonedDateTime","opts: {\n        payload: typeof payload;\n        function_id: string;\n        timeout?: string;\n      }","stepFetch","headers: Record<string, string>","step: GenericStepTools","group: GroupTools"],"sources":["../../src/components/InngestStepTools.ts"],"sourcesContent":["import { type AiAdapter, models } from \"@inngest/ai\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { z } from \"zod/v3\";\n\nimport type { InngestApi } from \"../api/api.ts\";\nimport type { Jsonify } from \"../helpers/jsonify.ts\";\nimport { normalizeEventMeta } from \"../helpers/sessions.ts\";\nimport { timeStr } from \"../helpers/strings.ts\";\nimport * as Temporal from \"../helpers/temporal.ts\";\nimport type {\n  ExclusiveKeys,\n  ParametersExceptFirst,\n  SendEventPayload,\n} from \"../helpers/types.ts\";\nimport {\n  type ApplyAllMiddlewareTransforms,\n  type Context,\n  type EventMeta,\n  type EventPayload,\n  type HashedOp,\n  type InvocationResult,\n  type InvokeTargetFunctionDefinition,\n  type MinimalEventPayload,\n  type OutgoingOp,\n  type ReceivedEventMeta,\n  type SendEventOutput,\n  StepMode,\n  StepOpCode,\n  type StepOptions,\n  type StepOptionsOrId,\n  type TriggerEventFromFunction,\n} from \"../types.ts\";\nimport { getAsyncCtx, getAsyncCtxSync } from \"./execution/als.ts\";\nimport type { InngestExecution } from \"./execution/InngestExecution.ts\";\nimport { fetch as stepFetch } from \"./Fetch.ts\";\nimport {\n  type ClientOptionsFromInngest,\n  type GetFunctionOutputRaw,\n  type GetStepTools,\n  type Inngest,\n  internalLoggerSymbol,\n} from \"./Inngest.ts\";\nimport { InngestFunction } from \"./InngestFunction.ts\";\nimport { InngestFunctionReference } from \"./InngestFunctionReference.ts\";\nimport type { GroupTools } from \"./InngestGroupTools.ts\";\nimport {\n  type MetadataBuilder,\n  type MetadataStepTool,\n  metadataSymbol,\n  UnscopedMetadataBuilder,\n} from \"./InngestMetadata.ts\";\nimport type { Middleware } from \"./middleware/index.ts\";\nimport { NonRetriableError } from \"./NonRetriableError.ts\";\nimport type { Realtime } from \"./realtime/types.ts\";\nimport type { EventType } from \"./triggers/triggers.ts\";\n\n/**\n * Middleware context for a step, created during step registration.\n *\n * Uses a \"deferred handler\" pattern: the `wrapStep` middleware chain starts\n * during discovery (so middleware can inject its own steps), but the real\n * handler isn't known until after the memoization lookup. `setActualHandler`\n * bridges the gap — the chain blocks on a deferred promise that is resolved\n * once `executeStep` determines the real result.\n */\nexport interface StepMiddlewareContext {\n  /**\n   * Sets the handler that the middleware pipeline will eventually call.\n   * Called after memoization lookup to set either:\n   * - A handler returning memoized data, OR\n   * - A handler executing the step fresh\n   */\n  setActualHandler: (handler: () => Promise<unknown>) => void;\n\n  /**\n   * Step info after middleware transformations. The `options.id` may differ\n   * from the original if middleware modified it via `transformStepInput`.\n   */\n  stepInfo: Middleware.StepInfo;\n\n  /**\n   * The middleware pipeline entry point. Call this to execute the step\n   * through all middleware transformations.\n   */\n  wrappedHandler: () => Promise<unknown>;\n}\n\nexport interface FoundStep extends HashedOp {\n  hashedId: string;\n  fn?: (...args: unknown[]) => unknown;\n  rawArgs: unknown[];\n\n  /**\n   * A boolean representing whether the step has been fulfilled, either\n   * resolving or rejecting the `Promise` returned to userland code.\n   *\n   * Note that this is distinct from {@link hasStepState}, which instead tracks\n   * whether the step has been given some state from the Executor. State from\n   * the Executor could be data other than a resolution or rejection, such as\n   * inputs.\n   */\n  fulfilled: boolean;\n\n  /**\n   * A boolean representing whether the step has been given some state from the\n   * Executor. State from the Executor could be data other than a resolution or\n   * rejection, such as inputs.\n   *\n   * This is distinct from {@link fulfilled}, which instead tracks whether the\n   * step has been fulfilled, either resolving or rejecting the `Promise`\n   * returned to userland code.\n   */\n  hasStepState: boolean;\n\n  handled: boolean;\n\n  /**\n   * The promise that has been returned to userland code for this step.\n   */\n  promise: Promise<unknown>;\n\n  /**\n   * Returns a boolean representing whether or not the step was handled on this\n   * invocation.\n   */\n  handle: () => boolean;\n\n  // TODO This is used to track the input we want for this step. Might be\n  // present in ctx from Executor.\n  input?: unknown;\n\n  /**\n   * Middleware context for this step. Holds the `wrapStep` chain entry point\n   * and the deferred handler setter used by `executeStep`.\n   */\n  middleware: StepMiddlewareContext;\n\n  /**\n   * For new steps where wrappedHandler is called during discovery,\n   * this holds the resolve/reject to be called when the step's data is\n   * memoized. Resolved with server-transformed data (post-wrapStepHandler),\n   * which unblocks wrapStep's `next()`.\n   *\n   * Is undefined when any of the following is true:\n   * - The step is fulfilled\n   * - The step has no handler (`step.sleep`, `step.waitForSignal`, etc.)\n   */\n  memoizationDeferred?: {\n    resolve: (value: unknown) => void;\n    reject: (error: unknown) => void;\n  };\n\n  /**\n   * For new steps where `wrappedHandler` is called during discovery, this holds\n   * the promise for the wrapStep-transformed result. In checkpointing mode,\n   * handle() reuses this promise to avoid a duplicate wrapStep call.\n   */\n  transformedResultPromise?: Promise<unknown>;\n\n  /**\n   * Optional metadata updates attached to this step, carried through from\n   * the OutgoingOp so that checkpoint payloads include metadata.\n   */\n  metadata?: OutgoingOp[\"metadata\"];\n}\n\nexport type MatchOpFn<\n  T extends (...args: unknown[]) => Promise<unknown> = (\n    ...args: unknown[]\n  ) => Promise<unknown>,\n> = (\n  stepOptions: StepOptions,\n  /**\n   * Arguments passed by the user.\n   */\n  ...args: ParametersExceptFirst<T>\n) => Omit<HashedOp, \"data\" | \"error\">;\n\nexport type StepHandler = (info: {\n  matchOp: MatchOpFn;\n  opts?: StepToolOptions;\n  args: [StepOptionsOrId, ...unknown[]];\n}) => Promise<unknown>;\n\nexport interface StepToolOptions<\n  T extends (...args: unknown[]) => Promise<unknown> = (\n    ...args: unknown[]\n  ) => Promise<unknown>,\n> {\n  /**\n   * Optionally, we can also provide a function that will be called when\n   * Inngest tells us to run this operation.\n   *\n   * If this function is defined, the first time the tool is used it will\n   * report the desired operation (including options) to the Inngest. Inngest\n   * will then call back to the function to tell it to run the step and then\n   * retrieve data.\n   *\n   * We do this in order to allow functionality such as per-step retries; this\n   * gives the SDK the opportunity to tell Inngest what it wants to do before\n   * it does it.\n   *\n   * This function is passed the arguments passed by the user. It will be run\n   * when we receive an operation matching this one that does not contain a\n   * `data` property.\n   */\n  fn?: (...args: [Context.Any, ...Parameters<T>]) => unknown;\n}\n\nexport const getStepOptions = (options: StepOptionsOrId): StepOptions => {\n  if (typeof options === \"string\") {\n    return { id: options };\n  }\n\n  return options;\n};\n\n/**\n * Suffix used to namespace steps that are automatically indexed.\n */\nexport const STEP_INDEXING_SUFFIX = \":\";\n\n/**\n * Create a new set of step function tools ready to be used in a step function.\n * This function should be run and a fresh set of tools provided every time a\n * function is run.\n *\n * An op stack (function state) is passed in as well as some mutable properties\n * that the tools can use to submit a new op.\n */\n/**\n * Merge client-level and function-level middleware into a single array type\n * for use with ApplyAllMiddlewareTransforms etc.\n */\ntype MergedMiddleware<\n  TClient extends Inngest.Any,\n  TFnMiddleware extends Middleware.Class[] | undefined,\n> = [\n  ...(ClientOptionsFromInngest<TClient>[\"middleware\"] extends Middleware.Class[]\n    ? ClientOptionsFromInngest<TClient>[\"middleware\"]\n    : []),\n  ...(TFnMiddleware extends Middleware.Class[] ? TFnMiddleware : []),\n];\n\nexport const createStepTools = <\n  TClient extends Inngest.Any,\n  TFnMiddleware extends Middleware.Class[] | undefined = undefined,\n>(\n  client: TClient,\n  execution: InngestExecution,\n  stepHandler: StepHandler,\n) => {\n  /**\n   * A local helper used to create tools that can be used to submit an op.\n   *\n   * When using this function, a generic type should be provided which is the\n   * function signature exposed to the user.\n   */\n  // biome-ignore lint/suspicious/noExplicitAny: intentional\n  const createTool = <T extends (...args: any[]) => Promise<unknown>>(\n    /**\n     * A function that returns an ID for this op. This is used to ensure that\n     * the op stack is correctly filled, submitted, and retrieved with the same\n     * ID.\n     *\n     * It is passed the arguments passed by the user.\n     *\n     * Most simple tools will likely only need to define this.\n     */\n    matchOp: MatchOpFn<T>,\n    opts?: StepToolOptions<T>,\n  ): T => {\n    const wrappedMatchOp: MatchOpFn<T> = (stepOptions, ...rest) => {\n      const op = matchOp(stepOptions, ...rest);\n\n      const alsCtx = getAsyncCtxSync()?.execution;\n\n      if (alsCtx?.insideExperimentSelect) {\n        throw new NonRetriableError(\n          \"Step tools (step.run, step.sleep, etc.) cannot be called inside \" +\n            \"an experiment select() callback. Move step calls into variant \" +\n            \"callbacks instead.\",\n        );\n      }\n\n      // Explicit option takes precedence, then check ALS context\n      const parallelMode = stepOptions.parallelMode ?? alsCtx?.parallelMode;\n\n      if (parallelMode) {\n        op.opts = { ...op.opts, parallelMode };\n      }\n\n      // Propagate experiment context to variant sub-steps\n      const experimentContext = alsCtx?.experimentContext;\n      if (experimentContext) {\n        op.opts = { ...op.opts, ...experimentContext };\n      }\n\n      // Track that a step tool was invoked inside a variant callback\n      const tracker = alsCtx?.experimentStepTracker;\n      if (tracker) {\n        tracker.found = true;\n      }\n\n      return op;\n    };\n\n    return (async (...args: Parameters<T>): Promise<unknown> => {\n      const parsedArgs = args as unknown as [StepOptionsOrId, ...unknown[]];\n      return stepHandler({ args: parsedArgs, matchOp: wrappedMatchOp, opts });\n    }) as T;\n  };\n\n  /**\n   * Create a new step run tool that can be used to run a step function using\n   * `step.run()` as a shim.\n   */\n  const createStepRun = (\n    /**\n     * The sub-type of this step tool, exposed via `opts.type` when the op is\n     * reported.\n     */\n    type?: string,\n  ) => {\n    return createTool<\n      // biome-ignore lint/suspicious/noExplicitAny: intentional\n      <TFn extends (...args: any[]) => unknown>(\n        idOrOptions: StepOptionsOrId,\n\n        /**\n         * The function to run when this step is executed. Can be synchronous or\n         * asynchronous.\n         *\n         * The return value of this function will be the return value of this\n         * call to `run`, meaning you can return and reason about return data\n         * for next steps.\n         */\n        fn: TFn,\n\n        /**\n         * Optional input to pass to the function. If this is specified, Inngest\n         * will keep track of the input for this step and be able to display it\n         * in the UI.\n         */\n        ...input: Parameters<TFn>\n      ) => Promise<\n        ApplyAllMiddlewareTransforms<\n          MergedMiddleware<TClient, TFnMiddleware>,\n          TFn extends (...args: Parameters<TFn>) => Promise<infer U>\n            ? Awaited<U extends void ? null : U>\n            : ReturnType<TFn> extends void\n              ? null\n              : ReturnType<TFn>\n        >\n      >\n    >(\n      ({ id, name }, _fn, ...input) => {\n        const opts: HashedOp[\"opts\"] = {\n          ...(input.length ? { input } : {}),\n          ...(type ? { type } : {}),\n        };\n\n        return {\n          id,\n          mode: StepMode.Sync,\n          op: StepOpCode.StepPlanned,\n          name: id,\n          displayName: name ?? id,\n          ...(Object.keys(opts).length ? { opts } : {}),\n          userland: { id },\n        };\n      },\n      {\n        fn: (_, __, fn, ...input) => fn(...input),\n      },\n    );\n  };\n\n  /**\n   * Creates a metadata builder wrapper for step.metadata(\"id\").\n   * Uses MetadataBuilder for config accumulation, but wraps .update() in tools.run() for memoization.\n   */\n  const createStepMetadataWrapper = (\n    memoizationId: string,\n    builder?: UnscopedMetadataBuilder,\n  ) => {\n    if (!client[\"experimentalMetadataEnabled\"]) {\n      throw new Error(\n        'step.metadata() is experimental. Enable it by adding metadataMiddleware() from \"inngest/experimental\" to your client middleware.',\n      );\n    }\n    const withBuilder = (next: UnscopedMetadataBuilder) =>\n      createStepMetadataWrapper(memoizationId, next);\n\n    if (!builder) {\n      builder = new UnscopedMetadataBuilder(client).run();\n    }\n\n    return {\n      run: (runId?: string) => withBuilder(builder.run(runId)),\n      step: (stepId: string, index?: number) =>\n        withBuilder(builder.step(stepId, index)),\n      attempt: (attemptIndex: number) =>\n        withBuilder(builder.attempt(attemptIndex)),\n      span: (spanId: string) => withBuilder(builder.span(spanId)),\n      update: async (\n        values: Record<string, unknown>,\n        kind = \"default\",\n      ): Promise<void> => {\n        await tools.run(memoizationId, async () => {\n          await builder.update(values, kind);\n        });\n      },\n\n      do: async (\n        fn: (builder: MetadataBuilder) => Promise<void>,\n      ): Promise<void> => {\n        await tools.run(memoizationId, async () => {\n          await fn(builder);\n        });\n      },\n    };\n  };\n\n  /**\n   * Define the set of tools the user has access to for their step functions.\n   *\n   * Each key is the function name and is expected to run `createTool` and pass\n   * a generic type for that function as it will appear in the user's code.\n   */\n  const tools = {\n    /**\n     * Send one or many events to Inngest. Should always be used in place of\n     * `inngest.send()` to ensure that the event send is successfully retried\n     * and not sent multiple times due to memoisation.\n     *\n     * @example\n     * ```ts\n     * await step.sendEvent(\"emit-user-creation\", {\n     *   name: \"app/user.created\",\n     *   data: { id: 123 },\n     * });\n     *\n     * await step.sendEvent(\"emit-user-updates\", [\n     *   {\n     *     name: \"app/user.created\",\n     *     data: { id: 123 },\n     *   },\n     *   {\n     *     name: \"app/user.feed.created\",\n     *     data: { id: 123 },\n     *   },\n     * ]);\n     * ```\n     *\n     * Returns a promise that will resolve once the event has been sent.\n     */\n    sendEvent: createTool<\n      (\n        idOrOptions: StepOptionsOrId,\n        payload: SendEventPayload,\n      ) => Promise<SendEventOutput<ClientOptionsFromInngest<TClient>>>\n    >(\n      ({ id, name }) => {\n        return {\n          id,\n          mode: StepMode.Sync,\n          op: StepOpCode.StepPlanned,\n          name: \"sendEvent\",\n          displayName: name ?? id,\n          opts: {\n            type: \"step.sendEvent\",\n          },\n          userland: { id },\n        };\n      },\n      {\n        fn: (_ctx, _idOrOptions, payload) => {\n          const fn = execution[\"options\"][\"fn\"];\n          return client[\"_send\"]({\n            payload,\n            headers: execution[\"options\"][\"headers\"],\n            fnMiddleware: fn.opts.middleware ?? [],\n            fn,\n          });\n        },\n      },\n    ),\n\n    /**\n     * EXPERIMENTAL: This API is not yet stable and may change in the future\n     * without a major version bump.\n     *\n     * Wait for a particular signal to be received before continuing. When the\n     * signal is received, its data will be returned.\n     */\n    waitForSignal: createTool<\n      <TData>(\n        idOrOptions: StepOptionsOrId,\n        opts: WaitForSignalOpts,\n      ) => Promise<{ signal: string; data: Jsonify<TData> } | null>\n    >(({ id, name }, opts) => {\n      return {\n        id,\n        mode: StepMode.Async,\n        op: StepOpCode.WaitForSignal,\n        name: opts.signal,\n        displayName: name ?? id,\n        opts: {\n          signal: opts.signal,\n          timeout: timeStr(opts.timeout),\n          conflict: opts.onConflict,\n        },\n        userland: { id },\n      };\n    }),\n\n    /**\n     * Step-level functionality related to realtime features.\n     *\n     * Unlike client-level realtime methods (`inngest.realtime.*`), these tools\n     * will be their own durable steps when run. If you wish to use realtime\n     * features outside of a step, make sure to use the client-level methods\n     * instead.\n     */\n    realtime: {\n      /**\n       * Publish a realtime message as a durable step. Memoized and will not\n       * re-fire on retry, unlike client-level `inngest.realtime.publish()`.\n       *\n       * Uses topic accessors: `step.realtime.publish(\"id\", chat.status, data)`\n       */\n      publish: createTool<\n        <TData>(\n          idOrOptions: StepOptionsOrId,\n          topicRef: Realtime.TopicRef<TData>,\n          data: TData,\n        ) => Promise<TData>\n      >(\n        ({ id, name }) => {\n          return {\n            id,\n            mode: StepMode.Sync,\n            op: StepOpCode.StepPlanned,\n            displayName: name ?? id,\n            opts: {\n              type: \"step.realtime.publish\",\n            },\n            userland: { id },\n          };\n        },\n        {\n          fn: async (ctx, _idOrOptions, topicRef, data) => {\n            const topicConfig = topicRef.config;\n            if (topicConfig && \"schema\" in topicConfig && topicConfig.schema) {\n              const result =\n                await topicConfig.schema[\"~standard\"].validate(data);\n              if (result.issues) {\n                throw new Error(\n                  `Schema validation failed for topic \"${topicRef.topic}\"`,\n                );\n              }\n            }\n\n            const res = await client[\"inngestApi\"].publish(\n              {\n                topics: [topicRef.topic],\n                channel: topicRef.channel,\n                runId: ctx.runId,\n              },\n              data,\n            );\n\n            if (!res.ok) {\n              throw new Error(\n                `Failed to publish to realtime: ${res.error?.error || \"Unknown error\"}`,\n              );\n            }\n\n            return data;\n          },\n        },\n      ),\n    },\n\n    /**\n     * Send a Signal to Inngest.\n     */\n    sendSignal: createTool<\n      (\n        idOrOptions: StepOptionsOrId,\n        opts: SendSignalOpts,\n      ) => Promise<InngestApi.SendSignalResponse>\n    >(\n      ({ id, name }, opts) => {\n        return {\n          id,\n          mode: StepMode.Sync,\n          op: StepOpCode.StepPlanned,\n          name: \"sendSignal\",\n          displayName: name ?? id,\n          opts: {\n            type: \"step.sendSignal\",\n            signal: opts.signal,\n          },\n          userland: { id },\n        };\n      },\n      {\n        fn: (_ctx, _idOrOptions, opts) => {\n          return client[\"_sendSignal\"]({\n            signal: opts.signal,\n            data: opts.data,\n            headers: execution[\"options\"][\"headers\"],\n          });\n        },\n      },\n    ),\n\n    /**\n     * Wait for a particular event to be received before continuing. When the\n     * event is received, it will be returned.\n     *\n     * You can also provide options to control the particular event that is\n     * received, for example to ensure that a user ID matches between two\n     * events, or to only wait a maximum amount of time before giving up and\n     * returning `null` instead of any event data.\n     */\n    waitForEvent: createTool<\n      <\n        TOpts extends {\n          /**\n           * The event to wait for.\n           */\n          event:\n            | string\n            // biome-ignore lint/suspicious/noExplicitAny: Allow any schema\n            | EventType<string, any>;\n\n          /**\n           * The step function will wait for the event for a maximum of this\n           * time, at which point the signal will be returned as `null` instead\n           * of any signal data.\n           *\n           * The time to wait can be specified using a `number` of milliseconds,\n           * an `ms`-compatible time string like `\"1 hour\"`, `\"30 mins\"`, or\n           * `\"2.5d\"`, a `Date`, a `Temporal.Duration` (relative wait), or a\n           * `Temporal.Instant` / `Temporal.ZonedDateTime` (absolute deadline).\n           *\n           * {@link https://npm.im/ms}\n           */\n          timeout:\n            | number\n            | string\n            | Date\n            | Temporal.DurationLike\n            | Temporal.InstantLike\n            | Temporal.ZonedDateTimeLike;\n        } & ExclusiveKeys<{ match?: string; if?: string }, \"match\", \"if\">,\n      >(\n        idOrOptions: StepOptionsOrId,\n        opts: TOpts,\n      ) => Promise<WaitForEventResult<TOpts>>\n    >(\n      (\n        { id, name },\n\n        /**\n         * Options to control the event we're waiting for.\n         */\n        opts,\n      ) => {\n        const matchOpts: { timeout: string; if?: string } = {\n          timeout: timeStr(typeof opts === \"string\" ? opts : opts.timeout),\n        };\n\n        if (typeof opts !== \"string\") {\n          if (opts?.match) {\n            matchOpts.if = `event.${opts.match} == async.${opts.match}`;\n          } else if (opts?.if) {\n            matchOpts.if = opts.if;\n          }\n        }\n\n        // Extract event name from string or EventType object\n        const eventName =\n          typeof opts.event === \"string\" ? opts.event : opts.event.name;\n\n        return {\n          id,\n          mode: StepMode.Async,\n          op: StepOpCode.WaitForEvent,\n          name: eventName,\n          opts: matchOpts,\n          displayName: name ?? id,\n          userland: { id },\n        };\n      },\n    ),\n\n    /**\n     * Use this tool to run business logic. Each call to `run` will be retried\n     * individually, meaning you can compose complex workflows that safely\n     * retry dependent asynchronous actions.\n     *\n     * The function you pass to `run` will be called only when this \"step\" is to\n     * be executed and can be synchronous or asynchronous.\n     *\n     * In either case, the return value of the function will be the return value\n     * of the `run` tool, meaning you can return and reason about return data\n     * for next steps.\n     */\n    run: createStepRun(),\n\n    /**\n     * AI tooling for running AI models and other AI-related tasks.\n     */\n    ai: {\n      /**\n       * Use this tool to have Inngest make your AI calls. Useful for agentic workflows.\n       *\n       * Input is also tracked for this tool, meaning you can pass input to the\n       * function and it will be displayed and editable in the UI.\n       */\n      infer: createTool<\n        <TAdapter extends AiAdapter>(\n          idOrOptions: StepOptionsOrId,\n          options: AiInferOpts<TAdapter>,\n        ) => Promise<AiAdapter.Output<TAdapter>>\n      >(({ id, name }, options) => {\n        // eslint-disable-next-line\n        const { model, body, ...rest } = options;\n\n        const modelCopy = { ...model };\n\n        // Allow the model to mutate options and body for this call\n        options.model.onCall?.(modelCopy, options.body);\n\n        return {\n          id,\n          mode: StepMode.Async,\n          op: StepOpCode.AiGateway,\n          displayName: name ?? id,\n          opts: {\n            type: \"step.ai.infer\",\n            url: modelCopy.url,\n            headers: modelCopy.headers,\n            auth_key: modelCopy.authKey,\n            format: modelCopy.format,\n            // eslint-disable-next-line\n            body,\n            // eslint-disable-next-line\n            ...rest,\n          },\n          userland: { id },\n        };\n      }),\n\n      /**\n       * Use this tool to wrap AI models and other AI-related tasks. Each call\n       * to `wrap` will be retried individually, meaning you can compose complex\n       * workflows that safely retry dependent asynchronous actions.\n       *\n       * Input is also tracked for this tool, meaning you can pass input to the\n       * function and it will be displayed and editable in the UI.\n       */\n      wrap: createStepRun(\"step.ai.wrap\"),\n\n      /**\n       * Models for AI inference and other AI-related tasks.\n       */\n      models: {\n        ...models,\n      },\n    },\n\n    /**\n     * Wait a specified amount of time before continuing.\n     *\n     * The time to wait can be specified using a `number` of milliseconds or an\n     * `ms`-compatible time string like `\"1 hour\"`, `\"30 mins\"`, or `\"2.5d\"`.\n     *\n     * {@link https://npm.im/ms}\n     *\n     * To wait until a particular date, use `sleepUntil` instead.\n     */\n    sleep: createTool<\n      (\n        idOrOptions: StepOptionsOrId,\n\n        /**\n         * The amount of time to wait before continuing.\n         */\n        time: number | string | Temporal.DurationLike,\n      ) => Promise<void>\n    >(({ id, name }, time) => {\n      /**\n       * The presence of this operation in the returned stack indicates that the\n       * sleep is over and we should continue execution.\n       */\n      const msTimeStr: string = timeStr(time);\n\n      return {\n        id,\n        mode: StepMode.Async,\n        op: StepOpCode.Sleep,\n        name: msTimeStr,\n        displayName: name ?? id,\n        userland: { id },\n      };\n    }),\n\n    /**\n     * Wait until a particular date before continuing by passing a `Date`.\n     *\n     * To wait for a particular amount of time from now, always use `sleep`\n     * instead.\n     */\n    sleepUntil: createTool<\n      (\n        idOrOptions: StepOptionsOrId,\n\n        /**\n         * The date to wait until before continuing.\n         */\n        time: Date | string | Temporal.InstantLike | Temporal.ZonedDateTimeLike,\n      ) => Promise<void>\n    >(({ id, name }, time) => {\n      try {\n        const iso = Temporal.getISOString(time);\n\n        /**\n         * The presence of this operation in the returned stack indicates that the\n         * sleep is over and we should continue execution.\n         */\n        return {\n          id,\n          mode: StepMode.Async,\n          op: StepOpCode.Sleep,\n          name: iso,\n          displayName: name ?? id,\n          userland: { id },\n        };\n      } catch (err) {\n        /**\n         * If we're here, it's because the date is invalid. We'll throw a custom\n         * error here to standardise this response.\n         */\n        client[internalLoggerSymbol].warn(\n          { err },\n          \"Invalid `Date`, date string, `Temporal.Instant`, or `Temporal.ZonedDateTime` passed to sleepUntil\",\n        );\n\n        throw new Error(\n          `Invalid \\`Date\\`, date string, \\`Temporal.Instant\\`, or \\`Temporal.ZonedDateTime\\` passed to sleepUntil: ${\n            time\n          }`,\n        );\n      }\n    }),\n\n    /**\n     * Invoke a passed Inngest `function` with the given `data`. Returns the\n     * result of the returned value of the function or `null` if the function\n     * does not return a value.\n     */\n    invoke: createTool<\n      <TFunction extends InvokeTargetFunctionDefinition>(\n        idOrOptions: StepOptionsOrId,\n        opts: InvocationOpts<TFunction>,\n      ) => InvocationResult<\n        ApplyAllMiddlewareTransforms<\n          MergedMiddleware<TClient, TFnMiddleware>,\n          GetFunctionOutputRaw<TFunction>,\n          \"functionOutputTransform\"\n        >\n      >\n    >(({ id, name }, invokeOpts) => {\n      // Create a discriminated union to operate on based on the input types\n      // available for this tool.\n      const optsSchema = invokePayloadSchema.extend({\n        timeout: z\n          .custom<\n            | number\n            | string\n            | Date\n            | Temporal.DurationLike\n            | Temporal.InstantLike\n            | Temporal.ZonedDateTimeLike\n          >(\n            (v) =>\n              typeof v === \"number\" ||\n              typeof v === \"string\" ||\n              v instanceof Date ||\n              Temporal.isTemporalDuration(v) ||\n              Temporal.isTemporalInstant(v) ||\n              Temporal.isTemporalZonedDateTime(v),\n            { message: \"Invalid timeout\" },\n          )\n          .optional(),\n      });\n\n      const parsedFnOpts = optsSchema\n        .extend({\n          _type: z.literal(\"fnInstance\").optional().default(\"fnInstance\"),\n          function: z.instanceof(InngestFunction),\n        })\n        .or(\n          optsSchema.extend({\n            _type: z.literal(\"refInstance\").optional().default(\"refInstance\"),\n            function: z.instanceof(InngestFunctionReference),\n          }),\n        )\n        .safeParse(invokeOpts);\n\n      if (!parsedFnOpts.success) {\n        throw new Error(\n          `Invalid invocation options passed to invoke; must include a function instance or referenceFunction().`,\n        );\n      }\n\n      const { _type, function: fn, data, v, meta, timeout } = parsedFnOpts.data;\n      const payload = {\n        data,\n        v,\n        meta: normalizeEventMeta(meta),\n      } satisfies MinimalEventPayload;\n      const opts: {\n        payload: typeof payload;\n        function_id: string;\n        timeout?: string;\n      } = {\n        payload,\n        function_id: \"\",\n        timeout: typeof timeout === \"undefined\" ? undefined : timeStr(timeout),\n      };\n\n      switch (_type) {\n        case \"fnInstance\":\n          opts.function_id = fn.id(fn[\"client\"].id);\n          break;\n\n        case \"refInstance\":\n          opts.function_id = [fn.opts.appId || client.id, fn.opts.functionId]\n            .filter(Boolean)\n            .join(\"-\");\n          break;\n      }\n\n      return {\n        id,\n        mode: StepMode.Async,\n        op: StepOpCode.InvokeFunction,\n        displayName: name ?? id,\n        opts,\n        userland: { id },\n      };\n    }),\n\n    /**\n     * `step.fetch` is a Fetch-API-compatible function that can be used to make\n     * any HTTP code durable if it's called within an Inngest function.\n     *\n     * It will gracefully fall back to the global `fetch` if called outside of\n     * this context, and a custom fallback can be set using the `config` method.\n     */\n    fetch: stepFetch,\n  };\n\n  // NOTE: This should be moved into the above object definition under the key\n  // \"metadata\" when metadata is made non-experimental.\n  (tools as unknown as ExperimentalStepTools)[metadataSymbol] = (\n    memoizationId: string,\n  ): MetadataStepTool => createStepMetadataWrapper(memoizationId);\n\n  // Attach a step.run variant with opts.type = \"group.experiment\" for use by\n  // group.experiment(). The symbol keeps it off the public `step` surface.\n  (tools as unknown as ExperimentStepTools)[experimentStepRunSymbol] =\n    createStepRun(\"group.experiment\");\n\n  // Add an uptyped gateway\n  (tools as unknown as InternalStepTools)[gatewaySymbol] = createTool(\n    ({ id, name }, input, init) => {\n      const url = input instanceof Request ? input.url : input.toString();\n\n      const headers: Record<string, string> = {};\n      if (input instanceof Request) {\n        input.headers.forEach((value, key) => {\n          headers[key] = value;\n        });\n      } else if (init?.headers) {\n        const h = new Headers(init.headers);\n        h.forEach((value, key) => {\n          headers[key] = value;\n        });\n      }\n\n      return {\n        id,\n        mode: StepMode.Async,\n        op: StepOpCode.Gateway,\n        displayName: name ?? id,\n        opts: {\n          url,\n          method: init?.method ?? \"GET\",\n          headers,\n          body: init?.body,\n        },\n        userland: { id },\n      };\n    },\n  );\n\n  return tools;\n};\n\n/**\n * A generic set of step tools, without typing information about the client used\n * to create them.\n */\nexport type GenericStepTools = GetStepTools<Inngest.Any>;\n\nexport const gatewaySymbol = Symbol.for(\"inngest.step.gateway\");\n\nexport type InternalStepTools = GetStepTools<Inngest.Any> & {\n  [gatewaySymbol]: (\n    idOrOptions: StepOptionsOrId,\n    ...args: Parameters<typeof fetch>\n  ) => Promise<{\n    status_code: number;\n    headers: Record<string, string>;\n    body: string;\n  }>;\n};\n\nexport type ExperimentalStepTools = GetStepTools<Inngest.Any> & {\n  [metadataSymbol]: (memoizationId: string) => MetadataStepTool;\n};\n\nexport const experimentStepRunSymbol = Symbol.for(\"inngest.group.experiment\");\n\nexport type ExperimentStepTools = GetStepTools<Inngest.Any> & {\n  [experimentStepRunSymbol]: (\n    idOrOptions: StepOptionsOrId,\n    fn: () => unknown,\n  ) => Promise<unknown>;\n};\n\n/**\n * A generic set of step tools that can be used without typing information about\n * the client used to create them.\n *\n * These tools use AsyncLocalStorage to track the context in which they are\n * used, and will throw an error if used outside of an Inngest context.\n *\n * The intention of these high-level tools is to allow usage of Inngest step\n * tools within API endpoints, though they can still be used within regular\n * Inngest functions as well.\n */\nexport const step: GenericStepTools = {\n  // TODO Support `step.fetch` (this is already kinda half way deferred)\n  fetch: null as unknown as GenericStepTools[\"fetch\"],\n  ai: {\n    infer: (...args) =>\n      getDeferredStepTooling().then((tools) => tools.ai.infer(...args)),\n    wrap: (...args) =>\n      getDeferredStepTooling().then((tools) => tools.ai.wrap(...args)),\n    models: {\n      ...models,\n    },\n  },\n  invoke: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.invoke(...args)),\n  run: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.run(...args)),\n  sendEvent: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.sendEvent(...args)),\n  sendSignal: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.sendSignal(...args)),\n  sleep: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.sleep(...args)),\n  sleepUntil: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.sleepUntil(...args)),\n  waitForEvent: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.waitForEvent(...args)),\n  waitForSignal: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.waitForSignal(...args)),\n  realtime: {\n    publish: (...args) =>\n      getDeferredStepTooling().then((tools) => tools.realtime.publish(...args)),\n  },\n};\n\n/**\n * An internal function used to retrieve or create step tooling for the current\n * execution context.\n *\n * Note that this requires an existing context to create the step tooling;\n * something must declare the Inngest execution context before this can be used.\n */\nconst getDeferredStepTooling = async (): Promise<GenericStepTools> => {\n  const ctx = await getAsyncCtx();\n  if (!ctx) {\n    throw new Error(\n      \"`step` tools can only be used within Inngest function executions; no context was found\",\n    );\n  }\n\n  if (!ctx.app) {\n    throw new Error(\n      \"`step` tools can only be used within Inngest function executions; no Inngest client was found in the execution context\",\n    );\n  }\n\n  if (!ctx.execution) {\n    throw new Error(\n      \"`step` tools can only be used within Inngest function executions; no execution context was found\",\n    );\n  }\n\n  // If we're here, we're in the context of a function execution already and\n  // we can return the existing step tooling.\n  return ctx.execution.ctx.step;\n};\n\nconst getDeferredGroupTooling = async (): Promise<GroupTools> => {\n  const ctx = await getAsyncCtx();\n  if (!ctx) {\n    throw new Error(\n      \"`group` tools can only be used within Inngest function executions; no context was found\",\n    );\n  }\n\n  if (!ctx.execution) {\n    throw new Error(\n      \"`group` tools can only be used within Inngest function executions; no execution context was found\",\n    );\n  }\n\n  return ctx.execution.ctx.group;\n};\n\n/**\n * A deferred proxy for `group` tools that delegates through ALS context.\n *\n * @public\n */\nexport const group: GroupTools = {\n  parallel: (...args) =>\n    getDeferredGroupTooling().then((tools) => tools.parallel(...args)),\n  experiment: (...args) =>\n    getDeferredGroupTooling().then((tools) => tools.experiment(...args)),\n};\n\n/**\n * The event payload portion of the options for `step.invoke()`. This does not\n * include non-payload options like `timeout` or the function to invoke.\n */\nexport const invokePayloadSchema = z.object({\n  data: z.record(z.any()).optional(),\n  v: z.string().optional(),\n  meta: z\n    .object({\n      sessions: z.record(z.any()).optional(),\n    })\n    .optional(),\n});\n\ntype InvocationTargetOpts<TFunction extends InvokeTargetFunctionDefinition> = {\n  function: TFunction;\n};\n\ntype InvocationOpts<TFunction extends InvokeTargetFunctionDefinition> =\n  InvocationTargetOpts<TFunction> &\n    Omit<TriggerEventFromFunction<TFunction>, \"id\"> & {\n      /**\n       * Event meta shared with the invoked run.\n       *\n       * Meta is not inherited from the calling run; pass `meta.sessions`\n       * explicitly to group the invoked run. Values are normalized to strings\n       * before sending, as with `inngest.send()`.\n       */\n      meta?: EventMeta;\n\n      /**\n       * The step function will wait for the invocation to finish for a maximum\n       * of this time, at which point the retured promise will be rejected\n       * instead of resolved with the output of the invoked function.\n       *\n       * Note that the invoked function will continue to run even if this step\n       * times out.\n       *\n       * The time to wait can be specified using a `number` of milliseconds, an\n       * `ms`-compatible time string like `\"1 hour\"`, `\"30 mins\"`, or `\"2.5d\"`,\n       * a `Date`, a `Temporal.Duration` (relative wait), or a `Temporal.Instant`\n       * / `Temporal.ZonedDateTime` (absolute deadline).\n       *\n       * {@link https://npm.im/ms}\n       */\n      timeout?:\n        | number\n        | string\n        | Date\n        | Temporal.DurationLike\n        | Temporal.InstantLike\n        | Temporal.ZonedDateTimeLike;\n    };\n\n/**\n * A set of parameters given to a `sendSignal` call.\n */\ntype SendSignalOpts = {\n  /**\n   * The signal to send.\n   */\n  signal: string;\n\n  /**\n   * The data to send with the signal.\n   */\n  data?: unknown;\n};\n\n/**\n * A set of parameters given to a `waitForSignal` call.\n */\ntype WaitForSignalOpts = {\n  /**\n   * The signal to wait for.\n   */\n  signal: string;\n\n  /**\n   * The step function will wait for the signal for a maximum of this time, at\n   * which point the signal will be returned as `null` instead of any signal\n   * data.\n   *\n   * The time to wait can be specified using a `number` of milliseconds, an\n   * `ms`-compatible time string like `\"1 hour\"`, `\"30 mins\"`, or `\"2.5d\"`, a\n   * `Date`, a `Temporal.Duration` (relative wait), or a `Temporal.Instant` /\n   * `Temporal.ZonedDateTime` (absolute deadline).\n   *\n   * {@link https://npm.im/ms}\n   */\n  timeout:\n    | number\n    | string\n    | Date\n    | Temporal.DurationLike\n    | Temporal.InstantLike\n    | Temporal.ZonedDateTimeLike;\n\n  /**\n   * When this `step.waitForSignal()` call is made, choose whether an existing\n   * wait for the same signal should be replaced, or whether this run should\n   * fail.\n   *\n   * `\"replace\"` will replace any existing wait with this one, and the existing\n   * wait will remain pending until it reaches its timeout.\n   *\n   * `\"fail\"` will cause this run to fail if there is already a wait for the\n   * same signal.\n   */\n  onConflict: \"replace\" | \"fail\";\n};\n\n/**\n * Computes the return type for `waitForEvent` based on the options provided.\n *\n * Handles three cases:\n * 1. `event: EventType<TName, TSchema>` - extracts name and data from EventType\n * 2. `event: string` with `schema` - uses string as name and schema for data\n * 3. `event: string` without schema - uses string as name with untyped data\n */\ntype WaitForEventResult<TOpts> =\n  // Case 1: event is an EventType with a schema\n  TOpts extends {\n    event: EventType<\n      infer TName extends string,\n      StandardSchemaV1<infer TData extends Record<string, unknown>>\n    >;\n  }\n    ? {\n        name: TName;\n        data: TData;\n        id: string;\n        ts: number;\n        v?: string;\n        meta?: ReceivedEventMeta;\n      } | null\n    : // Case 2: event is an EventType without a schema\n      TOpts extends {\n          event: EventType<infer TName extends string, undefined>;\n        }\n      ? {\n          name: TName;\n          // biome-ignore lint/suspicious/noExplicitAny: fallback for untyped events\n          data: Record<string, any>;\n          id: string;\n          ts: number;\n          v?: string;\n          meta?: ReceivedEventMeta;\n        } | null\n      : // Case 3: event is a string with schema (spread EventType)\n        TOpts extends {\n            event: infer TName extends string;\n            schema: StandardSchemaV1<\n              infer TData extends Record<string, unknown>\n            >;\n          }\n        ? {\n            name: TName;\n            data: TData;\n            id: string;\n            ts: number;\n            v?: string;\n            meta?: ReceivedEventMeta;\n          } | null\n        : // Case 4: event is just a string\n          TOpts extends { event: infer TName extends string }\n          ? {\n              name: TName;\n              // biome-ignore lint/suspicious/noExplicitAny: fallback for untyped events\n              data: Record<string, any>;\n              id: string;\n              ts: number;\n              v?: string;\n              meta?: ReceivedEventMeta;\n            } | null\n          : EventPayload | null;\n\n/**\n * Options for `step.ai.infer()`.\n */\ntype AiInferOpts<TModel extends AiAdapter> = {\n  /**\n   * The model to use for the inference. Create a model by importing from\n   * `\"inngest\"` or by using `step.ai.models.*`.\n   *\n   * @example Import `openai()`\n   * ```ts\n   * import { openai } from \"inngest\";\n   *\n   * const model = openai({ model: \"gpt-4\" });\n   * ```\n   *\n   * @example Use a model from `step.ai.models`\n   * ```ts\n   * async ({ step }) => {\n   *            const model = step.ai.models.openai({ model: \"gpt-4\" });\n   * }\n   * ```\n   */\n  model: TModel;\n\n  /**\n   * The input to pass to the model.\n   */\n  body: AiAdapter.Input<TModel>;\n};\n"],"mappings":"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"}
+{"version":3,"file":"InngestStepTools.js","names":["wrappedMatchOp: MatchOpFn<T>","opts: HashedOp[\"opts\"]","createStepScoreWrapper: ScoreStepTool","matchOpts: { timeout: string; if?: string }","msTimeStr: string","Temporal.getISOString","v","Temporal.isTemporalDuration","Temporal.isTemporalInstant","Temporal.isTemporalZonedDateTime","opts: {\n        payload: typeof payload;\n        function_id: string;\n        timeout?: string;\n      }","stepFetch","headers: Record<string, string>","step: GenericStepTools","group: GroupTools"],"sources":["../../src/components/InngestStepTools.ts"],"sourcesContent":["import { type AiAdapter, models } from \"@inngest/ai\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { z } from \"zod/v3\";\n\nimport type { InngestApi } from \"../api/api.ts\";\nimport type { Jsonify } from \"../helpers/jsonify.ts\";\nimport { normalizeEventMeta } from \"../helpers/sessions.ts\";\nimport { timeStr } from \"../helpers/strings.ts\";\nimport * as Temporal from \"../helpers/temporal.ts\";\nimport type {\n  ExclusiveKeys,\n  ParametersExceptFirst,\n  SendEventPayload,\n} from \"../helpers/types.ts\";\nimport {\n  type ApplyAllMiddlewareTransforms,\n  type Context,\n  type EventMeta,\n  type EventPayload,\n  type HashedOp,\n  type InvocationResult,\n  type InvokeTargetFunctionDefinition,\n  type MinimalEventPayload,\n  type OutgoingOp,\n  type ReceivedEventMeta,\n  type SendEventOutput,\n  StepMode,\n  StepOpCode,\n  type StepOptions,\n  type StepOptionsOrId,\n  type TriggerEventFromFunction,\n} from \"../types.ts\";\nimport { getAsyncCtx, getAsyncCtxSync } from \"./execution/als.ts\";\nimport type { InngestExecution } from \"./execution/InngestExecution.ts\";\nimport { fetch as stepFetch } from \"./Fetch.ts\";\nimport {\n  type ClientOptionsFromInngest,\n  type GetFunctionOutputRaw,\n  type GetStepTools,\n  type Inngest,\n  internalLoggerSymbol,\n} from \"./Inngest.ts\";\nimport { InngestFunction } from \"./InngestFunction.ts\";\nimport { InngestFunctionReference } from \"./InngestFunctionReference.ts\";\nimport type { GroupTools } from \"./InngestGroupTools.ts\";\nimport {\n  type MetadataBuilder,\n  type MetadataStepTool,\n  metadataSymbol,\n  UnscopedMetadataBuilder,\n} from \"./InngestMetadata.ts\";\nimport {\n  type ScoreStepTool,\n  scoreSymbol,\n  sendStepScore,\n  validateStepScoreOptions,\n} from \"./InngestScore.ts\";\nimport type { Middleware } from \"./middleware/index.ts\";\nimport { NonRetriableError } from \"./NonRetriableError.ts\";\nimport type { Realtime } from \"./realtime/types.ts\";\nimport type { EventType } from \"./triggers/triggers.ts\";\n\n/**\n * Middleware context for a step, created during step registration.\n *\n * Uses a \"deferred handler\" pattern: the `wrapStep` middleware chain starts\n * during discovery (so middleware can inject its own steps), but the real\n * handler isn't known until after the memoization lookup. `setActualHandler`\n * bridges the gap — the chain blocks on a deferred promise that is resolved\n * once `executeStep` determines the real result.\n */\nexport interface StepMiddlewareContext {\n  /**\n   * Sets the handler that the middleware pipeline will eventually call.\n   * Called after memoization lookup to set either:\n   * - A handler returning memoized data, OR\n   * - A handler executing the step fresh\n   */\n  setActualHandler: (handler: () => Promise<unknown>) => void;\n\n  /**\n   * Step info after middleware transformations. The `options.id` may differ\n   * from the original if middleware modified it via `transformStepInput`.\n   */\n  stepInfo: Middleware.StepInfo;\n\n  /**\n   * The middleware pipeline entry point. Call this to execute the step\n   * through all middleware transformations.\n   */\n  wrappedHandler: () => Promise<unknown>;\n}\n\nexport interface FoundStep extends HashedOp {\n  hashedId: string;\n  fn?: (...args: unknown[]) => unknown;\n  rawArgs: unknown[];\n\n  /**\n   * A boolean representing whether the step has been fulfilled, either\n   * resolving or rejecting the `Promise` returned to userland code.\n   *\n   * Note that this is distinct from {@link hasStepState}, which instead tracks\n   * whether the step has been given some state from the Executor. State from\n   * the Executor could be data other than a resolution or rejection, such as\n   * inputs.\n   */\n  fulfilled: boolean;\n\n  /**\n   * A boolean representing whether the step has been given some state from the\n   * Executor. State from the Executor could be data other than a resolution or\n   * rejection, such as inputs.\n   *\n   * This is distinct from {@link fulfilled}, which instead tracks whether the\n   * step has been fulfilled, either resolving or rejecting the `Promise`\n   * returned to userland code.\n   */\n  hasStepState: boolean;\n\n  handled: boolean;\n\n  /**\n   * The promise that has been returned to userland code for this step.\n   */\n  promise: Promise<unknown>;\n\n  /**\n   * Returns a boolean representing whether or not the step was handled on this\n   * invocation.\n   */\n  handle: () => boolean;\n\n  // TODO This is used to track the input we want for this step. Might be\n  // present in ctx from Executor.\n  input?: unknown;\n\n  /**\n   * Middleware context for this step. Holds the `wrapStep` chain entry point\n   * and the deferred handler setter used by `executeStep`.\n   */\n  middleware: StepMiddlewareContext;\n\n  /**\n   * For new steps where wrappedHandler is called during discovery,\n   * this holds the resolve/reject to be called when the step's data is\n   * memoized. Resolved with server-transformed data (post-wrapStepHandler),\n   * which unblocks wrapStep's `next()`.\n   *\n   * Is undefined when any of the following is true:\n   * - The step is fulfilled\n   * - The step has no handler (`step.sleep`, `step.waitForSignal`, etc.)\n   */\n  memoizationDeferred?: {\n    resolve: (value: unknown) => void;\n    reject: (error: unknown) => void;\n  };\n\n  /**\n   * For new steps where `wrappedHandler` is called during discovery, this holds\n   * the promise for the wrapStep-transformed result. In checkpointing mode,\n   * handle() reuses this promise to avoid a duplicate wrapStep call.\n   */\n  transformedResultPromise?: Promise<unknown>;\n\n  /**\n   * Optional metadata updates attached to this step, carried through from\n   * the OutgoingOp so that checkpoint payloads include metadata.\n   */\n  metadata?: OutgoingOp[\"metadata\"];\n}\n\nexport type MatchOpFn<\n  T extends (...args: unknown[]) => Promise<unknown> = (\n    ...args: unknown[]\n  ) => Promise<unknown>,\n> = (\n  stepOptions: StepOptions,\n  /**\n   * Arguments passed by the user.\n   */\n  ...args: ParametersExceptFirst<T>\n) => Omit<HashedOp, \"data\" | \"error\">;\n\nexport type StepHandler = (info: {\n  matchOp: MatchOpFn;\n  opts?: StepToolOptions;\n  args: [StepOptionsOrId, ...unknown[]];\n}) => Promise<unknown>;\n\nexport interface StepToolOptions<\n  T extends (...args: unknown[]) => Promise<unknown> = (\n    ...args: unknown[]\n  ) => Promise<unknown>,\n> {\n  /**\n   * Optionally, we can also provide a function that will be called when\n   * Inngest tells us to run this operation.\n   *\n   * If this function is defined, the first time the tool is used it will\n   * report the desired operation (including options) to the Inngest. Inngest\n   * will then call back to the function to tell it to run the step and then\n   * retrieve data.\n   *\n   * We do this in order to allow functionality such as per-step retries; this\n   * gives the SDK the opportunity to tell Inngest what it wants to do before\n   * it does it.\n   *\n   * This function is passed the arguments passed by the user. It will be run\n   * when we receive an operation matching this one that does not contain a\n   * `data` property.\n   */\n  fn?: (...args: [Context.Any, ...Parameters<T>]) => unknown;\n}\n\nexport const getStepOptions = (options: StepOptionsOrId): StepOptions => {\n  if (typeof options === \"string\") {\n    return { id: options };\n  }\n\n  return options;\n};\n\n/**\n * Suffix used to namespace steps that are automatically indexed.\n */\nexport const STEP_INDEXING_SUFFIX = \":\";\n\n/**\n * Create a new set of step function tools ready to be used in a step function.\n * This function should be run and a fresh set of tools provided every time a\n * function is run.\n *\n * An op stack (function state) is passed in as well as some mutable properties\n * that the tools can use to submit a new op.\n */\n/**\n * Merge client-level and function-level middleware into a single array type\n * for use with ApplyAllMiddlewareTransforms etc.\n */\ntype MergedMiddleware<\n  TClient extends Inngest.Any,\n  TFnMiddleware extends Middleware.Class[] | undefined,\n> = [\n  ...(ClientOptionsFromInngest<TClient>[\"middleware\"] extends Middleware.Class[]\n    ? ClientOptionsFromInngest<TClient>[\"middleware\"]\n    : []),\n  ...(TFnMiddleware extends Middleware.Class[] ? TFnMiddleware : []),\n];\n\nexport const createStepTools = <\n  TClient extends Inngest.Any,\n  TFnMiddleware extends Middleware.Class[] | undefined = undefined,\n>(\n  client: TClient,\n  execution: InngestExecution,\n  stepHandler: StepHandler,\n) => {\n  /**\n   * A local helper used to create tools that can be used to submit an op.\n   *\n   * When using this function, a generic type should be provided which is the\n   * function signature exposed to the user.\n   */\n  // biome-ignore lint/suspicious/noExplicitAny: intentional\n  const createTool = <T extends (...args: any[]) => Promise<unknown>>(\n    /**\n     * A function that returns an ID for this op. This is used to ensure that\n     * the op stack is correctly filled, submitted, and retrieved with the same\n     * ID.\n     *\n     * It is passed the arguments passed by the user.\n     *\n     * Most simple tools will likely only need to define this.\n     */\n    matchOp: MatchOpFn<T>,\n    opts?: StepToolOptions<T>,\n  ): T => {\n    const wrappedMatchOp: MatchOpFn<T> = (stepOptions, ...rest) => {\n      const op = matchOp(stepOptions, ...rest);\n\n      const alsCtx = getAsyncCtxSync()?.execution;\n\n      if (alsCtx?.insideExperimentSelect) {\n        throw new NonRetriableError(\n          \"Step tools (step.run, step.sleep, etc.) cannot be called inside \" +\n            \"an experiment select() callback. Move step calls into variant \" +\n            \"callbacks instead.\",\n        );\n      }\n\n      // Explicit option takes precedence, then check ALS context\n      const parallelMode = stepOptions.parallelMode ?? alsCtx?.parallelMode;\n\n      if (parallelMode) {\n        op.opts = { ...op.opts, parallelMode };\n      }\n\n      // Propagate experiment context to variant sub-steps\n      const experimentContext = alsCtx?.experimentContext;\n      if (experimentContext) {\n        op.opts = { ...op.opts, ...experimentContext };\n      }\n\n      // Track that a step tool was invoked inside a variant callback\n      const tracker = alsCtx?.experimentStepTracker;\n      if (tracker) {\n        tracker.found = true;\n      }\n\n      return op;\n    };\n\n    return (async (...args: Parameters<T>): Promise<unknown> => {\n      const parsedArgs = args as unknown as [StepOptionsOrId, ...unknown[]];\n      return stepHandler({ args: parsedArgs, matchOp: wrappedMatchOp, opts });\n    }) as T;\n  };\n\n  /**\n   * Create a new step run tool that can be used to run a step function using\n   * `step.run()` as a shim.\n   */\n  const createStepRun = (\n    /**\n     * The sub-type of this step tool, exposed via `opts.type` when the op is\n     * reported.\n     */\n    type?: string,\n  ) => {\n    return createTool<\n      // biome-ignore lint/suspicious/noExplicitAny: intentional\n      <TFn extends (...args: any[]) => unknown>(\n        idOrOptions: StepOptionsOrId,\n\n        /**\n         * The function to run when this step is executed. Can be synchronous or\n         * asynchronous.\n         *\n         * The return value of this function will be the return value of this\n         * call to `run`, meaning you can return and reason about return data\n         * for next steps.\n         */\n        fn: TFn,\n\n        /**\n         * Optional input to pass to the function. If this is specified, Inngest\n         * will keep track of the input for this step and be able to display it\n         * in the UI.\n         */\n        ...input: Parameters<TFn>\n      ) => Promise<\n        ApplyAllMiddlewareTransforms<\n          MergedMiddleware<TClient, TFnMiddleware>,\n          TFn extends (...args: Parameters<TFn>) => Promise<infer U>\n            ? Awaited<U extends void ? null : U>\n            : ReturnType<TFn> extends void\n              ? null\n              : ReturnType<TFn>\n        >\n      >\n    >(\n      ({ id, name }, _fn, ...input) => {\n        const opts: HashedOp[\"opts\"] = {\n          ...(input.length ? { input } : {}),\n          ...(type ? { type } : {}),\n        };\n\n        return {\n          id,\n          mode: StepMode.Sync,\n          op: StepOpCode.StepPlanned,\n          name: id,\n          displayName: name ?? id,\n          ...(Object.keys(opts).length ? { opts } : {}),\n          userland: { id },\n        };\n      },\n      {\n        fn: (_, __, fn, ...input) => fn(...input),\n      },\n    );\n  };\n\n  /**\n   * Creates a metadata builder wrapper for step.metadata(\"id\").\n   * Uses MetadataBuilder for config accumulation, but wraps .update() in tools.run() for memoization.\n   */\n  const createStepMetadataWrapper = (\n    memoizationId: string,\n    builder?: UnscopedMetadataBuilder,\n  ) => {\n    if (!client[\"experimentalMetadataEnabled\"]) {\n      throw new Error(\n        'step.metadata() is experimental. Enable it by adding metadataMiddleware() from \"inngest/experimental\" to your client middleware.',\n      );\n    }\n    const withBuilder = (next: UnscopedMetadataBuilder) =>\n      createStepMetadataWrapper(memoizationId, next);\n\n    if (!builder) {\n      builder = new UnscopedMetadataBuilder(client).run();\n    }\n\n    return {\n      run: (runId?: string) => withBuilder(builder.run(runId)),\n      step: (stepId: string, index?: number) =>\n        withBuilder(builder.step(stepId, index)),\n      attempt: (attemptIndex: number) =>\n        withBuilder(builder.attempt(attemptIndex)),\n      span: (spanId: string) => withBuilder(builder.span(spanId)),\n      update: async (\n        values: Record<string, unknown>,\n        kind = \"default\",\n      ): Promise<void> => {\n        await tools.run(memoizationId, async () => {\n          await builder.update(values, kind);\n        });\n      },\n\n      do: async (\n        fn: (builder: MetadataBuilder) => Promise<void>,\n      ): Promise<void> => {\n        await tools.run(memoizationId, async () => {\n          await fn(builder);\n        });\n      },\n    };\n  };\n\n  const createStepScoreWrapper: ScoreStepTool = async (\n    memoizationId,\n    options,\n  ) => {\n    if (!client[\"experimentalScoreEnabled\"]) {\n      // This is a config error, so retrying the function cannot fix it\n      throw new NonRetriableError(\n        'step.score() is experimental. Enable it by adding scoreMiddleware() from \"inngest/experimental\" to your client middleware.',\n      );\n    }\n\n    validateStepScoreOptions(options);\n\n    await tools.run(memoizationId, async () => {\n      await sendStepScore(client, options);\n    });\n  };\n\n  /**\n   * Define the set of tools the user has access to for their step functions.\n   *\n   * Each key is the function name and is expected to run `createTool` and pass\n   * a generic type for that function as it will appear in the user's code.\n   */\n  const tools = {\n    /**\n     * Send one or many events to Inngest. Should always be used in place of\n     * `inngest.send()` to ensure that the event send is successfully retried\n     * and not sent multiple times due to memoisation.\n     *\n     * @example\n     * ```ts\n     * await step.sendEvent(\"emit-user-creation\", {\n     *   name: \"app/user.created\",\n     *   data: { id: 123 },\n     * });\n     *\n     * await step.sendEvent(\"emit-user-updates\", [\n     *   {\n     *     name: \"app/user.created\",\n     *     data: { id: 123 },\n     *   },\n     *   {\n     *     name: \"app/user.feed.created\",\n     *     data: { id: 123 },\n     *   },\n     * ]);\n     * ```\n     *\n     * Returns a promise that will resolve once the event has been sent.\n     */\n    sendEvent: createTool<\n      (\n        idOrOptions: StepOptionsOrId,\n        payload: SendEventPayload,\n      ) => Promise<SendEventOutput<ClientOptionsFromInngest<TClient>>>\n    >(\n      ({ id, name }) => {\n        return {\n          id,\n          mode: StepMode.Sync,\n          op: StepOpCode.StepPlanned,\n          name: \"sendEvent\",\n          displayName: name ?? id,\n          opts: {\n            type: \"step.sendEvent\",\n          },\n          userland: { id },\n        };\n      },\n      {\n        fn: (_ctx, _idOrOptions, payload) => {\n          const fn = execution[\"options\"][\"fn\"];\n          return client[\"_send\"]({\n            payload,\n            headers: execution[\"options\"][\"headers\"],\n            fnMiddleware: fn.opts.middleware ?? [],\n            fn,\n          });\n        },\n      },\n    ),\n\n    /**\n     * EXPERIMENTAL: This API is not yet stable and may change in the future\n     * without a major version bump.\n     *\n     * Wait for a particular signal to be received before continuing. When the\n     * signal is received, its data will be returned.\n     */\n    waitForSignal: createTool<\n      <TData>(\n        idOrOptions: StepOptionsOrId,\n        opts: WaitForSignalOpts,\n      ) => Promise<{ signal: string; data: Jsonify<TData> } | null>\n    >(({ id, name }, opts) => {\n      return {\n        id,\n        mode: StepMode.Async,\n        op: StepOpCode.WaitForSignal,\n        name: opts.signal,\n        displayName: name ?? id,\n        opts: {\n          signal: opts.signal,\n          timeout: timeStr(opts.timeout),\n          conflict: opts.onConflict,\n        },\n        userland: { id },\n      };\n    }),\n\n    /**\n     * Step-level functionality related to realtime features.\n     *\n     * Unlike client-level realtime methods (`inngest.realtime.*`), these tools\n     * will be their own durable steps when run. If you wish to use realtime\n     * features outside of a step, make sure to use the client-level methods\n     * instead.\n     */\n    realtime: {\n      /**\n       * Publish a realtime message as a durable step. Memoized and will not\n       * re-fire on retry, unlike client-level `inngest.realtime.publish()`.\n       *\n       * Uses topic accessors: `step.realtime.publish(\"id\", chat.status, data)`\n       */\n      publish: createTool<\n        <TData>(\n          idOrOptions: StepOptionsOrId,\n          topicRef: Realtime.TopicRef<TData>,\n          data: TData,\n        ) => Promise<TData>\n      >(\n        ({ id, name }) => {\n          return {\n            id,\n            mode: StepMode.Sync,\n            op: StepOpCode.StepPlanned,\n            displayName: name ?? id,\n            opts: {\n              type: \"step.realtime.publish\",\n            },\n            userland: { id },\n          };\n        },\n        {\n          fn: async (ctx, _idOrOptions, topicRef, data) => {\n            const topicConfig = topicRef.config;\n            if (topicConfig && \"schema\" in topicConfig && topicConfig.schema) {\n              const result =\n                await topicConfig.schema[\"~standard\"].validate(data);\n              if (result.issues) {\n                throw new Error(\n                  `Schema validation failed for topic \"${topicRef.topic}\"`,\n                );\n              }\n            }\n\n            const res = await client[\"inngestApi\"].publish(\n              {\n                topics: [topicRef.topic],\n                channel: topicRef.channel,\n                runId: ctx.runId,\n              },\n              data,\n            );\n\n            if (!res.ok) {\n              throw new Error(\n                `Failed to publish to realtime: ${res.error?.error || \"Unknown error\"}`,\n              );\n            }\n\n            return data;\n          },\n        },\n      ),\n    },\n\n    /**\n     * Send a Signal to Inngest.\n     */\n    sendSignal: createTool<\n      (\n        idOrOptions: StepOptionsOrId,\n        opts: SendSignalOpts,\n      ) => Promise<InngestApi.SendSignalResponse>\n    >(\n      ({ id, name }, opts) => {\n        return {\n          id,\n          mode: StepMode.Sync,\n          op: StepOpCode.StepPlanned,\n          name: \"sendSignal\",\n          displayName: name ?? id,\n          opts: {\n            type: \"step.sendSignal\",\n            signal: opts.signal,\n          },\n          userland: { id },\n        };\n      },\n      {\n        fn: (_ctx, _idOrOptions, opts) => {\n          return client[\"_sendSignal\"]({\n            signal: opts.signal,\n            data: opts.data,\n            headers: execution[\"options\"][\"headers\"],\n          });\n        },\n      },\n    ),\n\n    /**\n     * Wait for a particular event to be received before continuing. When the\n     * event is received, it will be returned.\n     *\n     * You can also provide options to control the particular event that is\n     * received, for example to ensure that a user ID matches between two\n     * events, or to only wait a maximum amount of time before giving up and\n     * returning `null` instead of any event data.\n     */\n    waitForEvent: createTool<\n      <\n        TOpts extends {\n          /**\n           * The event to wait for.\n           */\n          event:\n            | string\n            // biome-ignore lint/suspicious/noExplicitAny: Allow any schema\n            | EventType<string, any>;\n\n          /**\n           * The step function will wait for the event for a maximum of this\n           * time, at which point the signal will be returned as `null` instead\n           * of any signal data.\n           *\n           * The time to wait can be specified using a `number` of milliseconds,\n           * an `ms`-compatible time string like `\"1 hour\"`, `\"30 mins\"`, or\n           * `\"2.5d\"`, a `Date`, a `Temporal.Duration` (relative wait), or a\n           * `Temporal.Instant` / `Temporal.ZonedDateTime` (absolute deadline).\n           *\n           * {@link https://npm.im/ms}\n           */\n          timeout:\n            | number\n            | string\n            | Date\n            | Temporal.DurationLike\n            | Temporal.InstantLike\n            | Temporal.ZonedDateTimeLike;\n        } & ExclusiveKeys<{ match?: string; if?: string }, \"match\", \"if\">,\n      >(\n        idOrOptions: StepOptionsOrId,\n        opts: TOpts,\n      ) => Promise<WaitForEventResult<TOpts>>\n    >(\n      (\n        { id, name },\n\n        /**\n         * Options to control the event we're waiting for.\n         */\n        opts,\n      ) => {\n        const matchOpts: { timeout: string; if?: string } = {\n          timeout: timeStr(typeof opts === \"string\" ? opts : opts.timeout),\n        };\n\n        if (typeof opts !== \"string\") {\n          if (opts?.match) {\n            matchOpts.if = `event.${opts.match} == async.${opts.match}`;\n          } else if (opts?.if) {\n            matchOpts.if = opts.if;\n          }\n        }\n\n        // Extract event name from string or EventType object\n        const eventName =\n          typeof opts.event === \"string\" ? opts.event : opts.event.name;\n\n        return {\n          id,\n          mode: StepMode.Async,\n          op: StepOpCode.WaitForEvent,\n          name: eventName,\n          opts: matchOpts,\n          displayName: name ?? id,\n          userland: { id },\n        };\n      },\n    ),\n\n    /**\n     * Use this tool to run business logic. Each call to `run` will be retried\n     * individually, meaning you can compose complex workflows that safely\n     * retry dependent asynchronous actions.\n     *\n     * The function you pass to `run` will be called only when this \"step\" is to\n     * be executed and can be synchronous or asynchronous.\n     *\n     * In either case, the return value of the function will be the return value\n     * of the `run` tool, meaning you can return and reason about return data\n     * for next steps.\n     */\n    run: createStepRun(),\n\n    /**\n     * AI tooling for running AI models and other AI-related tasks.\n     */\n    ai: {\n      /**\n       * Use this tool to have Inngest make your AI calls. Useful for agentic workflows.\n       *\n       * Input is also tracked for this tool, meaning you can pass input to the\n       * function and it will be displayed and editable in the UI.\n       */\n      infer: createTool<\n        <TAdapter extends AiAdapter>(\n          idOrOptions: StepOptionsOrId,\n          options: AiInferOpts<TAdapter>,\n        ) => Promise<AiAdapter.Output<TAdapter>>\n      >(({ id, name }, options) => {\n        // eslint-disable-next-line\n        const { model, body, ...rest } = options;\n\n        const modelCopy = { ...model };\n\n        // Allow the model to mutate options and body for this call\n        options.model.onCall?.(modelCopy, options.body);\n\n        return {\n          id,\n          mode: StepMode.Async,\n          op: StepOpCode.AiGateway,\n          displayName: name ?? id,\n          opts: {\n            type: \"step.ai.infer\",\n            url: modelCopy.url,\n            headers: modelCopy.headers,\n            auth_key: modelCopy.authKey,\n            format: modelCopy.format,\n            // eslint-disable-next-line\n            body,\n            // eslint-disable-next-line\n            ...rest,\n          },\n          userland: { id },\n        };\n      }),\n\n      /**\n       * Use this tool to wrap AI models and other AI-related tasks. Each call\n       * to `wrap` will be retried individually, meaning you can compose complex\n       * workflows that safely retry dependent asynchronous actions.\n       *\n       * Input is also tracked for this tool, meaning you can pass input to the\n       * function and it will be displayed and editable in the UI.\n       */\n      wrap: createStepRun(\"step.ai.wrap\"),\n\n      /**\n       * Models for AI inference and other AI-related tasks.\n       */\n      models: {\n        ...models,\n      },\n    },\n\n    /**\n     * Wait a specified amount of time before continuing.\n     *\n     * The time to wait can be specified using a `number` of milliseconds or an\n     * `ms`-compatible time string like `\"1 hour\"`, `\"30 mins\"`, or `\"2.5d\"`.\n     *\n     * {@link https://npm.im/ms}\n     *\n     * To wait until a particular date, use `sleepUntil` instead.\n     */\n    sleep: createTool<\n      (\n        idOrOptions: StepOptionsOrId,\n\n        /**\n         * The amount of time to wait before continuing.\n         */\n        time: number | string | Temporal.DurationLike,\n      ) => Promise<void>\n    >(({ id, name }, time) => {\n      /**\n       * The presence of this operation in the returned stack indicates that the\n       * sleep is over and we should continue execution.\n       */\n      const msTimeStr: string = timeStr(time);\n\n      return {\n        id,\n        mode: StepMode.Async,\n        op: StepOpCode.Sleep,\n        name: msTimeStr,\n        displayName: name ?? id,\n        userland: { id },\n      };\n    }),\n\n    /**\n     * Wait until a particular date before continuing by passing a `Date`.\n     *\n     * To wait for a particular amount of time from now, always use `sleep`\n     * instead.\n     */\n    sleepUntil: createTool<\n      (\n        idOrOptions: StepOptionsOrId,\n\n        /**\n         * The date to wait until before continuing.\n         */\n        time: Date | string | Temporal.InstantLike | Temporal.ZonedDateTimeLike,\n      ) => Promise<void>\n    >(({ id, name }, time) => {\n      try {\n        const iso = Temporal.getISOString(time);\n\n        /**\n         * The presence of this operation in the returned stack indicates that the\n         * sleep is over and we should continue execution.\n         */\n        return {\n          id,\n          mode: StepMode.Async,\n          op: StepOpCode.Sleep,\n          name: iso,\n          displayName: name ?? id,\n          userland: { id },\n        };\n      } catch (err) {\n        /**\n         * If we're here, it's because the date is invalid. We'll throw a custom\n         * error here to standardise this response.\n         */\n        client[internalLoggerSymbol].warn(\n          { err },\n          \"Invalid `Date`, date string, `Temporal.Instant`, or `Temporal.ZonedDateTime` passed to sleepUntil\",\n        );\n\n        throw new Error(\n          `Invalid \\`Date\\`, date string, \\`Temporal.Instant\\`, or \\`Temporal.ZonedDateTime\\` passed to sleepUntil: ${\n            time\n          }`,\n        );\n      }\n    }),\n\n    /**\n     * Invoke a passed Inngest `function` with the given `data`. Returns the\n     * result of the returned value of the function or `null` if the function\n     * does not return a value.\n     */\n    invoke: createTool<\n      <TFunction extends InvokeTargetFunctionDefinition>(\n        idOrOptions: StepOptionsOrId,\n        opts: InvocationOpts<TFunction>,\n      ) => InvocationResult<\n        ApplyAllMiddlewareTransforms<\n          MergedMiddleware<TClient, TFnMiddleware>,\n          GetFunctionOutputRaw<TFunction>,\n          \"functionOutputTransform\"\n        >\n      >\n    >(({ id, name }, invokeOpts) => {\n      // Create a discriminated union to operate on based on the input types\n      // available for this tool.\n      const optsSchema = invokePayloadSchema.extend({\n        timeout: z\n          .custom<\n            | number\n            | string\n            | Date\n            | Temporal.DurationLike\n            | Temporal.InstantLike\n            | Temporal.ZonedDateTimeLike\n          >(\n            (v) =>\n              typeof v === \"number\" ||\n              typeof v === \"string\" ||\n              v instanceof Date ||\n              Temporal.isTemporalDuration(v) ||\n              Temporal.isTemporalInstant(v) ||\n              Temporal.isTemporalZonedDateTime(v),\n            { message: \"Invalid timeout\" },\n          )\n          .optional(),\n      });\n\n      const parsedFnOpts = optsSchema\n        .extend({\n          _type: z.literal(\"fnInstance\").optional().default(\"fnInstance\"),\n          function: z.instanceof(InngestFunction),\n        })\n        .or(\n          optsSchema.extend({\n            _type: z.literal(\"refInstance\").optional().default(\"refInstance\"),\n            function: z.instanceof(InngestFunctionReference),\n          }),\n        )\n        .safeParse(invokeOpts);\n\n      if (!parsedFnOpts.success) {\n        throw new Error(\n          `Invalid invocation options passed to invoke; must include a function instance or referenceFunction().`,\n        );\n      }\n\n      const { _type, function: fn, data, v, meta, timeout } = parsedFnOpts.data;\n      const payload = {\n        data,\n        v,\n        meta: normalizeEventMeta(meta),\n      } satisfies MinimalEventPayload;\n      const opts: {\n        payload: typeof payload;\n        function_id: string;\n        timeout?: string;\n      } = {\n        payload,\n        function_id: \"\",\n        timeout: typeof timeout === \"undefined\" ? undefined : timeStr(timeout),\n      };\n\n      switch (_type) {\n        case \"fnInstance\":\n          opts.function_id = fn.id(fn[\"client\"].id);\n          break;\n\n        case \"refInstance\":\n          opts.function_id = [fn.opts.appId || client.id, fn.opts.functionId]\n            .filter(Boolean)\n            .join(\"-\");\n          break;\n      }\n\n      return {\n        id,\n        mode: StepMode.Async,\n        op: StepOpCode.InvokeFunction,\n        displayName: name ?? id,\n        opts,\n        userland: { id },\n      };\n    }),\n\n    /**\n     * `step.fetch` is a Fetch-API-compatible function that can be used to make\n     * any HTTP code durable if it's called within an Inngest function.\n     *\n     * It will gracefully fall back to the global `fetch` if called outside of\n     * this context, and a custom fallback can be set using the `config` method.\n     */\n    fetch: stepFetch,\n  };\n\n  // NOTE: This should be moved into the above object definition under the key\n  // \"metadata\" when metadata is made non-experimental.\n  (tools as unknown as ExperimentalStepTools)[metadataSymbol] = (\n    memoizationId: string,\n  ): MetadataStepTool => createStepMetadataWrapper(memoizationId);\n  (tools as unknown as ExperimentalStepTools)[scoreSymbol] =\n    createStepScoreWrapper;\n\n  // Attach a step.run variant with opts.type = \"group.experiment\" for use by\n  // group.experiment(). The symbol keeps it off the public `step` surface.\n  (tools as unknown as ExperimentStepTools)[experimentStepRunSymbol] =\n    createStepRun(\"group.experiment\");\n\n  // Add an uptyped gateway\n  (tools as unknown as InternalStepTools)[gatewaySymbol] = createTool(\n    ({ id, name }, input, init) => {\n      const url = input instanceof Request ? input.url : input.toString();\n\n      const headers: Record<string, string> = {};\n      if (input instanceof Request) {\n        input.headers.forEach((value, key) => {\n          headers[key] = value;\n        });\n      } else if (init?.headers) {\n        const h = new Headers(init.headers);\n        h.forEach((value, key) => {\n          headers[key] = value;\n        });\n      }\n\n      return {\n        id,\n        mode: StepMode.Async,\n        op: StepOpCode.Gateway,\n        displayName: name ?? id,\n        opts: {\n          url,\n          method: init?.method ?? \"GET\",\n          headers,\n          body: init?.body,\n        },\n        userland: { id },\n      };\n    },\n  );\n\n  return tools;\n};\n\n/**\n * A generic set of step tools, without typing information about the client used\n * to create them.\n */\nexport type GenericStepTools = GetStepTools<Inngest.Any>;\n\nexport const gatewaySymbol = Symbol.for(\"inngest.step.gateway\");\n\nexport type InternalStepTools = GetStepTools<Inngest.Any> & {\n  [gatewaySymbol]: (\n    idOrOptions: StepOptionsOrId,\n    ...args: Parameters<typeof fetch>\n  ) => Promise<{\n    status_code: number;\n    headers: Record<string, string>;\n    body: string;\n  }>;\n};\n\nexport type ExperimentalStepTools = GetStepTools<Inngest.Any> & {\n  [metadataSymbol]: (memoizationId: string) => MetadataStepTool;\n  [scoreSymbol]: ScoreStepTool;\n};\n\nexport const experimentStepRunSymbol = Symbol.for(\"inngest.group.experiment\");\n\nexport type ExperimentStepTools = GetStepTools<Inngest.Any> & {\n  [experimentStepRunSymbol]: (\n    idOrOptions: StepOptionsOrId,\n    fn: () => unknown,\n  ) => Promise<unknown>;\n};\n\n/**\n * A generic set of step tools that can be used without typing information about\n * the client used to create them.\n *\n * These tools use AsyncLocalStorage to track the context in which they are\n * used, and will throw an error if used outside of an Inngest context.\n *\n * The intention of these high-level tools is to allow usage of Inngest step\n * tools within API endpoints, though they can still be used within regular\n * Inngest functions as well.\n */\nexport const step: GenericStepTools = {\n  // TODO Support `step.fetch` (this is already kinda half way deferred)\n  fetch: null as unknown as GenericStepTools[\"fetch\"],\n  ai: {\n    infer: (...args) =>\n      getDeferredStepTooling().then((tools) => tools.ai.infer(...args)),\n    wrap: (...args) =>\n      getDeferredStepTooling().then((tools) => tools.ai.wrap(...args)),\n    models: {\n      ...models,\n    },\n  },\n  invoke: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.invoke(...args)),\n  run: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.run(...args)),\n  sendEvent: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.sendEvent(...args)),\n  sendSignal: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.sendSignal(...args)),\n  sleep: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.sleep(...args)),\n  sleepUntil: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.sleepUntil(...args)),\n  waitForEvent: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.waitForEvent(...args)),\n  waitForSignal: (...args) =>\n    getDeferredStepTooling().then((tools) => tools.waitForSignal(...args)),\n  realtime: {\n    publish: (...args) =>\n      getDeferredStepTooling().then((tools) => tools.realtime.publish(...args)),\n  },\n};\n\n/**\n * An internal function used to retrieve or create step tooling for the current\n * execution context.\n *\n * Note that this requires an existing context to create the step tooling;\n * something must declare the Inngest execution context before this can be used.\n */\nconst getDeferredStepTooling = async (): Promise<GenericStepTools> => {\n  const ctx = await getAsyncCtx();\n  if (!ctx) {\n    throw new Error(\n      \"`step` tools can only be used within Inngest function executions; no context was found\",\n    );\n  }\n\n  if (!ctx.app) {\n    throw new Error(\n      \"`step` tools can only be used within Inngest function executions; no Inngest client was found in the execution context\",\n    );\n  }\n\n  if (!ctx.execution) {\n    throw new Error(\n      \"`step` tools can only be used within Inngest function executions; no execution context was found\",\n    );\n  }\n\n  // If we're here, we're in the context of a function execution already and\n  // we can return the existing step tooling.\n  return ctx.execution.ctx.step;\n};\n\nconst getDeferredGroupTooling = async (): Promise<GroupTools> => {\n  const ctx = await getAsyncCtx();\n  if (!ctx) {\n    throw new Error(\n      \"`group` tools can only be used within Inngest function executions; no context was found\",\n    );\n  }\n\n  if (!ctx.execution) {\n    throw new Error(\n      \"`group` tools can only be used within Inngest function executions; no execution context was found\",\n    );\n  }\n\n  return ctx.execution.ctx.group;\n};\n\n/**\n * A deferred proxy for `group` tools that delegates through ALS context.\n *\n * @public\n */\nexport const group: GroupTools = {\n  parallel: (...args) =>\n    getDeferredGroupTooling().then((tools) => tools.parallel(...args)),\n  experiment: (...args) =>\n    getDeferredGroupTooling().then((tools) => tools.experiment(...args)),\n};\n\n/**\n * The event payload portion of the options for `step.invoke()`. This does not\n * include non-payload options like `timeout` or the function to invoke.\n */\nexport const invokePayloadSchema = z.object({\n  data: z.record(z.any()).optional(),\n  v: z.string().optional(),\n  meta: z\n    .object({\n      sessions: z.record(z.any()).optional(),\n    })\n    .optional(),\n});\n\ntype InvocationTargetOpts<TFunction extends InvokeTargetFunctionDefinition> = {\n  function: TFunction;\n};\n\ntype InvocationOpts<TFunction extends InvokeTargetFunctionDefinition> =\n  InvocationTargetOpts<TFunction> &\n    Omit<TriggerEventFromFunction<TFunction>, \"id\"> & {\n      /**\n       * Event meta shared with the invoked run.\n       *\n       * Meta is not inherited from the calling run; pass `meta.sessions`\n       * explicitly to group the invoked run. Values are normalized to strings\n       * before sending, as with `inngest.send()`.\n       */\n      meta?: EventMeta;\n\n      /**\n       * The step function will wait for the invocation to finish for a maximum\n       * of this time, at which point the retured promise will be rejected\n       * instead of resolved with the output of the invoked function.\n       *\n       * Note that the invoked function will continue to run even if this step\n       * times out.\n       *\n       * The time to wait can be specified using a `number` of milliseconds, an\n       * `ms`-compatible time string like `\"1 hour\"`, `\"30 mins\"`, or `\"2.5d\"`,\n       * a `Date`, a `Temporal.Duration` (relative wait), or a `Temporal.Instant`\n       * / `Temporal.ZonedDateTime` (absolute deadline).\n       *\n       * {@link https://npm.im/ms}\n       */\n      timeout?:\n        | number\n        | string\n        | Date\n        | Temporal.DurationLike\n        | Temporal.InstantLike\n        | Temporal.ZonedDateTimeLike;\n    };\n\n/**\n * A set of parameters given to a `sendSignal` call.\n */\ntype SendSignalOpts = {\n  /**\n   * The signal to send.\n   */\n  signal: string;\n\n  /**\n   * The data to send with the signal.\n   */\n  data?: unknown;\n};\n\n/**\n * A set of parameters given to a `waitForSignal` call.\n */\ntype WaitForSignalOpts = {\n  /**\n   * The signal to wait for.\n   */\n  signal: string;\n\n  /**\n   * The step function will wait for the signal for a maximum of this time, at\n   * which point the signal will be returned as `null` instead of any signal\n   * data.\n   *\n   * The time to wait can be specified using a `number` of milliseconds, an\n   * `ms`-compatible time string like `\"1 hour\"`, `\"30 mins\"`, or `\"2.5d\"`, a\n   * `Date`, a `Temporal.Duration` (relative wait), or a `Temporal.Instant` /\n   * `Temporal.ZonedDateTime` (absolute deadline).\n   *\n   * {@link https://npm.im/ms}\n   */\n  timeout:\n    | number\n    | string\n    | Date\n    | Temporal.DurationLike\n    | Temporal.InstantLike\n    | Temporal.ZonedDateTimeLike;\n\n  /**\n   * When this `step.waitForSignal()` call is made, choose whether an existing\n   * wait for the same signal should be replaced, or whether this run should\n   * fail.\n   *\n   * `\"replace\"` will replace any existing wait with this one, and the existing\n   * wait will remain pending until it reaches its timeout.\n   *\n   * `\"fail\"` will cause this run to fail if there is already a wait for the\n   * same signal.\n   */\n  onConflict: \"replace\" | \"fail\";\n};\n\n/**\n * Computes the return type for `waitForEvent` based on the options provided.\n *\n * Handles three cases:\n * 1. `event: EventType<TName, TSchema>` - extracts name and data from EventType\n * 2. `event: string` with `schema` - uses string as name and schema for data\n * 3. `event: string` without schema - uses string as name with untyped data\n */\ntype WaitForEventResult<TOpts> =\n  // Case 1: event is an EventType with a schema\n  TOpts extends {\n    event: EventType<\n      infer TName extends string,\n      StandardSchemaV1<infer TData extends Record<string, unknown>>\n    >;\n  }\n    ? {\n        name: TName;\n        data: TData;\n        id: string;\n        ts: number;\n        v?: string;\n        meta?: ReceivedEventMeta;\n      } | null\n    : // Case 2: event is an EventType without a schema\n      TOpts extends {\n          event: EventType<infer TName extends string, undefined>;\n        }\n      ? {\n          name: TName;\n          // biome-ignore lint/suspicious/noExplicitAny: fallback for untyped events\n          data: Record<string, any>;\n          id: string;\n          ts: number;\n          v?: string;\n          meta?: ReceivedEventMeta;\n        } | null\n      : // Case 3: event is a string with schema (spread EventType)\n        TOpts extends {\n            event: infer TName extends string;\n            schema: StandardSchemaV1<\n              infer TData extends Record<string, unknown>\n            >;\n          }\n        ? {\n            name: TName;\n            data: TData;\n            id: string;\n            ts: number;\n            v?: string;\n            meta?: ReceivedEventMeta;\n          } | null\n        : // Case 4: event is just a string\n          TOpts extends { event: infer TName extends string }\n          ? {\n              name: TName;\n              // biome-ignore lint/suspicious/noExplicitAny: fallback for untyped events\n              data: Record<string, any>;\n              id: string;\n              ts: number;\n              v?: string;\n              meta?: ReceivedEventMeta;\n            } | null\n          : EventPayload | null;\n\n/**\n * Options for `step.ai.infer()`.\n */\ntype AiInferOpts<TModel extends AiAdapter> = {\n  /**\n   * The model to use for the inference. Create a model by importing from\n   * `\"inngest\"` or by using `step.ai.models.*`.\n   *\n   * @example Import `openai()`\n   * ```ts\n   * import { openai } from \"inngest\";\n   *\n   * const model = openai({ model: \"gpt-4\" });\n   * ```\n   *\n   * @example Use a model from `step.ai.models`\n   * ```ts\n   * async ({ step }) => {\n   *            const model = step.ai.models.openai({ model: \"gpt-4\" });\n   * }\n   * ```\n   */\n  model: TModel;\n\n  /**\n   * The input to pass to the model.\n   */\n  body: AiAdapter.Input<TModel>;\n};\n"],"mappings":"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"}

package/components/ScoreFunction.cjs

@@ -0,0 +1,37 @@
+const require_DeferredFunction = require('./DeferredFunction.cjs');
+
+//#region src/components/ScoreFunction.ts
+/**
+* EXPERIMENTAL: This API is not yet stable and may change in the future without
+* a major version bump.
+*
+* Create a typed scorer function. Wraps `createDefer`: the handler's
+* return value is forwarded to `client.score(...)` inside a durable
+* `step.run("score", ...)`. `runId` defaults to the parent run's id (from
+* `event.data.parent.runId`) when the handler omits it. A nullish return
+* is a no-op.
+*/
+function createScorer(client, options, handler) {
+	return require_DeferredFunction.createDefer(client, options, async (ctx) => {
+		const result = await handler(ctx);
+		if (result) {
+			const parent = ctx.parents[0];
+			await ctx.step.run("score", async () => {
+				if (parent.experiment) await client.score.experiment({
+					experiment: parent.experiment,
+					runId: parent.runId,
+					...result
+				});
+				else await client.score({
+					runId: parent.runId,
+					...result
+				});
+			});
+		}
+		return result;
+	});
+}
+
+//#endregion
+exports.createScorer = createScorer;
+//# sourceMappingURL=ScoreFunction.cjs.map

package/components/ScoreFunction.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScoreFunction.cjs","names":["createDefer"],"sources":["../../src/components/ScoreFunction.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport {\n  type CreateDeferInput,\n  createDefer,\n  type DeferContext,\n  type DeferredFunction,\n} from \"./DeferredFunction.ts\";\nimport type { Inngest } from \"./Inngest.ts\";\nimport type { ScoreOptions } from \"./InngestScore.ts\";\nimport type { Middleware } from \"./middleware/index.ts\";\n\ntype ScorerResult =\n  | (Omit<ScoreOptions, \"runId\"> & { runId?: string })\n  | null\n  | undefined;\n\n/**\n * EXPERIMENTAL: This API is not yet stable and may change in the future without\n * a major version bump.\n *\n * Create a typed scorer function. Wraps `createDefer`: the handler's\n * return value is forwarded to `client.score(...)` inside a durable\n * `step.run(\"score\", ...)`. `runId` defaults to the parent run's id (from\n * `event.data.parent.runId`) when the handler omits it. A nullish return\n * is a no-op.\n */\nexport function createScorer<\n  TClient extends Inngest.Any,\n  TSchema extends\n    | StandardSchemaV1<Record<string, unknown>>\n    | undefined = undefined,\n  const TFnMiddleware extends Middleware.Class[] | undefined = undefined,\n>(\n  client: TClient,\n  options: CreateDeferInput<TFnMiddleware, TSchema>,\n  handler: (\n    ctx: DeferContext<TClient, TFnMiddleware, TSchema>,\n  ) => ScorerResult | Promise<ScorerResult>,\n): DeferredFunction<TSchema> {\n  return createDefer<TClient, TSchema, TFnMiddleware>(\n    client,\n    options,\n    async (ctx) => {\n      const result = await handler(ctx);\n      if (result) {\n        const parent = ctx.parents[0];\n        await ctx.step.run(\"score\", async () => {\n          if (parent.experiment) {\n            await client.score.experiment({\n              experiment: parent.experiment,\n              runId: parent.runId,\n              ...result,\n            });\n          } else {\n            await client.score({ runId: parent.runId, ...result });\n          }\n        });\n      }\n      return result;\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;AA0BA,SAAgB,aAOd,QACA,SACA,SAG2B;AAC3B,QAAOA,qCACL,QACA,SACA,OAAO,QAAQ;EACb,MAAM,SAAS,MAAM,QAAQ,IAAI;AACjC,MAAI,QAAQ;GACV,MAAM,SAAS,IAAI,QAAQ;AAC3B,SAAM,IAAI,KAAK,IAAI,SAAS,YAAY;AACtC,QAAI,OAAO,WACT,OAAM,OAAO,MAAM,WAAW;KAC5B,YAAY,OAAO;KACnB,OAAO,OAAO;KACd,GAAG;KACJ,CAAC;QAEF,OAAM,OAAO,MAAM;KAAE,OAAO,OAAO;KAAO,GAAG;KAAQ,CAAC;KAExD;;AAEJ,SAAO;GAEV"}

package/components/ScoreFunction.d.cts

@@ -0,0 +1,24 @@
+import { ScoreOptions } from "./InngestScore.cjs";
+import { Middleware } from "./middleware/middleware.cjs";
+import { CreateDeferInput, DeferContext, DeferredFunction } from "./DeferredFunction.cjs";
+import { Inngest } from "./Inngest.cjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/components/ScoreFunction.d.ts
+type ScorerResult = (Omit<ScoreOptions, "runId"> & {
+  runId?: string;
+}) | null | undefined;
+/**
+ * EXPERIMENTAL: This API is not yet stable and may change in the future without
+ * a major version bump.
+ *
+ * Create a typed scorer function. Wraps `createDefer`: the handler's
+ * return value is forwarded to `client.score(...)` inside a durable
+ * `step.run("score", ...)`. `runId` defaults to the parent run's id (from
+ * `event.data.parent.runId`) when the handler omits it. A nullish return
+ * is a no-op.
+ */
+declare function createScorer<TClient extends Inngest.Any, TSchema extends StandardSchemaV1<Record<string, unknown>> | undefined = undefined, const TFnMiddleware extends Middleware.Class[] | undefined = undefined>(client: TClient, options: CreateDeferInput<TFnMiddleware, TSchema>, handler: (ctx: DeferContext<TClient, TFnMiddleware, TSchema>) => ScorerResult | Promise<ScorerResult>): DeferredFunction<TSchema>;
+//#endregion
+export { createScorer };
+//# sourceMappingURL=ScoreFunction.d.cts.map

package/components/ScoreFunction.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScoreFunction.d.cts","names":[],"sources":["../../src/components/ScoreFunction.ts"],"sourcesContent":[],"mappings":";;;;;;;KAWK,YAAA,IACA,KAAK;;AAH8C,CAAA,CAAA,GAEnD,IAAA,GAAA,SAAY;;;;;AAejB;;;;;;AAOU,iBAPM,YAON,CAAA,gBANQ,OAAA,CAAQ,GAMhB,EAAA,gBAJJ,gBAII,CAJa,MAIb,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,GAAA,SAAA,GAAA,SAAA,EAAA,4BAFoB,UAAA,CAAW,KAE/B,EAAA,GAAA,SAAA,GAAA,SAAA,CAAA,CAAA,MAAA,EAAA,OAAA,EAAA,OAAA,EACC,gBADD,CACkB,aADlB,EACiC,OADjC,CAAA,EAAA,OAAA,EAAA,CAAA,GAAA,EAGD,YAHC,CAGY,OAHZ,EAGqB,aAHrB,EAGoC,OAHpC,CAAA,EAAA,GAIH,YAJG,GAIY,OAJZ,CAIoB,YAJpB,CAAA,CAAA,EAKP,gBALO,CAKU,OALV,CAAA"}

package/components/ScoreFunction.d.ts

@@ -0,0 +1,24 @@
+import { ScoreOptions } from "./InngestScore.js";
+import { Middleware } from "./middleware/middleware.js";
+import { CreateDeferInput, DeferContext, DeferredFunction } from "./DeferredFunction.js";
+import { Inngest } from "./Inngest.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/components/ScoreFunction.d.ts
+type ScorerResult = (Omit<ScoreOptions, "runId"> & {
+  runId?: string;
+}) | null | undefined;
+/**
+ * EXPERIMENTAL: This API is not yet stable and may change in the future without
+ * a major version bump.
+ *
+ * Create a typed scorer function. Wraps `createDefer`: the handler's
+ * return value is forwarded to `client.score(...)` inside a durable
+ * `step.run("score", ...)`. `runId` defaults to the parent run's id (from
+ * `event.data.parent.runId`) when the handler omits it. A nullish return
+ * is a no-op.
+ */
+declare function createScorer<TClient extends Inngest.Any, TSchema extends StandardSchemaV1<Record<string, unknown>> | undefined = undefined, const TFnMiddleware extends Middleware.Class[] | undefined = undefined>(client: TClient, options: CreateDeferInput<TFnMiddleware, TSchema>, handler: (ctx: DeferContext<TClient, TFnMiddleware, TSchema>) => ScorerResult | Promise<ScorerResult>): DeferredFunction<TSchema>;
+//#endregion
+export { createScorer };
+//# sourceMappingURL=ScoreFunction.d.ts.map

package/components/ScoreFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScoreFunction.d.ts","names":[],"sources":["../../src/components/ScoreFunction.ts"],"sourcesContent":[],"mappings":";;;;;;;KAWK,YAAA,IACA,KAAK;;AAH8C,CAAA,CAAA,GAEnD,IAAA,GAAA,SAAY;;;;;AAejB;;;;;;AAOU,iBAPM,YAON,CAAA,gBANQ,OAAA,CAAQ,GAMhB,EAAA,gBAJJ,gBAII,CAJa,MAIb,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,GAAA,SAAA,GAAA,SAAA,EAAA,4BAFoB,UAAA,CAAW,KAE/B,EAAA,GAAA,SAAA,GAAA,SAAA,CAAA,CAAA,MAAA,EAAA,OAAA,EAAA,OAAA,EACC,gBADD,CACkB,aADlB,EACiC,OADjC,CAAA,EAAA,OAAA,EAAA,CAAA,GAAA,EAGD,YAHC,CAGY,OAHZ,EAGqB,aAHrB,EAGoC,OAHpC,CAAA,EAAA,GAIH,YAJG,GAIY,OAJZ,CAIoB,YAJpB,CAAA,CAAA,EAKP,gBALO,CAKU,OALV,CAAA"}

package/components/ScoreFunction.js

@@ -0,0 +1,37 @@
+import { createDefer } from "./DeferredFunction.js";
+
+//#region src/components/ScoreFunction.ts
+/**
+* EXPERIMENTAL: This API is not yet stable and may change in the future without
+* a major version bump.
+*
+* Create a typed scorer function. Wraps `createDefer`: the handler's
+* return value is forwarded to `client.score(...)` inside a durable
+* `step.run("score", ...)`. `runId` defaults to the parent run's id (from
+* `event.data.parent.runId`) when the handler omits it. A nullish return
+* is a no-op.
+*/
+function createScorer(client, options, handler) {
+	return createDefer(client, options, async (ctx) => {
+		const result = await handler(ctx);
+		if (result) {
+			const parent = ctx.parents[0];
+			await ctx.step.run("score", async () => {
+				if (parent.experiment) await client.score.experiment({
+					experiment: parent.experiment,
+					runId: parent.runId,
+					...result
+				});
+				else await client.score({
+					runId: parent.runId,
+					...result
+				});
+			});
+		}
+		return result;
+	});
+}
+
+//#endregion
+export { createScorer };
+//# sourceMappingURL=ScoreFunction.js.map

package/components/ScoreFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScoreFunction.js","names":[],"sources":["../../src/components/ScoreFunction.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport {\n  type CreateDeferInput,\n  createDefer,\n  type DeferContext,\n  type DeferredFunction,\n} from \"./DeferredFunction.ts\";\nimport type { Inngest } from \"./Inngest.ts\";\nimport type { ScoreOptions } from \"./InngestScore.ts\";\nimport type { Middleware } from \"./middleware/index.ts\";\n\ntype ScorerResult =\n  | (Omit<ScoreOptions, \"runId\"> & { runId?: string })\n  | null\n  | undefined;\n\n/**\n * EXPERIMENTAL: This API is not yet stable and may change in the future without\n * a major version bump.\n *\n * Create a typed scorer function. Wraps `createDefer`: the handler's\n * return value is forwarded to `client.score(...)` inside a durable\n * `step.run(\"score\", ...)`. `runId` defaults to the parent run's id (from\n * `event.data.parent.runId`) when the handler omits it. A nullish return\n * is a no-op.\n */\nexport function createScorer<\n  TClient extends Inngest.Any,\n  TSchema extends\n    | StandardSchemaV1<Record<string, unknown>>\n    | undefined = undefined,\n  const TFnMiddleware extends Middleware.Class[] | undefined = undefined,\n>(\n  client: TClient,\n  options: CreateDeferInput<TFnMiddleware, TSchema>,\n  handler: (\n    ctx: DeferContext<TClient, TFnMiddleware, TSchema>,\n  ) => ScorerResult | Promise<ScorerResult>,\n): DeferredFunction<TSchema> {\n  return createDefer<TClient, TSchema, TFnMiddleware>(\n    client,\n    options,\n    async (ctx) => {\n      const result = await handler(ctx);\n      if (result) {\n        const parent = ctx.parents[0];\n        await ctx.step.run(\"score\", async () => {\n          if (parent.experiment) {\n            await client.score.experiment({\n              experiment: parent.experiment,\n              runId: parent.runId,\n              ...result,\n            });\n          } else {\n            await client.score({ runId: parent.runId, ...result });\n          }\n        });\n      }\n      return result;\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;AA0BA,SAAgB,aAOd,QACA,SACA,SAG2B;AAC3B,QAAO,YACL,QACA,SACA,OAAO,QAAQ;EACb,MAAM,SAAS,MAAM,QAAQ,IAAI;AACjC,MAAI,QAAQ;GACV,MAAM,SAAS,IAAI,QAAQ;AAC3B,SAAM,IAAI,KAAK,IAAI,SAAS,YAAY;AACtC,QAAI,OAAO,WACT,OAAM,OAAO,MAAM,WAAW;KAC5B,YAAY,OAAO;KACnB,OAAO,OAAO;KACd,GAAG;KACJ,CAAC;QAEF,OAAM,OAAO,MAAM;KAAE,OAAO,OAAO;KAAO,GAAG;KAAQ,CAAC;KAExD;;AAEJ,SAAO;GAEV"}

package/components/execution/InngestExecution.d.cts

@@ -1,8 +1,8 @@
 import { ExecutionVersion } from "../../helpers/consts.cjs";
-import { MaybePromise, Simplify } from "../../helpers/types.cjs";
 import { ServerTiming } from "../../helpers/ServerTiming.cjs";
-import { Middleware } from "../middleware/middleware.cjs";
+import { MaybePromise, Simplify } from "../../helpers/types.cjs";
 import { MetadataKind, MetadataOpcode, MetadataScope } from "../InngestMetadata.cjs";
+import { Middleware } from "../middleware/middleware.cjs";
 import { InngestFunction } from "../InngestFunction.cjs";
 import { Context, IncomingOp, InternalCheckpointingOptions, OutgoingOp, StepMode } from "../../types.cjs";
 import { Inngest } from "../Inngest.cjs";

package/components/execution/InngestExecution.d.ts

@@ -1,8 +1,8 @@
 import { ExecutionVersion } from "../../helpers/consts.js";
-import { MaybePromise, Simplify } from "../../helpers/types.js";
 import { ServerTiming } from "../../helpers/ServerTiming.js";
-import { Middleware } from "../middleware/middleware.js";
+import { MaybePromise, Simplify } from "../../helpers/types.js";
 import { MetadataKind, MetadataOpcode, MetadataScope } from "../InngestMetadata.js";
+import { Middleware } from "../middleware/middleware.js";
 import { InngestFunction } from "../InngestFunction.js";
 import { Context, IncomingOp, InternalCheckpointingOptions, OutgoingOp, StepMode } from "../../types.js";
 import { Inngest } from "../Inngest.js";

package/components/execution/als.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"als.cjs","names":["fallback: AsyncLocalStorageIsh"],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":["import type { Context, StepOptions } from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { Stream } from \"../StreamTools.ts\";\nimport type { IInngestExecution } from \"./InngestExecution.ts\";\n\n/**\n * Note - this structure can be used by other libraries, so cannot have breaking changes.\n */\nexport interface AsyncContext {\n  /**\n   * The Inngest App that is currently being used to execute the function.\n   *\n   * If this is defined, we are in the context of an Inngest function execution,\n   * or a possible one.\n   */\n  app: Inngest.Like;\n\n  /**\n   * Details of the current function execution context. If this doesn't exist,\n   * then we're not currently in a function execution context.\n   */\n  execution?: {\n    /**\n     * The execution instance that is currently running the function.\n     */\n    instance: IInngestExecution;\n\n    /**\n     * The `ctx` object that has been passed in to this function execution,\n     * including values such as `step` and `event`.\n     */\n    ctx: Context.Any;\n\n    /**\n     * If present, this indicates we are currently executing a `step.run()` step's\n     * callback. Useful to understand whether we are in the context of a step\n     * execution or within the main function body.\n     */\n    executingStep?: StepOptions & { hashedId?: string };\n\n    /**\n     * If present, indicates the parallel mode that should be applied to steps\n     * created within this context. Set by `group.parallel()`.\n     */\n    parallelMode?: \"race\";\n\n    /**\n     * The stream tools instance for this execution context. Used by the\n     * `stream` singleton to push/pipe SSE data to the client.\n     */\n    stream?: Stream;\n\n    /**\n     * If present, indicates the variant callback is executing within an\n     * experiment. Set by `group.experiment()`. Any `step.*()` call within\n     * this context will include these fields in `OutgoingOp.opts`.\n     */\n    experimentContext?: {\n      experimentStepID: string;\n      experimentName: string;\n      variant: string;\n      selectionStrategy: string;\n    };\n\n    /**\n     * A mutable tracker used to detect whether any step tool was invoked\n     * during a variant callback. Set by `group.experiment()`, flipped by\n     * `createTool` in `InngestStepTools.ts`.\n     */\n    experimentStepTracker?: { found: boolean };\n\n    /**\n     * If true, we are inside the `select()` callback of\n     * `group.experiment()`. Any `step.*()` call here would create a\n     * nested step, which is not allowed.\n     */\n    insideExperimentSelect?: boolean;\n  };\n}\n\n/**\n * A local-only symbol used as a key in global state to store the async local\n * storage instance.\n */\nconst alsSymbol = Symbol.for(\"inngest:als\");\n\n/**\n * Cache structure that stores both the promise and resolved ALS instance.\n * This allows synchronous access after initialization.\n */\ntype ALSCache = {\n  promise: Promise<AsyncLocalStorageIsh>;\n  resolved?: AsyncLocalStorageIsh;\n  isFallback?: boolean;\n};\n\n/**\n * A type that represents a partial, runtime-agnostic interface of\n * `AsyncLocalStorage`.\n */\ntype AsyncLocalStorageIsh = {\n  getStore: () => AsyncContext | undefined;\n  run: <R>(store: AsyncContext, fn: () => R) => R;\n};\n\nconst getCache = (): ALSCache => {\n  const g = globalThis as Record<symbol, ALSCache | undefined>;\n\n  if (!g[alsSymbol]) {\n    g[alsSymbol] = createCache();\n  }\n\n  return g[alsSymbol];\n};\n\nconst createCache = (): ALSCache => {\n  const cache = {} as ALSCache;\n  cache.promise = initializeALS(cache);\n  return cache;\n};\n\nconst initializeALS = async (\n  cache: ALSCache,\n): Promise<AsyncLocalStorageIsh> => {\n  try {\n    const { AsyncLocalStorage } = await import(\"node:async_hooks\");\n    const als = new AsyncLocalStorage<AsyncContext>();\n    cache.resolved = als;\n    cache.isFallback = false;\n    return als;\n  } catch {\n    const fallback: AsyncLocalStorageIsh = {\n      getStore: () => undefined,\n      run: (_, fn) => fn(),\n    };\n    cache.resolved = fallback;\n    cache.isFallback = true;\n    console.warn(\n      \"node:async_hooks is not supported in this runtime. Async context is disabled.\",\n    );\n    return fallback;\n  }\n};\n\n/**\n * Check if AsyncLocalStorage is unavailable and we're using the fallback.\n * Returns `undefined` if ALS hasn't been initialized yet.\n */\nexport const isALSFallback = (): boolean | undefined => {\n  return getCache().isFallback;\n};\n\n/**\n * Retrieve the async context for the current execution.\n */\nexport const getAsyncCtx = async (): Promise<AsyncContext | undefined> => {\n  return getAsyncLocalStorage().then((als) => als.getStore());\n};\n\n/**\n * Retrieve the async context for the current execution synchronously.\n * Returns undefined if ALS hasn't been initialized yet.\n */\nexport const getAsyncCtxSync = (): AsyncContext | undefined => {\n  return getCache().resolved?.getStore();\n};\n\n/**\n * Get a singleton instance of `AsyncLocalStorage` used to store and retrieve\n * async context for the current execution.\n */\nexport const getAsyncLocalStorage = async (): Promise<AsyncLocalStorageIsh> => {\n  return getCache().promise;\n};\n"],"mappings":";;;;;;AAoFA,MAAM,YAAY,OAAO,IAAI,cAAc;AAqB3C,MAAM,iBAA2B;CAC/B,MAAM,IAAI;AAEV,KAAI,CAAC,EAAE,WACL,GAAE,aAAa,aAAa;AAG9B,QAAO,EAAE;;AAGX,MAAM,oBAA8B;CAClC,MAAM,QAAQ,EAAE;AAChB,OAAM,UAAU,cAAc,MAAM;AACpC,QAAO;;AAGT,MAAM,gBAAgB,OACpB,UACkC;AAClC,KAAI;EACF,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAC3C,MAAM,MAAM,IAAI,mBAAiC;AACjD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,SAAO;SACD;EACN,MAAMA,WAAiC;GACrC,gBAAgB;GAChB,MAAM,GAAG,OAAO,IAAI;GACrB;AACD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,UAAQ,KACN,gFACD;AACD,SAAO;;;;;;;AAQX,MAAa,sBAA2C;AACtD,QAAO,UAAU,CAAC;;;;;AAMpB,MAAa,cAAc,YAA+C;AACxE,QAAO,sBAAsB,CAAC,MAAM,QAAQ,IAAI,UAAU,CAAC;;;;;;AAO7D,MAAa,wBAAkD;AAC7D,QAAO,UAAU,CAAC,UAAU,UAAU;;;;;;AAOxC,MAAa,uBAAuB,YAA2C;AAC7E,QAAO,UAAU,CAAC"}
+{"version":3,"file":"als.cjs","names":["fallback: AsyncLocalStorageIsh"],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":["import type { Context, StepOptions } from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { Stream } from \"../StreamTools.ts\";\nimport type { IInngestExecution } from \"./InngestExecution.ts\";\n\n/**\n * Note - this structure can be used by other libraries, so cannot have breaking changes.\n */\nexport interface AsyncContext {\n  /**\n   * The Inngest App that is currently being used to execute the function.\n   *\n   * If this is defined, we are in the context of an Inngest function execution,\n   * or a possible one.\n   */\n  app: Inngest.Like;\n\n  /**\n   * Details of the current function execution context. If this doesn't exist,\n   * then we're not currently in a function execution context.\n   */\n  execution?: {\n    /**\n     * The execution instance that is currently running the function.\n     */\n    instance: IInngestExecution;\n\n    /**\n     * The `ctx` object that has been passed in to this function execution,\n     * including values such as `step` and `event`.\n     */\n    ctx: Context.Any;\n\n    /**\n     * If present, this indicates we are currently executing a `step.run()` step's\n     * callback. Useful to understand whether we are in the context of a step\n     * execution or within the main function body.\n     */\n    executingStep?: StepOptions & {\n      hashedId?: string;\n      userlandId?: string;\n    };\n\n    /**\n     * If present, indicates the parallel mode that should be applied to steps\n     * created within this context. Set by `group.parallel()`.\n     */\n    parallelMode?: \"race\";\n\n    /**\n     * The stream tools instance for this execution context. Used by the\n     * `stream` singleton to push/pipe SSE data to the client.\n     */\n    stream?: Stream;\n\n    /**\n     * If present, indicates the variant callback is executing within an\n     * experiment. Set by `group.experiment()`. Any `step.*()` call within\n     * this context will include these fields in `OutgoingOp.opts`.\n     */\n    experimentContext?: {\n      experimentStepID: string;\n      experimentName: string;\n      variant: string;\n      selectionStrategy: string;\n    };\n\n    /**\n     * A mutable tracker used to detect whether any step tool was invoked\n     * during a variant callback. Set by `group.experiment()`, flipped by\n     * `createTool` in `InngestStepTools.ts`.\n     */\n    experimentStepTracker?: { found: boolean };\n\n    /**\n     * If true, we are inside the `select()` callback of\n     * `group.experiment()`. Any `step.*()` call here would create a\n     * nested step, which is not allowed.\n     */\n    insideExperimentSelect?: boolean;\n  };\n}\n\n/**\n * A local-only symbol used as a key in global state to store the async local\n * storage instance.\n */\nconst alsSymbol = Symbol.for(\"inngest:als\");\n\n/**\n * Cache structure that stores both the promise and resolved ALS instance.\n * This allows synchronous access after initialization.\n */\ntype ALSCache = {\n  promise: Promise<AsyncLocalStorageIsh>;\n  resolved?: AsyncLocalStorageIsh;\n  isFallback?: boolean;\n};\n\n/**\n * A type that represents a partial, runtime-agnostic interface of\n * `AsyncLocalStorage`.\n */\ntype AsyncLocalStorageIsh = {\n  getStore: () => AsyncContext | undefined;\n  run: <R>(store: AsyncContext, fn: () => R) => R;\n};\n\nconst getCache = (): ALSCache => {\n  const g = globalThis as Record<symbol, ALSCache | undefined>;\n\n  if (!g[alsSymbol]) {\n    g[alsSymbol] = createCache();\n  }\n\n  return g[alsSymbol];\n};\n\nconst createCache = (): ALSCache => {\n  const cache = {} as ALSCache;\n  cache.promise = initializeALS(cache);\n  return cache;\n};\n\nconst initializeALS = async (\n  cache: ALSCache,\n): Promise<AsyncLocalStorageIsh> => {\n  try {\n    const { AsyncLocalStorage } = await import(\"node:async_hooks\");\n    const als = new AsyncLocalStorage<AsyncContext>();\n    cache.resolved = als;\n    cache.isFallback = false;\n    return als;\n  } catch {\n    const fallback: AsyncLocalStorageIsh = {\n      getStore: () => undefined,\n      run: (_, fn) => fn(),\n    };\n    cache.resolved = fallback;\n    cache.isFallback = true;\n    console.warn(\n      \"node:async_hooks is not supported in this runtime. Async context is disabled.\",\n    );\n    return fallback;\n  }\n};\n\n/**\n * Check if AsyncLocalStorage is unavailable and we're using the fallback.\n * Returns `undefined` if ALS hasn't been initialized yet.\n */\nexport const isALSFallback = (): boolean | undefined => {\n  return getCache().isFallback;\n};\n\n/**\n * Retrieve the async context for the current execution.\n */\nexport const getAsyncCtx = async (): Promise<AsyncContext | undefined> => {\n  return getAsyncLocalStorage().then((als) => als.getStore());\n};\n\n/**\n * Retrieve the async context for the current execution synchronously.\n * Returns undefined if ALS hasn't been initialized yet.\n */\nexport const getAsyncCtxSync = (): AsyncContext | undefined => {\n  return getCache().resolved?.getStore();\n};\n\n/**\n * Get a singleton instance of `AsyncLocalStorage` used to store and retrieve\n * async context for the current execution.\n */\nexport const getAsyncLocalStorage = async (): Promise<AsyncLocalStorageIsh> => {\n  return getCache().promise;\n};\n"],"mappings":";;;;;;AAuFA,MAAM,YAAY,OAAO,IAAI,cAAc;AAqB3C,MAAM,iBAA2B;CAC/B,MAAM,IAAI;AAEV,KAAI,CAAC,EAAE,WACL,GAAE,aAAa,aAAa;AAG9B,QAAO,EAAE;;AAGX,MAAM,oBAA8B;CAClC,MAAM,QAAQ,EAAE;AAChB,OAAM,UAAU,cAAc,MAAM;AACpC,QAAO;;AAGT,MAAM,gBAAgB,OACpB,UACkC;AAClC,KAAI;EACF,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAC3C,MAAM,MAAM,IAAI,mBAAiC;AACjD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,SAAO;SACD;EACN,MAAMA,WAAiC;GACrC,gBAAgB;GAChB,MAAM,GAAG,OAAO,IAAI;GACrB;AACD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,UAAQ,KACN,gFACD;AACD,SAAO;;;;;;;AAQX,MAAa,sBAA2C;AACtD,QAAO,UAAU,CAAC;;;;;AAMpB,MAAa,cAAc,YAA+C;AACxE,QAAO,sBAAsB,CAAC,MAAM,QAAQ,IAAI,UAAU,CAAC;;;;;;AAO7D,MAAa,wBAAkD;AAC7D,QAAO,UAAU,CAAC,UAAU,UAAU;;;;;;AAOxC,MAAa,uBAAuB,YAA2C;AAC7E,QAAO,UAAU,CAAC"}

package/components/execution/als.d.cts

@@ -37,6 +37,7 @@ interface AsyncContext {
      */
     executingStep?: StepOptions & {
       hashedId?: string;
+      userlandId?: string;
     };
     /**
      * If present, indicates the parallel mode that should be applied to steps