@agent-native/core 0.157.7 → 0.157.8

package/dist/observability/routes.d.ts

@@ -41,27 +41,27 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
-    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
-} | {
     error?: undefined;
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id: string;
-} | {
+    error?: undefined;
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
+    ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/resources/handlers.d.ts

@@ -48,8 +48,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
 }>;
 /** DELETE /_agent-native/resources/:id — delete a resource */
 export declare function handleDeleteResource(event: any): Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

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/agent-engine-api-key-route.d.ts

@@ -27,10 +27,10 @@ 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 {};

package/dist/server/poll.d.ts

@@ -233,10 +233,10 @@ export declare class AppSyncState {
      *     bounded index range scan.
      *
      * The `lastDurablePrune` throttle below is per-process, so every serverless
-     * worker prunes on its first poll. That was survivable only once the work
-     * itself became bounded and indexed; if concurrency is still a problem,
-     * the next step is a `pg_try_advisory_xact_lock` so one worker prunes at a
-     * time. Deliberately not done yet — measure before adding a lock.
+     * worker prunes on its first poll. Postgres workers also take a
+     * transaction-scoped advisory lease for each batch: only one worker deletes
+     * at a time, but each batch still commits independently so a killed worker
+     * cannot hold a long transaction open.
      */
     private pruneDurableEvents;
     persistSyncEvent(event: ChangeEvent, dedupeKey?: string, presetId?: string): Promise<void>;

package/dist/server/poll.js

@@ -42,6 +42,12 @@ const DURABLE_RETENTION_MS = 24 * 60 * 60 * 1000;
  */
 const DURABLE_PRUNE_BATCH = 10_000;
 const DURABLE_PRUNE_MAX_BATCHES = 40;
+/**
+ * Postgres advisory-lock key for the per-database retention worker. The lock
+ * is transaction-scoped so a serverless worker that is killed cannot leave a
+ * lease behind for another worker to clear.
+ */
+const DURABLE_PRUNE_LOCK_KEY = "agent-native:sync-events-prune";
 /**
  * How far back a cold-started process replays durable action markers.
  * Covers the gap between a separate action process writing its marker and this
@@ -455,10 +461,10 @@ export class AppSyncState {
      *     bounded index range scan.
      *
      * The `lastDurablePrune` throttle below is per-process, so every serverless
-     * worker prunes on its first poll. That was survivable only once the work
-     * itself became bounded and indexed; if concurrency is still a problem,
-     * the next step is a `pg_try_advisory_xact_lock` so one worker prunes at a
-     * time. Deliberately not done yet — measure before adding a lock.
+     * worker prunes on its first poll. Postgres workers also take a
+     * transaction-scoped advisory lease for each batch: only one worker deletes
+     * at a time, but each batch still commits independently so a killed worker
+     * cannot hold a long transaction open.
      */
     async pruneDurableEvents(client) {
         const now = Date.now();
@@ -469,17 +475,43 @@ export class AppSyncState {
         let deleted = 0;
         try {
             for (let batch = 0; batch < DURABLE_PRUNE_MAX_BATCHES; batch++) {
-                const result = await client.execute({
+                const runBatch = async (tx) => {
+                    if (this.isPg()) {
+                        const lockResult = await tx.execute({
+                            sql: "SELECT pg_try_advisory_xact_lock(hashtextextended(?, 0::bigint)) AS acquired",
+                            args: [DURABLE_PRUNE_LOCK_KEY],
+                        });
+                        const acquired = lockResult.rows[0]?.acquired;
+                        if (acquired !== true && acquired !== "t")
+                            return null;
+                    }
                     // `id IN (...)` rather than ctid/rowid: both are dialect-specific,
                     // and the primary key is indexed on every dialect we ship.
-                    sql: `DELETE FROM sync_events WHERE id IN (
-                  SELECT id FROM sync_events WHERE created_at < ?
-                  ORDER BY created_at, id LIMIT ?
-                )`,
-                    args: [cutoff, DURABLE_PRUNE_BATCH],
-                });
-                deleted += result.rowsAffected;
-                if (result.rowsAffected < DURABLE_PRUNE_BATCH)
+                    const result = await tx.execute({
+                        sql: `DELETE FROM sync_events WHERE id IN (
+                    SELECT id FROM sync_events WHERE created_at < ?
+                    ORDER BY created_at, id LIMIT ?
+                  )`,
+                        args: [cutoff, DURABLE_PRUNE_BATCH],
+                    });
+                    return result.rowsAffected;
+                };
+                // A Postgres advisory transaction lock is only useful when the lock
+                // and delete share a connection and transaction. Never fall back to
+                // an uncoordinated delete on a transactionless client.
+                const rowsAffected = this.isPg()
+                    ? client.transaction
+                        ? await client.transaction(runBatch)
+                        : null
+                    : await runBatch(client);
+                if (rowsAffected == null) {
+                    if (this.isPg() && !client.transaction) {
+                        throw new Error("Postgres prune requires a database transaction");
+                    }
+                    break;
+                }
+                deleted += rowsAffected;
+                if (rowsAffected < DURABLE_PRUNE_BATCH)
                     break;
             }
             this.durablePruneFailures = 0;

package/dist/server/transcribe-voice.d.ts

@@ -20,6 +20,6 @@ export declare function createTranscribeVoiceHandler(): import("h3").EventHandle
     error: string;
     text?: undefined;
 } | {
-    text: string;
     error?: undefined;
+    text: string;
 }>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.157.7",
+  "version": "0.157.8",
   "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": {