alchemy 2.0.0-beta.61 → 2.0.0-beta.63

package/src/Cloudflare/AI/GatewayDynamicRouting.ts

@@ -406,12 +406,44 @@ export const DynamicRoutingProvider = () =>
       });
 
       if (current.name !== name) {
-        yield* aiGateway.patchDynamicRouting({
-          accountId,
-          gatewayId,
-          id: routeId,
-          name,
-        });
+        yield* aiGateway
+          .patchDynamicRouting({
+            accountId,
+            gatewayId,
+            id: routeId,
+            name,
+          })
+          .pipe(
+            // Cloudflare does not cascade-delete a gateway's routes when the
+            // gateway itself is deleted: recreating a gateway with the same
+            // id resurrects its old route rows, and a rename onto one of
+            // those ghosts trips the backing `UNIQUE(routes.name,
+            // routes.gateway_id)` constraint (leaked as a 500, typed as
+            // `RouteAlreadyExists` via a distilled patch). Route names are
+            // unique and deterministic, so the holder is a stale duplicate
+            // of this logical resource — delete it and retry the rename.
+            Effect.catchTag("RouteAlreadyExists", (error) =>
+              Effect.gen(function* () {
+                const holder = yield* findByName(accountId, gatewayId, name);
+                if (holder === undefined || holder.id === routeId) {
+                  return yield* Effect.fail(error);
+                }
+                yield* aiGateway
+                  .deleteDynamicRouting({
+                    accountId,
+                    gatewayId,
+                    id: holder.id,
+                  })
+                  .pipe(Effect.catchTag("RouteNotFound", () => Effect.void));
+                yield* aiGateway.patchDynamicRouting({
+                  accountId,
+                  gatewayId,
+                  id: routeId,
+                  name,
+                });
+              }),
+            ),
+          );
       }
 
       // `get` returns the *deployed* version's graph, so an undeployed

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);
+    });
+  }),
+);

package/src/Cloudflare/AI/SearchHttpClient.ts

@@ -0,0 +1,423 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as aisearch from "@distilled.cloud/cloudflare/aisearch";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
+import type { Credentials } from "../Credentials.ts";
+import { SearchError, type QuerySearchClient } from "./QuerySearch.ts";
+import type { QuerySearchNamespaceClient } from "./QuerySearchNamespace.ts";
+
+// Shared HTTP scaffolding for the AI Search `*Local` binding layers. NOT
+// re-exported from `index.ts` — only the per-level `*Local` layers are public.
+//
+// The `ai_search` / `ai_search_namespace` Worker bindings proxy the same AI
+// Search REST API that distilled wraps, so the whole data plane
+// (`search` / `chatCompletions` / `info` / `stats` / `list`) is reachable over
+// HTTP with the current credentials — no Worker host, no native binding.
+//
+// The one wrinkle: distilled decodes responses to **camelCase**, while the
+// binding client contract types come from `@cloudflare/workers-types` and are
+// the **snake_case** wire shape. These adapters translate both directions
+// (mirroring the D1 `*Local` shim), passing user-controlled maps
+// (`item.metadata`, retrieval `filters`) through untouched.
+
+/**
+ * Injectable auth shared by a future Http (scoped-token) impl and the Local
+ * (current-credentials) impl. `authorize` discharges the
+ * `Credentials | HttpClient` requirement of a distilled op; `accountId` is the
+ * Cloudflare account the ops run against.
+ */
+export interface SearchAuth {
+  authorize: <A, E>(
+    eff: Effect.Effect<A, E, Credentials | HttpClient.HttpClient>,
+  ) => Effect.Effect<A, E>;
+  accountId: string;
+}
+
+const u = <T>(v: T | null | undefined): T | undefined =>
+  v == null ? undefined : v;
+
+const run = <A, E>(
+  auth: SearchAuth,
+  eff: Effect.Effect<A, E, Credentials | HttpClient.HttpClient>,
+): Effect.Effect<A, SearchError, RuntimeContext> =>
+  auth.authorize(eff).pipe(
+    Effect.mapError((cause) => {
+      const message =
+        cause instanceof Error
+          ? cause.message
+          : typeof (cause as { message?: unknown } | undefined)?.message ===
+              "string"
+            ? (cause as { message: string }).message
+            : "AI Search HTTP error";
+      return new SearchError({ message, cause });
+    }),
+  );
+
+// ── response mappers (distilled camelCase -> runtime snake_case) ─────────────
+
+type ChunkIn = aisearch.SearchNamespaceInstanceResponse["chunks"][number];
+
+const mapChunk = (
+  c: ChunkIn,
+): runtime.AiSearchSearchResponse["chunks"][number] => ({
+  id: c.id,
+  type: c.type,
+  score: c.score,
+  text: c.text,
+  item: {
+    key: c.item?.key ?? "",
+    timestamp: u(c.item?.timestamp),
+    metadata: u(c.item?.metadata) as Record<string, unknown> | undefined,
+  },
+  scoring_details: c.scoringDetails
+    ? {
+        keyword_score: u(c.scoringDetails.keywordScore),
+        vector_score: u(c.scoringDetails.vectorScore),
+        keyword_rank: u(c.scoringDetails.keywordRank),
+        vector_rank: u(c.scoringDetails.vectorRank),
+        reranking_score: u(c.scoringDetails.rerankingScore),
+        fusion_method: u(c.scoringDetails.fusionMethod) as
+          | "rrf"
+          | "max"
+          | undefined,
+      }
+    : undefined,
+});
+
+const mapSearch = (
+  r: aisearch.SearchNamespaceInstanceResponse,
+): runtime.AiSearchSearchResponse => ({
+  search_query: r.searchQuery ?? "",
+  chunks: r.chunks.map(mapChunk),
+});
+
+const mapChat = (
+  r: aisearch.ChatCompletionsNamespaceInstanceResponse,
+): runtime.AiSearchChatCompletionsResponse => ({
+  id: u(r.id),
+  object: u(r.object),
+  model: u(r.model),
+  choices: r.choices.map((choice) => ({
+    index: u(choice.index),
+    message: {
+      role: choice.message.role as
+        | "system"
+        | "developer"
+        | "user"
+        | "assistant"
+        | "tool",
+      content:
+        typeof choice.message.content === "string"
+          ? choice.message.content
+          : choice.message.content == null
+            ? null
+            : JSON.stringify(choice.message.content),
+    },
+  })),
+  chunks: r.chunks.map(mapChunk),
+});
+
+const mapStats = (
+  r: aisearch.StatsNamespaceInstanceResponse,
+): runtime.AiSearchStatsResponse => ({
+  queued: u(r.queued),
+  running: u(r.running),
+  completed: u(r.completed),
+  error: u(r.error),
+  skipped: u(r.skipped),
+  outdated: u(r.outdated),
+  last_activity: u(r.lastActivity),
+  engine: r.engine
+    ? {
+        vectorize: r.engine.vectorize
+          ? {
+              vectorsCount: r.engine.vectorize.vectorsCount,
+              dimensions: r.engine.vectorize.dimensions,
+            }
+          : undefined,
+        r2: r.engine.r2
+          ? {
+              payloadSizeBytes: r.engine.r2.payloadSizeBytes,
+              metadataSizeBytes: r.engine.r2.metadataSizeBytes,
+              objectCount: r.engine.r2.objectCount,
+            }
+          : undefined,
+      }
+    : undefined,
+});
+
+const mapInfo = (
+  r: aisearch.ReadNamespaceInstanceResponse,
+): runtime.AiSearchInstanceInfo => ({
+  id: r.id,
+  type: u(r.type) as runtime.AiSearchInstanceInfo["type"],
+  source: u(r.source),
+  source_params: u(r.sourceParams),
+  paused: u(r.paused),
+  status: u(r.status),
+  namespace: u(r.namespace),
+  created_at: u(r.createdAt),
+  modified_at: u(r.modifiedAt),
+  token_id: u(r.tokenId),
+  ai_gateway_id: u(r.aiGatewayId),
+  rewrite_query: u(r.rewriteQuery),
+  reranking: u(r.reranking),
+  embedding_model: u(r.embeddingModel),
+  ai_search_model: u(r.aiSearchModel),
+  rewrite_model: u(r.rewriteModel),
+  reranking_model: u(r.rerankingModel),
+  hybrid_search_enabled: u(r.hybridSearchEnabled),
+  index_method: r.indexMethod
+    ? { vector: r.indexMethod.vector, keyword: r.indexMethod.keyword }
+    : undefined,
+  fusion_method: u(r.fusionMethod) as "max" | "rrf" | undefined,
+  indexing_options: r.indexingOptions
+    ? {
+        keyword_tokenizer: u(r.indexingOptions.keywordTokenizer) as
+          | "porter"
+          | "trigram"
+          | undefined,
+      }
+    : undefined,
+  retrieval_options: r.retrievalOptions
+    ? {
+        keyword_match_mode: u(r.retrievalOptions.keywordMatchMode) as
+          | "and"
+          | "or"
+          | undefined,
+        boost_by: u(r.retrievalOptions.boostBy)?.map((b) => ({
+          field: b.field,
+          direction: u(b.direction) as
+            | "asc"
+            | "desc"
+            | "exists"
+            | "not_exists"
+            | undefined,
+        })),
+      }
+    : undefined,
+  chunk_size: u(r.chunkSize),
+  chunk_overlap: u(r.chunkOverlap),
+  score_threshold: u(r.scoreThreshold),
+  max_num_results: u(r.maxNumResults),
+  cache: u(r.cache),
+  cache_threshold: u(
+    r.cacheThreshold,
+  ) as runtime.AiSearchInstanceInfo["cache_threshold"],
+  custom_metadata: u(r.customMetadata)?.map((m) => ({
+    field_name: m.fieldName,
+    data_type: m.dataType as "text" | "number" | "boolean" | "datetime",
+  })),
+  sync_interval: u(
+    r.syncInterval,
+  ) as runtime.AiSearchInstanceInfo["sync_interval"],
+  metadata: u(r.metadata) as Record<string, unknown> | undefined,
+});
+
+const mapList = (
+  result: aisearch.ReadNamespaceInstanceResponse[],
+): runtime.AiSearchListResponse => ({
+  result: result.map(mapInfo),
+});
+
+const mapMulti = (
+  r: aisearch.SearchNamespaceResponse,
+): runtime.AiSearchMultiSearchResponse => ({
+  search_query: r.searchQuery ?? "",
+  chunks: r.chunks.map((c) => ({ ...mapChunk(c), instance_id: c.instanceId })),
+  errors: u(r.errors)?.map((e) => ({
+    instance_id: e.instanceId,
+    message: e.message,
+  })),
+});
+
+// ── request mappers (runtime snake_case -> distilled camelCase) ──────────────
+
+const mapMessages = (messages: runtime.AiSearchMessage[]) =>
+  messages.map((m) => ({
+    role: m.role as "system" | "developer" | "user" | "assistant" | "tool",
+    content:
+      typeof m.content === "string" || m.content == null
+        ? m.content
+        : (m.content as unknown[]).map((part) => {
+            const p = part as Record<string, unknown>;
+            if ("image_url" in p || "imageUrl" in p) {
+              const img = (p.image_url ?? p.imageUrl) as { url: string };
+              return { type: "image_url" as const, imageUrl: { url: img.url } };
+            }
+            return { type: "text" as const, text: p.text as string };
+          }),
+  }));
+
+const mapOptions = (o: runtime.AiSearchOptions | undefined) => {
+  if (!o) return undefined;
+  return {
+    cache: o.cache
+      ? { enabled: o.cache.enabled, cacheThreshold: o.cache.cache_threshold }
+      : undefined,
+    queryRewrite: o.query_rewrite
+      ? {
+          enabled: o.query_rewrite.enabled,
+          model: o.query_rewrite.model,
+          rewritePrompt: o.query_rewrite.rewrite_prompt,
+        }
+      : undefined,
+    reranking: o.reranking
+      ? {
+          enabled: o.reranking.enabled,
+          model: o.reranking.model,
+          matchThreshold: o.reranking.match_threshold,
+        }
+      : undefined,
+    retrieval: o.retrieval
+      ? {
+          retrievalType: o.retrieval.retrieval_type,
+          fusionMethod: o.retrieval.fusion_method,
+          keywordMatchMode: o.retrieval.keyword_match_mode,
+          matchThreshold: o.retrieval.match_threshold,
+          maxNumResults: o.retrieval.max_num_results,
+          contextExpansion: o.retrieval.context_expansion,
+          returnOnFailure: o.retrieval.return_on_failure,
+          // `filters` is a Vectorize metadata filter over user-defined fields —
+          // pass through untouched.
+          filters: o.retrieval.filters as Record<string, unknown> | undefined,
+          boostBy: o.retrieval.boost_by,
+        }
+      : undefined,
+  };
+};
+
+// ── client builders ──────────────────────────────────────────────────────────
+
+/** Effect resolving `{ name (namespace), id (instanceId) }` at apply time. */
+export type InstanceRef = Effect.Effect<{ name: string; id: string }>;
+
+/** Effect resolving the namespace `name` at apply time. */
+export type NamespaceRef = Effect.Effect<string>;
+
+const dieRaw = (kind: string): Effect.Effect<never> =>
+  Effect.die(
+    new Error(
+      `The AI Search ${kind} *Local binding runs over the HTTP API; the raw native runtime binding is only available inside a deployed Worker.`,
+    ),
+  );
+
+/**
+ * Build a single-instance {@link QuerySearchClient} over the HTTP API. `ref`
+ * resolves the `{ namespace, instanceId }` at apply time.
+ */
+export const makeLocalSearchClient = (
+  auth: SearchAuth,
+  ref: InstanceRef,
+): QuerySearchClient => {
+  const withRef = <A, E>(
+    fn: (r: {
+      name: string;
+      id: string;
+    }) => Effect.Effect<A, E, Credentials | HttpClient.HttpClient>,
+  ) => Effect.flatMap(ref, (r) => run(auth, fn(r)));
+
+  return {
+    raw: dieRaw("instance"),
+    search: (params) =>
+      withRef((r) =>
+        aisearch.searchNamespaceInstance({
+          accountId: auth.accountId,
+          name: r.name,
+          id: r.id,
+          ...("query" in params && params.query !== undefined
+            ? { query: params.query }
+            : { messages: mapMessages(params.messages ?? []) }),
+          aiSearchOptions: mapOptions(params.ai_search_options),
+        } as aisearch.SearchNamespaceInstanceRequest),
+      ).pipe(Effect.map(mapSearch)),
+    chatCompletions: (params) =>
+      withRef((r) =>
+        aisearch.chatCompletionsNamespaceInstance({
+          accountId: auth.accountId,
+          name: r.name,
+          id: r.id,
+          messages: mapMessages(params.messages),
+          aiSearchOptions: mapOptions(params.ai_search_options),
+        } as aisearch.ChatCompletionsNamespaceInstanceRequest),
+      ).pipe(Effect.map(mapChat)),
+    info: () =>
+      withRef((r) =>
+        aisearch.readNamespaceInstance({
+          accountId: auth.accountId,
+          name: r.name,
+          id: r.id,
+        }),
+      ).pipe(Effect.map(mapInfo)),
+    stats: () =>
+      withRef((r) =>
+        aisearch.statsNamespaceInstance({
+          accountId: auth.accountId,
+          name: r.name,
+          id: r.id,
+        }),
+      ).pipe(Effect.map(mapStats)),
+  } satisfies QuerySearchClient;
+};
+
+/**
+ * Build a namespace {@link QuerySearchNamespaceClient} over the HTTP API.
+ * `.get(instanceName)` scopes a single-instance client to `(namespace,
+ * instanceName)`.
+ */
+export const makeLocalSearchNamespaceClient = (
+  auth: SearchAuth,
+  ref: NamespaceRef,
+): QuerySearchNamespaceClient => ({
+  raw: dieRaw("namespace"),
+  get: (instanceName) =>
+    makeLocalSearchClient(
+      auth,
+      Effect.map(ref, (name) => ({ name, id: instanceName })),
+    ),
+  list: (params) =>
+    Effect.flatMap(ref, (name) =>
+      run(
+        auth,
+        Stream.runCollect(
+          aisearch.listNamespaceInstances.pages({
+            accountId: auth.accountId,
+            name,
+            perPage: params?.per_page,
+            orderBy: params?.order_by,
+            orderByDirection: params?.order_by_direction,
+            search: params?.search,
+          }),
+        ),
+      ),
+    ).pipe(
+      Effect.map((chunk) =>
+        mapList(
+          Array.from(chunk).flatMap(
+            (page) =>
+              (page.result ??
+                []) as unknown as aisearch.ReadNamespaceInstanceResponse[],
+          ),
+        ),
+      ),
+    ),
+  search: (params) =>
+    Effect.flatMap(ref, (name) =>
+      run(
+        auth,
+        aisearch.searchNamespace({
+          accountId: auth.accountId,
+          name,
+          aiSearchOptions: {
+            instanceIds: params.ai_search_options.instance_ids,
+            ...mapOptions(params.ai_search_options),
+          },
+          ...("query" in params && params.query !== undefined
+            ? { query: params.query }
+            : { messages: mapMessages(params.messages ?? []) }),
+        } as aisearch.SearchNamespaceRequest),
+      ),
+    ).pipe(Effect.map(mapMulti)),
+});

package/src/Cloudflare/AI/SearchInstance.ts

@@ -835,9 +835,10 @@ const retryTokenPropagation = <A, E extends { _tag: string }, R>(
       // sparsely and detects a settled token tens of seconds late. Capped
       // polling detects within 6s of propagation completing while still
       // covering a long total window.
-      schedule: Schedule.exponential("1 second", 1.5).pipe(
-        Schedule.either(Schedule.spaced("6 seconds")),
-      ),
+      schedule: Schedule.min([
+        Schedule.exponential("1 second", 1.5),
+        Schedule.spaced("6 seconds"),
+      ]),
       times: 22,
     }),
   );

package/src/Cloudflare/AI/index.ts

@@ -11,8 +11,10 @@ export * from "./QueryGateway.ts";
 export * from "./QueryGatewayBinding.ts";
 export * from "./QuerySearch.ts";
 export * from "./QuerySearchBinding.ts";
+export * from "./QuerySearchLocal.ts";
 export * from "./QuerySearchNamespace.ts";
 export * from "./QuerySearchNamespaceBinding.ts";
+export * from "./QuerySearchNamespaceLocal.ts";
 export * from "./Search.ts";
 export * from "./SearchInstance.ts";
 export * from "./SearchNamespace.ts";