refactor(cloudflare): require ai search backend

Author: aryasaatvik

apps/host-cloudflare/src/app.ts

@@ -41,8 +41,6 @@ export const makeCloudflareApp = async (env: CloudflareEnv) => {
     config.secretKey,
     env.ANALYTICS,
     config.aiSearch,
-    env.VECTORIZE,
-    config.geminiApiKey,
     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 { AiSearchInstance, 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,17 +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;
-  /** AI Search instance binding - preferred semantic `tools.search` backend. */
+  /** AI Search instance binding for semantic `tools.search`. */
   readonly AI_SEARCH?: AiSearchInstance;
-  /** 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;
   /** 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. */
@@ -90,9 +81,6 @@ export interface CloudflareConfig {
   readonly secretKey: string;
   /** AI Search instance binding for semantic `tools.search`. */
   readonly aiSearch?: AiSearchInstance;
-  /** Gemini API key for the Vectorize search embeddings (a `wrangler secret`).
-   *  Unset → vectorize search is inert. */
-  readonly geminiApiKey?: string;
   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). */
@@ -151,7 +139,6 @@ export const loadConfig = (env: CloudflareEnv): CloudflareConfig => {
     organizationSlug: resolveOrgSlug(env.SELF_HOSTED_ORG_SLUG),
     secretKey,
     aiSearch: env.AI_SEARCH,
-    geminiApiKey: env.GEMINI_API_KEY?.trim() || undefined,
     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

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

apps/host-cloudflare/src/plugins.ts

@@ -14,11 +14,7 @@ import { serviceTokensPlugin } from "@executor-js/plugin-service-tokens/server";
 import { semanticSearchHttpPlugin } from "@executor-js/plugin-semantic-search/api";
 import {
   makeAiSearchToolSearchBackend,
-  makeVectorizeStore,
-  ToolSearchBackend,
-  withCloudflareLimits,
   type AiSearchInstance,
-  type VectorizeIndex,
 } from "@executor-js/plugin-semantic-search";
 
 // ---------------------------------------------------------------------------
@@ -41,31 +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 until a search backend binding is present. Prefer Cloudflare AI Search
-// when bound; otherwise fall back to the Vectorize + Gemini backend.
+// inert until the Cloudflare AI Search binding is present.
 // ---------------------------------------------------------------------------
 
 export const makeCloudflarePlugins = (
   secretKey: string,
   analytics?: AnalyticsEngineDataset,
   aiSearch?: AiSearchInstance,
-  vectorize?: VectorizeIndex,
-  geminiApiKey?: string,
   searchNamespace?: string,
 ) => {
-  const store = vectorize ? withCloudflareLimits(makeVectorizeStore(vectorize)) : undefined;
   const semanticSearchBackend = aiSearch
     ? makeAiSearchToolSearchBackend({
         aiSearch,
         namespace: searchNamespace,
       })
-    : store && geminiApiKey
-      ? ToolSearchBackend.vector({
-          store,
-          geminiApiKey,
-          namespace: searchNamespace,
-        })
-      : undefined;
+    : undefined;
   return [
     openApiHttpPlugin(),
     googleHttpPlugin(),