@@ -475,106 +475,95 @@ async def ainvoke_with_usage(self, prompt: str, collector: object) -> object:
475475
476476 # -- Internal -------------------------------------------------------------
477477
478+ @staticmethod
479+ def _remaining (deadline : float ) -> float :
480+ from skillspector .llm_analyzer_base import LLMRuntimeLimitError
481+
482+ remaining = deadline - time .monotonic ()
483+ if remaining <= 0 :
484+ raise LLMRuntimeLimitError ("pooled request runtime limit reached" )
485+ return remaining
486+
478487 def _invoke_with_retry (
479- self ,
480- prompt : str ,
481- * ,
482- callbacks : list [object ] | None = None ,
488+ self , prompt : str , * , callbacks : list [object ] | None = None ,
483489 ) -> object :
484- """Sync retry loop — acquire slot, call LLM, release, retry on 429."""
485- last_exception : Exception | None = None
486-
490+ """Share one deadline across slot waiting, requests, and key retries."""
491+ deadline = time .monotonic () + self ._timeout
487492 for attempt in range (self ._max_retries + 1 ):
488- key = self ._pool .acquire ()
489- llm = self ._build_llm (key )
490493 try :
491- if callbacks is None :
492- result = llm .invoke (prompt )
493- else :
494- result = llm .invoke (prompt , config = {"callbacks" : callbacks })
495- self ._pool .release (key , success = True )
496- if attempt > 0 :
497- self ._pool .record_retry_success ()
498- return result
494+ key = self ._pool .acquire (timeout = self ._remaining (deadline ))
495+ except Exception :
496+ self ._remaining (deadline )
497+ raise
498+ rate_limited = False
499+ try :
500+ llm = self ._build_llm (key , timeout = self ._remaining (deadline ))
501+ result = llm .invoke (prompt ) if callbacks is None else llm .invoke (
502+ prompt , config = {"callbacks" : callbacks }
503+ )
499504 except Exception as exc :
500- if self ._is_rate_limit (exc ) and attempt < self ._max_retries :
501- self ._pool .release (key , success = False )
502- logger .debug (
503- "PooledChatModel: rate-limited, retrying "
504- "(attempt %d/%d)" ,
505- attempt + 1 ,
506- self ._max_retries ,
507- )
505+ rate_limited = self ._is_rate_limit (exc )
506+ if rate_limited and attempt < self ._max_retries :
508507 continue
509- self ._pool .release (key , success = True )
510- last_exception = exc
511508 raise
512-
513- raise RuntimeError (
514- f"PooledChatModel: exhausted { self ._max_retries } retries "
515- "due to rate-limit errors"
516- ) from last_exception
509+ finally :
510+ self ._pool .release (key , success = not rate_limited )
511+ if attempt > 0 :
512+ self ._pool .record_retry_success ()
513+ return result
514+ raise RuntimeError ("PooledChatModel exhausted key retries" )
517515
518516 async def _ainvoke_with_retry (
519- self ,
520- prompt : str ,
521- * ,
522- callbacks : list [object ] | None = None ,
517+ self , prompt : str , * , callbacks : list [object ] | None = None ,
523518 ) -> object :
524- """Async retry loop — non-blocking acquire first, block only if full ."""
519+ """Bound asynchronous slot waiting without leaving an acquiring thread ."""
525520 import asyncio
526- last_exception : Exception | None = None
527521
522+ deadline = time .monotonic () + self ._timeout
528523 for attempt in range (self ._max_retries + 1 ):
524+ self ._remaining (deadline )
529525 key = self ._pool .try_acquire ()
530- if key is None :
531- key = await asyncio .to_thread (self ._pool .acquire )
532- llm = self ._build_llm (key )
526+ while key is None :
527+ await asyncio .sleep (min (0.05 , self ._remaining (deadline )))
528+ self ._remaining (deadline )
529+ key = self ._pool .try_acquire ()
530+ rate_limited = False
533531 try :
534- if callbacks is None :
535- result = await llm .ainvoke (prompt )
536- else :
537- result = await llm .ainvoke (prompt , config = {"callbacks" : callbacks })
538- self ._pool .release (key , success = True )
539- if attempt > 0 :
540- self ._pool .record_retry_success ()
541- return result
532+ llm = self ._build_llm (key , timeout = self ._remaining (deadline ))
533+ result = await llm .ainvoke (prompt ) if callbacks is None else await llm .ainvoke (
534+ prompt , config = {"callbacks" : callbacks }
535+ )
542536 except Exception as exc :
543- if self ._is_rate_limit (exc ) and attempt < self ._max_retries :
544- self ._pool .release (key , success = False )
545- logger .debug (
546- "PooledChatModel: rate-limited, retrying "
547- "(attempt %d/%d)" ,
548- attempt + 1 ,
549- self ._max_retries ,
550- )
537+ rate_limited = self ._is_rate_limit (exc )
538+ if rate_limited and attempt < self ._max_retries :
551539 continue
552- self ._pool .release (key , success = True )
553- last_exception = exc
554540 raise
555-
556- raise RuntimeError (
557- f"PooledChatModel: exhausted { self ._max_retries } retries "
558- "due to rate-limit errors"
559- ) from last_exception
560-
561- def _build_llm (self , key : ApiKey ):
541+ finally :
542+ self ._pool .release (key , success = not rate_limited )
543+ if attempt > 0 :
544+ self ._pool .record_retry_success ()
545+ return result
546+ raise RuntimeError ("PooledChatModel exhausted key retries" )
547+
548+ def _build_llm (self , key : ApiKey , * , timeout : float | None = None ):
562549 """Build a fresh :class:`~langchain_openai.ChatOpenAI` for *key*."""
563550 from langchain_openai import ChatOpenAI
564551 from pydantic import SecretStr
565552
553+ timeout = self ._timeout if timeout is None else timeout
566554 try :
567555 import httpx
568- _timeout = httpx .Timeout (self . _timeout , connect = 8.0 )
556+ _timeout = httpx .Timeout (timeout , connect = min ( 8.0 , timeout ) )
569557 except ImportError :
570- _timeout = self . _timeout
558+ _timeout = timeout
571559
572560 return ChatOpenAI (
573561 model = key .model ,
574562 base_url = key .base_url ,
575563 api_key = SecretStr (key .key ),
576564 max_completion_tokens = self ._max_tokens ,
577565 timeout = _timeout ,
566+ max_retries = 0 ,
578567 )
579568
580569 @staticmethod
0 commit comments