@agent-native/core 0.98.8 → 0.98.10

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 2239
-- template files: 5508
+- template files: 5512

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @agent-native/core
 
+## 0.98.10
+
+### Patch Changes
+
+- 079713c: Fall back to the portable A2A processor when a configured durable background worker rejects a task dispatch, and allow apps to explicitly opt out of stale deploy-wide background flags.
+- 079713c: Preserve structured payloads from read-only MCP actions so external agents can inspect detailed records and replay data directly.
+
+## 0.98.9
+
+### Patch Changes
+
+- 944c202: Preserve structured payloads from read-only MCP actions so external agents can inspect detailed records and replay data directly.
+
 ## 0.98.8
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.98.8",
+  "version": "0.98.10",
   "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/corpus/core/src/a2a/handlers.ts

@@ -82,33 +82,50 @@ async function fireProcessTaskDispatch(
   event: any,
   taskId: string,
   config: A2AConfig,
-  options?: { awaitResponse?: boolean },
 ): Promise<void> {
   const backgroundPath = resolveAgentChatProcessRunDispatchPath();
   const useBackgroundWorker =
     isAgentChatDurableBackgroundEnabled({
-      appOptIn: config.durableBackgroundRuns === true,
+      appOptIn: config.durableBackgroundRuns,
     }) && dispatchPathTargetsNetlifyBackgroundFunction(backgroundPath);
 
-  await fireInternalDispatch({
-    event,
-    path: useBackgroundWorker ? backgroundPath : A2A_PROCESS_TASK_PATH,
-    taskId,
-    ...(useBackgroundWorker
-      ? {
-          body: {
-            [AGENT_BACKGROUND_PROCESSOR_FIELD]: AGENT_BACKGROUND_PROCESSOR_A2A,
-          },
-        }
-      : {}),
-    // Only Netlify's background-function URL acknowledges enqueue with 202.
-    // The portable framework route keeps its HTTP response open until the
-    // processor completes, so awaiting that response would turn async
-    // message/send into a long synchronous request (or a 15s timeout).
-    ...(options?.awaitResponse && useBackgroundWorker
-      ? { awaitResponse: true }
-      : {}),
-  });
+  if (!useBackgroundWorker) {
+    await fireInternalDispatch({
+      event,
+      path: A2A_PROCESS_TASK_PATH,
+      taskId,
+    });
+    return;
+  }
+
+  try {
+    // A real Netlify background function acknowledges the enqueue quickly.
+    // Await that acknowledgement so a missing or rejected worker can fall
+    // back before the task is left in `working` with no processor.
+    await fireInternalDispatch({
+      event,
+      path: backgroundPath,
+      taskId,
+      body: {
+        [AGENT_BACKGROUND_PROCESSOR_FIELD]: AGENT_BACKGROUND_PROCESSOR_A2A,
+      },
+      awaitResponse: true,
+    });
+  } catch (backgroundError) {
+    // Deploys can retain a runtime env opt-in after the corresponding
+    // background function was removed from the build. Keep async A2A useful
+    // in that state by falling back to the portable processor route, which
+    // runs in the regular framework function with the same task/auth checks.
+    console.error(
+      "[a2a] Durable background dispatch failed; falling back to portable processor:",
+      backgroundError,
+    );
+    await fireInternalDispatch({
+      event,
+      path: A2A_PROCESS_TASK_PATH,
+      taskId,
+    });
+  }
 }
 
 /**
@@ -531,9 +548,7 @@ async function handleSend(
     // race for the portable route, which holds its response open until the
     // handler finishes.
     try {
-      await fireProcessTaskDispatch(event, task.id, config, {
-        awaitResponse: true,
-      });
+      await fireProcessTaskDispatch(event, task.id, config);
     } catch (err) {
       console.error("[a2a] Failed to dispatch process-task:", err);
     }

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

@@ -351,6 +351,12 @@ function isFlagExplicitlyDisabled(): boolean {
 export function isAgentChatDurableBackgroundEnabled(options?: {
   appOptIn?: boolean;
 }): boolean {
+  // An app-level opt-out must win over a stale deploy-wide env flag. Netlify
+  // environment variables can outlive the source config that originally set
+  // them; allowing that flag to re-enable a worker an app explicitly disabled
+  // recreates the missing-background-function failure this gate is meant to
+  // prevent.
+  if (options?.appOptIn === false) return false;
   const envOptIn = isFlagEnabled();
   const workspaceAppOptIn =
     options?.appOptIn === true &&

package/corpus/core/src/mcp/build-server.ts

@@ -512,28 +512,91 @@ function routePathFromOpenUrl(value: string): string | null {
  * `mcpApp.resource` (the resource path already strips them via
  * `mcpAppStructuredContent`).
  *
- * Depth-capped to avoid pathological / circular structures. Strings that
- * embed an `isEmbedStartUrl` substring (e.g. a longer message that includes
- * the URL) are replaced with `[hidden embed URL]`.
+ * Circular structures are replaced with a marker. Strings that embed an
+ * `isEmbedStartUrl` substring (e.g. a longer message that includes the URL)
+ * are replaced with `[hidden embed URL]`. Credential-like `ticket` fields are
+ * removed only inside an embed-signaled object/branch, so ordinary business
+ * fields from unrelated read actions remain faithful.
  */
-function purgeEmbedStartUrls(value: unknown, depth = 0): unknown {
-  if (depth > 5) return value;
+const EMBED_RESULT_SENSITIVE_KEYS = new Set([
+  "embedTargetPath",
+  "embedExpiresAt",
+  "embedTicket",
+]);
+
+function isEmbedCredentialKey(key: string): boolean {
+  return key === "ticket" || /Ticket$/.test(key);
+}
+
+function containsEmbedRoutingSignal(
+  value: unknown,
+  seen = new WeakSet<object>(),
+): boolean {
+  if (typeof value === "string") return isEmbedStartUrl(value);
+  if (!value || typeof value !== "object") return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result = value.some((item) => containsEmbedRoutingSignal(item, seen));
+    seen.delete(value);
+    return result;
+  }
+  for (const [key, val] of Object.entries(value)) {
+    if (EMBED_RESULT_SENSITIVE_KEYS.has(key)) {
+      seen.delete(value);
+      return true;
+    }
+    if (containsEmbedRoutingSignal(val, seen)) {
+      seen.delete(value);
+      return true;
+    }
+  }
+  seen.delete(value);
+  return false;
+}
+
+function purgeEmbedStartUrls(
+  value: unknown,
+  seen = new WeakSet<object>(),
+  embedContext = false,
+): unknown {
   if (typeof value === "string") {
     return isEmbedStartUrl(value) ? "[hidden embed URL]" : value;
   }
   if (Array.isArray(value)) {
-    return value.map((item) => purgeEmbedStartUrls(item, depth + 1));
+    if (seen.has(value)) return "[circular result]";
+    seen.add(value);
+    // An embed marker in one array item puts the whole result in the embed
+    // routing context. Credential fields in sibling items must not survive
+    // just because the marker lives elsewhere in the array.
+    const arrayEmbedContext = embedContext || containsEmbedRoutingSignal(value);
+    const out = value.map((item) =>
+      purgeEmbedStartUrls(item, seen, arrayEmbedContext),
+    );
+    seen.delete(value);
+    return out;
   }
   if (value && typeof value === "object") {
+    if (seen.has(value)) return "[circular result]";
+    seen.add(value);
+    const entries = Object.entries(value as Record<string, unknown>);
+    const localEmbedContext = embedContext || containsEmbedRoutingSignal(value);
     const out: Record<string, unknown> = {};
-    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+    for (const [key, val] of entries) {
+      if (
+        EMBED_RESULT_SENSITIVE_KEYS.has(key) ||
+        (localEmbedContext && isEmbedCredentialKey(key))
+      ) {
+        continue;
+      }
       if (typeof val === "string" && isEmbedStartUrl(val)) {
         // Drop the key entirely for object-typed inputs so a tool result like
         // `{ embedStartUrl: "..." }` does not appear at all in the LLM text.
         continue;
       }
-      out[key] = purgeEmbedStartUrls(val, depth + 1);
+      out[key] = purgeEmbedStartUrls(val, seen, localEmbedContext);
     }
+    seen.delete(value);
     return out;
   }
   return value;
@@ -1195,11 +1258,12 @@ function mcpAppStructuredContent(
   result: unknown,
   meta: Record<string, unknown> | undefined,
 ): Record<string, unknown> {
+  const purged = purgeEmbedStartUrls(result);
   const out: Record<string, unknown> =
-    result && typeof result === "object" && !Array.isArray(result)
-      ? { ...(result as Record<string, unknown>) }
-      : primitiveValue(result)
-        ? { result }
+    purged && typeof purged === "object" && !Array.isArray(purged)
+      ? { ...(purged as Record<string, unknown>) }
+      : primitiveValue(purged)
+        ? { result: purged }
         : {};
   for (const key of ["embedStartUrl", "startUrl"]) {
     const value = out[key];
@@ -1213,17 +1277,6 @@ function mcpAppStructuredContent(
   // LLM). `embedTargetPath` reveals the exact route + thread/draft id the user
   // is looking at; `embedExpiresAt` is an unintended timestamp; ticket-bearing
   // fields are single-use credentials. Drop all of them unconditionally.
-  for (const key of [
-    "embedTargetPath",
-    "embedExpiresAt",
-    "ticket",
-    "embedTicket",
-  ]) {
-    delete out[key];
-  }
-  for (const key of Object.keys(out)) {
-    if (/Ticket$/.test(key)) delete out[key];
-  }
   const openLink = meta?.["agent-native/openLink"];
   if (openLink && typeof openLink === "object" && !Array.isArray(openLink)) {
     const webUrl = (openLink as Record<string, unknown>).webUrl;
@@ -1275,12 +1328,25 @@ function isSuccessOnlyResult(value: Record<string, unknown>): boolean {
   });
 }
 
-function conciseToolResultText(name: string, result: unknown): string {
+function conciseToolResultText(
+  name: string,
+  result: unknown,
+  options?: { preserveObjectResult?: boolean },
+): string {
   const purged = purgeEmbedStartUrls(result);
   if (typeof purged === "string") return truncateToolText(purged);
   if (purged === true || purged == null) return `${name} completed.`;
   if (purged && typeof purged === "object" && !Array.isArray(purged)) {
     const record = purged as Record<string, unknown>;
+    // Read-only actions are data reads, not mutations. Keep their object
+    // payload available to MCP clients in the text fallback too; the
+    // structuredContent branch below is the lossless path for clients that
+    // support it. Mutating/action-style results retain the concise status
+    // text so we do not unexpectedly dump write results into conversations.
+    if (options?.preserveObjectResult) {
+      const text = JSON.stringify(purged);
+      return text === undefined ? `${name} completed.` : truncateToolText(text);
+    }
     const message = record.message ?? record.summary;
     if (typeof message === "string" && message.trim()) {
       return truncateToolText(message.trim());
@@ -1704,6 +1770,14 @@ export async function createMCPServerForRequest(
           Array.isArray(toolVisibility) &&
           toolVisibility.length > 0 &&
           toolVisibility.every((v) => v === "app");
+        const readOnlyStructuredResult =
+          entry.readOnly === true &&
+          rawResultForClient &&
+          typeof rawResultForClient === "object"
+            ? Array.isArray(rawResultForClient)
+              ? { items: rawResultForClient }
+              : rawResultForClient
+            : undefined;
         const structuredContent = mcpAppResource
           ? mcpAppStructuredContent(rawResultForClient, responseMeta)
           : isAppOnlyVisibility &&
@@ -1711,10 +1785,14 @@ export async function createMCPServerForRequest(
               typeof rawResult === "object" &&
               !Array.isArray(rawResult)
             ? (rawResult as Record<string, unknown>)
-            : undefined;
+            : readOnlyStructuredResult
+              ? mcpAppStructuredContent(readOnlyStructuredResult, responseMeta)
+              : undefined;
         const text = mcpAppResource
           ? conciseMcpAppToolText(name, resultForClient, structuredContent!)
-          : conciseToolResultText(name, resultForClient);
+          : conciseToolResultText(name, resultForClient, {
+              preserveObjectResult: entry.readOnly === true,
+            });
         const content: any[] = [{ type: "text", text }];
         if (block) content.push(block);
         return {

package/corpus/core/src/server/agent-chat/plugin-options.ts

@@ -42,7 +42,9 @@ export interface AgentChatPluginOptions {
   /**
    * Opt this app into Netlify durable background-function agent-chat runs. This
    * gives hosted agent turns the 15-minute async-function budget when the app's
-   * Netlify build also emits the background function.
+   * Netlify build also emits the background function. Set this to `false` to
+   * explicitly disable a stale deploy-wide `AGENT_CHAT_DURABLE_BACKGROUND`
+   * flag for this app.
    */
   durableBackgroundRuns?: boolean;
   /** Anthropic API key. Falls back to ANTHROPIC_API_KEY env var */

package/corpus/templates/analytics/server/plugins/agent-chat.ts

@@ -257,6 +257,10 @@ export default createAgentChatPlugin({
   // Operators deploying to trusted internal environments can set
   // AGENT_PROD_CODE_EXECUTION=trusted to also enable bash/read/edit/write.
   codeExecution: { production: "sandboxed" },
+  // Analytics uses the portable A2A processor until its dedicated background
+  // worker is verified live. This explicit opt-out also protects production
+  // from a stale deploy-wide AGENT_CHAT_DURABLE_BACKGROUND flag.
+  durableBackgroundRuns: false,
   connectorCatalog: [...ANALYTICS_CONNECTOR_CATALOG],
   externalAgents: {
     // Keep the direct MCP surface deliberately curated. External agents

package/corpus/templates/calendar/.agents/skills/event-management/SKILL.md

@@ -128,12 +128,26 @@ pnpm action create-event \
 # Working location
 pnpm action create-event \
   --title "Working from home" \
-  --start 2026-04-03T09:00:00 \
-  --end 2026-04-03T17:00:00 \
+  --start 2026-04-03 \
+  --end 2026-04-04 \
+  --allDay true \
   --eventType workingLocation \
   --workingLocationType homeOffice
 ```
 
+Working-location events sync from Google with `workingLocationProperties` and
+render as native working locations in the UI instead of generic all-day events.
+They are transparent/non-blocking for availability. Google allows timed working
+locations or single-day all-day working locations; multi-day all-day ranges must
+be represented as separate daily working-location events.
+
+For a visible occurrence in a recurring working-location series, default to
+`scope: "single"` and pass the occurrence's event `id`, not its
+`recurringEventId`. Use `scope: "all"` only when the user explicitly asks to
+change every day in the series. Keep office building/floor/desk metadata when
+editing an office label, and clear incompatible location labels when changing
+between Home, Office, and Other.
+
 Do not use `eventType` for Tasks or appointment schedules. Google Calendar
 Tasks are a separate product/API surface, and appointment schedules should use
 booking links or availability workflows instead.
@@ -225,6 +239,12 @@ pnpm action update-event --id google-event-id --attendees "alice@example.com" --
 pnpm action update-event --id google-event-id --addGoogleMeet=true
 pnpm action update-event --id google-event-id --addZoom=true
 
+# Update an existing working-location event's native metadata
+pnpm action update-event \
+  --id google-working-location-id \
+  --workingLocationType officeLocation \
+  --workingLocationLabel "Pier 57"
+
 # Add multiple alerts, a Google event color, and an attachment
 pnpm action update-event \
   --id google-event-id \
@@ -237,6 +257,15 @@ pnpm action update-event \
 
 For "add Zoom to this meeting", fetch or use the visible event id and call `update-event --addZoom=true`. Do not create an extension for Zoom; Zoom is a first-party calendar integration handled by the event actions and the Settings page.
 
+Google Calendar does not allow changing an existing event's `eventType`; use
+`workingLocationType` and `workingLocationLabel` only on events that already
+have `eventType: "workingLocation"`.
+
+Google Calendar API v3 currently documents working locations on Events, but the
+Settings API/discovery document does not expose working-hours settings. Treat
+working-hours overlays or Find a Time constraints as a follow-up only after a
+real provider data path exists.
+
 For recurring events, pass a Google Calendar RRULE in `--recurrence`. Example: to make a daily event weekdays only, use:
 
 ```bash

package/corpus/templates/calendar/AGENTS.md

@@ -37,6 +37,17 @@ Detailed event, availability, booking, storage, and UI rules live in
   with `stageAs` and analyze them with `query-staged-dataset`.
 - For Google Calendar, distinguish an empty calendar from missing auth,
   reauth-needed, or fetch failures.
+- Google Calendar working locations are status events (`eventType:
+"workingLocation"`). Sync and display them as working locations, keep them
+  transparent/non-blocking, and preserve `workingLocationProperties` instead of
+  treating the summary as a generic all-day event title.
+- When updating one visible occurrence in a recurring working-location series,
+  pass that occurrence's event `id` with `scope: "single"` by default. Use the
+  series scope only when the user explicitly chooses all days.
+- Google Calendar API v3 exposes working locations through Events. The current
+  Settings API and Calendar v3 discovery document do not expose working-hours
+  settings, so do not promise working-hours UI or overlays unless a real
+  provider data path has been verified first.
 - Use framework sharing actions for calendars/events/booking resources when
   applicable.
 - Booking-link sharing controls who can manage the link. Public booking access

package/corpus/templates/calendar/README.md

@@ -13,7 +13,8 @@ the agent can do through the same actions.
 ## Features
 
 - Day, week, and month views with multiple Google accounts overlayed.
-- Google Calendar sync and read-only ICS feed subscriptions.
+- Google Calendar sync, native working locations, and read-only ICS feed
+  subscriptions.
 - Weekly availability with timezone support for slot-finding.
 - Calendly-style public booking links at `/book/{slug}` with custom fields.
 - Ask the agent anything schedule-related, from "am I free Thursday?" to

package/corpus/templates/calendar/actions/create-event.ts

@@ -24,6 +24,7 @@ import {
   reminderMethodInput,
   reminderMinutesInput,
   remindersInput,
+  validateStatusEventTiming,
   visibilityInput,
   workingLocationTypeInput,
 } from "./event-action-helpers.js";
@@ -116,12 +117,12 @@ export default defineAction({
     if (args.addGoogleMeet && args.addZoom) {
       throw new Error("Choose either Google Meet or Zoom, not both.");
     }
-    if (
-      (args.eventType === "outOfOffice" || args.eventType === "focusTime") &&
-      args.allDay === true
-    ) {
-      throw new Error("Out of office and focus time events must be timed.");
-    }
+    validateStatusEventTiming({
+      eventType: args.eventType,
+      allDay: args.allDay,
+      start: args.start,
+      end: args.end,
+    });
 
     if (!(await googleCalendar.isConnected(email))) {
       throw new Error(

package/corpus/templates/calendar/actions/event-action-helpers.ts

@@ -303,3 +303,52 @@ export function buildStatusEventFields(args: {
           : { type, customLocation: { label } },
   };
 }
+
+function allDayDatePart(value: string): string {
+  const dateOnlyPattern = /^\d{4}-\d{2}-\d{2}$/;
+  if (dateOnlyPattern.test(value)) return value;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(
+      "All-day status events must use valid date or datetime start and end values.",
+    );
+  }
+  return date.toISOString().slice(0, 10);
+}
+
+function allDaySpanDays(start: string, end: string): number {
+  const startDate = allDayDatePart(start);
+  const endDate = allDayDatePart(end);
+  const startMs = Date.UTC(
+    Number(startDate.slice(0, 4)),
+    Number(startDate.slice(5, 7)) - 1,
+    Number(startDate.slice(8, 10)),
+  );
+  const endMs = Date.UTC(
+    Number(endDate.slice(0, 4)),
+    Number(endDate.slice(5, 7)) - 1,
+    Number(endDate.slice(8, 10)),
+  );
+  return Math.round((endMs - startMs) / 86_400_000);
+}
+
+export function validateStatusEventTiming(args: {
+  eventType?: "default" | "outOfOffice" | "focusTime" | "workingLocation";
+  allDay?: boolean;
+  start: string;
+  end: string;
+}) {
+  if (
+    (args.eventType === "outOfOffice" || args.eventType === "focusTime") &&
+    args.allDay === true
+  ) {
+    throw new Error("Out of office and focus time events must be timed.");
+  }
+
+  if (args.eventType === "workingLocation" && args.allDay === true) {
+    const days = allDaySpanDays(args.start, args.end);
+    if (days !== 1) {
+      throw new Error("All-day working location events must be a single day.");
+    }
+  }
+}