alchemy 2.0.0-beta.62 → 2.0.0-beta.63

package/src/Bundle/Vite.ts

@@ -3,7 +3,9 @@ import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
+import type { PlatformError } from "effect/PlatformError";
 import type * as vite from "vite";
+import { cachedFunction } from "../Util/cached-function.ts";
 import { sha256 } from "../Util/index.ts";
 import {
   BundleError,
@@ -17,6 +19,7 @@ export interface ViteBuildOutput {
   readonly clientDirectory: string | undefined;
   // This is emitted as an Effect instead of a value so we can process it in parallel with reading the client assets.
   readonly serverBundle: Effect.Effect<BundleOutput | undefined, BundleError>;
+  readonly externalWorkspaces: Effect.Effect<Set<string>, PlatformError>;
 }
 
 // `@vitejs/plugin-rsc` writes these modules separately after build completes instead of emitting them as chunks.
@@ -44,7 +47,42 @@ export const viteBuildOutputPlugin = Effect.fn(function* ({
     string,
     Effect.Effect<BundleFile, BundleError>
   >();
+  const maybeExternalWorkspaces = new Set<string>();
 
+  const findUp = yield* cachedFunction(
+    (
+      dir: string,
+      filenames: Array<string>,
+    ): Effect.Effect<string | undefined, PlatformError> =>
+      Effect.filter(
+        filenames.map((filename) => path.join(dir, filename)),
+        fs.exists,
+        { concurrency: "unbounded" },
+      ).pipe(
+        Effect.flatMap(([match]) => {
+          if (match) {
+            return Effect.succeed(match);
+          }
+          const parent = path.dirname(dir);
+          if (parent === dir) {
+            return Effect.undefined;
+          }
+          return findUp(parent, filenames);
+        }),
+      ),
+  );
+  const collectExternalWorkspaces = (): Effect.Effect<
+    Set<string>,
+    PlatformError
+  > =>
+    Effect.forEach(maybeExternalWorkspaces, (directory) =>
+      findUp(directory, ["package.json"]),
+    ).pipe(
+      Effect.map(
+        (paths) =>
+          new Set(paths.filter((file) => file !== undefined).map(path.dirname)),
+      ),
+    );
   const plugin: vite.Plugin = {
     name: "alchemy:build-output",
     sharedDuringBuild: true,
@@ -57,9 +95,20 @@ export const viteBuildOutputPlugin = Effect.fn(function* ({
     // `viteBuild` reads `output` *after* `builder.buildApp()` resolves — by
     // which point every environment that actually built has run `writeBundle`.
     async writeBundle(_, bundle) {
+      const root = path.resolve(this.environment.config.root);
+      for (const id of this.getModuleIds()) {
+        if (
+          !path.isAbsolute(id) ||
+          id.includes("node_modules") ||
+          id.startsWith(root)
+        ) {
+          continue;
+        }
+        maybeExternalWorkspaces.add(path.dirname(id));
+      }
       if (this.environment.name === "client") {
         clientDirectory = path.resolve(
-          this.environment.config.root,
+          root,
           this.environment.config.build.outDir,
         );
         return;
@@ -199,6 +248,7 @@ export const viteBuildOutputPlugin = Effect.fn(function* ({
       (): ViteBuildOutput => ({
         clientDirectory,
         serverBundle: makeServerBundle(),
+        externalWorkspaces: collectExternalWorkspaces(),
       }),
     ),
   };

package/src/Cli/LoggingCli.ts

@@ -113,22 +113,25 @@ export const LoggingCli = Layer.succeed(
 
         const counts = { ok: 0, fail: 0 };
         return {
+          // Write through the Effect Console SERVICE (not the global
+          // `console`) so environments that override it — e.g. the
+          // alchemy-test runner's per-test buffering console — capture
+          // apply progress instead of having it leak to stdout.
           emit: (event: ApplyEvent) =>
-            Effect.sync(() => {
+            Effect.suspend(() => {
               if (event.kind === "annotate") {
-                console.log(`${tag(event.id)} ${blue(event.message)}`);
-                return;
+                return Console.log(`${tag(event.id)} ${blue(event.message)}`);
               }
               const id = event.bindingId
                 ? `${event.id}/${event.bindingId}`
                 : event.id;
               const status = statusColor(event.status)(event.status);
               const msg = event.message ? ` ${dim("—")} ${event.message}` : "";
-              console.log(`${tag(id)} ${status}${msg}`);
               if (isTerminal(event.status)) {
                 if (event.status === "fail") counts.fail++;
                 else counts.ok++;
               }
+              return Console.log(`${tag(id)} ${status}${msg}`);
             }),
           done: () =>
             Console.log(

package/src/Cli/commands/_shared.ts

@@ -23,6 +23,12 @@ import {
   ALCHEMY_PROFILE,
   withProfileOverride,
 } from "../../Auth/Profile.ts";
+import { AwsAuth } from "../../AWS/AuthProvider.ts";
+import { AxiomAuth } from "../../Axiom/AuthProvider.ts";
+import { CloudflareAuth } from "../../Cloudflare/Auth/AuthProvider.ts";
+import { GitHubAuth } from "../../GitHub/AuthProvider.ts";
+import { NeonAuth } from "../../Neon/AuthProvider.ts";
+import { PlanetscaleAuth } from "../../Planetscale/AuthProvider.ts";
 import * as Stack from "../../Stack.ts";
 import { Stage } from "../../Stage.ts";
 import { recordCli } from "../../Telemetry/Metrics.ts";
@@ -440,3 +446,49 @@ export const buildStackProviders = Effect.fn("buildStackProviders")(function* (
   );
   return { authProviders, context, stackEffect };
 });
+
+/**
+ * The auth providers Alchemy ships with. Used as the baseline registry so
+ * `alchemy login` works from any folder (no `alchemy.run.ts` required) and
+ * `alchemy profile show` can pretty-print any provider a profile mentions,
+ * even one the current stack doesn't wire up.
+ */
+export const builtinAuth = Layer.mergeAll(
+  AwsAuth,
+  AxiomAuth,
+  CloudflareAuth,
+  GitHubAuth,
+  NeonAuth,
+  PlanetscaleAuth,
+);
+
+/**
+ * Build {@link builtinAuth} against `registry` so every built-in auth
+ * provider registers itself, without importing any stack entrypoint.
+ */
+export const buildBuiltinAuthProviders = Effect.fn("buildBuiltinAuthProviders")(
+  function* (options: {
+    envFile: Option.Option<string>;
+    profile: string;
+    /** Registry to populate. Defaults to a fresh empty registry. */
+    registry?: AuthProviders["Service"];
+  }) {
+    const authProviders = options.registry ?? {};
+    yield* Layer.build(
+      Layer.provide(
+        builtinAuth,
+        Layer.mergeAll(
+          Layer.succeed(AuthProviders, authProviders),
+          ConfigProvider.layer(
+            withProfileOverride(
+              yield* loadConfigProvider(options.envFile),
+              options.profile,
+            ),
+          ),
+          Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
+        ),
+      ),
+    );
+    return authProviders;
+  },
+);

package/src/Cli/commands/login.ts

@@ -1,17 +1,23 @@
 import * as Config from "effect/Config";
 import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
+import * as Argument from "effect/unstable/cli/Argument";
+import * as CliError from "effect/unstable/cli/CliError";
 
+import type { AuthProviders } from "../../Auth/AuthProvider.ts";
 import { AlchemyProfile } from "../../Auth/Profile.ts";
+import * as Clank from "../../Util/Clank.ts";
 
 import {
+  buildBuiltinAuthProviders,
   buildStackProviders,
   envFile,
   instrumentCommand,
   printProfile,
   profile,
-  script,
 } from "./_shared.ts";
 
 const loginConfigure = Flag.boolean("configure").pipe(
@@ -21,39 +27,109 @@ const loginConfigure = Flag.boolean("configure").pipe(
   Flag.withDefault(false),
 );
 
+/**
+ * Stack entrypoint whose `providers()` layer selects which auth providers
+ * to log in with. Optional: when omitted and no `alchemy.run.ts` exists in
+ * the current folder, `alchemy login` falls back to every built-in auth
+ * provider, so logging in (and refreshing credentials) works from any
+ * folder.
+ */
+const loginMain = Argument.file("main").pipe(
+  Argument.withDescription(
+    "Stack entrypoint whose providers() to log in with, defaults to alchemy.run.ts (falls back to all built-in providers when absent)",
+  ),
+  Argument.optional,
+);
+
 export const loginCommand = Command.make(
   "login",
   {
-    main: script,
+    main: loginMain,
     envFile,
     profile,
     configure: loginConfigure,
   },
   instrumentCommand(
     "login",
-    (a: { main: string; profile: string; configure: boolean }) => ({
+    (a: {
+      main: Option.Option<string>;
+      profile: string;
+      configure: boolean;
+    }) => ({
       "alchemy.profile": a.profile,
-      "alchemy.main": a.main,
+      "alchemy.main": Option.getOrElse(a.main, () => "alchemy.run.ts"),
       "alchemy.configure": a.configure,
     }),
   )(
     Effect.fn(function* ({ main, envFile, profile, configure }) {
-      // Build the user's providers() (+ state) layer to capture the auth
-      // providers their stack wires up.
-      const { authProviders } = yield* buildStackProviders({
-        main,
-        envFile,
-        profile,
-      });
+      const fs = yield* FileSystem.FileSystem;
+      const explicitMain = Option.getOrUndefined(main);
+      const mainPath = explicitMain ?? "alchemy.run.ts";
+      const mainExists = yield* fs
+        .exists(mainPath)
+        .pipe(Effect.catch(() => Effect.succeed(false)));
 
-      const profiles = yield* AlchemyProfile;
+      // An explicitly-passed entrypoint must exist; only the default may
+      // fall back to the built-in providers.
+      if (explicitMain != null && !mainExists) {
+        return yield* Effect.fail(
+          new CliError.InvalidValue({
+            option: "main",
+            value: explicitMain,
+            expected: "an existing stack entrypoint file",
+            kind: "argument",
+          }),
+        );
+      }
 
+      const profiles = yield* AlchemyProfile;
       const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
-      const providers = Object.values(authProviders);
+
+      let authProviders: AuthProviders["Service"];
+      // Providers to actually log in with; `undefined` means all registered.
+      let selected: string[] | undefined;
+      if (mainExists) {
+        // Build the user's providers() (+ state) layer to capture the auth
+        // providers their stack wires up.
+        ({ authProviders } = yield* buildStackProviders({
+          main: mainPath,
+          envFile,
+          profile,
+        }));
+      } else {
+        // No stack entrypoint — register every built-in auth provider so
+        // `alchemy login` works from any folder. Interactively, let the
+        // user pick which ones to log in with; in CI, take them all.
+        yield* Console.log(
+          "No alchemy.run.ts found — using Alchemy's built-in providers.",
+        );
+        authProviders = yield* buildBuiltinAuthProviders({ envFile, profile });
+        if (!ci) {
+          const existing = yield* profiles.getProfile(profile);
+          const names = Object.keys(authProviders).sort();
+          selected = yield* Clank.multiselect({
+            message: "Select providers to log in with",
+            options: names.map((name) => ({
+              value: name,
+              label: name,
+              hint: existing?.[name] != null ? "configured" : undefined,
+            })),
+            // Pre-select providers already in the profile so re-running
+            // login naturally refreshes/re-prints what's set up.
+            initialValues: names.filter((name) => existing?.[name] != null),
+          });
+        }
+      }
+
+      const providers = Object.values(authProviders).filter(
+        (provider) => selected == null || selected.includes(provider.name),
+      );
 
       if (providers.length === 0) {
         yield* Console.log(
-          "No AuthProviders registered. Make sure the stack's providers() layer includes AuthProviderLayer entries.",
+          selected != null
+            ? "No providers selected."
+            : "No AuthProviders registered. Make sure the stack's providers() layer includes AuthProviderLayer entries.",
         );
         return;
       }

package/src/Cli/commands/profile.ts

@@ -1,25 +1,15 @@
-import * as ConfigProvider from "effect/ConfigProvider";
 import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Logger from "effect/Logger";
 import * as Option from "effect/Option";
 import { Command } from "effect/unstable/cli";
 import * as Argument from "effect/unstable/cli/Argument";
 
 import { AuthProviders } from "../../Auth/AuthProvider.ts";
 import { CredentialsStore } from "../../Auth/Credentials.ts";
-import { AlchemyProfile, withProfileOverride } from "../../Auth/Profile.ts";
-import { AwsAuth } from "../../AWS/AuthProvider.ts";
-import { AxiomAuth } from "../../Axiom/AuthProvider.ts";
-import { CloudflareAuth } from "../../Cloudflare/Auth/AuthProvider.ts";
-import { GitHubAuth } from "../../GitHub/AuthProvider.ts";
-import { NeonAuth } from "../../Neon/AuthProvider.ts";
-import { PlanetscaleAuth } from "../../Planetscale/AuthProvider.ts";
-import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
-import { fileLogger } from "../../Util/FileLogger.ts";
+import { AlchemyProfile } from "../../Auth/Profile.ts";
 
 import {
+  buildBuiltinAuthProviders,
   buildStackProviders,
   envFile,
   instrumentCommand,
@@ -27,20 +17,6 @@ import {
   profile,
 } from "./_shared.ts";
 
-/**
- * The auth providers Alchemy ships with. Built into the registry as a
- * baseline so `profile show` can pretty-print any provider a profile
- * mentions, even one the current stack doesn't wire up.
- */
-const builtinAuth = Layer.mergeAll(
-  AwsAuth,
-  AxiomAuth,
-  CloudflareAuth,
-  GitHubAuth,
-  NeonAuth,
-  PlanetscaleAuth,
-);
-
 /**
  * Entrypoint whose `providers()` layer contributes the user's own auth
  * providers. Optional and best-effort — if it's missing or fails to load,
@@ -73,21 +49,11 @@ export const collectAuthProviders = Effect.fn("collectAuthProviders")(
     const authProviders: AuthProviders["Service"] = {};
 
     // 1. Built-in providers first (baseline).
-    yield* Layer.build(
-      Layer.provide(
-        builtinAuth,
-        Layer.mergeAll(
-          Layer.succeed(AuthProviders, authProviders),
-          ConfigProvider.layer(
-            withProfileOverride(
-              yield* loadConfigProvider(options.envFile),
-              options.profile,
-            ),
-          ),
-          Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
-        ),
-      ),
-    );
+    yield* buildBuiltinAuthProviders({
+      envFile: options.envFile,
+      profile: options.profile,
+      registry: authProviders,
+    });
 
     // 2. The user's own providers() layer on top — building into the same
     //    registry overrides the built-ins by name. Best-effort: swallow

package/src/Cloudflare/AI/LanguageModel.ts

@@ -560,7 +560,7 @@ interface StreamState {
   readonly reasoningId: string | undefined;
   readonly toolCalls: ReadonlyMap<
     number,
-    { readonly id: string; readonly name: string }
+    { readonly id: string; readonly name: string; readonly arguments: string }
   >;
   readonly lastToolIndex: number | undefined;
   readonly closedToolIndices: ReadonlySet<number>;
@@ -699,7 +699,7 @@ const handleToolDeltas = (
           s = closeToolCall(s, s.lastToolIndex, parts);
         }
         const id = rawId || (yield* idGen.generateId());
-        const entry = { id, name };
+        const entry = { id, name, arguments: args };
         const next = new Map(s.toolCalls);
         next.set(idx, entry);
         s = { ...s, toolCalls: next, lastToolIndex: idx };
@@ -708,12 +708,23 @@ const handleToolDeltas = (
           parts.push({ type: "tool-params-delta", id, delta: args });
         }
       } else {
-        s = { ...s, lastToolIndex: idx };
-        if (args.length > 0) {
+        // OpenAI-compatible providers stream argument fragments, while
+        // Workers AI can resend the complete accumulated JSON on every
+        // chunk. Normalize both shapes to incremental deltas.
+        const delta = args.startsWith(existing.arguments)
+          ? args.slice(existing.arguments.length)
+          : args;
+        const accumulated = args.startsWith(existing.arguments)
+          ? args
+          : existing.arguments + args;
+        const next = new Map(s.toolCalls);
+        next.set(idx, { ...existing, arguments: accumulated });
+        s = { ...s, toolCalls: next, lastToolIndex: idx };
+        if (delta.length > 0) {
           parts.push({
             type: "tool-params-delta",
             id: existing.id,
-            delta: args,
+            delta,
           });
         }
       }
@@ -785,6 +796,15 @@ const handleNativeToolCalls = (
   parts: StreamParts,
   idGen: IdGenerator.Service,
 ): Effect.Effect<StreamState> => {
+  const openAiToolCalls = (
+    chunk.choices as
+      | Array<{ delta?: { tool_calls?: ReadonlyArray<unknown> } }>
+      | undefined
+  )?.[0]?.delta?.tool_calls;
+  // Workers AI can mirror the same fragments in both its top-level native
+  // field and the OpenAI-compatible delta. Prefer the latter so every
+  // fragment is emitted exactly once.
+  if (Array.isArray(openAiToolCalls)) return Effect.succeed(state);
   if (!Array.isArray(chunk.tool_calls)) return Effect.succeed(state);
   return Effect.gen(function* () {
     const s = closeReasoning(state, parts);

package/src/Cloudflare/AI/QuerySearchLocal.ts

@@ -0,0 +1,66 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import type { Credentials } from "../Credentials.ts";
+import { QuerySearch } from "./QuerySearch.ts";
+import { makeLocalSearchClient, type SearchAuth } from "./SearchHttpClient.ts";
+import type { SearchInstance } from "./SearchInstance.ts";
+
+/**
+ * Local implementation of the {@link QuerySearch} binding — queries an AI
+ * Search instance over the Cloudflare HTTP API using the **current
+ * credentials** instead of a native Worker binding (`QuerySearchBinding`).
+ *
+ * Provide it on an {@link Action} (or any deploy-time Effect) to run
+ * `search` / `chatCompletions` / `info` / `stats` against an instance with the
+ * same client you'd use inside a Worker. The instance id and namespace are
+ * resolved at apply time through the ambient RuntimeContext, so
+ * `QuerySearch(instance)` works even when the instance is created in the same
+ * deploy.
+ *
+ * `raw` (the native `AiSearchInstance` runtime handle) is unavailable outside a
+ * deployed Worker and dies if forced.
+ *
+ * @example Read an instance's status from an Action
+ * ```typescript
+ * const Probe = Alchemy.Action(
+ *   "Probe",
+ *   Effect.gen(function* () {
+ *     const search = yield* Cloudflare.AI.QuerySearch(instance);
+ *     return Effect.fn(function* () {
+ *       const info = yield* search.info();
+ *       const stats = yield* search.stats();
+ *       return { status: info.status, indexed: stats.completed };
+ *     });
+ *   }).pipe(Effect.provide(Cloudflare.AI.QuerySearchLocal)),
+ * );
+ * ```
+ */
+export const QuerySearchLocal = Layer.effect(
+  QuerySearch,
+  Effect.gen(function* () {
+    // Account + credentials are ambient during stack-eval (the stack's
+    // providers layer). Capture the full context so each HTTP op can be run
+    // with the current credentials; no `host.bind`, no minted token.
+    const { accountId } = yield* yield* CloudflareEnvironment;
+    const context = yield* Effect.context<
+      Credentials | HttpClient.HttpClient
+    >();
+
+    const auth: SearchAuth = {
+      authorize: (eff) => eff.pipe(Effect.provideContext(context)),
+      accountId,
+    };
+
+    return Effect.fn(function* (instance: SearchInstance) {
+      // Deferred accessors — resolved against the tracker at apply time.
+      const instanceId = yield* instance.instanceId;
+      const namespace = yield* instance.namespace;
+      return makeLocalSearchClient(
+        auth,
+        Effect.all({ id: instanceId, name: namespace }),
+      );
+    });
+  }),
+);

package/src/Cloudflare/AI/QuerySearchNamespaceLocal.ts

@@ -0,0 +1,60 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import type { Credentials } from "../Credentials.ts";
+import { QuerySearchNamespace } from "./QuerySearchNamespace.ts";
+import {
+  makeLocalSearchNamespaceClient,
+  type SearchAuth,
+} from "./SearchHttpClient.ts";
+import type { SearchNamespace } from "./SearchNamespace.ts";
+
+/**
+ * Local implementation of the {@link QuerySearchNamespace} binding — queries an
+ * AI Search namespace over the Cloudflare HTTP API using the **current
+ * credentials** instead of a native Worker binding
+ * (`QuerySearchNamespaceBinding`).
+ *
+ * Provide it on an {@link Action} (or any deploy-time Effect) to `list`
+ * instances, run a multi-instance `search`, or `.get(instanceName)` a
+ * single-instance client — the same client you'd use inside a Worker. The
+ * namespace name is resolved at apply time through the ambient RuntimeContext.
+ *
+ * `raw` (the native `AiSearchNamespace` runtime handle) is unavailable outside a
+ * deployed Worker and dies if forced.
+ *
+ * @example List a namespace's instances from an Action
+ * ```typescript
+ * const Probe = Alchemy.Action(
+ *   "Probe",
+ *   Effect.gen(function* () {
+ *     const ns = yield* Cloudflare.AI.QuerySearchNamespace(namespace);
+ *     return Effect.fn(function* () {
+ *       const { result } = yield* ns.list();
+ *       return result.map((i) => i.id);
+ *     });
+ *   }).pipe(Effect.provide(Cloudflare.AI.QuerySearchNamespaceLocal)),
+ * );
+ * ```
+ */
+export const QuerySearchNamespaceLocal = Layer.effect(
+  QuerySearchNamespace,
+  Effect.gen(function* () {
+    const { accountId } = yield* yield* CloudflareEnvironment;
+    const context = yield* Effect.context<
+      Credentials | HttpClient.HttpClient
+    >();
+
+    const auth: SearchAuth = {
+      authorize: (eff) => eff.pipe(Effect.provideContext(context)),
+      accountId,
+    };
+
+    return Effect.fn(function* (namespace: SearchNamespace) {
+      // Deferred accessor — resolved against the tracker at apply time.
+      const name = yield* namespace.name;
+      return makeLocalSearchNamespaceClient(auth, name);
+    });
+  }),
+);