mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-19 06:23:32 +00:00
* 🗓️ fix: Surface a Run Now Scheduled Chat in the Sidebar Run Now left the conversation list untouched, so the chat it started was invisible until a reload. Refetching the list on success would not have fixed it either: run-now answers once the trigger delivery is durable, and the generation that writes the conversation starts after that, so the refetch comes back without the chat. Seed the row instead, from the id the response already names and the cached schedule's name and agent, resolving the destination project the same way the fire path does so it lands in that project's list and no other. Report the started generation to the active-job list and re-arm it, since it stops polling while nothing is listed and is the only thing that can show the row as running. * 🩹 fix: Wait for the Run to be Admitted Instead of Seeding a Row Codex found four ways the optimistic row goes wrong, three of them inherent to seeding a chat the server has not created: it is assembled from a client snapshot of the schedule that another tab may have moved on from, it outlives a delivery that never admits, and it can be opened before the conversation exists, which bounces that tab to a new chat it never recovers from. The conversation route answers 404 until the generation's first write commits and applies the same visibility rule the list query does, so it is an exact admission probe: a 200 means the chat is listable now and carries the server's own row. Wait on that instead, over a bounded set of probes, and add what came back. Nothing is written for a run that never admits. Re-arming the active-job poll moves to admission too, where a generation is known to exist, rather than at the click, where the thirty-second grace can lapse before a retried dispatch ever starts one. * 🩹 fix: Cover the Delivery Retry Window and Keep Transient Probes Alive Two follow-ups from codex on the admission watch. The probe budget stopped at forty-three seconds, inside the window the server is still willing to admit in: the trigger engine allows eight attempts backing off from a second and doubling, about two minutes of retries at worst. Widen to roughly five minutes across eleven probes, which covers that twice over. A dispatch refused with a long Retry-After can still be re-driven hours later; a watch held open for that is worse than the list refetch that already covers it. Ending the watch on any non-404 also gave up on failures that say nothing about the run: a 5xx, or a request that never got a response, is the probe failing while the durable delivery is still free to admit. Only a 4xx that is not 404 settles the matter. * 🩹 fix: Fence the Admission Watch to its Session and Queue its Title Two more from codex, both real. The watch can run for minutes, and signing out or signing in as someone else empties the query cache in between. A response arriving after that wrote one user's chat into another's sidebar. Fence it: capture who the cache belonged to when the watch started, and check again before probing and before writing. A conversation admitted mid-run has not been titled yet, so the row lands as "New Chat". The foreground paths hand that to the title queue, which already owns the timing the server was configured for; a scheduled run has no foreground path, so hand it over here instead of leaving the placeholder until an unrelated refetch. Not taken: widening the probe budget again to cover the trigger host's per-attempt timeout. That is the third arithmetic for the same knob, and no fixed budget closes the class — a Retry-After refusal can defer admission by up to a day. The ceiling is deliberate and the miss degrades to the next list refetch. * 🩹 fix: Honour Retryable Statuses and Keep Archived Chats Out of the Sidebar Two narrow ones from codex, plus a test-coupling bug they exposed. 408 and 429 ask to be retried by definition, and a proxy in front of the app can raise either without the run being involved, so a blanket "any 4xx but 404 is terminal" abandoned a watch over something that was going to resolve. The conversation route serves an archived chat while the list query filters one out, so a run archived from another tab between its first write and the next probe would land a row in the sidebar that no refetch agrees belongs there. The archive was deliberate; leave it alone. The archived-row assertion passed at first against the missing guard, because `clearAllMocks` leaves an undrained `mockRejectedValueOnce` queued for the next test, where it answered the first probe. Reset implementations between tests so one test's leftovers cannot vouch for another's. * 🩹 fix: Bind the Session Fence Late When the User Query is Still Loading The fence I added last round read an unloaded user cache as an identity. A run started before that query resolved captured `undefined`, and the account's own arrival then looked like the cache changing hands, so the watch abandoned a run it should have tracked — the fence failing closed on the feature it was protecting. Run-now answering 200 is itself proof a session existed at the click, so an empty entry then is a cache still loading rather than nobody signed in. Bind the owner on first sight instead, and fence only once one is known. Also restores import order in the spec, which is what Static checks caught: a later edit added an import without re-running the sorter. * 🩹 fix: Refuse the Write While the Cache Owner is Unknown Last round's fence compared only once an owner was known, which left the hole it was built to close: a run started before the user query resolved kept an undefined baseline, so a sign-in arriving while the probe was in flight was never noticed and one account's chat could seed another's cache. An unknown owner cannot be compared, so it cannot be seen to change either — "still loading" and "changed hands" are the same reading. Refuse the write instead. A late-resolving query still binds and still tracks, because that happens before the probe; only the genuinely ambiguous case is dropped, and every caller of this has a signed-in session. The tests now sign in, which is the only state this runs in, and the one that starts signed out keeps its premise so the boundary stays pinned from both sides. * 🩹 fix: Write the Session Fence Once and Mirror Foreground Project Bookkeeping Four rounds of fence patches each fixed one cell of a three-state problem and broke another. Write it as one state machine instead, on the property that makes it tractable: the server enforces ownership on the probe itself, so a request sent under one account can never return another's chat, and the only dangerous response is one sent under the account that clicked and landing after someone else signed in. So the owner is bound only from a reading taken before a probe goes out, a successful probe with no baseline yet is skipped rather than abandoned, and once bound any different reading ends the watch. Mirror the foreground path's project bookkeeping: a chat filed under a project moves that project's count and recent-activity ordering, which live on the project rows the conversation caches never touch. The watch moves to its own module so the schedules panel can hand it an automatic occurrence, and a run announced twice — by the click and by the poll that then lists it — is watched once. |
||
|---|---|---|
| .. | ||
| @types | ||
| __tests__ | ||
| a11y | ||
| common | ||
| components | ||
| constants | ||
| data-provider | ||
| hooks | ||
| lib/rum | ||
| locales | ||
| polyfills | ||
| Providers | ||
| routes | ||
| store | ||
| utils | ||
| App.jsx | ||
| main.jsx | ||
| mobile.css | ||
| style.css | ||
| vite-env.d.ts | ||