feat(semantic-search): add cloudflare ai search backend

apps/host-cloudflare/src/app.ts

@@ -40,8 +40,7 @@ export const makeCloudflareApp = async (env: CloudflareEnv) => {
   const plugins = makeCloudflarePlugins(
     config.secretKey,
     env.ANALYTICS,
-    env.VECTORIZE,
-    config.geminiApiKey,
+    config.aiSearch,
     config.organizationId,
   );
 

apps/host-cloudflare/src/config.ts

@@ -5,7 +5,7 @@ import type {
   R2Bucket,
 } from "@cloudflare/workers-types";
 import type { AnalyticsEngineDataset } from "@executor-js/plugin-execution-metrics/cloudflare";
-import type { VectorizeIndex } from "@executor-js/plugin-semantic-search";
+import type { AiSearchInstance } from "@executor-js/plugin-semantic-search";
 
 import { isValidOrgSlug } from "@executor-js/api";
 import { missingPublicOriginWarning, resolvePublicOrigin } from "@executor-js/sdk/public-origin";
@@ -34,15 +34,8 @@ export interface CloudflareEnv {
    *  bound (uncomment `analytics_engine_datasets` in wrangler.jsonc), each
    *  finished execution/tool call writes a data point; absent, metrics are off. */
   readonly ANALYTICS?: AnalyticsEngineDataset;
-  /** Vectorize index binding — opt-in semantic `tools.search`. When bound (add a
-   *  `vectorize` binding in wrangler.jsonc) the semantic-search plugin embeds
-   *  the tool catalog and answers `tools.search` from it; absent, the engine
-   *  keeps its built-in lexical search. */
-  readonly VECTORIZE?: VectorizeIndex;
-  /** Gemini API key (a `wrangler secret`) powering the embeddings for the
-   *  Vectorize search. Absent → semantic search stays inert even if the index
-   *  is bound. */
-  readonly GEMINI_API_KEY?: string;
+  /** AI Search instance binding for semantic `tools.search`. */
+  readonly AI_SEARCH?: AiSearchInstance;
   /** MCP session Durable Object namespace — one addressable isolate per MCP
    *  session (the DO id IS the session id), so a session survives across the
    *  Worker's stateless isolates. */
@@ -86,9 +79,8 @@ export interface CloudflareConfig {
   /** URL slug for org-prefixed console paths (`/<slug>/policies`). */
   readonly organizationSlug: string;
   readonly secretKey: string;
-  /** Gemini API key for the Vectorize search embeddings (a `wrangler secret`).
-   *  Unset → vectorize search is inert. */
-  readonly geminiApiKey?: string;
+  /** AI Search instance binding for semantic `tools.search`. */
+  readonly aiSearch?: AiSearchInstance;
   readonly allowLocalNetwork: boolean;
   /** Explicit web base URL (`VITE_PUBLIC_SITE_URL`). Unset on a Worker with no
    *  static URL — the per-request origin is used instead (see RequestWebOrigin). */
@@ -146,7 +138,7 @@ export const loadConfig = (env: CloudflareEnv): CloudflareConfig => {
     organizationName: env.SELF_HOSTED_ORG_NAME ?? "Default",
     organizationSlug: resolveOrgSlug(env.SELF_HOSTED_ORG_SLUG),
     secretKey,
-    geminiApiKey: env.GEMINI_API_KEY?.trim() || undefined,
+    aiSearch: env.AI_SEARCH,
     allowLocalNetwork: env.ALLOW_LOCAL_NETWORK === "true",
     // Pinned origin via the shared resolver. A Worker receives no PaaS platform
     // vars (env: {} — there is nothing to detect), so only the explicit

apps/host-cloudflare/src/execution.ts

@@ -38,7 +38,8 @@ export const makeCloudflarePluginsProvider = (
   config: CloudflareConfig,
 ): Layer.Layer<PluginsProvider> =>
   Layer.succeed(PluginsProvider)({
-    plugins: () => makeCloudflarePlugins(config.secretKey),
+    plugins: () =>
+      makeCloudflarePlugins(config.secretKey, undefined, config.aiSearch, config.organizationId),
   });
 
 export const makeCloudflareHostConfig = (config: CloudflareConfig): Layer.Layer<HostConfig> =>

apps/host-cloudflare/src/plugins.ts

@@ -13,10 +13,8 @@ import { noopExecutionObserver } from "@executor-js/sdk";
 import { serviceTokensPlugin } from "@executor-js/plugin-service-tokens/server";
 import { semanticSearchHttpPlugin } from "@executor-js/plugin-semantic-search/api";
 import {
-  makeVectorizeStore,
-  ToolSearchBackend,
-  withCloudflareLimits,
-  type VectorizeIndex,
+  makeAiSearchToolSearchBackend,
+  type AiSearchInstance,
 } from "@executor-js/plugin-semantic-search";
 
 // ---------------------------------------------------------------------------
@@ -39,27 +37,21 @@ import {
 //
 // Semantic search follows the same opt-in-by-binding shape: the plugin is
 // always in the tuple (its reindex route keeps the API shape stable), but it is
-// inert — the engine keeps its lexical `tools.search` — until BOTH a `vectorize`
-// binding and the `GEMINI_API_KEY` secret are present. To enable: create a
-// Vectorize index + add the binding in wrangler.jsonc and set the secret.
+// inert until the Cloudflare AI Search binding is present.
 // ---------------------------------------------------------------------------
 
 export const makeCloudflarePlugins = (
   secretKey: string,
   analytics?: AnalyticsEngineDataset,
-  vectorize?: VectorizeIndex,
-  geminiApiKey?: string,
+  aiSearch?: AiSearchInstance,
   searchNamespace?: string,
 ) => {
-  const store = vectorize ? withCloudflareLimits(makeVectorizeStore(vectorize)) : undefined;
-  const semanticSearchBackend =
-    store && geminiApiKey
-      ? ToolSearchBackend.vector({
-          store,
-          geminiApiKey,
-          namespace: searchNamespace,
-        })
-      : undefined;
+  const semanticSearchBackend = aiSearch
+    ? makeAiSearchToolSearchBackend({
+        aiSearch,
+        namespace: searchNamespace,
+      })
+    : undefined;
   return [
     openApiHttpPlugin(),
     googleHttpPlugin(),

apps/host-cloudflare/wrangler.jsonc

@@ -46,6 +46,10 @@
   // "analytics_engine_datasets": [
   //   { "binding": "ANALYTICS", "dataset": "executor_executions" },
   // ],
+  // Cloudflare AI Search is the preferred backend for semantic `tools.search`.
+  // Uncomment after creating the instance, otherwise deploy will fail because
+  // the binding target is absent.
+  // "ai_search": [{ "binding": "AI_SEARCH", "instance_name": "executor-tool-search" }],
   // The MCP session Durable Object: one addressable isolate per MCP session (the
   // DO id IS the session id) so a session survives across the Worker's stateless
   // isolates — without it, `tools/list` after `initialize` can land on a fresh

packages/plugins/semantic-search/src/api/group.ts

@@ -57,6 +57,13 @@ export const StatusResponse = Schema.Struct({
   namespace: Schema.String,
   indexed: Schema.Number,
   lexical: Schema.NullOr(Schema.Number),
+  queued: Schema.optional(Schema.Number),
+  running: Schema.optional(Schema.Number),
+  completed: Schema.optional(Schema.Number),
+  error: Schema.optional(Schema.Number),
+  skipped: Schema.optional(Schema.Number),
+  outdated: Schema.optional(Schema.Number),
+  lastActivity: Schema.optional(Schema.String),
 });
 
 export type SearchResultItemType = typeof SearchResultItem.Type;