@agent-native/core 0.222.2-nightly-20261029182928 → 0.222.2

package/dist/deploy/build.js

@@ -17,7 +17,7 @@ import { RECURRING_JOBS_BUILD_MARKER_ENV_VAR, resolveRecurringJobsBuildMarker, }
 import { normalizeAppBasePath } from "../server/app-base-path.js";
 import { frameworkSessionHintCookieName, resolveAuthCookieNamespace, } from "../server/cookie-namespace.js";
 import { resolveAgentNativeBuildId } from "../shared/build-id.js";
-import { DEFAULT_SPECULATION_RULES_PATH, resolveChunkRecoveryCacheHeaders, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_QUERY_CACHE_KEY_HEADER, } from "../shared/cache-control.js";
+import { CHUNK_RECOVERY_BROWSER_CACHE_CONTROL, DEFAULT_SPECULATION_RULES_PATH, DISABLED_SSR_CACHE_HEADERS, resolveChunkRecoveryCacheHeaders, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, resolveSsrCachePolicy, SSR_CACHEABLE_ERROR_STATUSES, SSR_MAX_AGE_HEADER, SSR_QUERY_CACHE_KEY_HEADER, ssrRouteCacheLimits, } from "../shared/cache-control.js";
 import { EMBED_TARGET_QUERY_PARAM, EMBED_TOKEN_QUERY_PARAM, } from "../shared/embed-auth.js";
 import { FRAMEWORK_INTERNAL_ROUTE_PREFIX, normalizeFrameworkRoutePrefix, toPublicFrameworkPath, } from "../shared/framework-route-prefix.js";
 import { mcpEmbedStaticAssetRouteRules } from "../shared/mcp-embed-headers.js";
@@ -1090,6 +1090,7 @@ export function generateWorkerEntry(routes, pluginPaths, defaultPluginStems = []
     const ssrCacheHeaders = resolveSsrCacheHeaders();
     const chunkRecoveryCacheHeaders = resolveChunkRecoveryCacheHeaders(ssrCacheHeaders);
     const ssrCacheKeyHeaders = resolveSsrCacheKeyHeaders();
+    const ssrRouteLimits = ssrRouteCacheLimits(resolveSsrCachePolicy());
     const ssrAuthRedirectCookieName = frameworkSessionHintCookieName(resolveAuthCookieNamespace().frameworkCookieName);
     const hasActions = actions.length > 0;
     const routeImports = [];
@@ -1806,6 +1807,13 @@ const SSR_CACHE_HEADERS = ${JSON.stringify(ssrCacheHeaders)};
 const CHUNK_RECOVERY_ALIAS_CACHE_HEADERS = ${JSON.stringify(chunkRecoveryCacheHeaders)};
 const SSR_CACHE_KEY_HEADERS = ${JSON.stringify(ssrCacheKeyHeaders)};
 const SSR_QUERY_CACHE_KEY_HEADER = ${JSON.stringify(SSR_QUERY_CACHE_KEY_HEADER)};
+const SSR_MAX_AGE_HEADER = ${JSON.stringify(SSR_MAX_AGE_HEADER)};
+// The longest windows a route's SSR_MAX_AGE_HEADER can ask for; null when the
+// deployment stores nothing.
+const SSR_ROUTE_CACHE_LIMITS = ${JSON.stringify(ssrRouteLimits)};
+const SSR_UNSTORED_CACHE_HEADERS = ${JSON.stringify(DISABLED_SSR_CACHE_HEADERS)};
+const SSR_ROUTE_BROWSER_CACHE_CONTROL = ${JSON.stringify(CHUNK_RECOVERY_BROWSER_CACHE_CONTROL)};
+const SSR_CACHEABLE_ERROR_STATUSES = new Set(${JSON.stringify(SSR_CACHEABLE_ERROR_STATUSES)});
 const CHUNK_RECOVERY_PATH_SUFFIX = ${JSON.stringify(CHUNK_RECOVERY_PATH_SUFFIX)};
 const CHUNK_RECOVERY_QUERY_PARAM = ${JSON.stringify(CHUNK_RECOVERY_QUERY_PARAM)};
 const CHUNK_RECOVERY_QUERY_VALUE = ${JSON.stringify(CHUNK_RECOVERY_QUERY_VALUE)};
@@ -1874,12 +1882,40 @@ function injectDefaultSocialImageMeta(html, imageUrl) {
 }
 
 function isSsrHtmlOrDataResponse(headers, status, pathname) {
-  if (status < 200 || status >= 400) return false;
+  if (status < 200) return false;
+  if (status >= 400 && !SSR_CACHEABLE_ERROR_STATUSES.has(status)) return false;
   const contentType = (headers.get("content-type") || "").toLowerCase();
   if (contentType.includes("text/html")) return true;
   return pathname.endsWith(".data") && contentType.includes("text/x-script");
 }
 
+// Mirror parseSsrMaxAge and ssrCacheHeadersWithin in shared/cache-control.ts;
+// build.spec.ts checks this worker against them.
+function parseSsrMaxAge(raw) {
+  if (raw == null) return null;
+  const value = raw.trim();
+  return /^\\d+$/.test(value) ? Number(value) : 0;
+}
+
+function sharedWithin(window, seconds) {
+  return (
+    "s-maxage=" +
+    Math.min(seconds, window.maxAge) +
+    ", stale-while-revalidate=" +
+    Math.min(seconds, window.stale)
+  );
+}
+
+function ssrCacheHeadersWithin(seconds) {
+  if (!SSR_ROUTE_CACHE_LIMITS || seconds <= 0) return SSR_UNSTORED_CACHE_HEADERS;
+  return {
+    "cache-control": SSR_ROUTE_BROWSER_CACHE_CONTROL,
+    "cdn-cache-control": "public, " + sharedWithin(SSR_ROUTE_CACHE_LIMITS.cdn, seconds),
+    "netlify-cdn-cache-control":
+      "public, durable, " + sharedWithin(SSR_ROUTE_CACHE_LIMITS.netlify, seconds),
+  };
+}
+
 /**
  * Apply the SSR cache policy to the response headers.
  *
@@ -1891,6 +1927,8 @@ function applyDefaultSsrCacheHeader(headers, status, pathname, isRecoveryAlias =
   const varyByQuery =
     (headers.get(SSR_QUERY_CACHE_KEY_HEADER) || "").trim().toLowerCase() === "query";
   headers.delete(SSR_QUERY_CACHE_KEY_HEADER);
+  const routeMaxAge = parseSsrMaxAge(headers.get(SSR_MAX_AGE_HEADER));
+  headers.delete(SSR_MAX_AGE_HEADER);
   if (!isSsrHtmlOrDataResponse(headers, status, pathname)) return;
 
   headers.delete("set-cookie");
@@ -1907,7 +1945,9 @@ function applyDefaultSsrCacheHeader(headers, status, pathname, isRecoveryAlias =
     else headers.delete("vary");
   }
 
-  for (const [name, value] of Object.entries(SSR_CACHE_HEADERS)) {
+  const cacheHeaders =
+    routeMaxAge === null ? SSR_CACHE_HEADERS : ssrCacheHeadersWithin(routeMaxAge);
+  for (const [name, value] of Object.entries(cacheHeaders)) {
     headers.set(name, value);
   }
   const netlifyVary = varyByQuery

package/dist/server/ssr-handler.js

@@ -2,7 +2,7 @@ import { defineEventHandler } from "h3";
 import { createRequestHandler } from "react-router";
 import { getAppConfig, resolveAppHomePath } from "../app-config/index.js";
 import { isMcpPublicPath } from "../mcp/route-paths.js";
-import { DEFAULT_SPECULATION_RULES_PATH, resolveChunkRecoveryCacheHeaders, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_QUERY_CACHE_KEY_HEADER, } from "../shared/cache-control.js";
+import { DEFAULT_SPECULATION_RULES_PATH, parseSsrMaxAge, resolveChunkRecoveryCacheHeaders, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, resolveSsrCachePolicy, SSR_CACHEABLE_ERROR_STATUSES, SSR_MAX_AGE_HEADER, SSR_QUERY_CACHE_KEY_HEADER, ssrCacheHeadersWithin, } from "../shared/cache-control.js";
 import { CHUNK_RECOVERY_PATH_SUFFIX, isLegacyChunkRecoveryRequest, } from "../shared/route-chunk-recovery-bootstrap.js";
 import { AGENT_NATIVE_SOCIAL_IMAGE_ALT, AGENT_NATIVE_SOCIAL_IMAGE_HEIGHT, AGENT_NATIVE_SOCIAL_IMAGE_PATH, AGENT_NATIVE_SOCIAL_IMAGE_TYPE, AGENT_NATIVE_SOCIAL_IMAGE_WIDTH, withAgentNativeSocialImageCacheBuster, } from "../shared/social-meta.js";
 import { getSsrAuthRedirectScript } from "../shared/ssr-auth-redirect.js";
@@ -186,7 +186,7 @@ function injectDefaultSocialImageMeta(html, imageUrl) {
         return html;
     return html.slice(0, headCloseIdx) + tags.join("") + html.slice(headCloseIdx);
 }
-const CACHEABLE_ERROR_STATUSES = new Set([404, 410]);
+const CACHEABLE_ERROR_STATUSES = new Set(SSR_CACHEABLE_ERROR_STATUSES);
 function isSsrHtmlOrDataResponse(headers, status, pathname) {
     if (status < 200)
         return false;
@@ -227,6 +227,11 @@ function isSsrHtmlOrDataResponse(headers, status, pathname) {
  * │ PER-USER response variation — no `private`, no `Vary: Cookie`, and no     │
  * │ request-specific content. Recovery keeps a bounded alias and never adds  │
  * │ arbitrary query-key variation to the normally cached shell.               │
+ * │                                                                            │
+ * │ A route whose content can change or be taken down may SHORTEN its own     │
+ * │ window with `SSR_MAX_AGE_HEADER`: one duration for every visitor of that  │
+ * │ route, never longer than the deployment's, so it can't personalize the    │
+ * │ shell or poison a shared key.                                              │
  * └──────────────────────────────────────────────────────────────────────────┘
  *
  * The same sharing rule governs any DIAGNOSTIC header on this response. A
@@ -240,6 +245,8 @@ function isSsrHtmlOrDataResponse(headers, status, pathname) {
 function applyDefaultSsrCacheHeader(headers, status, pathname, isRecoveryAlias = false, isLegacyRecovery = false) {
     const responseRequestsQueryVary = headers.get(SSR_QUERY_CACHE_KEY_HEADER)?.trim().toLowerCase() === "query";
     headers.delete(SSR_QUERY_CACHE_KEY_HEADER);
+    const routeMaxAge = parseSsrMaxAge(headers.get(SSR_MAX_AGE_HEADER));
+    headers.delete(SSR_MAX_AGE_HEADER);
     if (!isSsrHtmlOrDataResponse(headers, status, pathname))
         return;
     // Current recovery uses one fixed path alias. Still-deployed clients use the
@@ -267,7 +274,10 @@ function applyDefaultSsrCacheHeader(headers, status, pathname, isRecoveryAlias =
         else
             headers.delete("vary");
     }
-    for (const [name, value] of Object.entries(resolveSsrCacheHeaders())) {
+    const cacheHeaders = routeMaxAge === null
+        ? resolveSsrCacheHeaders()
+        : ssrCacheHeadersWithin(resolveSsrCachePolicy(), routeMaxAge);
+    for (const [name, value] of Object.entries(cacheHeaders)) {
         headers.set(name, value);
     }
     const cacheKeyHeaders = resolveSsrCacheKeyHeaders(undefined, {

package/dist/shared/cache-control.d.ts

@@ -10,6 +10,20 @@ export declare const DEFAULT_SSR_CACHE_HEADERS: {
 };
 export declare const SSR_HTML_CONTENT_TYPE = "text/html; charset=utf-8";
 export declare const SSR_QUERY_CACHE_KEY_HEADER = "x-agent-native-ssr-key";
+/**
+ * Response header a route sets to the most seconds its SSR response may be
+ * kept anywhere, for a page whose content can change or be taken down (a
+ * public share page, say). The SSR handler reads and removes it. It only ever
+ * shortens the deployment's policy, and it names one duration for every
+ * visitor of the route, so it can't vary the shell per request or per user.
+ * `0` means don't store it at all.
+ */
+export declare const SSR_MAX_AGE_HEADER = "x-agent-native-ssr-max-age";
+/**
+ * Error statuses whose SSR HTML/`.data` answer still gets the shared cache
+ * policy: a missing or removed page is the same for every visitor.
+ */
+export declare const SSR_CACHEABLE_ERROR_STATUSES: readonly number[];
 export type SsrHtmlContentTypeOptions = {
     varyByQuery?: boolean;
 };
@@ -32,6 +46,39 @@ export type SsrCachePolicy = {
 export type SsrCacheHeaders = Record<"cache-control" | "cdn-cache-control" | "netlify-cdn-cache-control", string>;
 export declare function parseSsrCacheSetting(raw: string | undefined | null): SsrCachePolicy;
 export declare function ssrCacheHeadersForPolicy(policy: SsrCachePolicy): SsrCacheHeaders;
+/**
+ * The route's `SSR_MAX_AGE_HEADER` value in seconds, or null when unset. A
+ * value that isn't whole seconds reads as 0: the route asked for a shorter
+ * window, and falling back to the deployment's would keep a page it takes
+ * down for as long as that window.
+ */
+export declare function parseSsrMaxAge(raw: string | null | undefined): number | null;
+export type SsrSharedWindow = {
+    maxAge: number;
+    stale: number;
+};
+export type SsrRouteCacheLimits = {
+    cdn: SsrSharedWindow;
+    netlify: SsrSharedWindow;
+};
+/**
+ * The longest shared-cache windows a route's `SSR_MAX_AGE_HEADER` can ask for
+ * under `policy`, read from the headers the deployment would send, one per CDN
+ * header since they differ. Null when the deployment stores nothing. The
+ * generated edge worker inlines these at build time.
+ */
+export declare function ssrRouteCacheLimits(policy: SsrCachePolicy): SsrRouteCacheLimits | null;
+/**
+ * The deployment's policy with every window cut to at most `seconds`, for a
+ * route that set `SSR_MAX_AGE_HEADER`. Browsers revalidate on each visit, so
+ * shared caches alone bound how old a copy gets: fresh for `seconds`, then
+ * served once more while it refreshes, so never more than twice `seconds`
+ * after the render. Nothing is served stale on origin errors either, since a
+ * page taken down must not come back while origin is failing.
+ */
+export declare function ssrCacheHeadersWithin(policy: SsrCachePolicy, seconds: number): SsrCacheHeaders;
+/** The deployment-wide policy from `AGENT_NATIVE_SSR_CACHE`. */
+export declare function resolveSsrCachePolicy(env?: Record<string, string | undefined>): SsrCachePolicy;
 export declare function resolveSsrCacheHeaders(env?: Record<string, string | undefined>): Readonly<SsrCacheHeaders>;
 export declare function resolveChunkRecoveryCacheHeaders(cacheHeaders?: Pick<SsrCacheHeaders, "cache-control">): Readonly<SsrCacheHeaders>;
 export declare function resolveSsrNetlifyQueryVary(varyByQuery?: boolean, varyByLegacyRecovery?: boolean): string;

package/dist/shared/cache-control.js

@@ -11,6 +11,20 @@ export const DEFAULT_SSR_CACHE_HEADERS = {
 };
 export const SSR_HTML_CONTENT_TYPE = "text/html; charset=utf-8";
 export const SSR_QUERY_CACHE_KEY_HEADER = "x-agent-native-ssr-key";
+/**
+ * Response header a route sets to the most seconds its SSR response may be
+ * kept anywhere, for a page whose content can change or be taken down (a
+ * public share page, say). The SSR handler reads and removes it. It only ever
+ * shortens the deployment's policy, and it names one duration for every
+ * visitor of the route, so it can't vary the shell per request or per user.
+ * `0` means don't store it at all.
+ */
+export const SSR_MAX_AGE_HEADER = "x-agent-native-ssr-max-age";
+/**
+ * Error statuses whose SSR HTML/`.data` answer still gets the shared cache
+ * policy: a missing or removed page is the same for every visitor.
+ */
+export const SSR_CACHEABLE_ERROR_STATUSES = [404, 410];
 export function withSsrHtmlContentType(response, options = {}) {
     response.headers.set("content-type", SSR_HTML_CONTENT_TYPE);
     if (options.varyByQuery) {
@@ -73,8 +87,84 @@ export function ssrCacheHeadersForPolicy(policy) {
         "netlify-cdn-cache-control": netlifyControl,
     };
 }
+/**
+ * The route's `SSR_MAX_AGE_HEADER` value in seconds, or null when unset. A
+ * value that isn't whole seconds reads as 0: the route asked for a shorter
+ * window, and falling back to the deployment's would keep a page it takes
+ * down for as long as that window.
+ */
+export function parseSsrMaxAge(raw) {
+    if (raw == null)
+        return null;
+    const value = raw.trim();
+    if (!/^\d+$/.test(value))
+        return 0;
+    return Math.min(Number(value), MAX_SSR_CACHE_SECONDS);
+}
+function directiveSeconds(control, name) {
+    const match = new RegExp(`(?:^|,)\\s*${name}=(\\d+)\\s*(?:,|$)`, "i").exec(control);
+    return match ? Number(match[1]) : null;
+}
+function sharedWindow(control) {
+    return {
+        maxAge: directiveSeconds(control, "s-maxage") ??
+            directiveSeconds(control, "max-age") ??
+            0,
+        stale: directiveSeconds(control, "stale-while-revalidate") ?? 0,
+    };
+}
+/**
+ * The longest shared-cache windows a route's `SSR_MAX_AGE_HEADER` can ask for
+ * under `policy`, read from the headers the deployment would send, one per CDN
+ * header since they differ. Null when the deployment stores nothing. The
+ * generated edge worker inlines these at build time.
+ */
+export function ssrRouteCacheLimits(policy) {
+    if (policy.kind === "disabled")
+        return null;
+    const headers = ssrCacheHeadersForPolicy(policy);
+    return {
+        cdn: sharedWindow(headers["cdn-cache-control"]),
+        netlify: sharedWindow(headers["netlify-cdn-cache-control"]),
+    };
+}
+function sharedWithin(window, seconds) {
+    return (`s-maxage=${Math.min(seconds, window.maxAge)}, ` +
+        `stale-while-revalidate=${Math.min(seconds, window.stale)}`);
+}
+/**
+ * The deployment's policy with every window cut to at most `seconds`, for a
+ * route that set `SSR_MAX_AGE_HEADER`. Browsers revalidate on each visit, so
+ * shared caches alone bound how old a copy gets: fresh for `seconds`, then
+ * served once more while it refreshes, so never more than twice `seconds`
+ * after the render. Nothing is served stale on origin errors either, since a
+ * page taken down must not come back while origin is failing.
+ */
+export function ssrCacheHeadersWithin(policy, seconds) {
+    const limits = ssrRouteCacheLimits(policy);
+    if (!limits || seconds <= 0)
+        return { ...DISABLED_SSR_CACHE_HEADERS };
+    return {
+        "cache-control": CHUNK_RECOVERY_BROWSER_CACHE_CONTROL,
+        "cdn-cache-control": `public, ${sharedWithin(limits.cdn, seconds)}`,
+        "netlify-cdn-cache-control": `public, durable, ${sharedWithin(limits.netlify, seconds)}`,
+    };
+}
 let memoizedRaw;
 let memoizedHeaders;
+let memoizedPolicyRaw;
+let memoizedPolicy;
+/** The deployment-wide policy from `AGENT_NATIVE_SSR_CACHE`. */
+export function resolveSsrCachePolicy(env = typeof process === "undefined"
+    ? {}
+    : process.env) {
+    const raw = env[SSR_CACHE_ENV_VAR];
+    if (memoizedPolicy && raw === memoizedPolicyRaw)
+        return memoizedPolicy;
+    memoizedPolicyRaw = raw;
+    memoizedPolicy = parseSsrCacheSetting(raw);
+    return memoizedPolicy;
+}
 export function resolveSsrCacheHeaders(env = typeof process === "undefined"
     ? {}
     : process.env) {

package/dist/shared/index.d.ts

@@ -22,7 +22,7 @@ export { formatAgentDesignSystemContext, loadAgentDesignSystemContext, type Agen
 export { formatHtmlStyleSummary, summarizeHtmlStyles, type HtmlStyleFragment, type HtmlStyleSummary, type HtmlStyleValue, } from "./html-style-summary.js";
 export { withBuilderUtmTrackingParams } from "./builder-link-tracking.js";
 export { BETA_FORCE_QUERY_PARAM, BETA_FORCE_SESSION_STORAGE_KEY, BETA_LANE_REDIRECT_QUERY_PARAM, BETA_LANE_RETURN_STORAGE_KEY, BETA_LANE_RETURNED_STORAGE_KEY, BETA_REDIRECT_DURATION_MS, BETA_REDIRECT_STORAGE_KEY, BETA_REDIRECT_SIGN_OUT_STORAGE_KEY, BETA_OPT_OUT_DURATION_MS, BETA_OPT_OUT_QUERY_PARAM, BETA_OPT_OUT_STORAGE_KEY, buildAutomaticBetaRedirectUrl, ENVIRONMENT_BETA_HOSTS, resolveEnvironmentTargets, type EnvironmentBadgeTargets, } from "./environment-lanes.js";
-export { SSR_HTML_CONTENT_TYPE, SSR_QUERY_CACHE_KEY_HEADER, type SsrHtmlContentTypeOptions, withSsrHtmlContentType, } from "./cache-control.js";
+export { SSR_HTML_CONTENT_TYPE, SSR_MAX_AGE_HEADER, SSR_QUERY_CACHE_KEY_HEADER, type SsrHtmlContentTypeOptions, withSsrHtmlContentType, } from "./cache-control.js";
 export { SURFACE_HIDDEN_FLAG, SURFACE_VISIBILITY_EVENT, addSurfaceVisibilityListener, buildSurfaceVisibilityScript, isHostSurfaceHidden, isSurfaceHidden, } from "./surface-visibility.js";
 export { AGENT_NATIVE_DOCS_ORIGIN, docsUrl, type DocsUrlOptions, } from "./docs-url.js";
 export { buildRuntimeConfigPrompt, formatRuntimeConfigReport, getRuntimeConfigReport, parseRuntimeConfigReport, runtimeConfigRequirementsFromSearchParams, type RuntimeConfigEnvironment, type RuntimeConfigIssue, type RuntimeConfigIssueCode, type RuntimeConfigIssueSeverity, type RuntimeConfigPhase, type RuntimeConfigReport, type RuntimeConfigRequirements, } from "./runtime-config.js";

package/dist/shared/index.js

@@ -22,7 +22,7 @@ export { formatAgentDesignSystemContext, loadAgentDesignSystemContext, } from ".
 export { formatHtmlStyleSummary, summarizeHtmlStyles, } from "./html-style-summary.js";
 export { withBuilderUtmTrackingParams } from "./builder-link-tracking.js";
 export { BETA_FORCE_QUERY_PARAM, BETA_FORCE_SESSION_STORAGE_KEY, BETA_LANE_REDIRECT_QUERY_PARAM, BETA_LANE_RETURN_STORAGE_KEY, BETA_LANE_RETURNED_STORAGE_KEY, BETA_REDIRECT_DURATION_MS, BETA_REDIRECT_STORAGE_KEY, BETA_REDIRECT_SIGN_OUT_STORAGE_KEY, BETA_OPT_OUT_DURATION_MS, BETA_OPT_OUT_QUERY_PARAM, BETA_OPT_OUT_STORAGE_KEY, buildAutomaticBetaRedirectUrl, ENVIRONMENT_BETA_HOSTS, resolveEnvironmentTargets, } from "./environment-lanes.js";
-export { SSR_HTML_CONTENT_TYPE, SSR_QUERY_CACHE_KEY_HEADER, withSsrHtmlContentType, } from "./cache-control.js";
+export { SSR_HTML_CONTENT_TYPE, SSR_MAX_AGE_HEADER, SSR_QUERY_CACHE_KEY_HEADER, withSsrHtmlContentType, } from "./cache-control.js";
 export { SURFACE_HIDDEN_FLAG, SURFACE_VISIBILITY_EVENT, addSurfaceVisibilityListener, buildSurfaceVisibilityScript, isHostSurfaceHidden, isSurfaceHidden, } from "./surface-visibility.js";
 export { AGENT_NATIVE_DOCS_ORIGIN, docsUrl, } from "./docs-url.js";
 export { buildRuntimeConfigPrompt, formatRuntimeConfigReport, getRuntimeConfigReport, parseRuntimeConfigReport, runtimeConfigRequirementsFromSearchParams, } from "./runtime-config.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.222.2-nightly-20261029182928",
+  "version": "0.222.2",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -742,8 +742,8 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.222.2-nightly-20261029182928",
-    "@agent-native/recap-cli": "^0.5.92"
+    "@agent-native/agentkit": "^0.222.2",
+    "@agent-native/recap-cli": "^0.5.93"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",
@@ -814,7 +814,7 @@
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@agent-native/core-corpus": "0.222.2-nightly-20261029182928",
+    "@agent-native/core-corpus": ">=0.196.0",
     "@ai-sdk/anthropic": ">=3",
     "@ai-sdk/cohere": ">=3",
     "@ai-sdk/google": ">=3",