@agent-native/core 0.131.9 → 0.132.0

package/src/server/poll.ts

@@ -442,6 +442,12 @@ export class AppSyncState {
   private lastExtensionsUpdatedAt: string | number | undefined;
   private lastExtensionMarkerTs = 0;
   private lastActionMarkerTs = 0;
+  /**
+   * Set by the seed when a durable action marker predates this process, so the
+   * first `doCheckExternalDbChanges` reads the marker rows even though the
+   * MAX(updated_at) probe cannot distinguish that row from the seeded max.
+   */
+  private replayActionMarkerOnce = false;
 
   /**
    * Tracks the latest updated_at seen on the `__screen_refresh__` key.
@@ -1355,6 +1361,7 @@ export class AppSyncState {
       // performed by a separate action process. Do not baseline past an existing
       // marker on cold start, or the first poll after the action will miss it.
       this.lastActionMarkerTs = 0;
+      this.replayActionMarkerOnce = actionMarkerTs > 0;
       this.lastScreenRefreshTs = refreshTs;
       this.lastScreenRefreshTsBySession.clear();
       for (const row of refreshResult.rows) {
@@ -1416,28 +1423,54 @@ export class AppSyncState {
       // concurrently to shave stacked latency; results are still processed in
       // the original sequential order, and conditional follow-up queries stay
       // sequential within their branch.
+      //
+      // `lastAppStateTs` is maintained as MAX(updated_at) over the whole
+      // `application_state` table (seeded in `seedVersionFromDb`, advanced by
+      // the scan below over every key, not just the ones that emit events).
+      // The application-state row scan and screen/extension marker reads only
+      // report rows strictly newer than a watermark that is itself <=
+      // `lastAppStateTs`, so an unadvanced MAX proves those reads are no-ops.
+      // The action marker keeps its own max probe because its watermark must
+      // remain independent under cross-process clock skew.
       const [
-        appResult,
+        appStateMaxTs,
         actionMarkerTs,
-        refreshResult,
-        extensionMarkerTs,
         settingsTs,
         extensionsMaxUpdatedAt,
       ] = await Promise.all([
-        db.execute({
-          sql: "SELECT session_id, key, updated_at FROM application_state WHERE updated_at > ? ORDER BY updated_at ASC",
-          args: [this.lastAppStateTs],
-        }),
+        readMaxUpdatedAt(db, "application_state"),
         readActionMarkerMaxUpdatedAt(db),
-        db.execute({
-          sql: "SELECT session_id, updated_at, value FROM application_state WHERE key = ?",
-          args: [SCREEN_REFRESH_KEY],
-        }),
-        readExtensionMarkerMaxUpdatedAt(db),
         readMaxUpdatedAt(db, "settings"),
         readMaxUpdatedAtRaw(db, "tools"),
       ]);
 
+      // The seed deliberately rewinds `lastActionMarkerTs` to 0 so a marker
+      // written before this process booted still reaches the first poll. That
+      // replay is invisible to the MAX probe (the row is already counted in the
+      // seeded max), so it gets one forced full read.
+      const replayActionMarker = this.replayActionMarkerOnce;
+      this.replayActionMarkerOnce = false;
+      const appStateChanged =
+        appStateMaxTs > this.lastAppStateTs || replayActionMarker;
+
+      const [appResult, refreshResult, extensionMarkerTs] = appStateChanged
+        ? await Promise.all([
+            db.execute({
+              sql: "SELECT session_id, key, updated_at FROM application_state WHERE updated_at > ? ORDER BY updated_at ASC",
+              args: [this.lastAppStateTs],
+            }),
+            db.execute({
+              sql: "SELECT session_id, updated_at, value FROM application_state WHERE key = ?",
+              args: [SCREEN_REFRESH_KEY],
+            }),
+            readExtensionMarkerMaxUpdatedAt(db),
+          ])
+        : ([
+            { rows: [] as Record<string, unknown>[] },
+            null,
+            this.lastExtensionMarkerTs,
+          ] as const);
+
       // Check application_state for external writes. Preserve the changed key so
       // clients can invalidate one-shot command queries (`navigate`, `__set_url__`)
       // only when those command rows actually change; noisy keys such as
@@ -1497,54 +1530,59 @@ export class AppSyncState {
       // tool writes to application_state under a well-known key; when its
       // updated_at bumps, emit a distinct event so the client invalidates
       // all queries (not just the ones matching its default queryKey prefix).
-      const refreshTs = refreshResult.rows.reduce(
-        (max, row) => Math.max(max, timestampValue(row.updated_at)),
-        0,
-      );
-      if (!this.screenRefreshInitialized) {
-        this.lastScreenRefreshTs = refreshTs;
-        for (const row of refreshResult.rows) {
-          if (typeof row.session_id === "string") {
-            this.lastScreenRefreshTsBySession.set(
-              row.session_id,
-              timestampValue(row.updated_at),
-            );
-          }
-        }
-        this.screenRefreshInitialized = true;
-      } else if (refreshTs > this.lastScreenRefreshTs) {
-        // Emit a per-user event only for the session(s) whose row actually
-        // advanced, scoped with `owner` so canSeeChangeForUser delivers it only
-        // to that user — not every authenticated poller.
-        for (const row of refreshResult.rows) {
-          const owner =
-            typeof row.session_id === "string" ? row.session_id : undefined;
-          if (!owner) continue;
-          const rowTs = timestampValue(row.updated_at);
-          if (rowTs <= (this.lastScreenRefreshTsBySession.get(owner) ?? 0)) {
-            continue;
+      // `refreshResult` is null exactly when the MAX probe proved no
+      // application_state row moved, which is also exactly when this block
+      // could not emit anything.
+      if (refreshResult) {
+        const refreshTs = refreshResult.rows.reduce(
+          (max, row) => Math.max(max, timestampValue(row.updated_at)),
+          0,
+        );
+        if (!this.screenRefreshInitialized) {
+          this.lastScreenRefreshTs = refreshTs;
+          for (const row of refreshResult.rows) {
+            if (typeof row.session_id === "string") {
+              this.lastScreenRefreshTsBySession.set(
+                row.session_id,
+                timestampValue(row.updated_at),
+              );
+            }
           }
-          let scope: string | undefined;
-          try {
-            const raw = row.value;
-            if (typeof raw === "string") {
-              const parsed = JSON.parse(raw);
-              if (typeof parsed?.scope === "string") scope = parsed.scope;
+          this.screenRefreshInitialized = true;
+        } else if (refreshTs > this.lastScreenRefreshTs) {
+          // Emit a per-user event only for the session(s) whose row actually
+          // advanced, scoped with `owner` so canSeeChangeForUser delivers it only
+          // to that user — not every authenticated poller.
+          for (const row of refreshResult.rows) {
+            const owner =
+              typeof row.session_id === "string" ? row.session_id : undefined;
+            if (!owner) continue;
+            const rowTs = timestampValue(row.updated_at);
+            if (rowTs <= (this.lastScreenRefreshTsBySession.get(owner) ?? 0)) {
+              continue;
             }
-          } catch {}
-          this.recordChange(
-            {
-              source: "screen-refresh",
-              type: "change",
-              key: SCREEN_REFRESH_KEY,
-              owner,
-              ...(scope ? { scope } : {}),
-            },
-            { dedupeKey: `screen-refresh|${rowTs}` },
-          );
-          this.lastScreenRefreshTsBySession.set(owner, rowTs);
+            let scope: string | undefined;
+            try {
+              const raw = row.value;
+              if (typeof raw === "string") {
+                const parsed = JSON.parse(raw);
+                if (typeof parsed?.scope === "string") scope = parsed.scope;
+              }
+            } catch {}
+            this.recordChange(
+              {
+                source: "screen-refresh",
+                type: "change",
+                key: SCREEN_REFRESH_KEY,
+                owner,
+                ...(scope ? { scope } : {}),
+              },
+              { dedupeKey: `screen-refresh|${rowTs}` },
+            );
+            this.lastScreenRefreshTsBySession.set(owner, rowTs);
+          }
+          this.lastScreenRefreshTs = refreshTs;
         }
-        this.lastScreenRefreshTs = refreshTs;
       }
 
       // Extension mutations write a durable marker row so delete and hide/unhide

package/src/server/voice-providers-status.ts

@@ -22,6 +22,7 @@ import {
 import { getOrgContext } from "../org/context.js";
 import { getSession } from "./auth.js";
 import {
+  prefetchSecrets,
   resolveHasCompleteBuilderConnection,
   resolveSecret,
 } from "./credential-provider.js";
@@ -74,10 +75,14 @@ export function createVoiceProvidersStatusHandler() {
     async function hasKey(key: string): Promise<boolean> {
       try {
         if (key === "GOOGLE_APPLICATION_CREDENTIALS") {
-          const resolved = await resolveGoogleRealtimeCredentials({
-            userEmail: session?.email,
-            orgId: orgCtx?.orgId ?? undefined,
-          });
+          // Same identity, passed explicitly — the context is here only so this
+          // scope sweep shares the prefetched per-request memo below.
+          const resolved = await withRequestContext(() =>
+            resolveGoogleRealtimeCredentials({
+              userEmail: session?.email,
+              orgId: orgCtx?.orgId ?? undefined,
+            }),
+          );
           return typeof resolved === "string" && resolved.length > 0;
         }
         const resolved = await withRequestContext(() => resolveSecret(key));
@@ -87,6 +92,16 @@ export function createVoiceProvidersStatusHandler() {
       }
     }
 
+    // One read per scope for every key below, instead of one per key per scope.
+    await withRequestContext(() =>
+      prefetchSecrets([
+        "GEMINI_API_KEY",
+        "OPENAI_API_KEY",
+        "GROQ_API_KEY",
+        "GOOGLE_APPLICATION_CREDENTIALS",
+      ]),
+    );
+
     let builder = false;
     try {
       builder =