@lostgradient/weft 0.7.0 → 0.8.0

package/dist/core/context/activity-retry-state.d.ts

@@ -10,6 +10,7 @@ import type { ContextInternals } from './internals.ts';
 export declare const ACTIVITY_RETRY_STATE_LOCAL_KEY = "__weftActivityRetryState";
 declare const ACTIVITY_RETRY_STATE_VERSION = 1;
 export declare const MAX_CHECKPOINTED_RETRY_ATTEMPT = 10000;
+export type ActivityRetryStateKey = number | string;
 export interface ActivityRetryState {
     version: typeof ACTIVITY_RETRY_STATE_VERSION;
     attempts: Record<string, number>;
@@ -24,15 +25,15 @@ export interface ActivityRetryState {
     dispatchedAt?: Record<string, number>;
 }
 export declare function isActivityRetryState(value: unknown): value is ActivityRetryState;
-export declare function readActivityRetryAttempt(internals: ContextInternals, step: number): number | undefined;
-export declare function readCompletedRetrySleepCount(internals: ContextInternals, step: number): number;
-export declare function writeActivityRetryAttempt(internals: ContextInternals, step: number, attempt: number): void;
-export declare function completeActivityRetryAttempt(internals: ContextInternals, step: number, completedRetrySleepCount: number): void;
+export declare function readActivityRetryAttempt(internals: ContextInternals, key: ActivityRetryStateKey): number | undefined;
+export declare function readCompletedRetrySleepCount(internals: ContextInternals, key: ActivityRetryStateKey): number;
+export declare function writeActivityRetryAttempt(internals: ContextInternals, key: ActivityRetryStateKey, attempt: number): void;
+export declare function completeActivityRetryAttempt(internals: ContextInternals, key: ActivityRetryStateKey, completedRetrySleepCount: number): void;
 /**
  * Read the first-dispatch anchor for a step's `scheduleToCloseTimeout`, writing
  * `now` on the first dispatch. Read-first so a crash/replay never resets the
  * window: the budget is measured from the original dispatch, and the anchor
  * lands in the checkpoint committed at the dispatch `yield` that follows.
  */
-export declare function readOrInitActivityDispatchedAt(internals: ContextInternals, step: number, now: number): number;
+export declare function readOrInitActivityDispatchedAt(internals: ContextInternals, key: ActivityRetryStateKey, now: number): number;
 export {};

package/dist/core/context/activity-retry-state.js

@@ -7,29 +7,39 @@ function isRecord(value) {
 export function isActivityRetryState(value) {
   return isRecord(value) && value.version === ACTIVITY_RETRY_STATE_VERSION && isRecord(value.attempts) && (value.completedRetrySleeps === void 0 || isRecord(value.completedRetrySleeps)) && (value.dispatchedAt === void 0 || isRecord(value.dispatchedAt));
 }
-function assertValidRetryAttempt(attempt, step) {
+function retryStateSlotKey(key) {
+  if (typeof key === "number")
+    return String(key);
+  if (key.length === 0)
+    throw Error("Invalid empty checkpointed activity retry state key");
+  return key;
+}
+function retryStateKeyLabel(key) {
+  return typeof key === "number" ? `step ${String(key)}` : `key ${key}`;
+}
+function assertValidRetryAttempt(attempt, key) {
   if (!Number.isInteger(attempt) || attempt <= 1 || attempt > MAX_CHECKPOINTED_RETRY_ATTEMPT)
-    throw Error(`Invalid checkpointed activity retry attempt ${String(attempt)} for step ${String(step)}`);
+    throw Error(`Invalid checkpointed activity retry attempt ${String(attempt)} for ${retryStateKeyLabel(key)}`);
 }
-export function readActivityRetryAttempt(internals, step) {
+export function readActivityRetryAttempt(internals, key) {
   const state = internals.checkpointLocals[ACTIVITY_RETRY_STATE_LOCAL_KEY];
   if (!isActivityRetryState(state))
     return;
-  const attempt = state.attempts[String(step)];
+  const attempt = state.attempts[retryStateSlotKey(key)];
   if (attempt === void 0)
     return;
-  assertValidRetryAttempt(attempt, step);
+  assertValidRetryAttempt(attempt, key);
   return attempt;
 }
-export function readCompletedRetrySleepCount(internals, step) {
+export function readCompletedRetrySleepCount(internals, key) {
   const state = internals.checkpointLocals[ACTIVITY_RETRY_STATE_LOCAL_KEY];
   if (!isActivityRetryState(state))
     return 0;
-  const count = state.completedRetrySleeps?.[String(step)];
+  const count = state.completedRetrySleeps?.[retryStateSlotKey(key)];
   if (count === void 0)
     return 0;
   if (!Number.isInteger(count) || count < 0 || count > MAX_CHECKPOINTED_RETRY_ATTEMPT)
-    throw Error(`Invalid checkpointed activity retry sleep count ${String(count)} for step ${String(step)}`);
+    throw Error(`Invalid checkpointed activity retry sleep count ${String(count)} for ${retryStateKeyLabel(key)}`);
   return count;
 }
 function currentRetryState(internals) {
@@ -52,38 +62,38 @@ function writeRetryStateSlot(internals, attempts, completedRetrySleeps, dispatch
     }
   };
 }
-export function writeActivityRetryAttempt(internals, step, attempt) {
-  assertValidRetryAttempt(attempt, step);
+export function writeActivityRetryAttempt(internals, key, attempt) {
+  assertValidRetryAttempt(attempt, key);
   const current = currentRetryState(internals), attempts = current ? { ...current.attempts } : {};
-  attempts[String(step)] = attempt;
+  attempts[retryStateSlotKey(key)] = attempt;
   writeRetryStateSlot(internals, attempts, current?.completedRetrySleeps, current?.dispatchedAt);
 }
-function clearActivityRetryAttempt(internals, step) {
+function clearActivityRetryAttempt(internals, key) {
   const current = currentRetryState(internals);
   if (!current)
     return;
   const attempts = { ...current.attempts };
-  delete attempts[String(step)];
+  delete attempts[retryStateSlotKey(key)];
   writeRetryStateSlot(internals, attempts, current.completedRetrySleeps, current.dispatchedAt);
 }
-export function completeActivityRetryAttempt(internals, step, completedRetrySleepCount) {
+export function completeActivityRetryAttempt(internals, key, completedRetrySleepCount) {
   if (!Number.isInteger(completedRetrySleepCount) || completedRetrySleepCount < 0 || completedRetrySleepCount > MAX_CHECKPOINTED_RETRY_ATTEMPT)
-    throw Error(`Invalid completed activity retry sleep count ${String(completedRetrySleepCount)} for step ${String(step)}`);
-  clearActivityRetryAttempt(internals, step);
+    throw Error(`Invalid completed activity retry sleep count ${String(completedRetrySleepCount)} for ${retryStateKeyLabel(key)}`);
+  clearActivityRetryAttempt(internals, key);
   if (completedRetrySleepCount === 0)
     return;
   const current = currentRetryState(internals), attempts = current ? { ...current.attempts } : {}, completedRetrySleeps = current ? { ...current.completedRetrySleeps } : {};
-  completedRetrySleeps[String(step)] = completedRetrySleepCount;
+  completedRetrySleeps[retryStateSlotKey(key)] = completedRetrySleepCount;
   writeRetryStateSlot(internals, attempts, completedRetrySleeps, current?.dispatchedAt);
 }
-export function readOrInitActivityDispatchedAt(internals, step, now) {
-  const current = currentRetryState(internals), existing = current?.dispatchedAt?.[String(step)];
+export function readOrInitActivityDispatchedAt(internals, key, now) {
+  const current = currentRetryState(internals), slotKey = retryStateSlotKey(key), existing = current?.dispatchedAt?.[slotKey];
   if (typeof existing === "number" && Number.isFinite(existing))
     return existing;
   if (existing !== void 0)
-    throw Error(`Invalid checkpointed activity dispatch anchor ${String(existing)} for step ${String(step)}`);
+    throw Error(`Invalid checkpointed activity dispatch anchor ${String(existing)} for ${retryStateKeyLabel(key)}`);
   const attempts = current ? { ...current.attempts } : {}, dispatchedAt = current?.dispatchedAt ? { ...current.dispatchedAt } : {};
-  dispatchedAt[String(step)] = now;
+  dispatchedAt[slotKey] = now;
   writeRetryStateSlot(internals, attempts, current?.completedRetrySleeps, dispatchedAt);
   return now;
 }

package/dist/core/context/durable-activity.d.ts

@@ -0,0 +1,117 @@
+import type { ActivityCallable, ActivityCallOptions } from '../types.ts';
+import { WeftError } from '../weft-error.ts';
+type BareActivityFunction<TInput, TResult> = ((input: TInput) => Promise<TResult> | TResult) & {
+    execute?: never;
+};
+type BareNoInputActivityFunction<TResult> = (() => Promise<TResult> | TResult) & {
+    execute?: never;
+};
+export type DurableActivityInput = string | ActivityCallable<void, unknown> | BareNoInputActivityFunction<unknown> | ActivityCallable<unknown, unknown> | BareActivityFunction<unknown, unknown>;
+export interface DurableActivityInvocation {
+    activity: DurableActivityInput;
+    arguments: readonly unknown[];
+    callerStack: string;
+}
+export interface DurableActivityScope {
+    dispatch<TResult>(invocation: DurableActivityInvocation): Promise<TResult>;
+}
+/**
+ * Thrown when `durableActivity()` is called without an active inline `ctx.memo`
+ * durable-activity scope, or after that scope has already closed.
+ *
+ * The error usually means helper code escaped the memo callback boundary, ran
+ * under Worker execution mode, or started a helper activity without awaiting it
+ * before the memo callback returned.
+ *
+ * @example
+ * ```ts
+ * import { durableActivity, DurableActivityScopeError } from '@lostgradient/weft';
+ *
+ * async function sendOutsideWorkflow(): Promise<void> {
+ *   try {
+ *     await durableActivity('sendEmail', { userId: 'user-1' });
+ *   } catch (error) {
+ *     if (error instanceof DurableActivityScopeError) {
+ *       console.error(error.message);
+ *     }
+ *   }
+ * }
+ *
+ * void sendOutsideWorkflow;
+ * ```
+ */
+export declare class DurableActivityScopeError extends WeftError<'DurableActivityScopeError'> {
+    constructor(message: string);
+}
+/**
+ * Thrown when helper-launched activity code reaches an activity feature that
+ * cannot safely be represented inside a plain async memo callback.
+ *
+ * The first unsupported feature is `ActivityContext.completeAsync()`: async
+ * activity completion must use `yield* ctx.run()` directly so the parked
+ * completion token stays attached to a normal workflow operation.
+ *
+ * @example
+ * ```ts
+ * import { durableActivity, DurableActivityUnsupportedError, workflow } from '@lostgradient/weft';
+ *
+ * export const completionWorkflow = workflow({ name: 'manual-completion' }).execute(async function* (
+ *   ctx,
+ * ) {
+ *   try {
+ *     yield* ctx.memo('manual-completion-helper', async () =>
+ *       durableActivity('manualCompletionActivity', undefined, {
+ *         idempotencyKey: 'manual-completion:1',
+ *       }),
+ *     );
+ *   } catch (error) {
+ *     if (error instanceof DurableActivityUnsupportedError) {
+ *       console.error(error.message);
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export declare class DurableActivityUnsupportedError extends WeftError<'DurableActivityUnsupportedError'> {
+    constructor(message: string);
+}
+export declare function runWithDurableActivityScope<TResult>(scope: DurableActivityScope, execute: () => TResult): TResult;
+/**
+ * Run a durable activity from plain async helper code while an inline workflow
+ * is executing a `ctx.memo()` callback.
+ *
+ * `durableActivity()` gives shared async helpers the same activity dispatch
+ * machinery as `yield* ctx.run()` without converting the helper stack to
+ * generators. It is intentionally scoped: call it only from code awaited by one
+ * inline `ctx.memo()` callback, and await each helper activity sequentially
+ * before the callback returns. Activities with `idempotencyKey` get immediate
+ * lease-fenced result durability for the crash window between the activity
+ * returning and the memo checkpoint commit; unkeyed helper activities keep the
+ * normal at-least-once crash behavior.
+ *
+ * @example
+ * ```ts
+ * import { durableActivity, workflow } from '@lostgradient/weft';
+ *
+ * async function reserveInventory(input: { orderId: string }): Promise<{ reservationId: string }> {
+ *   return { reservationId: input.orderId };
+ * }
+ *
+ * export const checkout = workflow({ name: 'checkout' }).execute(async function* (
+ *   ctx,
+ *   input: { orderId: string },
+ * ) {
+ *   return yield* ctx.memo('reserve-inventory', async () =>
+ *     durableActivity(reserveInventory, { orderId: input.orderId }, {
+ *       idempotencyKey: `reserve:${input.orderId}`,
+ *     }),
+ *   );
+ * });
+ * ```
+ */
+export declare function durableActivity<TResult = unknown>(name: string, input?: unknown, options?: ActivityCallOptions): Promise<TResult>;
+export declare function durableActivity<TResult>(fn: ActivityCallable<void, TResult>, options?: ActivityCallOptions): Promise<TResult>;
+export declare function durableActivity<TResult>(fn: BareNoInputActivityFunction<TResult>, options?: ActivityCallOptions): Promise<TResult>;
+export declare function durableActivity<TInput, TResult>(fn: ActivityCallable<TInput, TResult>, input: TInput, options?: ActivityCallOptions): Promise<TResult>;
+export declare function durableActivity<TInput, TResult>(fn: BareActivityFunction<TInput, TResult>, input: TInput, options?: ActivityCallOptions): Promise<TResult>;
+export {};

package/dist/core/context/durable-activity.js

@@ -0,0 +1,79 @@
+import { WeftError } from "../weft-error.js";
+import { captureCallerStack } from "./validation.js";
+
+export class DurableActivityScopeError extends WeftError {
+  constructor(message) {
+    super("DurableActivityScopeError", message);
+  }
+}
+
+export class DurableActivityUnsupportedError extends WeftError {
+  constructor(message) {
+    super("DurableActivityUnsupportedError", message);
+  }
+}
+let durableActivityScopeStorage;
+const fallbackDurableActivityScopes = [], AMBIGUOUS_FALLBACK_DURABLE_ACTIVITY_SCOPE = Symbol("AMBIGUOUS_FALLBACK_DURABLE_ACTIVITY_SCOPE");
+function loadAsyncLocalStorageConstructor() {
+  const getBuiltinModule = ("process" in globalThis ? globalThis.process : void 0)?.getBuiltinModule;
+  if (typeof getBuiltinModule !== "function")
+    return;
+  return getBuiltinModule("node:async_hooks")?.AsyncLocalStorage;
+}
+function getDurableActivityScopeStorage() {
+  if (durableActivityScopeStorage !== void 0)
+    return durableActivityScopeStorage;
+  const AsyncLocalStorage = loadAsyncLocalStorageConstructor();
+  durableActivityScopeStorage = AsyncLocalStorage === void 0 ? null : new AsyncLocalStorage;
+  return durableActivityScopeStorage;
+}
+function currentDurableActivityScope() {
+  const storage = getDurableActivityScopeStorage();
+  if (storage !== null)
+    return storage.getStore();
+  if (fallbackDurableActivityScopes.length > 1)
+    return AMBIGUOUS_FALLBACK_DURABLE_ACTIVITY_SCOPE;
+  return fallbackDurableActivityScopes.at(-1);
+}
+export function runWithDurableActivityScope(scope, execute) {
+  const storage = getDurableActivityScopeStorage();
+  if (storage === null)
+    return runWithFallbackDurableActivityScope(scope, execute);
+  return storage.run(scope, execute);
+}
+function runWithFallbackDurableActivityScope(scope, execute) {
+  fallbackDurableActivityScopes.push(scope);
+  let result;
+  try {
+    result = execute();
+  } catch (error) {
+    removeFallbackDurableActivityScope(scope);
+    throw error;
+  }
+  if (hasFinally(result))
+    return result.finally(() => removeFallbackDurableActivityScope(scope));
+  removeFallbackDurableActivityScope(scope);
+  return result;
+}
+function removeFallbackDurableActivityScope(scope) {
+  const index = fallbackDurableActivityScopes.lastIndexOf(scope);
+  if (index >= 0)
+    fallbackDurableActivityScopes.splice(index, 1);
+}
+function hasFinally(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null)
+    return !1;
+  return "finally" in value && typeof value.finally === "function";
+}
+export function durableActivity(activity, ...activityArguments) {
+  const scope = currentDurableActivityScope();
+  if (scope === AMBIGUOUS_FALLBACK_DURABLE_ACTIVITY_SCOPE)
+    return Promise.reject(new DurableActivityScopeError("durableActivity() cannot resolve a unique ctx.memo() scope because AsyncLocalStorage is unavailable and multiple memo callbacks are active. Run this workflow in a runtime with AsyncLocalStorage support."));
+  if (scope === void 0)
+    return Promise.reject(new DurableActivityScopeError("durableActivity() can only be called from a ctx.memo() callback during inline workflow activation. Use yield* ctx.run() in generator workflow code outside that memo helper boundary."));
+  return scope.dispatch({
+    activity,
+    arguments: activityArguments,
+    callerStack: captureCallerStack()
+  });
+}

package/dist/core/context/operation-request.d.ts

@@ -40,6 +40,14 @@ export type ContextOperationRequest = {
      * anchors the durable async-completion task token to a fixed activity.
      */
     step?: number;
+    /**
+     * Optional deterministic state key for activity sub-operations that are
+     * owned by another workflow step. Plain `ctx.run()` leaves this unset and
+     * uses `step`; memo-scoped helper activities set it to a key derived from
+     * the owning memo step, memo key, and helper-call ordinal so retry and
+     * heartbeat state cannot collide with the parent memo step.
+     */
+    activityStateKey?: string;
     /** Serialized interceptor headers (Map entries) for remote worker propagation. */
     headers?: [string, string][];
 } | {
@@ -122,6 +130,13 @@ export type ContextOperationRequest = {
     type: 'memo';
     operationId: string;
     key: string;
+    /**
+     * Workflow step index for the owning `ctx.memo()` call. Plain async
+     * helper activity calls derive sub-operation identity from this parent
+     * step, the memo key, and their call ordinal without consuming the
+     * workflow's outer step index.
+     */
+    step?: number;
     fn: () => unknown;
     callerStack?: string;
 } | {

package/dist/core/context/parallel-operations.js

@@ -139,6 +139,7 @@ export function* memo(context, internals, key, fn) {
     type: "memo",
     operationId,
     key,
+    step,
     fn,
     callerStack
   };

package/dist/core/context/run-operation-cached-request.d.ts

@@ -0,0 +1,8 @@
+import { type ActivityRetryStateKey } from './activity-retry-state.ts';
+import type { ContextInternals } from './internals.ts';
+import type { RunActivityRequest } from './run-operation.ts';
+type CachedRunActivityRequestConfiguration = {
+    advanceStepIndexForCachedRetryState: boolean;
+};
+export declare function getCachedRunActivityRequest<TResult>(internals: ContextInternals, step: number, retryStateKey: ActivityRetryStateKey, cacheResultStep: number | undefined, activityName: string, input: unknown, configuration: CachedRunActivityRequestConfiguration): RunActivityRequest<TResult>;
+export {};

package/dist/core/context/run-operation-cached-request.js

@@ -0,0 +1,59 @@
+import {
+  readActivityRetryAttempt,
+  readCompletedRetrySleepCount
+} from "./activity-retry-state.js";
+export function getCachedRunActivityRequest(internals, step, retryStateKey, cacheResultStep, activityName, input, configuration) {
+  const cachedResultState = readCachedResultState(internals, cacheResultStep);
+  if (cachedResultState.hasCachedResult)
+    return createCachedResultRequest(internals, step, retryStateKey, cacheResultStep, activityName, input, cachedResultState.cachedResult, configuration);
+  const retryAttempt = readActivityRetryAttempt(internals, retryStateKey);
+  if (retryAttempt !== void 0)
+    return createRetryStateRequest(internals, step, retryStateKey, cacheResultStep, activityName, input, retryAttempt, configuration);
+  return {
+    ...createBaseRequest(step, retryStateKey, cacheResultStep, activityName, input),
+    hasCachedResult: !1,
+    retryAttempt: 1
+  };
+}
+function readCachedResultState(internals, cacheResultStep) {
+  if (cacheResultStep === void 0)
+    return { hasCachedResult: !1 };
+  if (internals.accumulatedResults?.has(cacheResultStep) !== !0)
+    return { hasCachedResult: !1 };
+  return {
+    cachedResult: internals.accumulatedResults.get(cacheResultStep),
+    hasCachedResult: !0
+  };
+}
+function createCachedResultRequest(internals, step, retryStateKey, cacheResultStep, activityName, input, cachedResult, configuration) {
+  if (configuration.advanceStepIndexForCachedRetryState)
+    internals.stepIndex += readCompletedRetrySleepCount(internals, retryStateKey);
+  if (internals.explainMode)
+    console.log(`[weft] ctx.run(${activityName}) \u2192 Returning cached result from step ${step}`);
+  return {
+    ...createBaseRequest(step, retryStateKey, cacheResultStep, activityName, input),
+    cachedResult,
+    hasCachedResult: !0,
+    retryAttempt: 1
+  };
+}
+function createRetryStateRequest(internals, step, retryStateKey, cacheResultStep, activityName, input, retryAttempt, configuration) {
+  if (configuration.advanceStepIndexForCachedRetryState)
+    internals.stepIndex += retryAttempt - 2;
+  return {
+    ...createBaseRequest(step, retryStateKey, cacheResultStep, activityName, input),
+    hasCachedResult: !1,
+    retryAttempt
+  };
+}
+function createBaseRequest(step, retryStateKey, cacheResultStep, activityName, input) {
+  return {
+    request: createReplayActivityOperation(activityName, input),
+    step,
+    retryStateKey,
+    ...cacheResultStep === void 0 ? {} : { cacheResultStep }
+  };
+}
+function createReplayActivityOperation(activityName, input) {
+  return { type: "activity", operationId: "", activityName, input };
+}

package/dist/core/context/run-operation.d.ts

@@ -1,6 +1,8 @@
 import { type Duration, type RetryPolicy, type WorkflowContext } from '../types.ts';
-import { completeActivityRetryAttempt, readActivityRetryAttempt, readCompletedRetrySleepCount } from './activity-retry-state.ts';
+import { completeActivityRetryAttempt, readActivityRetryAttempt, readCompletedRetrySleepCount, type ActivityRetryStateKey } from './activity-retry-state.ts';
+import { type ScheduleToCloseBudget } from './activity-schedule-to-close.ts';
 import type { Context } from './index.ts';
+import { type ContextInternals } from './internals.ts';
 import type { ContextOperationRequest } from './operation-request.ts';
 /**
  * Recover the concrete {@link Context} from the public {@link WorkflowContext}
@@ -15,25 +17,41 @@ import type { ContextOperationRequest } from './operation-request.ts';
  * "Context internals not initialized" from a downstream `getInternals` call.
  */
 export declare function asConcreteContext(context: WorkflowContext): Context;
-type ActivityInput = string | (Function & {
+export type ActivityInput = string | (Function & {
     retry?: RetryPolicy;
 });
-type ActivityOperationRequest = Extract<ContextOperationRequest, {
+export type ActivityOperationRequest = Extract<ContextOperationRequest, {
     type: 'activity';
 }>;
-interface RunActivityRequest<TResult> {
+export interface RunActivityRequest<TResult> {
     request: ActivityOperationRequest;
     step: number;
+    retryStateKey: ActivityRetryStateKey;
+    cacheResultStep?: number;
     hasCachedResult: boolean;
     cachedResult?: TResult;
     retryAttempt: number;
     retryPolicy?: RetryPolicy;
     scheduleToCloseTimeout?: Duration;
 }
+export type ActivityRetrySleepGenerator = (duration: number, nextAttempt: number) => Generator<ContextOperationRequest, void, unknown>;
+export interface RunActivityAtStepConfiguration {
+    explicitName?: string;
+    advanceStepIndexForCachedRetryState?: boolean;
+    retryStateKey?: ActivityRetryStateKey;
+    cacheResultStep?: number | false;
+    activityStateKey?: string;
+    retrySleep?: ActivityRetrySleepGenerator;
+}
 export declare const readActivityRetryAttemptForTesting: typeof readActivityRetryAttempt;
 export declare const readCompletedRetrySleepCountForTesting: typeof readCompletedRetrySleepCount;
 export declare const completeActivityRetryAttemptForTesting: typeof completeActivityRetryAttempt;
+export declare function readOrInitActivityRetrySleepFireAt(context: Context, operationId: string, duration: number): number;
+/** Parse the schedule-to-close budget and anchor it to the step's first dispatch. */
+export declare function resolveScheduleToCloseBudget(internals: ContextInternals, retryStateKey: ActivityRetryStateKey, scheduleToCloseTimeout: Duration | undefined): ScheduleToCloseBudget | undefined;
 export declare function shouldRetryActivityError(error: unknown, policy: RetryPolicy | undefined, attempt: number): policy is RetryPolicy;
+export declare function prepareActivityRetryRequest(request: ActivityOperationRequest, attempt: number): ActivityOperationRequest;
 export declare function createRunActivityRequest<TResult>(context: Context, activity: ActivityInput, rest: readonly unknown[], explicitName?: string): RunActivityRequest<TResult>;
+export declare function createRunActivityRequestAtStep<TResult>(context: Context, activity: ActivityInput, rest: readonly unknown[], step: number, configuration?: RunActivityAtStepConfiguration): RunActivityRequest<TResult>;
 export declare function runActivityWithRetry<TResult>(context: Context, activity: ActivityInput, rest: readonly unknown[], explicitName?: string): Generator<ContextOperationRequest, TResult, unknown>;
-export {};
+export declare function runActivityWithRetryAtStep<TResult>(context: Context, activity: ActivityInput, rest: readonly unknown[], step: number, configuration?: RunActivityAtStepConfiguration): Generator<ContextOperationRequest, TResult, unknown>;