@agent-native/core 0.102.1 → 0.102.2

package/corpus/README.md

@@ -27,5 +27,5 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- core files: 2258
-- template files: 5964
+- core files: 2259
+- template files: 5982

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @agent-native/core
 
+## 0.102.2
+
+### Patch Changes
+
+- 76a9cca: Improve MCP connection status and make provider connection errors actionable.
+- 76a9cca: Keep queued chat follow-ups draining after fast turns and route cross-origin Assets pickers through a top-level sign-in-safe handoff.
+- 76a9cca: Recover the Agent panel when a stale lazy-loaded chat chunk fails to load.
+- 76a9cca: Keep the Builder source-change handoff card visible outside the collapsed chat work summary.
+
 ## 0.102.1
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.102.1",
+  "version": "0.102.2",
   "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/client/AgentPanel.tsx

@@ -110,6 +110,7 @@ import type {
   MultiTabAssistantChatHeaderProps,
   MultiTabAssistantChatProps,
 } from "./MultiTabAssistantChat.js";
+import { recoverFromStaleChunkError } from "./route-chunk-recovery.js";
 import { AgentNativeRouteWarmup } from "./route-warmup.js";
 import { withBuilderConnectTrackingParams } from "./settings/useBuilderStatus.js";
 import { useScreenRefreshKey } from "./use-db-sync.js";
@@ -2371,6 +2372,12 @@ class AgentPanelErrorBoundary extends React.Component<
   }
 
   componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
+    if (recoverFromStaleChunkError(error)) {
+      console.warn(
+        "[agent-native] Recovering agent panel after stale chunk error",
+      );
+      return;
+    }
     const recoverableKind = assistantUiRecoverableRenderErrorKind(error);
     if (recoverableKind) {
       console.warn(

package/corpus/core/src/client/AssistantChat.tsx

@@ -2354,6 +2354,11 @@ const AssistantChatInner = forwardRef<
   } | null>(null);
   const [authSessionAvailable, setAuthSessionAvailable] = useState(false);
   const [queuedMessages, setQueuedMessages] = useState<QueuedMessage[]>([]);
+  // The dequeue guard briefly stays locked after appending a queued turn so
+  // the adapter has time to claim the run. Wake the effect when that guard
+  // expires; otherwise a fast-completing turn can leave the remaining queue
+  // pending with no state transition left to trigger another dequeue.
+  const [queueWakeVersion, setQueueWakeVersion] = useState(0);
   const queuedMessagesRef = useRef<QueuedMessage[]>([]);
   const queueDirtyRef = useRef(false);
   const queueMutationVersionRef = useRef(0);
@@ -4041,6 +4046,7 @@ const AssistantChatInner = forwardRef<
           if (appended) {
             window.setTimeout(() => {
               dequeueInFlightRef.current = false;
+              setQueueWakeVersion((version) => version + 1);
             }, 500);
           } else {
             dequeueInFlightRef.current = false;
@@ -4062,6 +4068,7 @@ const AssistantChatInner = forwardRef<
     applyLocalQueuedMessages,
     isRestoring,
     isRunning,
+    queueWakeVersion,
     queuedMessages,
     threadId,
   ]);

package/corpus/core/src/client/agent-chat-adapter.ts

@@ -3392,7 +3392,13 @@ export function createAgentChatAdapter(
                   text: formatChatErrorText(
                     message,
                     preservedError?.upgradeUrl,
-                    errorCode,
+                    // `message` is already user-facing here: either a
+                    // recovery-specific explanation from exhaustedRecoveryMessage
+                    // or a normalized gateway message from errorInfo. Passing
+                    // the fallback connection_error code back through the
+                    // formatter would replace the useful recovery guidance
+                    // with the generic interruption copy.
+                    preservedError ? errorCode : undefined,
                   ),
                 });
                 yield {

package/corpus/core/src/client/chat/message-components.tsx

@@ -909,10 +909,24 @@ function ReasoningMessagePart() {
   );
 }
 
+const ALWAYS_VISIBLE_ASSISTANT_TOOLS = new Set(["connect-builder"]);
+
+export function isCollapsibleAssistantWorkPart(part: {
+  type?: string;
+  toolName?: string;
+}): boolean {
+  if (part.type === "reasoning") return true;
+  return (
+    part.type === "tool-call" &&
+    !ALWAYS_VISIBLE_ASSISTANT_TOOLS.has(part.toolName ?? "")
+  );
+}
+
 function groupAssistantWorkParts(part: {
   type?: string;
+  toolName?: string;
 }): ["group-work"] | null {
-  if (part.type === "reasoning" || part.type === "tool-call") {
+  if (isCollapsibleAssistantWorkPart(part)) {
     return ["group-work"];
   }
   return null;
@@ -1044,8 +1058,8 @@ export function AssistantMessage() {
     Array.isArray(msgContent) &&
     msgContent.some(
       (p) =>
-        p.type === "reasoning" ||
-        (p.type === "tool-call" && p.activity !== true),
+        (p.type !== "tool-call" || p.activity !== true) &&
+        isCollapsibleAssistantWorkPart(p),
     );
 
   if (!hasRenderableContent) return null;

package/corpus/core/src/client/composer/ComposerPlusMenu.tsx

@@ -42,6 +42,11 @@ import {
   type McpServerScope,
 } from "../resources/use-mcp-servers.js";
 import { cn } from "../utils.js";
+import {
+  createAssetPickerHandoffId,
+  isExternalAssetPickerUrl,
+  standaloneAssetPickerUrl,
+} from "./asset-picker-url.js";
 import type { ComposerMode } from "./types.js";
 
 interface ComposerPlusMenuProps {
@@ -73,6 +78,7 @@ interface EmbedEnvelope<TPayload = unknown> {
 
 interface AssetPickerPayload {
   assetId?: unknown;
+  handoffId?: unknown;
   url?: unknown;
   previewUrl?: unknown;
   downloadUrl?: unknown;
@@ -742,8 +748,31 @@ function AssetsPickerModal({
   onOpenChange: (open: boolean) => void;
 }) {
   const iframeRef = useRef<HTMLIFrameElement | null>(null);
+  const standaloneWindowRef = useRef<Window | null>(null);
   const [pickerReady, setPickerReady] = useState(false);
+  const [standaloneHandoffId, setStandaloneHandoffId] = useState<string | null>(
+    null,
+  );
   const sourceUrl = useMemo(() => assetPickerUrl(), []);
+  const externalPicker = useMemo(
+    () =>
+      typeof window !== "undefined" &&
+      isExternalAssetPickerUrl(sourceUrl, window.location.origin),
+    [sourceUrl],
+  );
+  const standaloneUrl = useMemo(
+    () =>
+      standaloneAssetPickerUrl(
+        sourceUrl,
+        typeof window !== "undefined" ? window.location.href : undefined,
+        {
+          handoffId: standaloneHandoffId ?? undefined,
+          returnOrigin:
+            typeof window !== "undefined" ? window.location.origin : undefined,
+        },
+      ),
+    [sourceUrl, standaloneHandoffId],
+  );
   const iframeUrl = useMemo(() => withEmbeddedParams(sourceUrl), [sourceUrl]);
   const targetOrigin = useMemo(() => assetPickerOrigin(iframeUrl), [iframeUrl]);
   const configurePicker = useCallback(() => {
@@ -758,14 +787,32 @@ function AssetsPickerModal({
   }, [targetOrigin]);
 
   useEffect(() => {
-    if (open) setPickerReady(false);
-  }, [iframeUrl, open]);
+    if (open) {
+      setPickerReady(false);
+      if (externalPicker) {
+        standaloneWindowRef.current = null;
+        setStandaloneHandoffId(createAssetPickerHandoffId());
+      } else {
+        setStandaloneHandoffId(null);
+      }
+      return;
+    }
+    if (!standaloneWindowRef.current) setStandaloneHandoffId(null);
+  }, [externalPicker, iframeUrl, open]);
 
   useEffect(() => {
-    if (!open || !targetOrigin) return;
+    if (
+      !targetOrigin ||
+      (!open && !standaloneWindowRef.current) ||
+      (externalPicker && !standaloneHandoffId)
+    )
+      return;
 
     const handleMessage = (event: MessageEvent) => {
-      if (event.source !== iframeRef.current?.contentWindow) return;
+      const expectedSource = externalPicker
+        ? standaloneWindowRef.current
+        : iframeRef.current?.contentWindow;
+      if (!expectedSource || event.source !== expectedSource) return;
       if (event.origin !== targetOrigin) return;
       if (!isEmbedEnvelope(event.data)) return;
 
@@ -776,6 +823,14 @@ function AssetsPickerModal({
       }
 
       if (event.data.type !== "message") return;
+      if (externalPicker) {
+        const payload = event.data.payload;
+        const handoffId =
+          payload && typeof payload === "object"
+            ? assetString((payload as AssetPickerPayload).handoffId)
+            : null;
+        if (handoffId !== standaloneHandoffId) return;
+      }
       if (event.data.name === "close") {
         onOpenChange(false);
         return;
@@ -798,6 +853,8 @@ function AssetsPickerModal({
         title: `Image: ${title}`,
         context: assetContext(event.data.payload, url),
       });
+      standaloneWindowRef.current = null;
+      setStandaloneHandoffId(null);
       onOpenChange(false);
     };
 
@@ -811,7 +868,26 @@ function AssetsPickerModal({
       window.removeEventListener("message", handleMessage);
       window.removeEventListener("keydown", handleKey);
     };
-  }, [configurePicker, onOpenChange, open, targetOrigin]);
+  }, [
+    configurePicker,
+    externalPicker,
+    onOpenChange,
+    open,
+    standaloneHandoffId,
+    targetOrigin,
+  ]);
+
+  const openStandalonePicker = useCallback(
+    (event: React.MouseEvent<HTMLAnchorElement>) => {
+      if (!standaloneHandoffId) return;
+      event.preventDefault();
+      const pickerWindow = window.open(standaloneUrl, "_blank");
+      if (!pickerWindow) return;
+      standaloneWindowRef.current = pickerWindow;
+      onOpenChange(false);
+    },
+    [onOpenChange, standaloneHandoffId, standaloneUrl],
+  );
 
   if (!open || typeof document === "undefined") return null;
 
@@ -842,7 +918,21 @@ function AssetsPickerModal({
             <IconX className="h-4 w-4" />
           </button>
         </div>
-        {targetOrigin ? (
+        {externalPicker ? (
+          <div className="flex min-h-0 flex-1 flex-col items-center justify-center gap-3 p-8 text-center">
+            <div className="max-w-md text-sm text-muted-foreground">
+              Open Assets in a new tab to sign in and choose an image securely.
+            </div>
+            <a
+              href={standaloneUrl}
+              target="_blank"
+              onClick={openStandalonePicker}
+              className="inline-flex h-9 items-center justify-center rounded-md bg-primary px-4 text-sm font-medium text-primary-foreground hover:bg-primary/90"
+            >
+              Open Assets image picker
+            </a>
+          </div>
+        ) : targetOrigin ? (
           <div className="relative min-h-0 flex-1 overflow-hidden bg-background">
             {!pickerReady && <AssetsPickerLoadingSkeleton />}
             <iframe

package/corpus/core/src/client/composer/asset-picker-url.ts

@@ -0,0 +1,80 @@
+const FALLBACK_BASE_URL = "http://agent-native.invalid";
+
+export const ASSET_PICKER_HANDOFF_PARAM = "__an_asset_picker_handoff";
+export const ASSET_PICKER_RETURN_ORIGIN_PARAM =
+  "__an_asset_picker_return_origin";
+
+export interface StandaloneAssetPickerOptions {
+  handoffId?: string;
+  returnOrigin?: string;
+}
+
+export function createAssetPickerHandoffId(): string {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join(
+      "",
+    );
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+
+/**
+ * Cross-origin Assets pages cannot inherit the host app's authenticated
+ * session inside an iframe. Treat those URLs as link-out targets so provider
+ * sign-in runs in a normal top-level browser context.
+ */
+export function isExternalAssetPickerUrl(
+  value: string,
+  currentOrigin: string,
+): boolean {
+  try {
+    return new URL(value, currentOrigin).origin !== currentOrigin;
+  } catch {
+    // A malformed configured URL should fail closed instead of being loaded in
+    // an iframe with an unknown auth boundary.
+    return true;
+  }
+}
+
+/** Build a top-level picker URL without iframe-only auth flags. */
+export function standaloneAssetPickerUrl(
+  value: string,
+  baseUrl = FALLBACK_BASE_URL,
+  options: StandaloneAssetPickerOptions = {},
+): string {
+  try {
+    const parsed = new URL(value, baseUrl);
+    parsed.searchParams.delete("embedded");
+    parsed.searchParams.delete("__an_embed_token");
+    parsed.searchParams.set("mediaType", "image");
+    let returnOrigin: string | null = null;
+    if (options.returnOrigin) {
+      try {
+        const parsedOrigin = new URL(options.returnOrigin);
+        if (
+          parsedOrigin.protocol === "http:" ||
+          parsedOrigin.protocol === "https:"
+        ) {
+          returnOrigin = parsedOrigin.origin;
+        }
+      } catch {
+        // Omit an invalid return target rather than emitting an unverified
+        // cross-origin callback URL.
+      }
+    }
+    if (options.handoffId && returnOrigin) {
+      parsed.searchParams.set(ASSET_PICKER_HANDOFF_PARAM, options.handoffId);
+      parsed.searchParams.set(ASSET_PICKER_RETURN_ORIGIN_PARAM, returnOrigin);
+    } else {
+      parsed.searchParams.delete(ASSET_PICKER_HANDOFF_PARAM);
+      parsed.searchParams.delete(ASSET_PICKER_RETURN_ORIGIN_PARAM);
+    }
+    return parsed.toString();
+  } catch {
+    return value;
+  }
+}

package/corpus/core/src/client/error-format.ts

@@ -102,6 +102,18 @@ function isProviderAuthenticationError(
   );
 }
 
+function isConnectionError(text: string, errorCode?: string): boolean {
+  const code = normalizeErrorCode(errorCode);
+  return (
+    code === "provider_network_error" ||
+    code === "connection_error" ||
+    code === "network_error" ||
+    /^(?:provider_network_error|connection_error|network_error)$/i.test(
+      text.trim(),
+    )
+  );
+}
+
 export function normalizeChatError(
   errorMessage: string,
   errorCode?: string,
@@ -126,6 +138,18 @@ export function normalizeChatError(
     };
   }
 
+  if (isConnectionError(text, errorCode)) {
+    const providerNetworkError =
+      normalizeErrorCode(errorCode) === "provider_network_error" ||
+      /provider_network_error/i.test(text);
+    return {
+      message: providerNetworkError
+        ? "The model provider could not be reached. Check your connection and retry."
+        : "The agent connection was interrupted. Check your connection and retry.",
+      details: text,
+    };
+  }
+
   if (/^Gateway error \(no detail; raw event:/i.test(text)) {
     // The previous copy promised auto-recovery and suggested switching models,
     // but neither helps for this code: the server already retried once and

package/corpus/core/src/client/resources/McpIntegrationDialog.tsx

@@ -115,7 +115,14 @@ export function McpIntegrationDialog({
       ...(mcpServersQuery.data?.user ?? []),
       ...(mcpServersQuery.data?.org ?? []),
     ];
-    return new Set(servers.map((server) => compareUrl(server.url)));
+    // A saved server is not necessarily a working connection. The settings
+    // page reports failed and unknown health states separately, so only mark
+    // catalog entries as connected after the health probe succeeds.
+    return new Set(
+      servers
+        .filter((server) => server.status.state === "connected")
+        .map((server) => compareUrl(server.url)),
+    );
   }, [mcpServersQuery.data]);
 
   const filteredIntegrations = useMemo(

package/corpus/templates/assets/app/routes/library.tsx

@@ -16,6 +16,8 @@ import {
   writeClientAppState,
 } from "@agent-native/core/client";
 import {
+  AGENT_NATIVE_EMBED_MESSAGE_TYPES,
+  createAgentNativeEmbedEnvelope,
   createEmbeddedAppBridge,
   type EmbeddedAppBridge,
 } from "@agent-native/core/embedding";
@@ -244,6 +246,31 @@ function isEmbeddedWindow() {
   }
 }
 
+interface StandalonePickerHandoff {
+  handoffId: string;
+  returnOrigin: string;
+}
+
+function standalonePickerHandoff(): StandalonePickerHandoff | null {
+  if (typeof window === "undefined") return null;
+  const params = new URLSearchParams(window.location.search);
+  const handoffId = params.get("__an_asset_picker_handoff")?.trim();
+  const rawReturnOrigin = params.get("__an_asset_picker_return_origin")?.trim();
+  if (!handoffId || handoffId.length > 128 || !rawReturnOrigin) return null;
+  try {
+    const parsed = new URL(rawReturnOrigin);
+    if (
+      (parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
+      parsed.origin !== rawReturnOrigin
+    ) {
+      return null;
+    }
+    return { handoffId, returnOrigin: parsed.origin };
+  } catch {
+    return null;
+  }
+}
+
 function normalizeCount(value: unknown): number {
   if (value === null || value === undefined || value === "") return 3;
   const count = Number(value);
@@ -2206,6 +2233,10 @@ export function AssetPickerSurface() {
       isEmbedAuthActive(),
     [searchParams],
   );
+  const standaloneHandoff = useMemo(
+    () => (embedded ? null : standalonePickerHandoff()),
+    [embedded],
+  );
   const pickerVariantScopeId = useMemo(
     () =>
       typeof window === "undefined" ? null : `picker:${getBrowserTabId()}`,
@@ -2552,6 +2583,35 @@ export function AssetPickerSurface() {
     [],
   );
 
+  const postStandaloneSelectionMessage = useCallback(
+    (payload: ReturnType<typeof assetPayload>) => {
+      if (
+        !standaloneHandoff ||
+        typeof window === "undefined" ||
+        !window.opener ||
+        window.opener.closed
+      ) {
+        return false;
+      }
+      try {
+        window.opener.postMessage(
+          createAgentNativeEmbedEnvelope(
+            AGENT_NATIVE_EMBED_MESSAGE_TYPES.MESSAGE,
+            {
+              name: "chooseAsset",
+              payload: { ...payload, handoffId: standaloneHandoff.handoffId },
+            },
+          ),
+          standaloneHandoff.returnOrigin,
+        );
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    [standaloneHandoff],
+  );
+
   const chooseAsset = (asset: Asset) => {
     const payload = assetPayload(asset, mediaType);
     if (embedded) {
@@ -2574,6 +2634,15 @@ export function AssetPickerSurface() {
       });
       return;
     }
+    if (postStandaloneSelectionMessage(payload)) {
+      toast.success(
+        t("assetPicker.selectedAsset", {
+          title: selectedAssetLabel(payload),
+        }),
+      );
+      window.setTimeout(() => window.close(), 0);
+      return;
+    }
     setStandaloneSelection(payload);
     setStandaloneCopyOk(false);
     void copyStandaloneSelection(payload);

package/corpus/templates/assets/changelog/2026-07-15-fixed-top-level-image-picker-selections-returning-to-the-com.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-15
+---
+
+Fixed top-level image picker selections returning to the composer

package/corpus/templates/clips/actions/disconnect-calendar.ts

@@ -13,10 +13,11 @@ import { writeAppState } from "@agent-native/core/application-state";
 import { deleteAppSecret, readAppSecret } from "@agent-native/core/secrets";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { and, eq, inArray, isNull, or } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { lockCalendarAccount } from "../server/lib/calendar-event-meetings.js";
 import { revokeToken } from "../server/lib/google-calendar-client.js";
 
 export default defineAction({
@@ -90,15 +91,62 @@ export default defineAction({
       }).catch(() => {});
     }
 
-    // Drop the synced events for this account so the meetings tab clears.
-    await db
-      .delete(schema.calendarEvents)
-      .where(eq(schema.calendarEvents.calendarAccountId, args.id));
+    await db.transaction(async (tx) => {
+      // Materialization takes this same account-row write lock before it
+      // snapshots/claims an event and inserts a meeting. Taking it before
+      // this cleanup snapshot prevents a new unrecorded meeting from being
+      // inserted after the rows below have been inspected.
+      if (!(await lockCalendarAccount(tx, args.id, account.ownerEmail))) {
+        throw new Error(`Calendar account not found: ${args.id}`);
+      }
 
-    // Drop the account row itself.
-    await db
-      .delete(schema.calendarAccounts)
-      .where(eq(schema.calendarAccounts.id, args.id));
+      // Preserve recorded meetings, but hide unrecorded calendar placeholders
+      // tied to this account. Without this cleanup, those materialized rows
+      // stay visible after the account and its event cache are removed.
+      const syncedEvents = await tx
+        .select({
+          id: schema.calendarEvents.id,
+          meetingId: schema.calendarEvents.meetingId,
+        })
+        .from(schema.calendarEvents)
+        .where(eq(schema.calendarEvents.calendarAccountId, args.id));
+      const syncedCalendarEventIds = syncedEvents.map((event) => event.id);
+      const syncedMeetingIds = syncedEvents
+        .map((event) => event.meetingId)
+        .filter((meetingId): meetingId is string => Boolean(meetingId));
+      if (syncedCalendarEventIds.length > 0 || syncedMeetingIds.length > 0) {
+        await tx
+          .update(schema.meetings)
+          .set({ trashedAt: new Date().toISOString() })
+          .where(
+            and(
+              or(
+                syncedMeetingIds.length > 0
+                  ? inArray(schema.meetings.id, syncedMeetingIds)
+                  : undefined,
+                syncedCalendarEventIds.length > 0
+                  ? inArray(
+                      schema.meetings.calendarEventId,
+                      syncedCalendarEventIds,
+                    )
+                  : undefined,
+              )!,
+              isNull(schema.meetings.recordingId),
+              isNull(schema.meetings.trashedAt),
+            ),
+          );
+      }
+
+      // Drop the synced events for this account so the meetings tab clears.
+      await tx
+        .delete(schema.calendarEvents)
+        .where(eq(schema.calendarEvents.calendarAccountId, args.id));
+
+      // Drop the account row itself.
+      await tx
+        .delete(schema.calendarAccounts)
+        .where(eq(schema.calendarAccounts.id, args.id));
+    });
 
     await writeAppState("refresh-signal", { ts: Date.now() });
     return { id: args.id, disconnected: true };