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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.46",
+  "version": "2.0.0-beta.47",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",

package/src/Apply.ts

@@ -138,7 +138,7 @@ export const apply = <P extends Plan>(
   Effect.gen(function* () {
     const cli = yield* Cli;
     const session = yield* cli.startApplySession(plan);
-    const state = yield* State;
+    const state = yield* yield* State;
     const stack = yield* Stack;
     const stage = yield* Stage;
     const stackName = stack.name;
@@ -1397,7 +1397,7 @@ const collectGarbage = Effect.fnUntraced(function* (
   plan: Plan,
   session: PlanStatusSession,
 ) {
-  const state = yield* State;
+  const state = yield* yield* State;
   const stack = yield* Stack;
   const stackName = stack.name;
   const stage = yield* Stage;

package/src/Cli/commands/_shared.ts

@@ -2,6 +2,7 @@ import * as Cause from "effect/Cause";
 import * as Config from "effect/Config";
 import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as S from "effect/Schema";
@@ -312,5 +313,10 @@ export const importStack = Effect.fn(function* (main: string) {
       ),
     );
   }
-  return stackEffect;
+  return stackEffect as typeof stackEffect & {
+    stackName: string;
+    stage: string;
+    providers: Layer.Layer<never>;
+    state: Layer.Layer<never>;
+  };
 });

package/src/Cli/commands/login.ts

@@ -1,4 +1,3 @@
-import * as Cause from "effect/Cause";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Console from "effect/Console";
@@ -10,10 +9,10 @@ import { Command, Flag } from "effect/unstable/cli";
 import { AuthProviders } from "../../Auth/AuthProvider.ts";
 import { Profile, withProfileOverride } from "../../Auth/Profile.ts";
 import { Stage } from "../../Stage.ts";
-import * as State from "../../State/index.ts";
 import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
 import { fileLogger } from "../../Util/FileLogger.ts";
 
+import { Stack } from "../../Stack.ts";
 import {
   envFile,
   importStack,
@@ -59,73 +58,83 @@ export const loginCommand = Command.make(
 
       const authProviders: AuthProviders["Service"] = {};
 
-      const services = Layer.mergeAll(
-        Layer.succeed(AuthProviders, authProviders),
-        ConfigProvider.layer(
-          withProfileOverride(yield* loadConfigProvider(envFile), profile),
+      // build the state + providers layer to capture the Auth Providers
+      yield* Layer.build(
+        (stackEffect.providers ?? Layer.empty).pipe(
+          Layer.provideMerge(stackEffect.state ?? Layer.empty),
+          Layer.provideMerge(
+            Layer.mergeAll(
+              Layer.succeed(AuthProviders, authProviders),
+              ConfigProvider.layer(
+                withProfileOverride(
+                  yield* loadConfigProvider(envFile),
+                  profile,
+                ),
+              ),
+              Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
+              Layer.succeed(Stage, stage),
+              Layer.succeed(Stack, {
+                actions: {},
+                bindings: {},
+                name: stackEffect.stackName,
+                resources: {},
+                stage,
+              }),
+            ),
+          ),
         ),
-        Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
-        Layer.succeed(Stage, stage),
-        State.localState(),
       );
 
-      yield* Effect.gen(function* () {
-        const profiles = yield* Profile;
-        yield* Effect.catchCause(stackEffect, (cause) =>
-          Console.warn(
-            `Ignoring error while building stack for login (likely due to missing or broken credentials):\n${Cause.pretty(cause)}`,
-          ),
-        );
+      const profiles = yield* Profile;
 
-        const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
-        const providers = Object.values(authProviders);
+      const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
+      const providers = Object.values(authProviders);
 
-        if (providers.length === 0) {
-          yield* Console.log(
-            "No AuthProviders registered. Make sure the stack's providers() layer includes AuthProviderLayer entries.",
-          );
-          return;
-        }
+      if (providers.length === 0) {
+        yield* Console.log(
+          "No AuthProviders registered. Make sure the stack's providers() layer includes AuthProviderLayer entries.",
+        );
+        return;
+      }
 
-        yield* Effect.forEach(
-          providers,
-          (provider) =>
-            Effect.gen(function* () {
-              const existing = yield* profiles.getProfile(profile);
-              // --configure treats every provider as missing, so configure
-              // runs unconditionally and overwrites the stored entry.
-              const stored = configure ? undefined : existing?.[provider.name];
+      yield* Effect.forEach(
+        providers,
+        (provider) =>
+          Effect.gen(function* () {
+            const existing = yield* profiles.getProfile(profile);
+            // --configure treats every provider as missing, so configure
+            // runs unconditionally and overwrites the stored entry.
+            const stored = configure ? undefined : existing?.[provider.name];
 
-              let cfg: { method: string };
-              if (stored == null) {
-                cfg = yield* provider.configure(profile, { ci });
-                yield* profiles.setProfile(profile, {
-                  ...existing,
-                  [provider.name]: cfg,
-                });
-              } else {
-                cfg = stored;
-              }
+            let cfg: { method: string };
+            if (stored == null) {
+              cfg = yield* provider.configure(profile, { ci });
+              yield* profiles.setProfile(profile, {
+                ...existing,
+                [provider.name]: cfg,
+              });
+            } else {
+              cfg = stored;
+            }
 
-              // `read` succeeds when creds are present and not expired
-              // (refreshing OAuth proactively if near expiry). Any failure
-              // — missing file, dead refresh token, etc. — falls through
-              // to `login`.
-              yield* provider
-                .read(profile, cfg)
-                .pipe(Effect.catch(() => provider.login(profile, cfg)));
-            }),
-          { discard: true },
-        );
+            // `read` succeeds when creds are present and not expired
+            // (refreshing OAuth proactively if near expiry). Any failure
+            // — missing file, dead refresh token, etc. — falls through
+            // to `login`.
+            yield* provider
+              .read(profile, cfg)
+              .pipe(Effect.catch(() => provider.login(profile, cfg)));
+          }),
+        { discard: true },
+      );
 
-        // Print the resulting profile using the same renderer as
-        // `alchemy profile show`.
-        const final = yield* profiles.getProfile(profile);
-        if (final != null) {
-          yield* Console.log("");
-          yield* printProfile(profile, final, authProviders);
-        }
-      }).pipe(Effect.provide(services));
+      // Print the resulting profile using the same renderer as
+      // `alchemy profile show`.
+      const final = yield* profiles.getProfile(profile);
+      if (final != null) {
+        yield* Console.log("");
+        yield* printProfile(profile, final, authProviders);
+      }
     }),
   ),
 );

package/src/Cli/commands/logs.ts

@@ -89,7 +89,7 @@ export const logsCommand = Command.make(
         const stack = yield* stackEffect;
 
         yield* Effect.gen(function* () {
-          const state = yield* State.State;
+          const state = yield* yield* State.State;
           const filterSet = parseResourceFilter(filter);
           const availableIds = [
             ...new Set(Object.values(stack.resources).map((r) => r.LogicalId)),

package/src/Cli/commands/state.ts

@@ -90,7 +90,7 @@ const withStateService = <A, E>(
     return yield* Effect.gen(function* () {
       const stack = yield* stackEffect;
       return yield* Effect.gen(function* () {
-        const state = yield* State.State;
+        const state = yield* yield* State.State;
         return yield* body(state);
       }).pipe(Effect.provide(stack.services));
     }).pipe(Effect.provide(services));

package/src/Cli/commands/tail.ts

@@ -62,7 +62,7 @@ export const tailCommand = Command.make(
         const stack = yield* stackEffect;
 
         yield* Effect.gen(function* () {
-          const state = yield* State.State;
+          const state = yield* yield* State.State;
           const filterSet = parseResourceFilter(filter);
           const availableIds = [
             ...new Set(Object.values(stack.resources).map((r) => r.LogicalId)),

package/src/Cloudflare/AiGateway/AiGateway.ts

@@ -231,7 +231,11 @@ export const isAiGateway = (value: unknown): value is AiGateway =>
  * governance across AI provider requests.
  *
  * AI Gateway gives your application a stable gateway ID and account-scoped
- * endpoint that can route model requests through Cloudflare.
+ * endpoint that can route model requests through Cloudflare. Once bound to a
+ * Worker, `aiGateway.model({...})` returns an `effect/unstable/ai`
+ * `LanguageModel` Layer so you use the standard `generateText` / `streamText`
+ * APIs — provider-agnostic, with caching, rate limiting, retries, and a
+ * unified request log handled by the gateway.
  *
  * @section Creating a Gateway
  * @example Basic gateway
@@ -260,6 +264,113 @@ export const isAiGateway = (value: unknown): value is AiGateway =>
  *   logManagementStrategy: "STOP_INSERTING",
  * });
  * ```
+ *
+ * @section Binding into a Worker
+ * @example Bind the gateway and provide the runtime layer
+ * `AiGateway.bind(gateway)` returns a typed, Effect-native client during the
+ * Worker's Init phase. Provide `Cloudflare.AiGatewayBindingLive` once at the
+ * bottom of the Init layer chain so every `bind(...)` resolves at runtime.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import { Gateway } from "./AiGateway.ts";
+ *
+ * export default class Api extends Cloudflare.Worker<Api>()(
+ *   "Api",
+ *   { main: import.meta.path },
+ *   Effect.gen(function* () {
+ *     const aiGateway = yield* Cloudflare.AiGateway.bind(Gateway);
+ *
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         // …routes
+ *       }),
+ *     };
+ *   }).pipe(Effect.provide(Cloudflare.AiGatewayBindingLive)),
+ * ) {}
+ * ```
+ *
+ * @section Building a LanguageModel
+ * @example `aiGateway.model(...)` -> Effect AI `LanguageModel`
+ * Call `aiGateway.model({...})` with a Workers AI model id. It returns a
+ * `Layer<LanguageModel, never, RuntimeContext>` directly — no API key and no
+ * `Layer.unwrap`, since the binding handles auth and the gateway URL. Build it
+ * in the Init phase; construction is pure.
+ * ```typescript
+ * const aiGateway = yield* Cloudflare.AiGateway.bind(Gateway);
+ *
+ * const languageModel = aiGateway.model({
+ *   client: aiGateway,
+ *   model: "@cf/meta/llama-3.1-8b-instruct",
+ *   parameters: { temperature: 0.7, maxTokens: 1024 },
+ * });
+ * ```
+ *
+ * @section Generating Text
+ * @example Generate text on a route
+ * Provide the `languageModel` layer to the handler and call
+ * `LanguageModel.generateText` like any other Effect. `Effect.orDie` collapses
+ * `AiError` to a defect (a 500); use `Effect.catchTag("AiError", …)` for typed
+ * handling instead.
+ * ```typescript
+ * import { LanguageModel } from "effect/unstable/ai";
+ * import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+ *
+ * fetch: Effect.gen(function* () {
+ *   const response = yield* LanguageModel.generateText({
+ *     prompt: "Say hello.",
+ *   }).pipe(Effect.orDie);
+ *   return yield* HttpServerResponse.json({
+ *     text: response.text,
+ *     usage: {
+ *       inputTokens: response.usage.inputTokens.total,
+ *       outputTokens: response.usage.outputTokens.total,
+ *     },
+ *   });
+ * }).pipe(Effect.provide(languageModel));
+ * ```
+ *
+ * @section Streaming Text
+ * @example Stream tokens as Server-Sent Events
+ * `LanguageModel.streamText` returns a `Stream` of typed response parts.
+ * `Stream.provide(languageModel)` keeps the model available for the whole
+ * stream lifetime; pipe through `Sse.encode` for an SSE response.
+ * ```typescript
+ * import { LanguageModel } from "effect/unstable/ai";
+ * import * as Stream from "effect/Stream";
+ * import * as Sse from "effect/unstable/encoding/Sse";
+ * import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+ *
+ * const stream = LanguageModel.streamText({ prompt }).pipe(
+ *   Stream.provide(languageModel),
+ *   Sse.encode,
+ * );
+ * return HttpServerResponse.stream(stream, {
+ *   headers: {
+ *     "content-type": "text/event-stream",
+ *     "cache-control": "no-cache",
+ *     "x-accel-buffering": "no",
+ *   },
+ * });
+ * ```
+ *
+ * @section Tuning the Gateway
+ * @example Production-grade caching, rate limits, and DLP
+ * Every prop maps to an in-place update — no replacement, no downtime.
+ * ```typescript
+ * export const Gateway = Cloudflare.AiGateway("Gateway", {
+ *   id: "prod-gateway",
+ *   cacheTtl: 300,
+ *   cacheInvalidateOnUpdate: true,
+ *   rateLimitingInterval: 60,
+ *   rateLimitingLimit: 100,
+ *   rateLimitingTechnique: "sliding",
+ *   collectLogs: true,
+ *   logManagement: 100_000,
+ *   logManagementStrategy: "DELETE_OLDEST",
+ *   authentication: true,
+ * });
+ * ```
  */
 export const AiGateway = Resource<AiGateway>("Cloudflare.AiGateway")({
   /**

package/src/Cloudflare/AiGateway/AiGatewayBinding.ts

@@ -3,15 +3,18 @@
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import type { LanguageModel } from "effect/unstable/ai/LanguageModel";
 import * as Binding from "../../Binding.ts";
 import type { ResourceLike } from "../../Resource.ts";
 import type { RuntimeContext } from "../../RuntimeContext.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { AiGateway as AiGatewayResource } from "./AiGateway.ts";
+import {
+  makeLanguageModelLayer,
+  type LanguageModelOptions,
+} from "./LanguageModel.ts";
 
-/**
- * Error raised by AI Gateway runtime operations.
- */
+// Error raised by AI Gateway runtime operations.
 export class AiGatewayError extends Data.TaggedError("AiGatewayError")<{
   /**
    * Human-readable runtime error message.
@@ -39,6 +42,12 @@ export interface AiGatewayClient {
    * Effect resolving to the raw AI Gateway runtime binding.
    */
   gateway: Effect.Effect<AiGateway, never, RuntimeContext>;
+  /**
+   * Effect resolving to the gateway id (the resource attribute, captured at
+   * bind time). Useful when calling `ai.run(model, inputs, { gateway: { id } })`
+   * — the in-account path for first-party services like Workers AI.
+   */
+  id: Effect.Effect<string, never, RuntimeContext>;
   /**
    * Update metadata on an existing AI Gateway log entry.
    */
@@ -65,17 +74,27 @@ export interface AiGatewayClient {
     data: Parameters<AiGateway["run"]>[0],
     options?: Parameters<AiGateway["run"]>[1],
   ): Effect.Effect<Response, AiGatewayError, RuntimeContext>;
+
+  model(
+    options: LanguageModelOptions,
+  ): Layer.Layer<LanguageModel, never, RuntimeContext>;
 }
 
 /**
- * Binding service that turns an {@link AiGatewayResource} resource into a typed
- * {@link AiGatewayClient} for Worker runtime code.
+ * Binding service that turns an {@link AiGatewayResource} resource
+ * into a typed {@link AiGatewayClient} for Worker runtime code. Wraps
+ * the Cloudflare AI Gateway runtime binding so each operation returns
+ * an Effect tagged with {@link AiGatewayError}, exposes the raw
+ * Workers AI handle for `ai.run(...)`, and provides a `model(options)`
+ * factory that produces an `effect/unstable/ai` `LanguageModel`
+ * `Layer`.
  *
- * @section Calling AI Gateway
- * Bind the gateway during the Worker's init phase, then use `run` or `getUrl`
- * from request handlers.
+ * @binding
  *
+ * @section Calling AI Gateway
  * @example Run through a gateway
+ * Bind the gateway during the Worker's init phase, then use `run` or
+ * `getUrl` from request handlers.
  * ```typescript
  * const aiGateway = yield* Cloudflare.AiGatewayBinding.bind(gateway);
  *
@@ -91,8 +110,29 @@ export interface AiGatewayClient {
  * };
  * ```
  *
- * Provide {@link AiGatewayBindingLive} in the worker's runtime layer to
- * resolve the underlying Cloudflare AI binding at request time.
+ * @section Driving Effect AI through the gateway
+ * @example `aiGateway.model(...)` -> Effect AI `LanguageModel`
+ * `model(options)` produces a `Layer<LanguageModel, never,
+ * RuntimeContext>` that translates `LanguageModel.generateText` /
+ * `streamText` calls (including tool calls and structured outputs)
+ * into `ai.run(...)` against the bound Workers AI model, routed
+ * through the gateway.
+ * ```typescript
+ * const aiGateway = yield* Cloudflare.AiGatewayBinding.bind(gateway);
+ *
+ * const languageModel = aiGateway.model({
+ *   client: aiGateway,
+ *   model: "@cf/meta/llama-3.1-8b-instruct",
+ *   parameters: { temperature: 0.7, maxTokens: 1024 },
+ * });
+ *
+ * const response = yield* AiLanguageModel.generateText({ prompt }).pipe(
+ *   Effect.provide(languageModel),
+ * );
+ * ```
+ *
+ * Provide {@link AiGatewayBindingLive} in the worker's runtime layer
+ * to resolve the underlying Cloudflare AI binding at request time.
  */
 export class AiGatewayBinding extends Binding.Service<
   AiGatewayBinding,
@@ -129,11 +169,13 @@ export const AiGatewayBindingLive = Layer.effect(
       return {
         raw: ai,
         gateway: runtimeGateway,
+        id: gatewayIdAccessor,
         patchLog: (logId, data) =>
           use((gateway) => gateway.patchLog(logId, data)),
         getLog: (logId) => use((gateway) => gateway.getLog(logId)),
         getUrl: (provider) => use((gateway) => gateway.getUrl(provider)),
         run: (data, options) => use((gateway) => gateway.run(data, options)),
+        model: (options) => makeLanguageModelLayer(options),
       } satisfies AiGatewayClient;
     });
   }),