Merge remote-tracking branch 'upstream/dev' into feat/ui-revamp

surfsense_web/features/chat-messages/hitl/approval-cards/generic-approval.tsx

@@ -2,13 +2,11 @@
 
 import { CornerDownLeftIcon, Pencil } from "lucide-react";
 import { useCallback, useEffect, useMemo, useState } from "react";
-import { toast } from "sonner";
 import { TextShimmerLoader } from "@/components/prompt-kit/loader";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Textarea } from "@/components/ui/textarea";
 import { getToolDisplayName } from "@/contracts/enums/toolIcons";
-import { connectorsApiService } from "@/lib/apis/connectors-api.service";
 import type { HitlDecision, InterruptResult, PerToolApprovalCard } from "../types";
 import { useHitlDecision } from "../use-hitl-decision";
 import { useHitlPhase } from "../use-hitl-phase";
@@ -81,12 +79,11 @@ function GenericApprovalCardView({
 
 	const mcpServer = interruptData.context?.mcp_server as string | undefined;
 	const toolDescription = interruptData.context?.tool_description as string | undefined;
-	const mcpConnectorId = interruptData.context?.mcp_connector_id as number | undefined;
-	const isMCPTool = mcpConnectorId != null;
 
 	const reviewConfig = interruptData.review_configs?.[0];
 	const allowedDecisions = reviewConfig?.allowed_decisions ?? ["approve", "reject"];
 	const canEdit = allowedDecisions.includes("edit");
+	const canApproveAlways = allowedDecisions.includes("approve_always");
 
 	const hasChanged = useMemo(() => {
 		return JSON.stringify(editedParams) !== JSON.stringify(args);
@@ -113,16 +110,11 @@ function GenericApprovalCardView({
 		editedParams,
 	]);
 
-	const handleAlwaysAllow = useCallback(() => {
-		if (phase !== "pending" || !isMCPTool) return;
+	const handleApproveAlways = useCallback(() => {
+		if (phase !== "pending" || !canApproveAlways) return;
 		setProcessing();
-		onDecision({ type: "approve" });
-		connectorsApiService.trustMCPTool(mcpConnectorId, toolName).catch(() => {
-			toast.error(
-				"Failed to save 'Always Allow' preference. The tool will still require approval next time."
-			);
-		});
-	}, [phase, setProcessing, onDecision, isMCPTool, mcpConnectorId, toolName]);
+		onDecision({ type: "approve_always" });
+	}, [phase, setProcessing, onDecision, canApproveAlways]);
 
 	useEffect(() => {
 		const handler = (e: KeyboardEvent) => {
@@ -214,8 +206,8 @@ function GenericApprovalCardView({
 								<CornerDownLeftIcon className="size-3 opacity-60" />
 							</Button>
 						)}
-						{isMCPTool && (
-							<Button size="sm" className="rounded-lg" onClick={handleAlwaysAllow}>
+						{canApproveAlways && (
+							<Button size="sm" className="rounded-lg" onClick={handleApproveAlways}>
 								Always Allow
 							</Button>
 						)}

surfsense_web/features/chat-messages/hitl/approval/pending-interrupt-context.tsx

@@ -3,8 +3,10 @@
 import { createContext, type ReactNode, useContext } from "react";
 import type { HitlDecision } from "../types";
 
-/** Snapshot of one in-flight HITL interrupt; ``null`` when nothing is pending. */
+/** One in-flight HITL interrupt (one paused subagent). */
 export interface PendingInterruptState {
+	/** Stable id keyed by the parent ``tool_call_id`` stamped on the interrupt. */
+	interruptId: string;
 	threadId: number;
 	assistantMsgId: string;
 	interruptData: Record<string, unknown>;
@@ -12,8 +14,19 @@ export interface PendingInterruptState {
 }
 
 export interface PendingInterruptValue {
-	pendingInterrupt: PendingInterruptState | null;
-	onSubmit: (decisions: HitlDecision[]) => void;
+	/**
+	 * Every paused subagent for the current turn, in the order the SSE stream
+	 * delivered them — which matches ``state.interrupts`` traversal on the
+	 * backend, which is the order ``slice_decisions_by_tool_call`` consumes.
+	 */
+	pendingInterrupts: PendingInterruptState[];
+	/**
+	 * Stage one card's decisions. The orchestrator (page-level) batches across
+	 * cards and dispatches the resume only once every pending interrupt has
+	 * submitted, so the backend slicer sees a single concatenated decisions
+	 * list whose total matches the parent state's pending action count.
+	 */
+	onSubmit: (interruptId: string, decisions: HitlDecision[]) => void;
 }
 
 const PendingInterruptContext = createContext<PendingInterruptValue | null>(null);
@@ -24,16 +37,16 @@ const PendingInterruptContext = createContext<PendingInterruptValue | null>(null
  * page root.
  */
 export function PendingInterruptProvider({
-	pendingInterrupt,
+	pendingInterrupts,
 	onSubmit,
 	children,
 }: {
-	pendingInterrupt: PendingInterruptState | null;
-	onSubmit: (decisions: HitlDecision[]) => void;
+	pendingInterrupts: PendingInterruptState[];
+	onSubmit: (interruptId: string, decisions: HitlDecision[]) => void;
 	children: ReactNode;
 }) {
 	return (
-		<PendingInterruptContext.Provider value={{ pendingInterrupt, onSubmit }}>
+		<PendingInterruptContext.Provider value={{ pendingInterrupts, onSubmit }}>
 			{children}
 		</PendingInterruptContext.Provider>
 	);

surfsense_web/features/chat-messages/hitl/types.ts

@@ -7,12 +7,12 @@ export interface InterruptActionRequest {
 
 export interface InterruptReviewConfig {
 	action_name: string;
-	allowed_decisions: Array<"approve" | "edit" | "reject">;
+	allowed_decisions: Array<"approve" | "edit" | "reject" | "approve_always">;
 }
 
 export interface InterruptResult<C extends Record<string, unknown> = Record<string, unknown>> {
 	__interrupt__: true;
-	__decided__?: "approve" | "reject" | "edit";
+	__decided__?: "approve" | "reject" | "edit" | "approve_always";
 	__completed__?: boolean;
 	action_requests: InterruptActionRequest[];
 	review_configs: InterruptReviewConfig[];
@@ -31,7 +31,7 @@ export function isInterruptResult(result: unknown): result is InterruptResult {
 }
 
 export interface HitlDecision {
-	type: "approve" | "reject" | "edit";
+	type: "approve" | "reject" | "edit" | "approve_always";
 	message?: string;
 	edited_action?: {
 		name: string;