Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🔀 feat: Show the Conversation Pull Request in the Sidebar List (#16815)
Marco Berettacaeb786e97a1
diff --git a/api/server/routes/__test-utils__/convos-route-mocks.js b/api/server/routes/__test-utils__/convos-route-mocks.jsindex ce6a630d93..402c0877dd 100644--- a/api/server/routes/__test-utils__/convos-route-mocks.js+++ b/api/server/routes/__test-utils__/convos-route-mocks.js@@ -148,7 +148,9 @@ module.exports = {),createBackgroundTaskPolicyMiddleware: jest.fn(() => (_req, _res, next) => next()),createGitHubPullRequestSource: jest.fn(() => ({ find: jest.fn() })),+ createProxyAwareFetch: jest.fn(() => jest.fn()),createPullRequestLookup: jest.fn(() => jest.fn()),+ createConversationPullRequestsHandler: jest.fn(() => jest.fn()),createConversationPullRequestHandler: jest.fn(() => (_req, res) => res.status(200).json({ pullRequest: null }),),diff --git a/api/server/routes/__tests__/config.spec.js b/api/server/routes/__tests__/config.spec.jsindex 07f4de4234..c6386d6867 100644--- a/api/server/routes/__tests__/config.spec.js+++ b/api/server/routes/__tests__/config.spec.js@@ -181,6 +181,7 @@ describe('GET /api/config', () => {expect(response.body).not.toHaveProperty('conversationImportMaxFileSize');expect(response.body).not.toHaveProperty('insightsEnabled');expect(response.body).not.toHaveProperty('pullRequestsEnabled');+ expect(response.body).not.toHaveProperty('pullRequestsBatchVersion');expect(response.body).not.toHaveProperty('mcpApps');});@@ -683,9 +684,26 @@ describe('GET /api/config', () => {});const response = await request(createApp(mockUser)).get('/api/config');expect(response.body.pullRequestsEnabled).toBe(expected);+ /** The batch route's version rides with the flag, so a client never sees one without the other. */+ if (expected) {+ expect(response.body.pullRequestsBatchVersion).toBe(1);+ expect(response.body.pullRequestsMaxConcurrentLookups).toBe(4);+ } else {+ expect(response.body).not.toHaveProperty('pullRequestsBatchVersion');+ expect(response.body).not.toHaveProperty('pullRequestsMaxConcurrentLookups');+ }},);+ it('advertises the configured lookup limit so a fallback client can keep to it', async () => {+ mockGetAppConfig.mockResolvedValue({+ ...baseAppConfig,+ endpoints: { agents: { pullRequests: { enabled: true, maxConcurrentLookups: 2 } } },+ });+ const response = await request(createApp(mockUser)).get('/api/config');+ expect(response.body.pullRequestsMaxConcurrentLookups).toBe(2);+ });+it('should not advertise pull requests for a config with no endpoints', async () => {mockGetAppConfig.mockResolvedValue(baseAppConfig);const response = await request(createApp(mockUser)).get('/api/config');diff --git a/api/server/routes/config.js b/api/server/routes/config.jsindex 3336a94d4c..62b0b7eb19 100644--- a/api/server/routes/config.js+++ b/api/server/routes/config.js@@ -23,6 +23,7 @@ const {resolveCodeWorkspaceInheritanceCapability,resolveCodeEnvironmentTransitionVersion,loadConversationListLimits,+ resolvePullRequestCapabilities,} = require('@librechat/api');const {DEFAULT_MCP_APP_CSP_LIMITS,@@ -331,8 +332,7 @@ router.get('/', async function (req, res) {langfuseConnectionAccess,insightsEnabled: isEnabled(process.env.ENABLE_INSIGHTS),/** Lets the client skip the pull request lookup entirely when the feature is off. */- pullRequestsEnabled:- appConfig?.endpoints?.[EModelEndpoint.agents]?.pullRequests?.enabled === true,+ ...resolvePullRequestCapabilities(appConfig),compactionEnabled: appConfig?.summarization?.enabled !== false,...(codeEnvironmentDecisionVersion != null ? { codeEnvironmentDecisionVersion } : {}),mcpApps: resolveMCPAppsPolicy(diff --git a/api/server/routes/convos.js b/api/server/routes/convos.jsindex 4c05abb57f..ef6b220150 100644--- a/api/server/routes/convos.js+++ b/api/server/routes/convos.js@@ -21,7 +21,9 @@ const {createBackgroundTaskPolicyMiddleware,createConversationPullRequestHandler,createGitHubPullRequestSource,+ createProxyAwareFetch,createPullRequestLookup,+ createConversationPullRequestsHandler,backgroundTaskRegistry,createSubagentThreadViewHandler,createGeneratedTitleHandler,@@ -170,10 +172,20 @@ const backgroundTaskIndexHandler = createBackgroundTaskIndexHandler({const backgroundTaskCancelHandler = createBackgroundTaskCancelHandler({registry: backgroundTaskRegistry,});+/** One lookup, so the header's single route and the sidebar's batch route share its cache. */+const pullRequestLookup = createPullRequestLookup({+ source: createGitHubPullRequestSource({ fetchFn: createProxyAwareFetch() }),+});const conversationPullRequestHandler = createConversationPullRequestHandler({getConvoLaneGit: db.getConvoLaneGit,getAppConfig,- lookup: createPullRequestLookup({ source: createGitHubPullRequestSource({ fetchFn: fetch }) }),+ lookup: pullRequestLookup,+ env: process.env,+});+const conversationPullRequestsHandler = createConversationPullRequestsHandler({+ getConvosLaneGit: db.getConvosLaneGit,+ getAppConfig,+ lookup: pullRequestLookup,env: process.env,});router.use(requireJwtAuth);@@ -248,6 +260,7 @@ router.post(subagentControlHandler,);router.get('/:parentConversationId/subagents', parentSubagentIndexHandler);+router.post('/pull-requests', conversationPullRequestsHandler);router.get('/:conversationId/pull-request', conversationPullRequestHandler);router.get('/:conversationId/background-tasks', backgroundTaskPolicy, backgroundTaskIndexHandler);router.post(diff --git a/api/server/services/ToolService.js b/api/server/services/ToolService.jsindex 632d884eca..446fe54004 100644--- a/api/server/services/ToolService.js+++ b/api/server/services/ToolService.js@@ -2376,6 +2376,7 @@ async function loadToolsForExecution({environmentId: codeExecutionContext.codeWorkspace.environmentId,workspaceId: codeExecutionContext.codeWorkspace.workspaceId,},+ admittedEpoch: req.resolvedConversation?.codeAttachmentEpoch,getConvoLaneContext,reserveConvoLaneGitSeq,setConvoLaneGit,diff --git a/api/server/services/__tests__/ToolService.spec.js b/api/server/services/__tests__/ToolService.spec.jsindex b00271883a..213827e73f 100644--- a/api/server/services/__tests__/ToolService.spec.js+++ b/api/server/services/__tests__/ToolService.spec.js@@ -3274,6 +3274,55 @@ describe('ToolService - Action Capability Gating', () => {expect(mockSetConvoLaneGit).toHaveBeenCalledWith(input);});+ it.each([+ ['a moved conversation', 3, 3],+ ['a conversation never moved', 0, 0],+ ['a conversation whose admitted read carried no epoch', undefined, undefined],+ ])(+ 'fences the lane report by the epoch of the admitted decision for %s',+ async (_label, admitted, expected) => {+ const capabilities = [+ AgentCapabilities.tools,+ AgentCapabilities.execute_code,+ AgentCapabilities.stateful_code_sessions,+ ];+ const req = createMockReq(capabilities);+ req.config.endpoints[EModelEndpoint.agents].pullRequests = { enabled: true };+ req.resolvedConversation = {+ conversationId: 'resolved-convo',+ codeWorkspaces: [{ environmentId: 'personal-machine', workspaceId: 'project-a' }],+ ...(admitted === undefined ? {} : { codeAttachmentEpoch: admitted }),+ };+ req.body = {+ conversationId: 'resolved-convo',+ codeWorkspaces: [{ environmentId: 'personal-machine', workspaceId: 'project-a' }],+ };+ mockGetEndpointsConfig.mockResolvedValue(createEndpointsConfig(capabilities));+ req.config.endpoints[EModelEndpoint.agents].statefulCodeSessions = {+ environments: [attachedEnvironment()],+ };+ mockCreateLaneGitRecorder.mockClear();++ await loadToolsForExecution({+ req,+ res: {},+ agent: {+ id: 'attached-agent',+ tools: [Tools.execute_code],+ stateful_code_sessions: true,+ stateful_code_environment: 'agent-user',+ code_environment_id: 'personal-machine',+ },+ conversationId: 'resolved-convo',+ toolNames: [AgentConstants.BASH_TOOL],+ toolRegistry: new Map([[AgentConstants.BASH_TOOL, { name: AgentConstants.BASH_TOOL }]]),+ actionsEnabled: false,+ });++ expect(mockCreateLaneGitRecorder.mock.calls[0][0].admittedEpoch).toBe(expected);+ },+ );+it.each([['unset', undefined],['disabled', { enabled: false }],diff --git a/client/src/components/Chat/PullRequest/Chip.tsx b/client/src/components/Chat/PullRequest/Chip.tsxindex 18c3bde4c1..fbd5763748 100644--- a/client/src/components/Chat/PullRequest/Chip.tsx+++ b/client/src/components/Chat/PullRequest/Chip.tsx@@ -5,31 +5,10 @@ import { useAgentsMapContext, useChatContext } from '~/Providers';import { TONE_DOT_CLASS, presentPullRequest } from './status';import { URLIcon } from '~/components/Endpoints/URLIcon';import { summarizePullRequest } from './summary';+import PullRequestPanel from './Panel';import { useLocalize } from '~/hooks';import PullRequestIcon from './Icon';-import PullRequestCard from './Card';-import { cn } from '~/utils';--/** Slides in from the chip's side, left to right, and fades; reduced motion only fades. */-const cardClass = cn(- 'border-border-light bg-surface-secondary text-text-primary z-[200] w-80 max-w-[calc(100vw-2rem)] rounded-xl border shadow-lg focus:outline-none',- 'origin-left -translate-x-3 opacity-0 transition duration-200 ease-out',- 'data-[enter]:translate-x-0 data-[enter]:opacity-100',- 'data-[leave]:-translate-x-3 data-[leave]:opacity-0',- 'motion-reduce:translate-x-0 motion-reduce:transition-opacity',-);--function CiDot({ dotClass }: { dotClass: string }) {- return (- <span- data-testid="pull-request-ci-dot"- className={cn(- 'ring-presentation absolute -right-0.5 -bottom-0.5 size-2 rounded-full ring-2',- dotClass,- )}- />- );-}+import CiDot from './CiDot';/** The agent's picture with the CI dot on its corner. */function AgentAvatar({@@ -72,7 +51,6 @@ function PullRequestChip({ conversationId }: { conversationId: string }) {hideTimeout: 150,});const open = Ariakit.useStoreState(hovercard, 'open');- const cardElement = Ariakit.useStoreState(hovercard, 'contentElement');const { data, isError, refetch } = useConversationPullRequestQuery(conversationId);const pullRequest = data?.pullRequest;@@ -108,21 +86,12 @@ function PullRequestChip({ conversationId }: { conversationId: string }) {</Ariakit.Button>}/>- <Ariakit.Hovercard- gutter={8}- portal- unmountOnHide- autoFocusOnShow={false}- aria-label={localize('com_ui_pull_request')}- className={cardClass}- >- <PullRequestCard- pullRequest={pullRequest}- refreshFailed={isError}- onRetry={() => void refetch()}- portalElement={cardElement}- />- </Ariakit.Hovercard>+ <PullRequestPanel+ store={hovercard}+ pullRequest={pullRequest}+ refreshFailed={isError}+ onRetry={() => void refetch()}+ /></Ariakit.HovercardProvider>);}diff --git a/client/src/components/Chat/PullRequest/CiDot.tsx b/client/src/components/Chat/PullRequest/CiDot.tsxnew file mode 100644index 0000000000..0e1e522c37--- /dev/null+++ b/client/src/components/Chat/PullRequest/CiDot.tsx@@ -0,0 +1,25 @@+import { cn } from '~/utils';++/**+ * The CI status dot that sits on the corner of the picture or icon it describes. The ring is+ * painted in the surface the dot sits on, so the caller names that surface.+ */+export default function CiDot({+ dotClass,+ ringClassName = 'ring-presentation',+}: {+ dotClass: string;+ ringClassName?: string;+}) {+ return (+ <span+ data-testid="pull-request-ci-dot"+ aria-hidden="true"+ className={cn(+ 'pointer-events-none absolute -right-0.5 -bottom-0.5 size-2 rounded-full ring-2',+ ringClassName,+ dotClass,+ )}+ />+ );+}diff --git a/client/src/components/Chat/PullRequest/Panel.tsx b/client/src/components/Chat/PullRequest/Panel.tsxnew file mode 100644index 0000000000..b9881e9407--- /dev/null+++ b/client/src/components/Chat/PullRequest/Panel.tsx@@ -0,0 +1,58 @@+import * as Ariakit from '@ariakit/react';+import type { TConversationPullRequest } from 'librechat-data-provider';+import { useLocalize } from '~/hooks';+import PullRequestCard from './Card';+import { cn } from '~/utils';++/** Slides in from the anchor's side, left to right, and fades; reduced motion only fades. */+export const panelClass = cn(+ 'border-border-light bg-surface-secondary text-text-primary z-[200] w-80 max-w-[calc(100vw-2rem)] rounded-xl border shadow-lg focus:outline-none',+ 'origin-left -translate-x-3 opacity-0 transition duration-200 ease-out',+ 'data-[enter]:translate-x-0 data-[enter]:opacity-100',+ 'data-[leave]:-translate-x-3 data-[leave]:opacity-0',+ 'motion-reduce:translate-x-0 motion-reduce:transition-opacity',+);++/**+ * The card as a hovercard beside its anchor. It is portaled, and a portal's events still bubble+ * to the React tree that rendered it, so anything that sits inside a clickable row stops them+ * here: a click on the card must not open the row it hangs from.+ */+export default function PullRequestPanel({+ store,+ pullRequest,+ refreshFailed,+ onRetry,+}: {+ store: Ariakit.HovercardStore;+ pullRequest: TConversationPullRequest;+ refreshFailed: boolean;+ onRetry: () => void;+}) {+ const localize = useLocalize();+ const panelElement = Ariakit.useStoreState(store, 'contentElement');+ const stop = (event: { stopPropagation: () => void }) => event.stopPropagation();++ return (+ <Ariakit.Hovercard+ store={store}+ gutter={8}+ portal+ unmountOnHide+ autoFocusOnShow={false}+ aria-label={localize('com_ui_pull_request')}+ className={panelClass}+ onClick={stop}+ onDoubleClick={stop}+ onContextMenu={stop}+ onKeyDown={stop}+ >+ <PullRequestCard+ pullRequest={pullRequest}+ refreshFailed={refreshFailed}+ onRetry={onRetry}+ portalElement={panelElement}+ />+ </Ariakit.Hovercard>+ );+}diff --git a/client/src/components/Chat/PullRequest/RowMark.tsx b/client/src/components/Chat/PullRequest/RowMark.tsxnew file mode 100644index 0000000000..918b11746b--- /dev/null+++ b/client/src/components/Chat/PullRequest/RowMark.tsx@@ -0,0 +1,150 @@+import { memo, useEffect } from 'react';+import * as Ariakit from '@ariakit/react';+import { Button } from '@librechat/client';+import { TriangleAlert } from 'lucide-react';+import type React from 'react';+import { useRowPullRequestQuery } from '~/data-provider/PullRequest';+import { TONE_DOT_CLASS, presentPullRequest } from './status';+import PullRequestPanel, { panelClass } from './Panel';+import { summarizePullRequest } from './summary';+import { useLocalize } from '~/hooks';+import PullRequestIcon from './Icon';+import { cn } from '~/utils';+import CiDot from './CiDot';++/** The row's own surface at each state, so the dot's ring blends into it. */+const RING_SELECTED = 'ring-surface-nav-selected';+const RING_IDLE = 'ring-surface-primary-alt group-hover:ring-surface-nav-hover';++/**+ * The pull request a conversation opened, as a mark in its sidebar row: the state icon with the+ * CI dot on its corner. It renders nothing until a pull request is known, so a row without one+ * is exactly what it was. The row's title stays the conversation's own title; this only adds+ * the icon. The mark is a button beside the row's own, so Tab reaches it: focusing it opens the+ * card, which holds the GitHub link, and activating it must not also open the row.+ */+function PullRequestRowMark({+ conversationId,+ labelId,+ selected,+ onDescribed,+}: {+ conversationId: string;+ /** The id the row lists in `aria-describedby`, so a screen reader hears what the colors say. */+ labelId: string;+ selected: boolean;+ /** Tells the row whether `labelId` is in the page, so it never points at text that is not. */+ onDescribed?: (described: boolean) => void;+}) {+ const localize = useLocalize();+ const store = Ariakit.useHovercardStore({+ placement: 'right-start',+ showTimeout: 100,+ hideTimeout: 150,+ });+ const open = Ariakit.useStoreState(store, 'open');+ const { data, isError, refetch } = useRowPullRequestQuery(conversationId);+ const pullRequest = data?.pullRequest;+ const described = pullRequest != null || isError;++ useEffect(() => {+ onDescribed?.(described);+ return () => onDescribed?.(false);+ }, [described, onDescribed]);++ /* A first lookup that failed is not the same as a chat with no pull request: say so, and+ offer a retry, instead of leaving the row looking like there is nothing to find. */+ if (pullRequest == null && isError) {+ const failed = localize('com_ui_pr_load_failed');+ return (+ <Ariakit.HovercardProvider store={store}>+ <Ariakit.HovercardAnchor+ render={<Ariakit.Button />}+ aria-label={failed}+ aria-expanded={open}+ data-testid="convo-pull-request-failed"+ onFocus={() => store.show()}+ onClick={(event: React.MouseEvent) => {+ event.stopPropagation();+ store.show();+ }}+ onKeyDown={(event: React.KeyboardEvent) => {+ if (event.key === 'Enter' || event.key === ' ') event.stopPropagation();+ }}+ className="focus-visible:ring-text-primary text-status-warning relative mr-1 flex size-4 shrink-0 items-center justify-center rounded-sm outline-hidden focus-visible:ring-2"+ >+ <TriangleAlert aria-hidden="true" className="size-4 shrink-0" />+ </Ariakit.HovercardAnchor>+ <span id={labelId} className="sr-only">+ {failed}+ </span>+ <Ariakit.Hovercard+ store={store}+ gutter={8}+ portal+ unmountOnHide+ autoFocusOnShow={false}+ aria-label={localize('com_ui_pull_request')}+ className={cn(panelClass, 'w-auto')}+ onClick={(event) => event.stopPropagation()}+ onDoubleClick={(event) => event.stopPropagation()}+ onContextMenu={(event) => event.stopPropagation()}+ onKeyDown={(event) => event.stopPropagation()}+ >+ <div role="status" className="text-status-warning flex items-center gap-2 p-3 text-xs">+ <span>{failed}</span>+ <Button type="button" variant="outline" size="sm" onClick={() => void refetch()}>+ {localize('com_ui_retry')}+ </Button>+ </div>+ </Ariakit.Hovercard>+ </Ariakit.HovercardProvider>+ );+ }++ if (pullRequest == null) return null;++ const view = presentPullRequest(pullRequest);+ const dotClass = view.dotTone == null ? null : TONE_DOT_CLASS[view.dotTone];+ const summary = summarizePullRequest(pullRequest, localize);++ return (+ <Ariakit.HovercardProvider store={store}>+ <Ariakit.HovercardAnchor+ render={<Ariakit.Button />}+ aria-label={summary}+ aria-expanded={open}+ data-testid="convo-pull-request"+ onFocus={() => store.show()}+ onClick={(event: React.MouseEvent) => {+ /* The row itself opens the conversation on click; this opens the card instead. */+ event.stopPropagation();+ store.show();+ }}+ onKeyDown={(event: React.KeyboardEvent) => {+ /* Enter and Space belong to this button, not to the row's own shortcuts. */+ if (event.key === 'Enter' || event.key === ' ') event.stopPropagation();+ }}+ className={cn(+ 'focus-visible:ring-text-primary relative mr-1 flex size-4 shrink-0 items-center justify-center rounded-sm outline-hidden focus-visible:ring-2',+ )}+ >+ <PullRequestIcon icon={view.icon} tone={view.iconTone} className="size-4 shrink-0" />+ {dotClass != null && (+ <CiDot dotClass={dotClass} ringClassName={selected ? RING_SELECTED : RING_IDLE} />+ )}+ </Ariakit.HovercardAnchor>+ <span id={labelId} className="sr-only">+ {summary}+ </span>+ <PullRequestPanel+ store={store}+ pullRequest={pullRequest}+ refreshFailed={isError}+ onRetry={() => void refetch()}+ />+ </Ariakit.HovercardProvider>+ );+}++export default memo(PullRequestRowMark);diff --git a/client/src/components/Chat/PullRequest/__tests__/RowMark.test.tsx b/client/src/components/Chat/PullRequest/__tests__/RowMark.test.tsxnew file mode 100644index 0000000000..99d738c18e--- /dev/null+++ b/client/src/components/Chat/PullRequest/__tests__/RowMark.test.tsx@@ -0,0 +1,438 @@+import React from 'react';+import '@testing-library/jest-dom';+import userEvent from '@testing-library/user-event';+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';+import { render, screen, waitFor, fireEvent } from '@testing-library/react';+import type { TConversationPullRequest } from 'librechat-data-provider';+import PullRequestRowMark from '../RowMark';++const mockGetMany = jest.fn();+const mockGetOne = jest.fn();+const mockStartup: {+ current: { pullRequestsEnabled?: boolean; pullRequestsBatchVersion?: number } | undefined;+} = {+ current: { pullRequestsEnabled: true, pullRequestsBatchVersion: 1 },+};++const mockUser: { current: { id: string } | undefined } = { current: { id: 'user-a' } };+jest.mock('recoil', () => ({+ ...jest.requireActual('recoil'),+ useRecoilValue: () => mockUser.current,+}));+jest.mock('~/data-provider/Endpoints', () => ({+ useGetStartupConfig: () => ({ data: mockStartup.current }),+}));+jest.mock('librechat-data-provider', () => {+ const actual = jest.requireActual('librechat-data-provider');+ return {+ ...actual,+ dataService: {+ ...actual.dataService,+ getConversationPullRequests: (...args: unknown[]) => mockGetMany(...args),+ getConversationPullRequest: (...args: unknown[]) => mockGetOne(...args),+ },+ };+});+jest.mock('~/hooks', () => ({+ useLocalize: () => (key: string, values?: Record<string, string | number>) =>+ values == null ? key : `${key}:${Object.values(values).join(',')}`,+}));++const pr: TConversationPullRequest = {+ number: 1234,+ title: 'Simplify Single Tool Execution Path',+ url: 'https://github.com/LibreChat-AI/LibreChat/pull/1234',+ additions: 1234,+ deletions: 56,+ state: 'open',+ isDraft: false,+ mergeable: 'clean',+ checks: 'passing',+};++const answer = (conversationId: string, value: TConversationPullRequest | null) => ({+ results: [{ conversationId, pullRequest: value }],+});++let pointerX = 100;+const movePointerOver = (element: HTMLElement) => {+ pointerX += 7;+ fireEvent.mouseMove(element, {+ screenX: pointerX,+ screenY: pointerX,+ movementX: 7,+ movementY: 7,+ });+};++const renderMark = (props: Partial<React.ComponentProps<typeof PullRequestRowMark>> = {}) => {+ const rowClick = jest.fn();+ const rowKey = jest.fn();+ const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });+ const view = render(+ <QueryClientProvider client={client}>+ <div data-testid="row" onClick={rowClick} onKeyDown={rowKey}>+ <PullRequestRowMark+ conversationId="convo-1"+ labelId="pr-label"+ selected={false}+ {...props}+ />+ </div>+ </QueryClientProvider>,+ );+ return { ...view, rowClick, rowKey, client };+};++describe('PullRequestRowMark', () => {+ beforeEach(() => {+ mockGetMany.mockReset();+ mockGetOne.mockReset();+ mockStartup.current = { pullRequestsEnabled: true, pullRequestsBatchVersion: 1 };+ mockUser.current = { id: 'user-a' };+ });++ it.each([+ [+ 'while loading',+ () => new Promise((resolve) => setTimeout(() => resolve(answer('convo-1', null)), 40)),+ ],+ ['without a pull request', () => Promise.resolve(answer('convo-1', null))],+ ])('renders nothing %s, so the row is unchanged', async (_label, respond) => {+ mockGetMany.mockImplementation(respond);+ const { container } = renderMark();+ await waitFor(() => expect(mockGetMany).toHaveBeenCalled());+ await new Promise((resolve) => setTimeout(resolve, 30));+ expect(container.querySelector('[data-testid="convo-pull-request"]')).toBeNull();+ expect(container.querySelector('[data-testid="convo-pull-request-failed"]')).toBeNull();+ });++ it.each([+ ['the request fails', () => Promise.reject(new Error('503'))],+ [+ 'that conversation failed on the server',+ () =>+ Promise.resolve({+ results: [{ conversationId: 'convo-1', error: { code: 'RATE_LIMITED' } }],+ }),+ ],+ ])('says the lookup failed, with a retry, when %s', async (_label, respond) => {+ mockGetMany.mockImplementationOnce(respond);+ renderMark();+ const failed = await screen.findByTestId('convo-pull-request-failed');+ expect(failed).toHaveAccessibleName('com_ui_pr_load_failed');+ expect(screen.queryByTestId('convo-pull-request')).toBeNull();+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ fireEvent.focus(failed);+ const retry = await screen.findByRole('button', { name: 'com_ui_retry' });+ fireEvent.click(retry);+ expect(await screen.findByTestId('convo-pull-request')).toBeInTheDocument();+ expect(mockGetMany).toHaveBeenCalledTimes(2);+ });++ it.each([+ ['an older server that has the flag but not the batch route', { pullRequestsEnabled: true }],+ [+ 'a batch version this client does not know',+ { pullRequestsEnabled: true, pullRequestsBatchVersion: 2 },+ ],+ ['the version without the flag', { pullRequestsBatchVersion: 1 }],+ ])('does not ask %s, so a rolling upgrade shows no failure marks', async (_label, startup) => {+ mockStartup.current = startup;+ const { container } = renderMark();+ await new Promise((resolve) => setTimeout(resolve, 80));+ expect(mockGetMany).not.toHaveBeenCalled();+ expect(container.querySelector('[data-testid="convo-pull-request"]')).toBeNull();+ expect(container.querySelector('[data-testid="convo-pull-request-failed"]')).toBeNull();+ });++ it('shows the failure when a refresh fails after an empty answer was cached', async () => {+ jest.useFakeTimers();+ try {+ mockGetMany+ .mockResolvedValueOnce(answer('convo-1', null))+ .mockRejectedValue(new Error('503'));+ renderMark();+ await jest.advanceTimersByTimeAsync(100);+ expect(screen.queryByTestId('convo-pull-request-failed')).toBeNull();+ await jest.advanceTimersByTimeAsync(61_000);+ window.dispatchEvent(new Event('focus'));+ await jest.advanceTimersByTimeAsync(100);+ expect(screen.getByTestId('convo-pull-request-failed')).toBeInTheDocument();+ } finally {+ jest.useRealTimers();+ }+ });++ it('keeps its spacing on the rendered mark, so an absent mark takes no room', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ const first = renderMark();+ expect(await screen.findByTestId('convo-pull-request')).toHaveClass('mr-1');+ first.unmount();+ mockGetMany.mockRejectedValueOnce(new Error('503'));+ renderMark();+ expect(await screen.findByTestId('convo-pull-request-failed')).toHaveClass('mr-1');+ });++ it('falls back to the single route when the replica that answered has no batch route', async () => {+ mockGetMany.mockRejectedValue(+ Object.assign(new Error('Not Found'), { response: { status: 404 } }),+ );+ mockGetOne.mockResolvedValue({ pullRequest: pr });+ renderMark();+ expect(await screen.findByTestId('convo-pull-request')).toBeInTheDocument();+ expect(mockGetOne).toHaveBeenCalledWith('convo-1', { signal: expect.any(AbortSignal) });+ expect(screen.queryByTestId('convo-pull-request-failed')).toBeNull();+ });++ it('shows no failure for a conversation without a pull request when only the batch route is missing', async () => {+ mockGetMany.mockRejectedValue(+ Object.assign(new Error('Not Found'), { response: { status: 404 } }),+ );+ mockGetOne.mockResolvedValue({ pullRequest: null });+ const { container } = renderMark();+ await waitFor(() => expect(mockGetOne).toHaveBeenCalled());+ await new Promise((resolve) => setTimeout(resolve, 30));+ expect(container.querySelector('[data-testid="convo-pull-request-failed"]')).toBeNull();+ expect(container.querySelector('[data-testid="convo-pull-request"]')).toBeNull();+ });++ it('does not ask for a user it cannot name, so a batch is never sent for no one', async () => {+ mockUser.current = undefined;+ const { container } = renderMark();+ await new Promise((resolve) => setTimeout(resolve, 80));+ expect(mockGetMany).not.toHaveBeenCalled();+ expect(container.querySelector('[data-testid="convo-pull-request"]')).toBeNull();+ });++ it('asks again for the next account, in a queue of its own, once the user changes', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ const first = renderMark({ conversationId: 'convo-1' });+ await screen.findByTestId('convo-pull-request');+ first.unmount();++ /** The next account's row is not held up by anything the previous account left queued. */+ mockUser.current = { id: 'user-b' };+ mockGetMany.mockResolvedValue(answer('convo-2', { ...pr, number: 2 }));+ renderMark({ conversationId: 'convo-2' });+ await screen.findByTestId('convo-pull-request');+ expect(mockGetMany).toHaveBeenLastCalledWith(['convo-2'], { signal: expect.any(AbortSignal) });+ });++ it('does not hold the next account behind work the previous account left in flight', async () => {+ /** The first account's request never answers, as a stalled upstream would leave it. */+ mockGetMany.mockImplementationOnce(() => new Promise(() => undefined));+ const stalled = renderMark({ conversationId: 'convo-1' });+ await waitFor(() => expect(mockGetMany).toHaveBeenCalledTimes(1));+ stalled.unmount();++ mockUser.current = { id: 'user-b' };+ mockGetMany.mockResolvedValue(answer('convo-2', { ...pr, number: 2 }));+ renderMark({ conversationId: 'convo-2' });+ /** Without a queue of its own it would wait out the other account's request, which never ends. */+ expect(await screen.findByTestId('convo-pull-request')).toBeInTheDocument();+ expect(mockGetMany).toHaveBeenLastCalledWith(['convo-2'], { signal: expect.any(AbortSignal) });+ });++ it('does not ask when the deployment does not advertise the feature', async () => {+ mockStartup.current = { pullRequestsEnabled: false };+ const { container } = renderMark();+ await new Promise((resolve) => setTimeout(resolve, 80));+ expect(mockGetMany).not.toHaveBeenCalled();+ expect(container.querySelector('[data-testid="convo-pull-request"]')).toBeNull();+ });++ it('asks through the batch endpoint with the conversation id', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ renderMark();+ await screen.findByTestId('convo-pull-request');+ expect(mockGetMany).toHaveBeenCalledWith(['convo-1'], { signal: expect.any(AbortSignal) });+ });++ it('shows the state icon with the CI dot, in the row surface colors', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ renderMark({ selected: false });+ const dot = await screen.findByTestId('pull-request-ci-dot');+ expect(dot).toHaveClass('bg-status-success', 'ring-surface-primary-alt');+ expect(screen.getByTestId('convo-pull-request').querySelector('svg')).toHaveClass(+ 'text-status-success',+ );+ });++ it('paints the dot ring in the selected surface for the open conversation', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ renderMark({ selected: true });+ expect(await screen.findByTestId('pull-request-ci-dot')).toHaveClass(+ 'ring-surface-nav-selected',+ );+ });++ it.each([+ ['failing', { checks: 'failing' as const }, 'bg-status-error', 'text-status-success'],+ ['running', { checks: 'running' as const }, 'bg-status-warning', 'text-status-success'],+ ['conflicts', { mergeable: 'conflicting' as const }, 'bg-status-success', 'text-status-error'],+ ])('colors the dot and icon for %s', async (_label, patch, dotClass, iconClass) => {+ mockGetMany.mockResolvedValue(answer('convo-1', { ...pr, ...patch }));+ renderMark();+ expect(await screen.findByTestId('pull-request-ci-dot')).toHaveClass(dotClass);+ expect(screen.getByTestId('convo-pull-request').querySelector('svg')).toHaveClass(iconClass);+ });++ it('shows no dot when there are no checks, or the pull request is finished', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', { ...pr, checks: 'none' }));+ const first = renderMark();+ await screen.findByTestId('convo-pull-request');+ expect(screen.queryByTestId('pull-request-ci-dot')).not.toBeInTheDocument();+ first.unmount();+ mockGetMany.mockResolvedValue(answer('convo-1', { ...pr, state: 'merged' }));+ renderMark();+ await screen.findByTestId('convo-pull-request');+ expect(screen.queryByTestId('pull-request-ci-dot')).not.toBeInTheDocument();+ });++ it('tells the row when its description exists, and when it stops existing', async () => {+ const onDescribed = jest.fn();+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ const { unmount } = renderMark({ onDescribed });+ await screen.findByTestId('convo-pull-request');+ expect(onDescribed).toHaveBeenLastCalledWith(true);+ unmount();+ expect(onDescribed).toHaveBeenLastCalledWith(false);+ });++ it('reports no description while loading or without a pull request', async () => {+ const onDescribed = jest.fn();+ mockGetMany.mockResolvedValue(answer('convo-1', null));+ renderMark({ onDescribed });+ await waitFor(() => expect(mockGetMany).toHaveBeenCalled());+ await new Promise((resolve) => setTimeout(resolve, 30));+ expect(onDescribed).not.toHaveBeenCalledWith(true);+ });++ it('reports a description for a failed lookup too, since it renders the failure text', async () => {+ const onDescribed = jest.fn();+ mockGetMany.mockRejectedValueOnce(new Error('503'));+ renderMark({ onDescribed });+ await screen.findByTestId('convo-pull-request-failed');+ expect(onDescribed).toHaveBeenLastCalledWith(true);+ });++ it('writes what the colors say into text the row can announce', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ renderMark({ labelId: 'row-pr' });+ await screen.findByTestId('convo-pull-request');+ const text = document.getElementById('row-pr');+ expect(text).toHaveTextContent(pr.title);+ expect(text).toHaveTextContent('com_ui_pr_state_open');+ expect(text).toHaveTextContent('com_ui_pr_checks_passing');+ });++ it('is a button with an accessible name that says what the colors say', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ renderMark();+ const mark = await screen.findByTestId('convo-pull-request');+ expect(mark.tagName).toBe('BUTTON');+ expect(mark).toHaveAccessibleName(expect.stringContaining(pr.title));+ expect(mark).toHaveAccessibleName(expect.stringContaining('com_ui_pr_checks_passing'));+ expect(mark).toHaveAttribute('aria-expanded', 'false');+ });++ it('opens the card for keyboard focus, so its GitHub link is reachable', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ renderMark();+ const mark = await screen.findByTestId('convo-pull-request');+ await userEvent.tab();+ expect(mark).toHaveFocus();+ expect(await screen.findByTestId('pull-request-card')).toBeInTheDocument();+ expect(mark).toHaveAttribute('aria-expanded', 'true');+ });++ it('opens the card on click without opening the row, and keeps Enter and Space off the row', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ const { rowClick, rowKey } = renderMark();+ const mark = await screen.findByTestId('convo-pull-request');+ fireEvent.click(mark);+ expect(await screen.findByTestId('pull-request-card')).toBeInTheDocument();+ fireEvent.keyDown(mark, { key: 'Enter' });+ fireEvent.keyDown(mark, { key: ' ' });+ expect(rowClick).not.toHaveBeenCalled();+ expect(rowKey).not.toHaveBeenCalled();+ });++ it('opens the card to the side on hover, and closes it when the pointer leaves', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ renderMark();+ const mark = await screen.findByTestId('convo-pull-request');+ expect(screen.queryByTestId('pull-request-card')).not.toBeInTheDocument();+ movePointerOver(mark);+ const card = await screen.findByTestId('pull-request-card');+ expect(card).toHaveTextContent(pr.title);+ expect(screen.getByTestId('pull-request-github-link')).toHaveAttribute('href', pr.url);+ fireEvent.mouseLeave(mark);+ fireEvent.mouseMove(document.body, { screenX: 900, screenY: 900, movementX: 7, movementY: 7 });+ await waitFor(() => expect(screen.queryByTestId('pull-request-card')).not.toBeInTheDocument());+ });++ it('does not open the row when the card is clicked', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ const { rowClick } = renderMark();+ movePointerOver(await screen.findByTestId('convo-pull-request'));+ const card = await screen.findByTestId('pull-request-card');+ fireEvent.click(card);+ fireEvent.click(screen.getByTestId('pull-request-github-link'));+ expect(rowClick).not.toHaveBeenCalled();+ });++ it('refreshes every row in one request when the window regains focus, once its answer is stale', async () => {+ jest.useFakeTimers();+ try {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ renderMark();+ await jest.advanceTimersByTimeAsync(100);+ expect(mockGetMany).toHaveBeenCalledTimes(1);+ await jest.advanceTimersByTimeAsync(61_000);+ window.dispatchEvent(new Event('focus'));+ await jest.advanceTimersByTimeAsync(100);+ expect(mockGetMany).toHaveBeenCalledTimes(2);+ } finally {+ jest.useRealTimers();+ }+ });++ it('does not refresh on focus while its answer is still fresh', async () => {+ jest.useFakeTimers();+ try {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ renderMark();+ await jest.advanceTimersByTimeAsync(100);+ window.dispatchEvent(new Event('focus'));+ await jest.advanceTimersByTimeAsync(100);+ expect(mockGetMany).toHaveBeenCalledTimes(1);+ } finally {+ jest.useRealTimers();+ }+ });++ it('never polls, so a list of rows does not poll GitHub once per row', async () => {+ jest.useFakeTimers();+ try {+ mockGetMany.mockResolvedValue(answer('convo-1', { ...pr, checks: 'running' }));+ renderMark();+ await jest.advanceTimersByTimeAsync(100);+ expect(mockGetMany).toHaveBeenCalledTimes(1);+ await jest.advanceTimersByTimeAsync(10 * 60_000);+ expect(mockGetMany).toHaveBeenCalledTimes(1);+ } finally {+ jest.useRealTimers();+ }+ });++ it('shares its cache entry with the header, so one conversation is fetched once', async () => {+ mockGetMany.mockResolvedValue(answer('convo-1', pr));+ const { client } = renderMark();+ await screen.findByTestId('convo-pull-request');+ expect(client.getQueryData(['conversationPullRequest', 'convo-1'])).toEqual({+ pullRequest: pr,+ });+ });+});diff --git a/client/src/components/Chat/PullRequest/index.ts b/client/src/components/Chat/PullRequest/index.tsindex 505e79db72..b87d27e106 100644--- a/client/src/components/Chat/PullRequest/index.ts+++ b/client/src/components/Chat/PullRequest/index.ts@@ -1,2 +1,3 @@export { default as PullRequestChip } from './Chip';export { default as usePullRequestMenu } from './menu';+export { default as PullRequestRowMark } from './RowMark';diff --git a/client/src/components/Conversations/Convo.tsx b/client/src/components/Conversations/Convo.tsxindex 197075123e..0276748919 100644--- a/client/src/components/Conversations/Convo.tsx+++ b/client/src/components/Conversations/Convo.tsx@@ -4,7 +4,11 @@ import { Link2 } from 'lucide-react';import { useRecoilValue } from 'recoil';import { useParams } from 'react-router-dom';import { Spinner, useToastContext, useMediaQuery } from '@librechat/client';-import { Constants, supportsConversationTitleOwnership } from 'librechat-data-provider';+import {+ Constants,+ PULL_REQUEST_BATCH_VERSION,+ supportsConversationTitleOwnership,+} from 'librechat-data-provider';import type { TConversation } from 'librechat-data-provider';import type { ConversationDragItem } from './dnd';import {@@ -13,6 +17,7 @@ import {useUpdateConversationMutation,} from '~/data-provider';import { cn, logger, setDocumentTitle, isConversationUnseen, hasRealTitle } from '~/utils';+import PullRequestRowMark from '~/components/Chat/PullRequest/RowMark';import { useNavigateToConvo, useLocalize, useShiftKey } from '~/hooks';import ConversationEndpointIcon from './ConversationEndpointIcon';import useDrawerViewport from '~/hooks/Nav/useDrawerViewport';@@ -70,6 +75,13 @@ function Conversation({const sharedLinksEnabled = startupConfig?.sharedLinksEnabled === true;const isSharedBadgeVisible = conversation.isShared === true && sharedLinksEnabled;const projectLabelId = useId();+ const pullRequestLabelId = useId();+ /** The mark owns the description text; the row points at it only while it is in the page. */+ const [pullRequestDescribed, setPullRequestDescribed] = useState(false);+ const showPullRequest =+ startupConfig?.pullRequestsEnabled === true &&+ startupConfig.pullRequestsBatchVersion === PULL_REQUEST_BATCH_VERSION &&+ !isGenerating;const projectBadgeProjectId = showProjectBadge ? conversation.chatProjectId : undefined;const isUnseen = isConversationUnseen(conversation);const isShiftHeld = useShiftKey();@@ -387,7 +399,14 @@ function Conversation({isSmallScreen={isSmallScreen}localize={localize}keyShortcuts={keyShortcuts}- describedBy={projectBadgeProjectId ? projectLabelId : undefined}+ describedBy={+ [+ projectBadgeProjectId ? projectLabelId : null,+ showPullRequest && pullRequestDescribed ? pullRequestLabelId : null,+ ]+ .filter(Boolean)+ .join(' ') || undefined+ }>{/* Status sits on the avatar so the row's trailing edge stays free for its badgesand menu. The ring is 2.125rem around the 1.25rem icon: offset by half the@@ -447,6 +466,19 @@ function Conversation({{/* Only render ConvoOptions when user interacts (hover/focus) or for active conversation */}{actionContent}</div>+ {/* After the action slot on purpose: that slot grows from zero on hover, and anything before+ it slides left under the pointer, so the mark would move out from under the cursor that+ is trying to reach it. The title is the only thing that gives way. */}+ {showPullRequest && (+ <span className="flex shrink-0 items-center">+ <PullRequestRowMark+ conversationId={conversationId ?? ''}+ labelId={pullRequestLabelId}+ onDescribed={setPullRequestDescribed}+ selected={isActiveConvo || isPopoverActive}+ />+ </span>+ )}</div>);}diff --git a/client/src/components/Conversations/__tests__/Convo.pullRequest.spec.tsx b/client/src/components/Conversations/__tests__/Convo.pullRequest.spec.tsxnew file mode 100644index 0000000000..fde5eb708d--- /dev/null+++ b/client/src/components/Conversations/__tests__/Convo.pullRequest.spec.tsx@@ -0,0 +1,176 @@+import React, { useEffect } from 'react';+import { DndProvider } from 'react-dnd';+import { HTML5Backend } from 'react-dnd-html5-backend';+import { render, screen } from '@testing-library/react';+import type { TConversation } from 'librechat-data-provider';++const mockStartup: {+ current: { pullRequestsEnabled?: boolean; pullRequestsBatchVersion?: number };+} = {+ current: { pullRequestsEnabled: true, pullRequestsBatchVersion: 1 },+};+const mockMarkProps: Array<Record<string, unknown>> = [];+/** What the mock mark reports to the row, as the real one does once it has text to show. */+const mockMarkState = { described: true };++jest.mock('@librechat/client', () => ({+ useMediaQuery: () => false,+ useRemScale: () => 1,+ useToastContext: () => ({ showToast: jest.fn() }),+ Spinner: () => <svg data-testid="status-ring" />,+ Button: ({ children, ...props }: React.ComponentProps<'button'>) => (+ <button {...props}>{children}</button>+ ),+}));+jest.mock('~/hooks', () => ({+ useLocalize: () => (key: string) => key,+ useNavigateToConvo: () => ({ navigateToConvo: jest.fn() }),+ useShiftKey: () => false,+}));+jest.mock('~/data-provider', () => ({+ useGetStartupConfig: () => ({ data: mockStartup.current }),+ useUpdateConversationMutation: () => ({ mutateAsync: jest.fn() }),+ usePinConversationMutation: () => ({ mutate: jest.fn() }),+ useProjectName: () => 'Scheduling',+}));+jest.mock('react-router-dom', () => ({ useParams: () => ({ conversationId: 'convo-1' }) }));+jest.mock('recoil', () => ({ useRecoilValue: () => [] }));+jest.mock('~/store', () => ({+ __esModule: true,+ default: {+ allConversationsSelector: 'allConversationsSelector',+ conversationIdByIndex: () => 'conversationIdByIndex',+ },+}));+jest.mock('~/utils', () => ({+ cn: (...classes: unknown[]) => classes.filter(Boolean).join(' '),+ logger: { error: jest.fn() },+ setDocumentTitle: jest.fn(),+ isConversationUnseen: () => false,+ hasRealTitle: (title: string) => !!title && title !== 'New Chat',+}));+jest.mock('../ConvoOptions', () => ({ ConvoOptions: () => <div data-testid="convo-options" /> }));+jest.mock('../ConversationEndpointIcon', () => ({+ __esModule: true,+ default: () => <div data-testid="convo-icon" />,+}));+jest.mock('../RenameForm', () => ({ __esModule: true, default: () => <form /> }));+/** Named with the `mock` prefix so the factory below may reference it, and a real component so+ * its hook is legal. It reports its description to the row the way the real mark does. */+function MockRowMark({+ labelId,+ onDescribed,+ ...rest+}: Record<string, unknown> & { labelId: string; onDescribed?: (described: boolean) => void }) {+ mockMarkProps.push({ labelId, ...rest });+ useEffect(() => {+ onDescribed?.(mockMarkState.described);+ return () => onDescribed?.(false);+ }, [onDescribed]);+ if (!mockMarkState.described) return null;+ return (+ <button type="button" data-testid="convo-pull-request">+ <span id={labelId} data-testid="mark-description" />+ </button>+ );+}+const mockRowMark = MockRowMark;++jest.mock('~/components/Chat/PullRequest/RowMark', () => ({+ __esModule: true,+ default: (props: Record<string, unknown>) => mockRowMark(props as never),+}));++import Conversation from '../Convo';++const conversation = {+ conversationId: 'convo-1',+ title: 'Tool Approval UI',+} as TConversation;++const renderRow = (props: { isGenerating?: boolean } = {}) =>+ render(+ <DndProvider backend={HTML5Backend}>+ <Conversation+ conversation={conversation}+ retainView={jest.fn()}+ toggleNav={jest.fn()}+ isGenerating={props.isGenerating}+ />+ </DndProvider>,+ );++const rowButton = () => screen.getByRole('button', { name: /^com_ui_conversation_label/ });++describe('Conversation row pull request', () => {+ beforeEach(() => {+ mockMarkProps.length = 0;+ mockMarkState.described = true;+ mockStartup.current = { pullRequestsEnabled: true, pullRequestsBatchVersion: 1 };+ });++ it("keeps the title the conversation's own and puts the pull request beside it, outside the row button", () => {+ renderRow();+ expect(screen.getByText('Tool Approval UI')).toBeInTheDocument();+ const mark = screen.getByTestId('convo-pull-request');+ expect(rowButton()).not.toContainElement(mark);+ expect(screen.getByTestId('convo-item')).toContainElement(mark);+ expect(mark.parentElement?.parentElement).toBe(screen.getByTestId('convo-item'));+ });++ it('sits after the row menu, which grows on hover, so it does not slide out from under the pointer', () => {+ renderRow();+ const row = screen.getByTestId('convo-item');+ const mark = screen.getByTestId('convo-pull-request');+ const menuSlot = screen.getByTestId('convo-options').parentElement as HTMLElement;+ expect(row).toContainElement(menuSlot);+ expect(menuSlot.compareDocumentPosition(mark) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();+ expect(row.lastElementChild).toBe(mark.parentElement);+ });++ it("names the pull request in the row's description so a screen reader hears what the colors say", () => {+ renderRow();+ const labelId = String(mockMarkProps[0].labelId);+ expect(rowButton().getAttribute('aria-describedby')).toContain(labelId);+ expect(document.getElementById(labelId)).toBeInTheDocument();+ });++ it('tells the mark which conversation it is for and that this row is the open one', () => {+ renderRow();+ expect(mockMarkProps[0]).toMatchObject({ conversationId: 'convo-1', selected: true });+ });++ it('reserves no space around the mark, since an absent mark must leave the row unchanged', () => {+ renderRow();+ const wrapper = screen.getByTestId('convo-pull-request').parentElement as HTMLElement;+ expect(wrapper.className).not.toMatch(/\bm[rlxy]?-\d/);+ expect(wrapper.className).not.toMatch(/\bp[rlxy]?-\d/);+ });++ it('does not point the row at a description that is not in the page', () => {+ mockMarkState.described = false;+ renderRow();+ expect(screen.queryByTestId('convo-pull-request')).not.toBeInTheDocument();+ expect(rowButton().getAttribute('aria-describedby')).toBeNull();+ const ids = (rowButton().getAttribute('aria-describedby') ?? '').split(' ').filter(Boolean);+ expect(ids.every((id) => document.getElementById(id) != null)).toBe(true);+ });++ it.each([+ ['not advertised', {}],+ ['advertised off', { pullRequestsEnabled: false }],+ ['advertised without the batch route', { pullRequestsEnabled: true }],+ ])('draws nothing and describes nothing when the feature is %s', (_label, startup) => {+ mockStartup.current = startup;+ renderRow();+ expect(screen.queryByTestId('convo-pull-request')).not.toBeInTheDocument();+ expect(mockMarkProps).toHaveLength(0);+ expect(rowButton().getAttribute('aria-describedby')).toBeNull();+ });++ it('leaves the mark out while the chat runs, so the ring is the only status', () => {+ renderRow({ isGenerating: true });+ expect(screen.queryByTestId('convo-pull-request')).not.toBeInTheDocument();+ expect(screen.getByTestId('status-ring')).toBeInTheDocument();+ });+});diff --git a/client/src/data-provider/PullRequest/batch.test.ts b/client/src/data-provider/PullRequest/batch.test.tsnew file mode 100644index 0000000000..8ff6dd9afd--- /dev/null+++ b/client/src/data-provider/PullRequest/batch.test.ts@@ -0,0 +1,758 @@+import type { TConversationPullRequest } from 'librechat-data-provider';+import { PullRequestBatchError, createBatchFetcher, createPullRequestBatcher } from './batch';++const pr: TConversationPullRequest = {+ number: 1,+ title: 't',+ url: 'https://github.com/o/r/pull/1',+ additions: 1,+ deletions: 0,+ state: 'open',+ isDraft: false,+ mergeable: 'clean',+ checks: 'passing',+};++describe('createPullRequestBatcher', () => {+ beforeEach(() => jest.useFakeTimers());+ afterEach(() => jest.useRealTimers());++ it('asks once for every conversation requested in the same moment', async () => {+ const fetchMany = jest.fn().mockResolvedValue({+ results: [+ { conversationId: 'a', pullRequest: pr },+ { conversationId: 'b', pullRequest: null },+ ],+ });+ const { load } = createPullRequestBatcher({ fetchMany });+ const first = load('a');+ const second = load('b');+ await jest.advanceTimersByTimeAsync(50);+ expect(fetchMany).toHaveBeenCalledTimes(1);+ expect(fetchMany).toHaveBeenCalledWith(['a', 'b'], expect.any(AbortSignal));+ await expect(first).resolves.toEqual({ pullRequest: pr });+ await expect(second).resolves.toEqual({ pullRequest: null });+ });++ it('shares one entry between callers asking for the same conversation', async () => {+ const fetchMany = jest+ .fn()+ .mockResolvedValue({ results: [{ conversationId: 'a', pullRequest: pr }] });+ const { load } = createPullRequestBatcher({ fetchMany });+ const calls = [load('a'), load('a')];+ await jest.advanceTimersByTimeAsync(50);+ expect(fetchMany).toHaveBeenCalledWith(['a'], expect.any(AbortSignal));+ await expect(Promise.all(calls)).resolves.toEqual([{ pullRequest: pr }, { pullRequest: pr }]);+ });++ it('answers no pull request for a conversation the server left out', async () => {+ const fetchMany = jest.fn().mockResolvedValue({ results: [] });+ const { load } = createPullRequestBatcher({ fetchMany });+ const answer = load('a');+ await jest.advanceTimersByTimeAsync(50);+ await expect(answer).resolves.toEqual({ pullRequest: null });+ });++ it('splits a crowd into requests the server accepts', async () => {+ const fetchMany = jest.fn(async (ids: string[]) => ({+ results: ids.map((conversationId) => ({ conversationId, pullRequest: null })),+ }));+ const { load } = createPullRequestBatcher({ fetchMany, maxBatch: 2 });+ const all = ['a', 'b', 'c', 'd', 'e'].map((id) => load(id));+ await jest.advanceTimersByTimeAsync(50);+ await Promise.all(all);+ expect(fetchMany.mock.calls.map(([ids]) => ids)).toEqual([['a', 'b'], ['c', 'd'], ['e']]);+ });++ describe('requests in flight', () => {+ /** A server that answers only when told to, so overlap is visible. */+ const slowServer = () => {+ let active = 0;+ let peak = 0;+ const releases: Array<() => void> = [];+ const fetchMany = jest.fn(+ (ids: string[]) =>+ new Promise<{ results: Array<{ conversationId: string; pullRequest: null }> }>(+ (resolve) => {+ active += 1;+ peak = Math.max(peak, active);+ releases.push(() => {+ active -= 1;+ resolve({+ results: ids.map((conversationId) => ({ conversationId, pullRequest: null })),+ });+ });+ },+ ),+ );+ return { fetchMany, releases, peak: () => peak };+ };++ it('sends the chunks of a crowd one at a time, so the server limit is not multiplied', async () => {+ const { fetchMany, releases, peak } = slowServer();+ const { load } = createPullRequestBatcher({ fetchMany, maxBatch: 2 });+ const all = ['a', 'b', 'c', 'd', 'e'].map((id) => load(id));+ await jest.advanceTimersByTimeAsync(50);+ expect(fetchMany).toHaveBeenCalledTimes(1);+ releases.shift()?.();+ await jest.advanceTimersByTimeAsync(0);+ expect(fetchMany).toHaveBeenCalledTimes(2);+ releases.shift()?.();+ await jest.advanceTimersByTimeAsync(0);+ expect(fetchMany).toHaveBeenCalledTimes(3);+ releases.shift()?.();+ await Promise.all(all);+ expect(peak()).toBe(1);+ expect(fetchMany.mock.calls.map(([ids]) => ids)).toEqual([['a', 'b'], ['c', 'd'], ['e']]);+ });++ it('does not start a later flush while an earlier request is still out', async () => {+ const { fetchMany, releases, peak } = slowServer();+ const { load } = createPullRequestBatcher({ fetchMany });+ const first = load('a');+ await jest.advanceTimersByTimeAsync(50);+ const second = load('b');+ await jest.advanceTimersByTimeAsync(50);+ expect(fetchMany).toHaveBeenCalledTimes(1);+ releases.shift()?.();+ await jest.advanceTimersByTimeAsync(0);+ expect(fetchMany).toHaveBeenCalledTimes(2);+ releases.shift()?.();+ await Promise.all([first, second]);+ expect(peak()).toBe(1);+ });++ it('moves on when a request never answers, failing only the callers it carried', async () => {+ const fetchMany = jest+ .fn()+ .mockImplementationOnce(() => new Promise(() => undefined))+ .mockResolvedValue({ results: [{ conversationId: 'b', pullRequest: null }] });+ const { load } = createPullRequestBatcher({ fetchMany, requestTimeoutMs: 1000 });+ const hung = load('a').catch((error) => error);+ await jest.advanceTimersByTimeAsync(50);+ const later = load('b');+ await jest.advanceTimersByTimeAsync(50);+ expect(fetchMany).toHaveBeenCalledTimes(1);+ await jest.advanceTimersByTimeAsync(1000);+ const error = await hung;+ expect(error).toBeInstanceOf(PullRequestBatchError);+ expect(error.code).toBe('TIMEOUT');+ await jest.advanceTimersByTimeAsync(50);+ await expect(later).resolves.toEqual({ pullRequest: null });+ });++ it('waits longer than the longest server deadline a deployment can configure by default', async () => {+ const fetchMany = jest+ .fn()+ .mockImplementationOnce(+ () =>+ new Promise((resolve) =>+ setTimeout(+ () => resolve({ results: [{ conversationId: 'a', pullRequest: null }] }),+ 125_000,+ ),+ ),+ )+ .mockResolvedValue({ results: [{ conversationId: 'b', pullRequest: null }] });+ const { load } = createPullRequestBatcher({ fetchMany });+ const slow = load('a');+ await jest.advanceTimersByTimeAsync(50);+ const queued = load('b');+ await jest.advanceTimersByTimeAsync(124_000);+ /** A 120 s server batch has not finished at 124 s of waiting, and the next must not have started. */+ expect(fetchMany).toHaveBeenCalledTimes(1);+ await jest.advanceTimersByTimeAsync(2_000);+ await expect(slow).resolves.toEqual({ pullRequest: null });+ await jest.advanceTimersByTimeAsync(50);+ await expect(queued).resolves.toEqual({ pullRequest: null });+ expect(fetchMany).toHaveBeenCalledTimes(2);+ });++ it('does not time out a request that answers in time', async () => {+ const fetchMany = jest+ .fn()+ .mockResolvedValue({ results: [{ conversationId: 'a', pullRequest: null }] });+ const { load } = createPullRequestBatcher({ fetchMany, requestTimeoutMs: 1000 });+ const answer = load('a');+ await jest.advanceTimersByTimeAsync(50);+ await expect(answer).resolves.toEqual({ pullRequest: null });+ await jest.advanceTimersByTimeAsync(5000);+ });++ it.each([+ ['no body', undefined],+ ['a body without results', {}],+ ['results that are not a list', { results: 'nope' }],+ ['a result that is not an entry', { results: [null] }],+ ])(+ 'fails its callers, and not the queue, when the server answers with %s',+ async (_label, body) => {+ const fetchMany = jest+ .fn()+ .mockResolvedValueOnce(body)+ .mockResolvedValue({ results: [{ conversationId: 'b', pullRequest: null }] });+ const { load } = createPullRequestBatcher({ fetchMany, maxBatch: 1 });+ const bad = load('a').then(+ () => 'resolved',+ () => 'rejected',+ );+ const good = load('b');+ await jest.advanceTimersByTimeAsync(50);+ await expect(bad).resolves.toBe('rejected');+ await expect(good).resolves.toEqual({ pullRequest: null });+ expect(fetchMany).toHaveBeenCalledTimes(2);+ },+ );++ it('keeps sending after a request fails', async () => {+ const fetchMany = jest+ .fn()+ .mockRejectedValueOnce(new Error('503'))+ .mockResolvedValue({ results: [{ conversationId: 'c', pullRequest: null }] });+ const { load } = createPullRequestBatcher({ fetchMany, maxBatch: 1 });+ const failed = load('a').catch((error) => error.message);+ const fine = load('c');+ await jest.advanceTimersByTimeAsync(50);+ await expect(failed).resolves.toBe('503');+ await expect(fine).resolves.toEqual({ pullRequest: null });+ });+ });++ it('rejects only the conversation whose entry failed, carrying its code', async () => {+ const fetchMany = jest.fn().mockResolvedValue({+ results: [+ { conversationId: 'a', error: { code: 'RATE_LIMITED' } },+ { conversationId: 'b', pullRequest: pr },+ ],+ });+ const { load } = createPullRequestBatcher({ fetchMany });+ const failed = load('a');+ const fine = load('b');+ const outcome = failed.catch((error) => error);+ await jest.advanceTimersByTimeAsync(50);+ const error = await outcome;+ expect(error).toBeInstanceOf(PullRequestBatchError);+ expect(error.code).toBe('RATE_LIMITED');+ await expect(fine).resolves.toEqual({ pullRequest: pr });+ });++ it('rejects every caller of a request that fails outright', async () => {+ const fetchMany = jest.fn().mockRejectedValue(new Error('503'));+ const { load } = createPullRequestBatcher({ fetchMany });+ const outcomes = [load('a'), load('b')].map((promise) =>+ promise.catch((error) => error.message),+ );+ await jest.advanceTimersByTimeAsync(50);+ await expect(Promise.all(outcomes)).resolves.toEqual(['503', '503']);+ });++ it('starts a new request for a conversation asked for after the last went out', async () => {+ const fetchMany = jest.fn(async (ids: string[]) => ({+ results: ids.map((conversationId) => ({ conversationId, pullRequest: null })),+ }));+ const { load } = createPullRequestBatcher({ fetchMany });+ const first = load('a');+ await jest.advanceTimersByTimeAsync(50);+ await first;+ const second = load('b');+ await jest.advanceTimersByTimeAsync(50);+ await second;+ expect(fetchMany.mock.calls.map(([ids]) => ids)).toEqual([['a'], ['b']]);+ });+});++describe('createPullRequestBatcher dispose', () => {+ beforeEach(() => jest.useFakeTimers());+ afterEach(() => jest.useRealTimers());++ it('rejects ids that have not gone out, and sends nothing for them', async () => {+ const fetchMany = jest.fn();+ const batcher = createPullRequestBatcher({ fetchMany });+ const waiting = batcher.load('a').catch((error) => error);+ batcher.dispose();+ await jest.advanceTimersByTimeAsync(100);+ const error = await waiting;+ expect(error).toBeInstanceOf(PullRequestBatchError);+ expect(error.code).toBe('DISPOSED');+ expect(fetchMany).not.toHaveBeenCalled();+ });++ it('does not send chunks that were still queued behind a request in flight', async () => {+ const releases: Array<() => void> = [];+ const fetchMany = jest.fn(+ (ids: string[]) =>+ new Promise<{ results: Array<{ conversationId: string; pullRequest: null }> }>((resolve) =>+ releases.push(() =>+ resolve({+ results: ids.map((conversationId) => ({ conversationId, pullRequest: null })),+ }),+ ),+ ),+ );+ const batcher = createPullRequestBatcher({ fetchMany, maxBatch: 1 });+ const outcomes = ['a', 'b', 'c'].map((id) =>+ batcher.load(id).then(+ () => 'sent',+ (error) => error.code,+ ),+ );+ await jest.advanceTimersByTimeAsync(50);+ expect(fetchMany).toHaveBeenCalledTimes(1);+ batcher.dispose();+ releases.shift()?.();+ await jest.advanceTimersByTimeAsync(50);+ /** The request on the wire is aborted with the batcher, and the queued chunks never go out. */+ expect(await Promise.all(outcomes)).toEqual(['ABORTED', 'DISPOSED', 'DISPOSED']);+ expect(fetchMany).toHaveBeenCalledTimes(1);+ });++ it('refuses new work once disposed', async () => {+ const batcher = createPullRequestBatcher({ fetchMany: jest.fn() });+ batcher.dispose();+ await expect(batcher.load('a')).rejects.toMatchObject({ code: 'DISPOSED' });+ });+});++describe('createBatchFetcher', () => {+ const entry = (conversationId: string) => ({ conversationId, pullRequest: null });+ const notFound = () => Object.assign(new Error('Not Found'), { response: { status: 404 } });++ it('uses the batch route when the server has it', async () => {+ const fetchMany = jest.fn().mockResolvedValue({ results: [entry('a')] });+ const fetchOne = jest.fn();+ await expect(+ createBatchFetcher({ fetchMany, fetchOne })(['a'], new AbortController().signal),+ ).resolves.toEqual({+ results: [entry('a')],+ });+ expect(fetchOne).not.toHaveBeenCalled();+ });++ it('asks the single route for each conversation when the replica has no batch route', async () => {+ const fetchMany = jest.fn().mockRejectedValue(notFound());+ const fetchOne = jest.fn(async (id: string) => ({ pullRequest: id === 'a' ? pr : null }));+ const results = await createBatchFetcher({ fetchMany, fetchOne })(+ ['a', 'b'],+ new AbortController().signal,+ );+ expect(results).toEqual({+ results: [+ { conversationId: 'a', pullRequest: pr },+ { conversationId: 'b', pullRequest: null },+ ],+ });+ expect(fetchOne.mock.calls.map(([id]) => id)).toEqual(['a', 'b']);+ });++ it("keeps one conversation's failure to itself and reports its code", async () => {+ const fetchMany = jest.fn().mockRejectedValue(notFound());+ const fetchOne = jest.fn(async (id: string) => {+ if (id === 'a') {+ throw Object.assign(new Error('x'), {+ response: { status: 503, data: { code: 'RATE_LIMITED' } },+ });+ }+ return { pullRequest: pr };+ });+ const { results } = await createBatchFetcher({ fetchMany, fetchOne })(+ ['a', 'b'],+ new AbortController().signal,+ );+ expect(results).toEqual([+ { conversationId: 'a', error: { code: 'RATE_LIMITED' } },+ { conversationId: 'b', pullRequest: pr },+ ]);+ });++ it('answers a failure with no code as an upstream error, never with its text', async () => {+ const fetchMany = jest.fn().mockRejectedValue(notFound());+ const fetchOne = jest.fn().mockRejectedValue(new Error('secret host name'));+ const { results } = await createBatchFetcher({ fetchMany, fetchOne })(+ ['a'],+ new AbortController().signal,+ );+ expect(results).toEqual([{ conversationId: 'a', error: { code: 'UPSTREAM_ERROR' } }]);+ expect(JSON.stringify(results)).not.toContain('secret');+ });++ it.each([+ ['a server error', { response: { status: 503 } }],+ ['a rate limit', { response: { status: 429 } }],+ ['an expired session', { response: { status: 401 } }],+ ['a network failure', new Error('Network Error')],+ ])(+ 'does not fall back on %s, since the route exists and really failed',+ async (_label, failure) => {+ const error = failure instanceof Error ? failure : Object.assign(new Error('x'), failure);+ const fetchMany = jest.fn().mockRejectedValue(error);+ const fetchOne = jest.fn();+ await expect(+ createBatchFetcher({ fetchMany, fetchOne })(['a'], new AbortController().signal),+ ).rejects.toBe(error);+ expect(fetchOne).not.toHaveBeenCalled();+ },+ );++ const measuredFallback = async (concurrency?: () => number | undefined) => {+ let active = 0;+ let peak = 0;+ const fetchMany = jest.fn().mockRejectedValue(notFound());+ const fetchOne = jest.fn(async () => {+ active += 1;+ peak = Math.max(peak, active);+ await new Promise((resolve) => setTimeout(resolve, 5));+ active -= 1;+ return { pullRequest: null };+ });+ jest.useRealTimers();+ const ids = Array.from({ length: 12 }, (_, i) => `c${i}`);+ const { results } = await createBatchFetcher({ fetchMany, fetchOne, concurrency })(+ ids,+ new AbortController().signal,+ );+ expect(results.map((r) => r.conversationId)).toEqual(ids);+ return peak;+ };++ it('runs the single-route calls one at a time when the server never said how many it allows', async () => {+ expect(await measuredFallback()).toBe(1);+ expect(await measuredFallback(() => undefined)).toBe(1);+ });++ it('runs the single-route calls at the limit the server advertised, no more', async () => {+ expect(await measuredFallback(() => 3)).toBe(3);+ expect(await measuredFallback(() => 1)).toBe(1);+ });++ it.each([0, -2, 1.5, Number.NaN])(+ 'treats an unusable advertised limit of %s as one',+ async (limit) => {+ expect(await measuredFallback(() => limit)).toBe(1);+ },+ );++ it('reads the advertised limit when the fallback runs, not when the fetcher was made', async () => {+ let limit = 1;+ const fetchMany = jest.fn().mockRejectedValue(notFound());+ let active = 0;+ let peak = 0;+ const fetchOne = jest.fn(async () => {+ active += 1;+ peak = Math.max(peak, active);+ await new Promise((resolve) => setTimeout(resolve, 5));+ active -= 1;+ return { pullRequest: null };+ });+ const fetcher = createBatchFetcher({ fetchMany, fetchOne, concurrency: () => limit });+ /** The startup config arrives after the fetcher exists, as it does for the module-level one. */+ limit = 3;+ jest.useRealTimers();+ const ids = Array.from({ length: 9 }, (_, i) => `c${i}`);+ await fetcher(ids, new AbortController().signal);+ expect(peak).toBe(3);+ });+});++describe('the single-route fallback and the queue', () => {+ const notFound = () => Object.assign(new Error('Not Found'), { response: { status: 404 } });++ /** A single-route call that ends only when released or aborted, like a stalled GET. */+ const stalledSingleRoute = () => {+ const calls: string[] = [];+ const aborted: string[] = [];+ const fetchOne = jest.fn(+ (id: string, signal: AbortSignal) =>+ new Promise<{ pullRequest: null }>((_, reject) => {+ calls.push(id);+ signal.addEventListener('abort', () => {+ aborted.push(id);+ reject(new Error('aborted'));+ });+ }),+ );+ return { fetchOne, calls, aborted };+ };++ it('stops its calls when the signal aborts, and starts no more', async () => {+ const { fetchOne, calls, aborted } = stalledSingleRoute();+ const controller = new AbortController();+ const ids = Array.from({ length: 12 }, (_, i) => `c${i}`);+ const fetcher = createBatchFetcher({+ fetchMany: jest.fn().mockRejectedValue(notFound()),+ fetchOne,+ concurrency: () => 4,+ });+ const settled = fetcher(ids, controller.signal).catch((error) => error);+ await Promise.resolve();+ await new Promise((resolve) => setTimeout(resolve, 5));+ expect(calls).toHaveLength(4);+ controller.abort();+ const error = await settled;+ expect(error).toBeInstanceOf(PullRequestBatchError);+ expect(error.code).toBe('ABORTED');+ expect(aborted).toHaveLength(4);+ await new Promise((resolve) => setTimeout(resolve, 20));+ expect(calls).toHaveLength(4);+ });++ it('starts nothing when the signal is already aborted', async () => {+ const controller = new AbortController();+ controller.abort();+ const fetchOne = jest.fn();+ const fetcher = createBatchFetcher({+ fetchMany: jest.fn().mockRejectedValue(notFound()),+ fetchOne,+ });+ await expect(fetcher(['a', 'b'], controller.signal)).rejects.toMatchObject({ code: 'ABORTED' });+ expect(fetchOne).not.toHaveBeenCalled();+ });++ it("does not report an aborted call as one conversation's failure", async () => {+ const controller = new AbortController();+ const fetchOne = jest.fn(+ (_id: string, signal: AbortSignal) =>+ new Promise<never>((_, reject) =>+ signal.addEventListener('abort', () => reject(new Error('x'))),+ ),+ );+ const fetcher = createBatchFetcher({+ fetchMany: jest.fn().mockRejectedValue(notFound()),+ fetchOne,+ });+ const settled = fetcher(['a'], controller.signal).catch((error) => error);+ await new Promise((resolve) => setTimeout(resolve, 5));+ controller.abort();+ expect(await settled).toMatchObject({ code: 'ABORTED' });+ });++ it('aborts a request that runs past its timeout, so its fallback stops before the next request starts', async () => {+ jest.useFakeTimers();+ try {+ const { fetchOne, calls, aborted } = stalledSingleRoute();+ const fetchMany = jest+ .fn()+ .mockRejectedValueOnce(notFound())+ .mockResolvedValue({ results: [{ conversationId: 'z', pullRequest: null }] });+ const fetcher = createBatchFetcher({ fetchMany, fetchOne });+ const batcher = createPullRequestBatcher({+ fetchMany: fetcher,+ maxBatch: 1,+ requestTimeoutMs: 1000,+ });+ const first = batcher.load('a').catch((error) => error.code);+ const second = batcher.load('z');+ await jest.advanceTimersByTimeAsync(50);+ expect(calls).toEqual(['a']);+ expect(fetchMany).toHaveBeenCalledTimes(1);+ await jest.advanceTimersByTimeAsync(1000);+ expect(await first).toBe('TIMEOUT');+ /** The stalled call was aborted before the queue handed the next request its turn. */+ expect(aborted).toEqual(['a']);+ await jest.advanceTimersByTimeAsync(50);+ await expect(second).resolves.toEqual({ pullRequest: null });+ expect(fetchMany).toHaveBeenCalledTimes(2);+ } finally {+ jest.useRealTimers();+ }+ });++ it('aborts the request on the wire when the batcher is disposed', async () => {+ const { fetchOne, calls, aborted } = stalledSingleRoute();+ const fetcher = createBatchFetcher({+ fetchMany: jest.fn().mockRejectedValue(notFound()),+ fetchOne,+ });+ const batcher = createPullRequestBatcher({ fetchMany: fetcher, delayMs: 1 });+ const outcome = batcher.load('a').catch((error) => error.code);+ await new Promise((resolve) => setTimeout(resolve, 20));+ expect(calls).toEqual(['a']);+ batcher.dispose();+ expect(aborted).toEqual(['a']);+ expect(await outcome).toBe('ABORTED');+ });++ it("hands the batcher's own signal to the fetcher, live while the request runs", async () => {+ let seen: AbortSignal | undefined;+ const fetchMany = jest.fn(async (_ids: string[], signal: AbortSignal) => {+ seen = signal;+ return { results: [{ conversationId: 'a', pullRequest: null }] };+ });+ const batcher = createPullRequestBatcher({ fetchMany, delayMs: 1 });+ await batcher.load('a');+ expect(seen).toBeDefined();+ expect(seen?.aborted).toBe(false);+ });+});++describe('the batch POST receives the request signal', () => {+ it("hands the batcher's signal to the primary batch call, and aborts it on timeout", async () => {+ jest.useFakeTimers();+ try {+ const seen: AbortSignal[] = [];+ const fetchMany = jest.fn(+ (_ids: string[], signal: AbortSignal) =>+ new Promise<never>(() => {+ seen.push(signal);+ }),+ );+ const fetcher = createBatchFetcher({ fetchMany, fetchOne: jest.fn() });+ const batcher = createPullRequestBatcher({ fetchMany: fetcher, requestTimeoutMs: 1000 });+ const outcome = batcher.load('a').catch((error) => error.code);+ await jest.advanceTimersByTimeAsync(50);+ expect(seen).toHaveLength(1);+ expect(seen[0].aborted).toBe(false);+ await jest.advanceTimersByTimeAsync(1000);+ expect(await outcome).toBe('TIMEOUT');+ expect(seen[0].aborted).toBe(true);+ } finally {+ jest.useRealTimers();+ }+ });++ it('aborts the batch call on the wire when the batcher is disposed', async () => {+ jest.useFakeTimers();+ try {+ let seen: AbortSignal | undefined;+ const fetchMany = jest.fn(+ (_ids: string[], signal: AbortSignal) =>+ new Promise<never>(() => {+ seen = signal;+ }),+ );+ const batcher = createPullRequestBatcher({+ fetchMany: createBatchFetcher({ fetchMany, fetchOne: jest.fn() }),+ });+ const outcome = batcher.load('a').catch(() => 'rejected');+ await jest.advanceTimersByTimeAsync(50);+ batcher.dispose();+ expect(seen?.aborted).toBe(true);+ expect(await outcome).toBe('rejected');+ } finally {+ jest.useRealTimers();+ }+ });+});++describe('withdrawing a caller that stopped waiting', () => {+ beforeEach(() => jest.useFakeTimers());+ afterEach(() => jest.useRealTimers());++ const answer = (ids: string[]) => ({+ results: ids.map((conversationId) => ({ conversationId, pullRequest: null })),+ });++ it('rejects the caller at once', async () => {+ const fetchMany = jest.fn(async (ids: string[]) => answer(ids));+ const { load } = createPullRequestBatcher({ fetchMany });+ const controller = new AbortController();+ const waiting = load('a', controller.signal).catch((error) => error);+ controller.abort();+ const error = await waiting;+ expect(error).toBeInstanceOf(PullRequestBatchError);+ expect(error.code).toBe('ABORTED');+ });++ it('never asks for an id whose only caller left before the request went out', async () => {+ const fetchMany = jest.fn(async (ids: string[]) => answer(ids));+ const { load } = createPullRequestBatcher({ fetchMany });+ const controller = new AbortController();+ void load('gone', controller.signal).catch(() => undefined);+ const kept = load('kept');+ controller.abort();+ await jest.advanceTimersByTimeAsync(50);+ await kept;+ expect(fetchMany).toHaveBeenCalledTimes(1);+ expect(fetchMany.mock.calls[0][0]).toEqual(['kept']);+ });++ it('sends nothing at all when every caller left', async () => {+ const fetchMany = jest.fn(async (ids: string[]) => answer(ids));+ const { load } = createPullRequestBatcher({ fetchMany });+ const controller = new AbortController();+ void load('a', controller.signal).catch(() => undefined);+ void load('b', controller.signal).catch(() => undefined);+ controller.abort();+ await jest.advanceTimersByTimeAsync(100);+ expect(fetchMany).not.toHaveBeenCalled();+ });++ it('keeps an id that another caller still waits for', async () => {+ const fetchMany = jest.fn(async (ids: string[]) => answer(ids));+ const { load } = createPullRequestBatcher({ fetchMany });+ const controller = new AbortController();+ void load('shared', controller.signal).catch(() => undefined);+ const stayed = load('shared');+ controller.abort();+ await jest.advanceTimersByTimeAsync(50);+ await expect(stayed).resolves.toEqual({ pullRequest: null });+ expect(fetchMany.mock.calls[0][0]).toEqual(['shared']);+ });++ it('skips a queued request nobody waits for any more, so the next one is not held behind it', async () => {+ const releases: Array<() => void> = [];+ const fetchMany = jest.fn(+ (ids: string[]) =>+ new Promise<ReturnType<typeof answer>>((resolve) => {+ releases.push(() => resolve(answer(ids)));+ }),+ );+ const { load } = createPullRequestBatcher({ fetchMany, maxBatch: 1 });+ const first = load('first');+ const controller = new AbortController();+ void load('queued', controller.signal).catch(() => undefined);+ const last = load('last');+ await jest.advanceTimersByTimeAsync(50);+ expect(fetchMany).toHaveBeenCalledTimes(1);+ controller.abort();+ releases.shift()?.();+ await first;+ await jest.advanceTimersByTimeAsync(0);+ expect(fetchMany.mock.calls.map(([ids]) => ids)).toEqual([['first'], ['last']]);+ releases.shift()?.();+ await last;+ });++ it('aborts the request on the wire once nobody waits for it', async () => {+ let seen: AbortSignal | undefined;+ const fetchMany = jest.fn(+ (_ids: string[], signal: AbortSignal) =>+ new Promise<never>(() => {+ seen = signal;+ }),+ );+ const { load } = createPullRequestBatcher({ fetchMany });+ const controller = new AbortController();+ void load('a', controller.signal).catch(() => undefined);+ await jest.advanceTimersByTimeAsync(50);+ expect(seen?.aborted).toBe(false);+ controller.abort();+ expect(seen?.aborted).toBe(true);+ });++ it('leaves the request on the wire running while another caller still waits for it', async () => {+ let seen: AbortSignal | undefined;+ const fetchMany = jest.fn(+ (_ids: string[], signal: AbortSignal) =>+ new Promise<never>(() => {+ seen = signal;+ }),+ );+ const { load } = createPullRequestBatcher({ fetchMany });+ const controller = new AbortController();+ void load('a', controller.signal).catch(() => undefined);+ void load('b').catch(() => undefined);+ await jest.advanceTimersByTimeAsync(50);+ controller.abort();+ expect(seen?.aborted).toBe(false);+ });++ it('rejects a caller whose signal had already aborted, without queueing it', async () => {+ const fetchMany = jest.fn(async (ids: string[]) => answer(ids));+ const { load } = createPullRequestBatcher({ fetchMany });+ const controller = new AbortController();+ controller.abort();+ await expect(load('a', controller.signal)).rejects.toMatchObject({ code: 'ABORTED' });+ await jest.advanceTimersByTimeAsync(100);+ expect(fetchMany).not.toHaveBeenCalled();+ });+});diff --git a/client/src/data-provider/PullRequest/batch.ts b/client/src/data-provider/PullRequest/batch.tsnew file mode 100644index 0000000000..9a914e0da2--- /dev/null+++ b/client/src/data-provider/PullRequest/batch.ts@@ -0,0 +1,300 @@+import {+ PULL_REQUEST_BATCH_MAX,+ PULL_REQUEST_BATCH_TIMEOUT_MAX_SECONDS,+} from 'librechat-data-provider';+import type {+ TConversationPullRequestResponse,+ TConversationPullRequestsResponse,+} from 'librechat-data-provider';++/** A failed entry keeps its stable server code, so a caller can tell a rate limit from an outage. */+export class PullRequestBatchError extends Error {+ constructor(public readonly code: string) {+ super(`Pull request lookup failed: ${code}`);+ this.name = 'PullRequestBatchError';+ }+}++type Waiter = {+ resolve: (value: TConversationPullRequestResponse) => void;+ reject: (reason: unknown) => void;+ /** Set when its caller stopped waiting; nothing is sent, or kept running, only for such waiters. */+ cancelled?: boolean;+};++/** A request that has been queued or sent and not yet settled. */+type Dispatch = { waiters: Map<string, Waiter[]>; controller?: AbortController };++const hasLiveWaiter = (list: Waiter[] | undefined): boolean =>+ list?.some((waiter) => !waiter.cancelled) === true;++type BatcherOptions = {+ /**+ * `signal` aborts when the request has run out of time or the batcher was disposed. A fetcher+ * that starts work of its own must stop it on abort: the queue moves on the moment the request+ * is settled, so work left running would overlap the next request.+ */+ fetchMany: (+ conversationIds: string[],+ signal: AbortSignal,+ ) => Promise<TConversationPullRequestsResponse>;+ /** How long to gather more ids before asking, so rows mounted together share one request. */+ delayMs?: number;+ /** Ids per request; the server refuses more than its own bound. */+ maxBatch?: number;+ /**+ * Longest a request may hold the queue. Requests go out one at a time, so one that never+ * answers would otherwise stop every later one. It defaults to just past the longest deadline a+ * deployment may configure for the server's own batch, so the server always answers first and+ * the next request never starts while the previous one's lookups are still running.+ */+ requestTimeoutMs?: number;+};++const DEFAULT_DELAY_MS = 30;+const DEFAULT_REQUEST_TIMEOUT_MS = (PULL_REQUEST_BATCH_TIMEOUT_MAX_SECONDS + 10) * 1000;++/**+ * Collects the conversation ids asked for within a short window and fetches them in one request.+ * Each caller gets its own conversation's answer, and callers asking for the same conversation+ * share one entry. A request that fails rejects only the callers it carried.+ */+export function createPullRequestBatcher({+ fetchMany,+ delayMs = DEFAULT_DELAY_MS,+ maxBatch = PULL_REQUEST_BATCH_MAX,+ requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,+}: BatcherOptions) {+ const pending = new Map<string, Waiter[]>();+ let timer: ReturnType<typeof setTimeout> | undefined;+ let disposed = false;++ /**+ * Requests go out one at a time. Each request lets the server run its own number of lookups at+ * once, so requests in flight together would multiply the limit the operator configured: a long+ * pinned list, or a second flush while one is still out, would otherwise put several times that+ * many lookups on GitHub at once. The tail never rejects, so one failed request cannot stall+ * the ones queued behind it.+ */+ let tail: Promise<void> = Promise.resolve();+ /** Aborts whatever request is on the wire, so disposal does not leave its work running. */+ let active: AbortController | undefined;+ /** Requests queued or on the wire, so a cancel can tell when one has nobody left waiting. */+ const dispatches = new Set<Dispatch>();++ const send = (dispatch: Dispatch): Promise<void> => {+ const { waiters } = dispatch;+ /** Ids nobody waits for any more (their rows unmounted while queued) are never asked for. */+ const ids = [...waiters.keys()].filter((id) => hasLiveWaiter(waiters.get(id)));+ if (!disposed && ids.length === 0) {+ dispatches.delete(dispatch);+ return Promise.resolve();+ }+ /** Work that was still waiting its turn when the batcher was disposed never goes out. */+ if (disposed) {+ for (const list of waiters.values()) {+ list.forEach((waiter) => waiter.reject(new PullRequestBatchError('DISPOSED')));+ }+ return Promise.resolve();+ }+ const settle = ({ results }: TConversationPullRequestsResponse) => {+ const byId = new Map(results.map((entry) => [entry.conversationId, entry]));+ for (const [id, list] of waiters) {+ const entry = byId.get(id);+ for (const waiter of list) {+ if (entry != null && 'error' in entry) {+ waiter.reject(new PullRequestBatchError(entry.error.code));+ } else {+ waiter.resolve({ pullRequest: entry?.pullRequest ?? null });+ }+ }+ }+ };+ const fail = (error: unknown) => {+ for (const list of waiters.values()) list.forEach((waiter) => waiter.reject(error));+ };+ const controller = new AbortController();+ dispatch.controller = controller;+ active = controller;+ let timer: ReturnType<typeof setTimeout> | undefined;+ /**+ * Settles the request on its timeout, and on an abort from disposal, so callers never wait on+ * a fetcher that ignores its signal. The timeout aborts first, so the code it reports stays+ * `TIMEOUT` and the abort listener only ever fires for disposal.+ */+ const timedOut = new Promise<never>((_, reject) => {+ timer = setTimeout(() => {+ reject(new PullRequestBatchError('TIMEOUT'));+ controller.abort();+ }, requestTimeoutMs);+ controller.signal.addEventListener('abort', () =>+ reject(new PullRequestBatchError('ABORTED')),+ );+ });+ /**+ * `settle` is inside the guarded chain: a response that is not the shape it should be would+ * otherwise throw out of it, leave these callers waiting forever and, because the queue chains+ * on this promise, stop every later request. Anything that goes wrong here fails the callers+ * this request carried and nothing else.+ */+ return Promise.race([fetchMany(ids, controller.signal), timedOut])+ .then(settle)+ .catch(fail)+ .finally(() => {+ clearTimeout(timer);+ dispatches.delete(dispatch);+ if (active === controller) active = undefined;+ });+ };++ const flush = () => {+ timer = undefined;+ const ids = [...pending.keys()];+ for (let start = 0; start < ids.length; start += maxBatch) {+ const chunk = ids.slice(start, start + maxBatch);+ const waiters = new Map<string, Waiter[]>();+ for (const id of chunk) {+ waiters.set(id, pending.get(id) ?? []);+ pending.delete(id);+ }+ const dispatch: Dispatch = { waiters };+ dispatches.add(dispatch);+ tail = tail.then(() => send(dispatch));+ }+ };++ return {+ /**+ * Ends this batcher's life, for the identity it was made for. What has not gone out yet is+ * rejected instead of being sent under whoever is signed in next, and nothing queued behind a+ * request still in flight waits on it for the next session. A request already on the wire+ * finishes on its own.+ */+ dispose(): void {+ disposed = true;+ active?.abort();+ clearTimeout(timer);+ timer = undefined;+ for (const list of pending.values()) {+ list.forEach((waiter) => waiter.reject(new PullRequestBatchError('DISPOSED')));+ }+ pending.clear();+ },+ /**+ * `signal` withdraws this caller: it is rejected at once, its id leaves the queue if it has not+ * gone out, and a request nobody is waiting for any more is not started, or is aborted if it+ * is already on the wire, so rows that scrolled away never hold up the ones now visible.+ */+ load(conversationId: string, signal?: AbortSignal): Promise<TConversationPullRequestResponse> {+ if (disposed) return Promise.reject(new PullRequestBatchError('DISPOSED'));+ if (signal?.aborted) return Promise.reject(new PullRequestBatchError('ABORTED'));+ return new Promise((resolve, reject) => {+ const waiter: Waiter = { resolve, reject };+ const waiters = pending.get(conversationId) ?? [];+ waiters.push(waiter);+ pending.set(conversationId, waiters);+ timer ??= setTimeout(flush, delayMs);+ signal?.addEventListener(+ 'abort',+ () => {+ waiter.cancelled = true;+ reject(new PullRequestBatchError('ABORTED'));+ const queued = pending.get(conversationId);+ if (queued != null) {+ const rest = queued.filter((candidate) => candidate !== waiter);+ if (rest.length > 0) pending.set(conversationId, rest);+ else pending.delete(conversationId);+ if (pending.size === 0) {+ clearTimeout(timer);+ timer = undefined;+ }+ }+ for (const dispatch of dispatches) {+ const ids = [...dispatch.waiters.values()];+ if (ids.every((list) => !hasLiveWaiter(list))) dispatch.controller?.abort();+ }+ },+ { once: true },+ );+ });+ },+ };+}++/** An unknown or unusable limit is one call at a time, never more than the operator allowed. */+const usableConcurrency = (value: number | undefined): number =>+ value != null && Number.isInteger(value) && value >= 1 ? value : 1;++const statusOf = (error: unknown): number | undefined => {+ if (error == null || typeof error !== 'object') return undefined;+ const candidate = error as { status?: number; response?: { status?: number } };+ return candidate.response?.status ?? candidate.status;+};++const codeOf = (error: unknown): string => {+ const code = (error as { response?: { data?: { code?: unknown } } } | null)?.response?.data?.code;+ return typeof code === 'string' ? code : 'UPSTREAM_ERROR';+};++/**+ * Asks the batch route, and when the server that answered does not have it (a replica that has+ * not been upgraded yet answers 404, whatever the startup config of another replica advertised),+ * asks the single route for each conversation instead, at the limit the server advertised (one at+ * a time when it did not say), since the single route has no limiter. Anything but a 404 is a+ * real failure and is passed on untouched.+ */+export function createBatchFetcher({+ fetchMany,+ fetchOne,+ concurrency,+}: {+ /** The limit the server advertised, read when the fallback runs; one call at a time without it. */+ concurrency?: () => number | undefined;+ fetchMany: (+ conversationIds: string[],+ signal: AbortSignal,+ ) => Promise<TConversationPullRequestsResponse>;+ fetchOne: (+ conversationId: string,+ signal: AbortSignal,+ ) => Promise<TConversationPullRequestResponse>;+}) {+ return async (+ conversationIds: string[],+ signal: AbortSignal,+ ): Promise<TConversationPullRequestsResponse> => {+ try {+ return await fetchMany(conversationIds, signal);+ } catch (error) {+ if (statusOf(error) !== 404) throw error;+ }+ const results: TConversationPullRequestsResponse['results'] = new Array(conversationIds.length);+ let next = 0;+ /**+ * The fallback is many requests, and the batcher moves on the moment this one is settled, so+ * it stops itself: once the signal aborts no worker starts another call, and the call each+ * has in flight is aborted with it, so nothing carries on beside the next request.+ */+ const worker = async (): Promise<void> => {+ for (let index = next++; index < conversationIds.length; index = next++) {+ if (signal.aborted) return;+ const conversationId = conversationIds[index];+ try {+ const { pullRequest } = await fetchOne(conversationId, signal);+ results[index] = { conversationId, pullRequest };+ } catch (error) {+ /** After an abort the whole fetch throws below, so a result written here is never read. */+ results[index] = { conversationId, error: { code: codeOf(error) } };+ }+ }+ };+ await Promise.all(+ Array.from(+ { length: Math.min(usableConcurrency(concurrency?.()), conversationIds.length) },+ worker,+ ),+ );+ if (signal.aborted) throw new PullRequestBatchError('ABORTED');+ return { results };+ };+}diff --git a/client/src/data-provider/PullRequest/index.ts b/client/src/data-provider/PullRequest/index.tsindex 3cf1ef310b..a4878becc8 100644--- a/client/src/data-provider/PullRequest/index.ts+++ b/client/src/data-provider/PullRequest/index.ts@@ -1 +1,2 @@export * from './queries';+export * from './batch';diff --git a/client/src/data-provider/PullRequest/queries.test.tsx b/client/src/data-provider/PullRequest/queries.test.tsxindex fe7448d7c9..444ed220fb 100644--- a/client/src/data-provider/PullRequest/queries.test.tsx+++ b/client/src/data-provider/PullRequest/queries.test.tsx@@ -1,11 +1,20 @@import React from 'react';-import { renderHook, waitFor } from '@testing-library/react';+import { RecoilRoot } from 'recoil';+import { act, renderHook, waitFor } from '@testing-library/react';import { QueryClient, QueryClientProvider } from '@tanstack/react-query';import type { TConversationPullRequest } from 'librechat-data-provider';-import { pullRequestRefetchInterval, useConversationPullRequestQuery } from './queries';+import type { TStartupConfig } from 'librechat-data-provider';+import {+ endPullRequestSession,+ pullRequestRefetchInterval,+ useRowPullRequestQuery,+ useConversationPullRequestQuery,+} from './queries';+import store from '~/store';const mockGet = jest.fn();-const mockStartup: { current: { pullRequestsEnabled?: boolean } | undefined } = {+const mockGetMany = jest.fn();+const mockStartup: { current: Partial<TStartupConfig> | undefined } = {current: { pullRequestsEnabled: true },};@@ -20,6 +29,7 @@ jest.mock('librechat-data-provider', () => {dataService: {...actual.dataService,getConversationPullRequest: (...args: unknown[]) => mockGet(...args),+ getConversationPullRequests: (...args: unknown[]) => mockGetMany(...args),},};});@@ -116,3 +126,134 @@ describe('useConversationPullRequestQuery', () => {expect(mockGet).toHaveBeenCalledTimes(1);});});++describe('useRowPullRequestQuery', () => {+ const rowStartup = {+ pullRequestsEnabled: true,+ pullRequestsBatchVersion: 1,+ pullRequestsMaxConcurrentLookups: 2,+ } as const;+ const answerFor = (ids: string[]) => ({+ results: ids.map((conversationId) => ({ conversationId, pullRequest: pr })),+ });++ const wrapRows = (userId = 'user-1') => {+ const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });+ const Wrapper = ({ children }: { children: React.ReactNode }) => (+ <QueryClientProvider client={client}>+ <RecoilRoot initializeState={({ set }) => set(store.user, { id: userId } as never)}>+ {children}+ </RecoilRoot>+ </QueryClientProvider>+ );+ return { Wrapper, client };+ };++ beforeEach(() => {+ endPullRequestSession();+ mockGet.mockReset().mockResolvedValue({ pullRequest: null });+ mockGetMany.mockReset().mockImplementation(async (ids: string[]) => answerFor(ids));+ mockStartup.current = { ...rowStartup };+ });+ afterEach(() => endPullRequestSession());++ it('asks the batch route once for rows mounted together', async () => {+ const { Wrapper } = wrapRows();+ const a = renderHook(() => useRowPullRequestQuery('a'), { wrapper: Wrapper });+ const b = renderHook(() => useRowPullRequestQuery('b'), { wrapper: Wrapper });+ await waitFor(() => expect(a.result.current.data).toEqual({ pullRequest: pr }));+ await waitFor(() => expect(b.result.current.data).toEqual({ pullRequest: pr }));+ expect(mockGetMany).toHaveBeenCalledTimes(1);+ expect(mockGetMany.mock.calls[0][0]).toEqual(['a', 'b']);+ });++ it('does not ask for a row that unmounted before its request went out', async () => {+ const { Wrapper } = wrapRows();+ const gone = renderHook(() => useRowPullRequestQuery('gone'), { wrapper: Wrapper });+ const kept = renderHook(() => useRowPullRequestQuery('kept'), { wrapper: Wrapper });+ gone.unmount();+ await waitFor(() => expect(kept.result.current.data).toEqual({ pullRequest: pr }));+ expect(mockGetMany).toHaveBeenCalledTimes(1);+ expect(mockGetMany.mock.calls[0][0]).toEqual(['kept']);+ });++ it('aborts a request on the wire once the last row waiting for it unmounts', async () => {+ let seen: AbortSignal | undefined;+ mockGetMany.mockReset().mockImplementation(+ (_ids: string[], options?: { signal?: AbortSignal }) =>+ new Promise(() => {+ seen = options?.signal;+ }),+ );+ const { Wrapper } = wrapRows();+ const row = renderHook(() => useRowPullRequestQuery('a'), { wrapper: Wrapper });+ await waitFor(() => expect(seen).toBeDefined());+ expect(seen?.aborted).toBe(false);+ row.unmount();+ await waitFor(() => expect(seen?.aborted).toBe(true));+ });++ it('starts a fresh queue after the session ends, even for the same account', async () => {+ const stalled: Array<AbortSignal | undefined> = [];+ mockGetMany+ .mockReset()+ .mockImplementationOnce(+ (_ids: string[], options?: { signal?: AbortSignal }) =>+ new Promise(() => {+ stalled.push(options?.signal);+ }),+ )+ .mockImplementation(async (ids: string[]) => answerFor(ids));+ const first = wrapRows();+ renderHook(() => useRowPullRequestQuery('a'), { wrapper: first.Wrapper });+ await waitFor(() => expect(stalled).toHaveLength(1));+ act(() => endPullRequestSession());+ expect(stalled[0]?.aborted).toBe(true);+ const second = wrapRows();+ const row = renderHook(() => useRowPullRequestQuery('b'), { wrapper: second.Wrapper });+ await waitFor(() => expect(row.result.current.data).toEqual({ pullRequest: pr }));+ expect(mockGetMany.mock.calls.at(-1)?.[0]).toEqual(['b']);+ });++ it('falls back to the single route no faster than the limit the server advertised', async () => {+ const notFound = Object.assign(new Error('Not Found'), { response: { status: 404 } });+ mockGetMany.mockReset().mockRejectedValue(notFound);+ let active = 0;+ let peak = 0;+ mockGet.mockReset().mockImplementation(async () => {+ active += 1;+ peak = Math.max(peak, active);+ await new Promise((resolve) => setTimeout(resolve, 10));+ active -= 1;+ return { pullRequest: null };+ });+ const { Wrapper } = wrapRows();+ const rows = ['a', 'b', 'c', 'd', 'e', 'f'].map((id) =>+ renderHook(() => useRowPullRequestQuery(id), { wrapper: Wrapper }),+ );+ await waitFor(() => rows.forEach((row) => expect(row.result.current.isSuccess).toBe(true)));+ expect(mockGet).toHaveBeenCalledTimes(6);+ expect(peak).toBe(2);+ });++ it('falls back one call at a time when the server advertised no limit', async () => {+ mockStartup.current = { pullRequestsEnabled: true, pullRequestsBatchVersion: 1 };+ const notFound = Object.assign(new Error('Not Found'), { response: { status: 404 } });+ mockGetMany.mockReset().mockRejectedValue(notFound);+ let active = 0;+ let peak = 0;+ mockGet.mockReset().mockImplementation(async () => {+ active += 1;+ peak = Math.max(peak, active);+ await new Promise((resolve) => setTimeout(resolve, 5));+ active -= 1;+ return { pullRequest: null };+ });+ const { Wrapper } = wrapRows();+ const rows = ['a', 'b', 'c'].map((id) =>+ renderHook(() => useRowPullRequestQuery(id), { wrapper: Wrapper }),+ );+ await waitFor(() => rows.forEach((row) => expect(row.result.current.isSuccess).toBe(true)));+ expect(peak).toBe(1);+ });+});diff --git a/client/src/data-provider/PullRequest/queries.ts b/client/src/data-provider/PullRequest/queries.tsindex 21294add9e..16e135194c 100644--- a/client/src/data-provider/PullRequest/queries.ts+++ b/client/src/data-provider/PullRequest/queries.ts@@ -1,8 +1,16 @@+import { useRecoilValue } from 'recoil';import { useQuery } from '@tanstack/react-query';-import { Constants, QueryKeys, dataService } from 'librechat-data-provider';+import {+ Constants,+ QueryKeys,+ dataService,+ PULL_REQUEST_BATCH_VERSION,+} from 'librechat-data-provider';import type { TConversationPullRequestResponse } from 'librechat-data-provider';import type { UseQueryOptions } from '@tanstack/react-query';+import { createBatchFetcher, createPullRequestBatcher } from './batch';import { useGetStartupConfig } from '../Endpoints';+import store from '~/store';const SETTLED_REFRESH_MS = 60_000;/** Checks and conflict state change while a pull request is being worked on. */@@ -23,6 +31,11 @@ export const pullRequestRefetchInterval = (return pr.mergeable === 'unknown' ? ACTIVE_REFRESH_MS : SETTLED_REFRESH_MS;};+const isSavedConversation = (conversationId: string) =>+ conversationId !== '' &&+ conversationId !== Constants.NEW_CONVO &&+ conversationId !== Constants.PENDING_CONVO;+/*** Asks only when the deployment advertises the feature and the conversation is a saved one, so a* default installation never calls the endpoint. The server answers no pull request for a chat@@ -37,11 +50,7 @@ export const useConversationPullRequestQuery = ([QueryKeys.conversationPullRequest, conversationId],() => dataService.getConversationPullRequest(conversationId),{- enabled:- startupConfig?.pullRequestsEnabled === true &&- conversationId !== '' &&- conversationId !== Constants.NEW_CONVO &&- conversationId !== Constants.PENDING_CONVO,+ enabled: startupConfig?.pullRequestsEnabled === true && isSavedConversation(conversationId),staleTime: 15_000,retry: false,refetchOnWindowFocus: true,@@ -51,3 +60,71 @@ export const useConversationPullRequestQuery = (},);};++/** What the server last advertised, for a fallback that has no batch limiter to lean on. */+let advertisedConcurrency: number | undefined;++const fetchRows = createBatchFetcher({+ fetchMany: (conversationIds, signal) =>+ dataService.getConversationPullRequests(conversationIds, { signal }),+ fetchOne: (conversationId, signal) =>+ dataService.getConversationPullRequest(conversationId, { signal }),+ concurrency: () => advertisedConcurrency,+});++type RowBatcher = ReturnType<typeof createPullRequestBatcher>;+let rowBatcher: { userId: string; batcher: RowBatcher } | undefined;++/**+ * The batcher for the signed-in user: every sidebar row mounted in the same moment shares one+ * request. It belongs to one identity, so when the user changes the old one is disposed, and ids+ * it still held are neither sent under the next account's authorization nor made to wait ahead+ * of that account's own rows.+ */+const batcherFor = (userId: string): RowBatcher => {+ if (rowBatcher?.userId === userId) return rowBatcher.batcher;+ rowBatcher?.batcher.dispose();+ const batcher = createPullRequestBatcher({ fetchMany: fetchRows });+ rowBatcher = { userId, batcher };+ return batcher;+};++/**+ * Ends the row queue with the session. Called wherever the session's client state is cleared, so+ * signing back in as the same account starts a fresh queue and neither waits behind, nor sends,+ * anything the previous session left.+ */+export const endPullRequestSession = (): void => {+ rowBatcher?.batcher.dispose();+ rowBatcher = undefined;+};++/**+ * The pull request of a sidebar row. It shares its cache entry with the header's query, so the+ * open conversation is never fetched twice, but it never polls: a list of rows would otherwise+ * poll GitHub once per row. It refreshes when the window regains focus and a row's answer is+ * older than a minute; every mounted row asks in the same moment, so the batcher turns that+ * into one request for the whole list rather than one per row.+ */+export const useRowPullRequestQuery = (conversationId: string) => {+ const { data: startupConfig } = useGetStartupConfig();+ const userId = useRecoilValue(store.user)?.id ?? '';+ return useQuery<TConversationPullRequestResponse>(+ [QueryKeys.conversationPullRequest, conversationId],+ ({ signal }) => {+ advertisedConcurrency = startupConfig?.pullRequestsMaxConcurrentLookups;+ return batcherFor(userId).load(conversationId, signal);+ },+ {+ /** The batch route is newer than the flag: ask only a server that says it has it. */+ enabled:+ startupConfig?.pullRequestsEnabled === true &&+ startupConfig.pullRequestsBatchVersion === PULL_REQUEST_BATCH_VERSION &&+ userId !== '' &&+ isSavedConversation(conversationId),+ staleTime: SETTLED_REFRESH_MS,+ retry: false,+ refetchOnWindowFocus: true,+ },+ );+};diff --git a/client/src/hooks/AuthContext.tsx b/client/src/hooks/AuthContext.tsxindex 69264b7097..e4752f8055 100644--- a/client/src/hooks/AuthContext.tsx+++ b/client/src/hooks/AuthContext.tsx@@ -37,6 +37,7 @@ import {import {useGetRole,useGetUserQuery,+ endPullRequestSession,useLoginUserMutation,useLogoutUserMutation,useRefreshTokenMutation,@@ -64,6 +65,7 @@ const endSessionClientState = (): void => {getDefaultStore().set(resetFacetsAtom);clearRetainedFileDeletions();clearComposerDraftStorage();+ endPullRequestSession();};/*** Only recognized codes override the HTTP status used by the login error translation.diff --git a/client/src/hooks/__tests__/AuthContext.spec.tsx b/client/src/hooks/__tests__/AuthContext.spec.tsxindex 135fc80ac4..f7a667bfc7 100644--- a/client/src/hooks/__tests__/AuthContext.spec.tsx+++ b/client/src/hooks/__tests__/AuthContext.spec.tsx@@ -52,6 +52,7 @@ let mockCapturedLogoutOptions: {onError: (...args: unknown[]) => void;};+const mockEndPullRequestSession = jest.fn();const mockRefreshMutate = jest.fn();const mockLoginMutate = jest.fn();const mockLogoutMutate = jest.fn();@@ -83,6 +84,7 @@ jest.mock('~/data-provider', () => ({error: null,})),useGetRole: jest.fn(() => ({ data: null })),+ endPullRequestSession: jest.fn(() => mockEndPullRequestSession()),useListRoles: jest.fn(() => ({ data: undefined })),}));@@ -508,6 +510,28 @@ describe('AuthContextProvider — logout onSuccess/onError handling', () => {jotaiStore.set(resetChatFilterSessionAtom);});+ it('ends the sidebar pull request queue at the logout session boundary', () => {+ mockEndPullRequestSession.mockClear();+ renderProvider();++ act(() => {+ mockCapturedLogoutOptions.onSuccess({ message: 'Logout successful' });+ });++ expect(mockEndPullRequestSession).toHaveBeenCalled();+ });++ it('does not end the sidebar pull request queue while a session is being established', () => {+ mockEndPullRequestSession.mockClear();+ renderProvider();++ act(() => {+ capturedAuthContext?.completeAuthentication('auth-token', { id: 'user-1' } as never);+ });++ expect(mockEndPullRequestSession).not.toHaveBeenCalled();+ });+it('does not call window.location.replace when redirect is absent', async () => {const replaceSpy = jest.spyOn(window.location, 'replace').mockImplementation(() => {});diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.jsonindex 10b2879b68..0b5d0574de 100644--- a/client/src/locales/en/translation.json+++ b/client/src/locales/en/translation.json@@ -7,6 +7,7 @@"com_ui_pr_checks_running": "Running","com_ui_pr_deletions": "{{0}} lines removed","com_ui_pr_label": "PR #{{0}}",+ "com_ui_pr_load_failed": "Couldn't load the pull request","com_ui_pr_open_in_github": "Open in GitHub","com_ui_pr_refresh_failed": "Couldn't refresh the pull request","com_ui_pr_state": "State: {{0}}",diff --git a/librechat.example.yaml b/librechat.example.yamlindex 982f7fd9d1..a22a981ad5 100644--- a/librechat.example.yaml+++ b/librechat.example.yaml@@ -946,11 +946,17 @@ endpoints:# # Credentials cached at once (1 to 10000), deployment-wide; the one idle longest is dropped# # past it. When principals configure different values, the largest applies.# cacheMaxCredentials: 256+ # # Lookups one sidebar request runs at once (1 to 16); each is a few GitHub requests.+ # maxConcurrentLookups: 4+ # # Seconds one sidebar request may stay open in total (1 to 120); entries still waiting then+ # # answer with an upstream error and the row shows nothing until the next refresh.+ # batchTimeoutSeconds: 20# # Bounds on one lookup. A repository with many check runs reads one page of 100 per request.# requestTimeoutSeconds: 10 # longest single GitHub request (1 to 60)# lookupTimeoutSeconds: 30 # longest the whole lookup may take (1 to 120)# maxCheckRunPages: 10 # pages read before checks are reported as running (1 to 50)# maxCandidatePullRequests: 10 # pull requests listed per state when matching a reused branch (1 to 100)+ # maxCandidatePages: 1 # pages of those read per state, for branch names reused more often (1 to 10)# maxHeadComparisons: 3 # candidates compared with the chat's last commit (0 to 20)# # "run_in_background" makes Code Interpreter tools eligible by default and enables per-tool MCP opt-in.# # "tool_intents" enables live model-written labels for native tools and opted-in MCP tools.diff --git a/packages/api/src/code/decision.ts b/packages/api/src/code/decision.tsindex 32d16e2f8c..ee6fd69c16 100644--- a/packages/api/src/code/decision.ts+++ b/packages/api/src/code/decision.ts@@ -20,7 +20,12 @@ export interface ConversationCodeEnvironmentDecision {export type StoredConversationDecision = Pick<TConversation,'conversationId' | 'codeEnvironmentMode' | 'codeWorkspaces'-> & { codeEnvironmentRevision?: number };+> & {+ codeEnvironmentRevision?: number;+ /** Read in the same snapshot as the workspaces, so a lane report can be fenced by exactly the+ * attachment the run was admitted on. Absent when the read did not carry it. */+ codeAttachmentEpoch?: number;+};function canonicalSelections(selections: CodeWorkspaceSelection[]): CodeWorkspaceSelection[] {return canonicalizeCodeWorkspaceSelections(selections);diff --git a/packages/api/src/code/lane.spec.ts b/packages/api/src/code/lane.spec.tsindex 922003e573..e7038e9f99 100644--- a/packages/api/src/code/lane.spec.ts+++ b/packages/api/src/code/lane.spec.ts@@ -466,6 +466,41 @@ describe('createLaneGitRecorder target conversation', () => {});});+ it('fences an ordinary conversation by the epoch of the snapshot the run was admitted on', async () => {+ const getConvoLaneContext = jest.fn().mockResolvedValue({ codeAttachmentEpoch: 2 });+ const { record, setConvoLaneGit } = build({ getConvoLaneContext, admittedEpoch: 0 });+ await record(laneGit);+ expect(written(setConvoLaneGit)[0].workspace.epoch).toBe(0);+ });++ it('keeps an admitted epoch of zero, rather than reading a newer one in its place', async () => {+ const getConvoLaneContext = jest.fn().mockResolvedValue({ codeAttachmentEpoch: 5 });+ const { record, setConvoLaneGit } = build({ getConvoLaneContext, admittedEpoch: 0 });+ await record(laneGit);+ expect(written(setConvoLaneGit)[0].workspace.epoch).toBe(0);+ });++ it('falls back to the route read when the admitted decision carried no epoch', async () => {+ const getConvoLaneContext = jest.fn().mockResolvedValue({ codeAttachmentEpoch: 3 });+ const { record, setConvoLaneGit } = build({ getConvoLaneContext });+ await record(laneGit);+ expect(written(setConvoLaneGit)[0].workspace.epoch).toBe(3);+ });++ it("fences a subagent thread by its root's epoch, which the admitted decision cannot know", async () => {+ const getConvoLaneContext = jest.fn().mockResolvedValue({+ subagentThread: { rootConversationId: 'visible-root' },+ codeAttachmentEpoch: 6,+ });+ const { record, setConvoLaneGit } = build({+ conversationId: 'child-thread',+ getConvoLaneContext,+ admittedEpoch: 1,+ });+ await record(laneGit);+ expect(written(setConvoLaneGit)[0].workspace.epoch).toBe(6);+ });+it('records an ordinary conversation on itself', async () => {const getConvoLaneContext = jest.fn().mockResolvedValue({ codeAttachmentEpoch: 0 });const { record, setConvoLaneGit } = build({ conversationId: 'plain', getConvoLaneContext });diff --git a/packages/api/src/code/lane.ts b/packages/api/src/code/lane.tsindex 61368ecb27..77322e9722 100644--- a/packages/api/src/code/lane.ts+++ b/packages/api/src/code/lane.ts@@ -79,6 +79,7 @@ export async function createLaneGitRecorder({conversationId,repo,workspace,+ admittedEpoch,getConvoLaneContext,reserveConvoLaneGitSeq,setConvoLaneGit,@@ -89,6 +90,13 @@ export async function createLaneGitRecorder({conversationId: string | undefined;repo?: string;workspace?: { environmentId: string; workspaceId: string };+ /**+ * The attachment epoch read in the same snapshot as the workspace this run was admitted on (the+ * admitted decision carries both). For a conversation that is its own lane it is the epoch the+ * fence uses, so an A to B to A move between two separate reads cannot satisfy both. A subagent+ * thread writes to its root, whose epoch only the route read can supply, so it still reads it.+ */+ admittedEpoch?: number;getConvoLaneContext?: LaneContextReader;reserveConvoLaneGitSeq: LaneSeqReserver;setConvoLaneGit: LaneGitWriter;@@ -103,7 +111,7 @@ export async function createLaneGitRecorder({placed = {conversationId: root || conversationId,required: Boolean(root),- epoch: context?.codeAttachmentEpoch ?? 0,+ epoch: (root ? undefined : admittedEpoch) ?? context?.codeAttachmentEpoch ?? 0,};} catch (error) {logger.warn('[LaneGit] Failed to place a lane recorder', getSafeErrorMetadata(error));diff --git a/packages/api/src/pulls/capabilities.spec.ts b/packages/api/src/pulls/capabilities.spec.tsnew file mode 100644index 0000000000..dd4288ad5e--- /dev/null+++ b/packages/api/src/pulls/capabilities.spec.ts@@ -0,0 +1,36 @@+import { PULL_REQUEST_BATCH_VERSION } from 'librechat-data-provider';+import type { AppConfig } from '@librechat/data-schemas';+import { resolvePullRequestCapabilities } from './capabilities';++const configWith = (pullRequests?: Record<string, unknown>) =>+ ({ endpoints: { agents: pullRequests ? { pullRequests } : {} } }) as unknown as AppConfig;++describe('resolvePullRequestCapabilities', () => {+ it('advertises the flag, the batch version and the lookup limit together when the feature is on', () => {+ expect(resolvePullRequestCapabilities(configWith({ enabled: true }))).toEqual({+ pullRequestsEnabled: true,+ pullRequestsBatchVersion: PULL_REQUEST_BATCH_VERSION,+ pullRequestsMaxConcurrentLookups: 4,+ });+ });++ it('advertises the configured lookup limit', () => {+ expect(+ resolvePullRequestCapabilities(configWith({ enabled: true, maxConcurrentLookups: 2 })),+ ).toMatchObject({ pullRequestsMaxConcurrentLookups: 2 });+ });++ it.each([+ ['no config', undefined],+ ['a null config', null],+ ['a config without endpoints', {} as AppConfig],+ ['no pull request settings', configWith()],+ ['the feature switched off', configWith({ enabled: false })],+ ['a non-true value', configWith({ enabled: 'yes' })],+ ])('advertises neither the flag nor a version with %s', (_label, appConfig) => {+ const capabilities = resolvePullRequestCapabilities(appConfig);+ expect(capabilities).toEqual({ pullRequestsEnabled: false });+ expect(capabilities).not.toHaveProperty('pullRequestsBatchVersion');+ expect(capabilities).not.toHaveProperty('pullRequestsMaxConcurrentLookups');+ });+});diff --git a/packages/api/src/pulls/capabilities.ts b/packages/api/src/pulls/capabilities.tsnew file mode 100644index 0000000000..846d876d6e--- /dev/null+++ b/packages/api/src/pulls/capabilities.ts@@ -0,0 +1,33 @@+import { EModelEndpoint, PULL_REQUEST_BATCH_VERSION } from 'librechat-data-provider';+import type { TAgentsEndpoint } from 'librechat-data-provider';+import type { AppConfig } from '@librechat/data-schemas';++export type PullRequestCapabilities = {+ pullRequestsEnabled: boolean;+ /** Present only with the feature on, so a client never sees a version without the flag. */+ pullRequestsBatchVersion?: typeof PULL_REQUEST_BATCH_VERSION;+ /** The lookups one batch runs at once, so a client that falls back to the single route can+ * keep to the same limit while a replica without the batch route is still serving it. */+ pullRequestsMaxConcurrentLookups?: number;+};++/**+ * What the startup config tells a client about pull requests: whether the deployment turned the+ * feature on, and, once it has, which version of the batch route this server serves, so the+ * sidebar asks only a server that has it.+ */+export function resolvePullRequestCapabilities(+ appConfig: Pick<AppConfig, 'endpoints'> | null | undefined,+): PullRequestCapabilities {+ const agents = appConfig?.endpoints?.[EModelEndpoint.agents] as TAgentsEndpoint | undefined;+ const enabled = agents?.pullRequests?.enabled === true;+ return {+ pullRequestsEnabled: enabled,+ ...(enabled+ ? {+ pullRequestsBatchVersion: PULL_REQUEST_BATCH_VERSION,+ pullRequestsMaxConcurrentLookups: agents?.pullRequests?.maxConcurrentLookups ?? 4,+ }+ : {}),+ };+}diff --git a/packages/api/src/pulls/github.spec.ts b/packages/api/src/pulls/github.spec.tsindex 2351923b34..93e9b2f2e6 100644--- a/packages/api/src/pulls/github.spec.ts+++ b/packages/api/src/pulls/github.spec.ts@@ -486,9 +486,9 @@ describe('matching the recorded head', () => {expect(compares.length).toBeLessThanOrEqual(3);});- it.each([null, undefined])('does not compare when no head was recorded (%s)', async (head) => {+ it('does not compare when the caller never recorded a head', async () => {const { source, fetchFn } = sourceFor(routes('diverged'));- await expect(findWith(source, head)).resolves.toMatchObject({ number: 7 });+ await expect(findWith(source, undefined)).resolves.toMatchObject({ number: 7 });expect(fetchFn.mock.calls.some(([url]) => String(url).includes('/compare/'))).toBe(false);});@@ -677,3 +677,260 @@ describe('a secondary rate limit without limiting headers', () => {expect(String(error.message)).not.toContain('secondary');});});++describe('a 429 that carries no wait', () => {+ const body = (message: string) => () =>+ new Response(JSON.stringify({ message }), { status: 429 });++ it('is read for the secondary limit message and waits at least a minute', async () => {+ const { source } = sourceFor({+ '/pulls?state=open': body('You have exceeded a secondary rate limit.'),+ });+ const error = await find(source).catch((caught) => caught);+ expect(error.code).toBe('RATE_LIMITED');+ expect(error.retryAfterMs).toBeGreaterThanOrEqual(60_000);+ });++ it('keeps the wait GitHub named, whatever the body says', async () => {+ const { source } = sourceFor({+ '/pulls?state=open': () =>+ new Response(JSON.stringify({ message: 'secondary rate limit' }), {+ status: 429,+ headers: { 'retry-after': '7' },+ }),+ });+ const error = await find(source).catch((caught) => caught);+ expect(error.retryAfterMs).toBe(7_000);+ });++ it('leaves the wait unnamed for an ordinary 429', async () => {+ const { source } = sourceFor({ '/pulls?state=open': body('Too many requests') });+ const error = await find(source).catch((caught) => caught);+ expect(error.code).toBe('RATE_LIMITED');+ expect(error.retryAfterMs).toBeUndefined();+ });+});++describe('check runs of a head that vanished', () => {+ it('is an upstream error, not a pull request with no checks', async () => {+ const { source } = sourceFor({+ '/pulls?state=open': () => json(listed()),+ '/pulls/7': () => json(pull()),+ '/check-runs': () => new Response('', { status: 404 }),+ });+ await expect(find(source)).rejects.toMatchObject({ code: 'UPSTREAM_ERROR' });+ });++ it('is an upstream error when a later page of check runs disappears', async () => {+ let calls = 0;+ const { source } = sourceFor({+ '/pulls?state=open': () => json(listed()),+ '/pulls/7': () => json(pull()),+ '/check-runs': () =>+ ++calls === 1+ ? json({+ total_count: 150,+ check_runs: Array.from({ length: 100 }, () => ({+ status: 'completed',+ conclusion: 'success',+ })),+ })+ : new Response('', { status: 404 }),+ });+ await expect(find(source)).rejects.toMatchObject({ code: 'UPSTREAM_ERROR' });+ });+});++describe('a lane with a branch and no commit yet', () => {+ it('matches nothing, so an earlier incarnation of the branch name is never shown', async () => {+ const { source, fetchFn } = sourceFor({+ '/pulls?state=open': () => json([]),+ '/pulls?state=closed': () => json([{ number: 9, state: 'closed', head: { sha } }]),+ '/pulls/9': () => json(pull({ number: 9, state: 'closed', merged: true })),+ '/check-runs': () => json({ check_runs: [] }),+ });+ await expect(+ source.find({ repo: 'o/r', branch: 'feat/x', head: null, token: 't' }),+ ).resolves.toBeNull();+ expect(fetchFn).not.toHaveBeenCalled();+ });++ it('still matches by branch when the caller never recorded a head', async () => {+ const { source } = sourceFor({+ '/pulls?state=open': () => json(listed()),+ '/pulls/7': () => json(pull()),+ '/check-runs': () => json({ check_runs: [] }),+ });+ await expect(find(source)).resolves.toMatchObject({ number: 7 });+ });+});++describe('open pull requests before closed ones, from any repository', () => {+ const recorded = 'c'.repeat(40);+ it('prefers an open pull request from a fork over a closed one in the base repository', async () => {+ const { source } = sourceFor({+ '/pulls?state=open': () => json([]),+ '/pulls?state=closed': () => json([{ number: 5, state: 'closed', head: { sha: recorded } }]),+ '/pulls?per_page': () =>+ json([{ number: 12, state: 'open', head: { sha: recorded, ref: 'feat/x' } }]),+ '/pulls/12': () => json(pull({ number: 12, head: { sha: recorded } })),+ '/pulls/5': () => json(pull({ number: 5, state: 'closed', head: { sha: recorded } })),+ '/check-runs': () => json({ total_count: 0, check_runs: [] }),+ });+ await expect(+ source.find({ repo: 'o/r', branch: 'feat/x', head: recorded, token: 't' }),+ ).resolves.toMatchObject({ number: 12, state: 'open' });+ });++ it('still takes a closed pull request when no open one matches anywhere', async () => {+ const { source } = sourceFor({+ '/pulls?state=open': () => json([]),+ '/pulls?state=closed': () => json([{ number: 5, state: 'closed', head: { sha: recorded } }]),+ '/pulls?per_page': () => json([]),+ '/pulls/5': () =>+ json(pull({ number: 5, state: 'closed', merged: true, head: { sha: recorded } })),+ '/check-runs': () => json({ total_count: 0, check_runs: [] }),+ });+ await expect(+ source.find({ repo: 'o/r', branch: 'feat/x', head: recorded, token: 't' }),+ ).resolves.toMatchObject({ number: 5, state: 'merged' });+ });+});++describe('the checks of a fork pull request', () => {+ const recorded = 'c'.repeat(40);+ const routes = () => ({+ '/pulls?state=open': () => json([]),+ '/pulls?state=closed': () => json([]),+ '/pulls?per_page': () =>+ json([{ number: 12, state: 'open', head: { sha: recorded, ref: 'feat/x' } }]),+ '/pulls/12': () =>+ json(+ pull({+ number: 12,+ head: { sha: recorded, repo: { full_name: 'fork-owner/r' } },+ }),+ ),+ '/check-runs': () =>+ json({ total_count: 1, check_runs: [{ status: 'completed', conclusion: 'failure' }] }),+ });+ const run = (+ source: ReturnType<typeof createGitHubPullRequestSource>,+ allowedRepositories?: string[],+ ) =>+ source.find({+ repo: 'o/r',+ branch: 'feat/x',+ head: recorded,+ token: 't',+ allowedRepositories,+ });+ const checkUrls = (fetchFn: jest.Mock) =>+ fetchFn.mock.calls.map(([url]) => String(url)).filter((url) => url.includes('/check-runs'));++ it('reads them from the fork when an administrator allowed that repository', async () => {+ const { source, fetchFn } = sourceFor(routes());+ await expect(run(source, ['o/r', 'fork-owner/*'])).resolves.toMatchObject({+ checks: 'failing',+ });+ expect(checkUrls(fetchFn)[0]).toContain('/repos/fork-owner/r/commits/');+ });++ it('never sends the token to a fork nobody allowed, and reads the base repository', async () => {+ const { source, fetchFn } = sourceFor(routes());+ await run(source, ['o/r']);+ expect(checkUrls(fetchFn)[0]).toContain('/repos/o/r/commits/');+ expect(fetchFn.mock.calls.some(([url]) => String(url).includes('fork-owner'))).toBe(false);+ });++ it('reads the base repository when the head lives there', async () => {+ const { source, fetchFn } = sourceFor({+ ...routes(),+ '/pulls/12': () =>+ json(pull({ number: 12, head: { sha: recorded, repo: { full_name: 'O/R' } } })),+ });+ await run(source, ['o/r', 'fork-owner/*']);+ expect(checkUrls(fetchFn)[0]).toContain('/repos/o/r/commits/');+ });+});++describe('reading more than one page of candidates', () => {+ const recorded = 'c'.repeat(40);+ const item = (number: number, sha_: string) => ({ number, state: 'open', head: { sha: sha_ } });+ const pageOf = (url: string) => Number(new URL(url).searchParams.get('page') ?? '1');++ function paged(pages: unknown[][]) {+ const fetchFn = jest.fn(async (input: string) => {+ const url = String(input);+ if (url.includes('/pulls?state=open')) return json(pages[pageOf(url) - 1] ?? []);+ if (url.includes('/pulls?state=closed')) return json([]);+ if (url.includes('/compare/')) {+ return json({ status: url.includes(`...${'d'.repeat(40)}`) ? 'ahead' : 'diverged' });+ }+ if (url.includes('/pulls/')) {+ return json(+ pull({ number: Number(url.split('/pulls/')[1]), head: { sha: 'd'.repeat(40) } }),+ );+ }+ if (url.includes('/check-runs')) return json({ total_count: 0, check_runs: [] });+ if (url.includes('/commits/')) return json([]);+ throw new Error(`unexpected ${url}`);+ });+ return { fetchFn, source: createGitHubPullRequestSource({ fetchFn }) };+ }+ const first = Array.from({ length: 2 }, (_, i) => item(i + 1, 'e'.repeat(40)));+ const second = [item(30, 'd'.repeat(40))];+ const limits = { maxCandidatePullRequests: 2, maxHeadComparisons: 5 };++ it('reaches an older matching pull request on a later page within the budget', async () => {+ const { source } = paged([first, second]);+ await expect(+ source.find({+ repo: 'o/r',+ branch: 'feat/x',+ head: recorded,+ token: 't',+ limits: { ...limits, maxCandidatePages: 2 },+ }),+ ).resolves.toMatchObject({ number: 30 });+ });++ it('stops at one page by default, as before', async () => {+ const { source, fetchFn } = paged([first, second]);+ await expect(+ source.find({ repo: 'o/r', branch: 'feat/x', head: recorded, token: 't', limits }),+ ).resolves.toBeNull();+ expect(+ fetchFn.mock.calls.filter(([url]) => String(url).includes('/pulls?state=open')),+ ).toHaveLength(1);+ });++ it('does not ask for another page after a short one', async () => {+ const { source, fetchFn } = paged([[item(1, 'e'.repeat(40))], second]);+ await source.find({+ repo: 'o/r',+ branch: 'feat/x',+ head: recorded,+ token: 't',+ limits: { ...limits, maxCandidatePages: 5 },+ });+ expect(+ fetchFn.mock.calls.filter(([url]) => String(url).includes('/pulls?state=open')),+ ).toHaveLength(1);+ });++ it('never reads past the configured page budget', async () => {+ const full = [first, first, first, first, first];+ const { source, fetchFn } = paged(full);+ await source.find({+ repo: 'o/r',+ branch: 'feat/x',+ head: recorded,+ token: 't',+ limits: { ...limits, maxCandidatePages: 3 },+ });+ expect(+ fetchFn.mock.calls.filter(([url]) => String(url).includes('/pulls?state=open')),+ ).toHaveLength(3);+ });+});diff --git a/packages/api/src/pulls/github.ts b/packages/api/src/pulls/github.tsindex 2b273c0b9a..80d3cff111 100644--- a/packages/api/src/pulls/github.ts+++ b/packages/api/src/pulls/github.ts@@ -5,6 +5,7 @@ import type {TConversationPullRequest,} from 'librechat-data-provider';import type { PullRequestSource } from './types';+import { isAllowedRepository } from './repository';import { PullRequestSourceError } from './types';const GITHUB_API_BASE = 'https://api.github.com';@@ -15,6 +16,7 @@ const DEFAULT_MAX_CHECK_RUN_PAGES = 10;const CHECK_RUN_PAGE_SIZE = 100;const DEFAULT_MAX_CANDIDATE_PULL_REQUESTS = 10;const DEFAULT_MAX_HEAD_COMPARISONS = 3;+const DEFAULT_MAX_CANDIDATE_PAGES = 1;/*** Comparing `recorded...candidate`: `ahead` means the candidate builds on the recorded commit and* `identical` that it is the recorded commit. `behind` means the candidate does not contain it@@ -48,6 +50,8 @@ type GitHubPull = {mergeable: boolean | null;/** The head this detail describes; the check runs are read for this same commit. */headSha: string;+ /** The repository that head lives in; a fork's checks run there, not in the base repository. */+ headRepo?: string;};type GitHubCheckRun = { status: string; conclusion: string | null };@@ -87,6 +91,10 @@ function parsePull(value: unknown): GitHubPull {) {throw new PullRequestSourceError('UPSTREAM_ERROR');}+ const headRepo =+ isRecord(value.head.repo) && typeof value.head.repo.full_name === 'string'+ ? value.head.repo.full_name+ : undefined;return {number: value.number,title: value.title,@@ -98,6 +106,7 @@ function parsePull(value: unknown): GitHubPull {deletions: value.deletions,mergeable: value.mergeable,headSha: value.head.sha,+ ...(headRepo ? { headRepo } : {}),};}@@ -198,7 +207,7 @@ function isRateLimited(response: Response): boolean {* message. The body is read bounded and only matched, never stored or returned.*/async function isSecondaryLimit(response: Response): Promise<boolean> {- if (response.status !== 403) return false;+ if (response.status !== 403 && response.status !== 429) return false;try {const text = (await response.text()).slice(0, MAX_ERROR_BODY_CHARS);return SECONDARY_LIMIT_MESSAGE.test(text);@@ -245,6 +254,7 @@ export function createGitHubPullRequestSource({maxCheckRunPages: number;maxCandidatePullRequests: number;maxHeadComparisons: number;+ maxCandidatePages: number;};async function getJson(@@ -252,6 +262,8 @@ export function createGitHubPullRequestSource({lookup: Lookup,/** Statuses that mean "nothing there" for this request, besides 404. */absent: readonly number[] = [],+ /** Whether a 404 means "nothing there". Check runs for a commit that was just read are not. */+ notFoundIsAbsent = true,): Promise<unknown | null> {let response: Response;try {@@ -275,13 +287,19 @@ export function createGitHubPullRequestSource({}}if (isRateLimited(response)) {- throw new PullRequestSourceError('RATE_LIMITED', retryAfterMs(response));+ const hinted = retryAfterMs(response);+ /** A 429 that names no wait may still be a secondary limit, told apart by its message. */+ const wait =+ hinted == null && (await isSecondaryLimit(response)) ? SECONDARY_LIMIT_WAIT_MS : hinted;+ throw new PullRequestSourceError('RATE_LIMITED', wait);}if (await isSecondaryLimit(response)) {throw new PullRequestSourceError('RATE_LIMITED', SECONDARY_LIMIT_WAIT_MS);}/** A repository the token cannot see is indistinguishable from one without pull requests. */- if (response.status === 404 || absent.includes(response.status)) return null;+ if ((notFoundIsAbsent && response.status === 404) || absent.includes(response.status)) {+ return null;+ }throw new PullRequestSourceError('UPSTREAM_ERROR');}@@ -292,11 +310,14 @@ export function createGitHubPullRequestSource({): Promise<{ runs: GitHubCheckRun[]; incomplete: boolean }> {const runs: GitHubCheckRun[] = [];for (let page = 1; page <= lookup.maxCheckRunPages; page++) {+ /** The head was read a moment ago, so a 404 here is a head that vanished, not no checks. */const body = await getJson(`${pathname}?per_page=${CHECK_RUN_PAGE_SIZE}&page=${page}`,lookup,+ [],+ false,);- if (body == null) return { runs, incomplete: false };+ if (body == null) throw new PullRequestSourceError('UPSTREAM_ERROR');const parsed = parseCheckRuns(body);runs.push(...parsed.runs);const done =@@ -309,7 +330,13 @@ export function createGitHubPullRequestSource({}return {- async find({ repo, branch, head: recordedHead, token, limits }) {+ async find({ repo, branch, head: recordedHead, token, limits, allowedRepositories }) {+ /**+ * A lane with a branch and no commit yet has nothing to match a pull request against, and+ * every candidate would be accepted, including an earlier incarnation of a reused branch+ * name. `undefined` is a caller that never recorded a head, which keeps matching by branch.+ */+ if (recordedHead === null) return null;const lookup: Lookup = {token,requestTimeoutMs: limits?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,@@ -318,6 +345,7 @@ export function createGitHubPullRequestSource({maxCandidatePullRequests:limits?.maxCandidatePullRequests ?? DEFAULT_MAX_CANDIDATE_PULL_REQUESTS,maxHeadComparisons: limits?.maxHeadComparisons ?? DEFAULT_MAX_HEAD_COMPARISONS,+ maxCandidatePages: limits?.maxCandidatePages ?? DEFAULT_MAX_CANDIDATE_PAGES,};const match = REPO_PATTERN.exec(repo);if (match == null || branch.length === 0) return null;@@ -326,9 +354,9 @@ export function createGitHubPullRequestSource({const base = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`;const headFilter = encodeURIComponent(`${owner}:${branch}`);/** `undefined`: the repository is not visible. An empty list: it is, and nothing matched. */- const listPulls = async (state: 'open' | 'closed', perPage: number) => {+ const listPulls = async (state: 'open' | 'closed', perPage: number, page = 1) => {const listed = await getJson(- `${base}/pulls?state=${state}&sort=updated&direction=desc&per_page=${perPage}&head=${headFilter}`,+ `${base}/pulls?state=${state}&sort=updated&direction=desc&per_page=${perPage}&page=${page}&head=${headFilter}`,lookup,);if (listed == null) return undefined;@@ -363,15 +391,35 @@ export function createGitHubPullRequestSource({}return null;};+ /**+ * Reads pages of one state until a short page, the configured page budget, or (without a+ * recorded commit, where only the newest matters) the first page. `undefined` is a+ * repository the token cannot see.+ */+ const listAll = async (state: 'open' | 'closed'): Promise<ListItem[] | undefined> => {+ const perPage =+ state === 'closed' && recorded == null ? 1 : lookup.maxCandidatePullRequests;+ const pages = state === 'closed' && recorded == null ? 1 : lookup.maxCandidatePages;+ const all: ListItem[] = [];+ for (let page = 1; page <= pages; page++) {+ const items = await listPulls(state, perPage, page);+ if (items === undefined) return page === 1 ? undefined : all;+ all.push(...items);+ if (items.length < perPage) break;+ }+ return all;+ };/** Open first on its own, so closed history on a reused branch name cannot hide it. */- const open = await listPulls('open', lookup.maxCandidatePullRequests);+ const open = await listAll('open');if (open === undefined) return null;/*** The head filter names the repository's own owner, so a pull request from a fork is not in* these lists. The recorded commit finds it instead: GitHub lists the pull requests that* carry a commit whatever fork they come from, and the branch name narrows them.*/- const forkCandidates = async (): Promise<ListItem[]> => {+ let forks: Promise<ListItem[]> | undefined;+ const forkCandidates = (): Promise<ListItem[]> => (forks ??= findForkCandidates());+ const findForkCandidates = async (): Promise<ListItem[]> => {if (recorded == null) return [];const found = await getJson(`${base}/commits/${recorded}/pulls?per_page=${lookup.maxCandidatePullRequests}`,@@ -382,15 +430,17 @@ export function createGitHubPullRequestSource({if (!Array.isArray(found)) throw new PullRequestSourceError('UPSTREAM_ERROR');return found.filter((item) => isRecord(item) && isRecord(item.head) && item.head.ref === branch)- .map(parseListItem)- .sort((a, b) => Number(a.state !== 'open') - Number(b.state !== 'open'));+ .map(parseListItem);};+ /**+ * Open pull requests win over closed ones whichever repository they come from, so a closed+ * pull request in the base repository cannot hide an open one from a fork.+ */const chosen =(await choose(open)) ??- (await choose(- (await listPulls('closed', recorded == null ? 1 : lookup.maxCandidatePullRequests)) ?? [],- )) ??- (await choose(await forkCandidates()));+ (await choose((await forkCandidates()).filter((item) => item.state === 'open'))) ??+ (await choose((await listAll('closed')) ?? [])) ??+ (await choose((await forkCandidates()).filter((item) => item.state !== 'open')));if (chosen == null) return null;/**@@ -403,7 +453,24 @@ export function createGitHubPullRequestSource({const pull = parsePull(detail);/** A push between the list and the detail can move the head off the recorded commit. */if (pull.headSha !== chosen.sha && !(await contains(pull.headSha))) return null;- const checks = await readCheckRuns(`${base}/commits/${pull.headSha}/check-runs`, lookup);+ /**+ * A fork's checks run in the fork. Its repository is read only when an administrator named+ * it, so the server's token is never used against a repository nobody authorized.+ */+ const checksBase = (() => {+ const headRepo = pull.headRepo;+ if (headRepo == null || headRepo.toLowerCase() === `${owner}/${name}`.toLowerCase()) {+ return base;+ }+ const parts = REPO_PATTERN.exec(headRepo);+ if (parts == null || !isPathSegment(parts[1]) || !isPathSegment(parts[2])) return base;+ if (!isAllowedRepository(headRepo, allowedRepositories)) return base;+ return `/repos/${encodeURIComponent(parts[1])}/${encodeURIComponent(parts[2])}`;+ })();+ const checks = await readCheckRuns(+ `${checksBase}/commits/${pull.headSha}/check-runs`,+ lookup,+ );return toConversationPullRequest(pull, checks.runs, checks.incomplete);},};diff --git a/packages/api/src/pulls/handler.spec.ts b/packages/api/src/pulls/handler.spec.tsindex ec862de7b4..dfbeaddede 100644--- a/packages/api/src/pulls/handler.spec.ts+++ b/packages/api/src/pulls/handler.spec.ts@@ -1,7 +1,11 @@import type { TConversationPullRequest } from 'librechat-data-provider';import type { Response } from 'express';import type { ServerRequest } from '~/types';-import { createConversationPullRequestHandler, resolveTokenReference } from './handler';+import {+ createConversationPullRequestHandler,+ createConversationPullRequestsHandler,+ resolveTokenReference,+} from './handler';jest.mock('@librechat/data-schemas', () => ({...jest.requireActual('@librechat/data-schemas'),@@ -84,12 +88,14 @@ describe('createConversationPullRequestHandler', () => {ttlMs: 30_000,cacheMaxEntries: 500,cacheMaxCredentials: 256,+ allowedRepositories: ['o/r'],limits: {requestTimeoutMs: 10_000,lookupTimeoutMs: 30_000,maxCheckRunPages: 10,maxCandidatePullRequests: 10,maxHeadComparisons: 3,+ maxCandidatePages: 1,},});expect(res.status).toHaveBeenCalledWith(200);@@ -104,6 +110,7 @@ describe('createConversationPullRequestHandler', () => {lookupTimeoutSeconds: 8,maxCheckRunPages: 4,maxCandidatePullRequests: 25,+ maxCandidatePages: 4,maxHeadComparisons: 6,cacheMaxEntries: 77,cacheMaxCredentials: 12,@@ -120,6 +127,7 @@ describe('createConversationPullRequestHandler', () => {maxCheckRunPages: 4,maxCandidatePullRequests: 25,maxHeadComparisons: 6,+ maxCandidatePages: 4,},}),);@@ -281,3 +289,645 @@ describe('createConversationPullRequestHandler', () => {expect(JSON.stringify(res.json.mock.calls)).not.toContain('ghp_secret');});});++describe('createConversationPullRequestsHandler', () => {+ type Row = {+ conversationId: string;+ laneGit: { branch: string | null; head: string | null; repo?: string };+ };+ const lane = (conversationId: string, repo = 'o/r', branch = `feat/${conversationId}`): Row => ({+ conversationId,+ laneGit: { branch, head: null, repo },+ });++ function batch(+ options: {+ settings?: Record<string, unknown> | null;+ lanes?: Row[];+ lookup?: jest.Mock;+ env?: Record<string, string | undefined>;+ } = {},+ ) {+ const settings = options.settings === undefined ? enabled : (options.settings ?? undefined);+ const lanes = options.lanes ?? [lane('a'), lane('b')];+ const lookup = options.lookup ?? jest.fn().mockResolvedValue({ ok: true, value: pr });+ const getConvosLaneGit = jest.fn().mockResolvedValue(lanes);+ const handler = createConversationPullRequestsHandler({+ getConvosLaneGit,+ getAppConfig: jest.fn().mockResolvedValue(configWith(settings)),+ lookup,+ env: options.env ?? { GH_TOKEN: 'ghp_secret' },+ });+ const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };+ const run = (...args: [body?: unknown, user?: string | null]) => {+ /** Read by count, so an explicit `undefined` is a real "none" and not the default. */+ const body = args.length > 0 ? args[0] : { conversationIds: ['a', 'b'] };+ const user = args.length > 1 ? args[1] : 'u1';+ return handler(+ { user: user ? { id: user } : undefined, body } as unknown as ServerRequest,+ res as unknown as Response,+ );+ };+ return { run, res, lookup, getConvosLaneGit };+ }++ it('answers each conversation in the order asked, from one owner-scoped read', async () => {+ const { run, res, getConvosLaneGit, lookup } = batch();+ await run({ conversationIds: ['b', 'a'] });+ expect(getConvosLaneGit).toHaveBeenCalledTimes(1);+ expect(getConvosLaneGit).toHaveBeenCalledWith('u1', ['b', 'a']);+ expect(lookup).toHaveBeenCalledTimes(2);+ expect(res.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'b', pullRequest: pr },+ { conversationId: 'a', pullRequest: pr },+ ],+ });+ });++ it('answers no pull request for a conversation without a stored lane, without a lookup', async () => {+ const { run, res, lookup } = batch({ lanes: [lane('a')] });+ await run({ conversationIds: ['a', 'ghost'] });+ expect(lookup).toHaveBeenCalledTimes(1);+ expect(res.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'a', pullRequest: pr },+ { conversationId: 'ghost', pullRequest: null },+ ],+ });+ });++ it('never looks up a repository the administrator did not allow', async () => {+ const { run, res, lookup } = batch({ lanes: [lane('a', 'o/r'), lane('b', 'evil/secret')] });+ await run();+ expect(lookup).toHaveBeenCalledTimes(1);+ expect(lookup).toHaveBeenCalledWith(expect.objectContaining({ repo: 'o/r' }));+ expect(res.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'a', pullRequest: pr },+ { conversationId: 'b', pullRequest: null },+ ],+ });+ });++ it('keeps one failure from hiding the others and exposes only its code', async () => {+ const lookup = jest+ .fn()+ .mockResolvedValueOnce({ ok: false, error: { code: 'RATE_LIMITED' } })+ .mockResolvedValueOnce({ ok: true, value: pr });+ const { run, res } = batch({ lookup });+ await run();+ expect(res.status).toHaveBeenCalledWith(200);+ expect(res.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'a', error: { code: 'RATE_LIMITED' } },+ { conversationId: 'b', pullRequest: pr },+ ],+ });+ });++ it('answers no pull request for everything, and reads no token, when the feature is off', async () => {+ const { run, res, lookup } = batch({ settings: { ...enabled, enabled: false } });+ await run();+ expect(lookup).not.toHaveBeenCalled();+ expect(res.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'a', pullRequest: null },+ { conversationId: 'b', pullRequest: null },+ ],+ });+ });++ it('says not configured only for the conversations that needed the token, and keeps the rest', async () => {+ const { run, res, lookup } = batch({ env: {}, lanes: [lane('a')] });+ await run({ conversationIds: ['a', 'ghost'] });+ expect(res.status).toHaveBeenCalledWith(200);+ expect(lookup).not.toHaveBeenCalled();+ expect(res.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'a', error: { code: 'NOT_CONFIGURED' } },+ { conversationId: 'ghost', pullRequest: null },+ ],+ });+ });++ it('answers a plain no pull request when nothing would have needed the token', async () => {+ const { run, res } = batch({ env: {}, lanes: [] });+ await run();+ expect(res.status).toHaveBeenCalledWith(200);+ expect(res.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'a', pullRequest: null },+ { conversationId: 'b', pullRequest: null },+ ],+ });+ });++ it('collapses duplicate ids so one conversation is looked up once', async () => {+ const { run, lookup, getConvosLaneGit } = batch({ lanes: [lane('a')] });+ await run({ conversationIds: ['a', 'a', 'a'] });+ expect(getConvosLaneGit).toHaveBeenCalledWith('u1', ['a']);+ expect(lookup).toHaveBeenCalledTimes(1);+ });++ it('runs no more lookups at once than configured', async () => {+ let active = 0;+ let peak = 0;+ const lookup = jest.fn(async () => {+ active += 1;+ peak = Math.max(peak, active);+ await new Promise((resolve) => setTimeout(resolve, 5));+ active -= 1;+ return { ok: true, value: pr };+ });+ const ids = ['a', 'b', 'c', 'd', 'e', 'f'];+ const { run } = batch({+ lookup,+ settings: { ...enabled, maxConcurrentLookups: 2 },+ lanes: ids.map((id) => lane(id)),+ });+ await run({ conversationIds: ids });+ expect(lookup).toHaveBeenCalledTimes(6);+ expect(peak).toBe(2);+ });++ it.each([+ ['no body', undefined],+ ['no list', {}],+ ['an empty list', { conversationIds: [] }],+ ['a list that is not an array', { conversationIds: 'a' }],+ ['a non-string id', { conversationIds: ['a', 7] }],+ ['a blank id', { conversationIds: ['a', ' '] }],+ ['an overlong id', { conversationIds: ['x'.repeat(257)] }],+ ['more ids than the bound', { conversationIds: Array.from({ length: 51 }, (_, i) => `c${i}`) }],+ ])('rejects %s before reading anything', async (_label, body) => {+ const { run, res, getConvosLaneGit, lookup } = batch();+ await run(body);+ expect(res.status).toHaveBeenCalledWith(400);+ expect(getConvosLaneGit).not.toHaveBeenCalled();+ expect(lookup).not.toHaveBeenCalled();+ });++ it('accepts exactly the bound', async () => {+ const ids = Array.from({ length: 50 }, (_, i) => `c${i}`);+ const { run, res } = batch({ lanes: [] });+ await run({ conversationIds: ids });+ expect(res.status).toHaveBeenCalledWith(200);+ });++ it('rejects an unauthenticated request', async () => {+ const { run, res, getConvosLaneGit } = batch();+ await run({ conversationIds: ['a'] }, null);+ expect(res.status).toHaveBeenCalledWith(400);+ expect(getConvosLaneGit).not.toHaveBeenCalled();+ });++ it('answers 500 without the error text when the read fails', async () => {+ const { run, res, getConvosLaneGit } = batch();+ getConvosLaneGit.mockRejectedValue(new Error('mongodb://u:secret@h'));+ await run();+ expect(res.status).toHaveBeenCalledWith(500);+ expect(JSON.stringify((res.json as jest.Mock).mock.calls)).not.toContain('secret');+ });++ describe('overall deadline', () => {+ const never = () => new Promise(() => undefined);++ it('answers within the deadline when a lookup stalls, keeping what finished', async () => {+ const lookup = jest+ .fn()+ .mockResolvedValueOnce({ ok: true, value: pr })+ .mockImplementationOnce(never);+ const { run, res } = batch({ lookup, settings: { ...enabled, batchTimeoutSeconds: 0.08 } });+ const started = Date.now();+ await run();+ expect(Date.now() - started).toBeLessThan(1000);+ expect(res.status).toHaveBeenCalledWith(200);+ expect(res.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'a', pullRequest: pr },+ { conversationId: 'b', error: { code: 'UPSTREAM_ERROR' } },+ ],+ });+ });++ it('starts nothing new once the deadline has passed', async () => {+ const lookup = jest.fn().mockImplementation(never);+ const ids = ['a', 'b', 'c'];+ const { run, res } = batch({+ lookup,+ lanes: ids.map((id) => lane(id)),+ settings: { ...enabled, maxConcurrentLookups: 1, batchTimeoutSeconds: 0.08 },+ });+ await run({ conversationIds: ids });+ expect(lookup).toHaveBeenCalledTimes(1);+ expect(res.json).toHaveBeenCalledWith({+ results: ids.map((conversationId) => ({+ conversationId,+ error: { code: 'UPSTREAM_ERROR' },+ })),+ });+ });++ it('counts the time spent reading the config and lanes against the deadline', async () => {+ /** The reads take most of the 0.2 s deadline, so the lookups get what is left of it, not a fresh 0.2 s. */+ const lookup = jest.fn(() => new Promise(() => undefined));+ const slowRead = <T>(value: T, ms: number) =>+ new Promise<T>((resolve) => setTimeout(() => resolve(value), ms));+ const handler = createConversationPullRequestsHandler({+ getConvosLaneGit: jest.fn(() => slowRead([lane('a')], 150)),+ getAppConfig: jest.fn(() =>+ slowRead(configWith({ ...enabled, batchTimeoutSeconds: 0.2 }), 10),+ ) as never,+ lookup: lookup as never,+ env: { GH_TOKEN: 'ghp_secret' },+ });+ const out = { status: jest.fn().mockReturnThis(), json: jest.fn() };+ const started = Date.now();+ await handler(+ { user: { id: 'u1' }, body: { conversationIds: ['a'] } } as unknown as ServerRequest,+ out as unknown as Response,+ );+ const took = Date.now() - started;+ expect(took).toBeLessThan(330);+ expect(out.json).toHaveBeenCalledWith({+ results: [{ conversationId: 'a', error: { code: 'UPSTREAM_ERROR' } }],+ });+ });++ const respond503 = {+ error: 'Pull request lookup is unavailable',+ code: 'UPSTREAM_ERROR',+ };+ const call = (handler: ReturnType<typeof createConversationPullRequestsHandler>) => {+ const out = { status: jest.fn().mockReturnThis(), json: jest.fn() };+ const pending = handler(+ { user: { id: 'u1' }, body: { conversationIds: ['a'] } } as unknown as ServerRequest,+ out as unknown as Response,+ );+ return { out, pending };+ };++ it('ends a request whose lane read never answers at the configured deadline, not the maximum', async () => {+ jest.useFakeTimers();+ try {+ const lookup = jest.fn();+ const { out, pending } = call(+ createConversationPullRequestsHandler({+ getConvosLaneGit: jest.fn(() => new Promise(() => undefined)) as never,+ getAppConfig: jest+ .fn()+ .mockResolvedValue(configWith({ ...enabled, batchTimeoutSeconds: 20 })),+ lookup: lookup as never,+ env: { GH_TOKEN: 'ghp_secret' },+ }),+ );+ await jest.advanceTimersByTimeAsync(19_000);+ expect(out.json).not.toHaveBeenCalled();+ await jest.advanceTimersByTimeAsync(2_000);+ await pending;+ expect(out.status).toHaveBeenCalledWith(503);+ expect(out.json).toHaveBeenCalledWith(respond503);+ expect(lookup).not.toHaveBeenCalled();+ } finally {+ jest.useRealTimers();+ }+ });++ it('ends a request whose config read never answers at the default deadline', async () => {+ jest.useFakeTimers();+ try {+ const lookup = jest.fn();+ const { out, pending } = call(+ createConversationPullRequestsHandler({+ getConvosLaneGit: jest.fn().mockResolvedValue([lane('a')]) as never,+ getAppConfig: jest.fn(() => new Promise(() => undefined)) as never,+ lookup: lookup as never,+ env: { GH_TOKEN: 'ghp_secret' },+ }),+ );+ await jest.advanceTimersByTimeAsync(19_000);+ expect(out.json).not.toHaveBeenCalled();+ await jest.advanceTimersByTimeAsync(2_000);+ await pending;+ expect(out.status).toHaveBeenCalledWith(503);+ expect(lookup).not.toHaveBeenCalled();+ } finally {+ jest.useRealTimers();+ }+ });++ it('holds the lane read to a configured deadline shorter than the default', async () => {+ jest.useFakeTimers();+ try {+ const { out, pending } = call(+ createConversationPullRequestsHandler({+ getConvosLaneGit: jest.fn(() => new Promise(() => undefined)) as never,+ getAppConfig: jest+ .fn()+ .mockResolvedValue(configWith({ ...enabled, batchTimeoutSeconds: 3 })),+ lookup: jest.fn() as never,+ env: { GH_TOKEN: 'ghp_secret' },+ }),+ );+ await jest.advanceTimersByTimeAsync(3_500);+ await pending;+ expect(out.status).toHaveBeenCalledWith(503);+ } finally {+ jest.useRealTimers();+ }+ });++ it('starts no lookup when the reads alone used up the deadline', async () => {+ const lookup = jest.fn().mockResolvedValue({ ok: true, value: pr });+ const { out, pending } = call(+ createConversationPullRequestsHandler({+ getConvosLaneGit: jest.fn(+ () => new Promise((resolve) => setTimeout(() => resolve([lane('a')]), 150)),+ ) as never,+ getAppConfig: jest+ .fn()+ .mockResolvedValue(configWith({ ...enabled, batchTimeoutSeconds: 0.05 })),+ lookup: lookup as never,+ env: { GH_TOKEN: 'ghp_secret' },+ }),+ );+ await pending;+ expect(lookup).not.toHaveBeenCalled();+ expect(out.status).toHaveBeenCalledWith(503);+ expect(out.json).toHaveBeenCalledWith(respond503);+ });++ it('does not fail unhandled when the lane read rejects after the request has ended', async () => {+ const unhandled = jest.fn();+ process.on('unhandledRejection', unhandled);+ try {+ const { pending } = call(+ createConversationPullRequestsHandler({+ getConvosLaneGit: jest.fn(+ () => new Promise((_, reject) => setTimeout(() => reject(new Error('late')), 30)),+ ) as never,+ getAppConfig: jest.fn().mockResolvedValue(configWith({ ...enabled, enabled: false })),+ lookup: jest.fn() as never,+ env: { GH_TOKEN: 'ghp_secret' },+ }),+ );+ await pending;+ await new Promise((resolve) => setTimeout(resolve, 80));+ expect(unhandled).not.toHaveBeenCalled();+ } finally {+ process.off('unhandledRejection', unhandled);+ }+ });++ it('does not change the answer of a batch that finishes in time', async () => {+ const { run, res } = batch({ settings: { ...enabled, batchTimeoutSeconds: 5 } });+ await run();+ expect(res.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'a', pullRequest: pr },+ { conversationId: 'b', pullRequest: null },+ ].map((entry, index) => (index === 1 ? { ...entry, pullRequest: pr } : entry)),+ });+ });+ });++ describe('concurrency across requests', () => {+ /** Lookups that end only when released, so a request can finish while its lookups still run. */+ const heldLookups = () => {+ let active = 0;+ let peak = 0;+ const releases: Array<() => void> = [];+ const lookup = jest.fn(+ () =>+ new Promise((resolve) => {+ active += 1;+ peak = Math.max(peak, active);+ releases.push(() => {+ active -= 1;+ resolve({ ok: true, value: pr });+ });+ }),+ );+ return { lookup, releases, active: () => active, peak: () => peak };+ };+ const ids = ['a', 'b', 'c', 'd'];+ const lanes = ids.map((id) => lane(id));+ const settings = { ...enabled, maxConcurrentLookups: 2, batchTimeoutSeconds: 0.08 };+ const flush = () => new Promise((resolve) => setTimeout(resolve, 20));++ it('keeps the lookups of a timed-out request inside the limit for the next request', async () => {+ const held = heldLookups();+ const handler = batch({ lookup: held.lookup, lanes, settings });+ await handler.run({ conversationIds: ids });+ /** The first request has answered, yet its two lookups are still out. */+ expect(held.active()).toBe(2);+ const second = handler.run({ conversationIds: ids });+ await flush();+ expect(held.lookup).toHaveBeenCalledTimes(2);+ expect(held.peak()).toBe(2);+ held.releases.splice(0).forEach((release) => release());+ await second;+ held.releases.splice(0).forEach((release) => release());+ expect(held.peak()).toBe(2);+ });++ it('starts no lookup for an entry that gave up while it waited behind another request', async () => {+ const held = heldLookups();+ const handler = batch({ lookup: held.lookup, lanes, settings });+ /** The first request ends with its two lookups still holding both slots. */+ await handler.run({ conversationIds: ids });+ expect(held.lookup).toHaveBeenCalledTimes(2);+ /** The second request's entries wait for those slots, and give up at its own deadline. */+ await handler.run({ conversationIds: ids });+ expect(held.lookup).toHaveBeenCalledTimes(2);+ /** Slots free up only now; the entries that already answered must not start work. */+ held.releases.splice(0).forEach((release) => release());+ await flush();+ expect(held.lookup).toHaveBeenCalledTimes(2);+ expect(held.active()).toBe(0);+ });++ it("counts slots per credential, so one tenant's stalled lookups do not block another's", async () => {+ const held = heldLookups();+ const configFor = (tokenName: string) =>+ configWith({+ ...enabled,+ token: `\${${tokenName}}`,+ maxConcurrentLookups: 1,+ batchTimeoutSeconds: 0.2,+ });+ /** Each tenant's config names its own token, as principal-scoped configuration can. */+ const getAppConfig = jest.fn(async (options: { userId?: string; role?: string }) =>+ configFor(options.userId === 'u2' ? 'TOKEN_TWO' : 'TOKEN_ONE'),+ );+ const handler = createConversationPullRequestsHandler({+ getConvosLaneGit: jest.fn().mockResolvedValue([lane('a')]),+ getAppConfig: getAppConfig as never,+ lookup: held.lookup as never,+ env: { TOKEN_ONE: 'token-one', TOKEN_TWO: 'token-two' },+ });+ const call = async (user: string) => {+ const out = { status: jest.fn().mockReturnThis(), json: jest.fn() };+ await handler(+ { user: { id: user }, body: { conversationIds: ['a'] } } as unknown as ServerRequest,+ out as unknown as Response,+ );+ return out;+ };++ /** The first tenant's only slot is now held by a lookup that outlived its request. */+ await call('u1');+ expect(held.active()).toBe(1);+ /** Same credential: the next request waits for that slot, gives up, and starts nothing. */+ const same = await call('u1');+ expect(held.lookup).toHaveBeenCalledTimes(1);+ expect(same.json).toHaveBeenCalledWith({+ results: [{ conversationId: 'a', error: { code: 'UPSTREAM_ERROR' } }],+ });+ /** Another credential has its own slots, so it is not held behind the first tenant. */+ await call('u2');+ expect(held.lookup).toHaveBeenCalledTimes(2);+ });++ it('looks identical lanes up once and spends one slot on them, so an unrelated lane still starts', async () => {+ const held = heldLookups();+ /** Four conversations on one branch and one on another, with room for a single lookup at a time. */+ const same = ['a', 'b', 'c', 'd'].map((id) => lane(id, 'o/r', 'feat/shared'));+ const other = lane('e', 'o/r', 'feat/other');+ const handler = batch({+ lookup: held.lookup,+ lanes: [...same, other],+ settings: { ...enabled, maxConcurrentLookups: 1, batchTimeoutSeconds: 5 },+ });+ const done = handler.run({ conversationIds: ['a', 'b', 'c', 'd', 'e'] });+ await flush();+ expect(held.lookup).toHaveBeenCalledTimes(1);+ held.releases.splice(0).forEach((release) => release());+ await flush();+ /** The shared branch finished in one lookup, freeing the only slot for the other branch. */+ expect(held.lookup).toHaveBeenCalledTimes(2);+ held.releases.splice(0).forEach((release) => release());+ await done;+ expect(handler.res.json).toHaveBeenCalledWith({+ results: ['a', 'b', 'c', 'd', 'e'].map((conversationId) => ({+ conversationId,+ pullRequest: pr,+ })),+ });+ });++ it('joins a lane another request already started instead of taking a slot of its own for it', async () => {+ const started: string[] = [];+ const releases: Array<() => void> = [];+ const lookup = jest.fn(+ (input: { branch: string }) =>+ new Promise((resolve) => {+ started.push(input.branch);+ releases.push(() => resolve({ ok: true, value: pr }));+ }),+ );+ const rows = [+ lane('a', 'o/r', 'feat/shared'),+ lane('b', 'o/r', 'feat/shared'),+ lane('e', 'o/r', 'feat/other'),+ ];+ const handler = createConversationPullRequestsHandler({+ getConvosLaneGit: jest.fn(async (_user: string, wanted: string[]) =>+ rows.filter((row) => wanted.includes(row.conversationId)),+ ),+ getAppConfig: jest+ .fn()+ .mockResolvedValue(+ configWith({ ...enabled, maxConcurrentLookups: 1, batchTimeoutSeconds: 5 }),+ ),+ lookup: lookup as never,+ env: { GH_TOKEN: 'ghp_secret' },+ });+ const call = (conversationIds: string[]) => {+ const out = { status: jest.fn().mockReturnThis(), json: jest.fn() };+ const done = handler(+ { user: { id: 'u1' }, body: { conversationIds } } as unknown as ServerRequest,+ out as unknown as Response,+ );+ return { out, done };+ };+ const first = call(['a']);+ await flush();+ const second = call(['b', 'e']);+ await flush();+ expect(started).toEqual(['feat/shared']);+ releases.shift()?.();+ await flush();+ /** The shared lane was answered once for both requests, so the only slot went to the other lane. */+ expect(started).toEqual(['feat/shared', 'feat/other']);+ releases.shift()?.();+ await Promise.all([first.done, second.done]);+ expect(second.out.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'b', pullRequest: pr },+ { conversationId: 'e', pullRequest: pr },+ ],+ });+ });++ it('gives every conversation on a shared branch the same failure when that lookup fails', async () => {+ const lookup = jest+ .fn()+ .mockResolvedValueOnce({ ok: false, error: { code: 'RATE_LIMITED' } })+ .mockResolvedValue({ ok: true, value: pr });+ const { run, res } = batch({+ lookup,+ lanes: [lane('a', 'o/r', 'feat/s'), lane('b', 'o/r', 'feat/s'), lane('c', 'o/r', 'feat/t')],+ });+ await run({ conversationIds: ['a', 'b', 'c'] });+ expect(lookup).toHaveBeenCalledTimes(2);+ expect(res.json).toHaveBeenCalledWith({+ results: [+ { conversationId: 'a', error: { code: 'RATE_LIMITED' } },+ { conversationId: 'b', error: { code: 'RATE_LIMITED' } },+ { conversationId: 'c', pullRequest: pr },+ ],+ });+ });++ it('does not merge lanes that differ in repository, branch or head', async () => {+ const head = 'a'.repeat(40);+ const rows = [+ lane('a', 'o/r', 'feat/x'),+ lane('b', 'o/r2', 'feat/x'),+ lane('c', 'o/r', 'feat/y'),+ { conversationId: 'd', laneGit: { branch: 'feat/x', head, repo: 'o/r' } },+ ];+ const { run, lookup } = batch({+ lanes: rows,+ settings: { ...enabled, allowedRepositories: ['o/*'] },+ });+ await run({ conversationIds: ['a', 'b', 'c', 'd'] });+ expect(lookup).toHaveBeenCalledTimes(4);+ });++ it('frees the slot when a lookup fails, so later requests are not stuck', async () => {+ const lookup = jest+ .fn()+ .mockRejectedValueOnce(new Error('boom'))+ .mockResolvedValue({ ok: true, value: pr });+ const handler = batch({+ lookup,+ lanes: [lane('a')],+ settings: { ...enabled, maxConcurrentLookups: 1 },+ });+ await handler.run({ conversationIds: ['a'] });+ await handler.run({ conversationIds: ['a'] });+ expect(lookup).toHaveBeenCalledTimes(2);+ });+ });++ it('uses the same lookup input as the single route', async () => {+ const single = setup({ laneGit: { branch: 'feat/a', head: null, repo: 'o/r' } });+ await single.run();+ const many = batch({ lanes: [lane('a')] });+ await many.run({ conversationIds: ['a'] });+ expect(many.lookup.mock.calls[0][0]).toEqual(single.lookup.mock.calls[0][0]);+ });+});diff --git a/packages/api/src/pulls/handler.ts b/packages/api/src/pulls/handler.tsindex 42a7209783..e04e8d7b46 100644--- a/packages/api/src/pulls/handler.ts+++ b/packages/api/src/pulls/handler.ts@@ -1,12 +1,20 @@+import { createHash } from 'node:crypto';import { logger } from '@librechat/data-schemas';-import { EModelEndpoint } from 'librechat-data-provider';-import type { TAgentsEndpoint, TConversationPullRequestResponse } from 'librechat-data-provider';+import { EModelEndpoint, PULL_REQUEST_BATCH_MAX } from 'librechat-data-provider';+import type {+ TAgentsEndpoint,+ TConversationPullRequest,+ TConversationPullRequestsEntry,+ TConversationPullRequestResponse,+ TConversationPullRequestsResponse,+} from 'librechat-data-provider';import type { AppConfig } from '@librechat/data-schemas';import type { Response } from 'express';import type { GetAppConfigOptions } from '~/app/service';import type { PullRequestLookup } from './types';import type { ServerRequest } from '~/types';import { getAppConfigOptionsFromUser } from '~/app/service';+import { isAllowedRepository } from './repository';import { getSafeErrorMetadata } from '~/utils';const MAX_CONVERSATION_ID_LENGTH = 256;@@ -24,20 +32,198 @@ export function resolveTokenReference(return env[name]?.trim() || null;}-/** `owner/name` or `owner/*`, compared without case as GitHub does. Nothing else matches. */-export function isAllowedRepository(repo: string, allowed: readonly string[] | undefined): boolean {- const [owner, name] = repo.toLowerCase().split('/');- return (allowed ?? []).some((entry) => {- const [allowedOwner, allowedName] = entry.toLowerCase().split('/');- return allowedOwner === owner && (allowedName === '*' || allowedName === name);- });-}-const validConversationId = (value: string | undefined): value is string =>value != null && value.trim() !== '' && value.length <= MAX_CONVERSATION_ID_LENGTH;const NONE: TConversationPullRequestResponse = { pullRequest: null };+type PullRequestSettings = NonNullable<TAgentsEndpoint['pullRequests']>;+type EligibleLane = { branch: string; head: string | null; repo: string };++/** Lookups in flight at once for one batch, unless configured. */+const DEFAULT_BATCH_CONCURRENCY = 4;+/** Longest one batch request may stay open, unless configured. */+const DEFAULT_BATCH_TIMEOUT_SECONDS = 20;++const TIMED_OUT = Symbol('timed-out');++/**+ * Lookups in flight across every batch request of one handler. A lookup that outlives its+ * request's deadline keeps running (and keeps its slot) until it really ends, so the next request+ * cannot start another on top of it: the configured concurrency holds across requests, not only+ * within one. Waiters are served in order.+ */+function createLookupLimiter() {+ type Scope = { active: number; waiting: Array<() => void> };+ const scopes = new Map<string, Scope>();+ return {+ /** Resolves once a slot is free under `limit`; the caller must `release` exactly once. */+ acquire(scopeKey: string, limit: number): Promise<void> {+ const scope = scopes.get(scopeKey) ?? { active: 0, waiting: [] };+ scopes.set(scopeKey, scope);+ if (scope.active < limit) {+ scope.active += 1;+ return Promise.resolve();+ }+ return new Promise<void>((resolve) => {+ scope.waiting.push(() => {+ scope.active += 1;+ resolve();+ });+ });+ },+ release(scopeKey: string, limit: number): void {+ const scope = scopes.get(scopeKey);+ if (scope == null) return;+ scope.active -= 1;+ while (scope.waiting.length > 0 && scope.active < limit) scope.waiting.shift()?.();+ /** An idle scope holds nothing, so credentials that come and go leave no entries behind. */+ if (scope.active === 0 && scope.waiting.length === 0) scopes.delete(scopeKey);+ },+ };+}++type LookupResultOf = Awaited<ReturnType<PullRequestLookup>>;+type SharedLookup = { promise: Promise<LookupResultOf | typeof TIMED_OUT>; interested: number };++/**+ * One upstream lookup per distinct input across every batch request of a handler. The first+ * request that needs a lane starts it and takes its slot; any other request for the same lane,+ * however concurrent, joins that promise and takes none. Interest is counted, so a lookup still+ * waiting for a slot starts only while some request still wants its answer, and one request+ * giving up never cancels what another is waiting for.+ */+function createSharedLookups(+ limiter: ReturnType<typeof createLookupLimiter>,+ lookup: PullRequestLookup,+) {+ const shared = new Map<string, SharedLookup>();+ return {+ /** `leave` must be called by a caller that stops waiting before the answer arrives. */+ join(+ key: string,+ scope: string,+ limit: number,+ input: Parameters<PullRequestLookup>[0],+ ): { promise: SharedLookup['promise']; leave: () => void } {+ let entry = shared.get(key);+ if (entry == null) {+ const created: SharedLookup = {+ interested: 0,+ promise: Promise.resolve(TIMED_OUT),+ };+ created.promise = (async () => {+ await limiter.acquire(scope, limit);+ try {+ if (created.interested === 0) {+ /** Nobody is waiting any more; a later request must start its own. */+ if (shared.get(key) === created) shared.delete(key);+ return TIMED_OUT;+ }+ return await lookup(input);+ } finally {+ limiter.release(scope, limit);+ }+ })().finally(() => {+ if (shared.get(key) === created) shared.delete(key);+ });+ shared.set(key, created);+ entry = created;+ }+ const joined = entry;+ joined.interested += 1;+ let left = false;+ return {+ promise: joined.promise,+ leave: () => {+ if (left) return;+ left = true;+ joined.interested -= 1;+ },+ };+ },+ };+}++/** A credential's digest, never the token, names the scope a lookup's slot is counted in. */+const limiterScope = (token: string): string =>+ createHash('sha256').update(token).digest('hex').slice(0, 32);++/** Settles with `TIMED_OUT` once `ms` has passed, and never leaves its timer running. */+async function withDeadline<T>(work: Promise<T>, ms: number): Promise<T | typeof TIMED_OUT> {+ if (ms <= 0) return TIMED_OUT;+ let timer: ReturnType<typeof setTimeout> | undefined;+ const expired = new Promise<typeof TIMED_OUT>((resolve) => {+ timer = setTimeout(() => resolve(TIMED_OUT), ms);+ });+ try {+ return await Promise.race([work, expired]);+ } finally {+ clearTimeout(timer);+ }+}++/** A lane the server's token may be used for: it names a branch and an allowed repository. */+function eligibleLane(+ laneGit: ConversationLaneGit | null | undefined,+ settings: PullRequestSettings,+): EligibleLane | null {+ if (laneGit?.branch == null || laneGit.repo == null) return null;+ if (!isAllowedRepository(laneGit.repo, settings.allowedRepositories)) return null;+ return { branch: laneGit.branch, head: laneGit.head, repo: laneGit.repo };+}++/** Everything one lookup needs from the settings, so the single and batch routes cannot differ. */+function lookupInput(settings: PullRequestSettings, token: string, lane: EligibleLane) {+ return {+ repo: lane.repo,+ branch: lane.branch,+ head: lane.head,+ token,+ ttlMs: (settings.cacheTtlSeconds ?? 30) * 1000,+ cacheMaxEntries: settings.cacheMaxEntries ?? 500,+ cacheMaxCredentials: settings.cacheMaxCredentials ?? 256,+ allowedRepositories: settings.allowedRepositories ?? [],+ limits: {+ requestTimeoutMs: (settings.requestTimeoutSeconds ?? 10) * 1000,+ lookupTimeoutMs: (settings.lookupTimeoutSeconds ?? 30) * 1000,+ maxCheckRunPages: settings.maxCheckRunPages ?? 10,+ maxCandidatePullRequests: settings.maxCandidatePullRequests ?? 10,+ maxHeadComparisons: settings.maxHeadComparisons ?? 3,+ maxCandidatePages: settings.maxCandidatePages ?? 1,+ },+ };+}++/** Runs `task` over `items` with at most `limit` in flight, keeping the results in order. */+async function mapWithLimit<T, R>(+ items: readonly T[],+ limit: number,+ task: (item: T) => Promise<R>,+): Promise<R[]> {+ const results = new Array<R>(items.length);+ let next = 0;+ const worker = async (): Promise<void> => {+ for (let index = next++; index < items.length; index = next++) {+ results[index] = await task(items[index]);+ }+ };+ await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));+ return results;+}++/** Accepts only a non-empty list of valid ids within the batch bound; duplicates collapse. */+function parseConversationIds(body: unknown): string[] | null {+ const ids = (body as { conversationIds?: unknown } | null | undefined)?.conversationIds;+ if (!Array.isArray(ids) || ids.length === 0 || ids.length > PULL_REQUEST_BATCH_MAX) return null;+ const seen = new Set<string>();+ for (const id of ids) {+ if (typeof id !== 'string' || !validConversationId(id)) return null;+ seen.add(id);+ }+ return [...seen];+}+/*** Serves the pull request of the branch a conversation's code workspace last reported. The* stored branch is read owner-scoped, so another user's conversation is indistinguishable from@@ -77,15 +263,11 @@ export function createConversationPullRequestHandler(deps: {return;}- if (laneGit?.branch == null || laneGit.repo == null) {- res.status(200).json(NONE);- return;- }-/** The repository comes from the worker, so it is never used with the token unless the* administrator named it. A repository that is not allowed looks like one without a pull* request. */- if (!isAllowedRepository(laneGit.repo, settings.allowedRepositories)) {+ const lane = eligibleLane(laneGit, settings);+ if (lane == null) {res.status(200).json(NONE);return;}@@ -97,22 +279,7 @@ export function createConversationPullRequestHandler(deps: {return;}- const result = await deps.lookup({- repo: laneGit.repo,- branch: laneGit.branch,- head: laneGit.head,- token,- ttlMs: (settings.cacheTtlSeconds ?? 30) * 1000,- cacheMaxEntries: settings.cacheMaxEntries ?? 500,- cacheMaxCredentials: settings.cacheMaxCredentials ?? 256,- limits: {- requestTimeoutMs: (settings.requestTimeoutSeconds ?? 10) * 1000,- lookupTimeoutMs: (settings.lookupTimeoutSeconds ?? 30) * 1000,- maxCheckRunPages: settings.maxCheckRunPages ?? 10,- maxCandidatePullRequests: settings.maxCandidatePullRequests ?? 10,- maxHeadComparisons: settings.maxHeadComparisons ?? 3,- },- });+ const result = await deps.lookup(lookupInput(settings, token, lane));if (!result.ok) {res.status(503).json({error: 'Pull request lookup is unavailable',@@ -127,3 +294,167 @@ export function createConversationPullRequestHandler(deps: {}};}++/**+ * Serves the pull requests of many conversations at once, for the sidebar list. It answers what+ * the single route answers for each id, from one owner-scoped read of the stored lanes, so a+ * conversation that is missing, expired, another user's or without a lane is simply "no pull+ * request". Each entry carries its own result or a stable failure code, so one repository's+ * rate limit does not hide the others. Lookups share the single route's cache, in-flight+ * sharing and rate-limit cooldown, and run a few at a time.+ */+export function createConversationPullRequestsHandler(deps: {+ getConvosLaneGit: (+ user: string,+ conversationIds: string[],+ ) => Promise<Array<{ conversationId: string; laneGit: ConversationLaneGit }>>;+ getAppConfig: (options: GetAppConfigOptions) => Promise<AppConfig>;+ lookup: PullRequestLookup;+ env: Readonly<Record<string, string | undefined>>;+}) {+ const limiter = createLookupLimiter();+ const sharedLookups = createSharedLookups(limiter, deps.lookup);+ return async (req: ServerRequest, res: Response): Promise<void> => {+ const userId = req.user?.id;+ const ids = parseConversationIds(req.body);+ if (!userId || ids == null) {+ res.status(400).json({ error: 'Invalid conversation list' });+ return;+ }+ try {+ /**+ * The clock starts when the request arrives. The configured deadline lives in the config,+ * so until the config has loaded the default applies to it; once it has, the lane read and+ * everything after it share what is left of the configured deadline, however the two reads+ * overlapped.+ */+ const startedAt = Date.now();+ const configRead = deps.getAppConfig({+ ...getAppConfigOptionsFromUser(req.user),+ skipRuntimeAugmentation: true,+ failClosed: true,+ });+ const laneRead = deps.getConvosLaneGit(userId, ids);+ /** A lane read nobody waits for (feature off, config timed out) must not fail unhandled. */+ laneRead.catch(() => undefined);+ const unavailable = () =>+ res+ .status(503)+ .json({ error: 'Pull request lookup is unavailable', code: 'UPSTREAM_ERROR' });+ const loaded = await withDeadline(configRead, DEFAULT_BATCH_TIMEOUT_SECONDS * 1000);+ if (loaded === TIMED_OUT) {+ unavailable();+ return;+ }+ const appConfig = loaded;+ const settings = (appConfig.endpoints?.[EModelEndpoint.agents] as TAgentsEndpoint | undefined)+ ?.pullRequests;+ const deadline =+ startedAt + (settings?.batchTimeoutSeconds ?? DEFAULT_BATCH_TIMEOUT_SECONDS) * 1000;+ const none = (): TConversationPullRequestsResponse => ({+ results: ids.map((conversationId) => ({ conversationId, pullRequest: null })),+ });+ if (settings?.enabled !== true) {+ res.status(200).json(none());+ return;+ }++ const lanes = await withDeadline(laneRead, deadline - Date.now());+ if (lanes === TIMED_OUT) {+ unavailable();+ return;+ }++ const eligible = new Map<string, EligibleLane>();+ for (const { conversationId, laneGit } of lanes) {+ const lane = eligibleLane(laneGit, settings);+ if (lane != null) eligible.set(conversationId, lane);+ }+ if (eligible.size === 0) {+ res.status(200).json(none());+ return;+ }++ /**+ * A missing token is a fact about the conversations that needed one, not about the request:+ * those entries say so, and every other conversation keeps its correct "no pull request".+ */+ const token = resolveTokenReference(settings.token, deps.env);+ if (token == null) {+ logger.warn('[PullRequests] Enabled without a usable token reference');+ res.status(200).json({+ results: ids.map(+ (conversationId): TConversationPullRequestsEntry =>+ eligible.has(conversationId)+ ? { conversationId, error: { code: 'NOT_CONFIGURED' } }+ : { conversationId, pullRequest: null },+ ),+ });+ return;+ }++ /**+ * One deadline for the whole request, not per lookup: each lookup may run for its own+ * configured limit, and a stalled upstream would otherwise hold a full batch open for many+ * times that. Past the deadline nothing new starts and the entries still waiting answer+ * with an upstream error; a lookup already running finishes in the background under its own+ * limit and fills the cache for the next request.+ */+ const limit = settings.maxConcurrentLookups ?? DEFAULT_BATCH_CONCURRENCY;+ const scope = limiterScope(token);+ /**+ * Conversations that share a repository, branch and head share one answer, and the lookup+ * already coalesces them, so each distinct lookup takes one slot and one deadline, not one+ * per conversation. Otherwise duplicates would hold every slot while a single request ran.+ */+ const keyOf = (lane: EligibleLane) => `${lane.repo}\0${lane.branch}\0${lane.head ?? ''}`;+ const distinct = new Map<string, EligibleLane>();+ for (const lane of eligible.values()) distinct.set(keyOf(lane), lane);+ type Outcome =+ | { ok: true; value: TConversationPullRequest | null }+ | { ok: false; code: string };+ const outcomes = new Map<string, Outcome>();+ await mapWithLimit([...distinct.entries()], limit, async ([key, lane]): Promise<void> => {+ /** Checked before anything is joined, so nothing starts once time is up. */+ const remaining = deadline - Date.now();+ if (remaining <= 0) {+ outcomes.set(key, { ok: false, code: 'UPSTREAM_ERROR' });+ return;+ }+ const input = lookupInput(settings, token, lane);+ /** The same lane under the same policy is one lookup for every request that wants it. */+ const shareKey = `${scope}\0${JSON.stringify([+ input.repo,+ input.branch,+ input.head,+ input.ttlMs,+ input.limits,+ input.allowedRepositories,+ ])}`;+ const joined = sharedLookups.join(shareKey, scope, limit, input);+ const result = await withDeadline(joined.promise, remaining);+ if (result === TIMED_OUT) {+ joined.leave();+ outcomes.set(key, { ok: false, code: 'UPSTREAM_ERROR' });+ return;+ }+ outcomes.set(+ key,+ result.ok ? { ok: true, value: result.value } : { ok: false, code: result.error.code },+ );+ });+ const looked = ids.map((conversationId): TConversationPullRequestsEntry => {+ const lane = eligible.get(conversationId);+ const outcome = lane == null ? undefined : outcomes.get(keyOf(lane));+ if (outcome == null) return { conversationId, pullRequest: null };+ return outcome.ok+ ? { conversationId, pullRequest: outcome.value }+ : { conversationId, error: { code: outcome.code } };+ });+ res.status(200).json({ results: looked });+ } catch (error) {+ logger.error('[PullRequests] Batch handler failed', getSafeErrorMetadata(error));+ res.status(500).json({ error: 'Failed to load the pull requests' });+ }+ };+}diff --git a/packages/api/src/pulls/index.ts b/packages/api/src/pulls/index.tsindex f6fca52670..7c5127bb32 100644--- a/packages/api/src/pulls/index.ts+++ b/packages/api/src/pulls/index.ts@@ -2,3 +2,6 @@ export * from './types';export * from './github';export * from './lookup';export * from './handler';+export * from './transport';+export * from './repository';+export * from './capabilities';diff --git a/packages/api/src/pulls/lookup.spec.ts b/packages/api/src/pulls/lookup.spec.tsindex 319d7c30ff..ae2ac28a62 100644--- a/packages/api/src/pulls/lookup.spec.ts+++ b/packages/api/src/pulls/lookup.spec.ts@@ -402,3 +402,44 @@ describe('cache capacity per credential', () => {expect(find).toHaveBeenCalledTimes(before);});});++describe('cache capacity shared by principals with one token', () => {+ it('keeps the largest capacity seen, so a smaller one does not trim what a larger keeps', async () => {+ const find = jest.fn().mockResolvedValue(value);+ const lookup = createPullRequestLookup({ source: { find } });+ for (const branch of ['a', 'b', 'c', 'd']) {+ await lookup({ ...input, branch, cacheMaxEntries: 100 });+ }+ await lookup({ ...input, branch: 'e', cacheMaxEntries: 2 });+ const before = find.mock.calls.length;+ for (const branch of ['a', 'b', 'c', 'd']) {+ await lookup({ ...input, branch, cacheMaxEntries: 2 });+ }+ expect(find).toHaveBeenCalledTimes(before);+ });++ it('does not let a larger capacity of one token raise the bound of another', async () => {+ const find = jest.fn().mockResolvedValue(value);+ const lookup = createPullRequestLookup({ source: { find } });+ await lookup({ ...input, token: 'big', branch: 'x', cacheMaxEntries: 100 });+ for (const branch of ['a', 'b', 'c']) {+ await lookup({ ...input, token: 'small', branch, cacheMaxEntries: 2 });+ }+ const before = find.mock.calls.length;+ await lookup({ ...input, token: 'small', branch: 'a', cacheMaxEntries: 2 });+ expect(find).toHaveBeenCalledTimes(before + 1);+ });+});++describe('the repositories the credential may be used for', () => {+ it('passes them to the source, and keeps answers for different lists apart', async () => {+ const find = jest.fn().mockResolvedValue(value);+ const lookup = createPullRequestLookup({ source: { find } });+ await lookup({ ...input, allowedRepositories: ['o/r'] });+ await lookup({ ...input, allowedRepositories: ['o/r', 'fork/*'] });+ expect(find).toHaveBeenCalledTimes(2);+ expect(find.mock.calls[1][0].allowedRepositories).toEqual(['o/r', 'fork/*']);+ await lookup({ ...input, allowedRepositories: ['FORK/*', 'o/r'] });+ expect(find).toHaveBeenCalledTimes(2);+ });+});diff --git a/packages/api/src/pulls/lookup.ts b/packages/api/src/pulls/lookup.tsindex c53fecd324..ed71c84ed5 100644--- a/packages/api/src/pulls/lookup.ts+++ b/packages/api/src/pulls/lookup.ts@@ -41,6 +41,9 @@ export function createPullRequestLookup({/** One bounded partition per credential, so a capacity setting only ever evicts entries* fetched with its own credential. */const partitions = new Map<string, Map<string, Entry>>();+ /** The largest capacity any caller asked for per credential. Principals can share a token yet+ * carry different configured sizes, and the smaller must not trim what the larger keeps. */+ const capacities = new Map<string, number>();const inflight = new Map<string, Promise<PullRequestLookupResult>>();const cooldowns = new Map<string, number>();const rateLimited: PullRequestLookupResult = { ok: false, error: { code: 'RATE_LIMITED' } };@@ -69,6 +72,7 @@ export function createPullRequestLookup({const idle = partitions.keys().next();if (idle.done) break;partitions.delete(idle.value);+ capacities.delete(idle.value);}return partition;}@@ -83,9 +87,11 @@ export function createPullRequestLookup({): void {const lifetime = result.ok ? ttlMs : Math.min(ttlMs, FAILURE_TTL_MS);const entries = partitionOf(scope, credentials);+ const bound = Math.max(capacities.get(scope) ?? 0, capacity);+ capacities.set(scope, bound);entries.delete(key);entries.set(key, { result, expiresAt: now() + lifetime });- while (entries.size > capacity) {+ while (entries.size > bound) {const oldest = entries.keys().next();if (oldest.done) break;entries.delete(oldest.value);@@ -107,6 +113,7 @@ export function createPullRequestLookup({token,ttlMs,limits,+ allowedRepositories,cacheMaxEntries,cacheMaxCredentials,}) => {@@ -119,6 +126,12 @@ export function createPullRequestLookup({limits?.maxCheckRunPages,limits?.maxCandidatePullRequests,limits?.maxHeadComparisons,+ limits?.maxCandidatePages,+ /** Which fork a pull request's checks may be read from depends on this list. */+ [...(allowedRepositories ?? [])]+ .map((entry) => entry.toLowerCase())+ .sort()+ .join('|'),].join(',');const key = `${scope}\0${repo}#${branch}\0${head ?? ''}\0${policy}`;const cached = touch(scope)?.get(key);@@ -134,7 +147,10 @@ export function createPullRequestLookup({const run = (async (): Promise<PullRequestLookupResult> => {let result: PullRequestLookupResult;try {- result = { ok: true, value: await source.find({ repo, branch, head, token, limits }) };+ result = {+ ok: true,+ value: await source.find({ repo, branch, head, token, limits, allowedRepositories }),+ };} catch (error) {if (!(error instanceof PullRequestSourceError)) {logger.warn('[PullRequests] Lookup failed', getSafeErrorMetadata(error));diff --git a/packages/api/src/pulls/repository.ts b/packages/api/src/pulls/repository.tsnew file mode 100644index 0000000000..3677cd0ba9--- /dev/null+++ b/packages/api/src/pulls/repository.ts@@ -0,0 +1,8 @@+/** `owner/name` or `owner/*`, compared without case as GitHub does. Nothing else matches. */+export function isAllowedRepository(repo: string, allowed: readonly string[] | undefined): boolean {+ const [owner, name] = repo.toLowerCase().split('/');+ return (allowed ?? []).some((entry) => {+ const [allowedOwner, allowedName] = entry.toLowerCase().split('/');+ return allowedOwner === owner && (allowedName === '*' || allowedName === name);+ });+}diff --git a/packages/api/src/pulls/transport.spec.ts b/packages/api/src/pulls/transport.spec.tsnew file mode 100644index 0000000000..cc04c975fa--- /dev/null+++ b/packages/api/src/pulls/transport.spec.ts@@ -0,0 +1,49 @@+import type { Dispatcher } from 'undici';+import { createProxyAwareFetch } from './transport';++const dispatcher = { name: 'proxy' } as unknown as Dispatcher;+type Fetch = typeof globalThis.fetch;+const recordingFetch = () => {+ const calls: Array<[unknown, RequestInit | undefined]> = [];+ const fetchFn = Object.assign(+ async (input: unknown, init?: RequestInit) => {+ calls.push([input, init]);+ return new Response('{}');+ },+ { preconnect: () => undefined },+ ) as unknown as Fetch;+ return { fetchFn, calls };+};++describe('createProxyAwareFetch', () => {+ it('sends the request through the proxy dispatcher when one is configured', async () => {+ const { fetchFn, calls } = recordingFetch();+ const signal = new AbortController().signal;+ await createProxyAwareFetch(fetchFn, () => dispatcher)('https://api.github.com/x', {+ headers: { a: 'b' },+ signal,+ });+ expect(calls).toEqual([+ ['https://api.github.com/x', { headers: { a: 'b' }, signal, dispatcher }],+ ]);+ });++ it('goes direct, with the request untouched, when no proxy is configured', async () => {+ const { fetchFn, calls } = recordingFetch();+ const init = { headers: { a: 'b' } };+ await createProxyAwareFetch(fetchFn, () => undefined)('https://api.github.com/x', init);+ expect(calls).toEqual([['https://api.github.com/x', init]]);+ expect((calls[0][1] as { dispatcher?: unknown }).dispatcher).toBeUndefined();+ });++ it('resolves the dispatcher for each request', async () => {+ const { fetchFn, calls } = recordingFetch();+ const getDispatcher = jest.fn<Dispatcher | undefined, []>().mockReturnValue(undefined);+ const wrapped = createProxyAwareFetch(fetchFn, getDispatcher);+ await wrapped('https://api.github.com/a');+ getDispatcher.mockReturnValue(dispatcher);+ await wrapped('https://api.github.com/b');+ expect(calls[1][1]).toMatchObject({ dispatcher });+ expect((calls[0][1] as { dispatcher?: unknown } | undefined)?.dispatcher).toBeUndefined();+ });+});diff --git a/packages/api/src/pulls/transport.ts b/packages/api/src/pulls/transport.tsnew file mode 100644index 0000000000..9d849492df--- /dev/null+++ b/packages/api/src/pulls/transport.ts@@ -0,0 +1,21 @@+import type { Dispatcher } from 'undici';+import type { PullRequestFetch } from './github';+import { getEnvProxyDispatcher } from '~/utils/proxy';++/**+ * Wraps a fetch so every request goes through the deployment's proxy when one is configured+ * (`HTTPS_PROXY` and friends, honoring `NO_PROXY`), and goes direct when none is. The dispatcher is+ * resolved per request, so an environment that changes at runtime is respected, and the client and+ * the dispatcher are both arguments, so a caller or a test supplies its own.+ */+export function createProxyAwareFetch(+ fetchFn: typeof globalThis.fetch = globalThis.fetch,+ getDispatcher: () => Dispatcher | undefined = getEnvProxyDispatcher,+): PullRequestFetch {+ return (input, init) => {+ const dispatcher = getDispatcher();+ if (dispatcher == null) return fetchFn(input, init);+ const request: RequestInit & { dispatcher?: Dispatcher } = { ...init, dispatcher };+ return fetchFn(input, request);+ };+}diff --git a/packages/api/src/pulls/types.ts b/packages/api/src/pulls/types.tsindex e177e67bc6..c06c1ca160 100644--- a/packages/api/src/pulls/types.ts+++ b/packages/api/src/pulls/types.ts@@ -32,6 +32,9 @@ export type PullRequestLookupLimits = {maxCandidatePullRequests?: number;/** Most candidates compared with the recorded commit before the search gives up. */maxHeadComparisons?: number;+ /** Pages of candidates read per state, so a branch name reused more than one page of times+ * can still reach an older pull request. One page is what the feature shipped with. */+ maxCandidatePages?: number;};export type PullRequestFindInput = {@@ -42,6 +45,9 @@ export type PullRequestFindInput = {head?: string | null;token: string;limits?: PullRequestLookupLimits;+ /** The repositories the token may be used for. A pull request from a fork has its checks read+ * from the fork only when the fork is named here, so the token never reaches an unlisted one. */+ allowedRepositories?: readonly string[];};/** Finds the pull request for a branch. Null is a documented absence, not a failure. */diff --git a/packages/data-provider/src/api-endpoints.ts b/packages/data-provider/src/api-endpoints.tsindex 69092d97ee..985fcf075e 100644--- a/packages/data-provider/src/api-endpoints.ts+++ b/packages/data-provider/src/api-endpoints.ts@@ -171,6 +171,8 @@ export const backgroundTasksCancel = (conversationId: string) =>export const conversationPullRequest = (conversationId: string) =>`${conversationsRoot}/${encodeURIComponent(conversationId)}/pull-request`;+export const conversationPullRequests = () => `${conversationsRoot}/pull-requests`;+export const genTitle = (conversationId: string) =>`${conversationsRoot}/gen_title/${encodeURIComponent(conversationId)}`;diff --git a/packages/data-provider/src/config.spec.ts b/packages/data-provider/src/config.spec.tsindex 99fb5de8b0..b84bdf48c0 100644--- a/packages/data-provider/src/config.spec.ts+++ b/packages/data-provider/src/config.spec.ts@@ -1132,9 +1132,12 @@ describe('agent pull request config', () => {lookupTimeoutSeconds: 30,maxCheckRunPages: 10,maxCandidatePullRequests: 10,+ maxCandidatePages: 1,maxHeadComparisons: 3,cacheMaxEntries: 500,cacheMaxCredentials: 256,+ maxConcurrentLookups: 4,+ batchTimeoutSeconds: 20,});});@@ -1185,6 +1188,8 @@ describe('agent pull request config', () => {['maxCheckRunPages', 1.5],['maxCandidatePullRequests', 0],['maxCandidatePullRequests', 101],+ ['maxCandidatePages', 0],+ ['maxCandidatePages', 11],['maxHeadComparisons', -1],['maxHeadComparisons', 21],['maxHeadComparisons', 1.5],@@ -1194,6 +1199,12 @@ describe('agent pull request config', () => {['cacheMaxCredentials', 0],['cacheMaxCredentials', 10_001],['cacheMaxCredentials', 1.5],+ ['maxConcurrentLookups', 0],+ ['maxConcurrentLookups', 17],+ ['maxConcurrentLookups', 1.5],+ ['batchTimeoutSeconds', 0],+ ['batchTimeoutSeconds', 121],+ ['batchTimeoutSeconds', 1.5],])('rejects %s of %s', (field, value) => {expect(parse({ [field]: value }).success).toBe(false);});@@ -1205,8 +1216,11 @@ describe('agent pull request config', () => {lookupTimeoutSeconds: 120,maxCheckRunPages: 50,maxCandidatePullRequests: 100,+ maxCandidatePages: 10,maxHeadComparisons: 20,cacheMaxEntries: 100_000,+ maxConcurrentLookups: 16,+ batchTimeoutSeconds: 120,}).success,).toBe(true);expect(parse({ maxHeadComparisons: 0 }).success).toBe(true);diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.tsindex 915bfbe775..950be640dd 100644--- a/packages/data-provider/src/config.ts+++ b/packages/data-provider/src/config.ts@@ -62,6 +62,10 @@ import { ComponentTypes, SettingTypes, OptionTypes } from './generate';import { STATEFUL_CODE_ENVIRONMENTS } from './stateful-code';import { specsConfigSchema, TSpecsConfig } from './models';import { fileConfigSchema } from './file-config';+import {+ PULL_REQUEST_BATCH_VERSION,+ PULL_REQUEST_BATCH_TIMEOUT_MAX_SECONDS,+} from './types/pullRequest';import { isActionTool } from './types/tools';import { apiBaseUrl } from './api-endpoints';import { FileSources } from './types/files';@@ -1876,6 +1880,17 @@ export const agentsEndpointSchema = baseEndpointSchema* Deployment-wide: when principals configure different values, the largest applies.* Raise it when many tenants each configure their own token. */cacheMaxCredentials: z.number().int().min(1).max(10_000).optional().default(256),+ /** Pull request lookups a single sidebar request runs at once. Each lookup is a few+ * GitHub requests, so this bounds how hard one request leans on the token. */+ maxConcurrentLookups: z.number().int().min(1).max(16).optional().default(4),+ /** Seconds one sidebar request may stay open in total, whatever its lookups are doing. */+ batchTimeoutSeconds: z+ .number()+ .int()+ .min(1)+ .max(PULL_REQUEST_BATCH_TIMEOUT_MAX_SECONDS)+ .optional()+ .default(20),/** Longest one GitHub request may take. Raise it behind a slow proxy. */requestTimeoutSeconds: z.number().int().min(1).max(60).optional().default(10),/** Longest a whole lookup, every request together, may hold the header request. */@@ -1885,6 +1900,9 @@ export const agentsEndpointSchema = baseEndpointSchema/** Pull requests listed per state when matching a branch's history to the commit a chat* last ran at. Raise it for branch names that are reused many times. */maxCandidatePullRequests: z.number().int().min(1).max(100).optional().default(10),+ /** Pages of those candidates read per state, so a branch name reused more often than one+ * page holds can still reach an older match. Each page is one request. */+ maxCandidatePages: z.number().int().min(1).max(10).optional().default(1),/** Candidates compared with that commit before the search gives up. Each is one request. */maxHeadComparisons: z.number().int().min(0).max(20).optional().default(3),})@@ -3140,6 +3158,11 @@ export type TStartupConfig = {insightsEnabled?: boolean;/** `endpoints.agents.pullRequests.enabled`; the header does not ask for a pull request without it. */pullRequestsEnabled?: boolean;+ /** Present with `pullRequestsEnabled` once this server has the batch route the sidebar uses. */+ pullRequestsBatchVersion?: typeof PULL_REQUEST_BATCH_VERSION;+ /** `endpoints.agents.pullRequests.maxConcurrentLookups`, so the single-route fallback of an+ * upgrade in progress keeps to the limit the operator configured. */+ pullRequestsMaxConcurrentLookups?: number;/** Manual context compaction, gated by the same `summarization.enabled`* switch that governs the automatic detour. */compactionEnabled?: boolean;diff --git a/packages/data-provider/src/data-service.ts b/packages/data-provider/src/data-service.tsindex 0898bed4ab..72687aef8d 100644--- a/packages/data-provider/src/data-service.ts+++ b/packages/data-provider/src/data-service.ts@@ -1229,8 +1229,16 @@ export function cancelBackgroundTasks(export function getConversationPullRequest(conversationId: string,+ options?: { signal?: AbortSignal },): Promise<t.TConversationPullRequestResponse> {- return request.get(endpoints.conversationPullRequest(conversationId));+ return request.get(endpoints.conversationPullRequest(conversationId), options);+}++export function getConversationPullRequests(+ conversationIds: string[],+ options?: { signal?: AbortSignal },+): Promise<t.TConversationPullRequestsResponse> {+ return request.post(endpoints.conversationPullRequests(), { conversationIds }, options);}export function getPrompt(id: string): Promise<{ prompt: t.TPrompt }> {diff --git a/packages/data-provider/src/request.ts b/packages/data-provider/src/request.tsindex acc8473502..21af6ed95e 100644--- a/packages/data-provider/src/request.ts+++ b/packages/data-provider/src/request.ts@@ -19,8 +19,9 @@ async function _getResponse<T = unknown>(return await axios.get<T>(url, { ...options });}-async function _post(url: string, data?: any) {+async function _post(url: string, data?: any, options?: AxiosRequestConfig) {const response = await axios.post(url, JSON.stringify(data), {+ ...options,headers: { 'Content-Type': 'application/json' },});return response.data;diff --git a/packages/data-provider/src/types/pullRequest.ts b/packages/data-provider/src/types/pullRequest.tsindex 0796962e56..02ef2cd42b 100644--- a/packages/data-provider/src/types/pullRequest.ts+++ b/packages/data-provider/src/types/pullRequest.ts@@ -22,6 +22,29 @@ export type TConversationPullRequest = {checks: PullRequestChecks;};+/** Most conversations one batch lookup may name. It bounds the fan-out to GitHub of a single+ * request; the lookups themselves stay governed by the configured limits and cache. */+export const PULL_REQUEST_BATCH_MAX = 50;++/** Version of the batch lookup route. The server advertises it with `pullRequestsEnabled`, and a+ * client that lists conversations asks for batches only when it matches, so during a rolling+ * upgrade it never sends a batch to a replica that does not have the route yet. */+export const PULL_REQUEST_BATCH_VERSION = 1 as const;++/** The most a deployment may set `batchTimeoutSeconds` to. The server answers by its own deadline,+ * so a client that waits just past this never gives up before the server does. */+export const PULL_REQUEST_BATCH_TIMEOUT_MAX_SECONDS = 120;++export type TConversationPullRequestsRequest = { conversationIds: string[] };++/** One conversation's answer: its pull request (null when it has none), or a stable failure code. */+export type TConversationPullRequestsEntry =+ | { conversationId: string; pullRequest: TConversationPullRequest | null }+ | { conversationId: string; error: { code: string } };++/** An array rather than an object keyed by id, so no client-supplied id is ever a property name. */+export type TConversationPullRequestsResponse = { results: TConversationPullRequestsEntry[] };+/** `pullRequest` is null when the conversation has no pull request, which is not an error. */export type TConversationPullRequestResponse = {pullRequest: TConversationPullRequest | null;diff --git a/packages/data-schemas/src/methods/conversation.spec.ts b/packages/data-schemas/src/methods/conversation.spec.tsindex 6215f558d7..ee5a4edeae 100644--- a/packages/data-schemas/src/methods/conversation.spec.ts+++ b/packages/data-schemas/src/methods/conversation.spec.ts@@ -10041,6 +10041,23 @@ describe('laneGit review hardening', () => {await expect(write(conversationId, 2, mac)).resolves.toBe(true);});+ it('returns the epoch with the admitted decision, from the same document read', async () => {+ const conversationId = await seedAttached([mac]);+ await expect(+ methods.readAdmittedConvoCodeEnvironmentDecision('lane-user', conversationId),+ ).resolves.toMatchObject({ codeWorkspaces: [mac], codeAttachmentEpoch: 0 });+ await move(conversationId, [team]);+ await expect(+ methods.readAdmittedConvoCodeEnvironmentDecision('lane-user', conversationId),+ ).resolves.toMatchObject({ codeWorkspaces: [team], codeAttachmentEpoch: 1 });+ await move(conversationId, [mac]);+ const admitted = await methods.readAdmittedConvoCodeEnvironmentDecision(+ 'lane-user',+ conversationId,+ );+ expect(admitted).toMatchObject({ codeWorkspaces: [mac], codeAttachmentEpoch: 2 });+ });+it('is not advanced by admitting a generation', async () => {const conversationId = await seedAttached([mac]);await methods.readAdmittedConvoCodeEnvironmentDecision('lane-user', conversationId);@@ -10088,6 +10105,101 @@ describe('laneGit review hardening', () => {});});+ it("does not read another user's conversation as the root", async () => {+ const rootId = uuidv4();+ await Conversation.collection.insertOne({+ conversationId: rootId,+ user: 'someone-else',+ title: 'Not yours',+ endpoint: 'agents',+ messages: [],+ codeAttachmentEpoch: 9,+ });+ const threadId = await seedThread(rootId);+ await expect(methods.getConvoLaneContext('lane-user', threadId)).resolves.toMatchObject({+ codeAttachmentEpoch: 0,+ });+ });++ it('does not read an expired root, which the write path treats as gone', async () => {+ const rootId = await seedAttached([mac]);+ await move(rootId, [team]);+ await Conversation.collection.updateOne(+ { conversationId: rootId },+ { $set: { expiredAt: new Date(Date.now() - 60_000) } },+ );+ const threadId = await seedThread(rootId);+ await expect(methods.getConvoLaneContext('lane-user', threadId)).resolves.toMatchObject({+ codeAttachmentEpoch: 0,+ });+ });++ it("does not read another tenant's conversation as the root", async () => {+ const rootId = uuidv4();+ await Conversation.collection.insertOne({+ conversationId: rootId,+ user: 'lane-user',+ title: 'Other tenant',+ endpoint: 'agents',+ messages: [],+ codeAttachmentEpoch: 7,+ tenantId: 'tenant-b',+ });+ const threadId = uuidv4();+ await Conversation.collection.insertOne({+ conversationId: threadId,+ user: 'lane-user',+ title: 'Thread',+ endpoint: 'agents',+ messages: [],+ tenantId: 'tenant-a',+ subagentThread: { rootConversationId: rootId, parentConversationId: rootId },+ });+ const context = await tenantStorage.run({ tenantId: 'tenant-a' }, () =>+ methods.getConvoLaneContext('lane-user', threadId),+ );+ expect(context).toMatchObject({ codeAttachmentEpoch: 0 });+ });++ it('reads a root in the same tenant', async () => {+ const rootId = uuidv4();+ await Conversation.collection.insertOne({+ conversationId: rootId,+ user: 'lane-user',+ title: 'Same tenant',+ endpoint: 'agents',+ messages: [],+ codeAttachmentEpoch: 4,+ tenantId: 'tenant-a',+ });+ const threadId = uuidv4();+ await Conversation.collection.insertOne({+ conversationId: threadId,+ user: 'lane-user',+ title: 'Thread',+ endpoint: 'agents',+ messages: [],+ tenantId: 'tenant-a',+ subagentThread: { rootConversationId: rootId, parentConversationId: rootId },+ });+ const context = await tenantStorage.run({ tenantId: 'tenant-a' }, () =>+ methods.getConvoLaneContext('lane-user', threadId),+ );+ expect(context).toMatchObject({ codeAttachmentEpoch: 4 });+ });++ it('reads the thread and its root in one database operation', async () => {+ const rootId = await seedAttached([mac]);+ const threadId = await seedThread(rootId);+ const spy = jest.spyOn(Conversation, 'findOne');+ const aggregate = jest.spyOn(Conversation, 'aggregate');+ await methods.getConvoLaneContext('lane-user', threadId);+ expect(spy).not.toHaveBeenCalled();+ expect(aggregate).toHaveBeenCalledTimes(1);+ spy.mockRestore();+ aggregate.mockRestore();+ });+it('reads zero when the root is gone, so the write is refused rather than guessed', async () => {const threadId = await seedThread(uuidv4());await expect(methods.getConvoLaneContext('lane-user', threadId)).resolves.toMatchObject({@@ -10109,3 +10221,65 @@ describe('laneGit review hardening', () => {});});});++describe('getConvosLaneGit', () => {+ const head = 'a'.repeat(40);+ const seedLane = async (+ user: string,+ laneGit?: Record<string, unknown>,+ extra: Record<string, unknown> = {},+ ) => {+ const conversationId = uuidv4();+ await Conversation.collection.insertOne({+ conversationId,+ user,+ title: 'Lane',+ endpoint: 'agents',+ messages: [],+ ...(laneGit ? { laneGit: { seq: 3, ...laneGit } } : {}),+ ...extra,+ });+ return conversationId;+ };++ it("returns the lanes of the owner's conversations in one query, without the sequence number", async () => {+ const a = await seedLane('bulk-user', { branch: 'feat/a', head, repo: 'o/r' });+ const b = await seedLane('bulk-user', { branch: 'feat/b', head: null });+ const found = await methods.getConvosLaneGit('bulk-user', [a, b]);+ expect(found).toHaveLength(2);+ expect(found).toEqual(+ expect.arrayContaining([+ { conversationId: a, laneGit: { branch: 'feat/a', head, repo: 'o/r' } },+ { conversationId: b, laneGit: { branch: 'feat/b', head: null } },+ ]),+ );+ expect(JSON.stringify(found)).not.toContain('seq');+ });++ it("leaves out a conversation with no lane, an unknown id and another owner's conversation alike", async () => {+ const mine = await seedLane('bulk-user', { branch: 'feat/a', head });+ const noLane = await seedLane('bulk-user');+ const theirs = await seedLane('someone-else', { branch: 'secret', head });+ const found = await methods.getConvosLaneGit('bulk-user', [mine, noLane, theirs, uuidv4()]);+ expect(found.map((row) => row.conversationId)).toEqual([mine]);+ });++ it('leaves out an expired temporary chat', async () => {+ const expired = await seedLane(+ 'bulk-user',+ { branch: 'feat/x', head },+ { expiredAt: new Date(Date.now() - 60_000) },+ );+ const live = await seedLane(+ 'bulk-user',+ { branch: 'feat/y', head },+ { expiredAt: new Date(Date.now() + 3_600_000) },+ );+ const found = await methods.getConvosLaneGit('bulk-user', [expired, live]);+ expect(found.map((row) => row.conversationId)).toEqual([live]);+ });++ it('asks nothing for an empty list', async () => {+ await expect(methods.getConvosLaneGit('bulk-user', [])).resolves.toEqual([]);+ });+});diff --git a/packages/data-schemas/src/methods/conversation.ts b/packages/data-schemas/src/methods/conversation.tsindex 1391d71b4e..0bfbcf7928 100644--- a/packages/data-schemas/src/methods/conversation.ts+++ b/packages/data-schemas/src/methods/conversation.ts@@ -79,6 +79,9 @@ function stripActorCheckpointFields(record: Record<string, unknown>): void {/** Written only by the lane methods, so no save, unset or import may reach them. */const LANE_PRIVATE_FIELDS = ['laneGit', 'laneGitSeq', 'codeAttachmentEpoch'] as const;+/** The lane state a reader may see; the sequence number that fences writes stays private. */+export type ConvoLaneGitView = Omit<NonNullable<IConversation['laneGit']>, 'seq'>;+/** What a lane recorder needs to place and fence its writes, read once when its tool is created. */export type ConvoLaneContext = {subagentThread?: IConversation['subagentThread'] | null;@@ -367,6 +370,10 @@ export interface ConversationMethods {user: string,conversationId: string,): Promise<Omit<NonNullable<IConversation['laneGit']>, 'seq'> | null>;+ getConvosLaneGit(+ user: string,+ conversationIds: string[],+ ): Promise<Array<{ conversationId: string; laneGit: ConvoLaneGitView }>>;addConvoToolApprovalAllows(input: {user: string;conversationId: string;@@ -378,7 +385,7 @@ export interface ConversationMethods {conversationId: string,): Promise<Pick<IConversation,- 'conversationId' | 'codeEnvironmentMode' | 'codeWorkspaces'+ 'conversationId' | 'codeEnvironmentMode' | 'codeWorkspaces' | 'codeAttachmentEpoch'> | null>;replaceConvoCodeEnvironmentDecision(params: {@@ -3078,22 +3085,59 @@ export function createConversationMethods(conversationId: string,): Promise<ConvoLaneContext | null> {const Conversation = mongoose.models.Conversation as Model<IConversation>;- const stored = await Conversation.findOne(- { user, conversationId, ...activeExpirationFilter<IConversation>() },- 'subagentThread +codeAttachmentEpoch',- ).lean<Pick<IConversation, 'subagentThread' | 'codeAttachmentEpoch'>>();- if (stored == null) return null;- const rootId = stored.subagentThread?.rootConversationId;+ const now = new Date();+ /**+ * The thread and its visible root in one operation, so the epoch cannot move between two+ * reads. The tenant plugin scopes only the base collection of an aggregate, never the joined+ * one, so the join is narrowed here to the same owner, tenant and visibility as the base row:+ * a root outside them reads as absent, exactly as it did when it was read on its own.+ */+ const [row] = await Conversation.aggregate<{+ subagentThread?: IConversation['subagentThread'] | null;+ codeAttachmentEpoch?: number;+ _root?: Array<{ codeAttachmentEpoch?: number }>;+ }>([+ { $match: { user, conversationId, ...activeExpirationFilter<IConversation>() } },+ {+ $lookup: {+ from: 'conversations',+ localField: 'subagentThread.rootConversationId',+ foreignField: 'conversationId',+ as: '_root',+ },+ },+ {+ $project: {+ subagentThread: 1,+ codeAttachmentEpoch: 1,+ _root: {+ $filter: {+ input: '$_root',+ as: 'r',+ cond: {+ $and: [+ { $eq: ['$$r.user', user] },+ { $eq: [{ $ifNull: ['$$r.tenantId', null] }, { $ifNull: ['$tenantId', null] }] },+ {+ $or: [+ { $eq: [{ $ifNull: ['$$r.expiredAt', null] }, null] },+ { $gt: ['$$r.expiredAt', now] },+ ],+ },+ ],+ },+ },+ },+ },+ },+ { $limit: 1 },+ ]);+ if (row == null) return null;+ const rootId = row.subagentThread?.rootConversationId;/** A thread's report is written to its visible root, so it is fenced by the root's epoch. */- const fenced =- rootId && rootId !== conversationId- ? await Conversation.findOne(- { user, conversationId: rootId, ...activeExpirationFilter<IConversation>() },- '+codeAttachmentEpoch',- ).lean<Pick<IConversation, 'codeAttachmentEpoch'>>()- : stored;+ const fenced = rootId && rootId !== conversationId ? row._root?.[0] : row;return {- subagentThread: stored.subagentThread ?? null,+ subagentThread: row.subagentThread ?? null,codeAttachmentEpoch: fenced?.codeAttachmentEpoch ?? 0,};}@@ -3214,17 +3258,51 @@ export function createConversationMethods(return { branch, head, ...(repo ? { repo } : {}) };}+ /**+ * The last reported lane state of each of the owner's conversations that has one, in one query.+ * A conversation that is missing, expired, another owner's or has no lane is simply absent, so a+ * caller cannot tell them apart.+ */+ async function getConvosLaneGit(+ user: string,+ conversationIds: string[],+ ): Promise<Array<{ conversationId: string; laneGit: ConvoLaneGitView }>> {+ if (conversationIds.length === 0) return [];+ const Conversation = mongoose.models.Conversation as Model<IConversation>;+ const stored = await Conversation.find({+ user,+ conversationId: { $in: conversationIds },+ laneGit: { $exists: true, $ne: null },+ ...activeExpirationFilter<IConversation>(),+ })+ .select('conversationId laneGit')+ .lean<Array<Pick<IConversation, 'conversationId' | 'laneGit'>>>();+ return stored.flatMap(({ conversationId, laneGit }) => {+ if (laneGit == null || conversationId == null) return [];+ const { branch, head, repo } = laneGit;+ return [{ conversationId, laneGit: { branch, head, ...(repo ? { repo } : {}) } }];+ });+ }++ /**+ * The decision a run is admitted on, with the attachment epoch of that same document. The epoch+ * is `0` for a conversation never moved, so a lane report can be fenced by exactly the snapshot+ * the workspace came from instead of a second read that a move could slip between.+ */async function readAdmittedConvoCodeEnvironmentDecision(user: string, conversationId: string) {const Conversation = mongoose.models.Conversation as Model<IConversation>;- return withoutMeiliIndexing(+ const admitted = await withoutMeiliIndexing(Conversation.findOneAndUpdate({ user, conversationId },{ $inc: { codeEnvironmentRevision: 1 } },{ new: true, timestamps: false },),)- .select('conversationId codeEnvironmentMode codeWorkspaces')+ .select('conversationId codeEnvironmentMode codeWorkspaces +codeAttachmentEpoch').lean<IConversation>();+ return admitted == null+ ? admitted+ : { ...admitted, codeAttachmentEpoch: admitted.codeAttachmentEpoch ?? 0 };}/**@@ -4452,6 +4530,7 @@ export function createConversationMethods(reserveConvoLaneGitSeq,setConvoLaneGit,getConvoLaneGit,+ getConvosLaneGit,getConvoLaneContext,readAdmittedConvoCodeEnvironmentDecision,replaceConvoCodeEnvironmentDecision,