effect-cf 0.13.1 → 0.15.0

package/src/Vectorize.ts

@@ -0,0 +1,213 @@
+import { Context, Data, Effect, type Layer } from "effect";
+import type {
+  Vectorize as CloudflareVectorize,
+  VectorizeAsyncMutation as CloudflareVectorizeAsyncMutation,
+  VectorizeIndex as CloudflareVectorizeIndex,
+  VectorizeIndexDetails as CloudflareVectorizeIndexDetails,
+  VectorizeIndexInfo as CloudflareVectorizeIndexInfo,
+  VectorizeMatch as CloudflareVectorizeMatch,
+  VectorizeMatches as CloudflareVectorizeMatches,
+  VectorizeQueryOptions as CloudflareVectorizeQueryOptions,
+  VectorizeVector as CloudflareVectorizeVector,
+  VectorizeVectorMetadata as CloudflareVectorizeVectorMetadata,
+  VectorizeVectorMetadataFilter as CloudflareVectorizeVectorMetadataFilter,
+  VectorizeVectorMetadataValue as CloudflareVectorizeVectorMetadataValue,
+  VectorizeVectorMutation as CloudflareVectorizeVectorMutation,
+} from "@cloudflare/workers-types";
+
+import * as Binding from "./Binding";
+import type { WorkerEnvironment } from "./Environment";
+
+const expectedVectorizeBinding =
+  "Vectorize index binding with describe(), query(), insert(), upsert(), deleteByIds(), and getByIds()";
+
+/** Error raised when a Vectorize operation fails. */
+export class VectorizeOperationError extends Data.TaggedError("VectorizeOperationError")<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+
+/** Typed Vectorize binding definition. */
+export interface VectorizeDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+
+export type VectorizeBinding = CloudflareVectorize | CloudflareVectorizeIndex;
+export type VectorizeVector = CloudflareVectorizeVector;
+export type VectorizeVectorMetadata = CloudflareVectorizeVectorMetadata;
+export type VectorizeVectorMetadataValue = CloudflareVectorizeVectorMetadataValue;
+export type VectorizeVectorMetadataFilter = CloudflareVectorizeVectorMetadataFilter;
+export type VectorizeQueryOptions = CloudflareVectorizeQueryOptions;
+export type VectorizeMatches = CloudflareVectorizeMatches;
+export type VectorizeMatch = CloudflareVectorizeMatch;
+export type VectorizeIndexInfo = CloudflareVectorizeIndexInfo;
+export type VectorizeIndexDetails = CloudflareVectorizeIndexDetails;
+export type VectorizeMutation =
+  | CloudflareVectorizeAsyncMutation
+  | CloudflareVectorizeVectorMutation;
+export type VectorizeValues = Float32Array | Float64Array | ReadonlyArray<number>;
+
+interface VectorizeRuntimeBinding {
+  readonly describe: () => Promise<VectorizeIndexInfo | VectorizeIndexDetails>;
+  readonly query: (
+    vector: Float32Array | Float64Array | number[],
+    options?: VectorizeQueryOptions,
+  ) => Promise<VectorizeMatches>;
+  readonly queryById?: (
+    vectorId: string,
+    options?: VectorizeQueryOptions,
+  ) => Promise<VectorizeMatches>;
+  readonly insert: (vectors: Array<VectorizeVector>) => Promise<VectorizeMutation>;
+  readonly upsert: (vectors: Array<VectorizeVector>) => Promise<VectorizeMutation>;
+  readonly deleteByIds: (ids: Array<string>) => Promise<VectorizeMutation>;
+  readonly getByIds: (ids: Array<string>) => Promise<Array<VectorizeVector>>;
+}
+
+export interface VectorizeClient {
+  readonly describe: Effect.Effect<
+    VectorizeIndexInfo | VectorizeIndexDetails,
+    VectorizeOperationError
+  >;
+  readonly query: (
+    vector: VectorizeValues,
+    options?: VectorizeQueryOptions,
+  ) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
+  readonly queryById: (
+    vectorId: string,
+    options?: VectorizeQueryOptions,
+  ) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
+  readonly insert: (
+    vectors: ReadonlyArray<VectorizeVector>,
+  ) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly upsert: (
+    vectors: ReadonlyArray<VectorizeVector>,
+  ) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly deleteByIds: (
+    ids: ReadonlyArray<string>,
+  ) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly delete: (
+    ids: ReadonlyArray<string>,
+  ) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly getByIds: (
+    ids: ReadonlyArray<string>,
+  ) => Effect.Effect<ReadonlyArray<VectorizeVector>, VectorizeOperationError>;
+  readonly unsafeRaw: Effect.Effect<VectorizeBinding>;
+  readonly definition: VectorizeDefinition;
+}
+
+declare const VectorizeServiceTypeId: unique symbol;
+
+/** Nominal service marker for Vectorize services created with {@link make}. */
+export interface VectorizeService<Id extends string> {
+  readonly [VectorizeServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
+  Self,
+  Id,
+  VectorizeClient
+> {
+  readonly id: Id;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
+const vectorizeError = (binding: string, operation: string, cause: unknown) =>
+  new VectorizeOperationError({ binding, operation, cause });
+
+const tryVectorizePromise = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => Promise<A>,
+): Effect.Effect<A, VectorizeOperationError> =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => vectorizeError(binding, operation, cause),
+  });
+
+const hasFunction = (value: object, key: string): boolean =>
+  typeof Reflect.get(value, key) === "function";
+
+export const isVectorizeBinding = (value: unknown): value is VectorizeBinding =>
+  typeof value === "object" &&
+  value !== null &&
+  hasFunction(value, "describe") &&
+  hasFunction(value, "query") &&
+  hasFunction(value, "insert") &&
+  hasFunction(value, "upsert") &&
+  hasFunction(value, "deleteByIds") &&
+  hasFunction(value, "getByIds");
+
+export const makeClient =
+  (definition: VectorizeDefinition) =>
+  (index: VectorizeBinding): VectorizeClient => {
+    const runtime = index as VectorizeRuntimeBinding;
+    const deleteByIds = (ids: ReadonlyArray<string>) =>
+      tryVectorizePromise(definition.binding, "deleteByIds", () => runtime.deleteByIds([...ids]));
+
+    return {
+      definition,
+      describe: tryVectorizePromise(definition.binding, "describe", () => runtime.describe()),
+      query: (vector, options) =>
+        tryVectorizePromise(definition.binding, "query", () =>
+          runtime.query(vector as Float32Array | Float64Array | number[], options),
+        ),
+      queryById: (vectorId, options) =>
+        runtime.queryById !== undefined
+          ? tryVectorizePromise(definition.binding, "queryById", () =>
+              runtime.queryById!(vectorId, options),
+            )
+          : Effect.fail(
+              vectorizeError(
+                definition.binding,
+                "queryById",
+                new TypeError("Vectorize binding does not expose queryById()"),
+              ),
+            ),
+      insert: (vectors) =>
+        tryVectorizePromise(definition.binding, "insert", () => runtime.insert([...vectors])),
+      upsert: (vectors) =>
+        tryVectorizePromise(definition.binding, "upsert", () => runtime.upsert([...vectors])),
+      deleteByIds,
+      delete: deleteByIds,
+      getByIds: (ids) =>
+        tryVectorizePromise(definition.binding, "getByIds", () => runtime.getByIds([...ids])),
+      unsafeRaw: Effect.succeed(index),
+    };
+  };
+
+export const layer = <Self>(
+  tag: Context.Service<Self, VectorizeClient>,
+  definition: VectorizeDefinition,
+) =>
+  Binding.layer(tag, definition.binding, isVectorizeBinding, makeClient(definition), {
+    expected: expectedVectorizeBinding,
+  });
+
+export const make = <Id extends string>(id: Id) => Tag<VectorizeService<Id>>()<Id>(id);
+
+export const Tag =
+  <Self>() =>
+  <Id extends string>(id: Id) => {
+    const tag = Context.Service<Self, VectorizeClient>()(id);
+
+    const makeLayer = (definition: LayerOptions) => layer(tag, definition);
+
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+    }) as TagClass<Self, Id>;
+  };

package/src/WorkersAi.ts

@@ -0,0 +1,239 @@
+import { Context, Data, Effect, 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";
+
+const expectedWorkersAiBinding = "Workers AI binding with run(), gateway(), and models()";
+
+/** Error raised when a Workers AI operation fails. */
+export class WorkersAiOperationError extends Data.TaggedError("WorkersAiOperationError")<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+
+/** Typed Workers AI binding definition. */
+export interface WorkersAiDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+
+export type WorkersAiBinding<ModelList extends AiModelListType = AiModels> =
+  CloudflareAi<ModelList>;
+export type WorkersAiOptions = AiOptions;
+export type WorkersAiModelsSearchParams = AiModelsSearchParams;
+export type WorkersAiModelsSearchObject = AiModelsSearchObject;
+export type WorkersAiAsyncBatchResponse = AiAsyncBatchResponse;
+export type WorkersAiEmbeddingInput =
+  | AiTextEmbeddingsInput
+  | Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input
+  | Record<string, unknown>;
+
+export interface WorkersAiEmbeddingResponse {
+  readonly data: ReadonlyArray<ReadonlyArray<number>>;
+  readonly shape: ReadonlyArray<number>;
+}
+
+export interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
+  readonly aiGatewayLogId: Effect.Effect<string | null, WorkersAiOperationError>;
+  readonly run: {
+    <Name extends keyof ModelList>(
+      model: Name,
+      input: {
+        readonly requests: ReadonlyArray<ModelList[Name]["inputs"]>;
+      },
+      options: WorkersAiOptions & {
+        readonly queueRequest: true;
+      },
+    ): Effect.Effect<WorkersAiAsyncBatchResponse, WorkersAiOperationError>;
+    <Name extends keyof ModelList>(
+      model: Name,
+      input: ModelList[Name]["inputs"],
+      options: WorkersAiOptions & {
+        readonly returnRawResponse: true;
+      },
+    ): Effect.Effect<Response, WorkersAiOperationError>;
+    <Name extends keyof ModelList>(
+      model: Name,
+      input: ModelList[Name]["inputs"],
+      options: WorkersAiOptions & {
+        readonly websocket: true;
+      },
+    ): Effect.Effect<Response, WorkersAiOperationError>;
+    <Name extends keyof ModelList>(
+      model: Name,
+      input: ModelList[Name]["inputs"] & {
+        readonly stream: true;
+      },
+      options?: WorkersAiOptions,
+    ): Effect.Effect<ReadableStream, WorkersAiOperationError>;
+    <Name extends keyof ModelList>(
+      model: Name,
+      input: ModelList[Name]["inputs"],
+      options?: WorkersAiOptions,
+    ): Effect.Effect<ModelList[Name]["postProcessedOutputs"], WorkersAiOperationError>;
+    <Input extends Record<string, unknown>, Output = Record<string, unknown>>(
+      model: string,
+      input: Input,
+      options?: WorkersAiOptions,
+    ): Effect.Effect<Output, WorkersAiOperationError>;
+  };
+  readonly runEmbedding: <Input extends WorkersAiEmbeddingInput>(
+    model: string,
+    input: Input,
+    options?: WorkersAiOptions,
+  ) => Effect.Effect<WorkersAiEmbeddingResponse, WorkersAiOperationError>;
+  readonly models: (
+    params?: WorkersAiModelsSearchParams,
+  ) => Effect.Effect<ReadonlyArray<WorkersAiModelsSearchObject>, WorkersAiOperationError>;
+  readonly gateway: (
+    gatewayId: string,
+  ) => Effect.Effect<CloudflareAiGateway, WorkersAiOperationError>;
+  readonly unsafeRaw: Effect.Effect<WorkersAiBinding<ModelList>>;
+  readonly definition: WorkersAiDefinition;
+}
+
+declare const WorkersAiServiceTypeId: unique symbol;
+
+/** Nominal service marker for Workers AI services created with {@link make}. */
+export interface WorkersAiService<Id extends string> {
+  readonly [WorkersAiServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<
+  Self,
+  Id extends string,
+  ModelList extends AiModelListType = AiModels,
+> extends Context.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
+  readonly id: Id;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
+const workersAiError = (binding: string, operation: string, cause: unknown) =>
+  new WorkersAiOperationError({ binding, operation, cause });
+
+const tryWorkersAiPromise = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => Promise<A>,
+): Effect.Effect<A, WorkersAiOperationError> =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => workersAiError(binding, operation, cause),
+  });
+
+const tryWorkersAiSync = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => A,
+): Effect.Effect<A, WorkersAiOperationError> =>
+  Effect.try({
+    try: evaluate,
+    catch: (cause) => workersAiError(binding, operation, cause),
+  });
+
+const hasFunction = (value: object, key: string): boolean =>
+  typeof Reflect.get(value, key) === "function";
+
+export const isWorkersAiBinding = (value: unknown): value is WorkersAiBinding =>
+  typeof value === "object" &&
+  value !== null &&
+  hasFunction(value, "run") &&
+  hasFunction(value, "gateway") &&
+  hasFunction(value, "models");
+
+export const embeddingResponse = (value: {
+  readonly data?: ReadonlyArray<ReadonlyArray<number>>;
+  readonly shape?: ReadonlyArray<number>;
+}): WorkersAiEmbeddingResponse => ({
+  data: value.data ?? [],
+  shape: value.shape ?? [],
+});
+
+export const makeClient =
+  <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) =>
+  (ai: WorkersAiBinding<ModelList>): WorkersAiClient<ModelList> => {
+    const run = ((model: string, input: Record<string, unknown>, options?: WorkersAiOptions) =>
+      tryWorkersAiPromise(definition.binding, "run", () =>
+        ai.run(model as string & {}, input, options),
+      )) as WorkersAiClient<ModelList>["run"];
+
+    return {
+      definition,
+      aiGatewayLogId: tryWorkersAiSync(
+        definition.binding,
+        "aiGatewayLogId",
+        () => ai.aiGatewayLogId,
+      ),
+      run,
+      runEmbedding: (model, input, options) =>
+        run(model, input, options).pipe(
+          Effect.map((response) =>
+            embeddingResponse(
+              response as {
+                readonly data?: ReadonlyArray<ReadonlyArray<number>>;
+                readonly shape?: ReadonlyArray<number>;
+              },
+            ),
+          ),
+        ),
+      models: (params) =>
+        tryWorkersAiPromise(definition.binding, "models", () => ai.models(params)),
+      gateway: (gatewayId) =>
+        tryWorkersAiSync(definition.binding, "gateway", () => ai.gateway(gatewayId)),
+      unsafeRaw: Effect.succeed(ai),
+    };
+  };
+
+export const layer = <Self, ModelList extends AiModelListType = AiModels>(
+  tag: Context.Service<Self, WorkersAiClient<ModelList>>,
+  definition: WorkersAiDefinition,
+) =>
+  Binding.layer(
+    tag,
+    definition.binding,
+    (value): value is WorkersAiBinding<ModelList> => isWorkersAiBinding(value),
+    makeClient<ModelList>(definition),
+    {
+      expected: expectedWorkersAiBinding,
+    },
+  );
+
+export const make = <Id extends string>(id: Id) => Tag<WorkersAiService<Id>>()<Id, AiModels>(id);
+
+export const Tag =
+  <Self>() =>
+  <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => {
+    const tag = Context.Service<Self, WorkersAiClient<ModelList>>()(id);
+
+    const makeLayer = (definition: LayerOptions) => layer(tag, definition);
+
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+    }) as TagClass<Self, Id, ModelList>;
+  };

package/src/Workflow.ts

@@ -21,6 +21,7 @@ export interface WorkflowEventService<Payload = unknown> {
   readonly payload: Payload;
   readonly timestamp: Date;
   readonly instanceId: string;
+  readonly workflowName: string;
 }
 
 export class WorkflowEvent extends Context.Service<WorkflowEvent, WorkflowEventService>()(
@@ -63,6 +64,7 @@ const fromWorkflowEvent = <Payload>(
   payload: event.payload,
   timestamp: event.timestamp,
   instanceId: event.instanceId,
+  workflowName: event.workflowName,
 });
 
 const fromWorkflowStep = (

package/src/WorkflowBinding.ts

@@ -1,3 +1,9 @@
+import type {
+  InstanceStatus as CloudflareInstanceStatus,
+  Workflow as CloudflareWorkflow,
+  WorkflowInstance as CloudflareWorkflowInstance,
+  WorkflowInstanceCreateOptions as CloudflareWorkflowInstanceCreateOptions,
+} from "@cloudflare/workers-types";
 import { Context, Data, Effect, Option, Schema as S } from "effect";
 
 import * as Binding from "./Binding";
@@ -6,7 +12,7 @@ import type * as RpcDefinition from "./RpcDefinition";
 const expectedWorkflow = "Workflow binding with create(), createBatch(), and get()";
 
 export type WorkflowInstanceCreateOptions<Payload> = Omit<
-  globalThis.WorkflowInstanceCreateOptions<Payload>,
+  CloudflareWorkflowInstanceCreateOptions<Payload>,
   "params"
 >;
 
@@ -22,7 +28,7 @@ export interface WorkflowInstanceRestartOptions {
   };
 }
 
-export type WorkflowInstanceStatusName = globalThis.InstanceStatus["status"];
+export type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
 
 export interface WorkflowInstanceStatus<Result> {
   readonly status: WorkflowInstanceStatusName;
@@ -34,7 +40,7 @@ export interface WorkflowInstanceStatus<Result> {
 }
 
 export interface WorkflowInstance<Result> {
-  readonly raw: globalThis.WorkflowInstance;
+  readonly raw: CloudflareWorkflowInstance;
   readonly id: string;
   readonly pause: Effect.Effect<void, WorkflowOperationError>;
   readonly resume: Effect.Effect<void, WorkflowOperationError>;
@@ -86,7 +92,7 @@ export interface WorkflowBindingClient<
   readonly get: (
     instanceId: string,
   ) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError>;
-  readonly unsafeRaw: Effect.Effect<globalThis.Workflow<S.Codec.Encoded<Payload>>>;
+  readonly unsafeRaw: Effect.Effect<CloudflareWorkflow<S.Codec.Encoded<Payload>>>;
 }
 
 export class WorkflowOperationError extends Data.TaggedError("WorkflowOperationError")<{
@@ -114,7 +120,7 @@ const tryWorkflowPromise = <A>(
     catch: (cause) => workflowError(binding, operation, cause),
   });
 
-export const isWorkflow = <Payload>(value: unknown): value is globalThis.Workflow<Payload> => {
+export const isWorkflow = <Payload>(value: unknown): value is CloudflareWorkflow<Payload> => {
   if (typeof value !== "object" || value === null) {
     return false;
   }
@@ -134,7 +140,7 @@ export const makeClient = <
 >(
   definition: WorkflowBindingDefinition<Payload, Result>,
 ): ((
-  workflow: globalThis.Workflow<S.Codec.Encoded<Payload>>,
+  workflow: CloudflareWorkflow<S.Codec.Encoded<Payload>>,
 ) => WorkflowBindingClient<Payload, Result>) => {
   type PayloadValue = S.Schema.Type<Payload>;
   type EncodedPayload = S.Codec.Encoded<Payload>;
@@ -143,7 +149,7 @@ export const makeClient = <
   const encodePayload = S.encodeEffect(definition.payload);
   const decodeResult = S.decodeUnknownEffect(definition.result);
 
-  const wrapInstance = (raw: globalThis.WorkflowInstance): WorkflowInstance<ResultValue> => {
+  const wrapInstance = (raw: CloudflareWorkflowInstance): WorkflowInstance<ResultValue> => {
     const operation = <A>(name: string, evaluate: () => Promise<A>) =>
       tryWorkflowPromise(definition.binding, name, evaluate);
 
@@ -205,7 +211,7 @@ export const makeClient = <
     createBatch: Effect.fnUntraced(function* (
       batch: WorkflowInstanceCreateBatchOptions<PayloadValue, EncodedPayload>,
     ) {
-      const encodedBatch: Array<globalThis.WorkflowInstanceCreateOptions<EncodedPayload>> = [];
+      const encodedBatch: Array<CloudflareWorkflowInstanceCreateOptions<EncodedPayload>> = [];
 
       for (const item of batch) {
         const { payload, ...options } = item;
@@ -241,7 +247,7 @@ export const layer = <
   Binding.layer(
     tag,
     definition.binding,
-    (value): value is globalThis.Workflow<S.Codec.Encoded<Payload>> =>
+    (value): value is CloudflareWorkflow<S.Codec.Encoded<Payload>> =>
       isWorkflow<S.Codec.Encoded<Payload>>(value),
     makeClient(definition),
     { expected: expectedWorkflow },

package/src/index.ts

@@ -1,4 +1,6 @@
+export * as AiGateway from "./AiGateway";
 export * as Binding from "./Binding";
+export * as BrowserRendering from "./BrowserRendering";
 export * as CloudflareOtlp from "./CloudflareOtlp";
 export * as D1 from "./D1";
 export * as DurableObject from "./DurableObject";
@@ -10,6 +12,7 @@ export * as DurableObjectSqlite from "./DurableObjectSqlite";
 export * as DurableObjectState from "./DurableObjectState";
 export * as DurableObjectWebSocket from "./DurableObjectWebSocket";
 export * as DurableObjectStorage from "./DurableObjectStorage";
+export * as Email from "./Email";
 export * as Hyperdrive from "./Hyperdrive";
 export * as Images from "./Images";
 export * as Kv from "./Kv";
@@ -25,4 +28,6 @@ export * as WorkerDefinition from "./WorkerDefinition";
 export * as Workflow from "./Workflow";
 export * as WorkflowBinding from "./WorkflowBinding";
 export * as WorkflowDefinition from "./WorkflowDefinition";
+export * as Vectorize from "./Vectorize";
+export * as WorkersAi from "./WorkersAi";
 export { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "./Environment";