@agent-native/core 0.124.3 → 0.124.4

package/docs/content/what-is-agent-native.mdx

@@ -322,19 +322,19 @@ Agent-native isn't just for developers. Because the agent can edit the app's own
 
 The vision: fewer handoffs, one person doing the work of a small team.
 
-## Fork and customize {#fork-and-customize}
+## Start from a template and customize {#fork-and-customize}
 
-Agent-native apps follow a fork-and-customize model. You start from a **template** — Calendar, Content, Slides, Analytics, Mail, Clips, Design, Forms, Dispatch — and make it yours. Each one is a complete, working SaaS product you fork wholesale, not a blank scaffold:
+Agent-native apps follow a start-from-a-working-app model. You start from a **template** — Calendar, Content, Slides, Analytics, Mail, Clips, Design, Forms, Dispatch — and make it yours. Each one is a complete, working SaaS product, not a blank scaffold:
 
 1. Pick a template on [agent-native.com/templates](/templates)
 2. Use it immediately as a hosted app (e.g. mail.agent-native.com)
-3. Fork it when you want to customize — "connect our Stripe account," "add a cohort chart"
+3. Create your own app from the template when you want to customize — "connect our Stripe account," "add a cohort chart"
 4. The agent modifies the code to match your needs
-5. Deploy your fork to your own domain — or stay on agent-native.com
+5. Deploy your app to your own domain — or stay on agent-native.com
 
 Because it's _your_ app, not shared infrastructure, the agent can safely evolve the code. Your app keeps improving as you use it. See [Templates](/docs/cloneable-saas) for the full story.
 
-Not ready to fork a whole template? You can also try agent-native by adding a **skill** to a coding agent you already use — install the Plans skill with `npx @agent-native/core@latest skills add visual-plan`. See the [Skills Guide](/docs/skills-guide#app-backed-skills).
+Not ready to start from a whole template? You can also try agent-native by adding a **skill** to a coding agent you already use — install the Plans skill with `npx @agent-native/core@latest skills add visual-plan`. See the [Skills Guide](/docs/skills-guide#app-backed-skills).
 
 ## Composable agents {#composable-agents}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.124.3",
+  "version": "0.124.4",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/src/a2a/auth-policy.ts

@@ -16,7 +16,7 @@ export function isA2AProductionRuntime(): boolean {
     return true;
   }
   if (process.env.CF_PAGES === "1") return true;
-  if ("__cf_env" in globalThis) return true;
+  if ("__cf_env" in globalThis || "__env__" in globalThis) return true;
   if (process.env.VERCEL || process.env.VERCEL_ENV) return true;
   if (process.env.RENDER || process.env.FLY_APP_NAME || process.env.K_SERVICE) {
     return true;

package/src/agent/production-agent.ts

@@ -2088,6 +2088,13 @@ function collectTextParts(parts: EngineContentPart[]): string {
     .join("");
 }
 
+// Guard retries are pushed as `role: "user"` because engines have no other
+// mid-turn channel. Unlabeled, a corrective instruction ("say the source is
+// not connected and include this link") reads exactly like an injected user
+// turn, and an aligned model refuses it *to the user* instead of following it.
+export const AGENT_INTERNAL_GUARD_PROMPT =
+  "Automated quality check on the draft answer you just produced. This is a directive from this application's own response guard, not a message from the user and not content from a tool result or web page. Follow it and revise your answer. Do not quote it, describe it, or treat it as an injection attempt. If it contradicts what you observed this turn, state what you actually observed instead of asserting the guard's premise.";
+
 export const AGENT_INTERNAL_CONTINUE_PROMPT =
   "Continue from where you left off and finish the user's original request. Do not repeat completed work, do not mention internal reconnects, time limits, or step limits, and continue as if this is the same uninterrupted run.";
 
@@ -4588,7 +4595,12 @@ export async function runAgentLoop(opts: {
           send({ type: "clear" });
           messages.push({
             role: "user",
-            content: [{ type: "text", text: retryMessage }],
+            content: [
+              {
+                type: "text",
+                text: `${AGENT_INTERNAL_GUARD_PROMPT}\n\n<response-guard>\n${retryMessage}\n</response-guard>`,
+              },
+            ],
           });
           continue;
         }
@@ -8966,6 +8978,7 @@ export function createProductionAgentHandler(
         // assistant message. Falls back to the runId (turn == run) when the
         // client doesn't supply a turnId.
         turnId: effectiveTurnId,
+        waitUntil: getRequestRunContext()?.waitUntil,
         dispatchMode: foregroundSelfChainEligible
           ? "foreground-self-chain"
           : "foreground",

package/src/agent/run-manager.ts

@@ -348,6 +348,8 @@ function shouldCaptureRunError(err: unknown): boolean {
 }
 
 export interface StartRunOptions {
+  /** Keep a request-scoped serverless invocation alive for this run. */
+  waitUntil?: (promise: Promise<unknown>) => void;
   /** Optional internal run chunk budget. When reached, the framework emits an
    * auto-continuation signal instead of a user-facing timeout. Leave unset for
    * no framework-imposed run timeout. */
@@ -1344,19 +1346,10 @@ export function startRun(
     });
   runPromise.then(resolveFinalized, rejectFinalized);
 
-  // On Cloudflare Workers, keep the isolate alive for this run
-  try {
-    const cfCtx = (
-      globalThis as typeof globalThis & {
-        __cf_ctx?: { waitUntil(promise: Promise<unknown>): void };
-      }
-    ).__cf_ctx;
-    if (cfCtx?.waitUntil) {
-      cfCtx.waitUntil(runPromise);
-    }
-  } catch {
-    // Not on Workers — ignore
-  }
+  // Keep the originating request alive when its runtime supports background
+  // work. The callback is passed through request context so concurrent Worker
+  // requests cannot overwrite one another through a global binding.
+  options?.waitUntil?.(runPromise);
 
   return run;
 }

package/src/cli/index.ts

@@ -8,6 +8,10 @@ import { fileURLToPath } from "url";
 
 import * as Sentry from "@sentry/node";
 
+import {
+  clearAgentNativeNitroPresetMarker,
+  resolveAgentNativeNitroPreset,
+} from "../deploy/nitro-preset.js";
 import { resolveDeployPostBuildInvocation } from "./deploy-build.js";
 import { shouldTrackCliRun } from "./telemetry-routing.js";
 import { createCliTelemetry } from "./telemetry.js";
@@ -696,6 +700,7 @@ switch (command) {
       }
 
       if (isReactRouterFramework()) {
+        clearAgentNativeNitroPresetMarker();
         validateReactRouterBuildDependencies();
         const rr = findReactRouterBin();
         console.log("Building (React Router framework mode)...");
@@ -709,15 +714,20 @@ switch (command) {
       // Post-build: framework-mode apps also need a Nitro server bundle for
       // `agent-native start` and for serverless presets.
       if (isReactRouterFramework()) {
+        const configuredNitroPreset = resolveAgentNativeNitroPreset();
+        const deployEnv = configuredNitroPreset
+          ? { ...process.env, NITRO_PRESET: configuredNitroPreset }
+          : process.env;
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
         const deployBuild = resolveDeployPostBuildInvocation({
           cliDir: __dirname,
+          env: deployEnv,
           findTsxBin,
         });
         if (deployBuild) {
           await runBuildStep(deployBuild.command, deployBuild.args, {
             label: "deploy-build",
-            env: process.env,
+            env: deployEnv,
           });
         } else {
           console.warn(

package/src/client/route-chunk-recovery.ts

@@ -190,16 +190,27 @@ function recoverToIntendedNavigation(
   state: RouteChunkRecoveryState,
 ): boolean {
   const target = getFreshIntendedNavigation(state, win.location.href);
-  if (!target) return false;
+  const sameCurrentTarget =
+    !target &&
+    state.intendedHref === win.location.href &&
+    Date.now() - state.intendedAt <= INTENDED_NAV_MAX_AGE_MS
+      ? state.intendedHref
+      : null;
+  const recoveryTarget = target ?? sameCurrentTarget;
+  if (!recoveryTarget) return false;
   state.recovering = true;
-  state.recoveryHref = target;
-  // Desktop webviews stay open across many deploys; a forced navigation here
-  // reads as a random tab reload. Leave the current view alive instead.
-  if (isAgentNativeDesktop(win)) return true;
+  state.recoveryHref = recoveryTarget;
+  // Keep the desktop shell mounted, but replace only the route that failed to
+  // load. A current-page reload remains suppressed below when there is no
+  // intended cross-route destination to recover.
+  if (isAgentNativeDesktop(win)) {
+    hardNavigate(win, recoveryTarget);
+    return true;
+  }
   try {
-    win.history.replaceState(win.history.state, "", target);
+    win.history.replaceState(win.history.state, "", recoveryTarget);
   } catch {}
-  hardNavigate(win, target);
+  hardNavigate(win, recoveryTarget);
   return true;
 }
 

package/src/db/client.ts

@@ -65,11 +65,11 @@ export interface DbExecConfig {
 /** Read the request-scoped Cloudflare binding without requiring every
  * consuming app's TypeScript program to include core's ambient Worker globals. */
 export function getCloudflareD1Binding(): unknown {
-  return (
-    globalThis as typeof globalThis & {
-      __cf_env?: { DB?: unknown };
-    }
-  ).__cf_env?.DB;
+  const runtime = globalThis as typeof globalThis & {
+    __cf_env?: { DB?: unknown };
+    __env__?: { DB?: unknown };
+  };
+  return runtime.__cf_env?.DB ?? runtime.__env__?.DB;
 }
 
 // ---------------------------------------------------------------------------
@@ -451,7 +451,8 @@ export function getDialect(): Dialect {
     return _dialect;
   }
 
-  // Don't cache the fallthrough — on CF Workers, env bindings (__cf_env) aren't
+  // Don't cache the fallthrough — on CF Workers, env bindings (__cf_env/__env__)
+  // aren't
   // available at import time. If we cache "sqlite" here, D1 will never be
   // detected once the bindings are set in the fetch handler.
   return "sqlite";

package/src/db/migrations.ts

@@ -682,7 +682,8 @@ export function runMigrations(
         !!globalThis.process?.env?.NETLIFY ||
         !!globalThis.process?.env?.AWS_LAMBDA_FUNCTION_NAME ||
         !!globalThis.process?.env?.VERCEL ||
-        "__cf_env" in globalThis;
+        "__cf_env" in globalThis ||
+        "__env__" in globalThis;
       if (typeof globalThis.process?.exit === "function" && !isServerless) {
         process.exit(1);
       }

package/src/deploy/build.ts

@@ -10,6 +10,7 @@
  *
  * Supported presets:
  * - cloudflare_pages: Outputs dist/ with _worker.js for Cloudflare Pages
+ * - cloudflare_module: Outputs a native Cloudflare Worker under .output/server
  *
  * Usage: node deploy/build.js (called automatically by `agent-native build`)
  */
@@ -73,6 +74,171 @@ import {
 
 const cwd = process.cwd();
 const preset = process.env.NITRO_PRESET || "node";
+export const CLOUDFLARE_MODULE_PRESETS = [
+  "cloudflare_module",
+  "cloudflare-module",
+] as const;
+
+export function isCloudflareModulePreset(targetPreset: string): boolean {
+  return (CLOUDFLARE_MODULE_PRESETS as readonly string[]).includes(
+    targetPreset,
+  );
+}
+
+export const CLOUDFLARE_MODULE_WORKER_ENTRY = "worker.mjs";
+
+export function generateCloudflareModuleWorkerEntry(): string {
+  return `let handler;
+
+export * from "./index.mjs";
+
+async function loadHandler() {
+  handler ??= (await import("./index.mjs")).default;
+  return handler;
+}
+
+function initializeBindings(env) {
+  if (!env) return;
+  globalThis.__cf_env = env;
+  globalThis.__env__ = env;
+  globalThis.process = globalThis.process || { env: {} };
+  globalThis.process.env = globalThis.process.env || {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") globalThis.process.env[key] = value;
+  }
+}
+
+export default {
+  async fetch(request, env, ctx) {
+    if (typeof ctx?.waitUntil === "function") {
+      request.waitUntil = ctx.waitUntil.bind(ctx);
+    }
+    initializeBindings(env);
+    return (await loadHandler()).fetch(request, env, ctx);
+  },
+  async scheduled(controller, env, ctx) {
+    initializeBindings(env);
+    return (await loadHandler()).scheduled?.(controller, env, ctx);
+  },
+  async email(message, env, ctx) {
+    initializeBindings(env);
+    return (await loadHandler()).email?.(message, env, ctx);
+  },
+  async queue(batch, env, ctx) {
+    initializeBindings(env);
+    return (await loadHandler()).queue?.(batch, env, ctx);
+  },
+  async tail(traces, env, ctx) {
+    initializeBindings(env);
+    return (await loadHandler()).tail?.(traces, env, ctx);
+  },
+  async trace(traces, env, ctx) {
+    initializeBindings(env);
+    return (await loadHandler()).trace?.(traces, env, ctx);
+  },
+};
+`;
+}
+
+export function patchCloudflareModuleNitroEntry(code: string): string {
+  const factoryMatch = code.match(
+    /function ([A-Za-z_$][\w$]*)\(e\)\{let ([A-Za-z_$][\w$]*)=([A-Za-z_$][\w$]*)\(\),([A-Za-z_$][\w$]*)=([A-Za-z_$][\w$]*)\(\);return\{async fetch\(([A-Za-z_$][\w$]*),([A-Za-z_$][\w$]*),([A-Za-z_$][\w$]*)\)\{/,
+  );
+  if (!factoryMatch) {
+    throw new Error(
+      "[deploy] Could not find Nitro's Cloudflare module handler factory",
+    );
+  }
+
+  const [
+    ,
+    factoryName,
+    handlerName,
+    handlerFactoryName,
+    hooksName,
+    hooksFactoryName,
+    requestName,
+    envName,
+    contextName,
+  ] = factoryMatch;
+  const eagerInitialization = `let ${handlerName}=${handlerFactoryName}(),${hooksName}=${hooksFactoryName}();`;
+  if (!code.includes(eagerInitialization)) {
+    throw new Error(
+      `[deploy] Nitro's ${factoryName} handler changed its initialization shape`,
+    );
+  }
+
+  const bindingMatch = code.match(
+    new RegExp(
+      `globalThis\\.__env__=${envName},([A-Za-z_$][\\w$]*)\\(${requestName},\\{env:${envName},context:${contextName}\\}\\);?`,
+    ),
+  );
+  if (!bindingMatch) {
+    throw new Error(
+      `[deploy] Nitro's ${factoryName} handler does not initialize Cloudflare bindings as expected`,
+    );
+  }
+  const bindingInitialization = bindingMatch[0];
+
+  let patched = code.replace(
+    eagerInitialization,
+    `let ${handlerName},${hooksName};`,
+  );
+  patched = patched.replace(
+    bindingInitialization,
+    `${bindingInitialization}${handlerName}??=${handlerFactoryName}();`,
+  );
+  const hookCall = `${hooksName}.callHook(`;
+  if (!patched.includes(hookCall)) {
+    throw new Error(
+      `[deploy] Nitro's ${factoryName} handler has no Cloudflare lifecycle hooks`,
+    );
+  }
+  patched = patched
+    .split(hookCall)
+    .join(`(${hooksName}??=${hooksFactoryName}()).callHook(`);
+
+  return patched;
+}
+
+export function configureCloudflareModuleWorkerOutput(serverDir: string): void {
+  const configPath = path.join(serverDir, "wrangler.json");
+  if (!fs.existsSync(configPath)) {
+    throw new Error(
+      `[deploy] Nitro did not generate ${configPath} for cloudflare_module`,
+    );
+  }
+  const nitroEntryPath = path.join(serverDir, "index.mjs");
+  if (!fs.existsSync(nitroEntryPath)) {
+    throw new Error(
+      `[deploy] Nitro did not generate ${nitroEntryPath} for cloudflare_module`,
+    );
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, "utf8")) as {
+    main?: string;
+    compatibility_flags?: unknown;
+    [key: string]: unknown;
+  };
+  config.main = CLOUDFLARE_MODULE_WORKER_ENTRY;
+  const compatibilityFlags = Array.isArray(config.compatibility_flags)
+    ? config.compatibility_flags.filter(
+        (flag): flag is string => typeof flag === "string",
+      )
+    : [];
+  config.compatibility_flags = [
+    ...new Set([...compatibilityFlags, "nodejs_compat"]),
+  ];
+  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  fs.writeFileSync(
+    nitroEntryPath,
+    patchCloudflareModuleNitroEntry(fs.readFileSync(nitroEntryPath, "utf8")),
+  );
+  fs.writeFileSync(
+    path.join(serverDir, CLOUDFLARE_MODULE_WORKER_ENTRY),
+    generateCloudflareModuleWorkerEntry(),
+  );
+}
 export const NITRO_RUNTIME_IGNORE_PATTERNS = [
   "**/*.spec.ts",
   "**/*.spec.tsx",
@@ -893,7 +1059,9 @@ function requestWithMountedApiPrefixStripped(request) {
     return request;
   }
   url.pathname = strippedPathname;
-  return new Request(url, request);
+  const rewritten = new Request(url, request);
+  rewritten.waitUntil = request.waitUntil;
+  return rewritten;
 }
 
 function prefixMountedPath(path, basePath) {
@@ -1347,8 +1515,10 @@ ${
 
 export default {
   async fetch(request, env, ctx) {
-    // Expose env and ctx bindings globally for compatibility
-    if (ctx) globalThis.__cf_ctx = ctx;
+    // Attach the request-scoped continuation hook before any URL rewrite.
+    if (typeof ctx?.waitUntil === "function") {
+      request.waitUntil = ctx.waitUntil.bind(ctx);
+    }
     if (env) {
       globalThis.process = globalThis.process || { env: {} };
       globalThis.process.env = globalThis.process.env || {};
@@ -2959,6 +3129,23 @@ export function bundleYjsRuntimeForServerlessOutput(
     );
   }
 
+  walkServerJavaScriptFiles(serverDir, (filePath) => {
+    const bundledImport = path
+      .relative(path.dirname(filePath), bundledYjsPath)
+      .split(path.sep)
+      .join("/");
+    const relativeBundledImport = bundledImport.startsWith(".")
+      ? bundledImport
+      : `./${bundledImport}`;
+    const source = fs.readFileSync(filePath, "utf-8");
+    const rewritten = source.replace(
+      /(\b(?:from\s*|import\s*\(\s*|import\s*))(["'])\.\.?\/(?:\.\.\/)*_libs\/yjs\.mjs\2/g,
+      (_match, importPrefix: string, quote: string) =>
+        `${importPrefix}${quote}${relativeBundledImport}${quote}`,
+    );
+    if (rewritten !== source) fs.writeFileSync(filePath, rewritten);
+  });
+
   return bareImports;
 }
 
@@ -3601,6 +3788,53 @@ const BROWSER_ONLY_SERVER_LIBS = [
   "mermaid",
 ];
 
+/**
+ * Packages that Nitro can discover through the shared server graph but that
+ * cannot be evaluated in a Cloudflare Worker. Keep the network-capable SDKs
+ * real; these are limited to Node/native/browser-runtime packages whose
+ * server-side paths already fail closed when the capability is unavailable.
+ */
+export const CLOUDFLARE_MODULE_STUB_MODULES = [
+  "@napi-rs/canvas",
+  "@resvg/resvg-js",
+  "@sentry/node",
+  "@sparticuz/chromium-min",
+  "better-sqlite3",
+  "chartjs-node-canvas",
+  "chokidar",
+  "fsevents",
+  "node-pty",
+  "playwright",
+  "playwright-core",
+] as const;
+
+/**
+ * Mirror the fail-closed package stubs used by the Pages bundler in Nitro's
+ * Rolldown graph. Without this, the native module preset emits a valid module
+ * graph that still crashes at Worker cold start when a Node-only optional
+ * dependency is evaluated.
+ */
+export function createCloudflareModuleStubPlugin() {
+  const stubbed = new Set<string>(CLOUDFLARE_MODULE_STUB_MODULES);
+  const stubIdPrefix = "\0agent-native-cloudflare-module-stub:";
+
+  return {
+    name: "agent-native-cloudflare-module-stub",
+    resolveId(id: string) {
+      const packageName = id.startsWith("@")
+        ? id.split("/").slice(0, 2).join("/")
+        : id.split("/")[0];
+      if (!stubbed.has(packageName) || id !== packageName) return null;
+      return `${stubIdPrefix}${packageName}`;
+    },
+    load(id: string) {
+      if (!id.startsWith(stubIdPrefix)) return null;
+      const packageName = id.slice(stubIdPrefix.length);
+      return CLOUDFLARE_WORKER_STUB_MODULES[packageName] ?? null;
+    },
+  };
+}
+
 /**
  * Dependencies Nitro itself must bundle outside the controlled serverless
  * output pass. Netlify, Vercel, and Lambda keep Yjs external through Nitro;
@@ -3811,7 +4045,12 @@ export default bundle;
       ...(preset === "netlify" || preset === "vercel" || preset === "aws-lambda"
         ? { external: ["yjs"] }
         : {}),
-      plugins: [createBrowserOnlyServerStubPlugin()],
+      plugins: [
+        ...(preset.startsWith("cloudflare")
+          ? [createCloudflareModuleStubPlugin()]
+          : []),
+        createBrowserOnlyServerStubPlugin(),
+      ],
     },
     ...(providedPluginsNitroPlugin
       ? { plugins: [providedPluginsNitroPlugin] }
@@ -3833,6 +4072,10 @@ export default bundle;
     cwd,
   });
 
+  if (isCloudflareModulePreset(preset)) {
+    configureCloudflareModuleWorkerOutput(nitro.options.output.serverDir);
+  }
+
   if (preset === "netlify" || preset === "vercel" || preset === "aws-lambda") {
     copyInstalledLibsqlNativePackages(nitro.options.output.serverDir);
     copyInstalledResvgPackages(nitro.options.output.serverDir);
@@ -3841,6 +4084,10 @@ export default bundle;
     bundleYjsRuntimeForServerlessOutput(nitro.options.output.serverDir, cwd);
   }
 
+  if (isCloudflareModulePreset(preset)) {
+    bundleYjsRuntimeForServerlessOutput(nitro.options.output.serverDir, cwd);
+  }
+
   if (preset === "netlify") {
     emitSingleTemplateNetlifyKeepWarmFunction(cwd);
 
@@ -3949,8 +4196,43 @@ export default bundle;
     if (bareImports.size > 0) {
       const libsDir = path.join(outputDir, "_libs");
       fs.mkdirSync(libsDir, { recursive: true });
+      function rewriteExternalImports(mod: string, outFile: string) {
+        function rewriteImports(dir: string) {
+          if (!fs.existsSync(dir)) return;
+          for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const p = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+              rewriteImports(p);
+              continue;
+            }
+            if (!entry.name.endsWith(".mjs") && !entry.name.endsWith(".js"))
+              continue;
+            const code = fs.readFileSync(p, "utf8");
+            const relPath = path
+              .relative(path.dirname(p), outFile)
+              .replace(/\\/g, "/");
+            const importPath = relPath.startsWith(".")
+              ? relPath
+              : "./" + relPath;
+            const escaped = mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const re = new RegExp(`from["']${escaped}["']`, "g");
+            const rewritten = code.replace(re, `from"${importPath}"`);
+            if (rewritten !== code) fs.writeFileSync(p, rewritten);
+          }
+        }
+        rewriteImports(outputDir);
+      }
       for (const mod of bareImports) {
         const outFile = path.join(libsDir, `${mod.replace(/[/@]/g, "_")}.mjs`);
+        // Nitro may already have emitted a correctly minified module wrapper
+        // for this dependency. Replacing that wrapper with an esbuild CJS
+        // adapter loses its public export aliases and makes otherwise valid
+        // sibling chunks fail during Worker module linking.
+        if (fs.existsSync(outFile)) {
+          console.log(`[deploy] Retaining Nitro external: ${mod}`);
+          rewriteExternalImports(mod, outFile);
+          continue;
+        }
         try {
           // Resolve the module — check workspace node_modules and pnpm store
           let resolvedMod = mod;
@@ -4244,6 +4526,10 @@ async function main() {
       // as multi-module Workers. Use the custom esbuild-based bundler.
       await buildCloudflarePages();
       break;
+    case "cloudflare_module":
+    case "cloudflare-module":
+      await buildWithNitro();
+      break;
     default:
       // All other presets (netlify, vercel, deno_deploy, aws-lambda, etc.)
       // are handled natively by Nitro's build API.

package/src/deploy/nitro-preset.ts

@@ -0,0 +1,50 @@
+import fs from "fs";
+import path from "path";
+
+export const AGENT_NATIVE_NITRO_PRESET_MARKER = path.join(
+  ".agent-native",
+  "nitro-preset",
+);
+
+function markerPath(cwd: string): string {
+  return path.join(cwd, AGENT_NATIVE_NITRO_PRESET_MARKER);
+}
+
+export function clearAgentNativeNitroPresetMarker(cwd = process.cwd()): void {
+  fs.rmSync(markerPath(cwd), { force: true });
+}
+
+export function writeAgentNativeNitroPresetMarker(
+  preset: string,
+  cwd = process.cwd(),
+): void {
+  const normalizedPreset = preset.trim();
+  if (!normalizedPreset) return;
+
+  const filePath = markerPath(cwd);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${normalizedPreset}\n`);
+}
+
+export function resolveAgentNativeNitroPreset({
+  cwd = process.cwd(),
+  env = process.env,
+}: {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+} = {}): string | undefined {
+  const environmentPreset = env.NITRO_PRESET?.trim();
+  if (environmentPreset) return environmentPreset;
+
+  const filePath = markerPath(cwd);
+  try {
+    const marker = fs.readFileSync(filePath, "utf8").trim();
+    if (!marker) {
+      throw new Error(`Agent-Native Nitro preset marker is empty: ${filePath}`);
+    }
+    return marker;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw error;
+  }
+}

package/src/integrations/pending-tasks-retry-job.ts

@@ -323,7 +323,8 @@ function getProcessingStuckAfterMs(): number {
     process.env.NETLIFY ||
     process.env.AWS_LAMBDA_FUNCTION_NAME ||
     process.env.VERCEL ||
-    "__cf_env" in globalThis
+    "__cf_env" in globalThis ||
+    "__env__" in globalThis
   ) {
     return SERVERLESS_PROCESSING_STUCK_AFTER_MS;
   }

package/src/scripts/call-agent.ts

@@ -77,12 +77,14 @@ function parseTimeoutMs(value: string | undefined): number | undefined {
 function isServerlessHost(): boolean {
   // Detection mirrors db/migrations.ts:297-301. On Cloudflare Workers/Pages,
   // `process.env` is shimmed and CF_PAGES isn't reliably populated at runtime —
-  // the canonical signal is the `__cf_env` global injected by workerd.
+  // the canonical signal is the `__cf_env`/`__env__` global injected by the
+  // Cloudflare runtime adapter.
   return (
     !!process.env.NETLIFY ||
     !!process.env.AWS_LAMBDA_FUNCTION_NAME ||
     !!process.env.VERCEL ||
-    "__cf_env" in globalThis
+    "__cf_env" in globalThis ||
+    "__env__" in globalThis
   );
 }