From 569c7203aa24b95440682983ce7940ba1d4247bd Mon Sep 17 00:00:00 2001 From: Dotta <34892728+cryppadotta@users.noreply.github.com> Date: Sat, 3 Oct 2026 06:52:49 -0500 Subject: [PATCH] fix(ui): use latest issue runtime callbacks (#14863) ## Thinking Path > - Paperclip lets people manage AI agents and their work. > - The issue page uses an external-store adapter for comments. > - The adapter must keep one identity during an unrelated render. > - The adapter must also call the newest send and cancel functions. > - Passive effects update those functions too late for a synchronous runtime call. > - This pull request updates the function refs during render and adds a regression test. > - The benefit is a stable comment thread with no stale comment action. ## Linked Issues or Issue Description Refs #3678 **What happened?** The issue comment runtime can call the prior send function after a render. The callback refs do not update until passive effects run. **Expected behavior** The stable runtime adapter must call the newest function as soon as the render supplies it. **Steps to reproduce** 1. Render the issue runtime with one send function. 2. Render it again with a new send function and the same thread data. 3. Call the stable adapter before passive effects run. 4. Observe that the prior send function runs. **Paperclip version or commit** `6395cae072` **Deployment mode** Local development from source. **Agent adapter(s) involved** This is a core UI bug. It is not adapter-specific. ## What Changed - Update the latest send and cancel refs during render. - Keep the external-store adapter stable across callback-only renders. - Add a test for a runtime callback before passive effects run. ## Verification - `pnpm --filter @paperclipai/ui exec vitest run src/hooks/usePaperclipIssueRuntime.test.tsx` - `pnpm --filter @paperclipai/ui typecheck` - `pnpm check:token-gates` - `pnpm -r typecheck` - `pnpm test:run` - `pnpm build` ## Risks - Low risk. The change only updates two refs earlier in the same render. - The adapter identity and its data dependencies do not change. > This bug fix does not add or overlap with a roadmap feature. ## Model Used - OpenAI Codex with GPT-5. The exact deployed model ID and context window are not exposed. Reasoning, tool use, and local code execution were enabled. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [x] All Paperclip CI gates are green - [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge --------- Co-authored-by: Paperclip --- .../hooks/usePaperclipIssueRuntime.test.tsx | 86 ++++++++++++++++++- ui/src/hooks/usePaperclipIssueRuntime.ts | 12 +-- 2 files changed, 85 insertions(+), 13 deletions(-) diff --git a/ui/src/hooks/usePaperclipIssueRuntime.test.tsx b/ui/src/hooks/usePaperclipIssueRuntime.test.tsx index 4d51c8ce248..81a38deb264 100644 --- a/ui/src/hooks/usePaperclipIssueRuntime.test.tsx +++ b/ui/src/hooks/usePaperclipIssueRuntime.test.tsx @@ -1,6 +1,6 @@ // @vitest-environment jsdom -import { act } from "react"; +import { act, useLayoutEffect } from "react"; import { createRoot } from "react-dom/client"; import { afterEach, describe, expect, it, vi } from "vitest"; import type { @@ -10,9 +10,22 @@ import type { } from "@assistant-ui/react"; import { usePaperclipIssueRuntime } from "./usePaperclipIssueRuntime"; -const { useExternalStoreRuntimeMock } = vi.hoisted(() => ({ - useExternalStoreRuntimeMock: vi.fn(() => ({ kind: "runtime" })), -})); +const { externalStoreRuntimeState, useExternalStoreRuntimeMock } = vi.hoisted( + () => { + const state: { + adapter: ExternalStoreAdapter | undefined; + } = { adapter: undefined }; + return { + externalStoreRuntimeState: state, + useExternalStoreRuntimeMock: vi.fn( + (adapter: ExternalStoreAdapter) => { + state.adapter = adapter; + return { kind: "runtime" }; + }, + ), + }; + }, +); vi.mock("@assistant-ui/react", () => ({ useExternalStoreRuntime: useExternalStoreRuntimeMock, @@ -26,6 +39,7 @@ function HookHarness({ isRunning, onSend, onCancel, + onLayout, }: { messages: readonly ThreadMessage[]; isRunning: boolean; @@ -38,6 +52,7 @@ function HookHarness({ }; }) => Promise; onCancel?: (() => Promise) | undefined; + onLayout?: ((adapter: ExternalStoreAdapter) => void) | undefined; }) { usePaperclipIssueRuntime({ messages, @@ -45,6 +60,11 @@ function HookHarness({ onSend, onCancel, }); + useLayoutEffect(() => { + if (externalStoreRuntimeState.adapter && onLayout) { + onLayout(externalStoreRuntimeState.adapter); + } + }, [onLayout]); return null; } @@ -86,6 +106,7 @@ function createAssistantMessage(id: string, text: string): ThreadMessage { describe("usePaperclipIssueRuntime", () => { afterEach(() => { useExternalStoreRuntimeMock.mockReset(); + externalStoreRuntimeState.adapter = undefined; }); it("forwards explicit upload selection separately from Markdown content", async () => { @@ -177,6 +198,63 @@ describe("usePaperclipIssueRuntime", () => { container.remove(); }); + it("uses the latest callbacks before passive effects run", async () => { + const container = document.createElement("div"); + document.body.appendChild(container); + const root = createRoot(container); + const messages: ThreadMessage[] = [createUserMessage("message-1", "hello")]; + const firstOnSend = vi.fn(async () => {}); + const secondOnSend = vi.fn(async () => {}); + const firstOnCancel = vi.fn(async () => {}); + const secondOnCancel = vi.fn(async () => {}); + + act(() => { + root.render( + , + ); + }); + + let immediateSend: Promise | undefined; + let immediateCancel: Promise | undefined; + + act(() => { + root.render( + { + immediateSend = adapter.onNew?.( + createAppendMessage("layout runtime callback"), + ); + immediateCancel = adapter.onCancel?.(); + }} + />, + ); + }); + await Promise.all([immediateSend, immediateCancel]); + + expect(firstOnSend).not.toHaveBeenCalled(); + expect(firstOnCancel).not.toHaveBeenCalled(); + expect(secondOnSend).toHaveBeenCalledWith({ + body: "layout runtime callback", + reopen: undefined, + reassignment: undefined, + }); + expect(secondOnCancel).toHaveBeenCalledOnce(); + + act(() => { + root.unmount(); + }); + container.remove(); + }); + it("rebuilds the adapter when thread data changes", () => { const container = document.createElement("div"); document.body.appendChild(container); diff --git a/ui/src/hooks/usePaperclipIssueRuntime.ts b/ui/src/hooks/usePaperclipIssueRuntime.ts index 494e3a444b1..19d6fdf66f8 100644 --- a/ui/src/hooks/usePaperclipIssueRuntime.ts +++ b/ui/src/hooks/usePaperclipIssueRuntime.ts @@ -1,4 +1,4 @@ -import { useEffect, useMemo, useRef } from "react"; +import { useMemo, useRef } from "react"; import { useExternalStoreRuntime, type ThreadMessage, @@ -52,14 +52,8 @@ export function usePaperclipIssueRuntime({ }: UsePaperclipIssueRuntimeOptions) { const onSendRef = useRef(onSend); const onCancelRef = useRef(onCancel); - - useEffect(() => { - onSendRef.current = onSend; - }, [onSend]); - - useEffect(() => { - onCancelRef.current = onCancel; - }, [onCancel]); + onSendRef.current = onSend; + onCancelRef.current = onCancel; const adapter = useMemo>( () => ({