@@ -482,66 +482,79 @@ async def observe(ctx: ToolContext, key: str) -> str:
482482 }
483483 return "accepted"
484484
485- async def run_owned (label : str , disabled : bool , sensitive : bool ) -> str :
486- async with (
487- ScriptedResponses (
488- [tool_call ("observe" , {"key" : label }, call_id = label )], [text ("done" )]
489- ) as peer ,
490- AsyncExitStack () as stack ,
491- ):
485+ phases = dict .fromkeys (labels , "opening" )
486+ async with AsyncExitStack () as stack :
487+ sessions : dict [str , Any ] = {}
488+ for label in labels :
489+ peer = await stack .enter_async_context (
490+ ScriptedResponses (
491+ [tool_call ("observe" , {"key" : label }, call_id = label )], [text ("done" )]
492+ )
493+ )
492494 agent = Agent (
493495 instructions = "Observe synthetic policy" , tools = [observe ], provider = peer .provider
494496 )
497+ # Initialize resources separately from the concurrent admission policies.
498+ sessions [label ] = await stack .enter_async_context (
499+ agent .session (parent_trace = {"traceparent" : PARENT })
500+ )
501+ phases [label ] = "ready"
502+
503+ async def run_owned (label : str , disabled : bool , sensitive : bool ) -> str :
495504 with telemetry .trace (
496505 label ,
497506 options = telemetry .TraceOptions (
498507 disabled = disabled ,
499508 include_sensitive_data = sensitive ,
500509 ),
501510 ):
502- session = await stack .enter_async_context (
503- agent .session (parent_trace = {"traceparent" : PARENT })
504- )
505- turn = await session .submit (label )
511+ phases [label ] = "submitting"
512+ turn = await sessions [label ].submit (label )
506513 closed [label ].set ()
514+ phases [label ] = "admitted"
507515 assert (await turn .get_result ()).final_output == "done"
516+ phases [label ] = "completed"
508517 return turn .turn_id
509518
510- restrictive = asyncio .create_task (run_owned ("restrictive" , True , False ))
511- permissive = asyncio .create_task (run_owned ("permissive" , False , True ))
519+ restrictive = asyncio .create_task (run_owned ("restrictive" , True , False ))
520+ permissive = asyncio .create_task (run_owned ("permissive" , False , True ))
512521
513- async def callers_closed () -> None :
514- await asyncio .gather (* (event .wait () for event in closed .values ()))
522+ async def callers_closed () -> None :
523+ await asyncio .gather (* (event .wait () for event in closed .values ()))
515524
516- barrier = asyncio .create_task (callers_closed ())
517- owners = (restrictive , permissive )
518- try :
519- # Both policies must be retained after admission and caller-scope close.
520- # Callback scheduling need not let both tools enter before either returns.
521- ready , _ = await asyncio .wait (
522- (barrier , * owners ), timeout = 30 , return_when = asyncio .FIRST_COMPLETED
523- )
524- for owner in owners :
525- if owner in ready :
526- # Surface setup/tool failures instead of hiding them in timeout cleanup.
527- owner .result ()
528- raise AssertionError ("Policy owner finished before the callbacks were released" )
529- if barrier not in ready :
530- raise TimeoutError (
531- {
532- label : {"entered" : entered [label ].is_set (), "closed" : closed [label ].is_set ()}
533- for label in labels
534- }
525+ barrier = asyncio .create_task (callers_closed ())
526+ owners = (restrictive , permissive )
527+ try :
528+ # Both policies must be retained after admission and caller-scope close.
529+ # Callback scheduling need not let both tools enter before either returns.
530+ ready , _ = await asyncio .wait (
531+ (barrier , * owners ), timeout = 30 , return_when = asyncio .FIRST_COMPLETED
535532 )
536- await barrier
537- release .set ()
538- results = await asyncio .gather (* owners )
539- finally :
540- release .set ()
541- for waiter in (barrier , * owners ):
542- if not waiter .done ():
543- waiter .cancel ()
544- await asyncio .gather (barrier , * owners , return_exceptions = True )
533+ for owner in owners :
534+ if owner in ready :
535+ # Surface setup/tool failures instead of hiding them in timeout cleanup.
536+ owner .result ()
537+ raise AssertionError ("Policy owner finished before the callbacks were released" )
538+ if barrier not in ready :
539+ raise TimeoutError (
540+ {
541+ label : {
542+ "phase" : phases [label ],
543+ "entered" : entered [label ].is_set (),
544+ "closed" : closed [label ].is_set (),
545+ }
546+ for label in labels
547+ }
548+ )
549+ await barrier
550+ release .set ()
551+ results = await asyncio .gather (* owners )
552+ finally :
553+ release .set ()
554+ for waiter in (barrier , * owners ):
555+ if not waiter .done ():
556+ waiter .cancel ()
557+ await asyncio .gather (barrier , * owners , return_exceptions = True )
545558 async with ScriptedResponses (
546559 [tool_call ("observe" , {"key" : "fresh" }, call_id = "fresh" )], [text ("done" )]
547560 ) as peer :
0 commit comments