@agent-native/core 0.80.2 → 0.80.5

package/corpus/core/src/agent/durable-background.ts

@@ -18,9 +18,11 @@
  * GUARDRAIL: when `isAgentChatDurableBackgroundEnabled()` returns false, the
  * agent-chat handler must behave byte-for-byte like the current synchronous
  * path. The gate is true only when ALL of these hold:
- *   1. `AGENT_CHAT_DURABLE_BACKGROUND` env is explicitly enabled. It is
- *      DEFAULT-OFF (opt-in): unset/empty/unknown counts as disabled; set it to a
- *      truthy value (`true`/`1`/`yes`/`on`) to opt a specific app in.
+ *   1. `AGENT_CHAT_DURABLE_BACKGROUND` env is explicitly enabled, or a
+ *      workspace app's agent-chat plugin opts in with `durableBackgroundRuns`
+ *      where the workspace deploy emits a per-app background function by
+ *      default. Single-template Netlify deploys must set the env flag because
+ *      that same flag controls whether `server-agent-background` is emitted.
  *   2. The runtime is hosted/serverless (local dev keeps the inline path so SSE
  *      stays a single live stream and no second function is needed).
  *   3. `A2A_SECRET` is configured (the HMAC handoff is required to authenticate
@@ -259,17 +261,36 @@ function isFlagEnabled(): boolean {
   );
 }
 
+function isFlagExplicitlyDisabled(): boolean {
+  const raw = process.env.AGENT_CHAT_DURABLE_BACKGROUND;
+  if (raw == null) return false;
+  const normalized = raw.trim().toLowerCase();
+  return (
+    normalized === "0" ||
+    normalized === "false" ||
+    normalized === "no" ||
+    normalized === "off"
+  );
+}
+
 /**
- * The single gate. True when the flag is explicitly enabled (opt-in/default-off)
- * AND the runtime is hosted AND A2A_SECRET is configured. False otherwise — and
- * false means the current synchronous behavior is used, unchanged. So a local /
- * non-hosted / unconfigured app stays synchronous, and an app that has not opted
- * in stays synchronous; durable only engages where it is explicitly enabled and
- * the runtime actually supports it.
+ * The single gate. True when the env flag is explicitly enabled, or a workspace
+ * app opted in and has a per-app background-function target, AND the runtime is
+ * hosted AND A2A_SECRET is configured. False otherwise — and false means the
+ * current synchronous behavior is used unchanged. Single-template Netlify app
+ * opt-ins deliberately require the env flag too because that flag controls
+ * whether the `server-agent-background` function exists in the deploy output.
  */
-export function isAgentChatDurableBackgroundEnabled(): boolean {
+export function isAgentChatDurableBackgroundEnabled(options?: {
+  appOptIn?: boolean;
+}): boolean {
+  const envOptIn = isFlagEnabled();
+  const workspaceAppOptIn =
+    options?.appOptIn === true &&
+    !isFlagExplicitlyDisabled() &&
+    resolveWorkspaceBackgroundFunctionUrlPath() !== null;
   return (
-    isFlagEnabled() &&
+    (envOptIn || workspaceAppOptIn) &&
     isHostedRuntimeForDurableBackground() &&
     hasConfiguredA2ASecret()
   );

package/corpus/core/src/agent/production-agent.ts

@@ -534,6 +534,9 @@ export interface ActionEntry {
    *  Defaults to true; false lets safe metadata/read actions run with
    *  `ctx.userEmail` undefined when auth resolution returns 401/403. */
   requiresAuth?: boolean;
+  /** Max HTTP request body in bytes; the route 413s on `Content-Length` before
+   *  parsing. For public, no-auth POST actions. */
+  maxBodyBytes?: number;
   /** Whether the action is exposed to the agent as a callable tool. Only an
    *  explicit `false` hides it from every agent tool surface (in-app assistant,
    *  MCP, A2A, job/trigger runners) while leaving it frontend/HTTP-callable.
@@ -888,6 +891,13 @@ export interface ProductionAgentOptions {
    *  timeout. When reached, the client receives an internal auto-continuation
    *  signal instead of a user-facing warning. */
   runSoftTimeoutMs?: number;
+  /**
+   * Opt this app into durable Netlify background-function agent-chat runs. This
+   * is a runtime opt-in layered on top of the hosted-runtime + A2A_SECRET gates;
+   * single-template Netlify deploys must also enable the deploy-time
+   * `AGENT_CHAT_DURABLE_BACKGROUND` flag so the background function is emitted.
+   */
+  durableBackgroundRuns?: boolean;
   /** Called when a run starts, with the send function for emitting events and the threadId */
   onRunStart?: (
     send: (event: AgentChatEvent) => void,
@@ -3991,7 +4001,10 @@ export function createProductionAgentHandler(
     // The foreground POST decides whether to dispatch into a background
     // function. The background worker itself never re-dispatches.
     const dispatchToBackground =
-      !isBackgroundWorker && isAgentChatDurableBackgroundEnabled();
+      !isBackgroundWorker &&
+      isAgentChatDurableBackgroundEnabled({
+        appOptIn: options.durableBackgroundRuns === true,
+      });
     const requestBrowserTabId = normalizeBrowserTabId(browserTabId);
     const requestChatScope = normalizeChatScope(scope);
     const requestRunCtx = ensureRequestRunContext();

package/corpus/core/src/agent/run-loop-with-resume.ts

@@ -29,6 +29,7 @@ import {
   continuationReasonForResumableError,
 } from "./production-agent.js";
 import { resolveRunSoftTimeoutMs } from "./run-manager.js";
+import type { ResolveRunSoftTimeoutOptions } from "./run-manager.js";
 import { getCurrentTurnEventsForThread } from "./run-store.js";
 import {
   classifyToolCallJournal,
@@ -120,8 +121,9 @@ export const RUN_BUDGET_EXHAUSTED_MESSAGE =
 export async function runAgentLoopDirectWithSoftTimeout(
   opts: Parameters<typeof runAgentLoop>[0],
   softTimeoutMs?: number,
+  timeoutOptions?: ResolveRunSoftTimeoutOptions,
 ): Promise<Awaited<ReturnType<typeof runAgentLoop>>> {
-  const timeoutMs = resolveRunSoftTimeoutMs(softTimeoutMs);
+  const timeoutMs = resolveRunSoftTimeoutMs(softTimeoutMs, timeoutOptions);
   if (timeoutMs <= 0) return runAgentLoop(opts);
 
   const upstreamSignal = opts.signal;

package/corpus/core/src/brand-kit/fig/index.ts

@@ -1,10 +1,4 @@
 import type { BrandKitData, BrandKitDefaults } from "../types.js";
-import { decodeFig } from "./decode.js";
-import { extractDesignSystemFromFig } from "./extract-design-system.js";
-
-export * from "./decode.js";
-export * from "./extract-design-system.js";
-export * from "./fig-to-html.js";
 
 export interface FigBrandKitPreview {
   gradients: string[];
@@ -25,6 +19,12 @@ export interface FigBrandKitExtraction {
 
 export const MAX_FIG_THUMBNAIL_BYTES = 512 * 1024;
 
+function unsupportedFigImport(): never {
+  throw new Error(
+    "Local .fig design-system extraction has moved to Builder indexing. Connect Builder and use the design system indexing flow instead.",
+  );
+}
+
 export function looksLikeFigFile(data: Uint8Array): boolean {
   const isZip =
     data[0] === 0x50 &&
@@ -42,39 +42,19 @@ export function figThumbnailDataUrl(thumbnail: Buffer | null): string | null {
 }
 
 export function extractFigBrandKit(
-  input: Buffer | Uint8Array,
+  _input: Buffer | Uint8Array,
 ): FigBrandKitExtraction {
-  const decoded = decodeFig(Buffer.from(input));
-  if (!decoded.document) {
-    throw new Error(
-      "Decoded the file but found no document. It may be a partial or corrupt export.",
-    );
-  }
+  return unsupportedFigImport();
+}
 
-  const extracted = extractDesignSystemFromFig(decoded.document);
-  const {
-    customInstructions,
-    gradients,
-    palette,
-    namedColors,
-    nodeCount,
-    ...data
-  } = extracted;
+export function decodeFig(_input: Buffer | Uint8Array): never {
+  return unsupportedFigImport();
+}
 
-  const thumbnailDataUrl = figThumbnailDataUrl(decoded.thumbnail);
+export function extractDesignSystemFromFig(_document: unknown): never {
+  return unsupportedFigImport();
+}
 
-  return {
-    format: decoded.format,
-    version: decoded.version ?? null,
-    data,
-    customInstructions: customInstructions ?? "",
-    preview: {
-      gradients: gradients ?? [],
-      palette: palette ?? [],
-      namedColors: namedColors ?? {},
-      thumbnailDataUrl,
-      nodeCount: nodeCount ?? 0,
-      imageCount: decoded.images.length,
-    },
-  };
+export function figToHtml(_node: unknown): never {
+  return unsupportedFigImport();
 }

package/corpus/core/src/cli/index.ts

@@ -927,7 +927,7 @@ Usage:
                                 reinstalling app skills/connectors.
   agent-native app-skill <cmd>  Install, launch, or package app-backed skills.
                                 cmds: ensure | launch | pack
-  agent-native skills add assets|content|design-exploration|visual-plan|visual-recap|context-xray
+  agent-native skills add assets|content|design-exploration|visual-edit|visual-plan|visual-recap|context-xray
                                 Install the skill instructions, register the MCP
                                 connector, AND authenticate it in one step.
                                 --no-connect skips auth (run 'connect' later);

package/corpus/core/src/cli/mcp-config-writers.ts

@@ -392,8 +392,124 @@ function codexMcpHeader(name: string): string {
   return `[mcp_servers.${tomlQuote(name)}]`;
 }
 
-function legacyCodexMcpHeader(name: string): string | null {
-  return /^[A-Za-z0-9_-]+$/.test(name) ? `[mcp_servers.${name}]` : null;
+/**
+ * Parse a TOML table-header line such as `[mcp_servers."plan".http_headers]`
+ * or `[mcp_servers.plan] # local note` into its decoded dotted-key components
+ * (`["mcp_servers", "plan", "http_headers"]`). Returns `null` when the line is
+ * not a single `[table]` header — blank lines, key/value pairs, comments,
+ * invalid trailing content, and `[[array-of-tables]]` headers all return `null`,
+ * so the result doubles as a reliable "is this line a table boundary?" check.
+ *
+ * Handles bare keys (`A-Za-z0-9_-`) and quoted keys (basic `"..."` with `\`
+ * escapes, and literal `'...'`), tolerating whitespace around the dot
+ * separators per the TOML spec. Quoted-key escape handling mirrors the inverse
+ * of `tomlQuote` (`\"` → `"`, `\\` → `\`).
+ */
+function parseTomlTableHeader(line: string): string[] | null {
+  const trimmed = line.trim();
+  if (trimmed.length < 2 || trimmed[0] !== "[") return null;
+  // `[[array-of-tables]]` is a different construct — leave it untouched.
+  if (trimmed[1] === "[") return null;
+
+  let quote: '"' | "'" | null = null;
+  let escaped = false;
+  let closeIndex = -1;
+  for (let i = 1; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (quote === '"') {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') quote = null;
+      continue;
+    }
+    if (quote === "'") {
+      if (ch === "'") quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "]") {
+      closeIndex = i;
+      break;
+    }
+  }
+  if (closeIndex < 0) return null;
+  const trailing = trimmed.slice(closeIndex + 1).trim();
+  if (trailing && !trailing.startsWith("#")) return null;
+
+  const inner = trimmed.slice(1, closeIndex);
+  const keys: string[] = [];
+  const isWs = (c: string) => c === " " || c === "\t";
+  const isBare = (c: string) => /[A-Za-z0-9_-]/.test(c);
+  let i = 0;
+  let expectKey = true;
+  while (i < inner.length) {
+    while (i < inner.length && isWs(inner[i])) i++;
+    if (i >= inner.length) break;
+    const ch = inner[i];
+    if (ch === ".") {
+      if (expectKey) return null; // leading or doubled dot
+      expectKey = true;
+      i++;
+      continue;
+    }
+    if (!expectKey) return null; // two keys with no dot between them
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      i++;
+      let key = "";
+      while (i < inner.length && inner[i] !== quote) {
+        if (quote === '"' && inner[i] === "\\" && i + 1 < inner.length) {
+          const next = inner[i + 1];
+          key += next === '"' ? '"' : next === "\\" ? "\\" : `\\${next}`;
+          i += 2;
+          continue;
+        }
+        key += inner[i];
+        i++;
+      }
+      if (i >= inner.length) return null; // unterminated quote
+      i++; // consume the closing quote
+      keys.push(key);
+      expectKey = false;
+    } else if (isBare(ch)) {
+      let key = "";
+      while (i < inner.length && isBare(inner[i])) {
+        key += inner[i];
+        i++;
+      }
+      keys.push(key);
+      expectKey = false;
+    } else {
+      return null; // unexpected character — not a table header
+    }
+  }
+  if (expectKey) return null; // empty header or trailing dot
+  return keys.length ? keys : null;
+}
+
+/**
+ * The MCP server name a TOML table header belongs to, or `undefined` when the
+ * header is not under `[mcp_servers.*]`. The server's own table
+ * (`[mcp_servers.<name>]`) AND every sub-table of it
+ * (`[mcp_servers.<name>.http_headers]`, `[mcp_servers.<name>.env]`, …) resolve
+ * to the same `<name>`, so callers can treat a server and all its sub-tables as
+ * one removable unit. This is what prevents a re-install from orphaning a stale
+ * `[mcp_servers.<name>.http_headers]` sub-table that would then collide with the
+ * freshly written inline `http_headers` (a TOML duplicate-key error).
+ */
+function codexServerNameOfHeader(line: string): string | undefined {
+  const keys = parseTomlTableHeader(line);
+  if (!keys || keys.length < 2 || keys[0] !== "mcp_servers") return undefined;
+  return keys[1];
 }
 
 /** Build a `[mcp_servers.<name>]` block for an HTTP-type MCP server. */
@@ -439,11 +555,16 @@ export function buildCodexLocalBlock(
 }
 
 /**
- * Replace (or append) the `[mcp_servers.<name>]` block in a TOML file
- * without disturbing other content. A block is the header line plus every
- * following line until the next top-level `[` table header or EOF. Pass
- * `block === null` to remove the block. Identical algorithm to `mcp.ts`'s
- * `writeCodexBlock` so the two never diverge.
+ * Replace (or append) the entire `[mcp_servers.<name>]` footprint in a TOML
+ * file without disturbing other content. The footprint is the server's own
+ * table AND every sub-table of it (`[mcp_servers.<name>.http_headers]`,
+ * `[mcp_servers.<name>.env]`, …), each spanning its header line plus every
+ * following line until the next table header or EOF. Removing the whole
+ * footprint — wherever the pieces sit in the file — is what keeps a re-install
+ * from leaving a stale sub-table that collides with the freshly written inline
+ * block (a TOML duplicate-key error). Matches both the canonical quoted header
+ * and the legacy bare header. Pass `block === null` to remove the footprint.
+ * Identical algorithm to `mcp.ts`'s `writeCodexBlock` so the two never diverge.
  */
 export function writeCodexBlock(
   file: string,
@@ -457,22 +578,18 @@ export function writeCodexBlock(
     content = "";
   }
 
-  const headers = new Set(
-    [codexMcpHeader(name), legacyCodexMcpHeader(name)].filter(
-      Boolean,
-    ) as string[],
-  );
   const lines = content.split(/\r?\n/);
   const out: string[] = [];
   let i = 0;
   let removed = false;
   while (i < lines.length) {
     const line = lines[i];
-    if (headers.has(line.trim())) {
-      // Skip this block entirely (header + body until next table header).
+    if (codexServerNameOfHeader(line) === name) {
+      // Skip this table and its body (until the next table header), covering
+      // the server table itself and any of its sub-tables.
       removed = true;
       i++;
-      while (i < lines.length && !/^\s*\[/.test(lines[i])) i++;
+      while (i < lines.length && parseTomlTableHeader(lines[i]) === null) i++;
       continue;
     }
     out.push(line);
@@ -496,12 +613,9 @@ export function writeCodexBlock(
 export function codexHasBlock(file: string, name: string): boolean {
   try {
     const content = fs.readFileSync(file, "utf-8");
-    const headers = new Set(
-      [codexMcpHeader(name), legacyCodexMcpHeader(name)].filter(
-        Boolean,
-      ) as string[],
-    );
-    return content.split(/\r?\n/).some((line) => headers.has(line.trim()));
+    return content
+      .split(/\r?\n/)
+      .some((line) => codexServerNameOfHeader(line) === name);
   } catch {
     return false;
   }
@@ -620,8 +734,11 @@ export function removeJsonSameUrlDuplicates(
 
 /**
  * After writing the canonical `keepName` Codex block, remove any OTHER
- * `[mcp_servers.*]` blocks in the same TOML file whose `url =` line
- * normalises to the same value as `mcpUrl`. Returns removed entry names.
+ * `[mcp_servers.*]` servers in the same TOML file whose `url =` line normalises
+ * to the same value as `mcpUrl`. A server's entire footprint is removed — its
+ * own table AND any sub-tables (`.http_headers`, `.env`, …), even when they are
+ * not contiguous — so cleanup never leaves an orphaned sub-table behind.
+ * Returns removed entry names in first-seen order.
  */
 export function removeCodexSameUrlDuplicates(
   file: string,
@@ -638,52 +755,71 @@ export function removeCodexSameUrlDuplicates(
   if (!targetCanonical) return [];
 
   const lines = content.split(/\r?\n/);
-  const out: string[] = [];
-  const removed: string[] = [];
+
+  // Pass 1: map each server name to the canonical URL declared on its own
+  // table, preserving first-seen order. Sub-tables don't carry the URL, so they
+  // only register the name.
+  const serverUrls = new Map<string, string | undefined>();
   let i = 0;
   while (i < lines.length) {
-    const line = lines[i];
-    const trimmed = line.trim();
-    const quoted = trimmed.match(/^\[mcp_servers\."((?:\\.|[^"])*)"\]$/);
-    const bare = trimmed.match(/^\[mcp_servers\.([A-Za-z0-9_-]+)\]$/);
-    const serverName = quoted
-      ? quoted[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\")
-      : bare?.[1];
-    if (serverName !== undefined && serverName !== keepName) {
-      // Collect the block
-      const block: string[] = [line];
+    const keys = parseTomlTableHeader(lines[i]);
+    const name =
+      keys && keys.length >= 2 && keys[0] === "mcp_servers"
+        ? keys[1]
+        : undefined;
+    if (name === undefined) {
       i++;
-      while (i < lines.length && !/^\s*\[/.test(lines[i])) {
-        block.push(lines[i]);
-        i++;
-      }
-      // Check url in block
-      const urlMatch = block
+      continue;
+    }
+    const isServerTable = keys!.length === 2;
+    const body: string[] = [];
+    i++;
+    while (i < lines.length && parseTomlTableHeader(lines[i]) === null) {
+      body.push(lines[i]);
+      i++;
+    }
+    if (isServerTable) {
+      const urlMatch = body
         .join("\n")
         .match(/^\s*url\s*=\s*"((?:\\.|[^"])*)"/m);
       const blockUrl = urlMatch
         ? urlMatch[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\")
         : undefined;
-      if (canonicalUrl(blockUrl) === targetCanonical) {
-        removed.push(serverName);
-        // Skip this block (don't push to out)
-        continue;
-      }
-      // Not a duplicate — keep it
-      for (const l of block) out.push(l);
+      serverUrls.set(name, canonicalUrl(blockUrl));
+    } else if (!serverUrls.has(name)) {
+      serverUrls.set(name, undefined);
+    }
+  }
+
+  const removeSet = new Set<string>();
+  for (const [name, canonical] of serverUrls) {
+    if (name !== keepName && canonical && canonical === targetCanonical) {
+      removeSet.add(name);
+    }
+  }
+  if (removeSet.size === 0) return [];
+
+  // Pass 2: rebuild, dropping every table/sub-table belonging to a removed
+  // server.
+  const out: string[] = [];
+  i = 0;
+  while (i < lines.length) {
+    const name = codexServerNameOfHeader(lines[i]);
+    if (name !== undefined && removeSet.has(name)) {
+      i++;
+      while (i < lines.length && parseTomlTableHeader(lines[i]) === null) i++;
       continue;
     }
-    out.push(line);
+    out.push(lines[i]);
     i++;
   }
 
-  if (removed.length === 0) return [];
   const next = out
     .join("\n")
     .replace(/\n{3,}/g, "\n\n")
     .replace(/\n*$/, "\n");
   writeFileAtomic(file, next);
-  return removed;
+  return [...removeSet];
 }
 
 /**