effect-cf 0.45.0 → 0.46.1

package/src/WorkersAi.ts

@@ -5,18 +5,6 @@ import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as S from "effect/Schema";
 import type { Layer } from "effect";
-import type {
-  Ai as CloudflareAi,
-  AiAsyncBatchResponse,
-  AiGateway as CloudflareAiGateway,
-  AiModelListType,
-  AiModels,
-  AiModelsSearchObject,
-  AiModelsSearchParams,
-  AiOptions,
-  AiTextEmbeddingsInput,
-  Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input,
-} from "@cloudflare/workers-types";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
@@ -40,8 +28,7 @@ export interface WorkersAiDefinition {
   readonly binding: string;
 }
 
-export type WorkersAiBinding<ModelList extends AiModelListType = AiModels> =
-  CloudflareAi<ModelList>;
+export type WorkersAiBinding<ModelList extends AiModelListType = AiModels> = Ai<ModelList>;
 export type WorkersAiOptions = AiOptions;
 export type WorkersAiModelsSearchParams = AiModelsSearchParams;
 export type WorkersAiModelsSearchObject = AiModelsSearchObject;
@@ -113,9 +100,7 @@ export interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
   readonly models: (
     params?: WorkersAiModelsSearchParams,
   ) => Effect.Effect<ReadonlyArray<WorkersAiModelsSearchObject>, WorkersAiOperationError>;
-  readonly gateway: (
-    gatewayId: string,
-  ) => Effect.Effect<CloudflareAiGateway, WorkersAiOperationError>;
+  readonly gateway: (gatewayId: string) => Effect.Effect<AiGateway, WorkersAiOperationError>;
   readonly rawUnsafe: Effect.Effect<WorkersAiBinding<ModelList>>;
   readonly definition: WorkersAiDefinition;
 }

package/src/Workflow.ts

@@ -218,6 +218,11 @@ const fromWorkflowStep = (step: CloudflareWorkflowStep): WorkflowStepService =>
 
 type RuntimeContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
 
+/** Override to instrument the whole workflow run, then call super[RunSymbol]. */
+export const RunSymbol = Symbol.for("effect-cf/Workflow/run");
+
+export interface RunOptions extends Runtime.RunOptions {}
+
 export type WorkflowRunContext<ROut> =
   | RuntimeContext<ROut>
   | WorkflowEvent
@@ -232,10 +237,14 @@ export interface WorkflowOptions<ROut, Payload = unknown, Result = unknown> {
   readonly run: WorkflowHandler<ROut, Payload, Result>;
 }
 
-export type WorkflowClass<Payload, Result, _ROut> = new (
+export type WorkflowClass<Payload, Result, ROut> = new (
   ctx: globalThis.ExecutionContext,
   env: WorkerEnv,
 ) => CloudflareWorkflowEntrypoint<WorkerEnv, Payload> & {
+  [RunSymbol]<A, E>(
+    effect: Effect.Effect<A, E, RuntimeContext<ROut> | Scope.Scope>,
+    options?: RunOptions,
+  ): Promise<A>;
   run(
     event: Readonly<CloudflareWorkflowEvent<Payload>>,
     step: CloudflareWorkflowStep,
@@ -275,7 +284,22 @@ export const make = <ROut, LayerError, Payload = unknown, Result = unknown>(
         Layer.succeed(WorkflowStep, fromWorkflowStep(step)),
       );
 
-      return Runtime.runEventPromise(this.runtime, options.run(event.payload), workflowServices);
+      return this[RunSymbol](
+        options.run(event.payload).pipe(Effect.provide(workflowServices, { local: true })),
+      );
+    }
+
+    [RunSymbol]<A, E>(
+      effect: Effect.Effect<A, E, RuntimeContext<ROut> | Scope.Scope>,
+      runOptions: RunOptions = {},
+    ): Promise<A> {
+      return Runtime.runEventPromise(
+        this.runtime,
+        effect,
+        undefined,
+        undefined,
+        runOptions.onFailure,
+      );
     }
   }
 

package/src/WorkflowBinding.ts

@@ -1,12 +1,3 @@
-import type {
-  InstanceStatus as CloudflareInstanceStatus,
-  Workflow as CloudflareWorkflow,
-  WorkflowInstance as CloudflareWorkflowInstance,
-  WorkflowInstanceCreateOptions as CloudflareWorkflowInstanceCreateOptions,
-  WorkflowInstanceLocationHint as CloudflareWorkflowInstanceLocationHint,
-  WorkflowInstanceRestartOptions as CloudflareWorkflowInstanceRestartOptions,
-  WorkflowInstanceTerminateOptions as CloudflareWorkflowInstanceTerminateOptions,
-} from "@cloudflare/workers-types";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
@@ -21,7 +12,7 @@ import * as ErrorMessage from "./internal/ErrorMessage";
 const expectedWorkflow = "Workflow binding with create(), createBatch(), and get()";
 
 export type WorkflowInstanceCreateOptions<Payload> = Omit<
-  CloudflareWorkflowInstanceCreateOptions<Payload>,
+  globalThis.WorkflowInstanceCreateOptions<Payload>,
   "params"
 >;
 
@@ -29,11 +20,11 @@ export type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown
   { readonly payload: Payload } & WorkflowInstanceCreateOptions<EncodedPayload>
 >;
 
-export type WorkflowInstanceRestartOptions = CloudflareWorkflowInstanceRestartOptions;
-export type WorkflowInstanceTerminateOptions = CloudflareWorkflowInstanceTerminateOptions;
-export type WorkflowInstanceLocationHint = CloudflareWorkflowInstanceLocationHint;
+export type WorkflowInstanceLocationHint = globalThis.WorkflowInstanceLocationHint;
+export type WorkflowInstanceRestartOptions = globalThis.WorkflowInstanceRestartOptions;
+export type WorkflowInstanceTerminateOptions = globalThis.WorkflowInstanceTerminateOptions;
 
-export type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
+export type WorkflowInstanceStatusName = InstanceStatus["status"];
 
 export interface WorkflowInstanceStatus<Result> {
   readonly status: WorkflowInstanceStatusName;
@@ -45,7 +36,7 @@ export interface WorkflowInstanceStatus<Result> {
 }
 
 export interface WorkflowInstance<Result> {
-  readonly raw: CloudflareWorkflowInstance;
+  readonly raw: globalThis.WorkflowInstance;
   readonly id: string;
   readonly pause: Effect.Effect<void, WorkflowOperationError>;
   readonly resume: Effect.Effect<void, WorkflowOperationError>;
@@ -97,7 +88,7 @@ export interface WorkflowBindingClient<
   readonly get: (
     instanceId: string,
   ) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareWorkflow<S.Codec.Encoded<Payload>>>;
+  readonly rawUnsafe: Effect.Effect<Workflow<S.Codec.Encoded<Payload>>>;
 }
 
 export class WorkflowOperationError extends Data.TaggedError("WorkflowOperationError")<{
@@ -136,7 +127,7 @@ const tryWorkflowPromise = <A>(
 type WorkflowBindingValue = S.Schema.Type<typeof S.Unknown>;
 
 const WorkflowBindingSchema = S.declare(
-  (value: WorkflowBindingValue): value is CloudflareWorkflow<WorkflowBindingValue> =>
+  (value: WorkflowBindingValue): value is Workflow<WorkflowBindingValue> =>
     Predicate.hasProperty(value, "create") &&
     Predicate.isFunction(value.create) &&
     Predicate.hasProperty(value, "createBatch") &&
@@ -146,18 +137,15 @@ const WorkflowBindingSchema = S.declare(
 );
 const decodeWorkflowBinding = S.decodeUnknownOption(WorkflowBindingSchema);
 
-export const isWorkflow = <Payload>(
-  value: WorkflowBindingValue,
-): value is CloudflareWorkflow<Payload> => Option.isSome(decodeWorkflowBinding(value));
+export const isWorkflow = <Payload>(value: WorkflowBindingValue): value is Workflow<Payload> =>
+  Option.isSome(decodeWorkflowBinding(value));
 
 export const makeClient = <
   Payload extends RpcDefinition.ServiceFreeSchema,
   Result extends RpcDefinition.ServiceFreeSchema,
 >(
   definition: WorkflowBindingDefinition<Payload, Result>,
-): ((
-  workflow: CloudflareWorkflow<S.Codec.Encoded<Payload>>,
-) => WorkflowBindingClient<Payload, Result>) => {
+): ((workflow: Workflow<S.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>) => {
   type PayloadValue = S.Schema.Type<Payload>;
   type EncodedPayload = S.Codec.Encoded<Payload>;
   type ResultValue = S.Schema.Type<Result>;
@@ -165,7 +153,7 @@ export const makeClient = <
   const encodePayload = S.encodeEffect(definition.payload);
   const decodeResult = S.decodeUnknownEffect(definition.result);
 
-  const wrapInstance = (raw: CloudflareWorkflowInstance): WorkflowInstance<ResultValue> => {
+  const wrapInstance = (raw: globalThis.WorkflowInstance): WorkflowInstance<ResultValue> => {
     const operation = <A>(name: string, evaluate: () => Promise<A>) =>
       tryWorkflowPromise(definition.binding, name, evaluate);
 
@@ -229,7 +217,7 @@ export const makeClient = <
     createBatch: Effect.fn("WorkflowBinding.createBatch", {
       attributes: { binding: definition.binding, operation: "createBatch" },
     })(function* (batch: WorkflowInstanceCreateBatchOptions<PayloadValue, EncodedPayload>) {
-      const encodedBatch: Array<CloudflareWorkflowInstanceCreateOptions<EncodedPayload>> = [];
+      const encodedBatch: Array<globalThis.WorkflowInstanceCreateOptions<EncodedPayload>> = [];
 
       for (const item of batch) {
         const { payload, ...options } = item;
@@ -265,7 +253,7 @@ export const layer = <
   Binding.layer(
     tag,
     definition.binding,
-    (value): value is CloudflareWorkflow<S.Codec.Encoded<Payload>> =>
+    (value): value is Workflow<S.Codec.Encoded<Payload>> =>
       isWorkflow<S.Codec.Encoded<Payload>>(value),
     makeClient(definition),
     { expected: expectedWorkflow },

package/src/internal/Runtime.ts

@@ -1,3 +1,4 @@
+import * as Cause from "effect/Cause";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -8,6 +9,44 @@ import { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "../Environment"
 import * as RpcTargets from "../RpcTargets";
 import { provideEntrypointServices } from "./Entrypoint";
 
+export interface RunOptions {
+  /**
+   * Observes a failed event's complete cause, including interruption, after its
+   * scope closes and before the native Promise rejects. Also observes runtime
+   * acquisition failures. Called once per failed invocation, never on success.
+   * Returned Promises are awaited; throws and rejections are ignored. The
+   * observer must settle and cannot use resources from the closed event scope.
+   * Reporting, filtering and privacy remain the caller's responsibility.
+   */
+  readonly onFailure?: (cause: Cause.Cause<unknown>) => void | Promise<void>;
+}
+
+const runPromise = <A, E, R, LayerError>(
+  runtime: ManagedRuntime.ManagedRuntime<R, LayerError>,
+  effect: Effect.Effect<A, E, R>,
+  onFailure: RunOptions["onFailure"],
+): Promise<A> => {
+  if (onFailure === undefined) {
+    return runtime.runPromise(effect);
+  }
+
+  return runtime.runPromiseExit(effect).then(async (exit) => {
+    if (exit._tag === "Success") {
+      return exit.value;
+    }
+
+    const rejection = Cause.squash(exit.cause);
+
+    try {
+      await onFailure(exit.cause);
+    } catch {
+      // An observer cannot change the event's outcome.
+    }
+
+    throw rejection;
+  });
+};
+
 /**
  * Assembles the shared `ManagedRuntime` used by the Cloudflare entrypoint
  * classes (Worker, Durable Object, Workflow).
@@ -36,6 +75,7 @@ export function runEventPromise<A, E, R, LayerError>(
   effect: Effect.Effect<A, E, NoInfer<R> | Scope.Scope>,
   eventLayer?: undefined,
   parent?: Tracer.AnySpan,
+  onFailure?: RunOptions["onFailure"],
 ): Promise<A>;
 /** Builds and provides an event layer inside the event effect's scope. */
 export function runEventPromise<A, E, R, REvent, EventLayerError, LayerError>(
@@ -43,6 +83,7 @@ export function runEventPromise<A, E, R, REvent, EventLayerError, LayerError>(
   effect: Effect.Effect<A, E, NoInfer<R> | REvent | Scope.Scope>,
   eventLayer: Layer.Layer<REvent, EventLayerError, NoInfer<R>>,
   parent?: Tracer.AnySpan,
+  onFailure?: RunOptions["onFailure"],
 ): Promise<A>;
 export function runEventPromise<A, E, R, REvent, EventLayerError, LayerError>(
   ...args:
@@ -51,25 +92,35 @@ export function runEventPromise<A, E, R, REvent, EventLayerError, LayerError>(
         effect: Effect.Effect<A, E, R | Scope.Scope>,
         eventLayer?: undefined,
         parent?: Tracer.AnySpan,
+        onFailure?: RunOptions["onFailure"],
       ]
     | readonly [
         runtime: ManagedRuntime.ManagedRuntime<R, LayerError>,
         effect: Effect.Effect<A, E, R | REvent | Scope.Scope>,
         eventLayer: Layer.Layer<REvent, EventLayerError, R>,
         parent?: Tracer.AnySpan,
+        onFailure?: RunOptions["onFailure"],
       ]
 ): Promise<A> {
-  const [runtime, effect, eventLayer, parent] = args;
+  const [runtime, effect, eventLayer, parent, onFailure] = args;
 
   if (eventLayer === undefined) {
     const event = Effect.scoped(RpcTargets.withScope(effect));
 
-    return runtime.runPromise(parent === undefined ? event : Effect.withParentSpan(event, parent));
+    return runPromise(
+      runtime,
+      parent === undefined ? event : Effect.withParentSpan(event, parent),
+      onFailure,
+    );
   }
 
   const event = Effect.scoped(
     RpcTargets.withScope(effect.pipe(Effect.provide(eventLayer, { local: true }))),
   );
 
-  return runtime.runPromise(parent === undefined ? event : Effect.withParentSpan(event, parent));
+  return runPromise(
+    runtime,
+    parent === undefined ? event : Effect.withParentSpan(event, parent),
+    onFailure,
+  );
 }