@agent-native/core 0.137.6 → 0.137.8

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

@@ -19,7 +19,8 @@ import { cn } from "../utils.js";
 import { MarkdownText, renderMarkdownToClipboardHtml, } from "./markdown-renderer.js";
 import { getAssistantRunDurationMs } from "./repo-helpers.js";
 import { getRunErrorMetadata, runErrorHeadline, runErrorKey, } from "./run-recovery.js";
-import { ToolCallFallback, ToolActivityPresentation, FilesChangedSummary, ASSISTANT_VISIBLE_TOOL_CALL_LIMIT, ChatRunningContext, ChatRunDurationContext, formatWorkedDuration, RanToolsSummary, ReasoningCell, WorkedForSummary, } from "./tool-call-display.js";
+import { ToolCallFallback, ToolActivityPresentation, FilesChangedSummary, ASSISTANT_VISIBLE_TOOL_CALL_LIMIT, ChatRunningContext, ChatRunDurationContext, formatWorkedDuration, RanToolsSummary, ReasoningCell, WorkedForSummary, toolCallHasPendingApproval, } from "./tool-call-display.js";
+export { toolCallHasPendingApproval };
 // ─── Pending selection context key ───────────────────────────────────────────
 // Mirrored from AssistantChat to avoid a cross-import on a private constant.
 const PENDING_SELECTION_KEY = "pending-selection-context";
@@ -506,7 +507,9 @@ export function assistantMessageHasCompletedCustomUi(content) {
         }
         hasCompletedTool = true;
         lastCompletedToolIsCustomUi =
-            record.chatUI !== undefined || record.mcpApp !== undefined;
+            record.chatUI !== undefined ||
+                record.mcpApp !== undefined ||
+                toolCallHasPendingApproval(record);
     }
     return hasCompletedTool && lastCompletedToolIsCustomUi;
 }
@@ -518,7 +521,9 @@ export function assistantMessageHasCustomUi(content) {
             return false;
         const record = part;
         return (record.type === "tool-call" &&
-            (record.chatUI !== undefined || record.mcpApp !== undefined));
+            (record.chatUI !== undefined ||
+                record.mcpApp !== undefined ||
+                toolCallHasPendingApproval(record)));
     });
 }
 // Only the last assistant message may shimmer as "the currently running
@@ -628,7 +633,11 @@ export function isCollapsibleAssistantWorkPart(part) {
     return (part.type === "tool-call" &&
         !ALWAYS_VISIBLE_ASSISTANT_TOOLS.has(part.toolName ?? "") &&
         part.chatUI === undefined &&
-        part.mcpApp === undefined);
+        part.mcpApp === undefined &&
+        // Keep the Approve/Deny affordance outside "Worked for…" — needsApproval
+        // tools finish with a result string, so without this they collapse and the
+        // human gate disappears from the viewport.
+        !toolCallHasPendingApproval(part));
 }
 export function getAssistantToolSummaryInfo(parts) {
     const toolCallIndices = parts.reduce((indices, part, index) => {

package/dist/client/chat/runtime.js

@@ -622,7 +622,10 @@ function mapAgentNativeEvent(raw, input) {
                 type: "approval-request",
                 ...base,
                 approvalId: ev.approvalKey ?? ev.id ?? createRuntimeId("approval"),
-                toolCallId: ev.id,
+                // `approval_required` carries the model-side call id as `toolCallId`,
+                // not `id`. Without this the request falls back to matching by tool
+                // name, which picks the wrong call when two are pending at once.
+                toolCallId: ev.toolCallId ?? ev.id,
                 toolName: ev.tool,
                 message: ev.label ?? "Approve this tool call?",
                 input: ev.input,
@@ -849,18 +852,26 @@ function applyRuntimeEventToContent(event, projection) {
         return { content: [...content] };
     }
     if (typed.type === "approval-request") {
-        const part = [...content]
-            .reverse()
-            .find((candidate) => candidate.type === "tool-call" &&
-            (candidate.toolCallId === typed.toolCallId ||
-                candidate.toolName === typed.toolName));
-        if (part) {
+        const reversed = [...content].reverse();
+        const isToolCall = (candidate) => candidate.type === "tool-call";
+        // Match on the exact call id whenever the server supplied one. Falling back
+        // to "newest call with this name" would hand this call's approvalKey to a
+        // different parallel call of the same action, so name matching is reserved
+        // for events that carry no id at all.
+        const part = typed.toolCallId
+            ? reversed.find((candidate) => isToolCall(candidate) && candidate.toolCallId === typed.toolCallId)
+            : reversed.find((candidate) => isToolCall(candidate) && candidate.toolName === typed.toolName);
+        if (part && part.type === "tool-call") {
             part.approval = { approvalKey: typed.approvalId };
         }
-        else {
+        else if (!typed.toolCallId) {
+            // Only runtimes that never announced the call (no id) get a synthesized
+            // card. An id that matches nothing means the call was never observed or
+            // is already resolved, and inventing an Approve/Deny card for it would
+            // gate something the user cannot see.
             content.push({
                 type: "tool-call",
-                toolCallId: typed.toolCallId ?? typed.approvalId,
+                toolCallId: typed.approvalId,
                 toolName: typed.toolName ?? "approval",
                 argsText: typed.input ? JSON.stringify(typed.input) : "",
                 args: toContentPartInput(typed.input),

package/dist/client/chat/tool-call-display.d.ts

@@ -30,6 +30,13 @@ export type ApprovalContextValue = {
     onAlwaysAllow?: (approvalKey: string) => void;
 };
 export declare const ApprovalContext: React.Context<ApprovalContextValue | null>;
+/** Pending human-in-the-loop gate still waiting for Approve/Deny. */
+export declare function toolCallHasPendingApproval(part: {
+    approval?: {
+        approvalKey?: string;
+        dismissed?: boolean;
+    } | null;
+}): boolean;
 export declare const TOOL_LONG_RUNNING_HINT_DELAY_MS = 45000;
 export declare function ToolActivityPresentation({ toolName, isRunning, isActiveTail, suppressLongRunningHint, children, }: {
     toolName: string;

package/dist/client/chat/tool-call-display.js

@@ -20,6 +20,13 @@ export const ChatRunningContext = React.createContext(false);
 export const ChatRunDurationContext = React.createContext(null);
 export const ASSISTANT_VISIBLE_TOOL_CALL_LIMIT = 3;
 export const ApprovalContext = React.createContext(null);
+/** Pending human-in-the-loop gate still waiting for Approve/Deny. */
+export function toolCallHasPendingApproval(part) {
+    const approval = part.approval;
+    return (typeof approval?.approvalKey === "string" &&
+        approval.approvalKey.length > 0 &&
+        approval.dismissed !== true);
+}
 export const TOOL_LONG_RUNNING_HINT_DELAY_MS = 45_000;
 export function ToolActivityPresentation({ toolName, isRunning, isActiveTail, suppressLongRunningHint = false, children, }) {
     const [showLongRunningHint, setShowLongRunningHint] = useState(false);
@@ -514,7 +521,8 @@ function isReconnectSummarizablePart(part) {
         (part.type === "tool-call" &&
             part.toolName !== "connect-builder" &&
             part.chatUI === undefined &&
-            part.mcpApp === undefined));
+            part.mcpApp === undefined &&
+            !toolCallHasPendingApproval(part)));
 }
 function isReconnectToolSummaryPart(content, index, startIndex) {
     if (startIndex < 0 || index >= startIndex)

package/dist/client/require-session.js

@@ -1,4 +1,4 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * Client-side session gate for an authenticated app shell.
  *
@@ -70,12 +70,12 @@ export function RequireSession({ children, fallback, redirect = true, signedOut,
     return (_jsx(ResolvedSessionGate, { fallback: fallback, redirect: redirect, signedOut: signedOut, children: children }));
 }
 function ResolvedSessionGate({ children, fallback, redirect = true, signedOut, }) {
-    const { session, isLoading } = useSession();
+    const { session, status, retry } = useSession();
     // Guard against firing the redirect more than once (effect re-runs, React
     // StrictMode double-invoke) — a second navigation while the first is in
     // flight is harmless but noisy.
     const redirectedRef = useRef(false);
-    const mustRedirect = !isLoading && !session && redirect;
+    const mustRedirect = status === "unauthenticated" && redirect;
     useEffect(() => {
         if (!mustRedirect)
             return;
@@ -97,8 +97,14 @@ function ResolvedSessionGate({ children, fallback, redirect = true, signedOut, }
     }, [mustRedirect]);
     // Still resolving, or redirect already in flight: show the loading fallback
     // rather than flashing app chrome the visitor can't use.
-    if (isLoading)
+    if (status === "loading")
         return _jsx(_Fragment, { children: fallback ?? _jsx(DefaultSpinner, {}) });
+    // Unreadable is not signed-out. Redirecting here would bounce a signed-in
+    // user to the sign-in page over a transient 5xx, and rendering the spinner
+    // would strand them on a screen that never resolves.
+    if (status === "unavailable") {
+        return _jsx(SessionUnavailableNotice, { retry: retry });
+    }
     if (!session) {
         if (redirect)
             return _jsx(_Fragment, { children: fallback ?? _jsx(DefaultSpinner, {}) });
@@ -106,4 +112,7 @@ function ResolvedSessionGate({ children, fallback, redirect = true, signedOut, }
     }
     return _jsx(_Fragment, { children: children });
 }
+function SessionUnavailableNotice({ retry }) {
+    return (_jsxs("div", { className: "flex h-screen w-full flex-col items-center justify-center gap-4 px-6 text-center", children: [_jsx("p", { className: "max-w-md text-sm text-muted-foreground", children: "We couldn't reach the server to confirm you're signed in. This is usually temporary." }), _jsxs("div", { className: "flex gap-2", children: [_jsx("button", { type: "button", onClick: retry, className: "rounded-md bg-primary px-3 py-1.5 text-sm font-medium text-primary-foreground", children: "Try again" }), _jsx("button", { type: "button", onClick: () => window.location.reload(), className: "rounded-md border border-border px-3 py-1.5 text-sm font-medium", children: "Reload page" })] })] }));
+}
 //# sourceMappingURL=require-session.js.map

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

@@ -68,6 +68,8 @@ export interface SSEEvent {
     /** Stable key the client echoes back in `approvedToolCalls` to approve a
      *  paused `needsApproval` tool call. Present on `approval_required` events. */
     approvalKey?: string;
+    /** Model-side tool-call id for `approval_required` (mirrors AgentChatEvent). */
+    toolCallId?: string;
     error?: string;
     seq?: number;
     agent?: string;

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

@@ -201,6 +201,39 @@ function findPendingToolCallIndexById(content, toolCallId) {
     }
     return -1;
 }
+/**
+ * Locate the tool call an `approval_required` event refers to.
+ *
+ * Stricter than `findPendingToolCallIndex`: when the server supplies a call id
+ * we never fall back to "newest pending call with this name". A paused
+ * `tool_done` resolves the call right after the gate fires, so a replayed or
+ * reordered approval would otherwise miss on id and silently attach this call's
+ * approvalKey to a *different* in-flight call of the same action — putting the
+ * wrong key behind a visible Approve button.
+ *
+ * The only tolerated fallback mirrors `findPendingActivityToolCallIndex`: a
+ * single unambiguous reader-local (`tc_N`) placeholder, which is how a call
+ * looks when an older server omitted the id on `tool_start`.
+ */
+function findApprovalToolCallIndex(content, toolName, toolCallId) {
+    if (!toolCallId) {
+        return findPendingToolCallIndex(content, toolName);
+    }
+    const exactIndex = findPendingToolCallIndexById(content, toolCallId);
+    if (exactIndex >= 0)
+        return exactIndex;
+    const readerLocalCandidates = [];
+    for (let i = 0; i < content.length; i += 1) {
+        const part = content[i];
+        if (part.type === "tool-call" &&
+            part.toolName === toolName &&
+            part.result === undefined &&
+            /^tc_\d+$/.test(part.toolCallId)) {
+            readerLocalCandidates.push(i);
+        }
+    }
+    return readerLocalCandidates.length === 1 ? readerLocalCandidates[0] : -1;
+}
 function findOldestPendingActivityToolCallIndex(content, toolName) {
     for (let i = 0; i < content.length; i += 1) {
         const part = content[i];
@@ -656,6 +689,8 @@ function coalesceJournalRecoveredTool(content, completedIndex) {
                 prior.mcpApp = current.mcpApp;
             if (current.chatUI)
                 prior.chatUI = current.chatUI;
+            if (current.approval)
+                prior.approval = { ...current.approval };
         }
         content.splice(completedIndex, 1);
         return true;
@@ -1044,7 +1079,10 @@ export function processEvent(ev, content, toolCallCounter, tabId, state) {
         const approvalTool = ev.tool ?? "unknown";
         const approvalKey = ev.approvalKey;
         if (approvalKey) {
-            const idx = findPendingToolCallIndex(content, approvalTool, ev.id);
+            // `toolCallId` is the model-side id in the `approval_required` contract;
+            // `id` is only carried by older frames. Same precedence as the runtime
+            // path so both processors resolve an event to the same call.
+            const idx = findApprovalToolCallIndex(content, approvalTool, ev.toolCallId ?? ev.id);
             if (idx >= 0) {
                 const part = content[idx];
                 if (part.type === "tool-call") {

package/dist/client/use-session.d.ts

@@ -1,8 +1,19 @@
 import type { AuthSession } from "../server/auth.js";
 export type { AuthSession };
+/**
+ * `"unavailable"` is the session endpoint being unreadable — a 5xx, a network
+ * failure, or a timeout. It is NOT the visitor being signed out, and a caller
+ * that collapses the two either strands the user on a spinner forever or
+ * bounces a signed-in user to the sign-in page over a transient blip.
+ */
+export type SessionStatus = "loading" | "authenticated" | "unauthenticated" | "unavailable";
 interface UseSessionResult {
     session: AuthSession | null;
     isLoading: boolean;
+    status: SessionStatus;
+    error: Error | null;
+    /** Restart the resolve loop, e.g. from a "Try again" control. */
+    retry: () => void;
 }
 /**
  * Client-side hook to get the current auth session.

package/dist/client/use-session.js

@@ -1,8 +1,9 @@
-import { useEffect, useState } from "react";
+import { useCallback, useEffect, useState } from "react";
 import { setSentryUser, trackSessionStatus } from "./analytics.js";
 import { fetchAuthSessionStatus } from "./client-status-requests.js";
 const SESSION_CACHE_TTL_MS = 30_000;
 const SESSION_RETRY_DELAY_MS = 1_000;
+const SESSION_MAX_ATTEMPTS = 4;
 let cachedSession;
 let cachedSessionAt = 0;
 let sessionRequest;
@@ -65,22 +66,41 @@ function fetchSharedSession() {
 export function useSession() {
     const cached = hasFreshSessionCache() ? (cachedSession ?? null) : null;
     const [session, setSession] = useState(cached);
-    const [isLoading, setIsLoading] = useState(!hasFreshSessionCache());
+    const [status, setStatus] = useState(() => {
+        if (!hasFreshSessionCache())
+            return "loading";
+        return cached ? "authenticated" : "unauthenticated";
+    });
+    const [error, setError] = useState(null);
+    const [retryToken, setRetryToken] = useState(0);
+    const retry = useCallback(() => {
+        setError(null);
+        setStatus("loading");
+        setRetryToken((token) => token + 1);
+    }, []);
     useEffect(() => {
         let cancelled = false;
         let retryTimer;
+        let attempts = 0;
         const resolveSession = async () => {
             const resolved = await fetchSharedSession();
             if (cancelled)
                 return;
             if (resolved === undefined) {
+                attempts += 1;
+                if (attempts >= SESSION_MAX_ATTEMPTS) {
+                    setError(new Error(`Could not read the session after ${attempts} attempts.`));
+                    setStatus("unavailable");
+                    return;
+                }
                 retryTimer = setTimeout(() => {
                     void resolveSession();
-                }, SESSION_RETRY_DELAY_MS);
+                }, SESSION_RETRY_DELAY_MS * attempts);
                 return;
             }
             setSession(resolved);
-            setIsLoading(false);
+            setError(null);
+            setStatus(resolved ? "authenticated" : "unauthenticated");
         };
         void resolveSession();
         return () => {
@@ -88,7 +108,15 @@ export function useSession() {
             if (retryTimer)
                 clearTimeout(retryTimer);
         };
-    }, []);
-    return { session, isLoading };
+    }, [retryToken]);
+    // Callers that only read `isLoading`/`session` (most of the codebase, not
+    // yet migrated to `status`) must not see "unavailable" as "signed out" —
+    // that bounces an authenticated user through sign-in-only UI over a
+    // transient blip. Keeping `isLoading` true here reproduces this hook's
+    // pre-existing behavior for those callers (an indefinite "still resolving"
+    // instead of a wrong answer); only `status`-aware callers get the distinct
+    // "unavailable" treatment with a retry affordance.
+    const isLoading = status === "loading" || status === "unavailable";
+    return { session, isLoading, status, error, retry };
 }
 //# sourceMappingURL=use-session.js.map

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

@@ -26,9 +26,9 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
+    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
-    error?: undefined;
 }>>;
 //# sourceMappingURL=realtime-token.d.ts.map

package/package.json

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