@agent-native/core 0.153.6 → 0.153.8

package/dist/agent/run-store.d.ts

@@ -681,13 +681,26 @@ export declare function listRunsForThread(threadId: string, options?: {
  * Best-effort on parse: malformed ledger rows are skipped rather than thrown.
  */
 export declare function getCurrentTurnEventsForThread(threadId: string, knownTurnId?: string): Promise<AgentChatEvent[]>;
+export interface StaleRunReapResult {
+    /** Rows this pass reaped. */
+    reaped: number;
+    /**
+     * Rows whose reap threw. Separate from `reaped` because a pass where every
+     * row failed must not read as "nothing was stale" — those were the same
+     * number before, and the caller's own `null`-vs-`0` distinction is worthless
+     * while the per-row failures underneath it are coerced away.
+     */
+    failed: number;
+    /** More stale rows remain than the batch cap; the next tick continues. */
+    truncated: boolean;
+}
 /**
  * Expire any "running" rows whose heartbeat is stale — producer died.
  * Safe to call at server startup on multi-isolate deployments: only rows
  * without a fresh heartbeat get reaped, so runs owned by OTHER live
  * isolates (which keep heartbeating) are left alone.
  */
-export declare function reapAllStaleRuns(): Promise<number>;
+export declare function reapAllStaleRuns(): Promise<StaleRunReapResult>;
 /**
  * Read the daily terminal-outcome counters rolled up from pruned runs. Pair
  * with live `agent_runs` rows for a complete picture — see

package/dist/agent/run-store.js

@@ -2253,6 +2253,18 @@ export async function getCurrentTurnEventsForThread(threadId, knownTurnId) {
     }
     return events;
 }
+/**
+ * Rows one pass will reap. Each costs ~5-10 serial round trips (reconcile,
+ * transactional reap plus recovery, terminal-event append), and this sweep now
+ * runs ahead of `processRecurringJobs` on the shared durable tick — so an
+ * unbounded first pass against a backlog spends the platform wall before jobs
+ * get any. Production carried 1,216 stale rows while nothing periodic reaped
+ * them, so the first tick after that fix lands on exactly such a backlog.
+ * A truncated pass is drained by the next tick (60s durable, 20s in-process),
+ * never dropped — `truncated` is what stops a partial sweep being reported as
+ * a clean one.
+ */
+const REAP_ALL_STALE_BATCH_LIMIT = 200;
 /**
  * Expire any "running" rows whose heartbeat is stale — producer died.
  * Safe to call at server startup on multi-isolate deployments: only rows
@@ -2260,9 +2272,14 @@ export async function getCurrentTurnEventsForThread(threadId, knownTurnId) {
  * isolates (which keep heartbeating) are left alone.
  */
 export async function reapAllStaleRuns() {
+    const nothingStale = {
+        reaped: 0,
+        failed: 0,
+        truncated: false,
+    };
     await ensureRunTables();
     if (!(await hasRunningRuns()))
-        return 0;
+        return nothingStale;
     const client = getDbExec();
     const now = Date.now();
     // Background-dispatched runs use the wider window; everything else 15s. The
@@ -2274,13 +2291,23 @@ export async function reapAllStaleRuns() {
     // server startup across possibly-multiple isolates, so a sibling isolate's
     // still-alive, in-flight run must not be reaped just because THIS isolate
     // just booted and has no heartbeat history for it.
-    const stale = await client.execute({
+    // One row over the cap is how a truncated pass is detected without a second
+    // COUNT query against the same predicate.
+    const scanned = await client.execute({
         sql: `SELECT id FROM agent_runs
           WHERE status = 'running'
             AND ${livenessBasisSql()} < ${backgroundAwareStaleCutoffSql()}
-            AND ${inFlightGraceSql()}`,
+            AND ${inFlightGraceSql()}
+          ORDER BY started_at ASC
+          LIMIT ${REAP_ALL_STALE_BATCH_LIMIT + 1}`,
         args: [now, now, now],
     });
+    const truncated = scanned.rows.length > REAP_ALL_STALE_BATCH_LIMIT;
+    const stale = {
+        rows: truncated
+            ? scanned.rows.slice(0, REAP_ALL_STALE_BATCH_LIMIT)
+            : scanned.rows,
+    };
     for (const row of stale.rows) {
         const id = row.id;
         if (typeof id === "string") {
@@ -2299,13 +2326,19 @@ export async function reapAllStaleRuns() {
     // already found stale; on an idle app `hasRunningRuns` returns before any of
     // this, so the 20s fast sweep (agent-chat-plugin.ts) costs one probe.
     let reapedCount = 0;
+    let failedCount = 0;
     for (const row of stale.rows) {
         const id = row.id;
         if (typeof id !== "string")
             continue;
-        const reaped = await reapSingleStaleRun(id).catch(() => false);
-        if (reaped)
-            reapedCount += 1;
+        try {
+            if (await reapSingleStaleRun(id))
+                reapedCount += 1;
+        }
+        catch (error) {
+            failedCount += 1;
+            console.error(`[run-store] stale reap failed for run ${id}:`, error);
+        }
     }
     for (const row of stale.rows) {
         const id = row.id;
@@ -2313,7 +2346,7 @@ export async function reapAllStaleRuns() {
             await safeAppendTerminalRunEvent(id, STALE_RUN_ERROR_EVENT, "reap-all-stale");
         }
     }
-    return reapedCount;
+    return { reaped: reapedCount, failed: failedCount, truncated };
 }
 const RUN_OUTCOME_DAY_MS = 86_400_000;
 /**

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

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;
     ok: boolean;
+    error?: undefined;
 }>>;

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<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     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-chat-plugin.js

@@ -4907,7 +4907,10 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     //
                     // Reported, never swallowed, and never fatal to the job sweep: a
                     // reap failure must not take recurring jobs down with it, and
-                    // `null` must stay distinguishable from "reaped nothing".
+                    // `null` must stay distinguishable from "reaped nothing". The
+                    // result carries `failed` and `truncated` for the same reason one
+                    // level down — a pass where every row threw, and a pass that hit
+                    // the batch cap, both used to be reportable as a clean sweep.
                     const { reapAllStaleRuns } = await import("../agent/run-store.js");
                     const staleRunsReaped = await reapAllStaleRuns().catch((error) => {
                         console.error("[agent-chat] durable stale-run reap failed:", error);

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/package.json

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