11import type { ProviderSession , ThreadId } from "@t3tools/contracts" ;
22import { describe , expect , it } from "@effect/vitest" ;
3+ import * as Deferred from "effect/Deferred" ;
34import * as Layer from "effect/Layer" ;
45import { ProviderService } from "../provider/Services/ProviderService.ts" ;
56import * as Effect from "effect/Effect" ;
7+ import * as Fiber from "effect/Fiber" ;
68
79import { MAX_CONCURRENT_PROVIDER_TURNS } from "./ConcurrentTurnPolicy.ts" ;
810import { make as makeService , layer , UsageLimitReservations } from "./UsageLimitReservations.ts" ;
@@ -17,7 +19,69 @@ function session(index: number): ProviderSession {
1719 } as ProviderSession ;
1820}
1921
22+ function assertReleasedReservationRemainsVisible ( kind : "turn" | "handover" ) {
23+ return Effect . scoped (
24+ Effect . gen ( function * ( ) {
25+ let runningSessions = Array . from ( { length : MAX_CONCURRENT_PROVIDER_TURNS - 1 } , ( _ , index ) =>
26+ session ( index ) ,
27+ ) ;
28+ let pauseSnapshot = false ;
29+ const snapshotStarted = yield * Deferred . make < void > ( ) ;
30+ const resumeSnapshot = yield * Deferred . make < void > ( ) ;
31+ const reservations = yield * make ( ( ) =>
32+ Effect . gen ( function * ( ) {
33+ const snapshot = [ ...runningSessions ] ;
34+ if ( pauseSnapshot ) {
35+ yield * Deferred . succeed ( snapshotStarted , undefined ) ;
36+ yield * Deferred . await ( resumeSnapshot ) ;
37+ }
38+ return snapshot ;
39+ } ) ,
40+ ) ;
41+ const reserve = kind === "turn" ? reservations . reserveTurn : reservations . reserveHandover ;
42+
43+ expect (
44+ yield * reserve ( {
45+ key : `${ kind } :eighth` ,
46+ threadId : "thread-eighth" as ThreadId ,
47+ } ) ,
48+ ) . toBeUndefined ( ) ;
49+
50+ pauseSnapshot = true ;
51+ const ninthReservation = yield * reserve ( {
52+ key : `${ kind } :ninth` ,
53+ threadId : "thread-ninth" as ThreadId ,
54+ } ) . pipe ( Effect . forkChild ) ;
55+ yield * Deferred . await ( snapshotStarted ) ;
56+ runningSessions = [
57+ ...runningSessions ,
58+ {
59+ ...session ( MAX_CONCURRENT_PROVIDER_TURNS - 1 ) ,
60+ threadId : "thread-eighth" as ThreadId ,
61+ } ,
62+ ] ;
63+ const releaseEighth = yield * reservations . release ( `${ kind } :eighth` ) . pipe ( Effect . forkChild ) ;
64+ yield * Effect . yieldNow ;
65+ expect ( releaseEighth . pollUnsafe ( ) ) . toBeUndefined ( ) ;
66+ yield * Deferred . succeed ( resumeSnapshot , undefined ) ;
67+
68+ expect ( yield * Fiber . join ( ninthReservation ) ) . toMatchObject ( {
69+ code : "concurrent-turn-limit" ,
70+ } ) ;
71+ yield * Fiber . join ( releaseEighth ) ;
72+ } ) ,
73+ ) ;
74+ }
75+
2076describe ( "UsageLimitReservations" , ( ) => {
77+ it . effect ( "keeps a released turn reservation visible to an in-flight snapshot" , ( ) =>
78+ assertReleasedReservationRemainsVisible ( "turn" ) ,
79+ ) ;
80+
81+ it . effect ( "keeps a released handover reservation visible to an in-flight snapshot" , ( ) =>
82+ assertReleasedReservationRemainsVisible ( "handover" ) ,
83+ ) ;
84+
2185 it . effect ( "shares admission capacity between runtime consumers" , ( ) =>
2286 Effect . gen ( function * ( ) {
2387 const turnConsumer = yield * UsageLimitReservations ;
@@ -86,7 +150,65 @@ describe("UsageLimitReservations", () => {
86150 } ) ,
87151 ) ;
88152
89- it . effect ( "releases a handover slot after completion" , ( ) =>
153+ it . effect ( "preserves same-thread followups when provider capacity is full" , ( ) =>
154+ Effect . gen ( function * ( ) {
155+ const reservations = yield * make ( ( ) =>
156+ Effect . succeed (
157+ Array . from ( { length : MAX_CONCURRENT_PROVIDER_TURNS } , ( _ , index ) => session ( index ) ) ,
158+ ) ,
159+ ) ;
160+
161+ expect (
162+ yield * reservations . reserveTurn ( {
163+ key : "turn:followup" ,
164+ threadId : "running-0" as ThreadId ,
165+ } ) ,
166+ ) . toBeUndefined ( ) ;
167+ yield * reservations . release ( "turn:followup" ) ;
168+ expect (
169+ yield * reservations . reserveTurn ( {
170+ key : "turn:new-thread" ,
171+ threadId : "thread-new" as ThreadId ,
172+ } ) ,
173+ ) . toMatchObject ( { code : "concurrent-turn-limit" } ) ;
174+ } ) ,
175+ ) ;
176+
177+ it . effect ( "releases admission synchronization when snapshot lookup is interrupted" , ( ) =>
178+ Effect . scoped (
179+ Effect . gen ( function * ( ) {
180+ let pauseSnapshot = true ;
181+ const snapshotStarted = yield * Deferred . make < void > ( ) ;
182+ const resumeSnapshot = yield * Deferred . make < void > ( ) ;
183+ const reservations = yield * make ( ( ) =>
184+ pauseSnapshot
185+ ? Deferred . succeed ( snapshotStarted , undefined ) . pipe (
186+ Effect . andThen ( Deferred . await ( resumeSnapshot ) ) ,
187+ Effect . as < ReadonlyArray < ProviderSession > > ( [ ] ) ,
188+ )
189+ : Effect . succeed ( [ ] ) ,
190+ ) ;
191+ const interruptedReservation = yield * reservations
192+ . reserveTurn ( {
193+ key : "turn:interrupted" ,
194+ threadId : "thread-interrupted" as ThreadId ,
195+ } )
196+ . pipe ( Effect . forkChild ) ;
197+ yield * Deferred . await ( snapshotStarted ) ;
198+ yield * Fiber . interrupt ( interruptedReservation ) ;
199+
200+ pauseSnapshot = false ;
201+ expect (
202+ yield * reservations . reserveTurn ( {
203+ key : "turn:after-interrupt" ,
204+ threadId : "thread-after-interrupt" as ThreadId ,
205+ } ) ,
206+ ) . toBeUndefined ( ) ;
207+ } ) ,
208+ ) ,
209+ ) ;
210+
211+ it . effect ( "releases a handover slot idempotently after completion" , ( ) =>
90212 Effect . gen ( function * ( ) {
91213 const reservations = yield * make ( ( ) =>
92214 Effect . succeed (
@@ -101,6 +223,7 @@ describe("UsageLimitReservations", () => {
101223 } ) ,
102224 ) . toBeUndefined ( ) ;
103225 yield * reservations . release ( "handover:first" ) ;
226+ yield * reservations . release ( "handover:first" ) ;
104227 expect (
105228 yield * reservations . reserveHandover ( {
106229 key : "handover:second" ,
0 commit comments