@agent-native/core 0.161.10 → 0.161.14

package/dist/mcp/embed-app.js

@@ -47,6 +47,8 @@ export function embedApp(options = {}) {
     iframe { display: block; width: 100%; height: var(--agent-native-viewport-height); border: 0; background: Canvas; }
     .message { display: grid; place-items: center; min-height: var(--agent-native-viewport-height); padding: 18px; color: color-mix(in srgb, CanvasText 62%, Canvas); font-size: 13px; line-height: 1.45; text-align: center; }
     .fallback { display: grid; align-content: center; justify-items: center; gap: 12px; min-height: var(--agent-native-viewport-height); padding: 24px; background: Canvas; color: CanvasText; text-align: center; }
+    .fallback-overlay { position: absolute; inset: 0; z-index: 2; display: grid; align-items: start; justify-items: end; padding: 12px; pointer-events: none; }
+    .fallback-overlay .fallback { width: min(100%, 560px); min-height: 0; border: 1px solid color-mix(in srgb, CanvasText 18%, Canvas); border-radius: 9px; background: color-mix(in srgb, Canvas 96%, transparent); box-shadow: 0 8px 24px color-mix(in srgb, CanvasText 16%, transparent); pointer-events: auto; }
     .fallback-title { max-width: 440px; font-size: 14px; font-weight: 700; }
     .fallback-copy { max-width: 520px; color: color-mix(in srgb, CanvasText 64%, Canvas); font-size: 13px; line-height: 1.45; }
     .fallback-actions { display: flex; flex-wrap: wrap; align-items: center; justify-content: center; gap: 8px; }
@@ -1073,14 +1075,64 @@ export function embedApp(options = {}) {
       } catch {}
     }
 
+    function clearFallbackOverlay() {
+      stage.querySelector("[data-fallback-overlay]")?.remove();
+    }
+
+    function renderFallbackOverlay({ title, copyHtml, retryLabel, onRetry }) {
+      if (!appFrame || appFrame.parentElement !== stage) return false;
+      clearFallbackOverlay();
+      const overlay = document.createElement("div");
+      overlay.className = "fallback-overlay";
+      overlay.dataset.fallbackOverlay = "1";
+      overlay.innerHTML =
+        '<div class="fallback">' +
+          '<div class="fallback-title">' + esc(title) + '</div>' +
+          '<div class="fallback-copy">' + copyHtml + '</div>' +
+          '<div class="fallback-actions">' +
+            '<button type="button" class="primary" data-fallback-open>Open in new tab</button>' +
+            '<button type="button" data-fallback-retry>' + esc(retryLabel) + '</button>' +
+          '</div>' +
+          (openUrl ? '<a class="fallback-url" href="' + esc(openUrl) + '" target="_blank" rel="noreferrer">' + esc(openUrl) + '</a>' : '') +
+        '</div>';
+      stage.appendChild(overlay);
+
+      const fallbackOpen = overlay.querySelector("[data-fallback-open]");
+      const fallbackRetry = overlay.querySelector("[data-fallback-retry]");
+      if (fallbackOpen) {
+        fallbackOpen.disabled = !openUrl;
+        fallbackOpen.onclick = () => {
+          if (openUrl) void openFallbackExternal();
+        };
+      }
+      if (fallbackRetry) {
+        fallbackRetry.disabled = typeof onRetry !== "function";
+        fallbackRetry.onclick = () => {
+          if (typeof onRetry === "function") void onRetry();
+        };
+      }
+      return true;
+    }
+
     function renderFrameFallback() {
       clearFrameReadyTimer();
       clearFrameLoadTimer();
-      appFrame = null;
+      appFrameReady = false;
       const fallbackCopy = openUrl
         ? "This chat host did not allow the embedded app frame to load inline. You can still open the same app route through the host or use the URL below."
         : "This chat host did not allow the embedded app frame to load inline.";
       reportEmbedError("frame-fallback", fallbackCopy);
+      if (renderFallbackOverlay({
+        title: "Open this app in its own tab",
+        copyHtml: esc(fallbackCopy),
+        retryLabel: "Try inline again",
+        onRetry: lastFrameSrc
+          ? () => renderFrame(lastFrameSrc)
+          : undefined
+      })) {
+        return;
+      }
+      appFrame = null;
       stage.innerHTML =
         '<div class="fallback">' +
           '<div class="fallback-title">Open this app in its own tab</div>' +
@@ -1110,7 +1162,7 @@ export function embedApp(options = {}) {
     function renderAppLaunchError(message) {
       clearFrameReadyTimer();
       clearFrameLoadTimer();
-      appFrame = null;
+      appFrameReady = false;
       const fallbackCopy = openUrl
         ? "The inline MCP app could not load in this chat host. You can open the same app route in a new tab or retry the inline load."
         : "The inline MCP app could not load in this chat host.";
@@ -1118,6 +1170,18 @@ export function embedApp(options = {}) {
       const copyHtml = message
         ? '<div>' + esc(message) + '</div><div>' + esc(fallbackCopy) + '</div>'
         : esc(fallbackCopy);
+      if (renderFallbackOverlay({
+        title: "App did not load",
+        copyHtml,
+        retryLabel: "Retry",
+        onRetry: () => {
+          startedFor = "";
+          void launchEmbed();
+        }
+      })) {
+        return;
+      }
+      appFrame = null;
       stage.innerHTML =
         '<div class="fallback">' +
           '<div class="fallback-title">App did not load</div>' +
@@ -1178,6 +1242,10 @@ export function embedApp(options = {}) {
         sendFrameReadyMessages(frame);
         startFrameReadyTimer(frame);
       });
+      frame.addEventListener("error", () => {
+        if (appFrame !== frame) return;
+        renderFrameFallback();
+      });
       stage.replaceChildren(frame);
       notifyHostHeight();
       appFrameLoadTimer = setTimeout(() => {
@@ -1475,6 +1543,7 @@ export function embedApp(options = {}) {
       const data = event.data.data || {};
       if (message.type === "agentNative.embeddedAppReady") {
         appFrameReady = true;
+        clearFallbackOverlay();
         embedSessionRefreshAttempts = 0;
         clearFrameLoadTimer();
         clearFrameReadyTimer();

package/dist/notifications/routes.d.ts

@@ -28,6 +28,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

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/secrets/routes.d.ts

@@ -34,37 +34,37 @@ export declare function createListSecretsHandler(): import("h3").EventHandlerWit
 /** POST /_agent-native/secrets/:key — write a secret. */
 export declare function createWriteSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     status: string;
+    error?: undefined;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — validate an optional candidate value
  * or the current stored value without changing anything.
  */
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
     note?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     note?: undefined;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     note: string;
+    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -95,11 +95,11 @@ export interface AdHocSecretPayload {
 export declare function createAdHocSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<AdHocSecretPayload[] | {
     error: string;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;

package/dist/server/poll.d.ts

@@ -23,6 +23,8 @@ import { EventEmitter } from "node:events";
 import { type DbExec } from "../db/client.js";
 export interface ChangeEvent {
     version: number;
+    /** Stable durable-row tie-breaker for events sharing a millisecond version. */
+    cursorId?: string;
     source: string;
     type: string;
     key?: string;
@@ -53,9 +55,15 @@ export interface ChangeEvent {
 }
 export declare const DURABLE_LEGACY_DB_CHECK_INTERVAL_MS = 30000;
 export declare const POLL_CHANGE_EVENT = "poll-change";
+type SyncCursor = {
+    version: number;
+    id: string;
+};
 export type ChangeReadResult = {
     version: number;
     events: ChangeEvent[];
+    /** Composite `(version,id)` cursor for durable rows sharing a version. */
+    cursor?: string;
     /**
      * True when the returned version is an intentional cursor stop, not the
      * source high-water mark. This happens when access is still pending or when a
@@ -143,11 +151,13 @@ export declare class AppSyncState {
     private dbVersionFallbacks;
     private warnedListenerThrow;
     private version;
+    private latestCursor;
     private readonly buffer;
     private readonly pollEmitter;
     private syncEventsInitPromise;
     private lastDurablePrune;
     private durablePruneFailures;
+    private durableWriteFailures;
     /**
      * Whether we've seeded `version` from the DB. In serverless (Netlify,
      * Vercel, etc.) each invocation starts fresh — without seeding, `version`
@@ -175,8 +185,9 @@ export declare class AppSyncState {
      * after a restart (where an existing row would look like a fresh bump).
      */
     private lastScreenRefreshTs;
+    private lastScreenRefreshSessionId;
     private screenRefreshInitialized;
-    private readonly lastScreenRefreshTsBySession;
+    private screenRefreshHasMore;
     private localEmittersWired;
     /**
      * TTL'd access cache for the access-aware branch of `canSeeChangeForUser`,
@@ -232,13 +243,15 @@ export declare class AppSyncState {
      *     `sync_events_created_at_id_idx` drives the batch and the delete is a
      *     bounded index range scan.
      *
-     * The `lastDurablePrune` throttle below is per-process, so every serverless
-     * worker prunes on its first poll. Postgres workers also take a
+     * The `lastDurablePrune` throttle below is per-process and starts at process
+     * initialization, so a cold serverless worker does not run a potentially
+     * large delete during its first request. Postgres workers also take a
      * transaction-scoped advisory lease for each batch. The lease and delete
      * are one bounded statement, so a serverless worker killed after the
      * statement starts cannot leave an open transaction.
      */
     private pruneDurableEvents;
+    private reportDurableWriteFailure;
     persistSyncEvent(event: ChangeEvent, dedupeKey?: string, presetId?: string): Promise<void>;
     /**
      * Persist with a DB-allocated version (see ALLOCATING_INSERT_SQL). Returns
@@ -340,12 +353,9 @@ export declare class AppSyncState {
      * Get changes after a given version, filtered to events the caller is
      * allowed to see.
      */
-    getChangesSinceForUser(since: number, userEmail: string, orgId: string | undefined): ChangeReadResult;
-    getDurableChangesSinceForUser(since: number, userEmail: string, orgId: string | undefined): Promise<ChangeReadResult>;
-    getCombinedChangesSinceForUser(since: number, userEmail: string, orgId: string | undefined, useDurableEvents: boolean): Promise<{
-        version: number;
-        events: ChangeEvent[];
-    }>;
+    getChangesSinceForUser(since: number, userEmail: string, orgId: string | undefined, cursor?: SyncCursor): ChangeReadResult;
+    getDurableChangesSinceForUser(since: number, userEmail: string, orgId: string | undefined, cursor?: SyncCursor): Promise<ChangeReadResult>;
+    getCombinedChangesSinceForUser(since: number, userEmail: string, orgId: string | undefined, useDurableEvents: boolean, cursor?: SyncCursor): Promise<ChangeReadResult>;
     /**
      * Seed `version` from DB timestamps on the first call so serverless cold
      * starts don't return version 0 and confuse polling clients.
@@ -395,7 +405,7 @@ export declare function getChangesSinceForUser(since: number, userEmail: string,
 /**
  * Create an H3 handler for the poll endpoint.
  *
- * GET /_agent-native/poll?since=N → { version, events[] }
+ * GET /_agent-native/poll?since=N[&cursor=N.id] → { version, events[] }
  *
  * Requires an authenticated session. Events are filtered to the caller's
  * tenant — global events (owner-less, table-level pings) reach every
@@ -403,9 +413,7 @@ export declare function getChangesSinceForUser(since: number, userEmail: string,
  * Without auth + filtering, an anonymous attacker could poll the deployment
  * and infer cross-tenant activity from the global event stream.
  */
-export declare function createPollHandler(state?: AppSyncState): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    version: number;
-    events: ChangeEvent[];
-} | {
+export declare function createPollHandler(state?: AppSyncState): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<ChangeReadResult | {
     error: string;
 }>>;
+export {};