@agent-native/core 0.91.2 → 0.92.1

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,11 +27,11 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
-    error?: undefined;
 }>>;
 export {};
 //# sourceMappingURL=agent-engine-api-key-route.d.ts.map

package/dist/server/poll.d.ts

@@ -54,6 +54,16 @@ export declare function invalidateCollabAccessCache(resourceType: string, resour
  * public API — do not rely on it outside tests.
  */
 export declare function __resetCollabAccessCacheForTests(): void;
+type ChangeReadResult = {
+    version: number;
+    events: ChangeEvent[];
+    /**
+     * 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
+     * durable page hit the read limit and more rows may remain unread.
+     */
+    cursorLimited?: boolean;
+};
 /**
  * Decide whether a poll/SSE change event should be delivered to a user.
  *
@@ -102,10 +112,7 @@ export declare function getChangesSince(since: number): {
  *     viewer+ sharees via the access-aware cache in `canSeeChangeForUser`.
  *   - All other owned events are filtered out.
  */
-export declare function getChangesSinceForUser(since: number, userEmail: string, orgId: string | undefined): {
-    version: number;
-    events: ChangeEvent[];
-};
+export declare function getChangesSinceForUser(since: number, userEmail: string, orgId: string | undefined): ChangeReadResult;
 /**
  * Create an H3 handler for the poll endpoint.
  *
@@ -123,4 +130,5 @@ export declare function createPollHandler(): import("h3").EventHandlerWithFetch<
 } | {
     error: string;
 }>>;
+export {};
 //# sourceMappingURL=poll.d.ts.map

package/dist/server/poll.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"poll.d.ts","sourceRoot":"","sources":["../../src/server/poll.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAmB3C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;AAOD,eAAO,MAAM,iBAAiB,gBAAgB,CAAC;AA0I/C,8CAA8C;AAC9C,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,wBAAgB,cAAc,IAAI,YAAY,CAE7C;AAyCD,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACjB,IAAI,CAaN;AA0DD;;;;GAIG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAIvD;AAID;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,OAAO,GAAG,cAAc,GAAG,YAAY,CAAC,EAC3E,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,OAAO,CAET;AAuCD,0DAA0D;AAC1D,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB,GAAG,IAAI,CAWP;AA+GD,6CAA6C;AAC7C,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB,CAMA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,CAmB5C;AA6SD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB;aA3UnB,MAAM;YAAU,WAAW,EAAE;;;IA4V1C"}
+{"version":3,"file":"poll.d.ts","sourceRoot":"","sources":["../../src/server/poll.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAoB3C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;AAWD,eAAO,MAAM,iBAAiB,gBAAgB,CAAC;AAwQ/C,8CAA8C;AAC9C,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,wBAAgB,cAAc,IAAI,YAAY,CAE7C;AAyCD,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACjB,IAAI,CAaN;AA0DD;;;;GAIG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAIvD;AAGD,KAAK,gBAAgB,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,OAAO,GAAG,cAAc,GAAG,YAAY,CAAC,EAC3E,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,OAAO,CAET;AAuCD,0DAA0D;AAC1D,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB,GAAG,IAAI,CAYP;AA+GD,6CAA6C;AAC7C,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB,CAMA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,gBAAgB,CAmBlB;AAobD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB;aAvWX,MAAM;YAAU,WAAW,EAAE;;;IAgYlD"}

package/dist/server/poll.js

@@ -16,18 +16,25 @@ import { EventEmitter } from "node:events";
 import { defineEventHandler, getQuery, setResponseStatus } from "h3";
 import { ACTION_CHANGE_MARKER_KEY, parseActionChangeMarker, } from "../action-change-marker.js";
 import { getAppStateEmitter } from "../application-state/emitter.js";
-import { getDbExec } from "../db/client.js";
+import { getDbExec, isPostgres } from "../db/client.js";
+import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
 import { EXTENSION_CHANGE_MARKER_KEY, parseExtensionChangeMarker, } from "../extensions/change-marker.js";
 import { getSettingsEmitter } from "../settings/store.js";
 import { getSession } from "./auth.js";
 // In-memory ring buffer of recent changes. Kept small since clients
 // poll frequently (every 2-3s) and only need events since their last poll.
 const MAX_BUFFER = 200;
+const DURABLE_READ_LIMIT = 1000;
+const DURABLE_RETENTION_MS = 24 * 60 * 60 * 1000;
+const LEGACY_DB_CHECK_INTERVAL_MS = 1000;
+const DURABLE_LEGACY_DB_CHECK_INTERVAL_MS = 30_000;
 let _version = 0;
 const _buffer = [];
 export const POLL_CHANGE_EVENT = "poll-change";
 const _pollEmitter = new EventEmitter();
 _pollEmitter.setMaxListeners(0);
+let _syncEventsInitPromise;
+let _lastDurablePrune = 0;
 /**
  * Whether we've seeded _version from the DB. In serverless (Netlify,
  * Vercel, etc.) each invocation starts fresh — without seeding, _version
@@ -98,6 +105,115 @@ function sqlWatermarkValue(value) {
         return value;
     return undefined;
 }
+function syncEventsDisabled() {
+    return (process.env.AGENT_NATIVE_SYNC_EVENTS_DISABLE === "1" ||
+        (process.env.VITEST === "true" &&
+            process.env.AGENT_NATIVE_SYNC_EVENTS_ENABLE_IN_TESTS !== "1"));
+}
+async function ensureSyncEventsTable() {
+    if (syncEventsDisabled())
+        return false;
+    if (!_syncEventsInitPromise) {
+        _syncEventsInitPromise = (async () => {
+            const client = getDbExec();
+            const createSql = `
+        CREATE TABLE IF NOT EXISTS sync_events (
+          id TEXT PRIMARY KEY,
+          version BIGINT NOT NULL,
+          event_json TEXT NOT NULL,
+          source TEXT NOT NULL,
+          type TEXT NOT NULL,
+          event_key TEXT,
+          owner TEXT,
+          org_id TEXT,
+          resource_type TEXT,
+          resource_id TEXT,
+          created_at BIGINT NOT NULL
+        )
+      `;
+            if (isPostgres()) {
+                await ensureTableExists("sync_events", createSql);
+                await ensureIndexExists("sync_events_version_idx", "CREATE INDEX IF NOT EXISTS sync_events_version_idx ON sync_events (version)");
+                await ensureIndexExists("sync_events_owner_version_idx", "CREATE INDEX IF NOT EXISTS sync_events_owner_version_idx ON sync_events (owner, version)");
+                await ensureIndexExists("sync_events_org_version_idx", "CREATE INDEX IF NOT EXISTS sync_events_org_version_idx ON sync_events (org_id, version)");
+                return true;
+            }
+            await client.execute(createSql);
+            for (const ddl of [
+                "CREATE INDEX IF NOT EXISTS sync_events_version_idx ON sync_events (version)",
+                "CREATE INDEX IF NOT EXISTS sync_events_owner_version_idx ON sync_events (owner, version)",
+                "CREATE INDEX IF NOT EXISTS sync_events_org_version_idx ON sync_events (org_id, version)",
+            ]) {
+                try {
+                    await client.execute(ddl);
+                }
+                catch {
+                    // Index already exists or the dialect rejected a duplicate.
+                }
+            }
+            return true;
+        })().catch(() => {
+            _syncEventsInitPromise = undefined;
+            return false;
+        });
+    }
+    return _syncEventsInitPromise;
+}
+function durableEventId(version) {
+    return `${version}-${Math.random().toString(36).slice(2, 10)}`;
+}
+async function pruneDurableEvents(client) {
+    const now = Date.now();
+    if (now - _lastDurablePrune < 5 * 60 * 1000)
+        return;
+    _lastDurablePrune = now;
+    await client
+        .execute({
+        sql: "DELETE FROM sync_events WHERE created_at < ?",
+        args: [now - DURABLE_RETENTION_MS],
+    })
+        .catch(() => { });
+}
+async function persistSyncEvent(event) {
+    if (!(await ensureSyncEventsTable()))
+        return;
+    const client = getDbExec();
+    await client
+        .execute({
+        sql: isPostgres()
+            ? `INSERT INTO sync_events (id, version, event_json, source, type, event_key, owner, org_id, resource_type, resource_id, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT (id) DO NOTHING`
+            : `INSERT OR IGNORE INTO sync_events (id, version, event_json, source, type, event_key, owner, org_id, resource_type, resource_id, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+            durableEventId(event.version),
+            event.version,
+            JSON.stringify(event),
+            event.source,
+            event.type,
+            event.key ?? null,
+            event.owner ?? null,
+            event.orgId ?? null,
+            event.resourceType ?? null,
+            event.resourceId ?? null,
+            Date.now(),
+        ],
+    })
+        .catch(() => { });
+    await pruneDurableEvents(client);
+}
+async function readMaxSyncEventVersion() {
+    if (!(await ensureSyncEventsTable()))
+        return 0;
+    try {
+        const result = await getDbExec().execute("SELECT MAX(version) as max_version FROM sync_events");
+        return timestampValue(result.rows[0]?.max_version);
+    }
+    catch {
+        return 0;
+    }
+}
 async function readMaxUpdatedAtRaw(db, table) {
     try {
         const result = await db.execute(`SELECT MAX(updated_at) as max_ts FROM ${table}`);
@@ -313,6 +429,7 @@ export function recordChange(event) {
         _buffer.splice(0, _buffer.length - MAX_BUFFER);
     }
     _pollEmitter.emit(POLL_CHANGE_EVENT, entry);
+    void persistSyncEvent(entry);
 }
 function extensionTargetKey(target) {
     if (target.owner)
@@ -437,11 +554,114 @@ export function getChangesSinceForUser(since, userEmail, orgId) {
         }
         if (visibility === "pending") {
             version = Math.max(since, event.version - 1);
-            break;
+            return { version, events, cursorLimited: true };
         }
     }
     return { version, events };
 }
+async function getDurableChangesSinceForUser(since, userEmail, orgId) {
+    if (since <= 0 || !(await ensureSyncEventsTable())) {
+        return { version: _version, events: [] };
+    }
+    try {
+        const result = await getDbExec().execute({
+            sql: `SELECT version, event_json FROM sync_events WHERE version > ? ORDER BY version ASC LIMIT ?`,
+            args: [since, DURABLE_READ_LIMIT + 1],
+        });
+        const events = [];
+        let version = Math.max(_version, since);
+        let lastDurableVersion = since;
+        const rows = result.rows.slice(0, DURABLE_READ_LIMIT);
+        const overflowVersion = timestampValue(result.rows[DURABLE_READ_LIMIT]?.version);
+        for (const row of rows) {
+            const rawVersion = timestampValue(row.version);
+            if (rawVersion > lastDurableVersion)
+                lastDurableVersion = rawVersion;
+            if (rawVersion > version)
+                version = rawVersion;
+            let event = null;
+            try {
+                const parsed = JSON.parse(String(row.event_json));
+                if (parsed &&
+                    typeof parsed === "object" &&
+                    typeof parsed.source === "string" &&
+                    typeof parsed.type === "string") {
+                    event = {
+                        ...parsed,
+                        version: rawVersion || parsed.version,
+                    };
+                }
+            }
+            catch {
+                event = null;
+            }
+            if (!event)
+                continue;
+            const visibility = getChangeVisibilityForUser(event, userEmail, orgId);
+            if (visibility === "visible") {
+                events.push(event);
+                continue;
+            }
+            if (visibility === "pending") {
+                return {
+                    version: Math.max(since, event.version - 1),
+                    events,
+                    cursorLimited: true,
+                };
+            }
+        }
+        if (rows.length >= DURABLE_READ_LIMIT) {
+            if (overflowVersion === lastDurableVersion) {
+                const boundaryVersion = lastDurableVersion;
+                return {
+                    version: Math.max(since, boundaryVersion - 1),
+                    events: events.filter((event) => event.version < boundaryVersion),
+                    cursorLimited: true,
+                };
+            }
+            return {
+                version: Math.max(since, lastDurableVersion),
+                events,
+                cursorLimited: true,
+            };
+        }
+        return { version, events };
+    }
+    catch {
+        return { version: _version, events: [] };
+    }
+}
+async function getCombinedChangesSinceForUser(since, userEmail, orgId, useDurableEvents) {
+    const memory = getChangesSinceForUser(since, userEmail, orgId);
+    if (!useDurableEvents)
+        return memory;
+    const durable = await getDurableChangesSinceForUser(since, userEmail, orgId);
+    const byIdentity = new Map();
+    for (const event of [...durable.events, ...memory.events]) {
+        byIdentity.set(JSON.stringify([
+            event.version,
+            event.source,
+            event.type,
+            event.key,
+            event.owner,
+            event.orgId,
+            event.resourceType,
+            event.resourceId,
+        ]), event);
+    }
+    const events = Array.from(byIdentity.values()).sort((a, b) => a.version - b.version);
+    const limitedVersions = [memory, durable]
+        .filter((result) => result.cursorLimited)
+        .map((result) => result.version);
+    return {
+        version: limitedVersions.length > 0
+            ? Math.min(...limitedVersions)
+            : Math.max(memory.version, durable.version, since),
+        events: limitedVersions.length > 0
+            ? events.filter((event) => event.version <= Math.min(...limitedVersions))
+            : events,
+    };
+}
 /**
  * Seed _version from DB timestamps on the first call so serverless
  * cold starts don't return version 0 and confuse polling clients.
@@ -452,7 +672,8 @@ async function seedVersionFromDb() {
     _versionSeeded = true;
     try {
         const db = getDbExec();
-        const [appTs, settingsTs, extensionsMaxUpdatedAt, extensionMarkerTs, actionMarkerTs, refreshResult,] = await Promise.all([
+        const [syncEventsTs, appTs, settingsTs, extensionsMaxUpdatedAt, extensionMarkerTs, actionMarkerTs, refreshResult,] = await Promise.all([
+            readMaxSyncEventVersion(),
             readMaxUpdatedAt(db, "application_state"),
             readMaxUpdatedAt(db, "settings"),
             readMaxUpdatedAtRaw(db, "tools"),
@@ -471,7 +692,7 @@ async function seedVersionFromDb() {
             refreshTs = Math.max(refreshTs, timestampValue(row.updated_at));
         }
         // Seed version — never decrease an already-set value
-        _version = Math.max(_version, appTs, settingsTs, extensionsTs, extensionMarkerTs, actionMarkerTs);
+        _version = Math.max(_version, syncEventsTs, appTs, settingsTs, extensionsTs, extensionMarkerTs, actionMarkerTs);
         // Set baselines so checkExternalDbChanges detects future writes
         _lastAppStateTs = appTs;
         _lastSettingsTs = settingsTs;
@@ -502,9 +723,12 @@ async function seedVersionFromDb() {
  * Check for cross-process DB writes by comparing updated_at timestamps.
  * Runs at most once per second to avoid excessive queries.
  */
-async function checkExternalDbChanges() {
+async function checkExternalDbChanges(options) {
     const now = Date.now();
-    if (now - _lastDbCheck < 1000)
+    const interval = options.durableEvents
+        ? DURABLE_LEGACY_DB_CHECK_INTERVAL_MS
+        : LEGACY_DB_CHECK_INTERVAL_MS;
+    if (now - _lastDbCheck < interval)
         return;
     // Coalesce: if a check is already running, await it instead of starting a
     // second overlapping run that would double-advance the shared watermarks
@@ -707,11 +931,14 @@ export function createPollHandler() {
         }
         // On cold start, seed _version from DB so we don't return version: 0
         await seedVersionFromDb();
-        // Check for cross-process writes before responding
-        await checkExternalDbChanges();
+        const durableEvents = await ensureSyncEventsTable();
+        // Durable sync_events rows are the cheap cross-process path. Keep the
+        // legacy watermark scan as a slower safety net for direct SQL writes and
+        // older processes that have not started writing durable events yet.
+        await checkExternalDbChanges({ durableEvents });
         const query = getQuery(event);
         const since = parseInt(String(query.since ?? "0"), 10) || 0;
-        return getChangesSinceForUser(since, session.email, session.orgId);
+        return getCombinedChangesSinceForUser(since, session.email, session.orgId, durableEvents);
     });
 }
 //# sourceMappingURL=poll.js.map