iris-chatbot 5.2.0 → 5.3.1

package/template/src/components/ChatView.tsx

@@ -280,16 +280,79 @@ function resolveMusicTargetFromResult(result: unknown): string | null {
   return artist ? `${title} by ${artist}` : title;
 }
 
-function toApprovalStatus(decision: "approve" | "deny" | "timeout") {
+function toApprovalStatus(decision: "approve" | "deny" | "timeout" | "supersede") {
   if (decision === "approve") {
     return "approved" as const;
   }
   if (decision === "deny") {
     return "denied" as const;
   }
+  if (decision === "supersede") {
+    return "superseded" as const;
+  }
   return "timeout" as const;
 }
 
+function isDraftSendApproval(
+  approval: ToolApproval,
+): approval is ToolApproval & { toolName: "mail_send" | "messages_send" } {
+  return approval.toolName === "mail_send" || approval.toolName === "messages_send";
+}
+
+type PendingDraftContext = {
+  toolName: "mail_send" | "messages_send";
+  to: string[];
+  cc: string[];
+  subject: string;
+  body: string;
+};
+
+function parsePendingDraftContext(approval: ToolApproval): PendingDraftContext | null {
+  if (!isDraftSendApproval(approval)) {
+    return null;
+  }
+  if (!approval.argsJson) {
+    return null;
+  }
+
+  let payload: unknown;
+  try {
+    payload = JSON.parse(approval.argsJson);
+  } catch {
+    return null;
+  }
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  const record = payload as Record<string, unknown>;
+
+  const to = Array.isArray(record.to) ? record.to.filter((value): value is string => typeof value === "string") : [];
+  const cc = Array.isArray(record.cc) ? record.cc.filter((value): value is string => typeof value === "string") : [];
+  const subject = typeof record.subject === "string" ? record.subject : "";
+  const body = typeof record.body === "string" ? record.body : "";
+
+  return {
+    toolName: approval.toolName,
+    to,
+    cc,
+    subject,
+    body,
+  };
+}
+
+function isLikelyDraftEditFollowup(input: string): boolean {
+  const text = input.replace(/\s+/g, " ").trim();
+  if (!text) {
+    return false;
+  }
+  const editVerb = /\b(edit|rewrite|change|update|improve|polish|adjust|expand|shorten|lengthen|make)\b/i.test(text);
+  const draftNoun = /\b(email|mail|message|text|draft|subject|body)\b/i.test(text);
+  const toneOrLength =
+    /\b(longer|shorter|formal|casual|professional|friendly|polite|concise|detailed|brief)\b/i.test(text);
+  const pronounEdit = /\b(make|rewrite|edit|change|update)\s+(?:it|this)\b/i.test(text);
+  return (editVerb && draftNoun) || toneOrLength || pronounEdit;
+}
+
 type MicMode = "off" | "dictation";
 type MicState = "idle" | "listening" | "processing";
 
@@ -341,7 +404,8 @@ export default function ChatView({
   const lastFollowScrollAtRef = useRef(0);
   const smoothFollowUntilRef = useRef(0);
   const abortControllersRef = useRef<Map<string, AbortController>>(new Map());
-  const inflightThreadIdsRef = useRef<Set<string>>(new Set());
+  const inflightThreadIdsRef = useRef<Map<string, number>>(new Map());
+  const streamingByThreadRef = useRef<Record<string, string>>({});
   const micModeRef = useRef<MicMode>("off");
   const micStateRef = useRef<MicState>("idle");
   const currentInputRef = useRef("");
@@ -500,6 +564,18 @@ export default function ChatView({
     }
     return streamingByThread[thread.id] ?? null;
   }, [streamingByThread, thread?.id]);
+  const pendingDraftApprovalMessageIds = useMemo(() => {
+    const set = new Set<string>();
+    for (const approval of toolApprovals) {
+      if (approval.status === "requested" && isDraftSendApproval(approval)) {
+        set.add(approval.assistantMessageId);
+      }
+    }
+    return set;
+  }, [toolApprovals]);
+  const isAwaitingDraftApproval = activeStreamingMessageId
+    ? pendingDraftApprovalMessageIds.has(activeStreamingMessageId)
+    : false;
   const micSupported = getSpeechRecognitionCtor() !== null;
 
   const toolEventsByMessage = useMemo(() => {
@@ -563,6 +639,10 @@ export default function ChatView({
     setInput(parts.join(" ").trim());
   }, []);
 
+  useEffect(() => {
+    streamingByThreadRef.current = streamingByThread;
+  }, [streamingByThread]);
+
   useEffect(() => {
     const controllers = abortControllersRef.current;
     const inflightThreadIds = inflightThreadIdsRef.current;
@@ -642,34 +722,81 @@ export default function ChatView({
     });
   }, [thread?.id, activeThreadId]);
 
-  const handleApprovalDecision = useCallback(
-    async (approvalId: string, decision: "approve" | "deny") => {
-      setApprovalBusyIds((current) => ({
-        ...current,
-        [approvalId]: true,
-      }));
+  const resolveApprovalDecision = useCallback(
+    async (params: {
+      approvalId: string;
+      decision: "approve" | "deny" | "supersede";
+      argsOverride?: Record<string, unknown>;
+      source?: "user" | "system";
+      reasonCode?: "user_cancel" | "internal_replace" | "timeout" | "other";
+      busy?: boolean;
+      suppressErrors?: boolean;
+    }) => {
+      const {
+        approvalId,
+        decision,
+        argsOverride,
+        source = "user",
+        reasonCode,
+        busy = true,
+        suppressErrors = false,
+      } = params;
+
+      if (busy) {
+        setApprovalBusyIds((current) => ({
+          ...current,
+          [approvalId]: true,
+        }));
+      }
 
       try {
+        const payload: {
+          approvalId: string;
+          decision: "approve" | "deny" | "supersede";
+          source: "user" | "system";
+          reasonCode?: "user_cancel" | "internal_replace" | "timeout" | "other";
+          args?: Record<string, unknown>;
+        } = { approvalId, decision, source };
+        if (reasonCode) {
+          payload.reasonCode = reasonCode;
+        }
+        if (decision === "approve" && argsOverride) {
+          payload.args = argsOverride;
+        }
+
         const response = await fetch("/api/tool-approval", {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ approvalId, decision }),
+          body: JSON.stringify(payload),
         });
 
         if (!response.ok) {
-          const payload = await response.json().catch(() => ({}));
-          throw new Error(payload.error || "Failed to resolve approval.");
+          const responsePayload = await response.json().catch(() => ({}));
+          const message = responsePayload.error || "Failed to resolve approval.";
+          if (!suppressErrors) {
+            throw new Error(message);
+          }
+          return;
         }
 
         await db.toolApprovals.update(approvalId, {
           status: toApprovalStatus(decision),
           resolvedAt: Date.now(),
+          ...(decision === "approve" && argsOverride
+            ? { argsJson: JSON.stringify(argsOverride) }
+            : {}),
         });
       } catch (err) {
+        if (suppressErrors) {
+          return;
+        }
         const message =
           err instanceof Error ? err.message : "Unable to resolve approval.";
         setError(message);
       } finally {
+        if (!busy) {
+          return;
+        }
         setApprovalBusyIds((current) => {
           if (!current[approvalId]) {
             return current;
@@ -680,7 +807,38 @@ export default function ChatView({
         });
       }
     },
-    []
+    [],
+  );
+
+  const handleApprovalDecision = useCallback(
+    async (
+      approvalId: string,
+      decision: "approve" | "deny",
+      argsOverride?: Record<string, unknown>,
+    ) => {
+      await resolveApprovalDecision({
+        approvalId,
+        decision,
+        argsOverride,
+        source: "user",
+        reasonCode: decision === "deny" ? "user_cancel" : undefined,
+      });
+    },
+    [resolveApprovalDecision],
+  );
+
+  const resolveApprovalSystemSupersede = useCallback(
+    async (approvalId: string) => {
+      await resolveApprovalDecision({
+        approvalId,
+        decision: "supersede",
+        source: "system",
+        reasonCode: "internal_replace",
+        busy: false,
+        suppressErrors: true,
+      });
+    },
+    [resolveApprovalDecision],
   );
 
   const startMicRecognitionSession = useCallback(
@@ -937,6 +1095,7 @@ export default function ChatView({
     const trimmed = (overrideInput ?? input).trim();
     const hasQuoted = Boolean(quotedContext);
     if (!trimmed && !hasQuoted) return;
+    let draftEditContextForRequest: PendingDraftContext | null = null;
     const sendTriggeredByMic =
       typeof overrideInput === "string" || micModeRef.current !== "off";
     const stopMicAfterValidationFailure = () => {
@@ -987,15 +1146,51 @@ export default function ChatView({
       setMicState("processing");
     }
 
-    if (
-      streamingByThread[resolvedThread.id] ||
-      inflightThreadIdsRef.current.has(resolvedThread.id)
-    ) {
+    const isThreadLocked = () =>
+      Boolean(streamingByThreadRef.current[resolvedThread.id]) ||
+      (inflightThreadIdsRef.current.get(resolvedThread.id) ?? 0) > 0;
+    if (isThreadLocked()) {
+      const pendingDraftApprovals = toolApprovals.filter(
+        (approval) =>
+          approval.threadId === resolvedThread.id &&
+          approval.status === "requested" &&
+          isDraftSendApproval(approval),
+      );
+
+      if (pendingDraftApprovals.length > 0) {
+        if (isLikelyDraftEditFollowup(trimmed)) {
+          const latestPendingApproval = [...pendingDraftApprovals].sort(
+            (left, right) => right.requestedAt - left.requestedAt,
+          )[0];
+          const parsedDraft = parsePendingDraftContext(latestPendingApproval);
+          if (parsedDraft) {
+            draftEditContextForRequest = parsedDraft;
+          }
+        }
+
+        for (const approval of pendingDraftApprovals) {
+          await resolveApprovalSystemSupersede(approval.id);
+        }
+
+        const controller = abortControllersRef.current.get(resolvedThread.id);
+        controller?.abort();
+
+        const unlockDeadline = Date.now() + 1500;
+        while (isThreadLocked() && Date.now() < unlockDeadline) {
+          await new Promise((resolve) => window.setTimeout(resolve, 25));
+        }
+      }
+    }
+
+    if (isThreadLocked()) {
       setError("This thread is already responding.");
       return;
     }
 
-    inflightThreadIdsRef.current.add(resolvedThread.id);
+    inflightThreadIdsRef.current.set(
+      resolvedThread.id,
+      (inflightThreadIdsRef.current.get(resolvedThread.id) ?? 0) + 1,
+    );
     setError(null);
     setInput("");
     const capturedQuotedContext = quotedContext;
@@ -1136,7 +1331,6 @@ export default function ChatView({
           siblingThreadsContext,
       });
     }
-
     payloadMessages.push(
       ...history
         .filter((message) => message.role !== "system")
@@ -1209,6 +1403,18 @@ export default function ChatView({
             threadId: resolvedThread.id,
             conversationId: resolvedThread.conversationId,
             assistantMessageId: assistantMessage.id,
+            ...(draftEditContextForRequest
+              ? {
+                forceToolRouting: true,
+                draftEditContext: {
+                  toolName: draftEditContextForRequest.toolName,
+                  to: draftEditContextForRequest.to,
+                  cc: draftEditContextForRequest.cc,
+                  subject: draftEditContextForRequest.subject,
+                  body: draftEditContextForRequest.body,
+                },
+              }
+              : {}),
           },
         }),
         signal: controller.signal,
@@ -1512,10 +1718,17 @@ export default function ChatView({
       });
       setError(message);
     } finally {
-      inflightThreadIdsRef.current.delete(resolvedThread.id);
-      abortControllersRef.current.delete(resolvedThread.id);
+      const currentInflight = inflightThreadIdsRef.current.get(resolvedThread.id) ?? 0;
+      if (currentInflight <= 1) {
+        inflightThreadIdsRef.current.delete(resolvedThread.id);
+      } else {
+        inflightThreadIdsRef.current.set(resolvedThread.id, currentInflight - 1);
+      }
+      if (abortControllersRef.current.get(resolvedThread.id) === controller) {
+        abortControllersRef.current.delete(resolvedThread.id);
+      }
       setStreamingByThread((current) => {
-        if (!current[resolvedThread.id]) {
+        if (current[resolvedThread.id] !== assistantMessage.id) {
           return current;
         }
         const next = { ...current };
@@ -1553,7 +1766,8 @@ export default function ChatView({
     threads,
     activeThreadId,
     onOpenSettings,
-    streamingByThread,
+    toolApprovals,
+    resolveApprovalSystemSupersede,
     scrollToBottom,
     setFocusedMessageId,
     maybeAutoScrollToBottom,
@@ -1641,7 +1855,10 @@ export default function ChatView({
               activeThreadId={activeThreadId}
               onSelectThread={onSelectThread}
               onDeleteThread={handleDeleteBranch}
-              isStreaming={activeStreamingMessageId === message.id}
+              isStreaming={
+                activeStreamingMessageId === message.id &&
+                !pendingDraftApprovalMessageIds.has(message.id)
+              }
               toolEvents={messageToolEvents}
               approvals={messageApprovals}
               onResolveApproval={handleApprovalDecision}
@@ -1659,6 +1876,7 @@ export default function ChatView({
       onSelectThread,
       handleDeleteBranch,
       activeStreamingMessageId,
+      pendingDraftApprovalMessageIds,
       toolEventsByMessage,
       toolApprovalsByMessage,
       handleApprovalDecision,
@@ -1688,10 +1906,11 @@ export default function ChatView({
                   void handleSend();
                 }}
                 onStop={handleStop}
-                isStreaming={Boolean(activeStreamingMessageId)}
+                isStreaming={Boolean(activeStreamingMessageId) && !isAwaitingDraftApproval}
+                showStopWhenStreaming={!isAwaitingDraftApproval}
                 onMicToggle={handleMicToggle}
                 micState={micState}
-                micDisabled={Boolean(activeStreamingMessageId)}
+                micDisabled={Boolean(activeStreamingMessageId) && !isAwaitingDraftApproval}
                 quotedContext={quotedContext}
                 onClearQuotedContext={handleClearQuotedContext}
               />
@@ -1753,10 +1972,11 @@ export default function ChatView({
                   void handleSend();
                 }}
                 onStop={handleStop}
-                isStreaming={Boolean(activeStreamingMessageId)}
+                isStreaming={Boolean(activeStreamingMessageId) && !isAwaitingDraftApproval}
+                showStopWhenStreaming={!isAwaitingDraftApproval}
                 onMicToggle={handleMicToggle}
                 micState={micState}
-                micDisabled={Boolean(activeStreamingMessageId)}
+                micDisabled={Boolean(activeStreamingMessageId) && !isAwaitingDraftApproval}
                 quotedContext={quotedContext}
                 onClearQuotedContext={handleClearQuotedContext}
               />

package/template/src/components/Composer.tsx

@@ -18,6 +18,7 @@ export default function Composer({
   onSend,
   onStop,
   isStreaming,
+  showStopWhenStreaming = true,
   onMicToggle,
   micState = "idle",
   micDisabled = false,
@@ -29,6 +30,7 @@ export default function Composer({
   onSend: () => void;
   onStop: () => void;
   isStreaming: boolean;
+  showStopWhenStreaming?: boolean;
   onMicToggle?: () => void;
   micState?: "idle" | "listening" | "processing";
   micDisabled?: boolean;
@@ -177,13 +179,15 @@ export default function Composer({
           </button>
         ) : null}
         {isStreaming ? (
-          <button
-            onClick={onStop}
-            className="flex items-center gap-2 rounded-full border border-[var(--border)] bg-[var(--panel-2)] px-3 py-2 text-xs text-[var(--text-secondary)]"
-          >
-            <Square className="h-3 w-3" />
-            Stop
-          </button>
+          showStopWhenStreaming ? (
+            <button
+              onClick={onStop}
+              className="flex items-center gap-2 rounded-full border border-[var(--border)] bg-[var(--panel-2)] px-3 py-2 text-xs text-[var(--text-secondary)]"
+            >
+              <Square className="h-3 w-3" />
+              Stop
+            </button>
+          ) : null
         ) : (
           <button
             onClick={onSend}
@@ -196,4 +200,3 @@ export default function Composer({
     </div>
   );
 }
-