alchemy 2.0.0-beta.46 → 2.0.0-beta.47

package/src/Cloudflare/AiGateway/index.ts

@@ -1,2 +1,3 @@
 export * from "./AiGateway.ts";
 export * from "./AiGatewayBinding.ts";
+export * from "./LanguageModel.ts";

package/src/Cloudflare/StateStore/State.ts

@@ -57,124 +57,130 @@ export const state = () =>
       const profileName = yield* ALCHEMY_PROFILE;
       const localStage = `${profileName}_${scriptName}`;
       const credStore = yield* CredentialsStore;
-      if (yield* hasLocalStack(localStage)) {
-        // if there's still a local stack, then we need to finish the bootstrap
-        // TODO(sam): what if the local stack was
-        return yield* deployWithLocalState({
-          scriptName,
-          profileName,
-          isCI,
-          force: false,
-        });
-      }
-
-      const ensureLatest = ({
-        url,
-        authToken,
-      }: {
-        url: string;
-        authToken: string;
-      }) =>
-        Effect.gen(function* () {
-          const { matches, expected, observed } =
-            yield* checkStateStoreVersion(url);
-
-          if (observed === undefined) {
-            const shouldDeploy = yield* Clank.confirm({
-              message: `Cloudflare State Store '${scriptName}' is not available. Do you want to deploy it?`,
-            });
-            if (shouldDeploy) {
-              return yield* bootstrap({
-                workerName: scriptName,
-                profile: profileName,
-              });
-            } else {
-              return yield* Effect.die(new Clank.PromptCancelled());
-            }
-          }
+      const context = yield* Effect.context<Effect.Services<typeof init>>();
+
+      const init = Effect.gen(function* () {
+        if (yield* hasLocalStack(localStage)) {
+          // if there's still a local stack, then we need to finish the bootstrap
+          // TODO(sam): what if the local stack was
+          return yield* deployWithLocalState({
+            scriptName,
+            profileName,
+            isCI,
+            force: false,
+          });
+        }
 
-          const httpState = yield* ensureAccess({ url, authToken });
-          if (matches) {
-            return httpState;
-          } else if (isCI) {
-            return yield* Effect.die(
-              new AuthError({
-                message: `Cloudflare State store not found. Run 'alchemy bootstrap cloudflare --profile <your-ci-profile>' to deploy it first.`,
-              }),
-            );
-          } else {
-            const shouldDeploy = yield* Clank.confirm({
-              message:
-                `Cloudflare State Store '${scriptName}' is out of date ` +
-                `(expected v${expected}, observed v${observed ?? "unknown"})`,
-            });
-            if (shouldDeploy) {
-              const stateStoreOptions = yield* deployStateStore({
-                stage: scriptName,
-                state: httpState,
-                force: false,
+        const ensureLatest = ({
+          url,
+          authToken,
+        }: {
+          url: string;
+          authToken: string;
+        }) =>
+          Effect.gen(function* () {
+            const { matches, expected, observed } =
+              yield* checkStateStoreVersion(url);
+
+            if (observed === undefined) {
+              const shouldDeploy = yield* Clank.confirm({
+                message: `Cloudflare State Store '${scriptName}' is not available. Do you want to deploy it?`,
               });
-              return yield* makeCloudflareStateStore(stateStoreOptions);
-            } else {
-              return yield* Effect.die(new Clank.PromptCancelled());
+              if (shouldDeploy) {
+                return yield* bootstrap({
+                  workerName: scriptName,
+                  profile: profileName,
+                });
+              } else {
+                return yield* Effect.die(new Clank.PromptCancelled());
+              }
             }
-          }
-        });
 
-      const ensureAccess = (credentials: HttpStateStoreCredentials) =>
-        Effect.gen(function* () {
-          const isAuth = yield* checkHttpStateStoreAuth(credentials);
-          if (!isAuth) {
-            // our token is wrong, force a refresh
-            yield* Clank.info(
-              `Cloudflare State store authentication failed, refreshing credentials...`,
-            );
-            const credentials = yield* loginWithCloudflare(profileName, true);
-            if (!(yield* checkHttpStateStoreAuth(credentials))) {
+            const httpState = yield* ensureAccess({ url, authToken });
+            if (matches) {
+              return httpState;
+            } else if (isCI) {
               return yield* Effect.die(
                 new AuthError({
-                  message: `Cloudflare State store authentication failed, after refreshing credentials.`,
+                  message: `Cloudflare State store not found. Run 'alchemy bootstrap cloudflare --profile <your-ci-profile>' to deploy it first.`,
                 }),
               );
+            } else {
+              const shouldDeploy = yield* Clank.confirm({
+                message:
+                  `Cloudflare State Store '${scriptName}' is out of date ` +
+                  `(expected v${expected}, observed v${observed ?? "unknown"})`,
+              });
+              if (shouldDeploy) {
+                const stateStoreOptions = yield* deployStateStore({
+                  stage: scriptName,
+                  state: httpState,
+                  force: false,
+                });
+                return yield* makeCloudflareStateStore(stateStoreOptions);
+              } else {
+                return yield* Effect.die(new Clank.PromptCancelled());
+              }
+            }
+          });
+
+        const ensureAccess = (credentials: HttpStateStoreCredentials) =>
+          Effect.gen(function* () {
+            const isAuth = yield* checkHttpStateStoreAuth(credentials);
+            if (!isAuth) {
+              // our token is wrong, force a refresh
+              yield* Clank.info(
+                `Cloudflare State store authentication failed, refreshing credentials...`,
+              );
+              const credentials = yield* loginWithCloudflare(profileName, true);
+              if (!(yield* checkHttpStateStoreAuth(credentials))) {
+                return yield* Effect.die(
+                  new AuthError({
+                    message: `Cloudflare State store authentication failed, after refreshing credentials.`,
+                  }),
+                );
+              }
+              return yield* makeCloudflareStateStore(credentials);
             }
             return yield* makeCloudflareStateStore(credentials);
-          }
-          return yield* makeCloudflareStateStore(credentials);
-        });
+          });
 
-      const credentials = yield* credStore.read<HttpStateStoreCredentials>(
-        profileName,
-        CREDENTIALS_FILE,
-      );
-      if (credentials) {
-        return yield* ensureLatest(credentials);
-      }
-      const workerExists = yield* isStateStoreAvailable(scriptName);
-      if (workerExists) {
-        return yield* ensureLatest(
-          yield* loginWithCloudflare(profileName, false),
-        );
-      } else if (isCI) {
-        // TODO(sam): do we want to support bootstrapping the state store from CI?
-        // for now - just die here
-        return yield* Effect.die(
-          new AuthError({
-            message: `Cloudflare State store not found. Run 'alchemy bootstrap cloudflare --profile <your-ci-profile>' to deploy it first.`,
-          }),
-        );
-      } else {
-        return yield* Clank.confirm({
-          message:
-            "Cloudflare State Store not found. Do you want to deploy it?",
-        }).pipe(
-          Effect.flatMap((shouldDeploy) =>
-            shouldDeploy
-              ? bootstrap()
-              : Effect.die(new Clank.PromptCancelled()),
-          ),
+        const credentials = yield* credStore.read<HttpStateStoreCredentials>(
+          profileName,
+          CREDENTIALS_FILE,
         );
-      }
-    }).pipe(recordStateStoreInit, Effect.orDie),
+        if (credentials) {
+          return yield* ensureLatest(credentials);
+        }
+        const workerExists = yield* isStateStoreAvailable(scriptName);
+        if (workerExists) {
+          return yield* ensureLatest(
+            yield* loginWithCloudflare(profileName, false),
+          );
+        } else if (isCI) {
+          // TODO(sam): do we want to support bootstrapping the state store from CI?
+          // for now - just die here
+          return yield* Effect.die(
+            new AuthError({
+              message: `Cloudflare State store not found. Run 'alchemy bootstrap cloudflare --profile <your-ci-profile>' to deploy it first.`,
+            }),
+          );
+        } else {
+          return yield* Clank.confirm({
+            message:
+              "Cloudflare State Store not found. Do you want to deploy it?",
+          }).pipe(
+            Effect.flatMap((shouldDeploy) =>
+              shouldDeploy
+                ? bootstrap()
+                : Effect.die(new Clank.PromptCancelled()),
+            ),
+          );
+        }
+      }).pipe(recordStateStoreInit, Effect.orDie);
+
+      return yield* Effect.cached(init.pipe(Effect.provideContext(context)));
+    }),
   ).pipe(
     Layer.provideMerge(Credentials.fromAuthProvider()),
     Layer.provideMerge(CloudflareEnvironment.fromProfile()),
@@ -311,7 +317,7 @@ const deployStateStore = ({
   Effect.gen(function* () {
     yield* annotateAccountHash();
     // deploy it with local state (which we will then hoist into the Cloudflare state store)
-    const stateLayer = Layer.succeed(State, state);
+    const stateLayer = Layer.succeed(State, Effect.succeed(state));
     const { url, authToken } = yield* deploy({
       // use the script name as the stage name (so the user can have multiple state stores)
       stage,

package/src/Cloudflare/Workers/DurableObjectBridge.ts

@@ -6,6 +6,7 @@ import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
 
 import { HttpServerResponse } from "effect/unstable/http";
 import type {
@@ -89,7 +90,15 @@ export const makeDurableObjectBridge =
               this.#execute((instance) => {
                 const method = instance[prop as keyof DurableObjectShape];
                 if (typeof method === "function") {
-                  return (method as any)(...args);
+                  const result = (method as any)(...args);
+                  // A streaming RPC method returns a `Stream` directly rather
+                  // than an `Effect`. Lift it into the success channel so the
+                  // resulting `Exit.value` is the `Stream` and `handleRpcExit`
+                  // can encode it as a stream envelope instead of trying to run
+                  // it as an effect.
+                  return Stream.isStream(result)
+                    ? Effect.succeed(result)
+                    : result;
                 } else if (Effect.isEffect(method)) {
                   return method;
                 } else {

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -232,7 +232,19 @@ export const LocalWorkerProvider = () =>
       }) {
         const name = yield* createWorkerName(id, props.name);
         const compatibility = getCompatibility(props);
-        const workerBindings: BindingHook<BindingServices>[] = [];
+        const workerBindings: BindingHook<BindingServices>[] = [
+          Text.local("ALCHEMY_PHASE", "runtime"),
+          Text.local("ALCHEMY_STACK_NAME", stack.name),
+          Text.local("ALCHEMY_STAGE", stack.stage),
+          ...Object.entries(props.env ?? {}).map(([key, value]) => {
+            const unredacted = Redacted.isRedacted(value)
+              ? Redacted.value(value)
+              : value;
+            return typeof unredacted === "string"
+              ? Text.local(key, unredacted)
+              : Json.local(key, unredacted);
+          }),
+        ];
         const durableObjectNamespaces: Record<string, string> = {};
         const hyperdrives: Record<string, Required<HyperdriveOrigin>> = {};
         for (const { data } of bindings) {

package/src/Cloudflare/Workers/Rpc.ts

@@ -223,19 +223,48 @@ export const makeRpcStub = <Shape>(
         return target[prop];
       }
       return (...args: any[]) =>
-        Effect.gen(function* () {
-          const stub = isLazy
-            ? yield* stubSource as Effect.Effect<any>
-            : stubSource;
-          return yield* Effect.tryPromise({
-            try: () => (stub as any)[prop](...args),
-            catch: (cause) => new RpcCallError({ method: String(prop), cause }),
-          }).pipe(Effect.flatMap(decodeRpcResult));
-        });
+        asEffectOrStream(
+          Effect.gen(function* () {
+            const stub = isLazy
+              ? yield* stubSource as Effect.Effect<any>
+              : stubSource;
+            return yield* Effect.tryPromise({
+              try: () => (stub as any)[prop](...args),
+              catch: (cause) =>
+                new RpcCallError({ method: String(prop), cause }),
+            }).pipe(Effect.flatMap(decodeRpcResult));
+          }),
+        );
     },
   }) as Shape;
 };
 
+// Effect's internal Stream brand. `Stream.isStream` recognises a value by
+// this property and reads its `channel`. A `makeRpcStub` method can't know
+// synchronously whether the remote method returns a value or a `Stream`
+// (the call is async), yet its declared type mirrors the DO `Shape`
+// verbatim — value methods are typed `Effect<A>`, streaming methods `Stream<A>`.
+// We satisfy BOTH by handing back the call `Effect` augmented with the Stream
+// brand + channel, so the single return value can be `yield*`-ed / `.pipe`d as
+// an Effect (value methods, e.g. `stub.put(k, v).pipe(Effect.orDie)`) AND piped
+// through `Stream.*` combinators (streaming methods, e.g.
+// `stub.tick(n).pipe(Stream.map(...))`).
+const StreamTypeId = "~effect/Stream";
+
+const asEffectOrStream = (
+  call: Effect.Effect<unknown, unknown>,
+): Effect.Effect<unknown, unknown> => {
+  const streamForm = Stream.unwrap(
+    Effect.map(call, (value) =>
+      Stream.isStream(value) ? value : Stream.succeed(value),
+    ),
+  );
+  return Object.assign(call, {
+    [StreamTypeId]: streamForm[StreamTypeId],
+    channel: streamForm.channel,
+  });
+};
+
 export const toRpcStream = (stream: Stream.Stream<any, any, any>) =>
   Effect.scoped(
     Effect.gen(function* () {

package/src/Cloudflare/Workers/WorkerBridge.ts

@@ -141,8 +141,17 @@ export const makeWorkerBridge = (
                       ),
                     );
                   }
+                  const result = dispatcher(...args);
+                  // A streaming RPC method returns a `Stream` directly rather
+                  // than an `Effect`. Lift it into the success channel so the
+                  // inner effect resolves to the `Stream` and `handleRpcExit`
+                  // can encode it as a stream envelope. Anything else is the
+                  // `Effect` it claims to be (its resolved value may itself be
+                  // a `Stream`, which `handleRpcExit` also handles).
                   return Effect.succeed([
-                    dispatcher(...args) as Effect.Effect<any>,
+                    Stream.isStream(result)
+                      ? Effect.succeed(result)
+                      : (result as Effect.Effect<any>),
                     Context.empty(),
                   ] as const);
                 }),
@@ -274,7 +283,16 @@ export const makeRpcProxy = (
                   ),
                 );
               }
-              return dispatcher(...args) as Effect.Effect<any>;
+              const result = dispatcher(...args);
+              // A streaming RPC method returns a `Stream` directly rather than
+              // an `Effect`. Lift it into the success channel so the resulting
+              // `Exit.value` is the `Stream` and `handleRpcExit` can encode it
+              // as a stream envelope. Anything else is the `Effect` it claims
+              // to be and is run normally (its resolved value may itself be a
+              // `Stream`, which `handleRpcExit` also handles).
+              return Stream.isStream(result)
+                ? Effect.succeed(result)
+                : (result as Effect.Effect<any>);
             }),
             processEvent,
           )

package/src/Output.ts

@@ -549,7 +549,7 @@ export const evaluate: <A, Req = never>(
       } else if (isNamedExpr(expr)) {
         return yield* evaluate(expr.expr, upstream);
       } else if (isRefExpr(expr)) {
-        const state = yield* State.State;
+        const state = yield* yield* State.State;
         const stack = expr.stack ?? (yield* Stack).name;
         const stage = expr.stage ?? (yield* Stage);
         const resource = yield* state.get({
@@ -572,7 +572,7 @@ export const evaluate: <A, Req = never>(
         // task's output value, otherwise undefined.
         return (resource as any).attr ?? (resource as any).output;
       } else if (isStackRefExpr(expr)) {
-        const state = yield* State.State;
+        const state = yield* yield* State.State;
         const stack = expr.stack;
         const stage = expr.stage ?? (yield* Stage);
         const output = yield* state.getOutput({ stack, stage });

package/src/Plan.ts

@@ -4,6 +4,7 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 import { asEffect } from ".//Util/types.ts";
+import { isAction, type ActionLike } from "./Action.ts";
 import {
   AdoptPolicy,
   OwnedBySomeoneElse,
@@ -41,19 +42,18 @@ import {
 } from "./Resource.ts";
 import { type StackSpec } from "./Stack.ts";
 import {
+  isActionState,
   State,
+  type ActionState,
   type CreatedResourceState,
   type CreatingResourceState,
-  isActionState,
   type RanActionState,
   type ReplacedResourceState,
   type ReplacingResourceState,
   type ResourceState,
-  type ActionState,
   type UpdatedResourceState,
   type UpdatingReourceState,
 } from "./State/index.ts";
-import { isAction, type ActionLike } from "./Action.ts";
 import { hashInput } from "./Util/hash.ts";
 import { findCycleMembers } from "./Util/scc.ts";
 
@@ -236,7 +236,7 @@ export const make = <A>(
 ): Effect.Effect<Plan<A>, never, State> =>
   // @ts-expect-error
   Effect.gen(function* () {
-    const state = yield* State;
+    const state = yield* yield* State;
 
     const resources = Object.values(stack.resources);
     const actions = Object.values(stack.actions ?? {});

package/src/Stack.ts

@@ -125,7 +125,10 @@ export const Stack: Context.ServiceClass<
             // by default, reference the stack at the "current" stage of the importer
             Output.stackRef<A>(stackName).pipe(effectClass),
             {
+              stackName,
               stage: createStageProxy(stackName),
+              state: options?.state,
+              providers: options?.providers,
               make: <Req = never>(
                 options: StackProps<NoInfer<Req>>,
                 eff: Effect.Effect<A, never, Req>,
@@ -140,7 +143,10 @@ export const Stack: Context.ServiceClass<
         }),
         (eff) =>
           Object.assign(eff, {
+            stackName,
             stage: createStageProxy(stackName),
+            state: options?.state,
+            providers: options?.providers,
           }),
       );
     },

package/src/State/InMemoryState.ts

@@ -18,8 +18,8 @@ export const inMemoryState = (
 ) =>
   Layer.effect(
     State,
-    Effect.succeed(InMemoryService(initialState, initialOutputs)).pipe(
-      recordStateStoreInit,
+    Effect.cached(
+      InMemoryService(initialState, initialOutputs).pipe(recordStateStoreInit),
     ),
   );
 
@@ -27,87 +27,89 @@ export const InMemoryService = (
   state: Record<StackId, Record<StageId, Record<Fqn, ResourceState>>> = {},
   outputs: Record<StackId, Record<StageId, unknown>> = {},
 ) =>
-  State.of({
-    id: "inmemory",
-    getVersion: () => Effect.succeed(STATE_STORE_VERSION),
-    listStacks: () => Effect.succeed(Array.from(Object.keys(state))),
-    listStages: (stack: string) =>
-      Effect.succeed(
-        Array.from(stack in state ? Object.keys(state[stack]) : []),
-      ),
-    get: ({
-      stack,
-      stage,
-      fqn,
-    }: {
-      stack: string;
-      stage: string;
-      fqn: string;
-    }) => Effect.succeed(state[stack]?.[stage]?.[fqn]),
-    getReplacedResources: ({
-      stack,
-      stage,
-    }: {
-      stack: string;
-      stage: string;
-    }) =>
-      Effect.succeed(
-        Array.from(Object.values(state[stack]?.[stage] ?? {}) ?? []).filter(
-          (s) => s.status === "replaced",
+  State.of(
+    Effect.succeed({
+      id: "inmemory",
+      getVersion: () => Effect.succeed(STATE_STORE_VERSION),
+      listStacks: () => Effect.succeed(Array.from(Object.keys(state))),
+      listStages: (stack: string) =>
+        Effect.succeed(
+          Array.from(stack in state ? Object.keys(state[stack]) : []),
         ),
-      ),
-    set: <V extends PersistedState>({
-      stack,
-      stage,
-      fqn,
-      value,
-    }: {
-      stack: string;
-      stage: string;
-      fqn: string;
-      value: V;
-    }) =>
-      Effect.sync(() => {
-        const stackState = (state[stack] ??= {});
-        const stageState = (stackState[stage] ??= {});
-        stageState[fqn] = value as ResourceState;
-        return value;
-      }),
-    delete: ({
-      stack,
-      stage,
-      fqn,
-    }: {
-      stack: string;
-      stage: string;
-      fqn: string;
-    }) => Effect.sync(() => delete state[stack]?.[stage]?.[fqn]),
-    deleteStack: ({ stack, stage }: { stack: string; stage?: string }) =>
-      Effect.sync(() => {
-        if (stage === undefined) {
-          delete state[stack];
-        } else {
-          delete state[stack]?.[stage];
-        }
-      }),
-    list: ({ stack, stage }: { stack: string; stage: string }) =>
-      Effect.succeed(
-        Array.from(Object.keys(state[stack]?.[stage] ?? {}) ?? []),
-      ),
-    getOutput: ({ stack, stage }: { stack: string; stage: string }) =>
-      Effect.succeed(outputs[stack]?.[stage]),
-    setOutput: ({
-      stack,
-      stage,
-      value,
-    }: {
-      stack: string;
-      stage: string;
-      value: unknown;
-    }) =>
-      Effect.sync(() => {
-        const stackOutputs = (outputs[stack] ??= {});
-        stackOutputs[stage] = value;
-        return value;
-      }),
-  });
+      get: ({
+        stack,
+        stage,
+        fqn,
+      }: {
+        stack: string;
+        stage: string;
+        fqn: string;
+      }) => Effect.succeed(state[stack]?.[stage]?.[fqn]),
+      getReplacedResources: ({
+        stack,
+        stage,
+      }: {
+        stack: string;
+        stage: string;
+      }) =>
+        Effect.succeed(
+          Array.from(Object.values(state[stack]?.[stage] ?? {}) ?? []).filter(
+            (s) => s.status === "replaced",
+          ),
+        ),
+      set: <V extends PersistedState>({
+        stack,
+        stage,
+        fqn,
+        value,
+      }: {
+        stack: string;
+        stage: string;
+        fqn: string;
+        value: V;
+      }) =>
+        Effect.sync(() => {
+          const stackState = (state[stack] ??= {});
+          const stageState = (stackState[stage] ??= {});
+          stageState[fqn] = value as ResourceState;
+          return value;
+        }),
+      delete: ({
+        stack,
+        stage,
+        fqn,
+      }: {
+        stack: string;
+        stage: string;
+        fqn: string;
+      }) => Effect.sync(() => delete state[stack]?.[stage]?.[fqn]),
+      deleteStack: ({ stack, stage }: { stack: string; stage?: string }) =>
+        Effect.sync(() => {
+          if (stage === undefined) {
+            delete state[stack];
+          } else {
+            delete state[stack]?.[stage];
+          }
+        }),
+      list: ({ stack, stage }: { stack: string; stage: string }) =>
+        Effect.succeed(
+          Array.from(Object.keys(state[stack]?.[stage] ?? {}) ?? []),
+        ),
+      getOutput: ({ stack, stage }: { stack: string; stage: string }) =>
+        Effect.succeed(outputs[stack]?.[stage]),
+      setOutput: ({
+        stack,
+        stage,
+        value,
+      }: {
+        stack: string;
+        stage: string;
+        value: unknown;
+      }) =>
+        Effect.sync(() => {
+          const stackOutputs = (outputs[stack] ??= {});
+          stackOutputs[stage] = value;
+          return value;
+        }),
+    }),
+  );