abstractcore 2.3.7__py3-none-any.whl → 2.3.9__py3-none-any.whl

{abstractcore-2.3.7.dist-info → abstractcore-2.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.3.7
+Version: 2.3.9
 Summary: Unified interface to all LLM providers with essential infrastructure for tool calling, streaming, and model management
 Author: Laurent-Philippe Albou
 Maintainer: Laurent-Philippe Albou

{abstractcore-2.3.7.dist-info → abstractcore-2.3.9.dist-info}/RECORD

@@ -1,10 +1,10 @@
-abstractcore-2.3.7.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
+abstractcore-2.3.9.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
 abstractllm/__init__.py,sha256=UWHXV-OyMpDeBsCFfLTTgVqkFTrj-uQWVqgFtkfjtxU,1859
 abstractllm/apps/__init__.py,sha256=H6fOR28gyBW8bDCEAft2RUZhNmRYA_7fF91szKBjhpA,30
 abstractllm/apps/__main__.py,sha256=YyAHo-0O4yAJ5JeinsioIM6Ytam2i4eq6UQt2oWB2s0,1579
-abstractllm/apps/extractor.py,sha256=T_9-GTMkTbswa2m3E294IO1eGiedNAWi0dK1xgdm0WE,23491
-abstractllm/apps/judge.py,sha256=gQBpwXLVLIyQxTwHblIPbNWRk6IGsRqkWq2dgj2vO1s,23278
-abstractllm/apps/summarizer.py,sha256=zf3MCJu5mwkOLhTxo41lHuc-462YkUYcFDB5pQu8Uv4,13786
+abstractllm/apps/extractor.py,sha256=iBDBStD17K1YV22jMlAa2gAk8oywn96r6QW2DEMjZEs,23733
+abstractllm/apps/judge.py,sha256=W6ILCLfDbMbuKsiaf0VOK86TEvi46z3yyViukG7kZWA,23151
+abstractllm/apps/summarizer.py,sha256=YBTV98-YenxVYzZLVFB9YkGaCy57sHaEyzMFGPDvDyo,14128
 abstractllm/architectures/__init__.py,sha256=-4JucAM7JkMWShWKkePoclxrUHRKgaG36UTguJihE0U,1046
 abstractllm/architectures/detection.py,sha256=PYYzJ73tXI5ssJOpEL6-mHBmTreYXIq5f4nsfqtrpmw,9465
 abstractllm/architectures/enums.py,sha256=9vIv2vDBEKhxwzwH9iaSAyf-iVj3p8y9loMeN_mYTJ8,3821
@@ -23,16 +23,16 @@ abstractllm/embeddings/manager.py,sha256=YCW1r7ldd_mZshRjWNiNLIyhZktFl1SIiwgDDf4
 abstractllm/embeddings/models.py,sha256=bsPAzL6gv57AVii8O15PT0kxfwRkOml3f3njJN4UDi4,4874
 abstractllm/events/__init__.py,sha256=Z7WIDjerS3G6zjcjiRH3tHIbKdFNzlWnibHMNxkWWzo,11064
 abstractllm/processing/__init__.py,sha256=t6hiakQjcZROT4pw9ZFt2q6fF3vf5VpdMKG2EWlsFd8,540
-abstractllm/processing/basic_extractor.py,sha256=geB9_bqH9Z3hcKq7SheHtsqv0sgitolyMo-SPGgR2Cc,49673
-abstractllm/processing/basic_judge.py,sha256=pHfTSYRjNZq4N3BdpST-hpHgUu6PJFgkeuRo9bK-fiw,31879
-abstractllm/processing/basic_summarizer.py,sha256=P-tkTm0qMDLudQrctAAf1MYqZIa-hvDRZRg8isaVg1U,25334
+abstractllm/processing/basic_extractor.py,sha256=IvigIkwF41G8SvsjVMoniHAu39gLKmKIp5-nTAoXx4E,49827
+abstractllm/processing/basic_judge.py,sha256=LQkloGBL96w65E-Qtp-Gf78_KuOrrA72otzk18h-_WA,32213
+abstractllm/processing/basic_summarizer.py,sha256=c420K0ExF3rrf-l4EuIAh2YKLxdxOloJujtuGTlk7AE,25488
 abstractllm/providers/__init__.py,sha256=UTpR2Bf_ICFG7M--1kxUmNXs4gl026Tp-KI9zJlvMKU,574
 abstractllm/providers/anthropic_provider.py,sha256=BM8Vu89c974yicvFwlsJ5C3N0wR9Kkt1pOszViWCwAQ,19694
-abstractllm/providers/base.py,sha256=rDxd5XglfZuZNj94iwjWc3ItPSddMQ92Y2G624mb60M,42780
-abstractllm/providers/huggingface_provider.py,sha256=4u3-Z4txonlKXE3DazvgUbxtzVfmdk-ZHsKPSaIfwD4,40785
-abstractllm/providers/lmstudio_provider.py,sha256=HcMltGyiXrLb2acA_XE4wDi1d-X2VZiT3eV1IjMF150,15701
-abstractllm/providers/mlx_provider.py,sha256=qusbTNvwWB8ydKVwv0adCLpMLFVT2RvX4LYHW-jUxlQ,14166
-abstractllm/providers/mock_provider.py,sha256=qORJxy_Yk0X970GiQG4JfU-T2IUx6C_PNASKM-M7ya8,4597
+abstractllm/providers/base.py,sha256=Pp1CuJmhsH_4PZBrRKzmccvbhvgu6JS-hvDNJkpElfE,42820
+abstractllm/providers/huggingface_provider.py,sha256=3RLqdZUbA9GgWRB0jpjtUMEs2FuzQwUlwC0mU-A1ysQ,42282
+abstractllm/providers/lmstudio_provider.py,sha256=vhZJWDVu9hiC1wCoZoNODY14axXsy_dv52TQ13bsxmw,16004
+abstractllm/providers/mlx_provider.py,sha256=eANGeexmJIS4KWn77fRBOJRkXvwgh7irAtu3kDVIVBA,15629
+abstractllm/providers/mock_provider.py,sha256=tIjA57Hlwu3vNODOZShNn0tY9HWvz1p4z-HyD_bsvbo,5741
 abstractllm/providers/ollama_provider.py,sha256=SkXD5gjuzeu9Thqnt4pRPSi-cjWxwuZGV2x5YMm26jo,19340
 abstractllm/providers/openai_provider.py,sha256=xGFrSkbCrsBnWnho1U2aMCBdzfCqf121wU1EFGmU3YQ,21678
 abstractllm/providers/streaming.py,sha256=KQUH1DB-7UvuZP0_Wrcajj1P-9jdqnQfpIEeSYkxVFU,31153
@@ -54,9 +54,9 @@ abstractllm/utils/cli.py,sha256=PcA5AKvAr3bADT9x9OytfE4MDUVh48q8DcbIu9CLkj8,5687
 abstractllm/utils/self_fixes.py,sha256=QEDwNTW80iQM4ftfEY3Ghz69F018oKwLM9yeRCYZOvw,5886
 abstractllm/utils/structured_logging.py,sha256=2_bbMRjOvf0gHsRejncel_-PrhYUsOUySX_eaPcQopc,15827
 abstractllm/utils/token_utils.py,sha256=wAZpqiPh4eL8ppl1lNjqTzxCmlvdJ1Xu62UJyaDq09Y,21096
-abstractllm/utils/version.py,sha256=QyoMwQlCZK5rKvZLjbmcREXZU6Z8CC4a29TpUO4do04,1386
-abstractcore-2.3.7.dist-info/METADATA,sha256=lcnxke_jx-tKffNdv6UM5r45KRHN-YWt9Uos3Zu1gpc,19399
-abstractcore-2.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstractcore-2.3.7.dist-info/entry_points.txt,sha256=plz04HNXbCbQkmEQj_8xKWW8x7zBxus68HD_04-IARM,306
-abstractcore-2.3.7.dist-info/top_level.txt,sha256=Md-8odCjB7hTNnE5hucnifAoLrL9HvRPffZmCq2jpoI,12
-abstractcore-2.3.7.dist-info/RECORD,,
+abstractllm/utils/version.py,sha256=qbYRDP1iRl-eg3KmpLRoIZcJHiyGDC7qZgJJwcRgurQ,605
+abstractcore-2.3.9.dist-info/METADATA,sha256=Hbqs0h67_AlDTRW676trCHF_I_6n0J8qjOauSIeM46U,19399
+abstractcore-2.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractcore-2.3.9.dist-info/entry_points.txt,sha256=plz04HNXbCbQkmEQj_8xKWW8x7zBxus68HD_04-IARM,306
+abstractcore-2.3.9.dist-info/top_level.txt,sha256=Md-8odCjB7hTNnE5hucnifAoLrL9HvRPffZmCq2jpoI,12
+abstractcore-2.3.9.dist-info/RECORD,,

abstractllm/apps/extractor.py

@@ -52,6 +52,18 @@ from ..processing import BasicExtractor
 from ..core.factory import create_llm
 
 
+def timeout_type(value):
+    """Parse timeout value - accepts None, 'none', or float"""
+    if value is None:
+        return None
+    if isinstance(value, str) and value.lower() == 'none':
+        return None
+    try:
+        return float(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"Invalid timeout value: {value}. Use 'none' for unlimited or a number in seconds.")
+
+
 def read_file_content(file_path: str) -> str:
     """
     Read content from various file types
@@ -295,9 +307,9 @@ Default model setup:
 
     parser.add_argument(
         '--timeout',
-        type=float,
-        default=600.0,
-        help='HTTP request timeout in seconds for LLM providers (default: 300, i.e., 5 minutes). Increase for large models like 36B+ parameters'
+        type=timeout_type,
+        default=None,
+        help='HTTP request timeout in seconds for LLM providers (default: unlimited). Use "none" for unlimited timeout or specify seconds (e.g., 600 for 10 minutes)'
     )
 
     parser.add_argument(
@@ -342,13 +354,7 @@ Default model setup:
             sys.exit(1)
 
         # Validate timeout parameter
-        if args.timeout < 30.0:
-            print("Error: Timeout must be at least 30 seconds")
-            sys.exit(1)
 
-        if args.timeout > 7200.0:  # 2 hours
-            print("Error: Timeout cannot exceed 7200 seconds (2 hours)")
-            sys.exit(1)
 
         # Validate provider/model pair
         if args.provider and not args.model:
@@ -423,7 +429,8 @@ Default model setup:
                 llm=llm,
                 max_chunk_size=adjusted_chunk_size,
                 max_tokens=args.max_tokens,
-                max_output_tokens=args.max_output_tokens
+                max_output_tokens=args.max_output_tokens,
+                timeout=args.timeout
             )
         else:
             # Default configuration
@@ -434,7 +441,8 @@ Default model setup:
                 extractor = BasicExtractor(
                     max_chunk_size=args.chunk_size,
                     max_tokens=args.max_tokens,
-                    max_output_tokens=args.max_output_tokens
+                    max_output_tokens=args.max_output_tokens,
+                    timeout=args.timeout
                 )
             except RuntimeError as e:
                 # Handle default model not available

abstractllm/apps/judge.py

@@ -383,9 +383,8 @@ Default model setup:
 
     parser.add_argument(
         '--timeout',
-        type=float,
-        default=300.0,
-        help='HTTP request timeout in seconds for LLM providers (default: 300)'
+        default=None,
+        help='HTTP request timeout in seconds for LLM providers (default: None = infininity)'
     )
 
     # Parse arguments
@@ -398,9 +397,6 @@ Default model setup:
             sys.exit(1)
 
         # Validate timeout
-        if args.timeout < 30.0:
-            print("Error: Timeout must be at least 30 seconds")
-            sys.exit(1)
 
         # Validate provider/model pair
         if args.provider and not args.model:

abstractllm/apps/summarizer.py

@@ -240,6 +240,12 @@ Default model setup:
         help='Show detailed progress information'
     )
 
+    parser.add_argument(
+        '--timeout',
+        default=None,
+        help='HTTP request timeout in seconds for LLM providers (default: None = unlimited)'
+    )
+
     # Parse arguments
     args = parser.parse_args()
 
@@ -286,12 +292,13 @@ Default model setup:
             if args.verbose:
                 print(f"Initializing summarizer ({args.provider}, {args.model}, {args.max_tokens} token context, {args.max_output_tokens} output tokens)...")
 
-            llm = create_llm(args.provider, model=args.model, max_tokens=args.max_tokens, max_output_tokens=args.max_output_tokens)
+            llm = create_llm(args.provider, model=args.model, max_tokens=args.max_tokens, max_output_tokens=args.max_output_tokens, timeout=args.timeout)
             summarizer = BasicSummarizer(
                 llm, 
                 max_chunk_size=args.chunk_size,
                 max_tokens=args.max_tokens,
-                max_output_tokens=args.max_output_tokens
+                max_output_tokens=args.max_output_tokens,
+                timeout=args.timeout
             )
         else:
             # Default configuration with chunk size override
@@ -302,12 +309,13 @@ Default model setup:
                     print(f"Initializing summarizer (ollama, gemma3:1b-it-qat, {args.max_tokens} token context, {args.max_output_tokens} output tokens, {args.chunk_size} chunk size)...")
 
                 try:
-                    llm = create_llm("ollama", model="gemma3:1b-it-qat", max_tokens=args.max_tokens, max_output_tokens=args.max_output_tokens)
+                    llm = create_llm("ollama", model="gemma3:1b-it-qat", max_tokens=args.max_tokens, max_output_tokens=args.max_output_tokens, timeout=args.timeout)
                     summarizer = BasicSummarizer(
                         llm, 
                         max_chunk_size=args.chunk_size,
                         max_tokens=args.max_tokens,
-                        max_output_tokens=args.max_output_tokens
+                        max_output_tokens=args.max_output_tokens,
+                        timeout=args.timeout
                     )
                 except Exception as e:
                     # Handle default model not available
@@ -327,7 +335,8 @@ Default model setup:
                     summarizer = BasicSummarizer(
                         max_chunk_size=args.chunk_size,
                         max_tokens=args.max_tokens,
-                        max_output_tokens=args.max_output_tokens
+                        max_output_tokens=args.max_output_tokens,
+                        timeout=args.timeout
                     )
                 except RuntimeError as e:
                     # Handle default model not available

abstractllm/processing/basic_extractor.py

@@ -53,7 +53,8 @@ class BasicExtractor:
         llm: Optional[AbstractLLMInterface] = None,
         max_chunk_size: int = 8000,
         max_tokens: int = 32000,
-        max_output_tokens: int = 8000
+        max_output_tokens: int = 8000,
+        timeout: Optional[float] = None
     ):
         """Initialize the extractor
         
@@ -62,10 +63,11 @@ class BasicExtractor:
             max_chunk_size: Maximum characters per chunk for long documents (default 8000)
             max_tokens: Maximum total tokens for LLM context (default 32000)
             max_output_tokens: Maximum tokens for LLM output generation (default 8000)
+            timeout: HTTP request timeout in seconds. None for unlimited timeout (default None)
         """
         if llm is None:
             try:
-                self.llm = create_llm("ollama", model="qwen3:4b-instruct-2507-q4_K_M", max_tokens=max_tokens, max_output_tokens=max_output_tokens)
+                self.llm = create_llm("ollama", model="qwen3:4b-instruct-2507-q4_K_M", max_tokens=max_tokens, max_output_tokens=max_output_tokens, timeout=timeout)
             except Exception as e:
                 error_msg = (
                     f"❌ Failed to initialize default Ollama model 'qwen3:4b-instruct-2507-q4_K_M': {e}\n\n"

abstractllm/processing/basic_judge.py

@@ -118,7 +118,8 @@ class BasicJudge:
         temperature: float = 0.1,  # Low temperature for consistent evaluation
         max_tokens: int = 32000,
         max_output_tokens: int = 8000,
-        debug: bool = False
+        debug: bool = False,
+        timeout: Optional[float] = None
     ):
         """Initialize the judge
         
@@ -128,12 +129,13 @@ class BasicJudge:
             max_tokens: Maximum total tokens for LLM context (default 32000)
             max_output_tokens: Maximum tokens for LLM output generation (default 8000)
             debug: Enable debug output showing raw LLM responses (default False)
+            timeout: HTTP request timeout in seconds. None for unlimited timeout (default None)
         """
         if llm is None:
             try:
                 # Use low temperature for consistent evaluation
                 self.llm = create_llm("ollama", model="qwen3:4b-instruct-2507-q4_K_M",
-                                    max_tokens=max_tokens, max_output_tokens=max_output_tokens, temperature=temperature)
+                                    max_tokens=max_tokens, max_output_tokens=max_output_tokens, temperature=temperature, timeout=timeout)
             except Exception as e:
                 error_msg = (
                     f"❌ Failed to initialize default Ollama model 'qwen3:4b-instruct-2507-q4_K_M': {e}\n\n"
@@ -663,6 +665,7 @@ def create_judge(
     max_tokens: int = 32000,
     max_output_tokens: int = 8000,
     debug: bool = False,
+    timeout: Optional[float] = None,
     **kwargs
 ) -> BasicJudge:
     """
@@ -675,13 +678,14 @@ def create_judge(
         max_tokens: Maximum total tokens for LLM context (default 32000)
         max_output_tokens: Maximum tokens for LLM output generation (default 8000)
         debug: Enable debug output showing raw LLM responses (default False)
+        timeout: HTTP request timeout in seconds. None for unlimited timeout (default None)
         **kwargs: Additional arguments passed to create_llm
 
     Returns:
         BasicJudge instance
     """
     if provider and model:
-        llm = create_llm(provider, model=model, temperature=temperature, max_tokens=max_tokens, max_output_tokens=max_output_tokens, **kwargs)
-        return BasicJudge(llm=llm, temperature=temperature, max_tokens=max_tokens, max_output_tokens=max_output_tokens, debug=debug)
+        llm = create_llm(provider, model=model, temperature=temperature, max_tokens=max_tokens, max_output_tokens=max_output_tokens, timeout=timeout, **kwargs)
+        return BasicJudge(llm=llm, temperature=temperature, max_tokens=max_tokens, max_output_tokens=max_output_tokens, debug=debug, timeout=timeout)
     else:
-        return BasicJudge(temperature=temperature, max_tokens=max_tokens, max_output_tokens=max_output_tokens, debug=debug)
+        return BasicJudge(temperature=temperature, max_tokens=max_tokens, max_output_tokens=max_output_tokens, debug=debug, timeout=timeout)

abstractllm/processing/basic_summarizer.py

@@ -82,7 +82,8 @@ class BasicSummarizer:
         llm: Optional[AbstractLLMInterface] = None, 
         max_chunk_size: int = 8000,
         max_tokens: int = 32000,
-        max_output_tokens: int = 8000
+        max_output_tokens: int = 8000,
+        timeout: Optional[float] = None
     ):
         """
         Initialize the summarizer
@@ -91,12 +92,13 @@ class BasicSummarizer:
             llm: AbstractLLM instance (any provider). If None, attempts to create ollama gemma3:1b-it-qat
             max_chunk_size: Maximum characters per chunk for long documents (default 8000)
             max_tokens: Maximum total tokens for LLM context (default 32000)
-            max_output_tokens: Maximum tokens for LLM output generation (default 4000)
+            max_output_tokens: Maximum tokens for LLM output generation (default 8000)
+            timeout: HTTP request timeout in seconds. None for unlimited timeout (default None)
         """
         if llm is None:
             try:
                 # Default to gemma3:1b-it-qat with configurable token limits
-                self.llm = create_llm("ollama", model="gemma3:1b-it-qat", max_tokens=max_tokens, max_output_tokens=max_output_tokens)
+                self.llm = create_llm("ollama", model="gemma3:1b-it-qat", max_tokens=max_tokens, max_output_tokens=max_output_tokens, timeout=timeout)
             except Exception as e:
                 error_msg = (
                     f"❌ Failed to initialize default Ollama model 'gemma3:1b-it-qat': {e}\n\n"

abstractllm/providers/base.py

@@ -48,8 +48,9 @@ class BaseProvider(AbstractLLMInterface, ABC):
         self.model_capabilities = get_model_capabilities(model)
 
         # Setup timeout configuration
-        self._timeout = kwargs.get('timeout', 300.0)  # Default 300 seconds (5 minutes) for HTTP requests
-        self._tool_timeout = kwargs.get('tool_timeout', 300.0)  # Default 300 seconds for tool execution
+        # Default to None for unlimited timeout
+        self._timeout = kwargs.get('timeout', None)  # Default None for unlimited HTTP requests
+        self._tool_timeout = kwargs.get('tool_timeout', None)  # Default None for unlimited tool execution
 
         # Setup tool execution mode
         # execute_tools: True = AbstractCore executes tools (legacy mode)

abstractllm/providers/huggingface_provider.py

@@ -62,6 +62,9 @@ class HuggingFaceProvider(BaseProvider):
 
         super().__init__(model, **kwargs)
 
+        # Handle timeout parameter for local models
+        self._handle_timeout_parameter(kwargs)
+
         # Initialize tool handler
         self.tool_handler = UniversalToolHandler(model)
 
@@ -427,6 +430,40 @@ class HuggingFaceProvider(BaseProvider):
 
         return sorted(similar_models)
 
+    def _handle_timeout_parameter(self, kwargs: Dict[str, Any]) -> None:
+        """
+        Handle timeout parameter for HuggingFace provider.
+        
+        Since HuggingFace models run locally (both transformers and GGUF),
+        timeout parameters don't apply. If a non-None timeout is provided,
+        issue a warning and treat it as None (infinity).
+        
+        Args:
+            kwargs: Initialization kwargs that may contain timeout
+        """
+        timeout_value = kwargs.get('timeout')
+        if timeout_value is not None:
+            import warnings
+            warnings.warn(
+                f"HuggingFace provider runs models locally and does not support timeout parameters. "
+                f"Provided timeout={timeout_value} will be ignored and treated as None (unlimited).",
+                UserWarning,
+                stacklevel=3
+            )
+            # Force timeout to None for local models
+            self._timeout = None
+        else:
+            # Keep None value (unlimited timeout is appropriate for local models)
+            self._timeout = None
+
+    def _update_http_client_timeout(self) -> None:
+        """
+        HuggingFace provider doesn't use HTTP clients for model inference.
+        Local models (transformers and GGUF) don't have timeout constraints.
+        """
+        # No-op for local models - they don't use HTTP clients
+        pass
+
     def generate(self, *args, **kwargs):
         """Public generate method that includes telemetry"""
         return self.generate_with_telemetry(*args, **kwargs)

abstractllm/providers/lmstudio_provider.py

@@ -30,10 +30,11 @@ class LMStudioProvider(BaseProvider):
 
         self.base_url = base_url.rstrip('/')
 
-        # Ensure timeout is properly set and not None
+        # Get timeout value - None means unlimited timeout
         timeout_value = getattr(self, '_timeout', None)
-        if timeout_value is None:
-            timeout_value = 300.0
+        # Validate timeout if provided (None is allowed for unlimited)
+        if timeout_value is not None and timeout_value <= 0:
+            timeout_value = None  # Invalid timeout becomes unlimited
 
         try:
             self.client = httpx.Client(timeout=timeout_value)
@@ -295,10 +296,11 @@ class LMStudioProvider(BaseProvider):
                 # Create new client with updated timeout
                 self.client.close()
 
-                # Ensure timeout is not None
+                # Get timeout value - None means unlimited timeout
                 timeout_value = getattr(self, '_timeout', None)
-                if timeout_value is None:
-                    timeout_value = 300.0
+                # Validate timeout if provided (None is allowed for unlimited)
+                if timeout_value is not None and timeout_value <= 0:
+                    timeout_value = None  # Invalid timeout becomes unlimited
 
                 self.client = httpx.Client(timeout=timeout_value)
             except Exception as e:

abstractllm/providers/mlx_provider.py

@@ -24,6 +24,9 @@ class MLXProvider(BaseProvider):
     def __init__(self, model: str = "mlx-community/Mistral-7B-Instruct-v0.1-4bit", **kwargs):
         super().__init__(model, **kwargs)
 
+        # Handle timeout parameter for local models
+        self._handle_timeout_parameter(kwargs)
+
         # Initialize tool handler
         self.tool_handler = UniversalToolHandler(model)
 
@@ -93,6 +96,40 @@ class MLXProvider(BaseProvider):
             if hasattr(self, 'logger'):
                 self.logger.warning(f"Error during unload: {e}")
 
+    def _handle_timeout_parameter(self, kwargs: Dict[str, Any]) -> None:
+        """
+        Handle timeout parameter for MLX provider.
+        
+        Since MLX models run locally on Apple Silicon,
+        timeout parameters don't apply. If a non-None timeout is provided,
+        issue a warning and treat it as None (infinity).
+        
+        Args:
+            kwargs: Initialization kwargs that may contain timeout
+        """
+        timeout_value = kwargs.get('timeout')
+        if timeout_value is not None:
+            import warnings
+            warnings.warn(
+                f"MLX provider runs models locally on Apple Silicon and does not support timeout parameters. "
+                f"Provided timeout={timeout_value} will be ignored and treated as None (unlimited).",
+                UserWarning,
+                stacklevel=3
+            )
+            # Force timeout to None for local models
+            self._timeout = None
+        else:
+            # Keep None value (unlimited timeout is appropriate for local models)
+            self._timeout = None
+
+    def _update_http_client_timeout(self) -> None:
+        """
+        MLX provider doesn't use HTTP clients for model inference.
+        Local models on Apple Silicon don't have timeout constraints.
+        """
+        # No-op for local models - they don't use HTTP clients
+        pass
+
     def generate(self, *args, **kwargs):
         """Public generate method that includes telemetry"""
         return self.generate_with_telemetry(*args, **kwargs)

abstractllm/providers/mock_provider.py

@@ -20,6 +20,10 @@ class MockProvider(BaseProvider):
 
     def __init__(self, model: str = "mock-model", **kwargs):
         super().__init__(model, **kwargs)
+        
+        # Handle timeout parameter for mock provider
+        self._handle_timeout_parameter(kwargs)
+        
         # Mock provider uses prompted strategy for structured output
         self.model_capabilities = {"structured_output": "prompted"}
 
@@ -106,6 +110,34 @@ class MockProvider(BaseProvider):
 
         return json.dumps(mock_data)
 
+    def _handle_timeout_parameter(self, kwargs: Dict[str, Any]) -> None:
+        """
+        Handle timeout parameter for Mock provider.
+        
+        Mock provider simulates responses instantly, so timeout parameters
+        don't apply. If a non-None timeout is provided, it's accepted but
+        has no effect on mock generation.
+        
+        Args:
+            kwargs: Initialization kwargs that may contain timeout
+        """
+        timeout_value = kwargs.get('timeout')
+        if timeout_value is not None:
+            # For mock provider, we accept timeout but it has no effect
+            # No warning needed since this is for testing
+            self._timeout = timeout_value
+        else:
+            # Keep None value 
+            self._timeout = None
+
+    def _update_http_client_timeout(self) -> None:
+        """
+        Mock provider doesn't use HTTP clients.
+        Timeout changes have no effect on mock responses.
+        """
+        # No-op for mock provider - no HTTP clients used
+        pass
+
     def get_capabilities(self) -> List[str]:
         """Get mock capabilities"""
         return ["tools", "streaming", "vision"]

abstractllm/utils/version.py

@@ -1,44 +1,14 @@
 """
 Version management for AbstractCore.
 
-This module provides a single source of truth for the package version,
-reading it dynamically from pyproject.toml to avoid version synchronization issues.
-"""
-
-import os
-import tomllib
-from pathlib import Path
-
-
-def get_version() -> str:
-    """
-    Get the package version from pyproject.toml.
-    
-    Returns:
-        str: The package version
-        
-    Raises:
-        FileNotFoundError: If pyproject.toml is not found
-        KeyError: If version is not found in pyproject.toml
-    """
-    # Get the project root directory (where pyproject.toml is located)
-    # When imported as a module, we need to go up from abstractllm/utils/ to the project root
-    current_dir = Path(__file__).parent  # abstractllm/utils/
-    project_root = current_dir.parent.parent  # Go up two levels: utils -> abstractllm -> project_root
-    pyproject_path = project_root / "pyproject.toml"
-    
-    if not pyproject_path.exists():
-        raise FileNotFoundError(f"pyproject.toml not found at {pyproject_path}")
-    
-    # Read and parse pyproject.toml
-    with open(pyproject_path, "rb") as f:
-        data = tomllib.load(f)
-    
-    try:
-        return data["project"]["version"]
-    except KeyError:
-        raise KeyError("Version not found in pyproject.toml [project] section")
+This module provides the package version as a static constant that serves as the
+single source of truth for the Python code. The version is also maintained in
+pyproject.toml for packaging, requiring manual synchronization during releases.
 
+This approach ensures reliable version access in all deployment scenarios,
+including when the package is installed from PyPI where pyproject.toml is not available.
+"""
 
-# Set the version as a module-level constant
-__version__ = get_version()
+# Package version - update this when releasing new versions
+# This must be manually synchronized with the version in pyproject.toml
+__version__ = "2.3.9"