@agent-native/core 0.179.0 → 0.179.1-nightly-20260914212129

package/corpus/templates/clips/app/components/library/bulk-action-toolbar.tsx

@@ -29,6 +29,7 @@ interface BulkActionToolbarProps {
   allSelected?: boolean;
   onSelectAll?: () => void;
   onArchive?: () => void;
+  archiveAction?: "archive" | "unarchive";
   onMove?: (folderId: string | null) => void;
   onTrash?: () => void;
   onClear?: () => void;
@@ -42,6 +43,7 @@ export function BulkActionToolbar({
   allSelected = false,
   onSelectAll,
   onArchive,
+  archiveAction = "archive",
   onMove,
   onTrash,
   onClear,
@@ -82,7 +84,12 @@ export function BulkActionToolbar({
         onClick={onArchive}
         disabled={isPending}
       >
-        <IconArchive className="h-3.5 w-3.5" /> {t("libraryGrid.archiveAction")}
+        <IconArchive className="h-3.5 w-3.5" />{" "}
+        {t(
+          archiveAction === "unarchive"
+            ? "clipsFinalRaw.unarchive"
+            : "libraryGrid.archiveAction",
+        )}
       </Button>
       {canMove && (
         <DropdownMenu>

package/corpus/templates/clips/app/components/library/library-grid.tsx

@@ -782,12 +782,17 @@ export function LibraryGrid({
                 allSelected={allSelected}
                 onSelectAll={toggleSelectAll}
                 moveTargets={moveTargets}
+                archiveAction={view === "archive" ? "unarchive" : "archive"}
                 onArchive={async () => {
                   setIsBulkPending(true);
                   try {
                     const ids = Array.from(selected);
                     const results = await Promise.allSettled(
-                      ids.map((id) => archiveRecording.mutateAsync({ id })),
+                      ids.map((id) =>
+                        view === "archive"
+                          ? restoreRecording.mutateAsync({ id })
+                          : archiveRecording.mutateAsync({ id }),
+                      ),
                     );
                     const succeededIds = ids.filter(
                       (_, i) => results[i].status === "fulfilled",
@@ -795,9 +800,12 @@ export function LibraryGrid({
                     const failed = ids.length - succeededIds.length;
                     if (succeededIds.length > 0) {
                       toast.success(
-                        t("libraryGrid.clipsArchived", {
-                          count: succeededIds.length,
-                        }),
+                        t(
+                          view === "archive"
+                            ? "trashRoute.clipsRestored"
+                            : "libraryGrid.clipsArchived",
+                          { count: succeededIds.length },
+                        ),
                       );
                       setSelected((prev) => {
                         const next = new Set(prev);
@@ -807,7 +815,12 @@ export function LibraryGrid({
                     }
                     if (failed > 0) {
                       toast.error(
-                        t("libraryGrid.clipsArchiveFailed", { count: failed }),
+                        t(
+                          view === "archive"
+                            ? "trashRoute.clipsRestoreFailed"
+                            : "libraryGrid.clipsArchiveFailed",
+                          { count: failed },
+                        ),
                       );
                     }
                   } finally {

package/corpus/templates/factory/app/components/factory/FactoryAgentsView.tsx

@@ -7,6 +7,7 @@ import {
   WorkspaceAppCard,
 } from "@agent-native/dispatch/components";
 import { IconPlus } from "@tabler/icons-react";
+import { forwardRef } from "react";
 
 import { Button } from "@/components/ui/button";
 
@@ -21,14 +22,19 @@ interface WorkspaceAppSummary {
   statusLabel?: string;
 }
 
-function CreateAppButton({ label }: { label: string }) {
-  return (
-    <Button size="sm">
-      <IconPlus size={15} />
-      {label}
-    </Button>
-  );
-}
+// Radix's PopoverTrigger asChild clones its child and injects onClick/ref
+// directly onto it. A plain function component here would drop those props
+// silently, leaving the trigger button inert. Forward both through to Button.
+const CreateAppTriggerButton = forwardRef<
+  HTMLButtonElement,
+  React.ComponentPropsWithoutRef<typeof Button> & { label: string }
+>(({ label, ...props }, ref) => (
+  <Button ref={ref} size="sm" {...props}>
+    <IconPlus size={15} />
+    {label}
+  </Button>
+));
+CreateAppTriggerButton.displayName = "CreateAppTriggerButton";
 
 function AgenticAppsSection({ t }: { t: ReturnType<typeof useT> }) {
   const query = useActionQuery<WorkspaceAppSummary[]>("list-workspace-apps", {
@@ -55,7 +61,7 @@ function AgenticAppsSection({ t }: { t: ReturnType<typeof useT> }) {
         {apps.length > 0 ? (
           <CreateAppPopover
             align="end"
-            trigger={<CreateAppButton label={createAppLabel} />}
+            trigger={<CreateAppTriggerButton label={createAppLabel} />}
             onCreated={() => void query.refetch()}
           />
         ) : null}
@@ -86,7 +92,7 @@ function AgenticAppsSection({ t }: { t: ReturnType<typeof useT> }) {
           </div>
           <div className="mt-4 flex justify-center">
             <CreateAppPopover
-              trigger={<CreateAppButton label={createAppLabel} />}
+              trigger={<CreateAppTriggerButton label={createAppLabel} />}
               onCreated={() => void query.refetch()}
             />
           </div>

package/dist/agent/production-agent.js

@@ -47,7 +47,7 @@ import { getDefaultMaxIterations, getDefaultMaxRunInputTokens, MAX_AGENT_MAX_ITE
 import { getContextWindowForModel, resolveFallbackModel, } from "./model-config.js";
 import { maybeCompactThread, buildObservationalContext, hasObservationalMemory, serializeObservationalMemoryBlock, } from "./observational-memory/index.js";
 import { ProcessorChain, TripWire, toolCallsFromContent, } from "./processors.js";
-import { startRun, subscribeToRun, replayCompletedTurn, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortTurnDurably, tryClaimRunSlot, isHostedRuntime, resolveRunSoftTimeoutMs, resolveRunToolTimeoutCeilingMs, endsAfterCompletedToolWithoutAssistantFinal, endsDuringActionPreparation, } from "./run-manager.js";
+import { startRun, subscribeToRun, replayCompletedTurn, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortTurnDurably, tryClaimRunSlot, isHostedRuntime, resolveRunSoftTimeoutMs, resolveRunToolTimeoutCeilingMs, endsAfterToolResultWithoutAssistantFinal, endsDuringActionPreparation, } from "./run-manager.js";
 import { writeLedgerEntry, readLedgerEntry, clearLedgerForThread, insertRun, insertRunEvent, isTurnAborted, markRunAborted, updateRunHeartbeat, updateRunStatusIfRunning, setRunError, setRunTerminalReason, claimBackgroundRun, readBackgroundRunClaim, recordRunDiagnostic, countRunsForTurn, RUN_DIAG_STAGE, UNCLAIMED_BACKGROUND_RUN_GRACE_MS, turnRunLedgerExhausted, } from "./run-store.js";
 import { buildCurrentTimeUserContext } from "./runtime-context.js";
 import { consumeAgentToolApproval, createAgentToolApproval, isAgentToolAlwaysAllowed, resolveAgentToolApprovalTurnId, } from "./tool-approval-store.js";
@@ -5972,7 +5972,7 @@ export function backgroundContinuationReasonForRun(run) {
             providerRetryable: last.providerRetryable,
         }));
     }
-    if (endsAfterCompletedToolWithoutAssistantFinal(run) ||
+    if (endsAfterToolResultWithoutAssistantFinal(run) ||
         endsDuringActionPreparation(run)) {
         return "stream_ended";
     }
@@ -6078,7 +6078,7 @@ export async function runAgentLoopWithMainChatInternalContinuations(opts) {
 }
 function endsAtContinuationBoundary(run) {
     return (endsAtInternalContinuationBoundary(run) ||
-        endsAfterCompletedToolWithoutAssistantFinal(run) ||
+        endsAfterToolResultWithoutAssistantFinal(run) ||
         endsDuringActionPreparation(run));
 }
 // Defined in `app-config/run-lifecycle-invariants.ts`, the neutral home for
@@ -6089,7 +6089,7 @@ function endsAtContinuationBoundary(run) {
  * Forward progress inside ONE chunk, read from the events it actually emitted:
  * assistant text or tool activity. Same evidence the agent-teams no-progress
  * budget counts (`agent-teams.ts`), and the same events
- * `endsAfterCompletedToolWithoutAssistantFinal` reads to tell an unfinished
+ * `endsAfterToolResultWithoutAssistantFinal` reads to tell an unfinished
  * turn from a finished one.
  */
 function chunkMadeForwardProgress(run) {

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

@@ -361,12 +361,22 @@ export declare function resolveBackgroundRunHardTimeoutMs(): number;
  */
 export declare function resolveBackgroundAutomationSoftTimeoutMs(overrideMs?: number): number;
 /**
- * A completed tool with no later assistant text is an unfinished turn, not a
+ * A tool result with no later assistant text is an unfinished turn, not a
  * successful terminal response. Keep this predicate beside the run-manager's
  * terminal synthesis so the run-manager and production continuation paths use
  * the same boundary evidence.
+ *
+ * A FAILED tool result counts too. Skipping it made the verdict depend on
+ * whether some earlier call in the same turn happened to succeed: a turn ending
+ * on `resources` ok then `web_request` failed continued, while the same turn
+ * with both failing terminated as a plain `done`. The client can only render
+ * "stopped after these actions ... without sending a final message" for that,
+ * so the tool's real error — an expired handoff URL, a missing credential —
+ * never reached the user, and typing "continue" by hand was the only way to see
+ * it. The model has not read the error yet at this point, which makes a failed
+ * tail strictly more unfinished than a successful one.
  */
-export declare function endsAfterCompletedToolWithoutAssistantFinal(run: ActiveRun): boolean;
+export declare function endsAfterToolResultWithoutAssistantFinal(run: ActiveRun): boolean;
 /**
  * A model can emit a lead-in before it starts assembling an action input. If
  * the run ends in that preparation phase, `done` is not a successful turn.

package/dist/agent/run-manager.js

@@ -457,21 +457,34 @@ function isTerminalRunEvent(event) {
         event.type === "auto_continue");
 }
 /**
- * A completed tool with no later assistant text is an unfinished turn, not a
+ * A tool result with no later assistant text is an unfinished turn, not a
  * successful terminal response. Keep this predicate beside the run-manager's
  * terminal synthesis so the run-manager and production continuation paths use
  * the same boundary evidence.
+ *
+ * A FAILED tool result counts too. Skipping it made the verdict depend on
+ * whether some earlier call in the same turn happened to succeed: a turn ending
+ * on `resources` ok then `web_request` failed continued, while the same turn
+ * with both failing terminated as a plain `done`. The client can only render
+ * "stopped after these actions ... without sending a final message" for that,
+ * so the tool's real error — an expired handoff URL, a missing credential —
+ * never reached the user, and typing "continue" by hand was the only way to see
+ * it. The model has not read the error yet at this point, which makes a failed
+ * tail strictly more unfinished than a successful one.
  */
-export function endsAfterCompletedToolWithoutAssistantFinal(run) {
-    let completedToolAfterLastAssistantText = false;
+export function endsAfterToolResultWithoutAssistantFinal(run) {
+    let toolResultAfterLastAssistantText = false;
     for (const { event } of run.events) {
         if (event.type === "text" && event.text.trim().length > 0) {
-            completedToolAfterLastAssistantText = false;
+            toolResultAfterLastAssistantText = false;
             continue;
         }
-        if (event.type === "tool_done" && event.isError !== true) {
-            completedToolAfterLastAssistantText =
-                event.chatUI === undefined && event.mcpApp === undefined;
+        if (event.type === "tool_done") {
+            // Custom UI is the one tool result that is a legitimate final answer on
+            // its own, and only when it succeeded.
+            toolResultAfterLastAssistantText =
+                event.isError === true ||
+                    (event.chatUI === undefined && event.mcpApp === undefined);
             continue;
         }
         if (event.type === "clear" ||
@@ -479,10 +492,10 @@ export function endsAfterCompletedToolWithoutAssistantFinal(run) {
             event.type === "missing_api_key" ||
             event.type === "auto_continue" ||
             event.type === "loop_limit") {
-            completedToolAfterLastAssistantText = false;
+            toolResultAfterLastAssistantText = false;
         }
     }
-    return completedToolAfterLastAssistantText;
+    return toolResultAfterLastAssistantText;
 }
 /**
  * A model can emit a lead-in before it starts assembling an action input. If
@@ -1635,7 +1648,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         // visible through StartedRun/getRun during the cleanup window.
         run.status = finalStatus;
         const shouldAutoContinueAfterUnfinishedTurn = finalStatus === "completed" &&
-            (endsAfterCompletedToolWithoutAssistantFinal(run) ||
+            (endsAfterToolResultWithoutAssistantFinal(run) ||
                 endsDuringActionPreparation(run)) &&
             (!terminalEventForCompletion ||
                 (terminalEventForCompletion.event.type === "done" &&

package/dist/automation/index.d.ts

@@ -186,8 +186,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
-    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
+    error?: undefined;
 }>;

package/dist/client/chat/message-components.js

@@ -656,7 +656,10 @@ export function isMissingFinalResponseWarningText(text) {
         return true;
     }
     return (normalized.includes("stopped before sending a final message") ||
-        normalized.includes("stopped without sending a final message"));
+        normalized.includes("stopped without sending a final message") ||
+        // "stopped after <action> failed, without sending a final message."
+        (normalized.startsWith("The agent stopped after ") &&
+            normalized.includes("without sending a final message")));
 }
 function finalResponseTextFromContent(content) {
     if (typeof content === "string")

package/dist/client/settings/BuilderConnectPopover.d.ts

@@ -2,15 +2,21 @@ import React from "react";
 import type { BuilderConnectFlow } from "./useBuilderStatus.js";
 type BuilderConnectTrigger = React.ReactElement<{
     onClick?: React.MouseEventHandler<HTMLElement>;
-    "aria-disabled"?: boolean;
+    "aria-busy"?: boolean;
 }>;
 export interface BuilderConnectPopoverProps {
     flow: Pick<BuilderConnectFlow, "connecting" | "start"> & {
         agentNativeProvisioningEnabled?: boolean;
         accountExists?: boolean;
-        /** Retry the status request without bypassing provisioning consent. */
-        retry?: () => void;
+        /**
+         * Retry the status request without bypassing provisioning consent.
+         * Returns true when a read actually started; a retry that cannot report
+         * that is treated as "did not start" and never queues a click.
+         */
+        retry?: () => boolean | void;
         statusResolved?: boolean;
+        /** Bounds a queued click: increments whenever a status read settles. */
+        statusReadSettledCount?: number;
     };
     children: BuilderConnectTrigger;
     /** Preserve a surface-specific tracking source or callback when choosing a path. */

package/dist/client/settings/BuilderConnectPopover.js

@@ -12,6 +12,14 @@ export function BuilderConnectPopover({ flow, children, onConnect, onTriggerClic
         (capabilityResolved && flow.agentNativeProvisioningEnabled === true);
     const accountExists = capabilityResolved && flow.accountExists;
     const initiatedByThisTriggerRef = useRef(false);
+    // A click landing before the first status read cannot be answered yet:
+    // whether it opens the provisioning consent choice is exactly what that read
+    // decides. The trigger renders as an ordinary enabled button for that whole
+    // window, which is seconds long on a cold serverless start, so the intent is
+    // held rather than discarded. The snapshot bounds the wait: once the read
+    // this click asked for has settled without resolving, the intent is dropped.
+    const [queuedClick, setQueuedClick] = useState(null);
+    const settledCount = flow.statusReadSettledCount ?? 0;
     useEffect(() => {
         if (accountExists && initiatedByThisTriggerRef.current) {
             initiatedByThisTriggerRef.current = false;
@@ -27,8 +35,38 @@ export function BuilderConnectPopover({ flow, children, onConnect, onTriggerClic
         }
         flow.start({ provisionAccount });
     };
+    // Only ever replays work that needs no popup. `flow.start` reaches
+    // `window.open`, which browsers permit solely inside the click that asked
+    // for it; calling it from this effect would trade a dead button for a
+    // blocked popup and an "allow popups" message that blames the user for a
+    // gesture we dropped. When the resolved capability has no consent choice to
+    // show, the intent is released instead, and the now-resolved trigger answers
+    // the next click synchronously.
+    const openQueuedPopoverRef = useRef(() => { });
+    openQueuedPopoverRef.current = () => {
+        setQueuedClick(null);
+        if (showPopover)
+            setOpen(true);
+    };
+    useEffect(() => {
+        if (!queuedClick)
+            return;
+        if (capabilityResolved) {
+            openQueuedPopoverRef.current();
+            return;
+        }
+        // The read this click triggered came back and still did not resolve the
+        // capability. Surfaces that render this popover also render `flow.error`,
+        // so the user already has the reason; dropping the intent here is what
+        // keeps the trigger from sitting busy forever against an unreachable
+        // status route. Any movement counts, not just an increment: disabling the
+        // flow cancels the pending read and resets the counter, and a snapshot
+        // taken above that reset would otherwise never be passed again.
+        if (settledCount !== queuedClick.settledAt)
+            setQueuedClick(null);
+    }, [queuedClick, capabilityResolved, settledCount]);
     const trigger = React.cloneElement(children, {
-        "aria-disabled": capabilityResolved || defaultProvisionAccount ? undefined : true,
+        "aria-busy": queuedClick ? true : undefined,
         onClick: (event) => {
             if (flow.connecting) {
                 event.preventDefault();
@@ -40,9 +78,17 @@ export function BuilderConnectPopover({ flow, children, onConnect, onTriggerClic
                 event.stopPropagation();
                 if (defaultProvisionAccount) {
                     setOpen(true);
+                    return;
                 }
-                else {
-                    flow.retry?.();
+                // A click is already waiting on a read. Starting a second one would
+                // supersede the first in the hook's newest-wins refresh, discarding a
+                // success that was about to land.
+                if (queuedClick)
+                    return;
+                // Only wait on a read that actually started. A disabled flow never
+                // reads, so queuing against it would spin the trigger forever.
+                if (flow.retry?.() === true) {
+                    setQueuedClick({ settledAt: settledCount });
                 }
                 return;
             }

package/dist/client/settings/useBuilderStatus.d.ts

@@ -102,6 +102,14 @@ export interface BuilderConnectFlow {
     configured: boolean;
     /** True after at least one successful Builder connection-status response. */
     statusResolved: boolean;
+    /**
+     * Increments every time a `retry`/lifecycle status read settles, whether it
+     * resolved or failed. `statusResolved` alone cannot bound a caller waiting
+     * on a read, because a second failure leaves it false with no observable
+     * change. Consumers that queue work on a read need the settle, not the
+     * outcome.
+     */
+    statusReadSettledCount: number;
     /**
      * True when the deploy has BUILDER_PRIVATE_KEY set as a fallback. Connect
      * is still available so users can override the fallback with their own
@@ -140,8 +148,12 @@ export interface BuilderConnectFlow {
     hasFetchedStatus: boolean;
     /** Open the popup and begin polling. Must be called from a user-gesture handler. */
     start: (options?: BuilderConnectStartOptions) => void;
-    /** Retry the status request before choosing a connection path. */
-    retry: () => void;
+    /**
+     * Retry the status request before choosing a connection path. Returns true
+     * when a read actually started. A disabled flow never reads, so a caller
+     * that waits on the result must be able to tell the difference.
+     */
+    retry: () => boolean;
 }
 export declare function withBuilderConnectTrackingParams(url: string, options?: {
     source?: string;

package/dist/client/settings/useBuilderStatus.js

@@ -441,6 +441,7 @@ export function useBuilderConnectFlow(opts = {}) {
     const [accountExists, setAccountExists] = useState(false);
     const [hasFetchedStatus, setHasFetchedStatus] = useState(false);
     const [statusResolved, setStatusResolved] = useState(false);
+    const [statusReadSettledCount, setStatusReadSettledCount] = useState(0);
     const [statusConnectUrl, setStatusConnectUrl] = useState(null);
     // When statusConnectUrl was last fetched. The server signs the embedded
     // _an_connect token with a 10-minute TTL; using an older URL fails the
@@ -455,7 +456,7 @@ export function useBuilderConnectFlow(opts = {}) {
     const activePopupRef = useRef(null);
     const popupClosedAtRef = useRef(null);
     const callbackSuccessStartedAtRef = useRef(null);
-    const retryStatusRef = useRef(() => { });
+    const retryStatusRef = useRef(() => false);
     const statusUnavailableRef = useRef(false);
     const mountedRef = useRef(true);
     const notifiedConnectedRef = useRef(false);
@@ -527,10 +528,11 @@ export function useBuilderConnectFlow(opts = {}) {
             setAccountExists(false);
             setHasFetchedStatus(false);
             setStatusResolved(false);
+            setStatusReadSettledCount(0);
             setStatusConnectUrl(null);
             statusConnectUrlAtRef.current = null;
             connectAttemptIdRef.current = null;
-            retryStatusRef.current = () => { };
+            retryStatusRef.current = () => false;
             return;
         }
         mountedRef.current = true;
@@ -548,6 +550,7 @@ export function useBuilderConnectFlow(opts = {}) {
             // "use initial props until the hook has an answer" pattern wants to
             // stop waiting after we've tried, regardless of network outcome.
             setHasFetchedStatus(true);
+            setStatusReadSettledCount((count) => count + 1);
             if (!s) {
                 // "Could not read the status" must not render the same as "no status
                 // yet". `statusResolved` only flips on success, so without a visible
@@ -606,7 +609,10 @@ export function useBuilderConnectFlow(opts = {}) {
                 setError(null);
             }
         };
-        retryStatusRef.current = () => void refresh();
+        retryStatusRef.current = () => {
+            void refresh();
+            return true;
+        };
         // Connect-CTA cards render above the fold but their status is not needed
         // for first paint; defer the initial read. Focus/visibility/event
         // refreshes below stay immediate.
@@ -636,15 +642,13 @@ export function useBuilderConnectFlow(opts = {}) {
             cancelled = true;
             mountedRef.current = false;
             cancelInitialRefresh();
-            retryStatusRef.current = () => { };
+            retryStatusRef.current = () => false;
             window.removeEventListener("focus", refreshNow);
             document.removeEventListener("visibilitychange", onVisible);
             window.removeEventListener("agent-engine:configured-changed", refreshNow);
         };
     }, [enabled, fetchStatus]);
-    const retry = useCallback(() => {
-        retryStatusRef.current();
-    }, []);
+    const retry = useCallback(() => retryStatusRef.current(), []);
     const start = useCallback((startOptions) => {
         if (!enabled)
             return;
@@ -1074,6 +1078,7 @@ export function useBuilderConnectFlow(opts = {}) {
         configured,
         codeChangeConfigured,
         statusResolved,
+        statusReadSettledCount,
         envManaged,
         credentialSource,
         canDisconnect,

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

@@ -260,6 +260,7 @@ export declare function appendMissingFinalResponseWarning(content: ContentPart[]
     message: string;
     errorCode: string;
     recoverable: true;
+    failedTools?: string[];
 } | null;
 interface ProcessEventState {
     completedToolsAfterLastAssistantText: Set<string>;

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

@@ -877,6 +877,50 @@ function completedToolOnlyMessage(toolNames) {
     const label = formatToolNames(toolNames);
     return `The agent completed ${label}, but stopped before sending a final message. Review the completed tool card above or ask the agent to continue.`;
 }
+const MAX_REPORTED_TOOL_ERROR_LENGTH = 300;
+/**
+ * The failing tool results the turn ended on, newest first.
+ *
+ * A turn that stops on a failed tool used to render the same "review the tool
+ * card above" note as one that stops on a successful tool, so the reason it
+ * stopped — an expired handoff URL, a missing Stripe credential — was one the
+ * user had to go hunting for. The error text the tool already returned is the
+ * answer, so say it.
+ */
+function failedToolResultsAfterLastAssistantText(content) {
+    const lastTextIndex = lastAssistantTextIndex(content);
+    const failures = [];
+    for (let index = content.length - 1; index > lastTextIndex; index--) {
+        const part = content[index];
+        if (part?.type !== "tool-call" ||
+            part.activity === true ||
+            part.isError !== true ||
+            part.result === undefined) {
+            continue;
+        }
+        failures.push({
+            toolName: part.toolName,
+            error: typeof part.result === "string" ? part.result.trim() : "",
+        });
+    }
+    return failures;
+}
+function failedToolMessage(failures) {
+    const latest = failures[0];
+    if (!latest)
+        return null;
+    const label = formatToolNames(failures.map((failure) => failure.toolName));
+    const detail = latest.error
+        ? ` ${truncateToolError(latest.error)}`
+        : " No error detail was returned.";
+    return `The agent stopped after ${label} failed, without sending a final message.${detail} Ask the agent to continue, or fix the underlying failure and retry.`;
+}
+function truncateToolError(error) {
+    const singleLine = error.replace(/\s+/g, " ").trim();
+    return singleLine.length > MAX_REPORTED_TOOL_ERROR_LENGTH
+        ? `${singleLine.slice(0, MAX_REPORTED_TOOL_ERROR_LENGTH)}…`
+        : singleLine;
+}
 function hasCompletedCustomUi(content) {
     const lastTextIndex = lastAssistantTextIndex(content);
     let lastCompletedToolIsCustomUi = false;
@@ -904,6 +948,7 @@ export function appendMissingFinalResponseWarning(content, completedToolNames) {
         ...new Set(completedToolNames ?? completedToolNamesAfterLastAssistantText(content)),
     ];
     let lastToolIndex = -1;
+    let lastToolResultFailed = false;
     const materializedToolNames = new Set();
     for (let index = lastTextIndex + 1; index < content.length; index++) {
         const part = content[index];
@@ -911,20 +956,28 @@ export function appendMissingFinalResponseWarning(content, completedToolNames) {
             part.activity !== true &&
             part.result !== undefined) {
             lastToolIndex = index;
+            lastToolResultFailed = part.isError === true;
             materializedToolNames.add(part.toolName);
         }
     }
-    if (hasCompletedCustomUi(content))
+    // A rendered custom UI is a legitimate final answer only when nothing failed
+    // after it. `hasCompletedCustomUi` skips errored results, so without this a
+    // widget followed by a failing tool would silently claim the turn finished —
+    // the same verdict the run manager makes from the last tool_done.
+    if (!lastToolResultFailed && hasCompletedCustomUi(content))
         return null;
     if (successfulToolNames.length === 0 && lastTextIndex > lastToolIndex) {
         return null;
     }
+    // A failure outranks the completed-tool note: it is both the reason the turn
+    // stopped and the only part of it the user cannot reconstruct on their own.
+    const failures = failedToolResultsAfterLastAssistantText(content);
     const completedToolMessage = completedToolOnlyMessage(successfulToolNames);
-    const message = completedToolMessage
-        ? completedToolMessage
-        : materializedToolNames.size > 0
+    const message = failedToolMessage(failures) ??
+        completedToolMessage ??
+        (materializedToolNames.size > 0
             ? `The agent stopped after ${formatToolNames([...materializedToolNames])} without sending a final message. Review the tool card above or ask the agent to continue.`
-            : "The agent stopped without sending a final message. Ask the agent to continue or retry.";
+            : "The agent stopped without sending a final message. Ask the agent to continue or retry.");
     if (!content.some((part) => part.type === "text" && part.text === message)) {
         content.push({ type: "text", text: message });
     }
@@ -934,6 +987,9 @@ export function appendMissingFinalResponseWarning(content, completedToolNames) {
             ? "final_response_missing_after_tool"
             : "final_response_missing",
         recoverable: true,
+        ...(failures.length > 0
+            ? { failedTools: failures.map((failure) => failure.toolName) }
+            : {}),
     };
 }
 function markAssistantText(state) {

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

@@ -28,6 +28,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    ok: boolean;
     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;
 } | {
+    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/secrets/routes.d.ts

@@ -53,16 +53,16 @@ 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;
 } | {
     ok: boolean;
     status: string;
     error?: undefined;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
     ok: boolean;
     removed: boolean;
@@ -73,9 +73,9 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
  * 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;
 } | {
     ok: boolean;
     note?: undefined;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.179.0",
+  "version": "0.179.1-nightly-20260914212129",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -475,9 +475,9 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.32",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.2.0",
-    "@agent-native/toolkit": "^0.20.0",
-    "@agent-native/recap-cli": "0.5.30"
+    "@agent-native/agentkit": "^0.2.1-nightly-20260914212129",
+    "@agent-native/recap-cli": "0.5.30",
+    "@agent-native/toolkit": "^0.20.1-nightly-20260914212129"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",