@agent-native/core 0.153.4 → 0.153.6

package/dist/client/sse-event-processor.d.ts

@@ -110,6 +110,13 @@ export interface AgentAutoContinueErrorInfo {
     recoverable?: boolean;
     upgradeUrl?: string;
 }
+/**
+ * Kept verbatim in sync with `INTERRUPTED_TOOL_RESULT_MARKER`
+ * (agent/production-agent.ts): the server matches this substring in replayed
+ * history to count how many times a write tool was interrupted, which is the
+ * only thing that tells "we do not know if it landed" apart from "it failed".
+ */
+export declare const INTERRUPTED_TOOL_RESULT = "Interrupted before this tool returned a result.";
 export declare function settleInterruptedToolCalls(content: ContentPart[], result?: string, options?: {
     includeActivity?: boolean;
     activityResult?: string;

package/dist/client/sse-event-processor.js

@@ -2,7 +2,13 @@ import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, }
 import { emitChatFirstOpenApp } from "./chat-first.js";
 import { formatChatErrorText, normalizeChatError } from "./error-format.js";
 import { humanizeToolLabelText, humanizeToolName, runningToolLabel, } from "./tool-display.js";
-const INTERRUPTED_TOOL_RESULT = "Interrupted before this tool returned a result.";
+/**
+ * Kept verbatim in sync with `INTERRUPTED_TOOL_RESULT_MARKER`
+ * (agent/production-agent.ts): the server matches this substring in replayed
+ * history to count how many times a write tool was interrupted, which is the
+ * only thing that tells "we do not know if it landed" apart from "it failed".
+ */
+export const INTERRUPTED_TOOL_RESULT = "Interrupted before this tool returned a result.";
 const INTERRUPTED_ACTIVITY_RESULT = "Stopped before this action started.";
 /**
  * Maximum number of assistant-ui repository updates we deliver in one browser
@@ -528,6 +534,13 @@ function isAutoRecoverableError(ev, errMsg) {
     }
     if (ev.recoverable === true)
         return true;
+    // An explicit flag outranks the message sniff below, which exists only for
+    // events that carry no flag at all. The repeat guards stop a turn with
+    // `recoverable: false` and a message that names the looping tool, so a stop
+    // on `list-workspace-connections` matched the "connection" sniff and
+    // auto-continued the very loop it was emitted to break.
+    if (ev.recoverable === false)
+        return false;
     if (msg.includes("daily gateway request cap"))
         return false;
     // "gateway error" intentionally absent — that's the no-detail Builder
@@ -1542,11 +1555,25 @@ export function processEvent(ev, content, toolCallCounter, tabId, state) {
     }
     return { action: "continue" };
 }
+/**
+ * Drop the draft the server is about to re-emit — the narration since the last
+ * completed tool, not the whole turn. A `clear` arrives on a final-answer-guard
+ * retry or a continuation, both of which resume AFTER the last completed tool
+ * call, so anything before that boundary is settled multi-step narration the
+ * retry will never re-send. Wiping it read to users as "it deleted its reply
+ * and started over", and `thread-data-builder` replays this same scoping on
+ * rebuild, so the loss survived a reload.
+ */
 function clearAssistantDraftContent(content) {
     for (let index = content.length - 1; index >= 0; index--) {
         const part = content[index];
         if (!part)
             continue;
+        if (part.type === "tool-call" &&
+            part.activity !== true &&
+            part.result !== undefined) {
+            return;
+        }
         if (part.type === "text" || part.type === "reasoning") {
             content.splice(index, 1);
             continue;

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/db/client.js

@@ -1091,7 +1091,7 @@ const _sharedDbPoolReplacementHooks = new Map();
  * database access down with it.
  */
 export function sharedDbPool(driver, url, create) {
-    const key = `${driver}${url}`;
+    const key = `${driver}\u0000${url}`;
     const existing = _sharedDbPools.get(key);
     if (existing)
         return existing;
@@ -1105,7 +1105,7 @@ export function sharedDbPool(driver, url, create) {
  * handing out the discarded pool.
  */
 export function replaceSharedDbPool(driver, url, previous, next) {
-    const key = `${driver}${url}`;
+    const key = `${driver}\u0000${url}`;
     if (_sharedDbPools.get(key) !== previous)
         return;
     _sharedDbPools.set(key, next);

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

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/provider-api/actions/github-repo-files.js

@@ -130,6 +130,7 @@ export function createGitHubRepoFilesAction(runtime, options = {}) {
         needsApproval: requireApprovalForWrites
             ? (args) => args.operation === "write" || args.operation === "delete"
             : false,
+        grounding: true,
         run: async (args) => {
             if (args.operation === "list") {
                 return runtime.listGitHubRepositoryFiles({

package/dist/provider-api/actions/provider-api.js

@@ -231,6 +231,7 @@ export function createProviderApiRequestAction(runtime, options = {}) {
             }),
             summary: (args) => buildProviderApiAuditSummary(args),
         },
+        grounding: true,
         run: async (rawArgs) => {
             const args = rawArgs;
             if (args.stageAs) {

package/dist/provider-api/actions/staged-datasets.js

@@ -120,6 +120,7 @@ export function createQueryStagedDatasetAction(options = {}) {
         schema,
         http: options.http ?? false,
         readOnly: true,
+        grounding: true,
         run: async (rawArgs) => {
             const args = rawArgs;
             const scope = resolveScope("query-staged-dataset", args, options);

package/dist/provider-api/corpus-jobs.js

@@ -205,6 +205,7 @@ export function createProviderCorpusJobAction(options) {
             "When status is paused or quota_wait, call operation=continue with the jobId after the indicated time/budget. Report coverage counts, paginationComplete, and any remaining gaps; a max-pages stop is not exhaustive.",
         schema: ProviderCorpusJobSchema,
         http: false,
+        grounding: true,
         run: async (args) => runProviderCorpusJobAction(args, options),
     });
 }

package/dist/server/action-discovery.js

@@ -168,6 +168,8 @@ function preserveActionFlags(entry) {
     }
     if (typeof entry.readOnly === "boolean")
         out.readOnly = entry.readOnly;
+    if (typeof entry.grounding === "boolean")
+        out.grounding = entry.grounding;
     if (typeof entry.allowInPlanMode === "boolean") {
         out.allowInPlanMode = entry.allowInPlanMode;
     }

package/dist/server/agent-chat-plugin.js

@@ -4890,18 +4890,41 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                             error: "Recurring-job sweep reached the synchronous server instead of the durable background worker.",
                         };
                     }
+                    // Stale reaping runs FIRST and site-wide, before the open-ended job
+                    // sweep can spend the platform wall. It is the durable driver the
+                    // in-process fast sweep below cannot be on serverless: that timer is
+                    // off wherever `shouldDisableInProcessSweeps` is on — i.e. every
+                    // production Lambda — and nothing replaced it, so a claimed run
+                    // whose producer died was only reaped when an unrelated request path
+                    // happened to look (prod: 1,216 runs, 12% of all runs, sitting
+                    // "running" for up to 59 minutes against a 15s window).
+                    //
+                    // One reap per site-tick instead of one per warm container is also
+                    // the point: the per-container timers are what issued 237k queries
+                    // in two minutes and earned that kill switch. `reapAllStaleRuns`
+                    // short-circuits on `hasRunningRuns()` (negative-cached), so an idle
+                    // app pays one probe.
+                    //
+                    // 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".
+                    const { reapAllStaleRuns } = await import("../agent/run-store.js");
+                    const staleRunsReaped = await reapAllStaleRuns().catch((error) => {
+                        console.error("[agent-chat] durable stale-run reap failed:", error);
+                        return null;
+                    });
                     try {
                         // Jobs may request MCP tools, and `getActions` is synchronous —
                         // hydrate before the sweep so a serverless container that never
                         // eagerly initialized still resolves them.
                         await ensureMcpInitialized();
                         await processRecurringJobs(schedulerDeps);
-                        return { ok: true };
+                        return { ok: true, staleRunsReaped };
                     }
                     catch (error) {
                         console.error("[recurring-jobs] Sweep route failed:", error);
                         setResponseStatus(event, 500);
-                        return { error: "Recurring-job sweep failed" };
+                        return { error: "Recurring-job sweep failed", staleRunsReaped };
                     }
                 }));
                 if (disableRecurringJobsRuntime) {
@@ -5139,7 +5162,16 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                             // against a 45s window). `reapAllStaleRuns` is per-row,
                             // idempotent, re-checks staleness at UPDATE time and honours
                             // the in-flight grace, so it is safe on this cadence.
-                            await reapAllStaleRuns().catch(() => { });
+                            //
+                            // This timer is the driver only where it actually runs — a
+                            // long-lived Node host. Wherever `sweepsDisabled` turns it off
+                            // (every production serverless function) the signed
+                            // RECURRING_JOBS_SWEEP_PATH route above owns the same reap,
+                            // driven by the platform scheduler. The two never both fire on
+                            // one host, which is why neither needs to coordinate.
+                            await reapAllStaleRuns().catch((error) => {
+                                console.error("[agent-chat] in-process stale-run reap failed:", error);
+                            });
                             let rows;
                             try {
                                 rows = await listUnclaimedBackgroundRunRows();

package/dist/server/realtime-token.d.ts

@@ -26,8 +26,8 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
-    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
+    error?: undefined;
 }>>;

package/package.json

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