@agent-native/core 0.165.4 → 0.167.1

package/dist/changelog/parse.js

@@ -237,6 +237,213 @@ function normalizedChangelogText(value) {
         .replace(/\s+/g, " ")
         .trim();
 }
+function stripHtmlComments(line, inComment, initialInlineCodeMarker) {
+    let cursor = 0;
+    let visibleLine = "";
+    const comments = [];
+    let inlineCodeMarker = initialInlineCodeMarker;
+    while (cursor < line.length) {
+        if (inComment) {
+            const commentEnd = line.indexOf("-->", cursor);
+            if (commentEnd === -1) {
+                return {
+                    line: visibleLine,
+                    inComment: true,
+                    inlineCodeMarker,
+                    comments,
+                };
+            }
+            cursor = commentEnd + 3;
+            inComment = false;
+            continue;
+        }
+        if (inlineCodeMarker) {
+            const codeEnd = line.indexOf(inlineCodeMarker, cursor);
+            if (codeEnd === -1) {
+                visibleLine += line.slice(cursor);
+                break;
+            }
+            visibleLine += line.slice(cursor, codeEnd + inlineCodeMarker.length);
+            cursor = codeEnd + inlineCodeMarker.length;
+            inlineCodeMarker = undefined;
+            continue;
+        }
+        const commentStart = line.indexOf("<!--", cursor);
+        const codeStartIndex = line.indexOf("`", cursor);
+        if (codeStartIndex !== -1 &&
+            (commentStart === -1 || codeStartIndex < commentStart)) {
+            visibleLine += line.slice(cursor, codeStartIndex);
+            const codeStart = /^`+/.exec(line.slice(codeStartIndex))?.[0] ?? "`";
+            visibleLine += codeStart;
+            cursor = codeStartIndex + codeStart.length;
+            inlineCodeMarker = codeStart;
+            continue;
+        }
+        if (commentStart === -1) {
+            visibleLine += line.slice(cursor);
+            break;
+        }
+        visibleLine += line.slice(cursor, commentStart);
+        const commentEnd = line.indexOf("-->", commentStart + 4);
+        if (commentEnd !== -1) {
+            comments.push(line.slice(commentStart, commentEnd + 3));
+        }
+        cursor = commentStart + 4;
+        inComment = true;
+    }
+    return { line: visibleLine, inComment, inlineCodeMarker, comments };
+}
+function splitChangelogBodyGroups(body) {
+    const matches = [];
+    let offset = 0;
+    let fenceMarker;
+    let htmlComment = false;
+    let inlineCodeMarker;
+    for (const line of body.split(/\r?\n/)) {
+        const lineEnd = offset + line.length;
+        if (fenceMarker) {
+            const fence = /^\s*(`{3,}|~{3,})(.*)$/.exec(line)?.[1];
+            const closingFence = /^\s*(`{3,}|~{3,})\s*$/.exec(line)?.[1];
+            if (fence &&
+                closingFence &&
+                fenceMarker.character === fence[0] &&
+                closingFence.length >= fenceMarker.length) {
+                fenceMarker = undefined;
+            }
+        }
+        else {
+            let visibleLine;
+            let headingComments = [];
+            if (!htmlComment && !inlineCodeMarker) {
+                const fence = /^\s*(`{3,}|~{3,})(.*)$/.exec(line)?.[1];
+                if (fence) {
+                    fenceMarker = { character: fence[0], length: fence.length };
+                }
+                else {
+                    const commentResult = stripHtmlComments(line, false, inlineCodeMarker);
+                    htmlComment = commentResult.inComment;
+                    inlineCodeMarker = commentResult.inlineCodeMarker;
+                    visibleLine = commentResult.line;
+                    headingComments = commentResult.comments;
+                }
+            }
+            else {
+                const commentResult = stripHtmlComments(line, htmlComment, inlineCodeMarker);
+                htmlComment = commentResult.inComment;
+                inlineCodeMarker = commentResult.inlineCodeMarker;
+                visibleLine = commentResult.line;
+                headingComments = commentResult.comments;
+            }
+            if (visibleLine !== undefined && !fenceMarker) {
+                const fence = /^\s*(`{3,}|~{3,})(.*)$/.exec(visibleLine)?.[1];
+                if (fence) {
+                    fenceMarker = { character: fence[0], length: fence.length };
+                }
+                else {
+                    const heading = /^ {0,3}###\s+(.+?)(?:\s+#+)?\s*$/.exec(visibleLine);
+                    if (heading &&
+                        CHANGELOG_GROUP_ORDER.some((type) => GROUP_LABELS[type].toLowerCase() ===
+                            heading[1].trim().toLowerCase())) {
+                        matches.push({
+                            title: heading[1].trim(),
+                            headingComments,
+                            start: offset,
+                            headingEnd: lineEnd,
+                        });
+                    }
+                }
+            }
+        }
+        const newlineLength = body.startsWith("\r\n", lineEnd)
+            ? 2
+            : lineEnd < body.length
+                ? 1
+                : 0;
+        offset = lineEnd + newlineLength;
+    }
+    if (matches.length === 0)
+        return { prefix: body.trim(), groups: [] };
+    const prefix = body.slice(0, matches[0].start).trim();
+    const groups = matches.map((match, index) => {
+        const end = matches[index + 1]?.start ?? body.length;
+        return {
+            title: match.title,
+            headingComments: match.headingComments,
+            body: body.slice(match.headingEnd, end).trim(),
+            index,
+        };
+    });
+    return { prefix, groups };
+}
+function changelogBodyGroupOrder(title) {
+    const normalizedTitle = title.toLowerCase();
+    const index = CHANGELOG_GROUP_ORDER.findIndex((type) => GROUP_LABELS[type].toLowerCase() === normalizedTitle);
+    return index === -1 ? CHANGELOG_GROUP_ORDER.length : index;
+}
+function normalizeChangelogBody(body) {
+    const { prefix, groups } = splitChangelogBodyGroups(body);
+    if (groups.length < 2)
+        return body.trim();
+    const uniqueGroups = new Map();
+    for (const group of groups) {
+        const key = group.title.toLowerCase();
+        const current = uniqueGroups.get(key);
+        const headingComments = current
+            ? [
+                ...current.headingComments,
+                ...group.headingComments.filter((comment) => !current.headingComments.includes(comment)),
+            ]
+            : group.headingComments;
+        uniqueGroups.set(key, {
+            title: current?.title ?? group.title,
+            headingComments,
+            body: [current?.body, group.body].filter(Boolean).join("\n"),
+            index: current?.index ?? group.index,
+        });
+    }
+    const renderedGroups = [...uniqueGroups.values()]
+        .sort((a, b) => changelogBodyGroupOrder(a.title) - changelogBodyGroupOrder(b.title) ||
+        a.index - b.index)
+        .map((group) => `### ${group.title}${group.headingComments.length ? ` ${group.headingComments.join(" ")}` : ""}\n\n${group.body}`);
+    return [prefix, ...renderedGroups].filter(Boolean).join("\n\n");
+}
+function mergeChangelogBodies(pendingBody, existingBody) {
+    const pending = splitChangelogBodyGroups(pendingBody);
+    const existing = splitChangelogBodyGroups(existingBody);
+    if (pending.groups.length === 0) {
+        return normalizeChangelogBody(existingBody);
+    }
+    if (existing.groups.length === 0) {
+        return [pendingBody, existingBody]
+            .map((body) => body.trim())
+            .filter(Boolean)
+            .join("\n\n");
+    }
+    const groups = new Map();
+    for (const group of [...pending.groups, ...existing.groups]) {
+        const key = group.title.toLowerCase();
+        const current = groups.get(key);
+        const headingComments = current
+            ? [
+                ...current.headingComments,
+                ...group.headingComments.filter((comment) => !current.headingComments.includes(comment)),
+            ]
+            : group.headingComments;
+        groups.set(key, {
+            title: current?.title ?? group.title,
+            headingComments,
+            body: [current?.body, group.body].filter(Boolean).join("\n"),
+            index: current?.index ?? group.index,
+        });
+    }
+    const prefix = [pending.prefix, existing.prefix].filter(Boolean).join("\n\n");
+    return normalizeChangelogBody([
+        prefix,
+        ...[...groups.values()].map((group) => `### ${group.title}${group.headingComments.length ? ` ${group.headingComments.join(" ")}` : ""}\n\n${group.body}`),
+    ]
+        .filter(Boolean)
+        .join("\n\n"));
+}
 /**
  * Render an app-facing changelog that includes both released CHANGELOG.md
  * sections and adjacent folder-backed `changelog/*.md` entries. This is pure
@@ -246,10 +453,19 @@ function normalizedChangelogText(value) {
 export function mergePendingChangelog(existing, pending) {
     const cleanExisting = stripChangelogArchiveNotes(existing);
     const existingEntries = parseChangelog(cleanExisting);
+    const pendingSeen = new Set();
     const pendingWithText = pending.filter((entry) => {
         const text = entry.text.trim();
         if (!text)
             return false;
+        const pendingKey = [
+            entry.date ?? "",
+            entry.type,
+            normalizedChangelogText(text),
+        ].join("\u0000");
+        if (pendingSeen.has(pendingKey))
+            return false;
+        pendingSeen.add(pendingKey);
         return !existingEntries.some((existingEntry) => {
             if (entry.date &&
                 existingEntry.date &&
@@ -261,7 +477,7 @@ export function mergePendingChangelog(existing, pending) {
     });
     if (pendingWithText.length === 0) {
         const sections = existingEntries
-            .map((entry) => `## ${entry.title}\n\n${cleanChangelogBody(entry.body)}`)
+            .map((entry) => `## ${entry.title}\n\n${normalizeChangelogBody(cleanChangelogBody(entry.body))}`)
             .join("\n\n");
         return `${changelogHeader(cleanExisting)}${sections ? `\n\n${sections}` : ""}\n\n${CHANGELOG_ARCHIVE_NOTE}\n`;
     }
@@ -273,7 +489,7 @@ export function mergePendingChangelog(existing, pending) {
     const sections = existingEntries.map((entry) => ({
         title: entry.title,
         date: entry.date,
-        body: cleanChangelogBody(entry.body),
+        body: normalizeChangelogBody(cleanChangelogBody(entry.body)),
     }));
     for (const title of [...pendingByTitle.keys()].sort(pendingSectionSort)) {
         const body = renderReleaseBody(pendingByTitle.get(title) ?? []);
@@ -283,12 +499,7 @@ export function mergePendingChangelog(existing, pending) {
             return entry.date === title || entry.title === title;
         });
         if (existingIndex !== -1) {
-            sections[existingIndex].body = [
-                body,
-                cleanChangelogBody(sections[existingIndex].body),
-            ]
-                .filter(Boolean)
-                .join("\n\n");
+            sections[existingIndex].body = mergeChangelogBodies(body, cleanChangelogBody(sections[existingIndex].body));
             continue;
         }
         const newSection = { title, date: title.match(ISO_DATE)?.[1], body };

package/dist/client/EnvironmentBadge.d.ts

@@ -1,6 +1,7 @@
 import type { AgentNativeDeploymentEnvironment, AgentNativeConfig } from "../config.js";
 export { BETA_OPT_OUT_DURATION_MS, BETA_OPT_OUT_QUERY_PARAM, BETA_OPT_OUT_STORAGE_KEY, buildEnvironmentOptOutUrl, buildEnvironmentUrl, resolveEnvironmentTargets, type EnvironmentBadgeTargets, } from "../shared/environment-lanes.js";
 export declare function isBuilderIoEmployee(email: string | null | undefined): boolean;
+export declare function isAgentNativeDesktopUserAgent(userAgent: string | undefined): boolean;
 export declare function resolveEnvironmentChannel(config: AgentNativeConfig, hostname: string | undefined): Extract<AgentNativeDeploymentEnvironment, "beta" | "production"> | null;
 export declare function isBetaOptOutActive(value: string | number | null | undefined, now?: number): boolean;
 /**

package/dist/client/EnvironmentBadge.js

@@ -10,6 +10,9 @@ export { BETA_OPT_OUT_DURATION_MS, BETA_OPT_OUT_QUERY_PARAM, BETA_OPT_OUT_STORAG
 export function isBuilderIoEmployee(email) {
     return email?.trim().toLowerCase().endsWith("@builder.io") ?? false;
 }
+export function isAgentNativeDesktopUserAgent(userAgent) {
+    return /AgentNativeDesktop/i.test(userAgent ?? "");
+}
 export function resolveEnvironmentChannel(config, hostname) {
     const configured = config.deployment?.environment;
     if (configured === "beta" || configured === "production") {
@@ -98,6 +101,10 @@ function ProductionEnvironmentBadge({ targets, }) {
         if (!isEligible || didAutoRedirect.current) {
             return;
         }
+        // Desktop child sessions are minted against their configured production
+        // origin. Do not move that WebView to beta after the session is created.
+        if (isAgentNativeDesktopUserAgent(window.navigator.userAgent))
+            return;
         if (readBetaOptOutUntil() !== null)
             return;
         if (consumeBetaOptOutQueryParam(window.location.href))

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/config.d.ts

@@ -101,6 +101,17 @@ export type AgentNativeConfigInput = AgentNativeConfig | AgentNativeConfigFactor
  * phase, while the browser only receives the resolved serializable result.
  */
 export declare function defineAgentNativeConfig(config: AgentNativeConfigInput): AgentNativeConfigInput;
+export declare const AGENT_NATIVE_CONFIG_ENV_PREFIX: "AGENT_NATIVE_CONFIG";
+/** Convert a config path such as `runtime.auth.enabled` to its env name. */
+export declare function agentNativeConfigEnvName(path: readonly string[]): string;
+/**
+ * Reads the public config's deterministic environment aliases.
+ *
+ * `AGENT_NATIVE_CONFIG` contains a complete JSON object. A suffixed name
+ * contains a JSON fragment at that config path, or a typed scalar at a leaf.
+ * Nodes are applied from shallowest to deepest so a more specific path wins.
+ */
+export declare function readAgentNativeConfigEnv(env: Record<string, string | undefined>): AgentNativeConfig;
 export declare function normalizeAgentNativeConfig(input: unknown, source?: string): AgentNativeConfig;
 export declare function mergeAgentNativeConfigs(base: AgentNativeConfig, override: AgentNativeConfig): AgentNativeConfig;
 export declare function resolveAgentNativeConfig(input: AgentNativeConfigInput | undefined, context: AgentNativeConfigContext): AgentNativeConfig;

package/dist/config.js

@@ -16,6 +16,254 @@ export const AGENT_NATIVE_CONFIG_VERSION = 1;
 export function defineAgentNativeConfig(config) {
     return config;
 }
+export const AGENT_NATIVE_CONFIG_ENV_PREFIX = "AGENT_NATIVE_CONFIG";
+/**
+ * Serializable public config nodes that may be initialized from the
+ * deployment environment. Object nodes accept JSON fragments, which lets a
+ * deploy set a whole section without requiring a separate alias for every
+ * leaf. Dynamic keys in the onboarding mode map stay JSON-only at the union
+ * node because they are not part of the fixed config shape.
+ */
+const AGENT_NATIVE_CONFIG_ENV_NODES = [
+    { path: [], kind: "object" },
+    { path: ["version"], kind: "number" },
+    { path: ["onboarding"], kind: "object" },
+    {
+        path: ["onboarding", "firstRun"],
+        kind: "union",
+        dynamicObjectKeys: true,
+    },
+    { path: ["runtime"], kind: "object" },
+    { path: ["runtime", "auth"], kind: "object" },
+    { path: ["runtime", "auth", "enabled"], kind: "boolean" },
+    { path: ["runtime", "database"], kind: "object" },
+    { path: ["runtime", "database", "required"], kind: "boolean" },
+    { path: ["runtime", "environment"], kind: "object" },
+    {
+        path: ["runtime", "environment", "required"],
+        kind: "array",
+    },
+    { path: ["deployment"], kind: "object" },
+    {
+        path: ["deployment", "environment"],
+        kind: "deployment-environment",
+    },
+    { path: ["diagnostics"], kind: "object" },
+    { path: ["diagnostics", "failOnBuild"], kind: "boolean" },
+    { path: ["instructions"], kind: "object" },
+    { path: ["instructions", "runtime"], kind: "string" },
+    { path: ["instructions", "development"], kind: "string" },
+    { path: ["translations"], kind: "object" },
+    { path: ["translations", "locales"], kind: "array" },
+    { path: ["changelog"], kind: "object" },
+    { path: ["changelog", "enabled"], kind: "boolean" },
+    { path: ["harness"], kind: "union" },
+    { path: ["harness", "runtimes"], kind: "array" },
+];
+function agentNativeConfigEnvSegment(segment) {
+    return segment
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[^A-Za-z0-9]+/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_|_$/g, "")
+        .toUpperCase();
+}
+/** Convert a config path such as `runtime.auth.enabled` to its env name. */
+export function agentNativeConfigEnvName(path) {
+    if (path.length === 0)
+        return AGENT_NATIVE_CONFIG_ENV_PREFIX;
+    return `${AGENT_NATIVE_CONFIG_ENV_PREFIX}_${path
+        .map(agentNativeConfigEnvSegment)
+        .join("_")}`;
+}
+function agentNativeConfigEnvKeys(node) {
+    return [agentNativeConfigEnvName(node.path), ...(node.aliases ?? [])];
+}
+function isAgentNativeConfigEnvKey(key) {
+    return (key === AGENT_NATIVE_CONFIG_ENV_PREFIX ||
+        key.startsWith(`${AGENT_NATIVE_CONFIG_ENV_PREFIX}_`));
+}
+function parseAgentNativeConfigJson(raw, key) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`${key} must contain valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function parseAgentNativeConfigEnvValue(raw, key, kind) {
+    const value = raw.trim();
+    switch (kind) {
+        case "object": {
+            const parsed = parseAgentNativeConfigJson(value, key);
+            if (!isRecord(parsed)) {
+                throw new Error(`${key} must contain a JSON object`);
+            }
+            return parsed;
+        }
+        case "array": {
+            const parsed = parseAgentNativeConfigJson(value, key);
+            if (!Array.isArray(parsed)) {
+                throw new Error(`${key} must contain a JSON array`);
+            }
+            return parsed;
+        }
+        case "boolean": {
+            const normalized = value.toLowerCase();
+            if (["1", "true", "yes", "on"].includes(normalized))
+                return true;
+            if (["0", "false", "no", "off"].includes(normalized))
+                return false;
+            throw new Error(`${key} must be a boolean`);
+        }
+        case "number": {
+            const parsed = Number(value);
+            if (!Number.isFinite(parsed))
+                throw new Error(`${key} must be a number`);
+            return parsed;
+        }
+        case "deployment-environment":
+            return value.toLowerCase();
+        case "string": {
+            if (value.startsWith('"')) {
+                const parsed = parseAgentNativeConfigJson(value, key);
+                if (typeof parsed !== "string") {
+                    throw new Error(`${key} must contain a string`);
+                }
+                return parsed;
+            }
+            return value;
+        }
+        case "union": {
+            if (value.startsWith("{") || value.startsWith("[")) {
+                return parseAgentNativeConfigJson(value, key);
+            }
+            const normalized = value.toLowerCase();
+            if (["1", "true", "yes", "on"].includes(normalized))
+                return true;
+            if (["0", "false", "no", "off"].includes(normalized))
+                return false;
+            if (value.startsWith('"')) {
+                const parsed = parseAgentNativeConfigJson(value, key);
+                if (typeof parsed !== "string") {
+                    throw new Error(`${key} must contain a string or JSON object`);
+                }
+                return parsed;
+            }
+            return value;
+        }
+    }
+}
+function agentNativeConfigEnvNodeForPath(path) {
+    return AGENT_NATIVE_CONFIG_ENV_NODES.find((node) => node.path.length === path.length &&
+        node.path.every((segment, index) => segment === path[index]));
+}
+function agentNativeConfigEnvChildren(path) {
+    return AGENT_NATIVE_CONFIG_ENV_NODES.filter((node) => node.path.length === path.length + 1 &&
+        path.every((segment, index) => node.path[index] === segment));
+}
+function validateAgentNativeConfigEnvFragment(value, path, key) {
+    const node = agentNativeConfigEnvNodeForPath(path);
+    if (!node)
+        return;
+    if (node.kind === "object") {
+        if (!isRecord(value)) {
+            throw new Error(`${key} must contain a JSON object`);
+        }
+    }
+    else if (node.kind !== "union" || !isRecord(value)) {
+        return;
+    }
+    if (node.dynamicObjectKeys)
+        return;
+    const children = new Map(agentNativeConfigEnvChildren(path).map((child) => [
+        child.path[child.path.length - 1],
+        child,
+    ]));
+    for (const [childKey, childValue] of Object.entries(value)) {
+        const child = children.get(childKey);
+        if (!child) {
+            const childPath = [...path, childKey].join(".");
+            throw new Error(`${key} contains unsupported Agent-Native config path ${childPath}`);
+        }
+        validateAgentNativeConfigEnvFragment(childValue, child.path, key);
+    }
+}
+function mergeAgentNativeConfigEnvFragments(base, override) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        const existing = result[key];
+        result[key] =
+            isRecord(existing) && isRecord(value)
+                ? mergeAgentNativeConfigEnvFragments(existing, value)
+                : value;
+    }
+    return result;
+}
+function assignAgentNativeConfigEnvFragment(target, path, value, key) {
+    if (path.length === 0) {
+        if (!isRecord(value)) {
+            throw new Error(`${key} must contain a JSON object`);
+        }
+        Object.assign(target, mergeAgentNativeConfigEnvFragments(target, value));
+        return;
+    }
+    let node = target;
+    for (const segment of path.slice(0, -1)) {
+        const existing = node[segment];
+        if (existing === undefined) {
+            node[segment] = {};
+        }
+        else if (!isRecord(existing)) {
+            node[segment] = {};
+        }
+        node = node[segment];
+    }
+    const leaf = path[path.length - 1];
+    const existing = node[leaf];
+    node[leaf] =
+        isRecord(existing) && isRecord(value)
+            ? mergeAgentNativeConfigEnvFragments(existing, value)
+            : value;
+}
+/**
+ * Reads the public config's deterministic environment aliases.
+ *
+ * `AGENT_NATIVE_CONFIG` contains a complete JSON object. A suffixed name
+ * contains a JSON fragment at that config path, or a typed scalar at a leaf.
+ * Nodes are applied from shallowest to deepest so a more specific path wins.
+ */
+export function readAgentNativeConfigEnv(env) {
+    const known = new Map();
+    for (const node of AGENT_NATIVE_CONFIG_ENV_NODES) {
+        for (const key of agentNativeConfigEnvKeys(node)) {
+            const previous = known.get(key);
+            if (previous && previous.path.join(".") !== node.path.join(".")) {
+                throw new Error(`Duplicate Agent-Native config environment key ${key}`);
+            }
+            known.set(key, node);
+        }
+    }
+    for (const key of Object.keys(env)) {
+        if (isAgentNativeConfigEnvKey(key) && !known.has(key)) {
+            throw new Error(`${key} is not a supported Agent-Native config path. Use agent-native.config.ts or a documented config env alias.`);
+        }
+    }
+    const layer = {};
+    const nodes = [...AGENT_NATIVE_CONFIG_ENV_NODES].sort((left, right) => left.path.length - right.path.length);
+    for (const node of nodes) {
+        for (const key of agentNativeConfigEnvKeys(node)) {
+            const raw = env[key];
+            if (raw === undefined || raw.trim() === "")
+                continue;
+            const value = parseAgentNativeConfigEnvValue(raw, key, node.kind);
+            validateAgentNativeConfigEnvFragment(value, node.path, key);
+            assignAgentNativeConfigEnvFragment(layer, node.path, value, key);
+            break;
+        }
+    }
+    return normalizeAgentNativeConfig(layer, "Agent-Native config environment");
+}
 export function normalizeAgentNativeConfig(input, source = "agent-native config") {
     if (!isRecord(input)) {
         throw new Error(`${source} must export an object`);

package/dist/deploy/build.js

@@ -18,10 +18,12 @@ import fs from "fs";
 import { createRequire } from "module";
 import path from "path";
 import { fileURLToPath } from "url";
+import { loadEnv } from "vite";
 import { AGENT_BACKGROUND_FUNCTION_NAME, AGENT_BACKGROUND_FUNCTION_URL_PATH, AGENT_BACKGROUND_PROCESSOR_A2A, AGENT_BACKGROUND_PROCESSOR_FIELD, AGENT_BACKGROUND_PROCESSOR_INTEGRATION, AGENT_BACKGROUND_PROCESSOR_ROUTE, AGENT_BACKGROUND_PROCESSOR_ROUTE_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, isDurableBackgroundFlagExplicitlyDisabled, } from "../agent/durable-background.js";
 import { INTEGRATION_RECOVERY_RUNTIME_MARKER, INTEGRATION_RETRY_SWEEP_PATH, INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT, isIntegrationDurableDispatchConfigured, } from "../integrations/integration-durable-dispatch-config.js";
 import { isValidCron } from "../jobs/cron.js";
 import { RECURRING_JOBS_SWEEP_PATH, RECURRING_JOBS_SWEEP_TOKEN_SUBJECT, } from "../jobs/scheduler-dispatch.js";
+import { findWorkspaceRoot as findAgentNativeWorkspaceRoot } from "../scripts/utils.js";
 import { normalizeAppBasePath } from "../server/app-base-path.js";
 import { DEFAULT_SPECULATION_RULES_PATH, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_QUERY_CACHE_KEY_HEADER, } from "../shared/cache-control.js";
 import { mcpEmbedStaticAssetRouteRules } from "../shared/mcp-embed-headers.js";
@@ -3922,7 +3924,16 @@ async function buildWithNitro() {
     // own virtual module registration. Both paths reuse `readAgentsBundleFromFs`
     // from `server/agents-bundle.ts` to guarantee identical content.
     const { readAgentsBundleFromFs } = await import("../server/agents-bundle.js");
-    const nitroAgentConfig = await loadResolvedAgentNativeConfig(cwd, createAgentNativeConfigContext("build", process.env.NODE_ENV === "development" ? "development" : "production"));
+    const nitroMode = process.env.NODE_ENV === "development" ? "development" : "production";
+    const agentNativeWorkspaceRoot = findAgentNativeWorkspaceRoot(cwd);
+    const nitroEnvironment = {
+        ...(agentNativeWorkspaceRoot && agentNativeWorkspaceRoot !== cwd
+            ? loadEnv(nitroMode, agentNativeWorkspaceRoot, "")
+            : {}),
+        ...loadEnv(nitroMode, cwd, ""),
+        ...process.env,
+    };
+    const nitroAgentConfig = await loadResolvedAgentNativeConfig(cwd, createAgentNativeConfigContext("build", nitroMode), { environment: nitroEnvironment });
     // Resolve the workspace core (if present) up front so the bundle embeds
     // enterprise-wide AGENTS.md + skills alongside the template's.
     const nitroWorkspaceCore = await getWorkspaceCoreExports(cwd);

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./config.js";
-export { createProductionAgentHandler, type ActionEntry, type ScriptEntry, type ProductionAgentOptions, type AgentActionSurface, type AgentActionSurfaceDetails, type ActionTool, type ScriptTool, type AgentMessage, type AgentChatRequest, type AgentChatEvent, type AgentChatAttachment, DEFAULT_MODEL, TripWire, type Processor, type ProcessorState, type ProcessorAbort, } from "./agent/index.js";
+export { createProductionAgentHandler, type ActionEntry, type ScriptEntry, type ProductionAgentOptions, type AgentActionSurface, type DefaultAgentActionSurface, type AgentActionSurfaceResolution, type AgentActionSurfaceDetails, type ActionTool, type ScriptTool, type AgentMessage, type AgentChatRequest, type AgentChatEvent, type AgentChatAttachment, DEFAULT_MODEL, TripWire, type Processor, type ProcessorState, type ProcessorAbort, } from "./agent/index.js";
 export { defineAction, ActionContractError, isActionContractError, type ActionContractErrorOptions, AgentActionStopError, isAgentActionStopError, type ActionDefinition, type ActionHttpConfig, type AgentActionStopOptions, type PublicAgentActionConfig, type ActionDeepLink, type ActionLinkBuilder, MCP_APP_EXTENSION_ID, MCP_APP_MIME_TYPE, MCP_APP_RESOURCE_URI_META_KEY, type ActionMcpAppConfig, type ActionMcpAppCsp, type ActionMcpAppCspBuilder, type ActionMcpAppHtmlBuilder, type ActionMcpAppPermissions, type ActionMcpAppResourceConfig, type ActionMcpAppResourceMeta, } from "./action.js";
 export * from "./user-profile/index.js";
 export { embedApp, MCP_APP_REQUEST_ORIGIN_CSP_SOURCE, type EmbedAppOptions, } from "./mcp/embed-app.js";

package/dist/observability/routes.d.ts

@@ -42,22 +42,22 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     avgEvalScore: number;
 } | {
     error?: undefined;
-    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
-    ok?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
-} | {
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
+    ok?: undefined;
 } | {
     error?: undefined;
     summary?: undefined;

package/dist/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;