Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

backend/packages/harness/deerflow/runtime/checkpointer/async_provider.py

@@ -67,10 +67,22 @@ async def _async_checkpointer(config) -> AsyncIterator[Checkpointer]:
         except ImportError as exc:
             raise ImportError(POSTGRES_INSTALL) from exc
 
+        try:
+            from psycopg.rows import dict_row
+            from psycopg_pool import AsyncConnectionPool
+        except ImportError as exc:
+            raise ImportError(POSTGRES_INSTALL) from exc
+
         if not config.connection_string:
             raise ValueError(POSTGRES_CONN_REQUIRED)
 
-        async with AsyncPostgresSaver.from_conn_string(config.connection_string) as saver:
+        pool = AsyncConnectionPool(
+            config.connection_string,
+            kwargs={"autocommit": True, "prepare_threshold": 0, "row_factory": dict_row},
+            check=AsyncConnectionPool.check_connection,
+        )
+        async with pool:
+            saver = AsyncPostgresSaver(conn=pool)
             await saver.setup()
             yield saver
         return
@@ -111,10 +123,22 @@ async def _async_checkpointer_from_database(db_config) -> AsyncIterator[Checkpoi
         except ImportError as exc:
             raise ImportError(POSTGRES_INSTALL) from exc
 
+        try:
+            from psycopg.rows import dict_row
+            from psycopg_pool import AsyncConnectionPool
+        except ImportError as exc:
+            raise ImportError(POSTGRES_INSTALL) from exc
+
         if not db_config.postgres_url:
             raise ValueError("database.postgres_url is required for the postgres backend")
 
-        async with AsyncPostgresSaver.from_conn_string(db_config.postgres_url) as saver:
+        pool = AsyncConnectionPool(
+            db_config.postgres_url,
+            kwargs={"autocommit": True, "prepare_threshold": 0, "row_factory": dict_row},
+            check=AsyncConnectionPool.check_connection,
+        )
+        async with pool:
+            saver = AsyncPostgresSaver(conn=pool)
             await saver.setup()
             yield saver
         return

backend/tests/test_checkpointer.py

@@ -326,6 +326,53 @@ class TestAsyncCheckpointer:
         mock_saver_cls.from_conn_string.assert_called_once_with("/tmp/resolved/test.db")
         mock_saver.setup.assert_awaited_once()
 
+    @pytest.mark.anyio
+    async def test_postgres_uses_connection_pool(self):
+        """Async postgres checkpointer should use AsyncConnectionPool, not a single connection."""
+        from deerflow.runtime.checkpointer.async_provider import make_checkpointer
+
+        mock_config = MagicMock()
+        mock_config.checkpointer = CheckpointerConfig(type="postgres", connection_string="postgresql://localhost/db")
+
+        mock_saver = AsyncMock()
+
+        mock_saver_cls = MagicMock(return_value=mock_saver)
+
+        mock_pool_instance = AsyncMock()
+        mock_pool_instance.__aenter__.return_value = mock_pool_instance
+        mock_pool_instance.__aexit__.return_value = False
+
+        mock_pool_cls = MagicMock(return_value=mock_pool_instance)
+        mock_pool_cls.check_connection = AsyncMock()
+        mock_dict_row = MagicMock()
+
+        mock_pg_module = MagicMock()
+        mock_pg_module.AsyncPostgresSaver = mock_saver_cls
+
+        mock_psycopg_rows = MagicMock()
+        mock_psycopg_rows.dict_row = mock_dict_row
+
+        with (
+            patch("deerflow.runtime.checkpointer.async_provider.get_app_config", return_value=mock_config),
+            patch.dict(sys.modules, {"langgraph.checkpoint.postgres.aio": mock_pg_module}),
+            patch.dict(sys.modules, {"psycopg.rows": mock_psycopg_rows}),
+            patch.dict(sys.modules, {"psycopg_pool": MagicMock(AsyncConnectionPool=mock_pool_cls)}),
+        ):
+            # AsyncConnectionPool() is a callable that returns mock_pool_instance
+            # We need the constructor to be an async context manager
+            async with make_checkpointer() as saver:
+                assert saver is mock_saver
+
+        # Verify the pool was constructed with check Connection
+        mock_pool_cls.assert_called_once()
+        call_kwargs = mock_pool_cls.call_args
+        assert call_kwargs[0][0] == "postgresql://localhost/db"
+        assert call_kwargs[1]["check"] is mock_pool_cls.check_connection
+
+        # Verify saver was constructed with the pool (not via from_conn_string)
+        mock_saver_cls.assert_called_once_with(conn=mock_pool_instance)
+        mock_saver.setup.assert_awaited_once()
+
 
 # ---------------------------------------------------------------------------
 # app_config.py integration

frontend/src/components/ai-elements/code-block.tsx

@@ -1,7 +1,6 @@
 "use client";
 
 import { Button } from "@/components/ui/button";
-import { writeTextToClipboard } from "@/core/clipboard";
 import { cn } from "@/lib/utils";
 import { CheckIcon, CopyIcon } from "lucide-react";
 import {
@@ -147,20 +146,20 @@ export const CodeBlockCopyButton = ({
   const [isCopied, setIsCopied] = useState(false);
   const { code } = useContext(CodeBlockContext);
 
-  const copyToClipboard = () => {
-    void (async () => {
-      const didCopy = await writeTextToClipboard(code);
-      if (!didCopy) {
-        onError?.(new Error("Clipboard API not available"));
-        return;
-      }
+  const copyToClipboard = async () => {
+    if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+      onError?.(new Error("Clipboard API not available"));
+      return;
+    }
 
+    try {
+      await navigator.clipboard.writeText(code);
       setIsCopied(true);
       onCopy?.();
       setTimeout(() => setIsCopied(false), timeout);
-    })().catch((error) => {
+    } catch (error) {
       onError?.(error as Error);
-    });
+    }
   };
 
   const Icon = isCopied ? CheckIcon : CopyIcon;

frontend/src/components/workspace/artifacts/artifact-file-detail.tsx

@@ -38,7 +38,6 @@ import {
   HTML_PREVIEW_SCROLL_MESSAGE_SOURCE,
 } from "@/core/artifacts/preview";
 import { urlOfArtifact } from "@/core/artifacts/utils";
-import { writeTextToClipboard } from "@/core/clipboard";
 import { useI18n } from "@/core/i18n/hooks";
 import { findToolCallResult } from "@/core/messages/utils";
 import { installSkill } from "@/core/skills/api";
@@ -238,20 +237,14 @@ export function ArtifactFileDetail({
                 icon={CopyIcon}
                 label={t.clipboard.copyToClipboard}
                 disabled={!content}
-                onClick={() => {
-                  void (async () => {
-                    const didCopy = await writeTextToClipboard(
-                      visibleContent ?? "",
-                    );
-                    if (!didCopy) {
-                      toast.error(t.clipboard.failedToCopyToClipboard);
-                      return;
-                    }
-
+                onClick={async () => {
+                  try {
+                    await navigator.clipboard.writeText(visibleContent ?? "");
                     toast.success(t.clipboard.copiedToClipboard);
-                  })().catch(() => {
-                    toast.error(t.clipboard.failedToCopyToClipboard);
-                  });
+                  } catch (error) {
+                    toast.error("Failed to copy to clipboard");
+                    console.error(error);
+                  }
                 }}
                 tooltip={t.clipboard.copyToClipboard}
               />

frontend/src/components/workspace/copy-button.tsx

@@ -1,9 +1,7 @@
 import { CheckIcon, CopyIcon } from "lucide-react";
 import { useCallback, useState, type ComponentProps } from "react";
-import { toast } from "sonner";
 
 import { Button } from "@/components/ui/button";
-import { writeTextToClipboard } from "@/core/clipboard";
 import { useI18n } from "@/core/i18n/hooks";
 
 import { Tooltip } from "./tooltip";
@@ -17,19 +15,10 @@ export function CopyButton({
   const { t } = useI18n();
   const [copied, setCopied] = useState(false);
   const handleCopy = useCallback(() => {
-    void (async () => {
-      const didCopy = await writeTextToClipboard(clipboardData);
-      if (!didCopy) {
-        toast.error(t.clipboard.failedToCopyToClipboard);
-        return;
-      }
-
-      setCopied(true);
-      setTimeout(() => setCopied(false), 2000);
-    })().catch(() => {
-      toast.error(t.clipboard.failedToCopyToClipboard);
-    });
-  }, [clipboardData, t.clipboard.failedToCopyToClipboard]);
+    void navigator.clipboard.writeText(clipboardData);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2000);
+  }, [clipboardData]);
   return (
     <Tooltip content={t.clipboard.copyToClipboard}>
       <Button

frontend/src/components/workspace/recent-chat-list.tsx

@@ -43,7 +43,6 @@ import {
   SidebarMenuItem,
 } from "@/components/ui/sidebar";
 import { getAPIClient } from "@/core/api";
-import { writeTextToClipboard } from "@/core/clipboard";
 import { useI18n } from "@/core/i18n/hooks";
 import {
   exportThreadAsJSON,
@@ -127,12 +126,7 @@ export function RecentChatList() {
       const baseUrl = isLocalhost ? VERCEL_URL : window.location.origin;
       const shareUrl = `${baseUrl}${pathOfThread(thread)}`;
       try {
-        const didCopy = await writeTextToClipboard(shareUrl);
-        if (!didCopy) {
-          toast.error(t.clipboard.failedToCopyToClipboard);
-          return;
-        }
-
+        await navigator.clipboard.writeText(shareUrl);
         toast.success(t.clipboard.linkCopied);
       } catch {
         toast.error(t.clipboard.failedToCopyToClipboard);

frontend/src/core/clipboard.ts

@@ -1,31 +0,0 @@
-export async function writeTextToClipboard(text: string): Promise<boolean> {
-  try {
-    const clipboard = globalThis.navigator?.clipboard;
-    if (clipboard?.writeText) {
-      await clipboard.writeText(text);
-      return true;
-    }
-
-    const document = globalThis.document;
-    if (!document?.body?.appendChild || !document.execCommand) {
-      return false;
-    }
-
-    const textarea = document.createElement("textarea");
-    textarea.value = text;
-    textarea.setAttribute("readonly", "");
-    textarea.style.position = "fixed";
-    textarea.style.top = "-9999px";
-    textarea.style.left = "-9999px";
-    document.body.appendChild(textarea);
-    textarea.select();
-
-    try {
-      return document.execCommand("copy");
-    } finally {
-      textarea.remove();
-    }
-  } catch {
-    return false;
-  }
-}

frontend/src/core/messages/utils.ts

@@ -266,42 +266,22 @@ export function extractTextFromMessage(message: Message) {
   return "";
 }
 
-const THINK_OPEN_TAG = "<think>";
 const THINK_TAG_RE = /<think>\s*([\s\S]*?)\s*<\/think>/g;
 
 function splitInlineReasoning(content: string) {
   const reasoningParts: string[] = [];
-
-  // First pass: strip every fully closed `<think>...</think>` pair and
-  // collect its body as reasoning.
-  let cleaned = content.replace(THINK_TAG_RE, (_, reasoning: string) => {
-    const normalized = reasoning.trim();
-    if (normalized) {
-      reasoningParts.push(normalized);
-    }
-    return "";
-  });
-
-  // Streaming-safe pass: a `<think>` opener whose `</think>` has not arrived
-  // yet means the rest of the chunk is reasoning in flight. Route it into the
-  // reasoning slot instead of letting it render as message content (the
-  // raw-HTML markdown pipeline would otherwise paint the inner text on
-  // screen until the closing tag lands).
-  //
-  // Skip when the opener sits right after a backtick — that is the model
-  // talking about `<think>` literally inside markdown inline code, not
-  // actually streaming reasoning.
-  const openTagIndex = cleaned.indexOf(THINK_OPEN_TAG);
-  if (openTagIndex !== -1 && cleaned[openTagIndex - 1] !== "`") {
-    const tail = cleaned.slice(openTagIndex + THINK_OPEN_TAG.length).trim();
-    if (tail) {
-      reasoningParts.push(tail);
-    }
-    cleaned = cleaned.slice(0, openTagIndex);
-  }
+  const cleaned = content
+    .replace(THINK_TAG_RE, (_, reasoning: string) => {
+      const normalized = reasoning.trim();
+      if (normalized) {
+        reasoningParts.push(normalized);
+      }
+      return "";
+    })
+    .trim();
 
   return {
-    content: cleaned.trim(),
+    content: cleaned,
     reasoning: reasoningParts.length > 0 ? reasoningParts.join("\n\n") : null,
   };
 }

frontend/tests/unit/core/clipboard.test.ts

@@ -1,146 +0,0 @@
-import { afterEach, expect, test, vi } from "vitest";
-
-import { writeTextToClipboard } from "@/core/clipboard";
-
-const originalNavigator = globalThis.navigator;
-const hadOriginalNavigator = "navigator" in globalThis;
-const originalDocument = globalThis.document;
-const hadOriginalDocument = "document" in globalThis;
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  if (!hadOriginalNavigator) {
-    Reflect.deleteProperty(globalThis, "navigator");
-  } else {
-    Object.defineProperty(globalThis, "navigator", {
-      configurable: true,
-      value: originalNavigator,
-    });
-  }
-
-  if (!hadOriginalDocument) {
-    Reflect.deleteProperty(globalThis, "document");
-  } else {
-    Object.defineProperty(globalThis, "document", {
-      configurable: true,
-      value: originalDocument,
-    });
-  }
-});
-
-test("writes text with the Clipboard API when available", async () => {
-  const writeText = vi.fn().mockResolvedValue(undefined);
-  Object.defineProperty(globalThis, "navigator", {
-    configurable: true,
-    value: {
-      clipboard: {
-        writeText,
-      },
-    },
-  });
-
-  await expect(writeTextToClipboard("hello")).resolves.toBe(true);
-  expect(writeText).toHaveBeenCalledWith("hello");
-});
-
-test("returns false when Clipboard API is unavailable", async () => {
-  Object.defineProperty(globalThis, "navigator", {
-    configurable: true,
-    value: {},
-  });
-  Object.defineProperty(globalThis, "document", {
-    configurable: true,
-    value: undefined,
-  });
-
-  await expect(writeTextToClipboard("hello")).resolves.toBe(false);
-});
-
-test("falls back to execCommand when Clipboard API is unavailable", async () => {
-  const textarea = {
-    remove: vi.fn(),
-    select: vi.fn(),
-    setAttribute: vi.fn(),
-    style: {},
-    value: "",
-  };
-  const appendChild = vi.fn();
-  const execCommand = vi.fn().mockReturnValue(true);
-
-  Object.defineProperty(globalThis, "navigator", {
-    configurable: true,
-    value: {},
-  });
-  Object.defineProperty(globalThis, "document", {
-    configurable: true,
-    value: {
-      body: {
-        appendChild,
-      },
-      createElement: vi.fn().mockReturnValue(textarea),
-      execCommand,
-    },
-  });
-
-  await expect(writeTextToClipboard("hello")).resolves.toBe(true);
-  expect(textarea.value).toBe("hello");
-  expect(appendChild).toHaveBeenCalledWith(textarea);
-  expect(textarea.select).toHaveBeenCalled();
-  expect(execCommand).toHaveBeenCalledWith("copy");
-  expect(textarea.remove).toHaveBeenCalled();
-});
-
-test("returns false when execCommand fallback fails", async () => {
-  const textarea = {
-    remove: vi.fn(),
-    select: vi.fn(),
-    setAttribute: vi.fn(),
-    style: {},
-    value: "",
-  };
-
-  Object.defineProperty(globalThis, "navigator", {
-    configurable: true,
-    value: {},
-  });
-  Object.defineProperty(globalThis, "document", {
-    configurable: true,
-    value: {
-      body: {
-        appendChild: vi.fn(),
-      },
-      createElement: vi.fn().mockReturnValue(textarea),
-      execCommand: vi.fn().mockReturnValue(false),
-    },
-  });
-
-  await expect(writeTextToClipboard("hello")).resolves.toBe(false);
-  expect(textarea.remove).toHaveBeenCalled();
-});
-
-test("returns false when navigator is unavailable", async () => {
-  Object.defineProperty(globalThis, "navigator", {
-    configurable: true,
-    value: undefined,
-  });
-  Object.defineProperty(globalThis, "document", {
-    configurable: true,
-    value: undefined,
-  });
-
-  await expect(writeTextToClipboard("hello")).resolves.toBe(false);
-});
-
-test("returns false when Clipboard API rejects", async () => {
-  const writeText = vi.fn().mockRejectedValue(new Error("denied"));
-  Object.defineProperty(globalThis, "navigator", {
-    configurable: true,
-    value: {
-      clipboard: {
-        writeText,
-      },
-    },
-  });
-
-  await expect(writeTextToClipboard("hello")).resolves.toBe(false);
-});

frontend/tests/unit/core/messages/utils.test.ts

@@ -1,26 +1,14 @@
 import type { Message } from "@langchain/langgraph-sdk";
-import { describe, expect, test } from "vitest";
+import { expect, test } from "vitest";
 
 import {
-  extractContentFromMessage,
-  extractReasoningContentFromMessage,
   getAssistantTurnCopyData,
   getAssistantTurnUsageMessages,
   getMessageGroups,
   getStreamingMessageLookup,
-  hasContent,
-  hasReasoning,
   isAssistantMessageGroupStreaming,
 } from "@/core/messages/utils";
 
-function aiMessage(content: string): Message {
-  return {
-    id: "ai-1",
-    type: "ai",
-    content,
-  } as Message;
-}
-
 test("aggregates token usage messages once per assistant turn", () => {
   const messages = [
     {
@@ -79,100 +67,6 @@ test("aggregates token usage messages once per assistant turn", () => {
   ).toEqual([null, null, ["ai-1", "ai-2"], null, ["ai-3"]]);
 });
 
-describe("inline <think> tag splitting", () => {
-  test("strips a fully closed <think> block from AI content", () => {
-    const message = aiMessage("<think>internal reasoning</think>final answer");
-    expect(extractContentFromMessage(message)).toBe("final answer");
-    expect(extractReasoningContentFromMessage(message)).toBe(
-      "internal reasoning",
-    );
-  });
-
-  test("strips multiple closed <think> blocks and joins their reasoning", () => {
-    const message = aiMessage(
-      "<think>step one</think>between<think>step two</think>after",
-    );
-    expect(extractContentFromMessage(message)).toBe("betweenafter");
-    expect(extractReasoningContentFromMessage(message)).toBe(
-      "step one\n\nstep two",
-    );
-  });
-
-  test("during streaming, an unclosed <think> tag does not leak its tail into content", () => {
-    // Simulates accumulated content mid-stream, before </think> arrives.
-    const message = aiMessage(
-      "<think>I need to analyze the user's question step by",
-    );
-    expect(extractContentFromMessage(message)).toBe("");
-    expect(extractContentFromMessage(message)).not.toContain("<think>");
-    expect(extractReasoningContentFromMessage(message)).toBe(
-      "I need to analyze the user's question step by",
-    );
-  });
-
-  test("preamble before an unclosed <think> stays in content", () => {
-    const message = aiMessage(
-      "Here is part of the answer.<think>but wait, let me reconsider",
-    );
-    expect(extractContentFromMessage(message)).toBe(
-      "Here is part of the answer.",
-    );
-    expect(extractReasoningContentFromMessage(message)).toBe(
-      "but wait, let me reconsider",
-    );
-  });
-
-  test("closed <think> followed by a trailing unclosed <think> merges both into reasoning", () => {
-    const message = aiMessage(
-      "<think>first step</think>partial answer<think>second step still streaming",
-    );
-    expect(extractContentFromMessage(message)).toBe("partial answer");
-    expect(extractReasoningContentFromMessage(message)).toBe(
-      "first step\n\nsecond step still streaming",
-    );
-  });
-
-  test("hasReasoning recognises an unclosed <think> tag mid-stream", () => {
-    expect(hasReasoning(aiMessage("<think>thinking in progress"))).toBe(true);
-  });
-
-  test("hasContent excludes an unclosed <think> tail when no preamble exists", () => {
-    expect(hasContent(aiMessage("<think>thinking in progress"))).toBe(false);
-  });
-
-  test("hasContent stays true when preamble precedes an unclosed <think>", () => {
-    expect(hasContent(aiMessage("preamble<think>still thinking"))).toBe(true);
-  });
-
-  test("a lone <think> open tag with no body yields no reasoning and no content", () => {
-    const message = aiMessage("<think>");
-    expect(extractContentFromMessage(message)).toBe("");
-    expect(extractReasoningContentFromMessage(message)).toBeNull();
-    expect(hasReasoning(message)).toBe(false);
-  });
-
-  test("a literal <think> inside markdown inline code is not treated as reasoning", () => {
-    const message = aiMessage(
-      "Use `<think>` markers to delimit reasoning sections.",
-    );
-    expect(extractContentFromMessage(message)).toBe(
-      "Use `<think>` markers to delimit reasoning sections.",
-    );
-    expect(extractReasoningContentFromMessage(message)).toBeNull();
-    expect(hasReasoning(message)).toBe(false);
-  });
-
-  test("a backtick-prefixed <think> mid-stream is not split into reasoning", () => {
-    // Simulates the moment the model has emitted the opening backtick and
-    // `<think>` for a literal documentation reference, before the closing
-    // backtick arrives. The pre-fix behaviour would have permanently
-    // truncated the content here.
-    const message = aiMessage("Documentation: `<think>");
-    expect(extractContentFromMessage(message)).toBe("Documentation: `<think>");
-    expect(extractReasoningContentFromMessage(message)).toBeNull();
-  });
-});
-
 test("hides internal todo reminder messages from message groups", () => {
   const messages = [
     {